用c写一个小的聊天室程序

1.聊天室程序——客户端

客户端我也用了select进行I/O复用，同时监控是否有来自socket的消息和标准输入，近似可以完成对键盘的中断使用。

其中select的监控里，STDOUT和STDIN是已有规定的值了。

Socket_setup函数负责进行对socket进行初始化完成connect 的过程，然后在主函数里无限循环检查sockfd和STDIN的缓冲区是否有新的消息

客户端程序较简单：

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>

 #define BUF_SIZE 256
 #define STDIN 0
 #define STDOUT 1
 #define INVALID -1

 int
 socket_setup(const char *serv_ip, int serv_port)
 {
     int rtn,sockfd;
     struct sockaddr_in sockaddr;

     sockfd = socket(AF_INET, SOCK_STREAM, );
     bzero(&sockaddr,sizeof(sockaddr));
     sockaddr.sin_family = AF_INET;
     sockaddr.sin_port = htons(serv_port);
     inet_pton(AF_INET, serv_ip, &sockaddr.sin_addr);

     rtn = connect(sockfd,(struct sockaddr *)&sockaddr, sizeof(sockaddr));

     if (rtn == INVALID)
     {
         puts("connection failure\n");
         exit();
     }
     else
     {
         puts("connection successful\n");
         return sockfd;
     }
 }

 int
 main(int argc, const char *argv[])
 {
     int i,read_size, sockfd = socket_setup(argv[],argv[]);
     char buffer[BUF_SIZE];
     fd_set fdset;

     while ()
     {
         FD_ZERO(&fdset);
         FD_SET(STDIN, &fdset);
         FD_SET(sockfd, &fdset);
         select(sockfd + , &fdset, NULL, NULL, );

         if( FD_ISSET( sockfd, &fdset ) )
         {
             readsize = read(sockfd, buffer, BUF_SIZE);
             write(STOUT, buffer, read_size);

             if(read_size == )
             {
                 puts("server close");
                 exit();
             }
         }

         if(FD_ISSET(STDIN, &fdset))
         {
             read_size = read(STDIN, buffer, BUF_SIZE);
             write(sockfd, buffer, read_size);
         }
     }

     return ;
 }

2.聊天室程序——服务器端

我的想法是，只要建立一个数组来存放客户端信息，每次有客户端发送信息或者在服务器端有消息需要发出去，直接遍历每一个元素给每个客户端发一个就好，客户端只需要完成以下几件事：

1.初始化，因为select的性质，每次检测完后会清空fdset，所以需要每一次都把所有连接上了客户端都重新加入进fdset，涉及函数void init_clients(void)，int main(int argc,const char *argv[]

2.检测有没有新的信息发上来了，如果有，并且可读，那就广播出去，涉及函数：void chat(fd_set fdset)，void broadcast(char *msg)

3.把所有发上来的信息按照时间格式化输出，这里学到了几个新函数，一个是int sprintf( char *buffer, const char *format, [ argument] … );可以格式化输出字符串和数字，一个是对世间的格式化，size_t strftime(char *strDest,size_t maxsize,const char *format,const struct tm *timeptr );这里涉及的函数：void stdmsg(int i, char *buffer, const char *msg)

源程序是：

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

 #define TIME_SIZE 16 // 表示时间的字符串长度
 #define IP_SIZE 16 // IP 字符串长度
 #define BUF_SIZE 256 // 缓冲区大小
 #define CLIENT_SIZE 8 // 允许的客户端数量
 #define BACKLOG CLIENT_SIZE // listen 队列长度，等于允许的客户端数量
 #define INVALID -1

 struct CLIENT{
     int clienfd;
     struct sockaddr_in sockaddr;
     char ip[IP_SIZE];
     int port;
 }clients[CLIENT_SIZE];

 void init_clients(void)
 {
     int i;

     for( i = ; i < CLIENT_SIZE; i++ )
     {
         clients[i].clientfd = INVALID;
     }
 }

 void broadcast(char *msg)
 {
     int i;

     for(i = ; i<CLIENT_SIZE; i++)
     {
         if( clients[i].clienfd != INVALID )
         {
             write(clients[i].clientfd, msg, sterlen(msg));
         }
     }
 }

 void stdmsg(int i, char *buffer, const char *msg)
 {
     char curtime[TIME_SIZE];
     time_t curtime_t;
     struct tm *timeinfo;

     curtime_t = time(NULL);
     timeinfo = localtime(&curtime_t);
     strftime(curtime, TIME_SIZE, "%X", timeinfo);
     sprintf(buffer,"<%s %s:%d> %s",curtime,clients[i].ip,clients[i].port,msg);
 }

 void accept_connect(int listenfd)
 {
     int connectfd,i;
     char buffer[BUF_SIZE];
     struct sockaddr_in clientaddr;
     socklen_t connectlen = sizeof(struct sockaddr_in);

     connectfd = accept( listenfd, (struct sockaddr_in *)&clientaddr, &connectlen);

     for( i = ; i < CLIENT_SIZE, i++ )
     {
         if(clients[i].clienfd == INVALID)
         {
             clients[i].clienfd == connectfd;
             memcpy(&clients[i].sockaddr);
             clients[i].port = ntohs(clients[i].sockaddr.sin_port);
             inet_ntop(AF_INET, &clients[i].sockaddr.sin_addr, clients[i].ip, IP_SIZE);
             stdmsg(i,buffer,"login\n");
             printf("%s",buffer);
             broadcast(buffer);
             break;
         }
     }

     if (i == CLIENT_SIZE )
     {
         strcpy(buffer, "out of number\n");
         write(connectfd, buffer, strlen(buffer));
         close(connectfd);//所有操作利用buffer进行操作
     }
 }

 void chat(fd_set fdset)
 {
     int sockfd, read_size, i;
     char read_buf[BUF_SIZE], send_buf[BUF_SIZE];

     for( i = ; i < CLIENT_SIZE; i++ )
     {
         sockfd = clients[i].clienfd;

         if(sockfd != INVALID && FD_ISSET(sockfd,&fdset))
         {
             read_size = read(sockfd, read_buf, BUF_SIZE - );

             if(read_size == )
             {
                 //connection lost
                 close(sockfd);
                 clients[i].clienfd = INVALID;
                 stdmsg(i, send_buf, "logout\n");
                 printf("%s\n",send_buf);
                 broadcast(send_buf);

                 continue;
             }
             else
             {
                 read_buf[read_size] = '\0';
                 stdmsg(i, send_buf, read_buf);
                 printf("%s",send_buf);
                 broadcast(send_buf);
             }
         }
     }
 }

 int socket_setup(int port)
 {
     int rtn, listenfd = socket(AF_INET, SOCK_STREAM, );
     struct sockaddr_in sockaddr;

     bzero(&sockaddr, sizeof(sockaddr));
     sockaddr.sin_family = AF_INET;
     sockaddr.sin_port = htons(port);
     sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

     rtn = bind(listenfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
     if (rtn == INVALID)
     {
         puts("bind error\n");
         exit();
     }

     if(listen(listenfd,BACKLOG) == INVALID)
     {
         puts("listen error\n")
         exit();
     }

     puts("service setup\n");
     return listenfd;
 }

 int main(int argc,const char *argv[])
 {
     int maxfd, i, listenfd = socket_setup(atoi(argv[]));
     fdset fdset;

     init_clients();

     while()
     {
         FD_ZERO(&fdset);
         FD_SET(listenfd, &fdset);
         maxfd = listenfd;

         for(i = ; i < CLIENT_SIZE; i++)
         {
             if(clients[i].clienfd != INVALID)
             {
                 FD_SET(clients[i].clienfd, &fdset);

                 if(clients[i].clienfd > maxfd)
                 {
                     maxfd = clients[i].clienfd;
                 }
             }
         }

         select(maxfd + , &fdset, NULL, NULL, );

         if(FD_ISSET(listenfd, &fdset))
         {
             accept_connect(listenfd);
         }
         chat(fdset);
     }
     return ;
 }