Linux 项目开发 | WEB服务器开发

一、基于HTTP协议的Web服务器(WWW服务器)开发

1.HTTP请求和响应

1)HTTP请求

包头<空行>[包体]
包头：
方法  路径    协议
|     |        |
GET    /   HTTP/1.1\r\n
Host: localhost:8000\r\n
User-Agent: Mozilla/5.0\r\n
Accept: text/html\r\n
Connection: keep-alive\r\n\r\n
[包体]

2)HTTP响应

包头<空行>[包体=页面内容(HTML语言+JavaScript脚本)]
包头：
协议      响应码   响应信息(解释响应码的字符串)
 |         |        |
HTTP/1.1   200      OK\r\n
Server: Tarena WebServer 1.0\r\n
Date: Tue, 14 Jan 2020 01:39:00 GMT\r\n
Content-Type: text/html\r\n
Connection: keep-alive\r\n\r\n
[包体=页面内容(HTML语言+JavaScript脚本)]

2.基于多线程的并发服务器模型

创建流式(基于TCP协议)套接字(socket)
设置套接字选项(setsockopt)
准备地址并绑定(bind)
启动侦听(listen)
等待并接受连接请求(accept)<---+ <-连接请求- 浏览器
                            |
    创建子线程持有accept返回  |
    的连接套接字与浏览器通信----+
        接收并解析来自浏览器的HTTP请求<--+ <-浏览器
        找到浏览器请求的资源            |
        组织HTTP响应并发送给浏览器------+  ->浏览器

3.用多个功能模块组成完整的项目

mime模块：文件扩展名与内容类型映射表
mime.h
http模块：实现HTTP协议
http.h、http.c
套接字模块：实现网络通信
socket.h、socket.c
资源模块：查找文件资源
resource.h、resource.c
客户机模块：实现处理客户机业务的子线程
client.h、client.c
信号模块：初始化信号处理
signals.h、signals.c
服务器模块：实现服务器的主线程
server.h、server.c
主模块：实现main函数
main.c
构建脚本：makefile

二、源代码

1、http模块：实现HTTP协议

代码：http.h

// 声明与HTTP协议有关的数据类型和函数
#ifndef _HTTP_H
#define _HTTP_H
#include <limits.h>
#include <sys/types.h>
// HTTP请求
typedef struct tag_HttpRequest {
   
    char method[32];         // 方法
    char path[PATH_MAX + 1]; // 路径
    char protocol[32];       // 协议
    char connection[32];     // 连接
}   HTTP_REQUEST;
// 解析请求
int parseRequest(char const* req,
    HTTP_REQUEST* hreq);
// HTTP响应
typedef struct tag_HttpRespond {
   
    char  protocol[32];   // 协议
    int   status;         // 状态
    char  desc[256];      // 描述
    char  type[32];       // 类型
    off_t length;         // 长度
    char  connection[32]; // 连接
}   HTTP_RESPOND;
// 构造响应头
void constructHead(HTTP_RESPOND const* hres,
    char* head);
#endif // _HTTP_H

gcc -c http.h

代码：http.c

// 定义与HTTP协议有关的函数
#include <unistd.h>
#include <sys/syscall.h>
#include <stdio.h>
#define __USE_GNU
#include <string.h>
#include <time.h>
#include "http.h"
// 解析请求
int parseRequest(char const* req,
    HTTP_REQUEST* hreq) {
   
    /*
     * GET / HTTP/1.1\r\n
     * Host: localhost:8000\r\n
     * User-Agent: Mozilla/5.0\r\n
     * Accept: text/html\r\n
     * Connection: keep-alive\r\n\r\n
     */
    sscanf(req, "%s%s%s", hreq->method,
        hreq->path, hreq->protocol);
    char* connection = strcasestr(
        req, "connection");
    if (connection)
        sscanf(connection, "%*s%s",
            hreq->connection);
    printf("%d.%ld> [%s][%s][%s][%s]\n",
        getpid(), syscall(SYS_gettid),
        hreq->method, hreq->path,
        hreq->protocol, hreq->connection);
    if (strcasecmp(hreq->method, "get")) {
   
        printf("%d.%ld> 无效方法\n",
            getpid(), syscall(SYS_gettid));
        return -1;
    }
    if (strcasecmp(hreq->protocol, "http/1.0") &&
        strcasecmp(hreq->protocol, "http/1.1")) {
   
        printf("%d.%ld> 无效协议\n",
            getpid(), syscall(SYS_gettid));
        return -1;
    }
    return 0;
}
// 构造响应头
void constructHead(HTTP_RESPOND const* hres,
    char* head) {
   
    /*
     * HTTP/1.1 200 OK\r\n
     * Server: Tarena WebServer 1.0\r\n
     * Date: Tue, 14 Jan 2020 01:39:00 GMT\r\n
     * Content-Type: text/html\r\n
     * Content-Length: 2048\r\n
     * Connection: keep-alive\r\n\r\n
     */
    char dateTime[32];
    time_t now = time(NULL);
    strftime(dateTime, sizeof(dateTime),
        "%a, %d %b %Y %T GMT", gmtime(&now));
    sprintf(head,
        "%s %d %s\r\n"
        "Server: Tarena WebServer 1.0\r\n"
        "Date: %s\r\n"
        "Content-Type: %s\r\n"
        "Content-Length: %ld\r\n"
        "Connecion: %s\r\n\r\n",
        hres->protocol, hres->status, hres->desc,
        dateTime, hres->type, hres->length,
        hres->connection);
}

2、套接字模块：实现网络通信

代码：socket.h

// 声明网络通信函数
#ifndef _SOCKET_H
#define _SOCKET_H
// 初始化套接字
int initSocket(short port);
// 接受客户机连接
int acceptClient(void);
// 接收请求
char* recvRequest(int conn);
// 发送响应头
int sendHead(int conn, char const* head);
// 发送响应体
int sendBody(int conn, char const* path);
// 终结化套接字
void deinitSocket(void);
#endif // _SOCKET_H

代码：socket.c

// 定义网络通信函数
#include <unistd.h>
#include <fcntl.h>
#include <sys/syscall.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "socket.h"
static int s_sock = -1; // 侦听套接字
// 初始化套接字
int initSocket(short port) {
   
    printf("%d> 创建套接字\n", getpid());
    if ((s_sock = socket(PF_INET, SOCK_STREAM,
        0)) == -1) {
   
        perror("socket");
        return -1;
    }
    printf("%d> 设置套接字\n", getpid());
    int on = 1;
    if (setsockopt(s_sock, SOL_SOCKET,
        SO_REUSEADDR, &on, sizeof(on)) == -1) {
   
        perror("setsockopt");
        return -1;
    }
    printf("%d> 绑定端口号\n", getpid());
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(s_sock, (struct sockaddr*)&addr,
        sizeof(addr)) == -1) {
   
        perror("bind");
        return -1;
    }
    printf("%d> 侦听套接字\n", getpid());
    if (listen(s_sock, 1024) == -1) {
   
        perror("listen");
        return -1;
    }
    return 0;
}
// 接受客户机连接
int acceptClient(void) {
   
    printf("%d> 等待客户机连接\n", getpid());
    struct sockaddr_in addrcli = {
   };
    socklen_t addrlen = sizeof(addrcli);
    int conn = accept(s_sock,
        (struct sockaddr*)&addrcli, &addrlen);
    if (conn == -1) {
   
        perror("accept");
        return -1;
    }
    printf("%d> 已连接客户机%s:%hu\n", getpid(),
        inet_ntoa(addrcli.sin_addr),
        ntohs(addrcli.sin_port));
    return conn;
}
// 接收请求
char* recvRequest(int conn) {
   
    char* req = NULL;
    ssize_t len = 0;
    for (;;) {
   
        char buf[1024] = {
   };
        ssize_t rlen = recv(conn, buf,
            sizeof(buf) - sizeof(buf[0]), 0);
        if (rlen == -1) {
   
            perror("recv");
            free(req);
            return NULL;
        }
        if (