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

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

代理服务器

开发平台：

Unix_Linux

comm.c：源码内容
  2. /*
  3.  * $Id: comm.c,v 1.299 1999/01/18 22:23:32 wessels Exp $
  4.  *
  5.  * DEBUG: section 5     Socket Functions
  6.  * AUTHOR: Harvest Derived
  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. #ifdef HAVE_NETINET_TCP_H
  39. #include <netinet/tcp.h>
  40. #endif
  42. #if USE_ASYNC_IO
  43. #define MAX_POLL_TIME 10
  44. #else
  45. #define MAX_POLL_TIME 1000
  46. #endif
  48. typedef struct {
  49.     char *host;
  50.     u_short port;
  51.     struct sockaddr_in S;
  52.     CNCB *callback;
  53.     void *data;
  54.     struct in_addr in_addr;
  55.     int locks;
  56.     int fd;
  57.     int tries;
  58.     int addrcount;
  59.     int connstart;
  60. } ConnectStateData;
  62. /* STATIC */
  63. static int commBind(int s, struct in_addr, u_short port);
  64. static void commSetReuseAddr(int);
  65. static void commSetNoLinger(int);
  66. static void CommWriteStateCallbackAndFree(int fd, int code);
  67. #ifdef TCP_NODELAY
  68. static void commSetTcpNoDelay(int);
  69. #endif
  70. static void commSetTcpRcvbuf(int, int);
  71. static PF commConnectFree;
  72. static PF commConnectHandle;
  73. static PF commHandleWrite;
  74. static IPH commConnectDnsHandle;
  75. static void commConnectCallback(ConnectStateData * cs, int status);
  76. static int commResetFD(ConnectStateData * cs);
  77. static int commRetryConnect(ConnectStateData * cs);
  79. static void
  80. CommWriteStateCallbackAndFree(int fd, int code)
  81. {
  82.     CommWriteStateData *CommWriteState = fd_table[fd].rwstate;
  83.     CWCB *callback = NULL;
  84.     void *data;
  85.     fd_table[fd].rwstate = NULL;
  86.     if (CommWriteState == NULL)
  87. return;
  88.     if (CommWriteState->free_func) {
  89. CommWriteState->free_func(CommWriteState->buf);
  90. CommWriteState->buf = NULL;
  91.     }
  92.     callback = CommWriteState->handler;
  93.     data = CommWriteState->handler_data;
  94.     CommWriteState->handler = NULL;
  95.     if (callback && cbdataValid(data))
  96. callback(fd, CommWriteState->buf, CommWriteState->offset, code, data);
  97.     cbdataUnlock(data);
  98.     safe_free(CommWriteState);
  99. }
  101. /* Return the local port associated with fd. */
  102. u_short
  103. comm_local_port(int fd)
  104. {
  105.     struct sockaddr_in addr;
  106.     socklen_t addr_len = 0;
  107.     fde *F = &fd_table[fd];
  109.     /* If the fd is closed already, just return */
  110.     if (!F->flags.open) {
  111. debug(5, 0) ("comm_local_port: FD %d has been closed.n", fd);
  112. return 0;
  113.     }
  114.     if (F->local_port)
  115. return F->local_port;
  116.     addr_len = sizeof(addr);
  117.     if (getsockname(fd, (struct sockaddr *) &addr, &addr_len)) {
  118. debug(50, 1) ("comm_local_port: Failed to retrieve TCP/UDP port number for socket: FD %d: %sn", fd, xstrerror());
  119. return 0;
  120.     }
  121.     F->local_port = ntohs(addr.sin_port);
  122.     debug(5, 6) ("comm_local_port: FD %d: port %dn", fd, (int) F->local_port);
  123.     return F->local_port;
  124. }
  126. static int
  127. commBind(int s, struct in_addr in_addr, u_short port)
  128. {
  129.     struct sockaddr_in S;
  131.     memset(&S, '', sizeof(S));
  132.     S.sin_family = AF_INET;
  133.     S.sin_port = htons(port);
  134.     S.sin_addr = in_addr;
  135.     Counter.syscalls.sock.binds++;
  136.     if (bind(s, (struct sockaddr *) &S, sizeof(S)) == 0)
  137. return COMM_OK;
  138.     debug(50, 0) ("commBind: Cannot bind socket FD %d to %s:%d: %sn",
  139. s,
  140. S.sin_addr.s_addr == INADDR_ANY ? "*" : inet_ntoa(S.sin_addr),
  141. (int) port,
  142. xstrerror());
  143.     return COMM_ERROR;
  144. }
  146. /* Create a socket. Default is blocking, stream (TCP) socket.  IO_TYPE
  147.  * is OR of flags specified in comm.h. */
  148. int
  149. comm_open(int sock_type,
  150.     int proto,
  151.     struct in_addr addr,
  152.     u_short port,
  153.     int flags,
  154.     const char *note)
  155. {
  156.     int new_socket;
  157.     fde *F = NULL;
  159.     /* Create socket for accepting new connections. */
  160.     Counter.syscalls.sock.sockets++;
  161.     if ((new_socket = socket(AF_INET, sock_type, proto)) < 0) {
  162. /* Increase the number of reserved fd's if calls to socket()
  163.  * are failing because the open file table is full.  This
  164.  * limits the number of simultaneous clients */
  165. switch (errno) {
  166. case ENFILE:
  167. case EMFILE:
  168.     debug(50, 1) ("comm_open: socket failure: %sn", xstrerror());
  169.     break;
  170. default:
  171.     debug(50, 0) ("comm_open: socket failure: %sn", xstrerror());
  172. }
  173. fdAdjustReserved();
  174. return -1;
  175.     }
  176.     /* update fdstat */
  177.     debug(5, 5) ("comm_open: FD %d is a new socketn", new_socket);
  178.     fd_open(new_socket, FD_SOCKET, note);
  179.     F = &fd_table[new_socket];
  180.     if (!(flags & COMM_NOCLOEXEC))
  181. commSetCloseOnExec(new_socket);
  182.     if ((flags & COMM_REUSEADDR))
  183. commSetReuseAddr(new_socket);
  184.     if (port > (u_short) 0) {
  185. commSetNoLinger(new_socket);
  186. if (opt_reuseaddr)
  187.     commSetReuseAddr(new_socket);
  188.     }
  189.     if (addr.s_addr != no_addr.s_addr) {
  190. if (commBind(new_socket, addr, port) != COMM_OK) {
  191.     comm_close(new_socket);
  192.     return -1;
  193. }
  194.     }
  195.     F->local_port = port;
  197.     if (flags & COMM_NONBLOCKING)
  198. if (commSetNonBlocking(new_socket) == COMM_ERROR)
  199.     return -1;
  200. #ifdef TCP_NODELAY
  201.     if (sock_type == SOCK_STREAM)
  202. commSetTcpNoDelay(new_socket);
  203. #endif
  204.     if (Config.tcpRcvBufsz > 0 && sock_type == SOCK_STREAM)
  205. commSetTcpRcvbuf(new_socket, Config.tcpRcvBufsz);
  206.     return new_socket;
  207. }
  209. /*
  210.  * NOTE: set the listen queue to Squid_MaxFD/4 and rely on the kernel to      
  211.  * impose an upper limit.  Solaris' listen(3n) page says it has   
  212.  * no limit on this parameter, but sys/socket.h sets SOMAXCONN 
  213.  * to 5.  HP-UX currently has a limit of 20.  SunOS is 5 and
  214.  * OSF 3.0 is 8.
  215.  */
  216. int
  217. comm_listen(int sock)
  218. {
  219.     int x;
  220.     if ((x = listen(sock, Squid_MaxFD >> 2)) < 0) {
  221. debug(50, 0) ("comm_listen: listen(%d, %d): %sn",
  222.     Squid_MaxFD >> 2,
  223.     sock, xstrerror());
  224. return x;
  225.     }
  226.     return sock;
  227. }
  229. void
  230. commConnectStart(int fd, const char *host, u_short port, CNCB * callback, void *data)
  231. {
  232.     ConnectStateData *cs = xcalloc(1, sizeof(ConnectStateData));
  233.     debug(5, 3) ("commConnectStart: FD %d, %s:%dn", fd, host, (int) port);
  234.     cbdataAdd(cs, cbdataXfree, 0);
  235.     cs->fd = fd;
  236.     cs->host = xstrdup(host);
  237.     cs->port = port;
  238.     cs->callback = callback;
  239.     cs->data = data;
  240.     cbdataLock(cs->data);
  241.     comm_add_close_handler(fd, commConnectFree, cs);
  242.     cs->locks++;
  243.     ipcache_nbgethostbyname(host, commConnectDnsHandle, cs);
  244. }
  246. static void
  247. commConnectDnsHandle(const ipcache_addrs * ia, void *data)
  248. {
  249.     ConnectStateData *cs = data;
  250.     assert(cs->locks == 1);
  251.     cs->locks--;
  252.     if (ia == NULL) {
  253. debug(5, 3) ("commConnectDnsHandle: Unknown host: %sn", cs->host);
  254. if (!dns_error_message) {
  255.     dns_error_message = "Unknown DNS error";
  256.     debug(5, 1) ("commConnectDnsHandle: Bad dns_error_messagen");
  257. }
  258. assert(dns_error_message != NULL);
  259. commConnectCallback(cs, COMM_ERR_DNS);
  260. return;
  261.     }
  262.     assert(ia->cur < ia->count);
  263.     cs->in_addr = ia->in_addrs[ia->cur];
  264.     ipcacheCycleAddr(cs->host, NULL);
  265.     cs->addrcount = ia->count;
  266.     cs->connstart = squid_curtime;
  267.     commConnectHandle(cs->fd, cs);
  268. }
  270. static void
  271. commConnectCallback(ConnectStateData * cs, int status)
  272. {
  273.     CNCB *callback = cs->callback;
  274.     void *data = cs->data;
  275.     int fd = cs->fd;
  276.     comm_remove_close_handler(fd, commConnectFree, cs);
  277.     cs->callback = NULL;
  278.     cs->data = NULL;
  279.     commSetTimeout(fd, -1, NULL, NULL);
  280.     commConnectFree(fd, cs);
  281.     if (cbdataValid(data))
  282. callback(fd, status, data);
  283.     cbdataUnlock(data);
  284. }
  286. static void
  287. commConnectFree(int fd, void *data)
  288. {
  289.     ConnectStateData *cs = data;
  290.     debug(5, 3) ("commConnectFree: FD %dn", fd);
  291.     if (cs->locks)
  292. ipcacheUnregister(cs->host, cs);
  293.     if (cs->data)
  294. cbdataUnlock(cs->data);
  295.     safe_free(cs->host);
  296.     cbdataFree(cs);
  297. }
  299. /* Reset FD so that we can connect() again */
  300. static int
  301. commResetFD(ConnectStateData * cs)
  302. {
  303.     int fd2;
  304.     if (!cbdataValid(cs->data))
  305. return 0;
  306.     Counter.syscalls.sock.sockets++;
  307.     fd2 = socket(AF_INET, SOCK_STREAM, 0);
  308.     Counter.syscalls.sock.sockets++;
  309.     if (fd2 < 0) {
  310. debug(5, 0) ("commResetFD: socket: %sn", xstrerror());
  311. fdAdjustReserved();
  312. return 0;
  313.     }
  314.     if (dup2(fd2, cs->fd) < 0) {
  315. debug(5, 0) ("commResetFD: dup2: %sn", xstrerror());
  316. fdAdjustReserved();
  317. return 0;
  318.     }
  319.     close(fd2);
  320.     fd_table[cs->fd].flags.called_connect = 0;
  321.     /*
  322.      * yuck, this has assumptions about comm_open() arguments for
  323.      * the original socket
  324.      */
  325.     commSetCloseOnExec(cs->fd);
  326.     if (Config.Addrs.tcp_outgoing.s_addr != no_addr.s_addr) {
  327. if (commBind(cs->fd, Config.Addrs.tcp_outgoing, 0) != COMM_OK) {
  328.     comm_close(cs->fd);
  329.     return 0;
  330. }
  331.     }
  332.     commSetNonBlocking(cs->fd);
  333. #ifdef TCP_NODELAY
  334.     commSetTcpNoDelay(cs->fd);
  335. #endif
  336.     if (Config.tcpRcvBufsz > 0)
  337. commSetTcpRcvbuf(cs->fd, Config.tcpRcvBufsz);
  338.     return 1;
  339. }
  341. static int
  342. commRetryConnect(ConnectStateData * cs)
  343. {
  344.     assert(cs->addrcount > 0);
  345.     if (cs->addrcount == 1) {
  346. if (cs->tries >= Config.retry.maxtries)
  347.     return 0;
  348. if (squid_curtime - cs->connstart > Config.Timeout.connect)
  349.     return 0;
  350.     } else {
  351. if (cs->tries > cs->addrcount)
  352.     return 0;
  353.     }
  354.     return commResetFD(cs);
  355. }
  357. /* Connect SOCK to specified DEST_PORT at DEST_HOST. */
  358. static void
  359. commConnectHandle(int fd, void *data)
  360. {
  361.     ConnectStateData *cs = data;
  362.     if (cs->S.sin_addr.s_addr == 0) {
  363. cs->S.sin_family = AF_INET;
  364. cs->S.sin_addr = cs->in_addr;
  365. cs->S.sin_port = htons(cs->port);
  366. if (Config.onoff.log_fqdn)
  367.     fqdncache_gethostbyaddr(cs->S.sin_addr, FQDN_LOOKUP_IF_MISS);
  368.     }
  369.     switch (comm_connect_addr(fd, &cs->S)) {
  370.     case COMM_INPROGRESS:
  371. debug(5, 5) ("commConnectHandle: FD %d: COMM_INPROGRESSn", fd);
  372. commSetSelect(fd, COMM_SELECT_WRITE, commConnectHandle, cs, 0);
  373. break;
  374.     case COMM_OK:
  375. ipcacheMarkGoodAddr(cs->host, cs->S.sin_addr);
  376. commConnectCallback(cs, COMM_OK);
  377. break;
  378.     default:
  379. cs->tries++;
  380. ipcacheMarkBadAddr(cs->host, cs->S.sin_addr);
  381. if (Config.onoff.test_reachability)
  382.     netdbDeleteAddrNetwork(cs->S.sin_addr);
  383. if (commRetryConnect(cs)) {
  384.     cs->locks++;
  385.     ipcache_nbgethostbyname(cs->host, commConnectDnsHandle, cs);
  386. } else {
  387.     commConnectCallback(cs, COMM_ERR_CONNECT);
  388. }
  389. break;
  390.     }
  391. }
  393. int
  394. commSetTimeout(int fd, int timeout, PF * handler, void *data)
  395. {
  396.     fde *F;
  397.     debug(5, 3) ("commSetTimeout: FD %d timeout %dn", fd, timeout);
  398.     assert(fd >= 0);
  399.     assert(fd < Squid_MaxFD);
  400.     F = &fd_table[fd];
  401.     assert(F->flags.open);
  402.     if (timeout < 0) {
  403. F->timeout_handler = NULL;
  404. F->timeout_data = NULL;
  405. return F->timeout = 0;
  406.     }
  407.     assert(handler || F->timeout_handler);
  408.     if (handler || data) {
  409. F->timeout_handler = handler;
  410. F->timeout_data = data;
  411.     }
  412.     return F->timeout = squid_curtime + (time_t) timeout;
  413. }
  415. int
  416. comm_connect_addr(int sock, const struct sockaddr_in *address)
  417. {
  418.     int status = COMM_OK;
  419.     fde *F = &fd_table[sock];
  420.     int x;
  421.     int err = 0;
  422.     socklen_t errlen;
  423.     assert(ntohs(address->sin_port) != 0);
  424.     /* Establish connection. */
  425.     errno = 0;
  426.     if (!F->flags.called_connect) {
  427. F->flags.called_connect = 1;
  428. Counter.syscalls.sock.connects++;
  429. x = connect(sock, (struct sockaddr *) address, sizeof(*address));
  430. if (x < 0)
  431.     debug(5, 9) ("connect FD %d: %sn", sock, xstrerror());
  432.     } else {
  433. #if defined(_SQUID_NEWSOS6_)
  434. /* Makoto MATSUSHITA <matusita@ics.es.osaka-u.ac.jp> */
  435. connect(sock, (struct sockaddr *) address, sizeof(*address));
  436. if (errno == EINVAL) {
  437.     errlen = sizeof(err);
  438.     x = getsockopt(sock, SOL_SOCKET, SO_ERROR, &err, &errlen);
  439.     if (x >= 0)
  440. errno = x;
  441. }
  442. #else
  443. errlen = sizeof(err);
  444. x = getsockopt(sock, SOL_SOCKET, SO_ERROR, &err, &errlen);
  445. if (x == 0)
  446.     errno = err;
  447. #if defined(_SQUID_SOLARIS_)
  448. /*
  449.  * Solaris 2.4's socket emulation doesn't allow you
  450.  * to determine the error from a failed non-blocking
  451.  * connect and just returns EPIPE.  Create a fake
  452.  * error message for connect.   -- fenner@parc.xerox.com
  453.  */
  454. if (x < 0 && errno == EPIPE)
  455.     errno = ENOTCONN;
  456. #endif
  457. #endif
  458.     }
  459.     if (errno == 0 || errno == EISCONN)
  460. status = COMM_OK;
  461.     else if (ignoreErrno(errno))
  462. status = COMM_INPROGRESS;
  463.     else
  464. return COMM_ERROR;
  465.     xstrncpy(F->ipaddr, inet_ntoa(address->sin_addr), 16);
  466.     F->remote_port = ntohs(address->sin_port);
  467.     if (status == COMM_OK) {
  468. debug(5, 10) ("comm_connect_addr: FD %d connected to %s:%dn",
  469.     sock, F->ipaddr, F->remote_port);
  470.     } else if (status == COMM_INPROGRESS) {
  471. debug(5, 10) ("comm_connect_addr: FD %d connection pendingn", sock);
  472.     }
  473.     return status;
  474. }
  476. /* Wait for an incoming connection on FD.  FD should be a socket returned
  477.  * from comm_listen. */
  478. int
  479. comm_accept(int fd, struct sockaddr_in *pn, struct sockaddr_in *me)
  480. {
  481.     int sock;
  482.     struct sockaddr_in P;
  483.     struct sockaddr_in M;
  484.     socklen_t Slen;
  485.     fde *F = NULL;
  486.     Slen = sizeof(P);
  487.     Counter.syscalls.sock.accepts++;
  488.     if ((sock = accept(fd, (struct sockaddr *) &P, &Slen)) < 0) {
  489. if (ignoreErrno(errno)) {
  490.     debug(50, 5) ("comm_accept: FD %d: %sn", fd, xstrerror());
  491.     return COMM_NOMESSAGE;
  492. } else if (ENFILE == errno || EMFILE == errno) {
  493.     debug(50, 3) ("comm_accept: FD %d: %sn", fd, xstrerror());
  494.     return COMM_ERROR;
  495. } else {
  496.     debug(50, 1) ("comm_accept: FD %d: %sn", fd, xstrerror());
  497.     return COMM_ERROR;
  498. }
  499.     }
  500.     if (pn)
  501. *pn = P;
  502.     Slen = sizeof(M);
  503.     memset(&M, '', Slen);
  504.     getsockname(sock, (struct sockaddr *) &M, &Slen);
  505.     if (me)
  506. *me = M;
  507.     commSetCloseOnExec(sock);
  508.     /* fdstat update */
  509.     fd_open(sock, FD_SOCKET, "HTTP Request");
  510.     F = &fd_table[sock];
  511.     xstrncpy(F->ipaddr, inet_ntoa(P.sin_addr), 16);
  512.     F->remote_port = htons(P.sin_port);
  513.     F->local_port = htons(M.sin_port);
  514.     commSetNonBlocking(sock);
  515.     return sock;
  516. }
  518. void
  519. commCallCloseHandlers(int fd)
  520. {
  521.     fde *F = &fd_table[fd];
  522.     close_handler *ch;
  523.     debug(5, 5) ("commCallCloseHandlers: FD %dn", fd);
  524.     while ((ch = F->close_handler) != NULL) {
  525. F->close_handler = ch->next;
  526. debug(5, 5) ("commCallCloseHandlers: ch->handler=%pn", ch->handler);
  527. if (cbdataValid(ch->data))
  528.     ch->handler(fd, ch->data);
  529. cbdataUnlock(ch->data);
  530. safe_free(ch);
  531.     }
  532. }
  534. #if LINGERING_CLOSE
  535. static void
  536. commLingerClose(int fd, void *unused)
  537. {
  538.     LOCAL_ARRAY(char, buf, 1024);
  539.     int n;
  540.     n = read(fd, buf, 1024);
  541.     if (n < 0)
  542. debug(5, 3) ("commLingerClose: FD %d read: %sn", fd, xstrerror());
  543.     comm_close(fd);
  544. }
  546. static void
  547. commLingerTimeout(int fd, void *unused)
  548. {
  549.     debug(5, 3) ("commLingerTimeout: FD %dn", fd);
  550.     comm_close(fd);
  551. }
  553. /*
  554.  * Inspired by apache
  555.  */
  556. void
  557. comm_lingering_close(int fd)
  558. {
  559.     if (shutdown(fd, 1) < 0) {
  560. comm_close(fd);
  561. return;
  562.     }
  563.     fd_note(fd, "lingering close");
  564.     commSetTimeout(fd, 10, commLingerTimeout, NULL);
  565.     commSetSelect(fd, COMM_SELECT_READ, commLingerClose, NULL, 0);
  566. }
  567. #endif
  569. void
  570. comm_close(int fd)
  571. {
  572.     fde *F = NULL;
  573. #if USE_ASYNC_IO
  574.     int doaioclose = 1;
  575. #endif
  576.     debug(5, 5) ("comm_close: FD %dn", fd);
  577.     assert(fd >= 0);
  578.     assert(fd < Squid_MaxFD);
  579.     F = &fd_table[fd];
  580.     if (F->flags.closing)
  581. return;
  582.     if (shutting_down && (!F->flags.open || F->type == FD_FILE))
  583. return;
  584.     assert(F->flags.open);
  585.     assert(F->type != FD_FILE);
  586. #ifdef USE_ASYNC_IO
  587.     if (F->flags.nolinger && F->flags.nonblocking)
  588. doaioclose = 0;
  589. #endif
  590.     F->flags.closing = 1;
  591.     CommWriteStateCallbackAndFree(fd, COMM_ERR_CLOSING);
  592.     commCallCloseHandlers(fd);
  593.     if (F->uses) /* assume persistent connect count */
  594. pconnHistCount(1, F->uses);
  595.     fd_close(fd); /* update fdstat */
  596. #if defined(_SQUID_LINUX_)
  597.     /*
  598.      * michael@metal.iinet.net.au sez close() on
  599.      * network sockets never blocks.
  600.      */
  601.     close(fd);
  602. #elif USE_ASYNC_IO
  603.     if (doaioclose)
  604. aioClose(fd);
  605.     else
  606. close(fd);
  607. #else
  608.     close(fd);
  609. #endif
  610.     Counter.syscalls.sock.closes++;
  611. }
  613. /* Send a udp datagram to specified TO_ADDR. */
  614. int
  615. comm_udp_sendto(int fd,
  616.     const struct sockaddr_in *to_addr,
  617.     int addr_len,
  618.     const void *buf,
  619.     int len)
  620. {
  621.     int x;
  622.     Counter.syscalls.sock.sendtos++;
  623.     x = sendto(fd, buf, len, 0, (struct sockaddr *) to_addr, addr_len);
  624.     if (x < 0) {
  625. #ifdef _SQUID_LINUX_
  626. if (ECONNREFUSED != errno)
  627. #endif
  628.     debug(50, 1) ("comm_udp_sendto: FD %d, %s, port %d: %sn",
  629. fd,
  630. inet_ntoa(to_addr->sin_addr),
  631. (int) htons(to_addr->sin_port),
  632. xstrerror());
  633. return COMM_ERROR;
  634.     }
  635.     return x;
  636. }
  638. void
  639. commSetDefer(int fd, DEFER * func, void *data)
  640. {
  641.     fde *F = &fd_table[fd];
  642.     F->defer_check = func;
  643.     F->defer_data = data;
  644. }
  646. void
  647. commSetSelect(int fd, unsigned int type, PF * handler, void *client_data, time_t timeout)
  648. {
  649.     fde *F = &fd_table[fd];
  650.     assert(fd >= 0);
  651.     assert(F->flags.open);
  652.     debug(5, 5) ("commSetSelect: FD %d type %dn", fd, type);
  653.     if (type & COMM_SELECT_READ) {
  654. F->read_handler = handler;
  655. F->read_data = client_data;
  656. commUpdateReadBits(fd, handler);
  657.     }
  658.     if (type & COMM_SELECT_WRITE) {
  659. F->write_handler = handler;
  660. F->write_data = client_data;
  661. commUpdateWriteBits(fd, handler);
  662.     }
  663.     if (timeout)
  664. F->timeout = squid_curtime + timeout;
  665. }
  667. void
  668. comm_add_close_handler(int fd, PF * handler, void *data)
  669. {
  670.     close_handler *new = xmalloc(sizeof(*new));
  671.     close_handler *c;
  672.     debug(5, 5) ("comm_add_close_handler: FD %d, handler=%p, data=%pn",
  673. fd, handler, data);
  674.     for (c = fd_table[fd].close_handler; c; c = c->next)
  675. assert(c->handler != handler || c->data != data);
  676.     new->handler = handler;
  677.     new->data = data;
  678.     new->next = fd_table[fd].close_handler;
  679.     fd_table[fd].close_handler = new;
  680.     cbdataLock(data);
  681. }
  683. void
  684. comm_remove_close_handler(int fd, PF * handler, void *data)
  685. {
  686.     close_handler *p;
  687.     close_handler *last = NULL;
  688.     /* Find handler in list */
  689.     debug(5, 5) ("comm_remove_close_handler: FD %d, handler=%p, data=%pn",
  690. fd, handler, data);
  691.     for (p = fd_table[fd].close_handler; p != NULL; last = p, p = p->next)
  692. if (p->handler == handler && p->data == data)
  693.     break; /* This is our handler */
  694.     assert(p != NULL);
  695.     /* Remove list entry */
  696.     if (last)
  697. last->next = p->next;
  698.     else
  699. fd_table[fd].close_handler = p->next;
  700.     cbdataUnlock(p->data);
  701.     safe_free(p);
  702. }
  704. static void
  705. commSetNoLinger(int fd)
  706. {
  707.     struct linger L;
  708.     L.l_onoff = 0; /* off */
  709.     L.l_linger = 0;
  710.     if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *) &L, sizeof(L)) < 0)
  711. debug(50, 0) ("commSetNoLinger: FD %d: %sn", fd, xstrerror());
  712.     fd_table[fd].flags.nolinger = 1;
  713. }
  715. static void
  716. commSetReuseAddr(int fd)
  717. {
  718.     int on = 1;
  719.     if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on)) < 0)
  720. debug(50, 1) ("commSetReuseAddr: FD %d: %sn", fd, xstrerror());
  721. }
  723. static void
  724. commSetTcpRcvbuf(int fd, int size)
  725. {
  726.     if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (char *) &size, sizeof(size)) < 0)
  727. debug(50, 1) ("commSetTcpRcvbuf: FD %d, SIZE %d: %sn",
  728.     fd, size, xstrerror());
  729. }
  731. int
  732. commSetNonBlocking(int fd)
  733. {
  734.     int flags;
  735.     int dummy = 0;
  736.     if ((flags = fcntl(fd, F_GETFL, dummy)) < 0) {
  737. debug(50, 0) ("FD %d: fcntl F_GETFL: %sn", fd, xstrerror());
  738. return COMM_ERROR;
  739.     }
  740.     if (fcntl(fd, F_SETFL, flags | SQUID_NONBLOCK) < 0) {
  741. debug(50, 0) ("commSetNonBlocking: FD %d: %sn", fd, xstrerror());
  742. return COMM_ERROR;
  743.     }
  744.     fd_table[fd].flags.nonblocking = 1;
  745.     return 0;
  746. }
  748. void
  749. commSetCloseOnExec(int fd)
  750. {
  751. #ifdef FD_CLOEXEC
  752.     int flags;
  753.     int dummy = 0;
  754.     if ((flags = fcntl(fd, F_GETFL, dummy)) < 0) {
  755. debug(50, 0) ("FD %d: fcntl F_GETFL: %sn", fd, xstrerror());
  756. return;
  757.     }
  758.     if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0)
  759. debug(50, 0) ("FD %d: set close-on-exec failed: %sn", fd, xstrerror());
  760. #endif
  761. }
  763. #ifdef TCP_NODELAY
  764. static void
  765. commSetTcpNoDelay(int fd)
  766. {
  767.     int on = 1;
  768.     if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *) &on, sizeof(on)) < 0)
  769. debug(50, 1) ("commSetTcpNoDelay: FD %d: %sn", fd, xstrerror());
  770. }
  771. #endif
  774. void
  775. comm_init(void)
  776. {
  777.     fd_table = xcalloc(Squid_MaxFD, sizeof(fde));
  778.     /* XXX account fd_table */
  779.     /* Keep a few file descriptors free so that we don't run out of FD's
  780.      * after accepting a client but before it opens a socket or a file.
  781.      * Since Squid_MaxFD can be as high as several thousand, don't waste them */
  782.     RESERVED_FD = XMIN(100, Squid_MaxFD / 4);
  783. }
  785. /* Write to FD. */
  786. static void
  787. commHandleWrite(int fd, void *data)
  788. {
  789.     CommWriteStateData *state = data;
  790.     int len = 0;
  791.     int nleft;
  793.     debug(5, 5) ("commHandleWrite: FD %d: off %d, sz %d.n",
  794. fd, (int) state->offset, state->size);
  796.     nleft = state->size - state->offset;
  797.     len = write(fd, state->buf + state->offset, nleft);
  798.     debug(5, 5) ("commHandleWrite: write() returns %dn", len);
  799.     fd_bytes(fd, len, FD_WRITE);
  800.     Counter.syscalls.sock.writes++;
  802.     if (len == 0) {
  803. /* Note we even call write if nleft == 0 */
  804. /* We're done */
  805. if (nleft != 0)
  806.     debug(5, 1) ("commHandleWrite: FD %d: write failure: connection closed with %d bytes remaining.n", fd, nleft);
  807. CommWriteStateCallbackAndFree(fd, nleft ? COMM_ERROR : COMM_OK);
  808.     } else if (len < 0) {
  809. /* An error */
  810. if (fd_table[fd].flags.socket_eof) {
  811.     debug(50, 2) ("commHandleWrite: FD %d: write failure: %s.n",
  812. fd, xstrerror());
  813.     CommWriteStateCallbackAndFree(fd, COMM_ERROR);
  814. } else if (ignoreErrno(errno)) {
  815.     debug(50, 10) ("commHandleWrite: FD %d: write failure: %s.n",
  816. fd, xstrerror());
  817.     commSetSelect(fd,
  818. COMM_SELECT_WRITE,
  819. commHandleWrite,
  820. state,
  821. 0);
  822. } else {
  823.     debug(50, 2) ("commHandleWrite: FD %d: write failure: %s.n",
  824. fd, xstrerror());
  825.     CommWriteStateCallbackAndFree(fd, COMM_ERROR);
  826. }
  827.     } else {
  828. /* A successful write, continue */
  829. state->offset += len;
  830. if (state->offset < state->size) {
  831.     /* Not done, reinstall the write handler and write some more */
  832.     commSetSelect(fd,
  833. COMM_SELECT_WRITE,
  834. commHandleWrite,
  835. state,
  836. 0);
  837. } else {
  838.     CommWriteStateCallbackAndFree(fd, COMM_OK);
  839. }
  840.     }
  841. }
  845. /* Select for Writing on FD, until SIZE bytes are sent.  Call
  846.  * * HANDLER when complete. */
  847. void
  848. comm_write(int fd, char *buf, int size, CWCB * handler, void *handler_data, FREE * free_func)
  849. {
  850.     CommWriteStateData *state = fd_table[fd].rwstate;
  851.     debug(5, 5) ("comm_write: FD %d: sz %d: hndl %p: data %p.n",
  852. fd, size, handler, handler_data);
  853.     if (NULL != state) {
  854. debug(5, 1) ("comm_write: fd_table[%d].rwstate != NULLn", fd);
  855. safe_free(state);
  856. fd_table[fd].rwstate = NULL;
  857.     }
  858.     assert(state == NULL);
  859.     fd_table[fd].rwstate = state = xcalloc(1, sizeof(CommWriteStateData));
  860.     state->buf = buf;
  861.     state->size = size;
  862.     state->offset = 0;
  863.     state->handler = handler;
  864.     state->handler_data = handler_data;
  865.     state->free_func = free_func;
  866.     cbdataLock(handler_data);
  867. #ifdef OPTIMISTIC_IO
  868.     commHandleWrite(fd, state);
  869. #else
  870.     commSetSelect(fd, COMM_SELECT_WRITE, commHandleWrite, state, 0);
  871. #endif
  872. }
  874. /* a wrapper around comm_write to allow for MemBuf to be comm_written in a snap */
  875. void
  876. comm_write_mbuf(int fd, MemBuf mb, CWCB * handler, void *handler_data)
  877. {
  878.     comm_write(fd, mb.buf, mb.size, handler, handler_data, memBufFreeFunc(&mb));
  879. }
  881. /*
  882.  * hm, this might be too general-purpose for all the places we'd
  883.  * like to use it.
  884.  */
  885. int
  886. ignoreErrno(int ierrno)
  887. {
  888.     switch (ierrno) {
  889.     case EINPROGRESS:
  890.     case EWOULDBLOCK:
  891. #if EAGAIN != EWOULDBLOCK
  892.     case EAGAIN:
  893. #endif
  894.     case EALREADY:
  895.     case EINTR:
  896. #ifdef ERESTART
  897.     case ERESTART:
  898. #endif
  899. return 1;
  900.     default:
  901. return 0;
  902.     }
  903.     /* NOTREACHED */
  904. }
  906. void
  907. commCloseAllSockets(void)
  908. {
  909.     int fd;
  910.     fde *F = NULL;
  911.     PF *callback;
  912.     for (fd = 0; fd <= Biggest_FD; fd++) {
  913. F = &fd_table[fd];
  914. if (!F->flags.open)
  915.     continue;
  916. if (F->type != FD_SOCKET)
  917.     continue;
  918. if (F->flags.ipc) /* don't close inter-process sockets */
  919.     continue;
  920. if (F->timeout_handler) {
  921.     debug(5, 5) ("commCloseAllSockets: FD %d: Calling timeout handlern",
  922. fd);
  923.     callback = F->timeout_handler;
  924.     F->timeout_handler = NULL;
  925.     callback(fd, F->timeout_data);
  926. } else {
  927.     debug(5, 5) ("commCloseAllSockets: FD %d: calling comm_close()n", fd);
  928.     comm_close(fd);
  929. }
  930.     }
  931. }