《深入理解计算机系统》Tiny Web服务器实验

最新推荐文章于 2024-08-01 22:38:04 发布
最新推荐文章于 2024-08-01 22:38:04 发布
阅读量3.2k 收藏 10
点赞数 1
分类专栏： C/C++ 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshijidutu/article/details/50589911
版权 
#include "csapp.h"
/*
 *说明:在用telnet时,Host头域指定请求资源的Intenet主机和端口号
 * 必须表示请求url的原始服务器或网关的位置。
 * HTTP/1.1请求必须包含主机头域，否则系统会以400状态码返回。
 */

void handler(int sig);
void doit(int fd);
void read_requesthdrs(rio_t *rp, int *length, int is_post_method);
int parse_uri(char *uri, char *filename, char *cgiargs);
void serve_static(int fd, char *filename, int filesize, int is_head_method);
void get_filetype(char *filename, char *filetype);
void serve_dynamic(int fd, char *filename, char *cgiargs, int is_head_method);
void post_dynamic(int fd, char *filename, int contentLength,rio_t *rp);
void clienterror(int fd, char *cause, char *errnum, char *shortmsg, char *longmsg);

int main(int argc, char **argv, char **environ)
{
    int listenfd, connfd, port, clientlen;
    struct sockaddr_in clientaddr;

    /* 检查命令行参数 */
    if (argc != 2) {
        fprintf(stderr, "usage: %s <port>\n", argv[0]);
        exit(0);
    }
    port = atoi(argv[1]);

    listenfd = Open_listenfd(port);
    printf("Tiny Web Server...\n");
    while (1) {
        clientlen = sizeof(clientaddr);
        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
	
	Signal(SIGCHLD, handler);	

	/* fork子进程处理请求 */
	if (Fork() == 0) {
	    Close(listenfd);  /* 关闭监听描述符 */
	    doit(connfd);     
            Close(connfd);    /* 关闭已连接描述符 */
	    exit(0);
	}
	Close(connfd);   /* 父进程关闭已连接描述符,此时文件表项的引用计数为0,到客户端的连接终止 */
        
    }
    exit(0);
}


void handler(int sig)
{
    pid_t pid;

    if ((pid = waitpid(-1, NULL, 0)) < 0)
        unix_error("waitpid error");
    //printf("Handler reaped child %d\n", (int)pid);
    return;
}


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

    Rio_readinitb(&rio, fd); /* 初始化缓冲区 */
    Rio_readlineb(&rio, buf, MAXLINE); /* 将缓冲区内的请求行(一行)内容读到buf里 */

    /* 读请求行 */
    sscanf(buf, "%s %s %s", method, uri, version);
    printf("%s %s %s\r\n", method, uri, version);                  //11.6题扩展A

    if (!strcasecmp(method, "HEAD")) {
        head = 1;
    }
    else if (!strcasecmp(method, "POST")) {   /* 忽略大小写比较字符串 */
        post = 1;

    }
    else if (!strcasecmp(method, "GET"));
    else {
        clienterror(fd, method, "501", "Not Implemented", "Tiny does not implement this method");
        return;
    }

    read_requesthdrs(&rio, &contentLength, post);   /* 读取并忽略请求报头 */

    /* 解析来自GET请求的URI */
    is_static = parse_uri(uri, filename, cgiargs);   /* is_static判断请求的文件是否为静态文件 */
    if (stat(filename, &sbuf) < 0) {
        clienterror(fd, filename, "404", "Not found", "Tiny couldn't read the file");
        return;
    }

    if (is_static) {
        if (!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode)) {
            clienterror(fd, filename, "403", "Forbidden", "Tiny couldn't read the file");
            return;
        }
        //printf("yes\n");
        serve_static(fd, filename, sbuf.st_size, head);    /* 处理静态内容 */
    }
    else {
        if (!(S_ISREG(sbuf.st_mode)) || !(S_IXUSR & sbuf.st_mode)) {
            clienterror(fd, filename, "403", "Forbidden", "Tiny couldn't run the CGI program");
            return;
        }
        if (!post)
            serve_dynamic(fd, filename, cgiargs, head);       /* 处理动态内容 */
        else
            post_dynamic(fd, filename, contentLength, &rio);
    }
}


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

    /* 生成HTTP响应主体 */
    sprintf(body, "<html><head><meta charset='UTF-8'><title>Tiny Error</title></head>");
    sprintf(body, "%s<body bgcolor='#ffffff'>\r\n", body);
    sprintf(body, "%s<h2>%s: %s</h2>\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></body></html>\r\n", body);  /* <hr>标签是水平分割线 */

    /* 打印HTTP响应 */
    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, int *length, int is_post_method) {
    char buf[MAXLINE];
    char *p;

    Rio_readlineb(rp, buf, MAXLINE);
    while (strcmp(buf, "\r\n")) {    /* 如果读到\r\n则结束循环,因为请求头以单独的\r\n一行结束 */
        Rio_readlineb(rp, buf, MAXLINE);
        if (is_post_method){
            if(strncasecmp(buf,"Content-Length:",15)==0) {
                p=&buf[15];
                p+=strspn(p," \t");
                *length=atol(p);
            }
        }
        printf("%s", buf);
        //printf("%d", *length);
    }
    //Rio_readlineb(rp, buf, MAXLINE);
    //Rio_readlineb(rp, buf, MAXLINE);

    return;
}


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

    /* 如果不是请求动态文件  */
    if (!strstr(uri, "cgi-bin")) {
        strcpy(cgiargs, "");
        strcpy(filename, ".");
        strcat(filename, uri);   /* 将filename和uri连接起来,结果保存在filename里,即将uri转化为相对路径 */
        if (uri[strlen(uri)-1] == '/')
            strcat(filename, "index.html");  /* 如果uri以"/"结尾,把默认的文件名加载后面 */
        return 1;
    }
    else {
        ptr = index(uri, '?');
        if (ptr) {
            strcpy(cgiargs, ptr+1); /* 抽取出参数 */
            *ptr = '\0';
        }
        else {
            strcpy(cgiargs, "");
        }
        strcpy(filename, ".");
        strcat(filename, uri); /* 将uri转化为相对路径 */
        return 0;
    }
}


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

    /* 发送响应报头给客户端 */
    get_filetype(filename, filetype);
    sprintf(buf, "HTTP/1.0 200 OK\r\n");
    sprintf(buf, "%sServer: Tiny Web Server\r\n",  buf);
    sprintf(buf, "%sContent-length: %d\r\n", buf, filesize);
    sprintf(buf, "%sContent-type: %s\r\n\r\n", buf, filetype);
    //int fd2;                                                     11.6题扩展B
    //fd2 = Open("test.txt", O_WRONLY, 0);                         11.6题扩展B
    Rio_writen(fd, buf, strlen(buf));
    //Rio_writen(fd2, buf, strlen(buf));                           11.6题扩展B
    /* 发送响应主体给客户端 */
    if (is_head_method)
        return;

    srcfd = Open(filename, O_RDONLY, 0);
    srcp = Mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0);
    Close(srcfd);  /* 分配了虚拟地址空间就不需要read/write了,也就不需要文件描述符 */

    //srcp = (char *)Malloc(filesize * sizeof(char));              11.9题
    //Rio_readn(srcfd, srcp, filesize);                            11.9题
    Rio_writen(fd, srcp, filesize);
    //free(srcp);                                                  11.9题

    //Rio_writen(fd2, srcp, filesize);                             11.6题扩展B
    Munmap(srcp, filesize);
}


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, ".jpg") || strstr(filename, ".jpeg"))
        strcpy(filetype,  "image/jpeg");
    else if (strstr(filename, ".mpg"))                        //11.6题扩展C
        strcpy(filetype, "video/mpg");
    else
        strcpy(filetype, "text/plain");
}


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

    /* 打印一部分HTTP响应信息 */
    sprintf(buf, "HTTP/1.0 200 OK\r\n");
    sprintf(buf, "%sServer: Tiny Web Server\r\n",  buf);
    Rio_writen(fd, buf, strlen(buf));

    if (is_head_method)
        return;

    Signal(SIGCHLD, handler);

    if (Fork() == 0) {
        setenv("QUERY_STRING", cgiargs, 1);  /* 只对当前进程有效 */
        Dup2(fd, STDOUT_FILENO);
        Execve(filename, emptylist, environ);

    }
    //Wait(NULL);  /* 父进程监听子进程 */
}

/* 解决CGI读取POST参数的关键在于这个stdin该指向哪里呢,
 * 首先Dup2(fd, 0)是错的,CGI程序不可能从套接字流中读取,
 * 因为已经全部保存在rio缓冲区了,所以只能从缓冲区读取
 * 剩下的请求主体,而CGI程序如何和原来的进程联系从而获
 * 得请求主体呢?答案就是管道,利用dup2函数将标准输入流
 * 重定向到管道的读端,而缓冲区的数据则写到管道写端.花
 * 了我好长时间理解 
 */

void post_dynamic(int fd, char *filename, int contentLength,rio_t *rp)
{
    char buf[MAXLINE], data[MAXLINE], length[32], *emptylist[] = {NULL};
    int pipe_fd[2];

    sprintf(length,"%d",contentLength);
    memset(data,0,MAXLINE);

    Signal(SIGCHLD, handler);

     /* 创建管道 */
    if (pipe(pipe_fd) < 0) {
        perror("pipe failed\n");
        exit(errno);
    }

    if (Fork() == 0) {   /* 创建子进程 */
        Close(pipe_fd[0]);  /* 关闭管道读端 */
        Rio_readnb(rp, data, contentLength);  /* 从缓冲区中读取数据,此时缓冲区的内容中请求头已经
                                               * 被read_requesthdrs函数读掉了,剩下的是请求主体内容
                                               * 但是不要使用Rio_readlineb,因为这个函数一次只能一行
                                               * 用Rio_readnb读取全部请求主体
                                               */
        Rio_writen(pipe_fd[1], data, contentLength); /* 将数据写进管道 */
        exit(0); /* 第一个子进程完成任务,退出 */
    }
    else {
        /* 打印一部分HTTP响应信息 */
        sprintf(buf, "HTTP/1.0 200 OK\r\n");
        sprintf(buf, "%sServer: Tiny Web Server\r\n",  buf);
        Rio_writen(fd, buf, strlen(buf));

        if (Fork() == 0) {
            Close(pipe_fd[1]);   /* 子进程关闭管道写端 */
            Dup2(pipe_fd[0], STDIN_FILENO); /* 让子进程不再从标准输入读取,而是从管道读取 */
            Close(pipe_fd[0]);  /* 关闭管道读端 */
            setenv("CONTENT_LENGTH", length, 1);
            Dup2(fd, STDOUT_FILENO); /* 重定向标准输出到客户端,让输出指向已连接的描述符 */
            Execve(filename, emptylist, environ);
        }
        else {
            /* 父进程关闭读端和写端 */
            close(pipe_fd[0]);
            close(pipe_fd[1]);
        }
    }

}


cgi-bin目录下的adder.c

#include "csapp.h"

int main(void)
{
    char *buf, *query, *env, *p1, *p2, *p3;
    char arg1[MAXLINE], arg2[MAXLINE], content[MAXLINE], postdata[MAXLINE], *lenstr;
    int n1=0, n2=0;
    long len=0;

    /* 提取两个参数  */
    query = getenv("QUERY_STRING");
    if (query == NULL) {
        if ((lenstr = getenv("CONTENT_LENGTH")) != NULL)
            len = atol(lenstr);
        fgets(postdata, len+1, stdin);
        buf = postdata;
    }
    else
        buf = query;

    p1 = strchr(buf, '&');
    *p1 = '\0';

    /* 提取第一个参数 */
    p2 = strchr(buf, '=');
    *p2 = '\0';
    strcpy(arg1, p2+1);

    /* 提取第二个参数 */
    p3 = strchr(p1+1, '=');
    *p3 = '\0';
    strcpy(arg2, p3+1);

    n1 = atoi(arg1);
    n2 = atoi(arg2);

     /* 生成响应主体 */
    sprintf(content, "%sTHE Internet addition portal,\r\n<p>", content);
    sprintf(content, "%sThe answer is: %d + %d = %d</p>\r\n<p>",
                        content, n1, n2, n1+n2);
    sprintf(content, "%sThanks for visiting!</p>\r\n", content);

    /* 生成HTTP响应 */
    printf("Content-length: %d\r\n", (int)strlen(content));
    printf("Content-type: text/html\r\n\r\n");
    printf("%s", content);
    fflush(stdout);
    exit(0);

}

github链接:  《深入理解计算机系统》网络编程课后习题


tenacity-go
关注
专栏目录
TinyWeb:深入理解计算机系统上的轻量级web代码
06-18
《TinyWeb：深入理解计算机系统上的轻量级Web代码》 在计算机科学中，Web开发是不可或缺的一部分，而TinyWeb项目则提供了一个深入了解Web服务器工作原理的绝佳平台。TinyWeb是一个用C语言编写的轻量级Web服务器，它...
CSAPP①：TingWeb
一只老风铃
10-23 230
主函数： 不断的监听8080端口，一旦accept到连接请求，变建立connect fd用于通信： int main() { int listenfd,connfd; listenfd=create_server(IP,8080); while(1) { struct sockaddr_in addr; int len= sizeof(addr); connfd=accept(listenfd, (
深入理解计算机系统（CSAPP）中TINY Web服务器搭建运行
weixin_42523686的博客
08-19 1823
搭建环境 在电脑(Windows)上下载虚拟机程序，安装ubuntu，具体教程网上一搜就有，这里不再细讲 程序编译运行 程序下载 CSAPP的代码位于http://csapp.cs.cmu.edu/public/code.html，在这里面找到tiny.c、csapp.h、csapp.c和adder.c 可以直接在Ubuntu里的火狐浏览器里输入网址下载，或者在Windows里下载好，通过虚拟机共享文件夹拷贝过去 程序文件夹 在Ubuntu中新建一个空文件夹TINY_Test，在其内部新建空文件夹cgi-
TinyWebSever代码解析(一）：初始化，进程通信部分
最新发布
SSuperwoman的博客
08-01 977
这段代码定义了 WebServer 类中的 eventListen 方法，用于初始化网络编程所需的基本步骤，包括创建监听 socket，设置 socket 选项，绑定地址，开始监听，以及配置 epoll 和信号处理等。这两行代码的目的是将 m_pipefd 和 m_epollfd 的值赋给 Utils 类的静态成员变量 u_pipefd 和 u_epollfd。socket() 函数的参数共同决定了创建的套接字的类型和行为，包括使用的地址族（协议族）、套接字的类型（面向连接或无连接）以及使用的具体协议。
轻量级web并发服务器——TinyWebServer的学习了解
热门推荐
qq_44184756的博客
05-31 1万+
tinyweb是Linux下C++轻量级web服务器，适合新手入门快速实践网络编程，本文旨在结合项目开发者社长（微信公众号：两猿社）的文章以及网上查询的一些资料对该项目的结构和原理等方面进行进一步的理解和掌握
TinyWebServer
weixin_45045804的博客
10-24 3448
tinywebserver
探索TinyWebServer：一个轻量级、高效的Web服务器
gitblog_00089的博客
03-14 1004
TinyWebServer: 构建轻量级、可扩展的网络服务器 TinyWebServerSmall web server for Arduino, fits in 10KB ROM, less than 512 bytes RAM项目地址:https://gitcode.com/gh_mirrors/tin/TinyWebServer TinyWebServer 是一个轻量级且高度可扩展的网络服...
<<深入理解计算机系统>>之构建tinyweb源码
11-14
《深入理解计算机系统》是一本经典的计算机科学教材，它涵盖了计算机系统的多个层面，从硬件到软件，从操作系统到网络通信。在这个项目中，我们将聚焦于其中的一个实践环节——构建并运行一个微型Web服务器：Tinyweb...
csapp-exercise:《深入理解计算机系统》课后习题
03-11
《深入理解计算机系统》(CS:APP) 是一本经典的计算机科学教材，主要涵盖了计算机系统的基础知识，包括处理器、内存、I/O系统、操作系统、网络以及编程语言等核心主题。课后习题是学习这本书的重要组成部分，它们旨在...
linux下tinyweb服务器
10-21
Linux下的TinyWeb服务器是一款轻量级的Web服务器，主要用于教学和学习目的，特别是与《计算机系统：概念与编程》(Computer Systems: A Programmer's Perspective，简称CSAPP)这本书的实践部分相结合。TinyWeb的设计...
Tiny_web_server(小型web服务器代码)
03-17
该服务器的实现是基于《计算机系统概论》（Computer Systems: A Programmer's Perspective，简称CSAPP）中的代码，并进行了改进，使其支持OpenMP和Pthread两种多线程库，可以根据需要轻松切换到单线程模式。...
TinyWebServer1--log
zhaojiazb的博客
05-29 917
哇咔咔 终于到第一个项目了。
【C++项目】Tiny Linux WebServer---开篇介绍
haojz
03-28 4428
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言Webserver 介绍Webserver基础架构Webserver详细技术总结 前言 【C++后端开发项目入门：TinywebServer】：一个简易轻型的webserver服务器，对于C++后台开发方向作为起始项目是一个不错的选择。关于webserver的c++实现网络上存在许许多多的资料，github也有许多开源的项目。 本系列文章将参考社长大大的TinyWebServer以及牛客网公布的开放课程Linux 高并发服务.
c++服务器开源项目Tinywebserver运行
weixin_44842318的博客
02-22 2917
C++服务器开源项目Tinywebserver运行
web实验超详细步骤
qq_56628318的博客
05-31 2240
web网页详细制作
CSAPP-Tiny Web服务器【1】编译搭建
weixin_30318645的博客
05-04 226
Tiny，一个有趣的程序，短短数百行代码，结合了诸如：进程控制、UnixI/O、Socket编程和HTTP等思想，虽然缺乏实际服务器的功能性、健壮性和安全性，但是它足够用来为实际Web服务器提供静态和动态内容。 ​此文代码来源于《深入理解计算机系统·第二版》11.6节的综合：TINYWeb服务器。 书上只给了源代码但是没给搭建的步骤，想要理解道理需要先有感性的认识，所以先把服务器...
【C++项目】Tiny Linux WebServer---webserver架构分析与介绍
haojz
03-30 2275
文章目录前言事务处理模式 Reactor 、 ProactorReactor模式Proactor同步I/O模拟Proactor模式基本架构模块介绍总结 前言 在进行linux网络编程之前，我们需要来了解整个项目的流程。 事务处理模式 Reactor 、 Proactor 在webserver服务器中，针对常见的三类事务：I/O事务、信号定时事件、逻辑事务。对于事务的处理模式，有两种高效的方式： Reactor和Proactor模式。其中同步I/O通常用于实现Reactor模式，异步I/O模型通常用于实现P
TinyWebServer大纲
chenmi123321的博客
10-26 859
webserver
《深入理解计算机系统》实验四Architecture Lab
达的程序员日记
12-13 6429
《深入理解计算机系统》实验四Architecture Lab(满分)
嵌入式系统中的通用嵌入式Web服务器设计与实现
本文主要探讨了嵌入式系统与ARM技术中通用嵌入式Web服务器模块的设计与实现，强调了嵌入式Internet技术在多个领域的广泛应用，并介绍了基于嵌入式Web服务器的控制系统的设计思路。 在互联网技术日新月异的今天，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值