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

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

代理服务器

开发平台：

Unix_Linux

ssl.c：源码内容
  2. /*
  3.  * $Id: ssl.c,v 1.92 1999/01/29 23:39:23 wessels Exp $
  4.  *
  5.  * DEBUG: section 26    Secure Sockets Layer Proxy
  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. typedef struct {
  39.     char *url;
  40.     char *host; /* either request->host or proxy host */
  41.     u_short port;
  42.     request_t *request;
  43.     struct {
  44. int fd;
  45. int len;
  46. char *buf;
  47.     } client, server;
  48.     size_t *size_ptr; /* pointer to size in an ConnStateData for logging */
  49.     int proxying;
  50. #if DELAY_POOLS
  51.     delay_id delay_id;
  52. #endif
  53. } SslStateData;
  55. static const char *const conn_established = "HTTP/1.0 200 Connection establishedrnrn";
  57. static CNCB sslConnectDone;
  58. static ERCB sslErrorComplete;
  59. static PF sslServerClosed;
  60. static PF sslClientClosed;
  61. static PF sslReadClient;
  62. static PF sslReadServer;
  63. static PF sslTimeout;
  64. static PF sslWriteClient;
  65. static PF sslWriteServer;
  66. static PSC sslPeerSelectComplete;
  67. static void sslStateFree(SslStateData * sslState);
  68. static void sslConnected(int fd, void *);
  69. static void sslProxyConnected(int fd, void *);
  70. static void sslSetSelect(SslStateData * sslState);
  71. #if DELAY_POOLS
  72. static DEFER sslDeferServerRead;
  73. #endif
  75. static void
  76. sslServerClosed(int fd, void *data)
  77. {
  78.     SslStateData *sslState = data;
  79.     debug(26, 3) ("sslServerClosed: FD %dn", fd);
  80.     assert(fd == sslState->server.fd);
  81.     sslState->server.fd = -1;
  82.     if (sslState->client.fd == -1)
  83. sslStateFree(sslState);
  84. }
  86. static void
  87. sslClientClosed(int fd, void *data)
  88. {
  89.     SslStateData *sslState = data;
  90.     debug(26, 3) ("sslClientClosed: FD %dn", fd);
  91.     assert(fd == sslState->client.fd);
  92.     sslState->client.fd = -1;
  93.     if (sslState->server.fd == -1)
  94. sslStateFree(sslState);
  95. }
  97. static void
  98. sslStateFree(SslStateData * sslState)
  99. {
  100.     debug(26, 3) ("sslStateFree: sslState=%pn", sslState);
  101.     assert(sslState != NULL);
  102.     assert(sslState->client.fd == -1);
  103.     assert(sslState->server.fd == -1);
  104.     safe_free(sslState->server.buf);
  105.     safe_free(sslState->client.buf);
  106.     safe_free(sslState->url);
  107.     sslState->host = NULL;
  108.     requestUnlink(sslState->request);
  109.     sslState->request = NULL;
  110.     cbdataFree(sslState);
  111. }
  113. #if DELAY_POOLS
  114. static int
  115. sslDeferServerRead(int fdnotused, void *data)
  116. {
  117.     SslStateData *s = data;
  118.     return delayBytesWanted(s->delay_id, 0, 1) == 0;
  119. }
  120. #endif
  122. static void
  123. sslSetSelect(SslStateData * sslState)
  124. {
  125.     size_t read_sz = SQUID_TCP_SO_RCVBUF;
  126.     assert(sslState->server.fd > -1 || sslState->client.fd > -1);
  127.     if (sslState->client.fd > -1) {
  128. if (sslState->server.len > 0) {
  129.     commSetSelect(sslState->client.fd,
  130. COMM_SELECT_WRITE,
  131. sslWriteClient,
  132. sslState,
  133. 0);
  134. }
  135. if (sslState->client.len < read_sz) {
  136.     commSetSelect(sslState->client.fd,
  137. COMM_SELECT_READ,
  138. sslReadClient,
  139. sslState,
  140. Config.Timeout.read);
  141. }
  142.     } else if (sslState->client.len == 0) {
  143. comm_close(sslState->server.fd);
  144.     }
  145.     if (sslState->server.fd > -1) {
  146. if (sslState->client.len > 0) {
  147.     commSetSelect(sslState->server.fd,
  148. COMM_SELECT_WRITE,
  149. sslWriteServer,
  150. sslState,
  151. 0);
  152. }
  153. #if DELAY_POOLS
  154. /* If this was allowed to return 0, there would be a possibility
  155.  * of the socket becoming "hung" with data accumulating but no
  156.  * write handler (server.len==0) and no read handler (!(0<0)) and
  157.  * no data flowing in the other direction.  Hence the argument of
  158.  * 1 as min.
  159.  */
  160. read_sz = delayBytesWanted(sslState->delay_id, 1, read_sz);
  161. #endif
  162. if (sslState->server.len < read_sz) {
  163.     /* Have room to read more */
  164.     commSetSelect(sslState->server.fd,
  165. COMM_SELECT_READ,
  166. sslReadServer,
  167. sslState,
  168. Config.Timeout.read);
  169. }
  170.     } else if (sslState->client.fd == -1) {
  171. /* client already closed, nothing more to do */
  172.     } else if (sslState->server.len == 0) {
  173. comm_close(sslState->client.fd);
  174.     }
  175. }
  177. /* Read from server side and queue it for writing to the client */
  178. static void
  179. sslReadServer(int fd, void *data)
  180. {
  181.     SslStateData *sslState = data;
  182.     int len;
  183.     size_t read_sz = SQUID_TCP_SO_RCVBUF - sslState->server.len;
  184.     assert(fd == sslState->server.fd);
  185.     debug(26, 3) ("sslReadServer: FD %d, reading %d bytes at offset %dn",
  186. fd, read_sz, sslState->server.len);
  187.     errno = 0;
  188. #if DELAY_POOLS
  189.     read_sz = delayBytesWanted(sslState->delay_id, 1, read_sz);
  190. #endif
  191.     Counter.syscalls.sock.reads++;
  192.     len = read(fd, sslState->server.buf + sslState->server.len, read_sz);
  193.     debug(26, 3) ("sslReadServer: FD %d, read   %d bytesn", fd, len);
  194.     if (len > 0) {
  195. fd_bytes(fd, len, FD_READ);
  196. #if DELAY_POOLS
  197. delayBytesIn(sslState->delay_id, len);
  198. #endif
  199. kb_incr(&Counter.server.all.kbytes_in, len);
  200. kb_incr(&Counter.server.other.kbytes_in, len);
  201. sslState->server.len += len;
  202.     }
  203.     cbdataLock(sslState);
  204.     if (len < 0) {
  205. debug(50, 1) ("sslReadServer: FD %d: read failure: %sn",
  206.     fd, xstrerror());
  207. if (!ignoreErrno(errno))
  208.     comm_close(fd);
  209.     } else if (len == 0) {
  210. comm_close(sslState->server.fd);
  211.     }
  212.     if (cbdataValid(sslState))
  213. sslSetSelect(sslState);
  214.     cbdataUnlock(sslState);
  215. }
  217. /* Read from client side and queue it for writing to the server */
  218. static void
  219. sslReadClient(int fd, void *data)
  220. {
  221.     SslStateData *sslState = data;
  222.     int len;
  223.     assert(fd == sslState->client.fd);
  224.     debug(26, 3) ("sslReadClient: FD %d, reading %d bytes at offset %dn",
  225. fd, SQUID_TCP_SO_RCVBUF - sslState->client.len,
  226. sslState->client.len);
  227.     Counter.syscalls.sock.reads++;
  228.     len = read(fd,
  229. sslState->client.buf + sslState->client.len,
  230. SQUID_TCP_SO_RCVBUF - sslState->client.len);
  231.     debug(26, 3) ("sslReadClient: FD %d, read   %d bytesn", fd, len);
  232.     if (len > 0) {
  233. fd_bytes(fd, len, FD_READ);
  234. kb_incr(&Counter.client_http.kbytes_in, len);
  235. sslState->client.len += len;
  236.     }
  237.     cbdataLock(sslState);
  238.     if (len < 0) {
  239. debug(50, 1) ("sslReadClient: FD %d: read failure: %sn",
  240.     fd, xstrerror());
  241. if (!ignoreErrno(errno))
  242.     comm_close(fd);
  243.     } else if (len == 0) {
  244. comm_close(fd);
  245.     }
  246.     if (cbdataValid(sslState))
  247. sslSetSelect(sslState);
  248.     cbdataUnlock(sslState);
  249. }
  251. /* Writes data from the client buffer to the server side */
  252. static void
  253. sslWriteServer(int fd, void *data)
  254. {
  255.     SslStateData *sslState = data;
  256.     int len;
  257.     assert(fd == sslState->server.fd);
  258.     debug(26, 3) ("sslWriteServer: FD %d, %d bytes to writen",
  259. fd, sslState->client.len);
  260.     Counter.syscalls.sock.writes++;
  261.     len = write(fd,
  262. sslState->client.buf,
  263. sslState->client.len);
  264.     debug(26, 3) ("sslWriteServer: FD %d, %d bytes writtenn", fd, len);
  265.     if (len > 0) {
  266. fd_bytes(fd, len, FD_WRITE);
  267. kb_incr(&Counter.server.all.kbytes_out, len);
  268. kb_incr(&Counter.server.other.kbytes_out, len);
  269. assert(len <= sslState->client.len);
  270. sslState->client.len -= len;
  271. if (sslState->client.len > 0) {
  272.     /* we didn't write the whole thing */
  273.     xmemmove(sslState->client.buf,
  274. sslState->client.buf + len,
  275. sslState->client.len);
  276. }
  277.     }
  278.     cbdataLock(sslState);
  279.     if (len < 0) {
  280. debug(50, 1) ("sslWriteServer: FD %d: write failure: %s.n",
  281.     fd, xstrerror());
  282. if (!ignoreErrno(errno))
  283.     comm_close(fd);
  284.     }
  285.     if (cbdataValid(sslState))
  286. sslSetSelect(sslState);
  287.     cbdataUnlock(sslState);
  288. }
  290. /* Writes data from the server buffer to the client side */
  291. static void
  292. sslWriteClient(int fd, void *data)
  293. {
  294.     SslStateData *sslState = data;
  295.     int len;
  296.     assert(fd == sslState->client.fd);
  297.     debug(26, 3) ("sslWriteClient: FD %d, %d bytes to writen",
  298. fd, sslState->server.len);
  299.     Counter.syscalls.sock.writes++;
  300.     len = write(fd,
  301. sslState->server.buf,
  302. sslState->server.len);
  303.     debug(26, 3) ("sslWriteClient: FD %d, %d bytes writtenn", fd, len);
  304.     if (len > 0) {
  305. fd_bytes(fd, len, FD_WRITE);
  306. kb_incr(&Counter.client_http.kbytes_out, len);
  307. assert(len <= sslState->server.len);
  308. sslState->server.len -= len;
  309. /* increment total object size */
  310. if (sslState->size_ptr)
  311.     *sslState->size_ptr += len;
  312. if (sslState->server.len > 0) {
  313.     /* we didn't write the whole thing */
  314.     xmemmove(sslState->server.buf,
  315. sslState->server.buf + len,
  316. sslState->server.len);
  317. }
  318.     }
  319.     cbdataLock(sslState);
  320.     if (len < 0) {
  321. debug(50, 1) ("sslWriteClient: FD %d: write failure: %s.n",
  322.     fd, xstrerror());
  323. if (!ignoreErrno(errno))
  324.     comm_close(fd);
  325.     }
  326.     if (cbdataValid(sslState))
  327. sslSetSelect(sslState);
  328.     cbdataUnlock(sslState);
  329. }
  331. static void
  332. sslTimeout(int fd, void *data)
  333. {
  334.     SslStateData *sslState = data;
  335.     debug(26, 3) ("sslTimeout: FD %dn", fd);
  336.     if (sslState->client.fd > -1)
  337. comm_close(sslState->client.fd);
  338.     if (sslState->server.fd > -1)
  339. comm_close(sslState->server.fd);
  340. }
  342. static void
  343. sslConnected(int fd, void *data)
  344. {
  345.     SslStateData *sslState = data;
  346.     debug(26, 3) ("sslConnected: FD %d sslState=%pn", fd, sslState);
  347.     xstrncpy(sslState->server.buf, conn_established, SQUID_TCP_SO_RCVBUF);
  348.     sslState->server.len = strlen(conn_established);
  349.     sslSetSelect(sslState);
  350. }
  352. static void
  353. sslErrorComplete(int fdnotused, void *data, size_t sizenotused)
  354. {
  355.     SslStateData *sslState = data;
  356.     assert(sslState != NULL);
  357.     if (sslState->client.fd > -1)
  358. comm_close(sslState->client.fd);
  359.     if (sslState->server.fd > -1)
  360. comm_close(sslState->server.fd);
  361. }
  364. static void
  365. sslConnectDone(int fdnotused, int status, void *data)
  366. {
  367.     SslStateData *sslState = data;
  368.     request_t *request = sslState->request;
  369.     ErrorState *err = NULL;
  370.     if (status == COMM_ERR_DNS) {
  371. debug(26, 4) ("sslConnect: Unknown host: %sn", sslState->host);
  372. err = errorCon(ERR_DNS_FAIL, HTTP_NOT_FOUND);
  373. err->request = requestLink(request);
  374. err->dnsserver_msg = xstrdup(dns_error_message);
  375. err->callback = sslErrorComplete;
  376. err->callback_data = sslState;
  377. errorSend(sslState->client.fd, err);
  378.     } else if (status != COMM_OK) {
  379. err = errorCon(ERR_CONNECT_FAIL, HTTP_SERVICE_UNAVAILABLE);
  380. err->xerrno = errno;
  381. err->host = xstrdup(sslState->host);
  382. err->port = sslState->port;
  383. err->request = requestLink(request);
  384. err->callback = sslErrorComplete;
  385. err->callback_data = sslState;
  386. errorSend(sslState->client.fd, err);
  387.     } else {
  388. if (sslState->proxying)
  389.     sslProxyConnected(sslState->server.fd, sslState);
  390. else
  391.     sslConnected(sslState->server.fd, sslState);
  392. commSetTimeout(sslState->server.fd,
  393.     Config.Timeout.read,
  394.     sslTimeout,
  395.     sslState);
  396. #if DELAY_POOLS
  397. commSetDefer(sslState->server.fd, sslDeferServerRead, sslState);
  398. #endif
  399.     }
  400. }
  402. void
  403. sslStart(int fd, const char *url, request_t * request, size_t * size_ptr)
  404. {
  405.     /* Create state structure. */
  406.     SslStateData *sslState = NULL;
  407.     int sock;
  408.     ErrorState *err = NULL;
  409.     debug(26, 3) ("sslStart: '%s %s'n",
  410. RequestMethodStr[request->method], url);
  411.     Counter.server.all.requests++;
  412.     Counter.server.other.requests++;
  413.     /* Create socket. */
  414.     sock = comm_open(SOCK_STREAM,
  415. 0,
  416. Config.Addrs.tcp_outgoing,
  417. 0,
  418. COMM_NONBLOCKING,
  419. url);
  420.     if (sock == COMM_ERROR) {
  421. debug(26, 4) ("sslStart: Failed because we're out of sockets.n");
  422. err = errorCon(ERR_SOCKET_FAILURE, HTTP_INTERNAL_SERVER_ERROR);
  423. err->xerrno = errno;
  424. err->request = requestLink(request);
  425. errorSend(fd, err);
  426. return;
  427.     }
  428.     sslState = xcalloc(1, sizeof(SslStateData));
  429.     cbdataAdd(sslState, cbdataXfree, 0);
  430. #if DELAY_POOLS
  431.     sslState->delay_id = delayClient(request);
  432. #endif
  433.     sslState->url = xstrdup(url);
  434.     sslState->request = requestLink(request);
  435.     sslState->size_ptr = size_ptr;
  436.     sslState->client.fd = fd;
  437.     sslState->server.fd = sock;
  438.     sslState->server.buf = xmalloc(SQUID_TCP_SO_RCVBUF);
  439.     sslState->client.buf = xmalloc(SQUID_TCP_SO_RCVBUF);
  440.     comm_add_close_handler(sslState->server.fd,
  441. sslServerClosed,
  442. sslState);
  443.     comm_add_close_handler(sslState->client.fd,
  444. sslClientClosed,
  445. sslState);
  446.     commSetTimeout(sslState->client.fd,
  447. Config.Timeout.lifetime,
  448. sslTimeout,
  449. sslState);
  450.     commSetTimeout(sslState->server.fd,
  451. Config.Timeout.connect,
  452. sslTimeout,
  453. sslState);
  454.     peerSelect(request,
  455. NULL,
  456. sslPeerSelectComplete,
  457. sslState);
  458.     /*
  459.      * Disable the client read handler until peer selection is complete
  460.      * Take control away from client_side.c.
  461.      */
  462.     commSetSelect(sslState->client.fd, COMM_SELECT_READ, NULL, NULL, 0);
  463. }
  465. static void
  466. sslProxyConnected(int fd, void *data)
  467. {
  468.     SslStateData *sslState = data;
  469.     MemBuf mb;
  470.     HttpHeader hdr_out;
  471.     Packer p;
  472.     http_state_flags flags;
  473.     debug(26, 3) ("sslProxyConnected: FD %d sslState=%pn", fd, sslState);
  474.     memset(&flags, '', sizeof(flags));
  475.     memBufDefInit(&mb);
  476.     memBufPrintf(&mb, "CONNECT %s HTTP/1.0rn", sslState->url);
  477.     httpBuildRequestHeader(sslState->request,
  478. sslState->request,
  479. NULL, /* StoreEntry */
  480. &hdr_out,
  481. sslState->client.fd,
  482. flags); /* flags */
  483.     packerToMemInit(&p, &mb);
  484.     httpHeaderPackInto(&hdr_out, &p);
  485.     httpHeaderClean(&hdr_out);
  486.     packerClean(&p);
  487.     memBufAppend(&mb, "rn", 2);
  488.     xstrncpy(sslState->client.buf, mb.buf, SQUID_TCP_SO_RCVBUF);
  489.     debug(26, 3) ("sslProxyConnected: Sending {%s}n", sslState->client.buf);
  490.     sslState->client.len = mb.size;
  491.     memBufClean(&mb);
  492.     commSetTimeout(sslState->server.fd,
  493. Config.Timeout.read,
  494. sslTimeout,
  495. sslState);
  496.     sslSetSelect(sslState);
  497. }
  499. static void
  500. sslPeerSelectComplete(FwdServer * fs, void *data)
  501. {
  502.     SslStateData *sslState = data;
  503.     request_t *request = sslState->request;
  504.     peer *g = NULL;
  506.     if (fs == NULL) {
  507. ErrorState *err;
  508. err = errorCon(ERR_CANNOT_FORWARD, HTTP_SERVICE_UNAVAILABLE);
  509. err->request = requestLink(sslState->request);
  510. err->callback = sslErrorComplete;
  511. err->callback_data = sslState;
  512. errorSend(sslState->client.fd, err);
  513. return;
  514.     }
  515.     sslState->proxying = fs->peer ? 1 : 0;
  516.     sslState->host = fs->peer ? fs->peer->host : request->host;
  517.     if (fs->peer == NULL) {
  518. sslState->port = request->port;
  519.     } else if (fs->peer->http_port != 0) {
  520. sslState->port = fs->peer->http_port;
  521.     } else if ((g = peerFindByName(fs->peer->host))) {
  522. sslState->port = g->http_port;
  523.     } else {
  524. sslState->port = CACHE_HTTP_PORT;
  525.     }
  526. #if DELAY_POOLS
  527.     /* no point using the delayIsNoDelay stuff since ssl is nice and simple */
  528.     if (g && g->options.no_delay)
  529. sslState->delay_id = 0;
  530. #endif
  531.     commConnectStart(sslState->server.fd,
  532. sslState->host,
  533. sslState->port,
  534. sslConnectDone,
  535. sslState);
  536. }