文章目录

• 1，I/O模型
• 2，阻塞I/O 模式
• • 2.1，读阻塞（以read函数为例）
  • 2.2，写阻塞
• 3，非阻塞I/O模式
• • 3.1，非阻塞I/O模式的实现（fcntl()函数、ioctl() 函数）
  • • 3.1.1，fcntl( )函数
    • 3.1.2，ioctl() 函数
• 4，多路复用I/O
• • 4.0 文件描述符表
  • • 4.0.1，fd_set
  • 4.1，实现多路复用函数 select()/poll()
  • • 4.1.1， select()
    • 4.1.2，pselect()/poll()
    • 4.1.3，epoll接口
• 5，TCP多路复用
• 6，IO复用select()示例
• • 6.1 select()---net.h
  • 6.2 select()---client.c
  • 6.3 select()---sever.c
  • 6.4 select()---linklist.h
  • 6.5 select()---linklist.c

1，I/O模型

在UNIX/Linux下主要有4种I/O 模型：

2，阻塞I/O 模式

• 阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。
• 缺省情况下，socket套接字建立后所处于的模式就是阻塞I/O 模式。
• 前面学习的很多读写函数在调用过程中会发生阻塞。
  • 读操作中的read、recv、recvfrom
  • 写操作中的write、send
  • 其他操作：accept、connect

2.1，读阻塞（以read函数为例）

• 进程调用read函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read将发生阻塞。
• 它会一直阻塞下去，等待套接字的接收缓冲区中有数据可读。
• 经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过read访问这些数据。
• 如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去。

2.2，写阻塞

• 在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
• 这时，写操作不进行任何拷贝工作，将发生阻塞。
• 一但发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。
• UDP不用等待，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞，例如sendto（）。

3，非阻塞I/O模式

• 当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”
• 当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。
• 应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
• 这种模式很少使用。
  

3.1，非阻塞I/O模式的实现（fcntl()函数、ioctl() 函数）

• 当你一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞IO模式。
• 可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。

3.1.1，fcntl( )函数

函数原型

int fcntl(int fd, int cmd, long arg);

使用实例：

int flag；
flag = fcntl(sockfd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(sockfd, F_SETFL, flag);

3.1.2，ioctl() 函数

使用实例：

int b_on =1;
ioctl(sock_fd, FIONBIO, &b_on);

4，多路复用I/O

• 基本常识：linux中每个进程最多可以打开1024个文件，最多有1024个文件描述符，文件描述符特点：1.非负整数，2.从最小可用 数字来分配，3.每个进程启动时默认打开1、2、3三个文件描述符.【系统设定的】

• 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；

• 若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；

• 若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；

• 多路复用不止针对套接字fd，也针对普通的文件描述符fd

• 比较好的方法是使用I/O多路复用。其基本思想是：【详情见5，TCP多路复用】

  • 先构造一张有关描述符的表（fd_set），
  • 然后调用一个函数（select()/poll()）去监控fd_set中的哪些文件描述符发生阻塞。
  • 当监控到某个文件描述符中的一个或多个已准备好进行I/O时函数才退出select（）阻塞。
  • 依次判断哪个文件描述符有数据
  • 依次处理有数据的文件描述符的上的数据

4.0 文件描述符表

4.0.1，fd_set

void FD_zero(fd_set * fdset);//对集合清零
void FD_set(int fd,fd_set * fdset);//把fd加入到集合中
void FD_CLR(int fd,fd_set * fdset);//从集合汇总清除fd
void FD_ISSET(int fd,fd_set * fdset);//片段fd是否存在fd_set中

4.1，实现多路复用函数 select()/poll()

4.1.1， select()

#include 
#include 
#include 
int select(int nfds, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);

参数：

• nfds：所有监控的文件描述符中最大的那一个加1（maxfd+1）
• read_fds ：所有要读的文件文件描述符的集合
• write_fds：所有要的写文件文件描述符的集合（一般填NULL）
• except_fds：其他要向我们通知的文件描述符（异常集合，如：带外数据。一般填NULL）
• timeout：超时设置.
  • Null：一直阻塞，直到有文件描述符就绪或出错
  • 时间值为0：仅仅检测文件描述符集的状态，然后立即返回
  • 时间值不为0：在指定时间内，如果没有事件发生，则超时返回。

struct timeval {long    tv_sec;         /* seconds 秒*/long    tv_usec;        /* microseconds 微妙*/
};

• 在我们调用select时进程会一直阻塞直到以下的一种情况发生.
  • 有文件可以读.
  • 有文件可以写.
  • 超时所设置的时间到.
• 为了设置文件描述符我们要使用几个宏：

4.1.2，pselect()/poll()

int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);

• 注意参数类似struct timespec 和sigset_t
• select()增强

struct timespec {long    tv_sec;         /* seconds */long    tv_nsec;        /* nanoseconds */
};

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

• 类似select(),稍节省空间
• 第二个参数nfds：要监视的描述符的数目。
• 最后一个参数timeout：是一个用毫秒表示的时间，是指定poll在返回前没有接收事件时应该等待的时间。如果 它的值为-1，poll就永远都不会超时。如果整数值为32个比特，那么最大的超时周期大约是30分钟。
• 第一个参数是结构体

struct pollfd {int   fd;         /* file descriptor */short events;     /* requested events */short revents;    /* returned events */};

4.1.3，epoll接口

epoll的接口非常简单，一共就三个函数：

int epoll_create(int size);

• 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

• epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：

第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，struct 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 */
};

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

epoll_wait的功能与select()类似，它等待_epfd_所代表的epoll实例中监听的事件发生。

参数：

• events指针返回已经准备好的事件，最多有maxevents个，
• 参数maxevent必须大于零。
• timeout参数指定epoll_wait函数阻塞的毫秒数的最小值（精度和系统时钟有关，内核调度也会对此造成一些影响），设置timeout为-1则epoll_wait()会一直阻塞，设置为0则会立即返回。

返回值

• 如果函数调用成功，epoll_wait()函数返回已经准备好进行所要求的I/O操作的文件描述符的数
  量，如果在_timeout_时间内没有描述符准备好则返回0。
• 出错时，epoll_wait()返回-1并且把errno设置为对应的值

5，TCP多路复用

TCP多路复用IO

1. select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化：
   前：表示关心的文件描述符集合
   后：有数据的集合（如不是在超时还回情况下）
   1.1. 因为kernel使fd_set集合发生了变化，将没有数据的文件描述符进行移除，只剩下有数据的
2. 若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数 4. 若是已建立连接的套接字上有数据，则去读数据

int main(void)
{fd_set rset;int maxfd = -1;struct timeval tout;fd = socket(...);bind(fd,...);listen(fd,...);while(1){maxfd = fd;FD_ZERO(&rset);FD_SET(fd,&rset);/*依次把已经建立好连接的fd加入到集合中，记录下来最大的文件描述符maxfd*/
#if 0select(maxfd+1,&rset,NULL,NULL,NULL);
#elsestruct timeval tout;tout.tv_sec = 5;tout.tv_usec = 0;select(maxfd+1,&rset,NULL,NULL,&tout);
#endifint newfd;if(FD_ISSET(fd,&rset))//依次判断，有多少文件描述符需要判断就写几个if判断语句{newfd = accept(fd,...);//若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数}/* 若是已建立连接的套接字上有数据，则去读数据 *//* ... */}}

6，IO复用select()示例

6.1 select()—net.h

#ifndef __NET_H__
#define __NET_H__#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include #define SERV_IP_ADDR "192.168.31.100"
#define SERV_PORT 5002
#define BACKLOG 5
#define QUIT_STR "quite"
#define SERV_RESP_STR "Server:"#endif

6.2 select()—client.c

/* ./client serv_ip serv_port */
#include "net.h"void usage(char *s)
{printf("Usage: %s  \n",s);printf("\tserv_ip: server ip address\n");printf("\tserv_port: server port(>5000)\n ");
}
int main(int argc, const char *argv[])
{int fd;short port;struct sockaddr_in sin;if(argc != 3){usage((char *)argv[0]);exit(1);}if((port = atoi(argv[2])) < 5000){usage((char *)argv[0]);exit(1);}/* 1 创建socket fd */if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0){perror("socket");exit(-1);}/* 2 连接服务器 *//* 2.1 填充struct sockaddr_in结构体变量*/bzero(&sin,sizeof(sin));sin.sin_family = AF_INET;sin.sin_port = htons(port);//转为网络字节序端口号if(inet_pton(AF_INET,argv[1],(void *)&sin.sin_addr.s_addr) < 0){perror("inet_pton");goto _error1;}/* 2.2 连接服务器*/if(connect(fd,(struct sockaddr *)&sin,sizeof(sin)) < 0){perror("connect");goto _error1;}printf("client staring ... OK!\n");fd_set rset;int maxfd = -1;struct timeval tout;char buf[BUFSIZ];int ret = -1;while(1){FD_ZERO(&rset);//将文件描述符添加到rset数组中FD_SET(0,&rset);//0sh标准输入的文件描述符FD_SET(fd,&rset);//fd是socket的文件描述符maxfd = fd;tout.tv_sec = 5;tout.tv_usec = 0;select(maxfd+1,&rset,NULL,NULL,&tout);if(FD_ISSET(0,&rset))//标准输入里面是不是有输入{/* 读取键盘输入，发送到网络套接字fd */bzero(buf,BUFSIZ);do {ret = read(0,buf,BUFSIZ-1);}while(ret <0 && EINTR == errno);if(ret < 0){perror("read");continue ;}if(ret == 0)//没读到数据{continue;}if(write(fd,buf,strlen(buf)) < 0){perror("write() to socket");continue ;}if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0)//退出在发送之后{printf("client is existing!\n");break;}}if(FD_ISSET(fd,&rset))//服务器发送了数据过来{/* 读取套接字数据，处理 */bzero(buf,BUFSIZ);do {ret = read(fd,buf,BUFSIZ-1);}while(ret <0 && EINTR == errno);if(ret < 0){perror("read from socket");continue ;}if(ret == 0)//从套接字中读到的数据个数小于0，说明服务器关闭{break ;}printf("server said: %s",buf);if((strlen(buf) > strlen(SERV_RESP_STR)) && strncasecmp(buf+strlen(SERV_RESP_STR),QUIT_STR,strlen(QUIT_STR)) == 0){printf("sender client is existing!\n");break;}}}_error1:close(fd);return 0;
}

6.3 select()—sever.c

#include "net.h"
#include "linklist.h"
#include /* 线程传参  */
typedef struct{int addr;//客户端IP地址int port;//客户端端口号int fd;//为请求链接的客户端分配的新的socket fd
}ARG;/* IO多路复用select()处理函数 */
void do_select(int fd);int main(int argc, const char *argv[])
{int fd;struct sockaddr_in sin;//如果是IPV6的编程，要使用struct sockddr_in6结构体（详细情况请参考man 7 ipv6）,通常更通用的方法可以通过struct sockaddr_storage来编程/* 1 创建socket fd */if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0){perror("socket");exit(-1);}/* 优化 1 允许绑定地址快速重用 */ int b_reuse = 1;setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&b_reuse,sizeof(int)); /* 2 绑定 *//* 2.1 填充struct sockaddr_in 结构体变量*/bzero(&sin,sizeof(sin));sin.sin_family = AF_INET;sin.sin_port = htons(SERV_PORT);
#if 1/* 优化 2 让服务器可以绑定在任意的IP上*/sin.sin_addr.s_addr = htonl(INADDR_ANY);
#elseif(inet_pton(AF_INET,SERV_IP_ADDR,(void *)&sin.sin_addr.s_addr) < 0){perror("inet_pton");goto _error1;}
#endif/* 2.2 绑定*/if(bind(fd,(struct sockaddr *)&sin,sizeof(sin))){perror("bind");goto _error1;}/* 3 使用listen()把主动套接字变成被动套接字 */if(listen(fd,BACKLOG) < 0){perror("listen");goto _error1;}do_select(fd);_error1:close(fd);return 0;
}void do_select(int fd)
{linklist fdlist,sin_list;//创建一个列表，用于文件描述符及客户端信息存储fdlist = create_linklist();datatype sin_data;//每个对象包括客户端的socket fd,ipv4地址，端口号sin_data.fd = fd;int maxfd = fd;//struct timeval tout = {5,0};insert_end_linklist(fdlist,sin_data);//将lsten()处理后的fd加入列表//show_linklist(fdlist);fd_set rset;int newfd = -1;int ret = -1;char buf[BUFSIZ];//BUFSIZ是系统提供的char resp_buf[BUFSIZ+10];struct sockaddr_in cin;socklen_t cin_addr_len = sizeof(cin);/* 用select()函数实现I/O多路复用*/while(1){int i;FD_ZERO(&rset);if(get_length_linklist(fdlist) >= 1)//将列表中的fd加入读集合进行处理{//puts("11111111111111111111111111111");for(i=0;isin_list = get_list_pos_linklist(fdlist,i);sin_data = sin_list->data;FD_SET(sin_data.fd,&rset);maxfd = sin_data.fd > maxfd ? sin_data.fd : maxfd;//printf("第 %d 个（fd:%d）（ip:%s）（port:%d）\n",i,sin_data.fd,sin_data.ipv4_addr,sin_data.port);}//show_linklist(fdlist);}else{continue ;}//switch(select(maxfd+1,&rset,NULL,NULL,&tout))switch(select(maxfd+1,&rset,NULL,NULL,NULL)){case 0:{printf("time out!\n");goto _error1;}case -1:{perror("select");goto _error1;}default:{if(FD_ISSET(fd,&rset))//有客户端发送了连接请求{if((newfd = accept(fd,(struct sockaddr *)&cin,&cin_addr_len)) < 0){perror("connect");goto _error1;}/* 将分配成功的套接字newfd设置成非阻塞模式*/int b_on = 1;ioctl(newfd, FIONBIO, &b_on);//将分配成功的套接字newfd设置为非阻塞方式sin_data.fd = newfd;if(inet_ntop(AF_INET,&cin.sin_addr.s_addr,sin_data.ipv4_addr,sizeof(sin_data.ipv4_addr)) < 0){perror("inet_ntop");goto _error2;}sin_data.port = ntohs(cin.sin_port);printf("get a new client->(ip:%s)(port:%d)(fd:%d)\n",sin_data.ipv4_addr,sin_data.port,sin_data.fd);insert_end_linklist(fdlist,sin_data);//将建立客户端连接的fd加入列表//show_linklist(fdlist);}else//有连接好的客户端发送了数据{//puts("22222222222222222222");for(i=0;isin_list = get_list_pos_linklist(fdlist,i);sin_data = sin_list->data;//printf("reading fd is ->(第 %d 个)(fd:%d)(ip:%s)(port:%d)\n",i,sin_data.fd,sin_data.ipv4_addr,sin_data.port);if(sin_data.fd == fd)//不是建立连接后分配的newfdcontinue ;//puts("########read before");bzero(buf,BUFSIZ);do{ret = read(sin_data.fd,buf,BUFSIZ-1);}while(ret < 0 && errno == EINTR);//阻塞读写if(ret < 0){//perror("read");continue;}if(ret == 0)//对方已关闭{printf("client is existing!\n");delete_locate_linklist(fdlist,sin_data);continue;}printf("client ip(:%s) port(:%d) fd(:%d) receive data: %s",sin_data.ipv4_addr,sin_data.port,sin_data.fd,buf);bzero(resp_buf,BUFSIZ+25);strncpy(resp_buf,SERV_RESP_STR,strlen(SERV_RESP_STR));strcat(resp_buf,"ip(");strcat(resp_buf,sin_data.ipv4_addr);char s_port[10];strcat(resp_buf,"  port(");sprintf(s_port,"%d",sin_data.port);strcat(resp_buf,s_port);strcat(resp_buf,"  data(");strcat(resp_buf,buf);do{ret = write(sin_data.fd,resp_buf,strlen(resp_buf));}while(ret < 0 && EINTR == errno);//puts("###############################");	if(strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)) == 0){printf("client (fd:%d)(ip:%s)(potr:%d) is existing!\n",sin_data.fd,sin_data.ipv4_addr,sin_data.port);delete_locate_linklist(fdlist,sin_data);//将退出的客户端的fd从列表中删除close(sin_data.fd);//show_linklist(fdlist);}}}		}}}_error2:close(newfd);
_error1:close(fd);clear_linklist(fdlist);}

6.4 select()—linklist.h

#ifndef __SINGLE_LINKLIST_H__
#define __SINGLE_LINKLIST_H__#include 
#include 
#include 
#include typedef struct{int fd;char ipv4_addr[16];int port;
}datatype;typedef struct node{datatype data;struct node *next;
}listnode,*linklist;linklist create_linklist(void);
linklist create_n_linklist(void);
int delete_pos_linklist(linklist L,int pos);
int delete_locate_linklist(linklist L,datatype x);
void clear_linklist(linklist L);int get_length_linklist(linklist L);
linklist get_list_pos_linklist(linklist L,int pos);
linklist get_list_locate_linklist(linklist L,datatype x);int insert_head_linklist(linklist L,datatype x);
int insert_n_head_linklist(linklist L);
int insert_end_linklist(linklist L,datatype x);
int insert_n_end_linklist(linklist L);
int insert_pos_linklist(linklist L,datatype x,int pos);
int insert_order_linklist(linklist L,datatype x);void reverse_linklist(linklist);
void sort_linklist(linklist L);void show_linklist(linklist L);#endif

6.5 select()—linklist.c

#include "linklist.h"linklist create_linklist(void)
{linklist L;if((L=(linklist)malloc(sizeof(listnode))) == NULL){printf("malloc no memmory!\n");return NULL;}L->data.fd = 0;bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));L->data.port = 0;L->next = NULL;return L;
}
linklist create_n_linklist(void)
{linklist L,H,r;datatype x;if((L=(linklist)malloc(sizeof(listnode))) == NULL){printf("malloc no memmory!\n");return NULL;}L->data.fd = 0;bzero(L->data.ipv4_addr,sizeof(L->data.ipv4_addr));L->data.port = 0;L->next = NULL;r = L;while(1){printf("Please input a NUM_NL80211_WOWLAN_TRIGber(-1 exit :");while(scanf("%d",&x.fd) != 1){printf("Please INPUT_PROP_CNTut a number(-1 exit :");getchar();}if(x.fd == -1)break;if((H=(linklist)malloc(sizeof(listnode))) == NULL){printf("malloc nexto memmory!\n");return L;}H->data = x;H->next = NULL;r->next = H;r=H;}return L;}
int delete_pos_linklist(linklist L,int pos)
{linklist r,p;int i=-1;if(pos < 0 ||pos >=get_length_linklist(L)){printf("input pos is invalid!\n");return -1;}r = L;while(i < pos-1){i++;r = r->next;}if(r == NULL || r->next==NULL){printf("argc is iavalid!\n");return -1;}else{p = r->next;r->next = p->next;p->next = NULL;free(p);return 0;}
}
int delete_locate_linklist(linklist L,datatype x)
{linklist r,p;if(L->next == NULL){printf("list is NULL!\n");return -1;}r = L;while(r->next->data.fd != x.fd){if(r->next == NULL){printf("value is not in list!\n");return -1;}r = r->next;}p = r->next;r->next = p->next;p->next = NULL;free(p);return 0;
}void clear_linklist(linklist L)
{while(get_length_linklist(L)){delete_pos_linklist(L,get_length_linklist(L)-1);}free(L);L->next = NULL;L = NULL;
}
int get_length_linklist(linklist L)
{int i=0;linklist r;r = L;while(r->next){r = r->next;i++;}return i++;
}
linklist get_list_pos_linklist(linklist L,int pos)
{int i=0;linklist r;if(L->next == NULL){printf("list is NULL!\n");return NULL;}if(pos<0 || pos>=get_length_linklist(L)){printf("input is invalid!\n");return NULL;}r = L->next;while(ir = r->next;i++;}return r;
}
linklist get_list_locate_linklist(linklist L,datatype x)
{linklist r;if(L->next == NULL){printf("list is NULL!\n");return NULL;}r = L->next;while(r->data.fd != x.fd){if(r->next == NULL){printf("value is not in list!\n");return NULL;}r = r->next;}return r;
}int insert_head_linklist(linklist L,datatype x)
{linklist H;if((H=(linklist)malloc(sizeof(listnode))) == NULL){printf("malloc no memmory\n");return -1;}H->data = x;H->next = L->next;L->next = H;return 0;
}
int insert_n_head_linklist(linklist L)
{datatype x;while(1){printf("Please input a number(-1 exit:");while(scanf("%d",&x.fd) != 1){printf("Please input a number:(-1 exit");getchar();}if(x.fd == -1)break;insert_head_linklist(L,x);}return 0;
}
int insert_end_linklist(linklist L,datatype x)
{linklist r,H;if((H = (linklist)malloc(sizeof(listnode))) == NULL){printf("malloc no memmory!");return -1;}r = L;while(r->next){r = r->next;}H->next = NULL;H->data = x;r->next = H;return 0;
}
int insert_n_end_linklist(linklist L)
{datatype x;while(1){printf("Please input a number(-1 exit:");while(scanf("%d",&x.fd) != 1){printf("Please input a number:(-1 exit");getchar();}if(x.fd == -1)break;insert_end_linklist(L,x);}return 0;
}
int insert_pos_linklist(linklist L,datatype x,int pos)
{linklist K,r;if(pos == 0){r = L;}else{r = get_list_pos_linklist(L,pos-1);}if(r == NULL){printf("argc is invalidateid!\n");return -1;}else{if((K = (linklist)malloc(sizeof(listnode))) == NULL){printf("malloc no memmory!");return -1;}K->data = x;K->next = r->next;r->next = K;}return 0;
}
int insert_order_linklist(linklist L,datatype x)
{linklist r,H;if((H = (linklist)malloc(sizeof(listnode))) == NULL){printf("malloc nexto memmory!\n");return -1;}H->data = x;r = L;while(r->next && r->next->data.fd < x.fd){r = r->next;}H->next = r->next;r->next = H;return 0;
}
void reverse_linklist(linklist L)
{linklist r,p;if(L->next == NULL){printf("list is NULL!\n");return ;}r = L->next;L->next = NULL;while(r){p = r;r = r->next;p->next = L->next;L->next = p;}return ;
}
void sort_linklist(linklist L)
{linklist r,p,q;if(L == NULL){printf("list is NULL!\n");return ;}r = L->next;L->next = NULL;while(r){p = r;r = r->next;q = L;while(q->next && q->next->data.fd < p->data.fd){q = q->next;}p->next = q->next;q->next = p;}
}void show_linklist(linklist L)
{printf("list is:\n");if(L->next == NULL){printf("\tlist is NULL!list\n");return ;}while(L->next){printf("\t%d %s %d\t",L->next->data.fd,L->next->data.ipv4_addr,L->next->data.port);L = L->next;puts("");}//puts("");return ;
}