| /** @file |
| |
| This file implements the LogAccess class. |
| |
| @section license License |
| |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| #include "proxy/logging/LogAccess.h" |
| |
| #include "records/RecCore.h" |
| #include "tscore/Version.h" |
| #include "proxy/hdrs/MIME.h" |
| #include "proxy/logging/TransactionLogData.h" |
| #include "iocore/utils/Machine.h" |
| #include "proxy/logging/LogFormat.h" |
| #include "proxy/logging/LogBuffer.h" |
| #include "records/RecHttp.h" |
| #include "swoc/BufferWriter.h" |
| #include "tscore/Encoding.h" |
| #include "tscore/ink_inet.h" |
| #include "tscore/ink_base64.h" |
| |
| char INVALID_STR[] = "!INVALID_STR!"; |
| |
| // should be at least 22 bytes to always accommodate a converted |
| // MgmtInt, MgmtIntCounter or MgmtFloat. 22 bytes is enough for 64 bit |
| // ints + sign + eos, and enough for %e floating point representation |
| // + eos |
| // |
| #define MARSHAL_RECORD_LENGTH 32 |
| |
| namespace |
| { |
| DbgCtl dbg_ctl_log_escape{"log-escape"}; |
| DbgCtl dbg_ctl_log_resolve{"log-resolve"}; |
| DbgCtl dbg_ctl_log_unmarshal_orun{"log-unmarshal-orun"}; // Overrun of unmarshaling destination buffer. |
| DbgCtl dbg_ctl_log_unmarshal_data{"log-unmarshal-data"}; // Error in txn data when unmarshalling. |
| |
| int |
| marshal_http_version_string(char *buf, HTTPHdr *response) |
| { |
| HTTPVersion version = response ? response->version_get() : HTTP_INVALID; |
| char str[8]; |
| int str_len = |
| snprintf(str, sizeof(str), "%u.%u", static_cast<unsigned>(version.get_major()), static_cast<unsigned>(version.get_minor())); |
| int len = LogAccess::padded_length(str_len + 1); |
| |
| ink_release_assert(str_len > 0 && str_len < static_cast<int>(sizeof(str))); |
| if (buf) { |
| LogAccess::marshal_str(buf, str, len); |
| } |
| return len; |
| } |
| |
| } // end anonymous namespace |
| |
| #define DBG_UNMARSHAL_DEST_OVERRUN Dbg(dbg_ctl_log_unmarshal_orun, "Unmarshal destination buffer overrun."); |
| |
| /*------------------------------------------------------------------------- |
| LogAccess |
| |
| Initialize from TransactionLogData supplied by the caller. |
| -------------------------------------------------------------------------*/ |
| |
| LogAccess::LogAccess(TransactionLogData &data) : m_data(&data) {} |
| |
| void |
| LogAccess::init() |
| { |
| ink_assert(m_data != nullptr); |
| |
| m_client_request = m_data->get_client_request(); |
| |
| const char *url_str = m_data->get_client_req_url_str(); |
| int url_len = m_data->get_client_req_url_len(); |
| if (url_str != nullptr && url_len > 0) { |
| m_client_req_url_len = url_len; |
| m_client_req_url_str = m_arena.str_alloc(m_client_req_url_len + 1); |
| memcpy(m_client_req_url_str, url_str, m_client_req_url_len); |
| m_client_req_url_str[m_client_req_url_len] = '\0'; |
| |
| m_client_req_url_canon_str = |
| Encoding::escapify_url(&m_arena, m_client_req_url_str, m_client_req_url_len, &m_client_req_url_canon_len); |
| } |
| |
| const char *path_str = m_data->get_client_req_url_path_str(); |
| int path_len = m_data->get_client_req_url_path_len(); |
| if (path_str != nullptr && path_len > 0) { |
| m_client_req_url_path_len = path_len; |
| char *path_copy = m_arena.str_alloc(m_client_req_url_path_len + 1); |
| memcpy(path_copy, path_str, m_client_req_url_path_len); |
| path_copy[m_client_req_url_path_len] = '\0'; |
| m_client_req_url_path_str = path_copy; |
| } else { |
| m_client_req_url_path_str = nullptr; |
| m_client_req_url_path_len = 0; |
| } |
| |
| m_proxy_response = m_data->get_proxy_response(); |
| |
| char *ct_str = m_data->get_proxy_resp_content_type_str(); |
| int ct_len = m_data->get_proxy_resp_content_type_len(); |
| if (ct_str != nullptr && ct_len > 0) { |
| m_proxy_resp_content_type_str = ct_str; |
| m_proxy_resp_content_type_len = ct_len; |
| LogUtils::remove_content_type_attributes(m_proxy_resp_content_type_str, &m_proxy_resp_content_type_len); |
| } |
| |
| char *reason_str = m_data->get_proxy_resp_reason_phrase_str(); |
| int reason_len = m_data->get_proxy_resp_reason_phrase_len(); |
| if (reason_str != nullptr && reason_len > 0) { |
| m_proxy_resp_reason_phrase_str = reason_str; |
| m_proxy_resp_reason_phrase_len = reason_len; |
| } |
| |
| m_proxy_request = m_data->get_proxy_request(); |
| m_server_response = m_data->get_server_response(); |
| m_cache_response = m_data->get_cache_response(); |
| } |
| |
| int |
| LogAccess::marshal_proxy_host_name(char *buf) |
| { |
| int len = 0; |
| char const *str = nullptr; |
| |
| if (Machine *machine = Machine::instance(); machine) { |
| str = machine->host_name.c_str(); |
| len = machine->host_name.length(); |
| } |
| |
| len = INK_ALIGN_DEFAULT(len + 1); |
| if (buf) { |
| marshal_str(buf, str, len); |
| } |
| |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_host_ip(char *buf) |
| { |
| return marshal_ip(buf, &Machine::instance()->ip.sa); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_process_uuid(char *buf) |
| { |
| int len = padded_length(TS_UUID_STRING_LEN + 1); |
| |
| if (buf) { |
| const char *str = const_cast<char *>(Machine::instance()->process_uuid.getString()); |
| marshal_str(buf, str, len); |
| } |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_process_sfid(char *buf) |
| { |
| char const *str = nullptr; |
| int len = 0; |
| |
| if (Machine *machine = Machine::instance(); machine) { |
| std::string_view snowflake_id = machine->process_snowflake_id->get_string(); |
| str = snowflake_id.data(); |
| len = snowflake_id.length(); |
| } |
| |
| len = INK_ALIGN_DEFAULT(len + 1); |
| if (buf) { |
| marshal_str(buf, str, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_config_int_var(char *config_var, char *buf) |
| { |
| if (buf) { |
| int64_t val; |
| val = RecGetRecordInt(config_var).value_or(0); |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_config_str_var(char *config_var, char *buf) |
| { |
| auto str{RecGetRecordStringAlloc(config_var)}; |
| auto c_str{ats_as_c_str(str)}; |
| int len = LogAccess::padded_strlen(c_str); |
| if (buf) { |
| marshal_str(buf, c_str, len); |
| } |
| return len; |
| } |
| |
| // To allow for a generic marshal_record function, rather than |
| // multiple functions (one per data type) we always marshal a record |
| // as a string of a fixed length. We use a fixed length because the |
| // marshal_record function can be called with a null *buf to request |
| // the length of the record, and later with a non-null *buf to |
| // actually request the record to be inserted in the buffer, and both |
| // calls should return the same number of characters. If we did not |
| // enforce a fixed size, this would not necessarily be the case |
| // because records --statistics in particular-- can potentially change |
| // between one call and the other. |
| // |
| int |
| LogAccess::marshal_record(char *record, char *buf) |
| { |
| const unsigned int max_chars = MARSHAL_RECORD_LENGTH; |
| |
| if (nullptr == buf) { |
| return max_chars; |
| } |
| |
| const char *record_not_found_msg = "RECORD_NOT_FOUND"; |
| const unsigned int record_not_found_chars = ::strlen(record_not_found_msg) + 1; |
| |
| char ascii_buf[max_chars]; |
| const char *out_buf; |
| unsigned int num_chars; |
| |
| #define LOG_INTEGER RECD_INT |
| #define LOG_COUNTER RECD_COUNTER |
| #define LOG_FLOAT RECD_FLOAT |
| #define LOG_STRING RECD_STRING |
| |
| RecDataT stype = RECD_NULL; |
| bool found = false; |
| |
| // Since, for now at least, String metrics are still in librecords, do that lookup |
| // first, and only do the new metrics lookup on a miss. |
| if (RecGetRecordDataType(record, &stype) != REC_ERR_OKAY) { |
| ts::Metrics &metrics = ts::Metrics::instance(); |
| ts::Metrics::IdType mid = metrics[record]; |
| |
| if (mid != ts::Metrics::NOT_FOUND) { |
| int64_t val = metrics[mid].load(); |
| |
| out_buf = int64_to_str(ascii_buf, max_chars, val, &num_chars); |
| ink_assert(out_buf); |
| } else { |
| out_buf = "INVALID_RECORD"; |
| num_chars = ::strlen(out_buf) + 1; |
| } |
| } else { |
| if (LOG_INTEGER == stype || LOG_COUNTER == stype) { |
| // we assume MgmtInt and MgmtIntCounter are int64_t for the |
| // conversion below, if this ever changes we should modify |
| // accordingly |
| // |
| ink_assert(sizeof(int64_t) >= sizeof(RecInt) && sizeof(int64_t) >= sizeof(RecCounter)); |
| |
| // so that a 64 bit integer will fit (including sign and eos) |
| // |
| ink_assert(max_chars > 21); |
| |
| auto tmp{LOG_INTEGER == stype ? RecGetRecordInt(record) : RecGetRecordCounter(record)}; |
| auto found{tmp.has_value()}; |
| |
| if (found) { |
| out_buf = int64_to_str(ascii_buf, max_chars, tmp.value(), &num_chars); |
| ink_assert(out_buf); |
| } else { |
| out_buf = const_cast<char *>(record_not_found_msg); |
| num_chars = record_not_found_chars; |
| } |
| } else if (LOG_FLOAT == stype) { |
| // we assume MgmtFloat is at least a float for the conversion below |
| // (the conversion itself assumes a double because of the %e) |
| // if this ever changes we should modify accordingly |
| // |
| ink_assert(sizeof(double) >= sizeof(RecFloat)); |
| |
| auto val{RecGetRecordFloat(record)}; |
| found = val.has_value(); |
| |
| if (found) { |
| // snprintf does not support "%e" in the format |
| // and we want to use "%e" because it is the most concise |
| // notation |
| |
| num_chars = snprintf(ascii_buf, sizeof(ascii_buf), "%e", val.value()) + 1; // include eos |
| |
| // the "%e" field above should take 13 characters at most |
| // |
| ink_assert(num_chars <= max_chars); |
| |
| // the following should never be true |
| // |
| if (num_chars > max_chars) { |
| // data does not fit, output asterisks |
| out_buf = "***"; |
| num_chars = ::strlen(out_buf) + 1; |
| } else { |
| out_buf = ascii_buf; |
| } |
| } else { |
| out_buf = const_cast<char *>(record_not_found_msg); |
| num_chars = record_not_found_chars; |
| } |
| } else if (LOG_STRING == stype) { |
| if (auto sv{RecGetRecordString(record, ascii_buf, sizeof(ascii_buf))}; sv) { |
| if (sv.value().length() > 0) { |
| num_chars = sv.value().length() + 1; |
| if (num_chars == max_chars) { |
| // truncate string and write ellipsis at the end |
| ascii_buf[max_chars - 1] = 0; |
| ascii_buf[max_chars - 2] = '.'; |
| ascii_buf[max_chars - 3] = '.'; |
| ascii_buf[max_chars - 4] = '.'; |
| } |
| out_buf = ascii_buf; |
| } else { |
| out_buf = "NULL"; |
| num_chars = ::strlen(out_buf) + 1; |
| } |
| } else { |
| out_buf = const_cast<char *>(record_not_found_msg); |
| num_chars = record_not_found_chars; |
| } |
| } else { |
| out_buf = "INVALID_MgmtType"; |
| num_chars = ::strlen(out_buf) + 1; |
| ink_assert(!"invalid MgmtType for requested record"); |
| } |
| } |
| |
| ink_assert(num_chars <= max_chars); |
| memcpy(buf, out_buf, num_chars); |
| |
| return max_chars; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::marshal_str |
| |
| Copy the given string to the destination buffer, including the trailing |
| NULL. For binary formatting, we need the NULL to distinguish the end of |
| the string, and we'll remove it for ascii formatting. |
| ASSUMES dest IS NOT NULL. |
| The array pointed to by dest must be at least padded_len in length. |
| -------------------------------------------------------------------------*/ |
| |
| void |
| LogAccess::marshal_str(char *dest, const char *source, int padded_len) |
| { |
| if (source == nullptr || source[0] == 0 || padded_len == 0) { |
| source = DEFAULT_STR; |
| } |
| ink_strlcpy(dest, source, padded_len); |
| |
| #ifdef DEBUG |
| // |
| // what padded_len should be, if there is no padding, is strlen()+1. |
| // if not, then we needed to pad and should touch the intermediate |
| // bytes to avoid UMR errors when the buffer is written. |
| // |
| size_t real_len = (::strlen(source) + 1); |
| while (static_cast<int>(real_len) < padded_len) { |
| dest[real_len] = '$'; |
| real_len++; |
| } |
| #endif |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_all_header_fields(char *buf) |
| { |
| return LogUtils::marshalMimeHdr(m_client_request, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::marshal_mem |
| |
| This is a version of marshal_str that works with unterminated strings. |
| In this case, we'll copy the buffer and then add a trailing null that |
| the rest of the system assumes. |
| -------------------------------------------------------------------------*/ |
| |
| void |
| LogAccess::marshal_mem(char *dest, const char *source, int actual_len, int padded_len) |
| { |
| if (source == nullptr || source[0] == 0 || actual_len == 0) { |
| source = DEFAULT_STR; |
| actual_len = DEFAULT_STR_LEN; |
| ink_assert(actual_len < padded_len); |
| } |
| memcpy(dest, source, actual_len); |
| dest[actual_len] = 0; // add terminating null |
| |
| #ifdef DEBUG |
| // |
| // what len should be, if there is no padding, is strlen()+1. |
| // if not, then we needed to pad and should touch the intermediate |
| // bytes to avoid UMR errors when the buffer is written. |
| // |
| int real_len = actual_len + 1; |
| while (real_len < padded_len) { |
| dest[real_len] = '$'; |
| real_len++; |
| } |
| #endif |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::marshal_ip |
| |
| Marshal an IP address in a reasonably compact way. If the address isn't |
| valid (NULL or not IP) then marshal an invalid address record. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_ip(char *dest, sockaddr const *ip) |
| { |
| LogFieldIpStorage data; |
| int len = sizeof(data._ip); |
| if (nullptr == ip) { |
| data._ip._family = AF_UNSPEC; |
| } else if (ats_is_ip4(ip)) { |
| if (dest) { |
| data._ip4._family = AF_INET; |
| data._ip4._addr = ats_ip4_addr_cast(ip); |
| } |
| len = sizeof(data._ip4); |
| } else if (ats_is_ip6(ip)) { |
| if (dest) { |
| data._ip6._family = AF_INET6; |
| data._ip6._addr = ats_ip6_addr_cast(ip); |
| } |
| len = sizeof(data._ip6); |
| } else if (ats_is_unix(ip)) { |
| if (dest) { |
| data._un._family = AF_UNIX; |
| strncpy(data._un._path, ats_unix_cast(ip)->sun_path, TS_UNIX_SIZE); |
| } |
| len = sizeof(data._un); |
| } else { |
| data._ip._family = AF_UNSPEC; |
| } |
| |
| if (dest) { |
| memcpy(dest, &data, len); |
| } |
| return INK_ALIGN_DEFAULT(len); |
| } |
| |
| int |
| LogAccess::marshal_custom_field(char *buf, LogField::Type type, const LogField::CustomMarshalFunc &plugin_marshal_func) |
| { |
| void *sm = m_data->http_sm_for_plugins(); |
| if (sm == nullptr) { |
| switch (type) { |
| case LogField::Type::sINT: |
| [[fallthrough]]; |
| case LogField::Type::dINT: |
| if (buf) { |
| marshal_int(buf, 0); |
| } |
| return INK_MIN_ALIGN; |
| case LogField::Type::STRING: { |
| int len = LogAccess::padded_strlen(nullptr); |
| if (buf) { |
| marshal_str(buf, nullptr, len); |
| } |
| return len; |
| } |
| case LogField::Type::IP: |
| return marshal_ip(buf, nullptr); |
| case LogField::Type::N_TYPES: |
| [[fallthrough]]; |
| case LogField::Type::INVALID: |
| break; |
| } |
| } |
| int len = plugin_marshal_func(sm, buf); |
| return LogAccess::padded_length(len); |
| } |
| |
| HTTPHdr * |
| LogAccess::header_for_container(LogField::Container container) const |
| { |
| switch (container) { |
| case LogField::CQH: |
| case LogField::ECQH: |
| return m_client_request; |
| |
| case LogField::PSH: |
| case LogField::EPSH: |
| return m_proxy_response; |
| |
| case LogField::PQH: |
| case LogField::EPQH: |
| return m_proxy_request; |
| |
| case LogField::SSH: |
| case LogField::ESSH: |
| return m_server_response; |
| |
| case LogField::CSSH: |
| case LogField::ECSSH: |
| return m_cache_response; |
| |
| default: |
| return nullptr; |
| } |
| } |
| |
| bool |
| LogAccess::has_http_header_field(LogField::Container container, const char *field) const |
| { |
| if (HTTPHdr const *header = header_for_container(container); header != nullptr) { |
| if (header->field_find(std::string_view{field}) != nullptr) { |
| return true; |
| } |
| } |
| |
| if (container == LogField::SSH && strcmp(field, "Transfer-Encoding") == 0) { |
| if (!m_data->get_server_response_transfer_encoding().empty()) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| inline int |
| LogAccess::unmarshal_with_map(int64_t code, char *dest, int len, const Ptr<LogFieldAliasMap> &map, const char *msg) |
| { |
| long int codeStrLen = 0; |
| |
| switch (map->asString(code, dest, len, reinterpret_cast<size_t *>(&codeStrLen))) { |
| case LogFieldAliasMap::INVALID_INT: |
| if (msg) { |
| const int bufSize = 64; |
| char invalidCodeMsg[bufSize]; |
| codeStrLen = snprintf(invalidCodeMsg, 64, "%s(%" PRId64 ")", msg, code); |
| if (codeStrLen < bufSize && codeStrLen < len) { |
| ink_strlcpy(dest, invalidCodeMsg, len); |
| } else { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| codeStrLen = -1; |
| } |
| } else { |
| codeStrLen = -1; |
| } |
| break; |
| case LogFieldAliasMap::BUFFER_TOO_SMALL: |
| DBG_UNMARSHAL_DEST_OVERRUN |
| codeStrLen = -1; |
| break; |
| } |
| |
| return codeStrLen; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_int |
| |
| Return the integer pointed at by the buffer and advance the buffer |
| pointer past the int. The int will be converted back to host byte order. |
| -------------------------------------------------------------------------*/ |
| |
| int64_t |
| LogAccess::unmarshal_int(char **buf) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| int64_t val; |
| |
| // TODO: this used to do nthol, do we need to worry? TS-1156. |
| val = *(reinterpret_cast<int64_t *>(*buf)); |
| *buf += INK_MIN_ALIGN; |
| return val; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_all_header_fields(char *buf) |
| { |
| return LogUtils::marshalMimeHdr(m_proxy_response, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------- |
| unmarshal_itoa |
| |
| This routine provides a fast conversion from a binary int to a string. |
| It returns the number of characters formatted. "dest" must point to the |
| LAST character of an array large enough to store the complete formatted |
| number. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_itoa(int64_t val, char *dest, int field_width, char leading_char) |
| { |
| ink_assert(dest != nullptr); |
| |
| char *p = dest; |
| bool negative = false; |
| |
| if (val < 0) { |
| negative = true; |
| val = -val; |
| } |
| |
| do { |
| *p-- = '0' + (val % 10); |
| val /= 10; |
| } while (val); |
| |
| while (dest - p < field_width) { |
| *p-- = leading_char; |
| } |
| |
| if (negative) { |
| *p-- = '-'; |
| } |
| |
| return static_cast<int>(dest - p); |
| } |
| |
| /*------------------------------------------------------------------------- |
| unmarshal_itox |
| |
| This routine provides a fast conversion from a binary int to a hex string. |
| It returns the number of characters formatted. "dest" must point to the |
| LAST character of an array large enough to store the complete formatted |
| number. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_itox(int64_t val, char *dest, int field_width, char leading_char) |
| { |
| ink_assert(dest != nullptr); |
| |
| char *p = dest; |
| static char table[] = "0123456789abcdef?"; |
| |
| for (int i = 0; i < static_cast<int>(sizeof(int64_t) * 2); i++) { |
| *p-- = table[val & 0xf]; |
| val >>= 4; |
| } |
| while (dest - p < field_width) { |
| *p-- = leading_char; |
| } |
| |
| return static_cast<int64_t>(dest - p); |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_int_to_str |
| |
| Return the string representation of the integer pointed at by buf. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_int_to_str(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| char val_buf[128]; |
| int64_t val = unmarshal_int(buf); |
| int val_len = unmarshal_itoa(val, val_buf + 127); |
| |
| if (val_len < len) { |
| memcpy(dest, val_buf + 128 - val_len, val_len); |
| return val_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_milestone_diff |
| |
| Unmarshal a milestone difference value. Returns "-" when the |
| marshalled value is -1 (the "missing" sentinel from difference_msec, |
| meaning one or both milestones were unset). Other negative values |
| (reversed milestone order) are preserved as numeric output for |
| debugging. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_milestone_diff(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| int64_t val = unmarshal_int(buf); |
| if (val == -1) { |
| if (len >= 1) { |
| dest[0] = '-'; |
| return 1; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| char val_buf[128]; |
| int val_len = unmarshal_itoa(val, val_buf + 127); |
| if (val_len < len) { |
| memcpy(dest, val_buf + 128 - val_len, val_len); |
| return val_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_int_to_str_hex |
| |
| Return the string representation (hexadecimal) of the integer pointed at by buf. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_int_to_str_hex(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| char val_buf[128]; |
| int64_t val = unmarshal_int(buf); |
| int val_len = unmarshal_itox(val, val_buf + 127); |
| |
| if (val_len < len) { |
| memcpy(dest, val_buf + 128 - val_len, val_len); |
| return val_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_req_all_header_fields(char *buf) |
| { |
| return LogUtils::marshalMimeHdr(m_proxy_request, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| namespace |
| { |
| class EscLookup |
| { |
| public: |
| static const char NO_ESCAPE{'\0'}; |
| static const char LONG_ESCAPE{'\x01'}; |
| |
| static char |
| result(char c) |
| { |
| return _lu.table[static_cast<unsigned char>(c)]; |
| } |
| |
| private: |
| struct _LUT { |
| _LUT(); |
| |
| char table[1 << 8]; |
| }; |
| |
| inline static _LUT const _lu; |
| }; |
| |
| EscLookup::_LUT::_LUT() |
| { |
| for (unsigned i = 0; i < ' '; ++i) { |
| table[i] = LONG_ESCAPE; |
| } |
| for (unsigned i = '\x7f'; i < sizeof(table); ++i) { |
| table[i] = LONG_ESCAPE; |
| } |
| |
| // Short escapes. |
| // |
| table[static_cast<int>('\b')] = 'b'; |
| table[static_cast<int>('\t')] = 't'; |
| table[static_cast<int>('\n')] = 'n'; |
| table[static_cast<int>('\f')] = 'f'; |
| table[static_cast<int>('\r')] = 'r'; |
| table[static_cast<int>('\\')] = '\\'; |
| table[static_cast<int>('\"')] = '"'; |
| table[static_cast<int>('/')] = '/'; |
| } |
| |
| char |
| nibble(int nib) |
| { |
| return nib >= 0xa ? 'a' + (nib - 0xa) : '0' + nib; |
| } |
| |
| int |
| escape_json(char *dest, const char *buf, int len) |
| { |
| int escaped_len = 0; |
| |
| for (int i = 0; i < len; i++) { |
| char c = buf[i]; |
| char ec = EscLookup::result(c); |
| if (__builtin_expect(EscLookup::NO_ESCAPE == ec, 1)) { |
| if (dest) { |
| if (escaped_len + 1 > len) { |
| break; |
| } |
| *dest++ = c; |
| } |
| escaped_len++; |
| |
| } else if (EscLookup::LONG_ESCAPE == ec) { |
| if (dest) { |
| if (escaped_len + 6 > len) { |
| break; |
| } |
| *dest++ = '\\'; |
| *dest++ = 'u'; |
| *dest++ = '0'; |
| *dest++ = '0'; |
| *dest++ = nibble(static_cast<unsigned char>(c) >> 4); |
| *dest++ = nibble(c & 0x0f); |
| } |
| escaped_len += 6; |
| |
| } else { // Short escape. |
| if (dest) { |
| if (escaped_len + 2 > len) { |
| break; |
| } |
| *dest++ = '\\'; |
| *dest++ = ec; |
| } |
| escaped_len += 2; |
| } |
| } // end for |
| return escaped_len; |
| } |
| |
| int |
| unmarshal_str_json(char **buf, char *dest, int len, LogSlice *slice) |
| { |
| Dbg(dbg_ctl_log_escape, "unmarshal_str_json start, len=%d, slice=%p", len, slice); |
| |
| char *val_buf = *buf; |
| int val_len = static_cast<int>(::strlen(val_buf)); |
| int escaped_len = escape_json(nullptr, val_buf, val_len); |
| |
| *buf += LogAccess::padded_strlen(val_buf); // this is how it was stored |
| |
| if (slice && slice->m_enable) { |
| int offset, n; |
| |
| n = slice->toStrOffset(escaped_len, &offset); |
| Dbg(dbg_ctl_log_escape, "unmarshal_str_json start, n=%d, offset=%d", n, offset); |
| if (n <= 0) { |
| return 0; |
| } |
| |
| if (n >= len) { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| return escape_json(dest, (val_buf + offset), n); |
| } |
| |
| if (escaped_len < len) { |
| escape_json(dest, val_buf, escaped_len); |
| return escaped_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| } // end anonymous namespace |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_str |
| |
| Retrieve the string from the location pointed at by the buffer and |
| advance the pointer past the string. The local strlen function is used |
| to advance the pointer, thus matching the corresponding strlen that was |
| used to lay the string into the buffer. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_str(char **buf, char *dest, int len, LogSlice *slice, LogEscapeType escape_type) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| if (LOG_ESCAPE_JSON == escape_type) { |
| return unmarshal_str_json(buf, dest, len, slice); |
| } |
| |
| char *val_buf = *buf; |
| int val_len = static_cast<int>(::strlen(val_buf)); |
| |
| *buf += LogAccess::padded_strlen(val_buf); // this is how it was stored |
| |
| if (slice && slice->m_enable) { |
| int offset, n; |
| |
| n = slice->toStrOffset(val_len, &offset); |
| if (n <= 0) { |
| return 0; |
| } |
| |
| if (n >= len) { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| memcpy(dest, (val_buf + offset), n); |
| return n; |
| } |
| |
| if (val_len < len) { |
| memcpy(dest, val_buf, val_len); |
| return val_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| int |
| LogAccess::unmarshal_ttmsf(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| int64_t val = unmarshal_int(buf); |
| int val_len = snprintf(dest, len, "%" PRId64 ".%03d", val / 1000, int((val < 0 ? -val : val) % 1000)); |
| if (val_len >= len) { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| return val_len; |
| } |
| |
| int |
| LogAccess::unmarshal_int_to_date_str(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| int64_t value = unmarshal_int(buf); |
| char *strval = LogUtils::timestamp_to_date_str(value); |
| int strlen = static_cast<int>(::strlen(strval)); |
| |
| if (strlen > len) { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| memcpy(dest, strval, strlen); |
| return strlen; |
| } |
| |
| int |
| LogAccess::unmarshal_int_to_time_str(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| int64_t value = unmarshal_int(buf); |
| char *strval = LogUtils::timestamp_to_time_str(value); |
| int strlen = static_cast<int>(::strlen(strval)); |
| |
| if (strlen > len) { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| memcpy(dest, strval, strlen); |
| return strlen; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_resp_all_header_fields(char *buf) |
| { |
| return LogUtils::marshalMimeHdr(m_server_response, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_int_to_netscape_str(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| int64_t value = unmarshal_int(buf); |
| char *strval = LogUtils::timestamp_to_netscape_str(value); |
| int strlen = static_cast<int>(::strlen(strval)); |
| |
| if (strlen > len) { |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| memcpy(dest, strval, strlen); |
| return strlen; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_http_method |
| |
| Retrieve the int pointed at by the buffer and treat as an HttpMethod |
| enumerated type. Then lookup the string representation for that enum and |
| return the string. Advance the buffer pointer past the enum. |
| -------------------------------------------------------------------------*/ |
| /* |
| int |
| LogAccess::unmarshal_http_method (char **buf, char *dest, int len) |
| { |
| return unmarshal_str (buf, dest, len); |
| } |
| */ |
| |
| int |
| LogAccess::marshal_cache_resp_all_header_fields(char *buf) |
| { |
| return LogUtils::marshalMimeHdr(m_cache_response, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_http_version |
| |
| The HTTP version is marshalled as a "major.minor" string. Prefix it with |
| "HTTP/" for the established text log representation. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_http_version(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| static constexpr std::string_view prefix{"HTTP/"}; |
| |
| char *version = *buf; |
| int version_len = static_cast<int>(strlen(version)); |
| int value_len = static_cast<int>(prefix.size()) + version_len; |
| |
| *buf += padded_strlen(version); |
| if (value_len <= len) { |
| memcpy(dest, prefix.data(), prefix.size()); |
| memcpy(dest + prefix.size(), version, version_len); |
| return value_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_http_status |
| |
| An http response status code (pssc,sssc) is just an INT, but it's always |
| formatted with three digits and leading zeros. So, we need a special |
| version of unmarshal_int_to_str that does this leading zero formatting. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_http_status(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| char val_buf[128]; |
| int64_t val = unmarshal_int(buf); |
| int val_len = unmarshal_itoa(val, val_buf + 127, 3, '0'); |
| if (val_len < len) { |
| memcpy(dest, val_buf + 128 - val_len, val_len); |
| return val_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_ip |
| |
| Retrieve an IP address directly. |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::unmarshal_ip(char **buf, IpEndpoint *dest) |
| { |
| int len = sizeof(LogFieldIp); // of object processed. |
| |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| LogFieldIp *raw = reinterpret_cast<LogFieldIp *>(*buf); |
| if (AF_INET == raw->_family) { |
| LogFieldIp4 *ip4 = static_cast<LogFieldIp4 *>(raw); |
| ats_ip4_set(dest, ip4->_addr); |
| len = sizeof(*ip4); |
| } else if (AF_INET6 == raw->_family) { |
| LogFieldIp6 *ip6 = static_cast<LogFieldIp6 *>(raw); |
| ats_ip6_set(dest, ip6->_addr); |
| len = sizeof(*ip6); |
| } else if (AF_UNIX == raw->_family) { |
| LogFieldUn *un = static_cast<LogFieldUn *>(raw); |
| ats_unix_set(dest, un->_path, TS_UNIX_SIZE); |
| len = sizeof(*un); |
| } else { |
| ats_ip_invalidate(dest); |
| } |
| len = INK_ALIGN_DEFAULT(len); |
| *buf += len; |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_ip_to_str |
| |
| Retrieve the IP addresspointed at by the buffer and convert to a |
| string in standard format. The string is written to @a dest and its |
| length (not including nul) is returned. @a *buf is advanced. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_ip_to_str(char **buf, char *dest, int len) |
| { |
| IpEndpoint ip; |
| |
| if (len > 0) { |
| unmarshal_ip(buf, &ip); |
| if (!ats_is_ip(&ip) && !ats_is_unix(ip)) { |
| *dest = '0'; |
| Dbg(dbg_ctl_log_unmarshal_data, "Invalid IP address"); |
| return 1; |
| } else if (ats_ip_ntop(&ip, dest, len)) { |
| return static_cast<int>(::strlen(dest)); |
| } |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_ip_to_hex |
| |
| Retrieve the int pointed at by the buffer and treat as an IP |
| address. Convert to a string in byte oriented hexadecimal and |
| return the string. Advance the buffer pointer. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_ip_to_hex(char **buf, char *dest, int len) |
| { |
| IpEndpoint ip; |
| |
| if (len > 0) { |
| unmarshal_ip(buf, &ip); |
| if (!ats_is_ip(&ip) && !ats_is_unix(ip)) { |
| *dest = '0'; |
| Dbg(dbg_ctl_log_unmarshal_data, "Invalid IP address"); |
| return 1; |
| } else { |
| return ats_ip_to_hex(&ip.sa, dest, len); |
| } |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_hierarchy |
| |
| Retrieve the int pointed at by the buffer and treat as a |
| SquidHierarchyCode. Use this as an index into the local string |
| conversion tables and return the string equivalent to the enum. |
| Advance the buffer pointer. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_hierarchy(char **buf, char *dest, int len, const Ptr<LogFieldAliasMap> &map) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| return (LogAccess::unmarshal_with_map(unmarshal_int(buf), dest, len, map, "INVALID_CODE")); |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_finish_status |
| |
| Retrieve the int pointed at by the buffer and treat as a finish code. |
| Use the enum as an index into a string table and return the string equiv |
| of the enum. Advance the pointer. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_finish_status(char **buf, char *dest, int len, const Ptr<LogFieldAliasMap> &map) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| return (LogAccess::unmarshal_with_map(unmarshal_int(buf), dest, len, map, "UNKNOWN_FINISH_CODE")); |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_cache_code |
| |
| Retrieve the int pointed at by the buffer and treat as a SquidLogCode. |
| Use this to index into the local string tables and return the string |
| equiv of the enum. Advance the pointer. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_cache_code(char **buf, char *dest, int len, const Ptr<LogFieldAliasMap> &map) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| return (LogAccess::unmarshal_with_map(unmarshal_int(buf), dest, len, map, "ERROR_UNKNOWN")); |
| } |
| |
| /*------------------------------------------------------------------------- |
| LogAccess::unmarshal_cache_hit_miss |
| |
| Retrieve the int pointed at by the buffer and treat as a SquidHitMissCode. |
| Use this to index into the local string tables and return the string |
| equiv of the enum. Advance the pointer. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::unmarshal_cache_hit_miss(char **buf, char *dest, int len, const Ptr<LogFieldAliasMap> &map) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| return (LogAccess::unmarshal_with_map(unmarshal_int(buf), dest, len, map, "HIT_MISS_UNKNOWN")); |
| } |
| |
| int |
| LogAccess::unmarshal_cache_write_code(char **buf, char *dest, int len, const Ptr<LogFieldAliasMap> &map) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| return (LogAccess::unmarshal_with_map(unmarshal_int(buf), dest, len, map, "UNKNOWN_CACHE_WRITE_CODE")); |
| } |
| |
| int |
| LogAccess::unmarshal_record(char **buf, char *dest, int len) |
| { |
| ink_assert(buf != nullptr); |
| ink_assert(*buf != nullptr); |
| ink_assert(dest != nullptr); |
| |
| char *val_buf = *buf; |
| int val_len = static_cast<int>(::strlen(val_buf)); |
| *buf += MARSHAL_RECORD_LENGTH; // this is how it was stored |
| if (val_len < len) { |
| memcpy(dest, val_buf, val_len); |
| return val_len; |
| } |
| DBG_UNMARSHAL_DEST_OVERRUN |
| return -1; |
| } |
| |
| /*------------------------------------------------------------------------- |
| resolve_logfield_string |
| |
| This function resolves the given custom log format string using the given |
| LogAccess context and returns the resulting string, which is ats_malloc'd. |
| The caller is responsible for ats_free'ing the return result. If there are |
| any problems, NULL is returned. |
| -------------------------------------------------------------------------*/ |
| char * |
| resolve_logfield_string(LogAccess *context, const char *format_str) |
| { |
| if (!context) { |
| Dbg(dbg_ctl_log_resolve, "No context to resolve?"); |
| return nullptr; |
| } |
| |
| if (!format_str) { |
| Dbg(dbg_ctl_log_resolve, "No format to resolve?"); |
| return nullptr; |
| } |
| |
| Dbg(dbg_ctl_log_resolve, "Resolving: %s", format_str); |
| |
| // |
| // Divide the format string into two parts: one for the printf-style |
| // string and one for the symbols. |
| // |
| char *printf_str = nullptr; |
| char *fields_str = nullptr; |
| int n_fields = LogFormat::parse_format_string(format_str, &printf_str, &fields_str); |
| |
| // |
| // Perhaps there were no fields to resolve? Then just return the |
| // format_str. Nothing to free here either. |
| // |
| if (!n_fields) { |
| Dbg(dbg_ctl_log_resolve, "No fields found; returning copy of format_str"); |
| ats_free(printf_str); |
| ats_free(fields_str); |
| return ats_strdup(format_str); |
| } |
| |
| Dbg(dbg_ctl_log_resolve, "%d fields: %s", n_fields, fields_str); |
| Dbg(dbg_ctl_log_resolve, "printf string: %s", printf_str); |
| |
| LogFieldList fields; |
| bool contains_aggregates; |
| int field_count = LogFormat::parse_symbol_string(fields_str, &fields, &contains_aggregates); |
| |
| if (field_count != n_fields) { |
| Error("format_str contains %d invalid field symbols", n_fields - field_count); |
| ats_free(printf_str); |
| ats_free(fields_str); |
| return nullptr; |
| } |
| // |
| // Ok, now marshal the data out of the LogAccess object and into a |
| // temporary storage buffer. Make sure the LogAccess context is |
| // initialized first. |
| // |
| Dbg(dbg_ctl_log_resolve, "Marshaling data from LogAccess into buffer ..."); |
| context->init(); |
| unsigned bytes_needed = fields.marshal_len(context); |
| char *buf = static_cast<char *>(ats_malloc(bytes_needed)); |
| unsigned bytes_used = fields.marshal(context, buf); |
| |
| ink_assert(bytes_needed == bytes_used); |
| Dbg(dbg_ctl_log_resolve, " %u bytes marshalled", bytes_used); |
| |
| // |
| // Now we can "unmarshal" the data from the buffer into a string, |
| // combining it with the data from the printf string. The problem is, |
| // we're not sure how much space it will take when it's unmarshalled. |
| // So, we'll just guess. |
| // |
| char *result = static_cast<char *>(ats_malloc(8192)); |
| unsigned bytes_resolved = |
| LogBuffer::resolve_custom_entry(&fields, printf_str, buf, result, 8191, LogUtils::timestamp(), 0, LOG_SEGMENT_VERSION); |
| ink_assert(bytes_resolved < 8192); |
| |
| if (!bytes_resolved) { |
| ats_free(result); |
| result = nullptr; |
| } else { |
| result[bytes_resolved] = 0; // NULL terminate |
| } |
| |
| ats_free(printf_str); |
| ats_free(fields_str); |
| ats_free(buf); |
| |
| return result; |
| } |
| void |
| LogAccess::set_client_req_url(char *buf, int len) |
| { |
| if (buf) { |
| m_client_req_url_len = std::min(len, m_client_req_url_len); |
| ink_strlcpy(m_client_req_url_str, buf, m_client_req_url_len + 1); |
| } |
| } |
| |
| void |
| LogAccess::set_client_req_url_canon(char *buf, int len) |
| { |
| if (buf) { |
| m_client_req_url_canon_len = std::min(len, m_client_req_url_canon_len); |
| ink_strlcpy(m_client_req_url_canon_str, buf, m_client_req_url_canon_len + 1); |
| } |
| } |
| |
| void |
| LogAccess::set_client_req_unmapped_url_canon(char *buf, int len) |
| { |
| if (buf && m_client_req_unmapped_url_canon_str) { |
| // m_client_req_unmapped_url_canon_str is not necessarily null terminated. |
| m_client_req_unmapped_url_canon_len = std::min(len, m_client_req_unmapped_url_canon_len); |
| memcpy(m_client_req_unmapped_url_canon_str, buf, m_client_req_unmapped_url_canon_len); |
| } |
| } |
| |
| void |
| LogAccess::set_client_req_unmapped_url_path(char *buf, int len) |
| { |
| if (buf && m_client_req_unmapped_url_path_str) { |
| m_client_req_unmapped_url_path_len = std::min(len, m_client_req_unmapped_url_path_len); |
| ink_strlcpy(m_client_req_unmapped_url_path_str, buf, m_client_req_unmapped_url_path_len + 1); |
| } |
| } |
| |
| void |
| LogAccess::set_client_req_unmapped_url_host(char *buf, int len) |
| { |
| if (buf && m_client_req_unmapped_url_host_str) { |
| m_client_req_unmapped_url_host_len = std::min(len, m_client_req_unmapped_url_host_len); |
| ink_strlcpy(m_client_req_unmapped_url_host_str, buf, m_client_req_unmapped_url_host_len + 1); |
| } |
| } |
| |
| void |
| LogAccess::set_client_req_url_path(char *buf, int len) |
| { |
| //?? use m_client_req_unmapped_url_path_str for now..may need to enhance later.. |
| this->set_client_req_unmapped_url_path(buf, len); |
| } |
| |
| /*------------------------------------------------------------------------- |
| The marshalling routines ... |
| |
| Header pointers may be null; each routine must guard before use. |
| -------------------------------------------------------------------------*/ |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_plugin_identity_id(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_plugin_id()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_plugin_identity_tag(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| const char *tag = m_data->get_plugin_tag(); |
| |
| if (!tag) { |
| tag = "*"; |
| } else { |
| len = LogAccess::padded_strlen(tag); |
| } |
| |
| if (buf) { |
| marshal_str(buf, tag, len); |
| } |
| |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_client_host_ip(char *buf) |
| { |
| return marshal_ip(buf, m_data->get_client_addr()); |
| } |
| |
| int |
| LogAccess::marshal_remote_host_ip(char *buf) |
| { |
| return marshal_ip(buf, m_data->get_client_src_addr()); |
| } |
| |
| int |
| LogAccess::marshal_host_interface_ip(char *buf) |
| { |
| return marshal_ip(buf, m_data->get_client_dst_addr()); |
| } |
| |
| int |
| LogAccess::marshal_client_host_ip_verified(char *buf) |
| { |
| if (m_data->get_verified_client_addr()) { |
| return marshal_ip(buf, m_data->get_verified_client_addr()); |
| } |
| |
| return marshal_client_host_ip(buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_cache_lookup_url_canon(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| |
| validate_lookup_url(); |
| if (m_cache_lookup_url_canon_str == INVALID_STR) { |
| // If the lookup URL isn't populated, we'll fall back to the request URL. |
| len = marshal_client_req_url_canon(buf); |
| } else { |
| len = padded_length(m_cache_lookup_url_canon_len + 1); // +1 for eos |
| if (buf) { |
| marshal_mem(buf, m_cache_lookup_url_canon_str, m_cache_lookup_url_canon_len, len); |
| } |
| } |
| |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_sni_server_name(char *buf) |
| { |
| const char *sni = m_data->get_sni_server_name(); |
| const char *server_name_cstr = sni ? sni : ""; |
| int len = LogAccess::padded_strlen(server_name_cstr); |
| if (buf) { |
| marshal_str(buf, server_name_cstr, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_provided_cert(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_client_provided_cert()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_proxy_provided_cert(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_server_connection_provided_cert()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_version_build_number(char *buf) |
| { |
| auto &version = AppVersionInfo::get_version(); |
| int len = LogAccess::padded_strlen(version.build_number()); |
| if (buf) { |
| marshal_str(buf, version.build_number(), len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_version_string(char *buf) |
| { |
| auto &version = AppVersionInfo::get_version(); |
| int len = LogAccess::padded_strlen(version.version()); |
| if (buf) { |
| marshal_str(buf, version.version(), len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_protocol_version(char *buf) |
| { |
| const char *version_str; |
| switch (m_data->get_pp_version()) { |
| case 1: |
| version_str = "V1"; |
| break; |
| case 2: |
| version_str = "V2"; |
| break; |
| default: |
| version_str = "-"; |
| break; |
| } |
| int len = LogAccess::padded_strlen(version_str); |
| if (buf) { |
| marshal_str(buf, version_str, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_proxy_protocol_src_ip(char *buf) |
| { |
| sockaddr const *ip = nullptr; |
| if (m_data->get_pp_version() != 0) { |
| ip = m_data->get_pp_src_addr(); |
| } |
| return marshal_ip(buf, ip); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_proxy_protocol_dst_ip(char *buf) |
| { |
| sockaddr const *ip = nullptr; |
| if (m_data->get_pp_version() != 0) { |
| ip = m_data->get_pp_dst_addr(); |
| } |
| return marshal_ip(buf, ip); |
| } |
| |
| int |
| LogAccess::marshal_proxy_protocol_authority(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| std::string_view authority = m_data->get_pp_authority(); |
| |
| if (!authority.empty()) { |
| len = padded_length(static_cast<int>(authority.size()) + 1); |
| if (buf) { |
| marshal_mem(buf, authority.data(), static_cast<int>(authority.size()), len); |
| } |
| } |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_proxy_protocol_tls_cipher(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| std::string_view cipher = m_data->get_pp_tls_cipher(); |
| |
| if (!cipher.empty()) { |
| len = padded_length(static_cast<int>(cipher.size()) + 1); |
| if (buf) { |
| marshal_mem(buf, cipher.data(), static_cast<int>(cipher.size()), len); |
| } |
| } else { |
| if (buf) { |
| marshal_mem(buf, nullptr, 0, len); |
| } |
| } |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_proxy_protocol_tls_version(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| std::string_view version = m_data->get_pp_tls_version(); |
| |
| if (!version.empty()) { |
| len = padded_length(static_cast<int>(version.size()) + 1); |
| if (buf) { |
| marshal_mem(buf, version.data(), static_cast<int>(version.size()), len); |
| } |
| } else { |
| if (buf) { |
| marshal_mem(buf, nullptr, 0, len); |
| } |
| } |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_proxy_protocol_tls_group(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| std::string_view group = m_data->get_pp_tls_group(); |
| |
| if (!group.empty()) { |
| len = padded_length(static_cast<int>(group.size()) + 1); |
| if (buf) { |
| marshal_mem(buf, group.data(), static_cast<int>(group.size()), len); |
| } |
| } else { |
| if (buf) { |
| marshal_mem(buf, nullptr, 0, len); |
| } |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_host_port(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_client_port()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_remote_host_port(char *buf) |
| { |
| if (buf) { |
| sockaddr const *src = m_data->get_client_src_addr(); |
| uint16_t port = src ? ats_ip_port_host_order(src) : 0; |
| marshal_int(buf, port); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| user authenticated to the proxy (RFC931) |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_auth_user_name(char *buf) |
| { |
| char *str = nullptr; |
| int len = INK_MIN_ALIGN; |
| |
| // Jira TS-40: |
| // NOTE: Authentication related code and modules were removed/disabled. |
| // Uncomment code path below when re-added/enabled. |
| /*if (auth_params.user_name) { |
| str = auth_params.user_name; |
| len = LogAccess::strlen(str); |
| } */ |
| if (buf) { |
| marshal_str(buf, str, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| Private utility function to validate m_client_req_unmapped_url_canon_str & |
| m_client_req_unmapped_url_canon_len fields. |
| -------------------------------------------------------------------------*/ |
| |
| void |
| LogAccess::validate_unmapped_url() |
| { |
| char *unmapped_url_str = m_data->get_unmapped_url_str(); |
| int unmapped_url_len = m_data->get_unmapped_url_len(); |
| |
| if (unmapped_url_str == nullptr) { |
| m_client_req_unmapped_url_canon_str = INVALID_STR; |
| return; |
| } |
| |
| if (m_client_req_unmapped_url_canon_str == nullptr) { |
| // prevent multiple validations |
| m_client_req_unmapped_url_canon_str = INVALID_STR; |
| |
| if (unmapped_url_len > 0) { |
| if (unmapped_url_str && unmapped_url_str[0] != 0) { |
| m_client_req_unmapped_url_canon_str = |
| Encoding::escapify_url(&m_arena, unmapped_url_str, unmapped_url_len, &m_client_req_unmapped_url_canon_len); |
| } |
| } |
| } |
| } |
| |
| /*------------------------------------------------------------------------- |
| Private utility function to validate m_client_req_unmapped_url_path_str & |
| m_client_req_unmapped_url_path_len fields. |
| -------------------------------------------------------------------------*/ |
| |
| void |
| LogAccess::validate_unmapped_url_path() |
| { |
| if (m_client_req_unmapped_url_path_str == nullptr && m_client_req_unmapped_url_host_str == nullptr) { |
| // Use unmapped canonical URL as default |
| m_client_req_unmapped_url_path_str = m_client_req_unmapped_url_canon_str; |
| m_client_req_unmapped_url_path_len = m_client_req_unmapped_url_canon_len; |
| // In case the code below fails, we prevent it from being used. |
| m_client_req_unmapped_url_host_str = INVALID_STR; |
| |
| if (m_client_req_unmapped_url_path_len >= 6) { // xxx:// - minimum schema size |
| int len; |
| char *c = |
| static_cast<char *>(memchr((void *)m_client_req_unmapped_url_path_str, ':', m_client_req_unmapped_url_path_len - 1)); |
| |
| if (c && (len = static_cast<int>(c - m_client_req_unmapped_url_path_str)) <= 5) { // 5 - max schema size |
| if (len + 2 <= m_client_req_unmapped_url_canon_len && c[1] == '/' && c[2] == '/') { |
| len += 3; // Skip "://" |
| m_client_req_unmapped_url_host_str = &m_client_req_unmapped_url_canon_str[len]; |
| m_client_req_unmapped_url_host_len = m_client_req_unmapped_url_path_len - len; |
| // Attempt to find first '/' in the path |
| if (m_client_req_unmapped_url_host_len > 0 && |
| (c = static_cast<char *>( |
| memchr((void *)m_client_req_unmapped_url_host_str, '/', m_client_req_unmapped_url_host_len))) != nullptr) { |
| m_client_req_unmapped_url_host_len = static_cast<int>(c - m_client_req_unmapped_url_host_str); |
| m_client_req_unmapped_url_path_str = &m_client_req_unmapped_url_host_str[m_client_req_unmapped_url_host_len]; |
| m_client_req_unmapped_url_path_len = m_client_req_unmapped_url_path_len - len - m_client_req_unmapped_url_host_len; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /*------------------------------------------------------------------------- |
| Private utility function to validate m_cache_lookup_url_canon_str & |
| m_cache_lookup__url_canon_len fields. |
| -------------------------------------------------------------------------*/ |
| void |
| LogAccess::validate_lookup_url() |
| { |
| char *lookup_url_str = m_data->get_cache_lookup_url_str(); |
| int lookup_url_len = m_data->get_cache_lookup_url_len(); |
| |
| if (lookup_url_str == nullptr) { |
| m_cache_lookup_url_canon_str = INVALID_STR; |
| return; |
| } |
| |
| if (m_cache_lookup_url_canon_str == nullptr) { |
| // prevent multiple validations |
| m_cache_lookup_url_canon_str = INVALID_STR; |
| |
| if (lookup_url_len > 0) { |
| if (lookup_url_str && lookup_url_str[0] != 0) { |
| m_cache_lookup_url_canon_str = |
| Encoding::escapify_url(&m_arena, lookup_url_str, lookup_url_len, &m_cache_lookup_url_canon_len); |
| } |
| } |
| } |
| } |
| |
| /*------------------------------------------------------------------------- |
| This is the method, url, and version all rolled into one. Use the |
| respective marshalling routines to do the job. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_text(char *buf) |
| { |
| int len = marshal_client_req_http_method(nullptr) + marshal_client_req_url(nullptr) + marshal_client_req_http_version(nullptr); |
| |
| if (buf) { |
| int offset = 0; |
| offset += marshal_client_req_http_method(&buf[offset]); |
| offset += marshal_client_req_url(&buf[offset]); |
| offset += marshal_client_req_http_version(&buf[offset]); |
| len = offset; |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_timestamp_sec(char *buf) |
| { |
| return marshal_milestone_fmt_sec(TS_MILESTONE_UA_BEGIN, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_timestamp_ms(char *buf) |
| { |
| return marshal_milestone_fmt_ms(TS_MILESTONE_UA_BEGIN, buf); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_http_method(char *buf) |
| { |
| std::string_view str; |
| int plen = INK_MIN_ALIGN; |
| |
| if (m_client_request) { |
| str = m_client_request->method_get(); |
| } |
| |
| if (str.empty()) { |
| str = m_data->get_method(); |
| } |
| |
| // calculate the padded length only if the actual length |
| // is not zero. We don't want the padded length to be zero |
| // because marshal_mem should write the DEFAULT_STR to the |
| // buffer if str is nil, and we need room for this. |
| // |
| if (!str.empty()) { |
| plen = padded_length(static_cast<int>(str.length()) + 1); // +1 for trailing 0 |
| } |
| |
| if (buf) { |
| marshal_mem(buf, str.data(), static_cast<int>(str.length()), plen); |
| } |
| return plen; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_url(char *buf) |
| { |
| int len = padded_length(m_client_req_url_len + 1); // +1 for trailing 0 |
| |
| if (buf) { |
| marshal_mem(buf, m_client_req_url_str, m_client_req_url_len, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_url_canon(char *buf) |
| { |
| int len = padded_length(m_client_req_url_canon_len + 1); |
| |
| if (buf) { |
| marshal_mem(buf, m_client_req_url_canon_str, m_client_req_url_canon_len, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_unmapped_url_canon(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| |
| validate_unmapped_url(); |
| if (m_client_req_unmapped_url_canon_str == INVALID_STR) { |
| // If the unmapped URL isn't populated, we'll fall back to the original |
| // client URL. This helps for example server intercepts to continue to |
| // log the requests, even when there is no remap rule for it. |
| len = marshal_client_req_url_canon(buf); |
| } else { |
| len = padded_length(m_client_req_unmapped_url_canon_len + 1); // +1 for eos |
| if (buf) { |
| marshal_mem(buf, m_client_req_unmapped_url_canon_str, m_client_req_unmapped_url_canon_len, len); |
| } |
| } |
| |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_unmapped_url_path(char *buf) |
| { |
| int len = INK_MIN_ALIGN; |
| |
| validate_unmapped_url(); |
| validate_unmapped_url_path(); |
| |
| if (m_client_req_unmapped_url_path_str == INVALID_STR) { |
| len = marshal_client_req_url_path(buf); |
| } else { |
| len = padded_length(m_client_req_unmapped_url_path_len + 1); // +1 for eos |
| if (buf) { |
| marshal_mem(buf, m_client_req_unmapped_url_path_str, m_client_req_unmapped_url_path_len, len); |
| } |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_unmapped_url_host(char *buf) |
| { |
| validate_unmapped_url(); |
| validate_unmapped_url_path(); |
| |
| int len = padded_length(m_client_req_unmapped_url_host_len + 1); // +1 for eos |
| if (buf) { |
| marshal_mem(buf, m_client_req_unmapped_url_host_str, m_client_req_unmapped_url_host_len, len); |
| } |
| |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_client_req_url_path(char *buf) |
| { |
| int len = padded_length(m_client_req_url_path_len + 1); |
| if (buf) { |
| marshal_mem(buf, m_client_req_url_path_str, m_client_req_url_path_len, len); |
| } |
| return len; |
| } |
| |
| int |
| LogAccess::marshal_client_req_url_scheme(char *buf) |
| { |
| const char *str = nullptr; |
| int alen = 0; |
| int plen = INK_MIN_ALIGN; |
| int scheme = m_data->get_orig_scheme(); |
| std::string_view scheme_sv = m_data->get_scheme(); |
| |
| if (scheme >= 0) { |
| str = hdrtoken_index_to_wks(scheme); |
| alen = hdrtoken_index_to_length(scheme); |
| } else if (!scheme_sv.empty()) { |
| str = scheme_sv.data(); |
| alen = static_cast<int>(scheme_sv.size()); |
| } else { |
| str = "UNKNOWN"; |
| alen = 7; |
| } |
| plen = padded_length(alen + 1); |
| |
| if (buf) { |
| marshal_mem(buf, str, alen, plen); |
| } |
| |
| return plen; |
| } |
| |
| /*------------------------------------------------------------------------- |
| For this one we're going to marshal two INTs, one the first representing |
| the major number and the second representing the minor. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_http_version(char *buf) |
| { |
| if (buf) { |
| if (m_client_request) { |
| HTTPVersion versionObject = m_client_request->version_get(); |
| marshal_int(buf, versionObject.get_major()); |
| marshal_int((buf + INK_MIN_ALIGN), versionObject.get_minor()); |
| } else { |
| marshal_int(buf, 0); |
| marshal_int((buf + INK_MIN_ALIGN), 0); |
| } |
| } |
| return (2 * INK_MIN_ALIGN); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_protocol_version(char *buf) |
| { |
| const char *protocol_str = m_data->get_client_protocol(); |
| std::string_view protocol_sv = m_data->get_client_protocol_str(); |
| if (protocol_str == nullptr || protocol_str[0] == '\0') { |
| if (!protocol_sv.empty()) { |
| protocol_str = protocol_sv.data(); |
| } else { |
| protocol_str = DEFAULT_STR; |
| } |
| } |
| |
| int len = LogAccess::padded_strlen(protocol_str); |
| |
| // Set major & minor versions when protocol_str is not "http/2". |
| if (::strlen(protocol_str) == 4 && strncmp("http", protocol_str, 4) == 0) { |
| if (m_client_request) { |
| HTTPVersion versionObject = m_client_request->version_get(); |
| if (versionObject == HTTP_1_1) { |
| protocol_str = "http/1.1"; |
| } else if (versionObject == HTTP_1_0) { |
| protocol_str = "http/1.0"; |
| } // else invalid http version |
| } else { |
| protocol_str = "*"; |
| } |
| |
| len = LogAccess::padded_strlen(protocol_str); |
| } |
| |
| if (buf) { |
| marshal_str(buf, protocol_str, len); |
| } |
| |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_req_protocol_version(char *buf) |
| { |
| const char *server_proto = m_data->get_server_protocol(); |
| const char *protocol_str = server_proto ? server_proto : DEFAULT_STR; |
| int len = LogAccess::padded_strlen(protocol_str); |
| |
| // Set major & minor versions when protocol_str is not "http/2". |
| if (::strlen(protocol_str) == 4 && strncmp("http", protocol_str, 4) == 0) { |
| if (m_proxy_request) { |
| HTTPVersion versionObject = m_proxy_request->version_get(); |
| if (versionObject == HTTP_1_1) { |
| protocol_str = "http/1.1"; |
| } else if (versionObject == HTTP_1_0) { |
| protocol_str = "http/1.0"; |
| } // else invalid http version |
| } else { |
| protocol_str = "*"; |
| } |
| |
| len = LogAccess::padded_strlen(protocol_str); |
| } |
| |
| if (buf) { |
| marshal_str(buf, protocol_str, len); |
| } |
| |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_header_len(char *buf) |
| { |
| if (buf) { |
| int64_t len = 0; |
| if (m_client_request) { |
| len = m_client_request->length_get(); |
| } |
| marshal_int(buf, len); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_content_len(char *buf) |
| { |
| if (buf) { |
| int64_t len = 0; |
| if (m_client_request) { |
| len = m_data->get_client_request_body_bytes(); |
| } |
| marshal_int(buf, len); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_client_req_squid_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_client_request) { |
| val = m_client_request->length_get() + m_data->get_client_request_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| Client request squid length plus TLS handshake bytes received for TLS connections. |
| For TLS 1.3 early data (0-RTT), we subtract the early data length from the |
| handshake bytes to avoid double-counting since the early data bytes are |
| already included in client_request_body_bytes. |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_req_squid_len_tls(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| |
| if (m_client_request) { |
| val = m_client_request->length_get() + m_data->get_client_request_body_bytes(); |
| } |
| |
| if (!m_data->get_client_tcp_reused()) { |
| uint64_t handshake_rx = m_data->get_client_tls_handshake_bytes_rx(); |
| size_t early_data_len = m_data->get_client_tls_early_data_len(); |
| |
| if (early_data_len > 0) { |
| handshake_rx -= std::min(handshake_rx, static_cast<uint64_t>(early_data_len)); |
| } |
| |
| val += handshake_rx; |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_tcp_reused(char *buf) |
| { |
| if (buf) { |
| int64_t val = m_data->get_client_tcp_reused() ? 1 : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_client_req_is_ssl(char *buf) |
| { |
| if (buf) { |
| int64_t val = m_data->get_client_connection_is_ssl() ? 1 : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_client_req_ssl_reused(char *buf) |
| { |
| if (buf) { |
| int64_t val = m_data->get_client_ssl_reused() ? 1 : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_client_ssl_resumption_type(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_client_ssl_resumption_type()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_client_req_is_internal(char *buf) |
| { |
| if (buf) { |
| int64_t val = m_data->get_is_internal() ? 1 : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_client_req_mptcp_state(char *buf) |
| { |
| if (buf) { |
| int val = -1; |
| std::optional<bool> mptcp_state = m_data->get_mptcp_state(); |
| |
| if (mptcp_state.has_value()) { |
| val = mptcp_state.value() ? 1 : 0; |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_finish_status_code(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_client_finish_status_code()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_id(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_sm_id()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_req_uuid(char *buf) |
| { |
| char str[TS_CRUUID_STRING_LEN + 1]; |
| const char *uuid = Machine::instance()->process_uuid.getString(); |
| int64_t req_id = m_data->get_sm_id(); |
| int len = snprintf(str, sizeof(str), "%s-%" PRId64 "", uuid, req_id); |
| |
| ink_assert(len <= TS_CRUUID_STRING_LEN); |
| len = padded_length(len + 1); |
| |
| if (buf) { |
| marshal_str(buf, str, len); // This will pad the remaining bytes properly ... |
| } |
| |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_rx_error_code(char *buf) |
| { |
| const char *err_code = m_data->get_client_rx_error_code(); |
| int round_len = LogAccess::padded_strlen(err_code); |
| |
| if (buf) { |
| marshal_str(buf, err_code, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| int |
| LogAccess::marshal_client_tx_error_code(char *buf) |
| { |
| const char *err_code = m_data->get_client_tx_error_code(); |
| int round_len = LogAccess::padded_strlen(err_code); |
| |
| if (buf) { |
| marshal_str(buf, err_code, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_security_protocol(char *buf) |
| { |
| const char *sec_proto = m_data->get_client_sec_protocol(); |
| const char *proto = sec_proto ? sec_proto : DEFAULT_STR; |
| int round_len = LogAccess::padded_strlen(proto); |
| |
| if (buf) { |
| marshal_str(buf, proto, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| int |
| LogAccess::marshal_client_security_cipher_suite(char *buf) |
| { |
| const char *cipher_suite = m_data->get_client_cipher_suite(); |
| const char *cipher = cipher_suite ? cipher_suite : DEFAULT_STR; |
| int round_len = LogAccess::padded_strlen(cipher); |
| |
| if (buf) { |
| marshal_str(buf, cipher, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| int |
| LogAccess::marshal_client_security_curve(char *buf) |
| { |
| const char *client_curve = m_data->get_client_curve(); |
| const char *curve = client_curve ? client_curve : DEFAULT_STR; |
| int round_len = LogAccess::padded_strlen(curve); |
| |
| if (buf) { |
| marshal_str(buf, curve, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| int |
| LogAccess::marshal_client_security_group(char *buf) |
| { |
| const char *sec_group = m_data->get_client_security_group(); |
| const char *group = sec_group ? sec_group : DEFAULT_STR; |
| int round_len = LogAccess::padded_strlen(group); |
| |
| if (buf) { |
| marshal_str(buf, group, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| int |
| LogAccess::marshal_client_security_alpn(char *buf) |
| { |
| const char *alpn = "-"; |
| int alpn_id = m_data->get_client_alpn_id(); |
| if (alpn_id != SessionProtocolNameRegistry::INVALID) { |
| swoc::TextView client_sec_alpn = globalSessionProtocolNameRegistry.nameFor(alpn_id); |
| alpn = client_sec_alpn.data(); |
| } |
| |
| int round_len = LogAccess::padded_strlen(alpn); |
| |
| if (buf) { |
| marshal_str(buf, alpn, round_len); |
| } |
| |
| return round_len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| TLS Handshake Bytes - Bytes received from client during TLS handshake |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_tls_handshake_bytes_rx(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_client_tls_handshake_bytes_rx())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| TLS Handshake Bytes - Bytes sent to client during TLS handshake |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_tls_handshake_bytes_tx(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_client_tls_handshake_bytes_tx())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| TLS Handshake Bytes - Total bytes (rx + tx) during TLS handshake |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_client_tls_handshake_bytes(char *buf) |
| { |
| if (buf) { |
| uint64_t total = m_data->get_client_tls_handshake_bytes_rx() + m_data->get_client_tls_handshake_bytes_tx(); |
| marshal_int(buf, static_cast<int64_t>(total)); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_content_type(char *buf) |
| { |
| int len = padded_length(m_proxy_resp_content_type_len + 1); |
| if (buf) { |
| marshal_mem(buf, m_proxy_resp_content_type_str, m_proxy_resp_content_type_len, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_reason_phrase(char *buf) |
| { |
| int len = padded_length(m_proxy_resp_reason_phrase_len + 1); |
| if (buf) { |
| marshal_mem(buf, m_proxy_resp_reason_phrase_str, m_proxy_resp_reason_phrase_len, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| Squid returns the content-length + header length as the total length. |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_squid_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = m_data->get_client_response_hdr_bytes() + m_data->get_client_response_body_bytes(); |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| Squid length plus TLS handshake bytes sent for TLS connections. |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_proxy_resp_squid_len_tls(char *buf) |
| { |
| if (buf) { |
| int64_t val = m_data->get_client_response_hdr_bytes() + m_data->get_client_response_body_bytes(); |
| |
| if (!m_data->get_client_tcp_reused()) { |
| val += m_data->get_client_tls_handshake_bytes_tx(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_content_len(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_client_response_body_bytes()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_status_code(char *buf) |
| { |
| if (buf) { |
| HTTPStatus status; |
| if (m_proxy_response && m_client_request) { |
| if (m_client_request->version_get() >= HTTPVersion(1, 0)) { |
| status = m_proxy_response->status_get(); |
| } |
| // INKqa10788 |
| // For bad/incomplete request, the request version may be 0.9. |
| // However, we can still log the status code if there is one. |
| else if (m_proxy_response->valid()) { |
| status = m_proxy_response->status_get(); |
| } else { |
| status = HTTPStatus::OK; |
| } |
| } else { |
| status = HTTPStatus::NONE; |
| } |
| marshal_int(buf, static_cast<int64_t>(status)); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_status_plugin_entry(char *buf) |
| { |
| char const *str = nullptr; |
| int len = INK_MIN_ALIGN; |
| std::string_view setter_name = m_data->get_http_return_code_setter_name(); |
| |
| if (!setter_name.empty()) { |
| str = setter_name.data(); |
| len = LogAccess::padded_strlen(str); |
| } |
| |
| if (buf) { |
| marshal_str(buf, str, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_resp_header_len(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_client_response_hdr_bytes()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_proxy_finish_status_code(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_proxy_finish_status_code()); |
| } |
| |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_proxy_host_port(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_incoming_port())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_result_code(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_log_code())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_result_subcode(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_subcode())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_hit_miss(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_hit_miss_code())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_req_header_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_proxy_request) { |
| val = m_proxy_request->length_get(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_req_content_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_proxy_request) { |
| val = m_data->get_server_request_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_proxy_req_squid_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_proxy_request) { |
| val = m_proxy_request->length_get() + m_data->get_server_request_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| // TODO: Change marshalling code to support both IPv4 and IPv6 addresses. |
| int |
| LogAccess::marshal_proxy_req_server_ip(char *buf) |
| { |
| return marshal_ip(buf, m_data->get_server_src_addr()); |
| } |
| |
| int |
| LogAccess::marshal_proxy_req_server_port(char *buf) |
| { |
| if (buf) { |
| uint16_t port = 0; |
| sockaddr const *src = m_data->get_server_src_addr(); |
| if (src) { |
| port = ats_ip_port_host_order(src); |
| } |
| marshal_int(buf, port); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_next_hop_ip(char *buf) |
| { |
| return marshal_ip(buf, m_data->get_server_dst_addr()); |
| } |
| |
| int |
| LogAccess::marshal_next_hop_port(char *buf) |
| { |
| if (buf) { |
| uint16_t port = 0; |
| sockaddr const *dst = m_data->get_server_dst_addr(); |
| if (dst) { |
| port = ats_ip_port_host_order(dst); |
| } |
| marshal_int(buf, port); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_req_is_ssl(char *buf) |
| { |
| if (buf) { |
| int64_t is_ssl = m_data->get_server_connection_is_ssl() ? 1 : 0; |
| marshal_int(buf, is_ssl); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_proxy_req_ssl_reused(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_server_ssl_reused() ? 1 : 0); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_proxy_hierarchy_route(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, static_cast<int64_t>(m_data->get_hier_code())); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| // TODO: Change marshalling code to support both IPv4 and IPv6 addresses. |
| int |
| LogAccess::marshal_server_host_ip(char *buf) |
| { |
| sockaddr const *ip = nullptr; |
| sockaddr const *info_dst = m_data->get_server_info_dst_addr(); |
| sockaddr const *server_dst = m_data->get_server_dst_addr(); |
| |
| if (info_dst && ats_is_ip(info_dst)) { |
| ip = info_dst; |
| } else if (server_dst && ats_is_ip(server_dst)) { |
| ip = server_dst; |
| } |
| return marshal_ip(buf, ip); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_host_name(char *buf) |
| { |
| const char *str = nullptr; |
| int len = INK_MIN_ALIGN; |
| sockaddr const *server_dst = m_data->get_server_dst_addr(); |
| const char *name = m_data->get_server_name(); |
| |
| if (server_dst && name != nullptr) { |
| str = name; |
| len = LogAccess::padded_strlen(str); |
| } |
| |
| if (buf) { |
| marshal_str(buf, str, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_resp_status_code(char *buf) |
| { |
| if (buf) { |
| HTTPStatus status; |
| if (m_server_response) { |
| status = m_server_response->status_get(); |
| } else { |
| status = HTTPStatus::NONE; |
| } |
| marshal_int(buf, static_cast<int64_t>(status)); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_resp_content_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_server_response) { |
| val = m_data->get_server_response_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_resp_header_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_server_response) { |
| val = m_server_response->length_get(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_server_resp_squid_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_server_response) { |
| val = m_server_response->length_get() + m_data->get_server_response_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_server_resp_http_version(char *buf) |
| { |
| return marshal_http_version_string(buf, m_server_response); |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_server_resp_time_ms(char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *ms = m_data->get_milestones(); |
| int64_t val = ms ? ms->difference_msec(TS_MILESTONE_SERVER_CONNECT, TS_MILESTONE_SERVER_CLOSE) : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_server_resp_time_s(char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *ms = m_data->get_milestones(); |
| int64_t val = ms ? static_cast<int64_t>(ms->difference_sec(TS_MILESTONE_SERVER_CONNECT, TS_MILESTONE_SERVER_CLOSE)) : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_transact_count(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_server_transact_count()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_simple_retry_count(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_simple_retry_attempts()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_unavailable_retry_count(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_unavailable_retry_attempts()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_server_connect_attempts(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_retry_attempts_saved()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_resp_status_code(char *buf) |
| { |
| if (buf) { |
| HTTPStatus status; |
| if (m_cache_response) { |
| status = m_cache_response->status_get(); |
| } else { |
| status = HTTPStatus::NONE; |
| } |
| marshal_int(buf, static_cast<int64_t>(status)); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_resp_content_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_cache_response) { |
| val = m_data->get_cache_response_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_cache_resp_squid_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_cache_response) { |
| val = m_cache_response->length_get() + m_data->get_cache_response_body_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_resp_header_len(char *buf) |
| { |
| if (buf) { |
| int64_t val = 0; |
| if (m_cache_response) { |
| val = m_data->get_cache_response_hdr_bytes(); |
| } |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_cache_resp_http_version(char *buf) |
| { |
| return marshal_http_version_string(buf, m_cache_response); |
| } |
| |
| int |
| LogAccess::marshal_client_retry_after_time(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_congestion_control_crat()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_cache_write_code(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_cache_write_code()); |
| } |
| |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_cache_write_transform_code(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_cache_transform_write_code()); |
| } |
| |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_key_hash(char *buf) |
| { |
| const ts::CryptoHash *hash = m_data->get_cache_lookup_hash(); |
| |
| if (!hash || hash->is_zero()) { |
| if (buf) { |
| marshal_str(buf, "-", padded_length(2)); |
| } |
| return padded_length(2); |
| } |
| |
| constexpr size_t b64_bufsize = ats_base64_encode_dstlen(CRYPTO_HASH_SIZE); |
| char b64_str[b64_bufsize]; |
| size_t b64_len = 0; |
| |
| ats_base64_encode(reinterpret_cast<const char *>(hash->u8), CRYPTO_HASH_SIZE, b64_str, b64_bufsize, &b64_len); |
| |
| int len = padded_length(b64_len + 1); |
| |
| if (buf) { |
| marshal_str(buf, b64_str, len); |
| } |
| return len; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_transfer_time_ms(char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *ms = m_data->get_milestones(); |
| int64_t val = ms ? ms->difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SM_FINISH) : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_transfer_time_s(char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *ms = m_data->get_milestones(); |
| int64_t val = ms ? static_cast<int64_t>(ms->difference_sec(TS_MILESTONE_SM_START, TS_MILESTONE_SM_FINISH)) : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| Figure out the size of the object *on origin*. This is somewhat tricky |
| since there are many variations on how this can be calculated. |
| -------------------------------------------------------------------------*/ |
| int |
| LogAccess::marshal_file_size(char *buf) |
| { |
| if (buf) { |
| MIMEField *fld; |
| HTTPHdr *hdr = m_server_response ? m_server_response : m_cache_response; |
| |
| if (hdr && (fld = hdr->field_find(static_cast<std::string_view>(MIME_FIELD_CONTENT_RANGE)))) { |
| auto value{fld->value_get()}; |
| int len = value.length(); |
| char *str = const_cast<char *>(value.data()); |
| char *pos = static_cast<char *>(memchr(str, '/', len)); // Find the / |
| |
| // If the size is not /* (which means unknown) use it as the file_size. |
| if (pos && !memchr(pos + 1, '*', len - (pos + 1 - str))) { |
| marshal_int(buf, ink_atoi64(pos + 1, len - (pos + 1 - str))); |
| } |
| } else { |
| // This is semi-broken when we serveq zero length objects. See TS-2213 |
| int64_t server_body = m_data->get_server_response_body_bytes(); |
| int64_t cache_body = m_data->get_cache_response_body_bytes(); |
| if (server_body > 0) { |
| marshal_int(buf, server_body); |
| } else if (cache_body > 0) { |
| marshal_int(buf, cache_body); |
| } |
| } |
| } |
| // Else, we don't set the value at all (so, -) |
| |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_http_connection_id(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_connection_id()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_http_transaction_id(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_transaction_id()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_http_transaction_priority_weight(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_transaction_priority_weight()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_client_http_transaction_priority_dependence(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_transaction_priority_dependence()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_read_retries(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_cache_open_read_tries()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_cache_write_retries(char *buf) |
| { |
| if (buf) { |
| marshal_int(buf, m_data->get_cache_open_write_tries()); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_cache_collapsed_connection_success(char *buf) |
| { |
| if (buf) { |
| int64_t id = 0; // default - no collapse attempt |
| SquidLogCode code = m_data->get_log_code(); |
| int open_write_tries = m_data->get_cache_open_write_tries(); |
| int max_write_retries = m_data->get_max_cache_open_write_retries(); |
| |
| if ((open_write_tries > 0) && ((code == SquidLogCode::TCP_HIT) || (code == SquidLogCode::TCP_MEM_HIT) || |
| (code == SquidLogCode::TCP_DISK_HIT) || (code == SquidLogCode::TCP_CF_HIT))) { |
| id = 1; |
| } else if (max_write_retries >= 0 && open_write_tries > max_write_retries) { |
| id = -1; |
| } |
| |
| marshal_int(buf, id); |
| } |
| return INK_MIN_ALIGN; |
| } |
| /*------------------------------------------------------------------------- |
| -------------------------------------------------------------------------*/ |
| |
| int |
| LogAccess::marshal_http_header_field(LogField::Container container, char *field, char *buf) |
| { |
| char *str = nullptr; |
| int padded_len = INK_MIN_ALIGN; |
| int actual_len = 0; |
| bool valid_field = false; |
| HTTPHdr *header = header_for_container(container); |
| |
| if (header) { |
| MIMEField *fld = header->field_find(std::string_view{field}); |
| if (fld) { |
| valid_field = true; |
| |
| // Loop over dups, marshalling each one into the buffer and |
| // summing up their length |
| // |
| int running_len = 0; |
| while (fld) { |
| auto value{fld->value_get()}; |
| actual_len = value.length(); |
| str = const_cast<char *>(value.data()); |
| if (buf) { |
| memcpy(buf, str, actual_len); |
| buf += actual_len; |
| } |
| running_len += actual_len; |
| fld = fld->m_next_dup; |
| |
| // Dups need to be comma separated. So if there's another |
| // dup, then add a comma and a space ... |
| // |
| if (fld != nullptr) { |
| if (buf) { |
| memcpy(buf, ", ", 2); |
| buf += 2; |
| } |
| running_len += 2; |
| } |
| } |
| |
| // Done with all dups. Ensure that the string is terminated |
| // and that the running_len is padded. |
| // |
| if (buf) { |
| *buf = '\0'; |
| buf++; |
| } |
| running_len += 1; |
| padded_len = padded_length(running_len); |
| |
| // Note: marshal_string fills the padding to |
| // prevent purify UMRs so we do it here too |
| // since we always pass the unpadded length on |
| // our calls to marshal string |
| #ifdef DEBUG |
| if (buf) { |
| int pad_len = padded_len - running_len; |
| for (int i = 0; i < pad_len; i++) { |
| *buf = '$'; |
| buf++; |
| } |
| } |
| #endif |
| } |
| } |
| |
| // The Transfer-Encoding:chunked value may have been removed from the header |
| // during processing, but we store it for logging purposes. |
| std::string_view transfer_enc = m_data->get_server_response_transfer_encoding(); |
| if (valid_field == false && !transfer_enc.empty() && container == LogField::SSH && strcmp(field, "Transfer-Encoding") == 0) { |
| std::string_view stored_te = transfer_enc; |
| if (!stored_te.empty()) { |
| valid_field = true; |
| actual_len = stored_te.length(); |
| str = const_cast<char *>(stored_te.data()); |
| |
| int running_len = actual_len + 1; // +1 for null terminator |
| padded_len = padded_length(running_len); |
| |
| if (buf) { |
| memcpy(buf, str, actual_len); |
| buf[actual_len] = '\0'; |
| buf += running_len; |
| |
| #ifdef DEBUG |
| int pad_len = padded_len - running_len; |
| for (int i = 0; i < pad_len; i++) { |
| *buf = '$'; |
| buf++; |
| } |
| #endif |
| } |
| } |
| } |
| |
| if (valid_field == false) { |
| padded_len = INK_MIN_ALIGN; |
| if (buf) { |
| marshal_str(buf, nullptr, padded_len); |
| } |
| } |
| |
| return (padded_len); |
| } |
| |
| int |
| LogAccess::marshal_http_header_field_escapify(LogField::Container container, char *field, char *buf) |
| { |
| char *str = nullptr, *new_str = nullptr; |
| int padded_len = INK_MIN_ALIGN; |
| int actual_len = 0, new_len = 0; |
| bool valid_field = false; |
| HTTPHdr *header = header_for_container(container); |
| |
| if (header) { |
| MIMEField *fld = header->field_find(std::string_view{field}); |
| if (fld) { |
| valid_field = true; |
| |
| // Loop over dups, marshalling each one into the buffer and |
| // summing up their length |
| // |
| int running_len = 0; |
| while (fld) { |
| auto value{fld->value_get()}; |
| actual_len = value.length(); |
| str = const_cast<char *>(value.data()); |
| new_str = Encoding::escapify_url(&m_arena, str, actual_len, &new_len); |
| if (buf) { |
| memcpy(buf, new_str, new_len); |
| buf += new_len; |
| } |
| running_len += new_len; |
| fld = fld->m_next_dup; |
| |
| // Dups need to be comma separated. So if there's another |
| // dup, then add a comma and an escapified space ... |
| constexpr const char SEP[] = ",%20"; |
| constexpr size_t SEP_LEN = sizeof(SEP) - 1; |
| if (fld != nullptr) { |
| if (buf) { |
| memcpy(buf, SEP, SEP_LEN); |
| buf += SEP_LEN; |
| } |
| running_len += SEP_LEN; |
| } |
| } |
| |
| // Done with all dups. Ensure that the string is terminated |
| // and that the running_len is padded. |
| // |
| if (buf) { |
| *buf = '\0'; |
| buf++; |
| } |
| running_len += 1; |
| padded_len = padded_length(running_len); |
| |
| // Note: marshal_string fills the padding to |
| // prevent purify UMRs so we do it here too |
| // since we always pass the unpadded length on |
| // our calls to marshal string |
| #ifdef DEBUG |
| if (buf) { |
| int pad_len = padded_len - running_len; |
| for (int i = 0; i < pad_len; i++) { |
| *buf = '$'; |
| buf++; |
| } |
| } |
| #endif |
| } |
| } |
| |
| if (valid_field == false) { |
| padded_len = INK_MIN_ALIGN; |
| if (buf) { |
| marshal_str(buf, nullptr, padded_len); |
| } |
| } |
| |
| return (padded_len); |
| } |
| |
| int |
| LogAccess::marshal_milestone(TSMilestonesType ms, char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *milestones = m_data->get_milestones(); |
| int64_t val = milestones ? ink_hrtime_to_msec((*milestones)[ms]) : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_milestone_fmt_sec(TSMilestonesType type, char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *milestones = m_data->get_milestones(); |
| ink_hrtime tsec = milestones ? ink_hrtime_to_sec((*milestones)[type]) : 0; |
| marshal_int(buf, tsec); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_milestone_fmt_ms(TSMilestonesType type, char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *milestones = m_data->get_milestones(); |
| ink_hrtime tmsec = milestones ? ink_hrtime_to_msec((*milestones)[type]) : 0; |
| marshal_int(buf, tmsec); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_milestone_diff(TSMilestonesType ms1, TSMilestonesType ms2, char *buf) |
| { |
| if (buf) { |
| TransactionMilestones const *milestones = m_data->get_milestones(); |
| int64_t val = milestones ? milestones->difference_msec(ms2, ms1) : 0; |
| marshal_int(buf, val); |
| } |
| return INK_MIN_ALIGN; |
| } |
| |
| int |
| LogAccess::marshal_milestones_csv(char *buf) |
| { |
| Dbg(dbg_ctl_log_unmarshal_data, "marshal_milestones_csv"); |
| |
| TransactionMilestones const *ms_ptr = m_data->get_milestones(); |
| if (!ms_ptr) { |
| int len = LogAccess::padded_strlen("-"); |
| if (buf) { |
| marshal_str(buf, "-", len); |
| } |
| return len; |
| } |
| auto const &milestones = *ms_ptr; |
| swoc::LocalBufferWriter<256> bw; |
| |
| bw.print("{}", milestones.difference_msec(TS_MILESTONE_TLS_HANDSHAKE_START, TS_MILESTONE_TLS_HANDSHAKE_END)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_UA_BEGIN)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_UA_FIRST_READ)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_UA_READ_HEADER_DONE)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_CACHE_OPEN_READ_BEGIN)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_CACHE_OPEN_READ_END)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_CACHE_OPEN_WRITE_BEGIN)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_CACHE_OPEN_WRITE_END)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_DNS_LOOKUP_BEGIN)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_DNS_LOOKUP_END)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SERVER_CONNECT)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SERVER_CONNECT_END)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SERVER_FIRST_READ)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SERVER_READ_HEADER_DONE)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SERVER_CLOSE)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_UA_BEGIN_WRITE)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_UA_CLOSE)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_SM_FINISH)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_PLUGIN_ACTIVE)); |
| bw.print(",{}", milestones.difference_msec(TS_MILESTONE_SM_START, TS_MILESTONE_PLUGIN_TOTAL)); |
| bw.print("\0"); |
| |
| auto const view = bw.view(); |
| int const len = LogAccess::padded_strlen(view.data()); |
| |
| if (nullptr != buf) { |
| marshal_str(buf, view.data(), len); |
| } |
| return len; |
| } |
| |
| void |
| LogAccess::set_http_header_field(LogField::Container container, char *field, char *buf, int len) |
| { |
| HTTPHdr *header; |
| |
| switch (container) { |
| case LogField::CQH: |
| case LogField::ECQH: |
| header = m_client_request; |
| break; |
| |
| case LogField::PSH: |
| case LogField::EPSH: |
| header = m_proxy_response; |
| break; |
| |
| case LogField::PQH: |
| case LogField::EPQH: |
| header = m_proxy_request; |
| break; |
| |
| case LogField::SSH: |
| case LogField::ESSH: |
| header = m_server_response; |
| break; |
| |
| case LogField::CSSH: |
| case LogField::ECSSH: |
| header = m_cache_response; |
| break; |
| |
| default: |
| header = nullptr; |
| break; |
| } |
| |
| if (header && buf) { |
| MIMEField *fld = header->field_find(std::string_view{field}); |
| if (fld) { |
| // Loop over dups, update each of them |
| // |
| while (fld) { |
| // make sure to reuse header heaps as otherwise |
| // coalesce logic in header heap may free up |
| // memory pointed to by cquuc or other log fields |
| header->field_value_set(fld, std::string_view{buf, static_cast<std::string_view::size_type>(len)}, true); |
| fld = fld->m_next_dup; |
| } |
| } |
| } |
| } |
