實現簡易Web服務器（c語言）

任務：

（1）實現服務器與客戶端間的通信。

（2）可以實現HTTP請求中的GET方法。

（3）提供靜態網頁瀏覽功能，如可瀏覽：HTML頁面，無格式文本，常見圖像格式等。

（4）提供可以傳遞參數的動態網頁瀏覽功能。

（5）可以檢查一些明顯錯誤報告給客戶端，如：403無權訪問，404找不到所請求的文件，501不支持相應方法等。

（6）在服務器端可輸出HTTP響應的相關信息。

服務器端可配置參數，如：主目錄，首頁文件名，HTTP端口號等項。

 

套接字接口

套接字接口是一組函數，它們和Unix I/O函數結合起來，用以創建網絡網絡應用。

客戶端和服務器使用socket函數來創建一個套接字描述符。

服務器端通過bind函數告訴內核將addr中的服務器套接字地址和套接字描述符sockfd聯系起來；通過listen函數告訴內核，描述符是被服務器而不是客戶端使用；通過accept函數來等待來自客戶端的連接請求。

 

HTTP（超文本傳輸協議）被用在Web客戶端和服務器之間的交互。當客戶端需要服務時，它就向服務器發送一個HTTP請求說明需要的東西，服務器收到后解析，然后進行回應。本次實驗，實現了應用最廣泛的GET方法，並通過解析，判斷是需要動態內容，還是靜態內容，還是錯誤處理。

 

 

doit函數：處理一個HTTP事務。

首先讀和解析請求行，獲得方法，如果不是所支持的GET方法，就發送給它一個錯誤消息，並返回到主程序，主程序隨后關閉連接並等待下一個連接請求。否則，讀並且調用read_requesthdrs忽略報頭中的其他信息。然后將URI解析為一個文件名和一個可能為空的CGI參數字符串，並且設置一個標志，表明請求的是靜態內容還是動態內容。如果所需的文件不存在，就發送一個錯誤信息到客戶端並返回。

 

parse_uri函數：解析URI並轉為所需的文件名。

初始時設主目錄為當前目錄，可執行文件的目錄為./cgi-bin。如果請求的是衣一個靜態內容，就清楚CGI參數字符串，然后轉為文件的路徑名。如果請求的是動態內容，就提取出所有的CGI參數，然后轉為文件的路徑名。

 

serve_static函數：處理靜態內容。

首先打開filename文件，用mmap函數將文件映射到一個虛擬內存空間，然后關閉這個文件，rio_writen函數復制到客戶端已連接的描述符。這樣前段就可以顯示出所需的內容。

 

serve_dynamic函數：處理動態內容。

首先向客戶端發送成功相應的內容，然后派生一個子進程，子進程用來自請求URI的CGI參數初始化QUERY_STRING環境變量，重定向標准輸出到已連接文件描述符，然后執行CGI程序。

 

signal_r(SIGCHLD, sigchild_handler)函數：處理僵屍進程函數。

fork創建出很多進程，這些進程執行完以后就exit(0)然后發個信號通知主進程，exit函數退出后，進程的有關資源（打開的文件描述符，棧，寄存器，有關信息等）還沒有釋放掉，如果進程不被回收的話就會占用存儲器資源這樣的進程就稱為僵屍進程。所以解決辦法就是主進程使用一個信號處理函數，等待僵屍進程回收。

 

/*
 * @filename:    webServer.c
 * @author:      Flyuz
 * @date:        2018年6月25日
 * @description: 主程序
 */

#include "functionLib.h"

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


int main(int argc, char **argv) {
  int listenfd, connfd;
  socklen_t clientlen;

  struct sockaddr_in clientaddr;

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

  printf("The web server has been started.....\n");

  listenfd = Open_listenfd(argv[1]);
  /*
  信號處理函數
  用來處理僵屍進程
  */
  signal_r(SIGCHLD, sigchild_handler);

  while (1) {
    clientlen = sizeof(clientaddr);
    if((connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen)) < 0)
    {
      if(errno == EINTR)
          continue;
      else
          printf("Accept error...");
    }
    pid_t pid = Fork();
    if(pid == 0)
    {
        doit(connfd);
        Close(connfd);
        exit(0);
    }
    else
    {
      Close(connfd);
    }
  }
}

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

  //初始化 rio 結構
  Rio_readinitb(&rio, fd);
  //讀取http請求行
  Rio_readlineb(&rio, buf, MAXLINE);
  //格式化存入 把該行拆分
  sscanf(buf, "%s %s %s", method, uri, version);

  //只能處理GET請求，如果不是GET請求的話返回錯誤
  if (strcasecmp(method, "GET")) {
    clienterror(fd, method, "501", "Not Implemented",
                "Flyuz does not implement thid method");
    return;
  }

  //讀取並忽略請求報頭
  read_requesthdrs(&rio);

  // memset(filename,0,sizeof(filename));
  //解析 URI
  is_static = parse_uri(uri, filename, cgiargs);

  //文件不存在
  if (stat(filename, &sbuf) < 0) {
    clienterror(fd, filename, "404", "Not found",
                "Flyuz couldn't find this file");
    return;
  }

  if (is_static) { //服務靜態內容
    if (!(S_ISREG(sbuf.st_mode)) || !(S_IRUSR & sbuf.st_mode)) {
      clienterror(fd, filename, "403", "Forbidden",
                  "Flyuz couldn't read the file");
      return;
    }
    serve_static(fd, filename, sbuf.st_size);
  } else { //服務動態內容
    if (!(S_ISREG(sbuf.st_mode)) || !(S_IXUSR & sbuf.st_mode)) {
      clienterror(fd, filename, "403", "Forbidden",
                  "Flyuz couldn't run the CGI program");
      return;
    }
    serve_dynamic(fd, filename, cgiargs);
  }
}

/*
 * 讀取http 請求報頭，無法使用請求報頭的任何信息，讀取之后忽略掉
 */
void read_requesthdrs(rio_t *rp) {
  char buf[MAXLINE];

  Rio_readlineb(rp, buf, MAXLINE);
  printf("%s", buf);
  //空文本行終止請求報頭，碰到 空行 就結束 空行后面是內容實體
  while (strcmp(buf, "\r\n")) {
    Rio_readlineb(rp, buf, MAXLINE);
    printf("%s", buf);
  }
  return;
}

/*
 * 解析URI 為 filename 和 CGI 參數
 * 如果是動態內容返回0；靜態內容返回 1
 */
int parse_uri(char *uri, char *filename, char *cgiargs) {
  if (!strstr(uri,
              "cgi-bin")) { //默認可執行文件都放在cgi-bin下，這里表示沒有找到
    strcpy(cgiargs, "");
    strcpy(filename, ".");
    strcat(filename, uri);
    /*
    if(uri[strlen(uri)-1] == "/")  //設置默認文件
        strcat(filename, "index.html");
    */

    return 1; // static
  } else {    //動態內容
    char *ptr = strchr(uri, '?');
    if (ptr) { //有參數
      strcpy(cgiargs, ptr + 1);
      *ptr = '\0';
    } else { //無參數
      strcpy(cgiargs, "");
    }

    strcpy(filename, ".");
    strcat(filename, uri);
    return 0;
  }
}

/*
 * 功能：發送一個HTTP響應，主體包含一個本地文件的內容
 */
void serve_static(int fd, char *filename, int filesize) {
  int srcfd;
  char *srcp, body[MAXBUF], filetype[MAXLINE];

  /* 發送 響應行 和 響應報頭 */
  get_filetype(filename, filetype);

  sprintf(body, "HTTP/1.0 200 OK\r\n");
  sprintf(body, "%sServer: Flyuz Web Server\r\n", body);
  sprintf(body, "%sConnection:close\r\n", body);
  sprintf(body, "%sContent-length: %d\r\n", body, filesize);
  sprintf(body, "%sContent-type: %s\r\n\r\n", body, filetype);
  Rio_writen(fd, body, strlen(body));
  printf("Response headers: \n%s", body);

  /* 發送響應主體 即請求文件的內容 */
  /* 只讀方式發開filename文件，得到描述符*/
  srcfd = Open(filename, O_RDONLY, 0);
  /* 將srcfd 的前 filesize 個字節映射到一個從地址 srcp 開始的只讀虛擬存儲器區域
   * 返回被映射區的指針 */
  srcp = Mmap(0, filesize, PROT_READ, MAP_PRIVATE, srcfd, 0);
  /* 此后通過指針 srcp 操作，不需要這個描述符，所以關掉 */
  Close(srcfd);

  Rio_writen(fd, srcp, filesize);
  /* 釋放映射的虛擬存儲器區域 */
  Munmap(srcp, filesize);
}

/*
 * 功能：從文件名得出文件的類型
 */
void get_filetype(char *filename, char *filetype) {
  if (strstr(filename, ".html") || strstr(filename, ".php"))
    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, ".ipg"))
    strcpy(filetype, "image/jpeg");
  else
    strcpy(filetype, "text/plain");
}

/*
 * 功能：運行客戶端請求的CGI程序
 */
void serve_dynamic(int fd, char *filename, char *cgiargs) {
  char buf[MAXLINE];
  char *emptylist[] = {NULL};

  /* 發送響應行 和 響應報頭 */
  sprintf(buf, "HTTP/1.0 200 OK\r\n");
  Rio_writen(fd, buf, strlen(buf));
  sprintf(buf, "Server Flyuz Web Server\r\n");
  Rio_writen(fd, buf, strlen(buf));

  /* 剩下的內容由CGI程序負責發送 */
  if (Fork() == 0) { //子進程
    setenv("QUERY_STRING", cgiargs, 1);
    Dup2(fd, STDOUT_FILENO);
    Execve(filename, emptylist, __environ);
  }
  Wait(NULL);
  /*
  if(strstr(filename, ".php")) {
            sprintf(response, "HTTP/1.1 200 OK\r\n");
            sprintf(response, "%sServer: Pengge Web Server\r\n",response);
            sprintf(response, "%sConnection: close\r\n",response);
            sprintf(response, "%sContent-type: %s\r\n\r\n",response,filetype);
            Write(connfd, response, strlen(response));
            printf("Response headers:\n");
            printf("%s\n",response);
            php_cgi(filename, connfd,cgi_params);
            Close(connfd);
            exit(0);
        //靜態頁面輸出
  }
  */
}

/*
 * 檢查一些明顯的錯誤，報告給客戶端
 */
void clienterror(int fd, char *cause, char *errnum, char *shortmsg,
                 char *longmsg) {
  char buf[MAXLINE], body[MAXBUF];

  /* 構建HTTP response 響應主體 */
  sprintf(body, "<html><title>Flyuz Error</title>");
  sprintf(body,
          "%s<body bgcolor="
          "white"
          ">\r\n",
          body);
  sprintf(body, "%s<center><h1>%s: %s</h1></center>", body, errnum, shortmsg);
  sprintf(body, "%s<center><h3>%s: %s</h3></center>", body, longmsg, cause);
  sprintf(body, "%s<hr><center>The Flyuzy Web server</center>\r\n", body);

  /* 打印HTTP響應報文 */
  sprintf(buf, "HTTP/1.0 %s %s", 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));
}

/*
 * @filename:    functionLib.h
 * @author:      Flyuz
 * @date:        2018年6月25日
 * @description: 函數實現
 */

#ifndef ALL_H
#define ALL_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/mman.h>

#define RIO_BUFSIZE 8192
#define    MAXLINE     8192  /* 一行最大長度 */
typedef struct {
    int rio_fd;                 //內部讀緩沖區描述符
    int rio_cnt;                //內部緩沖區中未讀字節數
    char *rio_bufp;           //內部緩沖區中下一個未讀的字節
    char rio_buf[RIO_BUFSIZE];  //內部讀緩沖區
}rio_t;                         //一個類型為rio_t的讀緩沖區

#define     MAXLINE     8192
#define     MAXBUF      8192
#define     LISTENQ     1024

typedef struct sockaddr SA;
typedef void handler_t(int);
void unix_error(char *msg);

/* Process control wrappers */
pid_t Fork();
void Execve(const char *filename, char *const argv[], char *const envp[]);
pid_t Wait(int *status);

/* Unix I/O */
int Open(const char *pathname, int flags, mode_t mode);
void Close(int fd);
int Dup2(int oldfd, int newfd);



void *Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset);
void Munmap(void *start, size_t length);

/* RIO package */
ssize_t rio_readn(int fd, void *usrbuf, size_t n);
ssize_t rio_writen(int fd, void *usrbuf, size_t n);
void rio_readinitb(rio_t *rp, int fd);
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);


ssize_t Rio_readn(int fd, void *usrbuf, size_t n);
void Rio_writen(int fd, void *usrbuf, size_t n);
void Rio_readinitb(rio_t *rp, int fd);
ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen);
ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n);


int open_listenfd(char *port);

int Open_listenfd(char *port);

int Accept(int s, struct sockaddr *addr, socklen_t *addrlen);

handler_t  *signal_r(int signum, handler_t *handler);
void sigchild_handler(int sig);

#endif

/*
 * @filename:    functionLib.c
 * @author:      Flyuz
 * @date:        2018年6月25日
 * @description: 輔助函數
 */

#include "functionLib.h"

void unix_error(char *msg)
{
    fprintf(stderr, "%s: %s\n",msg, strerror(errno));
    exit(0);
}

pid_t Fork()
{
    pid_t pid;
    pid = fork();
    if(pid < 0)
        unix_error("fork error");
    return pid;
}

void Execve(const char *filename, char *const argv[], char *const envp[])
{
    if(execve(filename, argv,envp) < 0)
        unix_error("Execve error");
}

pid_t Wait(int *status)
{
    pid_t pid;

    if((pid = wait(status)) < 0)
        unix_error("Wait error");
    return pid;
}



int Open(const char *pathname, int flags, mode_t mode)
{
    int rc;

    if((rc = open(pathname, flags, mode)) < 0)
        unix_error("Open error");
    return rc;
}

int Accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
    int rc;

    if((rc = accept(s, addr,addrlen)) < 0)
        unix_error("Accept error");
    return rc;
}

void Close(int fd)
{
    int rc;

    if((rc = close(fd)) < 0)
        unix_error("Close error");
}

int Dup2(int oldfd, int newfd)
{
    int rc;

    if((rc = dup2(oldfd, newfd)) < 0 )
        unix_error("Dup2 error");
    return rc;
}


void *Mmap(void *addr, size_t len, int prot, int flags, int fd, off_t offset)
{
    void *ptr;

    if((ptr = mmap(addr, len, prot, flags, fd, offset)) == ((void *)-1))
        unix_error("Mmap error");
    return ptr;
}

void Munmap(void *start, size_t length)
{
    if(munmap(start, length) < 0)
        unix_error("Munmap error");
}
/*
 * 無緩沖輸入函數
 * 成功返回收入的字節數
 * 若EOF返回0 ，出錯返回-1
 */
ssize_t rio_readn(int fd, void *usrbuf, size_t n)
{
    char *bufp = usrbuf;
    size_t nleft = n;
    ssize_t nread;
    while(nleft > 0) {
        if((nread = read(fd,bufp,nleft)) < 0) {
            if(errno == EINTR)
                nread = 0;
            else
                return -1;
        } else if( nread == 0 )
            break;
        nleft -= nread;
        bufp += nread;
    }
    return (n-nleft);
}
/*
 * 無緩沖輸出函數
 * 成功返回輸出的字節數，出錯返回-1
*/
ssize_t rio_writen(int fd, void *usrbuf, size_t n)
{
    char *bufp = usrbuf;
    size_t nleft = n;
    ssize_t nwritten;
    while(nleft > 0) {
        if((nwritten = write(fd, bufp, nleft)) <= 0) {
            if(errno == EINTR)
                nwritten = 0;
            else
                return -1;
        }
        nleft -= nwritten;
        bufp += nwritten;
    }
    return n;
}


static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    while(rp -> rio_cnt <= 0) {
        rp -> rio_cnt = read(rp -> rio_fd, rp -> rio_buf,
                sizeof(rp -> rio_buf));
        if(rp -> rio_cnt < 0) {
            if(errno != EINTR)
                return -1;
        } else if(rp -> rio_cnt == 0)
            return 0;
        else
            rp -> rio_bufp = rp -> rio_buf;
    }

    int cnt = rp -> rio_cnt < n ? rp -> rio_cnt : n;

    memcpy(usrbuf, rp -> rio_bufp, cnt);
    rp -> rio_bufp += cnt;
    rp -> rio_cnt -= cnt;
    return cnt;
}
// 初始化rio_t結構，創建一個空的讀緩沖區
// 將fd和地址rp處的這個讀緩沖區聯系起來
void rio_readinitb(rio_t *rp, int fd)
{
    rp -> rio_fd = fd;
    rp -> rio_cnt = 0;
    rp -> rio_bufp = rp -> rio_buf;
}

//帶緩沖輸入函數
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n)
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;

    while(nleft > 0) {
        if((nread = rio_read(rp, bufp, nleft)) < 0)
            return -1;
        else if (nread == 0)
            break;

        nleft -= nread;
        bufp += nread;
    }
    return (n-nleft);
}
/*
**帶緩沖輸入函數，每次輸入一行
**從文件rp讀出一個文本行(包括結尾的換行符)，將它拷貝到usrbuf，並且用空字符來結束這個文本行
**最多讀maxlen-1個字節，余下的一個留給結尾的空字符
**/
ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
    int n, rc;
    char c, *bufp = usrbuf;
    for(n = 1; n<maxlen; n++) {
        if((rc = rio_read(rp, &c, 1)) == 1) {
            *bufp++ = c;
            if( c == '\n' ){
                n++;
                break;
            }
        } else if(rc == 0) {
            if( n  == 1 )
                return 0;
            else
                break;
        } else
            return -1;
    }
    *bufp = '\0';
    return n-1;
}

ssize_t Rio_readn(int fd, void *usrbuf, size_t n)
{
    ssize_t nbytes;
    if((nbytes = rio_readn(fd, usrbuf, n)) < 0)
        unix_error("Rio_readn error");

    return nbytes;
}

void Rio_writen(int fd, void *usrbuf, size_t n)
{
    if(rio_writen(fd, usrbuf, n) != n)
        unix_error("Rio_writen error");
}

void Rio_readinitb(rio_t *rp, int fd)
{
    rio_readinitb(rp, fd);
}

ssize_t Rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen)
{
    ssize_t nbytes;
    if((nbytes = rio_readlineb(rp, usrbuf, maxlen)) < 0)
        unix_error("Rio_readlineb error");
    return nbytes;
}

ssize_t Rio_readnb(rio_t *rp, void *usrbuf, size_t n)
{
    ssize_t nbytes;
    if((nbytes = rio_readnb(rp, usrbuf, n)) < 0)
        unix_error("Rio_readnb error");
    return nbytes;
}

/*打開並返回監聽描述符*/
int open_listenfd(char *port)
{
    int listenfd, optval = 1;
    struct sockaddr_in serveraddr;

    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
        return -1;
    }

    if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,
                (const void *)&optval, sizeof(int)) < 0)
        return -1;

    bzero((char *)&serveraddr, sizeof(serveraddr));

    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons((unsigned short)atoi(port));

    if(bind(listenfd, (SA *)&serveraddr, sizeof(serveraddr)) < 0)
        return -1;

    if(listen(listenfd, LISTENQ) < 0)
        return -1;

    return listenfd;
}

int Open_listenfd(char *port)
{
    int rc;
    if((rc = open_listenfd(port)) < 0)
        unix_error("open_listenfd error");
    return rc;
}
//信號處理
handler_t  *signal_r(int signum, handler_t *handler)
{
    struct sigaction action, old_action;

    action.sa_handler = handler;
    sigemptyset(&action.sa_mask);
    action.sa_flags = SA_RESTART;

    if (sigaction(signum, &action, &old_action) < 0)
          perror("Signal error");
    return (old_action.sa_handler);
}
//排隊 防止阻塞
void sigchild_handler(int sig)
{
    int stat;
      while(waitpid(-1,&stat,WNOHANG)>0);
      return;
}