C++實現簡單的http服務器

一、高級I/O函數：

linux提供了很多高級I/O函數。他們並不像linux基礎的I/O函數那么常用（編寫內核模塊時候一般需要這些I/O函數），但是在特定條件下表現出優秀的性能。

1、用於創建問價描述符的函數，pipe，dup，dup2；

2、用於讀寫數據的函數。

3、用於控制I/O行為和屬性的函數，包括fcntl函數。

1、pipe函數：

#include<unistd.h>

int pipe(int filedes[2]);

pipe（）會建立管道，將文件描述符有參數filedes[]數組返回。

filedes[0]為管道李的讀取端，filededs[1]為管道寫入端。

返回值：若成功，返回0，否則返回-1，錯誤原因存於errno中。

錯誤代碼：

EMFILE：進程已用完文件描述符最大量。

ENFILE：系統已無文件描述符。

EFAULT參數filedes數組地址不合法。

舉例：

#include <unistd.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <string.h>

using namespace std;

int main(void){
	int filedes[2];
	char buf[80];
	pid_t pid ;
	
	pipe(filedes);
	pid = fork();
	if(pid>0){cout<<"this is the father process ,here write a string to the pipe"<<endl;
	char s[] = "hello world, this is writen by pipe";
	//write(filedes[1],s,sizeof(s));
	send(filedes[1],s,sizeof(s),0);	
	
	close(filedes[0]);
	close(filedes[1]);
	}
	else if(pid == 0){
	cout<<"this is in the child process ,here read a string from the pipe"<<endl;
	//read(filedes[0],buf,sizeof(buf));
	recv(filedes[1],buf,sizeof(buf),0);	
	cout<<buf<<endl;
	close(filedes[0]);
	close(filedes[1]);	
	}
	waitpid(pid,NULL,0);
	return 0;
}

　　管道是一種把倆個進程之間的標准輸入和標准輸出連接起來的機制，從而提供一種讓多個進程間通信的方法，當進程創建管到時候，每次都需要提供倆個文件描述符來操作管道，讀取，寫入。對於管道的讀寫與一般的I/O系統函數一直i，使用write和read。

　　命名管道：FIFO

　　管道最大的劣勢就是沒有名字，只能用於有一個共同的祖先的各個進程之間。FIFO代表先進先出，但她似乎是一個單項數據流，也就是半雙工，和管道不同的是:每個FIFO都有一個路徑與之關聯，從而允許無親緣關系的進程訪問。

　　由於命名管道是以文件形式創建的，所以也具有一些特性，它可以使用fcntl函數改變屬性。

#include<sys/socket.h>

#include <sys/types.h>

#include<sys/stat.h>

int mkfifo(const char*pathname,mode_t mode);

這里的pathname是路徑，mode是sys/stat.h里面定義的創建文件的權限。

實例：

/*
 * 有親緣關系的進程間的fifo的使用
 * fifo 使用的簡單例子
 */

#include "../all.h"

#define FIFO_PATH "/tmp/hover_fifo"


void 
do_sig(int signo)
{
    if (signo == SIGCHLD)
        while (waitpid(-1, NULL, WNOHANG) > 0)
            ;
}

int
main(void)
{
    int ret;
    int fdr, fdw;
    pid_t pid;

    char words[10] = "123456789";
    char buf[10] = {'\0'};    
    
    // 創建它,若存在則不算是錯誤,
    // 若想修改其屬性需要先打開得到fd,然后用fcntl來獲取屬性,然后設置屬性.

    if (((ret = mkfifo(FIFO_PATH, FILE_MODE)) == -1) 
                     && (errno != EEXIST))
        perr_exit("mkfifo()");
    fprintf(stderr, "fifo : %s created successfully!\n", FIFO_PATH);

    signal(SIGCHLD, do_sig);

    pid = fork();
    if (pid == 0) { // child

        if ((fdr = open(FIFO_PATH, O_WRONLY)) < 0) // 打開fifo用來寫
            perr_exit("open()");
        sleep(2);
        // 寫入數據
        if (write(fdr, words, sizeof(words)) != sizeof(words)) 
            perr_exit("write");
        fprintf(stderr, "child write : %s\n", words);
        close(fdw);
    } else if (pid > 0) { // parent

        if ((fdr = open(FIFO_PATH, O_RDONLY)) < 0) // 打開fifo用來讀

            perr_exit("open()");

        fprintf(stderr, "I father read, waiting for child ...\n");
        if (read(fdr, buf, 9) != 9) //讀數據
            perr_exit("read");

        fprintf(stderr, "father get buf : %s\n", buf);
        close(fdr);
    }
    // 到這里fifo管道並沒有被刪除,必須手動調用函數unlink或remove刪除.

    return 0;    
}

　　從事列中可以看出使用fifo需要注意：fifo管道是先調用mkfifo創建，然后在調用open打開。得到fd來使用。再打開fifo時候需要注意，它是半雙工的，一般不能使用O_WDWR打開，而只能使用只讀，或是只寫打開。

　　fifo可以用在非親緣關系的進程之間，而他的真正用途是在客戶端和服務器之間，由於它是半雙工的所以，如果客戶端和服務器雙方的通信的話，每個方向都必須建立倆個管道，一個用於讀，一個用於寫。下面是一個服務端對多個客戶端等的fifo例子：

/*
 * FIFO server
 */

#include "all.h"

int
main(void)
{
    int fdw, fdw2;
    int fdr;
    char clt_path[PATH_LEN] = {'\0'};
    char buf[MAX_LINE] = {'\0'};
    char *p;
    int n;
    
    if (mkfifo(FIFO_SVR, FILE_MODE) == -1 && errno != EEXIST)    
        perr_exit("mkfifo()");    
    if ((fdr = open(FIFO_SVR, O_RDONLY)) < 0)    
        perr_exit("open()");
    /* 
     * 根據fifo的創建規則, 若從一個空管道或fifo讀, 
     * 而在讀之前管道或fifo有打開來寫的操作, 那么讀操作將會阻塞 
     * 直到管道或fifo不打開來讀, 或管道或fifo中有數據為止. 
     *
     * 這里,我們的fifo本來是打開用來讀的,但是為了,read不返回0,
     * 讓每次client端讀完都阻塞在fifo上,我們又打開一次來讀.
     * 見unpv2 charper 4.7
     */
    if ((fdw2 = open(FIFO_SVR, O_WRONLY)) < 0)    
        fprintf(stderr, "open()");
    
    while (1) {
        /* read client fifo path from FIFO_SVR */
     /* 這里由於FIFO_SVR有打開來寫的操作,所以當管道沒有數據時, 
      * read會阻塞,而不是返回0. 
      */
        if (read(fdr, clt_path, PATH_LEN) < 0) {
            fprintf(stderr, "read fifo client path error : %s\n", strerror(errno));    
            break;
        }
        if ((p = strstr(clt_path, "\r\n")) == NULL) {
            fprintf(stderr, "clt_path error: %s\n", clt_path);
            break;
        }
        *p = '\0';
        DBG("clt_path", clt_path);
        if (access(clt_path, W_OK) == -1) { // client fifo ok, but no permission

            perror("access()");    
            continue;
        }
        /* open client fifo for write */
        if ((fdw = open(clt_path, O_WRONLY)) < 0) {
            perror("open()");    
            continue;
        }
        if ((n = read(fdr, buf, WORDS_LEN)) > 0) { /* read server words is ok */
            printf("server read words : %s\n", buf);
            buf[n] = '\0';
            write(fdw, buf, strlen(buf));    
        }
    }
    
    close(fdw);    
    unlink(FIFO_SVR);
    exit(0);
}

　　客戶端的例子：

/*
 * Fifo client
 *
 */
#include "all.h"



int
main(void)
{
    int fdr, fdw;
    pid_t pid;    
    char clt_path[PATH_LEN] = {'\0'};
    char buf[MAX_LINE] = {'\0'};
    char buf_path[MAX_LINE] = {'\0'};
    
    snprintf(clt_path, PATH_LEN, FIFO_CLT_FMT, (long)getpid());        
    DBG("clt_path1 = ", clt_path);
    snprintf(buf_path, PATH_LEN, "%s\r\n", clt_path);

    if (mkfifo(clt_path, FILE_MODE) == -1 && errno != EEXIST)    
        perr_exit("mkfifo()");

    /* client open clt_path for read
     * open server for write 
       */
    if ((fdw = open(FIFO_SVR, O_WRONLY)) < 0) 
        perr_exit("open()");
    
    /* write my fifo path to server */    
    if (write(fdw, buf_path, PATH_LEN) != PATH_LEN)        
        perr_exit("write()");
    if (write(fdw, WORDS, WORDS_LEN) < 0)    /* write words to fifo server */
        perr_exit("error");

    if ((fdr = open(clt_path, O_RDONLY)) < 0)    
        perr_exit("open()");
    if (read(fdr, buf, WORDS_LEN) > 0) {     /* read reply from fifo server */
        buf[WORDS_LEN] = '\0';
        printf("server said : %s\n", buf);
    }
    
    close(fdr);
    unlink(clt_path);
    
    exit(0);
}

2、dup（）函數和dup2（）函數。

　　有時候，我們希望將標准輸出重定向到一個新的文件描述符，該新文件描述符和原有的文件描述符指向相同的文件，管道或者網絡連接。並且dup返回的文件描述符總是取系統當前可用的最小的整數值。dup2和dup類似，不過他將返回一個不小於file_desctriptor_two的整數值。dup和dup2系統調用失敗時返回-1，並設置errno。

注意：通過dup和dup2創建的問價描述符並不繼承源文件描述符的屬性，比如close-on-exec和

non-blocking等。

實例：使用dup（）創建一個基本的CGI服務器。

#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
using namespace std;

int main(int argc,char*argv[]){
	const char* ip = argv[1];
	int port = atoi(argv[2]);
	
	struct sockaddr_in address;
	bzero(&address,sizeof(address));
	address.sin_family = AF_INET;
	address.sin_port  = htons(port);
	//address.sin_addr.s_addr = inet_addr("127.0.0.1");
	inet_pton(AF_INET,ip,&address.sin_addr);
	
	int sock = socket(AF_INET,SOCK_STREAM,0);
	if(sock<0){cout<<"socket failed"<<endl;}

	int ret = bind(sock,(struct sockaddr*)&address,sizeof(address));
	if(ret <0){cout<<"bind failed"<<endl;}

	ret = listen(sock,10);
	if(ret < 0){cout<<"listen failed"<<endl;}
	
	struct sockaddr_in client;
	socklen_t client_addrlength = sizeof(client);
	int connfd = accept(sock,(struct sockaddr*)&client,&client_addrlength);
	if(connfd<0){cout<<"accept failed"<<endl;}
	
	else{
	close(STDOUT_FILENO);
	dup(connfd);
	cout<<"abcd"<<endl;
	close(connfd);	
	}
	close(sock);
	return 0;
}

　在代碼中，我們先關閉標准輸出文件描述符STDOUT_FILENO（值為1），然后復制socket文件描述符connfd。因為dup總是返回系統中最小的可以調用的文件描述符，所以他的返回值實際上是1，就是之前關閉標准輸出文件描述符的值。這樣一拉，服務器輸出到標准輸出的內容“abcd”就會直接發送到客戶連接對應的socket上，因此cout<<調用的輸出將被客戶端獲得（而不是顯示在服務器程序中端上）。這就是CGI服務器的基本工作原理。

3、（1）通用數據讀寫函數。

#include<sys/socket.h>

ssize_t　recvmsg(int sockfd,struct msghdr*msg,int flags);

ssize_t　sendmsg(int sockfd,struct msghdr*msg,int flags);

msg是結構體類型的指針，msghdr結構體的定義如下：

struct msghdr{
void* msg_name;//socket地址
socklen_t msg_namelen;//socket地址長度
struct iovec* msg_iov;//分散的內存塊
int msg_iovlen;//分散內存塊的數量
void* msg_control;//指向輔助數據的起始位置
socklen_t msg_controller;//輔助數據的長度
int msg_flags;//復制函數中的flags參數，並在調用中跟新
}

struct iovec{
void* iov_base;//內存起始地址
size_t iov_len;//這塊內存的長度
}

　　由此可見，iovec結構體封裝了一塊內存的起始位置和長度。msg_iovlen指向iovec的結構體對象有多少個。對於recvmsg而言，數據讀取並存放在msg_iovlen的內存中，這些內存的長度和位置由msg_iov指向的數組制定，分散讀；對於sendmsg而言，msg_iovlen快分散的內存數據將被一並發送，這稱為集中寫。

 （2）帶外標記：檢測帶外標記的函數：sockmark(int sockfd);

判斷sockfd是否處於帶外標記，就是下一個被讀取到的數據是否是帶外數據。如果是，sockmark（）返回1，此時我們就可以使用MSG_OOB標志的recv調用來接受帶外數據，如果不是sockmark（）返回0。

（3）地址信息函數。

int getsockname(int sockfd,struct sockaddr* address,socklen_t * address_len);

int getpeername(int sockfd,struct sockaddr* address,socklen_t * address_len);

從sockfd獲得本端（遠端）socket地址，並存儲於address，長度存儲於address_len。

（4）socket選項。

讀取和設置文件描述符的方法：

int  getsockopt(int sockfd,int level,int option_name,void* option_value,socklen_t * restrict option_len);

int  setsockopt(int sockfd,int level,int option_name,void* option_value,socklen_t * restrict option_len);

sockfd是備操作的目標socket。

level是指定那個協議的選項（SOL_SOCKET,IPPRPTO_IP,IPPROT_IPV6）。

option_name：指定選項的名字。

option_value:操作選項的值。

option_len：操作選項的長度。

getsockopt（）和setsockopt（）成功時候返回0，失敗時返回-1，並設置errno。

注意：服務器而言，部分socket選項只能在調用listen之前針對監聽socket設置才有效。（連接socket只能由accept調用返回，而accept從listen中接受的連接至少已經完成了TCP三次握手的前倆個步驟，進入SYN_RCVD狀態）對監聽socket設置這些選項，那么accept返回的連接socket將自動繼承這些選項。

SO_REUSEADDR選項：