SOCKET编程与复用

int fd = socket(AF_INET, SOCK_STREAM, 0);

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));

bind(fd, local_addr, sizeof(local_addr));

conn_fd = accept(fd, backlog);

recv(conn_fd, buff, sizeof(buff), 0);
send(conn_fd, buff, sizeof(buff), 0);

int fd = socket(AF_INET, SOCK_DGRAM, 0);

bind(fd, local_addr, sizeof(local_addr));

//和recv的区别是后两个参数是出参，能够获得IP地址，供sendto使用
recvfrom(fd, buff, sizeof(buff), 0, client_addr, sizeof(client_addr));
sendto(fd, buff, sizeof(buff), 0, client_addr, sizeof(client_addr));

pid_t pid = fork();

//接收到连接...
pid = fork();

if(pid !=0)
{
    continue;
}
//对accept_socket处理...

#include <sys/select.h>

int select(int nfds, fd_set *restrict readfds,
           fd_set *restrict writefds, fd_set *restrict exceptfds,
           struct timeval *restrict timeout);

void FD_CLR(int fd, fd_set *set);
int  FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);

 int select(int nfds, 				//三个fd_set里最大的数量
            fd_set *readfds, 		 //判断读是否阻塞的fd
            fd_set *writefds,		 //判断写是否阻塞的fd
            fd_set *exceptfds,  	 //判断是否有异常的fd
            struct timeval *timeout	 //阻塞超时
           );

#define __FD_SETSIZE	1024

typedef struct {
	unsigned long fds_bits[__FD_SETSIZE / (8 * sizeof(long))];
} __kernel_fd_set;

int main() {
	//变量定义，部分省略
	int ret = -1;

	int accept_fd = -1;
	int socket_fd = -1;
    //用于保存所有fd
	int accept_fds[FD_SIZE] = { -1, };

	int curpos = -1;
	int maxpos = 0;
	int backlog = 10;

	int max_fd = -1;
    //用于select
	fd_set fd_sets;
	int events = 0;

	//创建socket
	socket_fd = socket(AF_INET, SOCK_STREAM, 0);

	//设置NON_BLOCK和bind地址，省略...
    //skip...

    //listen
	ret = listen(socket_fd, backlog);

	max_fd = socket_fd;
	for (int i = 0; i < FD_SIZE; i++) {
		accept_fds[i] = -1;
	}

	for (;;) {

		FD_ZERO(&fd_sets); //清空sets
		FD_SET(socket_fd, &fd_sets); //将socket_fd 添加到sets

		for (int k = 0; k < maxpos; k++) {
			if (accept_fds[k] != -1) {
				if (accept_fds[k] > max_fd) {
					max_fd = accept_fds[k];
				}
				FD_SET(accept_fds[k], &fd_sets); //继续向sets添加fd
			}
		}

		//通过select找到是否有可写的
		events = select(max_fd + 1, &fd_sets, NULL, NULL, NULL);
        //经过select，不满足监控条件（可读可写等）的socket对应的那个bit位设为0，否则不变为1（通过此操作与array里存的所有socket进行对比得到是否可用）
		if (events < 0) {
			//error
			break;
		}
		else if (events == 0) {
			//timeout
			continue;
		}
		else if (events) {
			if (FD_ISSET(socket_fd, &fd_sets)) { // 如果来的是新连接
                 //分配一个新的，并存入array结构
				int a = 0;
				for (; a < FD_SIZE; a++) {
					if (accept_fds[a] == -1) {
						curpos = a;
						break;
					}
				}

				if (a == FD_SIZE) {
					printf("the connection is full!\n");
					continue;
				}

				int addr_len = sizeof(struct sockaddr_in);
				accept_fd = accept(socket_fd, (struct sockaddr*)&remote_addr, &addr_len); //创建一个新连接的fd

				int flags = fcntl(accept_fd, F_GETFL, 0); //取出新连接的 fd 的相关选项
				fcntl(accept_fd, F_SETFL, flags | O_NONBLOCK); //设置为非阻塞

                 //存入array结构
				accept_fds[curpos] = accept_fd;

				//修改maxpos和max_fd，省略...
			}

			for (int j = 0; j < maxpos; j++) {
				if ((accept_fds[j] != -1) && FD_ISSET(accept_fds[j], &fd_sets)) { //有事件时
					printf("accept event :%d, accept_fd: %d\n", j, accept_fds[j]);
                      //逻辑处理部分，例如发送与接收，部分省略...
					char in_buf[MESSAGE_SIZE];
					int ret = recv(accept_fds[j], &in_buf, MESSAGE_SIZE, 0);
					send(accept_fds[j], (void*)in_buf, MESSAGE_SIZE, 0);
				}
			}//end for
		}//end if events != 0
	}//end for

	//关闭socket，省略...

	return 0;
}

#include <sys/epoll.h>

int epoll_create(int size);
 int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
//op 操作模式
EPOLL_CTL_ADD
EPOLL_CTL_MOD
EPOLL_CTL_DEL
    
//epoll_event 事件
typedef union epoll_data {
    void        *ptr;
    int          fd;
    uint32_t     u32;
    uint64_t     u64;
} epoll_data_t;

struct epoll_event {
    uint32_t     events;      /* Epoll events */
    epoll_data_t data;        /* User data variable */
};

//Epoll events
EPOLLIN     //read
EPOLLOUT    //write
EPOLLRDHUP  
EPOLLPRI
EPOLLERR
EPOLLHUP
EPOLLET
EPOLLONESHOT
EPOLLWAKEUP
EPOLLEXCLUSIVE 

struct eventpoll {
　　...
　　/*红黑树的根节点，这棵树中存储着所有添加到epoll中的事件，
　　也就是这个epoll监控的事件*/
　　struct rb_root_cached rbr;
　　/*双向链表rdllist保存着将要通过epoll_wait返回给用户的、满足条件的事件*/
　　struct list_head rdllist;
　　...
};

int main() {

	int ret = -1;

	int socket_fd = -1;
	int accept_fd = -1;

	int curpos = 0;
	int backlog = 10;
	int flag = 1;
	int flags;

	char in_buf[MESSAGE_SIZE] = { 0, };
	struct sockaddr_in local_addr, remote_addr;

	int epoll_fd;
	struct epoll_event ev, events[MAX_EVENTS];
	int event_number;

	//创建socket，设置NON_BLOCK，设置opt，bind IP, 开启listen 已省略

	epoll_fd = epoll_create(256);
	//添加侦听socket，水平触发确保能接收到
	ev.events = EPOLLIN;
	ev.data.fd = socket_fd;
	epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &ev);

	//loop
	for (;;) {
		event_number = epoll_wait(epoll_fd, events, MAX_EVENTS, TIMEOUT);
		for (int i = 0; i < event_number; i++) {
			//该空闲socket是侦听socket
			if (events[i].data.fd == socket_fd) {
				//侦听socket空闲，连接新的
				socklen_t addr_len = sizeof(struct sockaddr_in);
				accept_fd = accept(socket_fd, (struct sockaddr*)&remote_addr, &addr_len);
				//设置非阻塞
				flags = fcntl(accept_fd, F_GETFL, 0);
				fcntl(accept_fd, F_SETLK, flags | O_NONBLOCK);
				//添加新的socket到epoll里
				ev.events = EPOLLIN | EPOLLET;
				ev.data.fd = accept_fd;
				epoll_ctl(epoll_fd, EPOLL_CTL_ADD, accept_fd, &ev);
			}
             //判断事件类型
			else if (events[i].events & EPOLLIN) {
				//该空闲socket是侦听socket
                  //逻辑处理
                  ret = recv(events[i].data.fd, (void*)in_buf, MESSAGE_SIZE, 0);
			}
		}

	}

	printf("quit server...\n");
	close(socket_fd);

	return 0;
}