嵌入式Linux网络编程，I/O多路复用，阻塞I/O模式，非阻塞I/O模式fcntl()/ioctl()，多路复用I/O select()/pselect()/poll()，信号驱动I/O

其他 2018-12-14 18:48:48 阅读次数: 0

文章目录

1，I/O模型

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

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

2，阻塞I/O 模式

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

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

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

2.2，写阻塞

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

3，非阻塞模式I/O

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

在这里插入图片描述

3.1，非阻塞模式的实现（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

  1. 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
  2. 若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
  3. 若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；
  4. 比较好的方法是使用I/O多路复用。其基本思想是：
    ·先构造一张有关描述符的表（fd_set），然后调用一个函数（select()/poll()）。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
    ·函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。
  5. 多路复用不止针对套接字fd，也针对普通的文件描述符fd

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

4.1.1，实现多路复用 select()

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
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 微妙*/
           };

1秒（s） = 103毫秒（ms） = 106微妙（us） = 109纳秒（ns） = 1012皮秒（ps）

  1. 在我们调用select时进程会一直阻塞直到以下的一种情况发生.
    ·有文件可以读.
    ·有文件可以写.
    ·超时所设置的时间到.
  2. 为了设置文件描述符我们要使用几个宏：
宏 形式 含义
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(),稍节省空间
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 描述字不是一个打开的文件
  1. 第二个参数nfds：要监视的描述符的数目。
  2. 最后一个参数timeout：是一个用毫秒表示的时间，是指定poll在返回前没有接收事件时应该等待的时间。如果 它的值为-1，poll就永远都不会超时。如果整数值为32个比特，那么最大的超时周期大约是30分钟。

4.1.3，另外的函数：epoll接口

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

  1. int epoll_create(int size);

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

  1. 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队列里
  1. int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
  1. 参数

epoll_wait的功能与select()类似，它等待_epfd_所代表的epoll实例中监听的事件发生。
_events_指针返回已经准备好的事件，最多有_maxevents_个，参数_maxevent_必须大于零。
_timeout_参数指定epoll_wait函数阻塞的毫秒数的最小值（精度和系统时钟有关，内核调度也会
对此造成一些影响），设置_timeout_为-1则epoll_wait()会一直阻塞，设置为0则会立即返回。

  1. 返回值

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

5，TCP多路复用

TCP多路复用I/O 关键点
1. select( )函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化：
前：表示关心的文件描述符集合
后：有数据的集合（如不是在超时还回情况下）
2. kernel使fd_set集合发生了变化
3. 若是监听套接字上有数据，则有新客户端连接，就去调用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))//依次判断
		{
			newfd = accept(fd,...);//若是监听套接字上有数据，则有新客户端连接，就去调用accept()函数
		}
	  	
	  	/* 若是已建立连接的套接字上有数据，则去读数据 */
	  	/* ... */
	  
	 }
	 
}

6，IO复用select()示例

6.1 select()—net.h

#ifndef __NET_H__
#define __NET_H__

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/select.h>

#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 <serv_ip> <serv_port>\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;
	struct timeval tout;
	char buf[BUFSIZ];
	int ret = -1;
	while(1)
	{
		FD_ZERO(&rset);

		FD_SET(0,&rset);
		FD_SET(fd,&rset);
		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 <sys/ioctl.h>

/* 线程传参  */
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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

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 ;
}

猜你喜欢

转载自blog.csdn.net/m0_37542524/article/details/84310149
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022