| /** @file |
| |
| A brief file description |
| |
| @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 "iocore/dns/DNSProcessor.h" |
| #include "proxy/http/HttpDebugNames.h" |
| #include "proxy/http/HttpTunnel.h" |
| #include "proxy/Transform.h" |
| #include "proxy/http/HttpSM.h" |
| #include <ts/apidefs.h> |
| #include "iocore/eventsystem/Event.h" |
| |
| //---------------------------------------------------------------------------- |
| const char * |
| HttpDebugNames::get_server_state_name(HttpTransact::ServerState_t state) |
| { |
| switch (state) { |
| case HttpTransact::STATE_UNDEFINED: |
| return "STATE_UNDEFINED"; |
| case HttpTransact::ACTIVE_TIMEOUT: |
| return "ACTIVE_TIMEOUT"; |
| case HttpTransact::BAD_INCOMING_RESPONSE: |
| return "BAD_INCOMING_RESPONSE"; |
| case HttpTransact::CONNECTION_ALIVE: |
| return "CONNECTION_ALIVE"; |
| case HttpTransact::CONNECTION_CLOSED: |
| return "CONNECTION_CLOSED"; |
| case HttpTransact::CONNECTION_ERROR: |
| return "CONNECTION_ERROR"; |
| case HttpTransact::INACTIVE_TIMEOUT: |
| return "INACTIVE_TIMEOUT"; |
| case HttpTransact::OPEN_RAW_ERROR: |
| return "OPEN_RAW_ERROR"; |
| case HttpTransact::PARSE_ERROR: |
| return "PARSE_ERROR"; |
| case HttpTransact::TRANSACTION_COMPLETE: |
| return "TRANSACTION_COMPLETE"; |
| case HttpTransact::PARENT_RETRY: |
| return "PARENT_RETRY"; |
| case HttpTransact::OUTBOUND_CONGESTION: |
| return "OUTBOUND_CONGESTION"; |
| } |
| |
| return ("unknown state name"); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // HttpDebugNames::get_method_name() |
| // |
| ////////////////////////////////////////////////////////////////// |
| const char * |
| HttpDebugNames::get_method_name(const char *method) |
| { |
| if (method == HTTP_METHOD_CONNECT.c_str()) { |
| return ("HTTP_METHOD_CONNECT"); |
| } else if (method == HTTP_METHOD_DELETE.c_str()) { |
| return ("HTTP_METHOD_DELETE"); |
| } else if (method == HTTP_METHOD_GET.c_str()) { |
| return ("HTTP_METHOD_GET"); |
| } else if (method == HTTP_METHOD_HEAD.c_str()) { |
| return ("HTTP_METHOD_HEAD"); |
| } else if (method == HTTP_METHOD_OPTIONS.c_str()) { |
| return ("HTTP_METHOD_OPTIONS"); |
| } else if (method == HTTP_METHOD_POST.c_str()) { |
| return ("HTTP_METHOD_POST"); |
| } else if (method == HTTP_METHOD_PURGE.c_str()) { |
| return ("HTTP_METHOD_PURGE"); |
| } else if (method == HTTP_METHOD_PUT.c_str()) { |
| return ("HTTP_METHOD_PUT"); |
| } else if (method == HTTP_METHOD_TRACE.c_str()) { |
| return ("HTTP_METHOD_TRACE"); |
| } else { |
| return ("HTTP_METHOD_UNKNOWN"); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // HttpDebugNames::get_event_name() |
| // |
| ////////////////////////////////////////////////////////////////// |
| const char * |
| HttpDebugNames::get_event_name(int event) |
| { |
| switch (event) { |
| case EVENT_NONE: |
| static_assert(static_cast<int>(EVENT_NONE) == static_cast<int>(VC_EVENT_NONE)); |
| return "EVENT_NONE/VC_EVENT_NONE"; |
| case EVENT_IMMEDIATE: |
| static_assert(static_cast<int>(EVENT_IMMEDIATE) == static_cast<int>(TS_EVENT_IMMEDIATE)); |
| static_assert(static_cast<int>(EVENT_IMMEDIATE) == static_cast<int>(VC_EVENT_IMMEDIATE)); |
| return "EVENT_IMMEDIATE/TS_EVENT_IMMEDIATE/VC_EVENT_IMMEDIATE"; |
| case EVENT_ERROR: |
| static_assert(static_cast<int>(EVENT_ERROR) == static_cast<int>(TS_EVENT_ERROR)); |
| static_assert(static_cast<int>(EVENT_ERROR) == static_cast<int>(VC_EVENT_ERROR)); |
| return "EVENT_ERROR/TS_EVENT_ERROR/VC_EVENT_ERROR"; |
| case EVENT_INTERVAL: |
| return "EVENT_INTERVAL"; |
| case VC_EVENT_READ_READY: |
| static_assert(static_cast<int>(VC_EVENT_READ_READY) == static_cast<int>(TS_EVENT_VCONN_READ_READY)); |
| return "VC_EVENT_READ_READY/TS_EVENT_VCONN_READ_READY"; |
| case VC_EVENT_WRITE_READY: |
| static_assert(static_cast<int>(VC_EVENT_WRITE_READY) == static_cast<int>(TS_EVENT_VCONN_WRITE_READY)); |
| return "VC_EVENT_WRITE_READY/TS_EVENT_VCONN_WRITE_READY"; |
| case VC_EVENT_READ_COMPLETE: |
| static_assert(static_cast<int>(VC_EVENT_READ_COMPLETE) == static_cast<int>(TS_EVENT_VCONN_READ_COMPLETE)); |
| return "VC_EVENT_READ_COMPLETE/TS_EVENT_VCONN_READ_COMPLETE"; |
| case VC_EVENT_WRITE_COMPLETE: |
| static_assert(static_cast<int>(VC_EVENT_WRITE_COMPLETE) == static_cast<int>(TS_EVENT_VCONN_WRITE_COMPLETE)); |
| return "VC_EVENT_WRITE_COMPLETE/TS_EVENT_VCONN_WRITE_COMPLETE"; |
| case VC_EVENT_EOS: |
| static_assert(static_cast<int>(VC_EVENT_EOS) == static_cast<int>(TS_EVENT_VCONN_EOS)); |
| return "VC_EVENT_EOS/TS_EVENT_VCONN_EOS"; |
| case VC_EVENT_INACTIVITY_TIMEOUT: |
| static_assert(static_cast<int>(VC_EVENT_INACTIVITY_TIMEOUT) == static_cast<int>(TS_EVENT_VCONN_INACTIVITY_TIMEOUT)); |
| return "VC_EVENT_INACTIVITY_TIMEOUT/TS_EVENT_VCONN_INACTIVITY_TIMEOUT"; |
| case VC_EVENT_ACTIVE_TIMEOUT: |
| static_assert(static_cast<int>(VC_EVENT_ACTIVE_TIMEOUT) == static_cast<int>(TS_EVENT_VCONN_ACTIVE_TIMEOUT)); |
| return "VC_EVENT_ACTIVE_TIMEOUT/TS_EVENT_VCONN_ACTIVE_TIMEOUT"; |
| |
| ///////////////// |
| // NET EVENTS // |
| ///////////////// |
| case NET_EVENT_OPEN: |
| static_assert(static_cast<int>(NET_EVENT_OPEN) == static_cast<int>(TS_EVENT_NET_CONNECT)); |
| return "NET_EVENT_OPEN/TS_EVENT_NET_CONNECT"; |
| case NET_EVENT_ACCEPT: |
| static_assert(static_cast<int>(NET_EVENT_ACCEPT) == static_cast<int>(TS_EVENT_NET_ACCEPT)); |
| return "NET_EVENT_ACCEPT/TS_EVENT_NET_ACCEPT"; |
| case NET_EVENT_OPEN_FAILED: |
| static_assert(static_cast<int>(NET_EVENT_OPEN_FAILED) == static_cast<int>(TS_EVENT_NET_CONNECT_FAILED)); |
| return "NET_EVENT_OPEN_FAILED/TS_EVENT_NET_CONNECT_FAILED"; |
| |
| //////////////////// |
| // CONNECT_EVENTS // |
| //////////////////// |
| case CONNECT_EVENT_TXN: |
| return "CONNECT_EVENT_TXN"; |
| case CONNECT_EVENT_DIRECT: |
| return "CONNECT_EVENT_DIRECT"; |
| case CONNECT_EVENT_RETRY: |
| return "CONNECT_EVENT_RETRY"; |
| |
| //////////////////// |
| // HOSTDB EVENTS // |
| //////////////////// |
| case EVENT_HOST_DB_LOOKUP: |
| static_assert(static_cast<int>(EVENT_HOST_DB_LOOKUP) == static_cast<int>(TS_EVENT_HOST_LOOKUP)); |
| return "EVENT_HOST_DB_LOOKUP/TS_EVENT_HOST_LOOKUP"; |
| case EVENT_HOST_DB_GET_RESPONSE: |
| return "EVENT_HOST_DB_GET_RESPONSE"; |
| case EVENT_SRV_LOOKUP: |
| return "EVENT_SRV_LOOKUP"; |
| case EVENT_SRV_IP_REMOVED: |
| return "EVENT_SRV_IP_REMOVED"; |
| case EVENT_SRV_GET_RESPONSE: |
| return "EVENT_SRV_GET_RESPONSE"; |
| |
| //////////////////// |
| // DNS EVENTS // |
| //////////////////// |
| case DNS_EVENT_LOOKUP: |
| return "DNS_EVENT_LOOKUP"; |
| |
| //////////////////// |
| // CACHE EVENTS // |
| //////////////////// |
| case CACHE_EVENT_LOOKUP_FAILED: |
| return "CACHE_EVENT_LOOKUP_FAILED"; |
| case CACHE_EVENT_OPEN_READ: |
| static_assert(static_cast<int>(CACHE_EVENT_OPEN_READ) == static_cast<int>(TS_EVENT_CACHE_OPEN_READ)); |
| return "CACHE_EVENT_OPEN_READ/TS_EVENT_CACHE_OPEN_READ"; |
| case CACHE_EVENT_OPEN_READ_FAILED: |
| static_assert(static_cast<int>(CACHE_EVENT_OPEN_READ_FAILED) == static_cast<int>(TS_EVENT_CACHE_OPEN_READ_FAILED)); |
| return "CACHE_EVENT_OPEN_READ_FAILED/TS_EVENT_CACHE_OPEN_READ_FAILED"; |
| case CACHE_EVENT_OPEN_WRITE: |
| static_assert(static_cast<int>(CACHE_EVENT_OPEN_WRITE) == static_cast<int>(TS_EVENT_CACHE_OPEN_WRITE)); |
| return "CACHE_EVENT_OPEN_WRITE/TS_EVENT_CACHE_OPEN_WRITE"; |
| case CACHE_EVENT_OPEN_WRITE_FAILED: |
| static_assert(static_cast<int>(CACHE_EVENT_OPEN_WRITE_FAILED) == static_cast<int>(TS_EVENT_CACHE_OPEN_WRITE_FAILED)); |
| return "CACHE_EVENT_OPEN_WRITE_FAILED/TS_EVENT_CACHE_OPEN_WRITE_FAILED"; |
| case CACHE_EVENT_REMOVE: |
| static_assert(static_cast<int>(CACHE_EVENT_REMOVE) == static_cast<int>(TS_EVENT_CACHE_REMOVE)); |
| return "CACHE_EVENT_REMOVE/TS_EVENT_CACHE_REMOVE"; |
| case CACHE_EVENT_REMOVE_FAILED: |
| static_assert(static_cast<int>(CACHE_EVENT_REMOVE_FAILED) == static_cast<int>(TS_EVENT_CACHE_REMOVE_FAILED)); |
| return "CACHE_EVENT_REMOVE_FAILED/TS_EVENT_CACHE_REMOVE_FAILED"; |
| case CACHE_EVENT_UPDATE: |
| return "CACHE_EVENT_UPDATE"; |
| case CACHE_EVENT_UPDATE_FAILED: |
| return "CACHE_EVENT_UPDATE_FAILED"; |
| case TRANSFORM_READ_READY: |
| static_assert(static_cast<int>(TRANSFORM_READ_READY) == static_cast<int>(TS_EVENT_SSL_SESSION_GET)); |
| return "TRANSFORM_READ_READY/TS_EVENT_SSL_SESSION_GET"; |
| |
| ///////////////////////// |
| // HttpTunnel Events // |
| ///////////////////////// |
| case HTTP_TUNNEL_EVENT_DONE: |
| return "HTTP_TUNNEL_EVENT_DONE"; |
| case HTTP_TUNNEL_EVENT_PRECOMPLETE: |
| return "HTTP_TUNNEL_EVENT_PRECOMPLETE"; |
| case HTTP_TUNNEL_EVENT_CONSUMER_DETACH: |
| return "HTTP_TUNNEL_EVENT_CONSUMER_DETACH"; |
| |
| ///////////////////////////// |
| // Plugin Events |
| ///////////////////////////// |
| case HTTP_API_CONTINUE: |
| static_assert(static_cast<int>(HTTP_API_CONTINUE) == static_cast<int>(TS_EVENT_HTTP_CONTINUE)); |
| return "HTTP_API_CONTINUE/TS_EVENT_HTTP_CONTINUE"; |
| case HTTP_API_ERROR: |
| static_assert(static_cast<int>(HTTP_API_ERROR) == static_cast<int>(TS_EVENT_HTTP_ERROR)); |
| return "HTTP_API_ERROR/TS_EVENT_HTTP_ERROR"; |
| |
| case TS_EVENT_NET_ACCEPT_FAILED: |
| return "TS_EVENT_NET_ACCEPT_FAILED"; |
| case TS_EVENT_CACHE_SCAN: |
| return "TS_EVENT_CACHE_SCAN"; |
| case TS_EVENT_CACHE_SCAN_FAILED: |
| return "TS_EVENT_CACHE_SCAN_FAILED"; |
| case TS_EVENT_CACHE_SCAN_OBJECT: |
| return "TS_EVENT_CACHE_SCAN_OBJECT"; |
| case TS_EVENT_CACHE_SCAN_OPERATION_BLOCKED: |
| return "TS_EVENT_CACHE_SCAN_OPERATION_BLOCKED"; |
| case TS_EVENT_CACHE_SCAN_OPERATION_FAILED: |
| return "TS_EVENT_CACHE_SCAN_OPERATION_FAILED"; |
| case TS_EVENT_CACHE_SCAN_DONE: |
| return "TS_EVENT_CACHE_SCAN_DONE"; |
| case TS_EVENT_CACHE_LOOKUP: |
| return "TS_EVENT_CACHE_LOOKUP"; |
| case TS_EVENT_CACHE_READ: |
| return "TS_EVENT_CACHE_READ"; |
| case TS_EVENT_CACHE_DELETE: |
| return "TS_EVENT_CACHE_DELETE"; |
| case TS_EVENT_CACHE_WRITE: |
| return "TS_EVENT_CACHE_WRITE"; |
| case TS_EVENT_CACHE_WRITE_HEADER: |
| return "TS_EVENT_CACHE_WRITE_HEADER"; |
| case TS_EVENT_CACHE_CLOSE: |
| return "TS_EVENT_CACHE_CLOSE"; |
| case TS_EVENT_CACHE_LOOKUP_READY: |
| return "TS_EVENT_CACHE_LOOKUP_READY"; |
| case TS_EVENT_CACHE_LOOKUP_COMPLETE: |
| return "TS_EVENT_CACHE_LOOKUP_COMPLETE"; |
| case TS_EVENT_CACHE_READ_READY: |
| return "TS_EVENT_CACHE_READ_READY"; |
| case TS_EVENT_CACHE_READ_COMPLETE: |
| return "TS_EVENT_CACHE_READ_COMPLETE"; |
| case TS_EVENT_INTERNAL_1200: |
| return "TS_EVENT_INTERNAL_1200"; |
| case TS_EVENT_SSL_SESSION_NEW: |
| return "TS_EVENT_SSL_SESSION_NEW"; |
| case TS_EVENT_SSL_SESSION_REMOVE: |
| return "TS_EVENT_SSL_SESSION_REMOVE"; |
| case TS_EVENT_AIO_DONE: |
| return "TS_EVENT_AIO_DONE"; |
| case TS_EVENT_HTTP_READ_REQUEST_HDR: |
| return "TS_EVENT_HTTP_READ_REQUEST_HDR"; |
| case TS_EVENT_HTTP_OS_DNS: |
| return "TS_EVENT_HTTP_OS_DNS"; |
| case TS_EVENT_HTTP_SEND_REQUEST_HDR: |
| return "TS_EVENT_HTTP_SEND_REQUEST_HDR"; |
| case TS_EVENT_HTTP_READ_CACHE_HDR: |
| return "TS_EVENT_HTTP_READ_CACHE_HDR"; |
| case TS_EVENT_HTTP_READ_RESPONSE_HDR: |
| return "TS_EVENT_HTTP_READ_RESPONSE_HDR"; |
| case TS_EVENT_HTTP_SEND_RESPONSE_HDR: |
| return "TS_EVENT_HTTP_SEND_RESPONSE_HDR"; |
| case TS_EVENT_HTTP_REQUEST_TRANSFORM: |
| return "TS_EVENT_HTTP_REQUEST_TRANSFORM"; |
| case TS_EVENT_HTTP_RESPONSE_TRANSFORM: |
| return "TS_EVENT_HTTP_RESPONSE_TRANSFORM"; |
| case TS_EVENT_HTTP_SELECT_ALT: |
| return "TS_EVENT_HTTP_SELECT_ALT"; |
| case TS_EVENT_HTTP_TXN_START: |
| return "TS_EVENT_HTTP_TXN_START"; |
| case TS_EVENT_HTTP_TXN_CLOSE: |
| return "TS_EVENT_HTTP_TXN_CLOSE"; |
| case TS_EVENT_HTTP_SSN_START: |
| return "TS_EVENT_HTTP_SSN_START"; |
| case TS_EVENT_HTTP_SSN_CLOSE: |
| return "TS_EVENT_HTTP_SSN_CLOSE"; |
| case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE: |
| return "TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE"; |
| case TS_EVENT_HTTP_PRE_REMAP: |
| return "TS_EVENT_HTTP_PRE_REMAP"; |
| case TS_EVENT_HTTP_POST_REMAP: |
| return "TS_EVENT_HTTP_POST_REMAP"; |
| case TS_EVENT_HTTP_TUNNEL_START: |
| return "TS_EVENT_HTTP_TUNNEL_START"; |
| case TS_EVENT_LIFECYCLE_PORTS_INITIALIZED: |
| return "TS_EVENT_LIFECYCLE_PORTS_INITIALIZED"; |
| case TS_EVENT_LIFECYCLE_PORTS_READY: |
| return "TS_EVENT_LIFECYCLE_PORTS_READY"; |
| case TS_EVENT_LIFECYCLE_CACHE_READY: |
| return "TS_EVENT_LIFECYCLE_CACHE_READY"; |
| case TS_EVENT_LIFECYCLE_SERVER_SSL_CTX_INITIALIZED: |
| return "TS_EVENT_LIFECYCLE_SERVER_SSL_CTX_INITIALIZED"; |
| case TS_EVENT_LIFECYCLE_CLIENT_SSL_CTX_INITIALIZED: |
| return "TS_EVENT_LIFECYCLE_CLIENT_SSL_CTX_INITIALIZED"; |
| case TS_EVENT_LIFECYCLE_TASK_THREADS_READY: |
| return "TS_EVENT_LIFECYCLE_TASK_THREADS_READY"; |
| case TS_EVENT_LIFECYCLE_SHUTDOWN: |
| return "TS_EVENT_LIFECYCLE_SHUTDOWN"; |
| case TS_EVENT_VCONN_START: |
| return "TS_EVENT_VCONN_START"; |
| case TS_EVENT_VCONN_CLOSE: |
| return "TS_EVENT_VCONN_CLOSE"; |
| case TS_EVENT_LIFECYCLE_MSG: |
| return "TS_EVENT_LIFECYCLE_MSG"; |
| case TS_EVENT_HTTP_REQUEST_BUFFER_READ_COMPLETE: |
| return "TS_EVENT_HTTP_REQUEST_BUFFER_READ_COMPLETE"; |
| case TS_EVENT_MGMT_UPDATE: |
| return "TS_EVENT_MGMT_UPDATE"; |
| case TS_EVENT_INTERNAL_60200: |
| return "TS_EVENT_INTERNAL_60200"; |
| case TS_EVENT_INTERNAL_60201: |
| return "TS_EVENT_INTERNAL_60201"; |
| case TS_EVENT_INTERNAL_60202: |
| return "TS_EVENT_INTERNAL_60202"; |
| case TS_EVENT_SSL_CLIENT_HELLO: |
| return "TS_EVENT_SSL_CLIENT_HELLO"; |
| case TS_EVENT_SSL_CERT: |
| return "TS_EVENT_SSL_CERT"; |
| case TS_EVENT_SSL_SERVERNAME: |
| return "TS_EVENT_SSL_SERVERNAME"; |
| case TS_EVENT_SSL_VERIFY_SERVER: |
| return "TS_EVENT_SSL_VERIFY_SERVER"; |
| case TS_EVENT_SSL_VERIFY_CLIENT: |
| return "TS_EVENT_SSL_VERIFY_CLIENT"; |
| case TS_EVENT_VCONN_OUTBOUND_START: |
| return "TS_EVENT_VCONN_OUTBOUND_START"; |
| case TS_EVENT_VCONN_OUTBOUND_CLOSE: |
| return "TS_EVENT_VCONN_OUTBOUND_CLOSE"; |
| } |
| |
| return ("unknown event"); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // HttpDebugNames::get_action_name() |
| // |
| ////////////////////////////////////////////////////////////////// |
| const char * |
| HttpDebugNames::get_action_name(HttpTransact::StateMachineAction_t e) |
| { |
| switch (e) { |
| case HttpTransact::StateMachineAction_t::UNDEFINED: |
| return ("StateMachineAction_t::UNDEFINED"); |
| |
| case HttpTransact::StateMachineAction_t::CACHE_ISSUE_WRITE: |
| return ("StateMachineAction_t::CACHE_ISSUE_WRITE"); |
| |
| case HttpTransact::StateMachineAction_t::CACHE_ISSUE_WRITE_TRANSFORM: |
| return ("StateMachineAction_t::CACHE_ISSUE_WRITE_TRANSFORM"); |
| |
| case HttpTransact::StateMachineAction_t::CACHE_LOOKUP: |
| return ("StateMachineAction_t::CACHE_LOOKUP"); |
| |
| case HttpTransact::StateMachineAction_t::DNS_LOOKUP: |
| return ("StateMachineAction_t::DNS_LOOKUP"); |
| |
| case HttpTransact::StateMachineAction_t::DNS_REVERSE_LOOKUP: |
| return ("StateMachineAction_t::DNS_REVERSE_LOOKUP"); |
| |
| case HttpTransact::StateMachineAction_t::CACHE_PREPARE_UPDATE: |
| return ("StateMachineAction_t::CACHE_PREPARE_UPDATE"); |
| |
| case HttpTransact::StateMachineAction_t::CACHE_ISSUE_UPDATE: |
| return ("StateMachineAction_t::CACHE_ISSUE_UPDATE"); |
| |
| case HttpTransact::StateMachineAction_t::ORIGIN_SERVER_OPEN: |
| return ("StateMachineAction_t::ORIGIN_SERVER_OPEN"); |
| |
| case HttpTransact::StateMachineAction_t::ORIGIN_SERVER_RAW_OPEN: |
| return ("StateMachineAction_t::ORIGIN_SERVER_RAW_OPEN"); |
| |
| case HttpTransact::StateMachineAction_t::READ_PUSH_HDR: |
| return ("StateMachineAction_t::READ_PUSH_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::STORE_PUSH_BODY: |
| return ("StateMachineAction_t::STORE_PUSH_BODY"); |
| |
| case HttpTransact::StateMachineAction_t::INTERNAL_CACHE_WRITE: |
| return ("StateMachineAction_t::INTERNAL_CACHE_WRITE"); |
| |
| case HttpTransact::StateMachineAction_t::INTERNAL_CACHE_DELETE: |
| return ("StateMachineAction_t::INTERNAL_CACHE_DELETE"); |
| |
| case HttpTransact::StateMachineAction_t::INTERNAL_CACHE_NOOP: |
| return ("StateMachineAction_t::INTERNAL_CACHE_NOOP"); |
| |
| case HttpTransact::StateMachineAction_t::INTERNAL_CACHE_UPDATE_HEADERS: |
| return ("StateMachineAction_t::INTERNAL_CACHE_UPDATE_HEADERS"); |
| |
| case HttpTransact::StateMachineAction_t::SEND_ERROR_CACHE_NOOP: |
| return ("StateMachineAction_t::SEND_ERROR_CACHE_NOOP"); |
| |
| case HttpTransact::StateMachineAction_t::SERVE_FROM_CACHE: |
| return ("StateMachineAction_t::SERVE_FROM_CACHE"); |
| |
| case HttpTransact::StateMachineAction_t::SERVER_READ: |
| return ("StateMachineAction_t::SERVER_READ"); |
| |
| case HttpTransact::StateMachineAction_t::SSL_TUNNEL: |
| return ("StateMachineAction_t::SSL_TUNNEL"); |
| |
| case HttpTransact::StateMachineAction_t::API_READ_REQUEST_HDR: |
| return ("StateMachineAction_t::API_READ_REQUEST_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::API_TUNNEL_START: |
| return ("StateMachineAction_t::API_TUNNEL_START"); |
| |
| case HttpTransact::StateMachineAction_t::API_OS_DNS: |
| return ("StateMachineAction_t::API_OS_DNS"); |
| |
| case HttpTransact::StateMachineAction_t::API_SEND_REQUEST_HDR: |
| return ("StateMachineAction_t::API_SEND_REQUEST_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::API_READ_CACHE_HDR: |
| return ("StateMachineAction_t::API_READ_CACHE_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::API_CACHE_LOOKUP_COMPLETE: |
| return ("StateMachineAction_t::API_CACHE_LOOKUP_COMPLETE"); |
| |
| case HttpTransact::StateMachineAction_t::API_READ_RESPONSE_HDR: |
| return ("StateMachineAction_t::API_READ_RESPONSE_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::API_SEND_RESPONSE_HDR: |
| return ("StateMachineAction_t::API_SEND_RESPONSE_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::INTERNAL_100_RESPONSE: |
| return ("StateMachineAction_t::INTERNAL_100_RESPONSE"); |
| |
| case HttpTransact::StateMachineAction_t::SERVER_PARSE_NEXT_HDR: |
| return ("StateMachineAction_t::SERVER_PARSE_NEXT_HDR"); |
| |
| case HttpTransact::StateMachineAction_t::TRANSFORM_READ: |
| return ("StateMachineAction_t::TRANSFORM_READ"); |
| |
| case HttpTransact::StateMachineAction_t::WAIT_FOR_FULL_BODY: |
| return ("StateMachineAction_t::WAIT_FOR_FULL_BODY"); |
| |
| case HttpTransact::StateMachineAction_t::REQUEST_BUFFER_READ_COMPLETE: |
| return ("StateMachineAction_t::REQUEST_BUFFER_READ_COMPLETE"); |
| case HttpTransact::StateMachineAction_t::API_SM_START: |
| return ("StateMachineAction_t::API_SM_START"); |
| case HttpTransact::StateMachineAction_t::REDIRECT_READ: |
| return ("StateMachineAction_t::REDIRECT_READ"); |
| case HttpTransact::StateMachineAction_t::API_SM_SHUTDOWN: |
| return ("StateMachineAction_t::API_SM_SHUTDOWN"); |
| case HttpTransact::StateMachineAction_t::REMAP_REQUEST: |
| return ("StateMachineAction_t::REMAP_REQUEST"); |
| case HttpTransact::StateMachineAction_t::API_PRE_REMAP: |
| return ("StateMachineAction_t::API_PRE_REMAP"); |
| case HttpTransact::StateMachineAction_t::API_POST_REMAP: |
| return ("StateMachineAction_t::API_POST_REMAP"); |
| case HttpTransact::StateMachineAction_t::POST_REMAP_SKIP: |
| return ("StateMachineAction_t::POST_REMAP_SKIP"); |
| } |
| |
| return ("unknown state name"); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // HttpDebugNames::get_cache_action_name() |
| // |
| ////////////////////////////////////////////////////////////////// |
| const char * |
| HttpDebugNames::get_cache_action_name(HttpTransact::CacheAction_t t) |
| { |
| switch (t) { |
| case HttpTransact::CacheAction_t::UNDEFINED: |
| return ("CacheAction_t::UNDEFINED"); |
| case HttpTransact::CacheAction_t::NO_ACTION: |
| return ("CacheAction_t::NO_ACTION"); |
| case HttpTransact::CacheAction_t::DELETE: |
| return ("CacheAction_t::DELETE"); |
| case HttpTransact::CacheAction_t::LOOKUP: |
| return ("CacheAction_t::LOOKUP"); |
| case HttpTransact::CacheAction_t::REPLACE: |
| return ("CacheAction_t::REPLACE"); |
| case HttpTransact::CacheAction_t::SERVE: |
| return ("CacheAction_t::SERVE"); |
| case HttpTransact::CacheAction_t::SERVE_AND_DELETE: |
| return ("CacheAction_t::SERVE_AND_DELETE"); |
| case HttpTransact::CacheAction_t::SERVE_AND_UPDATE: |
| return ("CacheAction_t::SERVE_AND_UPDATE"); |
| case HttpTransact::CacheAction_t::UPDATE: |
| return ("CacheAction_t::UPDATE"); |
| case HttpTransact::CacheAction_t::WRITE: |
| return ("CacheAction_t::WRITE"); |
| case HttpTransact::CacheAction_t::PREPARE_TO_DELETE: |
| return ("CacheAction_t::PREPARE_TO_DELETE"); |
| case HttpTransact::CacheAction_t::PREPARE_TO_UPDATE: |
| return ("CacheAction_t::PREPARE_TO_UPDATE"); |
| case HttpTransact::CacheAction_t::PREPARE_TO_WRITE: |
| return ("CacheAction_t::PREPARE_TO_WRITE"); |
| case HttpTransact::CacheAction_t::TOTAL_TYPES: |
| return ("CacheAction_t::TOTAL_TYPES"); |
| } |
| |
| return ("unknown cache action"); |
| } |
| |
| ////////////////////////////////////////////////////////////////// |
| // |
| // HttpDebugNames::get_api_hook_name() |
| // |
| ////////////////////////////////////////////////////////////////// |
| const char * |
| HttpDebugNames::get_api_hook_name(TSHttpHookID t) |
| { |
| switch (t) { |
| case TS_HTTP_READ_REQUEST_HDR_HOOK: |
| return "TS_HTTP_READ_REQUEST_HDR_HOOK"; |
| case TS_HTTP_TUNNEL_START_HOOK: |
| return "TS_HTTP_TUNNEL_START_HOOK"; |
| case TS_HTTP_OS_DNS_HOOK: |
| return "TS_HTTP_OS_DNS_HOOK"; |
| case TS_HTTP_SEND_REQUEST_HDR_HOOK: |
| return "TS_HTTP_SEND_REQUEST_HDR_HOOK"; |
| case TS_HTTP_READ_CACHE_HDR_HOOK: |
| return "TS_HTTP_READ_CACHE_HDR_HOOK"; |
| case TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK: |
| return "TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK"; |
| case TS_HTTP_READ_RESPONSE_HDR_HOOK: |
| return "TS_HTTP_READ_RESPONSE_HDR_HOOK"; |
| case TS_HTTP_SEND_RESPONSE_HDR_HOOK: |
| return "TS_HTTP_SEND_RESPONSE_HDR_HOOK"; |
| case TS_HTTP_REQUEST_TRANSFORM_HOOK: |
| return "TS_HTTP_REQUEST_TRANSFORM_HOOK"; |
| case TS_HTTP_REQUEST_BUFFER_READ_COMPLETE_HOOK: |
| return "TS_HTTP_REQUEST_BUFFER_READ_COMPLETE_HOOK"; |
| case TS_HTTP_RESPONSE_TRANSFORM_HOOK: |
| return "TS_HTTP_RESPONSE_TRANSFORM_HOOK"; |
| case TS_HTTP_SELECT_ALT_HOOK: |
| return "TS_HTTP_SELECT_ALT_HOOK"; |
| case TS_HTTP_TXN_START_HOOK: |
| return "TS_HTTP_TXN_START_HOOK"; |
| case TS_HTTP_TXN_CLOSE_HOOK: |
| return "TS_HTTP_TXN_CLOSE_HOOK"; |
| case TS_HTTP_SSN_START_HOOK: |
| return "TS_HTTP_SSN_START_HOOK"; |
| case TS_HTTP_SSN_CLOSE_HOOK: |
| return "TS_HTTP_SSN_CLOSE_HOOK"; |
| case TS_HTTP_PRE_REMAP_HOOK: |
| return "TS_HTTP_PRE_REMAP_HOOK"; |
| case TS_HTTP_POST_REMAP_HOOK: |
| return "TS_HTTP_POST_REMAP_HOOK"; |
| case TS_HTTP_RESPONSE_CLIENT_HOOK: |
| return "TS_HTTP_RESPONSE_CLIENT_HOOK"; |
| case TS_HTTP_REQUEST_CLIENT_HOOK: |
| return "TS_HTTP_REQUEST_CLIENT_HOOK"; |
| case TS_HTTP_LAST_HOOK: |
| return "TS_HTTP_LAST_HOOK"; |
| case TS_VCONN_START_HOOK: |
| return "TS_VCONN_START_HOOK"; |
| case TS_VCONN_CLOSE_HOOK: |
| return "TS_VCONN_CLOSE_HOOK"; |
| case TS_SSL_CLIENT_HELLO_HOOK: |
| return "TS_SSL_CLIENT_HELLO_HOOK"; |
| case TS_SSL_CERT_HOOK: |
| return "TS_SSL_CERT_HOOK"; |
| case TS_SSL_SERVERNAME_HOOK: |
| return "TS_SSL_SERVERNAME_HOOK"; |
| case TS_SSL_VERIFY_SERVER_HOOK: |
| return "TS_SSL_VERIFY_SERVER_HOOK"; |
| case TS_SSL_VERIFY_CLIENT_HOOK: |
| return "TS_SSL_VERIFY_CLIENT_HOOK"; |
| case TS_SSL_SESSION_HOOK: |
| return "TS_SSL_SESSION_HOOK"; |
| case TS_VCONN_OUTBOUND_START_HOOK: |
| return "TS_VCONN_OUTBOUND_START_HOOK"; |
| case TS_VCONN_OUTBOUND_CLOSE_HOOK: |
| return "TS_VCONN_OUTBOUND_CLOSE_HOOK"; |
| } |
| |
| return "unknown hook"; |
| } |
| |
| swoc::BufferWriter & |
| bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec, HttpTransact::ServerState_t state) |
| { |
| if (spec.has_numeric_type()) { |
| return bwformat(w, spec, static_cast<uintmax_t>(state)); |
| } else { |
| return bwformat(w, spec, HttpDebugNames::get_server_state_name(state)); |
| } |
| } |
| |
| swoc::BufferWriter & |
| bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec, HttpTransact::CacheAction_t state) |
| { |
| if (spec.has_numeric_type()) { |
| return bwformat(w, spec, static_cast<uintmax_t>(state)); |
| } else { |
| return bwformat(w, spec, HttpDebugNames::get_cache_action_name(state)); |
| } |
| } |
| |
| swoc::BufferWriter & |
| bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec, HttpTransact::StateMachineAction_t state) |
| { |
| if (spec.has_numeric_type()) { |
| return bwformat(w, spec, static_cast<uintmax_t>(state)); |
| } else { |
| return bwformat(w, spec, HttpDebugNames::get_action_name(state)); |
| } |
| } |
| |
| swoc::BufferWriter & |
| bwformat(swoc::BufferWriter &w, swoc::bwf::Spec const &spec, TSHttpHookID id) |
| { |
| if (spec.has_numeric_type()) { |
| return bwformat(w, spec, static_cast<uintmax_t>(id)); |
| } else { |
| return bwformat(w, spec, HttpDebugNames::get_api_hook_name(id)); |
| } |
| } |
