Linux中select函数的使用举例

linux中select函数的使用例子

/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>
/* for select */
#include <sys/select.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

char rot13_char(char c) {
/* We don't want to use isalpha here; setting the locale would change
* which characters are considered alphabetical. */
if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
return c + 13;
else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
return c - 13;
else
return c;
}

struct fd_state {
char buffer[MAX_LINE];
size_t buffer_used;

int writing;
size_t n_written;
size_t write_upto;
};

struct fd_state * alloc_fd_state(void)
{
struct fd_state *state = malloc(sizeof(struct fd_state));
if (!state)
return NULL;
state->buffer_used = state->n_written = state->writing =
state->write_upto = 0;
return state;
}

void free_fd_state(struct fd_state *state) {
free(state);
}

void make_nonblocking(int fd) {
fcntl(fd, F_SETFL, O_NONBLOCK);
}

/*
* result = 0时，表示连接断开，return 0;
* resut = -1时，如果errno = EAGAIN，表示阻塞式socket无数据可读，return 0；
* result = -1时，如果errno != EAGAIN, 表示读取失败，return -1.
*/
int do_read(int fd, struct fd_state *state) {
char buf[1024];
int i;
ssize_t result;
while (1) {
/* 从终端设备读，通常以行为单位，读到换行符就返回了.
* recv函数返回时，不会添加'\0'结束符，因此buffer_used用来表示实际读取到的字节数。
*/
result = recv(fd, buf, sizeof(buf), 0);
printf("do_read, fd = %d, buf = %s, strlen(buf) = %d, recv return %d, errno = %d\n", fd, buf, strlen(buf), result, errno);
if (result <= 0)
break;

for (i = 0; i < result; ++i) {
if (state->buffer_used < sizeof(state->buffer))
state->buffer[state->buffer_used++] = buf[i];
/* 如果recv中碰到‘\n’，置该socket为可写状态, 一般从终端读取时最后一个字符为‘\n’.*/
if (buf[i] == '\n') {
state->writing = 1;
state->write_upto = state->buffer_used;
}
}
}

if (result == 0) {
return 1;
} else if (result < 0) {
if (errno == EAGAIN)
return 0;
return -1;
}

return 0;
}

/*
* 将state->write_upto个数据写入客户端，如果写入完毕，置为不可写状态.
* 写入失败则return -1；成功或发送缓冲区满则return 0.
* */
int do_write(int fd, struct fd_state *state) {
printf("do_write, fd = %d, state->written = %d, upto = %d\n", fd, state->n_written, state->write_upto);
while (state->n_written < state->write_upto) {
ssize_t result = send(fd, state->buffer + state->n_written,
state->write_upto - state->n_written, 0);
printf("do_write(), result = %d, fd = %d\n", result, fd);
if (result < 0) {
if (errno == EAGAIN) {
return 0;
}
return -1;
}
assert(result != 0);

state->n_written += result;
}

/*读到的数据已经全部写入客户端,则重置标志位*/
if (state->n_written == state->buffer_used) {
printf("Write completed\n");
state->n_written = state->write_upto = state->buffer_used = 0;
}

/*置为不可写状态*/
state->writing = 0;

return 0;
}

void run(int port)
{
struct fd_state *state[FD_SETSIZE];
struct sockaddr_in sin;
int i, maxfd;
fd_set readset, writeset, exset;

sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons(port);

printf("FD_SETSIZE = %d\n", FD_SETSIZE);
for (i = 0; i < FD_SETSIZE; ++i)
state[i] = NULL;

int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
printf("listen_fd = %d\n", listen_fd);
make_nonblocking(listen_fd);

#ifndef WIN32
{
int one = 1;
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
}
#endif

if (bind(listen_fd, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
perror("bind");
return;
}

if (listen(listen_fd, 16)<0) {
perror("listen");
return;
}

FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_ZERO(&exset);

while (1) {
maxfd = listen_fd;

FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_ZERO(&exset);

FD_SET(listen_fd, &readset);

/* maxfd表示描述符集中最大的一个 */
for (i = 0; i < FD_SETSIZE; ++i) {
if (state[i]) {
if (i > maxfd) {
maxfd = i;
}

FD_SET(i, &readset);
/*writing = 1表示该socket还有未发送的数据，添加对可写状态的监听.*/
if (state[i]->writing) {
FD_SET(i, &writeset);
}
}
}

if (select(maxfd + 1, &readset, &writeset, &exset, NULL) < 0) {
perror("select");
return;
}

/*判断listen_fd是否有读事件发生，即是否有新的连接过来.*/
if (FD_ISSET(listen_fd, &readset)) {
struct sockaddr_storage ss;
socklen_t slen = sizeof(ss);
int fd = accept(listen_fd, (struct sockaddr*) &ss, &slen);
if (fd < 0) {
perror("accept");
} else if (fd > FD_SETSIZE) {
close(fd);
} else {
make_nonblocking(fd);
state[fd] = alloc_fd_state();
assert(state[fd]);/*XXX*/
}
}

/*遍历0~maxfd描述符*/
for (i = 0; i < maxfd + 1; ++i) {
int r = 0;
if (i == listen_fd) {
continue;
}

if (FD_ISSET(i, &readset)) {
/*这里如果输入的数据很大, 是有可能比较耗时间的*/
r = do_read(i, state[i]);
}

if (r == 0 && FD_ISSET(i, &writeset)) {
r = do_write(i, state[i]);
}

/*读取或写入失败，则关闭该socket.*/
if (r) {
free_fd_state(state[i]);
state[i] = NULL;
close(i);
}
}
}
}

int main(int argc, char **argv) {
if(argc < 2) {
fprintf(stderr, "Usage:\n./server <port>\n");
exit(1);
}

setvbuf(stdout, NULL, _IONBF, 0);

run(atoi(argv[1]));
return 0;
}