poll函数

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <pthread.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <stdarg.h>
#include <netdb.h>
#include <poll.h>

#define SER_IP "127.0.0.1" /*服务器的IP地址*/
#define OPEN_MAX 512

int read_socket(int socket_id, char *pbuf, int len);
int write_socket(int socket_id, char *pbuf, int len);

int main(int argc, char ** argv) /*服务端程序*/
{
    char    serv_ip[20];
    char    guest_ip[20];
    memset(serv_ip, 0, sizeof(serv_ip));
    memset(guest_ip, 0, sizeof(guest_ip));

    int count;
    pid_t pid;
    char ip_buf[32];
    char readbuf[1024];
    int sockfd = -1; /*监听套接字*/
    int newfd = -1; /*连接套接字*/
    int ret = -1;
    int opt = 1;
    int len;
    int i=0;
    int read_count = 1; /*读取次数*/
    struct sockaddr_in seraddr; /*用来保存服务器自己的ip地址和端口号的*/
    struct sockaddr_in cliaddr; /*用来保存连接过来的客户的ip地址和端口号的*/
    struct sockaddr_in bindaddr; /*用来保存连接过来的客户的ip地址和端口号的*/
    struct sockaddr lbindaddr;

    memset(ip_buf, 0, sizeof(ip_buf));
    memset(readbuf, 0, sizeof(readbuf));

    memset(&seraddr, 0, sizeof(seraddr));
    memset(&cliaddr, 0, sizeof(cliaddr));
    memset(&bindaddr, 0, sizeof(bindaddr));
    memset(&lbindaddr, 0, sizeof(lbindaddr));


    printf("有数据可读：POLLIN=[%d]\n", POLLIN);
    //printf("有普通数据可读：POLLRDNORM=[%d]\n", POLLRDNORM);
    //printf("有优先数据可读：POLLRDBAND=[%d]\n", POLLRDBAND);
    //printf("有紧迫数据可读：POLLPRI=[%d]\n", POLLPRI);

    //printf("写普通数据不会导致阻塞：POLLOUT=[%d]\n", POLLOUT);
    //printf("写普通数据不会导致阻塞：POLLWRNORM=[%d]\n", POLLWRNORM);
    //printf("写优先数据不会导致阻塞：POLLWRBAND=[%d]\n", POLLWRBAND);

    //printf("fd发生错误：POLLERR=[%d]\n", POLLERR);
    //printf("fd挂起：POLLHUP=[%d]\n", POLLHUP);
    //printf("fd非法：POLLNVAL=[%d]\n", POLLNVAL);


    sockfd = socket(AF_INET, SOCK_STREAM, 0); /*创建连接套接字,TCP协议*/
    if(sockfd < 0)
    {
        return -1;
    }
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); /*将服务端设置具有端口号可以重复*/

    seraddr.sin_family = AF_INET; /*指定服务器地址协议族*/
    seraddr.sin_port = htons(4989);     /*指定要监听的服务器的端口号*/
    /*seraddr.sin_addr.s_addr = INADDR_ANY;*/ /*指定要监听的服务器的ip：0.0.0.0:则客户端可连 127.0.0.1 和 真实的主机地址*/

    char * hostname = NULL;
    hostname = getenv("HOST");
    if(hostname == NULL)
    {
        printf("HOST环境变量不存在!\n");
        exit(-1);
    }
    struct hostent * myhost;
    myhost = gethostbyname(hostname);
    if(myhost == NULL)
    {
        printf("myhost is null!\n");
        exit(-1);
    }
    bcopy(myhost->h_addr, &seraddr.sin_addr, myhost->h_length);
    char ipbuf[128];
    memset(ipbuf, 0, sizeof(ipbuf));
    inet_ntop(AF_INET, &seraddr.sin_addr.s_addr, ipbuf, sizeof(ipbuf));
    printf("主机名=[%s],IP地址=[%s]\n", myhost->h_name, ipbuf);
    printf("IP地址=[%s]\n", ipbuf);

    ret = bind(sockfd, (struct sockaddr*)&seraddr, sizeof(struct sockaddr)); /*将IP地址，端口号和文件绑定,为套接字命名*/
    if(ret < 0)
    {
        printf("bind err! ret = [%d]\n", ret);
        return -1;
    }

    ret = listen(sockfd, 10); /*listen一执行，sockfd就能接受连接请求*/
    if(ret < 0)
    {
        return -1;
    }

    //定义
    struct pollfd fdset[OPEN_MAX];
  for(i = 0; i < OPEN_MAX; i++)
  {
      fdset[i].fd = -1;//循环将fd赋值为-1.
  }

    count = 0;
    //将0和sockfd加入到pollfd结构体中
    fdset[0].fd = 0;
    fdset[0].events = POLLIN; //监视是否有数据可读
    count++;
    fdset[1].fd = sockfd;
    printf("监听sockfd=[%d]\n", sockfd);
    fdset[1].events = POLLIN;
    //fdset[1].events = POLLOUT;
    count++;
    int j;

    while(1)
  {
       /*
        函数原型 : int poll(struct pollfd *fds, nfds_t nfds, int timeout);
        功能 : 使用poll查询这 count 个描述符的状态。poll可以同时查询多个文件。
                     有描述符准备好，则立即返回，没有描述符准备好，则等待timeout时间，还未准备好，再返回。
        参数 :
                    fds : 所有的文件的描述符到保存在集合fds中
                    nfds : 查询的文件数目
                    timeout : 超时时间,以ms为单位的

       */
          ret = poll(fdset, count, 1000);
          for(i=0; i<count; i++)
          {
                  if(fdset[i].revents & POLLIN) //判断描述符fdset[i]的POLLIN是否触发
                  {
                          if(fdset[i].fd == 0) /*是标准输入设备*/
                          {
                                  printf("从标准输入设备读取\n");
                                  memset(readbuf, 0, sizeof(readbuf));
                                    ret = read(0, readbuf, sizeof(readbuf));
                                    printf("read=[%s] ret = [%d]\n", readbuf, ret);
                          }
                          else if(fdset[i].fd == sockfd) /*监听套接字sockfd可读：表示sockfd已经接受客户端的连接请求*/
                          {
                                    printf("有客户端已经连接：可以用accept获得连接请求并建立连接！\n");
                                    len = sizeof(cliaddr); /*值-结果参数*/
                                    /*if((newfd=accept(sockfd,(struct sockaddr *)&cliaddr,(socklen_t *)&len))==-1)*/
                                    if((newfd=accept(sockfd, (struct sockaddr *)NULL, (socklen_t *)NULL)) == -1) /*不关心客户端标识*/
                         {
                                  perror("accept() failed");
                         exit(1);
                         }
                                  struct sockaddr_in serv;
                                  struct sockaddr_in guest;
                                  socklen_t serv_len = sizeof(serv);
                                  socklen_t guest_len = sizeof(guest);

                                  getsockname(newfd, (struct sockaddr *)&serv, &guest_len);
                                  getpeername(newfd, (struct sockaddr *)&guest, &serv_len);

                                  inet_ntop(AF_INET, &guest.sin_addr.s_addr, guest_ip, sizeof(guest_ip));
                                  inet_ntop(AF_INET, &serv.sin_addr.s_addr, serv_ip, sizeof(serv_ip));
                                  printf("服务端IP和PORT[%s]:[%d]\n", serv_ip, ntohs(serv.sin_port));
                                  printf("客户端IP和PORT[%s]:[%d]\n", guest_ip, ntohs(guest.sin_port));

                              fdset[count].fd = newfd; /*将连接套接字加入pollfd结构中*/
                              printf("count=[%d]\n", count);
                              printf("fdset[count].fd newfd=[%d]\n", newfd);
                                    fdset[count].events = POLLIN;
                                    count++;
                          }
                          else /*走到这里的，都是连接套接字*/
                          {
                                  printf("count=[%d]\n", count);
                                  printf("服务器读取套接字[%d]的内容：\n", fdset[i].fd);
                                    memset(readbuf, 0, sizeof(readbuf));
                                    ret = read(fdset[i].fd, readbuf, sizeof(readbuf));
                                    printf("read=[%s] ret = [%d]\n", readbuf, ret);
                                    for(j=0; j<ret; j++)
                                    {
                                            printf("***[%02x]***\n", readbuf[j]);
                                    }

                                    printf("服务器写入套接字[%d]的内容：\n", fdset[i].fd);
                                    ret = write(fdset[i].fd, readbuf, strlen(readbuf));
                                    printf("write=[%s] ret = [%d]\n", readbuf, ret);
                          }
                  }
      }
  }
  close(sockfd);

    return 0;
}