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

server端的主要功能：

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

server端的程序结构：

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

这三个函数分别从属于三个线程（准确说是大于等于三个，以下说明原因）：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];//分别记录server端的套接字与连接的多个client的套接字
11. void quit();//server关闭函数
12. void rcv_snd(int n);//server接收并转发消息函数
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函数创建server端的套接字
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函数使得server端的套接字与地址实现绑定
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. //创建一个线程。对server程序进行管理（关闭）
43. pthread_create(&thread,NULL,(void*)(&quit),NULL);
44. //记录空暇的client的套接字描写叙述符（-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];//分别记录server端的套接字与连接的多个client的套接字

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

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

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

//调用bind函数使得server端的套接字与地址实现绑定
    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);

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

//记录空暇的client的套接字描写叙述符（-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. }