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

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

代理服务器

开发平台：

Unix_Linux

pconn-banger.c：源码内容
  2. #include "config.h"
  4. /*
  5.  * On some systems, FD_SETSIZE is set to something lower than the
  6.  * actual number of files which can be opened.  IRIX is one case,
  7.  * NetBSD is another.  So here we increase FD_SETSIZE to our
  8.  * configure-discovered maximum *before* any system includes.
  9.  */
  10. #define CHANGE_FD_SETSIZE 1
  12. /* Cannot increase FD_SETSIZE on Linux */
  13. #if defined(_SQUID_LINUX_)
  14. #undef CHANGE_FD_SETSIZE
  15. #define CHANGE_FD_SETSIZE 0
  16. #endif
  18. /* Cannot increase FD_SETSIZE on FreeBSD before 2.2.0, causes select(2)
  19.  * to return EINVAL. */
  20. /* Marian Durkovic <marian@svf.stuba.sk> */
  21. /* Peter Wemm <peter@spinner.DIALix.COM> */
  22. #if defined(_SQUID_FREEBSD_)
  23. #include <osreldate.h>
  24. #if __FreeBSD_version < 220000
  25. #undef CHANGE_FD_SETSIZE
  26. #define CHANGE_FD_SETSIZE 0
  27. #endif
  28. #endif
  30. /* Increase FD_SETSIZE if SQUID_MAXFD is bigger */
  31. #if CHANGE_FD_SETSIZE && SQUID_MAXFD > DEFAULT_FD_SETSIZE
  32. #define FD_SETSIZE SQUID_MAXFD
  33. #endif
  35. #if HAVE_UNISTD_H
  36. #include <unistd.h>
  37. #endif
  38. #if HAVE_STDLIB_H
  39. #include <stdlib.h>
  40. #endif
  41. #if HAVE_STDIO_H
  42. #include <stdio.h>
  43. #endif
  44. #if HAVE_FCNTL_H
  45. #include <fcntl.h>
  46. #endif
  47. #ifdef HAVE_STRING_H
  48. #include <string.h>
  49. #endif
  50. #ifdef HAVE_STRINGS_H
  51. #include <strings.h>
  52. #endif
  53. #ifdef HAVE_BSTRING_H
  54. #include <bstring.h>
  55. #endif
  56. #if HAVE_SYS_TYPES_H
  57. #include <sys/types.h>
  58. #endif
  59. #if HAVE_SYS_SELECT_H
  60. #include <sys/select.h>
  61. #endif
  62. #if HAVE_SIGNAL_H
  63. #include <signal.h>
  64. #endif
  65. #if HAVE_TIME_H
  66. #include <time.h>
  67. #endif
  68. #if HAVE_SYS_TIME_H
  69. #include <sys/time.h>
  70. #endif
  71. #if HAVE_SYS_SOCKET_H
  72. #include <sys/socket.h>
  73. #endif
  74. #if HAVE_NETINET_IN_H
  75. #include <netinet/in.h>
  76. #endif
  77. #if HAVE_ARPA_INET_H
  78. #include <arpa/inet.h>
  79. #endif
  80. #if HAVE_ERRNO_H
  81. #include <errno.h>
  82. #endif
  83. #if HAVE_CTYPE_H
  84. #include <ctype.h>
  85. #endif
  86. #if HAVE_ASSERT_H
  87. #include <assert.h>
  88. #endif
  89. #if HAVE_SYS_STAT_H
  90. #include <sys/stat.h>
  91. #endif
  93. #define PROXY_PORT 3128
  94. #define PROXY_ADDR "127.0.0.1"
  95. #define MAX_FDS 1024
  96. #define READ_BUF_SZ 4096
  97. #define min(x,y) ((x)<(y)? (x) : (y))
  99. static int proxy_port = PROXY_PORT;
  100. static char *proxy_addr = PROXY_ADDR;
  101. static char *progname;
  102. static int noutstanding = 0;
  103. static int done_reading_urls = 0;
  104. static int opt_ims = 0;
  105. static int opt_checksum = 0;
  106. static int opt_reopen = 1;
  107. static int max_outstanding = 10;
  108. static time_t lifetime = 60;
  109. static const char *const crlf = "rn";
  110. static int trace_fd = -1;
  111. static int total_bytes_read = 0;
  113. #define REPLY_HDR_SZ 8192
  115. struct _r {
  116.     char url[1024];
  117.     int content_length;
  118.     int hdr_length;
  119.     int hdr_offset;
  120.     int bytes_read;
  121.     char reply_hdrs[REPLY_HDR_SZ];
  122.     struct _r *next;
  123.     long sum;
  124.     long validsize;
  125.     long validsum;
  126. };
  128. static struct _r *Requests;
  130. char *
  131. mkrfc850(t)
  132.      time_t *t;
  133. {
  134.     static char buf[128];
  135.     struct tm *gmt = gmtime(t);
  136.     buf[0] = '';
  137.     (void) strftime(buf, 127, "%A, %d-%b-%y %H:%M:%S GMT", gmt);
  138.     return buf;
  139. }
  142. char *
  143. mime_headers_end(const char *mime)
  144. {
  145.     const char *p1, *p2;
  146.     const char *end = NULL;
  148.     p1 = strstr(mime, "nrn");
  149.     p2 = strstr(mime, "nn");
  151.     if (p1 && p2)
  152. end = p1 < p2 ? p1 : p2;
  153.     else
  154. end = p1 ? p1 : p2;
  155.     if (end)
  156. end += (end == p1 ? 3 : 2);
  158.     return (char *) end;
  159. }
  161. void
  162. sig_intr(int sig)
  163. {
  164.     fprintf(stderr, "rWaiting for open connections to finish...n");
  165.     signal(sig, SIG_DFL);
  166.     done_reading_urls = 1;
  167. }
  169. int
  171. open_http_socket(void)
  172. {
  173.     int s;
  174.     struct sockaddr_in S;
  175.     if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
  176. perror("socket");
  177. return -1;
  178.     }
  179.     memset(&S, '', sizeof(struct sockaddr_in));
  180.     S.sin_family = AF_INET;
  181.     S.sin_port = htons(proxy_port);
  182.     S.sin_addr.s_addr = inet_addr(proxy_addr);
  183.     if (connect(s, (struct sockaddr *) &S, sizeof(S)) < 0) {
  184. close(s);
  185. perror("connect");
  186. return -1;
  187.     }
  188.     return s;
  189. }
  191. int
  192. send_request(int fd, const char *data)
  193. {
  194.     char msg[4096],buf[4096];
  195.     int len;
  196.     time_t w;
  197.     struct _r *r;
  198.     struct _r **R;
  199.     char *method, *url, *file, *size, *checksum;
  200.     char *tmp = strdup(data);
  201.     struct stat st;
  202.     int file_fd = -1;
  203.     method=strtok(tmp, " ");
  204.     url=strtok(NULL, " ");
  205.     file=strtok(NULL, " ");
  206.     size=strtok(NULL, " ");
  207.     checksum=strtok(NULL, " ");
  208.     if (!url) {
  209.       url=method;
  210.       method="GET";
  211.     }
  212.     if (file && strcmp(file,"-")==0)
  213. file=NULL;
  214.     if (size && strcmp(size,"-")==0)
  215. size=NULL;
  216.     if (checksum && strcmp(checksum,"-")==0)
  217. checksum=NULL;
  218.     msg[0] = '';
  219.     sprintf(buf, "%s %s HTTP/1.0rn", method, url);
  220.     strcat(msg,buf);
  221.     strcat(msg, "Accept: */*rn");
  222.     strcat(msg, "Proxy-Connection: Keep-Alivern");
  223.     if (opt_ims && (lrand48() & 0x03) == 0) {
  224. w = time(NULL) - (lrand48() & 0x3FFFF);
  225. sprintf(buf, "If-Modified-Since: %srn", mkrfc850(&w));
  226. strcat(msg, buf);
  227.     }
  228.     if (file) {
  229. if ( (file_fd = open(file,O_RDONLY)) < 0) {
  230.     perror("open");
  231.     return -1;
  232. }
  233. if ( fstat(file_fd, &st) ) {
  234.     perror("fstat");
  235.     close(file_fd);
  236.     return -1;
  237. }
  238. sprintf(buf, "Content-length: %drn", st.st_size);
  239. strcat(msg, buf);
  240.     }
  241.     strcat(msg, "rn");
  242.     len = strlen(msg);
  243.     if (write(fd, msg, len) < 0) {
  244. close(fd);
  245. perror("request write");
  246. close(file_fd);
  247. return -1;
  248.     }
  249.     if (file) {
  250. while((len=read(file_fd, buf, sizeof buf)) > 0) {
  251.     if (write(fd, buf, len) < 0) {
  252. close(fd);
  253. perror("body write");
  254. close(file_fd);
  255. return -1;
  256.     }
  257. }
  258. if (len < 0) {
  259.     perror("file read");
  260.     close(file_fd);
  261.     return -1;
  262. }
  263. close(file_fd);
  264.     }
  265.     r = calloc(1, sizeof(struct _r));
  266.     strcpy(r->url, url);
  267.     if (size)
  268. r->validsize = atoi(size);
  269.     else
  270. r->validsize = -1;
  271.     if (checksum)
  272. r->validsum = atoi(checksum);
  273.     for (R = &Requests; *R; R = &(*R)->next);
  274.     *R = r;
  275. /*    fprintf(stderr, "REQUESTED %sn", url); */
  276.     noutstanding++;
  277.     return 0;
  278. }
  280. static int
  281. get_header_int_value(const char *hdr, const char *buf, const char *end)
  282. {
  283.     const char *t;
  284.     for (t = buf; t < end; t += strcspn(t, crlf), t += strspn(t, crlf)) {
  285. if (strncasecmp(t, hdr, strlen(hdr)) == 0) {
  286.     t += strlen(hdr);
  287.     while (isspace(*t))
  288. t++;
  289.     return atoi(t);
  290. }
  291.     }
  292.     return -1;
  293. }
  295. static const char *
  296. get_header_string_value(const char *hdr, const char *buf, const char *end)
  297. {
  298.     const char *t;
  299.     static char result[8192];
  300.     for (t = buf; t < end; t += strcspn(t, crlf), t += strspn(t, crlf)) {
  301. if (strncasecmp(t, hdr, strlen(hdr)) == 0) {
  302.     t += strlen(hdr);
  303.     while (isspace(*t))
  304. t++;
  305.     strcpy(result,"");
  306.     strncat(result,t,strcspn(t, crlf));
  307.     return result;
  308. }
  309.     }
  310.     return NULL;
  311. }
  313. void
  314. request_done(struct _r *r)
  315. {
  316. #if 0
  317.     fprintf(stderr, "DONE: %s, (%d+%d)n",
  318.     r->url,
  319.     r->hdr_length,
  320.     r->content_length);
  321. #endif
  322.     if (r->content_length != r->bytes_read)
  323. fprintf(stderr, "ERROR! Short reply, expected %d bytes got %dn",
  324.     r->content_length, r->bytes_read);
  325.     else if (r->validsize >= 0) {
  326. if (r->validsize != r->bytes_read)
  327.     fprintf(stderr, "WARNING: %s Object size mismatch, expected %d got %dn",
  328.     r->url, r->validsize, r->bytes_read);
  329. else if (opt_checksum && r->sum != r->validsum)
  330.     fprintf(stderr, "WARNING: %s Checksum error. Expected %d got %dn",
  331.     r->url, r->validsum, r->sum);
  332.     }
  333. }
  334. int
  335. handle_read(char *inbuf, int len)
  336. {
  337.     struct _r *r = Requests;
  338.     const char *end;
  339.     const char *url;
  340.     static char buf[READ_BUF_SZ];
  341.     int hlen,blen;
  342.     if (len < 0 ) {
  343. perror("read");
  344. Requests = r->next;
  345. request_done(r);
  346. free(r);
  347. noutstanding--;
  348. if (trace_fd >= 0)
  349.     write(trace_fd,"n[CLOSED]n",10);
  350. return -1;
  351.     }
  352.     total_bytes_read += len;
  353.     xmemcpy(buf,inbuf,len);
  354.     if (len == 0) {
  355. fprintf(stderr, "WARNING: %s, server closed socket after %d+%d bytesn", r->url, r->hdr_offset, r->bytes_read);
  356. /* XXX, If no data was received and it isn't the first request on this
  357.  * connection then the request should be restarted rather than aborted
  358.  * but this is a simple test program an not a full blown HTTP client.
  359.  */
  360. request_done(r);
  361. Requests = r->next;
  362. free(r);
  363. noutstanding--;
  364. return -1;
  365.     }
  366.     if (trace_fd > 0)
  367. write(trace_fd, buf, len);
  368.     while (len > 0) {
  369. /* Build headers */
  370. if (r->hdr_length == 0) {
  371.     hlen = min(len, REPLY_HDR_SZ - r->hdr_offset - 1);
  372.     xmemcpy(r->reply_hdrs + r->hdr_offset, buf, hlen);
  373.     r->hdr_offset += hlen;
  374.     r->reply_hdrs[r->hdr_offset] = '';
  375.     len -= hlen;
  376.     /* Save any remaining read data */
  377.     xmemmove(buf, buf + hlen, len);
  378. }
  379. /* Process headers */
  380. if (r->hdr_length == 0 && (end = mime_headers_end(r->reply_hdrs)) != NULL) {
  381. #if 0
  382.     fprintf(stderr, "FOUND EOH FOR %sn", r->url); */
  383. #endif
  384.     r->hdr_length = end - r->reply_hdrs;
  385. #if 0
  386.       fprintf(stderr, "HDR_LENGTH = %dn", r->hdr_length);
  387. #endif
  388.     /* "unread" any body contents received */
  389.     blen = r->hdr_offset - r->hdr_length;
  390.     assert(blen >= 0);
  391.     if (blen > 0) {
  392. xmemmove(buf + blen, buf, len);
  393. xmemcpy(buf, r->reply_hdrs + r->hdr_length, blen);
  394. len += blen;
  395.     }
  396.     r->reply_hdrs[r->hdr_length]=''; /* Null terminate headers */
  397.     /* Parse headers */
  398.     r->content_length = get_header_int_value("content-length:", r->reply_hdrs, end);
  399. /*     fprintf(stderr, "CONTENT_LENGTH = %dn", r->content_length); */
  400.     url = get_header_string_value("X-Request-URI:", r->reply_hdrs, end);
  401.     if (url != NULL && strcmp(r->url, url) != 0)
  402. fprintf(stderr, "WARNING: %s got reply %sn", r->url, url);
  403. #if XREQUESTURI || 0
  404.     fprintf(stderr, "LOCATION = %sn", get_header_string_value("X-Request-URI:", r->reply_hdrs, end));  
  405. #endif
  406. }
  407. if ( !(len==0 || r->hdr_length > 0) ) {
  408.     fprintf(stderr, "ERROR!!!n");
  409.     assert((len==0 || r->hdr_length > 0));
  410. }
  411. /* Process body */
  412. if (r->hdr_length != 0) {
  413.     int i;
  414.     int bytes_left, bytes_used;
  415.     if (r->content_length >= 0) {
  416. bytes_left = r->content_length - r->bytes_read;
  417. assert(bytes_left >= 0);
  418.      bytes_used = len < bytes_left ? len : bytes_left;
  419.     } else {
  420. bytes_left = len + 1; /* Unknown end... */
  421. bytes_used = len;
  422.     }
  423.     if (opt_checksum) {
  424. for(i=0; i<bytes_used; i++)
  425.     r->sum += (int)buf[i] & 0xFF;
  426.     }
  427.     r->bytes_read += bytes_used;
  428.     len -= bytes_used;
  429.     if (bytes_left == bytes_used) {
  430. request_done(r);
  431. Requests = r->next;
  432. free(r);
  433. noutstanding--;
  434. r = Requests;
  435.     } else if (r->content_length > -1) {
  436. assert(r->bytes_read < r->content_length);
  437.     }
  438.     xmemmove(buf, buf + bytes_used, len);
  439. }
  440.     }
  441.     return 0;
  442. }
  444. int
  445. read_reply(int fd)
  446. {
  447.     static char buf[READ_BUF_SZ];
  448.     int len;
  449.     int x;
  450.     len = read(fd, buf, READ_BUF_SZ);
  451.     x = handle_read(buf, len);
  452.     if (x < 0) {
  453. perror("read reply");
  454. close(fd);
  455.     }
  456.     return x;
  457. }
  459. void
  460. main_loop(void)
  461. {
  462.     static int pconn_fd = -1;
  463.     static char buf[8192];
  464.     struct timeval to;
  465.     struct timeval now,last,start;
  466.     fd_set R;
  467.     struct _r *r;
  468.     struct _r *nextr;
  469.     int x;
  470.     int timeouts;
  471.     int nrequests = 0, rrequests = 0, reqpersec = 0;
  473.     gettimeofday(&start, NULL);
  474.     last = start;
  476.     pconn_fd = open_http_socket();
  477.     if (pconn_fd < 0) {
  478. perror("socket");
  479. exit(1);
  480.     }
  481.     while (!done_reading_urls || noutstanding) {
  482. if (!opt_reopen && pconn_fd < 0) {
  483.     fprintf(stderr,"TERMINATED: Connection closedn");
  484.     break;
  485. }
  486. if (pconn_fd<0) {
  487.     pconn_fd = open_http_socket();
  488.     if (pconn_fd < 0) {
  489. perror("socket");
  490. exit(1);
  491.     }
  492.     nextr = Requests;
  493.     Requests = NULL;
  494.     noutstanding=0;
  495.     while ((r = nextr) != NULL) {
  496. nextr = r->next;
  497. if (send_request(pconn_fd, r->url) != 0) {
  498.     close(pconn_fd);
  499.     pconn_fd=-1;
  500.     nextr = r;
  501.     for (r = Requests; r!=NULL && r->next; r=r->next);
  502.     if (r != NULL)
  503. r->next = nextr;
  504.     else
  505. Requests = nextr;
  506.     break;
  507. }
  508. free(r);
  509.     }
  510.     timeouts = 0;
  511.     if (pconn_fd <0)
  512. continue;
  513. }
  514. if (timeouts == 200) {
  515.     close(pconn_fd);
  516.     pconn_fd = -1;
  517.     r = Requests;
  518.     Requests = Requests->next;
  519.     fprintf(stderr, "ABORT %sn", Requests->url);
  520.     free(r);
  521.     noutstanding--;
  522. }
  523. if (pconn_fd>=0 && noutstanding < max_outstanding && !done_reading_urls) {
  524.     char *t;
  525.     if (fgets(buf, 8191, stdin) == NULL) {
  526. fprintf(stderr, "Done Reading URLSn");
  527. done_reading_urls = 1;
  528. continue;
  529.     }
  530.     rrequests++;
  531.     if ((t = strchr(buf, 'n')))
  532. *t = '';
  533.     if (send_request(pconn_fd, buf) != 0) {
  534. close(pconn_fd);
  535. pconn_fd=-1;
  536. continue;
  537.     }
  538.     nrequests++;
  539.     reqpersec++;
  540.     timeouts = 0;
  541. }
  542. FD_ZERO(&R);
  543. to.tv_sec = 1;
  544. to.tv_usec = 0;
  545. FD_SET(pconn_fd, &R);
  546. x = select(pconn_fd + 1, &R, NULL, NULL, &to);
  547. if (x < 0) {
  548.     if (errno != EINTR)
  549. perror("select");
  550.     continue;
  551. } else if (x == 0) {
  552.     assert(Requests != NULL);
  553.     fprintf(stderr, "TIMEOUT %s; %d, %dn", Requests->url,
  554. ++timeouts, noutstanding);
  555.     continue;
  556. }
  557. if (FD_ISSET(pconn_fd, &R)) {
  558.     timeouts = 0;
  559.     if (read_reply(pconn_fd) != 0)
  560. pconn_fd = -1;
  561. }
  562. gettimeofday(&now, NULL);
  563.         if (now.tv_sec > last.tv_sec) {
  564.     int dt;
  565.     int nreq;
  566.     last = now;
  567.     dt = (int) (now.tv_sec - start.tv_sec);
  568.     nreq=0;
  569.     for (r=Requests; r ; r=r->next) nreq++;
  570.     printf("T+ %6d: %9d req (%+4d), %4d pend, %3d/sec avg, %dmb, %dkb/sec avgn",
  571.     dt,
  572.     nrequests,
  573.     reqpersec,
  574.     nreq,
  575.     (int) (nrequests / dt),
  576.     (int)total_bytes_read / 1024 / 1024,
  577.     (int)total_bytes_read / 1024 / dt);
  578.     reqpersec = 0;
  579. }
  580.     }
  581. }
  583. void
  584. usage(void)
  585. {
  586.     fprintf(stderr, "usage: %s: -p port -h host -n max -t tracefile -i -c -l lifetimen", progname);
  587. }
  589. int
  590. main(argc, argv)
  591.      int argc;
  592.      char *argv[];
  593. {
  594.     int c;
  595.     setbuf(stdout, NULL);
  596.     setbuf(stderr, NULL);
  597.     progname = strdup(argv[0]);
  598.     while ((c = getopt(argc, argv, "p:h:n:t:icl:r")) != -1) {
  599. switch (c) {
  600. case 'p':
  601.     proxy_port = atoi(optarg);
  602.     break;
  603. case 'h':
  604.     proxy_addr = strdup(optarg);
  605.     break;
  606. case 'n':
  607.     max_outstanding = atoi(optarg);
  608.     break;
  609. case 'i':
  610.     opt_ims = 1;
  611.     break;
  612. case 'c':
  613.     opt_checksum = 1;
  614.     break;
  615. case 'l':
  616.     lifetime = (time_t) atoi(optarg);
  617.     break;
  618. case 't':
  619.     trace_fd = open(optarg,O_WRONLY|O_CREAT|O_TRUNC,0666);
  620.     break;
  621. case 'r':
  622.     opt_reopen = !opt_reopen;
  623.     break;
  624. default:
  625.     usage();
  626.     return 1;
  627. }
  628.     }
  629.     signal(SIGINT, sig_intr);
  630.     signal(SIGPIPE, SIG_IGN);
  631.     main_loop();
  632.     return 0;
  633. }