poll函数

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<sys/wait.h>      //*进程用的头文件*/
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<poll.h>        //包含poll的头文件

#define MAXLINE  1024  //通信内容的最大长度

#ifndef FD_SETSIZE
#define FD_SETSIZE 25  //select最多能处理的文件描述符
#endif

ssize_t readn(int fd, void *buf, size_t count)
{
    ssize_t nleft=count;
    ssize_t nread;
    char *charbuf=(char*) buf;

    while(nleft>0)
    {
        nread=read(fd,charbuf,nleft);
        if(nread<0)
          {
              if(errno==EINTR)
               continue;
                        return -1;
          }
        else if(nread==0)
                       return count-nleft;

        charbuf +=nread;
                nleft=count-nread;
    }
    return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
        ssize_t nleft=count;
        ssize_t nwrite;
        char *charbuf=(char*) buf;

        while(nleft>0)
        {
                nwrite=write(fd,charbuf,nleft);
                if(nwrite<0)
                  {
                        if(errno==EINTR)
                           continue;
                        return -1;
                  }
                else if(nwrite==0)
                       return count-nleft;
                charbuf +=nwrite;
                nleft=count-nwrite; 

        }
       return count;
}

 ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
        int ret;
    while(1)
    {
            ret=recv(sockfd,buf,len,MSG_PEEK);
                if(ret==-1&& errno==EINTR)
                    continue;
                return ret;
    }
}

 ssize_t readline(int sockfd, void *buf, size_t len)
{
        ssize_t nleft=len,nread;
        int ret;
        char* bufchar=buf;
        while(1)
        {
                ret=recv_peek(sockfd,bufchar,len);
                if(ret<0||ret==0)
                        return ret;
                nread=ret;
                int i;
                for(i=0;i<nread;i++)
                {
                        if(bufchar[i]==‘\n‘)
                        {
                                ret=readn(sockfd,bufchar,i+1);
                                if(ret!=i+1)
                                        exit(EXIT_FAILURE);
                                return ret;
                        }
                }
                if(nread>nleft)
                        exit(EXIT_FAILURE);
                nleft-=nread;
                ret=readn(sockfd,bufchar,nread);
                if(ret!=nread)
                        exit(EXIT_FAILURE);
                bufchar+=nread;

        }
        return -1;

}

int main()
{
    int sock_fd,new_fd,fd;//sock_fd用于监听,new_fd用于连接
    int maxi;
    struct pollfd client[FD_SETSIZE];//用于存放客户端描述符
    int nready;//检测到的事件数
    struct sockaddr_in srv_addr;//服务器的地址信息
    struct sockaddr_in client_addr;//客户机的地址信息
    int i,size; //地址结构数据的长度
    fd_set rset,allset;
    char sendbuf[1024],recvbuf[1024];
    memset(sendbuf,0,sizeof(sendbuf));
    memset(recvbuf,0,sizeof(recvbuf));

    /*创建套接字*/
    sock_fd=socket(AF_INET,SOCK_STREAM,0);//采用IPv4协议
    if(sock_fd==-1)
    {
        perror("creat socket failed");
        exit(1);
    }

    /*服务器地址参数*/
    srv_addr.sin_family=AF_INET;
    srv_addr.sin_port=htons(3490);
    srv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    bzero(&srv_addr.sin_zero,sizeof(struct sockaddr_in));//bzero位清零函数,将sin_zero清零,sin_zero为填充字段,必须全部为零

    int on=1; //表示开启reuseaddr
    if(setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on))<0)  //打开地址、端口重用
        perror("setsockopt");

    /*绑定地址和端口*/
    if(bind(sock_fd,(struct sockaddr*)&srv_addr,sizeof(struct sockaddr))==-1)
    {
        perror("bind failed");
        exit(1);
    }

    /*设置监听模式,等待客户机的监听*/
     if((listen(sock_fd,5))==-1)
    {
        perror("listen failed");
        exit(1);
    }

    int maxi=0;
    client[0].fd=sock_fd;    //将监听套接字放在数组中
    client[0].events=POOLIN; //感兴趣的事件为数据可读
    for(i=1;i<FD_SETSIZE;i++)
        client[i].fd=-1;    //描述符为-1表示空闲

    //使用poll实现并发服务器
    while(1)
    {
        nready=poll(client,maxi+1,-1);  //超时时间为-1,表示阻塞直到检测到事件
        if(nready==-1)
        {
            if(errno==EINTR)     //因为信号中断退出
                continue;
            perror("select\n");
        }
        else if(nready==0) //超时
        {
            continue;
        }

        if(client[0].revents & POLLIN) //监听套接口产生可读
        {
            size=sizeof(struct sockaddr_in);
            new_fd=accept(sock_fd,(struct sockaddr*)&client_addr,&size);  /*接受连接,采用非阻塞是的模式调用accep*/
            if(new_fd==-1)
            {
                perror("accept failed");
            //continue;//restart accept when EINTR
            }

                printf("server:got connection from IP= %s prot= %d \n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));//连接成功,打印客户机IP地址和端口号
            /*char *inet_nota(struct sockaddr_in in);
            头文件:
            arpa/inet.h
            Winsock2.h
            参数:
            一个网络上的IP地址
            返回值:
            如果正确,返回一个字符指针,指向一块存储着点分格式IP地址的静态缓冲区(同一线程内共享此内存);错误,返回NULL。
            uint31_t ntohs(uint32_t net32bitvalue);
            头文件:
            #include<netinet/in.h>
            把net32bitvalue有网络字节序转换为主机字节序。
            */
                    if(send(new_fd,"Hello client,I am 192.168.229.125!\n",50,0)==-1)  //192.168.229.125为子进程IP,可更改
                        perror("send failed");
            for(i=1;i<FD_SETSIZE;i++)
                if(client[i].fd<0)
                {
                    client[i].fd=new_fd;         //将描述符保存在某一个空闲的位置
                    break;
                }
            if(i==FD_SETSIZE)                //没有找到空闲的位置,即描述符个数达到上限
                perror("too many client");
            if(i>maxi)
                maxi=i;
            client[i].events=POLLIN;
            if(--nready<=0)         //若检测到的套接口已经处理完,则继续用poll监听
                continue;
        }

        for(i=1;i<=maxi;i++)
        {
            if((fd=client[i].fd)<0)
                continue;
            if(client[i].revents & POLLIN)   //连接套接口产生事件
            {
                memset(recvbuf,0,sizeof(recvbuf));
                if((n=readline(fd,recvbuf,MAXLINE))==0)
                {
                    printf("client closed\n");
                    close(fd);
                    client[i].fd=-1;
                }
                else if(n==-1)
                    perror("readline\n");
                else
                {
                    writen(fd,recvbuf,n);
                    fputs(recvbuf,stdout);
                }

                if(--nready<=0)
                    break;
            }
        }

    }
 }
时间: 2024-10-12 04:15:30

poll函数的相关文章

linux poll函数

poll函数与select函数差不多 函数原型: #include <poll.h> int poll(struct pollfd fd[], nfds_t nfds, int timeout); struct pollfd的结构如下: struct pollfd{ int fd: // 文件描述符 short event:// 请求的事件 short revent:// 返回的事件 } 每个pollfd结构体指定了一个被监视的文件描述符.第一个参数是一个数组,即poll函数可以监视多个文件描

poll函数和串口设置.DOC

2015.1.24 今天星期六,多云,早晨8:17起床的,今天是来南京起床最迟的一天,因为昨晚睡得有点迟,今天又不用上课,整个人有点放松.收拾好来到教室,教室门没有开,胡明也到了,其他人还在宿舍睡觉,等了10分钟还没有人来开门,就决定出去逛逛,看看南京市有什么好玩的或者特别的.9点没到从鸿运大厦出门,回来的时候10点10分左右,走了一个多小时,百度地图还是有点管用的,起码没有让我迷路.逛了一圈,以前觉得南京算是个大城市,应该比较繁华或者时尚之类的,但是现在完全没有这种感觉,想到以后的工作,我就想

select在并发中的两点限制与poll函数的使用

用select实现的并发服务器,能达到的并发数,受两方面限制: 一个进程能打开的最大文件描述符限制.这可以通过调整内核参数. select中的fd_set集合容量的限制(FD_SETSIZE) ,这需要重新编译内核.//这个不能通过调整内核参数来限制  FD_SETSIZE宏等于1024在一个头文件中设置 改变它需要重新编译内核. ulinit   -n来查询最大文件描述符 得到1024   可以通过sudo  bash 换位root用户    ulimit  -n  2048进行修改最大文件描

【unix网络编程第三版】阅读笔记(五):I/O复用:select和poll函数

本博文主要针对UNP一书中的第六章内容来聊聊I/O复用技术以及其在网络编程中的实现 1. I/O复用技术 I/O多路复用是指内核一旦发现进程指定的一个或者多个I/O条件准备就绪,它就通知该进程.I/O复用适用于以下场合: (1) 当客户处理多个描述符(一般是交互式输入或网络套接字),必须适用I/O复用 (2) 当一个客户处理多个套接字时,这种情况很少见,但也可能出现 (3) 当一个TCP服务器既要处理监听套接字,又要处理已连接套接字,一般就要使用I/O复用 (4) 如果一个服务器既要适用TCP,

linux C poll 函数使用

在学习linux 并发非阻塞服务器时候.看到有使用poll 函数的方式.初步理解并编写程序进行了测试. 服务器: #include <unistd.h> #include <sys/types.h> /* basic system data types */ #include <sys/socket.h> /* basic socket definitions */ #include <netinet/in.h> /* sockaddr_in{} and o

Unix网络编程学习笔记之第6章 I/O复用:select和poll函数

一.I/O复用应用场合 1. 当客户处理多个描述符(既有标准输入,又有网络套接字)时,必须使用IO复用. 2. 一个客户同时处理多个套接字是可能的. 3. 如果一个服务器既要处理监听套接字,又要处理已连接套接字,一般就要使用I/O复用. 4. 如果一个服务器既要处理TCP,又要处理UDP,一般就要I/O复用. 5. 如果一个服务器要处理多个服务或协议,就要用到I/O复用. 其实IO复用就是一个进程/线程处理多个套接字描述符. 二. I/O模型 Unix提供了5种I/O模型: 1. 阻塞式I/O模

Linux网络编程——I/O复用之poll函数

一.回顾前面的select select优点: 目前几乎在所有的平台上支持,其良好跨平台支持也是它的一个优点 select缺点: 1.每次调用 select(),都需要把 fd 集合从用户态拷贝到内核态,这个开销在 fd 很多时会很大,同时每次调用 select() 都需要在内核遍历传递进来的所有 fd,这个开销在 fd 很多时也很大. 2.单个进程能够监视的文件描述符的数量存在最大限制,在 Linux 上一般为 1024,可以通过修改宏定义甚至重新编译内核的方式提升这一限制,但是这样也会造成效

【Unix网络编程】chapter6 IO复用:select和poll函数

chapter6 6.1 概述 I/O复用典型使用在下列网络应用场合. (1):当客户处理多个描述符时,必须使用IO复用 (2):一个客户同时处理多个套接字是可能的,不过不叫少见. (3):如果一个TCP服务器既要处理监听套接字,又要处理已连接套接字. (4):如果一个服务器既要处理TCP,又要处理UDP (5):如果一个服务器要处理多个服务或多个协议 IO复用并非只限于网络,许多重要的应用程序也需要使用这项技术. 6.2 I/O模型 在Unix下可用的5种I/O模型的基本区别: (1)阻塞式I

Linux下poll函数实现多用户聊天

Client: #define _GNU_SOURCE 1 #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include<arpa/inet.h> #include <assert.h> #include <stdio.h> #include <unistd.h> #include <string.h> #incl