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

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

代理服务器

开发平台：

Unix_Linux

icp_v2.c：源码内容
  2. /*
  3.  * $Id: icp_v2.c,v 1.58 1999/01/29 21:28:13 wessels Exp $
  4.  *
  5.  * DEBUG: section 12    Internet Cache Protocol
  6.  * AUTHOR: Duane Wessels
  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. static void icpLogIcp(struct in_addr, log_type, int, const char *, int);
  39. static void icpHandleIcpV2(int, struct sockaddr_in, char *, int);
  40. static void icpCount(void *, int, size_t, int);
  42. /*
  43.  * IcpQueueHead is global so comm_incoming() knows whether or not
  44.  * to call icpUdpSendQueue.
  45.  */
  46. static icpUdpData *IcpQueueTail = NULL;
  48. static void
  49. icpLogIcp(struct in_addr caddr, log_type logcode, int len, const char *url, int delay)
  50. {
  51.     AccessLogEntry al;
  52.     if (LOG_TAG_NONE == logcode)
  53. return;
  54.     if (LOG_ICP_QUERY == logcode)
  55. return;
  56.     clientdbUpdate(caddr, logcode, PROTO_ICP, len);
  57.     if (!Config.onoff.log_udp)
  58. return;
  59.     memset(&al, '', sizeof(al));
  60.     al.icp.opcode = ICP_QUERY;
  61.     al.url = url;
  62.     al.cache.caddr = caddr;
  63.     al.cache.size = len;
  64.     al.cache.code = logcode;
  65.     al.cache.msec = delay;
  66.     accessLogLog(&al);
  67. }
  69. void
  70. icpUdpSendQueue(int fd, void *unused)
  71. {
  72.     icpUdpData *q;
  73.     int x;
  74.     int delay;
  75.     while ((q = IcpQueueHead) != NULL) {
  76. delay = tvSubUsec(q->queue_time, current_time);
  77. /* increment delay to prevent looping */
  78. x = icpUdpSend(fd, &q->address, q->msg, q->logcode, ++delay);
  79. IcpQueueHead = q->next;
  80. safe_free(q);
  81. if (x < 0)
  82.     break;
  83.     }
  84. }
  86. void *
  87. icpCreateMessage(
  88.     icp_opcode opcode,
  89.     int flags,
  90.     const char *url,
  91.     int reqnum,
  92.     int pad)
  93. {
  94.     char *buf = NULL;
  95.     icp_common_t *headerp = NULL;
  96.     char *urloffset = NULL;
  97.     int buf_len;
  98.     buf_len = sizeof(icp_common_t) + strlen(url) + 1;
  99.     if (opcode == ICP_QUERY)
  100. buf_len += sizeof(u_num32);
  101.     buf = xcalloc(buf_len, 1);
  102.     headerp = (icp_common_t *) (void *) buf;
  103.     headerp->opcode = (char) opcode;
  104.     headerp->version = ICP_VERSION_CURRENT;
  105.     headerp->length = (u_short) htons(buf_len);
  106.     headerp->reqnum = htonl(reqnum);
  107.     headerp->flags = htonl(flags);
  108.     headerp->pad = htonl(pad);
  109.     headerp->shostid = theOutICPAddr.s_addr;
  110.     urloffset = buf + sizeof(icp_common_t);
  111.     if (opcode == ICP_QUERY)
  112. urloffset += sizeof(u_num32);
  113.     xmemcpy(urloffset, url, strlen(url));
  114.     return buf;
  115. }
  117. int
  118. icpUdpSend(int fd,
  119.     const struct sockaddr_in *to,
  120.     icp_common_t * msg,
  121.     log_type logcode,
  122.     int delay)
  123. {
  124.     icpUdpData *queue;
  125.     int x;
  126.     int len;
  127.     len = (int) ntohs(msg->length);
  128.     debug(12, 5) ("icpUdpSend: FD %d sending %s, %d bytes to %s:%dn",
  129. fd,
  130. icp_opcode_str[msg->opcode],
  131. len,
  132. inet_ntoa(to->sin_addr),
  133. ntohs(to->sin_port));
  134.     x = comm_udp_sendto(fd, to, sizeof(*to), msg, len);
  135.     if (x >= 0) {
  136. /* successfully written */
  137. icpLogIcp(to->sin_addr, logcode, len, (char *) (msg + 1), delay);
  138. icpCount(msg, SENT, (size_t) len, delay);
  139. safe_free(msg);
  140.     } else if (0 == delay) {
  141. /* send failed, but queue it */
  142. queue = xcalloc(1, sizeof(icpUdpData));
  143. queue->address = *to;
  144. queue->msg = msg;
  145. queue->len = (int) ntohs(msg->length);
  146. queue->queue_time = current_time;
  147. queue->logcode = logcode;
  148. if (IcpQueueHead == NULL) {
  149.     IcpQueueHead = queue;
  150.     IcpQueueTail = queue;
  151. } else if (IcpQueueTail == IcpQueueHead) {
  152.     IcpQueueTail = queue;
  153.     IcpQueueHead->next = queue;
  154. } else {
  155.     IcpQueueTail->next = queue;
  156.     IcpQueueTail = queue;
  157. }
  158. commSetSelect(fd, COMM_SELECT_WRITE, icpUdpSendQueue, NULL, 0);
  159. Counter.icp.replies_queued++;
  160.     } else {
  161. /* don't queue it */
  162. Counter.icp.replies_dropped++;
  163.     }
  164.     return x;
  165. }
  167. int
  168. icpCheckUdpHit(StoreEntry * e, request_t * request)
  169. {
  170.     if (e == NULL)
  171. return 0;
  172.     if (!storeEntryValidToSend(e))
  173. return 0;
  174.     if (Config.onoff.icp_hit_stale)
  175. return 1;
  176.     if (refreshCheckICP(e, request))
  177. return 0;
  178.     return 1;
  179. }
  181. static void
  182. icpHandleIcpV2(int fd, struct sockaddr_in from, char *buf, int len)
  183. {
  184.     icp_common_t header;
  185.     StoreEntry *entry = NULL;
  186.     char *url = NULL;
  187.     const cache_key *key;
  188.     request_t *icp_request = NULL;
  189.     int allow = 0;
  190.     aclCheck_t checklist;
  191.     icp_common_t *reply;
  192.     int src_rtt = 0;
  193.     u_num32 flags = 0;
  194.     int rtt = 0;
  195.     int hops = 0;
  196.     xmemcpy(&header, buf, sizeof(icp_common_t));
  197.     /*
  198.      * Only these fields need to be converted
  199.      */
  200.     header.length = ntohs(header.length);
  201.     header.reqnum = ntohl(header.reqnum);
  202.     header.flags = ntohl(header.flags);
  203.     header.pad = ntohl(header.pad);
  205.     switch (header.opcode) {
  206.     case ICP_QUERY:
  207. /* We have a valid packet */
  208. url = buf + sizeof(icp_common_t) + sizeof(u_num32);
  209. if (strpbrk(url, w_space)) {
  210.     url = rfc1738_escape(url);
  211.     reply = icpCreateMessage(ICP_ERR, 0, url, header.reqnum, 0);
  212.     icpUdpSend(fd, &from, reply, LOG_UDP_INVALID, 0);
  213.     break;
  214. }
  215. if ((icp_request = urlParse(METHOD_GET, url)) == NULL) {
  216.     reply = icpCreateMessage(ICP_ERR, 0, url, header.reqnum, 0);
  217.     icpUdpSend(fd, &from, reply, LOG_UDP_INVALID, 0);
  218.     break;
  219. }
  220. checklist.src_addr = from.sin_addr;
  221. checklist.my_addr = no_addr;
  222. checklist.request = icp_request;
  223. allow = aclCheckFast(Config.accessList.icp, &checklist);
  224. if (!allow) {
  225.     debug(12, 2) ("icpHandleIcpV2: Access Denied for %s by %s.n",
  226. inet_ntoa(from.sin_addr), AclMatchedName);
  227.     if (clientdbCutoffDenied(from.sin_addr)) {
  228. /*
  229.  * count this DENIED query in the clientdb, even though
  230.  * we're not sending an ICP reply...
  231.  */
  232. clientdbUpdate(from.sin_addr, LOG_UDP_DENIED, PROTO_ICP, 0);
  233.     } else {
  234. reply = icpCreateMessage(ICP_DENIED, 0, url, header.reqnum, 0);
  235. icpUdpSend(fd, &from, reply, LOG_UDP_DENIED, 0);
  236.     }
  237.     break;
  238. }
  239. if (header.flags & ICP_FLAG_SRC_RTT) {
  240.     rtt = netdbHostRtt(icp_request->host);
  241.     hops = netdbHostHops(icp_request->host);
  242.     src_rtt = ((hops & 0xFFFF) << 16) | (rtt & 0xFFFF);
  243.     if (rtt)
  244. flags |= ICP_FLAG_SRC_RTT;
  245. }
  246. /* The peer is allowed to use this cache */
  247. entry = storeGetPublic(url, METHOD_GET);
  248. debug(12, 5) ("icpHandleIcpV2: OPCODE %sn", icp_opcode_str[header.opcode]);
  249. if (icpCheckUdpHit(entry, icp_request)) {
  250.     reply = icpCreateMessage(ICP_HIT, flags, url, header.reqnum, src_rtt);
  251.     icpUdpSend(fd, &from, reply, LOG_UDP_HIT, 0);
  252.     break;
  253. }
  254. if (Config.onoff.test_reachability && rtt == 0) {
  255.     if ((rtt = netdbHostRtt(icp_request->host)) == 0)
  256. netdbPingSite(icp_request->host);
  257. }
  258. /* if store is rebuilding, return a UDP_HIT, but not a MISS */
  259. if (store_rebuilding && opt_reload_hit_only) {
  260.     reply = icpCreateMessage(ICP_MISS_NOFETCH, flags, url, header.reqnum, src_rtt);
  261.     icpUdpSend(fd, &from, reply, LOG_UDP_MISS_NOFETCH, 0);
  262. } else if (hit_only_mode_until > squid_curtime) {
  263.     reply = icpCreateMessage(ICP_MISS_NOFETCH, flags, url, header.reqnum, src_rtt);
  264.     icpUdpSend(fd, &from, reply, LOG_UDP_MISS_NOFETCH, 0);
  265. } else if (Config.onoff.test_reachability && rtt == 0) {
  266.     reply = icpCreateMessage(ICP_MISS_NOFETCH, flags, url, header.reqnum, src_rtt);
  267.     icpUdpSend(fd, &from, reply, LOG_UDP_MISS_NOFETCH, 0);
  268. } else {
  269.     reply = icpCreateMessage(ICP_MISS, flags, url, header.reqnum, src_rtt);
  270.     icpUdpSend(fd, &from, reply, LOG_UDP_MISS, 0);
  271. }
  272. break;
  274.     case ICP_HIT:
  275. #if ALLOW_SOURCE_PING
  276.     case ICP_SECHO:
  277. #endif
  278.     case ICP_DECHO:
  279.     case ICP_MISS:
  280.     case ICP_DENIED:
  281.     case ICP_MISS_NOFETCH:
  282. if (neighbors_do_private_keys && header.reqnum == 0) {
  283.     debug(12, 0) ("icpHandleIcpV2: Neighbor %s returned reqnum = 0n",
  284. inet_ntoa(from.sin_addr));
  285.     debug(12, 0) ("icpHandleIcpV2: Disabling use of private keysn");
  286.     neighbors_do_private_keys = 0;
  287. }
  288. url = buf + sizeof(icp_common_t);
  289. debug(12, 3) ("icpHandleIcpV2: %s from %s for '%s'n",
  290.     icp_opcode_str[header.opcode],
  291.     inet_ntoa(from.sin_addr),
  292.     url);
  293. key = icpGetCacheKey(url, (int) header.reqnum);
  294. /* call neighborsUdpAck even if ping_status != PING_WAITING */
  295. neighborsUdpAck(key, &header, &from);
  296. break;
  298.     case ICP_INVALID:
  299.     case ICP_ERR:
  300. break;
  302.     default:
  303. debug(12, 0) ("icpHandleIcpV2: UNKNOWN OPCODE: %d from %sn",
  304.     header.opcode, inet_ntoa(from.sin_addr));
  305. break;
  306.     }
  307.     if (icp_request)
  308. requestDestroy(icp_request);
  309. }
  311. #ifdef ICP_PKT_DUMP
  312. static void
  313. icpPktDump(icp_common_t * pkt)
  314. {
  315.     struct in_addr a;
  317.     debug(12, 9) ("opcode:     %3d %sn",
  318. (int) pkt->opcode,
  319. icp_opcode_str[pkt->opcode]);
  320.     debug(12, 9) ("version: %-8dn", (int) pkt->version);
  321.     debug(12, 9) ("length:  %-8dn", (int) ntohs(pkt->length));
  322.     debug(12, 9) ("reqnum:  %-8dn", ntohl(pkt->reqnum));
  323.     debug(12, 9) ("flags:   %-8xn", ntohl(pkt->flags));
  324.     a.s_addr = pkt->shostid;
  325.     debug(12, 9) ("shostid: %sn", inet_ntoa(a));
  326.     debug(12, 9) ("payload: %sn", (char *) pkt + sizeof(icp_common_t));
  327. }
  328. #endif
  330. void
  331. icpHandleUdp(int sock, void *data)
  332. {
  333.     int *N = data;
  334.     struct sockaddr_in from;
  335.     socklen_t from_len;
  336.     LOCAL_ARRAY(char, buf, SQUID_UDP_SO_RCVBUF);
  337.     int len;
  338.     int icp_version;
  339.     int max = INCOMING_ICP_MAX;
  340.     commSetSelect(sock, COMM_SELECT_READ, icpHandleUdp, NULL, 0);
  341.     while (max--) {
  342. from_len = sizeof(from);
  343. memset(&from, '', from_len);
  344. Counter.syscalls.sock.recvfroms++;
  345. len = recvfrom(sock,
  346.     buf,
  347.     SQUID_UDP_SO_RCVBUF - 1,
  348.     0,
  349.     (struct sockaddr *) &from,
  350.     &from_len);
  351. if (len == 0)
  352.     break;
  353. if (len < 0) {
  354.     if (ignoreErrno(errno))
  355. break;
  356. #ifdef _SQUID_LINUX_
  357.     /* Some Linux systems seem to set the FD for reading and then
  358.      * return ECONNREFUSED when sendto() fails and generates an ICMP
  359.      * port unreachable message. */
  360.     /* or maybe an EHOSTUNREACH "No route to host" message */
  361.     if (errno != ECONNREFUSED && errno != EHOSTUNREACH)
  362. #endif
  363. debug(50, 1) ("icpHandleUdp: FD %d recvfrom: %sn",
  364.     sock, xstrerror());
  365.     break;
  366. }
  367. (*N)++;
  368. icpCount(buf, RECV, (size_t) len, 0);
  369. buf[len] = '';
  370. debug(12, 4) ("icpHandleUdp: FD %d: received %d bytes from %s.n",
  371.     sock,
  372.     len,
  373.     inet_ntoa(from.sin_addr));
  374. #ifdef ICP_PACKET_DUMP
  375. icpPktDump(buf);
  376. #endif
  377. if (len < sizeof(icp_common_t)) {
  378.     debug(12, 4) ("icpHandleUdp: Ignoring too-small UDP packetn");
  379.     break;
  380. }
  381. icp_version = (int) buf[1]; /* cheat! */
  382. if (icp_version == ICP_VERSION_2)
  383.     icpHandleIcpV2(sock, from, buf, len);
  384. else if (icp_version == ICP_VERSION_3)
  385.     icpHandleIcpV3(sock, from, buf, len);
  386. else
  387.     debug(12, 1) ("WARNING: Unused ICP version %d received from %s:%dn",
  388. icp_version,
  389. inet_ntoa(from.sin_addr),
  390. ntohs(from.sin_port));
  391.     }
  392. }
  394. void
  395. icpConnectionsOpen(void)
  396. {
  397.     u_short port;
  398.     struct in_addr addr;
  399.     struct sockaddr_in xaddr;
  400.     int x;
  401.     socklen_t len;
  402.     wordlist *s;
  403.     if (Config2.Accel.on && !Config.onoff.accel_with_proxy)
  404. return;
  405.     if ((port = Config.Port.icp) <= 0)
  406. return;
  407.     enter_suid();
  408.     theInIcpConnection = comm_open(SOCK_DGRAM,
  409. 0,
  410. Config.Addrs.udp_incoming,
  411. port,
  412. COMM_NONBLOCKING,
  413. "ICP Socket");
  414.     leave_suid();
  415.     if (theInIcpConnection < 0)
  416. fatal("Cannot open ICP Port");
  417.     commSetSelect(theInIcpConnection,
  418. COMM_SELECT_READ,
  419. icpHandleUdp,
  420. NULL,
  421. 0);
  422.     for (s = Config.mcast_group_list; s; s = s->next)
  423. ipcache_nbgethostbyname(s->key, mcastJoinGroups, NULL);
  424.     debug(12, 1) ("Accepting ICP messages on port %d, FD %d.n",
  425. (int) port, theInIcpConnection);
  426.     if ((addr = Config.Addrs.udp_outgoing).s_addr != no_addr.s_addr) {
  427. enter_suid();
  428. theOutIcpConnection = comm_open(SOCK_DGRAM,
  429.     0,
  430.     addr,
  431.     port,
  432.     COMM_NONBLOCKING,
  433.     "ICP Port");
  434. leave_suid();
  435. if (theOutIcpConnection < 0)
  436.     fatal("Cannot open Outgoing ICP Port");
  437. commSetSelect(theOutIcpConnection,
  438.     COMM_SELECT_READ,
  439.     icpHandleUdp,
  440.     NULL,
  441.     0);
  442. debug(12, 1) ("Outgoing ICP messages on port %d, FD %d.n",
  443.     (int) port, theOutIcpConnection);
  444. fd_note(theOutIcpConnection, "Outgoing ICP socket");
  445. fd_note(theInIcpConnection, "Incoming ICP socket");
  446.     } else {
  447. theOutIcpConnection = theInIcpConnection;
  448.     }
  449.     memset(&theOutICPAddr, '', sizeof(struct in_addr));
  450.     len = sizeof(struct sockaddr_in);
  451.     memset(&xaddr, '', len);
  452.     x = getsockname(theOutIcpConnection,
  453. (struct sockaddr *) &xaddr, &len);
  454.     if (x < 0)
  455. debug(50, 1) ("theOutIcpConnection FD %d: getsockname: %sn",
  456.     theOutIcpConnection, xstrerror());
  457.     else
  458. theOutICPAddr = xaddr.sin_addr;
  459. }
  461. /*
  462.  * icpConnectionShutdown only closes the 'in' socket if it is 
  463.  * different than the 'out' socket.
  464.  */
  465. void
  466. icpConnectionShutdown(void)
  467. {
  468.     if (theInIcpConnection < 0)
  469. return;
  470.     if (theInIcpConnection != theOutIcpConnection) {
  471. debug(12, 1) ("FD %d Closing ICP connectionn", theInIcpConnection);
  472. comm_close(theInIcpConnection);
  473.     }
  474.     /*
  475.      * Here we set 'theInIcpConnection' to -1 even though the ICP 'in'
  476.      * and 'out' sockets might be just one FD.  This prevents this
  477.      * function from executing repeatedly.  When we are really ready to
  478.      * exit or restart, main will comm_close the 'out' descriptor.
  479.      */
  480.     theInIcpConnection = -1;
  481.     /*
  482.      * Normally we only write to the outgoing ICP socket, but
  483.      * we also have a read handler there to catch messages sent
  484.      * to that specific interface.  During shutdown, we must
  485.      * disable reading on the outgoing socket.
  486.      */
  487.     assert(theOutIcpConnection > -1);
  488.     commSetSelect(theOutIcpConnection, COMM_SELECT_READ, NULL, NULL, 0);
  489. }
  491. void
  492. icpConnectionClose(void)
  493. {
  494.     icpConnectionShutdown();
  495.     if (theOutIcpConnection > -1) {
  496. debug(12, 1) ("FD %d Closing ICP connectionn", theOutIcpConnection);
  497. comm_close(theOutIcpConnection);
  498. theOutIcpConnection = -1;
  499.     }
  500. }
  502. static void
  503. icpCount(void *buf, int which, size_t len, int delay)
  504. {
  505.     icp_common_t *icp = buf;
  506.     if (len < sizeof(*icp))
  507. return;
  508.     if (SENT == which) {
  509. Counter.icp.pkts_sent++;
  510. kb_incr(&Counter.icp.kbytes_sent, len);
  511. if (ICP_QUERY == icp->opcode) {
  512.     Counter.icp.queries_sent++;
  513.     kb_incr(&Counter.icp.q_kbytes_sent, len);
  514. } else {
  515.     Counter.icp.replies_sent++;
  516.     kb_incr(&Counter.icp.r_kbytes_sent, len);
  517.     /* this is the sent-reply service time */
  518.     statHistCount(&Counter.icp.reply_svc_time, delay);
  519. }
  520. if (ICP_HIT == icp->opcode)
  521.     Counter.icp.hits_sent++;
  522.     } else if (RECV == which) {
  523. Counter.icp.pkts_recv++;
  524. kb_incr(&Counter.icp.kbytes_recv, len);
  525. if (ICP_QUERY == icp->opcode) {
  526.     Counter.icp.queries_recv++;
  527.     kb_incr(&Counter.icp.q_kbytes_recv, len);
  528. } else {
  529.     Counter.icp.replies_recv++;
  530.     kb_incr(&Counter.icp.r_kbytes_recv, len);
  531.     /* Counter.icp.query_svc_time set in clientUpdateCounters */
  532. }
  533. if (ICP_HIT == icp->opcode)
  534.     Counter.icp.hits_recv++;
  535.     }
  536. }
  538. #define N_QUERIED_KEYS 8192
  539. #define N_QUERIED_KEYS_MASK 8191
  540. static cache_key queried_keys[N_QUERIED_KEYS][MD5_DIGEST_CHARS];
  542. int
  543. icpSetCacheKey(const cache_key * key)
  544. {
  545.     static int reqnum = 0;
  546.     if (++reqnum < 0)
  547. reqnum = 1;
  548.     storeKeyCopy(queried_keys[reqnum & N_QUERIED_KEYS_MASK], key);
  549.     return reqnum;
  550. }
  552. const cache_key *
  553. icpGetCacheKey(const char *url, int reqnum)
  554. {
  555.     if (neighbors_do_private_keys && reqnum)
  556. return queried_keys[reqnum & N_QUERIED_KEYS_MASK];
  557.     return storeKeyPublic(url, METHOD_GET);
  558. }