HTTP服务器

图片来源于网络，侵删。

前言

实现一个http 服务器项目，服务器启动后监听80端口的tcp 连接，当用户通过任意一款浏览器（IE、火狐和腾讯浏览器等）访问我们的http服务器，http服务器会查找用户访问的html页面是否存在，如果存在则通过http 协议响应客户端的请求，把页面返回给浏览器，浏览器显示html页面；如果页面不存在，则通知浏览器此页面不存在（404 NOT FOUND）

什么是HTML

全称Hypertext Markup Language，也就是"超文本链接标示语言"。

HTML文本是由HTML命令组成的描述性文本。

HTTP协议

HTTP协议是Hyper Text Transfer Protocol(超文本传输协议)的缩写,是用于从万维网(WWW:World Wide Web ) 服务器传输超文本到本地浏览器的传送协议。

客户端发起请求

客户端发送一个HTTP请求到服务器的请求消息包括以下格式：请求行（request line）、请求头部（header）、空行和请求数据四个部分组成，下图给出了请求报文的一般格式。

示例:

GET /demo.html HTTP/1.1
Host: 12.120.162.171
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.26 Safari/537.36 Core/1.63.6788.400 QQBrowser/10.3.2767.400
Upgrade-Insecure-Requests: 1
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie:cna=BT0+EoVi1FACAXH3Nv5I7h6k;isg=BIOD99I03BNYvZDfE2FJUOsMB0ftUBZcBFi4E7VgYOJZdKOWPcvRinAl6kSfVG8y

服务端响应

服务器响应客户端的HTTP请求也由四个部分组成:

状态行、消息报头、空行和响应正文。

示例:

HTTP/1.0 200 OK
Server: ZYX Server
Content-Type: text/html
Connection: Close
Content-Length: 526

xxx

Mini HTTP服务器

执行流程

接收http请求——>解析http请求——>响应http请求

main.c

#include "minihttp.h"
#include <pthread.h>

int main(void) {

    int sock;
    struct sockaddr_in server_addr;
    sock = socket(AF_INET, SOCK_STREAM, 0);
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERVER_PORT);
    bind(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
    listen(sock, 128);
    printf("Wait conecting......\n");
    int done = 1;

    while (done) {
        struct sockaddr_in client;
        int client_socket;
        int len;
        char client_ip[64];
        char buf[256];

        pthread_t id;//存储线程id
        int* pclient_sock = NULL;


        socklen_t client_addr_len;
        client_addr_len = sizeof(client);
        client_socket = accept(sock, (struct sockaddr*)&client, &client_addr_len);
        printf("client address:%s\tport:%d\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, client_ip, sizeof(client_ip)), ntohs(client.sin_port));

        //处理Http请求，读取客户端发来的数据
        //do_http_request(client_socket);
        
        //启动线程，处理HTTP请求
        
        pclient_sock = (int*)malloc(sizeof(int));
        *pclient_sock = client_socket;
        pthread_create(&id,NULL,do_http_request,(void*)pclient_sock);
    }

    close(sock);

    return 0;
}

minihttp.h

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/stat.h>


#define SERVER_PORT 80 //端口

static int debug = 1;


//处理请求的每行数据
//返回值:-1读取出错，=0表示读到空行，>0表示成功读取。
int get_line(int sock, char* buf, int size);

//读取客户端发来的http请求
void* do_http_request(void* client_sock);
                                                            
//根据请求返回内容
void do_http_response(int client_sock, const char* path);

//响应404
void not_found(int client_sock);                

//返回请求头
int headers(int client_sock,FILE* resource); 

//发送html文件中的内容
void cat(int client_sock,FILE* resource);    

//服务器内部错误500
void iner_error(int client_sock);     

//响应未定义的请求
void unimplemented(int client_sock);    

minihttp.c

#include "minihttp.h"

int get_line(int sock, char* buf, int size) {

    int count = 0;
    char ch = '\0';
    int len = 0;

    while ((count < size - 1) && ch != '\n') {
        len = read(sock,&ch,1);

        if (len == 1) {
            if (ch == '\r') {
                continue;
            } else if (ch == '\n') {
                
                break;//读取完毕
            }

            //这里处理一般的字符
            buf[count] = ch;
            count++;
        } else if(len == -1){//读取出错
            perror("read failed!");
            count = -1;
            break;
        } else {//返回0——客户端关闭socket链接
            fprintf(stderr,"clinet close\n");
            count = -1;
            break;
        }
    }
    if (count >= 0) {
        buf[count] = '\0';//添加字符串结束符
    }

    return count;
}


void* do_http_request(void* pclient_sock){
    
    int len = 0;
    char buf[256];
    char method[64];
    char url[256];
    char path[256];

    int client_sock = *(int*)pclient_sock;

    struct  stat st;
    //读取请求行 
    
    len = get_line(client_sock, buf, sizeof(buf));

    if (len > 0) {//读到了请求行数(第一行)
        int i = 0;
        int j = 0;

        while (!isspace(buf[j]) && i <sizeof(method)-1) {
            method[i] = buf[j];
            i++;
            j++;
        }

        method[i] = '\0';
        printf("request method:%s\n",method);


        if (strncasecmp(method, "GET", i) == 0) {//只处理get请求
            if (debug) {
                printf("method = GET\n");
            }

            //获取url
            while (isspace(buf[j++])) {//跳过空格
                i = 0;
            }

            while (!isspace(buf[j]) && i < sizeof(url) - 1) {
                url[i] = buf[j];
                i++;
                j++;
            }

            url[i] = '\0';

            if (debug) {
                printf("url:%s\n", url);
            }
            //继续读取http头部
            do 
            {
                len = get_line(client_sock, buf, sizeof(buf));
                if(debug){
                    printf("read:%s\n",buf);
                }
            } while (len>0);

            //定位服务器本地的html文件
            

            //处理url中的？，过滤掉？后面的内容
            {
                char* pos = strchr(url, '?');
                if (pos) {
                    *pos = '\0';
                    printf("real url:%s\n",url);
                }
            }

            sprintf(path,"./html_docs/%s",url);

            if (debug) {
                printf("path:%s\n", path);
            } 

            //get请求服务端回复
            //判断文件是否存在，如果存在就相应200 OK，同时发送相应的html文件
            //如果不存在就相应404 not found 
            
            if (stat(path, &st) == -1) {//文件不存在或者出错
                fprintf(stderr,"stat %s failed,reason:%s\n",path,strerror(errno));
                not_found(client_sock);
            } else {//文件存在

                if (S_ISDIR(st.st_mode)) {//如果是目录,添加默认网页
                    strcat(path,"/index.html");
                }

    
                do_http_response(client_sock,path);
            }


        } else {//非get请求，读取http头部，并相应客户端501
            fprintf(stderr,"warning! other rquest [%s]\n",method);
            do 
            {
                len = get_line(client_sock, buf, sizeof(buf));
            } while (len>0);
            
            unimplemented(client_sock);
        }
    } else {//请求格式有问题，出错处理。

        not_found(client_sock);
    }

    close(client_sock);

    if (pclient_sock) {
        free(pclient_sock);
    }

    return NULL;
}


void do_http_response(int client_sock, const char* path) {

    int ret = 0;

    FILE *resource = NULL;

    resource = fopen(path,"r");

    if (resource == NULL) {
        not_found(client_sock);
        return;
    }


    //发送http头部
    ret = headers(client_sock, resource);

    if (!ret) {
        //成功发送头部后
        //发送http body
        cat(client_sock, resource);
    }

    fclose(resource);
}

void not_found(int client_sock){
    const char* reply = "HTTP/1.0 404 NOT FOUND\r\n\
        Content - Type: text / html\r\n\
        \r\n\
        <HTML>\r\n\
        <HEAD>\r\n\
        <TITLE>NOT FOUND</TITLE>\r\n\
        </HEAD>\r\n\
        <BODY>\r\n\
        <P>The server could not fulfill your request because the resource specified is unavailable or nonexistent.\r\n\
        </BODY>\r\n\
        </HTML>\r\n";
    
    int len = write(client_sock,reply,strlen(reply));
    
    if (len <= 0) {
        fprintf(stderr,"send reply failed,reason:%s\n",strerror(errno));
    }

    //if (debug) {
    //    fprintf(stdout,reply);
    //}
}

int headers(int client_sock, FILE* resource) {

    struct stat st;

    int fileid = 0;

    char tmp[128];

    char buf[1024] = { 0 };

    strcpy(buf, "HTTP/1.0 200 OK\r\n");
    strcat(buf, "Server: XUANXUAN Server\r\n");
    strcat(buf, "Content-Type:text/html\r\n");
    strcat(buf, "Connection: Close\r\n");

    fileid = fileno(resource);                        //拿到文件fd——文件描述符

    if (fstat(fileid, &st) == -1) {
        iner_error(client_sock);
        return -1;//失败
    }

    sprintf(tmp, "Content-Length:%ld\r\n\r\n", st.st_size);
    strcat(buf, tmp);

    if (debug) {
        fprintf(stdout, "header:%s\n", buf);
    }

    if (send(client_sock, buf, strlen(buf), 0) < 0) {//如果发送失败
        fprintf(stderr, "send failed.data:%s,reason:%s\n", buf, strerror(errno));
        return -1;
    }

    return 0;
}

void cat(int client_sock, FILE* resource) {

    char buf[1024];
    fgets(buf,sizeof(buf),resource);

    //没有到达文件尾部就一直读
    while (!feof(resource)) {
        int len = write(client_sock, buf, strlen(buf));

        if (len < 0) {//发送body的过程中出现问题
            fprintf(stderr,"send body error. reason:%s\n",strerror(errno));
            break;
        }

        if (debug) {
            fprintf(stdout,"%s",buf);
        }

        fgets(buf, sizeof(buf), resource);
    }

}

void iner_error(int client_sock) {
    const char* reply = "HTTP/1.0 500 Internal Sever Error\r\n\
        Content - Type: text / html\r\n\
        \r\n\
        <HTML>\
        <HEAD>\
        <TITLE>inner_error</TITLE>\
        </HEAD>\
        <BODY>\
        <P>Error prohibited CGI execution.\
        </BODY>\
        </HTML>";

    int len = write(client_sock, reply, strlen(reply));

    if (len <= 0) {
        fprintf(stderr, "send reply failed,reason:%s\n", strerror(errno));
    }

    /*if (debug) {
        fprintf(stdout, reply);
    }*/
}

void unimplemented(int client_sock) {
    const char* reply = "HTTP/1.0 404 NOT FOUND\r\n\
        Content - Type: text / html\r\n\
        \r\n\
        <HTML>\r\n\
        <HEAD>\r\n\
        <TITLE>NO Implemented</TITLE>\r\n\
        </HEAD>\r\n\
        <BODY>\r\n\
        <P>The server could not fulfill your request because the resource specified is unavailable or nonexistent.\r\n\
        </BODY>\r\n\
        </HTML>\r\n";

    int len = write(client_sock, reply, strlen(reply));

    if (len <= 0) {
        fprintf(stderr, "send reply failed,reason:%s\n", strerror(errno));
    }
}

并发

什么是并发?

通俗的并发通常是指同时能并行的处理多个任务。

程序同时拥有两个或多个线程，如果程序在单核处理器上运行，多个线程将交替的换入或者换出内存，这些线程是同时"存在"的。同一时间点上，只能有一个线程执行。

每个线程都处于执行中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器核上，因此可以同时运行。

高并发

高并发是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够 同时并行处理很多请求。

注意:

编译时记得加声明 -pthread

gcc minihttp.c main.c -pthread -o minihttp

连不上记得使用root用户执行。