select详解
select
- select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024，单纯改变进程打开的文件描述符个数并不能改变select监听文件个数
- 解决1024以下客户端时使用select是很合适的，但如果链接客户端过多，select采用的是轮询模型，会大大降低服务器响应效率，不应在select上投入更多精力
#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
nfds: 监控的文件描述符集里最大文件描述符加1，因为此参数会告诉内核检测前多少个文件描述符的状态
readfds： 监控有读数据到达文件描述符集合，传入传出参数
writefds： 监控写数据到达文件描述符集合，传入传出参数
exceptfds： 监控异常发生达文件描述符集合,如带外数据到达异常，传入传出参数
timeout： 定时阻塞监控时间，3种情况
1.NULL，永远等下去
2.设置timeval，等待固定时间
3.设置timeval里时间均为0，检查描述字后立即返回，轮询
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
void FD_CLR(int fd, fd_set *set); //把文件描述符集合里fd清0
int FD_ISSET(int fd, fd_set *set); //测试文件描述符集合里fd是否置1
void FD_SET(int fd, fd_set *set); //把文件描述符集合里fd位置1
void FD_ZERO(fd_set *set); //把文件描述符集合里所有位清0为了代码的简洁性首先将常用的函数进行了一次封装，分装了出错处理的内容
wrap.h
#ifndef __WRAP_H_
#define __WRAP_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);
#endif
wrap.c
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/socket.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;
}
server.c
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/select.h>
#include<unistd.h>
#include<sys/time.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<assert.h>
#define SIZE 128
#include"wrap.h"
int startup(char *ip,int port)
{
assert(ip);
int sock=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
struct sockaddr_in local;
local.sin_family=AF_INET;
local.sin_port=htons(port);
local.sin_addr.s_addr=inet_addr(ip);
Bind(sock,(struct sockaddr*)&local,sizeof(local));
Listen(sock,5);
return sock;
}
int main(int argc,char* argv[])
{
if(argc!=3)
{
printf("usae: %s [IP] [PORT]\n",argv[0]);
return 0;
}
int lis_sock=startup(argv[1],atoi(argv[2]));
//自定义数组gfds用于保存事件集合
int gfds[SIZE];
memset(gfds,-1,SIZE*4);
//读事件集合
fd_set rfds;
FD_ZERO(&rfds);
while(1)
{
struct timeval timeout={5,0};
//一开始lis_sock的文件描述符集合就已经就绪了
gfds[0]=lis_sock;
//现将最大的文件描述符设为-1
int max_fd=-1;
int i=0;
for(;i<SIZE;i++)
{
if(max_fd<gfds[i])
{
max_fd=gfds[i];
}
//将就绪的事件设置进文件描述集合（位图）
if(gfds[i]>=0)
{
FD_SET(gfds[i],&rfds);
}
}
int ret=select(max_fd+1,&rfds,NULL,NULL,NULL);
switch(ret)
{
case 0:
printf("timeout...\n");
break;
case -1:
printf("error");
break;
default:
//如果有主机连上服务器，也就是listen有了结果，则accept
if(FD_ISSET(gfds[0],&rfds))
{
struct sockaddr_in peer;
socklen_t len=sizeof(peer);
//listen 就绪，则accept;
int connfd=accept(lis_sock,(struct sockaddr *)&peer,&len);
if(connfd<0)
{
perror("accept");
}
else
{
printf("client: %s:%d fd(%d)\n",inet_ntoa(peer.sin_addr),\
ntohs(peer.sin_port),connfd);
int k=0;
//将就绪的文件描述符加入集合
for(;k<SIZE;k++)
{
if(gfds[k]==-1)
{
gfds[k]=connfd;
break;
}
}
if(k>=SIZE)
{
Close(connfd);
gfds[k]=-1;
}
}
}
int j=1;
for(;j<SIZE;j++)
{
if(FD_ISSET(gfds[j],&rfds))
{
char buf[SIZE];
//从已经就绪的文件描述符里读数据到buf里
ssize_t s=read(gfds[j],buf,sizeof(buf));
if(s<0)
{
perror("read");
continue;
}
else if(s==0)
{
printf("client is quit!\n");
Close(gfds[j]);
gfds[j]=-1;
}
else
{
//逻辑处理模块
//将读到的数据打印到标准输出上
buf[s]=0;
printf("client# %s\n",buf);
}
}
}
break;
}
}
return 0;
}
client.c
/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "wrap.h"
#define MAXLINE 80
int main(int argc, char *argv[])
{
struct sockaddr_in servaddr;
char buf[MAXLINE];
int sockfd, n;
if (argc != 3)
printf("./client IP\n");
sockfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
servaddr.sin_port = htons(atoi(argv[2]));
Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
printf("------------connect ok----------------\n");
while (1) {
fgets(buf, sizeof(buf), stdin);
Write(sockfd, buf, strlen(buf));
n = Read(sockfd, buf, sizeof(buf));
if (n == 0) {
printf("the other side has been closed.\n");
break;
}
else
Write(STDOUT_FILENO, buf, n);
}
Close(sockfd);
return 0;
}
使用 nc 127.0.0.1 8080命令链接服务器，或者使用客户端链接服务器。
浙公网安备 33010602011771号