网络编程

最新推荐文章于 2024-07-17 15:00:16 发布
最新推荐文章于 2024-07-17 15:00:16 发布
阅读量201 收藏
点赞数
分类专栏： C/C++ 网络编程 文章标签： 网络 epoll 高并发编程 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40423358/article/details/116272499
版权

网络编程

1、API函数封装

//wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.h>

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
int tcp4bind(short port,const char *IP);
#endif

//wrap.c
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.h>

void perr_exit(const char *s){
	perror(s);
	exit(-1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr){
	int n;

again:
	if ((n = accept(fd, sa, salenptr)) < 0) {
		if ((errno == ECONNABORTED) || (errno == EINTR))
			goto again;
		else
			perr_exit("accept error");
	}
	return n;
}

int Bind(int fd, const struct sockaddr *sa, socklen_t salen){
    int n;

	if ((n = bind(fd, sa, salen)) < 0)
		perr_exit("bind error");

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen){
    int n;

	if ((n = connect(fd, sa, salen)) < 0)
		perr_exit("connect error");

    return n;
}

int Listen(int fd, int backlog){
    int n;

	if ((n = listen(fd, backlog)) < 0)
		perr_exit("listen error");

    return n;
}

int Socket(int family, int type, int protocol){
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		perr_exit("socket error");

	return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes){
	ssize_t n;

again:
	if ( (n = read(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes){
	ssize_t n;

again:
	if ( (n = write(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

int Close(int fd){
    int n;
	if ((n = close(fd)) == -1)
		perr_exit("close error");

    return n;
}

/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n){
	size_t  nleft;              //usigned int 剩余未读取的字节数
	ssize_t nread;              //int 实际读到的字节数
	char   *ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		if ((nread = read(fd, ptr, nleft)) < 0) {
			if (errno == EINTR)
				nread = 0;
			else
				return -1;
		} else if (nread == 0)
			break;

		nleft -= nread;
		ptr += nread;
	}
	return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n){
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR)
				nwritten = 0;
			else
				return -1;
		}

		nleft -= nwritten;
		ptr += nwritten;
	}
	return n;
}

static ssize_t my_read(int fd, char *ptr){
	static int read_cnt;
	static char *read_ptr;
	static char read_buf[100];

	if (read_cnt <= 0) {
again:
		if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
			if (errno == EINTR)
				goto again;
			return -1;
		} else if (read_cnt == 0)
			return 0;
		read_ptr = read_buf;
	}
	read_cnt--;
	*ptr = *read_ptr++;

	return 1;
}

ssize_t Readline(int fd, void *vptr, size_t maxlen){
	ssize_t n, rc;
	char    c, *ptr;

	ptr = vptr;
	for (n = 1; n < maxlen; n++) {
		if ( (rc = my_read(fd, &c)) == 1) {
			*ptr++ = c;
			if (c  == '\n')
				break;
		} else if (rc == 0) {
			*ptr = 0;
			return n - 1;
		} else
			return -1;
	}
	*ptr  = 0;

	return n;
}

int tcp4bind(short port,const char *IP){
    struct sockaddr_in serv_addr;
    int lfd = Socket(AF_INET,SOCK_STREAM,0);
    bzero(&serv_addr,sizeof(serv_addr));
    if(IP == NULL){
        //如果这样使用 0.0.0.0,任意ip将可以连接
        serv_addr.sin_addr.s_addr = INADDR_ANY;
    }else{
        if(inet_pton(AF_INET,IP,&serv_addr.sin_addr.s_addr) <= 0){
            perror(IP);//转换失败
            exit(1);
        }
    }
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port   = htons(port);
    Bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    return lfd;
}

//客户端client.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "wrap.h"

int main(int argc,char *argv[])
{
    //创建socket
    int cfd = Socket(AF_INET, SOCK_STREAM, 0);
    
    //连接服务端
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);
    Connect(cfd, (struct sockaddr *)&serv, sizeof(serv));

    int n;
    char buf[256];
    while(1){
        //读标准输入数据
        memset(buf, 0x00, sizeof(buf));
        n = Read(STDIN_FILENO, buf, sizeof(buf));

        //发送数据
        Write(cfd, buf, sizeof(buf));

        //读服务端恢回复的数据
        memset(buf, 0x00, sizeof(buf));
        n = Read(cfd, buf, sizeof(buf));
        if(n<=0){
            printf("read error or server closed, n==[%d]\n", n);
            break;
        }
        printf("n==[%d], buf==[%s]\n", n, buf);
    }

    //关闭套接字
    close(cfd);

	return 0;
}

2、多进程版的网络服务器

//多进程版本的服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#include <sys/wait.h>
#include <ctype.h>
#include "wrap.h"

//信号处理函数
void waitchild(int signo){
	pid_t wpid;
	while(1){
		wpid = waitpid(-1, NULL, WNOHANG);
		if(wpid>0){
			printf("child exit, wpid==[%d]\n", wpid);
		}
		else if(wpid==0 || wpid==-1){
			break;
		}
	}
}

int main()
{
	//创建socket
	int lfd = Socket(AF_INET, SOCK_STREAM, 0);

	//设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

	//绑定-bind
	struct sockaddr_in serv;
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

	//监听-listen
	Listen(lfd, 128);

	//阻塞SIGCHLD信号
	sigset_t mask;
	sigemptyset(&mask);
	sigaddset(&mask, SIGCHLD);
	sigprocmask(SIG_BLOCK, &mask, NULL);

	int cfd;
	socklen_t len;
	char sIP[16];
	pid_t pid;
	struct sockaddr_in client;
	while(1){
		//等待客户端连接--accept
		memset(sIP, 0x00, sizeof(sIP));
		len = sizeof(client);
		bzero(&client, sizeof(client));
		
		cfd = Accept(lfd, (struct sockaddr *)&client, &len);	
		printf("client-->[%s]:[%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));

		//创建子进程
		pid = fork();
		if(pid<0){
			perror("fork error");
			close(lfd);
			return -1;
		}	
		else if(pid>0) //父进程
        {
			//关闭通信的文件描述符
			close(cfd);

			//注册SIGCHLD信号处理函数
			struct sigaction act;
			act.sa_handler = waitchild;
			act.sa_flags = 0;
			sigemptyset(&act.sa_mask);
			sigaction(SIGCHLD, &act, NULL);

			//解除对SIGCHLD信号的阻塞
			sigprocmask(SIG_UNBLOCK, &mask, NULL);
		}
		else if(pid==0) //子进程
		{
			//关闭监听文件描述符
			close(lfd);	

			int i = 0;
			int n = 0;
			char buf[1024];

			while(1){
				memset(buf, 0x00, sizeof(buf));
				n = Read(cfd, buf, sizeof(buf));
				if(n<=0)	{
					printf("read error or client closed, n==[%d]\n", n);
					break;	
				}
				printf("read over, n==[%d],buf==[%s]\n", n, buf);
				
				for(i=0; i<n; i++){
					buf[i] = toupper(buf[i]);
				}
				write(cfd, buf, n);
			}

			close(cfd);
			exit(0);
		}
	}

	//关闭监听文件描述符
	close(lfd);

	return 0;
}

3、多线程版本的服务器

//多线程版本的服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include <pthread.h>
#include "wrap.h"

typedef struct info{
	int cfd;   //若为-1表示可用, 大于0表示已被占用
	int idx;
	pthread_t thread;
	struct sockaddr_in client;
}INFO;

INFO thInfo[1024];

//线程执行函数
void *thread_work(void *arg){
	INFO *p = (INFO *)arg;
	printf("idx==[%d]\n", p->idx);

	char sIP[16];
	memset(sIP, 0x00, sizeof(sIP));
	printf("new client:[%s][%d]\n", inet_ntop(AF_INET, &(p->client.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(p->client.sin_port));

	int n;
	int cfd = p->cfd;
	struct sockaddr_in client;
	memcpy(&client, &(p->client), sizeof(client));
	
	char buf[1024];
	
	while(1){
		memset(buf, 0x00, sizeof(buf));
		//读数据
		n = Read(cfd, buf, sizeof(buf));
		if(n<=0){
			printf("read error or client closed, n==[%d]\n", n);
			Close(cfd);
			p->cfd =-1;  //设置为-1表示该位置可用
			pthread_exit(NULL);
		}
		
		for(int i=0; i<n; i++){
			buf[i] = toupper(buf[i]);
		}
		//发送数据
		Write(cfd, buf, n);
	}
}

void init_thInfo(){
	int i = 0;
	for(i=0; i<1024; i++){
		thInfo[i].cfd = -1;;
	}
}

int findIndex(){
	int i;
	for(i=0; i<1024; i++){
		if(thInfo[i].cfd==-1){
			break;
		}
	}
	if(i==1024){
		return -1;
	}
	
	return i;
}

int main()
{
	//创建socket
	int lfd = Socket(AF_INET, SOCK_STREAM, 0);
	
	//设置端口复用
	int opt = 1;
	setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
	
	//绑定--将lfd 和 IP PORT绑定
	struct sockaddr_in serv;
	bzero(&serv, sizeof(serv));
	serv.sin_family = AF_INET;
	serv.sin_port = htons(8888);
	serv.sin_addr.s_addr = htonl(INADDR_ANY);
	Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));
	
	//监听
	Listen(lfd, 128);
		
	//初始化
	init_thInfo();
	
	int cfd;
	int ret;
	int idx;
	socklen_t len;
	pthread_t thread;
	struct sockaddr_in client;
	while(1){
		len = sizeof(client);
		bzero(&client, sizeof(client));
		//获得一个新的连接
		cfd = Accept(lfd, (struct sockaddr *)&client, &len);
		//创建一个子进程, 让子进程处理连接---接收数据和发送数据
		
		//找数组中空闲的位置
		idx = findIndex();
		if(idx==-1){
			Close(cfd);
			continue;
		}
		
		//对空闲位置的元素的成员赋值
		thInfo[idx].cfd = cfd;
		thInfo[idx].idx = idx;
		memcpy(&thInfo[idx].client, &client, sizeof(client));
		
		//创建子线程---该子线程完成对数据的收发
		ret = pthread_create(&thInfo[idx].thread, NULL, thread_work, &thInfo[idx]);
		if(ret!=0){
			printf("create thread error:[%s]\n", strerror(ret));
			exit(-1);
		}
		
		//设置子线程为分离属性
		pthread_detach(thInfo[idx].thread);
	
	}
	
	Close(lfd);
	
	return 0;
	
}

4、select网络服务器

//多路IO复用---select网络服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include <signal.h>
#include <sys/wait.h>
#include "wrap.h"

int main(int argc,char *argv[])
{
    //创建socket
    int lfd = Socket(AF_INET, SOCK_STREAM, 0);

    //设置端口复用
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

    //绑定
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);   //任意IP地址
    bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

    //设置监听
    Listen(lfd, 128);

    //定义fd_set类型的变量
    fd_set readfds;
    fd_set tmpfds;

    //清空readfds和tmpfds集合
    FD_ZERO(&readfds);
    FD_ZERO(&tmpfds);

    //将文件描述符加入到readfds中，委托内核监控
    FD_SET(lfd, &readfds);

    int nready;
    int maxfd = lfd;
    int cfd;
    int i;
    int sockfd;
    int n;
    char buf[1024];
    char sIP[16];
    socklen_t len;
    struct sockaddr_in client;
    while(1)
    {
        //tmpfds是输入输出参数
        //输入：告诉内核要监控那些文件描述符
        //输出：内核告诉应用程序有哪些文件描述符发生了变化
        tmpfds = readfds;
        nready = select(maxfd+1, &tmpfds, NULL,NULL, NULL);
        if(nready<0)
        {
            if(errno==EINTR)    //被信号中断
            {
                continue;
            }
            break;
        }

        //有客户端连接请求到来
        if(FD_ISSET(lfd, &tmpfds))
        {
            //接受新的客户端连接请求
            memset(sIP, 0x00, sizeof(sIP));
            len = sizeof(client);
            bzero(&client, sizeof(client));
            cfd = Accept(lfd, (struct sockaddr *)&client, &len);
            printf("client:[%s] [%d]\n", inet_ntop(AF_INET, &(client.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(client.sin_port));
            
            //将cfd加入到readfds
            FD_SET(cfd, &readfds);
            
            //修改内核监控范围
            if(maxfd<cfd)
            {
                maxfd = cfd;
            }
            
            if(--nready==0)
            {
                continue;
            }
        }

        //有客户端数据发来情况
        for(i=lfd+1; i<=maxfd; i++)
        {
            sockfd = i;
            //判断sockfd文件描述符是否有变化
            if(FD_ISSET(sockfd, &tmpfds))
            {
                //读数据
                memset(buf, 0x00, sizeof(buf));
                n = Read(sockfd, buf, sizeof(buf));
                if(n<=0)
                {
                    //关闭连接
                    close(sockfd);

                    //将sockfd从readfds中删除
                    FD_CLR(sockfd, &readfds);
                }
                else
                {
                    memset(sIP, 0x00, sizeof(sIP));
                    printf("client:[%s] [%d], buf==[%s]\n", inet_ntop(AF_INET, &(client.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(client.sin_port), buf);

                    int k;
                    for(k=0; k<n; k++)
                    {
                        buf[k] = toupper(buf[k]);
                    }

                    //发送数据
                    Write(sockfd, buf, n);
                }

                if(--nready==0)
                {
                    break;
                }
            }
        }
    }

    
    //关闭监听文件描述符
    close(lfd);

	return 0;
}

5、poll网络服务器

//多路IO复用---poll网络服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <poll.h>
#include <ctype.h>
#include "wrap.h"

int main(int argc,char *argv[])
{
    //创建socket
    int lfd = Socket(AF_INET, SOCK_STREAM, 0);

    //设置端口复用
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

    //绑定
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);   //任意IP地址
    bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

    //设置监听
    Listen(lfd, 128);

    struct pollfd client[1024];
    int i;
    for(i=0; i<1024; i++)
    {
        client[i].fd = -1;
    }

    //将监听文件描述符委托给内核监控 --- 监控读事件
    client[0].fd = lfd;
    client[0].events = POLLIN;

    int nready;
    int maxfd = 0;
    int cfd;
    int sockfd;
    int n;
    char buf[1024];
    char sIP[16];
    socklen_t len;
    struct sockaddr_in clit;
    while(1)
    {
        nready = poll(client, maxfd+1, -1);
        if(nready<0)
        {
            if(errno==EINTR)    //被信号中断
            {
                continue;
            }
            break;
        }

        //有客户端连接请求到来
        if(client[0].fd==lfd && (client[0].revents & POLLIN))
        {
            //接受新的客户端连接请求
            memset(sIP, 0x00, sizeof(sIP));
            len = sizeof(clit);
            bzero(&clit, sizeof(clit));
            cfd = Accept(lfd, (struct sockaddr *)&clit, &len);
            printf("client:[%s] [%d]\n", inet_ntop(AF_INET, &(clit.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(clit.sin_port));

            //寻找client数组中的可用位置
            for(i=1; i<1024; i++)
            {
                if(client[i].fd==-1)
                {
                    client[i].fd = cfd;
                    client[i].events = POLLIN;
                    break;
                }
            }

            //若没有可用位置，则关闭连接
            if(i==1024)
            {
                close(cfd);
                continue;
            }

            //修改内核的监控范围
            if(maxfd<i)
            {
                maxfd = i;
            }

            if(--nready==0)
            {
                continue;
            }

        }

        //有客户端数据发来情况
        for(i=1; i<=maxfd; i++)
        {
            //若fd为-1，表示连接已经关闭或者没有连接
            if(client[i].fd==-1)
            {
                continue;
            }

            if(client[i].revents==POLLIN)
            {
                sockfd = client[i].fd;
                //读数据
                memset(buf, 0x00, sizeof(buf));
                n = Read(sockfd, buf, sizeof(buf));
                if(n<=0)
                {
                    printf("read error or client closed ,n==[%d]\n", n);
                    //关闭连接
                    close(sockfd);
                    client[i].fd = -1;
                }
                else
                {
                    memset(sIP, 0x00, sizeof(sIP));
                    printf("client:[%s] [%d], buf==[%s]\n", inet_ntop(AF_INET, &(clit.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(clit.sin_port), buf);

                    int k;
                    for(k=0; k<n; k++)
                    {
                        buf[k] = toupper(buf[k]);
                    }

                    //发送数据
                    Write(sockfd, buf, n);
                }

                if(--nready==0)
                {
                    break;
                }
            }
        }
    }

    //关闭监听文件描述符
    close(lfd);

    return 0;
}

6、epoll网络服务器

//多路IO复用---epoll网络服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <sys/epoll.h>
#include <ctype.h>
#include <fcntl.h>
#include "wrap.h"

int main(int argc,char *argv[])
{
    //创建socket
    int lfd = Socket(AF_INET, SOCK_STREAM, 0);

    //设置端口复用
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

    //绑定
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);   //任意IP地址
    bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

    //设置监听
    Listen(lfd, 128);

    //创建epoll树
    int epfd = epoll_create(1024);
    if(epfd<0)
    {
        perror("eprll_create error");
        close(lfd);
        return -1;
    }

    //将lfd上epfd树
    //int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    struct epoll_event ev;
    ev.data.fd = lfd;
    ev.events = EPOLLIN;
    epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    int nready;
    int cfd;
    int sockfd;
    int n;
    int i;
    char buf[1024];
    char sIP[16];
    socklen_t len;
    memset(sIP, 0x00, sizeof(sIP));
    struct sockaddr_in client;
    bzero(&client, sizeof(client));
    struct epoll_event events[1024];
    //循环等待时间的发生
    while(1)
    {
        //int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
        nready = epoll_wait(epfd, events, 1024, -1);
        if(nready<0)
        {
            perror("epoll_wait error");
            if(errno==EINTR)    //被信号中断
            {
                continue;
            }
            break;
        }

        for(i=0; i<nready; i++)
        {
            len = sizeof(client);
            sockfd = events[i].data.fd;
            //有客户端连接请求到来
            if(sockfd==lfd)
            {
                cfd = Accept(lfd, (struct sockaddr *)&client, &len);
                printf("client:[%s] [%d]\n", inet_ntop(AF_INET, (struct sockaddr *)&client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));

                //将新的通信文件描述符上树
                ev.data.fd = cfd;
                //ev.events = EPOLLIN;  //默认是水平触发模式
                ev.events = EPOLLIN | EPOLLET;  //设置边缘触发模式
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);

                //将cfd设置为非阻塞模式
                int flags = fcntl(cfd, F_GETFL, 0);
                flags |= O_NONBLOCK;
                fcntl(cfd, F_SETFL, flags);
                continue;
            }

            //有客户端数据发来
            while(1)
            {
                memset(buf, 0x00, sizeof(buf));
                //n = Read(sockfd, buf, sizeof(buf));
                n = Read(sockfd, buf, 2);
                if(n==-1)    //read error or read over
                {
                    printf("read over, n==[%d]\n",n);
                    break;
                }
                
                //对方关闭连接或者读异常
                if(n==0 || (n<0 && n!=-1))
                {
                    printf("n==[%d], buf==[%s]\n", n, buf);
                    Close(sockfd);
                    //将sockfd对应的事件下树
                    epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
                    break;
                }
                else   //正常读到数据
                {
                    printf("client:[%s] [%d], [%s]\n", inet_ntop(AF_INET, (struct sockaddr *)&client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port), buf);

                    int k = 0;
                    for(k=0; k<n; k++)
                    {
                        buf[k] = toupper(buf[k]);
                    }
                    //回应数据
                    Write(sockfd, buf, n);
                }
            }
        }
    }

    //关闭文件根结点和监听文件描述符
    Close(epfd);
    Close(lfd);

    return 0;
}

7、epoll反应堆网络服务器

//多路IO复用---epoll反应堆网络服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <ctype.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "wrap.h"

#define BUF_LEN 1024
#define EVENT_SIZE 1024

//全局变量
int gepfd = 0;

//函数申明
void readdata(int fd, int events, void *arg);

//事件驱动结构体
typedef struct Event
{
    int fd;
    int events;
    void (*call_back)(int fd, int events, void *arg);
    void *arg;
    char buf[1024];
    int buflen;
    int epfd;
}xevent;
xevent myevents[EVENT_SIZE+1];

//添加事件
void eventadd(int fd, int events, void (*call_back)(int, int, void *), void *arg, xevent *ev)
{
    ev->fd = fd;
    ev->events = events;
    ev->arg = arg;
    ev->call_back = call_back;

    struct epoll_event epv;
    epv.events = events;
    epv.data.ptr = ev;
    epoll_ctl(gepfd, EPOLL_CTL_ADD, fd, &epv);  //上树
}

//修改事件
void eventset(int fd, int events, void (*call_back)(int, int, void *), void *arg, xevent *ev)
{
    ev->fd = fd;
    ev->events = events;
    ev->arg = arg;
    ev->call_back = call_back;

    struct epoll_event epv;
    epv.events = events;
    epv.data.ptr = ev;
    epoll_ctl(gepfd, EPOLL_CTL_MOD, fd, &epv);   //修改事件
}

//删除事件
void eventdel(xevent *ev, int fd, int events)
{
    printf("begin call %s\n", __FUNCTION__);
    
    ev->fd = 0;
    ev->events = 0;
    ev->call_back = NULL;
    memset(ev->buf, 0x00, sizeof(ev->buf));
    ev->buflen = 0;

    struct epoll_event epv;
    epv.data.ptr = NULL;
    epv.events = events;
    epoll_ctl(gepfd, EPOLL_CTL_DEL, fd, &epv);  //下树
}

//发送数据
void senddata(int fd, int events, void *arg)
{
    printf("begin call %s\n", __FUNCTION__);

    xevent *ev = arg;
    Write(fd, ev->buf, ev->buflen);
    eventset(fd, EPOLLIN, readdata, arg, ev);
}

//读数据
void readdata(int fd, int events, void *arg)
{
    printf("begin call %s\n", __FUNCTION__);
    xevent *ev = arg;

    ev->buflen = Read(fd, ev->buf, sizeof(ev->buf));
    if(ev->buflen>0)      //读到数据
    {
        eventset(fd, EPOLLOUT, senddata, arg, ev);
        printf("n==[%d] buf==[%s]\n", ev->buflen, ev->buf);

        int i = 0;
        for(i=0; i<ev->buflen; i++)
        {
            ev->buf[i] = toupper(ev->buf[i]);
        }
    }
    else if(ev->buflen==0)   //对方关闭连接
    {
        Close(fd);
        eventdel(ev, fd, EPOLLIN);
    }
}

//新连接处理
void initAccept(int fd, int events, void *arg)
{
    printf("begin call %s, grep==%d\n", __FUNCTION__, gepfd);

    int i;
    struct sockaddr_in client;
    char sIP[16];
    memset(sIP, 0x00, sizeof(sIP));
    bzero(&client, sizeof(client));
    socklen_t len = sizeof(client);
    int cfd = Accept(fd, (struct sockaddr *)&client, &len);
    printf("client:[%s] [%d]\n",inet_ntop(AF_INET, (struct soctaddr *)&client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));

    //查找myevents数组中可用的位置
    for(i=0; i<EVENT_SIZE; i++)
    {
        if(myevents[i].fd = 0)
        {
            break;
        }
    }

    //设置新连接为读事件
    eventadd(cfd, EPOLLIN, readdata, &myevents[i], &myevents[i]);
}

int main(int argc,char *argv[])
{
    //创建socket
    int lfd = Socket(AF_INET, SOCK_STREAM, 0);

    //设置端口复用
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));

    //绑定
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);   //任意IP地址
    bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

    //设置监听
    Listen(lfd, 128);

    //创建epoll树
    gepfd = epoll_create(1024);
    if(gepfd<0)
    {
        perror("eprll_create error");
        close(lfd);
        return -1;
    }
    printf("gepfd==[%d]\n", gepfd);

    struct epoll_event events[1024];

    //添加最初始的事件，将监听文件描述符上树
    //void eventadd(int fd, int events, void (*call_back)(int, int, void *), void *arg, xevent *ev)
    eventadd(lfd, EPOLLIN, initAccept, &myevents[EVENT_SIZE], &myevents[EVENT_SIZE]);
    
    while(1)
    {
        int nready = epoll_wait(gepfd, events, 1024, -1);
        if(nready<0)   //调用epoll_wait失败
        {
            perr_exit("epoll_wait error");
        }
        else if(nready>0)   //调用epoll_wait成功，返回有事件发生的文件描述符的个数
        {
            int i = 0;
            for(i=0; i<nready; i++)
            {
                xevent *xe = events[i].data.ptr;   //取ptr指向的结构体地址
                printf("fd==%d\n", xe->fd);

                if(xe->events & events[i].events)
                {
                    xe->call_back(xe->fd, xe->events, xe);   //调用事件的回调函数
                }
            }
        }
    }

    //关闭监听文件描述符
    Close(lfd);

    return 0;
}

8、udp通信

//udp服务端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>

int main(int argc,char *argv[])
{
    //创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd<0)
    {
        perror("socket error");
        return -1;
    }

    //绑定
    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    serv.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(sockfd, (struct sockaddr *)&serv, sizeof(serv));
    
    int n;
    char sIP[16];
    char buf[1024];
    socklen_t len;
    struct sockaddr_in client;
    while(1)
    {
        //接收数据
        len = sizeof(client);
        memset(sIP, 0x00, sizeof(sIP));
        memset(buf, 0x00, sizeof(buf));
        bzero(&client, sizeof(client));
        n = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&client, &len);
        printf("client:[%s] [%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));

        if(n<0)   //读失败
        {
            printf("recvfrom error, n==[%d]\n", n);
            continue;
        }
        if(n==0)   //没有读到数据
        {
            printf("no data recvied, n==[%d]\n", n);
            continue;
        }
        else if(n>0)
        {
            printf("n==[%d], buf==[%s]\n", n, buf);

            len = sizeof(client);
            int i;
            for(i=0; i<n; i++)
            {
                buf[i] = toupper(buf[i]);
            }
            sendto(sockfd, buf, n, 0, (struct sockaddr *)&client, len);
        }
    }

    //关闭文件描述符
    close(sockfd);

	return 0;
}

//udp客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

int main(int argc,char *argv[])
{
    //创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd<0)
    {
        perror("socket error");
        return -1;
    }

    struct sockaddr_in serv;
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8888);
    inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr);

    int n;
    char sIP[16];
    char buf[1024];
    socklen_t len;
    struct sockaddr_in client;

    while(1)
    {
        //发送数据
        memset(buf, 0x00, sizeof(buf));
        n = read(STDIN_FILENO, buf, sizeof(buf));
        sendto(sockfd,buf, n, 0, (struct sockaddr *)&serv, sizeof(serv));

        //接收数据
        memset(buf, 0x00, sizeof(buf));
        n = recvfrom(sockfd, buf, sizeof(buf), 0, NULL, NULL);
        printf("n==[%d] [%s]\n", n, buf);
    }   

    //关闭文件描述符
    close(sockfd);

	return 0;
}

9、线程池

#ifndef _THREADPOOL_H
#define _THREADPOOL_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>


typedef struct _PoolTask
{
    int tasknum;//模拟任务编号
    void *arg;//回调函数参数
    void (*task_func)(void *arg);//任务的回调函数
}PoolTask ;

typedef struct _ThreadPool
{
    int max_job_num;//最大任务个数
    int job_num;//实际任务个数
    PoolTask *tasks;//任务队列数组
    int job_push;//入队位置
    int job_pop;// 出队位置

    int thr_num;//线程池内线程个数
    pthread_t *threads;//线程池内线程数组
    int shutdown;//是否关闭线程池
    pthread_mutex_t pool_lock;//线程池的锁
    pthread_cond_t empty_task;//任务队列为空的条件
    pthread_cond_t not_empty_task;//任务队列不为空的条件

}ThreadPool;

void create_threadpool(int thrnum,int maxtasknum);//创建线程池--thrnum  代表线程个数，maxtasknum 最大任务个数
void destroy_threadpool(ThreadPool *pool);//摧毁线程池
void addtask(ThreadPool *pool);//添加任务到线程池
void taskRun(void *arg);//任务回调函数
#endif

//简易版线程池
#include "threadpoolsimple.h"

ThreadPool *thrPool = NULL;

int beginnum = 1000;

void *thrRun(void *arg)
{
    //printf("begin call %s-----\n",__FUNCTION__);
    ThreadPool *pool = (ThreadPool*)arg;
    int taskpos = 0;//任务位置
    PoolTask *task = (PoolTask *)malloc(sizeof(PoolTask));

    while(1)
	{
        //获取任务，先要尝试加锁
        pthread_mutex_lock(&thrPool->pool_lock);

		//无任务并且线程池不是要摧毁
        while(thrPool->job_num <= 0 && !thrPool->shutdown )
		{
			//如果没有任务，线程会阻塞
            pthread_cond_wait(&thrPool->not_empty_task,&thrPool->pool_lock);
        }
        
        if(thrPool->job_num)
		{
            //有任务需要处理
            taskpos = (thrPool->job_pop++)%thrPool->max_job_num;
            //printf("task out %d...tasknum===%d tid=%lu\n",taskpos,thrPool->tasks[taskpos].tasknum,pthread_self());
			//为什么要拷贝？避免任务被修改，生产者会添加任务
            memcpy(task,&thrPool->tasks[taskpos],sizeof(PoolTask));
            task->arg = task;
            thrPool->job_num--;
            //task = &thrPool->tasks[taskpos];
            pthread_cond_signal(&thrPool->empty_task);//通知生产者
        }

        if(thrPool->shutdown)
		{
            //代表要摧毁线程池，此时线程退出即可
            //pthread_detach(pthread_self());//临死前分家
            pthread_mutex_unlock(&thrPool->pool_lock);
            free(task);
			pthread_exit(NULL);
        }

        //释放锁
        pthread_mutex_unlock(&thrPool->pool_lock);
        task->task_func(task->arg);//执行回调函数
    }
    
    //printf("end call %s-----\n",__FUNCTION__);
}

//创建线程池
void create_threadpool(int thrnum,int maxtasknum)
{
    printf("begin call %s-----\n",__FUNCTION__);
    thrPool = (ThreadPool*)malloc(sizeof(ThreadPool));

    thrPool->thr_num = thrnum;
    thrPool->max_job_num = maxtasknum;
    thrPool->shutdown = 0;//是否摧毁线程池，1代表摧毁
    thrPool->job_push = 0;//任务队列添加的位置
    thrPool->job_pop = 0;//任务队列出队的位置
    thrPool->job_num = 0;//初始化的任务个数为0

    thrPool->tasks = (PoolTask*)malloc((sizeof(PoolTask)*maxtasknum));//申请最大的任务队列

    //初始化锁和条件变量
    pthread_mutex_init(&thrPool->pool_lock,NULL);
    pthread_cond_init(&thrPool->empty_task,NULL);
    pthread_cond_init(&thrPool->not_empty_task,NULL);

    int i = 0;
    thrPool->threads = (pthread_t *)malloc(sizeof(pthread_t)*thrnum);//申请n个线程id的空间
	
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    for(i = 0;i < thrnum;i++)
	{
        pthread_create(&thrPool->threads[i],&attr,thrRun,(void*)thrPool);//创建多个线程
    }
    //printf("end call %s-----\n",__FUNCTION__);
}
//摧毁线程池
void destroy_threadpool(ThreadPool *pool)
{
    pool->shutdown = 1;//开始自爆
    pthread_cond_broadcast(&pool->not_empty_task);//诱杀 

    int i = 0;
    for(i = 0; i < pool->thr_num ; i++)
	{
        pthread_join(pool->threads[i],NULL);
    }

    pthread_cond_destroy(&pool->not_empty_task);
    pthread_cond_destroy(&pool->empty_task);
    pthread_mutex_destroy(&pool->pool_lock);

    free(pool->tasks);
    free(pool->threads);
    free(pool);
}

//添加任务到线程池
void addtask(ThreadPool *pool)
{
    //printf("begin call %s-----\n",__FUNCTION__);
    pthread_mutex_lock(&pool->pool_lock);

	//实际任务总数大于最大任务个数则阻塞等待(等待任务被处理)
    while(pool->max_job_num <= pool->job_num)
	{
        pthread_cond_wait(&pool->empty_task,&pool->pool_lock);
    }

    int taskpos = (pool->job_push++)%pool->max_job_num;
    //printf("add task %d  tasknum===%d\n",taskpos,beginnum);
    pool->tasks[taskpos].tasknum = beginnum++;
    pool->tasks[taskpos].arg = (void*)&pool->tasks[taskpos];
    pool->tasks[taskpos].task_func = taskRun;
    pool->job_num++;

    pthread_mutex_unlock(&pool->pool_lock);

    pthread_cond_signal(&pool->not_empty_task);//通知包身工
    //printf("end call %s-----\n",__FUNCTION__);
}

//任务回调函数
void taskRun(void *arg)
{
    PoolTask *task = (PoolTask*)arg;
    int num = task->tasknum;
    printf("task %d is runing %lu\n",num,pthread_self());

    sleep(1);
    printf("task %d is done %lu\n",num,pthread_self());
}


int main()
{
    create_threadpool(3,20);
    int i = 0;
    for(i = 0;i < 50 ; i++)
	{
        addtask(thrPool);//模拟添加任务
    }

    sleep(20);
    destroy_threadpool(thrPool);

    return 0;
}

10、web服务器

//pub.h
#ifndef _PUB_H
#define _PUB_H
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.h>
#include <ctype.h>
char *get_mime_type(char *name);
int get_line(int sock, char *buf, int size);
int hexit(char c);//16进制转10进制
void strencode(char* to, size_t tosize, const char* from);//编码
void strdecode(char *to, char *from);//解码
#endif

//pub.c
#include "pub.h"
//通过文件名字获得文件类型
char *get_mime_type(char *name)
{
    char* dot;

    dot = strrchr(name, '.');	//自右向左查找‘.’字符;如不存在返回NULL
    /*
     *charset=iso-8859-1	西欧的编码，说明网站采用的编码是英文；
     *charset=gb2312		说明网站采用的编码是简体中文；
     *charset=utf-8			代表世界通用的语言编码；
     *						可以用到中文、韩文、日文等世界上所有语言编码上
     *charset=euc-kr		说明网站采用的编码是韩文；
     *charset=big5			说明网站采用的编码是繁体中文；
     *
     *以下是依据传递进来的文件名，使用后缀判断是何种文件类型
     *将对应的文件类型按照http定义的关键字发送回去
     */
    if (dot == (char*)0)
        return "text/plain; charset=utf-8";
    if (strcmp(dot, ".html") == 0 || strcmp(dot, ".htm") == 0)
        return "text/html; charset=utf-8";
    if (strcmp(dot, ".jpg") == 0 || strcmp(dot, ".jpeg") == 0)
        return "image/jpeg";
    if (strcmp(dot, ".gif") == 0)
        return "image/gif";
    if (strcmp(dot, ".png") == 0)
        return "image/png";
    if (strcmp(dot, ".css") == 0)
        return "text/css";
    if (strcmp(dot, ".au") == 0)
        return "audio/basic";
    if (strcmp( dot, ".wav") == 0)
        return "audio/wav";
    if (strcmp(dot, ".avi") == 0)
        return "video/x-msvideo";
    if (strcmp(dot, ".mov") == 0 || strcmp(dot, ".qt") == 0)
        return "video/quicktime";
    if (strcmp(dot, ".mpeg") == 0 || strcmp(dot, ".mpe") == 0)
        return "video/mpeg";
    if (strcmp(dot, ".vrml") == 0 || strcmp(dot, ".wrl") == 0)
        return "model/vrml";
    if (strcmp(dot, ".midi") == 0 || strcmp(dot, ".mid") == 0)
        return "audio/midi";
    if (strcmp(dot, ".mp3") == 0)
        return "audio/mpeg";
    if (strcmp(dot, ".ogg") == 0)
        return "application/ogg";
    if (strcmp(dot, ".pac") == 0)
        return "application/x-ns-proxy-autoconfig";

    return "text/plain; charset=utf-8";
}

//获得一行数据，每行以\r\n作为结束标记
int get_line(int sock, char *buf, int size)
{
    int i = 0;
    char c = '\0';
    int n;

    while ((i < size - 1) && (c != '\n'))
    {
        n = recv(sock, &c, 1, 0);
        /* DEBUG printf("%02X\n", c); */
        if (n > 0)
        {
            if (c == '\r')
            {
                n = recv(sock, &c, 1, MSG_PEEK);//MSG_PEEK 从缓冲区读数据，但是数据不从缓冲区清除
                /* DEBUG printf("%02X\n", c); */
                if ((n > 0) && (c == '\n'))
                    recv(sock, &c, 1, 0);
                else
                    c = '\n';
            }
            buf[i] = c;
            i++;
        }
        else
            c = '\n';
    }
    buf[i] = '\0';

    return(i);
}

/*
 * 这里的内容是处理%20之类的东西！是"解码"过程。
 * %20 URL编码中的‘ ’(space)
 * %21 '!' %22 '"' %23 '#' %24 '$'
 * %25 '%' %26 '&' %27 ''' %28 '('......
 * 相关知识html中的‘ ’(space)是&nbsp
 */
void strdecode(char *to, char *from)
{
    for ( ; *from != '\0'; ++to, ++from) {

        if (from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2])) { //依次判断from中 %20 三个字符

            *to = hexit(from[1])*16 + hexit(from[2]);//字符串E8变成了真正的16进制的E8
            from += 2;                      //移过已经处理的两个字符(%21指针指向1),表达式3的++from还会再向后移一个字符
        } else
            *to = *from;
    }
    *to = '\0';
}

//16进制数转化为10进制, return 0不会出现
int hexit(char c)
{
    if (c >= '0' && c <= '9')
        return c - '0';
    if (c >= 'a' && c <= 'f')
        return c - 'a' + 10;
    if (c >= 'A' && c <= 'F')
        return c - 'A' + 10;

    return 0;
}

//"编码"，用作回写浏览器的时候，将除字母数字及/_.-~以外的字符转义后回写。
//strencode(encoded_name, sizeof(encoded_name), name);
void strencode(char* to, size_t tosize, const char* from)
{
    int tolen;

    for (tolen = 0; *from != '\0' && tolen + 4 < tosize; ++from) {
        if (isalnum(*from) || strchr("/_.-~", *from) != (char*)0) {
            *to = *from;
            ++to;
            ++tolen;
        } else {
            sprintf(to, "%%%02x", (int) *from & 0xff);
            to += 3;
            tolen += 3;
        }
    }
    *to = '\0';
}

//web服务端程序--使用epoll模型 webserver.c
#include <unistd.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>
#include <signal.h>
#include <dirent.h>

#include "pub.h"
#include "wrap.h"

int http_request(int cfd, int epfd);

int main()
{
	//若web服务器给浏览器发送数据的时候, 浏览器已经关闭连接, 
	//则web服务器就会收到SIGPIPE信号
	struct sigaction act;
	act.sa_handler = SIG_IGN;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGPIPE, &act, NULL);
	
	//改变当前进程的工作目录
	char path[255] = {0};
	sprintf(path, "%s/%s", getenv("HOME"), "webpath");
	chdir(path);
	printf("path==[%s]\n", path);
	
	//创建socket--设置端口复用---bind
	int lfd = tcp4bind(9999, NULL);
	
	//设置监听
	Listen(lfd, 128);

	//创建epoll树
	int epfd = epoll_create(1024);
	if(epfd<0)
	{
		perror("epoll_create error");
		close(lfd);
		return -1;
	}
	
	//将监听文件描述符lfd上树
	struct epoll_event ev;
	ev.data.fd = lfd;
	ev.events = EPOLLIN;
	epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
	
	int i;
	int cfd;
	int nready;
	int sockfd;
	struct epoll_event events[1024];
	while(1)
	{
		//等待事件发生
		nready = epoll_wait(epfd, events, 1024, -1);
		if(nready<0)
		{
			if(errno==EINTR)
			{
				continue;
			}
			break;
		}
		
		for(i=0; i<nready; i++)
		{
			sockfd = events[i].data.fd;
			//有客户端连接请求
			if(sockfd==lfd)
			{
				//接受新的客户端连接
				cfd = Accept(lfd, NULL, NULL);
				
				//设置cfd为非阻塞
				int flag = fcntl(cfd, F_GETFL);
				flag |= O_NONBLOCK;
				fcntl(cfd, F_SETFL, flag);
				
				//将新的cfd上树
				ev.data.fd = cfd;
				ev.events = EPOLLIN;
				epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
			}
			else 
			{
				//有客户端数据发来
				http_request(sockfd, epfd);
			}			
		}		
	}
}

int send_header(int cfd, char *code, char *msg, char *fileType, int len)
{
	char buf[1024] = {0};
	sprintf(buf, "HTTP/1.1 %s %s\r\n", code, msg);  //状态行 包括http版本号,状态码,状态信息
	//消息报头 说明客户端要使用的一些附加信息,也是键值对
	sprintf(buf+strlen(buf), "Content-Type:%s\r\n", fileType);
	if(len>0)
	{
		sprintf(buf+strlen(buf), "Content-Length:%d\r\n", len);
	}
	strcat(buf, "\r\n");  //空行 \r\n 同样不能省略
	Write(cfd, buf, strlen(buf));
	return 0;
}

int send_file(int cfd, char *fileName)
{
	//打开文件
	int fd = open(fileName, O_RDONLY);
	if(fd<0)
	{
		perror("open error");
		return -1;
	}
	
	//循环读文件, 然后发送
	int n;
	char buf[1024];
	while(1)
	{
		memset(buf, 0x00, sizeof(buf));
		n = read(fd, buf, sizeof(buf));
		if(n<=0)
		{
			break;
		}
		else 
		{
			Write(cfd, buf, n);
		}
	}
}

int http_request(int cfd, int epfd)
{
	int n;
	char buf[1024];
	//读取 请求行 数据, 分析出要请求的资源文件名
	memset(buf, 0x00, sizeof(buf));
	n = Readline(cfd, buf, sizeof(buf));
	if(n<=0)
	{
		//printf("read error or client closed, n==[%d]\n", n);
		//关闭连接
		close(cfd);
		
		//将文件描述符从epoll树上删除
		epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, NULL);
		return -1;	
	}
	printf("buf==[%s]\n", buf);
	//GET /hanzi.c HTTP/1.1
	char reqType[16] = {0};
	char fileName[255] = {0};
	char protocal[16] = {0};
	sscanf(buf, "%[^ ] %[^ ] %[^ \r\n]", reqType, fileName, protocal);
	//printf("[%s]\n", reqType);
	printf("--[%s]--\n", fileName);
	//printf("[%s]\n", protocal);
	
	char *pFile = fileName;
	if(strlen(fileName)<=1)
	{
		strcpy(pFile, "./");
	}
	else 
	{
		pFile = fileName+1;
	}
	
	//转换汉字编码
	strdecode(pFile, pFile);
	printf("[%s]\n", pFile);
	
	//循环读取完剩余的数据,避免产生粘包
	while((n=Readline(cfd, buf, sizeof(buf)))>0);
	
	//判断文件是否存在
	struct stat st;
	if(stat(pFile, &st)<0)
	{
		printf("file not exist\n");
		
		//发送头部信息
		send_header(cfd, "404", "NOT FOUND", get_mime_type(".html"), 0);
		
		//发送文件内容
		send_file(cfd, "error.html");	  //响应正文 服务器返回给客户端的文本信息
	}
	else //若文件存在
	{
		//判断文件类型
		//普通文件
		if(S_ISREG(st.st_mode))
		{
			printf("file exist\n");
			//发送头部信息
			send_header(cfd, "200", "OK", get_mime_type(pFile), st.st_size);
			
			//发送文件内容
			send_file(cfd, pFile);    //响应正文 服务器返回给客户端的文本信息
		}
		//目录文件
		else if(S_ISDIR(st.st_mode))
		{
			printf("目录文件\n");
			
			char buffer[1024];
			//发送头部信息
			send_header(cfd, "200", "OK", get_mime_type(".html"), 0);	
			
			//发送html文件头部
			send_file(cfd, "html/dir_header.html");	
			
			//文件列表信息
			struct dirent **namelist;
			int num;

			num = scandir(pFile, &namelist, NULL, alphasort);
			if (num < 0)
			{
			   perror("scandir");
			   close(cfd);
			   epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, NULL);
			   return -1;
			   
			}
			else 
			{
			   while (num--) 
			   {
			       printf("%s\n", namelist[num]->d_name);
			       memset(buffer, 0x00, sizeof(buffer));
			       if(namelist[num]->d_type==DT_DIR)  //目录文件
			       {
			       		sprintf(buffer, "<li><a href=%s/>%s</a></li>", namelist[num]->d_name, namelist[num]->d_name);
			       }
			       else   //普通文件
			       {
			       		sprintf(buffer, "<li><a href=%s>%s</a></li>", namelist[num]->d_name, namelist[num]->d_name);
			       }
			       free(namelist[num]);
			       Write(cfd, buffer, strlen(buffer));   //发送文件中间内容
			   }
			   free(namelist);
			}
			//发送html尾部
			sleep(10);
			send_file(cfd, "html/dir_tail.html");		
		}
	}
	
	return 0;
}
浪迹天崖_1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式网络编程wrap.h与wrap.c的两种编译
libochun3217的专栏
06-14 2208
*************************************************************************************************************wrap.c文件*********************************************** #include "wrap.h"  void perr_exit
TCPIP网络编程
03-16
最适合入门的网络编程入门书，初学者必看
网络编程函数的封装
嵌入式
05-22 361
封装目的： 在 server.c 编程过程中突出逻辑，将出错处理与逻辑分开，可以直接跳转man手册。 【wrap.c】 存放网络通信相关常用 自定义函数。 【wrap.h】 存放 网络通信相关常用 自定义函数原型(声明)。 命名方式：系统调用函数首字符大写, 方便查看man手册 如：Listen()、Accept(); 函数功能：调用系统调用函数，处理出错场景。 在 server.c...
Linux 网络编程 wrap.c和wrap.h
qq_36229636的博客
11-29 1502
部分转载自：https://blog.csdn.net/libochun3217/article/details/9095569 添加ssize_t Readline(int fd,void *vptr,size_t maxlen);函数 wrap.h #ifndef WRAP_H #define WRAP_H #include <stdlib.h> #include <errno.h> #include <sys/socket.h> void perr
Linux 网络连接出错处理
浮躁的人，终究一事无成！
06-28 671
1.wrap.h #ifndef __WRAP_H_ #define __WRAP_H_ void perr_exit(const char *s); int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr); void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
TCP网络编程
weixin_47783699的博客
11-20 670
TCP网络编程，实现客户端 与 网络助手 相互通信
C++网络编程文档
03-16
C++网络编程是计算机科学中的一个重要领域，它允许开发者创建能够通过网络进行通信的应用程序。这份"C++网络编程文档"涵盖了这一主题的广泛内容，旨在帮助程序员深入理解并掌握网络编程的基本概念和技术。 首先，...
UNIX网络编程
03-12
对于开发网游服务器的人开说，是本非常好的书，书中核心的学习部分还是SOCKET 套接口基本API相关的使用和注意细节，其他部分...网络游戏服务端编程其实针对网络底层所需要的技术点并不多，因此此书只需要针对性的学习。
（网络编程笔记）：TCP建立连接过程、滑动窗口、函数封装思想、粘包及并发案例
baidu_41388533的博客
10-16 388
三次握手和四次挥手 三次握手: 建立连接需要三次握手过程 四次挥手: 断开连接需要四次挥手过程 TCP是面向连接的安全的数据传输 在客户端与服务端建立建立的时候要经过三次握手的过程，在客户端与服务端断开连接的时候要经历四次挥手的过程，下图是客户端与服务端三次握手建立连接, 数据传输和断开连接四次挥手的全过程。 TCP时序: 图的含义 SYN：表示请求 ACK：表示确认 mss：表示最大段尺寸，如果一个段太大，封装成帧后超过了链路层的最大帧长度，就必须在IP层...
linux select编程示例
心清的专栏
12-07 4843
select编程示例 代码中出现的errwrap.h和errwrap.c请参考我的上一篇文章 服务器 #include #include #include #include #include #include "errwrap.h" #define MAXLINE 80 #define SERVERPORT 8000 int main(int argc, char *argv[
套接字错误处理函数的封装思想及函数实现
weixin_42374938的博客
08-08 702
一、套接字错误处理函数的封装思想 在上篇文章中的 CS 模型，存在 bug： 先关 server，再关 client，立即再启动 server，此时会发现无法启动。原因是：先关 server，再关 client，执行 shell 命令netstat -apn | grep 端口号，会发现服务器处于 “TIME_WAIT”状态，即不是真正的退出状态，也就 意味着，原先 server 端口号并没有被释放掉，再次启动 server，因为端口号是固定的，而且正在被占用中，所以无法启动，问题出现在 bind 函数调用
linux网络编程二
luseysd的博客
04-13 139
Linux网络编程二——TCP通信时序、滑动窗口、多进程并发服务器、多线程并发服务器1 三次握手四次挥手建立连接（三次握手）的过程1.客户端发送一个带SYN标志的TCP报文到服务器，这是三次握手过程中的段1。2. 服务器端回应客户端，是三次握手中的第2个报文段。3. 客户必须再次回应服务器端一个ACK报文，这是报文段3。数据传输的过程关闭连接（四次握手）的过程2 滑动窗口3 函数封装思想（重要）4 多进程高并发服务器5 高并发多线程服务器 1 三次握手四次挥手 TCP是面向连接的安全的数据传输, 在客户端与
Linux网络编程 | “wrap.c“代码 | 一些系统调用函数的进一步封装
weixin_45615071的博客
03-05 671
"wrap.c"代码示例 #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <errno.h> #include <string.h> #include <sys/socket.h> #include <arpa/inet.h> #include <strings.h> void perr_exit(const char *s
27_MobileNetV3网络详解
https://github.com/foxpup11?tab=repositories
07-17 797
https://www.bilibili.com/video/BV1GK4y1p7uE/?spm_id_from=333.999.0.0&vd_source=7dace3632125a1ef7fd32c285eb2fbac
RTI DDS大数据碎片
qq_33089547的博客
07-17 950
PublicationBuiltingTopicData或SubscriptionBuiltnTopicData样本较大的最常见原因是序列化的TypeCode或TypeObject，但您也可能发送了大量属性（通过7.5.19 PROPERTY QosPolicy（DDS扩展））或具有较大的ContentFilteredTopic筛选器表达式，以及其他大小可变的字段，这可能会导致样本大小较大。如果您尝试发送一个大小大于MTU的DDS样本，但尚未设置DDS级碎片，您将看到IP级碎片。
Internet 控制报文协议 —— ICMPv4 和 ICMPv6 详解
u013669912的博客
07-17 770
…
计算机网络技术期末复习
最新发布
CWPIN21的博客
07-17 1013
本文深入探讨了计算机网络的核心概念与关键技术。涵盖了网络拓扑结构，如星型、总线型和环形等，分析了它们的特点与适用场景。详细阐述了 TCP/IP 协议栈的工作原理，包括 IP 地址分配、子网掩码的作用以及路由选择算法。还探讨了网络安全方面的常见威胁，如病毒、黑客攻击等，并介绍了相应的防护措施。通过实例，让读者对计算机网络有更全面、深入的理解。
【windows|014】TCP协议详解
小鹏linux的博客
07-15 1193
TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。它工作在OSI模型的第四层，即传输层，为用户提供可靠的、有序的和无差错的数据传输服务。TCP协议与UDP协议是传输层的两大主要协议，但两者在设计上有明显的不同：TCP提供的是可靠的数据传输服务，而UDP则更注重传输的速度和效率
计算机网络复习笔记【面向考纲整理】
无
07-13 395
计算机网络（简称网络）由若干结点（node，节点）和连接这些结点的链路（link）组成。
Beej的网络编程指南
这本书主要介绍了如何使用 Internet Sockets 进行网络编程，是网络编程初学者和进阶者的宝贵资料。 在书中，作者首先介绍了网络编程的基础概念，包括网络通信的基本原理，如TCP/IP协议栈、端口号和IP地址等。他详细...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值