Linux网络编程——IO多路复用

文章目录

  • 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 模型:

I/O模型 含义
阻塞I/O 最常用
非阻塞I/O 可防止进程阻塞在I/O操作上,需要轮询
I/O 多路复用 允许同时对多个I/O进行控制
信号驱动I/O 一种异步通信模型(当IO有事件的时 候,在应用程序中会收到一个信号SIGIO,可以对信号安装一个处理句柄,就可以对信号实现异步的处理)用signal函数

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 资源的操作
  • 这种模式很少使用。
    Linux网络编程——IO多路复用_第1张图片

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时进程会一直阻塞直到以下的一种情况发生.
    • 有文件可以读.
    • 有文件可以写.
    • 超时所设置的时间到.
  • 为了设置文件描述符我们要使用几个宏:
形式 含义
FD_SET void FD_SET(int fd,fd_set *fdset) 将fd加入到fdset
FD_CLR void FD_CLR(int fd,fd_set *fdset) 将fd从fdset里面清除
FD_ZERO void FD_ZERO(fd_set *fdset) 从fdset中清除所有的文件描述符
FD_ISSET int FD_ISSET(int fd,fd_set *fdset) 判断fd是否在fdset集合中

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 */
 };
常量(events/revents) 说明
POLLIN 普通或优先级带数据可读,有数据可读
POLLRDNORM 普通数据可读,有普通数据可读
POLLRDBAND 优先级带数据可读,有优先数据可读
POLLPRI 高优先级数据可读, 有紧迫数据可读
POLLOUT 普通数据可写, 写数据不会导致阻塞
POLLWRNORM 普通数据可写, 写普通数据不会导致阻塞
POLLWRBAND 优先级带数据可写,写优先数据不会导致阻塞
POLLMSGSIGPOLL 消息可用
POLLER 发生错误
POLLHUP 发生挂起
POLLNVAL 描述字不是一个打开的文件

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()的返回值,第二个参数表示动作,用三个宏来表示:
宏(动作) 含义
EPOLL_CTL_ADD 注册新的fd到epfd中
EPOLL_CTL_MOD 修改已经注册的fd的监听事件
EPOLL_CTL_DEL 从epfd中删除一个fd

第三个参数是需要监听的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 */
};
宏(enents) 含义
EPOLLIN 表示对应的文件描述符可以读(包括对端SOCKET正常关闭)
EPOLLOUT 表示对应的文件描述符可以写
EPOLLPRI 表示对应的文件描述符有紧急的数据可读(这里应该表示有带外数据到来)
EPOLLERR 表示对应的文件描述符发生错误
EPOLLHUP 表示对应的文件描述符被挂断
EPOLLET 将EPOLL设为边缘触发(Edge Triggered)模式,这是相对于水平触发(Level Triggered)来说的
EPOLLONESHOT 只监听一次事件,当监听完这次事件之后,如果还需要继续监听这个socket的话,需要再次把这个socket加入到EPOLL队列里
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
Linux网络编程——IO多路复用_第2张图片

  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 0
		select(maxfd+1,&rset,NULL,NULL,NULL);
#else
		 struct timeval tout;
		 tout.tv_sec = 5;
		 tout.tv_usec = 0;
		select(maxfd+1,&rset,NULL,NULL,&tout);
#endif
		int 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);
#else
	if(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;i<get_length_linklist(fdlist);i++)
			{
				sin_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;i<get_length_linklist(fdlist);i++)//将链表中的fd都处理一遍
					{
						
						sin_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)//不是建立连接后分配的newfd
							continue ;
						//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(i<pos)
	{
		r = 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 ;
}

你可能感兴趣的:(Linux,网络,linux,运维)