2 * nghttp2 - HTTP/2 C Library
4 * Copyright (c) 2012 Tatsuhiro Tsujikawa
6 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sublicense, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice shall be
15 * included in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 StringRef get_reason_phrase(unsigned int status_code) {
36 switch (status_code) {
38 return StringRef::from_lit("Continue");
40 return StringRef::from_lit("Switching Protocols");
42 return StringRef::from_lit("Early Hints");
44 return StringRef::from_lit("OK");
46 return StringRef::from_lit("Created");
48 return StringRef::from_lit("Accepted");
50 return StringRef::from_lit("Non-Authoritative Information");
52 return StringRef::from_lit("No Content");
54 return StringRef::from_lit("Reset Content");
56 return StringRef::from_lit("Partial Content");
58 return StringRef::from_lit("Multiple Choices");
60 return StringRef::from_lit("Moved Permanently");
62 return StringRef::from_lit("Found");
64 return StringRef::from_lit("See Other");
66 return StringRef::from_lit("Not Modified");
68 return StringRef::from_lit("Use Proxy");
69 // case 306: return StringRef::from_lit("(Unused)");
71 return StringRef::from_lit("Temporary Redirect");
73 return StringRef::from_lit("Permanent Redirect");
75 return StringRef::from_lit("Bad Request");
77 return StringRef::from_lit("Unauthorized");
79 return StringRef::from_lit("Payment Required");
81 return StringRef::from_lit("Forbidden");
83 return StringRef::from_lit("Not Found");
85 return StringRef::from_lit("Method Not Allowed");
87 return StringRef::from_lit("Not Acceptable");
89 return StringRef::from_lit("Proxy Authentication Required");
91 return StringRef::from_lit("Request Timeout");
93 return StringRef::from_lit("Conflict");
95 return StringRef::from_lit("Gone");
97 return StringRef::from_lit("Length Required");
99 return StringRef::from_lit("Precondition Failed");
101 return StringRef::from_lit("Payload Too Large");
103 return StringRef::from_lit("URI Too Long");
105 return StringRef::from_lit("Unsupported Media Type");
107 return StringRef::from_lit("Requested Range Not Satisfiable");
109 return StringRef::from_lit("Expectation Failed");
111 return StringRef::from_lit("Misdirected Request");
113 // https://tools.ietf.org/html/rfc8470
114 return StringRef::from_lit("Too Early");
116 return StringRef::from_lit("Upgrade Required");
118 return StringRef::from_lit("Precondition Required");
120 return StringRef::from_lit("Too Many Requests");
122 return StringRef::from_lit("Request Header Fields Too Large");
124 return StringRef::from_lit("Unavailable For Legal Reasons");
126 return StringRef::from_lit("Internal Server Error");
128 return StringRef::from_lit("Not Implemented");
130 return StringRef::from_lit("Bad Gateway");
132 return StringRef::from_lit("Service Unavailable");
134 return StringRef::from_lit("Gateway Timeout");
136 return StringRef::from_lit("HTTP Version Not Supported");
138 return StringRef::from_lit("Network Authentication Required");
144 StringRef stringify_status(BlockAllocator &balloc, unsigned int status_code) {
145 switch (status_code) {
147 return StringRef::from_lit("100");
149 return StringRef::from_lit("101");
151 return StringRef::from_lit("103");
153 return StringRef::from_lit("200");
155 return StringRef::from_lit("201");
157 return StringRef::from_lit("202");
159 return StringRef::from_lit("203");
161 return StringRef::from_lit("204");
163 return StringRef::from_lit("205");
165 return StringRef::from_lit("206");
167 return StringRef::from_lit("300");
169 return StringRef::from_lit("301");
171 return StringRef::from_lit("302");
173 return StringRef::from_lit("303");
175 return StringRef::from_lit("304");
177 return StringRef::from_lit("305");
178 // case 306: return StringRef::from_lit("306");
180 return StringRef::from_lit("307");
182 return StringRef::from_lit("308");
184 return StringRef::from_lit("400");
186 return StringRef::from_lit("401");
188 return StringRef::from_lit("402");
190 return StringRef::from_lit("403");
192 return StringRef::from_lit("404");
194 return StringRef::from_lit("405");
196 return StringRef::from_lit("406");
198 return StringRef::from_lit("407");
200 return StringRef::from_lit("408");
202 return StringRef::from_lit("409");
204 return StringRef::from_lit("410");
206 return StringRef::from_lit("411");
208 return StringRef::from_lit("412");
210 return StringRef::from_lit("413");
212 return StringRef::from_lit("414");
214 return StringRef::from_lit("415");
216 return StringRef::from_lit("416");
218 return StringRef::from_lit("417");
220 return StringRef::from_lit("421");
222 return StringRef::from_lit("426");
224 return StringRef::from_lit("428");
226 return StringRef::from_lit("429");
228 return StringRef::from_lit("431");
230 return StringRef::from_lit("451");
232 return StringRef::from_lit("500");
234 return StringRef::from_lit("501");
236 return StringRef::from_lit("502");
238 return StringRef::from_lit("503");
240 return StringRef::from_lit("504");
242 return StringRef::from_lit("505");
244 return StringRef::from_lit("511");
246 return util::make_string_ref_uint(balloc, status_code);
250 void capitalize(DefaultMemchunks *buf, const StringRef &s) {
251 buf->append(util::upcase(s[0]));
252 for (size_t i = 1; i < s.size(); ++i) {
253 if (s[i - 1] == '-') {
254 buf->append(util::upcase(s[i]));
261 bool lws(const char *value) {
262 for (; *value; ++value) {
274 void copy_url_component(std::string &dest, const http_parser_url *u, int field,
276 if (u->field_set & (1 << field)) {
277 dest.assign(url + u->field_data[field].off, u->field_data[field].len);
281 Headers::value_type to_header(const uint8_t *name, size_t namelen,
282 const uint8_t *value, size_t valuelen,
283 bool no_index, int32_t token) {
284 return Header(std::string(reinterpret_cast<const char *>(name), namelen),
285 std::string(reinterpret_cast<const char *>(value), valuelen),
289 void add_header(Headers &nva, const uint8_t *name, size_t namelen,
290 const uint8_t *value, size_t valuelen, bool no_index,
294 for (i = 0; i < valuelen && (value[i] == ' ' || value[i] == '\t'); ++i)
296 for (j = valuelen - 1; j > i && (value[j] == ' ' || value[j] == '\t'); --j)
299 valuelen -= i + (valuelen - j - 1);
301 nva.push_back(to_header(name, namelen, value, valuelen, no_index, token));
304 const Headers::value_type *get_header(const Headers &nva, const char *name) {
305 const Headers::value_type *res = nullptr;
306 for (auto &nv : nva) {
307 if (nv.name == name) {
314 bool non_empty_value(const HeaderRefs::value_type *nv) {
315 return nv && !nv->value.empty();
319 nghttp2_nv make_nv_internal(const std::string &name, const std::string &value,
320 bool no_index, uint8_t nv_flags) {
324 nv_flags | (no_index ? NGHTTP2_NV_FLAG_NO_INDEX : NGHTTP2_NV_FLAG_NONE);
326 return {(uint8_t *)name.c_str(), (uint8_t *)value.c_str(), name.size(),
327 value.size(), flags};
332 nghttp2_nv make_nv_internal(const StringRef &name, const StringRef &value,
333 bool no_index, uint8_t nv_flags) {
337 nv_flags | (no_index ? NGHTTP2_NV_FLAG_NO_INDEX : NGHTTP2_NV_FLAG_NONE);
339 return {(uint8_t *)name.c_str(), (uint8_t *)value.c_str(), name.size(),
340 value.size(), flags};
344 nghttp2_nv make_nv(const std::string &name, const std::string &value,
346 return make_nv_internal(name, value, no_index, NGHTTP2_NV_FLAG_NONE);
349 nghttp2_nv make_nv(const StringRef &name, const StringRef &value,
351 return make_nv_internal(name, value, no_index, NGHTTP2_NV_FLAG_NONE);
354 nghttp2_nv make_nv_nocopy(const std::string &name, const std::string &value,
356 return make_nv_internal(name, value, no_index,
357 NGHTTP2_NV_FLAG_NO_COPY_NAME |
358 NGHTTP2_NV_FLAG_NO_COPY_VALUE);
361 nghttp2_nv make_nv_nocopy(const StringRef &name, const StringRef &value,
363 return make_nv_internal(name, value, no_index,
364 NGHTTP2_NV_FLAG_NO_COPY_NAME |
365 NGHTTP2_NV_FLAG_NO_COPY_VALUE);
369 void copy_headers_to_nva_internal(std::vector<nghttp2_nv> &nva,
370 const HeaderRefs &headers, uint8_t nv_flags,
372 auto it_forwarded = std::end(headers);
373 auto it_xff = std::end(headers);
374 auto it_xfp = std::end(headers);
375 auto it_via = std::end(headers);
377 for (auto it = std::begin(headers); it != std::end(headers); ++it) {
379 if (kv->name.empty() || kv->name[0] == ':') {
386 case HD_HTTP2_SETTINGS:
388 case HD_PROXY_CONNECTION:
391 case HD_TRANSFER_ENCODING:
395 if (flags & HDOP_STRIP_EARLY_DATA) {
399 case HD_SEC_WEBSOCKET_ACCEPT:
400 if (flags & HDOP_STRIP_SEC_WEBSOCKET_ACCEPT) {
404 case HD_SEC_WEBSOCKET_KEY:
405 if (flags & HDOP_STRIP_SEC_WEBSOCKET_KEY) {
410 if (flags & HDOP_STRIP_FORWARDED) {
414 if (it_forwarded == std::end(headers)) {
419 kv = &(*it_forwarded);
422 case HD_X_FORWARDED_FOR:
423 if (flags & HDOP_STRIP_X_FORWARDED_FOR) {
427 if (it_xff == std::end(headers)) {
435 case HD_X_FORWARDED_PROTO:
436 if (flags & HDOP_STRIP_X_FORWARDED_PROTO) {
440 if (it_xfp == std::end(headers)) {
449 if (flags & HDOP_STRIP_VIA) {
453 if (it_via == std::end(headers)) {
463 make_nv_internal(kv->name, kv->value, kv->no_index, nv_flags));
468 void copy_headers_to_nva(std::vector<nghttp2_nv> &nva,
469 const HeaderRefs &headers, uint32_t flags) {
470 copy_headers_to_nva_internal(nva, headers, NGHTTP2_NV_FLAG_NONE, flags);
473 void copy_headers_to_nva_nocopy(std::vector<nghttp2_nv> &nva,
474 const HeaderRefs &headers, uint32_t flags) {
475 copy_headers_to_nva_internal(
477 NGHTTP2_NV_FLAG_NO_COPY_NAME | NGHTTP2_NV_FLAG_NO_COPY_VALUE, flags);
480 void build_http1_headers_from_headers(DefaultMemchunks *buf,
481 const HeaderRefs &headers,
483 auto it_forwarded = std::end(headers);
484 auto it_xff = std::end(headers);
485 auto it_xfp = std::end(headers);
486 auto it_via = std::end(headers);
488 for (auto it = std::begin(headers); it != std::end(headers); ++it) {
490 if (kv->name.empty() || kv->name[0] == ':') {
497 case HD_HTTP2_SETTINGS:
499 case HD_PROXY_CONNECTION:
504 if (flags & HDOP_STRIP_EARLY_DATA) {
508 case HD_TRANSFER_ENCODING:
509 if (flags & HDOP_STRIP_TRANSFER_ENCODING) {
514 if (flags & HDOP_STRIP_FORWARDED) {
518 if (it_forwarded == std::end(headers)) {
523 kv = &(*it_forwarded);
526 case HD_X_FORWARDED_FOR:
527 if (flags & HDOP_STRIP_X_FORWARDED_FOR) {
531 if (it_xff == std::end(headers)) {
539 case HD_X_FORWARDED_PROTO:
540 if (flags & HDOP_STRIP_X_FORWARDED_PROTO) {
544 if (it_xfp == std::end(headers)) {
553 if (flags & HDOP_STRIP_VIA) {
557 if (it_via == std::end(headers)) {
566 capitalize(buf, kv->name);
568 buf->append(kv->value);
573 int32_t determine_window_update_transmission(nghttp2_session *session,
575 int32_t recv_length, window_size;
576 if (stream_id == 0) {
577 recv_length = nghttp2_session_get_effective_recv_data_length(session);
578 window_size = nghttp2_session_get_effective_local_window_size(session);
580 recv_length = nghttp2_session_get_stream_effective_recv_data_length(
582 window_size = nghttp2_session_get_stream_effective_local_window_size(
585 if (recv_length != -1 && window_size != -1) {
586 if (recv_length >= window_size / 2) {
593 void dump_nv(FILE *out, const char **nv) {
594 for (size_t i = 0; nv[i]; i += 2) {
595 fprintf(out, "%s: %s\n", nv[i], nv[i + 1]);
601 void dump_nv(FILE *out, const nghttp2_nv *nva, size_t nvlen) {
602 auto end = nva + nvlen;
603 for (; nva != end; ++nva) {
604 fprintf(out, "%s: %s\n", nva->name, nva->value);
610 void dump_nv(FILE *out, const Headers &nva) {
611 for (auto &nv : nva) {
612 fprintf(out, "%s: %s\n", nv.name.c_str(), nv.value.c_str());
618 void dump_nv(FILE *out, const HeaderRefs &nva) {
619 for (auto &nv : nva) {
620 fprintf(out, "%s: %s\n", nv.name.c_str(), nv.value.c_str());
626 void erase_header(HeaderRef *hd) {
627 hd->name = StringRef{};
631 StringRef rewrite_location_uri(BlockAllocator &balloc, const StringRef &uri,
632 const http_parser_url &u,
633 const StringRef &match_host,
634 const StringRef &request_authority,
635 const StringRef &upstream_scheme) {
636 // We just rewrite scheme and authority.
637 if ((u.field_set & (1 << UF_HOST)) == 0) {
640 auto field = &u.field_data[UF_HOST];
641 if (!util::starts_with(std::begin(match_host), std::end(match_host),
642 &uri[field->off], &uri[field->off] + field->len) ||
643 (match_host.size() != field->len && match_host[field->len] != ':')) {
648 if (!request_authority.empty()) {
649 len += upstream_scheme.size() + str_size("://") + request_authority.size();
652 if (u.field_set & (1 << UF_PATH)) {
653 field = &u.field_data[UF_PATH];
657 if (u.field_set & (1 << UF_QUERY)) {
658 field = &u.field_data[UF_QUERY];
659 len += 1 + field->len;
662 if (u.field_set & (1 << UF_FRAGMENT)) {
663 field = &u.field_data[UF_FRAGMENT];
664 len += 1 + field->len;
667 auto iov = make_byte_ref(balloc, len + 1);
670 if (!request_authority.empty()) {
671 p = std::copy(std::begin(upstream_scheme), std::end(upstream_scheme), p);
672 p = util::copy_lit(p, "://");
673 p = std::copy(std::begin(request_authority), std::end(request_authority),
676 if (u.field_set & (1 << UF_PATH)) {
677 field = &u.field_data[UF_PATH];
678 p = std::copy_n(&uri[field->off], field->len, p);
680 if (u.field_set & (1 << UF_QUERY)) {
681 field = &u.field_data[UF_QUERY];
683 p = std::copy_n(&uri[field->off], field->len, p);
685 if (u.field_set & (1 << UF_FRAGMENT)) {
686 field = &u.field_data[UF_FRAGMENT];
688 p = std::copy_n(&uri[field->off], field->len, p);
693 return StringRef{iov.base, p};
696 int check_nv(const uint8_t *name, size_t namelen, const uint8_t *value,
698 if (!nghttp2_check_header_name(name, namelen)) {
701 if (!nghttp2_check_header_value(value, valuelen)) {
707 int parse_http_status_code(const StringRef &src) {
708 if (src.size() != 3) {
728 int lookup_token(const StringRef &name) {
729 return lookup_token(name.byte(), name.size());
732 // This function was generated by genheaderfunc.py. Inspired by h2o
733 // header lookup. https://github.com/h2o/h2o
734 int lookup_token(const uint8_t *name, size_t namelen) {
739 if (util::streq_l("t", name, 1)) {
748 if (util::streq_l("vi", name, 2)) {
757 if (util::streq_l("dat", name, 3)) {
762 if (util::streq_l("lin", name, 3)) {
767 if (util::streq_l("hos", name, 3)) {
776 if (util::streq_l(":pat", name, 4)) {
781 if (util::streq_l(":hos", name, 4)) {
790 if (util::streq_l("cooki", name, 5)) {
795 if (util::streq_l("serve", name, 5)) {
800 if (util::streq_l("expec", name, 5)) {
809 if (util::streq_l("alt-sv", name, 6)) {
814 if (util::streq_l(":metho", name, 6)) {
819 if (util::streq_l(":schem", name, 6)) {
822 if (util::streq_l("upgrad", name, 6)) {
827 if (util::streq_l("traile", name, 6)) {
832 if (util::streq_l(":statu", name, 6)) {
841 if (util::streq_l("locatio", name, 7)) {
850 if (util::streq_l("forwarde", name, 8)) {
855 if (util::streq_l(":protoco", name, 8)) {
864 if (util::streq_l("early-dat", name, 9)) {
865 return HD_EARLY_DATA;
869 if (util::streq_l("keep-aliv", name, 9)) {
870 return HD_KEEP_ALIVE;
874 if (util::streq_l("connectio", name, 9)) {
875 return HD_CONNECTION;
879 if (util::streq_l("user-agen", name, 9)) {
880 return HD_USER_AGENT;
884 if (util::streq_l(":authorit", name, 9)) {
885 return HD__AUTHORITY;
893 if (util::streq_l("content-typ", name, 11)) {
894 return HD_CONTENT_TYPE;
902 if (util::streq_l("cache-contro", name, 12)) {
903 return HD_CACHE_CONTROL;
911 if (util::streq_l("content-lengt", name, 13)) {
912 return HD_CONTENT_LENGTH;
916 if (util::streq_l("http2-setting", name, 13)) {
917 return HD_HTTP2_SETTINGS;
925 if (util::streq_l("accept-languag", name, 14)) {
926 return HD_ACCEPT_LANGUAGE;
930 if (util::streq_l("accept-encodin", name, 14)) {
931 return HD_ACCEPT_ENCODING;
935 if (util::streq_l("x-forwarded-fo", name, 14)) {
936 return HD_X_FORWARDED_FOR;
944 if (util::streq_l("proxy-connectio", name, 15)) {
945 return HD_PROXY_CONNECTION;
953 if (util::streq_l("if-modified-sinc", name, 16)) {
954 return HD_IF_MODIFIED_SINCE;
958 if (util::streq_l("transfer-encodin", name, 16)) {
959 return HD_TRANSFER_ENCODING;
963 if (util::streq_l("x-forwarded-prot", name, 16)) {
964 return HD_X_FORWARDED_PROTO;
968 if (util::streq_l("sec-websocket-ke", name, 16)) {
969 return HD_SEC_WEBSOCKET_KEY;
977 if (util::streq_l("sec-websocket-accep", name, 19)) {
978 return HD_SEC_WEBSOCKET_ACCEPT;
987 void init_hdidx(HeaderIndex &hdidx) {
988 std::fill(std::begin(hdidx), std::end(hdidx), -1);
991 void index_header(HeaderIndex &hdidx, int32_t token, size_t idx) {
995 assert(token < HD_MAXIDX);
999 const Headers::value_type *get_header(const HeaderIndex &hdidx, int32_t token,
1000 const Headers &nva) {
1001 auto i = hdidx[token];
1008 Headers::value_type *get_header(const HeaderIndex &hdidx, int32_t token,
1010 auto i = hdidx[token];
1018 template <typename InputIt> InputIt skip_lws(InputIt first, InputIt last) {
1019 for (; first != last; ++first) {
1033 template <typename InputIt>
1034 InputIt skip_to_next_field(InputIt first, InputIt last) {
1035 for (; first != last; ++first) {
1050 // Skip to the right dquote ('"'), handling backslash escapes.
1051 // Returns |last| if input is not terminated with '"'.
1052 template <typename InputIt>
1053 InputIt skip_to_right_dquote(InputIt first, InputIt last) {
1054 for (; first != last;) {
1060 if (first == last) {
1072 // Returns true if link-param does not match pattern |pat| of length
1073 // |patlen| or it has empty value (""). |pat| should be parmname
1075 bool check_link_param_empty(const char *first, const char *last,
1076 const char *pat, size_t patlen) {
1077 if (first + patlen <= last) {
1078 if (std::equal(pat, pat + patlen, first, util::CaseCmp())) {
1079 // we only accept URI if pat is followd by "" (e.g.,
1080 // loadpolicy="") here.
1081 if (first + patlen + 2 <= last) {
1082 if (*(first + patlen) != '"' || *(first + patlen + 1) != '"') {
1086 // here we got invalid production (anchor=") or anchor=?
1096 // Returns true if link-param consists of only parmname, and it
1097 // matches string [pat, pat + patlen).
1098 bool check_link_param_without_value(const char *first, const char *last,
1099 const char *pat, size_t patlen) {
1100 if (first + patlen > last) {
1104 if (first + patlen == last) {
1105 return std::equal(pat, pat + patlen, first, util::CaseCmp());
1108 switch (*(first + patlen)) {
1111 return std::equal(pat, pat + patlen, first, util::CaseCmp());
1119 std::pair<LinkHeader, const char *>
1120 parse_next_link_header_once(const char *first, const char *last) {
1121 first = skip_to_next_field(first, last);
1122 if (first == last || *first != '<') {
1123 return {{StringRef{}}, last};
1125 auto url_first = ++first;
1126 first = std::find(first, last, '>');
1127 if (first == last) {
1128 return {{StringRef{}}, first};
1130 auto url_last = first++;
1131 if (first == last) {
1132 return {{StringRef{}}, first};
1134 // we expect ';' or ',' here
1137 return {{StringRef{}}, ++first};
1142 return {{StringRef{}}, last};
1148 first = skip_lws(first, last);
1149 if (first == last) {
1150 return {{StringRef{}}, first};
1152 // we expect link-param
1156 // rel can take several relations using quoted form.
1157 static constexpr char PLP[] = "rel=\"";
1158 static constexpr size_t PLPLEN = str_size(PLP);
1160 static constexpr char PLT[] = "preload";
1161 static constexpr size_t PLTLEN = str_size(PLT);
1162 if (first + PLPLEN < last && *(first + PLPLEN - 1) == '"' &&
1163 std::equal(PLP, PLP + PLPLEN, first, util::CaseCmp())) {
1164 // we have to search preload in whitespace separated list:
1165 // rel="preload something http://example.org/foo"
1168 for (; first != last;) {
1169 if (*first != ' ' && *first != '"') {
1174 if (start == first) {
1175 return {{StringRef{}}, last};
1178 if (!ok && start + PLTLEN == first &&
1179 std::equal(PLT, PLT + PLTLEN, start, util::CaseCmp())) {
1183 if (*first == '"') {
1186 first = skip_lws(first, last);
1189 if (first == last) {
1190 return {{StringRef{}}, last};
1192 assert(*first == '"');
1194 if (first == last || *first == ',') {
1197 if (*first == ';') {
1199 // parse next link-param
1202 return {{StringRef{}}, last};
1205 // we are only interested in rel=preload parameter. Others are
1207 static constexpr char PL[] = "rel=preload";
1208 static constexpr size_t PLLEN = str_size(PL);
1209 if (first + PLLEN == last) {
1210 if (std::equal(PL, PL + PLLEN, first, util::CaseCmp())) {
1212 // this is the end of sequence
1213 return {{{url_first, url_last}}, last};
1215 } else if (first + PLLEN + 1 <= last) {
1216 switch (*(first + PLLEN)) {
1218 if (!std::equal(PL, PL + PLLEN, first, util::CaseCmp())) {
1222 // skip including ','
1224 return {{{url_first, url_last}}, first};
1226 if (!std::equal(PL, PL + PLLEN, first, util::CaseCmp())) {
1230 // skip including ';'
1232 // continue parse next link-param
1236 // we have to reject URI if we have nonempty anchor parameter.
1237 static constexpr char ANCHOR[] = "anchor=";
1238 static constexpr size_t ANCHORLEN = str_size(ANCHOR);
1239 if (!ign && !check_link_param_empty(first, last, ANCHOR, ANCHORLEN)) {
1243 // reject URI if we have non-empty loadpolicy. This could be
1244 // tightened up to just pick up "next" or "insert".
1245 static constexpr char LOADPOLICY[] = "loadpolicy=";
1246 static constexpr size_t LOADPOLICYLEN = str_size(LOADPOLICY);
1248 !check_link_param_empty(first, last, LOADPOLICY, LOADPOLICYLEN)) {
1252 // reject URI if we have nopush attribute.
1253 static constexpr char NOPUSH[] = "nopush";
1254 static constexpr size_t NOPUSHLEN = str_size(NOPUSH);
1256 check_link_param_without_value(first, last, NOPUSH, NOPUSHLEN)) {
1261 auto param_first = first;
1262 for (; first != last;) {
1263 if (util::in_attr_char(*first)) {
1267 // '*' is only allowed at the end of parameter name and must be
1269 if (last - first >= 2 && first != param_first) {
1270 if (*first == '*' && *(first + 1) == '=') {
1275 if (*first == '=' || *first == ';' || *first == ',') {
1278 return {{StringRef{}}, last};
1280 if (param_first == first) {
1282 return {{StringRef{}}, last};
1284 // link-param without value is acceptable (see link-extension) if
1285 // it is not followed by '='
1286 if (first == last || *first == ',') {
1289 if (*first == ';') {
1291 // parse next link-param
1294 // now parsing link-param value
1295 assert(*first == '=');
1297 if (first == last) {
1298 // empty value is not acceptable
1299 return {{StringRef{}}, first};
1301 if (*first == '"') {
1303 first = skip_to_right_dquote(first + 1, last);
1304 if (first == last) {
1305 return {{StringRef{}}, first};
1308 if (first == last || *first == ',') {
1311 if (*first == ';') {
1313 // parse next link-param
1316 return {{StringRef{}}, last};
1318 // not quoted-string, skip to next ',' or ';'
1319 if (*first == ',' || *first == ';') {
1321 return {{StringRef{}}, last};
1323 for (; first != last; ++first) {
1324 if (*first == ',' || *first == ';') {
1328 if (first == last || *first == ',') {
1331 assert(*first == ';');
1333 // parse next link-param
1337 assert(first == last || *first == ',');
1339 if (first != last) {
1343 return {{{url_first, url_last}}, first};
1345 return {{StringRef{}}, first};
1349 std::vector<LinkHeader> parse_link_header(const StringRef &src) {
1350 std::vector<LinkHeader> res;
1351 for (auto first = std::begin(src); first != std::end(src);) {
1352 auto rv = parse_next_link_header_once(first, std::end(src));
1354 auto &link = rv.first;
1355 if (!link.uri.empty()) {
1356 res.push_back(link);
1362 std::string path_join(const StringRef &base_path, const StringRef &base_query,
1363 const StringRef &rel_path, const StringRef &rel_query) {
1364 BlockAllocator balloc(1024, 1024);
1366 return path_join(balloc, base_path, base_query, rel_path, rel_query).str();
1369 bool expect_response_body(int status_code) {
1370 return status_code == 101 ||
1371 (status_code / 100 != 1 && status_code != 304 && status_code != 204);
1374 bool expect_response_body(const std::string &method, int status_code) {
1375 return method != "HEAD" && expect_response_body(status_code);
1378 bool expect_response_body(int method_token, int status_code) {
1379 return method_token != HTTP_HEAD && expect_response_body(status_code);
1382 int lookup_method_token(const StringRef &name) {
1383 return lookup_method_token(name.byte(), name.size());
1386 // This function was generated by genmethodfunc.py.
1387 int lookup_method_token(const uint8_t *name, size_t namelen) {
1392 if (util::streq_l("AC", name, 2)) {
1397 if (util::streq_l("GE", name, 2)) {
1400 if (util::streq_l("PU", name, 2)) {
1409 if (util::streq_l("BIN", name, 3)) {
1412 if (util::streq_l("HEA", name, 3)) {
1417 if (util::streq_l("MOV", name, 3)) {
1422 if (util::streq_l("LIN", name, 3)) {
1425 if (util::streq_l("LOC", name, 3)) {
1430 if (util::streq_l("POS", name, 3)) {
1435 if (util::streq_l("COP", name, 3)) {
1444 if (util::streq_l("MERG", name, 4)) {
1447 if (util::streq_l("PURG", name, 4)) {
1450 if (util::streq_l("TRAC", name, 4)) {
1455 if (util::streq_l("PATC", name, 4)) {
1460 if (util::streq_l("MKCO", name, 4)) {
1469 if (util::streq_l("REBIN", name, 5)) {
1472 if (util::streq_l("UNBIN", name, 5)) {
1477 if (util::streq_l("DELET", name, 5)) {
1480 if (util::streq_l("SOURC", name, 5)) {
1485 if (util::streq_l("SEARC", name, 5)) {
1490 if (util::streq_l("UNLIN", name, 5)) {
1493 if (util::streq_l("UNLOC", name, 5)) {
1498 if (util::streq_l("REPOR", name, 5)) {
1503 if (util::streq_l("NOTIF", name, 5)) {
1512 if (util::streq_l("MSEARC", name, 6)) {
1513 return HTTP_MSEARCH;
1517 if (util::streq_l("OPTION", name, 6)) {
1518 return HTTP_OPTIONS;
1522 if (util::streq_l("CONNEC", name, 6)) {
1523 return HTTP_CONNECT;
1531 if (util::streq_l("PROPFIN", name, 7)) {
1532 return HTTP_PROPFIND;
1536 if (util::streq_l("CHECKOU", name, 7)) {
1537 return HTTP_CHECKOUT;
1545 if (util::streq_l("SUBSCRIB", name, 8)) {
1546 return HTTP_SUBSCRIBE;
1550 if (util::streq_l("PROPPATC", name, 8)) {
1551 return HTTP_PROPPATCH;
1559 if (util::streq_l("MKCALENDA", name, 9)) {
1560 return HTTP_MKCALENDAR;
1564 if (util::streq_l("MKACTIVIT", name, 9)) {
1565 return HTTP_MKACTIVITY;
1573 if (util::streq_l("UNSUBSCRIB", name, 10)) {
1574 return HTTP_UNSUBSCRIBE;
1583 StringRef to_method_string(int method_token) {
1584 // we happened to use same value for method with llhttp.
1586 llhttp_method_name(static_cast<llhttp_method>(method_token))};
1589 StringRef get_pure_path_component(const StringRef &uri) {
1592 http_parser_url u{};
1593 rv = http_parser_parse_url(uri.c_str(), uri.size(), 0, &u);
1598 if (u.field_set & (1 << UF_PATH)) {
1599 auto &f = u.field_data[UF_PATH];
1600 return StringRef{uri.c_str() + f.off, f.len};
1603 return StringRef::from_lit("/");
1606 int construct_push_component(BlockAllocator &balloc, StringRef &scheme,
1607 StringRef &authority, StringRef &path,
1608 const StringRef &base, const StringRef &uri) {
1610 StringRef rel, relq;
1612 if (uri.size() == 0) {
1616 http_parser_url u{};
1618 rv = http_parser_parse_url(uri.c_str(), uri.size(), 0, &u);
1621 if (uri[0] == '/') {
1625 // treat link_url as relative URI.
1626 auto end = std::find(std::begin(uri), std::end(uri), '#');
1627 auto q = std::find(std::begin(uri), end, '?');
1629 rel = StringRef{std::begin(uri), q};
1631 relq = StringRef{q + 1, std::end(uri)};
1634 if (u.field_set & (1 << UF_SCHEMA)) {
1635 scheme = util::get_uri_field(uri.c_str(), u, UF_SCHEMA);
1638 if (u.field_set & (1 << UF_HOST)) {
1639 auto auth = util::get_uri_field(uri.c_str(), u, UF_HOST);
1640 auto len = auth.size();
1641 auto port_exists = u.field_set & (1 << UF_PORT);
1643 len += 1 + str_size("65535");
1645 auto iov = make_byte_ref(balloc, len + 1);
1647 p = std::copy(std::begin(auth), std::end(auth), p);
1650 p = util::utos(p, u.port);
1654 authority = StringRef{iov.base, p};
1657 if (u.field_set & (1 << UF_PATH)) {
1658 auto &f = u.field_data[UF_PATH];
1659 rel = StringRef{uri.c_str() + f.off, f.len};
1661 rel = StringRef::from_lit("/");
1664 if (u.field_set & (1 << UF_QUERY)) {
1665 auto &f = u.field_data[UF_QUERY];
1666 relq = StringRef{uri.c_str() + f.off, f.len};
1670 path = http2::path_join(balloc, base, StringRef{}, rel, relq);
1676 template <typename InputIt> InputIt eat_file(InputIt first, InputIt last) {
1677 if (first == last) {
1682 if (*(last - 1) == '/') {
1687 for (; p != first && *(p - 1) != '/'; --p)
1690 // this should not happened in normal case, where we expect path
1701 template <typename InputIt> InputIt eat_dir(InputIt first, InputIt last) {
1702 auto p = eat_file(first, last);
1708 return eat_file(first, p);
1712 StringRef path_join(BlockAllocator &balloc, const StringRef &base_path,
1713 const StringRef &base_query, const StringRef &rel_path,
1714 const StringRef &rel_query) {
1715 auto res = make_byte_ref(
1716 balloc, std::max(static_cast<size_t>(1), base_path.size()) +
1717 rel_path.size() + 1 +
1718 std::max(base_query.size(), rel_query.size()) + 1);
1721 if (rel_path.empty()) {
1722 if (base_path.empty()) {
1725 p = std::copy(std::begin(base_path), std::end(base_path), p);
1727 if (rel_query.empty()) {
1728 if (!base_query.empty()) {
1730 p = std::copy(std::begin(base_query), std::end(base_query), p);
1733 return StringRef{res.base, p};
1736 p = std::copy(std::begin(rel_query), std::end(rel_query), p);
1738 return StringRef{res.base, p};
1741 auto first = std::begin(rel_path);
1742 auto last = std::end(rel_path);
1744 if (rel_path[0] == '/') {
1747 for (; first != last && *first == '/'; ++first)
1749 } else if (base_path.empty()) {
1752 p = std::copy(std::begin(base_path), std::end(base_path), p);
1755 for (; first != last;) {
1756 if (*first == '.') {
1757 if (first + 1 == last) {
1760 if (*(first + 1) == '/') {
1764 if (*(first + 1) == '.') {
1765 if (first + 2 == last) {
1766 p = eat_dir(res.base, p);
1769 if (*(first + 2) == '/') {
1770 p = eat_dir(res.base, p);
1776 if (*(p - 1) != '/') {
1777 p = eat_file(res.base, p);
1779 auto slash = std::find(first, last, '/');
1780 if (slash == last) {
1781 p = std::copy(first, last, p);
1784 p = std::copy(first, slash + 1, p);
1786 for (; first != last && *first == '/'; ++first)
1789 if (!rel_query.empty()) {
1791 p = std::copy(std::begin(rel_query), std::end(rel_query), p);
1794 return StringRef{res.base, p};
1797 StringRef normalize_path(BlockAllocator &balloc, const StringRef &path,
1798 const StringRef &query) {
1799 // First, decode %XX for unreserved characters, then do
1802 // We won't find %XX if length is less than 3.
1803 if (path.size() < 3 ||
1804 std::find(std::begin(path), std::end(path), '%') == std::end(path)) {
1805 return path_join(balloc, StringRef{}, StringRef{}, path, query);
1808 // includes last terminal NULL.
1809 auto result = make_byte_ref(balloc, path.size() + 1);
1810 auto p = result.base;
1812 auto it = std::begin(path);
1813 for (; it + 2 < std::end(path);) {
1815 if (util::is_hex_digit(*(it + 1)) && util::is_hex_digit(*(it + 2))) {
1817 (util::hex_to_uint(*(it + 1)) << 4) + util::hex_to_uint(*(it + 2));
1818 if (util::in_rfc3986_unreserved_chars(c)) {
1826 *p++ = util::upcase(*(it + 1));
1827 *p++ = util::upcase(*(it + 2));
1837 p = std::copy(it, std::end(path), p);
1840 return path_join(balloc, StringRef{}, StringRef{}, StringRef{result.base, p},
1844 std::string normalize_path(const StringRef &path, const StringRef &query) {
1845 BlockAllocator balloc(1024, 1024);
1847 return normalize_path(balloc, path, query).str();
1850 StringRef rewrite_clean_path(BlockAllocator &balloc, const StringRef &src) {
1851 if (src.empty() || src[0] != '/') {
1854 // probably, not necessary most of the case, but just in case.
1855 auto fragment = std::find(std::begin(src), std::end(src), '#');
1856 auto raw_query = std::find(std::begin(src), fragment, '?');
1857 auto query = raw_query;
1858 if (query != fragment) {
1861 return normalize_path(balloc, StringRef{std::begin(src), raw_query},
1862 StringRef{query, fragment});
1865 StringRef copy_lower(BlockAllocator &balloc, const StringRef &src) {
1866 auto iov = make_byte_ref(balloc, src.size() + 1);
1868 p = std::copy(std::begin(src), std::end(src), p);
1870 util::inp_strlower(iov.base, p);
1871 return StringRef{iov.base, p};
1874 bool contains_trailers(const StringRef &s) {
1875 constexpr auto trailers = StringRef::from_lit("trailers");
1877 for (auto p = std::begin(s), end = std::end(s);; ++p) {
1878 p = std::find_if(p, end, [](char c) { return c != ' ' && c != '\t'; });
1879 if (p == end || static_cast<size_t>(end - p) < trailers.size()) {
1882 if (util::strieq(trailers, StringRef{p, p + trailers.size()})) {
1883 // Make sure that there is no character other than white spaces
1884 // before next "," or end of string.
1885 p = std::find_if(p + trailers.size(), end,
1886 [](char c) { return c != ' ' && c != '\t'; });
1887 if (p == end || *p == ',') {
1891 // Skip to next ",".
1892 p = std::find_if(p, end, [](char c) { return c == ','; });
1899 StringRef make_websocket_accept_token(uint8_t *dest, const StringRef &key) {
1900 static constexpr uint8_t magic[] = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
1901 std::array<uint8_t, base64::encode_length(16) + str_size(magic)> s;
1902 auto p = std::copy(std::begin(key), std::end(key), std::begin(s));
1903 std::copy_n(magic, str_size(magic), p);
1905 std::array<uint8_t, 20> h;
1906 if (util::sha1(h.data(), StringRef{std::begin(s), std::end(s)}) != 0) {
1910 auto end = base64::encode(std::begin(h), std::end(h), dest);
1911 return StringRef{dest, end};
1914 bool legacy_http1(int major, int minor) {
1915 return major <= 0 || (major == 1 && minor == 0);
1918 } // namespace http2
1920 } // namespace nghttp2