• Linux实训——单机版聊天室

    Linux实训《单机版聊天室》源码，答辩ppt，实习计划书，实习报告

    https://download.csdn.net/download/weixin_43042683/86949831?spm=1001.2014.3001.5503

    一、综合训练任务

    本次实习设计的单主机聊天室需要满足以下功能需求：

    （1）提供客户端和服务端，所有用户通过客户端进行聊天，每个用户可以看到所有聊天信息。

    （2）要求所有登录的系统用户可以登录服务器进行聊天，服务器为守护进程。

    （3）使用消息队列完成。服务器启动后使用特定的key或目录（将目录转换为key）建立消息队列，监听客户程序发出的消息（登录消息、退出消息、聊天消息）并完成消息的转发，对特定信息进行捕获来退出服务，退出服务是要通知客户端退出；客户端程序启动时检查特定key的消息队列是否建立，并通过位置参数获取用户名，若消息队列没有建立，则发送登录消息，然后准备发送消息，同事监听消息队列读取服务程序转发的聊天消息，当用户发出特定的字符时退出聊天。

    二、总体设计

    单机聊天室采用客户端，服务器的模式。通过消息队列存储客户端之间的信息交流，所有用户可以登录服务器进入聊天室参与聊天，服务器采用守护进程。

    客户端的功能如下：

    1. 客户端之间可以相互收发消息
    2. 能收到进入聊天室的通知消息
    3. 离开聊天室的通知消息
    4. 每条消息都有时间记录

    服务器功能如下：

    1. 广播将所有通知消息转发给所有用户
    2. 完成客户端之间的消息转发
    3. 解散聊天室，杀死所有进程
    4. 记录客户端进出服务器的信息

     

    三、详细设计说明

    客户端功能

    设计如下：

    1，客户端之间的收发消息通过子进程读消息，父进程发消息来实现。发消息时通过msgsnd函数将包含消息的结构体加入消息队列，收消息时通过msgrcv函数读取消息队列信息。

    1. fgets(msg.mtext,MSG_SIZE,stdin);
    2. 			struct timeval tv;
    3. 			gettimeofday(&tv, NULL);
    4. 			t = tv.tv_sec;
    5. 			struct tm*p_time = localtime(&t);
    6. 			strftime(str, 26, "%Y-%m-%d %H:%M:%S", p_time);
    7. 			strcpy(msg.msg_time, str);//记录时间信息
    8.  
    9. 			msgsnd(msgid,&msg,MSG_LEN,0);//发送结构体

    以上代码实现消息的发送功能，在结构体发送给消息队列时记录发送时间，达到对消息计时的功能。

    2，客户端收到新用户加入和离开聊天室的信息通过服务器的广播功能实现，用户进入和离开聊天室时将进入、离开信息发送给消息队列，服务器将这些消息广播给所有客户端。

    1. if(strncmp(msg.mtext,"exit",4)==0){
    2. 				msg.subtype = 3;
    3.  
    4. 				struct timeval tv; 
    5. 				gettimeofday(&tv, NULL);
    6. 				t = tv.tv_sec;
    7. 				struct tm*p_time = localtime(&t);
    8. 				strftime(str, 26, "%Y-%m-%d %H:%M:%S", p_time);
    9. 				strcpy(msg.msg_time, str);//记录时间信息
    10.  
    11. 				msgsnd(msgid,&msg,MSG_LEN,0);//发送退出信息
    12. 				fflush(stdout);//刷新缓冲区
    13. 				sleep(2);
    14. 				kill(pid,SIGKILL);
    15. 			exit(0);
    16. 			}

    以上代码实现离开聊天室通知所有客户端的功能，将包含客户端退出聊天室的结构体发送给消息队列后，必须要刷新缓冲区，不然不能及时输出客户端的退出信息。

    3，消息的时间记录，通过Linux中时间结构体来记录，在发送结构体给消息队列时及时记录时间信息。

    服务器设

    计功能如下：

    服务器生成一个采用链表的形式生成消息队列链表结构如下：

    1. struct msgbuf{
    2.     long mtype;
    3.     int subtype;    //消息请求类型
    4.     int pid;	//发送消息进程号
    5.     char user_name[MSG_SIZE];
    6.     char mtext[MSG_SIZE];
    7.     char msg_time[MSG_SIZE];
    8. }msg;

    结构体中包含进程号、消息请求类型（设计时采用switch选择语句实现消息的不同的类型便于扩展功能）、内容信息、时间信息。

    1，广播消息时遍历消息队列，给每个进程发送消息。

    1. int i;
    2. 	for(i=0 ;i<Length(head) ;i++){
    3. 		msg->mtype = GetValue(head,i);
    4. 		if(msg->mtype != msg->pid){//mtype = pid排除将广播消息发送给发消息的进程
    5. 			msgsnd(msgid,msg,MSG_LEN,0);
    6. 		}
    7. 	}

    2，解散聊天室杀死进程，在服务器接收到quit消息时杀死所有进程，删除消息队列，以此实现解散聊天室的功能，删除消息队列和杀死进程的代码如下：

    1. void Delete(LinkList head,int value)
    2. {
    3. 	LinkList p = head->next;
    4. 	while(p!=NULL){
    5. 		if(p->data == value){
    6. 			head->next = p->next;
    7. 			free(p);
    8. 			p = head->next;
    9. 		}else{
    10. 			head = p;
    11. 			p = p->next;
    12. 		}
    13. 	}
    14. }

    以上代码实现对链表的删除

    1. if(strncmp(msg.mtext,"quit",4)==0){
    2. 				msgsnd(msgid,&msg,MSG_LEN,0);
    3. 				sleep(2);
    4. 				msgctl(msgid,IPC_RMID,NULL);//删除消息队列
    5. 				kill(pid,SIGKILL);	//杀死子进程
    6. 				exit(0);
    7. 			}

    以上代码杀死所有进程，实现模拟解散聊天室的功能，此代码虽然实现了对进程的杀死但是并没有按照本次实习的要求处理进程信号，是按照系统默认杀死进程，实习要求应该是对退出信号进行处理，在答辩时发现这个问题，所以这个单机聊天室没能完全按照要求实现，这也提醒我在今后的实习或是工作中一定要仔细审题和老师多交流，避免这种问题发生。

    四、调试与测试

    1.调试时首先启动服务器，直接登录客户端会提示服务器没有开启，如图所示：

     

     2.启动服务器后客户端可以登录服务器进入聊天室。

    3. 客户端登录后相互之间通过服务器的转发实现聊天功能，客户端之间的聊天如下图

     4.在客户端输入exit后退出聊天室，服务器会收集客户端的提示信息并且通知所有在聊天室中的客户端有客户端退出聊天室。

     

     5.在服务器输入quit退出服务器，这时服务器会通知所有进程服务器即将关闭，然后杀死所有进程并且删除消息队列，模拟解散聊天室；此功能的不足时没能对退出消息捕获处理而是按照系统默认处理，这不符合实际，还需优化。

     五、附录：核心代码清单

    以下代码是客户端子进程和父进程的相关代码实现了消息的收发。

    1. if((pid = fork())==-1){
    2. 		perror("fork error.");//创建进程失败
    3. 		exit(1);
    4. 	}else if(pid == 0){	//子进程负责读
    5. 		while(1){
    6. 			msgrcv(msgid,&msg,MSG_LEN,TYPE_ME,0);
    7. 			//判断接收到的消息是否为quit
    8. 			if(strncmp(msg.mtext,"quit",4) == 0){
    9. 				printf("\33[36m-------------------------服务器即将关闭-----------------------\33[0m\n");
    10. 				kill(TYPE_ME,SIGUSR1); //杀死所有进程
    11. 				exit(0);
    12. 			}
    13. 			//检测用户是否输入exit退出操作 
    14. 			if(strncmp(msg.mtext,"exit",4) == 0){
    15. 				msg.subtype = 3;
    16. 			}
    17.  
    18. 			switch(msg.subtype){
    19. 				case 1:
    20. 					printf("\033[33m\n%s\n\033[0m",msg.msg_time);//显示进入聊天室时间
    21. 					printf("\033[33m[%s 进入聊天室]\033[0m\n\n",msg.user_name);
    22. 					break;
    23. 				case 2:
    24. 					printf("\033[33m\n%s\n\033[0m", msg.msg_time);//显示发送消息的时间
    25. 					printf("\033[33m[%s]:\033[0m %s\n",msg.user_name,msg.mtext);
    26. 					break;
    27. 				case 3:
    28. 					printf("\033[33m\n%s\n\033[0m", msg.msg_time);//显示退出聊天室时间
    29. 					printf("\033[33m[%s 退出聊天室]\033[0m\n\n",msg.user_name);
    30. 					break;
    31. 				default :
    32. 					break;
    33. 			}
    34. 		}
    35. 	}else{	//父进程用于发送消息
    36. 		msg.mtype = MSG_TO_SERVER;
    37. 		msg.subtype = 2;//广播
    38. 		while(1){
    39. 			fgets(msg.mtext,MSG_SIZE,stdin);
    40.  
    41. 			struct timeval tv;//生成当前时间信息
    42. 			gettimeofday(&tv, NULL);
    43. 			t = tv.tv_sec;
    44. 			struct tm*p_time = localtime(&t);
    45. 			strftime(str, 26, "%Y-%m-%d %H:%M:%S", p_time);
    46. 			strcpy(msg.msg_time, str);
    47.  
    48. 			msgsnd(msgid,&msg,MSG_LEN,0);//结构体进入消息队列
    49. 			//当此进程输入exit时，表示进程推出聊天
    50. 			//由服务器通知其他进程，该进程已下线
    51. 			if(strncmp(msg.mtext,"exit",4)==0){
    52. 				msg.subtype = 3;
    53.  
    54. 				struct timeval tv;//生成当前时间信息
    55. 				gettimeofday(&tv, NULL);
    56. 				t = tv.tv_sec;
    57. 				struct tm*p_time = localtime(&t);
    58. 				strftime(str, 26, "%Y-%m-%d %H:%M:%S", p_time);
    59. 				strcpy(msg.msg_time, str);
    60.  
    61. 				msgsnd(msgid,&msg,MSG_LEN,0);
    62. 				fflush(stdout);//刷新缓冲区输出信息，如果不刷新，其他终端不能及时收到退出信息
    63. 				sleep(2);
    64. 				kill(pid,SIGKILL);//杀死当前进程
    65. 				exit(0);
    66. 			}
    67. 		}
    68. 	}

     以下代码是服务器子进程和父进程的相关代码用于实现对客户端之间的消息转发和客户端进出聊天室的监控。

    1. if((pid = fork())==-1){
    2. 		perror("error to fork.");
    3. 		exit(1);
    4. 	}else if(pid == 0){ //pid=0，当前进程为子进程
    5. 		//消息队列
    6. 		LinkList head;
    7. 		head = CreateLinkList();
    8. 		while(1){
    9. 			//从消息队列中获取一条消息
    10. 			if(msgrcv(msgid,&msg,MSG_LEN,MSG_TO_SERVER,0)==-1){
    11. 				perror("msgrcv error.\n");
    12. 				exit(1);
    13. 			}else{
    14. 				//对接收到的消息，子进程进行消息类型判断
    15. 				switch(msg.subtype)
    16. 				{
    17. 				case 1:	//客户端登录
    18. 					if(Insert(head,msg.pid)!=0){
    19. 						printf("insert error.\n");
    20. 						exit(1);
    21. 					}
    22. 					printf("\033[33m%s\033[0m", msg.msg_time);//输出登录时间
    23. 					printf("\033[33m[客户端  %s  登录]\033[0m\n\n",msg.user_name);
    24. 					BroadCast(head,msgid,&msg);	//把收到的消息广播
    25. 					break;
    26. 				case 2: //消息广播
    27.  
    28. 					BroadCast(head,msgid,&msg);
    29. 					if(strncmp(msg.mtext,"quit",4)==0){
    30. 						exit(0);
    31. 					}
    32. 					break;
    33. 				case 3:	//客户端退出
    34. 					if(!Empty(head)){
    35. 						Delete(head,msg.mtype);
    36. 					}
    37. 					printf("\033[33m%s\033[0m", msg.msg_time);//输出退出时间
    38. 					printf("\033[33m[客户端  %s  退出]\033[0m\n\n",msg.user_name);
    39. 					break;
    40. 				default:
    41. 					break;
    42. 				}
    43. 			}
    44. 		}
    45. 	}else{//父进程用于服务器控制台
    46. 		msg.mtype = MSG_TO_SERVER;
    47. 		msg.subtype = 2;
    48. 		while(1){
    49. 	printf("\33[36m*************************************************************\n\33[0m");
    50. 	printf("\33[36m*---------------------服务器控制端--------------------------*\n\33[0m");
    51. 	printf("\33[36m*---------服务端已开启，客户可登陆聊天室进行聊天------------*\n\33[0m");
    52. 	printf("\33[36m*----------------若想关闭服务器，请输入“quit”---------------*\n\33[0m");
    53. 	printf("\33[36m*************************************************************\33[0m\n");
    54. 			fgets(msg.mtext,MSG_SIZE,stdin);
    55. 			//控制台接收到quit时，通知客户端，server结束
    56. 			if(strncmp(msg.mtext,"quit",4)==0){
    57.  
    58. 				msgsnd(msgid,&msg,MSG_LEN,0);
    59. 				sleep(2);
    60. 				msgctl(msgid,IPC_RMID,NULL);//删除消息队列
    61. 				kill(pid,SIGKILL);	//杀死子进程
    62. 				exit(0);
    63. 			}
    64. 		}
    65. 	}
    66. 	return 0;
    67.  
    68. }
    69.  
    70. LinkList CreateLinkList()
    71. {
    72. 	LinkList head;
    73. 	head = (LinkList)malloc(sizeof(ListNode));
    74. 	head->next = NULL;
    75. 	return head;
    76. }
    77. int Length(LinkList head)
    78. {
    79. 	int n = 0;
    80. 	head = head->next;
    81. 	while(head){
    82. 		n++;
    83. 		head = head->next;
    84. 	}
    85. 	return n;
    86. }
    87. void BroadCast(LinkList head,int msgid,struct msgbuf *msg)
    88. {
    89. 	int i;
    90. 	for(i=0 ;i<Length(head) ;i++){
    91. 		msg->mtype = GetValue(head,i);
    92. 		if(msg->mtype != msg->pid){//mtype = pid说明是发送消息的客户端，不用再接收自己发送的消息
    93.  
    94. 			msgsnd(msgid,msg,MSG_LEN,0);
    95. 		}
    96. 	}
    97. }
    98.  
    99. int Empty(LinkList head)
    100. {
    101. 	return (head->next == NULL);
    102. }
    103.  
    104. int Insert(LinkList head,int value)
    105. {
    106. 	LinkList p;
    107. 	p = (LinkList)malloc(sizeof(ListNode));
    108. 	p->data = value;
    109. 	p->next = NULL;
    110. 	while(head->next){
    111. 		head = head->next;
    112. 	}
    113. 	head->next = p;
    114. 	return 0;
    115. }
    116.  
    117. void Delete(LinkList head,int value)
    118. {
    119. 	LinkList p = head->next;
    120. 	while(p!=NULL){
    121. 		if(p->data == value){
    122. 			head->next = p->next;
    123. 			free(p);
    124. 			p = head->next;
    125. 		}else{
    126. 			head = p;
    127. 			p = p->next;
    128. 		}
    129. 	}
    130. }
    131.  
    132. int GetValue(LinkList head,int pos)
    133. {
    134. 	head = head->next;
    135. 	while(pos--){
    136. 		head = head->next;
    137. 	}
    138. 	return head->data;
    139. }

  • 相关阅读:
    【自动化测试】——robotframework实战（二）新建测试用例
    win10 磁盘命令 修复磁盘硬盘
    【ACM数论】和式变换技术，也许是最好的讲解之一
    【面试：并发篇27：多线程：犹豫模式】
    marquee.弹窗事件
    Java架构师内功计算机网络
    编程机器人的参数表怎么看
    Python和Numpy的加权抛硬币游戏的概率
    Docker Swarm集群部署管理
    大数据基础设施搭建 - Flink
  • 原文地址：https://blog.csdn.net/weixin_43042683/article/details/127797687