第十一章 网络编程

struct in_addr  
{  
    uint32_t s_addr;  /* Address in network byte order(big-endian) */  
};  

#include <arpa/inet.h>  
// 把主机上的数据按照网络字节顺序返回  
uint32_t htonl(uint32_t hostlong);  
uint16_t htons(uint16_t hostshort);  
// 把网络上的数据按照主机字节顺序返回  
uint32_t ntohl(uint32_t netlong);  
uint16_t ntohs(uint16_t netshort);  

linux> hostname -i  
127.0.1.1  

#include <arpa/inet.h>  
// AF_NET表示32位的IPv4地址，若使用AF_INET6则表示128位的IPv6地址  
// 将点分十进制串src转换为二进制的网络字节顺序的IP地址dst  
// 若成功则返回1，若src为非法点分十进制地址则返回0，出错时返回-1  
int inet_pton(AF_INET, const char *src, void *dst);  
// 将二进制的网络字节顺序的IP地址src转换为对应的点分十进制表示  
// 并把得到的以null结尾的字符串最多size字节复制到dst中  
// 若成功则返回指向点分十进制字符串的指针，出错则返回NULL  
const char *inet_ntop(AF_INET, const void *src, char *dst, socklen_t size);  

(cliaddr:cliport, servaddr:servport)  

/* IP socket address structure */  
struct sockaddr_in  
{  
    uint16_t sin_family;       // Protocol family (always AF_INET)  
    uint16_t sin_port;         // Port number in network byte order  
    struct in_addr sin_addr;   // IP address in network byte order  
    unsigned char sin_zero[8]; // Pad to sizeof(struct sockaddr)  
};  
/* Generic socket address structure (for connect, bind and accept) */  
struct sockaddr  
{  
    uint16_t sa_family;  // Protocol family  
    char sa_data[14];    // Address data  
};  

#include <sys/types.h>  
#include <sys/socket.h>  
// 成功时返回非负描述符，出错返回-1  
int socket(int domain, int type, int protocol);  
// 使用硬编码使套接字成为连接的一个端点  
clientfd = Socket(AF_INET, SOCK_STREAM, 0);  

#include <sys/socket.h>  
// 成功时返回0，出错返回-1  
int connect(int clientfd, const struct sockaddr *addr, socklen_t addrlen);  

#include <sys/socket.h>  
// 成功返回0，出错返回-1  
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);  

#include <sys/socket.h>  
// 成功返回0，出错返回-1  
int listen(int sockfd, int backlog);  

#include <sys/socket.h>  
// 成功时返回非负连接描述符，出错返回-1  
int accept(int listenfd, struct sockaddr *addr, int *addrlen);  

#include <sys/types.h>  
#include <sys/socket.h>  
#include <netdb.h>  
// 成功时返回0， 错误时返回非0错误码  
// host参数可以是域名或点分十进制IP地址  
// service可以是服务名(如http)，或十进制端口号  
// host和service中必须指定两者中的一个  
// hints是一个addrinfo结构，实际中用memset将结构清零，然后设置一些字段  
// 默认最多返回三个addrinfo结构，每个ai_socktype字段不同：连接/数据报/原始套接字  
// hints的ai_flags设置AI_PASSIVE时说明套接字地址用作监听套接字，此时host参数应该为NUNLL  
// hints的ai_flags(位掩码)设置AI_ADDRCONFIG是使用连接推荐使用的标志  
int getaddrinfo(const char *host, const char *service,   
        const struct addrinfo *hints, struct addrinfo **result);  
void freeaddrinfo(struct addrinfo *result);  
// 返回错误码对应的错误消息  
const char *gai_strerror(int errcode);  

// getaddrinfo创建输出列表中的addrinfo结构时会填写除ai_flags外的每个字段  
// addrinfo中的字段是不透明的，可以直接传递给套接字接口中的函数，应用程序代码无需再做任何处理  
struct addrinfo  
{  
    int ai_flags;      // Hints argument flags  
    int ai_family;     // First arg to socket function  
    int ai_socktype;   // Second arg to socket function  
    int ai_protocol;   // Third arg to socket function  
    char *ai_canonname;// Canonical hostname  
    size_t ai_addrlen; // Size of ai_addr struct  
    struct sockaddr *ai_addr; // Ptr to socket address structure  
    struct addrinfo *ai_next; // Ptr to next item in linked list  
};  

#include <sys/socket.h>  
#include <netdb.h>  
// 成功时返回0，错误时返回非零的错误代码  
// sa指向大小为salen字节的套接字地址结构  
// host指向大小为hostlen字节的缓冲区  
// service指向大小为servlen字节的缓冲区，host和service至少设置其中之一不为NULL  
int getnameinfo(const struct sockaddr *sa, socklen_t salen,  
        char *host, size_t hostlen, char *service, size_t servlen, int flags);  

// 客户端与运行在hostname主机port端口上的服务器建立连接  
// 返回一个打开的套接字描述符，该描述符可以用Unix I/O函数做输入输出  
int open_clientfd(char *hostname, char *port)  
{  
    int clientfd;  
    struct addrinfo hints, *listp, *p;  

    /* Get a list of potential server addresses */  
    memset(&hints, 0, sizeof(struct addrinfo));  
    hints.ai_socktype = SOCK_STREAM;   /* Open a connection */  
    hints.ai_flags = AI_NUMERICSERV;   /* ... using a numeric port arg. */  
    hints.ai_flags |= AI_ADDRCONFIG;   /* Recommended for connections */  
    Getaddrinfo(hostname, port, &hints, &listp);  

    /* Walk the list for one that we can successfully connect to */  
    for(p = listp; p; p = p->ai_next)  
    {  
        /* Create a socket descriptor */  
        if((clientfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0)  
            continue;    /* Socket failed, try the next */  
        if(connect(clientfd, p->ai_addr, p->ai_addrlen) != -1)  
            break;  /* Success */  
        Close(clientfd);   /* Connect failed, try another */          
    }  

    /* Clean up*/  
    Freeaddrinfo(listp);  
    if(!p)   /* All connects failed */  
        return -1;  
    else     /* The last connect succeeded */  
        return clientfd;  
}  

// 打开和返回一个监听描述符，这个描述符准备好在端口port上接收连接请求  
int open_listenfd(char *port)  
{  
    struct addrinfo hints, *listp, *p;  
    int listenfd, optval = 1;  

    /* Get a list of potential server addresses */  
    memset(&hints, 0, sizeof(struct addrinfo));  
    hints.ai_socktype = SOCK_STREAM;             /* Accept connections */  
    hints.ai_flags = AI_PASSIVE | AI_ADDRCONFIG; /* ... on any IP address */  
    hints.ai_flags |= AI_NUMERICSERV;            /* ... using port number */  
    Getaddrinfo(NULL, port, &hints, &listp);  

    /* Walk the list for one that we can bind to */  
    for(p = listp; p; p = p->ai_next)  
    {  
        /* Create a socket descriptor */  
        if((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0)  
            continue;   /*  Socket failed, try the next */  

        /* Eliminates "Address already in use" error from bind */  
        Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *)&optval, sizeof(int));  

        /* Bind the descriptor to the address */  
        if(bind(listenfd, p->ai_addr, p->ai_addrlen) == 0)  
            break;  /* Success */  
        Close(listenfd);  /* Bind failed, try the next */  
    }  

    /* Clean up */  
    Freeaddrinfo(listp);  
    if(!p)  /* No address worked */  
        return -1;  

    /* Make it a listening socket ready to accept connection requests */  
    if(listen(listenfd,, LISTENQ) < 0)  
    {  
        Close(listenfd);  
        return -1;  
    }  
    return listenfd;  
}  

method URI version  

version status-code status-message  

/*  
 * tiny.c - A simple, iterative HTTP/1.0 Web server that uses the  
 *     GET method to serve static and dynamic content  
 */  
#include "csapp.h"  

void doit(int fd);  
void clienterror(int fd, char *cause, char *errnum, char *shortmsg, char *longmsg);  
void read_requesthdrs(rio_t *rp);  
int parse_uri(char *uri, char *filename, char *cgiargs);  
void serve_static(int fd, char *filename, int  filesize);  
void serve_dynamic(int fd, char *filename, char *cgiargs);  
void get_filetype(char *filename, char *filetype);  

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

    /* Check command-line args */  
    if(argc != 2)  
    {  
        fprintf(stderr, "usage: %s <port>\n", argv[0]);  
        exit(1);  
    }  

    listenfd = Open_listenfd(argv[1]);  
    while(1)  
    {  
        clientlen = sizeof(clientaddr);  
        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);  
        Getnameinfo((SA *)&clientaddr, clientlen, hostname, MAXLINE, port, MAXLINE, 0);  
        printf("Accept connection from (%s, %s)\n", hostname, port);  
        doit(connfd);  
        Close(connfd);  
    }  
}  

void doit(int fd)  
{  
    int is_static;  
    struct stat sbuf;  
    char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE];  
    char filename[MAXLINE], cgiargs[MAXLINE];  
    rio_t rio;  

    /* Read request line and headers */  
    Rio_readinitb(&rio, fd);  
    Rio_readlineb(&rio, buf, MAXLINE);  
    printf("Request headers:\n");  
    printf("%s", buf);  
    sscanf(buf, "%s %s %s", method, uri, version);  
    if(strcasecmp(method, "GET"))  
    {  
        clienterror(fd, method, "501", "Not implemented", "Tiny does not implement this method");  
        return;  
    }  
    read_requesthdrs(&rio);  

    /* Parse URI from GET request */  
    is_static = parse_uri(uri, filename, cgiargs);  
    if(stat(filename, &sbuf) < 0)  
    {  
        clienterror(fd, filename, "404", "Not found", "Tiny couldn't find this file");  
        return;  
    }  

    if(is_static)  /* Serve static content */  
    {  
        if(!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode))  
        {  
            clienterror(fd, filename, "403", "Forbidden", "Tiny couldn't read the file");  
            return;  
        }  
        serve_static(fd, filename, sbuf.st_size);  
    }  
    else     /* Serve dynamic content */  
    {  
        if(!(S_ISREG(sbuf.st_mode)) || !(S_IXUSR & sbuf.st_mode))  
        {  
            clienterror(fd, filename, "403", "Forbidden", "Tiny couldn't run the CGI program");  
            return;  
        }  
        serve_dynamic(fd, filename, cgiargs);  
    }  
}  

void clienterror(int fd, char *cause, char *errnum, char *shortmsg, char *longmsg)  
{  
    char buf[MAXLINE], body[MAXBUF];  

    /* Build the HTTP response body */  
    sprintf(body, "<html><title>Tiny Error</title>");  
    sprintf(body, "%s<body bgcolor=""ffffff"">\r\n", body);  
    sprintf(body, "%s%s: %s\r\n", body, errnum, shortmsg);  
    sprintf(body, "%s<p>%s: %s</p>\r\n", body, longmsg, cause);  
    sprintf(body, "%s<hr><em>The Tiny Web server</em>\r\n", body);  

    /* Print the HTTP response */  
    sprintf(buf, "HTTP/1.0 %s %s\r\n", errnum, shortmsg);  
    Rio_writen(fd, buf, strlen(buf));  
    sprintf(buf, "Content-type: text/html\r\n");  
    Rio_writen(fd, buf, strlen(buf));  
    sprintf(buf, "Content-length: %d\r\n\r\n", (int)strlen(body));  
    Rio_writen(fd, buf, strlen(buf));  
    Rio_writen(fd, body, strlen(body));  
}  

void read_requesthdrs(rio_t *rp)  
{  
    char buf[MAXLINE];  

    Rio_readlineb(rp, buf, MAXLINE);  
    while(strcmp(buf, "\r\n"))  
    {  
        Rio_readlineb(rp, buf, MAXLINE);  
        printf("%s", buf);  
    }  
    return;  
}  

int parse_uri(char *uri, char *filename, char *cgiargs)  
{  
    char *ptr;  

    if(!strstr(uri, "cgi-bin"))  
    {   /* Static content */  
        strcpy(cgiargs, "");  
        strcpy(filename, ".");  
        strcat(filename, uri);  
        if(uri[strlen(uri) - 1] == '/')  
            strcat(filename, "home.html");  
        return 1;  
    }  
    else  
    {  /* Dynamic content */  
        ptr = index(uri, '?');  
        if(ptr)  
        {  
            strcpy(cgiargs, ptr+1);  
            *ptr = '\0';  
        }  
        else  
            strcpy(cgiargs, "");  
        strcpy(filename, ".");  
        strcat(filename, uri);  
        return 0;  
    }  
}  

void serve_static(int fd, char *filename, int filesize)  
{  
    int srcfd;  
    char *srcp, filetype[MAXLINE], buf[MAXBUF];  

    /* Send response headers to client */  
    get_filetype(filename, filetype);  
    sprintf(buf, "HTTP/1.0 200 OK\r\n");  
    sprintf(buf, "%sServer: Tiny Web Servre\r\n", buf);  
    sprintf(buf, "%sConnection: close\r\n", buf);  
    sprintf(buf, "%sContent-length: %d\r\n", buf, filesize);  
    sprintf(buf, "%sContent-type: %s\r\n\r\n", buf, filetype);  
    Rio_writen(fd, buf, strlen(buf));  
    printf("Response header:\n");  
    printf("%s", buf);  

    /* Send response body to client */  
    srcfd = Open(filename, O_RDONLY, 0);  
    srcp = Mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0);  
    Close(srcfd);  
    Rio_writen(fd, srcp, filesize);  
    Munmap(srcp, filesize);  
}  

/*  
 * get_filetype - Derive file type from filename  
 */  
void get_filetype(char *filename, char *filetype)  
{  
    if(strstr(filename, ".html"))  
        strcpy(filetype, "text/html");  
    else if(strstr(filename, ".gif"))  
        strcpy(filetype, "image/gif");  
    else if(strstr(filename, ".png"))  
        strcpy(filetype, "image/png");  
    else if(strstr(filename, ".jpg"))  
        strcpy(filetype, "image/jpeg");  
    else  
        strcpy(filetype, "text/plain");  
}  

void serve_dynamic(int fd, char *filename, char *cgiargs)  
{  
    char buf[MAXLINE], *emptylist[] = {NULL};  

    /* Return first part of HTTP response */  
    sprintf(buf, "HTTP/1.0 200 OK\r\n");  
    Rio_writen(fd, buf, strlen(buf));  
    sprintf(buf, "Server: Tiny Web Server\r\n");  
    Rio_writen(fd, buf, strlen(buf));  

    if(Fork() == 0)  
    {/* Child  */  
        /* Real server would set all CGI vars here */  
        setenv("QUERY_STRING", cgiargs, 1);  
        Dup2(fd, STDOUT_FILENO);   /* Redirect stdout to client */  
        Execve(filename, emptylist, environ);   /* Run CGI program */  
    }  
    Wait(NULL);  /* Parent waits for and reaps child */  
}