Linux C 网络编程——多线程的聊天室实现（服务器端）

服务器端的主要功能：

实现多用户群体聊天功能（此程序最多设定为10人，可进行更改），每个人所发送的消息其他用户均可以收到。用户可以随意的加入或退出（推出以字符串“bye”实现），服务器也可以进行关闭。

服务器端的程序结构：

总共有三个函数：主函数（main），实现服务器端的初始化，接受连接；消息处理函数（rcv_snd），接受某一用户的消息，将其进行简单处理之后发送给其他所有的用户；退出函数（quit），可实现服务器关停。

这三个函数分别从属于三个线程（准确说是大于等于三个，下面说明原因）：main函数的作为诛仙程线程，又创建了一个退出函数所在的线程，以及每次接受到一个连接之后会新创建一个对此连接的消息进行处理的线程（多于三个的原因在此）。

具体代码实现如下：

1. #include<time.h>
2. #include<stdio.h>
3. #include<sys/socket.h>
4. #include<netinet/in.h>
5. #include<string.h>
6. #define LISTENQ 5
7. #define MAXLINE 512
8. #define MAXMEM 10
9. #define NAMELEN 20
10. int listenfd,connfd[MAXMEM];//分别记录服务器端的套接字与连接的多个客户端的套接字
11. void quit();//服务器关闭函数
12. void rcv_snd(int n);//服务器接收并转发消息函数
13. int main()
14. {
15. pthread_t thread;
16. struct sockaddr_in servaddr,cliaddr;
17. socklen_t len;
18. time_t ticks;
19. char buff[MAXLINE];
20. //调用socket函数创建服务器端的套接字
21. printf("Socket...\n");
22. listenfd=socket(AF_INET,SOCK_STREAM,0);
23. if(listenfd<0)
24. {
25. printf("Socket created failed.\n");
26. return -1;
27. }
28. //调用bind函数使得服务器端的套接字与地址实现绑定
29. printf("Bind...\n");
30. servaddr.sin_family=AF_INET;
31. servaddr.sin_port=htons(6666);
32. servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
33. if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
34. {
35. printf("Bind failed.\n");
36. return -1;
37. }
38. //调用listen函数，将一个主动连接套接字变为被动的倾听套接字
39. //在此过程中完成tcp的三次握手连接
40. printf("listening...\n");
41. listen(listenfd,LISTENQ);
42. //创建一个线程，对服务器程序进行管理（关闭）
43. pthread_create(&thread,NULL,(void*)(&quit),NULL);
44. //记录空闲的客户端的套接字描述符（-1为空闲）
45. int i=0;
46. for(i=0;i<MAXMEM;i++)
47. {
48. connfd[i]=-1;
49. }
50. while(1)
51. {
52. len=sizeof(cliaddr);
53. for(i=0;i<MAXMEM;i++)
54. {
55. if(connfd[i]==-1)
56. {
57. break;
58. }
59. }
60. //调用accept从listen接受的连接队列中取得一个连接
61. connfd[i]=accept(listenfd,(struct sockaddr*)&cliaddr,&len);
62. ticks=time(NULL);
63. sprintf(buff,"% .24s \r \n",ctime(&ticks));
64. printf("%s Connect from: %s,port %d\n\n",buff,inet_ntoa(cliaddr.sin_addr.s_addr),ntohs(cliaddr.sin_port));
65. //针对当前套接字创建一个线程，对当前套接字的消息进行处理
66. pthread_create(malloc(sizeof(pthread_t)),NULL,(void*)(&rcv_snd),(void*)i);
67. }
68. return 0;
69. }
70. void quit()
71. {
72. char msg[10];
73. while(1)
74. {
75. scanf("%s",msg);
76. if(strcmp("quit",msg)==0)
77. {
78. printf("Byebye...\n");
79. close(listenfd);
80. exit(0);
81. }
82. }
83. }
84. void rcv_snd(int n)
85. {
86. char* ask="Your name please：";
87. char buff[MAXLINE];
88. char buff1[MAXLINE];
89. char buff2[MAXLINE];
90. char name[NAMELEN];
91. time_t ticks;
92. int i=0;
93. int retval;
94. //获取此进程对应的套接字用户的名字
95. write(connfd[n],ask,strlen(ask));
96. int len;
97. len=read(connfd[n],name,NAMELEN);
98. if(len>0)
99. {
100. name[len]=0;
101. }
102. //把当前用户的加入告知所有用户
103. strcpy(buff,name);
104. strcat(buff,"\tjoin in\0");
105. for(i=0;i<MAXMEM;i++)
106. {
107. if(connfd[i]!=-1)
108. {
109. write(connfd[i],buff,strlen(buff));
110. }
111. }
112. //接受当前用户的信息并将其转发给所有的用户
113. while(1)
114. {
115. if((len=read(connfd[n],buff1,MAXLINE))>0)
116. {
117. buff1[len]=0;
118. //当当前用户的输入信息为“bye”时，当前用户退出
119. if(strcmp("bye",buff)==0)
120. {
121. close(connfd[n]);
122. connfd[n]=-1;
123. pthread_exit(&retval);
124. }
125. ticks=time(NULL);
126. sprintf(buff2,"%.24s\r\n",ctime(&ticks));

#include<time.h>
#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>

#define LISTENQ 5
#define MAXLINE 512
#define MAXMEM 10
#define NAMELEN 20

int listenfd,connfd[MAXMEM];//分别记录服务器端的套接字与连接的多个客户端的套接字

void quit();//服务器关闭函数
void rcv_snd(int n);//服务器接收并转发消息函数

int main()
{
    pthread_t thread;
    struct sockaddr_in servaddr,cliaddr;
    socklen_t len;
    time_t ticks;
    char buff[MAXLINE];

//调用socket函数创建服务器端的套接字
    printf("Socket...\n");
    listenfd=socket(AF_INET,SOCK_STREAM,0);
    if(listenfd<0)
    {
        printf("Socket created failed.\n");
        return -1;
    }

//调用bind函数使得服务器端的套接字与地址实现绑定
    printf("Bind...\n");
    servaddr.sin_family=AF_INET;
    servaddr.sin_port=htons(6666);
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
    {
        printf("Bind failed.\n");
        return -1;
    }

//调用listen函数，将一个主动连接套接字变为被动的倾听套接字
//在此过程中完成tcp的三次握手连接
    printf("listening...\n");
    listen(listenfd,LISTENQ);

//创建一个线程，对服务器程序进行管理（关闭）
    pthread_create(&thread,NULL,(void*)(&quit),NULL);

//记录空闲的客户端的套接字描述符（-1为空闲）
    int i=0;
    for(i=0;i<MAXMEM;i++)
    {
        connfd[i]=-1;
    }

    while(1)
    {
        len=sizeof(cliaddr);
        for(i=0;i<MAXMEM;i++)
        {
            if(connfd[i]==-1)
            {
                break;
            }
        }

//调用accept从listen接受的连接队列中取得一个连接
        connfd[i]=accept(listenfd,(struct sockaddr*)&cliaddr,&len);

        ticks=time(NULL);
        sprintf(buff,"% .24s \r \n",ctime(&ticks));
        printf("%s Connect from: %s,port %d\n\n",buff,inet_ntoa(cliaddr.sin_addr.s_addr),ntohs(cliaddr.sin_port));

//针对当前套接字创建一个线程，对当前套接字的消息进行处理
        pthread_create(malloc(sizeof(pthread_t)),NULL,(void*)(&rcv_snd),(void*)i);

    }
    return 0;
}

void quit()
{
    char msg[10];
    while(1)
    {
        scanf("%s",msg);
        if(strcmp("quit",msg)==0)
        {
            printf("Byebye...\n");
            close(listenfd);
            exit(0);
        }
    }
}

void rcv_snd(int n)
{
    char* ask="Your name please：";
    char buff[MAXLINE];
    char buff1[MAXLINE];
    char buff2[MAXLINE];
    char name[NAMELEN];
    time_t ticks;
    int i=0;
    int retval;

//获取此进程对应的套接字用户的名字
    write(connfd[n],ask,strlen(ask));
    int len;
    len=read(connfd[n],name,NAMELEN);
     if(len>0)
     {
         name[len]=0;
     }

//把当前用户的加入告知所有用户
    strcpy(buff,name);
    strcat(buff,"\tjoin in\0");
    for(i=0;i<MAXMEM;i++)
    {
        if(connfd[i]!=-1)
        {
            write(connfd[i],buff,strlen(buff));
        }
    }

//接受当前用户的信息并将其转发给所有的用户
    while(1)
    {
        if((len=read(connfd[n],buff1,MAXLINE))>0)
        {
            buff1[len]=0;

//当当前用户的输入信息为“bye”时，当前用户退出
             if(strcmp("bye",buff)==0)
             {
                 close(connfd[n]);
                 connfd[n]=-1;
                 pthread_exit(&retval);
             }

             ticks=time(NULL);
             sprintf(buff2,"%.24s\r\n",ctime(&ticks));

1. strcpy(buff,name);
2. strcat(buff,"\t");
3. strcat(buff,buff2);
4. strcat(buff,buff1);
5. for(i=0;i<MAXMEM;i++)
6. {
7. if(connfd[i]!=-1)
8. {
9. write(connfd[i],buff,strlen(buff));
10. }
11. }
12. }
13. }