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

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

代理服务器

开发平台：

Unix_Linux

htcp.c：源码内容
  2. /*
  3.  * $Id: htcp.c,v 1.26 1998/10/08 20:10:21 wessels Exp $
  4.  *
  5.  * DEBUG: section 31    Hypertext Caching Protocol
  6.  * AUTHOR: Duane Wesssels
  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. typedef struct _Countstr Countstr;
  39. typedef struct _htcpHeader htcpHeader;
  40. typedef struct _htcpDataHeader htcpDataHeader;
  41. typedef struct _htcpAuthHeader htcpAuthHeader;
  42. typedef struct _htcpStuff htcpStuff;
  43. typedef struct _htcpSpecifier htcpSpecifier;
  44. typedef struct _htcpDetail htcpDetail;
  46. struct _Countstr {
  47.     u_short length;
  48.     char *text;
  49. };
  51. struct _htcpHeader {
  52.     u_short length;
  53.     u_char major;
  54.     u_char minor;
  55. };
  57. struct _htcpDataHeader {
  58.     u_short length;
  59. #if !WORDS_BIGENDIAN
  60.     u_char opcode:4;
  61.     u_char response:4;
  62. #else
  63.     u_char response:4;
  64.     u_char opcode:4;
  65. #endif
  66. #if !WORDS_BIGENDIAN
  67.     u_char reserved:6;
  68.     u_char F1:1;
  69.     u_char RR:1;
  70. #else
  71.     u_char RR:1;
  72.     u_char F1:1;
  73.     u_char reserved:6;
  74. #endif
  75.     u_num32 msg_id;
  76. };
  78.     /* RR == 0 --> F1 = RESPONSE DESIRED FLAG */
  79.     /* RR == 1 --> F1 = MESSAGE OVERALL FLAG */
  80.     /* RR == 0 --> REQUEST */
  81.     /* RR == 1 --> RESPONSE */
  83. struct _htcpAuthHeader {
  84.     u_short length;
  85.     time_t sig_time;
  86.     time_t sig_expire;
  87.     Countstr key_name;
  88.     Countstr signature;
  89. };
  91. struct _htcpSpecifier {
  92.     char *method;
  93.     char *uri;
  94.     char *version;
  95.     char *req_hdrs;
  96. };
  98. struct _htcpDetail {
  99.     char *resp_hdrs;
  100.     char *entity_hdrs;
  101.     char *cache_hdrs;
  102. };
  104. struct _htcpStuff {
  105.     int op;
  106.     int rr;
  107.     int f1;
  108.     int response;
  109.     u_num32 msg_id;
  110.     htcpSpecifier S;
  111.     htcpDetail D;
  112. };
  114. enum {
  115.     HTCP_NOP,
  116.     HTCP_TST,
  117.     HTCP_MON,
  118.     HTCP_SET,
  119.     HTCP_CLR,
  120.     HTCP_END
  121. };
  123. static const char *const htcpOpcodeStr[] =
  124. {
  125.     "HTCP_NOP",
  126.     "HTCP_TST",
  127.     "HTCP_MON",
  128.     "HTCP_SET",
  129.     "HTCP_CLR",
  130.     "HTCP_END"
  131. };
  133. /*
  134.  * values for htcpDataHeader->response
  135.  */
  136. enum {
  137.     AUTH_REQUIRED,
  138.     AUTH_FAILURE,
  139.     OPCODE_UNIMPLEMENTED,
  140.     MAJOR_VERSION_UNSUPPORTED,
  141.     MINOR_VERSION_UNSUPPORTED,
  142.     INVALID_OPCODE
  143. };
  145. /*
  146.  * values for htcpDataHeader->RR
  147.  */
  148. enum {
  149.     RR_REQUEST,
  150.     RR_RESPONSE
  151. };
  153. static u_num32 msg_id_counter = 0;
  154. static int htcpInSocket = -1;
  155. static int htcpOutSocket = -1;
  156. #define N_QUERIED_KEYS 256
  157. static cache_key queried_keys[N_QUERIED_KEYS][MD5_DIGEST_CHARS];
  159. static char *htcpBuildPacket(htcpStuff * stuff, ssize_t * len);
  160. static htcpSpecifier *htcpUnpackSpecifier(char *buf, int sz);
  161. static htcpDetail *htcpUnpackDetail(char *buf, int sz);
  162. static int htcpUnpackCountstr(char *buf, int sz, char **str);
  163. static ssize_t htcpBuildAuth(char *buf, size_t buflen);
  164. static ssize_t htcpBuildCountstr(char *buf, size_t buflen, const char *s);
  165. static ssize_t htcpBuildData(char *buf, size_t buflen, htcpStuff * stuff);
  166. static ssize_t htcpBuildDetail(char *buf, size_t buflen, htcpStuff * stuff);
  167. static ssize_t htcpBuildOpData(char *buf, size_t buflen, htcpStuff * stuff);
  168. static ssize_t htcpBuildSpecifier(char *buf, size_t buflen, htcpStuff * stuff);
  169. static ssize_t htcpBuildTstOpData(char *buf, size_t buflen, htcpStuff * stuff);
  170. static void htcpFreeSpecifier(htcpSpecifier * s);
  171. static void htcpFreeDetail(htcpDetail * s);
  172. static void htcpHandle(char *buf, int sz, struct sockaddr_in *from);
  173. static void htcpHandleData(char *buf, int sz, struct sockaddr_in *from);
  174. static void htcpHandleMon(htcpDataHeader *, char *buf, int sz, struct sockaddr_in *from);
  175. static void htcpHandleNop(htcpDataHeader *, char *buf, int sz, struct sockaddr_in *from);
  176. static void htcpHandleSet(htcpDataHeader *, char *buf, int sz, struct sockaddr_in *from);
  177. static void htcpHandleTst(htcpDataHeader *, char *buf, int sz, struct sockaddr_in *from);
  178. static void htcpRecv(int fd, void *data);
  179. static void htcpSend(const char *buf, int len, struct sockaddr_in *to);
  180. static void htcpTstReply(htcpDataHeader *, StoreEntry *, htcpSpecifier *, struct sockaddr_in *);
  181. static void htcpHandleTstRequest(htcpDataHeader *, char *buf, int sz, struct sockaddr_in *from);
  182. static void htcpHandleTstResponse(htcpDataHeader *, char *, int, struct sockaddr_in *);
  184. static void
  185. htcpHexdump(const char *tag, const char *s, int sz)
  186. {
  187. #if USE_HEXDUMP
  188.     int i;
  189.     int k;
  190.     char hex[80];
  191.     debug(31, 3) ("htcpHexdump %sn", tag);
  192.     memset(hex, '', 80);
  193.     for (i = 0; i < sz; i++) {
  194. k = i % 16;
  195. snprintf(&hex[k * 3], 4, " %02x", (int) *(s + i));
  196. if (k < 15 && i < (sz - 1))
  197.     continue;
  198. debug(31, 3) ("t%sn", hex);
  199. memset(hex, '', 80);
  200.     }
  201. #endif
  202. }
  204. /*
  205.  * STUFF FOR SENDING HTCP MESSAGES
  206.  */
  208. static ssize_t
  209. htcpBuildAuth(char *buf, size_t buflen)
  210. {
  211.     htcpAuthHeader auth;
  212.     size_t copy_sz = 0;
  213.     assert(2 == sizeof(u_short));
  214.     auth.length = htons(2);
  215.     copy_sz += 2;
  216.     assert(buflen >= copy_sz);
  217.     xmemcpy(buf, &auth, copy_sz);
  218.     return copy_sz;
  219. }
  221. static ssize_t
  222. htcpBuildCountstr(char *buf, size_t buflen, const char *s)
  223. {
  224.     u_short length;
  225.     size_t len;
  226.     off_t off = 0;
  227.     if (buflen - off < 2)
  228. return -1;
  229.     if (s)
  230. len = strlen(s);
  231.     else
  232. len = 0;
  233.     debug(31, 3) ("htcpBuildCountstr: LENGTH = %dn", len);
  234.     debug(31, 3) ("htcpBuildCountstr: TEXT = {%s}n", s ? s : "<NULL>");
  235.     length = htons((u_short) len);
  236.     xmemcpy(buf + off, &length, 2);
  237.     off += 2;
  238.     if (buflen - off < len)
  239. return -1;
  240.     if (len)
  241. xmemcpy(buf + off, s, len);
  242.     off += len;
  243.     return off;
  244. }
  246. static ssize_t
  247. htcpBuildSpecifier(char *buf, size_t buflen, htcpStuff * stuff)
  248. {
  249.     ssize_t off = 0;
  250.     ssize_t s;
  251.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->S.method);
  252.     if (s < 0)
  253. return s;
  254.     off += s;
  255.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->S.uri);
  256.     if (s < 0)
  257. return s;
  258.     off += s;
  259.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->S.version);
  260.     if (s < 0)
  261. return s;
  262.     off += s;
  263.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->S.req_hdrs);
  264.     if (s < 0)
  265. return s;
  266.     off += s;
  267.     debug(31, 3) ("htcpBuildSpecifier: size %dn", (int) off);
  268.     return off;
  269. }
  271. static ssize_t
  272. htcpBuildDetail(char *buf, size_t buflen, htcpStuff * stuff)
  273. {
  274.     ssize_t off = 0;
  275.     ssize_t s;
  276.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->D.resp_hdrs);
  277.     if (s < 0)
  278. return s;
  279.     off += s;
  280.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->D.entity_hdrs);
  281.     if (s < 0)
  282. return s;
  283.     off += s;
  284.     s = htcpBuildCountstr(buf + off, buflen - off, stuff->D.cache_hdrs);
  285.     if (s < 0)
  286. return s;
  287.     off += s;
  288.     return off;
  289. }
  291. static ssize_t
  292. htcpBuildTstOpData(char *buf, size_t buflen, htcpStuff * stuff)
  293. {
  294.     switch (stuff->rr) {
  295.     case RR_REQUEST:
  296. debug(31, 3) ("htcpBuildTstOpData: RR_REQUESTn");
  297. return htcpBuildSpecifier(buf, buflen, stuff);
  298.     case RR_RESPONSE:
  299. debug(31, 3) ("htcpBuildTstOpData: RR_RESPONSEn");
  300. debug(31, 3) ("htcpBuildTstOpData: F1 = %dn", stuff->f1);
  301. if (stuff->f1) /* cache miss */
  302.     return 0;
  303. else /* cache hit */
  304.     return htcpBuildDetail(buf, buflen, stuff);
  305.     default:
  306. fatal_dump("htcpBuildTstOpData: bad RR value");
  307.     }
  308.     return 0;
  309. }
  311. static ssize_t
  312. htcpBuildOpData(char *buf, size_t buflen, htcpStuff * stuff)
  313. {
  314.     ssize_t off = 0;
  315.     debug(31, 3) ("htcpBuildOpData: opcode %sn",
  316. htcpOpcodeStr[stuff->op]);
  317.     switch (stuff->op) {
  318.     case HTCP_TST:
  319. off = htcpBuildTstOpData(buf + off, buflen, stuff);
  320. break;
  321.     default:
  322. assert(0);
  323. break;
  324.     }
  325.     return off;
  326. }
  328. static ssize_t
  329. htcpBuildData(char *buf, size_t buflen, htcpStuff * stuff)
  330. {
  331.     ssize_t off = 0;
  332.     ssize_t op_data_sz;
  333.     size_t hdr_sz = sizeof(htcpDataHeader);
  334.     htcpDataHeader hdr;
  335.     if (buflen < hdr_sz)
  336. return -1;
  337.     off += hdr_sz; /* skip! */
  338.     op_data_sz = htcpBuildOpData(buf + off, buflen - off, stuff);
  339.     if (op_data_sz < 0)
  340. return op_data_sz;
  341.     off += op_data_sz;
  342.     debug(31, 3) ("htcpBuildData: hdr.length = %dn", (int) off);
  343.     hdr.length = (u_short) off;
  344.     hdr.opcode = stuff->op;
  345.     hdr.response = stuff->response;
  346.     hdr.RR = stuff->rr;
  347.     hdr.F1 = stuff->f1;
  348.     hdr.msg_id = stuff->msg_id;
  349.     /* convert multi-byte fields */
  350.     hdr.length = htons(hdr.length);
  351.     hdr.msg_id = htonl(hdr.msg_id);
  352.     xmemcpy(buf, &hdr, hdr_sz);
  353.     debug(31, 3) ("htcpBuildData: size %dn", (int) off);
  354.     return off;
  355. }
  357. static char *
  358. htcpBuildPacket(htcpStuff * stuff, ssize_t * len)
  359. {
  360.     size_t buflen = 8192;
  361.     size_t s;
  362.     ssize_t off = 0;
  363.     size_t hdr_sz = sizeof(htcpHeader);
  364.     htcpHeader hdr;
  365.     char *buf = xcalloc(buflen, 1);
  366.     /* skip the header -- we don't know the overall length */
  367.     if (buflen < hdr_sz)
  368. return NULL;
  369.     off += hdr_sz;
  370.     s = htcpBuildData(buf + off, buflen - off, stuff);
  371.     if (s < 0)
  372. return NULL;
  373.     off += s;
  374.     s = htcpBuildAuth(buf + off, buflen - off);
  375.     if (s < 0)
  376. return NULL;
  377.     off += s;
  378.     hdr.length = htons((u_short) off);
  379.     hdr.major = 0;
  380.     hdr.minor = 0;
  381.     xmemcpy(buf, &hdr, hdr_sz);
  382.     *len = off;
  383.     debug(31, 3) ("htcpBuildPacket: size %dn", (int) off);
  384.     return buf;
  385. }
  387. static void
  388. htcpSend(const char *buf, int len, struct sockaddr_in *to)
  389. {
  390.     int x;
  391.     debug(31, 3) ("htcpSend: %s/%dn",
  392. inet_ntoa(to->sin_addr), (int) ntohs(to->sin_port));
  393.     htcpHexdump("htcpSend", buf, len);
  394.     x = comm_udp_sendto(htcpOutSocket,
  395. to,
  396. sizeof(struct sockaddr_in),
  397. buf,
  398. len);
  399.     if (x < 0)
  400. debug(31, 0) ("htcpSend: FD %d sendto: %sn", htcpOutSocket, xstrerror());
  401. }
  403. /*
  404.  * STUFF FOR RECEIVING HTCP MESSAGES
  405.  */
  407. static void
  408. htcpFreeSpecifier(htcpSpecifier * s)
  409. {
  410.     safe_free(s->method);
  411.     safe_free(s->uri);
  412.     safe_free(s->version);
  413.     safe_free(s->req_hdrs);
  414.     xfree(s);
  415. }
  417. static void
  418. htcpFreeDetail(htcpDetail * d)
  419. {
  420.     safe_free(d->resp_hdrs);
  421.     safe_free(d->entity_hdrs);
  422.     safe_free(d->cache_hdrs);
  423.     xfree(d);
  424. }
  426. static int
  427. htcpUnpackCountstr(char *buf, int sz, char **str)
  428. {
  429.     u_short l;
  430.     debug(31, 3) ("htcpUnpackCountstr: sz = %dn", sz);
  431.     if (sz < 2) {
  432. debug(31, 3) ("htcpUnpackCountstr: sz < 2n");
  433. return -1;
  434.     }
  435.     htcpHexdump("htcpUnpackCountstr", buf, sz);
  436.     xmemcpy(&l, buf, 2);
  437.     l = ntohs(l);
  438.     buf += 2;
  439.     sz -= 2;
  440.     debug(31, 3) ("htcpUnpackCountstr: LENGTH = %dn", (int) l);
  441.     if (sz < l) {
  442. debug(31, 3) ("htcpUnpackCountstr: sz(%d) < l(%d)n", sz, l);
  443. return -1;
  444.     }
  445.     if (str) {
  446. *str = xmalloc(l + 1);
  447. xstrncpy(*str, buf, l + 1);
  448. debug(31, 3) ("htcpUnpackCountstr: TEXT = {%s}n", *str);
  449.     }
  450.     return (int) l + 2;
  451. }
  453. static htcpSpecifier *
  454. htcpUnpackSpecifier(char *buf, int sz)
  455. {
  456.     htcpSpecifier *s = xcalloc(1, sizeof(htcpSpecifier));
  457.     int o;
  458.     debug(31, 3) ("htcpUnpackSpecifier: %d bytesn", (int) sz);
  459.     o = htcpUnpackCountstr(buf, sz, &s->method);
  460.     if (o < 0) {
  461. debug(31, 1) ("htcpUnpackSpecifier: failed to unpack METHODn");
  462. htcpFreeSpecifier(s);
  463. return NULL;
  464.     }
  465.     buf += o;
  466.     sz -= o;
  467.     o = htcpUnpackCountstr(buf, sz, &s->uri);
  468.     if (o < 0) {
  469. debug(31, 1) ("htcpUnpackSpecifier: failed to unpack URIn");
  470. htcpFreeSpecifier(s);
  471. return NULL;
  472.     }
  473.     buf += o;
  474.     sz -= o;
  475.     o = htcpUnpackCountstr(buf, sz, &s->version);
  476.     if (o < 0) {
  477. debug(31, 1) ("htcpUnpackSpecifier: failed to unpack VERSIONn");
  478. htcpFreeSpecifier(s);
  479. return NULL;
  480.     }
  481.     buf += o;
  482.     sz -= o;
  483.     o = htcpUnpackCountstr(buf, sz, &s->req_hdrs);
  484.     if (o < 0) {
  485. debug(31, 1) ("htcpUnpackSpecifier: failed to unpack REQ-HDRSn");
  486. htcpFreeSpecifier(s);
  487. return NULL;
  488.     }
  489.     buf += o;
  490.     sz -= o;
  491.     debug(31, 3) ("htcpUnpackSpecifier: %d bytes leftn", sz);
  492.     return s;
  493. }
  495. static htcpDetail *
  496. htcpUnpackDetail(char *buf, int sz)
  497. {
  498.     htcpDetail *d = xcalloc(1, sizeof(htcpDetail));
  499.     int o;
  500.     debug(31, 3) ("htcpUnpackDetail: %d bytesn", (int) sz);
  501.     o = htcpUnpackCountstr(buf, sz, &d->resp_hdrs);
  502.     if (o < 0) {
  503. debug(31, 1) ("htcpUnpackDetail: failed to unpack RESP_HDRSn");
  504. htcpFreeDetail(d);
  505. return NULL;
  506.     }
  507.     buf += o;
  508.     sz -= o;
  509.     o = htcpUnpackCountstr(buf, sz, &d->entity_hdrs);
  510.     if (o < 0) {
  511. debug(31, 1) ("htcpUnpackDetail: failed to unpack ENTITY_HDRSn");
  512. htcpFreeDetail(d);
  513. return NULL;
  514.     }
  515.     buf += o;
  516.     sz -= o;
  517.     o = htcpUnpackCountstr(buf, sz, &d->cache_hdrs);
  518.     if (o < 0) {
  519. debug(31, 1) ("htcpUnpackDetail: failed to unpack CACHE_HDRSn");
  520. htcpFreeDetail(d);
  521. return NULL;
  522.     }
  523.     buf += o;
  524.     sz -= o;
  525.     debug(31, 3) ("htcpUnpackDetail: %d bytes leftn", sz);
  526.     return d;
  527. }
  529. static void
  530. htcpTstReply(htcpDataHeader * dhdr, StoreEntry * e, htcpSpecifier * spec, struct sockaddr_in *from)
  531. {
  532.     htcpStuff stuff;
  533.     char *pkt;
  534.     HttpHeader hdr;
  535.     MemBuf mb;
  536.     Packer p;
  537.     ssize_t pktlen;
  538.     char *host;
  539.     int rtt = 0;
  540.     int hops = 0;
  541.     int samp = 0;
  542.     char cto_buf[128];
  543.     stuff.op = HTCP_TST;
  544.     stuff.rr = RR_RESPONSE;
  545.     stuff.f1 = 0;
  546.     stuff.response = e ? 0 : 1;
  547.     stuff.msg_id = dhdr->msg_id;
  548.     if (spec) {
  549. memBufDefInit(&mb);
  550. packerToMemInit(&p, &mb);
  551. httpHeaderInit(&hdr, hoHtcpReply);
  552. stuff.S.method = spec->method;
  553. stuff.S.uri = spec->uri;
  554. stuff.S.version = spec->version;
  555. stuff.S.req_hdrs = spec->req_hdrs;
  556. httpHeaderPutInt(&hdr, HDR_AGE,
  557.     e->timestamp <= squid_curtime ?
  558.     squid_curtime - e->timestamp : 0);
  559. httpHeaderPackInto(&hdr, &p);
  560. stuff.D.resp_hdrs = xstrdup(mb.buf);
  561. debug(31, 3) ("htcpTstReply: resp_hdrs = {%s}n", stuff.D.resp_hdrs);
  562. memBufReset(&mb);
  563. httpHeaderReset(&hdr);
  564. if (e->expires > -1)
  565.     httpHeaderPutTime(&hdr, HDR_EXPIRES, e->expires);
  566. if (e->lastmod > -1)
  567.     httpHeaderPutTime(&hdr, HDR_LAST_MODIFIED, e->lastmod);
  568. httpHeaderPackInto(&hdr, &p);
  569. stuff.D.entity_hdrs = xstrdup(mb.buf);
  570. debug(31, 3) ("htcpTstReply: entity_hdrs = {%s}n", stuff.D.entity_hdrs);
  571. memBufReset(&mb);
  572. httpHeaderReset(&hdr);
  573. if ((host = urlHostname(spec->uri))) {
  574.     netdbHostData(host, &samp, &rtt, &hops);
  575.     if (rtt || hops) {
  576. snprintf(cto_buf, 128, "%s %d %f %d",
  577.     host, samp, 0.001 * rtt, hops);
  578. httpHeaderPutExt(&hdr, "Cache-to-Origin", cto_buf);
  579.     }
  580. }
  581. httpHeaderPackInto(&hdr, &p);
  582. stuff.D.cache_hdrs = xstrdup(mb.buf);
  583. debug(31, 3) ("htcpTstReply: cache_hdrs = {%s}n", stuff.D.cache_hdrs);
  584. memBufClean(&mb);
  585. httpHeaderClean(&hdr);
  586. packerClean(&p);
  587.     }
  588.     pkt = htcpBuildPacket(&stuff, &pktlen);
  589.     if (pkt == NULL) {
  590. debug(31, 0) ("htcpTstReply: htcpBuildPacket() failedn");
  591. return;
  592.     }
  593.     htcpSend(pkt, (int) pktlen, from);
  594.     xfree(pkt);
  595. }
  597. static void
  598. htcpHandleNop(htcpDataHeader * hdr, char *buf, int sz, struct sockaddr_in *from)
  599. {
  600.     debug(31, 3) ("htcpHandleNop: Unimplementedn");
  601. }
  603. static void
  604. htcpHandleTst(htcpDataHeader * hdr, char *buf, int sz, struct sockaddr_in *from)
  605. {
  606.     debug(31, 3) ("htcpHandleTst: sz = %dn", (int) sz);
  607.     if (hdr->RR == RR_REQUEST)
  608. htcpHandleTstRequest(hdr, buf, sz, from);
  609.     else
  610. htcpHandleTstResponse(hdr, buf, sz, from);
  611. }
  613. static void
  614. htcpHandleTstResponse(htcpDataHeader * hdr, char *buf, int sz, struct sockaddr_in *from)
  615. {
  616.     htcpReplyData htcpReply;
  617.     cache_key *key = NULL;
  618.     htcpDetail *d = NULL;
  619.     char *t;
  620.     if (hdr->F1 == 1) {
  621. debug(31, 1) ("htcpHandleTstResponse: error condition, F1/MO == 1n");
  622. return;
  623.     }
  624.     memset(&htcpReply, '', sizeof(htcpReply));
  625.     httpHeaderInit(&htcpReply.hdr, hoHtcpReply);
  626.     htcpReply.msg_id = hdr->msg_id;
  627.     debug(31, 3) ("htcpHandleTstResponse: msg_id = %dn", (int) htcpReply.msg_id);
  628.     htcpReply.hit = hdr->response ? 0 : 1;
  629.     if (hdr->F1) {
  630. debug(31, 3) ("htcpHandleTstResponse: MISSn");
  631.     } else {
  632. debug(31, 3) ("htcpHandleTstResponse: HITn");
  633. d = htcpUnpackDetail(buf, sz);
  634. if (d == NULL) {
  635.     debug(31, 1) ("htcpHandleTstResponse: bad DETAILn");
  636.     return;
  637. }
  638. if ((t = d->resp_hdrs))
  639.     httpHeaderParse(&htcpReply.hdr, t, t + strlen(t));
  640. if ((t = d->entity_hdrs))
  641.     httpHeaderParse(&htcpReply.hdr, t, t + strlen(t));
  642. if ((t = d->cache_hdrs))
  643.     httpHeaderParse(&htcpReply.hdr, t, t + strlen(t));
  644.     }
  645.     key = queried_keys[htcpReply.msg_id % N_QUERIED_KEYS];
  646.     debug(31, 3) ("htcpHandleTstResponse: key (%p) %sn", key, storeKeyText(key));
  647.     neighborsHtcpReply(key, &htcpReply, from);
  648.     if (d)
  649. htcpFreeDetail(d);
  650. }
  652. static void
  653. htcpHandleTstRequest(htcpDataHeader * dhdr, char *buf, int sz, struct sockaddr_in *from)
  654. {
  655.     /* buf should be a SPECIFIER */
  656.     htcpSpecifier *s;
  657.     StoreEntry *e;
  658.     method_t m;
  659.     if (sz == 0) {
  660. debug(31, 3) ("htcpHandleTst: nothing to don");
  661. return;
  662.     }
  663.     if (dhdr->F1 == 0)
  664. return;
  665.     s = htcpUnpackSpecifier(buf, sz);
  666.     if (NULL == s) {
  667. debug(31, 3) ("htcpHandleTstRequest: htcpUnpackSpecifier failedn");
  668. return;
  669.     }
  670.     debug(31, 3) ("htcpHandleTstRequest: %s %s %sn",
  671. s->method,
  672. s->uri,
  673. s->version);
  674.     m = urlParseMethod(s->method);
  675.     debug(31, 3) ("htcpHandleTstRequest: %sn", s->req_hdrs);
  676.     e = storeGetPublic(s->uri, m);
  677.     if (NULL == e) {
  678. /* cache miss */
  679. htcpTstReply(dhdr, NULL, NULL, from);
  680. #if WIP
  681.     } else if (!checkHeaders()) {
  682. /* refresh/other miss */
  683. htcpTstReply(dhdr, NULL, NULL, from);
  684. #endif
  685.     } else {
  686. /* hit */
  687. htcpTstReply(dhdr, e, s, from);
  688.     }
  689.     htcpFreeSpecifier(s);
  690. }
  692. static void
  693. htcpHandleMon(htcpDataHeader * hdr, char *buf, int sz, struct sockaddr_in *from)
  694. {
  695.     debug(31, 3) ("htcpHandleMon: Unimplementedn");
  696. }
  698. static void
  699. htcpHandleSet(htcpDataHeader * hdr, char *buf, int sz, struct sockaddr_in *from)
  700. {
  701.     debug(31, 3) ("htcpHandleSet: Unimplementedn");
  702. }
  704. static void
  705. htcpHandleData(char *buf, int sz, struct sockaddr_in *from)
  706. {
  707.     htcpDataHeader hdr;
  708.     if (sz < sizeof(htcpDataHeader)) {
  709. debug(31, 0) ("htcpHandleData: msg size less than htcpDataHeader sizen");
  710. return;
  711.     }
  712.     xmemcpy(&hdr, buf, sizeof(htcpDataHeader));
  713.     hdr.length = ntohs(hdr.length);
  714.     hdr.msg_id = ntohl(hdr.msg_id);
  715.     debug(31, 3) ("htcpHandleData: sz = %dn", sz);
  716.     debug(31, 3) ("htcpHandleData: length = %dn", (int) hdr.length);
  717.     if (hdr.opcode > HTCP_END) {
  718. debug(31, 0) ("htcpHandleData: opcode %d out of rangen",
  719.     (int) hdr.opcode);
  720. return;
  721.     }
  722.     debug(31, 3) ("htcpHandleData: opcode = %d %sn",
  723. (int) hdr.opcode, htcpOpcodeStr[hdr.opcode]);
  724.     debug(31, 3) ("htcpHandleData: response = %dn", (int) hdr.response);
  725.     debug(31, 3) ("htcpHandleData: F1 = %dn", (int) hdr.F1);
  726.     debug(31, 3) ("htcpHandleData: RR = %dn", (int) hdr.RR);
  727.     debug(31, 3) ("htcpHandleData: msg_id = %dn", (int) hdr.msg_id);
  728.     if (sz < hdr.length) {
  729. debug(31, 0) ("htcpHandle: sz < hdr.lengthn");
  730. return;
  731.     }
  732.     /*
  733.      * set sz = hdr.length so we ignore any AUTH fields following
  734.      * the DATA.
  735.      */
  736.     sz = (int) hdr.length;
  737.     buf += sizeof(htcpDataHeader);
  738.     sz -= sizeof(htcpDataHeader);
  739.     debug(31, 3) ("htcpHandleData: sz = %dn", sz);
  740.     htcpHexdump("htcpHandleData", buf, sz);
  741.     switch (hdr.opcode) {
  742.     case HTCP_NOP:
  743. htcpHandleNop(&hdr, buf, sz, from);
  744. break;
  745.     case HTCP_TST:
  746. htcpHandleTst(&hdr, buf, sz, from);
  747. break;
  748.     case HTCP_MON:
  749. htcpHandleMon(&hdr, buf, sz, from);
  750. break;
  751.     case HTCP_SET:
  752. htcpHandleSet(&hdr, buf, sz, from);
  753. break;
  754.     default:
  755. assert(0);
  756. break;
  757.     }
  758. }
  760. static void
  761. htcpHandle(char *buf, int sz, struct sockaddr_in *from)
  762. {
  763.     htcpHeader htcpHdr;
  764.     if (sz < sizeof(htcpHeader)) {
  765. debug(31, 0) ("htcpHandle: msg size less than htcpHeader sizen");
  766. return;
  767.     }
  768.     htcpHexdump("htcpHandle", buf, sz);
  769.     xmemcpy(&htcpHdr, buf, sizeof(htcpHeader));
  770.     htcpHdr.length = ntohs(htcpHdr.length);
  771.     debug(31, 3) ("htcpHandle: htcpHdr.length = %dn", (int) htcpHdr.length);
  772.     debug(31, 3) ("htcpHandle: htcpHdr.major = %dn", (int) htcpHdr.major);
  773.     debug(31, 3) ("htcpHandle: htcpHdr.minor = %dn", (int) htcpHdr.minor);
  774.     if (sz != htcpHdr.length) {
  775. debug(31, 0) ("htcpHandle: sz != htcpHdr.lengthn");
  776. return;
  777.     }
  778.     buf += sizeof(htcpHeader);
  779.     sz -= sizeof(htcpHeader);
  780.     htcpHandleData(buf, sz, from);
  781. }
  783. static void
  784. htcpRecv(int fd, void *data)
  785. {
  786.     static char buf[8192];
  787.     int len;
  788.     static struct sockaddr_in from;
  789.     int flen = sizeof(struct sockaddr_in);
  790.     memset(&from, '', flen);
  791.     Counter.syscalls.sock.recvfroms++;
  792.     len = recvfrom(fd, buf, 8192, 0, (struct sockaddr *) &from, &flen);
  793.     debug(31, 3) ("htcpRecv: FD %d, %d bytes from %s:%dn",
  794. fd, len, inet_ntoa(from.sin_addr), ntohs(from.sin_port));
  795.     htcpHandle(buf, len, &from);
  796.     commSetSelect(fd, COMM_SELECT_READ, htcpRecv, NULL, 0);
  797. }
  799. /*
  800.  * ======================================================================
  801.  * PUBLIC FUNCTIONS
  802.  * ======================================================================
  803.  */
  805. void
  806. htcpInit(void)
  807. {
  808.     enter_suid();
  809.     htcpInSocket = comm_open(SOCK_DGRAM,
  810. 0,
  811. Config.Addrs.udp_incoming,
  812. Config.Port.htcp,
  813. COMM_NONBLOCKING,
  814. "HTCP Socket");
  815.     leave_suid();
  816.     if (htcpInSocket < 0)
  817. fatal("Cannot open HTCP Socket");
  818.     commSetSelect(htcpInSocket, COMM_SELECT_READ, htcpRecv, NULL, 0);
  819.     debug(31, 1) ("Accepting HTCP messages on port %d, FD %d.n",
  820. (int) Config.Port.htcp, htcpInSocket);
  821.     if (Config.Addrs.udp_outgoing.s_addr != no_addr.s_addr) {
  822. enter_suid();
  823. htcpOutSocket = comm_open(SOCK_DGRAM,
  824.     0,
  825.     Config.Addrs.udp_outgoing,
  826.     Config.Port.htcp,
  827.     COMM_NONBLOCKING,
  828.     "Outgoing HTCP Socket");
  829. leave_suid();
  830. if (htcpOutSocket < 0)
  831.     fatal("Cannot open Outgoing HTCP Socket");
  832. commSetSelect(htcpOutSocket, COMM_SELECT_READ, htcpRecv, NULL, 0);
  833. debug(31, 1) ("Outgoing HTCP messages on port %d, FD %d.n",
  834.     (int) Config.Port.htcp, htcpOutSocket);
  835. fd_note(htcpInSocket, "Incoming HTCP socket");
  836.     } else {
  837. htcpOutSocket = htcpInSocket;
  838.     }
  839. }
  841. void
  842. htcpQuery(StoreEntry * e, request_t * req, peer * p)
  843. {
  844.     cache_key *save_key;
  845.     char *pkt;
  846.     ssize_t pktlen;
  847.     char vbuf[32];
  848.     htcpStuff stuff;
  849.     HttpHeader hdr;
  850.     Packer pa;
  851.     MemBuf mb;
  852.     http_state_flags flags;
  853.     memset(&flags, '', sizeof(flags));
  854.     snprintf(vbuf, sizeof(vbuf), "%3.1f", req->http_ver);
  855.     stuff.op = HTCP_TST;
  856.     stuff.rr = RR_REQUEST;
  857.     stuff.f1 = 1;
  858.     stuff.response = 0;
  859.     stuff.msg_id = ++msg_id_counter;
  860.     stuff.S.method = (char *) RequestMethodStr[req->method];
  861.     stuff.S.uri = (char *) storeUrl(e);
  862.     stuff.S.version = vbuf;
  863.     httpBuildRequestHeader(req, req, e, &hdr, -1, flags);
  864.     memBufDefInit(&mb);
  865.     packerToMemInit(&pa, &mb);
  866.     httpHeaderPackInto(&hdr, &pa);
  867.     httpHeaderClean(&hdr);
  868.     packerClean(&pa);
  869.     stuff.S.req_hdrs = mb.buf;
  870.     pkt = htcpBuildPacket(&stuff, &pktlen);
  871.     if (pkt == NULL) {
  872. debug(31, 0) ("htcpQuery: htcpBuildPacket() failedn");
  873. return;
  874.     }
  875.     htcpSend(pkt, (int) pktlen, &p->in_addr);
  876.     save_key = queried_keys[stuff.msg_id % N_QUERIED_KEYS];
  877.     storeKeyCopy(save_key, e->key);
  878.     debug(31, 3) ("htcpQuery: key (%p) %sn", save_key, storeKeyText(save_key));
  879.     xfree(pkt);
  880. }
  882. /*  
  883.  * htcpSocketShutdown only closes the 'in' socket if it is
  884.  * different than the 'out' socket.
  885.  */
  886. void
  887. htcpSocketShutdown(void)
  888. {
  889.     if (htcpInSocket < 0)
  890. return;
  891.     if (htcpInSocket != htcpOutSocket) {
  892. debug(12, 1) ("FD %d Closing HTCP socketn", htcpInSocket);
  893. comm_close(htcpInSocket);
  894.     }
  895.     /*      
  896.      * Here we set 'htcpInSocket' to -1 even though the HTCP 'in'
  897.      * and 'out' sockets might be just one FD.  This prevents this
  898.      * function from executing repeatedly.  When we are really ready to
  899.      * exit or restart, main will comm_close the 'out' descriptor.
  900.      */
  901.     htcpInSocket = -1;
  902.     /*      
  903.      * Normally we only write to the outgoing HTCP socket, but
  904.      * we also have a read handler there to catch messages sent
  905.      * to that specific interface.  During shutdown, we must
  906.      * disable reading on the outgoing socket.
  907.      */
  908.     assert(htcpOutSocket > -1);
  909.     commSetSelect(htcpOutSocket, COMM_SELECT_READ, NULL, NULL, 0);
  910. }
  912. void
  913. htcpSocketClose(void)
  914. {
  915.     htcpSocketShutdown();
  916.     if (htcpOutSocket > -1) {
  917. debug(12, 1) ("FD %d Closing HTCP socketn", htcpOutSocket);
  918. comm_close(htcpOutSocket);
  919.     }
  920. }