use {
alloc::{
collections::BTreeMap,
string::{String, ToString},
},
core::{
fmt::{self, Display, Formatter},
str::FromStr,
},
crate::Error,
};
pub type HeaderMap = BTreeMap<Header, String>;
pub const LINE_BREAK: &str = concat!('\r', '\n');
const HEADER_WWW_AUTHENTICATE: &str = "WWW-Authenticate";
const HEADER_AUTHORIZATION: &str = "Authorization";
const HEADER_PROXY_AUTHENTICATE: &str = "Proxy-Authenticate";
const HEADER_PROXY_AUTHORIZATION: &str = "Proxy-Authorization";
const HEADER_AGE: &str = "Age";
const HEADER_CACHE_CONTROL: &str = "Cache-Control";
const HEADER_CLEAR_SITE_DATA: &str = "Clear-Site-Data";
const HEADER_EXPIRES: &str = "Expires";
const HEADER_PRAGMA: &str = "Pragma";
const HEADER_WARNING: &str = "Warning";
const HEADER_LAST_MODIFIED: &str = "Last-Modified";
const HEADER_ETAG: &str = "ETag";
const HEADER_IF_MATCH: &str = "If-Match";
const HEADER_IF_NONE_MATCH: &str = "If-None-Match";
const HEADER_IF_MODIFIED_SINCE: &str = "If-Modified-Since";
const HEADER_IF_UNMODIFIED_SINCE: &str = "If-Unmodified-Since";
const HEADER_VARY: &str = "Vary";
const HEADER_CONNECTION: &str = "Connection";
const HEADER_KEEP_ALIVE: &str = "Keep-Alive";
const HEADER_ACCEPT: &str = "Accept";
const HEADER_ACCEPT_CHARSET: &str = "Accept-Charset";
const HEADER_ACCEPT_ENCODING: &str = "Accept-Encoding";
const HEADER_ACCEPT_LANGUAGE: &str = "Accept-Language";
const HEADER_EXPECT: &str = "Expect";
const HEADER_MAX_FORWARDS: &str = "Max-Forwards";
const HEADER_COOKIE: &str = "Cookie";
const HEADER_SET_COOKIE: &str = "Set-Cookie";
const HEADER_ACCESS_CONTROL_ALLOW_ORIGIN: &str = "Access-Control-Allow-Origin";
const HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS: &str = "Access-Control-Allow-Credentials";
const HEADER_ACCESS_CONTROL_ALLOW_HEADERS: &str = "Access-Control-Allow-Headers";
const HEADER_ACCESS_CONTROL_ALLOW_METHODS: &str = "Access-Control-Allow-Methods";
const HEADER_ACCESS_CONTROL_EXPOSE_HEADERS: &str = "Access-Control-Expose-Headers";
const HEADER_ACCESS_CONTROL_MAX_AGE: &str = "Access-Control-Max-Age";
const HEADER_ACCESS_CONTROL_REQUEST_HEADERS: &str = "Access-Control-Request-Headers";
const HEADER_ACCESS_CONTROL_REQUEST_METHOD: &str = "Access-Control-Request-Method";
const HEADER_ORIGIN: &str = "Origin";
const HEADER_SERVICE_WORKER_ALLOWED: &str = "Service-Worker-Allowed";
const HEADER_TIMING_ALLOW_ORIGIN: &str = "Timing-Allow-Origin";
const HEADER_X_PERMITTED_CROSS_DOMAIN_POLICIES: &str = "X-Permitted-Cross-Domain-Policies";
const HEADER_DNT: &str = "DNT";
const HEADER_TK: &str = "Tk";
const HEADER_CONTENT_DISPOSITION: &str = "Content-Disposition";
const HEADER_CONTENT_LENGTH: &str = "Content-Length";
const HEADER_CONTENT_TYPE: &str = "Content-Type";
const HEADER_CONTENT_ENCODING: &str = "Content-Encoding";
const HEADER_CONTENT_LANGUAGE: &str = "Content-Language";
const HEADER_CONTENT_LOCATION: &str = "Content-Location";
const HEADER_FORWARDED: &str = "Forwarded";
const HEADER_VIA: &str = "Via";
const HEADER_LOCATION: &str = "Location";
const HEADER_FROM: &str = "From";
const HEADER_HOST: &str = "Host";
const HEADER_REFERER: &str = "Referer";
const HEADER_REFERRER_POLICY: &str = "Referrer-Policy";
const HEADER_USER_AGENT: &str = "User-Agent";
const HEADER_ALLOW: &str = "Allow";
const HEADER_SERVER: &str = "Server";
const HEADER_ACCEPT_RANGES: &str = "Accept-Ranges";
const HEADER_RANGE: &str = "Range";
const HEADER_IF_RANGE: &str = "If-Range";
const HEADER_CONTENT_RANGE: &str = "Content-Range";
const HEADER_CROSS_ORIGIN_OPENER_POLICY: &str = "Cross-Origin-Opener-Policy";
const HEADER_CROSS_ORIGIN_RESOURCE_POLICY: &str = "Cross-Origin-Resource-Policy";
const HEADER_CONTENT_SECURITY_POLICY: &str = "Content-Security-Policy";
const HEADER_CONTENT_SECURITY_POLICY_REPORT_ONLY: &str = "Content-Security-Policy-Report-Only";
const HEADER_EXPECT_CT: &str = "Expect-CT";
const HEADER_FEATURE_POLICY: &str = "Feature-Policy";
const HEADER_PUBLIC_KEY_PINS: &str = "Public-Key-Pins";
const HEADER_PUBLIC_KEY_PINS_REPORT_ONLY: &str = "Public-Key-Pins-Report-Only";
const HEADER_STRICT_TRANSPORT_SECURITY: &str = "Strict-Transport-Security";
const HEADER_UPGRADE_INSECURE_REQUESTS: &str = "Upgrade-Insecure-Requests";
const HEADER_X_CONTENT_TYPE_OPTIONS: &str = "X-Content-Type-Options";
const HEADER_X_DOWNLOAD_OPTIONS: &str = "X-Download-Options";
const HEADER_X_FRAME_OPTIONS: &str = "X-Frame-Options";
const HEADER_X_POWERED_BY: &str = "X-Powered-By";
const HEADER_X_XSS_PROTECTION: &str = "X-XSS-Protection";
const HEADER_LAST_EVENT_ID: &str = "Last-Event-ID";
const HEADER_PING_FROM: &str = "Ping-From";
const HEADER_PING_TO: &str = "Ping-To";
const HEADER_REPORT_TO: &str = "Report-To";
const HEADER_TRANSFER_ENCODING: &str = "Transfer-Encoding";
const HEADER_TE: &str = "TE";
const HEADER_TRAILER: &str = "Trailer";
const HEADER_SEC_WEBSOCKET_KEY: &str = "Sec-WebSocket-Key";
const HEADER_SEC_WEBSOCKET_EXTENSIONS: &str = "Sec-WebSocket-Extensions";
const HEADER_SEC_WEBSOCKET_ACCEPT: &str = "Sec-WebSocket-Accept";
const HEADER_SEC_WEBSOCKET_PROTOCOL: &str = "Sec-WebSocket-Protocol";
const HEADER_SEC_WEBSOCKET_VERSION: &str = "Sec-WebSocket-Version";
const HEADER_ALT_SVC: &str = "Alt-Svc";
const HEADER_DATE: &str = "Date";
const HEADER_LARGE_ALLOCATION: &str = "Large-Allocation";
const HEADER_LINK: &str = "Link";
const HEADER_RETRY_AFTER: &str = "Retry-After";
const HEADER_SERVER_TIMING: &str = "Server-Timing";
const HEADER_SOURCEMAP: &str = "SourceMap";
const HEADER_UPGRADE: &str = "Upgrade";
const HEADER_X_DNS_PREFETCH_CONTROL: &str = "X-DNS-Prefetch-Control";
const HEADER_X_REQUESTED_WITH: &str = "X-Requested-With";
#[derive(Debug, Eq, PartialEq, Hash, Ord, PartialOrd, Clone)]
pub enum Header {
WWWAuthenticate,
Authorization,
ProxyAuthenticate,
ProxyAuthorization,
Age,
CacheControl,
ClearSiteData,
Expires,
Pragma,
Warning,
LastModified,
ETag,
IfMatch,
IfNoneMatch,
IfModifiedSince,
IfUnmodifiedSince,
Vary,
Connection,
KeepAlive,
Accept,
AcceptCharset,
AcceptEncoding,
AcceptLanguage,
Expect,
MaxForwards,
Cookie,
SetCookie,
AccessControlAllowOrigin,
AccessControlAllowCredentials,
AccessControlAllowHeaders,
AccessControlAllowMethods,
AccessControlExposeHeaders,
AccessControlMaxAge,
AccessControlRequestHeaders,
AccessControlRequestMethod,
Origin,
ServiceWorkerAllowed,
TimingAllowOrigin,
XPermittedCrossDomainPolicies,
DNT,
Tk,
ContentDisposition,
ContentLength,
ContentType,
ContentEncoding,
ContentLanguage,
ContentLocation,
Forwarded,
Via,
Location,
From,
Host,
Referer,
ReferrerPolicy,
UserAgent,
Allow,
Server,
AcceptRanges,
Range,
IfRange,
ContentRange,
CrossOriginOpenerPolicy,
CrossOriginResourcePolicy,
ContentSecurityPolicy,
ContentSecurityPolicyReportOnly,
ExpectCT,
FeaturePolicy,
PublicKeyPins,
PublicKeyPinsReportOnly,
StrictTransportSecurity,
UpgradeInsecureRequests,
XContentTypeOptions,
XDownloadOptions,
XFrameOptions,
XPoweredBy,
XXSSProtection,
LastEventID,
PingFrom,
PingTo,
ReportTo,
TransferEncoding,
TE,
Trailer,
SecWebSocketKey,
SecWebSocketExtensions,
SecWebSocketAccept,
SecWebSocketProtocol,
SecWebSocketVersion,
AltSvc,
Date,
LargeAllocation,
Link,
RetryAfter,
ServerTiming,
SourceMap,
Upgrade,
XDNSPrefetchControl,
XRequestedWith,
Unknown(String),
}
impl Header {
pub fn is_standard(&self) -> bool {
match self {
Header::Unknown(_) => false,
_ => true,
}
}
}
impl Display for Header {
fn fmt(&self, f: &mut Formatter) -> core::result::Result<(), fmt::Error> {
f.write_str(match self {
Header::WWWAuthenticate => HEADER_WWW_AUTHENTICATE,
Header::Authorization => HEADER_AUTHORIZATION,
Header::ProxyAuthenticate => HEADER_PROXY_AUTHENTICATE,
Header::ProxyAuthorization => HEADER_PROXY_AUTHORIZATION,
Header::Age => HEADER_AGE,
Header::CacheControl => HEADER_CACHE_CONTROL,
Header::ClearSiteData => HEADER_CLEAR_SITE_DATA,
Header::Expires => HEADER_EXPIRES,
Header::Pragma => HEADER_PRAGMA,
Header::Warning => HEADER_WARNING,
Header::LastModified => HEADER_LAST_MODIFIED,
Header::ETag => HEADER_ETAG,
Header::IfMatch => HEADER_IF_MATCH,
Header::IfNoneMatch => HEADER_IF_NONE_MATCH,
Header::IfModifiedSince => HEADER_IF_MODIFIED_SINCE,
Header::IfUnmodifiedSince => HEADER_IF_UNMODIFIED_SINCE,
Header::Vary => HEADER_VARY,
Header::Connection => HEADER_CONNECTION,
Header::KeepAlive => HEADER_KEEP_ALIVE,
Header::Accept => HEADER_ACCEPT,
Header::AcceptCharset => HEADER_ACCEPT_CHARSET,
Header::AcceptEncoding => HEADER_ACCEPT_ENCODING,
Header::AcceptLanguage => HEADER_ACCEPT_LANGUAGE,
Header::Expect => HEADER_EXPECT,
Header::MaxForwards => HEADER_MAX_FORWARDS,
Header::Cookie => HEADER_COOKIE,
Header::SetCookie => HEADER_SET_COOKIE,
Header::AccessControlAllowOrigin => HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
Header::AccessControlAllowCredentials => HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS,
Header::AccessControlAllowHeaders => HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
Header::AccessControlAllowMethods => HEADER_ACCESS_CONTROL_ALLOW_METHODS,
Header::AccessControlExposeHeaders => HEADER_ACCESS_CONTROL_EXPOSE_HEADERS,
Header::AccessControlMaxAge => HEADER_ACCESS_CONTROL_MAX_AGE,
Header::AccessControlRequestHeaders => HEADER_ACCESS_CONTROL_REQUEST_HEADERS,
Header::AccessControlRequestMethod => HEADER_ACCESS_CONTROL_REQUEST_METHOD,
Header::Origin => HEADER_ORIGIN,
Header::ServiceWorkerAllowed => HEADER_SERVICE_WORKER_ALLOWED,
Header::TimingAllowOrigin => HEADER_TIMING_ALLOW_ORIGIN,
Header::XPermittedCrossDomainPolicies => HEADER_X_PERMITTED_CROSS_DOMAIN_POLICIES,
Header::DNT => HEADER_DNT,
Header::Tk => HEADER_TK,
Header::ContentDisposition => HEADER_CONTENT_DISPOSITION,
Header::ContentLength => HEADER_CONTENT_LENGTH,
Header::ContentType => HEADER_CONTENT_TYPE,
Header::ContentEncoding => HEADER_CONTENT_ENCODING,
Header::ContentLanguage => HEADER_CONTENT_LANGUAGE,
Header::ContentLocation => HEADER_CONTENT_LOCATION,
Header::Forwarded => HEADER_FORWARDED,
Header::Via => HEADER_VIA,
Header::Location => HEADER_LOCATION,
Header::From => HEADER_FROM,
Header::Host => HEADER_HOST,
Header::Referer => HEADER_REFERER,
Header::ReferrerPolicy => HEADER_REFERRER_POLICY,
Header::UserAgent => HEADER_USER_AGENT,
Header::Allow => HEADER_ALLOW,
Header::Server => HEADER_SERVER,
Header::AcceptRanges => HEADER_ACCEPT_RANGES,
Header::Range => HEADER_RANGE,
Header::IfRange => HEADER_IF_RANGE,
Header::ContentRange => HEADER_CONTENT_RANGE,
Header::CrossOriginOpenerPolicy => HEADER_CROSS_ORIGIN_OPENER_POLICY,
Header::CrossOriginResourcePolicy => HEADER_CROSS_ORIGIN_RESOURCE_POLICY,
Header::ContentSecurityPolicy => HEADER_CONTENT_SECURITY_POLICY,
Header::ContentSecurityPolicyReportOnly => HEADER_CONTENT_SECURITY_POLICY_REPORT_ONLY,
Header::ExpectCT => HEADER_EXPECT_CT,
Header::FeaturePolicy => HEADER_FEATURE_POLICY,
Header::PublicKeyPins => HEADER_PUBLIC_KEY_PINS,
Header::PublicKeyPinsReportOnly => HEADER_PUBLIC_KEY_PINS_REPORT_ONLY,
Header::StrictTransportSecurity => HEADER_STRICT_TRANSPORT_SECURITY,
Header::UpgradeInsecureRequests => HEADER_UPGRADE_INSECURE_REQUESTS,
Header::XContentTypeOptions => HEADER_X_CONTENT_TYPE_OPTIONS,
Header::XDownloadOptions => HEADER_X_DOWNLOAD_OPTIONS,
Header::XFrameOptions => HEADER_X_FRAME_OPTIONS,
Header::XPoweredBy => HEADER_X_POWERED_BY,
Header::XXSSProtection => HEADER_X_XSS_PROTECTION,
Header::LastEventID => HEADER_LAST_EVENT_ID,
Header::PingFrom => HEADER_PING_FROM,
Header::PingTo => HEADER_PING_TO,
Header::ReportTo => HEADER_REPORT_TO,
Header::TransferEncoding => HEADER_TRANSFER_ENCODING,
Header::TE => HEADER_TE,
Header::Trailer => HEADER_TRAILER,
Header::SecWebSocketKey => HEADER_SEC_WEBSOCKET_KEY,
Header::SecWebSocketExtensions => HEADER_SEC_WEBSOCKET_EXTENSIONS,
Header::SecWebSocketAccept => HEADER_SEC_WEBSOCKET_ACCEPT,
Header::SecWebSocketProtocol => HEADER_SEC_WEBSOCKET_PROTOCOL,
Header::SecWebSocketVersion => HEADER_SEC_WEBSOCKET_VERSION,
Header::AltSvc => HEADER_ALT_SVC,
Header::Date => HEADER_DATE,
Header::LargeAllocation => HEADER_LARGE_ALLOCATION,
Header::Link => HEADER_LINK,
Header::RetryAfter => HEADER_RETRY_AFTER,
Header::ServerTiming => HEADER_SERVER_TIMING,
Header::SourceMap => HEADER_SOURCEMAP,
Header::Upgrade => HEADER_UPGRADE,
Header::XDNSPrefetchControl => HEADER_X_DNS_PREFETCH_CONTROL,
Header::XRequestedWith => HEADER_X_REQUESTED_WITH,
Header::Unknown(s) => s,
})
}
}
impl FromStr for Header {
type Err = Error;
fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
if let Some(result) = parse_authenticating_headers(s) {
return Ok(result);
}
if let Some(result) = parse_caching_headers(s) {
return Ok(result);
}
if let Some(result) = parse_conditional_headers(s) {
return Ok(result);
}
if let Some(result) = parse_connection_management_headers(s) {
return Ok(result);
}
if let Some(result) = parse_content_negotiating_headers(s) {
return Ok(result);
}
if let Some(result) = parse_control_headers(s) {
return Ok(result);
}
if let Some(result) = parse_cookie_headers(s) {
return Ok(result);
}
if let Some(result) = parse_cors_headers(s) {
return Ok(result);
}
if let Some(result) = parse_dnt_headers(s) {
return Ok(result);
}
if let Some(result) = parse_downloading_headers(s) {
return Ok(result);
}
if let Some(result) = parse_message_body_information_headers(s) {
return Ok(result);
}
if let Some(result) = parse_proxy_headers(s) {
return Ok(result);
}
if let Some(result) = parse_redirecting_headers(s) {
return Ok(result);
}
if let Some(result) = parse_request_headers(s) {
return Ok(result);
}
if let Some(result) = parse_response_headers(s) {
return Ok(result);
}
if let Some(result) = parse_range_headers(s) {
return Ok(result);
}
if let Some(result) = parse_security_headers(s) {
return Ok(result);
}
if let Some(result) = parse_server_headers(s) {
return Ok(result);
}
if let Some(result) = parse_transfer_encoding_headers(s) {
return Ok(result);
}
if let Some(result) = parse_web_sockets_headers(s) {
return Ok(result);
}
if let Some(result) = parse_other_headers(s) {
return Ok(result);
}
Ok(Header::Unknown(s.to_string()))
}
}
fn parse_authenticating_headers(s: &str) -> Option<Header> {
if HEADER_WWW_AUTHENTICATE.eq_ignore_ascii_case(s) {
return Some(Header::WWWAuthenticate);
}
if HEADER_AUTHORIZATION.eq_ignore_ascii_case(s) {
return Some(Header::Authorization);
}
if HEADER_PROXY_AUTHENTICATE.eq_ignore_ascii_case(s) {
return Some(Header::ProxyAuthenticate);
}
if HEADER_PROXY_AUTHORIZATION.eq_ignore_ascii_case(s) {
return Some(Header::ProxyAuthorization);
}
None
}
fn parse_caching_headers(s: &str) -> Option<Header> {
if HEADER_AGE.eq_ignore_ascii_case(s) {
return Some(Header::Age);
}
if HEADER_CACHE_CONTROL.eq_ignore_ascii_case(s) {
return Some(Header::CacheControl);
}
if HEADER_CLEAR_SITE_DATA.eq_ignore_ascii_case(s) {
return Some(Header::ClearSiteData);
}
if HEADER_EXPIRES.eq_ignore_ascii_case(s) {
return Some(Header::Expires);
}
if HEADER_PRAGMA.eq_ignore_ascii_case(s) {
return Some(Header::Pragma);
}
if HEADER_WARNING.eq_ignore_ascii_case(s) {
return Some(Header::Warning);
}
None
}
fn parse_conditional_headers(s: &str) -> Option<Header> {
if HEADER_LAST_MODIFIED.eq_ignore_ascii_case(s) {
return Some(Header::LastModified);
}
if HEADER_ETAG.eq_ignore_ascii_case(s) {
return Some(Header::ETag);
}
if HEADER_IF_MATCH.eq_ignore_ascii_case(s) {
return Some(Header::IfMatch);
}
if HEADER_IF_NONE_MATCH.eq_ignore_ascii_case(s) {
return Some(Header::IfNoneMatch);
}
if HEADER_IF_MODIFIED_SINCE.eq_ignore_ascii_case(s) {
return Some(Header::IfModifiedSince);
}
if HEADER_IF_UNMODIFIED_SINCE.eq_ignore_ascii_case(s) {
return Some(Header::IfUnmodifiedSince);
}
if HEADER_VARY.eq_ignore_ascii_case(s) {
return Some(Header::Vary);
}
None
}
fn parse_connection_management_headers(s: &str) -> Option<Header> {
if HEADER_CONNECTION.eq_ignore_ascii_case(s) {
return Some(Header::Connection);
}
if HEADER_KEEP_ALIVE.eq_ignore_ascii_case(s) {
return Some(Header::KeepAlive);
}
None
}
fn parse_content_negotiating_headers(s: &str) -> Option<Header> {
if HEADER_ACCEPT.eq_ignore_ascii_case(s) {
return Some(Header::Accept);
}
if HEADER_ACCEPT_CHARSET.eq_ignore_ascii_case(s) {
return Some(Header::AcceptCharset);
}
if HEADER_ACCEPT_ENCODING.eq_ignore_ascii_case(s) {
return Some(Header::AcceptEncoding);
}
if HEADER_ACCEPT_LANGUAGE.eq_ignore_ascii_case(s) {
return Some(Header::AcceptLanguage);
}
None
}
fn parse_control_headers(s: &str) -> Option<Header> {
if HEADER_EXPECT.eq_ignore_ascii_case(s) {
return Some(Header::Expect);
}
if HEADER_MAX_FORWARDS.eq_ignore_ascii_case(s) {
return Some(Header::MaxForwards);
}
None
}
fn parse_cookie_headers(s: &str) -> Option<Header> {
if HEADER_COOKIE.eq_ignore_ascii_case(s) {
return Some(Header::Cookie);
}
if HEADER_SET_COOKIE.eq_ignore_ascii_case(s) {
return Some(Header::SetCookie);
}
None
}
fn parse_cors_headers(s: &str) -> Option<Header> {
if HEADER_ACCESS_CONTROL_ALLOW_ORIGIN.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlAllowOrigin);
}
if HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlAllowCredentials);
}
if HEADER_ACCESS_CONTROL_ALLOW_HEADERS.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlAllowHeaders);
}
if HEADER_ACCESS_CONTROL_ALLOW_METHODS.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlAllowMethods);
}
if HEADER_ACCESS_CONTROL_EXPOSE_HEADERS.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlExposeHeaders);
}
if HEADER_ACCESS_CONTROL_MAX_AGE.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlMaxAge);
}
if HEADER_ACCESS_CONTROL_REQUEST_HEADERS.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlRequestHeaders);
}
if HEADER_ACCESS_CONTROL_REQUEST_METHOD.eq_ignore_ascii_case(s) {
return Some(Header::AccessControlRequestMethod);
}
if HEADER_ORIGIN.eq_ignore_ascii_case(s) {
return Some(Header::Origin);
}
if HEADER_SERVICE_WORKER_ALLOWED.eq_ignore_ascii_case(s) {
return Some(Header::ServiceWorkerAllowed);
}
if HEADER_TIMING_ALLOW_ORIGIN.eq_ignore_ascii_case(s) {
return Some(Header::TimingAllowOrigin);
}
if HEADER_X_PERMITTED_CROSS_DOMAIN_POLICIES.eq_ignore_ascii_case(s) {
return Some(Header::XPermittedCrossDomainPolicies);
}
None
}
fn parse_dnt_headers(s: &str) -> Option<Header> {
if HEADER_DNT.eq_ignore_ascii_case(s) {
return Some(Header::DNT);
}
if HEADER_TK.eq_ignore_ascii_case(s) {
return Some(Header::Tk);
}
None
}
fn parse_downloading_headers(s: &str) -> Option<Header> {
if HEADER_CONTENT_DISPOSITION.eq_ignore_ascii_case(s) {
return Some(Header::ContentDisposition);
}
None
}
fn parse_message_body_information_headers(s: &str) -> Option<Header> {
if HEADER_CONTENT_LENGTH.eq_ignore_ascii_case(s) {
return Some(Header::ContentLength);
}
if HEADER_CONTENT_TYPE.eq_ignore_ascii_case(s) {
return Some(Header::ContentType);
}
if HEADER_CONTENT_ENCODING.eq_ignore_ascii_case(s) {
return Some(Header::ContentEncoding);
}
if HEADER_CONTENT_LANGUAGE.eq_ignore_ascii_case(s) {
return Some(Header::ContentLanguage);
}
if HEADER_CONTENT_LOCATION.eq_ignore_ascii_case(s) {
return Some(Header::ContentLocation);
}
None
}
fn parse_proxy_headers(s: &str) -> Option<Header> {
if HEADER_FORWARDED.eq_ignore_ascii_case(s) {
return Some(Header::Forwarded);
}
if HEADER_VIA.eq_ignore_ascii_case(s) {
return Some(Header::Via);
}
None
}
fn parse_redirecting_headers(s: &str) -> Option<Header> {
if HEADER_LOCATION.eq_ignore_ascii_case(s) {
return Some(Header::Location);
}
None
}
fn parse_request_headers(s: &str) -> Option<Header> {
if HEADER_FROM.eq_ignore_ascii_case(s) {
return Some(Header::From);
}
if HEADER_HOST.eq_ignore_ascii_case(s) {
return Some(Header::Host);
}
if HEADER_REFERER.eq_ignore_ascii_case(s) {
return Some(Header::Referer);
}
if HEADER_REFERRER_POLICY.eq_ignore_ascii_case(s) {
return Some(Header::ReferrerPolicy);
}
if HEADER_USER_AGENT.eq_ignore_ascii_case(s) {
return Some(Header::UserAgent);
}
None
}
fn parse_response_headers(s: &str) -> Option<Header> {
if HEADER_ALLOW.eq_ignore_ascii_case(s) {
return Some(Header::Allow);
}
if HEADER_SERVER.eq_ignore_ascii_case(s) {
return Some(Header::Server);
}
None
}
fn parse_range_headers(s: &str) -> Option<Header> {
if HEADER_ACCEPT_RANGES.eq_ignore_ascii_case(s) {
return Some(Header::AcceptRanges);
}
if HEADER_RANGE.eq_ignore_ascii_case(s) {
return Some(Header::Range);
}
if HEADER_IF_RANGE.eq_ignore_ascii_case(s) {
return Some(Header::IfRange);
}
if HEADER_CONTENT_RANGE.eq_ignore_ascii_case(s) {
return Some(Header::ContentRange);
}
None
}
fn parse_security_headers(s: &str) -> Option<Header> {
if HEADER_CROSS_ORIGIN_OPENER_POLICY.eq_ignore_ascii_case(s) {
return Some(Header::CrossOriginOpenerPolicy);
}
if HEADER_CROSS_ORIGIN_RESOURCE_POLICY.eq_ignore_ascii_case(s) {
return Some(Header::CrossOriginResourcePolicy);
}
if HEADER_CONTENT_SECURITY_POLICY.eq_ignore_ascii_case(s) {
return Some(Header::ContentSecurityPolicy);
}
if HEADER_CONTENT_SECURITY_POLICY_REPORT_ONLY.eq_ignore_ascii_case(s) {
return Some(Header::ContentSecurityPolicyReportOnly);
}
if HEADER_EXPECT_CT.eq_ignore_ascii_case(s) {
return Some(Header::ExpectCT);
}
if HEADER_FEATURE_POLICY.eq_ignore_ascii_case(s) {
return Some(Header::FeaturePolicy);
}
if HEADER_PUBLIC_KEY_PINS.eq_ignore_ascii_case(s) {
return Some(Header::PublicKeyPins);
}
if HEADER_PUBLIC_KEY_PINS_REPORT_ONLY.eq_ignore_ascii_case(s) {
return Some(Header::PublicKeyPinsReportOnly);
}
if HEADER_STRICT_TRANSPORT_SECURITY.eq_ignore_ascii_case(s) {
return Some(Header::StrictTransportSecurity);
}
if HEADER_UPGRADE_INSECURE_REQUESTS.eq_ignore_ascii_case(s) {
return Some(Header::UpgradeInsecureRequests);
}
if HEADER_X_CONTENT_TYPE_OPTIONS.eq_ignore_ascii_case(s) {
return Some(Header::XContentTypeOptions);
}
if HEADER_X_DOWNLOAD_OPTIONS.eq_ignore_ascii_case(s) {
return Some(Header::XDownloadOptions);
}
if HEADER_X_FRAME_OPTIONS.eq_ignore_ascii_case(s) {
return Some(Header::XFrameOptions);
}
if HEADER_X_POWERED_BY.eq_ignore_ascii_case(s) {
return Some(Header::XPoweredBy);
}
if HEADER_X_XSS_PROTECTION.eq_ignore_ascii_case(s) {
return Some(Header::XXSSProtection);
}
None
}
fn parse_server_headers(s: &str) -> Option<Header> {
if HEADER_LAST_EVENT_ID.eq_ignore_ascii_case(s) {
return Some(Header::LastEventID);
}
if HEADER_PING_FROM.eq_ignore_ascii_case(s) {
return Some(Header::PingFrom);
}
if HEADER_PING_TO.eq_ignore_ascii_case(s) {
return Some(Header::PingTo);
}
if HEADER_REPORT_TO.eq_ignore_ascii_case(s) {
return Some(Header::ReportTo);
}
None
}
fn parse_transfer_encoding_headers(s: &str) -> Option<Header> {
if HEADER_TRANSFER_ENCODING.eq_ignore_ascii_case(s) {
return Some(Header::TransferEncoding);
}
if HEADER_TE.eq_ignore_ascii_case(s) {
return Some(Header::TE);
}
if HEADER_TRAILER.eq_ignore_ascii_case(s) {
return Some(Header::Trailer);
}
None
}
fn parse_web_sockets_headers(s: &str) -> Option<Header> {
if HEADER_SEC_WEBSOCKET_KEY.eq_ignore_ascii_case(s) {
return Some(Header::SecWebSocketKey);
}
if HEADER_SEC_WEBSOCKET_EXTENSIONS.eq_ignore_ascii_case(s) {
return Some(Header::SecWebSocketExtensions);
}
if HEADER_SEC_WEBSOCKET_ACCEPT.eq_ignore_ascii_case(s) {
return Some(Header::SecWebSocketAccept);
}
if HEADER_SEC_WEBSOCKET_PROTOCOL.eq_ignore_ascii_case(s) {
return Some(Header::SecWebSocketProtocol);
}
if HEADER_SEC_WEBSOCKET_VERSION.eq_ignore_ascii_case(s) {
return Some(Header::SecWebSocketVersion);
}
None
}
fn parse_other_headers(s: &str) -> Option<Header> {
if HEADER_ALT_SVC.eq_ignore_ascii_case(s) {
return Some(Header::AltSvc);
}
if HEADER_DATE.eq_ignore_ascii_case(s) {
return Some(Header::Date);
}
if HEADER_LARGE_ALLOCATION.eq_ignore_ascii_case(s) {
return Some(Header::LargeAllocation);
}
if HEADER_LINK.eq_ignore_ascii_case(s) {
return Some(Header::Link);
}
if HEADER_RETRY_AFTER.eq_ignore_ascii_case(s) {
return Some(Header::RetryAfter);
}
if HEADER_SERVER_TIMING.eq_ignore_ascii_case(s) {
return Some(Header::ServerTiming);
}
if HEADER_SOURCEMAP.eq_ignore_ascii_case(s) {
return Some(Header::SourceMap);
}
if HEADER_UPGRADE.eq_ignore_ascii_case(s) {
return Some(Header::Upgrade);
}
if HEADER_X_DNS_PREFETCH_CONTROL.eq_ignore_ascii_case(s) {
return Some(Header::XDNSPrefetchControl);
}
if HEADER_X_REQUESTED_WITH.eq_ignore_ascii_case(s) {
return Some(Header::XRequestedWith);
}
None
}