开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
HttpHeader.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：33k
源码类别：

代理服务器

开发平台：

Unix_Linux

HttpHeader.c：源码内容
  2. /*
  3.  * $Id: HttpHeader.c,v 1.61.2.1 1999/02/12 19:38:18 wessels Exp $
  4.  *
  5.  * DEBUG: section 55    HTTP Header
  6.  * AUTHOR: Alex Rousskov
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "squid.h"
  38. /*
  39.  * On naming conventions:
  40.  * 
  41.  * HTTP/1.1 defines message-header as 
  42.  * 
  43.  * message-header = field-name ":" [ field-value ] CRLF
  44.  * field-name     = token
  45.  * field-value    = *( field-content | LWS )
  46.  * 
  47.  * HTTP/1.1 does not give a name name a group of all message-headers in a message.
  48.  * Squid 1.1 seems to refer to that group _plus_ start-line as "headers".
  49.  * 
  50.  * HttpHeader is an object that represents all message-headers in a message.
  51.  * HttpHeader does not manage start-line.
  52.  * 
  53.  * HttpHeader is implemented as a collection of header "entries".
  54.  * An entry is a (field_id, field_name, field_value) triplet.
  55.  */
  58. /*
  59.  * local constants and vars
  60.  */
  62. /*
  63.  * A table with major attributes for every known field. 
  64.  * We calculate name lengths and reorganize this array on start up. 
  65.  * After reorganization, field id can be used as an index to the table.
  66.  */
  67. static const HttpHeaderFieldAttrs HeadersAttrs[] =
  68. {
  69.     {"Accept", HDR_ACCEPT, ftStr},
  70.     {"Accept-Charset", HDR_ACCEPT_CHARSET, ftStr},
  71.     {"Accept-Encoding", HDR_ACCEPT_ENCODING, ftStr},
  72.     {"Accept-Language", HDR_ACCEPT_LANGUAGE, ftStr},
  73.     {"Accept-Ranges", HDR_ACCEPT_RANGES, ftStr},
  74.     {"Age", HDR_AGE, ftInt},
  75.     {"Allow", HDR_ALLOW, ftStr},
  76.     {"Authorization", HDR_AUTHORIZATION, ftStr}, /* for now */
  77.     {"Cache-Control", HDR_CACHE_CONTROL, ftPCc},
  78.     {"Connection", HDR_CONNECTION, ftStr},
  79.     {"Content-Base", HDR_CONTENT_BASE, ftStr},
  80.     {"Content-Encoding", HDR_CONTENT_ENCODING, ftStr},
  81.     {"Content-Language", HDR_CONTENT_LANGUAGE, ftStr},
  82.     {"Content-Length", HDR_CONTENT_LENGTH, ftInt},
  83.     {"Content-Location", HDR_CONTENT_LOCATION, ftStr},
  84.     {"Content-MD5", HDR_CONTENT_MD5, ftStr}, /* for now */
  85.     {"Content-Range", HDR_CONTENT_RANGE, ftPContRange},
  86.     {"Content-Type", HDR_CONTENT_TYPE, ftStr},
  87.     {"Date", HDR_DATE, ftDate_1123},
  88.     {"ETag", HDR_ETAG, ftETag},
  89.     {"Expires", HDR_EXPIRES, ftDate_1123},
  90.     {"From", HDR_FROM, ftStr},
  91.     {"Host", HDR_HOST, ftStr},
  92.     {"If-Match", HDR_IF_MATCH, ftStr}, /* for now */
  93.     {"If-Modified-Since", HDR_IF_MODIFIED_SINCE, ftDate_1123},
  94.     {"If-None-Match", HDR_IF_NONE_MATCH, ftStr}, /* for now */
  95.     {"If-Range", HDR_IF_RANGE, ftDate_1123_or_ETag},
  96.     {"Last-Modified", HDR_LAST_MODIFIED, ftDate_1123},
  97.     {"Link", HDR_LINK, ftStr},
  98.     {"Location", HDR_LOCATION, ftStr},
  99.     {"Max-Forwards", HDR_MAX_FORWARDS, ftInt},
  100.     {"Mime-Version", HDR_MIME_VERSION, ftStr}, /* for now */
  101.     {"Pragma", HDR_PRAGMA, ftStr},
  102.     {"Proxy-Authenticate", HDR_PROXY_AUTHENTICATE, ftStr},
  103.     {"Proxy-Authorization", HDR_PROXY_AUTHORIZATION, ftStr},
  104.     {"Proxy-Connection", HDR_PROXY_CONNECTION, ftStr},
  105.     {"Public", HDR_PUBLIC, ftStr},
  106.     {"Range", HDR_RANGE, ftPRange},
  107.     {"Referer", HDR_REFERER, ftStr},
  108.     {"Request-Range", HDR_REQUEST_RANGE, ftPRange}, /* usually matches HDR_RANGE */
  109.     {"Retry-After", HDR_RETRY_AFTER, ftStr}, /* for now (ftDate_1123 or ftInt!) */
  110.     {"Server", HDR_SERVER, ftStr},
  111.     {"Set-Cookie", HDR_SET_COOKIE, ftStr},
  112.     {"Title", HDR_TITLE, ftStr},
  113.     {"Upgrade", HDR_UPGRADE, ftStr}, /* for now */
  114.     {"User-Agent", HDR_USER_AGENT, ftStr},
  115.     {"Vary", HDR_VARY, ftStr}, /* for now */
  116.     {"Via", HDR_VIA, ftStr}, /* for now */
  117.     {"Warning", HDR_WARNING, ftStr}, /* for now */
  118.     {"WWW-Authenticate", HDR_WWW_AUTHENTICATE, ftStr},
  119.     {"X-Cache", HDR_X_CACHE, ftStr},
  120.     {"X-Cache-Lookup", HDR_X_CACHE_LOOKUP, ftStr},
  121.     {"X-Forwarded-For", HDR_X_FORWARDED_FOR, ftStr},
  122.     {"X-Request-URI", HDR_X_REQUEST_URI, ftStr},
  123.     {"X-Squid-Error", HDR_X_SQUID_ERROR, ftStr},
  124.     {"Other:", HDR_OTHER, ftStr} /* ':' will not allow matches */
  125. };
  126. static HttpHeaderFieldInfo *Headers = NULL;
  128. /*
  129.  * headers with field values defined as #(values) in HTTP/1.1
  130.  * Headers that are currently not recognized, are commented out.
  131.  */
  132. static HttpHeaderMask ListHeadersMask; /* set run-time using  ListHeadersArr */
  133. static http_hdr_type ListHeadersArr[] =
  134. {
  135.     HDR_ACCEPT,
  136.     HDR_ACCEPT_CHARSET, HDR_ACCEPT_ENCODING, HDR_ACCEPT_LANGUAGE,
  137.     HDR_ACCEPT_RANGES, HDR_ALLOW,
  138.     HDR_CACHE_CONTROL,
  139.     HDR_CONTENT_ENCODING,
  140.     HDR_CONTENT_LANGUAGE,
  141.     HDR_CONNECTION,
  142.     HDR_IF_MATCH, HDR_IF_NONE_MATCH,
  143.     HDR_LINK, HDR_PRAGMA,
  144.     /* HDR_TRANSFER_ENCODING, */
  145.     HDR_UPGRADE,
  146.     HDR_VARY,
  147.     HDR_VIA,
  148.     /* HDR_WARNING, */
  149.     HDR_WWW_AUTHENTICATE,
  150.     /* HDR_EXPECT, HDR_TE, HDR_TRAILER */
  151.     HDR_X_FORWARDED_FOR
  152. };
  154. /* general-headers */
  155. static http_hdr_type GeneralHeadersArr[] =
  156. {
  157.     HDR_CACHE_CONTROL, HDR_CONNECTION, HDR_DATE, HDR_PRAGMA,
  158.     /* HDR_TRANSFER_ENCODING, */
  159.     HDR_UPGRADE,
  160.     /* HDR_TRAILER, */
  161.     HDR_VIA
  162. };
  164. /* entity-headers */
  165. static http_hdr_type EntityHeadersArr[] =
  166. {
  167.     HDR_ALLOW, HDR_CONTENT_BASE, HDR_CONTENT_ENCODING, HDR_CONTENT_LANGUAGE,
  168.     HDR_CONTENT_LENGTH, HDR_CONTENT_LOCATION, HDR_CONTENT_MD5,
  169.     HDR_CONTENT_RANGE, HDR_CONTENT_TYPE, HDR_ETAG, HDR_EXPIRES, HDR_LAST_MODIFIED, HDR_LINK,
  170.     HDR_OTHER
  171. };
  173. static HttpHeaderMask ReplyHeadersMask; /* set run-time using ReplyHeaders */
  174. static http_hdr_type ReplyHeadersArr[] =
  175. {
  176.     HDR_ACCEPT, HDR_ACCEPT_CHARSET, HDR_ACCEPT_ENCODING, HDR_ACCEPT_LANGUAGE,
  177.     HDR_ACCEPT_RANGES, HDR_AGE,
  178.     HDR_LOCATION, HDR_MAX_FORWARDS,
  179.     HDR_MIME_VERSION, HDR_PUBLIC, HDR_RETRY_AFTER, HDR_SERVER, HDR_SET_COOKIE,
  180.     HDR_VARY,
  181.     HDR_WARNING, HDR_PROXY_CONNECTION, HDR_X_CACHE,
  182.     HDR_X_CACHE_LOOKUP,
  183.     HDR_X_REQUEST_URI,
  184.     HDR_X_SQUID_ERROR
  185. };
  187. static HttpHeaderMask RequestHeadersMask; /* set run-time using RequestHeaders */
  188. static http_hdr_type RequestHeadersArr[] =
  189. {
  190.     HDR_AUTHORIZATION, HDR_FROM, HDR_HOST,
  191.     HDR_IF_MATCH, HDR_IF_MODIFIED_SINCE, HDR_IF_NONE_MATCH,
  192.     HDR_IF_RANGE, HDR_MAX_FORWARDS, HDR_PROXY_CONNECTION,
  193.     HDR_PROXY_AUTHORIZATION, HDR_RANGE, HDR_REFERER, HDR_REQUEST_RANGE,
  194.     HDR_USER_AGENT, HDR_X_FORWARDED_FOR
  195. };
  197. /* header accounting */
  198. static HttpHeaderStat HttpHeaderStats[] =
  199. {
  200.     {"all"},
  201. #if USE_HTCP
  202.     {"HTCP reply"},
  203. #endif
  204.     {"request"},
  205.     {"reply"}
  206. };
  207. static int HttpHeaderStatCount = countof(HttpHeaderStats);
  209. static int HeaderEntryParsedCount = 0;
  211. /*
  212.  * local routines
  213.  */
  215. #define assert_eid(id) assert((id) >= 0 && (id) < HDR_ENUM_END)
  217. static HttpHeaderEntry *httpHeaderEntryCreate(http_hdr_type id, const char *name, const char *value);
  218. static void httpHeaderEntryDestroy(HttpHeaderEntry * e);
  219. static HttpHeaderEntry *httpHeaderEntryParseCreate(const char *field_start, const char *field_end);
  220. static void httpHeaderNoteParsedEntry(http_hdr_type id, String value, int error);
  222. static void httpHeaderStatInit(HttpHeaderStat * hs, const char *label);
  223. static void httpHeaderStatDump(const HttpHeaderStat * hs, StoreEntry * e);
  225. /*
  226.  * Module initialization routines
  227.  */
  229. void
  230. httpHeaderInitModule()
  231. {
  232.     int i;
  233.     /* check that we have enough space for masks */
  234.     assert(8 * sizeof(HttpHeaderMask) >= HDR_ENUM_END);
  235.     /* all headers must be described */
  236.     assert(countof(HeadersAttrs) == HDR_ENUM_END);
  237.     if (!Headers)
  238. Headers = httpHeaderBuildFieldsInfo(HeadersAttrs, HDR_ENUM_END);
  239.     /* create masks */
  240.     httpHeaderMaskInit(&ListHeadersMask, 0);
  241.     httpHeaderCalcMask(&ListHeadersMask, (const int *) ListHeadersArr, countof(ListHeadersArr));
  242.     httpHeaderMaskInit(&ReplyHeadersMask, 0);
  243.     httpHeaderCalcMask(&ReplyHeadersMask, (const int *) ReplyHeadersArr, countof(ReplyHeadersArr));
  244.     httpHeaderCalcMask(&ReplyHeadersMask, (const int *) GeneralHeadersArr, countof(GeneralHeadersArr));
  245.     httpHeaderCalcMask(&ReplyHeadersMask, (const int *) EntityHeadersArr, countof(EntityHeadersArr));
  246.     httpHeaderMaskInit(&RequestHeadersMask, 0);
  247.     httpHeaderCalcMask(&RequestHeadersMask, (const int *) RequestHeadersArr, countof(RequestHeadersArr));
  248.     httpHeaderCalcMask(&RequestHeadersMask, (const int *) GeneralHeadersArr, countof(GeneralHeadersArr));
  249.     httpHeaderCalcMask(&RequestHeadersMask, (const int *) EntityHeadersArr, countof(EntityHeadersArr));
  250.     /* init header stats */
  251.     assert(HttpHeaderStatCount == hoReply + 1);
  252.     for (i = 0; i < HttpHeaderStatCount; i++)
  253. httpHeaderStatInit(HttpHeaderStats + i, HttpHeaderStats[i].label);
  254.     HttpHeaderStats[hoRequest].owner_mask = &RequestHeadersMask;
  255.     HttpHeaderStats[hoReply].owner_mask = &ReplyHeadersMask;
  256. #if USE_HTCP
  257.     HttpHeaderStats[hoHtcpReply].owner_mask = &ReplyHeadersMask;
  258. #endif
  259.     /* init dependent modules */
  260.     httpHdrCcInitModule();
  261.     /* register with cache manager */
  262.     cachemgrRegister("http_headers",
  263. "HTTP Header Statistics", httpHeaderStoreReport, 0, 1);
  264. }
  266. void
  267. httpHeaderCleanModule()
  268. {
  269.     httpHeaderDestroyFieldsInfo(Headers, HDR_ENUM_END);
  270.     Headers = NULL;
  271.     httpHdrCcCleanModule();
  272. }
  274. static void
  275. httpHeaderStatInit(HttpHeaderStat * hs, const char *label)
  276. {
  277.     assert(hs);
  278.     assert(label);
  279.     memset(hs, 0, sizeof(HttpHeaderStat));
  280.     hs->label = label;
  281.     statHistEnumInit(&hs->hdrUCountDistr, 32); /* not a real enum */
  282.     statHistEnumInit(&hs->fieldTypeDistr, HDR_ENUM_END);
  283.     statHistEnumInit(&hs->ccTypeDistr, CC_ENUM_END);
  284. }
  286. /*
  287.  * HttpHeader Implementation
  288.  */
  290. void
  291. httpHeaderInit(HttpHeader * hdr, http_hdr_owner_type owner)
  292. {
  293.     assert(hdr);
  294.     assert(owner > hoNone && owner <= hoReply);
  295.     debug(55, 7) ("init-ing hdr: %p owner: %dn", hdr, owner);
  296.     memset(hdr, 0, sizeof(*hdr));
  297.     hdr->owner = owner;
  298.     arrayInit(&hdr->entries);
  299. }
  301. void
  302. httpHeaderClean(HttpHeader * hdr)
  303. {
  304.     HttpHeaderPos pos = HttpHeaderInitPos;
  305.     HttpHeaderEntry *e;
  307.     assert(hdr);
  308.     assert(hdr->owner > hoNone && hdr->owner <= hoReply);
  309.     debug(55, 7) ("cleaning hdr: %p owner: %dn", hdr, hdr->owner);
  311.     statHistCount(&HttpHeaderStats[hdr->owner].hdrUCountDistr, hdr->entries.count);
  312.     HttpHeaderStats[hdr->owner].destroyedCount++;
  313.     HttpHeaderStats[hdr->owner].busyDestroyedCount += hdr->entries.count > 0;
  314.     while ((e = httpHeaderGetEntry(hdr, &pos))) {
  315. /* tmp hack to try to avoid coredumps */
  316. if (e->id < 0 || e->id >= HDR_ENUM_END) {
  317.     debug(55, 0) ("httpHeaderClean BUG: entry[%d] is invalid (%d). Ignored.n",
  318. pos, e->id);
  319. } else {
  320.     statHistCount(&HttpHeaderStats[hdr->owner].fieldTypeDistr, e->id);
  321.     /* yes, this destroy() leaves us in an incosistent state */
  322.     httpHeaderEntryDestroy(e);
  323. }
  324.     }
  325.     arrayClean(&hdr->entries);
  326. }
  328. /* append entries (also see httpHeaderUpdate) */
  329. void
  330. httpHeaderAppend(HttpHeader * dest, const HttpHeader * src)
  331. {
  332.     const HttpHeaderEntry *e;
  333.     HttpHeaderPos pos = HttpHeaderInitPos;
  334.     assert(src && dest);
  335.     assert(src != dest);
  336.     debug(55, 7) ("appending hdr: %p += %pn", dest, src);
  338.     while ((e = httpHeaderGetEntry(src, &pos))) {
  339. httpHeaderAddEntry(dest, httpHeaderEntryClone(e));
  340.     }
  341. }
  343. /* use fresh entries to replace old ones */
  344. void
  345. httpHeaderUpdate(HttpHeader * old, const HttpHeader * fresh, const HttpHeaderMask * denied_mask)
  346. {
  347.     const HttpHeaderEntry *e;
  348.     HttpHeaderPos pos = HttpHeaderInitPos;
  349.     assert(old && fresh);
  350.     assert(old != fresh);
  351.     debug(55, 7) ("updating hdr: %p <- %pn", old, fresh);
  353.     while ((e = httpHeaderGetEntry(fresh, &pos))) {
  354. /* deny bad guys (ok to check for HDR_OTHER) here */
  355. if (denied_mask && CBIT_TEST(*denied_mask, e->id))
  356.     continue;
  357. httpHeaderDelByName(old, strBuf(e->name));
  358. httpHeaderAddEntry(old, httpHeaderEntryClone(e));
  359.     }
  360. }
  362. /* just handy in parsing: resets and returns false */
  363. int
  364. httpHeaderReset(HttpHeader * hdr)
  365. {
  366.     http_hdr_owner_type ho = hdr->owner;
  367.     assert(hdr);
  368.     ho = hdr->owner;
  369.     httpHeaderClean(hdr);
  370.     httpHeaderInit(hdr, ho);
  371.     return 0;
  372. }
  374. int
  375. httpHeaderParse(HttpHeader * hdr, const char *header_start, const char *header_end)
  376. {
  377.     const char *field_start = header_start;
  378.     HttpHeaderEntry *e;
  380.     assert(hdr);
  381.     assert(header_start && header_end);
  382.     debug(55, 7) ("parsing hdr: (%p)n%sn", hdr, getStringPrefix(header_start, header_end));
  383.     HttpHeaderStats[hdr->owner].parsedCount++;
  384.     /* commonn format headers are "<name>:[ws]<value>" lines delimited by <CRLF> */
  385.     while (field_start < header_end) {
  386. const char *field_end = field_start + strcspn(field_start, "rn");
  387. if (!*field_end || field_end > header_end)
  388.     return httpHeaderReset(hdr); /* missing <CRLF> */
  389. e = httpHeaderEntryParseCreate(field_start, field_end);
  390. if (e != NULL)
  391.     httpHeaderAddEntry(hdr, e);
  392. else
  393.     debug(55, 2) ("warning: ignoring unparseable http header field near '%s'n",
  394. getStringPrefix(field_start, field_end));
  395. field_start = field_end;
  396. /* skip CRLF */
  397. if (*field_start == 'r')
  398.     field_start++;
  399. if (*field_start == 'n')
  400.     field_start++;
  401.     }
  402.     return 1; /* even if no fields where found, it is a valid header */
  403. }
  405. /* packs all the entries using supplied packer */
  406. void
  407. httpHeaderPackInto(const HttpHeader * hdr, Packer * p)
  408. {
  409.     HttpHeaderPos pos = HttpHeaderInitPos;
  410.     const HttpHeaderEntry *e;
  411.     assert(hdr && p);
  412.     debug(55, 7) ("packing hdr: (%p)n", hdr);
  413.     /* pack all entries one by one */
  414.     while ((e = httpHeaderGetEntry(hdr, &pos)))
  415. httpHeaderEntryPackInto(e, p);
  416. }
  418. /* returns next valid entry */
  419. HttpHeaderEntry *
  420. httpHeaderGetEntry(const HttpHeader * hdr, HttpHeaderPos * pos)
  421. {
  422.     assert(hdr && pos);
  423.     assert(*pos >= HttpHeaderInitPos && *pos < hdr->entries.count);
  424.     for ((*pos)++; *pos < hdr->entries.count; (*pos)++) {
  425. if (hdr->entries.items[*pos])
  426.     return hdr->entries.items[*pos];
  427.     }
  428.     return NULL;
  429. }
  431. /*
  432.  * returns a pointer to a specified entry if any 
  433.  * note that we return one entry so it does not make much sense to ask for
  434.  * "list" headers
  435.  */
  436. HttpHeaderEntry *
  437. httpHeaderFindEntry(const HttpHeader * hdr, http_hdr_type id)
  438. {
  439.     HttpHeaderPos pos = HttpHeaderInitPos;
  440.     HttpHeaderEntry *e;
  441.     assert(hdr);
  442.     assert_eid(id);
  443.     assert(!CBIT_TEST(ListHeadersMask, id));
  445.     /* check mask first */
  446.     if (!CBIT_TEST(hdr->mask, id))
  447. return NULL;
  448.     /* looks like we must have it, do linear search */
  449.     while ((e = httpHeaderGetEntry(hdr, &pos))) {
  450. if (e->id == id)
  451.     return e;
  452.     }
  453.     /* hm.. we thought it was there, but it was not found */
  454.     assert(0);
  455.     return NULL; /* not reached */
  456. }
  458. /*
  459.  * same as httpHeaderFindEntry
  460.  */
  461. static HttpHeaderEntry *
  462. httpHeaderFindLastEntry(const HttpHeader * hdr, http_hdr_type id)
  463. {
  464.     HttpHeaderPos pos = HttpHeaderInitPos;
  465.     HttpHeaderEntry *e;
  466.     HttpHeaderEntry *result = NULL;
  467.     assert(hdr);
  468.     assert_eid(id);
  469.     assert(!CBIT_TEST(ListHeadersMask, id));
  471.     /* check mask first */
  472.     if (!CBIT_TEST(hdr->mask, id))
  473. return NULL;
  474.     /* looks like we must have it, do linear search */
  475.     while ((e = httpHeaderGetEntry(hdr, &pos))) {
  476. if (e->id == id)
  477.     result = e;
  478.     }
  479.     assert(result); /* must be there! */
  480.     return result;
  481. }
  483. /*
  484.  * deletes all fields with a given name if any, returns #fields deleted; 
  485.  */
  486. int
  487. httpHeaderDelByName(HttpHeader * hdr, const char *name)
  488. {
  489.     int count = 0;
  490.     HttpHeaderPos pos = HttpHeaderInitPos;
  491.     HttpHeaderEntry *e;
  492.     httpHeaderMaskInit(&hdr->mask, 0); /* temporal inconsistency */
  493.     debug(55, 7) ("deleting '%s' fields in hdr %pn", name, hdr);
  494.     while ((e = httpHeaderGetEntry(hdr, &pos))) {
  495. if (!strCaseCmp(e->name, name)) {
  496.     httpHeaderDelAt(hdr, pos);
  497.     count++;
  498. } else
  499.     CBIT_SET(hdr->mask, e->id);
  500.     }
  501.     return count;
  502. }
  504. /* deletes all entries with a given id, returns the #entries deleted */
  505. int
  506. httpHeaderDelById(HttpHeader * hdr, http_hdr_type id)
  507. {
  508.     int count = 0;
  509.     HttpHeaderPos pos = HttpHeaderInitPos;
  510.     HttpHeaderEntry *e;
  511.     debug(55, 8) ("%p del-by-id %dn", hdr, id);
  512.     assert(hdr);
  513.     assert_eid(id);
  514.     assert_eid(id != HDR_OTHER); /* does not make sense */
  515.     if (!CBIT_TEST(hdr->mask, id))
  516. return 0;
  517.     while ((e = httpHeaderGetEntry(hdr, &pos))) {
  518. if (e->id == id) {
  519.     httpHeaderDelAt(hdr, pos);
  520.     count++;
  521. }
  522.     }
  523.     CBIT_CLR(hdr->mask, id);
  524.     assert(count);
  525.     return count;
  526. }
  528. /*
  529.  * deletes an entry at pos and leaves a gap; leaving a gap makes it
  530.  * possible to iterate(search) and delete fields at the same time
  531.  */
  532. void
  533. httpHeaderDelAt(HttpHeader * hdr, HttpHeaderPos pos)
  534. {
  535.     HttpHeaderEntry *e;
  536.     assert(pos >= HttpHeaderInitPos && pos < hdr->entries.count);
  537.     e = hdr->entries.items[pos];
  538.     hdr->entries.items[pos] = NULL;
  539.     /* decrement header length, allow for ": " and crlf */
  540.     hdr->len -= strLen(e->name) + 2 + strLen(e->value) + 2;
  541.     assert(hdr->len >= 0);
  542.     httpHeaderEntryDestroy(e);
  543. }
  546. /* appends an entry; 
  547.  * does not call httpHeaderEntryClone() so one should not reuse "*e"
  548.  */
  549. void
  550. httpHeaderAddEntry(HttpHeader * hdr, HttpHeaderEntry * e)
  551. {
  552.     assert(hdr && e);
  553.     assert_eid(e->id);
  555.     debug(55, 7) ("%p adding entry: %d at %dn",
  556. hdr, e->id, hdr->entries.count);
  557.     if (CBIT_TEST(hdr->mask, e->id))
  558. Headers[e->id].stat.repCount++;
  559.     else
  560. CBIT_SET(hdr->mask, e->id);
  561.     arrayAppend(&hdr->entries, e);
  562.     /* increment header length, allow for ": " and crlf */
  563.     hdr->len += strLen(e->name) + 2 + strLen(e->value) + 2;
  564. }
  566. /* return a list of entries with the same id separated by ',' and ws */
  567. String
  568. httpHeaderGetList(const HttpHeader * hdr, http_hdr_type id)
  569. {
  570.     String s = StringNull;
  571.     HttpHeaderEntry *e;
  572.     HttpHeaderPos pos = HttpHeaderInitPos;
  573.     debug(55, 6) ("%p: joining for id %dn", hdr, id);
  574.     /* only fields from ListHeaders array can be "listed" */
  575.     assert(CBIT_TEST(ListHeadersMask, id));
  576.     if (!CBIT_TEST(hdr->mask, id))
  577. return s;
  578.     while ((e = httpHeaderGetEntry(hdr, &pos))) {
  579. if (e->id == id)
  580.     strListAdd(&s, strBuf(e->value), ',');
  581.     }
  582.     /*
  583.      * note: we might get an empty (len==0) string if there was an "empty"
  584.      * header; we must not get a NULL string though.
  585.      */
  586.     assert(strBuf(s));
  587.     /* temporary warning: remove it! @?@ @?@ @?@ */
  588.     if (!strLen(s))
  589. debug(55, 3) ("empty list header: %s (%d)n", strBuf(Headers[id].name), id);
  590.     debug(55, 6) ("%p: joined for id %d: %sn", hdr, id, strBuf(s));
  591.     return s;
  592. }
  595. /* test if a field is present */
  596. int
  597. httpHeaderHas(const HttpHeader * hdr, http_hdr_type id)
  598. {
  599.     assert(hdr);
  600.     assert_eid(id);
  601.     assert(id != HDR_OTHER);
  602.     debug(55, 7) ("%p lookup for %dn", hdr, id);
  603.     return CBIT_TEST(hdr->mask, id);
  604. }
  606. void
  607. httpHeaderPutInt(HttpHeader * hdr, http_hdr_type id, int number)
  608. {
  609.     assert_eid(id);
  610.     assert(Headers[id].type == ftInt); /* must be of an appropriate type */
  611.     assert(number >= 0);
  612.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(id, NULL, xitoa(number)));
  613. }
  615. void
  616. httpHeaderPutTime(HttpHeader * hdr, http_hdr_type id, time_t time)
  617. {
  618.     assert_eid(id);
  619.     assert(Headers[id].type == ftDate_1123); /* must be of an appropriate type */
  620.     assert(time >= 0);
  621.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(id, NULL, mkrfc1123(time)));
  622. }
  624. void
  625. httpHeaderPutStr(HttpHeader * hdr, http_hdr_type id, const char *str)
  626. {
  627.     assert_eid(id);
  628.     assert(Headers[id].type == ftStr); /* must be of an appropriate type */
  629.     assert(str);
  630.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(id, NULL, str));
  631. }
  633. void
  634. httpHeaderPutAuth(HttpHeader * hdr, const char *authScheme, const char *realm)
  635. {
  636.     assert(hdr && authScheme && realm);
  637.     httpHeaderPutStrf(hdr, HDR_WWW_AUTHENTICATE, "%s realm="%s"", authScheme, realm);
  638. }
  640. void
  641. httpHeaderPutCc(HttpHeader * hdr, const HttpHdrCc * cc)
  642. {
  643.     MemBuf mb;
  644.     Packer p;
  645.     assert(hdr && cc);
  646.     /* remove old directives if any */
  647.     httpHeaderDelById(hdr, HDR_CACHE_CONTROL);
  648.     /* pack into mb */
  649.     memBufDefInit(&mb);
  650.     packerToMemInit(&p, &mb);
  651.     httpHdrCcPackInto(cc, &p);
  652.     /* put */
  653.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_CACHE_CONTROL, NULL, mb.buf));
  654.     /* cleanup */
  655.     packerClean(&p);
  656.     memBufClean(&mb);
  657. }
  659. void
  660. httpHeaderPutContRange(HttpHeader * hdr, const HttpHdrContRange * cr)
  661. {
  662.     MemBuf mb;
  663.     Packer p;
  664.     assert(hdr && cr);
  665.     /* remove old directives if any */
  666.     httpHeaderDelById(hdr, HDR_CONTENT_RANGE);
  667.     /* pack into mb */
  668.     memBufDefInit(&mb);
  669.     packerToMemInit(&p, &mb);
  670.     httpHdrContRangePackInto(cr, &p);
  671.     /* put */
  672.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_CONTENT_RANGE, NULL, mb.buf));
  673.     /* cleanup */
  674.     packerClean(&p);
  675.     memBufClean(&mb);
  676. }
  678. void
  679. httpHeaderPutRange(HttpHeader * hdr, const HttpHdrRange * range)
  680. {
  681.     MemBuf mb;
  682.     Packer p;
  683.     assert(hdr && range);
  684.     /* remove old directives if any */
  685.     httpHeaderDelById(hdr, HDR_RANGE);
  686.     /* pack into mb */
  687.     memBufDefInit(&mb);
  688.     packerToMemInit(&p, &mb);
  689.     httpHdrRangePackInto(range, &p);
  690.     /* put */
  691.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_RANGE, NULL, mb.buf));
  692.     /* cleanup */
  693.     packerClean(&p);
  694.     memBufClean(&mb);
  695. }
  697. /* add extension header (these fields are not parsed/analyzed/joined, etc.) */
  698. void
  699. httpHeaderPutExt(HttpHeader * hdr, const char *name, const char *value)
  700. {
  701.     assert(name && value);
  702.     debug(55, 8) ("%p adds ext entry '%s: %s'n", hdr, name, value);
  703.     httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_OTHER, name, value));
  704. }
  706. int
  707. httpHeaderGetInt(const HttpHeader * hdr, http_hdr_type id)
  708. {
  709.     HttpHeaderEntry *e;
  710.     int value = -1;
  711.     int ok;
  712.     assert_eid(id);
  713.     assert(Headers[id].type == ftInt); /* must be of an appropriate type */
  714.     if ((e = httpHeaderFindEntry(hdr, id))) {
  715. ok = httpHeaderParseInt(strBuf(e->value), &value);
  716. httpHeaderNoteParsedEntry(e->id, e->value, !ok);
  717.     }
  718.     return value;
  719. }
  721. time_t
  722. httpHeaderGetTime(const HttpHeader * hdr, http_hdr_type id)
  723. {
  724.     HttpHeaderEntry *e;
  725.     time_t value = -1;
  726.     assert_eid(id);
  727.     assert(Headers[id].type == ftDate_1123); /* must be of an appropriate type */
  728.     if ((e = httpHeaderFindEntry(hdr, id))) {
  729. value = parse_rfc1123(strBuf(e->value));
  730. httpHeaderNoteParsedEntry(e->id, e->value, value < 0);
  731.     }
  732.     return value;
  733. }
  735. /* sync with httpHeaderGetLastStr */
  736. const char *
  737. httpHeaderGetStr(const HttpHeader * hdr, http_hdr_type id)
  738. {
  739.     HttpHeaderEntry *e;
  740.     assert_eid(id);
  741.     assert(Headers[id].type == ftStr); /* must be of an appropriate type */
  742.     if ((e = httpHeaderFindEntry(hdr, id))) {
  743. httpHeaderNoteParsedEntry(e->id, e->value, 0); /* no errors are possible */
  744. return strBuf(e->value);
  745.     }
  746.     return NULL;
  747. }
  749. /* unusual */
  750. const char *
  751. httpHeaderGetLastStr(const HttpHeader * hdr, http_hdr_type id)
  752. {
  753.     HttpHeaderEntry *e;
  754.     assert_eid(id);
  755.     assert(Headers[id].type == ftStr); /* must be of an appropriate type */
  756.     if ((e = httpHeaderFindLastEntry(hdr, id))) {
  757. httpHeaderNoteParsedEntry(e->id, e->value, 0); /* no errors are possible */
  758. return strBuf(e->value);
  759.     }
  760.     return NULL;
  761. }
  763. HttpHdrCc *
  764. httpHeaderGetCc(const HttpHeader * hdr)
  765. {
  766.     HttpHdrCc *cc;
  767.     String s;
  768.     if (!CBIT_TEST(hdr->mask, HDR_CACHE_CONTROL))
  769. return NULL;
  770.     s = httpHeaderGetList(hdr, HDR_CACHE_CONTROL);
  771.     cc = httpHdrCcParseCreate(&s);
  772.     HttpHeaderStats[hdr->owner].ccParsedCount++;
  773.     if (cc)
  774. httpHdrCcUpdateStats(cc, &HttpHeaderStats[hdr->owner].ccTypeDistr);
  775.     httpHeaderNoteParsedEntry(HDR_CACHE_CONTROL, s, !cc);
  776.     stringClean(&s);
  777.     return cc;
  778. }
  780. HttpHdrRange *
  781. httpHeaderGetRange(const HttpHeader * hdr)
  782. {
  783.     HttpHdrRange *r = NULL;
  784.     HttpHeaderEntry *e;
  785.     /* some clients will send "Request-Range" _and_ *matching* "Range"
  786.      * who knows, some clients might send Request-Range only;
  787.      * this "if" should work correctly in both cases;
  788.      * hopefully no clients send mismatched headers! */
  789.     if ((e = httpHeaderFindEntry(hdr, HDR_RANGE)) ||
  790. (e = httpHeaderFindEntry(hdr, HDR_REQUEST_RANGE))) {
  791. r = httpHdrRangeParseCreate(&e->value);
  792. httpHeaderNoteParsedEntry(e->id, e->value, !r);
  793.     }
  794.     return r;
  795. }
  797. HttpHdrContRange *
  798. httpHeaderGetContRange(const HttpHeader * hdr)
  799. {
  800.     HttpHdrContRange *cr = NULL;
  801.     HttpHeaderEntry *e;
  802.     if ((e = httpHeaderFindEntry(hdr, HDR_CONTENT_RANGE))) {
  803. cr = httpHdrContRangeParseCreate(strBuf(e->value));
  804. httpHeaderNoteParsedEntry(e->id, e->value, !cr);
  805.     }
  806.     return cr;
  807. }
  809. const char *
  810. httpHeaderGetAuth(const HttpHeader * hdr, http_hdr_type id, const char *authScheme)
  811. {
  812.     const char *field;
  813.     int l;
  814.     assert(hdr && authScheme);
  815.     field = httpHeaderGetStr(hdr, id);
  816.     if (!field) /* no authorization field */
  817. return NULL;
  818.     l = strlen(authScheme);
  819.     if (!l || strncasecmp(field, authScheme, l)) /* wrong scheme */
  820. return NULL;
  821.     field += l;
  822.     if (!xisspace(*field)) /* wrong scheme */
  823. return NULL;
  824.     /* skip white space */
  825.     field += xcountws(field);
  826.     if (!*field) /* no authorization cookie */
  827. return NULL;
  828.     return base64_decode(field);
  829. }
  831. ETag
  832. httpHeaderGetETag(const HttpHeader * hdr, http_hdr_type id)
  833. {
  834.     ETag etag =
  835.     {NULL, -1};
  836.     HttpHeaderEntry *e;
  837.     assert(Headers[id].type == ftETag); /* must be of an appropriate type */
  838.     if ((e = httpHeaderFindEntry(hdr, id)))
  839. etagParseInit(&etag, strBuf(e->value));
  840.     return etag;
  841. }
  843. TimeOrTag
  844. httpHeaderGetTimeOrTag(const HttpHeader * hdr, http_hdr_type id)
  845. {
  846.     TimeOrTag tot;
  847.     HttpHeaderEntry *e;
  848.     assert(Headers[id].type == ftDate_1123_or_ETag); /* must be of an appropriate type */
  849.     memset(&tot, 0, sizeof(tot));
  850.     if ((e = httpHeaderFindEntry(hdr, id))) {
  851. const char *str = strBuf(e->value);
  852. /* try as an ETag */
  853. if (etagParseInit(&tot.tag, str)) {
  854.     tot.valid = tot.tag.str != NULL;
  855.     tot.time = -1;
  856. } else {
  857.     /* or maybe it is time? */
  858.     tot.time = parse_rfc1123(str);
  859.     tot.valid = tot.time >= 0;
  860.     tot.tag.str = NULL;
  861. }
  862.     }
  863.     assert(tot.time < 0 || !tot.tag.str); /* paranoid */
  864.     return tot;
  865. }
  867. /*
  868.  * HttpHeaderEntry
  869.  */
  871. static HttpHeaderEntry *
  872. httpHeaderEntryCreate(http_hdr_type id, const char *name, const char *value)
  873. {
  874.     HttpHeaderEntry *e;
  875.     assert_eid(id);
  876.     e = memAllocate(MEM_HTTP_HDR_ENTRY);
  877.     e->id = id;
  878.     if (id != HDR_OTHER)
  879. e->name = Headers[id].name;
  880.     else
  881. stringInit(&e->name, name);
  882.     stringInit(&e->value, value);
  883.     Headers[id].stat.aliveCount++;
  884.     debug(55, 9) ("created entry %p: '%s: %s'n", e, strBuf(e->name), strBuf(e->value));
  885.     return e;
  886. }
  888. static void
  889. httpHeaderEntryDestroy(HttpHeaderEntry * e)
  890. {
  891.     assert(e);
  892.     assert_eid(e->id);
  893.     debug(55, 9) ("destroying entry %p: '%s: %s'n", e, strBuf(e->name), strBuf(e->value));
  894.     /* clean name if needed */
  895.     if (e->id == HDR_OTHER)
  896. stringClean(&e->name);
  897.     stringClean(&e->value);
  898.     assert(Headers[e->id].stat.aliveCount);
  899.     Headers[e->id].stat.aliveCount--;
  900.     e->id = -1;
  901.     memFree(e, MEM_HTTP_HDR_ENTRY);
  902. }
  904. /* parses and inits header entry, returns new entry on success */
  905. static HttpHeaderEntry *
  906. httpHeaderEntryParseCreate(const char *field_start, const char *field_end)
  907. {
  908.     HttpHeaderEntry *e;
  909.     int id;
  910.     /* note: name_start == field_start */
  911.     const char *name_end = strchr(field_start, ':');
  912.     const int name_len = name_end ? name_end - field_start : 0;
  913.     const char *value_start = field_start + name_len + 1; /* skip ':' */
  914.     /* note: value_end == field_end */
  916.     HeaderEntryParsedCount++;
  918.     /* do we have a valid field name within this field? */
  919.     if (!name_len || name_end > field_end)
  920. return NULL;
  921.     /* now we know we can parse it */
  922.     e = memAllocate(MEM_HTTP_HDR_ENTRY);
  923.     debug(55, 9) ("creating entry %p: near '%s'n", e, getStringPrefix(field_start, field_end));
  924.     /* is it a "known" field? */
  925.     id = httpHeaderIdByName(field_start, name_len, Headers, HDR_ENUM_END);
  926.     if (id < 0)
  927. id = HDR_OTHER;
  928.     assert_eid(id);
  929.     e->id = id;
  930.     /* set field name */
  931.     if (id == HDR_OTHER)
  932. stringLimitInit(&e->name, field_start, name_len);
  933.     else
  934. e->name = Headers[id].name;
  935.     /* trim field value */
  936.     while (value_start < field_end && xisspace(*value_start))
  937. value_start++;
  938.     /* set field value */
  939.     stringLimitInit(&e->value, value_start, field_end - value_start);
  940.     Headers[id].stat.seenCount++;
  941.     Headers[id].stat.aliveCount++;
  942.     debug(55, 9) ("created entry %p: '%s: %s'n", e, strBuf(e->name), strBuf(e->value));
  943.     return e;
  944. }
  946. HttpHeaderEntry *
  947. httpHeaderEntryClone(const HttpHeaderEntry * e)
  948. {
  949.     return httpHeaderEntryCreate(e->id, strBuf(e->name), strBuf(e->value));
  950. }
  952. void
  953. httpHeaderEntryPackInto(const HttpHeaderEntry * e, Packer * p)
  954. {
  955.     assert(e && p);
  956.     packerAppend(p, strBuf(e->name), strLen(e->name));
  957.     packerAppend(p, ": ", 2);
  958.     packerAppend(p, strBuf(e->value), strLen(e->value));
  959.     packerAppend(p, "rn", 2);
  960. }
  962. static void
  963. httpHeaderNoteParsedEntry(http_hdr_type id, String context, int error)
  964. {
  965.     Headers[id].stat.parsCount++;
  966.     if (error) {
  967. Headers[id].stat.errCount++;
  968. debug(55, 2) ("cannot parse hdr field: '%s: %s'n",
  969.     strBuf(Headers[id].name), strBuf(context));
  970.     }
  971. }
  973. /*
  974.  * Reports
  975.  */
  977. /* tmp variable used to pass stat info to dumpers */
  978. extern const HttpHeaderStat *dump_stat; /* argh! */
  979. const HttpHeaderStat *dump_stat = NULL;
  981. static void
  982. httpHeaderFieldStatDumper(StoreEntry * sentry, int idx, double val, double size, int count)
  983. {
  984.     const int id = (int) val;
  985.     const int valid_id = id >= 0 && id < HDR_ENUM_END;
  986.     const char *name = valid_id ? strBuf(Headers[id].name) : "INVALID";
  987.     int visible = count > 0;
  988.     /* for entries with zero count, list only those that belong to current type of message */
  989.     if (!visible && valid_id && dump_stat->owner_mask)
  990. visible = CBIT_TEST(*dump_stat->owner_mask, id);
  991.     if (visible)
  992. storeAppendPrintf(sentry, "%2dt %-20st %5dt %6.2fn",
  993.     id, name, count, xdiv(count, dump_stat->busyDestroyedCount));
  994. }
  996. static void
  997. httpHeaderFldsPerHdrDumper(StoreEntry * sentry, int idx, double val, double size, int count)
  998. {
  999.     if (count)
  1000. storeAppendPrintf(sentry, "%2dt %5dt %5dt %6.2fn",
  1001.     idx, (int) val, count,
  1002.     xpercent(count, dump_stat->destroyedCount));
  1003. }
  1006. static void
  1007. httpHeaderStatDump(const HttpHeaderStat * hs, StoreEntry * e)
  1008. {
  1009.     assert(hs && e);
  1011.     dump_stat = hs;
  1012.     storeAppendPrintf(e, "nHeader Stats: %sn", hs->label);
  1013.     storeAppendPrintf(e, "nField type distributionn");
  1014.     storeAppendPrintf(e, "%2st %-20st %5st %6sn",
  1015. "id", "name", "count", "#/header");
  1016.     statHistDump(&hs->fieldTypeDistr, e, httpHeaderFieldStatDumper);
  1017.     storeAppendPrintf(e, "nCache-control directives distributionn");
  1018.     storeAppendPrintf(e, "%2st %-20st %5st %6sn",
  1019. "id", "name", "count", "#/cc_field");
  1020.     statHistDump(&hs->ccTypeDistr, e, httpHdrCcStatDumper);
  1021.     storeAppendPrintf(e, "nNumber of fields per header distributionn");
  1022.     storeAppendPrintf(e, "%2st %-5st %5st %6sn",
  1023. "id", "#flds", "count", "%total");
  1024.     statHistDump(&hs->hdrUCountDistr, e, httpHeaderFldsPerHdrDumper);
  1025.     dump_stat = NULL;
  1026. }
  1028. void
  1029. httpHeaderStoreReport(StoreEntry * e)
  1030. {
  1031.     int i;
  1032.     http_hdr_type ht;
  1033.     assert(e);
  1035.     HttpHeaderStats[0].parsedCount =
  1036. HttpHeaderStats[hoRequest].parsedCount + HttpHeaderStats[hoReply].parsedCount;
  1037.     HttpHeaderStats[0].ccParsedCount =
  1038. HttpHeaderStats[hoRequest].ccParsedCount + HttpHeaderStats[hoReply].ccParsedCount;
  1039.     HttpHeaderStats[0].destroyedCount =
  1040. HttpHeaderStats[hoRequest].destroyedCount + HttpHeaderStats[hoReply].destroyedCount;
  1041.     HttpHeaderStats[0].busyDestroyedCount =
  1042. HttpHeaderStats[hoRequest].busyDestroyedCount + HttpHeaderStats[hoReply].busyDestroyedCount;
  1044.     for (i = 1; i < HttpHeaderStatCount; i++) {
  1045. httpHeaderStatDump(HttpHeaderStats + i, e);
  1046. storeAppendPrintf(e, "%sn", "<br>");
  1047.     }
  1048.     /* field stats for all messages */
  1049.     storeAppendPrintf(e, "nHttp Fields Stats (replies and requests)n");
  1050.     storeAppendPrintf(e, "%2st %-20st %5st %6st %6sn",
  1051. "id", "name", "#alive", "%err", "%repeat");
  1052.     for (ht = 0; ht < HDR_ENUM_END; ht++) {
  1053. HttpHeaderFieldInfo *f = Headers + ht;
  1054. storeAppendPrintf(e, "%2dt %-20st %5dt %6.3ft %6.3fn",
  1055.     f->id, strBuf(f->name), f->stat.aliveCount,
  1056.     xpercent(f->stat.errCount, f->stat.parsCount),
  1057.     xpercent(f->stat.repCount, f->stat.seenCount));
  1058.     }
  1059.     storeAppendPrintf(e, "Headers Parsed: %d + %d = %dn",
  1060. HttpHeaderStats[hoRequest].parsedCount,
  1061. HttpHeaderStats[hoReply].parsedCount,
  1062. HttpHeaderStats[0].parsedCount);
  1063.     storeAppendPrintf(e, "Hdr Fields Parsed: %dn", HeaderEntryParsedCount);
  1064. }
  1066. int
  1067. httpHeaderIdByName(const char *name, int name_len, const HttpHeaderFieldInfo * info, int end)
  1068. {
  1069.     int i;
  1070.     for (i = 0; i < end; ++i) {
  1071. if (name_len >= 0 && name_len != strLen(info[i].name))
  1072.     continue;
  1073. if (!strncasecmp(name, strBuf(info[i].name),
  1074. name_len < 0 ? strLen(info[i].name) + 1 : name_len))
  1075.     return i;
  1076.     }
  1077.     return -1;
  1078. }
  1080. int
  1081. httpHeaderIdByNameDef(const char *name, int name_len)
  1082. {
  1083.     if (!Headers)
  1084. Headers = httpHeaderBuildFieldsInfo(HeadersAttrs, HDR_ENUM_END);
  1085.     return httpHeaderIdByName(name, name_len, Headers, HDR_ENUM_END);
  1086. }