You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by bc...@apache.org on 2025/06/18 18:24:42 UTC
(trafficserver) branch master updated: Cleanup: Use string_view in URL and HTTPHdr (#12243)
This is an automated email from the ASF dual-hosted git repository.
bcall pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new 1890ee0beb Cleanup: Use string_view in URL and HTTPHdr (#12243)
1890ee0beb is described below
commit 1890ee0bebf523e8d0ab932909ac155fb21d49b0
Author: Hiroaki Nakamura <hn...@gmail.com>
AuthorDate: Thu Jun 19 03:24:37 2025 +0900
Cleanup: Use string_view in URL and HTTPHdr (#12243)
---
include/proxy/hdrs/HTTP.h | 152 ++++--------
include/proxy/hdrs/URL.h | 220 +++++++----------
src/api/InkAPI.cc | 67 +++--
src/api/InkAPIInternal.cc | 186 +++++++-------
src/iocore/cache/P_CacheInternal.h | 8 +-
src/proxy/ControlBase.cc | 12 +-
src/proxy/FetchSM.cc | 3 +-
src/proxy/ParentConsistentHash.cc | 10 +-
src/proxy/ParentSelection.cc | 8 +-
src/proxy/Transform.cc | 2 +-
src/proxy/hdrs/HTTP.cc | 280 ++++++++-------------
src/proxy/hdrs/HeaderValidator.cc | 3 +-
src/proxy/hdrs/URL.cc | 338 +++++++++++---------------
src/proxy/hdrs/VersionConverter.cc | 13 +-
src/proxy/hdrs/unit_tests/test_HdrHeap.cc | 6 +-
src/proxy/hdrs/unit_tests/test_URL.cc | 6 +-
src/proxy/http/HttpDebugNames.cc | 18 +-
src/proxy/http/HttpSM.cc | 75 +++---
src/proxy/http/HttpTransact.cc | 123 +++++-----
src/proxy/http/HttpTransactHeaders.cc | 16 +-
src/proxy/http/RegressionHttpTransact.cc | 40 +--
src/proxy/http/remap/NextHopConsistentHash.cc | 39 ++-
src/proxy/http/remap/RemapConfig.cc | 103 ++++----
src/proxy/http/remap/RemapProcessor.cc | 17 +-
src/proxy/http/remap/UrlMappingPathIndex.cc | 23 +-
src/proxy/http/remap/UrlRewrite.cc | 105 ++++----
src/proxy/http2/Http2ConnectionState.cc | 4 +-
src/proxy/http2/Http2Stream.cc | 6 +-
28 files changed, 832 insertions(+), 1051 deletions(-)
diff --git a/include/proxy/hdrs/HTTP.h b/include/proxy/hdrs/HTTP.h
index 4807d4aa22..eeecba31d7 100644
--- a/include/proxy/hdrs/HTTP.h
+++ b/include/proxy/hdrs/HTTP.h
@@ -338,16 +338,16 @@ struct HTTPParser {
MIMEParser m_mime_parser;
};
-extern const char *HTTP_METHOD_CONNECT;
-extern const char *HTTP_METHOD_DELETE;
-extern const char *HTTP_METHOD_GET;
-extern const char *HTTP_METHOD_HEAD;
-extern const char *HTTP_METHOD_OPTIONS;
-extern const char *HTTP_METHOD_POST;
-extern const char *HTTP_METHOD_PURGE;
-extern const char *HTTP_METHOD_PUT;
-extern const char *HTTP_METHOD_TRACE;
-extern const char *HTTP_METHOD_PUSH;
+extern c_str_view HTTP_METHOD_CONNECT;
+extern c_str_view HTTP_METHOD_DELETE;
+extern c_str_view HTTP_METHOD_GET;
+extern c_str_view HTTP_METHOD_HEAD;
+extern c_str_view HTTP_METHOD_OPTIONS;
+extern c_str_view HTTP_METHOD_POST;
+extern c_str_view HTTP_METHOD_PURGE;
+extern c_str_view HTTP_METHOD_PUT;
+extern c_str_view HTTP_METHOD_TRACE;
+extern c_str_view HTTP_METHOD_PUSH;
extern int HTTP_WKSIDX_CONNECT;
extern int HTTP_WKSIDX_DELETE;
@@ -361,66 +361,30 @@ extern int HTTP_WKSIDX_TRACE;
extern int HTTP_WKSIDX_PUSH;
extern int HTTP_WKSIDX_METHODS_CNT;
-extern int HTTP_LEN_CONNECT;
-extern int HTTP_LEN_DELETE;
-extern int HTTP_LEN_GET;
-extern int HTTP_LEN_HEAD;
-extern int HTTP_LEN_OPTIONS;
-extern int HTTP_LEN_POST;
-extern int HTTP_LEN_PURGE;
-extern int HTTP_LEN_PUT;
-extern int HTTP_LEN_TRACE;
-extern int HTTP_LEN_PUSH;
-
-extern const char *HTTP_VALUE_BYTES;
-extern const char *HTTP_VALUE_CHUNKED;
-extern const char *HTTP_VALUE_CLOSE;
-extern const char *HTTP_VALUE_COMPRESS;
-extern const char *HTTP_VALUE_DEFLATE;
-extern const char *HTTP_VALUE_GZIP;
-extern const char *HTTP_VALUE_BROTLI;
-extern const char *HTTP_VALUE_IDENTITY;
-extern const char *HTTP_VALUE_KEEP_ALIVE;
-extern const char *HTTP_VALUE_MAX_AGE;
-extern const char *HTTP_VALUE_MAX_STALE;
-extern const char *HTTP_VALUE_MIN_FRESH;
-extern const char *HTTP_VALUE_MUST_REVALIDATE;
-extern const char *HTTP_VALUE_NONE;
-extern const char *HTTP_VALUE_NO_CACHE;
-extern const char *HTTP_VALUE_NO_STORE;
-extern const char *HTTP_VALUE_NO_TRANSFORM;
-extern const char *HTTP_VALUE_ONLY_IF_CACHED;
-extern const char *HTTP_VALUE_PRIVATE;
-extern const char *HTTP_VALUE_PROXY_REVALIDATE;
-extern const char *HTTP_VALUE_PUBLIC;
-extern const char *HTTP_VALUE_S_MAXAGE;
-extern const char *HTTP_VALUE_NEED_REVALIDATE_ONCE;
-extern const char *HTTP_VALUE_100_CONTINUE;
-
-extern int HTTP_LEN_BYTES;
-extern int HTTP_LEN_CHUNKED;
-extern int HTTP_LEN_CLOSE;
-extern int HTTP_LEN_COMPRESS;
-extern int HTTP_LEN_DEFLATE;
-extern int HTTP_LEN_GZIP;
-extern int HTTP_LEN_BROTLI;
-extern int HTTP_LEN_IDENTITY;
-extern int HTTP_LEN_KEEP_ALIVE;
-extern int HTTP_LEN_MAX_AGE;
-extern int HTTP_LEN_MAX_STALE;
-extern int HTTP_LEN_MIN_FRESH;
-extern int HTTP_LEN_MUST_REVALIDATE;
-extern int HTTP_LEN_NONE;
-extern int HTTP_LEN_NO_CACHE;
-extern int HTTP_LEN_NO_STORE;
-extern int HTTP_LEN_NO_TRANSFORM;
-extern int HTTP_LEN_ONLY_IF_CACHED;
-extern int HTTP_LEN_PRIVATE;
-extern int HTTP_LEN_PROXY_REVALIDATE;
-extern int HTTP_LEN_PUBLIC;
-extern int HTTP_LEN_S_MAXAGE;
-extern int HTTP_LEN_NEED_REVALIDATE_ONCE;
-extern int HTTP_LEN_100_CONTINUE;
+extern c_str_view HTTP_VALUE_BYTES;
+extern c_str_view HTTP_VALUE_CHUNKED;
+extern c_str_view HTTP_VALUE_CLOSE;
+extern c_str_view HTTP_VALUE_COMPRESS;
+extern c_str_view HTTP_VALUE_DEFLATE;
+extern c_str_view HTTP_VALUE_GZIP;
+extern c_str_view HTTP_VALUE_BROTLI;
+extern c_str_view HTTP_VALUE_IDENTITY;
+extern c_str_view HTTP_VALUE_KEEP_ALIVE;
+extern c_str_view HTTP_VALUE_MAX_AGE;
+extern c_str_view HTTP_VALUE_MAX_STALE;
+extern c_str_view HTTP_VALUE_MIN_FRESH;
+extern c_str_view HTTP_VALUE_MUST_REVALIDATE;
+extern c_str_view HTTP_VALUE_NONE;
+extern c_str_view HTTP_VALUE_NO_CACHE;
+extern c_str_view HTTP_VALUE_NO_STORE;
+extern c_str_view HTTP_VALUE_NO_TRANSFORM;
+extern c_str_view HTTP_VALUE_ONLY_IF_CACHED;
+extern c_str_view HTTP_VALUE_PRIVATE;
+extern c_str_view HTTP_VALUE_PROXY_REVALIDATE;
+extern c_str_view HTTP_VALUE_PUBLIC;
+extern c_str_view HTTP_VALUE_S_MAXAGE;
+extern c_str_view HTTP_VALUE_NEED_REVALIDATE_ONCE;
+extern c_str_view HTTP_VALUE_100_CONTINUE;
/* Private */
void http_hdr_adjust(HTTPHdrImpl *hdrp, int32_t offset, int32_t length, int32_t delta);
@@ -440,15 +404,14 @@ void http_hdr_describe(HdrHeapObjImpl *obj, bool recurse = true);
bool http_hdr_version_set(HTTPHdrImpl *hh, const HTTPVersion &ver);
std::string_view http_hdr_method_get(HTTPHdrImpl *hh);
-void http_hdr_method_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *method, int16_t method_wks_idx, int method_length,
- bool must_copy);
+void http_hdr_method_set(HdrHeap *heap, HTTPHdrImpl *hh, std::string_view method, int16_t method_wks_idx, bool must_copy);
void http_hdr_url_set(HdrHeap *heap, HTTPHdrImpl *hh, URLImpl *url);
// HTTPStatus http_hdr_status_get (HTTPHdrImpl *hh);
void http_hdr_status_set(HTTPHdrImpl *hh, HTTPStatus status);
std::string_view http_hdr_reason_get(HTTPHdrImpl *hh);
-void http_hdr_reason_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *value, int length, bool must_copy);
+void http_hdr_reason_set(HdrHeap *heap, HTTPHdrImpl *hh, std::string_view value, bool must_copy);
const char *http_hdr_reason_lookup(HTTPStatus status);
void http_parser_init(HTTPParser *parser);
@@ -523,7 +486,7 @@ public:
std::string_view method_get();
int method_get_wksidx() const;
- void method_set(const char *value, int length);
+ void method_set(std::string_view value);
URL *url_create(URL *url);
@@ -603,7 +566,7 @@ public:
*/
std::string_view scheme_get();
void url_set(URL *url);
- void url_set(const char *str, int length);
+ void url_set(std::string_view value);
/// Check location of target host.
/// @return @c true if the host was in the URL, @c false otherwise.
@@ -629,7 +592,7 @@ public:
void status_set(HTTPStatus status);
std::string_view reason_get();
- void reason_set(const char *value, int length);
+ void reason_set(std::string_view value);
void mark_early_data(bool flag = true) const;
bool is_early_data() const;
@@ -780,9 +743,7 @@ HTTPHdr::host_get() const
{
this->_test_and_fill_target_cache();
if (m_target_in_url) {
- int length;
- auto host{url_get()->host_get(&length)};
- return std::string_view{host, static_cast<std::string_view::size_type>(length)};
+ return url_get()->host_get();
} else if (m_host_mime) {
return std::string_view{m_host_mime->m_ptr_value, static_cast<std::string_view::size_type>(m_host_length)};
}
@@ -969,13 +930,13 @@ HTTPHdr::method_get_wksidx() const
-------------------------------------------------------------------------*/
inline void
-HTTPHdr::method_set(const char *value, int length)
+HTTPHdr::method_set(std::string_view value)
{
ink_assert(valid());
ink_assert(m_http->m_polarity == HTTPType::REQUEST);
- int method_wks_idx = hdrtoken_tokenize(value, length);
- http_hdr_method_set(m_heap, m_http, value, method_wks_idx, length, true);
+ int method_wks_idx = hdrtoken_tokenize(value.data(), static_cast<int>(value.length()));
+ http_hdr_method_set(m_heap, m_http, value, method_wks_idx, true);
}
/*-------------------------------------------------------------------------
@@ -1045,7 +1006,7 @@ HTTPHdr::url_set(URL *url)
-------------------------------------------------------------------------*/
inline void
-HTTPHdr::url_set(const char *str, int length)
+HTTPHdr::url_set(std::string_view value)
{
URLImpl *url_impl;
@@ -1054,7 +1015,8 @@ HTTPHdr::url_set(const char *str, int length)
url_impl = m_http->u.req.m_url_impl;
::url_clear(url_impl);
- ::url_parse(m_heap, url_impl, &str, str + length, true);
+ const char *str{value.data()};
+ ::url_parse(m_heap, url_impl, &str, str + value.length(), true);
}
/*-------------------------------------------------------------------------
@@ -1111,12 +1073,12 @@ HTTPHdr::reason_get()
-------------------------------------------------------------------------*/
inline void
-HTTPHdr::reason_set(const char *value, int length)
+HTTPHdr::reason_set(std::string_view value)
{
ink_assert(valid());
ink_assert(m_http->m_polarity == HTTPType::RESPONSE);
- http_hdr_reason_set(m_heap, m_http, value, length, true);
+ http_hdr_reason_set(m_heap, m_http, value, true);
}
/*-------------------------------------------------------------------------
@@ -1205,11 +1167,9 @@ HTTPHdr::path_get()
{
URL *url = this->url_get();
if (url) {
- int length;
- auto path{url->path_get(&length)};
- return std::string_view{path, static_cast<std::string_view::size_type>(length)};
+ return url->path_get();
}
- return std::string_view{};
+ return {};
}
inline std::string_view
@@ -1217,9 +1177,7 @@ HTTPHdr::query_get()
{
URL *url = this->url_get();
if (url) {
- int length;
- auto query{url->query_get(&length)};
- return std::string_view{query, static_cast<std::string_view::size_type>(length)};
+ return url->query_get();
}
return std::string_view{};
}
@@ -1229,9 +1187,7 @@ HTTPHdr::fragment_get()
{
URL *url = this->url_get();
if (url) {
- int length;
- auto fragment{url->fragment_get(&length)};
- return std::string_view{fragment, static_cast<std::string_view::size_type>(length)};
+ return url->fragment_get();
}
return std::string_view{};
}
@@ -1241,9 +1197,7 @@ HTTPHdr::scheme_get()
{
URL *url = this->url_get();
if (url) {
- int length;
- auto scheme{url->scheme_get(&length)};
- return std::string_view{scheme, static_cast<std::string_view::size_type>(length)};
+ return url->scheme_get();
}
return std::string_view{};
}
diff --git a/include/proxy/hdrs/URL.h b/include/proxy/hdrs/URL.h
index 4906c4a705..ffc708c036 100644
--- a/include/proxy/hdrs/URL.h
+++ b/include/proxy/hdrs/URL.h
@@ -82,29 +82,29 @@ public:
// 8 bytes + 4 bits, will result in padding
// Accessors
- const char *get_scheme(int *length);
- const char *set_scheme(HdrHeap *heap, const char *value, int value_wks_idx, int length, bool copy_string);
- const char *get_user(int *length);
- void set_user(HdrHeap *heap, const char *value, int length, bool copy_string);
- const char *get_password(int *length);
- void set_password(HdrHeap *heap, const char *value, int length, bool copy_string);
- const char *get_host(int *length);
- void set_host(HdrHeap *heap, const char *value, int length, bool copy_string);
- int get_port();
- void set_port(HdrHeap *heap, unsigned int port);
- void set_port(HdrHeap *heap, const char *value, int length, bool copy_string);
- const char *get_path(int *length);
- void set_path(HdrHeap *heap, const char *value, int length, bool copy_string);
- URLType get_type();
- void set_type(URLType type);
- int get_type_code();
- void set_type_code(unsigned int typecode);
- const char *get_params(int *length);
- void set_params(HdrHeap *heap, const char *value, int length, bool copy_string);
- const char *get_query(int *length);
- void set_query(HdrHeap *heap, const char *value, int length, bool copy_string);
- const char *get_fragment(int *length);
- void set_fragment(HdrHeap *heap, const char *value, int length, bool copy_string);
+ std::string_view get_scheme() const noexcept;
+ const char *set_scheme(HdrHeap *heap, std::string_view value, int value_wks_idx, bool copy_string);
+ std::string_view get_user() const noexcept;
+ void set_user(HdrHeap *heap, std::string_view value, bool copy_string);
+ std::string_view get_password() const noexcept;
+ void set_password(HdrHeap *heap, std::string_view value, bool copy_string);
+ std::string_view get_host() const noexcept;
+ void set_host(HdrHeap *heap, std::string_view value, bool copy_string);
+ int get_port();
+ void set_port(HdrHeap *heap, unsigned int port);
+ void set_port(HdrHeap *heap, std::string_view value, bool copy_string);
+ std::string_view get_path() const noexcept;
+ void set_path(HdrHeap *heap, std::string_view value, bool copy_string);
+ URLType get_type();
+ void set_type(URLType type);
+ int get_type_code();
+ void set_type_code(unsigned int typecode);
+ std::string_view get_params() const noexcept;
+ void set_params(HdrHeap *heap, std::string_view value, bool copy_string);
+ std::string_view get_query() const noexcept;
+ void set_query(HdrHeap *heap, std::string_view value, bool copy_string);
+ std::string_view get_fragment() const noexcept;
+ void set_fragment(HdrHeap *heap, std::string_view value, bool copy_string);
// Marshaling Functions
int marshal(MarshalXlate *str_xlate, int num_xlate);
@@ -121,26 +121,26 @@ private:
using URLHashContext = CryptoContext;
-extern const char *URL_SCHEME_FILE;
-extern const char *URL_SCHEME_FTP;
-extern const char *URL_SCHEME_GOPHER;
-extern const char *URL_SCHEME_HTTP;
-extern const char *URL_SCHEME_HTTPS;
-extern const char *URL_SCHEME_WS;
-extern const char *URL_SCHEME_WSS;
-extern const char *URL_SCHEME_MAILTO;
-extern const char *URL_SCHEME_NEWS;
-extern const char *URL_SCHEME_NNTP;
-extern const char *URL_SCHEME_PROSPERO;
-extern const char *URL_SCHEME_TELNET;
-extern const char *URL_SCHEME_TUNNEL;
-extern const char *URL_SCHEME_WAIS;
-extern const char *URL_SCHEME_PNM;
-extern const char *URL_SCHEME_RTSP;
-extern const char *URL_SCHEME_RTSPU;
-extern const char *URL_SCHEME_MMS;
-extern const char *URL_SCHEME_MMSU;
-extern const char *URL_SCHEME_MMST;
+extern c_str_view URL_SCHEME_FILE;
+extern c_str_view URL_SCHEME_FTP;
+extern c_str_view URL_SCHEME_GOPHER;
+extern c_str_view URL_SCHEME_HTTP;
+extern c_str_view URL_SCHEME_HTTPS;
+extern c_str_view URL_SCHEME_WS;
+extern c_str_view URL_SCHEME_WSS;
+extern c_str_view URL_SCHEME_MAILTO;
+extern c_str_view URL_SCHEME_NEWS;
+extern c_str_view URL_SCHEME_NNTP;
+extern c_str_view URL_SCHEME_PROSPERO;
+extern c_str_view URL_SCHEME_TELNET;
+extern c_str_view URL_SCHEME_TUNNEL;
+extern c_str_view URL_SCHEME_WAIS;
+extern c_str_view URL_SCHEME_PNM;
+extern c_str_view URL_SCHEME_RTSP;
+extern c_str_view URL_SCHEME_RTSPU;
+extern c_str_view URL_SCHEME_MMS;
+extern c_str_view URL_SCHEME_MMSU;
+extern c_str_view URL_SCHEME_MMST;
extern int URL_WKSIDX_FILE;
extern int URL_WKSIDX_FTP;
@@ -163,27 +163,6 @@ extern int URL_WKSIDX_MMS;
extern int URL_WKSIDX_MMSU;
extern int URL_WKSIDX_MMST;
-extern int URL_LEN_FILE;
-extern int URL_LEN_FTP;
-extern int URL_LEN_GOPHER;
-extern int URL_LEN_HTTP;
-extern int URL_LEN_HTTPS;
-extern int URL_LEN_WS;
-extern int URL_LEN_WSS;
-extern int URL_LEN_MAILTO;
-extern int URL_LEN_NEWS;
-extern int URL_LEN_NNTP;
-extern int URL_LEN_PROSPERO;
-extern int URL_LEN_TELNET;
-extern int URL_LEN_TUNNEL;
-extern int URL_LEN_WAIS;
-extern int URL_LEN_PNM;
-extern int URL_LEN_RTSP;
-extern int URL_LEN_RTSPU;
-extern int URL_LEN_MMS;
-extern int URL_LEN_MMSU;
-extern int URL_LEN_MMST;
-
/* Public */
bool validate_host_name(std::string_view addr);
bool validate_scheme(std::string_view scheme);
@@ -282,32 +261,31 @@ public:
void hash_get92(CryptoHash *hash, bool ignore_query = false, cache_generation_t generation = -1) const;
void host_hash_get(CryptoHash *hash) const;
- const char *scheme_get(int *length);
- const std::string_view scheme_get();
- int scheme_get_wksidx() const;
- void scheme_set(const char *value, int length);
+ std::string_view scheme_get() const noexcept;
+ int scheme_get_wksidx() const;
+ void scheme_set(std::string_view value);
- const char *user_get(int *length);
- void user_set(const char *value, int length);
- const char *password_get(int *length);
- void password_set(const char *value, int length);
- const char *host_get(int *length);
- void host_set(const char *value, int length);
+ std::string_view user_get() const noexcept;
+ void user_set(std::string_view value);
+ std::string_view password_get() const noexcept;
+ void password_set(std::string_view value);
+ std::string_view host_get() const noexcept;
+ void host_set(std::string_view value);
int port_get() const;
int port_get_raw() const;
void port_set(int port);
- const char *path_get(int *length);
- void path_set(const char *value, int length);
+ std::string_view path_get() const noexcept;
+ void path_set(std::string_view value);
int type_code_get();
void type_code_set(int type);
- const char *query_get(int *length);
- void query_set(const char *value, int length);
- const char *fragment_get(int *length);
- void fragment_set(const char *value, int length);
+ std::string_view query_get() const noexcept;
+ void query_set(std::string_view value);
+ std::string_view fragment_get() const noexcept;
+ void fragment_set(std::string_view value);
/**
* Parse the given URL string and populate URL state with the parts.
@@ -521,21 +499,11 @@ URL::host_hash_get(CryptoHash *hash) const
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const std::string_view
-URL::scheme_get()
+inline std::string_view
+URL::scheme_get() const noexcept
{
ink_assert(valid());
- int length;
- const char *scheme = m_url_impl->get_scheme(&length);
- return std::string_view{scheme, static_cast<size_t>(length)};
-}
-
-inline const char *
-URL::scheme_get(int *length)
-{
- std::string_view ret = this->scheme_get();
- *length = ret.size();
- return ret.data();
+ return m_url_impl->get_scheme();
}
inline int
@@ -549,71 +517,71 @@ URL::scheme_get_wksidx() const
-------------------------------------------------------------------------*/
inline void
-URL::scheme_set(const char *value, int length)
+URL::scheme_set(std::string_view value)
{
ink_assert(valid());
- int scheme_wks_idx = (value ? hdrtoken_tokenize(value, length) : -1);
- m_url_impl->set_scheme(m_heap, value, scheme_wks_idx, length, true);
+ int scheme_wks_idx = (!value.empty() ? hdrtoken_tokenize(value.data(), value.length()) : -1);
+ m_url_impl->set_scheme(m_heap, value, scheme_wks_idx, true);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const char *
-URL::user_get(int *length)
+inline std::string_view
+URL::user_get() const noexcept
{
ink_assert(valid());
- return m_url_impl->get_user(length);
+ return m_url_impl->get_user();
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
inline void
-URL::user_set(const char *value, int length)
+URL::user_set(std::string_view value)
{
ink_assert(valid());
- m_url_impl->set_user(m_heap, value, length, true);
+ m_url_impl->set_user(m_heap, value, true);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const char *
-URL::password_get(int *length)
+inline std::string_view
+URL::password_get() const noexcept
{
ink_assert(valid());
- return m_url_impl->get_password(length);
+ return m_url_impl->get_password();
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
inline void
-URL::password_set(const char *value, int length)
+URL::password_set(std::string_view value)
{
ink_assert(valid());
- m_url_impl->set_password(m_heap, value, length, true);
+ m_url_impl->set_password(m_heap, value, true);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const char *
-URL::host_get(int *length)
+inline std::string_view
+URL::host_get() const noexcept
{
ink_assert(valid());
- return m_url_impl->get_host(length);
+ return m_url_impl->get_host();
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
inline void
-URL::host_set(const char *value, int length)
+URL::host_set(std::string_view value)
{
ink_assert(valid());
- m_url_impl->set_host(m_heap, value, length, true);
+ m_url_impl->set_host(m_heap, value, true);
}
/*-------------------------------------------------------------------------
@@ -649,21 +617,21 @@ URL::port_set(int port)
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const char *
-URL::path_get(int *length)
+inline std::string_view
+URL::path_get() const noexcept
{
ink_assert(valid());
- return m_url_impl->get_path(length);
+ return m_url_impl->get_path();
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
inline void
-URL::path_set(const char *value, int length)
+URL::path_set(std::string_view value)
{
ink_assert(valid());
- m_url_impl->set_path(m_heap, value, length, true);
+ m_url_impl->set_path(m_heap, value, true);
}
/*-------------------------------------------------------------------------
@@ -689,41 +657,41 @@ URL::type_code_set(int typecode)
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const char *
-URL::query_get(int *length)
+inline std::string_view
+URL::query_get() const noexcept
{
ink_assert(valid());
- return m_url_impl->get_query(length);
+ return m_url_impl->get_query();
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
inline void
-URL::query_set(const char *value, int length)
+URL::query_set(std::string_view value)
{
ink_assert(valid());
- m_url_impl->set_query(m_heap, value, length, true);
+ m_url_impl->set_query(m_heap, value, true);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-inline const char *
-URL::fragment_get(int *length)
+inline std::string_view
+URL::fragment_get() const noexcept
{
ink_assert(valid());
- return m_url_impl->get_fragment(length);
+ return m_url_impl->get_fragment();
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
inline void
-URL::fragment_set(const char *value, int length)
+URL::fragment_set(std::string_view value)
{
ink_assert(valid());
- m_url_impl->set_fragment(m_heap, value, length, true);
+ m_url_impl->set_fragment(m_heap, value, true);
}
/**
diff --git a/src/api/InkAPI.cc b/src/api/InkAPI.cc
index c103f2d0c6..13bd26f53b 100644
--- a/src/api/InkAPI.cc
+++ b/src/api/InkAPI.cc
@@ -1050,22 +1050,21 @@ TSUrlStringGet(TSMBuffer bufp, TSMLoc obj, int *length)
return url_string_get(url_impl, nullptr, length, nullptr);
}
-using URLPartGetF = const char *(URL::*)(int *);
-using URLPartSetF = void (URL::*)(const char *, int);
+using URLPartGetF = std::string_view (URL::*)() const noexcept;
+using URLPartSetF = void (URL::*)(std::string_view);
-static const char *
-URLPartGet(TSMBuffer bufp, TSMLoc obj, int *length, URLPartGetF url_f)
+static const std::string_view
+URLPartGet(TSMBuffer bufp, TSMLoc obj, URLPartGetF url_f)
{
sdk_assert(sdk_sanity_check_mbuffer(bufp) == TS_SUCCESS);
sdk_assert(sdk_sanity_check_url_handle(obj) == TS_SUCCESS);
- sdk_assert(sdk_sanity_check_null_ptr((void *)length) == TS_SUCCESS);
URL u;
u.m_heap = (reinterpret_cast<HdrHeapSDKHandle *>(bufp))->m_heap;
u.m_url_impl = reinterpret_cast<URLImpl *>(obj);
- return (u.*url_f)(length);
+ return (u.*url_f)();
}
static TSReturnCode
@@ -1087,7 +1086,7 @@ URLPartSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length, URLPartSet
} else if (length < 0) {
length = strlen(value);
}
- (u.*url_f)(value, length);
+ (u.*url_f)(std::string_view{value, static_cast<std::string_view::size_type>(length)});
return TS_SUCCESS;
}
@@ -1095,7 +1094,11 @@ URLPartSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length, URLPartSet
const char *
TSUrlRawSchemeGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::scheme_get);
+ auto scheme{URLPartGet(bufp, obj, &URL::scheme_get)};
+ if (length) {
+ *length = static_cast<int>(scheme.length());
+ }
+ return scheme.data();
}
const char *
@@ -1107,12 +1110,12 @@ TSUrlSchemeGet(TSMBuffer bufp, TSMLoc obj, int *length)
}
switch (reinterpret_cast<URLImpl *>(obj)->m_url_type) {
case URLType::HTTP:
- data = URL_SCHEME_HTTP;
- *length = URL_LEN_HTTP;
+ data = URL_SCHEME_HTTP.c_str();
+ *length = static_cast<int>(URL_SCHEME_HTTP.length());
break;
case URLType::HTTPS:
- data = URL_SCHEME_HTTPS;
- *length = URL_LEN_HTTPS;
+ data = URL_SCHEME_HTTPS.c_str();
+ *length = static_cast<int>(URL_SCHEME_HTTPS.length());
break;
default:
*length = 0;
@@ -1132,7 +1135,11 @@ TSUrlSchemeSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
const char *
TSUrlUserGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::user_get);
+ auto user{URLPartGet(bufp, obj, &URL::user_get)};
+ if (length) {
+ *length = static_cast<int>(user.length());
+ }
+ return user.data();
}
TSReturnCode
@@ -1144,7 +1151,11 @@ TSUrlUserSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
const char *
TSUrlPasswordGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::password_get);
+ auto password{URLPartGet(bufp, obj, &URL::password_get)};
+ if (length) {
+ *length = static_cast<int>(password.length());
+ }
+ return password.data();
}
TSReturnCode
@@ -1156,7 +1167,11 @@ TSUrlPasswordSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
const char *
TSUrlHostGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::host_get);
+ auto host{URLPartGet(bufp, obj, &URL::host_get)};
+ if (length) {
+ *length = static_cast<int>(host.length());
+ }
+ return host.data();
}
TSReturnCode
@@ -1214,7 +1229,11 @@ TSUrlPortSet(TSMBuffer bufp, TSMLoc obj, int port)
const char *
TSUrlPathGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::path_get);
+ auto path{URLPartGet(bufp, obj, &URL::path_get)};
+ if (length) {
+ *length = static_cast<int>(path.length());
+ }
+ return path.data();
}
TSReturnCode
@@ -1262,7 +1281,11 @@ TSUrlFtpTypeSet(TSMBuffer bufp, TSMLoc obj, int type)
const char *
TSUrlHttpQueryGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::query_get);
+ auto query{URLPartGet(bufp, obj, &URL::query_get)};
+ if (length) {
+ *length = static_cast<int>(query.length());
+ }
+ return query.data();
}
TSReturnCode
@@ -1274,7 +1297,11 @@ TSUrlHttpQuerySet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
const char *
TSUrlHttpFragmentGet(TSMBuffer bufp, TSMLoc obj, int *length)
{
- return URLPartGet(bufp, obj, length, &URL::fragment_get);
+ auto fragment{URLPartGet(bufp, obj, &URL::fragment_get)};
+ if (length) {
+ *length = static_cast<int>(fragment.length());
+ }
+ return fragment.data();
}
TSReturnCode
@@ -2828,7 +2855,7 @@ TSHttpHdrMethodSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
length = strlen(value);
}
- h.method_set(value, length);
+ h.method_set(std::string_view{value, static_cast<std::string_view::size_type>(length)});
return TS_SUCCESS;
}
@@ -2964,7 +2991,7 @@ TSHttpHdrReasonSet(TSMBuffer bufp, TSMLoc obj, const char *value, int length)
if (length < 0) {
length = strlen(value);
}
- h.reason_set(value, length);
+ h.reason_set(std::string_view{value, static_cast<std::string_view::size_type>(length)});
return TS_SUCCESS;
}
diff --git a/src/api/InkAPIInternal.cc b/src/api/InkAPIInternal.cc
index f81c3bbcde..85f00287c5 100644
--- a/src/api/InkAPIInternal.cc
+++ b/src/api/InkAPIInternal.cc
@@ -540,33 +540,33 @@ api_init()
init = 0;
/* URL schemes */
- TS_URL_SCHEME_FILE = URL_SCHEME_FILE;
- TS_URL_SCHEME_FTP = URL_SCHEME_FTP;
- TS_URL_SCHEME_GOPHER = URL_SCHEME_GOPHER;
- TS_URL_SCHEME_HTTP = URL_SCHEME_HTTP;
- TS_URL_SCHEME_HTTPS = URL_SCHEME_HTTPS;
- TS_URL_SCHEME_MAILTO = URL_SCHEME_MAILTO;
- TS_URL_SCHEME_NEWS = URL_SCHEME_NEWS;
- TS_URL_SCHEME_NNTP = URL_SCHEME_NNTP;
- TS_URL_SCHEME_PROSPERO = URL_SCHEME_PROSPERO;
- TS_URL_SCHEME_TELNET = URL_SCHEME_TELNET;
- TS_URL_SCHEME_WAIS = URL_SCHEME_WAIS;
- TS_URL_SCHEME_WS = URL_SCHEME_WS;
- TS_URL_SCHEME_WSS = URL_SCHEME_WSS;
-
- TS_URL_LEN_FILE = URL_LEN_FILE;
- TS_URL_LEN_FTP = URL_LEN_FTP;
- TS_URL_LEN_GOPHER = URL_LEN_GOPHER;
- TS_URL_LEN_HTTP = URL_LEN_HTTP;
- TS_URL_LEN_HTTPS = URL_LEN_HTTPS;
- TS_URL_LEN_MAILTO = URL_LEN_MAILTO;
- TS_URL_LEN_NEWS = URL_LEN_NEWS;
- TS_URL_LEN_NNTP = URL_LEN_NNTP;
- TS_URL_LEN_PROSPERO = URL_LEN_PROSPERO;
- TS_URL_LEN_TELNET = URL_LEN_TELNET;
- TS_URL_LEN_WAIS = URL_LEN_WAIS;
- TS_URL_LEN_WS = URL_LEN_WS;
- TS_URL_LEN_WSS = URL_LEN_WSS;
+ TS_URL_SCHEME_FILE = URL_SCHEME_FILE.c_str();
+ TS_URL_SCHEME_FTP = URL_SCHEME_FTP.c_str();
+ TS_URL_SCHEME_GOPHER = URL_SCHEME_GOPHER.c_str();
+ TS_URL_SCHEME_HTTP = URL_SCHEME_HTTP.c_str();
+ TS_URL_SCHEME_HTTPS = URL_SCHEME_HTTPS.c_str();
+ TS_URL_SCHEME_MAILTO = URL_SCHEME_MAILTO.c_str();
+ TS_URL_SCHEME_NEWS = URL_SCHEME_NEWS.c_str();
+ TS_URL_SCHEME_NNTP = URL_SCHEME_NNTP.c_str();
+ TS_URL_SCHEME_PROSPERO = URL_SCHEME_PROSPERO.c_str();
+ TS_URL_SCHEME_TELNET = URL_SCHEME_TELNET.c_str();
+ TS_URL_SCHEME_WAIS = URL_SCHEME_WAIS.c_str();
+ TS_URL_SCHEME_WS = URL_SCHEME_WS.c_str();
+ TS_URL_SCHEME_WSS = URL_SCHEME_WSS.c_str();
+
+ TS_URL_LEN_FILE = static_cast<int>(URL_SCHEME_FILE.length());
+ TS_URL_LEN_FTP = static_cast<int>(URL_SCHEME_FTP.length());
+ TS_URL_LEN_GOPHER = static_cast<int>(URL_SCHEME_GOPHER.length());
+ TS_URL_LEN_HTTP = static_cast<int>(URL_SCHEME_HTTP.length());
+ TS_URL_LEN_HTTPS = static_cast<int>(URL_SCHEME_HTTPS.length());
+ TS_URL_LEN_MAILTO = static_cast<int>(URL_SCHEME_MAILTO.length());
+ TS_URL_LEN_NEWS = static_cast<int>(URL_SCHEME_NEWS.length());
+ TS_URL_LEN_NNTP = static_cast<int>(URL_SCHEME_NNTP.length());
+ TS_URL_LEN_PROSPERO = static_cast<int>(URL_SCHEME_PROSPERO.length());
+ TS_URL_LEN_TELNET = static_cast<int>(URL_SCHEME_TELNET.length());
+ TS_URL_LEN_WAIS = static_cast<int>(URL_SCHEME_WAIS.length());
+ TS_URL_LEN_WS = static_cast<int>(URL_SCHEME_WS.length());
+ TS_URL_LEN_WSS = static_cast<int>(URL_SCHEME_WSS.length());
/* MIME fields */
TS_MIME_FIELD_ACCEPT = MIME_FIELD_ACCEPT.c_str();
@@ -718,74 +718,74 @@ api_init()
TS_MIME_LEN_FORWARDED = static_cast<int>(MIME_FIELD_FORWARDED.length());
/* HTTP methods */
- TS_HTTP_METHOD_CONNECT = HTTP_METHOD_CONNECT;
- TS_HTTP_METHOD_DELETE = HTTP_METHOD_DELETE;
- TS_HTTP_METHOD_GET = HTTP_METHOD_GET;
- TS_HTTP_METHOD_HEAD = HTTP_METHOD_HEAD;
- TS_HTTP_METHOD_OPTIONS = HTTP_METHOD_OPTIONS;
- TS_HTTP_METHOD_POST = HTTP_METHOD_POST;
- TS_HTTP_METHOD_PURGE = HTTP_METHOD_PURGE;
- TS_HTTP_METHOD_PUT = HTTP_METHOD_PUT;
- TS_HTTP_METHOD_TRACE = HTTP_METHOD_TRACE;
- TS_HTTP_METHOD_PUSH = HTTP_METHOD_PUSH;
-
- TS_HTTP_LEN_CONNECT = HTTP_LEN_CONNECT;
- TS_HTTP_LEN_DELETE = HTTP_LEN_DELETE;
- TS_HTTP_LEN_GET = HTTP_LEN_GET;
- TS_HTTP_LEN_HEAD = HTTP_LEN_HEAD;
- TS_HTTP_LEN_OPTIONS = HTTP_LEN_OPTIONS;
- TS_HTTP_LEN_POST = HTTP_LEN_POST;
- TS_HTTP_LEN_PURGE = HTTP_LEN_PURGE;
- TS_HTTP_LEN_PUT = HTTP_LEN_PUT;
- TS_HTTP_LEN_TRACE = HTTP_LEN_TRACE;
- TS_HTTP_LEN_PUSH = HTTP_LEN_PUSH;
+ TS_HTTP_METHOD_CONNECT = HTTP_METHOD_CONNECT.c_str();
+ TS_HTTP_METHOD_DELETE = HTTP_METHOD_DELETE.c_str();
+ TS_HTTP_METHOD_GET = HTTP_METHOD_GET.c_str();
+ TS_HTTP_METHOD_HEAD = HTTP_METHOD_HEAD.c_str();
+ TS_HTTP_METHOD_OPTIONS = HTTP_METHOD_OPTIONS.c_str();
+ TS_HTTP_METHOD_POST = HTTP_METHOD_POST.c_str();
+ TS_HTTP_METHOD_PURGE = HTTP_METHOD_PURGE.c_str();
+ TS_HTTP_METHOD_PUT = HTTP_METHOD_PUT.c_str();
+ TS_HTTP_METHOD_TRACE = HTTP_METHOD_TRACE.c_str();
+ TS_HTTP_METHOD_PUSH = HTTP_METHOD_PUSH.c_str();
+
+ TS_HTTP_LEN_CONNECT = static_cast<int>(HTTP_METHOD_CONNECT.length());
+ TS_HTTP_LEN_DELETE = static_cast<int>(HTTP_METHOD_DELETE.length());
+ TS_HTTP_LEN_GET = static_cast<int>(HTTP_METHOD_GET.length());
+ TS_HTTP_LEN_HEAD = static_cast<int>(HTTP_METHOD_HEAD.length());
+ TS_HTTP_LEN_OPTIONS = static_cast<int>(HTTP_METHOD_OPTIONS.length());
+ TS_HTTP_LEN_POST = static_cast<int>(HTTP_METHOD_POST.length());
+ TS_HTTP_LEN_PURGE = static_cast<int>(HTTP_METHOD_PURGE.length());
+ TS_HTTP_LEN_PUT = static_cast<int>(HTTP_METHOD_PUT.length());
+ TS_HTTP_LEN_TRACE = static_cast<int>(HTTP_METHOD_TRACE.length());
+ TS_HTTP_LEN_PUSH = static_cast<int>(HTTP_METHOD_PUSH.length());
/* HTTP miscellaneous values */
- TS_HTTP_VALUE_BYTES = HTTP_VALUE_BYTES;
- TS_HTTP_VALUE_CHUNKED = HTTP_VALUE_CHUNKED;
- TS_HTTP_VALUE_CLOSE = HTTP_VALUE_CLOSE;
- TS_HTTP_VALUE_COMPRESS = HTTP_VALUE_COMPRESS;
- TS_HTTP_VALUE_DEFLATE = HTTP_VALUE_DEFLATE;
- TS_HTTP_VALUE_GZIP = HTTP_VALUE_GZIP;
- TS_HTTP_VALUE_BROTLI = HTTP_VALUE_BROTLI;
- TS_HTTP_VALUE_IDENTITY = HTTP_VALUE_IDENTITY;
- TS_HTTP_VALUE_KEEP_ALIVE = HTTP_VALUE_KEEP_ALIVE;
- TS_HTTP_VALUE_MAX_AGE = HTTP_VALUE_MAX_AGE;
- TS_HTTP_VALUE_MAX_STALE = HTTP_VALUE_MAX_STALE;
- TS_HTTP_VALUE_MIN_FRESH = HTTP_VALUE_MIN_FRESH;
- TS_HTTP_VALUE_MUST_REVALIDATE = HTTP_VALUE_MUST_REVALIDATE;
- TS_HTTP_VALUE_NONE = HTTP_VALUE_NONE;
- TS_HTTP_VALUE_NO_CACHE = HTTP_VALUE_NO_CACHE;
- TS_HTTP_VALUE_NO_STORE = HTTP_VALUE_NO_STORE;
- TS_HTTP_VALUE_NO_TRANSFORM = HTTP_VALUE_NO_TRANSFORM;
- TS_HTTP_VALUE_ONLY_IF_CACHED = HTTP_VALUE_ONLY_IF_CACHED;
- TS_HTTP_VALUE_PRIVATE = HTTP_VALUE_PRIVATE;
- TS_HTTP_VALUE_PROXY_REVALIDATE = HTTP_VALUE_PROXY_REVALIDATE;
- TS_HTTP_VALUE_PUBLIC = HTTP_VALUE_PUBLIC;
- TS_HTTP_VALUE_S_MAXAGE = HTTP_VALUE_S_MAXAGE;
-
- TS_HTTP_LEN_BYTES = HTTP_LEN_BYTES;
- TS_HTTP_LEN_CHUNKED = HTTP_LEN_CHUNKED;
- TS_HTTP_LEN_CLOSE = HTTP_LEN_CLOSE;
- TS_HTTP_LEN_COMPRESS = HTTP_LEN_COMPRESS;
- TS_HTTP_LEN_DEFLATE = HTTP_LEN_DEFLATE;
- TS_HTTP_LEN_GZIP = HTTP_LEN_GZIP;
- TS_HTTP_LEN_BROTLI = HTTP_LEN_BROTLI;
- TS_HTTP_LEN_IDENTITY = HTTP_LEN_IDENTITY;
- TS_HTTP_LEN_KEEP_ALIVE = HTTP_LEN_KEEP_ALIVE;
- TS_HTTP_LEN_MAX_AGE = HTTP_LEN_MAX_AGE;
- TS_HTTP_LEN_MAX_STALE = HTTP_LEN_MAX_STALE;
- TS_HTTP_LEN_MIN_FRESH = HTTP_LEN_MIN_FRESH;
- TS_HTTP_LEN_MUST_REVALIDATE = HTTP_LEN_MUST_REVALIDATE;
- TS_HTTP_LEN_NONE = HTTP_LEN_NONE;
- TS_HTTP_LEN_NO_CACHE = HTTP_LEN_NO_CACHE;
- TS_HTTP_LEN_NO_STORE = HTTP_LEN_NO_STORE;
- TS_HTTP_LEN_NO_TRANSFORM = HTTP_LEN_NO_TRANSFORM;
- TS_HTTP_LEN_ONLY_IF_CACHED = HTTP_LEN_ONLY_IF_CACHED;
- TS_HTTP_LEN_PRIVATE = HTTP_LEN_PRIVATE;
- TS_HTTP_LEN_PROXY_REVALIDATE = HTTP_LEN_PROXY_REVALIDATE;
- TS_HTTP_LEN_PUBLIC = HTTP_LEN_PUBLIC;
- TS_HTTP_LEN_S_MAXAGE = HTTP_LEN_S_MAXAGE;
+ TS_HTTP_VALUE_BYTES = HTTP_VALUE_BYTES.c_str();
+ TS_HTTP_VALUE_CHUNKED = HTTP_VALUE_CHUNKED.c_str();
+ TS_HTTP_VALUE_CLOSE = HTTP_VALUE_CLOSE.c_str();
+ TS_HTTP_VALUE_COMPRESS = HTTP_VALUE_COMPRESS.c_str();
+ TS_HTTP_VALUE_DEFLATE = HTTP_VALUE_DEFLATE.c_str();
+ TS_HTTP_VALUE_GZIP = HTTP_VALUE_GZIP.c_str();
+ TS_HTTP_VALUE_BROTLI = HTTP_VALUE_BROTLI.c_str();
+ TS_HTTP_VALUE_IDENTITY = HTTP_VALUE_IDENTITY.c_str();
+ TS_HTTP_VALUE_KEEP_ALIVE = HTTP_VALUE_KEEP_ALIVE.c_str();
+ TS_HTTP_VALUE_MAX_AGE = HTTP_VALUE_MAX_AGE.c_str();
+ TS_HTTP_VALUE_MAX_STALE = HTTP_VALUE_MAX_STALE.c_str();
+ TS_HTTP_VALUE_MIN_FRESH = HTTP_VALUE_MIN_FRESH.c_str();
+ TS_HTTP_VALUE_MUST_REVALIDATE = HTTP_VALUE_MUST_REVALIDATE.c_str();
+ TS_HTTP_VALUE_NONE = HTTP_VALUE_NONE.c_str();
+ TS_HTTP_VALUE_NO_CACHE = HTTP_VALUE_NO_CACHE.c_str();
+ TS_HTTP_VALUE_NO_STORE = HTTP_VALUE_NO_STORE.c_str();
+ TS_HTTP_VALUE_NO_TRANSFORM = HTTP_VALUE_NO_TRANSFORM.c_str();
+ TS_HTTP_VALUE_ONLY_IF_CACHED = HTTP_VALUE_ONLY_IF_CACHED.c_str();
+ TS_HTTP_VALUE_PRIVATE = HTTP_VALUE_PRIVATE.c_str();
+ TS_HTTP_VALUE_PROXY_REVALIDATE = HTTP_VALUE_PROXY_REVALIDATE.c_str();
+ TS_HTTP_VALUE_PUBLIC = HTTP_VALUE_PUBLIC.c_str();
+ TS_HTTP_VALUE_S_MAXAGE = HTTP_VALUE_S_MAXAGE.c_str();
+
+ TS_HTTP_LEN_BYTES = static_cast<int>(HTTP_VALUE_BYTES.length());
+ TS_HTTP_LEN_CHUNKED = static_cast<int>(HTTP_VALUE_CHUNKED.length());
+ TS_HTTP_LEN_CLOSE = static_cast<int>(HTTP_VALUE_CLOSE.length());
+ TS_HTTP_LEN_COMPRESS = static_cast<int>(HTTP_VALUE_COMPRESS.length());
+ TS_HTTP_LEN_DEFLATE = static_cast<int>(HTTP_VALUE_DEFLATE.length());
+ TS_HTTP_LEN_GZIP = static_cast<int>(HTTP_VALUE_GZIP.length());
+ TS_HTTP_LEN_BROTLI = static_cast<int>(HTTP_VALUE_BROTLI.length());
+ TS_HTTP_LEN_IDENTITY = static_cast<int>(HTTP_VALUE_IDENTITY.length());
+ TS_HTTP_LEN_KEEP_ALIVE = static_cast<int>(HTTP_VALUE_KEEP_ALIVE.length());
+ TS_HTTP_LEN_MAX_AGE = static_cast<int>(HTTP_VALUE_MAX_AGE.length());
+ TS_HTTP_LEN_MAX_STALE = static_cast<int>(HTTP_VALUE_MAX_STALE.length());
+ TS_HTTP_LEN_MIN_FRESH = static_cast<int>(HTTP_VALUE_MIN_FRESH.length());
+ TS_HTTP_LEN_MUST_REVALIDATE = static_cast<int>(HTTP_VALUE_MUST_REVALIDATE.length());
+ TS_HTTP_LEN_NONE = static_cast<int>(HTTP_VALUE_NONE.length());
+ TS_HTTP_LEN_NO_CACHE = static_cast<int>(HTTP_VALUE_NO_CACHE.length());
+ TS_HTTP_LEN_NO_STORE = static_cast<int>(HTTP_VALUE_NO_STORE.length());
+ TS_HTTP_LEN_NO_TRANSFORM = static_cast<int>(HTTP_VALUE_NO_TRANSFORM.length());
+ TS_HTTP_LEN_ONLY_IF_CACHED = static_cast<int>(HTTP_VALUE_ONLY_IF_CACHED.length());
+ TS_HTTP_LEN_PRIVATE = static_cast<int>(HTTP_VALUE_PRIVATE.length());
+ TS_HTTP_LEN_PROXY_REVALIDATE = static_cast<int>(HTTP_VALUE_PROXY_REVALIDATE.length());
+ TS_HTTP_LEN_PUBLIC = static_cast<int>(HTTP_VALUE_PUBLIC.length());
+ TS_HTTP_LEN_S_MAXAGE = static_cast<int>(HTTP_VALUE_S_MAXAGE.length());
init_global_http_hooks();
init_global_lifecycle_hooks();
diff --git a/src/iocore/cache/P_CacheInternal.h b/src/iocore/cache/P_CacheInternal.h
index a0e3603d50..87a2105321 100644
--- a/src/iocore/cache/P_CacheInternal.h
+++ b/src/iocore/cache/P_CacheInternal.h
@@ -497,7 +497,9 @@ Cache::generate_key(CryptoHash *hash, CacheURL *url)
inline void
Cache::generate_key(HttpCacheKey *key, CacheURL *url, bool ignore_query, cache_generation_t generation)
{
- key->hostname = url->host_get(&key->hostlen);
+ auto host{url->host_get()};
+ key->hostname = host.data();
+ key->hostlen = static_cast<int>(host.length());
url->hash_get(&key->hash, ignore_query, generation);
}
@@ -510,7 +512,9 @@ Cache::generate_key92(CryptoHash *hash, CacheURL *url)
inline void
Cache::generate_key92(HttpCacheKey *key, CacheURL *url, bool ignore_query, cache_generation_t generation)
{
- key->hostname = url->host_get(&key->hostlen);
+ auto host{url->host_get()};
+ key->hostname = host.data();
+ key->hostlen = static_cast<int>(host.length());
url->hash_get92(&key->hash, ignore_query, generation);
}
diff --git a/src/proxy/ControlBase.cc b/src/proxy/ControlBase.cc
index 7bd5102c1c..80da22fae0 100644
--- a/src/proxy/ControlBase.cc
+++ b/src/proxy/ControlBase.cc
@@ -521,9 +521,8 @@ PrefixMod::name() const
bool
PrefixMod::check(HttpRequestData *req) const
{
- int path_len;
- const char *path = req->hdr->url_get()->path_get(&path_len);
- bool zret = path_len >= static_cast<int>(text.size()) && 0 == memcmp(path, text.data(), text.size());
+ auto path{req->hdr->url_get()->path_get()};
+ bool zret = path.length() >= text.size() && 0 == memcmp(path.data(), text.data(), text.size());
/*
Dbg(dbg_ctl_cache_control, "Prefix check: URL=%0.*s Mod=%0.*s Z=%s",
path_len, path, text.size(), text.data(),
@@ -568,16 +567,15 @@ SuffixMod::name() const
bool
SuffixMod::check(HttpRequestData *req) const
{
- int path_len;
- const char *path = req->hdr->url_get()->path_get(&path_len);
+ auto path{req->hdr->url_get()->path_get()};
if (1 == this->text_vec.size() && 1 == this->text_vec[0].size() && this->text_vec[0][0] == '*') {
return true;
}
for (auto text_iter : this->text_vec) {
- if (path_len >= static_cast<int>(text_iter.size()) &&
- 0 == strncasecmp(path + path_len - text_iter.size(), text_iter.data(), text_iter.size())) {
+ if (path.length() >= text_iter.size() &&
+ 0 == strncasecmp(path.data() + path.length() - text_iter.size(), text_iter.data(), text_iter.size())) {
return true;
}
}
diff --git a/src/proxy/FetchSM.cc b/src/proxy/FetchSM.cc
index 92c7665756..cc024c8836 100644
--- a/src/proxy/FetchSM.cc
+++ b/src/proxy/FetchSM.cc
@@ -657,7 +657,8 @@ FetchSM::ext_init(Continuation *cont, const char *method, const char *url, const
req_buffer->write(version, strlen(version));
req_buffer->write("\r\n", 2);
- if ((method_len == HTTP_LEN_HEAD) && !memcmp(method, HTTP_METHOD_HEAD, HTTP_LEN_HEAD)) {
+ if ((method_len == static_cast<int>(HTTP_METHOD_HEAD.length())) &&
+ !memcmp(method, HTTP_METHOD_HEAD.c_str(), static_cast<int>(HTTP_METHOD_HEAD.length()))) {
is_method_head = true;
}
}
diff --git a/src/proxy/ParentConsistentHash.cc b/src/proxy/ParentConsistentHash.cc
index 4c7e438da9..a9dab9a1d3 100644
--- a/src/proxy/ParentConsistentHash.cc
+++ b/src/proxy/ParentConsistentHash.cc
@@ -92,16 +92,14 @@ ParentConsistentHash::getPathHash(HttpRequestData *hrdata, ATSHash64 *h)
// Always hash on '/' because paths returned by ATS are always stripped of it
h->update("/", 1);
- url_string_ref = ps_url->path_get(&len);
- if (url_string_ref) {
- h->update(url_string_ref, len);
+ if (auto path{ps_url->path_get()}; !path.empty()) {
+ h->update(path.data(), path.length());
}
if (!ignore_query) {
- url_string_ref = ps_url->query_get(&len);
- if (url_string_ref) {
+ if (auto query{ps_url->query_get()}; !query.empty()) {
h->update("?", 1);
- h->update(url_string_ref, len);
+ h->update(query.data(), query.length());
}
}
diff --git a/src/proxy/ParentSelection.cc b/src/proxy/ParentSelection.cc
index bd52d2559c..f93bbc3a04 100644
--- a/src/proxy/ParentSelection.cc
+++ b/src/proxy/ParentSelection.cc
@@ -32,6 +32,10 @@
#include "tscore/Regression.h"
#include "tscore/Tokenizer.h"
+#include <string_view>
+
+using namespace std::literals;
+
#define MAX_SIMPLE_RETRIES 5
#define MAX_UNAVAILABLE_SERVER_RETRIES 5
@@ -1199,8 +1203,8 @@ EXCLUSIVE_REGRESSION_TEST(PARENTSELECTION)(RegressionTest * /* t ATS_UNUSED */,
ST(6);
REINIT;
br(request, "www.snoopy.net");
- const char *snoopy_dog = "http://www.snoopy.com/";
- request->hdr->url_set(snoopy_dog, strlen(snoopy_dog));
+ auto snoopy_dog = "http://www.snoopy.com/"sv;
+ request->hdr->url_set(snoopy_dog);
FP;
RE(verify(result, ParentResultType::SPECIFIED, "odie", 80) + verify(result, ParentResultType::SPECIFIED, "garfield", 80), 5);
// Test 7
diff --git a/src/proxy/Transform.cc b/src/proxy/Transform.cc
index b4ee43bba3..4269595213 100644
--- a/src/proxy/Transform.cc
+++ b/src/proxy/Transform.cc
@@ -1079,7 +1079,7 @@ RangeTransform::change_response_header()
status_code = HTTPStatus::PARTIAL_CONTENT;
m_transform_resp->status_set(status_code);
reason_phrase = const_cast<char *>(http_hdr_reason_lookup(status_code));
- m_transform_resp->reason_set(reason_phrase, strlen(reason_phrase));
+ m_transform_resp->reason_set(std::string_view{reason_phrase});
if (m_num_range_fields > 1) {
// set the right Content-Type for multiple entry Range
diff --git a/src/proxy/hdrs/HTTP.cc b/src/proxy/hdrs/HTTP.cc
index 4aedf392cb..a6c41c5f4a 100644
--- a/src/proxy/hdrs/HTTP.cc
+++ b/src/proxy/hdrs/HTTP.cc
@@ -32,6 +32,8 @@
#include "proxy/hdrs/HdrToken.h"
#include "tscore/Diags.h"
+using namespace std::literals;
+
/***********************************************************************
* *
* C O M P I L E O P T I O N S *
@@ -46,16 +48,16 @@
* *
***********************************************************************/
-const char *HTTP_METHOD_CONNECT;
-const char *HTTP_METHOD_DELETE;
-const char *HTTP_METHOD_GET;
-const char *HTTP_METHOD_HEAD;
-const char *HTTP_METHOD_OPTIONS;
-const char *HTTP_METHOD_POST;
-const char *HTTP_METHOD_PURGE;
-const char *HTTP_METHOD_PUT;
-const char *HTTP_METHOD_TRACE;
-const char *HTTP_METHOD_PUSH;
+c_str_view HTTP_METHOD_CONNECT;
+c_str_view HTTP_METHOD_DELETE;
+c_str_view HTTP_METHOD_GET;
+c_str_view HTTP_METHOD_HEAD;
+c_str_view HTTP_METHOD_OPTIONS;
+c_str_view HTTP_METHOD_POST;
+c_str_view HTTP_METHOD_PURGE;
+c_str_view HTTP_METHOD_PUT;
+c_str_view HTTP_METHOD_TRACE;
+c_str_view HTTP_METHOD_PUSH;
int HTTP_WKSIDX_CONNECT;
int HTTP_WKSIDX_DELETE;
@@ -69,41 +71,30 @@ int HTTP_WKSIDX_TRACE;
int HTTP_WKSIDX_PUSH;
int HTTP_WKSIDX_METHODS_CNT = 0;
-int HTTP_LEN_CONNECT;
-int HTTP_LEN_DELETE;
-int HTTP_LEN_GET;
-int HTTP_LEN_HEAD;
-int HTTP_LEN_OPTIONS;
-int HTTP_LEN_POST;
-int HTTP_LEN_PURGE;
-int HTTP_LEN_PUT;
-int HTTP_LEN_TRACE;
-int HTTP_LEN_PUSH;
-
-const char *HTTP_VALUE_BYTES;
-const char *HTTP_VALUE_CHUNKED;
-const char *HTTP_VALUE_CLOSE;
-const char *HTTP_VALUE_COMPRESS;
-const char *HTTP_VALUE_DEFLATE;
-const char *HTTP_VALUE_GZIP;
-const char *HTTP_VALUE_BROTLI;
-const char *HTTP_VALUE_IDENTITY;
-const char *HTTP_VALUE_KEEP_ALIVE;
-const char *HTTP_VALUE_MAX_AGE;
-const char *HTTP_VALUE_MAX_STALE;
-const char *HTTP_VALUE_MIN_FRESH;
-const char *HTTP_VALUE_MUST_REVALIDATE;
-const char *HTTP_VALUE_NONE;
-const char *HTTP_VALUE_NO_CACHE;
-const char *HTTP_VALUE_NO_STORE;
-const char *HTTP_VALUE_NO_TRANSFORM;
-const char *HTTP_VALUE_ONLY_IF_CACHED;
-const char *HTTP_VALUE_PRIVATE;
-const char *HTTP_VALUE_PROXY_REVALIDATE;
-const char *HTTP_VALUE_PUBLIC;
-const char *HTTP_VALUE_S_MAXAGE;
-const char *HTTP_VALUE_NEED_REVALIDATE_ONCE;
-const char *HTTP_VALUE_100_CONTINUE;
+c_str_view HTTP_VALUE_BYTES;
+c_str_view HTTP_VALUE_CHUNKED;
+c_str_view HTTP_VALUE_CLOSE;
+c_str_view HTTP_VALUE_COMPRESS;
+c_str_view HTTP_VALUE_DEFLATE;
+c_str_view HTTP_VALUE_GZIP;
+c_str_view HTTP_VALUE_BROTLI;
+c_str_view HTTP_VALUE_IDENTITY;
+c_str_view HTTP_VALUE_KEEP_ALIVE;
+c_str_view HTTP_VALUE_MAX_AGE;
+c_str_view HTTP_VALUE_MAX_STALE;
+c_str_view HTTP_VALUE_MIN_FRESH;
+c_str_view HTTP_VALUE_MUST_REVALIDATE;
+c_str_view HTTP_VALUE_NONE;
+c_str_view HTTP_VALUE_NO_CACHE;
+c_str_view HTTP_VALUE_NO_STORE;
+c_str_view HTTP_VALUE_NO_TRANSFORM;
+c_str_view HTTP_VALUE_ONLY_IF_CACHED;
+c_str_view HTTP_VALUE_PRIVATE;
+c_str_view HTTP_VALUE_PROXY_REVALIDATE;
+c_str_view HTTP_VALUE_PUBLIC;
+c_str_view HTTP_VALUE_S_MAXAGE;
+c_str_view HTTP_VALUE_NEED_REVALIDATE_ONCE;
+c_str_view HTTP_VALUE_100_CONTINUE;
// Cache-control: extension "need-revalidate-once" is used internally by T.S.
// to invalidate a document, and it is not returned/forwarded.
// If a cached document has this extension set (ie, is invalidated),
@@ -116,31 +107,6 @@ const char *HTTP_VALUE_100_CONTINUE;
// To test, use regular Cache-control testing functions, eg,
// is_cache_control_set(HTTP_VALUE_NEED_REVALIDATE_ONCE)
-int HTTP_LEN_BYTES;
-int HTTP_LEN_CHUNKED;
-int HTTP_LEN_CLOSE;
-int HTTP_LEN_COMPRESS;
-int HTTP_LEN_DEFLATE;
-int HTTP_LEN_GZIP;
-int HTTP_LEN_BROTLI;
-int HTTP_LEN_IDENTITY;
-int HTTP_LEN_KEEP_ALIVE;
-int HTTP_LEN_MAX_AGE;
-int HTTP_LEN_MAX_STALE;
-int HTTP_LEN_MIN_FRESH;
-int HTTP_LEN_MUST_REVALIDATE;
-int HTTP_LEN_NONE;
-int HTTP_LEN_NO_CACHE;
-int HTTP_LEN_NO_STORE;
-int HTTP_LEN_NO_TRANSFORM;
-int HTTP_LEN_ONLY_IF_CACHED;
-int HTTP_LEN_PRIVATE;
-int HTTP_LEN_PROXY_REVALIDATE;
-int HTTP_LEN_PUBLIC;
-int HTTP_LEN_S_MAXAGE;
-int HTTP_LEN_NEED_REVALIDATE_ONCE;
-int HTTP_LEN_100_CONTINUE;
-
Arena *const HTTPHdr::USE_HDR_HEAP_MAGIC = reinterpret_cast<Arena *>(1);
namespace
@@ -176,100 +142,64 @@ http_init()
mime_init();
url_init();
- HTTP_METHOD_CONNECT = hdrtoken_string_to_wks("CONNECT");
- HTTP_METHOD_DELETE = hdrtoken_string_to_wks("DELETE");
- HTTP_METHOD_GET = hdrtoken_string_to_wks("GET");
- HTTP_METHOD_HEAD = hdrtoken_string_to_wks("HEAD");
- HTTP_METHOD_OPTIONS = hdrtoken_string_to_wks("OPTIONS");
- HTTP_METHOD_POST = hdrtoken_string_to_wks("POST");
- HTTP_METHOD_PURGE = hdrtoken_string_to_wks("PURGE");
- HTTP_METHOD_PUT = hdrtoken_string_to_wks("PUT");
- HTTP_METHOD_TRACE = hdrtoken_string_to_wks("TRACE");
- HTTP_METHOD_PUSH = hdrtoken_string_to_wks("PUSH");
+ HTTP_METHOD_CONNECT = hdrtoken_string_to_wks_sv("CONNECT");
+ HTTP_METHOD_DELETE = hdrtoken_string_to_wks_sv("DELETE");
+ HTTP_METHOD_GET = hdrtoken_string_to_wks_sv("GET");
+ HTTP_METHOD_HEAD = hdrtoken_string_to_wks_sv("HEAD");
+ HTTP_METHOD_OPTIONS = hdrtoken_string_to_wks_sv("OPTIONS");
+ HTTP_METHOD_POST = hdrtoken_string_to_wks_sv("POST");
+ HTTP_METHOD_PURGE = hdrtoken_string_to_wks_sv("PURGE");
+ HTTP_METHOD_PUT = hdrtoken_string_to_wks_sv("PUT");
+ HTTP_METHOD_TRACE = hdrtoken_string_to_wks_sv("TRACE");
+ HTTP_METHOD_PUSH = hdrtoken_string_to_wks_sv("PUSH");
// HTTP methods index calculation. Don't forget to count them!
// Don't change the order of calculation! Each index has related bitmask (see http quick filter)
- HTTP_WKSIDX_CONNECT = hdrtoken_wks_to_index(HTTP_METHOD_CONNECT);
+ HTTP_WKSIDX_CONNECT = hdrtoken_wks_to_index(HTTP_METHOD_CONNECT.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_DELETE = hdrtoken_wks_to_index(HTTP_METHOD_DELETE);
+ HTTP_WKSIDX_DELETE = hdrtoken_wks_to_index(HTTP_METHOD_DELETE.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_GET = hdrtoken_wks_to_index(HTTP_METHOD_GET);
+ HTTP_WKSIDX_GET = hdrtoken_wks_to_index(HTTP_METHOD_GET.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_HEAD = hdrtoken_wks_to_index(HTTP_METHOD_HEAD);
+ HTTP_WKSIDX_HEAD = hdrtoken_wks_to_index(HTTP_METHOD_HEAD.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_OPTIONS = hdrtoken_wks_to_index(HTTP_METHOD_OPTIONS);
+ HTTP_WKSIDX_OPTIONS = hdrtoken_wks_to_index(HTTP_METHOD_OPTIONS.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_POST = hdrtoken_wks_to_index(HTTP_METHOD_POST);
+ HTTP_WKSIDX_POST = hdrtoken_wks_to_index(HTTP_METHOD_POST.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_PURGE = hdrtoken_wks_to_index(HTTP_METHOD_PURGE);
+ HTTP_WKSIDX_PURGE = hdrtoken_wks_to_index(HTTP_METHOD_PURGE.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_PUT = hdrtoken_wks_to_index(HTTP_METHOD_PUT);
+ HTTP_WKSIDX_PUT = hdrtoken_wks_to_index(HTTP_METHOD_PUT.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_TRACE = hdrtoken_wks_to_index(HTTP_METHOD_TRACE);
+ HTTP_WKSIDX_TRACE = hdrtoken_wks_to_index(HTTP_METHOD_TRACE.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_WKSIDX_PUSH = hdrtoken_wks_to_index(HTTP_METHOD_PUSH);
+ HTTP_WKSIDX_PUSH = hdrtoken_wks_to_index(HTTP_METHOD_PUSH.c_str());
HTTP_WKSIDX_METHODS_CNT++;
- HTTP_LEN_CONNECT = hdrtoken_wks_to_length(HTTP_METHOD_CONNECT);
- HTTP_LEN_DELETE = hdrtoken_wks_to_length(HTTP_METHOD_DELETE);
- HTTP_LEN_GET = hdrtoken_wks_to_length(HTTP_METHOD_GET);
- HTTP_LEN_HEAD = hdrtoken_wks_to_length(HTTP_METHOD_HEAD);
- HTTP_LEN_OPTIONS = hdrtoken_wks_to_length(HTTP_METHOD_OPTIONS);
- HTTP_LEN_POST = hdrtoken_wks_to_length(HTTP_METHOD_POST);
- HTTP_LEN_PURGE = hdrtoken_wks_to_length(HTTP_METHOD_PURGE);
- HTTP_LEN_PUT = hdrtoken_wks_to_length(HTTP_METHOD_PUT);
- HTTP_LEN_TRACE = hdrtoken_wks_to_length(HTTP_METHOD_TRACE);
- HTTP_LEN_PUSH = hdrtoken_wks_to_length(HTTP_METHOD_PUSH);
-
- HTTP_VALUE_BYTES = hdrtoken_string_to_wks("bytes");
- HTTP_VALUE_CHUNKED = hdrtoken_string_to_wks("chunked");
- HTTP_VALUE_CLOSE = hdrtoken_string_to_wks("close");
- HTTP_VALUE_COMPRESS = hdrtoken_string_to_wks("compress");
- HTTP_VALUE_DEFLATE = hdrtoken_string_to_wks("deflate");
- HTTP_VALUE_GZIP = hdrtoken_string_to_wks("gzip");
- HTTP_VALUE_BROTLI = hdrtoken_string_to_wks("br");
- HTTP_VALUE_IDENTITY = hdrtoken_string_to_wks("identity");
- HTTP_VALUE_KEEP_ALIVE = hdrtoken_string_to_wks("keep-alive");
- HTTP_VALUE_MAX_AGE = hdrtoken_string_to_wks("max-age");
- HTTP_VALUE_MAX_STALE = hdrtoken_string_to_wks("max-stale");
- HTTP_VALUE_MIN_FRESH = hdrtoken_string_to_wks("min-fresh");
- HTTP_VALUE_MUST_REVALIDATE = hdrtoken_string_to_wks("must-revalidate");
- HTTP_VALUE_NONE = hdrtoken_string_to_wks("none");
- HTTP_VALUE_NO_CACHE = hdrtoken_string_to_wks("no-cache");
- HTTP_VALUE_NO_STORE = hdrtoken_string_to_wks("no-store");
- HTTP_VALUE_NO_TRANSFORM = hdrtoken_string_to_wks("no-transform");
- HTTP_VALUE_ONLY_IF_CACHED = hdrtoken_string_to_wks("only-if-cached");
- HTTP_VALUE_PRIVATE = hdrtoken_string_to_wks("private");
- HTTP_VALUE_PROXY_REVALIDATE = hdrtoken_string_to_wks("proxy-revalidate");
- HTTP_VALUE_PUBLIC = hdrtoken_string_to_wks("public");
- HTTP_VALUE_S_MAXAGE = hdrtoken_string_to_wks("s-maxage");
- HTTP_VALUE_NEED_REVALIDATE_ONCE = hdrtoken_string_to_wks("need-revalidate-once");
- HTTP_VALUE_100_CONTINUE = hdrtoken_string_to_wks("100-continue");
-
- HTTP_LEN_BYTES = hdrtoken_wks_to_length(HTTP_VALUE_BYTES);
- HTTP_LEN_CHUNKED = hdrtoken_wks_to_length(HTTP_VALUE_CHUNKED);
- HTTP_LEN_CLOSE = hdrtoken_wks_to_length(HTTP_VALUE_CLOSE);
- HTTP_LEN_COMPRESS = hdrtoken_wks_to_length(HTTP_VALUE_COMPRESS);
- HTTP_LEN_DEFLATE = hdrtoken_wks_to_length(HTTP_VALUE_DEFLATE);
- HTTP_LEN_GZIP = hdrtoken_wks_to_length(HTTP_VALUE_GZIP);
- HTTP_LEN_BROTLI = hdrtoken_wks_to_length(HTTP_VALUE_BROTLI);
- HTTP_LEN_IDENTITY = hdrtoken_wks_to_length(HTTP_VALUE_IDENTITY);
- HTTP_LEN_KEEP_ALIVE = hdrtoken_wks_to_length(HTTP_VALUE_KEEP_ALIVE);
- HTTP_LEN_MAX_AGE = hdrtoken_wks_to_length(HTTP_VALUE_MAX_AGE);
- HTTP_LEN_MAX_STALE = hdrtoken_wks_to_length(HTTP_VALUE_MAX_STALE);
- HTTP_LEN_MIN_FRESH = hdrtoken_wks_to_length(HTTP_VALUE_MIN_FRESH);
- HTTP_LEN_MUST_REVALIDATE = hdrtoken_wks_to_length(HTTP_VALUE_MUST_REVALIDATE);
- HTTP_LEN_NONE = hdrtoken_wks_to_length(HTTP_VALUE_NONE);
- HTTP_LEN_NO_CACHE = hdrtoken_wks_to_length(HTTP_VALUE_NO_CACHE);
- HTTP_LEN_NO_STORE = hdrtoken_wks_to_length(HTTP_VALUE_NO_STORE);
- HTTP_LEN_NO_TRANSFORM = hdrtoken_wks_to_length(HTTP_VALUE_NO_TRANSFORM);
- HTTP_LEN_ONLY_IF_CACHED = hdrtoken_wks_to_length(HTTP_VALUE_ONLY_IF_CACHED);
- HTTP_LEN_PRIVATE = hdrtoken_wks_to_length(HTTP_VALUE_PRIVATE);
- HTTP_LEN_PROXY_REVALIDATE = hdrtoken_wks_to_length(HTTP_VALUE_PROXY_REVALIDATE);
- HTTP_LEN_PUBLIC = hdrtoken_wks_to_length(HTTP_VALUE_PUBLIC);
- HTTP_LEN_S_MAXAGE = hdrtoken_wks_to_length(HTTP_VALUE_S_MAXAGE);
- HTTP_LEN_NEED_REVALIDATE_ONCE = hdrtoken_wks_to_length(HTTP_VALUE_NEED_REVALIDATE_ONCE);
- HTTP_LEN_100_CONTINUE = hdrtoken_wks_to_length(HTTP_VALUE_100_CONTINUE);
+ HTTP_VALUE_BYTES = hdrtoken_string_to_wks_sv("bytes");
+ HTTP_VALUE_CHUNKED = hdrtoken_string_to_wks_sv("chunked");
+ HTTP_VALUE_CLOSE = hdrtoken_string_to_wks_sv("close");
+ HTTP_VALUE_COMPRESS = hdrtoken_string_to_wks_sv("compress");
+ HTTP_VALUE_DEFLATE = hdrtoken_string_to_wks_sv("deflate");
+ HTTP_VALUE_GZIP = hdrtoken_string_to_wks_sv("gzip");
+ HTTP_VALUE_BROTLI = hdrtoken_string_to_wks_sv("br");
+ HTTP_VALUE_IDENTITY = hdrtoken_string_to_wks_sv("identity");
+ HTTP_VALUE_KEEP_ALIVE = hdrtoken_string_to_wks_sv("keep-alive");
+ HTTP_VALUE_MAX_AGE = hdrtoken_string_to_wks_sv("max-age");
+ HTTP_VALUE_MAX_STALE = hdrtoken_string_to_wks_sv("max-stale");
+ HTTP_VALUE_MIN_FRESH = hdrtoken_string_to_wks_sv("min-fresh");
+ HTTP_VALUE_MUST_REVALIDATE = hdrtoken_string_to_wks_sv("must-revalidate");
+ HTTP_VALUE_NONE = hdrtoken_string_to_wks_sv("none");
+ HTTP_VALUE_NO_CACHE = hdrtoken_string_to_wks_sv("no-cache");
+ HTTP_VALUE_NO_STORE = hdrtoken_string_to_wks_sv("no-store");
+ HTTP_VALUE_NO_TRANSFORM = hdrtoken_string_to_wks_sv("no-transform");
+ HTTP_VALUE_ONLY_IF_CACHED = hdrtoken_string_to_wks_sv("only-if-cached");
+ HTTP_VALUE_PRIVATE = hdrtoken_string_to_wks_sv("private");
+ HTTP_VALUE_PROXY_REVALIDATE = hdrtoken_string_to_wks_sv("proxy-revalidate");
+ HTTP_VALUE_PUBLIC = hdrtoken_string_to_wks_sv("public");
+ HTTP_VALUE_S_MAXAGE = hdrtoken_string_to_wks_sv("s-maxage");
+ HTTP_VALUE_NEED_REVALIDATE_ONCE = hdrtoken_string_to_wks_sv("need-revalidate-once");
+ HTTP_VALUE_100_CONTINUE = hdrtoken_string_to_wks_sv("100-continue");
}
}
@@ -720,13 +650,12 @@ http_hdr_method_get(HTTPHdrImpl *hh)
-------------------------------------------------------------------------*/
void
-http_hdr_method_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *method, int16_t method_wks_idx, int method_length, bool must_copy)
+http_hdr_method_set(HdrHeap *heap, HTTPHdrImpl *hh, std::string_view method, int16_t method_wks_idx, bool must_copy)
{
ink_assert(hh->m_polarity == HTTPType::REQUEST);
hh->u.req.m_method_wks_idx = method_wks_idx;
- mime_str_u16_set(heap, std::string_view{method, static_cast<std::string_view::size_type>(method_length)},
- &(hh->u.req.m_ptr_method), &(hh->u.req.m_len_method), must_copy);
+ mime_str_u16_set(heap, method, &(hh->u.req.m_ptr_method), &(hh->u.req.m_len_method), must_copy);
}
/*-------------------------------------------------------------------------
@@ -780,11 +709,10 @@ http_hdr_reason_get(HTTPHdrImpl *hh)
-------------------------------------------------------------------------*/
void
-http_hdr_reason_set(HdrHeap *heap, HTTPHdrImpl *hh, const char *value, int length, bool must_copy)
+http_hdr_reason_set(HdrHeap *heap, HTTPHdrImpl *hh, std::string_view value, bool must_copy)
{
ink_assert(hh->m_polarity == HTTPType::RESPONSE);
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(hh->u.resp.m_ptr_reason),
- &(hh->u.resp.m_len_reason), must_copy);
+ mime_str_u16_set(heap, value, &(hh->u.resp.m_ptr_reason), &(hh->u.resp.m_len_reason), must_copy);
}
/*-------------------------------------------------------------------------
@@ -996,7 +924,7 @@ http_parser_parse_req(HTTPParser *parser, HdrHeap *heap, HTTPHdrImpl *hh, const
HTTPVersion version{static_cast<uint8_t>(end[-5] - '0'), static_cast<uint8_t>(end[-3] - '0')};
- http_hdr_method_set(heap, hh, &(cur[0]), hdrtoken_wks_to_index(HTTP_METHOD_GET), 3, must_copy_strings);
+ http_hdr_method_set(heap, hh, {&(cur[0]), 3}, HTTP_WKSIDX_GET, must_copy_strings);
ink_assert(hh->u.req.m_url_impl != nullptr);
url = hh->u.req.m_url_impl;
url_start = &(cur[4]);
@@ -1143,7 +1071,8 @@ http_parser_parse_req(HTTPParser *parser, HdrHeap *heap, HTTPHdrImpl *hh, const
ink_assert(url_end);
int method_wks_idx = hdrtoken_method_tokenize(method_start, static_cast<int>(method_end - method_start));
- http_hdr_method_set(heap, hh, method_start, method_wks_idx, static_cast<int>(method_end - method_start), must_copy_strings);
+ http_hdr_method_set(heap, hh, {method_start, static_cast<std::string_view::size_type>(method_end - method_start)},
+ method_wks_idx, must_copy_strings);
ink_assert(hh->u.req.m_url_impl != nullptr);
@@ -1188,15 +1117,12 @@ ParseResult
validate_hdr_request_target(int method_wk_idx, URLImpl *url)
{
ParseResult ret = ParseResult::DONE;
- int host_len;
- url->get_host(&host_len);
- int path_len;
- const char *path = url->get_path(&path_len);
- int scheme_len;
- url->get_scheme(&scheme_len);
-
- if (host_len == 0) {
- if (path_len == 1 && path[0] == '*') { // asterisk-form
+ auto host{url->get_host()};
+ auto path{url->get_path()};
+ auto scheme{url->get_scheme()};
+
+ if (host.empty()) {
+ if (path == "*"sv) { // asterisk-form
// Skip this check for now because URLImpl can't distinguish '*' and '/*'
// if (method_wk_idx != HTTP_WKSIDX_OPTIONS) {
// ret = ParseResult::ERROR;
@@ -1204,7 +1130,7 @@ validate_hdr_request_target(int method_wk_idx, URLImpl *url)
} else { // origin-form
// Nothing to check here
}
- } else if (scheme_len == 0 && host_len != 0) { // authority-form
+ } else if (scheme.empty() && !host.empty()) { // authority-form
if (method_wk_idx != HTTP_WKSIDX_CONNECT) {
ret = ParseResult::ERROR;
}
@@ -1386,7 +1312,8 @@ http_parser_parse_resp(HTTPParser *parser, HdrHeap *heap, HTTPHdrImpl *hh, const
http_hdr_version_set(hh, version);
http_hdr_status_set(hh, status);
- http_hdr_reason_set(heap, hh, reason_start, static_cast<int>(reason_end - reason_start), must_copy_strings);
+ http_hdr_reason_set(heap, hh, {reason_start, static_cast<std::string_view::size_type>(reason_end - reason_start)},
+ must_copy_strings);
end = real_end;
parser->m_parsing_http = false;
@@ -1503,7 +1430,8 @@ http_parser_parse_resp(HTTPParser *parser, HdrHeap *heap, HTTPHdrImpl *hh, const
}
if (reason_start && reason_end) {
- http_hdr_reason_set(heap, hh, reason_start, static_cast<int>(reason_end - reason_start), must_copy_strings);
+ http_hdr_reason_set(heap, hh, {reason_start, static_cast<std::string_view::size_type>(reason_end - reason_start)},
+ must_copy_strings);
}
end = real_end;
@@ -1711,13 +1639,15 @@ HTTPHdr::_fill_target_cache() const
m_port_in_header = false;
m_host_mime = nullptr;
// Check in the URL first, then the HOST field.
- if (nullptr != url->host_get(&m_host_length)) {
+ std::string_view host;
+ if (host = url->host_get(); nullptr != host.data()) {
m_target_in_url = true;
m_port = url->port_get();
m_port_in_header = 0 != url->port_get_raw();
m_host_mime = nullptr;
+ m_host_length = static_cast<int>(host.length());
} else {
- std::string_view host, port;
+ std::string_view port;
std::tie(m_host_mime, host, port) = const_cast<HTTPHdr *>(this)->get_host_port_values();
m_host_length = static_cast<int>(host.length());
@@ -1747,16 +1677,14 @@ HTTPHdr::set_url_target_from_host_field(URL *url)
// Use local cached URL and don't copy if the target
// is already there.
if (!m_target_in_url && m_host_mime && m_host_length) {
- m_url_cached.host_set(m_host_mime->m_ptr_value, m_host_length);
+ m_url_cached.host_set({m_host_mime->m_ptr_value, static_cast<std::string_view::size_type>(m_host_length)});
if (m_port_in_header) {
m_url_cached.port_set(m_port);
}
m_target_in_url = true; // it's there now.
}
} else {
- auto host{host_get()};
-
- url->host_set(host.data(), static_cast<int>(host.length()));
+ url->host_set(host_get());
if (m_port_in_header) {
url->port_set(m_port);
}
diff --git a/src/proxy/hdrs/HeaderValidator.cc b/src/proxy/hdrs/HeaderValidator.cc
index 0e7e35ff40..9cbe9457a5 100644
--- a/src/proxy/hdrs/HeaderValidator.cc
+++ b/src/proxy/hdrs/HeaderValidator.cc
@@ -35,8 +35,7 @@ HeaderValidator::is_h2_h3_header_valid(const HTTPHdr &hdr, bool is_response, boo
bool has_connect_method = false;
if (method_field) {
auto method{method_field->value_get()};
- has_connect_method =
- method == std::string_view{HTTP_METHOD_CONNECT, static_cast<std::string_view::size_type>(HTTP_LEN_CONNECT)};
+ has_connect_method = method == static_cast<std::string_view>(HTTP_METHOD_CONNECT);
}
unsigned int expected_pseudo_header_count = is_response ? 1 : has_connect_method ? 2 : 4;
unsigned int pseudo_header_count = 0;
diff --git a/src/proxy/hdrs/URL.cc b/src/proxy/hdrs/URL.cc
index 034e5ac55a..c5c4c10040 100644
--- a/src/proxy/hdrs/URL.cc
+++ b/src/proxy/hdrs/URL.cc
@@ -30,26 +30,26 @@
#include "proxy/hdrs/HTTP.h"
#include "tscore/Diags.h"
-const char *URL_SCHEME_FILE;
-const char *URL_SCHEME_FTP;
-const char *URL_SCHEME_GOPHER;
-const char *URL_SCHEME_HTTP;
-const char *URL_SCHEME_HTTPS;
-const char *URL_SCHEME_WSS;
-const char *URL_SCHEME_WS;
-const char *URL_SCHEME_MAILTO;
-const char *URL_SCHEME_NEWS;
-const char *URL_SCHEME_NNTP;
-const char *URL_SCHEME_PROSPERO;
-const char *URL_SCHEME_TELNET;
-const char *URL_SCHEME_TUNNEL;
-const char *URL_SCHEME_WAIS;
-const char *URL_SCHEME_PNM;
-const char *URL_SCHEME_RTSP;
-const char *URL_SCHEME_RTSPU;
-const char *URL_SCHEME_MMS;
-const char *URL_SCHEME_MMSU;
-const char *URL_SCHEME_MMST;
+c_str_view URL_SCHEME_FILE;
+c_str_view URL_SCHEME_FTP;
+c_str_view URL_SCHEME_GOPHER;
+c_str_view URL_SCHEME_HTTP;
+c_str_view URL_SCHEME_HTTPS;
+c_str_view URL_SCHEME_WSS;
+c_str_view URL_SCHEME_WS;
+c_str_view URL_SCHEME_MAILTO;
+c_str_view URL_SCHEME_NEWS;
+c_str_view URL_SCHEME_NNTP;
+c_str_view URL_SCHEME_PROSPERO;
+c_str_view URL_SCHEME_TELNET;
+c_str_view URL_SCHEME_TUNNEL;
+c_str_view URL_SCHEME_WAIS;
+c_str_view URL_SCHEME_PNM;
+c_str_view URL_SCHEME_RTSP;
+c_str_view URL_SCHEME_RTSPU;
+c_str_view URL_SCHEME_MMS;
+c_str_view URL_SCHEME_MMSU;
+c_str_view URL_SCHEME_MMST;
int URL_WKSIDX_FILE;
int URL_WKSIDX_FTP;
@@ -72,27 +72,6 @@ int URL_WKSIDX_MMS;
int URL_WKSIDX_MMSU;
int URL_WKSIDX_MMST;
-int URL_LEN_FILE;
-int URL_LEN_FTP;
-int URL_LEN_GOPHER;
-int URL_LEN_HTTP;
-int URL_LEN_HTTPS;
-int URL_LEN_WS;
-int URL_LEN_WSS;
-int URL_LEN_MAILTO;
-int URL_LEN_NEWS;
-int URL_LEN_NNTP;
-int URL_LEN_PROSPERO;
-int URL_LEN_TELNET;
-int URL_LEN_TUNNEL;
-int URL_LEN_WAIS;
-int URL_LEN_PNM;
-int URL_LEN_RTSP;
-int URL_LEN_RTSPU;
-int URL_LEN_MMS;
-int URL_LEN_MMSU;
-int URL_LEN_MMST;
-
namespace
{
// Whether we should implement url_CryptoHash_get() using url_CryptoHash_get_fast(). Note that
@@ -163,73 +142,53 @@ url_init()
hdrtoken_init();
- URL_SCHEME_FILE = hdrtoken_string_to_wks("file");
- URL_SCHEME_FTP = hdrtoken_string_to_wks("ftp");
- URL_SCHEME_GOPHER = hdrtoken_string_to_wks("gopher");
- URL_SCHEME_HTTP = hdrtoken_string_to_wks("http");
- URL_SCHEME_HTTPS = hdrtoken_string_to_wks("https");
- URL_SCHEME_WSS = hdrtoken_string_to_wks("wss");
- URL_SCHEME_WS = hdrtoken_string_to_wks("ws");
- URL_SCHEME_MAILTO = hdrtoken_string_to_wks("mailto");
- URL_SCHEME_NEWS = hdrtoken_string_to_wks("news");
- URL_SCHEME_NNTP = hdrtoken_string_to_wks("nntp");
- URL_SCHEME_PROSPERO = hdrtoken_string_to_wks("prospero");
- URL_SCHEME_TELNET = hdrtoken_string_to_wks("telnet");
- URL_SCHEME_TUNNEL = hdrtoken_string_to_wks("tunnel");
- URL_SCHEME_WAIS = hdrtoken_string_to_wks("wais");
- URL_SCHEME_PNM = hdrtoken_string_to_wks("pnm");
- URL_SCHEME_RTSP = hdrtoken_string_to_wks("rtsp");
- URL_SCHEME_RTSPU = hdrtoken_string_to_wks("rtspu");
- URL_SCHEME_MMS = hdrtoken_string_to_wks("mms");
- URL_SCHEME_MMSU = hdrtoken_string_to_wks("mmsu");
- URL_SCHEME_MMST = hdrtoken_string_to_wks("mmst");
-
- ink_assert(URL_SCHEME_FILE && URL_SCHEME_FTP && URL_SCHEME_GOPHER && URL_SCHEME_HTTP && URL_SCHEME_HTTPS && URL_SCHEME_WS &&
- URL_SCHEME_WSS && URL_SCHEME_MAILTO && URL_SCHEME_NEWS && URL_SCHEME_NNTP && URL_SCHEME_PROSPERO &&
- URL_SCHEME_TELNET && URL_SCHEME_TUNNEL && URL_SCHEME_WAIS && URL_SCHEME_PNM && URL_SCHEME_RTSP && URL_SCHEME_RTSPU &&
- URL_SCHEME_MMS && URL_SCHEME_MMSU && URL_SCHEME_MMST);
-
- URL_WKSIDX_FILE = hdrtoken_wks_to_index(URL_SCHEME_FILE);
- URL_WKSIDX_FTP = hdrtoken_wks_to_index(URL_SCHEME_FTP);
- URL_WKSIDX_GOPHER = hdrtoken_wks_to_index(URL_SCHEME_GOPHER);
- URL_WKSIDX_HTTP = hdrtoken_wks_to_index(URL_SCHEME_HTTP);
- URL_WKSIDX_HTTPS = hdrtoken_wks_to_index(URL_SCHEME_HTTPS);
- URL_WKSIDX_WS = hdrtoken_wks_to_index(URL_SCHEME_WS);
- URL_WKSIDX_WSS = hdrtoken_wks_to_index(URL_SCHEME_WSS);
- URL_WKSIDX_MAILTO = hdrtoken_wks_to_index(URL_SCHEME_MAILTO);
- URL_WKSIDX_NEWS = hdrtoken_wks_to_index(URL_SCHEME_NEWS);
- URL_WKSIDX_NNTP = hdrtoken_wks_to_index(URL_SCHEME_NNTP);
- URL_WKSIDX_PROSPERO = hdrtoken_wks_to_index(URL_SCHEME_PROSPERO);
- URL_WKSIDX_TELNET = hdrtoken_wks_to_index(URL_SCHEME_TELNET);
- URL_WKSIDX_TUNNEL = hdrtoken_wks_to_index(URL_SCHEME_TUNNEL);
- URL_WKSIDX_WAIS = hdrtoken_wks_to_index(URL_SCHEME_WAIS);
- URL_WKSIDX_PNM = hdrtoken_wks_to_index(URL_SCHEME_PNM);
- URL_WKSIDX_RTSP = hdrtoken_wks_to_index(URL_SCHEME_RTSP);
- URL_WKSIDX_RTSPU = hdrtoken_wks_to_index(URL_SCHEME_RTSPU);
- URL_WKSIDX_MMS = hdrtoken_wks_to_index(URL_SCHEME_MMS);
- URL_WKSIDX_MMSU = hdrtoken_wks_to_index(URL_SCHEME_MMSU);
- URL_WKSIDX_MMST = hdrtoken_wks_to_index(URL_SCHEME_MMST);
-
- URL_LEN_FILE = hdrtoken_wks_to_length(URL_SCHEME_FILE);
- URL_LEN_FTP = hdrtoken_wks_to_length(URL_SCHEME_FTP);
- URL_LEN_GOPHER = hdrtoken_wks_to_length(URL_SCHEME_GOPHER);
- URL_LEN_HTTP = hdrtoken_wks_to_length(URL_SCHEME_HTTP);
- URL_LEN_HTTPS = hdrtoken_wks_to_length(URL_SCHEME_HTTPS);
- URL_LEN_WS = hdrtoken_wks_to_length(URL_SCHEME_WS);
- URL_LEN_WSS = hdrtoken_wks_to_length(URL_SCHEME_WSS);
- URL_LEN_MAILTO = hdrtoken_wks_to_length(URL_SCHEME_MAILTO);
- URL_LEN_NEWS = hdrtoken_wks_to_length(URL_SCHEME_NEWS);
- URL_LEN_NNTP = hdrtoken_wks_to_length(URL_SCHEME_NNTP);
- URL_LEN_PROSPERO = hdrtoken_wks_to_length(URL_SCHEME_PROSPERO);
- URL_LEN_TELNET = hdrtoken_wks_to_length(URL_SCHEME_TELNET);
- URL_LEN_TUNNEL = hdrtoken_wks_to_length(URL_SCHEME_TUNNEL);
- URL_LEN_WAIS = hdrtoken_wks_to_length(URL_SCHEME_WAIS);
- URL_LEN_PNM = hdrtoken_wks_to_length(URL_SCHEME_PNM);
- URL_LEN_RTSP = hdrtoken_wks_to_length(URL_SCHEME_RTSP);
- URL_LEN_RTSPU = hdrtoken_wks_to_length(URL_SCHEME_RTSPU);
- URL_LEN_MMS = hdrtoken_wks_to_length(URL_SCHEME_MMS);
- URL_LEN_MMSU = hdrtoken_wks_to_length(URL_SCHEME_MMSU);
- URL_LEN_MMST = hdrtoken_wks_to_length(URL_SCHEME_MMST);
+ URL_SCHEME_FILE = hdrtoken_string_to_wks_sv("file");
+ URL_SCHEME_FTP = hdrtoken_string_to_wks_sv("ftp");
+ URL_SCHEME_GOPHER = hdrtoken_string_to_wks_sv("gopher");
+ URL_SCHEME_HTTP = hdrtoken_string_to_wks_sv("http");
+ URL_SCHEME_HTTPS = hdrtoken_string_to_wks_sv("https");
+ URL_SCHEME_WSS = hdrtoken_string_to_wks_sv("wss");
+ URL_SCHEME_WS = hdrtoken_string_to_wks_sv("ws");
+ URL_SCHEME_MAILTO = hdrtoken_string_to_wks_sv("mailto");
+ URL_SCHEME_NEWS = hdrtoken_string_to_wks_sv("news");
+ URL_SCHEME_NNTP = hdrtoken_string_to_wks_sv("nntp");
+ URL_SCHEME_PROSPERO = hdrtoken_string_to_wks_sv("prospero");
+ URL_SCHEME_TELNET = hdrtoken_string_to_wks_sv("telnet");
+ URL_SCHEME_TUNNEL = hdrtoken_string_to_wks_sv("tunnel");
+ URL_SCHEME_WAIS = hdrtoken_string_to_wks_sv("wais");
+ URL_SCHEME_PNM = hdrtoken_string_to_wks_sv("pnm");
+ URL_SCHEME_RTSP = hdrtoken_string_to_wks_sv("rtsp");
+ URL_SCHEME_RTSPU = hdrtoken_string_to_wks_sv("rtspu");
+ URL_SCHEME_MMS = hdrtoken_string_to_wks_sv("mms");
+ URL_SCHEME_MMSU = hdrtoken_string_to_wks_sv("mmsu");
+ URL_SCHEME_MMST = hdrtoken_string_to_wks_sv("mmst");
+
+ ink_assert(URL_SCHEME_FILE.c_str() && URL_SCHEME_FTP.c_str() && URL_SCHEME_GOPHER.c_str() && URL_SCHEME_HTTP.c_str() &&
+ URL_SCHEME_HTTPS.c_str() && URL_SCHEME_WS.c_str() && URL_SCHEME_WSS.c_str() && URL_SCHEME_MAILTO.c_str() &&
+ URL_SCHEME_NEWS.c_str() && URL_SCHEME_NNTP.c_str() && URL_SCHEME_PROSPERO.c_str() && URL_SCHEME_TELNET.c_str() &&
+ URL_SCHEME_TUNNEL.c_str() && URL_SCHEME_WAIS.c_str() && URL_SCHEME_PNM.c_str() && URL_SCHEME_RTSP.c_str() &&
+ URL_SCHEME_RTSPU.c_str() && URL_SCHEME_MMS.c_str() && URL_SCHEME_MMSU.c_str() && URL_SCHEME_MMST.c_str());
+
+ URL_WKSIDX_FILE = hdrtoken_wks_to_index(URL_SCHEME_FILE.c_str());
+ URL_WKSIDX_FTP = hdrtoken_wks_to_index(URL_SCHEME_FTP.c_str());
+ URL_WKSIDX_GOPHER = hdrtoken_wks_to_index(URL_SCHEME_GOPHER.c_str());
+ URL_WKSIDX_HTTP = hdrtoken_wks_to_index(URL_SCHEME_HTTP.c_str());
+ URL_WKSIDX_HTTPS = hdrtoken_wks_to_index(URL_SCHEME_HTTPS.c_str());
+ URL_WKSIDX_WS = hdrtoken_wks_to_index(URL_SCHEME_WS.c_str());
+ URL_WKSIDX_WSS = hdrtoken_wks_to_index(URL_SCHEME_WSS.c_str());
+ URL_WKSIDX_MAILTO = hdrtoken_wks_to_index(URL_SCHEME_MAILTO.c_str());
+ URL_WKSIDX_NEWS = hdrtoken_wks_to_index(URL_SCHEME_NEWS.c_str());
+ URL_WKSIDX_NNTP = hdrtoken_wks_to_index(URL_SCHEME_NNTP.c_str());
+ URL_WKSIDX_PROSPERO = hdrtoken_wks_to_index(URL_SCHEME_PROSPERO.c_str());
+ URL_WKSIDX_TELNET = hdrtoken_wks_to_index(URL_SCHEME_TELNET.c_str());
+ URL_WKSIDX_TUNNEL = hdrtoken_wks_to_index(URL_SCHEME_TUNNEL.c_str());
+ URL_WKSIDX_WAIS = hdrtoken_wks_to_index(URL_SCHEME_WAIS.c_str());
+ URL_WKSIDX_PNM = hdrtoken_wks_to_index(URL_SCHEME_PNM.c_str());
+ URL_WKSIDX_RTSP = hdrtoken_wks_to_index(URL_SCHEME_RTSP.c_str());
+ URL_WKSIDX_RTSPU = hdrtoken_wks_to_index(URL_SCHEME_RTSPU.c_str());
+ URL_WKSIDX_MMS = hdrtoken_wks_to_index(URL_SCHEME_MMS.c_str());
+ URL_WKSIDX_MMSU = hdrtoken_wks_to_index(URL_SCHEME_MMSU.c_str());
+ URL_WKSIDX_MMST = hdrtoken_wks_to_index(URL_SCHEME_MMST.c_str());
}
}
@@ -422,16 +381,15 @@ URLImpl::check_strings(HeapCheck *heaps, int num_heaps)
***********************************************************************/
const char *
-URLImpl::set_scheme(HdrHeap *heap, const char *scheme_str, int scheme_wks_idx, int length, bool copy_string)
+URLImpl::set_scheme(HdrHeap *heap, std::string_view value, int scheme_wks_idx, bool copy_string)
{
const char *scheme_wks;
url_called_set(this);
- if (length == 0) {
- scheme_str = nullptr;
+ if (value.empty()) {
+ value = {nullptr, 0};
}
- mime_str_u16_set(heap, std::string_view{scheme_str, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_scheme),
- &(this->m_len_scheme), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_scheme), &(this->m_len_scheme), copy_string);
this->m_scheme_wks_idx = scheme_wks_idx;
if (scheme_wks_idx >= 0) {
@@ -440,9 +398,9 @@ URLImpl::set_scheme(HdrHeap *heap, const char *scheme_str, int scheme_wks_idx, i
scheme_wks = nullptr;
}
- if (scheme_wks == URL_SCHEME_HTTP || scheme_wks == URL_SCHEME_WS) {
+ if (scheme_wks == URL_SCHEME_HTTP.c_str() || scheme_wks == URL_SCHEME_WS.c_str()) {
this->m_url_type = URLType::HTTP;
- } else if (scheme_wks == URL_SCHEME_HTTPS || scheme_wks == URL_SCHEME_WSS) {
+ } else if (scheme_wks == URL_SCHEME_HTTPS.c_str() || scheme_wks == URL_SCHEME_WSS.c_str()) {
this->m_url_type = URLType::HTTPS;
} else {
this->m_url_type = URLType::HTTP;
@@ -455,63 +413,59 @@ URLImpl::set_scheme(HdrHeap *heap, const char *scheme_str, int scheme_wks_idx, i
-------------------------------------------------------------------------*/
void
-URLImpl::set_user(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_user(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- if (length == 0) {
- value = nullptr;
+ if (value.empty()) {
+ value = {nullptr, 0};
}
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_user),
- &(this->m_len_user), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_user), &(this->m_len_user), copy_string);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
void
-URLImpl::set_password(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_password(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- if (length == 0) {
- value = nullptr;
+ if (value.empty()) {
+ value = {nullptr, 0};
}
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_password),
- &(this->m_len_password), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_password), &(this->m_len_password), copy_string);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
void
-URLImpl::set_host(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_host(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- if (length == 0) {
- value = nullptr;
+ if (value.empty()) {
+ value = {nullptr, 0};
}
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_host),
- &(this->m_len_host), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_host), &(this->m_len_host), copy_string);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
void
-URLImpl::set_port(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_port(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- if (length == 0) {
- value = nullptr;
+ if (value.empty()) {
+ value = {nullptr, 0};
}
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_port),
- &(this->m_len_port), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_port), &(this->m_len_port), copy_string);
this->m_port = 0;
- for (int i = 0; i < length; i++) {
- if (!ParseRules::is_digit(value[i])) {
+ for (auto digit : value) {
+ if (!ParseRules::is_digit(digit)) {
break;
}
- this->m_port = this->m_port * 10 + (value[i] - '0');
+ this->m_port = this->m_port * 10 + (digit - '0');
}
}
@@ -539,14 +493,13 @@ URLImpl::set_port(HdrHeap *heap, unsigned int port)
-------------------------------------------------------------------------*/
void
-URLImpl::set_path(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_path(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- if (length == 0) {
- value = nullptr;
+ if (value.empty()) {
+ value = {nullptr, 0};
}
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_path),
- &(this->m_len_path), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_path), &(this->m_len_path), copy_string);
}
/*-------------------------------------------------------------------------
@@ -556,22 +509,20 @@ URLImpl::set_path(HdrHeap *heap, const char *value, int length, bool copy_string
// url_{query|fragment}_set()
void
-URLImpl::set_query(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_query(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_query),
- &(this->m_len_query), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_query), &(this->m_len_query), copy_string);
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
void
-URLImpl::set_fragment(HdrHeap *heap, const char *value, int length, bool copy_string)
+URLImpl::set_fragment(HdrHeap *heap, std::string_view value, bool copy_string)
{
url_called_set(this);
- mime_str_u16_set(heap, std::string_view{value, static_cast<std::string_view::size_type>(length)}, &(this->m_ptr_fragment),
- &(this->m_len_fragment), copy_string);
+ mime_str_u16_set(heap, value, &(this->m_ptr_fragment), &(this->m_len_fragment), copy_string);
}
/*-------------------------------------------------------------------------
@@ -716,46 +667,42 @@ url_string_get_buf(URLImpl *url, char *dstbuf, int dstbuf_size, int *length)
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_scheme(int *length)
+std::string_view
+URLImpl::get_scheme() const noexcept
{
if (this->m_scheme_wks_idx >= 0) {
- *length = hdrtoken_index_to_length(this->m_scheme_wks_idx);
- return hdrtoken_index_to_wks(this->m_scheme_wks_idx);
+ return {hdrtoken_index_to_wks(this->m_scheme_wks_idx),
+ static_cast<std::string_view::size_type>(hdrtoken_index_to_length(this->m_scheme_wks_idx))};
} else {
- *length = this->m_len_scheme;
- return this->m_ptr_scheme;
+ return {this->m_ptr_scheme, static_cast<std::string_view::size_type>(this->m_len_scheme)};
}
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_user(int *length)
+std::string_view
+URLImpl::get_user() const noexcept
{
- *length = this->m_len_user;
- return this->m_ptr_user;
+ return {this->m_ptr_user, static_cast<std::string_view::size_type>(this->m_len_user)};
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_password(int *length)
+std::string_view
+URLImpl::get_password() const noexcept
{
- *length = this->m_len_password;
- return this->m_ptr_password;
+ return {this->m_ptr_password, static_cast<std::string_view::size_type>(this->m_len_password)};
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_host(int *length)
+std::string_view
+URLImpl::get_host() const noexcept
{
- *length = this->m_len_host;
- return this->m_ptr_host;
+ return {this->m_ptr_host, static_cast<std::string_view::size_type>(this->m_len_host)};
}
/*-------------------------------------------------------------------------
@@ -770,31 +717,28 @@ URLImpl::get_port()
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_path(int *length)
+std::string_view
+URLImpl::get_path() const noexcept
{
- *length = this->m_len_path;
- return this->m_ptr_path;
+ return {this->m_ptr_path, static_cast<std::string_view::size_type>(this->m_len_path)};
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_query(int *length)
+std::string_view
+URLImpl::get_query() const noexcept
{
- *length = this->m_len_query;
- return this->m_ptr_query;
+ return {this->m_ptr_query, static_cast<std::string_view::size_type>(this->m_len_query)};
}
/*-------------------------------------------------------------------------
-------------------------------------------------------------------------*/
-const char *
-URLImpl::get_fragment(int *length)
+std::string_view
+URLImpl::get_fragment() const noexcept
{
- *length = this->m_len_fragment;
- return this->m_ptr_fragment;
+ return {this->m_ptr_fragment, static_cast<std::string_view::size_type>(this->m_len_fragment)};
}
/*-------------------------------------------------------------------------
@@ -837,10 +781,10 @@ url_length_get(URLImpl *url, unsigned normalization_flags)
} else if (normalization_flags & URLNormalize::IMPLIED_SCHEME) {
if (URLType::HTTP == url->m_url_type) {
- length += URL_LEN_HTTP + 3;
+ length += static_cast<int>(URL_SCHEME_HTTP.length()) + 3;
} else if (URLType::HTTPS == url->m_url_type) {
- length += URL_LEN_HTTPS + 3;
+ length += static_cast<int>(URL_SCHEME_HTTPS.length()) + 3;
}
}
@@ -914,7 +858,7 @@ url_to_string(URLImpl *url, Arena *arena, int *length)
if (url->m_ptr_scheme) {
memcpy(&str[idx], url->m_ptr_scheme, url->m_len_scheme);
idx += url->m_len_scheme;
- if ((url->m_scheme_wks_idx >= 0) && (hdrtoken_index_to_wks(url->m_scheme_wks_idx) == URL_SCHEME_FILE)) {
+ if ((url->m_scheme_wks_idx >= 0) && (hdrtoken_index_to_wks(url->m_scheme_wks_idx) == URL_SCHEME_FILE.c_str())) {
str[idx++] = ':';
} else {
str[idx++] = ':';
@@ -1173,7 +1117,8 @@ url_parse_scheme(HdrHeap *heap, URLImpl *url, const char **start, const char *en
return ParseResult::ERROR;
}
}
- url->set_scheme(heap, scheme_start, scheme_wks_idx, scheme_end - scheme_start, copy_strings_p);
+ url->set_scheme(heap, std::string_view{scheme_start, static_cast<std::string_view::size_type>(scheme_end - scheme_start)},
+ scheme_wks_idx, copy_strings_p);
}
}
*start = scheme_end;
@@ -1365,9 +1310,9 @@ url_parse_internet(HdrHeap *heap, URLImpl *url, const char **start, char const *
// character past the parse area.
if (user) {
- url->set_user(heap, user.data(), user.size(), copy_strings_p);
+ url->set_user(heap, user, copy_strings_p);
if (passw) {
- url->set_password(heap, passw.data(), passw.size(), copy_strings_p);
+ url->set_password(heap, passw, copy_strings_p);
}
}
@@ -1382,7 +1327,7 @@ url_parse_internet(HdrHeap *heap, URLImpl *url, const char **start, char const *
}
if (!host.empty()) {
if (!verify_host_characters || validate_host_name(host)) {
- url->set_host(heap, host.data(), host.size(), copy_strings_p);
+ url->set_host(heap, host, copy_strings_p);
} else {
return ParseResult::ERROR;
}
@@ -1394,7 +1339,7 @@ url_parse_internet(HdrHeap *heap, URLImpl *url, const char **start, char const *
if (port.empty()) {
return ParseResult::ERROR; // colon w/o port value.
}
- url->set_port(heap, port.data(), port.size(), copy_strings_p);
+ url->set_port(heap, port, copy_strings_p);
}
*start = cur;
return ParseResult::DONE;
@@ -1502,7 +1447,7 @@ done:
}
}
- url->set_path(heap, path_start, path_end - path_start, copy_strings);
+ url->set_path(heap, {path_start, static_cast<std::string_view::size_type>(path_end - path_start)}, copy_strings);
} else if (!nothing_after_host) {
// There was no path set via '/': it is absolutely empty. However, if there
// is no path, query, or fragment after the host, we by convention add a
@@ -1515,14 +1460,15 @@ done:
if (!query_end) {
query_end = cur;
}
- url->set_query(heap, query_start, query_end - query_start, copy_strings);
+ url->set_query(heap, {query_start, static_cast<std::string_view::size_type>(query_end - query_start)}, copy_strings);
}
if (fragment_start) {
// There was a fragment string marked by '#'.
if (!fragment_end) {
fragment_end = cur;
}
- url->set_fragment(heap, fragment_start, fragment_end - fragment_start, copy_strings);
+ url->set_fragment(heap, {fragment_start, static_cast<std::string_view::size_type>(fragment_end - fragment_start)},
+ copy_strings);
}
*start = cur;
@@ -1578,16 +1524,16 @@ url_parse_http_regex(HdrHeap *heap, URLImpl *url, const char **start, const char
port_len = host_end - port - 1; // must compute this first.
host_end = port; // then point at colon.
++port; // drop colon from port.
- url->set_port(heap, port, port_len, copy_strings);
+ url->set_port(heap, {port, static_cast<std::string_view::size_type>(port_len)}, copy_strings);
}
// Now we can set the host.
- url->set_host(heap, base, host_end - base, copy_strings);
+ url->set_host(heap, {base, static_cast<std::string_view::size_type>(host_end - base)}, copy_strings);
}
// path is anything that's left.
if (cur < end) {
- url->set_path(heap, cur, end - cur, copy_strings);
+ url->set_path(heap, {cur, static_cast<std::string_view::size_type>(end - cur)}, copy_strings);
cur = end;
}
*start = cur;
@@ -1620,13 +1566,11 @@ url_print(URLImpl *url, char *buf_start, int buf_length, int *buf_index_inout, i
} else if (normalization_flags & URLNormalize::IMPLIED_SCHEME) {
if (URLType::HTTP == url->m_url_type) {
- TRY(mime_mem_print(std::string_view{URL_SCHEME_HTTP, static_cast<std::string_view::size_type>(URL_LEN_HTTP)}, buf_start,
- buf_length, buf_index_inout, buf_chars_to_skip_inout));
+ TRY(mime_mem_print(std::string_view{URL_SCHEME_HTTP}, buf_start, buf_length, buf_index_inout, buf_chars_to_skip_inout));
scheme_added = true;
} else if (URLType::HTTPS == url->m_url_type) {
- TRY(mime_mem_print(std::string_view{URL_SCHEME_HTTPS, static_cast<std::string_view::size_type>(URL_LEN_HTTPS)}, buf_start,
- buf_length, buf_index_inout, buf_chars_to_skip_inout));
+ TRY(mime_mem_print(std::string_view{URL_SCHEME_HTTPS}, buf_start, buf_length, buf_index_inout, buf_chars_to_skip_inout));
scheme_added = true;
}
}
diff --git a/src/proxy/hdrs/VersionConverter.cc b/src/proxy/hdrs/VersionConverter.cc
index fbf52f391b..02196ddc27 100644
--- a/src/proxy/hdrs/VersionConverter.cc
+++ b/src/proxy/hdrs/VersionConverter.cc
@@ -90,8 +90,7 @@ VersionConverter::_convert_req_from_1_to_2(HTTPHdr &header) const
if (!value.empty()) {
field->value_set(header.m_heap, header.m_mime, value);
} else {
- field->value_set(header.m_heap, header.m_mime,
- std::string_view{URL_SCHEME_HTTPS, static_cast<std::string_view::size_type>(URL_LEN_HTTPS)});
+ field->value_set(header.m_heap, header.m_mime, std::string_view{URL_SCHEME_HTTPS});
}
} else {
ink_abort("initialize HTTP/2 pseudo-headers, no :scheme");
@@ -164,11 +163,11 @@ VersionConverter::_convert_req_from_2_to_1(HTTPHdr &header) const
if (MIMEField *field = header.field_find(PSEUDO_HEADER_METHOD);
field != nullptr && field->value_is_valid(is_control_BIT | is_ws_BIT)) {
auto method{field->value_get()};
- if (method == std::string_view{HTTP_METHOD_CONNECT, static_cast<std::string_view::size_type>(HTTP_LEN_CONNECT)}) {
+ if (method == static_cast<std::string_view>(HTTP_METHOD_CONNECT)) {
is_connect_method = true;
}
- header.method_set(method.data(), method.length());
+ header.method_set(method);
header.field_delete(field);
} else {
return ParseResult::ERROR;
@@ -190,7 +189,7 @@ VersionConverter::_convert_req_from_2_to_1(HTTPHdr &header) const
}
}
- header.m_http->u.req.m_url_impl->set_scheme(header.m_heap, scheme.data(), scheme_wks_idx, scheme.length(), true);
+ header.m_http->u.req.m_url_impl->set_scheme(header.m_heap, scheme, scheme_wks_idx, true);
header.field_delete(field);
} else {
@@ -202,7 +201,7 @@ VersionConverter::_convert_req_from_2_to_1(HTTPHdr &header) const
if (MIMEField *field = header.field_find(PSEUDO_HEADER_AUTHORITY);
field != nullptr && field->value_is_valid(is_control_BIT | is_ws_BIT)) {
auto authority{field->value_get()};
- header.m_http->u.req.m_url_impl->set_host(header.m_heap, authority.data(), authority.length(), true);
+ header.m_http->u.req.m_url_impl->set_host(header.m_heap, authority, true);
if (!is_connect_method) {
MIMEField *host = header.field_find(static_cast<std::string_view>(MIME_FIELD_HOST));
@@ -237,7 +236,7 @@ VersionConverter::_convert_req_from_2_to_1(HTTPHdr &header) const
path.remove_prefix(1);
}
- header.m_http->u.req.m_url_impl->set_path(header.m_heap, path.data(), path.length(), true);
+ header.m_http->u.req.m_url_impl->set_path(header.m_heap, path, true);
header.field_delete(field);
} else {
diff --git a/src/proxy/hdrs/unit_tests/test_HdrHeap.cc b/src/proxy/hdrs/unit_tests/test_HdrHeap.cc
index f02213d1a8..cd52588475 100644
--- a/src/proxy/hdrs/unit_tests/test_HdrHeap.cc
+++ b/src/proxy/hdrs/unit_tests/test_HdrHeap.cc
@@ -42,7 +42,7 @@ TEST_CASE("HdrHeap", "[proxy][hdrheap]")
// Checking that we have no rw heap
CHECK(heap->m_read_write_heap.get() == nullptr);
- url->set_path(heap, buf, next_required_overflow_size, true);
+ url->set_path(heap, {buf, next_required_overflow_size}, true);
// Checking that we've completely consumed the rw heap
CHECK(heap->m_read_write_heap->space_avail() == 0);
@@ -63,7 +63,7 @@ TEST_CASE("HdrHeap", "[proxy][hdrheap]")
}
URLImpl *url2 = url_create(heap);
- url2->set_path(heap, buf2, next_required_overflow_size, true);
+ url2->set_path(heap, {buf2, next_required_overflow_size}, true);
// Checking the current rw heap is next_rw_heap_size bytes
CHECK(heap->m_read_write_heap->total_size() == (uint32_t)next_rw_heap_size);
@@ -92,7 +92,7 @@ TEST_CASE("HdrHeap", "[proxy][hdrheap]")
}
URLImpl *aliased_str_url = url_create(heap);
- aliased_str_url->set_path(heap, buf3, next_required_overflow_size, false); // don't copy this string
+ aliased_str_url->set_path(heap, {buf3, next_required_overflow_size}, false); // don't copy this string
// Checking that the aliased string shows having proper length
CHECK(aliased_str_url->m_len_path == next_required_overflow_size);
// Checking that the aliased string is correctly pointing at buf
diff --git a/src/proxy/hdrs/unit_tests/test_URL.cc b/src/proxy/hdrs/unit_tests/test_URL.cc
index 1a73c21e80..0356d7b42a 100644
--- a/src/proxy/hdrs/unit_tests/test_URL.cc
+++ b/src/proxy/hdrs/unit_tests/test_URL.cc
@@ -744,10 +744,8 @@ TEST_CASE("UrlPathGet", "[url][path_get]")
HdrHeap *heap = new_HdrHeap();
url.create(heap);
url.parse(test_case.uri);
- const char *path;
- int path_len;
- path = url.path_get(&path_len);
- CHECK(std::string_view(path, path_len) == test_case.path);
+ auto path{url.path_get()};
+ CHECK(path == test_case.path);
heap->destroy();
}
}
diff --git a/src/proxy/http/HttpDebugNames.cc b/src/proxy/http/HttpDebugNames.cc
index 829d3469ab..18a124a482 100644
--- a/src/proxy/http/HttpDebugNames.cc
+++ b/src/proxy/http/HttpDebugNames.cc
@@ -72,23 +72,23 @@ HttpDebugNames::get_server_state_name(HttpTransact::ServerState_t state)
const char *
HttpDebugNames::get_method_name(const char *method)
{
- if (method == HTTP_METHOD_CONNECT) {
+ if (method == HTTP_METHOD_CONNECT.c_str()) {
return ("HTTP_METHOD_CONNECT");
- } else if (method == HTTP_METHOD_DELETE) {
+ } else if (method == HTTP_METHOD_DELETE.c_str()) {
return ("HTTP_METHOD_DELETE");
- } else if (method == HTTP_METHOD_GET) {
+ } else if (method == HTTP_METHOD_GET.c_str()) {
return ("HTTP_METHOD_GET");
- } else if (method == HTTP_METHOD_HEAD) {
+ } else if (method == HTTP_METHOD_HEAD.c_str()) {
return ("HTTP_METHOD_HEAD");
- } else if (method == HTTP_METHOD_OPTIONS) {
+ } else if (method == HTTP_METHOD_OPTIONS.c_str()) {
return ("HTTP_METHOD_OPTIONS");
- } else if (method == HTTP_METHOD_POST) {
+ } else if (method == HTTP_METHOD_POST.c_str()) {
return ("HTTP_METHOD_POST");
- } else if (method == HTTP_METHOD_PURGE) {
+ } else if (method == HTTP_METHOD_PURGE.c_str()) {
return ("HTTP_METHOD_PURGE");
- } else if (method == HTTP_METHOD_PUT) {
+ } else if (method == HTTP_METHOD_PUT.c_str()) {
return ("HTTP_METHOD_PUT");
- } else if (method == HTTP_METHOD_TRACE) {
+ } else if (method == HTTP_METHOD_TRACE.c_str()) {
return ("HTTP_METHOD_TRACE");
} else {
return ("HTTP_METHOD_UNKNOWN");
diff --git a/src/proxy/http/HttpSM.cc b/src/proxy/http/HttpSM.cc
index 62d02914f1..c874e605cd 100644
--- a/src/proxy/http/HttpSM.cc
+++ b/src/proxy/http/HttpSM.cc
@@ -485,26 +485,25 @@ HttpSM::setup_blind_tunnel_port()
{
NetVConnection *netvc = _ua.get_txn()->get_netvc();
ink_release_assert(netvc);
- int host_len;
// This applies to both the TLS and non TLS cases
- if (!t_state.hdr_info.client_request.url_get()->host_get(&host_len)) {
+ if (t_state.hdr_info.client_request.url_get()->host_get().empty()) {
// the URL object has not been created in the start of the transaction. Hence, we need to create the URL here
URL u;
t_state.hdr_info.client_request.create(HTTPType::REQUEST);
- t_state.hdr_info.client_request.method_set(HTTP_METHOD_CONNECT, HTTP_LEN_CONNECT);
+ t_state.hdr_info.client_request.method_set(static_cast<std::string_view>(HTTP_METHOD_CONNECT));
t_state.hdr_info.client_request.url_create(&u);
- u.scheme_set(URL_SCHEME_TUNNEL, URL_LEN_TUNNEL);
+ u.scheme_set(std::string_view{URL_SCHEME_TUNNEL});
t_state.hdr_info.client_request.url_set(&u);
}
TLSTunnelSupport *tts = nullptr;
if (!_ua.get_txn()->is_outbound_transparent() && (tts = netvc->get_service<TLSTunnelSupport>())) {
- if (!t_state.hdr_info.client_request.url_get()->host_get(&host_len)) {
+ if (t_state.hdr_info.client_request.url_get()->host_get().empty()) {
if (tts->has_tunnel_destination()) {
auto tunnel_host = tts->get_tunnel_host();
- t_state.hdr_info.client_request.url_get()->host_set(tunnel_host.data(), tunnel_host.size());
+ t_state.hdr_info.client_request.url_get()->host_set(tunnel_host);
if (tts->get_tunnel_port() > 0) {
t_state.tunnel_port_is_dynamic = tts->tunnel_port_is_dynamic();
t_state.hdr_info.client_request.url_get()->port_set(tts->get_tunnel_port());
@@ -516,7 +515,7 @@ HttpSM::setup_blind_tunnel_port()
if (auto *snis = netvc->get_service<TLSSNISupport>(); snis) {
server_name = snis->get_sni_server_name();
}
- t_state.hdr_info.client_request.url_get()->host_set(server_name, strlen(server_name));
+ t_state.hdr_info.client_request.url_get()->host_set({server_name});
t_state.hdr_info.client_request.url_get()->port_set(netvc->get_local_port());
}
}
@@ -524,7 +523,7 @@ HttpSM::setup_blind_tunnel_port()
char new_host[INET6_ADDRSTRLEN];
ats_ip_ntop(netvc->get_local_addr(), new_host, sizeof(new_host));
- t_state.hdr_info.client_request.url_get()->host_set(new_host, strlen(new_host));
+ t_state.hdr_info.client_request.url_get()->host_set({new_host});
t_state.hdr_info.client_request.url_get()->port_set(netvc->get_local_port());
}
t_state.api_next_action = HttpTransact::StateMachineAction_t::API_TUNNEL_START;
@@ -740,8 +739,7 @@ HttpSM::state_read_client_request_header(int event, void *data)
(t_state.hdr_info.client_request.method_get_wksidx() == HTTP_WKSIDX_POST ||
t_state.hdr_info.client_request.method_get_wksidx() == HTTP_WKSIDX_PUT)) {
auto expect{t_state.hdr_info.client_request.value_get(static_cast<std::string_view>(MIME_FIELD_EXPECT))};
- if (strcasecmp(expect, std::string_view{HTTP_VALUE_100_CONTINUE,
- static_cast<std::string_view::size_type>(HTTP_LEN_100_CONTINUE)}) == 0) {
+ if (strcasecmp(expect, static_cast<std::string_view>(HTTP_VALUE_100_CONTINUE)) == 0) {
// When receive an "Expect: 100-continue" request from client, ATS sends a "100 Continue" response to client
// immediately, before receive the real response from original server.
if (t_state.http_config_param->send_100_continue_response) {
@@ -1379,16 +1377,16 @@ plugins required to work with sni_routing.
URL u;
t_state.hdr_info.client_request.create(HTTPType::REQUEST);
- t_state.hdr_info.client_request.method_set(HTTP_METHOD_CONNECT, HTTP_LEN_CONNECT);
+ t_state.hdr_info.client_request.method_set(static_cast<std::string_view>(HTTP_METHOD_CONNECT));
t_state.hdr_info.client_request.url_create(&u);
- u.scheme_set(URL_SCHEME_TUNNEL, URL_LEN_TUNNEL);
+ u.scheme_set(std::string_view{URL_SCHEME_TUNNEL});
t_state.hdr_info.client_request.url_set(&u);
NetVConnection *netvc = _ua.get_txn()->get_netvc();
if (auto tts = netvc->get_service<TLSTunnelSupport>(); tts) {
if (tts->has_tunnel_destination()) {
auto tunnel_host = tts->get_tunnel_host();
- t_state.hdr_info.client_request.url_get()->host_set(tunnel_host.data(), tunnel_host.size());
+ t_state.hdr_info.client_request.url_get()->host_set(tunnel_host);
ushort tunnel_port = tts->get_tunnel_port();
if (tunnel_port > 0) {
t_state.hdr_info.client_request.url_get()->port_set(tunnel_port);
@@ -1400,7 +1398,7 @@ plugins required to work with sni_routing.
if (auto *snis = netvc->get_service<TLSSNISupport>(); snis) {
server_name = snis->get_sni_server_name();
}
- t_state.hdr_info.client_request.url_get()->host_set(server_name, strlen(server_name));
+ t_state.hdr_info.client_request.url_get()->host_set({server_name});
t_state.hdr_info.client_request.url_get()->port_set(netvc->get_local_port());
}
}
@@ -4470,7 +4468,7 @@ HttpSM::do_remap_request(bool run_inline)
}
// Set values
- t_state.unmapped_url.host_set(host_name.data(), host_name.length());
+ t_state.unmapped_url.host_set(host_name);
if (port >= 0) {
t_state.unmapped_url.port_set(port);
}
@@ -5870,9 +5868,7 @@ HttpSM::mark_host_failure(ResolveInfo *info, ts_time time_down)
if (auto [down, fail_count] = info->active->increment_fail_count(time_down, t_state.txn_conf->connect_attempts_rr_retries);
down) {
char *url_str = t_state.hdr_info.client_request.url_string_get_ref(nullptr);
- int host_len;
- const char *host_name_ptr = t_state.unmapped_url.host_get(&host_len);
- std::string_view host_name{host_name_ptr, static_cast<size_t>(host_len)};
+ std::string_view host_name{t_state.unmapped_url.host_get()};
swoc::bwprint(error_bw_buffer, "CONNECT : {::s} connecting to {} for host='{}' url='{}' fail_count='{}' marking down",
swoc::bwf::Errno(t_state.current.server->connect_result), t_state.current.server->dst_addr, host_name,
swoc::bwf::FirstOf(url_str, "<none>"), fail_count);
@@ -6678,9 +6674,8 @@ HttpSM::attach_server_session()
!t_state.hdr_info.server_request.presence(MIME_PRESENCE_TRANSFER_ENCODING)) {
// Stuff in a TE setting so we treat this as chunked, sort of.
t_state.server_info.transfer_encoding = HttpTransact::TransferEncoding_t::CHUNKED;
- t_state.hdr_info.server_request.value_append(
- static_cast<std::string_view>(MIME_FIELD_TRANSFER_ENCODING),
- std::string_view{HTTP_VALUE_CHUNKED, static_cast<std::string_view::size_type>(HTTP_LEN_CHUNKED)}, true);
+ t_state.hdr_info.server_request.value_append(static_cast<std::string_view>(MIME_FIELD_TRANSFER_ENCODING),
+ static_cast<std::string_view>(HTTP_VALUE_CHUNKED), true);
}
}
}
@@ -8422,10 +8417,7 @@ HttpSM::redirect_request(const char *arg_redirect_url, const int arg_redirect_le
redirectUrl.parse(arg_redirect_url, arg_redirect_len);
{
- int _scheme_len = -1;
- int _host_len = -1;
- if (redirectUrl.scheme_get(&_scheme_len) == nullptr && redirectUrl.host_get(&_host_len) != nullptr &&
- arg_redirect_url[0] != '/') {
+ if (redirectUrl.scheme_get().empty() && !redirectUrl.host_get().empty() && arg_redirect_url[0] != '/') {
// RFC7230 § 5.5
// The redirect URL lacked a scheme and so it is a relative URL.
// The redirect URL did not begin with a slash, so we parsed some or all
@@ -8500,16 +8492,14 @@ HttpSM::redirect_request(const char *arg_redirect_url, const int arg_redirect_le
// check to see if the client request passed a host header, if so copy the host and port from the redirect url and
// make a new host header
if (t_state.hdr_info.client_request.presence(MIME_PRESENCE_HOST)) {
- int host_len;
- const char *host = clientUrl.host_get(&host_len);
+ auto host{clientUrl.host_get()};
+ auto host_len{static_cast<int>(host.length())};
- if (host != nullptr) {
- int port = clientUrl.port_get();
- int redirectSchemeLen;
- const char *redirectScheme = clientUrl.scheme_get(&redirectSchemeLen);
+ if (!host.empty()) {
+ int port = clientUrl.port_get();
- if (redirectScheme == nullptr) {
- clientUrl.scheme_set(scheme_str, scheme_len);
+ if (auto redirectScheme{clientUrl.scheme_get()}; redirectScheme.empty()) {
+ clientUrl.scheme_set({scheme_str, static_cast<std::string_view::size_type>(scheme_len)});
SMDbg(dbg_ctl_http_redirect, "URL without scheme");
}
@@ -8526,12 +8516,11 @@ HttpSM::redirect_request(const char *arg_redirect_url, const int arg_redirect_le
if (!noPortInHost) {
char buf[host_len + 7]; // 5 + 1 + 1 ("12345" + ':' + '\0')
- host_len = snprintf(buf, host_len + 7, "%.*s:%d", host_len, host, port);
+ host_len = snprintf(buf, host_len + 7, "%.*s:%d", host_len, host.data(), port);
t_state.hdr_info.client_request.value_set(static_cast<std::string_view>(MIME_FIELD_HOST),
std::string_view{buf, static_cast<std::string_view::size_type>(host_len)});
} else {
- t_state.hdr_info.client_request.value_set(static_cast<std::string_view>(MIME_FIELD_HOST),
- std::string_view{host, static_cast<std::string_view::size_type>(host_len)});
+ t_state.hdr_info.client_request.value_set(static_cast<std::string_view>(MIME_FIELD_HOST), host);
}
t_state.hdr_info.client_request.m_target_cached = false;
t_state.hdr_info.server_request.m_target_cached = false;
@@ -8574,15 +8563,19 @@ HttpSM::redirect_request(const char *arg_redirect_url, const int arg_redirect_le
// Cleanup of state etc.
url_nuke_proxy_stuff(clientUrl.m_url_impl);
url_nuke_proxy_stuff(t_state.hdr_info.client_request.m_url_cached.m_url_impl);
- t_state.hdr_info.client_request.method_set(origMethod, std::min(origMethod_len, static_cast<int>(sizeof(origMethod))));
+ t_state.hdr_info.client_request.method_set(
+ std::string_view{origMethod, std::min(static_cast<std::string_view::size_type>(origMethod_len), sizeof(origMethod))});
t_state.hdr_info.client_request.m_target_cached = false;
t_state.hdr_info.server_request.m_target_cached = false;
- clientUrl.scheme_set(scheme_str, scheme_len);
+ clientUrl.scheme_set({scheme_str, static_cast<std::string_view::size_type>(scheme_len)});
if (isRedirectUrlOriginForm) {
// build the rest of the effictive URL: the authority part
- clientUrl.user_set(origUrl.m_url_impl->m_ptr_user, origUrl.m_url_impl->m_len_user);
- clientUrl.password_set(origUrl.m_url_impl->m_ptr_password, origUrl.m_url_impl->m_len_password);
- clientUrl.host_set(origUrl.m_url_impl->m_ptr_host, origUrl.m_url_impl->m_len_host);
+ clientUrl.user_set(
+ {origUrl.m_url_impl->m_ptr_user, static_cast<std::string_view::size_type>(origUrl.m_url_impl->m_len_user)});
+ clientUrl.password_set(
+ {origUrl.m_url_impl->m_ptr_password, static_cast<std::string_view::size_type>(origUrl.m_url_impl->m_len_password)});
+ clientUrl.host_set(
+ {origUrl.m_url_impl->m_ptr_host, static_cast<std::string_view::size_type>(origUrl.m_url_impl->m_len_host)});
clientUrl.port_set(origUrl.port_get());
}
} else {
diff --git a/src/proxy/http/HttpTransact.cc b/src/proxy/http/HttpTransact.cc
index c4542f64e4..778c97d4fa 100644
--- a/src/proxy/http/HttpTransact.cc
+++ b/src/proxy/http/HttpTransact.cc
@@ -766,7 +766,7 @@ do_cookies_prevent_caching(int cookies_conf, HTTPHdr *request, HTTPHdr *response
// Furthermore, if there is a Set-Cookie header, then
// Cache-Control must be set.
if (static_cast<CookiesConfig>(cookies_conf) == CookiesConfig::CACHE_ALL_BUT_TEXT_EXT &&
- ((!response->presence(MIME_PRESENCE_SET_COOKIE)) || response->is_cache_control_set(HTTP_VALUE_PUBLIC))) {
+ ((!response->presence(MIME_PRESENCE_SET_COOKIE)) || response->is_cache_control_set(HTTP_VALUE_PUBLIC.c_str()))) {
return false;
}
return true;
@@ -932,9 +932,7 @@ HttpTransact::OriginDown(State *s)
build_error_response(s, HTTPStatus::BAD_GATEWAY, "Origin Server Marked Down", "connect#failed_connect");
Metrics::Counter::increment(http_rsb.down_server_no_requests);
char *url_str = s->hdr_info.client_request.url_string_get_ref(nullptr);
- int host_len;
- const char *host_name_ptr = s->unmapped_url.host_get(&host_len);
- std::string_view host_name{host_name_ptr, size_t(host_len)};
+ std::string_view host_name{s->unmapped_url.host_get()};
swoc::bwprint(error_bw_buffer, "CONNECT: down server no request to {} for host='{}' url='{}'", s->current.server->dst_addr,
host_name, swoc::bwf::FirstOf(url_str, "<none>"));
Log::error("%s", error_bw_buffer.c_str());
@@ -961,9 +959,9 @@ HttpTransact::HandleBlindTunnel(State *s)
bootstrap_state_variables_from_request(s, &s->hdr_info.client_request);
if (dbg_ctl_http_trans.on()) {
- int host_len;
- const char *host = s->hdr_info.client_request.url_get()->host_get(&host_len);
- TxnDbg(dbg_ctl_http_trans, "destination set to %.*s:%d", host_len, host, s->hdr_info.client_request.url_get()->port_get());
+ auto host{s->hdr_info.client_request.url_get()->host_get()};
+ TxnDbg(dbg_ctl_http_trans, "destination set to %.*s:%d", static_cast<int>(host.length()), host.data(),
+ s->hdr_info.client_request.url_get()->port_get());
}
// Set the mode to tunnel so that we don't lookup the cache
@@ -1352,10 +1350,10 @@ HttpTransact::handle_websocket_upgrade_pre_remap(State *s)
URL *url = s->hdr_info.client_request.url_get();
if (url->scheme_get_wksidx() == URL_WKSIDX_HTTP) {
TxnDbg(dbg_ctl_http_trans_websocket_upgrade_pre_remap, "Changing scheme to WS for remapping.");
- url->scheme_set(URL_SCHEME_WS, URL_LEN_WS);
+ url->scheme_set(std::string_view{URL_SCHEME_WS});
} else if (url->scheme_get_wksidx() == URL_WKSIDX_HTTPS) {
TxnDbg(dbg_ctl_http_trans_websocket_upgrade_pre_remap, "Changing scheme to WSS for remapping.");
- url->scheme_set(URL_SCHEME_WSS, URL_LEN_WSS);
+ url->scheme_set(std::string_view{URL_SCHEME_WSS});
} else {
TxnDbg(dbg_ctl_http_trans_websocket_upgrade_pre_remap, "Invalid scheme for websocket upgrade");
build_error_response(s, HTTPStatus::BAD_REQUEST, "Invalid Upgrade Request", "request#syntax_error");
@@ -1415,10 +1413,10 @@ HttpTransact::ModifyRequest(State *s)
s->method = request.method_get_wksidx();
if (scheme < 0 && s->method != HTTP_WKSIDX_CONNECT) {
if (s->client_info.port_attribute == HttpProxyPort::TRANSPORT_SSL) {
- url->scheme_set(URL_SCHEME_HTTPS, URL_LEN_HTTPS);
+ url->scheme_set(std::string_view{URL_SCHEME_HTTPS});
s->orig_scheme = URL_WKSIDX_HTTPS;
} else {
- url->scheme_set(URL_SCHEME_HTTP, URL_LEN_HTTP);
+ url->scheme_set(std::string_view{URL_SCHEME_HTTP});
s->orig_scheme = URL_WKSIDX_HTTP;
}
}
@@ -1572,7 +1570,7 @@ HttpTransact::HandleRequest(State *s)
if (expect != nullptr) {
auto expect_hdr_val{expect->value_get()};
- if (ptr_len_casecmp(expect_hdr_val.data(), expect_hdr_val.length(), HTTP_VALUE_100_CONTINUE, HTTP_LEN_100_CONTINUE) == 0) {
+ if (strcasecmp(expect_hdr_val, static_cast<std::string_view>(HTTP_VALUE_100_CONTINUE)) == 0) {
// Let's error out this request.
TxnDbg(dbg_ctl_http_trans, "Client sent a post expect: 100-continue, sending 405.");
Metrics::Counter::increment(http_rsb.disallowed_post_100_continue);
@@ -2148,10 +2146,10 @@ HttpTransact::DecideCacheLookup(State *s)
if (auto [field, host, port_sv]{incoming_request->get_host_port_values()}; field != nullptr) {
int port = 0;
if (!port_sv.empty()) {
- s->cache_info.lookup_url->host_set(host.data(), static_cast<int>(host.length()));
+ s->cache_info.lookup_url->host_set(host);
port = ink_atoi(port_sv.data(), static_cast<int>(port_sv.length()));
} else {
- s->cache_info.lookup_url->host_set(host.data(), static_cast<int>(host.length()));
+ s->cache_info.lookup_url->host_set(host);
}
s->cache_info.lookup_url->port_set(port);
}
@@ -2260,7 +2258,7 @@ HttpTransact::HandlePushResponseHdr(State *s)
// We need to create the request header storing in the cache
s->hdr_info.server_request.create(HTTPType::REQUEST);
s->hdr_info.server_request.copy(&s->hdr_info.client_request);
- s->hdr_info.server_request.method_set(HTTP_METHOD_GET, HTTP_LEN_GET);
+ s->hdr_info.server_request.method_set(static_cast<std::string_view>(HTTP_METHOD_GET));
s->hdr_info.server_request.value_set("X-Inktomi-Source"sv, "http PUSH"sv);
dump_header(dbg_ctl_http_hdrs, &s->hdr_info.server_response, s->state_machine_id(), "Pushed Response Header");
@@ -2441,7 +2439,7 @@ HttpTransact::issue_revalidate(State *s)
ink_assert(GET_VIA_STRING(VIA_DETAIL_CACHE_LOOKUP) != ' ');
if (s->www_auth_content == CacheAuth_t::FRESH) {
- s->hdr_info.server_request.method_set(HTTP_METHOD_HEAD, HTTP_LEN_HEAD);
+ s->hdr_info.server_request.method_set(static_cast<std::string_view>(HTTP_METHOD_HEAD));
// The document is fresh in cache and we just want to see if the
// the client has the right credentials
// this cache action is just to get us into the hcoofsr function
@@ -2484,7 +2482,8 @@ HttpTransact::issue_revalidate(State *s)
// that case here.
bool no_cache_in_request = false;
- if (s->hdr_info.client_request.is_pragma_no_cache_set() || s->hdr_info.client_request.is_cache_control_set(HTTP_VALUE_NO_CACHE)) {
+ if (s->hdr_info.client_request.is_pragma_no_cache_set() ||
+ s->hdr_info.client_request.is_cache_control_set(HTTP_VALUE_NO_CACHE.c_str())) {
TxnDbg(dbg_ctl_http_trans, "no-cache header directive in request, folks");
no_cache_in_request = true;
}
@@ -3297,7 +3296,7 @@ HttpTransact::HandleCacheOpenReadMiss(State *s)
HTTPHdr *h = &s->hdr_info.client_request;
- if (!h->is_cache_control_set(HTTP_VALUE_ONLY_IF_CACHED)) {
+ if (!h->is_cache_control_set(HTTP_VALUE_ONLY_IF_CACHED.c_str())) {
// Initialize the server_info structure if we haven't been through DNS
// Otherwise, the http_version will not be initialized
if (!s->current.server || !s->current.server->dst_addr.isValid()) {
@@ -3802,13 +3801,11 @@ HttpTransact::error_log_connection_failure(State *s, ServerState_t conn_state)
ats_ip_nptop(&s->current.server->dst_addr.sa, addrbuf, sizeof(addrbuf)));
if (s->current.server->had_connect_fail()) {
- char *url_str = s->hdr_info.client_request.url_string_get(&s->arena);
- int host_len = 0;
- const char *host_name_ptr = "";
+ char *url_str = s->hdr_info.client_request.url_string_get(&s->arena);
+ std::string_view host_name{};
if (s->unmapped_url.valid()) {
- host_name_ptr = s->unmapped_url.host_get(&host_len);
+ host_name = s->unmapped_url.host_get();
}
- std::string_view host_name{host_name_ptr, size_t(host_len)};
swoc::bwprint(error_bw_buffer,
"CONNECT: attempt fail [{}] to {} for host='{}' "
"connection_result={::s} error={::s} retry_attempts={} url='{}'",
@@ -4766,7 +4763,7 @@ HttpTransact::merge_and_update_headers_for_cache_update(State *s)
s->cache_info.object_store.request_get()->url_set(s_url->valid() ? s_url : s->hdr_info.client_request.url_get());
if (s->cache_info.object_store.request_get()->method_get_wksidx() == HTTP_WKSIDX_HEAD) {
- s->cache_info.object_store.request_get()->method_set(HTTP_METHOD_GET, HTTP_LEN_GET);
+ s->cache_info.object_store.request_get()->method_set(static_cast<std::string_view>(HTTP_METHOD_GET));
}
if (s->api_modifiable_cached_resp) {
@@ -4944,7 +4941,7 @@ HttpTransact::set_headers_for_cache_write(State *s, HTTPInfo *cache_info, HTTPHd
}
if (s->api_server_request_body_set) {
- cache_info->request_get()->method_set(HTTP_METHOD_GET, HTTP_LEN_GET);
+ cache_info->request_get()->method_set(static_cast<std::string_view>(HTTP_METHOD_GET));
}
// Set-Cookie should not be put in the cache to prevent
@@ -5386,9 +5383,8 @@ HttpTransact::check_request_validity(State *s, HTTPHdr *incoming_hdr)
} else {
// Stuff in a TE setting so we treat this as chunked, sort of.
s->client_info.transfer_encoding = HttpTransact::TransferEncoding_t::CHUNKED;
- incoming_hdr->value_append(
- static_cast<std::string_view>(MIME_FIELD_TRANSFER_ENCODING),
- std::string_view{HTTP_VALUE_CHUNKED, static_cast<std::string_view::size_type>(HTTP_LEN_CHUNKED)}, true);
+ incoming_hdr->value_append(static_cast<std::string_view>(MIME_FIELD_TRANSFER_ENCODING),
+ static_cast<std::string_view>(HTTP_VALUE_CHUNKED), true);
}
}
if (HTTP_UNDEFINED_CL == s->hdr_info.request_content_length) {
@@ -5418,7 +5414,7 @@ HttpTransact::check_request_validity(State *s, HTTPHdr *incoming_hdr)
while (te_raw) {
te_val = http_parse_te(te_raw, te_raw_len, &s->arena);
- if (te_val->encoding == HTTP_VALUE_IDENTITY) {
+ if (te_val->encoding == HTTP_VALUE_IDENTITY.c_str()) {
if (te_val->qvalue <= 0.0) {
s->arena.free(te_val, sizeof(HTTPValTE));
return RequestError_t::UNACCEPTABLE_TE_REQUIRED;
@@ -5450,7 +5446,7 @@ HttpTransact::set_client_request_state(State *s, HTTPHdr *incoming_hdr)
while (enc_value) {
const char *wks_value = hdrtoken_string_to_wks(enc_value, enc_val_len);
- if (wks_value == HTTP_VALUE_CHUNKED) {
+ if (wks_value == HTTP_VALUE_CHUNKED.c_str()) {
s->client_info.transfer_encoding = TransferEncoding_t::CHUNKED;
break;
}
@@ -5681,12 +5677,12 @@ HttpTransact::initialize_state_variables_from_request(State *s, HTTPHdr *obsolet
TxnDbg(dbg_ctl_http_trans, "Switching WS next hop scheme to http.");
s->next_hop_scheme = URL_WKSIDX_HTTP;
s->scheme = URL_WKSIDX_HTTP;
- // s->request_data.hdr->url_get()->scheme_set(URL_SCHEME_HTTP, URL_LEN_HTTP);
+ // s->request_data.hdr->url_get()->scheme_set(std::string_view{URL_SCHEME_HTTP});
} else if (s->next_hop_scheme == URL_WKSIDX_WSS) {
TxnDbg(dbg_ctl_http_trans, "Switching WSS next hop scheme to https.");
s->next_hop_scheme = URL_WKSIDX_HTTPS;
s->scheme = URL_WKSIDX_HTTPS;
- // s->request_data.hdr->url_get()->scheme_set(URL_SCHEME_HTTPS, URL_LEN_HTTPS);
+ // s->request_data.hdr->url_get()->scheme_set(std::string_view{URL_SCHEME_HTTPS});
} else {
Error("Scheme doesn't match websocket...!");
}
@@ -5829,7 +5825,7 @@ HttpTransact::initialize_state_variables_from_response(State *s, HTTPHdr *incomi
while (enc_value) {
const char *wks_value = hdrtoken_string_to_wks(enc_value, enc_val_len);
- if (wks_value == HTTP_VALUE_CHUNKED && !is_response_body_precluded(status_code, s->method)) {
+ if (wks_value == HTTP_VALUE_CHUNKED.c_str() && !is_response_body_precluded(status_code, s->method)) {
TxnDbg(dbg_ctl_http_hdrs, "transfer encoding: chunked!");
s->current.server->transfer_encoding = TransferEncoding_t::CHUNKED;
@@ -5990,8 +5986,6 @@ HttpTransact::url_looks_dynamic(URL *url)
{
const char *p_start, *p, *t;
static const char *asp = ".asp";
- const char *part;
- int part_length;
if (url->scheme_get_wksidx() != URL_WKSIDX_HTTP && url->scheme_get_wksidx() != URL_WKSIDX_HTTPS) {
return false;
@@ -6000,20 +5994,19 @@ HttpTransact::url_looks_dynamic(URL *url)
// (1) If URL contains query stuff in it, call it dynamic //
////////////////////////////////////////////////////////////
- part = url->query_get(&part_length);
- if (part != nullptr) {
+ if (!url->query_get().empty()) {
return true;
}
///////////////////////////////////////////////
// (2) If path ends in "asp" call it dynamic //
///////////////////////////////////////////////
- part = url->path_get(&part_length);
- if (part) {
- p = &part[part_length - 1];
+ auto path{url->path_get()};
+ if (path.data()) {
+ p = &path[path.length() - 1];
t = &asp[3];
- while (p != part) {
+ while (p != path.data()) {
if (ParseRules::ink_tolower(*p) == ParseRules::ink_tolower(*t)) {
p -= 1;
t -= 1;
@@ -6029,8 +6022,8 @@ HttpTransact::url_looks_dynamic(URL *url)
// (3) If the path of the url contains "cgi", call it dynamic. //
/////////////////////////////////////////////////////////////////
- if (part && part_length >= 3) {
- for (p_start = part; p_start <= &part[part_length - 3]; p_start++) {
+ if (path.data() && path.length() >= 3) {
+ for (p_start = path.data(); p_start <= &path[path.length() - 3]; p_start++) {
if (((p_start[0] == 'c') || (p_start[0] == 'C')) && ((p_start[1] == 'g') || (p_start[1] == 'G')) &&
((p_start[2] == 'i') || (p_start[2] == 'I'))) {
return (true);
@@ -6954,7 +6947,7 @@ HttpTransact::handle_response_keep_alive_headers(State *s, HTTPVersion ver, HTTP
(s->source == Source_t::TRANSFORM && s->hdr_info.trust_response_cl == false))) {
s->client_info.receive_chunked_response = true;
heads->value_append(static_cast<std::string_view>(MIME_FIELD_TRANSFER_ENCODING),
- std::string_view{HTTP_VALUE_CHUNKED, static_cast<std::string_view::size_type>(HTTP_LEN_CHUNKED)}, true);
+ static_cast<std::string_view>(HTTP_VALUE_CHUNKED), true);
} else {
s->client_info.receive_chunked_response = false;
}
@@ -7075,7 +7068,7 @@ HttpTransact::does_client_request_permit_cached_response(const OverridableHttpCo
////////////////////////////////////////////////////////////////////////
if (!c->ignore_client_no_cache) {
- if (h->is_cache_control_set(HTTP_VALUE_NO_CACHE)) {
+ if (h->is_cache_control_set(HTTP_VALUE_NO_CACHE.c_str())) {
return (false);
}
if (h->is_pragma_no_cache_set()) {
@@ -7094,7 +7087,7 @@ HttpTransact::does_client_request_permit_cached_response(const OverridableHttpCo
bool
HttpTransact::does_client_request_permit_dns_caching(CacheControlResult *c, HTTPHdr *h)
{
- if (h->is_pragma_no_cache_set() && h->is_cache_control_set(HTTP_VALUE_NO_CACHE) && (!c->ignore_client_no_cache)) {
+ if (h->is_pragma_no_cache_set() && h->is_cache_control_set(HTTP_VALUE_NO_CACHE.c_str()) && (!c->ignore_client_no_cache)) {
return (false);
}
return (true);
@@ -7107,7 +7100,7 @@ HttpTransact::does_client_request_permit_storing(CacheControlResult *c, HTTPHdr
// If aren't ignoring client's cache directives, meet client's wishes //
////////////////////////////////////////////////////////////////////////
if (!c->ignore_client_no_cache) {
- if (h->is_cache_control_set(HTTP_VALUE_NO_STORE)) {
+ if (h->is_cache_control_set(HTTP_VALUE_NO_STORE.c_str())) {
return (false);
}
}
@@ -7482,12 +7475,12 @@ HttpTransact::AuthenticationNeeded(const OverridableHttpConfigParams *p, HTTPHdr
///////////////////////////////////////////////////////////////////////
if ((p->cache_ignore_auth == 0) && client_request->presence(MIME_PRESENCE_AUTHORIZATION)) {
- if (obj_response->is_cache_control_set(HTTP_VALUE_MUST_REVALIDATE) ||
- obj_response->is_cache_control_set(HTTP_VALUE_PROXY_REVALIDATE)) {
+ if (obj_response->is_cache_control_set(HTTP_VALUE_MUST_REVALIDATE.c_str()) ||
+ obj_response->is_cache_control_set(HTTP_VALUE_PROXY_REVALIDATE.c_str())) {
return Authentication_t::MUST_REVALIDATE;
- } else if (obj_response->is_cache_control_set(HTTP_VALUE_PROXY_REVALIDATE)) {
+ } else if (obj_response->is_cache_control_set(HTTP_VALUE_PROXY_REVALIDATE.c_str())) {
return Authentication_t::MUST_REVALIDATE;
- } else if (obj_response->is_cache_control_set(HTTP_VALUE_PUBLIC)) {
+ } else if (obj_response->is_cache_control_set(HTTP_VALUE_PUBLIC.c_str())) {
return Authentication_t::SUCCESS;
} else {
if (obj_response->field_find("@WWW-Auth"sv) && client_request->method_get_wksidx() == HTTP_WKSIDX_GET) {
@@ -7714,25 +7707,24 @@ HttpTransact::build_request(State *s, HTTPHdr *base_request, HTTPHdr *outgoing_r
URL *url = outgoing_request->url_get();
// Remove fragment from upstream URL
- url->fragment_set(nullptr, 0);
+ url->fragment_set({nullptr, 0});
// Check whether a Host header field is missing from a 1.0 or 1.1 request.
if (outgoing_version != HTTP_0_9 && !outgoing_request->presence(MIME_PRESENCE_HOST)) {
- int host_len;
- const char *host = url->host_get(&host_len);
+ auto host{url->host_get()};
// Add a ':port' to the HOST header if the request is not going
// to the default port.
int port = url->port_get();
if (port != url_canonicalize_port(URLType::HTTP, 0)) {
+ auto host_len{static_cast<int>(host.length())};
char *buf = static_cast<char *>(alloca(host_len + 15));
- memcpy(buf, host, host_len);
+ memcpy(buf, host.data(), host_len);
host_len += snprintf(buf + host_len, 15, ":%d", port);
outgoing_request->value_set(static_cast<std::string_view>(MIME_FIELD_HOST),
std::string_view{buf, static_cast<std::string_view::size_type>(host_len)});
} else {
- outgoing_request->value_set(static_cast<std::string_view>(MIME_FIELD_HOST),
- std::string_view{host, static_cast<std::string_view::size_type>(host_len)});
+ outgoing_request->value_set(static_cast<std::string_view>(MIME_FIELD_HOST), host);
}
}
@@ -7756,9 +7748,8 @@ HttpTransact::build_request(State *s, HTTPHdr *base_request, HTTPHdr *outgoing_r
// If we are going to a peer cache and want to use the pristine URL, get it from the base request
if (s->parent_result.use_pristine) {
- int tmp_len = 0;
- auto tmp_char = s->unmapped_url.host_get(&tmp_len);
- outgoing_request->url_get()->host_set(tmp_char, tmp_len);
+ auto host{s->unmapped_url.host_get()};
+ outgoing_request->url_get()->host_set(host);
}
// If the response is most likely not cacheable, eg, request with Authorization,
@@ -8168,8 +8159,6 @@ HttpTransact::build_redirect_response(State *s)
{
TxnDbg(dbg_ctl_http_redirect, "Entering HttpTransact::build_redirect_response");
URL *u;
- const char *old_host;
- int old_host_len;
const char *new_url = nullptr;
int new_url_len;
char *to_free = nullptr;
@@ -8184,9 +8173,9 @@ HttpTransact::build_redirect_response(State *s)
// inserts expanded hostname into old url in order to //
// get scheme information, then puts the old url back. //
//////////////////////////////////////////////////////////
- u = s->hdr_info.client_request.url_get();
- old_host = u->host_get(&old_host_len);
- u->host_set(s->dns_info.lookup_name, strlen(s->dns_info.lookup_name));
+ u = s->hdr_info.client_request.url_get();
+ auto old_host{u->host_get()};
+ u->host_set({s->dns_info.lookup_name});
new_url = to_free = u->string_get(&s->arena, &new_url_len);
assert(to_free != nullptr); // needed to avoid false positive nullptr deref from clang-analyzer.
// The following code may not be needed if string_get above always returns non nullptr,
@@ -8194,7 +8183,7 @@ HttpTransact::build_redirect_response(State *s)
if (new_url == nullptr) {
new_url = "";
}
- u->host_set(old_host, old_host_len);
+ u->host_set(old_host);
//////////////////////////
// set redirect headers //
@@ -8902,7 +8891,7 @@ HttpTransact::change_response_header_because_of_range_request(State *s, HTTPHdr
header->status_set(HTTPStatus::PARTIAL_CONTENT);
reason_phrase = const_cast<char *>(http_hdr_reason_lookup(HTTPStatus::PARTIAL_CONTENT));
- header->reason_set(reason_phrase, strlen(reason_phrase));
+ header->reason_set(std::string_view{reason_phrase});
// set the right Content-Type for multiple entry Range
if (s->num_range_fields > 1) {
diff --git a/src/proxy/http/HttpTransactHeaders.cc b/src/proxy/http/HttpTransactHeaders.cc
index fba58282a7..891001fcc8 100644
--- a/src/proxy/http/HttpTransactHeaders.cc
+++ b/src/proxy/http/HttpTransactHeaders.cc
@@ -120,8 +120,9 @@ HttpTransactHeaders::insert_supported_methods_in_response(HTTPHdr *response, int
{
int method_output_lengths[32];
const char *methods[] = {
- HTTP_METHOD_CONNECT, HTTP_METHOD_DELETE, HTTP_METHOD_GET, HTTP_METHOD_HEAD, HTTP_METHOD_OPTIONS,
- HTTP_METHOD_POST, HTTP_METHOD_PURGE, HTTP_METHOD_PUT, HTTP_METHOD_PUSH, HTTP_METHOD_TRACE,
+ HTTP_METHOD_CONNECT.c_str(), HTTP_METHOD_DELETE.c_str(), HTTP_METHOD_GET.c_str(), HTTP_METHOD_HEAD.c_str(),
+ HTTP_METHOD_OPTIONS.c_str(), HTTP_METHOD_POST.c_str(), HTTP_METHOD_PURGE.c_str(), HTTP_METHOD_PUT.c_str(),
+ HTTP_METHOD_PUSH.c_str(), HTTP_METHOD_TRACE.c_str(),
};
char inline_buffer[64];
char *alloced_buffer, *value_buffer;
@@ -204,7 +205,7 @@ HttpTransactHeaders::build_base_response(HTTPHdr *outgoing_response, HTTPStatus
outgoing_response->version_set(HTTPVersion(1, 1));
outgoing_response->status_set(status);
- outgoing_response->reason_set(reason_phrase, reason_phrase_len);
+ outgoing_response->reason_set(std::string_view{reason_phrase, static_cast<std::string_view::size_type>(reason_phrase_len)});
outgoing_response->set_date(date);
}
@@ -358,7 +359,7 @@ HttpTransactHeaders::convert_to_1_0_response_header(HTTPHdr *outgoing_response,
// Set reason phrase if passed in.
if (reason_phrase != nullptr) {
Dbg(dbg_ctl_http_transact_headers, "Setting HTTP/1.0 reason phrase to '%s'", reason_phrase);
- outgoing_response->reason_set(reason_phrase, strlen(reason_phrase));
+ outgoing_response->reason_set(std::string_view{reason_phrase});
}
// Keep-Alive?
@@ -380,7 +381,7 @@ HttpTransactHeaders::convert_to_1_1_response_header(HTTPHdr *outgoing_response,
// Set reason phrase if passed in.
if (reason_phrase != nullptr) {
Dbg(dbg_ctl_http_transact_headers, "Setting HTTP/1.1 reason phrase to '%s'", reason_phrase);
- outgoing_response->reason_set(reason_phrase, strlen(reason_phrase));
+ outgoing_response->reason_set(std::string_view{reason_phrase});
}
}
@@ -892,8 +893,7 @@ HttpTransactHeaders::remove_100_continue_headers(HttpTransact::State *s, HTTPHdr
{
auto expect{s->hdr_info.client_request.value_get(static_cast<std::string_view>(MIME_FIELD_EXPECT))};
- if (strcasecmp(expect,
- std::string_view{HTTP_VALUE_100_CONTINUE, static_cast<std::string_view::size_type>(HTTP_LEN_100_CONTINUE)}) == 0) {
+ if (strcasecmp(expect, static_cast<std::string_view>(HTTP_VALUE_100_CONTINUE)) == 0) {
outgoing->field_delete(static_cast<std::string_view>(MIME_FIELD_EXPECT));
}
}
@@ -1261,5 +1261,5 @@ HttpTransactHeaders::add_connection_close(HTTPHdr *header)
field = header->field_create(static_cast<std::string_view>(MIME_FIELD_CONNECTION));
header->field_attach(field);
}
- header->field_value_set(field, std::string_view{HTTP_VALUE_CLOSE, static_cast<std::string_view::size_type>(HTTP_LEN_CLOSE)});
+ header->field_value_set(field, static_cast<std::string_view>(HTTP_VALUE_CLOSE));
}
diff --git a/src/proxy/http/RegressionHttpTransact.cc b/src/proxy/http/RegressionHttpTransact.cc
index e4aa133569..2376da4d67 100644
--- a/src/proxy/http/RegressionHttpTransact.cc
+++ b/src/proxy/http/RegressionHttpTransact.cc
@@ -25,6 +25,10 @@
#include "proxy/http/HttpTransact.h"
#include "proxy/http/HttpSM.h"
+#include <string_view>
+
+using namespace std::literals;
+
void
forceLinkRegressionHttpTransact()
{
@@ -38,7 +42,7 @@ init_sm(HttpSM *sm)
}
static void
-setup_client_request(HttpSM *sm, const char *scheme, const char *request)
+setup_client_request(HttpSM *sm, std::string_view scheme, const char *request)
{
init_sm(sm);
@@ -50,7 +54,7 @@ setup_client_request(HttpSM *sm, const char *scheme, const char *request)
http_parser_init(&httpParser);
int bytes_used = 0;
sm->t_state.hdr_info.client_request.parse_req(&httpParser, buffer_reader, &bytes_used, true /* eos */);
- sm->t_state.hdr_info.client_request.url_get()->scheme_set(scheme, strlen(scheme));
+ sm->t_state.hdr_info.client_request.url_get()->scheme_set(scheme);
sm->t_state.method = sm->t_state.hdr_info.client_request.method_get_wksidx();
free_MIOBuffer(read_buffer);
}
@@ -69,29 +73,29 @@ REGRESSION_TEST(HttpTransact_is_request_valid)(RegressionTest *t, int /* level *
*pstatus = REGRESSION_TEST_PASSED;
struct {
- const char *scheme;
- const char *req;
- bool result;
+ std::string_view scheme;
+ const char *req;
+ bool result;
} requests[] = {
// missing host header
- {"http", "GET / HTTP/1.1\r\n\r\n", false},
+ {"http"sv, "GET / HTTP/1.1\r\n\r\n", false},
// good get request
- {"http", "GET / HTTP/1.1\r\nHost: abc.com\r\n\r\n", true },
+ {"http"sv, "GET / HTTP/1.1\r\nHost: abc.com\r\n\r\n", true },
// good trace request
- {"http", "TRACE / HTTP/1.1\r\nHost: abc.com\r\n\r\n", true },
+ {"http"sv, "TRACE / HTTP/1.1\r\nHost: abc.com\r\n\r\n", true },
// content len < 0
- {"http", "POST / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: -1\r\n\r\n", false},
- {"http", "PUSH / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: -1\r\n\r\n", false},
- {"http", "PUT / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: -1\r\n\r\n", false},
+ {"http"sv, "POST / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: -1\r\n\r\n", false},
+ {"http"sv, "PUSH / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: -1\r\n\r\n", false},
+ {"http"sv, "PUT / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: -1\r\n\r\n", false},
// valid content len
- {"http", "POST / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: 10\r\n\r\n", true },
- {"http", "PUSH / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: 10\r\n\r\n", true },
- {"http", "PUT / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: 10\r\n\r\n", true },
+ {"http"sv, "POST / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: 10\r\n\r\n", true },
+ {"http"sv, "PUSH / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: 10\r\n\r\n", true },
+ {"http"sv, "PUT / HTTP/1.1\r\nHost: abc.com\r\nContent-Length: 10\r\n\r\n", true },
// Content Length missing
- {"http", "POST / HTTP/1.1\r\nHost: abc.com\r\n\r\n", false},
- {"http", "PUSH / HTTP/1.1\r\nHost: abc.com\r\n\r\n", false},
- {"http", "PUT / HTTP/1.1\r\nHost: abc.com\r\n\r\n", false},
- {nullptr, nullptr, false}
+ {"http"sv, "POST / HTTP/1.1\r\nHost: abc.com\r\n\r\n", false},
+ {"http"sv, "PUSH / HTTP/1.1\r\nHost: abc.com\r\n\r\n", false},
+ {"http"sv, "PUT / HTTP/1.1\r\nHost: abc.com\r\n\r\n", false},
+ {""sv, nullptr, false}
};
for (int i = 0; requests[i].req; i++) {
setup_client_request(&sm, requests[i].scheme, requests[i].req);
diff --git a/src/proxy/http/remap/NextHopConsistentHash.cc b/src/proxy/http/remap/NextHopConsistentHash.cc
index 895157ca2f..855655063d 100644
--- a/src/proxy/http/remap/NextHopConsistentHash.cc
+++ b/src/proxy/http/remap/NextHopConsistentHash.cc
@@ -203,35 +203,30 @@ NextHopConsistentHash::getHashKey(uint64_t sm_id, const HttpRequestData &hrdata,
break;
// hostname hash
case NHHashKeyType::HOSTNAME_HASH_KEY:
- url_string_ref = url->host_get(&len);
- if (url_string_ref && len > 0) {
- h->update(url_string_ref, len);
+ if (auto host{url->host_get()}; !host.empty()) {
+ h->update(host.data(), host.length());
}
break;
// path + query string
case NHHashKeyType::PATH_QUERY_HASH_KEY:
- url_string_ref = url->path_get(&len);
h->update("/", 1);
- if (url_string_ref && len > 0) {
- h->update(url_string_ref, len);
+ if (auto path{url->path_get()}; !path.empty()) {
+ h->update(path.data(), path.length());
}
- url_string_ref = url->query_get(&len);
- if (url_string_ref && len > 0) {
+ if (auto query{url->query_get()}; !query.empty()) {
h->update("?", 1);
- h->update(url_string_ref, len);
+ h->update(query.data(), query.length());
}
break;
// path + fragment hash
case NHHashKeyType::PATH_FRAGMENT_HASH_KEY:
- url_string_ref = url->path_get(&len);
h->update("/", 1);
- if (url_string_ref && len > 0) {
- h->update(url_string_ref, len);
+ if (auto path{url->path_get()}; !path.empty()) {
+ h->update(path.data(), path.length());
}
- url_string_ref = url->fragment_get(&len);
- if (url_string_ref && len > 0) {
+ if (auto fragment{url->fragment_get()}; !fragment.empty()) {
h->update("?", 1);
- h->update(url_string_ref, len);
+ h->update(fragment.data(), fragment.length());
}
break;
// use the cache key created by the TSCacheUrlSet() API (e.g. the cachekey plugin)
@@ -246,22 +241,20 @@ NextHopConsistentHash::getHashKey(uint64_t sm_id, const HttpRequestData &hrdata,
}
} else {
// URL defaults to hrdata.hdr->url_get() above
- url_string_ref = url->path_get(&len);
h->update("/", 1);
- if (url_string_ref && len > 0) {
- NH_Dbg(NH_DBG_CTL, "[%" PRIu64 "] the parent selection over-ride url is not set, using default path: %s.", sm_id,
- url_string_ref);
- h->update(url_string_ref, len);
+ if (auto path{url->path_get()}; !path.empty()) {
+ NH_Dbg(NH_DBG_CTL, "[%" PRIu64 "] the parent selection over-ride url is not set, using default path: %.*s.", sm_id,
+ static_cast<int>(path.length()), path.data());
+ h->update(path.data(), path.length());
}
}
break;
// use the path as the hash, default.
case NHHashKeyType::PATH_HASH_KEY:
default:
- url_string_ref = url->path_get(&len);
h->update("/", 1);
- if (url_string_ref && len > 0) {
- h->update(url_string_ref, len);
+ if (auto path{url->path_get()}; !path.empty()) {
+ h->update(path.data(), path.length());
}
break;
}
diff --git a/src/proxy/http/remap/RemapConfig.cc b/src/proxy/http/remap/RemapConfig.cc
index 79dd705c56..d20262d2a6 100644
--- a/src/proxy/http/remap/RemapConfig.cc
+++ b/src/proxy/http/remap/RemapConfig.cc
@@ -37,6 +37,8 @@
#include "proxy/IPAllow.h"
#include "proxy/http/remap/PluginFactory.h"
+using namespace std::literals;
+
#define modulePrefix "[ReverseProxy]"
load_remap_file_func load_remap_file_cb = nullptr;
@@ -969,12 +971,10 @@ remap_load_plugin(const char *const *argv, int argc, url_mapping *mp, char *errb
static bool
process_regex_mapping_config(const char *from_host_lower, url_mapping *new_mapping, UrlRewrite::RegexMapping *reg_map)
{
- const char *str;
- int str_index;
- const char *to_host;
- int to_host_len;
- int substitution_id;
- int captures;
+ std::string_view to_host{};
+ int to_host_len;
+ int substitution_id;
+ int captures;
reg_map->to_url_host_template = nullptr;
reg_map->to_url_host_template_len = 0;
@@ -1000,8 +1000,9 @@ process_regex_mapping_config(const char *from_host_lower, url_mapping *new_mappi
goto lFail;
}
- to_host = new_mapping->toURL.host_get(&to_host_len);
- for (int i = 0; i < (to_host_len - 1); ++i) {
+ to_host = new_mapping->toURL.host_get();
+ to_host_len = static_cast<int>(to_host.length());
+ for (int i = 0; i < to_host_len - 1; ++i) {
if (to_host[i] == '$') {
substitution_id = to_host[i + 1] - '0';
if ((substitution_id < 0) || (substitution_id > captures)) {
@@ -1017,10 +1018,9 @@ process_regex_mapping_config(const char *from_host_lower, url_mapping *new_mappi
// so the regex itself is stored in fromURL.host; string to match
// will be in the request; string to use for substitutions will be
// in this buffer
- str = new_mapping->toURL.host_get(&str_index); // reusing str and str_index
- reg_map->to_url_host_template_len = str_index;
- reg_map->to_url_host_template = static_cast<char *>(ats_malloc(str_index));
- memcpy(reg_map->to_url_host_template, str, str_index);
+ reg_map->to_url_host_template_len = to_host_len;
+ reg_map->to_url_host_template = static_cast<char *>(ats_malloc(to_host_len));
+ memcpy(reg_map->to_url_host_template, to_host.data(), to_host_len);
return true;
@@ -1047,22 +1047,20 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
ParseResult rparse;
// Vars to build the mapping
- const char *fromScheme, *toScheme;
- int fromSchemeLen, toSchemeLen;
- const char *fromHost, *toHost;
- int fromHostLen, toHostLen;
- char *map_from, *map_from_start;
- char *map_to, *map_to_start;
- const char *tmp; // Appease the DEC compiler
- char *fromHost_lower = nullptr;
- char *fromHost_lower_ptr = nullptr;
- char fromHost_lower_buf[1024];
- url_mapping *new_mapping = nullptr;
- mapping_type maptype;
- referer_info *ri;
- int origLength;
- int length;
- int tok_count;
+ std::string_view fromScheme{}, toScheme{};
+ std::string_view fromHost{}, toHost{};
+ char *map_from, *map_from_start;
+ char *map_to, *map_to_start;
+ const char *tmp; // Appease the DEC compiler
+ char *fromHost_lower = nullptr;
+ char *fromHost_lower_ptr = nullptr;
+ char fromHost_lower_buf[1024];
+ url_mapping *new_mapping = nullptr;
+ mapping_type maptype;
+ referer_info *ri;
+ int origLength;
+ int length;
+ int tok_count;
UrlRewrite::RegexMapping *reg_map;
bool is_cur_mapping_regex;
@@ -1243,29 +1241,31 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
goto MAP_ERROR;
}
- fromScheme = new_mapping->fromURL.scheme_get(&fromSchemeLen);
+ fromScheme = new_mapping->fromURL.scheme_get();
// If the rule is "/" or just some other relative path
// we need to default the scheme to http
- if (fromScheme == nullptr || fromSchemeLen == 0) {
- new_mapping->fromURL.scheme_set(URL_SCHEME_HTTP, URL_LEN_HTTP);
- fromScheme = new_mapping->fromURL.scheme_get(&fromSchemeLen);
+ if (fromScheme.empty()) {
+ new_mapping->fromURL.scheme_set(std::string_view{URL_SCHEME_HTTP});
+ fromScheme = new_mapping->fromURL.scheme_get();
new_mapping->wildcard_from_scheme = true;
}
- toScheme = new_mapping->toURL.scheme_get(&toSchemeLen);
+ toScheme = new_mapping->toURL.scheme_get();
// Include support for HTTPS scheme
// includes support for FILE scheme
- if ((fromScheme != URL_SCHEME_HTTP && fromScheme != URL_SCHEME_HTTPS && fromScheme != URL_SCHEME_FILE &&
- fromScheme != URL_SCHEME_TUNNEL && fromScheme != URL_SCHEME_WS && fromScheme != URL_SCHEME_WSS) ||
- (toScheme != URL_SCHEME_HTTP && toScheme != URL_SCHEME_HTTPS && toScheme != URL_SCHEME_TUNNEL &&
- toScheme != URL_SCHEME_WS && toScheme != URL_SCHEME_WSS)) {
+ if ((fromScheme != std::string_view{URL_SCHEME_HTTP} && fromScheme != std::string_view{URL_SCHEME_HTTPS} &&
+ fromScheme != std::string_view{URL_SCHEME_FILE} && fromScheme != std::string_view{URL_SCHEME_TUNNEL} &&
+ fromScheme != std::string_view{URL_SCHEME_WS} && fromScheme != std::string_view{URL_SCHEME_WSS}) ||
+ (toScheme != std::string_view{URL_SCHEME_HTTP} && toScheme != std::string_view{URL_SCHEME_HTTPS} &&
+ toScheme != std::string_view{URL_SCHEME_TUNNEL} && toScheme != std::string_view{URL_SCHEME_WS} &&
+ toScheme != std::string_view{URL_SCHEME_WSS})) {
errStr = "only http, https, ws, wss, and tunnel remappings are supported";
goto MAP_ERROR;
}
// If mapping from WS or WSS we must map out to WS or WSS
- if ((fromScheme == URL_SCHEME_WSS || fromScheme == URL_SCHEME_WS) &&
- (toScheme != URL_SCHEME_WSS && toScheme != URL_SCHEME_WS)) {
+ if ((fromScheme == std::string_view{URL_SCHEME_WSS} || fromScheme == std::string_view{URL_SCHEME_WS}) &&
+ (toScheme != std::string_view{URL_SCHEME_WSS} && toScheme != std::string_view{URL_SCHEME_WS})) {
errStr = "WS or WSS can only be mapped out to WS or WSS.";
goto MAP_ERROR;
}
@@ -1314,16 +1314,15 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
}
// Check to see the fromHost remapping is a relative one
- fromHost = new_mapping->fromURL.host_get(&fromHostLen);
- if (fromHost == nullptr || fromHostLen <= 0) {
+ fromHost = new_mapping->fromURL.host_get();
+ if (fromHost.empty()) {
if (maptype == mapping_type::FORWARD_MAP || maptype == mapping_type::FORWARD_MAP_REFERER ||
maptype == mapping_type::FORWARD_MAP_WITH_RECV_PORT) {
if (*map_from_start != '/') {
errStr = "relative remappings must begin with a /";
goto MAP_ERROR;
} else {
- fromHost = "";
- fromHostLen = 0;
+ fromHost = ""sv;
}
} else {
errStr = "remap source in reverse mappings requires a hostname";
@@ -1331,8 +1330,8 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
}
}
- toHost = new_mapping->toURL.host_get(&toHostLen);
- if (toHost == nullptr || toHostLen <= 0) {
+ toHost = new_mapping->toURL.host_get();
+ if (toHost.empty()) {
errStr = "The remap destinations require a hostname";
goto MAP_ERROR;
}
@@ -1345,18 +1344,18 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
// the rest of the system assumes that trailing slashes have
// been removed.
- if (unlikely(fromHostLen >= static_cast<int>(sizeof(fromHost_lower_buf)))) {
- fromHost_lower = (fromHost_lower_ptr = static_cast<char *>(ats_malloc(fromHostLen + 1)));
+ if (unlikely(fromHost.length() >= sizeof(fromHost_lower_buf))) {
+ fromHost_lower = (fromHost_lower_ptr = static_cast<char *>(ats_malloc(fromHost.length() + 1)));
} else {
fromHost_lower = &fromHost_lower_buf[0];
}
// Canonicalize the hostname by making it lower case
- memcpy(fromHost_lower, fromHost, fromHostLen);
- fromHost_lower[fromHostLen] = 0;
+ memcpy(fromHost_lower, fromHost.data(), fromHost.length());
+ fromHost_lower[fromHost.length()] = 0;
LowerCaseStr(fromHost_lower);
// set the normalized string so nobody else has to normalize this
- new_mapping->fromURL.host_set(fromHost_lower, fromHostLen);
+ new_mapping->fromURL.host_set({fromHost_lower, fromHost.length()});
reg_map = nullptr;
if (is_cur_mapping_regex) {
@@ -1378,7 +1377,7 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
// and gives a new remap rule with the IPv4 addr.
if ((maptype == mapping_type::FORWARD_MAP || maptype == mapping_type::FORWARD_MAP_REFERER ||
maptype == mapping_type::FORWARD_MAP_WITH_RECV_PORT) &&
- fromScheme == URL_SCHEME_TUNNEL && (fromHost_lower[0] < '0' || fromHost_lower[0] > '9')) {
+ fromScheme == std::string_view{URL_SCHEME_TUNNEL} && (fromHost_lower[0] < '0' || fromHost_lower[0] > '9')) {
addrinfo *ai_records; // returned records.
ip_text_buffer ipb; // buffer for address string conversion.
if (0 == getaddrinfo(fromHost_lower, nullptr, nullptr, &ai_records)) {
@@ -1390,7 +1389,7 @@ remap_parse_config_bti(const char *path, BUILD_TABLE_INFO *bti)
u_mapping = new url_mapping;
u_mapping->fromURL.create(nullptr);
u_mapping->fromURL.copy(&new_mapping->fromURL);
- u_mapping->fromURL.host_set(ipb, strlen(ipb));
+ u_mapping->fromURL.host_set({ipb});
u_mapping->toURL.create(nullptr);
u_mapping->toURL.copy(&new_mapping->toURL);
diff --git a/src/proxy/http/remap/RemapProcessor.cc b/src/proxy/http/remap/RemapProcessor.cc
index 6ebb203062..63304229bc 100644
--- a/src/proxy/http/remap/RemapProcessor.cc
+++ b/src/proxy/http/remap/RemapProcessor.cc
@@ -140,8 +140,7 @@ RemapProcessor::finish_remap(HttpTransact::State *s, UrlRewrite *table)
URL *request_url = request_header->url_get();
char **redirect_url = &s->remap_redirect;
char tmp_referer_buf[4096], tmp_redirect_buf[4096], tmp_buf[2048];
- const char *remapped_host;
- int remapped_host_len, tmp;
+ int tmp;
int from_len;
referer_info *ri;
@@ -197,10 +196,11 @@ RemapProcessor::finish_remap(HttpTransact::State *s, UrlRewrite *table)
break;
case 'f':
case 't':
- remapped_host = (rc->type == 'f') ?
- map->fromURL.string_get_buf(tmp_buf, static_cast<int>(sizeof(tmp_buf)), &from_len) :
- ((s->url_map).getToURL())->string_get_buf(tmp_buf, static_cast<int>(sizeof(tmp_buf)), &from_len);
- if (remapped_host && from_len > 0) {
+ if (auto remapped_host_cstr =
+ (rc->type == 'f') ?
+ map->fromURL.string_get_buf(tmp_buf, static_cast<int>(sizeof(tmp_buf)), &from_len) :
+ ((s->url_map).getToURL())->string_get_buf(tmp_buf, static_cast<int>(sizeof(tmp_buf)), &from_len);
+ remapped_host_cstr && from_len > 0) {
c = &tmp_buf[0];
}
break;
@@ -245,14 +245,15 @@ RemapProcessor::finish_remap(HttpTransact::State *s, UrlRewrite *table)
// Create the new host header field being careful that our
// temporary buffer has adequate length
//
- remapped_host = request_url->host_get(&remapped_host_len);
+ auto remapped_host{request_url->host_get()};
+ auto remapped_host_len{static_cast<int>(remapped_host.length())};
int remapped_port = request_url->port_get_raw();
char host_hdr_buf[TS_MAX_HOST_NAME_LEN];
if (TS_MAX_HOST_NAME_LEN > remapped_host_len) {
tmp = remapped_host_len;
- memcpy(host_hdr_buf, remapped_host, remapped_host_len);
+ memcpy(host_hdr_buf, remapped_host.data(), remapped_host_len);
if (remapped_port) {
tmp += snprintf(host_hdr_buf + remapped_host_len, TS_MAX_HOST_NAME_LEN - remapped_host_len - 1, ":%d", remapped_port);
}
diff --git a/src/proxy/http/remap/UrlMappingPathIndex.cc b/src/proxy/http/remap/UrlMappingPathIndex.cc
index a2195823c4..aaa1c798bf 100644
--- a/src/proxy/http/remap/UrlMappingPathIndex.cc
+++ b/src/proxy/http/remap/UrlMappingPathIndex.cc
@@ -44,8 +44,6 @@ UrlMappingPathIndex::Insert(url_mapping *mapping)
int scheme_idx;
int port = (mapping->fromURL).port_get();
UrlMappingTrie *trie;
- int from_path_len;
- const char *from_path;
trie = _GetTrie(&(mapping->fromURL), scheme_idx, port);
@@ -55,8 +53,8 @@ UrlMappingPathIndex::Insert(url_mapping *mapping)
Dbg(dbg_ctl_UrlMappingPathIndex_Insert, "Created new trie for scheme index, port combo <%d, %d>", scheme_idx, port);
}
- from_path = mapping->fromURL.path_get(&from_path_len);
- if (!trie->Insert(from_path, mapping, mapping->getRank(), from_path_len)) {
+ auto from_path{mapping->fromURL.path_get()};
+ if (!trie->Insert(from_path.data(), mapping, mapping->getRank(), static_cast<int>(from_path.length()))) {
Error("Couldn't insert into trie!");
return false;
}
@@ -67,11 +65,11 @@ UrlMappingPathIndex::Insert(url_mapping *mapping)
url_mapping *
UrlMappingPathIndex::Search(URL *request_url, int request_port, bool normal_search /* = true */) const
{
- url_mapping *retval = nullptr;
- int scheme_idx;
- UrlMappingTrie *trie;
- int path_len;
- const char *path;
+ url_mapping *retval = nullptr;
+ int scheme_idx;
+ UrlMappingTrie *trie;
+ int path_len;
+ std::string_view path{};
trie = _GetTrie(request_url, scheme_idx, request_port, normal_search);
@@ -80,9 +78,10 @@ UrlMappingPathIndex::Search(URL *request_url, int request_port, bool normal_sear
goto lFail;
}
- path = request_url->path_get(&path_len);
- if (!(retval = trie->Search(path, path_len))) {
- Dbg(dbg_ctl_UrlMappingPathIndex_Search, "Couldn't find entry for url with path [%.*s]", path_len, path);
+ path = request_url->path_get();
+ path_len = static_cast<int>(path.length());
+ if (!(retval = trie->Search(path.data(), path_len))) {
+ Dbg(dbg_ctl_UrlMappingPathIndex_Search, "Couldn't find entry for url with path [%.*s]", path_len, path.data());
goto lFail;
}
return retval;
diff --git a/src/proxy/http/remap/UrlRewrite.cc b/src/proxy/http/remap/UrlRewrite.cc
index add0b36c68..1926682c56 100644
--- a/src/proxy/http/remap/UrlRewrite.cc
+++ b/src/proxy/http/remap/UrlRewrite.cc
@@ -48,11 +48,10 @@ DbgCtl dbg_ctl_url_rewrite{"url_rewrite"};
void
SetHomePageRedirectFlag(url_mapping *new_mapping, URL &new_to_url)
{
- int fromLen, toLen;
- const char *from_path = new_mapping->fromURL.path_get(&fromLen);
- const char *to_path = new_to_url.path_get(&toLen);
+ auto from_path{new_mapping->fromURL.path_get()};
+ auto to_path{new_to_url.path_get()};
- new_mapping->homePageRedirect = (from_path && !to_path) ? true : false;
+ new_mapping->homePageRedirect = (!from_path.empty() && to_path.empty()) ? true : false;
}
} // end anonymous namespace
@@ -316,77 +315,66 @@ UrlRewrite::_tableLookup(std::unique_ptr<URLTable> &h_table, URL *request_url, i
void
url_rewrite_remap_request(const UrlMappingContainer &mapping_container, URL *request_url, int method)
{
- URL *map_to = mapping_container.getToURL();
- URL *map_from = mapping_container.getFromURL();
- const char *toHost;
- int toHostLen;
-
- toHost = map_to->host_get(&toHostLen);
+ URL *map_to = mapping_container.getToURL();
+ URL *map_from = mapping_container.getFromURL();
Dbg(dbg_ctl_url_rewrite, "%s: Remapping rule id: %d matched", __func__, mapping_container.getMapping()->map_id);
- request_url->host_set(toHost, toHostLen);
+ request_url->host_set(map_to->host_get());
request_url->port_set(map_to->port_get_raw());
// With the CONNECT method, we have to avoid messing with the scheme and path, because it's not part of
// the CONNECT request (only host and port is).
if (HTTP_WKSIDX_CONNECT != method) {
- const char *toScheme;
- int toSchemeLen;
- const char *requestPath;
- int requestPathLen = 0;
- int fromPathLen = 0;
- const char *toPath;
- int toPathLen;
-
- toScheme = map_to->scheme_get(&toSchemeLen);
- request_url->scheme_set(toScheme, toSchemeLen);
+ request_url->scheme_set(map_to->scheme_get());
- map_from->path_get(&fromPathLen);
- toPath = map_to->path_get(&toPathLen);
- requestPath = request_url->path_get(&requestPathLen);
+ auto fromPathLen{static_cast<int>(map_from->path_get().length())};
+ auto toPath{map_to->path_get()};
+ auto toPathLen{static_cast<int>(toPath.length())};
+ auto requestPath{request_url->path_get()};
+ auto requestPathLen{static_cast<int>(requestPath.length())};
// Should be +3, little extra padding won't hurt.
char newPath[(requestPathLen - fromPathLen) + toPathLen + 8];
int newPathLen = 0;
*newPath = 0;
- if (toPath) {
- memcpy(newPath, toPath, toPathLen);
+ if (!toPath.empty()) {
+ memcpy(newPath, toPath.data(), toPathLen);
newPathLen += toPathLen;
}
// We might need to insert a trailing slash in the new portion of the path
// if more will be added and none is present and one will be needed.
- if (!fromPathLen && requestPathLen && newPathLen && toPathLen && *(newPath + newPathLen - 1) != '/') {
- *(newPath + newPathLen) = '/';
+ if (!fromPathLen && requestPathLen && newPathLen && toPathLen && newPath[newPathLen - 1] != '/') {
+ newPath[newPathLen] = '/';
newPathLen++;
}
- if (requestPath) {
+ if (!requestPath.empty()) {
// avoid adding another trailing slash if the requestPath already had one and so does the toPath
if (requestPathLen < fromPathLen) {
- if (toPath && requestPath[requestPathLen - 1] == '/' && toPath[toPathLen - 1] == '/') {
+ if (!toPath.empty() && requestPath[requestPathLen - 1] == '/' && toPath[toPathLen - 1] == '/') {
fromPathLen++;
}
- } else {
- if (toPath && requestPath[fromPathLen] == '/' && toPath[toPathLen - 1] == '/') {
+ } else if (requestPathLen > fromPathLen) {
+ if (!toPath.empty() && requestPath[fromPathLen] == '/' && toPath[toPathLen - 1] == '/') {
fromPathLen++;
}
}
// copy the end of the path past what has been mapped
if ((requestPathLen - fromPathLen) > 0) {
- memcpy(newPath + newPathLen, requestPath + fromPathLen, requestPathLen - fromPathLen);
+ memcpy(newPath + newPathLen, requestPath.data() + fromPathLen, requestPathLen - fromPathLen);
newPathLen += (requestPathLen - fromPathLen);
}
}
// Skip any leading / in the path when setting the new URL path
if (*newPath == '/') {
- request_url->path_set(newPath + 1, newPathLen - 1);
+ request_url->path_set({newPath + 1, static_cast<std::string_view::size_type>(newPathLen - 1)});
} else {
- request_url->path_set(newPath, newPathLen);
+ request_url->path_set({newPath, static_cast<std::string_view::size_type>(newPathLen)});
}
}
}
@@ -398,8 +386,6 @@ UrlRewrite::ReverseMap(HTTPHdr *response_header)
{
URL location_url;
bool remap_found = false;
- const char *host;
- int host_len;
char *new_loc_hdr;
int new_loc_length;
int i;
@@ -425,11 +411,12 @@ UrlRewrite::ReverseMap(HTTPHdr *response_header)
location_url.create(nullptr);
location_url.parse(location_hdr.data(), static_cast<int>(location_hdr.length()));
- host = location_url.host_get(&host_len);
+ auto host{location_url.host_get()};
UrlMappingContainer reverse_mapping(response_header->m_heap);
- if (reverseMappingLookup(&location_url, location_url.port_get(), host, host_len, reverse_mapping)) {
+ if (reverseMappingLookup(&location_url, location_url.port_get(), host.data(), static_cast<int>(host.length()),
+ reverse_mapping)) {
if (i == 0) {
remap_found = true;
}
@@ -634,8 +621,6 @@ UrlRewrite::Remap_redirect(HTTPHdr *request_header, URL *redirect_url)
{
URL *request_url;
mapping_type mappingType;
- const char *host = nullptr;
- int host_len = 0, request_port = 0;
bool prt, trt; // existence of permanent and temporary redirect tables, respectively
prt = (num_rules_redirect_permanent != 0);
@@ -659,15 +644,16 @@ UrlRewrite::Remap_redirect(HTTPHdr *request_header, URL *redirect_url)
return mapping_type::NONE;
}
- host = request_url->host_get(&host_len);
- request_port = request_url->port_get();
+ auto host{request_url->host_get()};
+ auto request_port{request_url->port_get()};
- if (host_len == 0 && reverse_proxy != 0) { // Server request. Use the host header to figure out where
- // it goes. Host header parsing is same as in ::Remap
+ if (host.empty() && reverse_proxy != 0) { // Server request. Use the host header to figure out where
+ // it goes. Host header parsing is same as in ::Remap
auto host_hdr{request_header->value_get(static_cast<std::string_view>(MIME_FIELD_HOST))};
const char *tmp = static_cast<const char *>(memchr(host_hdr.data(), ':', host_hdr.length()));
+ int host_len;
if (tmp == nullptr) {
host_len = static_cast<int>(host_hdr.length());
} else {
@@ -681,7 +667,7 @@ UrlRewrite::Remap_redirect(HTTPHdr *request_header, URL *redirect_url)
}
}
- host = host_hdr.data();
+ host = {host_hdr.data(), static_cast<std::string_view::size_type>(host_len)};
}
// Temporary Redirects have precedence over Permanent Redirects
// the rationale behind this is that network administrators might
@@ -692,12 +678,12 @@ UrlRewrite::Remap_redirect(HTTPHdr *request_header, URL *redirect_url)
UrlMappingContainer redirect_mapping(request_header->m_heap);
if (trt) {
- if (temporaryRedirectLookup(request_url, request_port, host, host_len, redirect_mapping)) {
+ if (temporaryRedirectLookup(request_url, request_port, host.data(), static_cast<int>(host.length()), redirect_mapping)) {
mappingType = mapping_type::TEMPORARY_REDIRECT;
}
}
if ((mappingType == mapping_type::NONE) && prt) {
- if (permanentRedirectLookup(request_url, request_port, host, host_len, redirect_mapping)) {
+ if (permanentRedirectLookup(request_url, request_port, host.data(), static_cast<int>(host.length()), redirect_mapping)) {
mappingType = mapping_type::PERMANENT_REDIRECT;
}
}
@@ -1009,17 +995,12 @@ UrlRewrite::_regexMappingLookup(RegexMappingList ®ex_mappings, URL *request_u
Dbg(dbg_ctl_url_rewrite_regex, "Going to match regexes with rank <= %d", rank_ceiling);
}
- int request_scheme_len, reg_map_scheme_len;
- const char *request_scheme = request_url->scheme_get(&request_scheme_len), *reg_map_scheme;
-
- int request_path_len, reg_map_path_len;
- const char *request_path = request_url->path_get(&request_path_len), *reg_map_path;
+ auto request_scheme{request_url->scheme_get()};
// If the scheme is empty (e.g. because of a CONNECT method), guess it based on port
// This is equivalent to the logic in UrlMappingPathIndex::_GetTrie().
- if (request_scheme_len == 0) {
- request_scheme = request_port == 80 ? URL_SCHEME_HTTP : URL_SCHEME_HTTPS;
- request_scheme_len = hdrtoken_wks_to_length(request_scheme);
+ if (request_scheme.empty()) {
+ request_scheme = std::string_view{80 ? URL_SCHEME_HTTP : URL_SCHEME_HTTPS};
}
// Loop over the entire linked list, or until we're satisfied
@@ -1031,8 +1012,7 @@ UrlRewrite::_regexMappingLookup(RegexMappingList ®ex_mappings, URL *request_u
break;
}
- reg_map_scheme = list_iter->url_map->fromURL.scheme_get(®_map_scheme_len);
- if ((request_scheme_len != reg_map_scheme_len) || strncmp(request_scheme, reg_map_scheme, request_scheme_len)) {
+ if (auto reg_map_scheme{list_iter->url_map->fromURL.scheme_get()}; request_scheme != reg_map_scheme) {
Dbg(dbg_ctl_url_rewrite_regex, "Skipping regex with rank %d as scheme does not match request scheme", reg_map_rank);
continue;
}
@@ -1045,9 +1025,10 @@ UrlRewrite::_regexMappingLookup(RegexMappingList ®ex_mappings, URL *request_u
continue;
}
- reg_map_path = list_iter->url_map->fromURL.path_get(®_map_path_len);
- if ((request_path_len < reg_map_path_len) ||
- strncmp(reg_map_path, request_path, reg_map_path_len)) { // use the shorter path length here
+ auto request_path{request_url->path_get()};
+ auto reg_map_path{list_iter->url_map->fromURL.path_get()};
+ if ((request_path.length() < reg_map_path.length()) ||
+ strncmp(reg_map_path.data(), request_path.data(), reg_map_path.length())) { // use the shorter path length here
Dbg(dbg_ctl_url_rewrite_regex, "Skipping regex with rank %d as path does not cover request path", reg_map_rank);
continue;
}
@@ -1070,7 +1051,7 @@ UrlRewrite::_regexMappingLookup(RegexMappingList ®ex_mappings, URL *request_u
buf_len = _expandSubstitutions(matches_info, list_iter, request_host, buf, sizeof(buf));
URL *expanded_url = mapping_container.createNewToURL();
expanded_url->copy(&((list_iter->url_map)->toURL));
- expanded_url->host_set(buf, buf_len);
+ expanded_url->host_set({buf, static_cast<std::string_view::size_type>(buf_len)});
Dbg(dbg_ctl_url_rewrite_regex, "Expanded toURL to [%.*s]", expanded_url->length_get(), expanded_url->string_get_ref());
retval = true;
diff --git a/src/proxy/http2/Http2ConnectionState.cc b/src/proxy/http2/Http2ConnectionState.cc
index b08fa59ae3..53d62d8169 100644
--- a/src/proxy/http2/Http2ConnectionState.cc
+++ b/src/proxy/http2/Http2ConnectionState.cc
@@ -2456,7 +2456,7 @@ Http2ConnectionState::send_headers_frame(Http2Stream *stream)
bool explicit_zero_length = has_content_header && send_hdr->get_content_length() == 0;
int64_t content_length = has_content_header ? send_hdr->get_content_length() : 0L;
bool is_chunked = is_transfer_encoded && send_hdr->value_get(static_cast<std::string_view>(MIME_FIELD_TRANSFER_ENCODING)) ==
- std::string_view(HTTP_VALUE_CHUNKED);
+ static_cast<std::string_view>(HTTP_VALUE_CHUNKED);
bool expect_content_stream =
is_transfer_encoded || // transfer encoded content length is unknown
@@ -2536,7 +2536,7 @@ Http2ConnectionState::send_push_promise_frame(Http2Stream *stream, URL &url, con
ts::PostScript hdr_defer([&]() -> void { hdr.destroy(); });
hdr.create(HTTPType::REQUEST, HTTP_2_0);
hdr.url_set(&url);
- hdr.method_set(HTTP_METHOD_GET, HTTP_LEN_GET);
+ hdr.method_set(static_cast<std::string_view>(HTTP_METHOD_GET));
if (accept_encoding != nullptr) {
auto name{accept_encoding->name_get()};
diff --git a/src/proxy/http2/Http2Stream.cc b/src/proxy/http2/Http2Stream.cc
index edd43cfb07..3a98f19160 100644
--- a/src/proxy/http2/Http2Stream.cc
+++ b/src/proxy/http2/Http2Stream.cc
@@ -310,14 +310,14 @@ Http2Stream::send_headers(Http2ConnectionState & /* cstate ATS_UNUSED */)
if (_receive_header.type_get() == HTTPType::REQUEST) {
// There's no way to cause Bad Request directly at this time.
// Set an invalid method so it causes an error later.
- _receive_header.method_set("\xffVOID", 1);
+ _receive_header.method_set(std::string_view{"\xffVOID", 1});
}
}
if (_receive_header.type_get() == HTTPType::REQUEST) {
// Check whether the request uses CONNECT method
auto method{_receive_header.method_get()};
- if (method == std::string_view{HTTP_METHOD_CONNECT, static_cast<std::string_view::size_type>(HTTP_LEN_CONNECT)}) {
+ if (method == static_cast<std::string_view>(HTTP_METHOD_CONNECT)) {
this->_is_tunneling = true;
}
}
@@ -842,7 +842,7 @@ Http2Stream::update_write_request(bool call_update)
MIMEField *field = this->_send_header.field_find(static_cast<std::string_view>(MIME_FIELD_CONNECTION));
if (field) {
auto value{field->value_get()};
- if (value == std::string_view{HTTP_VALUE_CLOSE, static_cast<std::string_view::size_type>(HTTP_LEN_CLOSE)}) {
+ if (value == static_cast<std::string_view>(HTTP_VALUE_CLOSE)) {
SCOPED_MUTEX_LOCK(lock, _proxy_ssn->mutex, this_ethread());
if (connection_state.get_shutdown_state() == HTTP2_SHUTDOWN_NONE) {
connection_state.set_shutdown_state(HTTP2_SHUTDOWN_NOT_INITIATED, Http2ErrorCode::HTTP2_ERROR_NO_ERROR);