这是本书的最后一个lab了，但总体上没有前面的malloclab和shelllab难，好好看书，多多参考tinyweb的代码，还是比较容易写出来的。

代码

  1. #include <stdio.h>
  2. #include "csapp.h"
  4. /* Recommended max cache and object sizes */
  5. #define MAX_CACHE_SIZE 1049000
  6. #define MAX_OBJECT_SIZE 102400
  7. #define MMAXLINE 2048
  8. #define MAXHEADER 4096
  9. #define MAXCACHEBLOCK 50
  11. struct cache_block
  12. {
  13.     char header[MAXHEADER];
  14.     char path[MMAXLINE];
  15.     char *body;
  16.     int body_size;
  17.     char visit;
  18. };
  20. struct _cache
  21. {
  22.     struct cache_block *block_slot[MAXCACHEBLOCK];
  23.     int clock_p;
  24.     int used_size;
  25.     int used_block;
  26. } cache;
  28. int read_cnt;
  29. sem_t mutex, write_lock;
  31. /* You won't lose style points for including this long line in your code */
  32. static const char *user_agent_hdr = "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.3) Gecko/20120305 Firefox/10.0.3";
  34. void doit(int connfd);
  35. void request_back_server(rio_t *rio_buf, char *host, char *port, char *path, char *real_path);
  36. void http_error(int fd, char *errnum, char *msg);
  37. int parse_request(char *request, char *host, char *port, char *path);
  38. void deal_request_header(char *header_line, int back_server_fd);
  39. void get_back_response_and_send_to_client(int fd_conn_back_server, int client_fd, char *path);
  40. void html_error(int fd, char *msg);
  41. void *thread(void *vargp);
  42. void init_cache();
  43. int read_cache(char *header, char *body, char *real_path);
  44. int write_cache(char *header, char *body, int body_size, char *real_path);
  45. int next_slot(int need_size);
  46. void evict();
  48. int main(int argc, char **argv)
  49. {
  50.     //printf("%s
  51. ", user_agent_hdr);
  52.     int listenfd, connfd;
  53.     pthread_t tid;
  54.     int *vargs = NULL;
  55.     socklen_t clientlen;
  56.     struct sockaddr_storage clientaddr;
  57.     /* Check command line args */
  58.     if (argc != 2)
  59.     {
  60.         fprintf(stderr, "usage: %s <port>
  61. ", argv[0]);
  62.         exit(1);
  63.     }
  65.     init_cache();
  66.     listenfd = Open_listenfd(argv[1]);
  67.     while (1)
  68.     {
  69.         clientlen = sizeof(clientaddr);
  70.         connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
  71.         //doit(connfd);
  73.         if ((vargs = (int *)malloc(sizeof(int))) == NULL)
  74.         {
  75.             http_error(connfd, "500", "not enough memory!");
  76.             Close(connfd);
  77.         }
  78.         else
  79.         {
  80.             *vargs = connfd;
  81.             pthread_create(&tid, NULL, thread, (void *)vargs);
  82.         }
  83.     }
  84. }
  86. void *thread(void *vargp)
  87. {
  88.     int connfd = *((int *)vargp);
  89.     pthread_detach(pthread_self());
  90.     free(vargp);
  91.     doit(connfd);
  92.     Close(connfd);
  93.     return NULL;
  94. }
  96. void doit(int connfd)
  97. {
  98.     rio_t Riobuf;
  99.     char req_buf[MMAXLINE], host[MMAXLINE], port[MMAXLINE], path[MMAXLINE], real_path[MAXLINE];
  100.     char *header, *body;
  101.     int body_size;
  102.     rio_readinitb(&Riobuf, connfd);
  103.     if (!rio_readlineb(&Riobuf, req_buf, MMAXLINE))
  104.         return;
  106.     if (parse_request(req_buf, host, port, path) < 0)
  107.         http_error(connfd, "403", "Unknown request");
  108.     else
  109.     {
  110.         sprintf(real_path, "%s:%s%s", host, port, path);
  111.         header = (char *)malloc(MAXHEADER);
  112.         body = (char *)malloc(MAX_OBJECT_SIZE);
  113.         if (header != NULL && body != NULL)
  114.         {
  115.             if ((body_size = read_cache(header, body, real_path)) >= 0)
  116.             {
  117.                 Rio_writen(connfd, header, strlen(header));
  118.                 Rio_writen(connfd, "
  119. ", strlen("
  120. "));
  121.                 Rio_writen(connfd, body, body_size);
  122.                 free(header);
  123.                 free(body);
  124.                 return;
  125.             }
  126.         }
  127.         free(header);
  128.         free(body);
  129.         request_back_server(&Riobuf, host, port, path, real_path);
  130.     }
  131. }
  133. /*根据第一行的请求解析出host，port与请求path，正确返回0，出错返回-1*/
  134. int parse_request(char *request, char *host, char *port, char *path)
  135. {
  136.     char method[MMAXLINE], path_buf[MMAXLINE], version[MMAXLINE], host_buf[MMAXLINE], port_buf[MMAXLINE];
  137.     char *i, *host_buf_p, *port_buf_p;
  138.     int have_port = 1;
  139.     memset(path_buf, 0, MMAXLINE);
  140.     sscanf(request, "%s %s %s", method, path_buf, version);
  141.     if (strcmp(method, "GET"))
  142.         return -1;
  143.     i = path_buf;
  144.     host_buf_p = host_buf;
  145.     port_buf_p = port_buf;
  146.     while (*i != '/' && *i != '')
  147.         i++;
  148.     if (*i != '')
  149.         i++;
  150.     if (*i != '')
  151.         i++;
  152.     while (*i != ':' && *i != '')
  153.     {
  154.         if (*i == '/')
  155.         {
  156.             have_port = 0;
  157.             break;
  158.         }
  159.         *host_buf_p++ = *i++;
  160.     }
  161.     *host_buf_p = '';
  162.     if (!have_port)
  163.     {
  164.         sprintf(port_buf_p, "80");
  165.     }
  166.     else
  167.     {
  168.         i++;
  169.         while (*i != '/' && *i != '')
  170.         {
  171.             *port_buf_p++ = *i++;
  172.         }
  173.         *port_buf_p = '';
  174.     }
  176.     if (*i == '')
  177.         return -1;
  179.     sprintf(host, "%s", host_buf);
  180.     sprintf(port, "%s", port_buf);
  181.     sprintf(path, "%s", i);
  182.     //sprintf(request, "%s %s %s
  183. ", method, i, "HTTP/1.0");
  184.     return 0;
  185. }
  187. /*解析剩下的头部，构造并发送向后台服务器的请求,最后接受请求并返回给客户端*/
  188. void request_back_server(rio_t *rio_buf, char *host, char *port, char *path, char *real_path)
  189. {
  190.     int fd_conn_back_server, fd_conn_client;
  191.     char buf[MMAXLINE];
  193.     fd_conn_client = rio_buf->rio_fd;
  194.     fd_conn_back_server = Open_clientfd(host, port);
  196.     sprintf(buf, "GET %s HTTP/1.0
  197. ", path);
  198.     Rio_writen(fd_conn_back_server, buf, strlen(buf));
  199.     sprintf(buf, "Host: %s:%s
  200. ", host, port);
  201.     Rio_writen(fd_conn_back_server, buf, strlen(buf));
  202.     sprintf(buf, "User-Agent: %s
  203. ", user_agent_hdr);
  204.     Rio_writen(fd_conn_back_server, buf, strlen(buf));
  205.     sprintf(buf, "Connection: close
  206. ");
  207.     Rio_writen(fd_conn_back_server, buf, strlen(buf));
  208.     sprintf(buf, "Proxy-Connection: close
  209. ");
  210.     Rio_writen(fd_conn_back_server, buf, strlen(buf));
  212.     while (1)
  213.     {
  214.         Rio_readlineb(rio_buf, buf, MMAXLINE);
  215.         if (!strcmp(buf, "
  216. "))
  217.         {
  218.             Rio_writen(fd_conn_back_server, buf, strlen(buf));
  219.             break;
  220.         }
  221.         deal_request_header(buf, fd_conn_back_server);
  222.     }
  224.     get_back_response_and_send_to_client(fd_conn_back_server, fd_conn_client, real_path);
  225.     //Close(connfd);
  226.     return;
  227. }
  229. /*处理请求头,忽略给定的头（需要修改的头）,并把其余头发送给后台服务器*/
  230. void deal_request_header(char *header_line, int back_server_fd)
  231. {
  232.     char key[MMAXLINE], value[MMAXLINE];
  233.     sscanf(header_line, "%s %s", key, value);
  234.     if (!strcmp(key, "Host:"))
  235.         return;
  236.     else if (!strcmp(key, "User-Agent:"))
  237.     {
  238.         return;
  239.     }
  240.     else if (!strcmp(key, "Connection:"))
  241.     {
  242.         return;
  243.     }
  244.     else if (!strcmp(key, "Proxy-Connection:"))
  245.     {
  246.         return;
  247.     }
  248.     else
  249.     {
  250.         Rio_writen(back_server_fd, header_line, strlen(header_line));
  251.         return;
  252.     }
  253. }
  255. /*读后台的返回，并且写给客户端*/
  256. void get_back_response_and_send_to_client(int fd_conn_back_server, int client_fd, char *real_path)
  257. {
  258.     int body_length, body_length_record;
  259.     ssize_t read_size;
  260.     rio_t rio_buf;
  261.     char buf[MMAXLINE], key[MMAXLINE], value[MMAXLINE];
  262.     char *body_data, *temp_body_data_ptr, *temp_buf_ptr, *header_data;
  263.     Rio_readinitb(&rio_buf, fd_conn_back_server);
  265.     if ((header_data = (char *)malloc(MAXHEADER)) == NULL)
  266.     {
  267.         http_error(client_fd, "500", "not enough memory");
  268.         return;
  269.     }
  271.     Rio_readlineb(&rio_buf, buf, MMAXLINE); //返回码
  272.     Rio_writen(client_fd, buf, strlen(buf));
  273.     sprintf(header_data, "%s", buf);
  275.     while (1)
  276.     { /*读头部*/
  277.         Rio_readlineb(&rio_buf, buf, MMAXLINE);
  278.         if (!strcmp(buf, "
  279. "))
  280.         {
  281.             Rio_writen(client_fd, buf, strlen(buf));
  282.             break;
  283.         }
  284.         //deal_request_header(buf, fd_conn_back_server);
  285.         sscanf(buf, "%s %s", key, value);
  286.         if (!strcmp(key, "Content-length:"))
  287.         {
  288.             body_length = atoi(value);
  289.         }
  290.         Rio_writen(client_fd, buf, strlen(buf));
  291.         strcat(header_data, buf);
  292.     }
  294.     if (body_length > MAX_OBJECT_SIZE) //不能缓存
  295.     {
  296.         while (body_length > 0)
  297.         {
  298.             read_size = Rio_readnb(&rio_buf, buf, MMAXLINE);
  299.             body_length -= read_size;
  300.             Rio_writen(client_fd, buf, read_size);
  301.         }
  302.         free(header_data);
  303.     }
  304.     else //可以缓存
  305.     {
  306.         if ((body_data = (char *)malloc(body_length)) == NULL)
  307.         {
  308.             html_error(client_fd, "not enough memory");
  309.             //Close(client_fd);
  310.             Close(fd_conn_back_server);
  311.             return;
  312.         }
  313.         body_length_record = body_length;
  314.         temp_body_data_ptr = body_data;
  315.         while (body_length > 0)
  316.         {
  317.             read_size = Rio_readnb(&rio_buf, buf, MMAXLINE);
  318.             body_length -= read_size;
  320.             Rio_writen(client_fd, buf, read_size);
  322.             temp_buf_ptr = buf; //写局部缓存
  323.             while (read_size > 0)
  324.             {
  325.                 *temp_body_data_ptr++ = *temp_buf_ptr++;
  326.                 read_size--;
  327.             }
  328.         }
  329.         write_cache(header_data, body_data, body_length_record, real_path);
  330.         free(header_data);
  331.         free(body_data);
  332.     }
  334.     Close(fd_conn_back_server);
  335.     //Rio_writen(client_fd, )
  336. }
  337. /*如函数名*/
  338. void http_error(int fd, char *errnum, char *msg)
  339. {
  340.     char buf[MMAXLINE];
  342.     /* Print the HTTP response headers */
  343.     sprintf(buf, "HTTP/1.0 %s %s
  344. ", errnum, msg);
  345.     Rio_writen(fd, buf, strlen(buf));
  346.     sprintf(buf, "Content-type: text/html
  348. ");
  349.     Rio_writen(fd, buf, strlen(buf));
  351.     /* Print the HTTP response body */
  352.     sprintf(buf, "<html><title>Request Error</title>");
  353.     Rio_writen(fd, buf, strlen(buf));
  354.     sprintf(buf, "<body bgcolor="
  355.                  "ffffff"
  356.                  ">
  357. ");
  358.     Rio_writen(fd, buf, strlen(buf));
  359.     sprintf(buf, "%s: %s
  360. ", errnum, msg);
  361.     Rio_writen(fd, buf, strlen(buf));
  362.     sprintf(buf, "<hr><em>The Tiny Proxy server</em>
  363. ");
  364.     Rio_writen(fd, buf, strlen(buf));
  365. }
  367. void html_error(int fd, char *msg)
  368. {
  369.     char buf[MMAXLINE];
  371.     sprintf(buf, "<html><title>Request Error</title>");
  372.     Rio_writen(fd, buf, strlen(buf));
  373.     sprintf(buf, "<body bgcolor="
  374.                  "ffffff"
  375.                  ">
  376. ");
  377.     Rio_writen(fd, buf, strlen(buf));
  378.     sprintf(buf, "%s
  379. ", msg);
  380.     Rio_writen(fd, buf, strlen(buf));
  381.     sprintf(buf, "<hr><em>The Tiny Proxy server</em>
  382. ");
  383.     Rio_writen(fd, buf, strlen(buf));
  384. }
  386. void init_cache()
  387. {
  388.     memset(cache.block_slot, 0, MAXCACHEBLOCK * sizeof(struct cache_block *));
  389.     cache.clock_p = 0;
  390.     cache.used_block = 0;
  391.     cache.used_size = 0;
  392.     read_cnt = 0;
  393.     sem_init(&mutex, 0, 1);
  394.     sem_init(&write_lock, 0, 1);
  395. }
  397. /*找到返回body_size，并且写header与body，找不到返回-1*/
  398. int read_cache(char *header, char *body, char *real_path)
  399. {
  400.     P(&mutex);
  401.     if (++read_cnt == 1)
  402.         P(&write_lock);
  403.     V(&mutex);
  405.     int i, find = 0;
  406.     for (i = 0; i < MAXCACHEBLOCK; i++)
  407.     {
  408.         if (cache.block_slot[i] != NULL && !strcmp(cache.block_slot[i]->path, real_path))
  409.         {
  410.             find = 1;
  411.             break;
  412.         }
  413.     }
  415.     if (find)
  416.     {
  417.         struct cache_block *block = cache.block_slot[i];
  418.         sprintf(header, "%s", block->header);
  419.         memcpy(body, block->body, block->body_size);
  420.         block->visit = 1;
  421.         find = block->body_size;
  422.     }
  423.     else
  424.         find = -1;
  426.     P(&mutex);
  427.     if (--read_cnt == 0)
  428.         V(&write_lock);
  429.     V(&mutex);
  431.     return find;
  432. }
  434. /*成功返回1，失败返回0*/
  435. int write_cache(char *header, char *body, int body_size, char *real_path)
  436. {
  437.     P(&write_lock);
  439.     int slot;
  440.     struct cache_block *block;
  442.     slot = next_slot(body_size);
  443.     block = cache.block_slot[slot] = (struct cache_block *)malloc(sizeof(struct cache_block));
  445.     sprintf((block->path), "%s", real_path);
  446.     sprintf((block->header), "%s", header);
  447.     block->visit = 1;
  448.     block->body_size = body_size;
  449.     cache.used_block++;
  450.     cache.used_size += body_size;
  451.     if ((block->body = (char *)malloc(body_size)) == NULL)
  452.     {
  453.         V(&write_lock);
  454.         return 0;
  455.     }
  456.     memcpy(block->body, body, body_size);
  457.     V(&write_lock);
  458.     return 1;
  459. }
  461. /*write已经获得了写锁，所以next_slot与evict都不用再加锁*/
  462. int next_slot(int need_size)
  463. {
  464.     while (cache.used_size + need_size > MAX_CACHE_SIZE || cache.used_block >= MAXCACHEBLOCK)
  465.         evict();
  466.     while (cache.block_slot[cache.clock_p] != NULL)
  467.         cache.clock_p = (cache.clock_p + 1) % MAXCACHEBLOCK;
  468.     return cache.clock_p;
  469. }
  471. void evict()
  472. {
  473.     struct cache_block *block;
  474.     while (1)
  475.     {
  476.         block = cache.block_slot[cache.clock_p];
  477.         if (block == NULL)
  478.         {
  479.             cache.clock_p = (cache.clock_p + 1) % MAXCACHEBLOCK;
  480.             continue;
  481.         }
  482.         if (block->visit)
  483.         {
  484.             block->visit = 0;
  485.         }
  486.         else
  487.         {
  488.             free(block->body);
  489.             cache.used_size -= block->body_size;
  490.             cache.used_block--;
  491.             free(block);
  492.             cache.block_slot[cache.clock_p] = NULL;
  493.             return;
  494.         }
  496.         cache.clock_p = (cache.clock_p + 1) % MAXCACHEBLOCK;
  497.     }
  498. }

源文件

proxy.c