tree f926dcda083c18517266b4fd1fabbbe51fbf6f5f
parent ebf77b9feb4b0cfe89ec45e2faa03c98e2fb043b
author Maxim Dounin <mdounin@mdounin.ru> 1653935133 +0300
committer Maxim Dounin <mdounin@mdounin.ru> 1653935133 +0300

Reworked multi headers to use linked lists.

Multi headers are now using linked lists instead of arrays.  Notably,
the following fields were changed: r->headers_in.cookies (renamed
to r->headers_in.cookie), r->headers_in.x_forwarded_for,
r->headers_out.cache_control, r->headers_out.link, u->headers_in.cache_control
u->headers_in.cookies (renamed to u->headers_in.set_cookie).

The r->headers_in.cookies and u->headers_in.cookies fields were renamed
to r->headers_in.cookie and u->headers_in.set_cookie to match header names.

The ngx_http_parse_multi_header_lines() and ngx_http_parse_set_cookie_lines()
functions were changed accordingly.

With this change, multi headers are now essentially equivalent to normal
headers, and following changes will further make them equivalent.
