CSAPP(CMU 15-213)：Lab7 proxylab详解

# 前言

本系列文章意在记录答主学习CSAPP Lab的过程，也旨在可以帮助后人一二，欢迎大家指正！

---

tips:完成一个 Web proxy(代码服务器、并发服务器、可以缓存)

Implementation

基本思想就是tiny server和echo server的结合，我因为之前不熟悉网络编程，所以把这两部分的示例代码重写了一遍，熟悉了一下。

tips:

• 信号SIGPIPE
• 依照handout的要求重新改写HTTP request headers

Part I: Implementing a sequential web proxy

代码proxy.c

#include <stdio.h>
#include "csapp.h"

/* Recommended max cache and object sizes */
#define MAX_CACHE_SIZE 1049000
#define MAX_OBJECT_SIZE 102400

static void parse_uri(char *uri, char *hostname, char *port, char *filepath);
static void build_request_header(rio_t *rp, char *reqhd, char *hostname);
void *thread(void *vargp);

/* You won't lose style points for including this long line in your code */
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";

static void doit(int fd);

int main(int argc, char **argv)
{
    char *server_port;
    int listenfd, *connfdp;
    socklen_t clientlen;
    struct sockaddr_storage clientaddr;
    char hostname[MAXLINE], port[MAXLINE];
    pthread_t tid;

    if (argc != 2) {
        fprintf(stderr, "usage: %s <port>\n", argv[0]);
        exit(0);
    }
    Signal(SIGPIPE, SIG_IGN);

    server_port = argv[1];
    listenfd = Open_listenfd(server_port);
    
    while (1) {
        clientlen = sizeof(struct sockaddr_storage);
        connfdp = Malloc(sizeof(int));
        *connfdp = Accept(listenfd, (SA *) &clientaddr, &clientlen);
        
        Getnameinfo((SA *) &clientaddr, clientlen, hostname, MAXLINE, port, MAXLINE, 0);
        printf("\nAccepted connection from (%s, %s) in proxy.\n", hostname, port);

        Pthread_create(&tid, NULL, thread, connfdp);

    }
    return 0;
}

void *thread(void *vargp) {
    int connfd = *((int *)vargp);
    Pthread_detach(pthread_self());
    Free(vargp);
    doit(connfd);
    Close(connfd);
    return NULL;
}
//handle HTTP request
static void doit(int serverfd) 
{
    rio_t rio_server;  //make proxy as server
    rio_t rio_client;  //make proxy as client
    char buf[MAXLINE];
    char method[MAXLINE], uri[MAXLINE], version[MAXLINE];
    char hostname[MAXLINE], filepath[MAXLINE], server_port[MAXLINE];
    int clientfd;
    char reqhd[MAXLINE];

    Rio_readinitb(&rio_server, serverfd);

    //handle HTTP request line
    if (!Rio_readlineb(&rio_server, buf, MAXLINE)) {

        return ;
    }
    sscanf(buf, "%s %s %s", method, uri, version);
    if (strcasecmp(method, "GET")) {   // only deal with "GET"
        return ;
    }
    if (!strcmp(version, "HTTP/1.1")) {
        strcpy(version, "HTTP/1.0");
    }

    parse_uri(uri, hostname, server_port, filepath);
    sprintf(uri, "%s %s %s\r\n", method, filepath, version);
    // build connect to web server
    clientfd = Open_clientfd(hostname, server_port);
    Rio_readinitb(&rio_client, clientfd);

    //read HTTP request from browser 
    strcpy(reqhd, uri);
    build_request_header(&rio_server, reqhd, hostname);
    //write HTTP headers to web server
    Rio_writen(clientfd, reqhd, strlen(reqhd));
    // send HTTP response to client browser
    ssize_t n;
    while ((n = Rio_readlineb(&rio_client, buf, MAXLINE))) {
        Rio_writen(serverfd, buf, n);
    }

    Close(clientfd);
}

//  eg. uri = http://localhost:4600/ 
static void parse_uri(char *uri, char *hostname, char *port, char *filepath)
{
    char *ptr1, *ptr2;
    uri += 7;
    ptr1 = index(uri, ':');    //default port is 80
    *ptr1 = '\0';
    ptr1++;
    strcpy(hostname, uri);

    ptr2 = index(ptr1, '/');
    *ptr2 = '\0';
    strcpy(port, ptr1);
    strcpy(filepath, "/");
    strcat(filepath, ptr2+1);
}

static void build_request_header(rio_t *rp, char *reqhd, char *hostname) {
    char buf[MAXLINE];

    while (Rio_readlineb(rp, buf, MAXLINE) > 0) {
        if (!strcmp(buf, "\r\n")) break;
        if (strstr(buf,"Host:") != NULL) continue;
        if (strstr(buf,"User-Agent:") != NULL) continue;
        if (strstr(buf,"Connection:") != NULL) continue;
        if (strstr(buf,"Proxy-Connection:") != NULL) continue;

        strcat(reqhd, buf);
    }
    sprintf(buf, "Host: %s\r\n", hostname);
    strcat(reqhd, buf);
    sprintf(buf, "User-Agent: %s", user_agent_hdr);
    strcat(reqhd, buf);
    strcat(reqhd, "Connection: false\r\n");
    strcat(reqhd, "Proxy-Connection: false\r\n");
    strcat(reqhd, "\r\n");
}

测试结果：

$ curl -v --proxy http://localhost:4600 http://localhost:4500/
*   Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to localhost (127.0.0.1) port 4600 (#0)
> GET http://localhost:4500/ HTTP/1.1
> Host: localhost:4500
> User-Agent: curl/7.58.0
> Accept: */*
> Proxy-Connection: Keep-Alive
> 
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Server: Tiny Web Server
< Content-length: 120
< Content-type: text/html
< 
<html>
<head><title>test</title></head>
<body> 
<img align="middle" src="godzilla.gif">
Dave O'Hallaron
</body>
</html>
* Closing connection 0

Part II: Dealing with multiple concurrent requests

第二部分很简单，只要依照书上的并发服务器重写就好啦，代码已经在第一部分出现啦

评分:

$ ./driver.sh
*** Basic ***
Starting tiny on 7990
Starting proxy on 8086
1: home.html
   Fetching ./tiny/home.html into ./.proxy using the proxy
   Fetching ./tiny/home.html into ./.noproxy directly from Tiny
   Comparing the two files
   Success: Files are identical.
2: csapp.c
   Fetching ./tiny/csapp.c into ./.proxy using the proxy
   Fetching ./tiny/csapp.c into ./.noproxy directly from Tiny
   Comparing the two files
   Success: Files are identical.
3: tiny.c
   Fetching ./tiny/tiny.c into ./.proxy using the proxy
   Fetching ./tiny/tiny.c into ./.noproxy directly from Tiny
   Comparing the two files
   Success: Files are identical.
4: godzilla.jpg
   Fetching ./tiny/godzilla.jpg into ./.proxy using the proxy
   Fetching ./tiny/godzilla.jpg into ./.noproxy directly from Tiny
   Comparing the two files
   Success: Files are identical.
5: tiny
   Fetching ./tiny/tiny into ./.proxy using the proxy
   Fetching ./tiny/tiny into ./.noproxy directly from Tiny
   Comparing the two files
   Success: Files are identical.
Killing tiny and proxy
basicScore: 40/40

*** Concurrency ***
Starting tiny on port 2104
Starting proxy on port 16490
Starting the blocking NOP server on port 26940
Trying to fetch a file from the blocking nop-server
Fetching ./tiny/home.html into ./.noproxy directly from Tiny
Fetching ./tiny/home.html into ./.proxy using the proxy
Checking whether the proxy fetch succeeded
Success: Was able to fetch tiny/home.html from the proxy.
Killing tiny, proxy, and nop-server
concurrencyScore: 15/15

*** Cache ***
Starting tiny on port 10359
Starting proxy on port 32380
Fetching ./tiny/tiny.c into ./.proxy using the proxy
Fetching ./tiny/home.html into ./.proxy using the proxy
Fetching ./tiny/csapp.c into ./.proxy using the proxy
Killing tiny
Fetching a cached copy of ./tiny/home.html into ./.noproxy
Failure: Was not able to fetch tiny/home.html from the proxy cache.
Killing proxy
cacheScore: 0/15

totalScore: 55/70

Part III: Caching web objects

​ 最近太忙啦，所以这个第三部分就暂时先不写了，日后如果涉及到网络编程的时候再来重构一下代码~