用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, 0);
    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
");
        exit(1);
    }
    else
    {
        puts("connection successful
");
        return sockfd;
    }
}

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

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

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

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

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

    return 0;
}

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 = 0; i < CLIENT_SIZE; i++ )
    {
        clients[i].clientfd = INVALID;
    }
}

void broadcast(char *msg)
{
    int i;

    for(i = 0; 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 = 0; 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
");
            printf("%s",buffer);
            broadcast(buffer);
            break;
        }
    }

    if (i == CLIENT_SIZE )
    {
        strcpy(buffer, "out of number
");
        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 = 0; i < CLIENT_SIZE; i++ )
    {
        sockfd = clients[i].clienfd;

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

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

                continue;
            }
            else
            {
                read_buf[read_size] = '';
                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, 0);
    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
");
        exit(1);
    }

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

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

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

    init_clients();

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

        for(i = 0; 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 + 1, &fdset, NULL, NULL, 0);

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