• CSAPP Lab08——Proxy Lab完成思路

    蓝色的思念

    突然演变成了阳光的夏天

    空气中的温暖不会很遥远

    ——被风吹过的夏天

    完整代码见：CSAPP/proxylab-handout at main · SnowLegend-star/CSAPP (github.com)

    Q：计算机网络中port的作用是什么？

    A：在计算机网络中，"port"（端口）是用于标识网络通信中的特定应用程序或服务的数字标识符。端口是网络通信的重要组成部分，它允许多个应用程序在同一台计算机上共享网络连接，并确保正确地将数据传递给目标应用程序。

    端口通常与 IP 地址结合使用，构成了网络通信中的目标地址。IP 地址用于标识网络中的设备，而端口则用于标识设备上的具体应用程序或服务。

    端口的作用包括：

    1. 标识应用程序或服务：每个应用程序或服务都可以绑定到一个或多个端口上，通过端口号来唯一标识。
    2. 实现多路复用：通过使用端口，多个应用程序可以在同一台计算机上共享网络连接。这意味着同一时间内，可以同时进行多个不同应用程序的通信，每个应用程序使用不同的端口。
    3. 提供通信路由：在网络通信中，端口号帮助路由数据到正确的目标应用程序。当数据包到达目标设备后，根据目标端口号将数据包分发给相应的应用程序或服务。

    总之，端口在计算机网络中起着非常重要的作用，它们允许多个应用程序共享网络连接，并确保数据被正确地路由到目标应用程序或服务。

    运行课本样例code的方法 

    今天突然想把《CSAPP》书上的例子跑一下，结果还是经典的报错。本来以前运行过书上的示例代码，当时就是报错。折腾半天无果索性放弃了。现在想到书都快看完了还没跑成功过示例代码，我心血来潮决定好好研究下到底怎么执行。

    想不到还不好搜，找半天才看到一个可行的方案，原来编译书上的代码时都得和csapp.c进行联合编译。因为好多函数都在csapp.c里面重写了，如果不带上这个文件就会有各种报错，看似是没引入头文件导致库函数无法使用，实则是因为当前文件用到的函数其实是在csapp.c内部重新实现了的，只不过csapp.c内部编写的函数命名方式和库函数神似，有点以假乱真。

    至此，终于是成功运行了书上的示例代码。

     

    一不小心又在proxy lab上磨了好久，主要是一开始对怎么测试proxy感到很疑惑，就去b站上搜了下，结果发现了个讲得很好的up。遂跟着这个up把10~12章重新温习了一番，收获颇多。由于up主的github上只有通过最后一次实验的记录，我又研究半天怎么获得github的历史提交记录，最后也是成功掌握了这个技巧。

    言归正传，下面讲讲我完成这个lab的历程。

    首先，总体思路图大致如下

     

    1、Proxy先与Client进行通信，建立连接并接收并分析来自Client的http-request。

    2、Proxy把处理好的http-request发送给Server

    3、Server发送response给Proxy

    4、Proxy将response转发给Client

    Part I: Implementing a sequential web proxy

    第一部分要求我们实现一个简单的sequential proxy，类似的代码在书上随处可见，tiny.c就是一个很好的模仿对象。它的大致流程如下：

    1、在main()里面创建一个监听描述符listenfd，然后在while的循环体里不断尝试与客户端进行连接connfd=Accept(listenfd)。连接成功后将connfd传入请求处理函数handleRequest()中。

    2、进入handRequest()后，分别创建好两个I/O缓冲区rio_Proxy2Client和rio_Proxy2Server，Proxy可以利用这两个不同的缓冲区分别和Client与Server进行读写操作。

    GET http://www.cmu.edu:8080/hub/index.html HTTP/1.1

    Host: www.cmu.edu

    User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.3) Gecko/20120305 Firefox/10.0.3

    Connection: close

    Proxy-Connection: close

    3、利用rio_Proxy2Client读入http-request，并把这个请求分割成writeup要求的几部分，即method、url、version；其中url又可以分割为hostName、port和fielName。

    4、处理完request的第一行后，开始处理后序的四个request header，少哪个header就自己补上哪个header。

    5、 Proxy利用刚才得到的hostName和port，调用clientfd=Open_clientfd()冒充一个Client与Server建立连接。

    6、Proxy利用clientfd和rio_Proxy2Server，先把从Client处得到的http-request发送给Server，然后不断读入Server回复的response。Proxy在读入response的同时，又利用connfd把它们发送给Client。

    7、还得加上一个如果method不是“GET”的错误处理函数，直接照着书上的敲一遍或者把tiny.c的那个clientError()复制过来就行。

    第一部分的代码难度并不高，核心操作就是要对字符串进行各种处理。

    part I的实现如下
     

    1. #include 
    2. #include"csapp.h"
    3. #include"sbuf.h"
    4.  
    5. /* Recommended max cache and object sizes */
    6. #define MAX_CACHE_SIZE 1049000
    7. #define MAX_OBJECT_SIZE 102400
    8. #define HTTP_PREFIX "http://"
    9.  
    10. /* You won't lose style points for including this long line in your code */
    11. 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\r\n";
    12.  
    13. void handleRequest(int fd);
    14. void parseRequest(char* buf, char* host, char* port, char* method, char* url, char* version, char* fileName);
    15. void clientError(int fd, char* cause, char* errnum, char* errmsg, char* errmsg_datail);
    16. int readAndFormatRequestHeader(rio_t* rio, char* clientRequest, char* Host, char* port,
    17.                                 char* method, char* url, char* version, char* filename);
    18.  
    19. //和tiny.c里面的那个差不多
    20. void clientError(int fd, char* cause, char* errnum, char* errmsg, char* errmsg_datail){
    21.     char buf[MAXLINE];
    22.  
    23.     //打印HTTP的响应头
    24.     sprintf(buf, "HTTP/1.0 %s %s\r\n", errnum, errmsg);
    25.     Rio_writen(fd, buf, strlen(buf));
    26.     sprintf(buf, "Content-type: text/html\r\n\r\n");
    27.     Rio_writen(fd, buf, strlen(buf));
    28.  
    29.     //打印HTTP响应的主体
    30.     sprintf(buf, "Tiny Error");
    31.     Rio_writen(fd,buf,strlen(buf));
    32.     sprintf(buf, ""ffffff"">\r\n");
    33.     Rio_writen(fd,buf,strlen(buf));
    34.     sprintf(buf, "%s: %s\r\n", errmsg, errmsg);
    35.     Rio_writen(fd, buf, strlen(buf));
    36.     sprintf(buf, "
      %s: %s\r\n", errmsg_datail, cause);
    37.     Rio_writen(fd, buf, strlen(buf));
    38.     sprintf(buf, "
      The Tiny Web Server\r\n"      );
    39.     Rio_writen(fd, buf, strlen(buf));
    40. }
    41.  
    42. void handleRequest(int fd){
    43.     //处理各种定位的指针
    44.     char* pos=NULL;
    45.  
    46.     //分割http请求的参数
    47.     char buf[MAXLINE],method[MAXLINE],uri[MAXLINE],version[MAXLINE],fileName[MAXLINE];
    48.  
    49.     //客户端的几个请求头的主体
    50.     char clientRequest[MAXLINE];
    51.     char hostName[MAXLINE],port[MAXLINE];
    52.  
    53.     //proxy-client和proxy-server的IO
    54.     rio_t rio_Proxy2Client,rio_Proxy2Server;
    55.  
    56.     //Step1: proxy读入来自client的请求
    57.     Rio_readinitb(&rio_Proxy2Client,fd);
    58.     if(Rio_readlineb(&rio_Proxy2Client,buf,MAXLINE)==0){
    59.         //这个请求是空的
    60.         printf("Oops! empty request\n");
    61.         return ;
    62.     }
    63.  
    64.     //如果http的版本是1.1，处理成1.0
    65.     if((pos=strstr(buf,"HTTP/1.1"))!=NULL){
    66.         buf[pos-buf-1+strlen("HTTP/1.1")]='0';
    67.     }
    68.  
    69.     //Step2: 分割请求
    70.     parseRequest(buf, hostName, port, method, uri, version, fileName);
    71.  
    72.     //判断请求是否有效
    73.     if(strcasecmp(method,"GET")!=0){
    74.         clientError(fd, method, "501", "Not Implement", "Tiny Does not implement this method");
    75.         return ;
    76.     }
    77.  
    78.     int rv=readAndFormatRequestHeader(&rio_Proxy2Client, clientRequest, hostName, port, method, uri, version, fileName);
    79.     if(rv==0){
    80.         return ;
    81.     }
    82.  
    83.     //Step3: tiny server和proxy建立连接
    84.     int clientfd=Open_clientfd(hostName, port);
    85.  
    86.     Rio_readinitb(&rio_Proxy2Server, clientfd);
    87.     Rio_writen(rio_Proxy2Server.rio_fd, clientRequest, strlen(clientRequest));
    88.  
    89.     //Step4: 从tiny server读入response，并且把它发送给client
    90.     printf("The Proxy is ready to relay the response\n");
    91.  
    92.     char tinyResponse[MAXLINE];
    93.     int n;
    94.  
    95.     while((n=Rio_readlineb(&rio_Proxy2Server, tinyResponse, MAXLINE))!=0){
    96.         Rio_writen(fd, tinyResponse, n);
    97.     }
    98. }
    99.  
    100.  
    101.     //client request is like this
    102.     //GET http://www.cmu.edu/hub/index.html HTTP/1.1
    103. void parseRequest(char* buf, char* host, char* port, char* method, char* url, char* version, char* fileName){
    104.     sscanf(buf,"%s %s %s", method, url, version);
    105.     //method = "GET", url = "http://localhost:15213/home.html", version = "HTTP1.0"
    106.  
    107.     char* host_pos =strstr(url,HTTP_PREFIX)+strlen(HTTP_PREFIX);    //主机名开始的位置
    108.     char* port_pos =strstr(host_pos,":");                           //端口开始的位置
    109.     char* slash_pos=strstr(host_pos,"/");                           //suffix开始的位置
    110.    
    111.     //判断url有没有带端口号，如果没带就是默认端口80
    112.     if(port_pos==NULL){ //没带端口号
    113.         strcpy(port,"80");
    114.         strncmp(host,host_pos,slash_pos-host_pos);      
    115.     }
    116.     else{
    117.         strncpy(host,host_pos,port_pos-host_pos);
    118.         strncpy(port,port_pos+1,slash_pos-port_pos-1);
    119.     }
    120.  
    121.     strcpy(fileName,slash_pos);
    122.     printf("HostName: %s",host);
    123.     printf("Port: %s",port);
    124.     printf("fileName: %s",fileName);
    125. }
    126.  
    127. int readAndFormatRequestHeader(rio_t* rio, char* clientRequest, char* Host, char* port,
    128.                                 char* method, char* url, char* version, char* fileName){
    129.  
    130.     int UserAgent=0, Connection=0, proxyConnection=0, hostInfo=0;
    131.     char buf[MAXLINE/2];
    132.     int n;
    133.     char* findpos;
    134.  
    135.     sprintf(clientRequest, "GET %s HTTP/1.0\r\n",fileName);
    136.  
    137.     n=Rio_readlineb(rio, buf, MAXLINE);
    138.     printf("receive buf %s\n", buf);
    139.     printf("n = %d", n);
    140.  
    141.     while(strcmp("\r\n",buf)!=0&&n!=0){
    142.         strcat(clientRequest, buf);
    143.         printf("receive buf %s\n", buf);
    144.         
    145.         //判断要求的四个请求头是否存在
    146.         if((findpos=strstr(buf, "User-Agent:"))!=NULL){
    147.             UserAgent=1;
    148.         }
    149.         if((findpos=strstr(buf,"Proxy-Connection:"))!=NULL){
    150.             proxyConnection=1;
    151.         }
    152.         if((findpos=strstr(buf,"Connection"))!=NULL){
    153.             Connection=1;
    154.         }
    155.         if((findpos=strstr(buf, "Host"))!=NULL){
    156.             hostInfo=1;
    157.         }
    158.  
    159.         n=Rio_readlineb(rio, buf ,MAXLINE);
    160.     }
    161.  
    162.     if(n==0){
    163.         return 0;
    164.     }
    165.  
    166.  
    167.     //如果缺失了这四个头部，则进行添加    
    168.     if(hostInfo==0){
    169.         sprintf(buf, "Host: %s\r\n", Host);
    170.         strcat(clientRequest, buf);
    171.     }
    172.  
    173.     if(UserAgent==0){
    174.         strcat(clientRequest, user_agent_hdr);
    175.     }
    176.  
    177.     if(Connection==0){
    178.         sprintf(buf, "Connection: close\r\n");
    179.         strcat(clientRequest, buf);
    180.     }
    181.  
    182.     if(proxyConnection==0){
    183.         sprintf(buf, "Proxy-Connection: close\r\n");
    184.         strcat(clientRequest, buf);
    185.     }
    186.  
    187.     //添加最后的空行
    188.     strcat(clientRequest,"\r\n");
    189.     return 1;
    190. }
    191.  
    192. int main(int argc,char** argv){
    193.     if(argc!=2){
    194.         unix_error("proxy usage: ./proxy ");
    195.     }
    196.  
    197.     int listenfd=Open_listenfd(argv[1]);
    198.     struct sockaddr_storage clientaddr;
    199.     char hostName[MAXLINE], port[MAXLINE];
    200.  
    201.     while(1){
    202.         socklen_t clientlen=sizeof(struct sockaddr_storage);
    203.         int connfd=Accept(listenfd,(SA*) &clientaddr,&clientlen);
    204.  
    205.         Getnameinfo((SA*) &clientaddr,clientlen,hostName,MAXLINE,port,MAXLINE,0);
    206.  
    207.         handleRequest(connfd);
    208.         Close(connfd);
    209.     }
    210.     return 0;
    211. }

    Part II

    书上给出了三种并发编程的方式：

    1、基于进程

    2、基于I/O多路复用

    3、基于线程

    不得不说基于线程是最为通俗易懂的，而且书上还有一个基于线程进行并发编程的例子“echoservert-pre.c”。结合这份代码，在Part I的基础上稍作改动即可。

    对了，书上还要求在main()函数里面加入Signal(SIGPIPE, SIG_IGN)来屏蔽SIGPIPE信号。我一开始并没有加这个顺利通过了lab，(:

    part II实现如下
     

    1. #include 
    2. #include"csapp.h"
    3. #include"sbuf.h"
    4.  
    5. /* Recommended max cache and object sizes */
    6. #define MAX_CACHE_SIZE 1049000
    7. #define MAX_OBJECT_SIZE 102400
    8. #define HTTP_PREFIX "http://"
    9. #define NTHREADS 4
    10. #define SBUFSIZE 16
    11.  
    12. sbuf_t sbuf;    //shared buffer of connected descriptor
    13. void *thread(void *vargp);
    14.  
    15. /* You won't lose style points for including this long line in your code */
    16. 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\r\n";
    17.  
    18. void handleRequest(int fd);
    19. void parseRequest(char* buf, char* host, char* port, char* method, char* url, char* version, char* fileName);
    20. void clientError(int fd, char* cause, char* errnum, char* errmsg, char* errmsg_datail);
    21. int readAndFormatRequestHeader(rio_t* rio, char* clientRequest, char* Host, char* port,
    22.                                 char* method, char* url, char* version, char* filename);
    23.  
    24. //和tiny.c里面的那个差不多
    25. void clientError(int fd, char* cause, char* errnum, char* errmsg, char* errmsg_datail){
    26.     char buf[MAXLINE];
    27.  
    28.     //打印HTTP的响应头
    29.     sprintf(buf, "HTTP/1.0 %s %s\r\n", errnum, errmsg);
    30.     Rio_writen(fd, buf, strlen(buf));
    31.     sprintf(buf, "Content-type: text/html\r\n\r\n");
    32.     Rio_writen(fd, buf, strlen(buf));
    33.  
    34.     //打印HTTP响应的主体
    35.     sprintf(buf, "Tiny Error");
    36.     Rio_writen(fd,buf,strlen(buf));
    37.     sprintf(buf, ""ffffff"">\r\n");
    38.     Rio_writen(fd,buf,strlen(buf));
    39.     sprintf(buf, "%s: %s\r\n", errmsg, errmsg);
    40.     Rio_writen(fd, buf, strlen(buf));
    41.     sprintf(buf, "
      %s: %s\r\n", errmsg_datail, cause);
    42.     Rio_writen(fd, buf, strlen(buf));
    43.     sprintf(buf, "
      The Tiny Web Server\r\n"      );
    44.     Rio_writen(fd, buf, strlen(buf));
    45. }
    46.  
    47. void handleRequest(int fd){
    48.     //处理各种定位的指针
    49.     char* pos=NULL;
    50.  
    51.     //分割http请求的参数
    52.     char buf[MAXLINE],method[MAXLINE],uri[MAXLINE],version[MAXLINE],fileName[MAXLINE];
    53.  
    54.     //客户端的几个请求头的主体
    55.     char clientRequest[MAXLINE];
    56.     char hostName[MAXLINE],port[MAXLINE];
    57.  
    58.     //proxy-client和proxy-server的IO
    59.     rio_t rio_Proxy2Client,rio_Proxy2Server;
    60.  
    61.     //Step1: proxy读入来自client的请求
    62.     Rio_readinitb(&rio_Proxy2Client,fd);
    63.     if(Rio_readlineb(&rio_Proxy2Client,buf,MAXLINE)==0){
    64.         //这个请求是空的
    65.         printf("Oops! empty request\n");
    66.         return ;
    67.     }
    68.  
    69.     //如果http的版本是1.1，处理成1.0
    70.     if((pos=strstr(buf,"HTTP/1.1"))!=NULL){
    71.         buf[pos-buf-1+strlen("HTTP/1.1")]='0';
    72.     }
    73.  
    74.     //Step2: 分割请求
    75.     parseRequest(buf, hostName, port, method, uri, version, fileName);
    76.  
    77.     //判断请求是否有效
    78.     if(strcasecmp(method,"GET")!=0){
    79.         clientError(fd, method, "501", "Not Implement", "Tiny Does not implement this method");
    80.         return ;
    81.     }
    82.  
    83.     int rv=readAndFormatRequestHeader(&rio_Proxy2Client, clientRequest, hostName, port, method, uri, version, fileName);
    84.     if(rv==0){
    85.         return ;
    86.     }
    87.  
    88.     //Step3: tiny server和proxy建立连接
    89.     int clientfd=Open_clientfd(hostName, port);
    90.  
    91.     Rio_readinitb(&rio_Proxy2Server, clientfd);
    92.     Rio_writen(rio_Proxy2Server.rio_fd, clientRequest, strlen(clientRequest));
    93.  
    94.     //Step4: 从tiny server读入response，并且把它发送给client
    95.     printf("The Proxy is ready to relay the response\n");
    96.  
    97.     char tinyResponse[MAXLINE];
    98.     int n;
    99.  
    100.     while((n=Rio_readlineb(&rio_Proxy2Server, tinyResponse, MAXLINE))!=0){
    101.         Rio_writen(fd, tinyResponse, n);
    102.     }
    103. }
    104.  
    105.  
    106.     //client request is like this
    107.     //GET http://www.cmu.edu/hub/index.html HTTP/1.1
    108. void parseRequest(char* buf, char* host, char* port, char* method, char* url, char* version, char* fileName){
    109.     sscanf(buf,"%s %s %s", method, url, version);
    110.     //method = "GET", url = "http://localhost:15213/home.html", version = "HTTP1.0"
    111.  
    112.     char* host_pos =strstr(url,HTTP_PREFIX)+strlen(HTTP_PREFIX);    //主机名开始的位置
    113.     char* port_pos =strstr(host_pos,":");                           //端口开始的位置
    114.     char* slash_pos=strstr(host_pos,"/");                           //suffix开始的位置
    115.    
    116.     //判断url有没有带端口号，如果没带就是默认端口80
    117.     if(port_pos==NULL){ //没带端口号
    118.         strcpy(port,"80");
    119.         strncmp(host,host_pos,slash_pos-host_pos);      
    120.     }
    121.     else{
    122.         strncpy(host,host_pos,port_pos-host_pos);
    123.         strncpy(port,port_pos+1,slash_pos-port_pos-1);
    124.     }
    125.  
    126.     strcpy(fileName,slash_pos);
    127.     printf("HostName: %s",host);
    128.     printf("Port: %s",port);
    129.     printf("fileName: %s",fileName);
    130. }
    131.  
    132. int readAndFormatRequestHeader(rio_t* rio, char* clientRequest, char* Host, char* port,
    133.                                 char* method, char* url, char* version, char* fileName){
    134.  
    135.     int UserAgent=0, Connection=0, proxyConnection=0, hostInfo=0;
    136.     char buf[MAXLINE/2];
    137.     int n;
    138.     char* findpos;
    139.  
    140.     sprintf(clientRequest, "GET %s HTTP/1.0\r\n",fileName);
    141.  
    142.     n=Rio_readlineb(rio, buf, MAXLINE);
    143.     printf("receive buf %s\n", buf);
    144.     printf("n = %d", n);
    145.  
    146.     while(strcmp("\r\n",buf)!=0&&n!=0){
    147.         strcat(clientRequest, buf);
    148.         printf("receive buf %s\n", buf);
    149.         
    150.         //判断要求的四个请求头是否存在
    151.         if((findpos=strstr(buf, "User-Agent:"))!=NULL){
    152.             UserAgent=1;
    153.         }
    154.         if((findpos=strstr(buf,"Proxy-Connection:"))!=NULL){
    155.             proxyConnection=1;
    156.         }
    157.         if((findpos=strstr(buf,"Connection"))!=NULL){
    158.             Connection=1;
    159.         }
    160.         if((findpos=strstr(buf, "Host"))!=NULL){
    161.             hostInfo=1;
    162.         }
    163.  
    164.         n=Rio_readlineb(rio, buf ,MAXLINE);
    165.     }
    166.  
    167.     if(n==0){
    168.         return 0;
    169.     }
    170.  
    171.  
    172.     //如果缺失了这四个头部，则进行添加    
    173.     if(hostInfo==0){
    174.         sprintf(buf, "Host: %s\r\n", Host);
    175.         strcat(clientRequest, buf);
    176.     }
    177.  
    178.     if(UserAgent==0){
    179.         strcat(clientRequest, user_agent_hdr);
    180.     }
    181.  
    182.     if(Connection==0){
    183.         sprintf(buf, "Connection: close\r\n");
    184.         strcat(clientRequest, buf);
    185.     }
    186.  
    187.     if(proxyConnection==0){
    188.         sprintf(buf, "Proxy-Connection: close\r\n");
    189.         strcat(clientRequest, buf);
    190.     }
    191.  
    192.     //添加最后的空行
    193.     strcat(clientRequest,"\r\n");
    194.     return 1;
    195. }
    196.  
    197. int main(int argc,char** argv){
    198.     if(argc!=2){
    199.         unix_error("proxy usage: ./proxy ");
    200.     }
    201.  
    202.     int listenfd=Open_listenfd(argv[1]), i;
    203.     pthread_t tid;
    204.     struct sockaddr_storage clientaddr;
    205.     char hostName[MAXLINE], port[MAXLINE];
    206.     sbuf_init(&sbuf, SBUFSIZE);
    207.  
    208.     for(i=0;i//创建工作线程
    209.         Pthread_create(&tid, NULL, thread, NULL);
    210.     }
    211.  
    212.     while(1){
    213.         socklen_t clientlen=sizeof(struct sockaddr_storage);
    214.         int connfd=Accept(listenfd,(SA*) &clientaddr,&clientlen);
    215.         //Getnameinfo((SA*)&clientaddr, clientlen, hostName, MAXLINE, port, MAXLINE, 0);
    216.         sbuf_insert(&sbuf, connfd);
    217.     }
    218.     return 0;
    219. }
    220.  
    221. void *thread(void *vargp){
    222.     pthread_detach(pthread_self());
    223.     while(1){
    224.         int connfd=sbuf_remove(&sbuf);
    225.         handleRequest(connfd);
    226.         Close(connfd);
    227.     }
    228. }

     

    Part III

    最后一部分写的我汗流浃背了。

    这一部分要求我们给Proxy添加cache。对于cache的读取方式，可以参照第一类“读者-写者”问题。我一开始也并没有反应过来可以在此引入“读者-写者”模式，还是在网上参考了其他人的解决方案才隐约发现得这么做的哈哈哈。

    其实可以直接把和cache相关的代码写在proxy.c里面，就是会让proxy.c更为臃肿一点。但我一想书上都给出sbuf.c和sbuf.h了，我也模仿着写一个cache.c和cache.h岂不美哉？正式这个决定让我后序改bug改得一头大包。我先在proxy.c中定义了缓存cache_t cache,然后进行参数传递在cache.c中修改cache。由于我对全局变量跨文件的处理方式一知半解，但还是硬着头皮写了下去。

    后面仔细思考了下，关于“全局变量跨文件的处理”其实有两种方案。

           方案一：我直接把cache_t cache写入cache.h当中，而不是写在proxy.c。这样只需要在cache.c和proxy.c中直接引入“cache.h”就可以直接用cache了，但是这样有个弊端———有且仅有一个cache供proxy.c使用，如果还有个proxy2.c也要用到cache，那就没得用了。还是治标不治本。

           方案二：用指针传递来在cahce.c中修改proxy.c定义的cache_t cache。这方法其实不难，我最后也是采用的这个方法。坏就坏在昨晚写的代码简直就是一坨，好像用了指针传递又好像没用，我就在这一坨东西上反复修改，然后越陷越深。理清了思路之后问题就迎刃而解了。

    还有几个让我困惑的小问题:

    ①malloc问题

    1. void cache_init(cache_t *cache) {
    2.     // cache=(cache_t*)Malloc(sizeof(cache_t));
    3.     cache->cache_Item_Using = 0;
    4. }

    在这里我开始准备模仿sbuf.c给cache分配个空间再说，结果测试的时候一直报错“Segmentation fault”，搞得我一度以为是malloc出了问题。最后把参数传递的问题解决后发现这里的malloc可用可不用，由于cache_t cache是全局变量，它的生命周期和进行同步，故没必要多此一举再在堆上给它分配空间了。

    ②url问题

    1.      printf("=====The length of url is: %d====\n",(int)sizeof(url));
    2.     // strncpy(item->url,url,sizeof(url));  西八，这个bug害得我好苦啊
    3.     strncpy(item->url,url,MAXLINE);

    在解决缓存的问题后，我发现cache部分的得分依然是0昏。初步判断是url的匹配有问题，测试了一番后发现一个十分怪异的情况——存入的url长度并不能用sizeof(url)，实际长度好像比sizeof(url)还要长。

     

     

    把每次存进cache的item->url打印出来一看果然如此，于是最后直接假设url的长度是MAXLINE，这样就可以通过测试了

     

    Q：例如char* url=“http://localhost:7710/”

    那sizeof（url）是输出8还是字符串本身的长度22呢？

    A：    在这种情况下，char* url = "http://localhost:7710/"中的url是一个指向字符的指针，指向字符串常量"http://localhost:7710/"的首地址。因此，使用sizeof(url)将返回指针的大小，而不是字符串的长度。

    在大多数平台上，指针的大小通常是机器字长的大小。在64位系统上，指针通常是8个字节，因此sizeof(url)将返回8。

    要获取字符串本身的长度，您可以使用strlen函数，如下所示：

    1. #include 
    2.  
    3. #include 
    4.  
    5. int main() {
    6.  
    7. char *url = "http://localhost:7710/";
    8.  
    9. size_t length = strlen(url);
    10.  
    11. printf("Length of the string: %zu\n", length); // 这里将输出字符串的长度，即22
    12.  
    13. return 0;
    14.  
    15. }

    这段代码将输出字符串的长度，即22。

    但是，由于strlen(str)不会包括结尾的‘\0’,所以得用strncpy(item->url,url,strlen(url)+1)

    至此，真相大白。 

    csche.c如下
     

    1. #include "csapp.h"
    2. #include "cache.h"
    3.  
    4. void initializeCache(cache_t* cache){
    5.     cache->head = Malloc(sizeof(*(cache->head)));
    6.     cache->head->flag = '@';
    7.     cache->head->prev = NULL;
    8.     cache->head->next = NULL;
    9.  
    10.     cache->tail = Malloc(sizeof(*(cache->tail)));
    11.     cache->tail->flag = '@';
    12.     cache->tail->prev = NULL;
    13.     cache->tail->next = NULL;
    14.  
    15.     /* construct the doubly linked list */
    16.     cache->head->next = cache->tail;
    17.     cache->tail->prev = cache->head;
    18.  
    19.     cache->nitems = 0;
    20. }

    cache.h实现如下

    1. #include "csapp.h"
    2. #define MAX_CACHE_SIZE 1049000
    3. #define MAX_OBJECT_SIZE 102400
    4.  
    5. typedef struct _obj_t{
    6.     char flag;
    7.     char uri[100];
    8.     char respHeader[1024];
    9.     char respBody[MAX_OBJECT_SIZE];
    10.     int respHeaderLen;
    11.     int respBodyLen;
    12.     struct _obj_t* prev;
    13.     struct _obj_t* next;
    14. }obj_t;
    15.  
    16. typedef struct _cache_t{
    17.     obj_t* head;
    18.     obj_t* tail;    
    19.     int nitems;
    20. }cache_t;
    21.  
    22. //write to cache
    23. //read cache
    24. //search cache
    25.  
    26. void initializeCache(cache_t* );

    写入到cache的实现如下

    1. /*
    2.  * This function is guarded by Write Lock, thus is thread safe
    3.  * assume head is the newest part, we evict the last part
    4.  * if possible
    5.  */
    6. void writeToCache(obj_t* obj){
    7.     /* step1: check current capacity, if full ,delete one */
    8.     while(obj->respBodyLen + cacheSize > MAX_CACHE_SIZE && cache.head->next != cache.tail){
    9.         obj_t* last = cache.tail->prev;
    10.         last->next->prev = last->prev;
    11.         last->prev->next = last->next;
    12.  
    13.         last->next = NULL;
    14.         last->prev = NULL;
    15.         Free(last);
    16.     }
    17.  
    18.     /* step2: add into the cache */
    19.     //mount the current obj into cache
    20.     obj->next = cache.head->next;
    21.     obj->prev = cache.head;
    22.     cache.head->next->prev = obj;
    23.     cache.head->next       = obj;
    24.     cacheSize += obj->respBodyLen;
    25. }

     

     读取cahce条目的实现如下

    1. obj_t* readItem(char* targetURI, int clientfd){
    2.     P(&mutex);
    3.     readcnt++;
    4.     if(readcnt == 1){
    5.         P(&W);
    6.     }
    7.     V(&mutex);
    8.  
    9.     /***** reading section starts *****/
    10.     obj_t* cur = cache.head->next;
    11.     rio_t rio;
    12.     Rio_readinitb(&rio, clientfd);
    13.     while(cur->flag != '@'){
    14.         if(strcmp(targetURI, cur->uri) == 0){
    15.             return cur;
    16.         }
    17.  
    18.         cur = cur->next;
    19.     }
    20.  
    21.  
    22.     /***** reading section ends *****/
    23.     P(&mutex);
    24.     readcnt--;
    25.     if(readcnt == 0){
    26.         V(&W);
    27.     }
    28.     V(&mutex);
    29.  
    30.     return NULL;
    31. }

     

     

  • 相关阅读:
    白嫖阿里云服务器教程来了，薅秃阿里云！
    优化算法 - 梯度下降
    算法——双指针
    Spring的RestTemplate学习
    ModuleNotFoundError: No module named ‘sklearn.cross_validation‘
    华为HCDA论证教程
    数据治理容易走进哪些误区？
    第五章 神经网络（下）
    JavaScript系列从入门到精通系列第十七篇：JavaScript中的全局作用域
    数字逻辑·数制转换、编码方法
  • 原文地址：https://blog.csdn.net/John_Snowww/article/details/139370089