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选项：

 

转载于:https://www.cnblogs.com/yjds/p/8962788.html