java黑洞网 首页 博客 问答 站长公众号 pdf 视频 游戏 脚本 实战 其它资源
写博客 注册
本站消息

站长简介/公众号

  出租广告位,需要合作请联系站长


+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

2024-11(1)

项目 - 员工信息管理系统

发布于2022-12-29 06:38     阅读(679)     评论(0)     点赞(23)     收藏(4)

员工管理系统工作流程图：

员工管理系统-服务器端流程图：

 员工管理系统-客户端流程图：

 

项目名称：员工管理系统

项目时间：3天

项目描述：

1）服务器负责管理所有员工表单（以数据库形式或文件形式都可），其他客户端可通过网络连接服务器来查询员工表单。

2）需要账号密码登陆，其中需要区分管理员账号还是普通用户账号。

3）管理员账号可以查看、修改员工表单，管理员要负责管理所有的普通用户。

4）普通用户只能查询修改与本人有关的相关信息，其他员工信息（出于保密原则）不得泄露。

5）有查询历史记录功能。

6）能同时处理多台客户端的请求功能。

  1. 【1】TCP通信的编程步骤
  2.   1.服务器：
  3. 	1）创建套接字
  4. 	2）绑定ip和端口号
  5. 	3）监听
  6. 	4）等待客户端连接
  7. 	
  8. 	int main()
  9. 	{
  10. 		//1.创建套接字
  11. 		int sockfd = socket();
  12. 		//2.初始化通信结构
  13. 		struct sockaddr_in addr;
  14. 		addr.sin_family=AF_INET;
  15. 		addr.sin_port = port;
  16. 		addr.sin_addr=addr;
  17. 		bind(sockfd, &addr);
  18. 		//3.监听
  19. 		listen();
  20. 		//4.连接
  21. 		while(1)
  22. 		{
  23. 			int connfd = accept();
  24. 			//5.循环数据收发
  25. 			while(1)
  26. 			{
  27. 				recv();
  28. 				send();
  29. 			}
  30. 		}
  31. 		close(sockfd);
  32. 		close(connfd);
  33. 	}
  34.   2.客户端：
  35. 	1）创建套接字
  36. 	2）连接服务器
  37. 	
  38. 	int main()
  39. 	{
  40. 		//1.创建套接字
  41. 		int sockfd = socket();
  42. 		//2.初始化通信结构
  43. 		struct sockaddr_in addr;
  44. 		addr.sin_family=AF_INET;
  45. 		addr.sin_port = port;
  46. 		addr.sin_addr=addr;
  47. 		//3.连接
  48. 		connect();
  49. 		//5.循环数据收发
  50. 		while(1)
  51. 		{
  52. 			send();
  53. 			recv();
  54. 		}
  55. 	}
  56. 	
  57. 【2】服务器模型
  58.  1.循环服务器
  59.  2.并发服务器
  60. 	1）多线程
  61. 	2）多进程
  62. 	3）IO多路复用：
  63. 		a. select：
  64. 		基本思想：
  65. 		1. 先构造一张有关文件描述符的表(集合、数组); fd_set fd;
  66. 		2. 将你关心的文件描述符加入到这个表中;FD_SET();
  67. 		3. 然后调用一个函数。 select / poll 
  68. 		4. 当这些文件描述符中的一个或多个已准备好进行I/O操作的时候
  69. 				该函数才返回(阻塞)。
  70. 		5. 判断是哪一个或哪些文件描述符产生了事件(IO操作);
  71. 		6. 做对应的逻辑处理;
  72. 		****select函数返回之后，会自动将除了产生事件的文件描述符以外的位全部清空;
  73. 		程序步骤：
  74. 		1.把关心的文件描述符放入集合--FD_SET
  75. 		2.监听集合中的文件描述符--select
  76. 		3.依次判断哪个文件描述符有数据--FD_ISSET
  77. 		4.依次处理有数据的文件描述符的数据
  78. 		伪代码：
  79. 		fd_set fd;
  80. 		FD_SET(sockfd);
  81. 		while(1) {
  82. 			设置监听读写文件描述符集合(FD_*);
  83. 			调用select;
  84. 			select();	
  85. 			如果是监听套接字就绪,说明有新的连接请求 
  86. 			if(sockfd)
  87. 			{
  88. 				建立连接();
  89. 				int connfd = accept();
  90. 				加入到监听文件描述符集合;
  91. 				FD_SET(connfd);
  92. 			}否则说明是一个已经连接过的描述符 
  93. 			else
  94. 			{
  95. 				进行操作(send或者recv);
  96. 				recv();
  97. 				send();
  98. 			}
  99. 		} 
  100. 		select弊端： 
  101. 			1. 一个进程最多只能监听1024个文件描述符 （千级别）
  102. 			2. select是一种轮询的机制;
  103. 			3. 涉及到用户态和内核态的数据拷贝;
  104. 		
  105. 		b. poll
  106. 			1. 优化文件描述符个数的限制;
  107. 			2. poll是一种轮询的机制;
  108. 			3. 涉及到用户态和内核态的数据拷贝;
  109. 			函数接口：	   
  110. 			int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  111. 			参数：
  112. 				struct pollfd *fds
  113. 				关心的文件描述符数组struct pollfd fds[N];
  114. 				nfds:个数
  115. 				timeout： 超市检测
  116. 						毫秒级的：如果填1000，1秒
  117. 								  如果-1，阻塞
  118. 								  
  119. 			问题：
  120. 			我想检测是键盘事件(标准输入 文件描述如为0 )，
  121. 			还是鼠标事件(文件描述符是/dev/input/mouse1);				  				
  122. 			1. 创建一个结构体数组
  123. 				struct pollfd fds[2];
  124. 			2. 将你关心的文件描述符加入到结构体成员中
  125. 				struct pollfd {
  126. 				   int   fd;         // 关心的文件描述符;
  127. 				   short events;     // 关心的事件，读
  128. 				   short revents;    // 如果产生事件，则会自动填充该成员的值
  129. 				};
  130. 			
  131. 				// 键盘
  132. 				fds[0].fd = 0;
  133. 				fds[0].events = POLLIN;
  134. 				
  135. 				//鼠标
  136. 				fds[1].fd = mouse1_fd;
  137. 				fds[1].events = POLLIN;
  138. 			
  139. 			3. 调用poll函数
  140. 				如果返回表示有事件产生;
  141. 				poll(fds,2,1000)
  142. 			4. 判断具体是哪个文件描述符产生了事件
  143. 				if(fds[0].revents == POLLIN)
  144. 				{
  145. 					....
  146. 				}
  147. 			
  148. 		c. epoll
  149. 			1. 没有文件描述符的限制
  150. 			2. 异步IO，当有事件产生，文件描述符主动调用callback
  151. 			3. 不用数据拷贝;
  152. 			
  153. 		3个功能函数：
  154. 			#include <sys/epoll.h>
  155. 			int epoll_create(int size);//创建红黑树根节点
  156. 			//成功时返回epoll文件描述符，失败时返回-1
  157. 			
  158. 			//控制epoll属性
  159. 			int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
  160. 			epfd:epoll_create函数的返回句柄。
  161. 			op:表示动作类型。有三个宏 来表示：
  162. 			EPOLL_CTL_ADD：注册新的fd到epfd中
  163. 			EPOLL_CTL_MOD：修改已注册fd的监听事件
  164. 			EPOLL_CTL_DEL：从epfd中删除一个fd
  165. 			FD:需要监听的fd。
  166. 			event:告诉内核需要监听什么事件
  167. 				EPOLLIN:表示对应文件描述符可读
  168. 				EPOLLOUT:可写
  169. 				EPOLLPRI：有紧急数据可读；
  170. 				EPOLLERR：错误；
  171. 				EPOLLHUP：被挂断；
  172. 				EPOLLET：触发方式，电平触发；
  173. 					 ET模式：表示状态的变化；
  174. 			//成功时返回0，失败时返回-1
  175. 			
  176. 			//等待事件到来
  177. 			int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
  178. 			功能：等待事件的产生，类似于select嗲用
  179. 			epfd:句柄；
  180. 			events：用来从内核得到事件的集合；
  181. 			maxevents:表示每次能处理事件最大个数；
  182. 			timeout：超时时间，毫秒，0立即返回，-1阻塞		
  183. 			//成功时返回发生事件的文件描述数，失败时返回-1
  184. 		伪代码：
  185. 		1.定义epoll事件，创建epoll的fd
  186. 			int epfd,epct,i;
  187. 			struct epoll_event event;       //定义epoll 事件
  188. 			struct epoll_event events[20];  //定义epoll 事件集合
  189. 			epfd = epoll_create(1); // 创建epoll 的fd 
  190. 		2.填充事件
  191. 			event.data.fd = serverFd;           //填充事件的fd
  192. 			event.events = EPOLLIN | EPOLLET;   //填充 事件类型 
  193. 			epoll_ctl(epfd,EPOLL_CTL_ADD,serverFd,&event);  //把serverFd（监听FD）注册到epfd中
  194. 		3.监听事件
  195. 			while(1){		
  196. 				epct = epoll_wait(epfd,events,20,-1); // 等待事件到来，阻塞模式 
  197. 				for(i=0;i<epct;i++){  //根据epoll返回的值来查询事件			
  198. 					if(events[i].data.fd == serverFd){ // 如果事件的fd是监听fd，调用accept处理
  199. 						clientFd = accept();
  200. 						//添加clientfd描述符
  201. 						epoll_ctl(epfd,EPOLL_CTL_ADD,clientFd,&event);					
  202. 					}else {  
  203. 					//如果不是serverFd，应是client数据事件，调用读数据
  204. 						read();
  205. 					}	
  206. 				}
  207. 			}
  208.  
  209. 【3】数据库函数接口
  210. 	1.int   sqlite3_open(char  *path,   sqlite3 **db)；        
  211. 	功能：打开sqlite数据库  
  212. 	参数：
  213. 		path： 数据库文件路径         
  214. 		db： 指向sqlite句柄的指针     
  215. 	返回值：成功返回0，失败返回错误码(非零值)
  217. 	2.int   sqlite3_close(sqlite3 *db);
  218. 	功能：关闭sqlite数据库
  219.     返回值：成功返回0，失败返回错误码
  220.  
  221. 	3.int sqlite3_exec(sqlite3 *db, const  char  *sql,  
  222. 			sqlite3_callback callback, void *,  char **errmsg);
  223. 	功能：执行SQL语句
  224. 	参数：
  225. 		 db：数据库句柄
  226.          sql：SQL语句 ("create table stu .....;")
  227.          callback：回调函数
  228. 		 void * arg： 
  229. 			当使用查询命令的时候，callback和arg才有意义；
  230. 			select .....			
  231.          errmsg：错误信息指针的地址
  232. 			 char *errmsg;    
  233. 			 &errmsg;
  234. 	返回值：成功返回0，失败返回错误码
  235. 	int callback(void *para, int f_num, char **f_value, char **f_name);
  236. 	功能：每找到一条记录自动执行一次回调函数
  237. 	参数：
  238. 		para：   传递给回调函数的参数
  239. 		f_num：  记录中包含的字段数目(id name score) 
  240. 				 相当于有多少列;
  241. 		f_value：包含每个字段值的指针数组
  242. 		f_name：包含每个字段名称的指针数组		
  243. 	返回值：成功返回0，失败返回-1
  244. 	
  245. 	4.int  sqlite3_get_table(sqlite3 *db, const  char  *sql,
  246. 			char ***resultp,  int *nrow,  int *ncolumn, char **errmsg);
  247.     功能：执行SQL操作
  248. 	参数：
  249. 		db：数据库句柄
  250. 		sql：SQL语句
  251. 		resultp：用来指向sql执行结果的指针;实际上就是“指针数组指针”；
  252. 		nrow：满足条件的记录的数目，实际上就是有多少行数据;
  253. 		ncolumn：每条记录包含的字段数目，实际上就是有多少个字段(多少列);
  254. 		errmsg：错误信息指针的地址
  255.     返回值：成功返回0，失败返回错误码
  256. 	
  257. 练习：创建数据库stu.db，包含name、id、score字段，实现对数据库的增删改查。

代码实现：

服务器端（common.h文件,客户端服务器通用）：

  1.  
  2. #ifndef _COMMON_H_
  3. #define _COMMON_H_
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <sys/socket.h>
  8. #include <sys/types.h>
  9. #include <arpa/inet.h>
  10. #include <unistd.h>
  11. #include <errno.h>
  12. #include <string.h>
  13. #include <sqlite3.h>
  14. #include <sys/wait.h>
  15. #include <signal.h>
  16. #include <time.h>
  17. #include <pthread.h>
  18. #include <sys/stat.h>
  19. #include <sqlite3.h>
  20. #include <netinet/in.h>
  21. #include <sys/select.h>
  22. #include <pthread.h>
  23.  
  24. #define STAFF_DATABASE 	 "staff_manage_system.db"
  25.  
  26. #define USER_LOGIN 		0x00000000  // login	登陆    0x00000001
  27. #define USER_MODIFY 	0x00000001  // user-modification  修改
  28. #define USER_QUERY 		0x00000002  // user-query   查询
  29.  
  30. #define ADMIN_LOGIN 	0x10000000  // login	         登陆    0x00000001
  31. #define ADMIN_MODIFY 	0x10000001 // admin_modification 修改
  32. #define ADMIN_ADDUSER 	0x10000002 // admin_adduser      添加
  33. #define ADMIN_DELUSER 	0x10000004 // admin_deluser      删除
  34. #define ADMIN_QUERY 	0x10000008  //hitory_query       查找
  35. #define ADMIN_HISTORY 	0x10000010  //hitory_history     历史
  36.  
  37. #define ADMIN_LIST      0x10000011 //列表
  38.  
  39. #define QUIT 			0x11111111
  40.  
  41. #define ADMIN 0	//管理员
  42. #define USER  1	//用户
  43.  
  44. #define PASSLEN 8
  45. #define NAMELEN 16
  46. #define DATALEN 128
  47.  
  48. /*员工基本信息*/
  49. typedef struct staff_info
  50. {
  51. 	int  no; 					//员工编号
  52. 	int  usertype;  			//ADMIN 1	USER 2	 
  53. 	char name[NAMELEN];			//姓名
  54. 	char passwd[PASSLEN]; 		//密码
  55. 	int  age; 					// 年龄
  56. 	char phone[NAMELEN];		//电话
  57. 	char addr[DATALEN]; 		// 地址
  58. 	char work[DATALEN]; 		//职位
  59. 	char date[DATALEN];			//入职年月
  60. 	int level;					// 等级
  61. 	int salary;					// 工资
  62. 	
  63. }staff_info_t;
  64.  
  65. /*定义双方通信的结构体信息*/
  66. typedef struct 
  67. {
  68. 	int  msgtype;       	 //请求的消息类型
  69. 	int  usertype;   		 //ADMIN 1	USER 2	   
  70. 	char username[NAMELEN];  //姓名
  71. 	char passwd[PASSLEN];	 //登陆密码
  72. 	char recvmsg[DATALEN];   //通信的消息
  73. 	int  flags;      		 //标志位
  74. 	staff_info_t info;       //员工信息
  75. }MSG;
  76.  
  77. #define S_IP "10.0.12.9"
  78. #define IP "124.223.177.144"
  79. #define PORT "8888"
  80.  
  81. char user_name[NAMELEN];	 //姓名
  82. char user_passwd[PASSLEN];	 //登陆密码
  83.  
  84. char history[DATALEN+100];
  85.  
  86.  
  87.  
  88.  
  89. #endif
  90.

服务器端（server.h文件）：

  1. int process_user_or_admin_login_request(int acceptfd, MSG *msg);
  2. int process_user_modify_request(int acceptfd, MSG *msg);
  3. int process_user_query_request(int acceptfd, MSG *msg);
  4. int process_admin_modify_request(int acceptfd, MSG *msg);
  5. int process_admin_adduser_request(int acceptfd, MSG *msg);
  6. int process_admin_deluser_request(int acceptfd, MSG *msg);
  7. int process_admin_query_request(int acceptfd, MSG *msg);
  8. int process_admin_history_request(int acceptfd, MSG *msg);
  9. int process_admin_list_request(int acceptfd, MSG *msg);
  10. int process_client_quit_request(int acceptfd, MSG *msg);
  11. int process_client_request(int acceptfd, MSG *msg);
  12. int process_recv_history_request(char *name,char *str);

服务器端（server.c文件）：

  1.  
  2. #include "common.h"
  3. #include "server.h"
  4.  
  5. sqlite3 *db = NULL;
  6.  
  7. //登录
  8. int process_user_or_admin_login_request(int acceptfd, MSG *msg)
  9. {
  10.  
  11. 	//封装sql命令，表中查询用户名和密码－存在－登录成功－发送响应－失败－发送失败响应
  12. 	char sql[DATALEN] = {0};
  13. 	char *errmsg;
  14. 	char **result;
  15. 	int nrow, ncolumn;
  16.  
  17. 	msg->info.usertype = msg->usertype;
  18. 	strcpy(msg->info.name, msg->username);
  19. 	strcpy(msg->info.passwd, msg->passwd);
  20.  
  21. 	strcpy(user_name, msg->username);
  22. 	strcpy(user_passwd, msg->username);
  23.  
  24. 	printf("usertype: %#x ,username: %s ,userpasswd: %s.\n", msg->info.usertype, msg->info.name, msg->info.passwd);
  25. 	sprintf(sql, "select * from usrinfo where usertype=%d and name='%s' and passwd='%s';", msg->info.usertype, msg->info.name, msg->info.passwd);
  26.  
  27. 	if (sqlite3_get_table(db, sql, &result, &nrow, &ncolumn, &errmsg) != SQLITE_OK)
  28. 	{
  29. 		printf("---****----%s.\n", errmsg);
  30. 	}
  31. 	else
  32. 	{
  33. 		// printf("----nrow-----%d,ncolumn-----%d.\n",nrow,ncolumn);
  34. 		if (nrow == 0)
  35. 		{
  36. 			//查询到行为0
  37. 			strcpy(msg->recvmsg, "name or passwd failed.\n");
  38. 			send(acceptfd, msg, sizeof(MSG), 0);
  39. 			process_recv_history_request(msg->username, "longin error!");
  40. 		}
  41. 		else
  42. 		{
  43. 			strcpy(msg->recvmsg, "OK");
  44. 			send(acceptfd, msg, sizeof(MSG), 0);
  45. 			process_recv_history_request(msg->username, "longin success!");
  46. 		}
  47. 	}
  48. 	return 0;
  49. }
  50.  
  51. //用户修改
  52. int process_user_modify_request(int acceptfd, MSG *msg)
  53. {
  54. 	char cmd[NAMELEN] = "";
  55. 	char *errmsg;
  56. 	char sql[DATALEN + 100] = "";
  57. 	int nrow = 0, ncolumn;
  58. 	char **result;
  59.  
  60. 	switch (msg->flags)
  61. 	{
  62. 	case 1:
  63. 		sprintf(sql, "select * from usrinfo where taffon=%d;",msg->info.no);
  64.  
  65. 		if (sqlite3_get_table(db, sql, &result, &nrow, &ncolumn, &errmsg) == SQLITE_OK)
  66. 		{
  67. 			memset(msg->recvmsg, 0, DATALEN);
  68. 			strcpy(msg->recvmsg, "no");
  69. 			send(acceptfd, msg, sizeof(MSG), 0);
  70. 			sqlite3_free_table(result);
  71. 			return -1;
  72. 		}
  73. 		sprintf(sql, "UPDATE usrinfo SET taffon=%d WHERE name='%s' AND passwd='%s';", msg->info.no, msg->username, msg->passwd);
  74. 		
  75. 		memset(history, 0, DATALEN);
  76. 		sprintf(history,"change taffon -> %d", msg->info.no);
  77. 		process_recv_history_request(msg->username, history);
  78. 		
  79. 		break;
  80. 	case 2:
  81. 		// sprintf(sql, "UPDATE usrinfo SET usertype=%d WHERE name='%s' AND passwd='%s';",msg->info.usertype,msg->username,msg->passwd);
  82. 		{
  83. 			memset(msg, 0, sizeof(MSG));
  84. 			strcpy(msg->recvmsg, "no");
  85. 			if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  86. 			{
  87. 				printf("Sending the account to the client error\n");
  88. 				return -1;
  89. 			}
  90. 			return -1;
  91. 		}
  92. 		break;
  93. 	case 3:
  94. 		sprintf(sql, "UPDATE usrinfo SET name='%s' WHERE name='%s' AND passwd='%s';", msg->info.name, msg->username, msg->passwd);
  95. 		
  96. 		memset(history, 0, DATALEN);
  97. 		sprintf(history,"change name -> %s", msg->info.name);
  98. 		process_recv_history_request(msg->username, history);
  99. 		
  100. 		break;
  101. 	case 4:
  102. 		sprintf(sql, "UPDATE usrinfo SET passwd='%s' WHERE name='%s' AND passwd='%s';", msg->info.passwd, msg->username, msg->passwd);
  103. 		
  104. 		memset(history, 0, DATALEN);
  105. 		sprintf(history,"change passwd -> %s", msg->info.passwd);
  106. 		process_recv_history_request(msg->username, history);
  107.  
  108. 		break;
  109. 	case 5:
  110. 		sprintf(sql, "UPDATE usrinfo SET age=%d WHERE name='%s' AND passwd='%s';", msg->info.age, msg->username, msg->passwd);
  111.  
  112. 		memset(history, 0, DATALEN);
  113. 		sprintf(history,"change age -> %d", msg->info.age);
  114. 		process_recv_history_request(msg->username, history);
  115. 		
  116. 		break;
  117. 	case 6:
  118. 		sprintf(sql, "UPDATE usrinfo SET phone='%s' WHERE name='%s' AND passwd='%s';", msg->info.phone, msg->username, msg->passwd);
  119.  
  120. 		memset(history, 0, DATALEN);
  121. 		sprintf(history,"change phone -> %s", msg->info.phone);
  122. 		process_recv_history_request(msg->username, history);
  123. 		
  124. 		break;
  125. 	case 7:
  126. 		sprintf(sql, "UPDATE usrinfo SET addr='%s' WHERE name='%s' AND passwd='%s';", msg->info.addr, msg->username, msg->passwd);
  127.  
  128. 		memset(history, 0, DATALEN);
  129. 		sprintf(history,"change addr -> %s", msg->info.addr);
  130. 		process_recv_history_request(msg->username, history);
  131. 		
  132. 		break;
  133. 	case 8:
  134. 		sprintf(sql, "UPDATE usrinfo SET work='%s' WHERE name='%s' AND passwd='%s';", msg->info.work, msg->username, msg->passwd);
  135.  
  136. 		memset(history, 0, DATALEN);
  137. 		sprintf(history,"change work -> %s", msg->info.work);
  138. 		process_recv_history_request(msg->username, history);
  139. 		
  140. 		break;
  141. 	case 9:
  142. 		sprintf(sql, "UPDATE usrinfo SET date='%s' WHERE name='%s' AND passwd='%s';", msg->info.date, msg->username, msg->passwd);
  143.  
  144. 		memset(history, 0, DATALEN);
  145. 		sprintf(history,"change date -> %s", msg->info.date);
  146. 		process_recv_history_request(msg->username, history);
  147. 		
  148. 		break;
  149. 	case 10:
  150. 		sprintf(sql, "UPDATE usrinfo SET level=%d WHERE name='%s' AND passwd='%s';", msg->info.level, msg->username, msg->passwd);
  151.  
  152. 		memset(history, 0, DATALEN);
  153. 		sprintf(history,"change level -> %d", msg->info.level);
  154. 		process_recv_history_request(msg->username, history);
  155. 		
  156. 		break;
  157. 	case 11:
  158. 		sprintf(sql, "UPDATE usrinfo SET salary=%d WHERE name='%s' AND passwd='%s';", msg->info.salary, msg->username, msg->passwd);
  159.  
  160. 		memset(history, 0, DATALEN);
  161. 		sprintf(history,"change salary -> %d", msg->info.salary);
  162. 		process_recv_history_request(msg->username, history);
  163. 		
  164. 		break;
  165. 	default:
  166. 		printf("enter error\n");
  167. 		return -1;
  168. 	}
  169.  
  170. 	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
  171. 	{
  172. 		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
  173. 		memset(msg, 0, sizeof(MSG));
  174. 		strcpy(msg->recvmsg, "no");
  175. 		if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  176. 		{
  177. 			printf("Sending the account to the client error\n");
  178. 			return -1;
  179. 		}
  180. 		return -1;
  181. 	}
  182. 	memset(msg, 0, sizeof(MSG));
  183. 	strcpy(msg->recvmsg, "ok");
  184. 	if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  185. 	{
  186. 		printf("Sending the account to the client error\n");
  187. 		return -1;
  188. 	}
  189. 	return 1;
  190. }
  191.  
  192. //用户查找
  193. int process_user_query_request(int acceptfd, MSG *msg)
  194. {
  195. 	char sql[DATALEN + 50] = "";
  196. 	char **result = NULL;
  197. 	int row, column;
  198. 	char *errmsg = NULL;
  199.  
  200. 	memset(history, 0, DATALEN);
  201. 	sprintf(history,"query self request");
  202. 	process_recv_history_request(msg->username, history);
  203.  
  204. 	sprintf(sql, "select * from usrinfo where name='%s' and passwd='%s';", msg->username, msg->passwd);
  205.  
  206. 	if (sqlite3_get_table(db, sql, &result, &row, &column, &errmsg) != SQLITE_OK)
  207. 	{
  208. 		goto end;
  209. 	}
  210. 	printf("查询结果成功\n");
  211.  
  212. 	if (row == 0)
  213. 	{
  214. 		memset(msg->recvmsg, 0, DATALEN);
  215. 		strcpy(msg->recvmsg, "no");
  216. 		send(acceptfd, msg, sizeof(MSG), 0);
  217. 		sqlite3_free_table(result);
  218. 		return -1;
  219. 	}
  220.  
  221. 	printf("row=%d column=%d\n", row, column);
  222.  
  223. 	int i = 0;
  224.  
  225. 	memset(msg->recvmsg, 0, DATALEN);
  226. 	for (i = 11; i < (row + 1) * column; i++)
  227. 	{
  228. 		switch (i % column)
  229. 		{
  230. 		case 0:
  231. 			msg->info.no = atoi(result[i]);
  232. 			break;
  233. 		case 1:
  234. 			msg->info.usertype = atoi(result[i]);
  235. 			break;
  236. 		case 2:
  237. 			strcpy(msg->info.name, result[i]);
  238. 			break;
  239. 		case 3:
  240. 			strcpy(msg->info.passwd, result[i]);
  241. 			break;
  242. 		case 4:
  243. 			msg->info.age = atoi(result[i]);
  244. 			break;
  245. 		case 5:
  246. 			strcpy(msg->info.phone, result[i]);
  247. 			break;
  248. 		case 6:
  249. 			strcpy(msg->info.addr, result[i]);
  250. 			break;
  251. 		case 7:
  252. 			strcpy(msg->info.work, result[i]);
  253. 			break;
  254. 		case 8:
  255. 			strcpy(msg->info.date, result[i]);
  256. 			break;
  257. 		case 9:
  258. 			msg->info.level = atoi(result[i]);
  259. 			break;
  260. 		case 10:
  261. 			msg->info.salary = atoi(result[i]);
  262. 			break;
  263. 		default:
  264. 			break;
  265. 		}
  266. 		if (i % column == (column - 1))
  267. 		{
  268. 			send(acceptfd, msg, sizeof(MSG), 0);
  269. 			memset(msg->recvmsg, 0, DATALEN);
  270. 		}
  271. 	}
  272. 	putchar(10);
  273.  
  274. end:
  275. 	memset(msg->recvmsg, 0, DATALEN);
  276. 	strcpy(msg->recvmsg, "end");
  277. 	send(acceptfd, msg, sizeof(MSG), 0);
  278.  
  279. 	//释放查询到的结果
  280. 	sqlite3_free_table(result);
  281.  
  282. 	return 0;
  283. }
  284.  
  285. //管理修改
  286. int process_admin_modify_request(int acceptfd, MSG *msg)
  287. {
  288. 	char cmd[NAMELEN] = "";
  289. 	char *errmsg;
  290. 	char sql[DATALEN + 100] = "";
  291. 	int nrow = 0, ncolumn;
  292. 	char **result;
  293.  
  294. 	sprintf(sql, "select * from usrinfo where name='%s';", msg->username);
  295.  
  296. 	if (sqlite3_get_table(db, sql, &result, &nrow, &ncolumn, &errmsg) != SQLITE_OK)
  297. 	{
  298. 		printf("---select error----%s.\n", errmsg);
  299. 	}
  300.  
  301. 	if (nrow == 0)
  302. 	{
  303. 		//如果此人信息不存在
  304. 		memset(msg, 0, sizeof(MSG));
  305. 		strcpy(msg->recvmsg, "no");
  306. 		send(acceptfd, msg, sizeof(MSG), 0);
  307. 		return 0;
  308. 	}
  309.  
  310. 	switch (msg->flags)
  311. 	{
  312. 	case 1:
  313. 		sprintf(sql, "UPDATE usrinfo SET taffon=%d WHERE name='%s';", msg->info.no, msg->username);
  314. 				
  315. 		memset(history, 0, DATALEN);
  316. 		sprintf(history,"change %s taffon -> %d",msg->username,msg->info.no);
  317. 		process_recv_history_request(msg->username, history);
  318. 		
  319. 		break;
  320. 	case 2:
  321. 		sprintf(sql, "UPDATE usrinfo SET usertype=%d WHERE name='%s';", msg->info.usertype, msg->username);
  322. 				
  323. 		memset(history, 0, DATALEN);
  324. 		sprintf(history,"change %s usertype -> %s",msg->username, msg->info.name);
  325. 		process_recv_history_request(msg->username, history);
  326. 		
  327. 		break;
  328. 	case 3:
  329. 		sprintf(sql, "UPDATE usrinfo SET name='%s' WHERE name='%s';", msg->info.name, msg->username);
  330. 				
  331. 		memset(history, 0, DATALEN);
  332. 		sprintf(history,"change %s name -> %s",msg->username, msg->info.name);
  333. 		process_recv_history_request(msg->username, history);
  334. 		
  335. 		break;
  336. 	case 4:
  337. 		sprintf(sql, "UPDATE usrinfo SET passwd='%s' WHERE name='%s';", msg->info.passwd, msg->username);
  338. 				
  339. 		memset(history, 0, DATALEN);
  340. 		sprintf(history,"change %s passwd -> %s",msg->username, msg->info.passwd);
  341. 		process_recv_history_request(msg->username, history);
  342.  
  343. 		break;
  344. 	case 5:
  345. 		sprintf(sql, "UPDATE usrinfo SET age=%d WHERE name='%s';", msg->info.age, msg->username);
  346. 		
  347. 		memset(history, 0, DATALEN);
  348. 		sprintf(history,"change %s age -> %d", msg->username,msg->info.age);
  349. 		process_recv_history_request(msg->username, history);
  350. 		
  351. 		break;
  352. 	case 6:
  353. 		sprintf(sql, "UPDATE usrinfo SET phone='%s' WHERE name='%s';", msg->info.phone, msg->username);
  354. 		
  355. 		memset(history, 0, DATALEN);
  356. 		sprintf(history,"change %s phone -> %s",msg->username, msg->info.phone);
  357. 		process_recv_history_request(msg->username, history);
  358. 		
  359. 		break;
  360. 	case 7:
  361. 		sprintf(sql, "UPDATE usrinfo SET addr='%s' WHERE name='%s';", msg->info.addr, msg->username);
  362. 		
  363. 		memset(history, 0, DATALEN);
  364. 		sprintf(history,"change %s addr -> %s",msg->username, msg->info.addr);
  365. 		process_recv_history_request(msg->username, history);
  366. 		
  367. 		break;
  368. 	case 8:
  369. 		sprintf(sql, "UPDATE usrinfo SET work='%s' WHERE name='%s';", msg->info.work, msg->username);
  370. 		
  371. 		memset(history, 0, DATALEN);
  372. 		sprintf(history,"change %s work -> %s",msg->username, msg->info.work);
  373. 		process_recv_history_request(msg->username, history);
  374. 		
  375. 		break;
  376. 	case 9:
  377. 		sprintf(sql, "UPDATE usrinfo SET date='%s' WHERE name='%s';", msg->info.date, msg->username);
  378. 		
  379. 		memset(history, 0, DATALEN);
  380. 		sprintf(history,"change %s date -> %s",msg->username, msg->info.date);
  381. 		process_recv_history_request(msg->username, history);
  382. 		
  383. 		break;
  384. 	case 10:
  385. 		sprintf(sql, "UPDATE usrinfo SET level=%d WHERE name='%s';", msg->info.level, msg->username);
  386. 		
  387. 		memset(history, 0, DATALEN);
  388. 		sprintf(history,"change %s level -> %d",msg->username, msg->info.level);
  389. 		process_recv_history_request(msg->username, history);
  390. 		
  391. 		break;
  392. 	case 11:
  393. 		sprintf(sql, "UPDATE usrinfo SET salary=%d WHERE name='%s';", msg->info.salary, msg->username);
  394. 		
  395. 		memset(history, 0, DATALEN);
  396. 		sprintf(history,"change %s salary -> %d", msg->username,msg->info.salary);
  397. 		process_recv_history_request(msg->username, history);
  398. 		
  399. 		break;
  400. 	default:
  401. 		printf("enter error\n");
  402. 		return -1;
  403. 	}
  404.  
  405. 	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
  406. 	{
  407. 		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
  408. 		return -1;
  409. 	}
  410. 	memset(msg, 0, sizeof(MSG));
  411. 	strcpy(msg->recvmsg, "ok");
  412. 	if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  413. 	{
  414. 		printf("Sending the account to the client error\n");
  415. 		return -1;
  416. 	}
  417. 	return 1;
  418. }
  419.  
  420. //管理添加
  421. int process_admin_adduser_request(int acceptfd, MSG *msg)
  422. {
  423. 	char cmd[NAMELEN] = "";
  424. 	char *errmsg;
  425. 	char sql[DATALEN + 400] = "";
  426. 	int nrow = 0, ncolumn;
  427. 	char **result;
  428.  
  429. 					
  430. 	memset(history, 0, DATALEN);
  431. 	sprintf(history,"%s add %s",user_name,msg->info.name);
  432. 	process_recv_history_request(msg->username, history);
  433. 		
  434.  
  435. 	sprintf(sql, "select * from usrinfo where staffno=%d;", msg->info.no);
  436.  
  437. 	if (sqlite3_get_table(db, sql, &result, &nrow, &ncolumn, &errmsg) != SQLITE_OK)
  438. 	{
  439. 		printf("%d\n", __LINE__);
  440. 		memset(msg, 0, sizeof(MSG));
  441. 		strcpy(msg->recvmsg, "no");
  442. 		send(acceptfd, msg, sizeof(MSG), 0);
  443. 		return -1;
  444. 	}
  445.  
  446. 	if (nrow != 0)
  447. 	{
  448. 		//如果此人信息存在
  449. 		printf("%d\n", __LINE__);
  450. 		memset(msg, 0, sizeof(MSG));
  451. 		strcpy(msg->recvmsg, "no");
  452. 		send(acceptfd, msg, sizeof(MSG), 0);
  453. 		return 0;
  454. 	}
  455.  
  456. 	sprintf(sql, "INSERT INTO usrinfo VALUES (%d,%d,'%s','%s',%d,'%s','%s','%s','%s',%d,%d);", msg->info.no, msg->info.usertype, msg->info.name, msg->info.passwd, msg->info.age, msg->info.phone, msg->info.addr, msg->info.work, msg->info.date, msg->info.level, msg->info.salary);
  457.  
  458. 	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
  459. 	{
  460. 		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
  461. 		return -1;
  462. 	}
  463. 	memset(msg, 0, sizeof(MSG));
  464. 	strcpy(msg->recvmsg, "ok");
  465. 	if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  466. 	{
  467. 		printf("Sending the account to the client error\n");
  468. 		return -1;
  469. 	}
  470. }
  471.  
  472. //管理删除
  473. int process_admin_deluser_request(int acceptfd, MSG *msg)
  474. {
  475. 	char sql[DATALEN] = "";
  476. 	char *errmsg;
  477.  
  478. 	memset(history, 0, DATALEN);
  479. 	sprintf(history,"%s del no -> %d",user_name,msg->info.no);
  480. 	process_recv_history_request(msg->username, history);
  481.  
  482. 	sprintf(sql, "DELETE FROM usrinfo WHERE staffno=%d;", msg->info.no);
  483.  
  484. 	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
  485. 	{
  486. 		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
  487. 		memset(msg, 0, sizeof(MSG));
  488. 		strcpy(msg->recvmsg, "no");
  489. 		if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  490. 		{
  491. 			printf("Sending the account to the client error\n");
  492. 			return -1;
  493. 		}
  494. 		return -1;
  495. 	}
  496.  
  497. 	memset(msg, 0, sizeof(MSG));
  498. 	strcpy(msg->recvmsg, "ok");
  499. 	if (send(acceptfd, msg, sizeof(MSG), 0) < 0)
  500. 	{
  501. 		printf("Sending the account to the client error\n");
  502. 		return -1;
  503. 	}
  504. }
  505.  
  506. //管理查找
  507. int process_admin_query_request(int acceptfd, MSG *msg)
  508. {
  509. 	char sql[DATALEN + 50] = "";
  510. 	char **result = NULL;
  511. 	int row, column;
  512. 	char *errmsg = NULL;
  513.  
  514. 	
  515. 	memset(history, 0, DATALEN);
  516. 	sprintf(history,"find no-> %d",msg->info.no);
  517. 	process_recv_history_request(user_name, history);
  518.  
  519.  
  520. 	sprintf(sql, "select * from usrinfo where staffno=%d;", atoi(msg->recvmsg));
  521.  
  522. 	if (sqlite3_get_table(db, sql, &result, &row, &column, &errmsg) != SQLITE_OK)
  523. 	{
  524. 		goto end;
  525. 	}
  526. 	printf("查询结果成功\n");
  527.  
  528. 	if (row == 0)
  529. 	{
  530. 		memset(msg->recvmsg, 0, DATALEN);
  531. 		strcpy(msg->recvmsg, "no");
  532. 		send(acceptfd, msg, sizeof(MSG), 0);
  533. 		sqlite3_free_table(result);
  534. 		return -1;
  535. 	}
  536.  
  537. 	printf("row=%d column=%d\n", row, column);
  538.  
  539. 	int i = 0;
  540.  
  541. 	memset(msg->recvmsg, 0, DATALEN);
  542. 	for (i = 11; i < (row + 1) * column; i++)
  543. 	{
  544. 		switch (i % column)
  545. 		{
  546. 		case 0:
  547. 			msg->info.no = atoi(result[i]);
  548. 			break;
  549. 		case 1:
  550. 			msg->info.usertype = atoi(result[i]);
  551. 			break;
  552. 		case 2:
  553. 			strcpy(msg->info.name, result[i]);
  554. 			break;
  555. 		case 3:
  556. 			strcpy(msg->info.passwd, result[i]);
  557. 			break;
  558. 		case 4:
  559. 			msg->info.age = atoi(result[i]);
  560. 			break;
  561. 		case 5:
  562. 			strcpy(msg->info.phone, result[i]);
  563. 			break;
  564. 		case 6:
  565. 			strcpy(msg->info.addr, result[i]);
  566. 			break;
  567. 		case 7:
  568. 			strcpy(msg->info.work, result[i]);
  569. 			break;
  570. 		case 8:
  571. 			strcpy(msg->info.date, result[i]);
  572. 			break;
  573. 		case 9:
  574. 			msg->info.level = atoi(result[i]);
  575. 			break;
  576. 		case 10:
  577. 			msg->info.salary = atoi(result[i]);
  578. 			break;
  579. 		default:
  580. 			break;
  581. 		}
  582. 		if (i % column == (column - 1))
  583. 		{
  584. 			send(acceptfd, msg, sizeof(MSG), 0);
  585. 			memset(msg->recvmsg, 0, DATALEN);
  586. 		}
  587. 	}
  588. 	putchar(10);
  589.  
  590. end:
  591. 	memset(msg->recvmsg, 0, DATALEN);
  592. 	strcpy(msg->recvmsg, "end");
  593. 	send(acceptfd, msg, sizeof(MSG), 0);
  594.  
  595. 	//释放查询到的结果
  596. 	sqlite3_free_table(result);
  597.  
  598. 	return 0;
  599. }
  600.  
  601. //管理历史
  602. int process_admin_history_request(int acceptfd, MSG *msg)
  603. {
  604. 	
  605. 	memset(history, 0, DATALEN);
  606. 	sprintf(history,"(passwd:%s) -> cat history",user_passwd);
  607. 	process_recv_history_request(user_name, history);
  608.  
  609.  
  610. 	char sql[DATALEN] = "";
  611. 	char **result = NULL;
  612. 	int row, column;
  613. 	char *errmsg = NULL;
  614.  
  615. 	sprintf(sql, "SELECT * FROM historyinfo;");
  616.  
  617. 	if (sqlite3_get_table(db, sql, &result, &row, &column, &errmsg) != SQLITE_OK)
  618. 	{
  619. 		memset(msg->recvmsg, 0, DATALEN);
  620. 	
  621. 		msg->flags = 1;
  622.  
  623. 		send(acceptfd, msg, sizeof(MSG), 0);
  624.  
  625. 		//释放查询到的结果
  626. 		sqlite3_free_table(result);
  627.  
  628. 		return -1;
  629.  
  630. 	}
  631. 	printf("查询结果成功\n");
  632.  
  633. 	if (row == 0)
  634. 	{
  635. 		memset(msg->recvmsg, 0, DATALEN);
  636. 		//strcpy(msg->recvmsg, "no");
  637.  
  638. 		msg->flags = 2;
  639.  
  640. 		send(acceptfd, msg, sizeof(MSG), 0);
  641. 		sqlite3_free_table(result);
  642. 		
  643. 		return -1;
  644. 	}
  645.  
  646. 	printf("row=%d column=%d\n", row, column);
  647.  
  648. 	int i = 0;
  649.  
  650. 	
  651. 	for (i = 3; i < (row + 1) * column; i++)
  652. 	{
  653. 		strcat(msg->recvmsg, result[i]);
  654. 		strcat(msg->recvmsg, "\t");
  655. 		if (i % column == (column - 1))
  656. 		{
  657. 			strcat(msg->recvmsg, "\n");
  658. 			send(acceptfd, msg, sizeof(MSG), 0);
  659.  
  660. 			recv(acceptfd, msg, sizeof(MSG), 0);
  661. 			
  662. 			printf("%s",msg->recvmsg);
  663. 			
  664. 			memset(msg->recvmsg, 0, DATALEN);
  665. 		}
  666. 	}
  667.  
  668. 	memset(msg->recvmsg, 0, DATALEN);
  669. 	
  670. 	msg->flags = 1;
  671.  
  672. 	send(acceptfd, msg, sizeof(MSG), 0);
  673.  
  674. 	//释放查询到的结果
  675. 	sqlite3_free_table(result);
  676. }
  677.  
  678. int process_recv_history_request(char *name, char *str)
  679. {
  680. 	char data[11] = ""; // 2022/10/29
  681. 	char timeb[9] = ""; // 02:18:00
  682.  
  683. 	char his[50] = "";
  684. 	char sql[DATALEN] = "";
  685. 	char *errmsg = NULL;
  686.  
  687. 	strcat(his, name);
  688. 	strcat(his, " : ");
  689. 	strcat(his, str);
  690.  
  691. 	//转换成日历格式
  692. 	struct tm *p = NULL;
  693. 	long int q;
  694.  
  695. 	q = time(NULL);
  696. 	p = localtime(&q);
  697.  
  698. 	sprintf(data, "%04d-%02d-%02d", p->tm_year + 1900, p->tm_mon + 1, p->tm_mday);
  699. 	sprintf(timeb, "%02d:%02d:%02d", p->tm_hour, p->tm_min, p->tm_sec);
  700.  
  701. 	sprintf(sql, "INSERT INTO historyinfo VALUES ('%s','%s','%s');", data, timeb, his);
  702.  
  703. 	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
  704. 	{
  705. 		fprintf(stderr, "__%d__ sqlite3_exec:%s\n", __LINE__, errmsg);
  706. 		return -1;
  707. 	}
  708. }
  709.  
  710. //列表
  711. int process_admin_list_request(int acceptfd, MSG *msg)
  712. {
  713. 		
  714. 	memset(history, 0, DATALEN);
  715. 	sprintf(history,"(passwd:%s) -> cat list",user_passwd);
  716. 	process_recv_history_request(user_name, history);
  717.  
  718.  
  719.  
  720. 	char sql[DATALEN] = "";
  721. 	char **result = NULL;
  722. 	int row, column;
  723. 	char *errmsg = NULL;
  724.  
  725. 	sprintf(sql, "SELECT * FROM usrinfo;");
  726.  
  727. 	if (sqlite3_get_table(db, sql, &result, &row, &column, &errmsg) != SQLITE_OK)
  728. 	{
  729. 		goto end;
  730. 	}
  731. 	printf("查询结果成功\n");
  732.  
  733. 	if (row == 0)
  734. 	{
  735. 		memset(msg->recvmsg, 0, DATALEN);
  736. 		strcpy(msg->recvmsg, "no");
  737. 		send(acceptfd, msg, sizeof(MSG), 0);
  738. 		sqlite3_free_table(result);
  739. 		return -1;
  740. 	}
  741.  
  742. 	printf("row=%d column=%d\n", row, column);
  743.  
  744. 	int i = 0;
  745.  
  746. 	memset(msg->recvmsg, 0, DATALEN);
  747. 	for (i = 11; i < (row + 1) * column; i++)
  748. 	{
  749. 		switch (i % column)
  750. 		{
  751. 		case 0:
  752. 			msg->info.no = atoi(result[i]);
  753. 			break;
  754. 		case 1:
  755. 			msg->info.usertype = atoi(result[i]);
  756. 			break;
  757. 		case 2:
  758. 			strcpy(msg->info.name, result[i]);
  759. 			break;
  760. 		case 3:
  761. 			strcpy(msg->info.passwd, result[i]);
  762. 			break;
  763. 		case 4:
  764. 			msg->info.age = atoi(result[i]);
  765. 			break;
  766. 		case 5:
  767. 			strcpy(msg->info.phone, result[i]);
  768. 			break;
  769. 		case 6:
  770. 			strcpy(msg->info.addr, result[i]);
  771. 			break;
  772. 		case 7:
  773. 			strcpy(msg->info.work, result[i]);
  774. 			break;
  775. 		case 8:
  776. 			strcpy(msg->info.date, result[i]);
  777. 			break;
  778. 		case 9:
  779. 			msg->info.level = atoi(result[i]);
  780. 			break;
  781. 		case 10:
  782. 			msg->info.salary = atoi(result[i]);
  783. 			break;
  784. 		default:
  785. 			break;
  786. 		}
  787. 		if (i % column == (column - 1))
  788. 		{
  789. 			send(acceptfd, msg, sizeof(MSG), 0);
  790. 			recv(acceptfd, msg, sizeof(MSG), 0);
  791. 			memset(msg->recvmsg, 0, DATALEN);
  792. 		}
  793. 	}
  794. 	putchar(10);
  795.  
  796. end:
  797. 	memset(msg->recvmsg, 0, DATALEN);
  798. 	strcpy(msg->recvmsg, "endd");
  799. 	send(acceptfd, msg, sizeof(MSG), 0);
  800.  
  801. 	//释放查询到的结果
  802. 	sqlite3_free_table(result);
  803. }
  804.  
  805. //客户端退出
  806. int process_client_quit_request(int acceptfd, MSG *msg)
  807. {
  808. 	printf("------------%s-----------%d.\n", __func__, __LINE__);
  809. }
  810.  
  811. //处理客户端请求
  812. int process_client_request(int acceptfd, MSG *msg)
  813. {
  814. 	//请求的消息类型
  815. 	switch (msg->msgtype)
  816. 	{
  817. 	case USER_LOGIN:
  818. 	case ADMIN_LOGIN:
  819. 		process_user_or_admin_login_request(acceptfd, msg); //登录
  820. 		break;
  821. 	case USER_MODIFY:
  822. 		process_user_modify_request(acceptfd, msg); //用户修改
  823. 		break;
  824. 	case USER_QUERY:
  825. 		process_user_query_request(acceptfd, msg); //用户查找
  826. 		break;
  827. 	case ADMIN_MODIFY:
  828. 		process_admin_modify_request(acceptfd, msg); //管理修改
  829. 		break;
  830. 	case ADMIN_ADDUSER:
  831. 		process_admin_adduser_request(acceptfd, msg); //管理添加
  832. 		break;
  833. 	case ADMIN_DELUSER:
  834. 		process_admin_deluser_request(acceptfd, msg); //管理删除
  835. 		break;
  836. 	case ADMIN_QUERY:
  837. 		process_admin_query_request(acceptfd, msg); //管理查找
  838. 		break;
  839. 	case ADMIN_HISTORY:
  840. 		process_admin_history_request(acceptfd, msg); //管理历史
  841. 		break;
  842. 	case ADMIN_LIST:
  843. 		process_admin_list_request(acceptfd, msg); //列表
  844. 		break;
  845. 	case QUIT:
  846. 		process_client_quit_request(acceptfd, msg); //客户端退出
  847. 		break;
  848. 	default:
  849. 		break;
  850. 	}
  851. }
  852.  
  853. int main(int argc, const char *argv[])
  854. {
  855. 	system("clear");
  856. 	//打开数据库
  857. 	if (sqlite3_open(STAFF_DATABASE, &db) != SQLITE_OK)
  858. 	{
  859. 		printf("%s.\n", sqlite3_errmsg(db));
  860. 		return -1;
  861. 	}
  862. 	printf("database open success\n");
  863. 	
  864.  
  865. 	// socket->填充->绑定->监听->等待连接->数据交互->关闭
  866.  
  867. 	//创建网络通信的套接字
  868. 	int socketfd = socket(AF_INET, SOCK_STREAM, 0);
  869. 	if (socketfd < 0)
  870. 	{
  871. 		printf("socket error\n");
  872. 		return -1;
  873. 	}
  874. 	printf("socket success\n");
  875.  
  876. 	//允许端口快速重用
  877. 	int reuse = 1;
  878. 	if (setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
  879. 	{
  880. 		printf("setsockopt error\n");
  881. 		return -1;
  882. 	}
  883. 	printf("setsockopt success\n");
  884.  
  885. 	//填充网络结构体
  886. 	//填充服务器网路信息结构体
  887. 	struct sockaddr_in sin;
  888. 	//填充为IPV4地址
  889. 	sin.sin_family = AF_INET;
  890. 	//填充服务器IP
  891. 	sin.sin_addr.s_addr = inet_addr(S_IP);
  892. 	//填充服务器端口号
  893. 	sin.sin_port = htons(atoi(PORT));
  894.  
  895. 	//绑定网络套接字和网络结构体
  896. 	if (bind(socketfd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
  897. 	{
  898. 		printf("bind error\n");
  899. 		return -1;
  900. 	}
  901. 	printf("bind success\n");
  902.  
  903. 	//监听套接字，将主动套接字转化为被动套接字
  904. 	if (listen(socketfd, 10) < 0)
  905. 	{
  906. 		printf("listen error\n");
  907. 		return -1;
  908. 	}
  909. 	printf("listen success\n");
  910.  
  911. 	//通过select实现并发
  912. 	//客户端网络信息结构体
  913. 	struct sockaddr_in cin;
  914. 	socklen_t addrlen = sizeof(cin);
  915.  
  916. 	//创建一个读集合
  917. 	fd_set readfds, tempfds;
  918.  
  919. 	//将集合清空
  920. 	FD_ZERO(&readfds);
  921. 	FD_ZERO(&tempfds);
  922.  
  923. 	//将sfd文件描述符添加到集合
  924. 	FD_SET(socketfd, &readfds);
  925.  
  926. 	//最大文件描述符
  927. 	int maxfd = socketfd;
  928. 	//接收select返回值
  929. 	int select_res = 0;
  930. 	MSG msg;
  931. 	ssize_t recvbytes = 0;
  932. 	int acceptfd = -1;
  933. 	int i = 0;
  934.  
  935. 	//定义一个数组，存储每次连接成功的客户端的信息
  936. 	struct sockaddr_in save_addr[1024 - 4];
  937.  
  938. 	while (1)
  939. 	{
  940. 		tempfds = readfds;
  941. 		//>0, 三个集合中成功触发事件的文件描述符个数  =0超时  =-1失败;
  942. 		select_res = select(maxfd + 1, &tempfds, NULL, NULL, NULL);
  943. 		if (select_res < 0)
  944. 		{
  945. 			printf("select error\n");
  946. 			return -1;
  947. 		}
  948. 		else if (select_res == 0)
  949. 		{
  950. 			printf("select timeout\n");
  951. 			return -1;
  952. 		}
  953.  
  954. 		for (i = 0; i <= maxfd; i++)
  955. 		{
  956. 			//判断0～maxfd这些文件描述符在不在集合中
  957. 			if (FD_ISSET(i, &tempfds) == 0)
  958. 			{
  959. 				continue;
  960. 			}
  961.  
  962. 			//能运行到当前位置，则说明i所代表的文件描述符有事件产生
  963.  
  964. 			//判断是否是集合里关注的事件
  965.  
  966. 			if (socketfd == i)
  967. 			{
  968. 				printf("触发客户端连接事件：");
  969. 				fflush(stdout);
  970.  
  971. 				//数据交互
  972. 				acceptfd = accept(socketfd, (struct sockaddr *)&cin, &addrlen);
  973. 				if (acceptfd == -1)
  974. 				{
  975. 					printf("acceptfd error\n");
  976. 					return -1;
  977. 				}
  978. 				//网络字节序的IP-->点分十进制  网络字节序的port--->本机字节序
  979. 				printf("[%s : %d] acceptfd = %d\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), acceptfd);
  980.  
  981. 				memset(history, 0, DATALEN);
  982. 				sprintf(history,"[%s : %d] acceptfd[%d]",inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), acceptfd);
  983. 				process_recv_history_request("connect", history);
  984.  
  985.  
  986.  
  987. 				//将cin存储到 save_addr数组对应的位置，
  988. 				// acceptfd==4,则存储到下标为0，acceptfd==5，存储到下标为1，acceptfd==n，则存储到下标为n-4的位置
  989. 				save_addr[acceptfd - 4] = cin;
  990.  
  991. 				//将acceptfd添加到集合中
  992. 				FD_SET(acceptfd, &readfds);
  993.  
  994. 				//更新maxfd
  995. 				maxfd = maxfd > acceptfd ? maxfd : acceptfd;
  996. 			}
  997. 			else
  998. 			{
  999. 				//客户端交互事件
  1000. 				bzero(&msg, sizeof(MSG));
  1001. 				recvbytes = recv(i, &msg, sizeof(MSG), 0);
  1002. 				if (recvbytes == -1)
  1003. 				{
  1004. 					// <0 错误
  1005. 					printf("recv error\n");
  1006. 					continue;
  1007. 				}
  1008. 				else if (recvbytes == 0)
  1009. 				{
  1010. 					// ==0
  1011. 					printf("[%s : %d] acceptfd = %d client off-line\n",
  1012. 						   inet_ntoa(save_addr[i - 4].sin_addr), ntohs(save_addr[i - 4].sin_port), i);
  1013.  
  1014. 					memset(history, 0, DATALEN);
  1015. 					sprintf(history,"[%s : %d] acceptfd = [%d]",inet_ntoa(save_addr[i - 4].sin_addr), ntohs(save_addr[i - 4].sin_port), i);
  1016. 					process_recv_history_request("lost connect", history);
  1017.  
  1018. 					//关闭文件描述符
  1019. 					close(i);
  1020.  
  1021. 					//将文件描述符从集合中剔除
  1022. 					FD_CLR(i, &readfds);
  1023.  
  1024. 					//更新maxfd
  1025. 					for (int i = maxfd; i > 0; i--)
  1026. 					{
  1027. 						if (FD_ISSET(i, &readfds))
  1028. 						{
  1029. 							maxfd = i;
  1030. 							break;
  1031. 						}
  1032. 					}
  1033. 					printf("peer shutdown.\n");
  1034. 				}
  1035. 				else
  1036. 				{
  1037. 					//处理客户端请求
  1038. 					process_client_request(i, &msg);
  1039. 				}
  1040. 			}
  1041. 		}
  1042. 	}
  1043.  
  1044. 	close(socketfd);
  1045.  
  1046. 	return 0;
  1047. }

客户端（client.h文件）：

  1. void do_admin_query(int sockfd, MSG *msg);
  2. void do_admin_modification(int sockfd, MSG *msg);
  3. void do_admin_adduser(int sockfd, MSG *msg);
  4. void do_admin_deluser(int sockfd, MSG *msg);
  5. void do_admin_history(int sockfd, MSG *msg);
  6. void do_admin_list(int sockfd, MSG *msg);
  7. void admin_menu(int sockfd, MSG *msg);
  8. void do_user_query(int sockfd, MSG *msg);
  9. void do_user_modification(int sockfd, MSG *msg);
  10. void user_menu(int sockfd, MSG *msg);
  11. int admin_or_user_login(int sockfd, MSG *msg);
  12. int do_login(int socketfd);

客户端（client.c文件）：

  1.  
  2. #include "common.h"
  3. #include "client.h"
  4.  
  5. /**************************************
  6.  *函数名：do_query
  7.  *参   数：消息结构体
  8.  *功   能：管理员查询
  9.  ****************************************/
  10. void do_admin_query(int sockfd, MSG *msg)
  11. {
  12. 	system("clear");
  13. 	memset(msg, 0, sizeof(MSG));
  14. 	msg->msgtype = ADMIN_QUERY;
  15. 	char name[NAMELEN] = "";
  16. 	printf("Please enter find no:");
  17. 	scanf("%s", name);
  18. 	while (getchar() != '\n')
  19. 		;
  20. 	strcpy(msg->recvmsg, name);
  21. 	//发送查询请求
  22. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  23. 	{
  24. 		printf("Sending the account to the server error\n");
  25. 		return;
  26. 	}
  27.  
  28. 	//接受服务器响应
  29. 	while (1)
  30. 	{
  31. 		recv(sockfd, msg, sizeof(MSG), 0);
  32. 		if (!strncmp(msg->recvmsg, "end", 3))
  33. 		{
  34. 			printf("find success\n");
  35. 			return;
  36. 		}
  37. 		if (!strncmp(msg->recvmsg, "no", 2))
  38. 		{
  39. 			printf("find error\n");
  40. 			return;
  41. 		}
  42. 		printf("----------------------------------\n");
  43. 		printf("staffno :%d\nusertype:%d\nname    :%s\npasswd  :%s\nage     :%d\nphone   :%s\naddr    :%s\nwork    :%s\ndate    :%s\nlevel   :%d\nsalary  :%d\n", msg->info.no, msg->info.usertype, msg->info.name, msg->info.passwd, msg->info.age, msg->info.phone, msg->info.addr, msg->info.work, msg->info.date, msg->info.level, msg->info.salary);
  44. 		printf("----------------------------------\n");
  45. 	}
  46. }
  47.  
  48. /**************************************
  49.  *函数名：admin_modification
  50.  *参   数：消息结构体
  51.  *功   能：管理员修改
  52.  ****************************************/
  53. void do_admin_modification(int sockfd, MSG *msg) //管理员修改
  54. {
  55. 	system("clear");
  56. 	memset(msg, 0, sizeof(MSG));
  57. 	msg->msgtype = ADMIN_MODIFY;
  58. 	int opt = 0;
  59. 	int tem;
  60. 	char str1[NAMELEN] = "";
  61. 	char str2[DATALEN] = "";
  62. 	char str3[PASSLEN] = "";
  63. 	printf("please enter user name:");
  64. 	scanf("%s",msg->username);
  65. 	printf("1:no\n2:usertype\n3:name\n4:passwd\n5:age\n6:phone\n7:addr\n8:work\n9:date\n10:level\n11:salary\nplease enter change option:");
  66. 	scanf("%d", &opt);
  67. 	while(getchar()!='\n');
  68. 	
  69. 	switch (opt)
  70. 	{
  71. 	case 1:
  72. 		msg->flags = 1;
  73. 		printf("please enter no:");
  74. 		scanf("%d", &tem);
  75. 		msg->info.no = tem;
  76. 		break;
  77. 	case 2:
  78. 		msg->flags = 2;
  79. 		printf("please enter usertype:");
  80. 		scanf("%d", &tem);
  81. 		msg->info.usertype = tem;
  82. 		break;
  83. 	case 3:
  84. 		msg->flags = 3;
  85. 		printf("please enter name:");
  86. 		fgets(str1,NAMELEN,stdin);
  87. 		str1[strlen(str1)-1]='\0';
  88. 		strcpy(msg->info.name, str1);
  89. 		break;
  90. 	case 4:
  91. 		msg->flags = 4;
  92. 		printf("please enter passwd:");
  93. 		fgets(str3,PASSLEN,stdin);
  94. 		str3[strlen(str3)-1]='\0';
  95. 		strcpy(msg->info.passwd, str1);
  96. 		break;
  97. 	case 5:
  98. 		msg->flags = 5;
  99. 		printf("please enter age:");
  100. 		scanf("%d", &tem);
  101. 		msg->info.age = tem;
  102. 		break;
  103. 	case 6:
  104. 		msg->flags = 6;
  105. 		printf("please enter phone:");
  106. 		fgets(str1,NAMELEN,stdin);
  107. 		str1[strlen(str1)-1]='\0';
  108. 		strcpy(msg->info.phone, str1);
  109. 		break;
  110. 	case 7:
  111. 		msg->flags = 7;
  112. 		printf("please enter addr:");
  113. 		fgets(str2,DATALEN,stdin);
  114. 		str2[strlen(str2)-1]='\0';
  115. 		strcpy(msg->info.addr, str2);
  116. 		break;
  117. 	case 8:
  118. 		msg->flags = 8;
  119. 		printf("please enter work:");
  120. 		fgets(str2,DATALEN,stdin);
  121. 		str2[strlen(str2)-1]='\0';
  122. 		strcpy(msg->info.work, str2);
  123. 		break;
  124. 	case 9:
  125. 		msg->flags = 9;
  126. 		printf("please enter date:");
  127. 		fgets(str2,DATALEN,stdin);
  128. 		str2[strlen(str2)-1]='\0';
  129. 		strcpy(msg->info.date, str2);
  130. 		break;
  131. 	case 10:
  132. 		msg->flags = 10;
  133. 		printf("please enter level:");
  134. 		scanf("%d", &tem);
  135. 		msg->info.level = tem;
  136. 		break;
  137. 	case 11:
  138. 		msg->flags = 11;
  139. 		printf("please enter salary:");
  140. 		scanf("%d", &tem);
  141. 		msg->info.salary = tem;
  142. 		break;
  143. 	default:
  144. 		printf("enter error\n");
  145. 		return;
  146. 	}
  147. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  148. 	{
  149. 		printf("Sending the account to the server error\n");
  150. 		return;
  151. 	}
  152. 	
  153.  
  154. 	system("clear");
  155.  
  156. 	recv(sockfd, msg, sizeof(MSG), 0);
  157. 	if (!strncmp(msg->recvmsg, "ok", 2))
  158. 	{
  159. 		printf("user change success\n");
  160. 		return;
  161. 	}
  162. 	else if(!strncmp(msg->recvmsg, "no", 2))
  163. 	{
  164. 		printf("user change error\n");
  165. 		return;
  166. 	}
  167. 	
  168. }
  169.  
  170. /**************************************
  171.  *函数名：admin_adduser
  172.  *参   数：消息结构体
  173.  *功   能：管理员创建用户
  174.  ****************************************/
  175. void do_admin_adduser(int sockfd, MSG *msg) //管理员添加用户
  176. {
  177. 	system("clear");
  178. 	int tem;
  179. 	char str1[NAMELEN] = "";
  180. 	char str2[DATALEN] = "";
  181. 	char str3[PASSLEN] = "";
  182.  
  183. 	memset(msg, 0, sizeof(MSG));
  184. 	msg->msgtype = ADMIN_ADDUSER;
  185. 	printf("please enter no:");
  186. 	scanf("%d", &tem);
  187. 	msg->info.no = tem;
  188.  
  189. 	printf("please enter usertype:");
  190. 	scanf("%d", &tem);
  191. 	msg->info.usertype = tem;
  192. 	while (getchar() != '\n');
  193.  
  194. 	printf("please enter name:");
  195. 	fgets(str1,NAMELEN,stdin);
  196. 	str1[strlen(str1)-1]='\0';
  197. 	strcpy(msg->info.name, str1);
  198.  
  199. 	printf("please enter passwd:");
  200. 	fgets(str3,PASSLEN,stdin);
  201. 	str3[strlen(str3)-1]='\0';
  202. 	strcpy(msg->info.passwd, str3);
  203.  
  204. 	printf("please enter age:");
  205. 	scanf("%d", &tem);
  206. 	msg->info.age = tem;
  207. 	while (getchar() != '\n');
  208.  
  209. 	printf("please enter phone:");
  210. 	fgets(str1,NAMELEN,stdin);
  211. 	str1[strlen(str1)-1]='\0';
  212. 	strcpy(msg->info.phone, str1);
  213.  
  214. 	printf("please enter addr:");
  215. 	fgets(str2,DATALEN,stdin);
  216. 	str2[strlen(str2)-1]='\0';
  217. 	strcpy(msg->info.addr, str2);
  218.  
  219. 	printf("please enter work:");
  220. 	fgets(str2,DATALEN,stdin);
  221. 	str2[strlen(str2)-1]='\0';
  222. 	strcpy(msg->info.work, str2);
  223.  
  224. 	printf("please enter date:");
  225. 	fgets(str2,DATALEN,stdin);
  226. 	str2[strlen(str2)-1]='\0';
  227. 	strcpy(msg->info.date, str2);
  228.  
  229. 	printf("please enter level:");
  230. 	scanf("%d", &tem);
  231. 	msg->info.level = tem;
  232.  
  233. 	printf("please enter salary:");
  234. 	scanf("%d", &tem);
  235. 	msg->info.salary = tem;
  236.  
  237. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  238. 	{
  239. 		printf("Sending the account to the server error\n");
  240. 		return;
  241. 	}
  242.  
  243. 	recv(sockfd, msg, sizeof(MSG), 0);
  244. 	if (!strncmp(msg->recvmsg, "ok", 2))
  245. 	{
  246. 		printf("user add success\n");
  247. 		return;
  248. 	}
  249. 	else if (!strncmp(msg->recvmsg, "no", 2))
  250. 	{
  251. 		printf("user add error\n");
  252. 		return;
  253. 	}
  254. 	
  255.  
  256. 	printf("user add error\n");
  257. }
  258.  
  259. /**************************************
  260.  *函数名：admin_deluser
  261.  *参   数：消息结构体
  262.  *功   能：管理员删除用户
  263.  ****************************************/
  264. void do_admin_deluser(int sockfd, MSG *msg) //管理员删除用户
  265. {
  266. 	system("clear");
  267. 	msg->msgtype = ADMIN_DELUSER;
  268. 	int no = 0;
  269. 	printf("pelase enter delete user NO:");
  270. 	scanf("%d", &no);
  271. 	msg->info.no = no;
  272. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  273. 	{
  274. 		printf("Sending the account to the server error\n");
  275. 		return;
  276. 	}
  277. 	recv(sockfd, msg, sizeof(MSG), 0);
  278. 	if (!strncmp(msg->recvmsg, "ok", 2))
  279. 	{
  280. 		printf("user delete success\n");
  281. 		return;
  282. 	}
  283. 	else if (!strncmp(msg->recvmsg, "no", 2))
  284. 	{
  285. 		printf("user delete error\n");
  286. 		return;
  287. 	}
  288. }
  289.  
  290. /**************************************
  291.  *函数名：do_history
  292.  *参   数：消息结构体
  293.  *功   能：管理员查看历史记录
  294.  ****************************************/
  295. void do_admin_history(int sockfd, MSG *msg)
  296. {
  297. 	system("clear");
  298. 	memset(msg, 0, sizeof(MSG));
  299. 	msg->msgtype = ADMIN_HISTORY;
  300. 	putchar(10);
  301.  
  302. 	printf("   %s     |     %s     |                        %s                        \n","data","time","log");
  303.  
  304.  
  305.  
  306. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  307. 	{
  308. 		printf("Sending the account to the server error\n");
  309. 		return;
  310. 	}
  311. 	
  312. 	
  313.  
  314. 	while (1)
  315. 	{
  316. 		recv(sockfd, msg, sizeof(MSG), 0);
  317. 		if (msg->flags == 1)
  318. 		{
  319. 			printf("find success\n");
  320. 			break;
  321. 		}
  322. 		if (msg->flags == 2)
  323. 		{
  324. 			printf("find error\n");
  325. 			break;
  326. 		}
  327.  
  328. 		printf("%s",msg->recvmsg);
  329.  
  330. 		send(sockfd, msg, sizeof(MSG), 0);
  331.  
  332. 	}
  333.  
  334. }
  335.  
  336. void do_admin_list(int sockfd, MSG *msg)
  337. {
  338. 	system("clear");
  339. 	memset(msg, 0, sizeof(MSG));
  340. 	msg->msgtype = ADMIN_LIST;
  341. 	char name[NAMELEN] = "";
  342. 	//发送查询请求
  343. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  344. 	{
  345. 		printf("Sending the account to the server error\n");
  346. 		return;
  347. 	}
  348.  
  349. 	//接受服务器响应
  350. 	while (1)
  351. 	{
  352. 		recv(sockfd, msg, sizeof(MSG), 0);
  353. 		if (!strncmp(msg->recvmsg, "endd", 4))
  354. 		{
  355. 			printf("find success\n");
  356. 			return;
  357. 		}
  358. 		if (!strncmp(msg->recvmsg, "no", 2))
  359. 		{
  360. 			printf("find error\n");
  361. 			return;
  362. 		}
  363. 		//printf("%d\t%d\t%s\t%s\t%d\t%s\t%s\t%s\t%s\t%d\t%d\n", msg->info.no, msg->info.usertype, msg->info.name, msg->info.passwd, msg->info.age, msg->info.phone, msg->info.addr, msg->info.work, msg->info.date, msg->info.level, msg->info.salary);
  364. 		printf("----------------------------------\n");
  365. 		printf("staffno :%d\nusertype:%d\nname    :%s\npasswd  :%s\nage     :%d\nphone   :%s\naddr    :%s\nwork    :%s\ndate    :%s\nlevel   :%d\nsalary  :%d\n", msg->info.no, msg->info.usertype, msg->info.name, msg->info.passwd, msg->info.age, msg->info.phone, msg->info.addr, msg->info.work, msg->info.date, msg->info.level, msg->info.salary);
  366. 		printf("----------------------------------\n");
  367.  
  368. 		send(sockfd, msg, sizeof(MSG), 0);
  369. 	}
  370. }
  371.  
  372. /**************************************
  373.  *函数名：admin_menu
  374.  *参   数：套接字、消息结构体
  375.  *功   能：管理员菜单
  376.  ****************************************/
  377. void admin_menu(int sockfd, MSG *msg)
  378. {
  379. 	int op = -1;
  380. 	printf(" ************ 1  find   ************\n");
  381. 	printf(" ************ 2 change  ************\n");
  382. 	printf(" ************ 3  add    ************\n");
  383. 	printf(" ************ 4 delete  ************\n");
  384. 	printf(" ************ 5  list   ************\n");
  385. 	printf(" ************ 6  clean   ************\n");
  386. 	printf(" ************ 7 history ************\n");
  387. 	printf(" ************ 0  quit   ************\n");
  388. 	printf("please enter your option:");
  389. 	scanf("%d", &op);
  390. 	while(getchar()!='\n');
  391. 	if(op < 0 || op > 7)
  392. 	{
  393. 		system("clear");
  394. 		printf("输入错误 请重新输入\n");
  395. 		admin_menu(sockfd,msg);
  396. 	}
  397. 	switch (op)
  398. 	{
  399. 	case 0:
  400. 		system("clear");
  401. 		do_login(sockfd);
  402. 		break;
  403. 	case 1:
  404. 		do_admin_query(sockfd, msg);
  405. 		break;
  406. 	case 2:
  407. 		do_admin_modification(sockfd, msg);
  408. 		break;
  409. 	case 3:
  410. 		do_admin_adduser(sockfd, msg);
  411. 		break;
  412. 	case 4:
  413. 		do_admin_deluser(sockfd, msg);
  414. 		break;
  415. 	case 5:
  416. 		do_admin_list(sockfd, msg);
  417. 		break;
  418. 	case 6:
  419. 		system("clear");
  420. 		break;
  421. 	case 7:
  422. 		do_admin_history(sockfd,msg);
  423. 		break;
  424. 	default:
  425. 		printf("enter error\n");
  426. 		return;
  427. 	}
  428. }
  429.  
  430. /**************************************
  431.  *函数名：do_query
  432.  *参   数：消息结构体
  433.  *功   能：用户查找
  434.  ****************************************/
  435. void do_user_query(int sockfd, MSG *msg)
  436. {
  437. 	system("clear");
  438. 	memset(msg, 0, sizeof(MSG));
  439. 	msg->msgtype = USER_QUERY;
  440. 	strcpy(msg->username, user_name);
  441. 	strcpy(msg->passwd,user_passwd);
  442. 	//发送查询请求
  443. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  444. 	{
  445. 		printf("Sending the account to the server error\n");
  446. 		return;
  447. 	}
  448.  
  449. 	//接受服务器响应
  450. 	while(1)
  451. 	{
  452. 	recv(sockfd, msg, sizeof(MSG), 0);
  453. 	if (!strncmp(msg->recvmsg, "end", 3))
  454. 	{
  455. 		printf("find success\n");
  456. 		return;
  457. 	}
  458. 	if (!strncmp(msg->recvmsg, "no", 2))
  459. 	{
  460. 		printf("find error\n");
  461. 		return;
  462. 	}
  463. 	printf("----------------------------------\n");
  464. 	printf("staffno :%d\nusertype:%d\nname    :%s\npasswd  :%s\nage     :%d\nphone   :%s\naddr    :%s\nwork    :%s\ndate    :%s\nlevel   :%d\nsalary  :%d\n", msg->info.no, msg->info.usertype, msg->info.name, msg->info.passwd, msg->info.age, msg->info.phone, msg->info.addr, msg->info.work, msg->info.date, msg->info.level, msg->info.salary);
  465. 	printf("----------------------------------\n");
  466. 	}
  467. }
  468.  
  469. /**************************************
  470.  *函数名：do_modification
  471.  *参   数：消息结构体
  472.  *功   能：用户修改
  473.  ****************************************/
  474. void do_user_modification(int sockfd, MSG *msg)
  475. {
  476. 	
  477. 	system("clear");
  478. 	memset(msg, 0, sizeof(MSG));
  479. 	msg->msgtype = USER_MODIFY;
  480. 	strcpy(msg->username, user_name);
  481. 	strcpy(msg->passwd,user_passwd);
  482.  
  483. 	int opt = 0;
  484. 	int tem;
  485. 	char str1[NAMELEN] = "";
  486. 	char str2[DATALEN] = "";
  487. 	char str3[PASSLEN] = "";
  488. 	printf("1:no\n2:usertype(Please contact the administrator)\n3:name\n4:passwd\n5:age\n6:phone\n7:addr\n8:work\n9:date\n10:level\n11:salary\nplease enter change option:");
  489. 	scanf("%d", &opt);
  490. 	while(getchar()!='\n');
  491. 	
  492. 	switch (opt)
  493. 	{
  494. 	case 1:
  495. 		msg->flags = 1;
  496. 		printf("please enter no:");
  497. 		scanf("%d", &tem);
  498. 		msg->info.no = tem;
  499. 		break;
  500. 	case 2:
  501. 		msg->flags = 2;
  502. 		printf("please enter usertype:");
  503. 		scanf("%d", &tem);
  504. 		msg->info.usertype = tem;
  505. 		break;
  506. 	case 3:
  507. 		msg->flags = 3;
  508. 		printf("please enter name:");
  509. 		fgets(str1,NAMELEN,stdin);
  510. 		str1[strlen(str1)-1]='\0';
  511. 		strcpy(msg->info.name, str1);
  512. 		break;
  513. 	case 4:
  514. 		msg->flags = 4;
  515. 		printf("please enter passwd:");
  516. 		fgets(str3,PASSLEN,stdin);
  517. 		str3[strlen(str3)-1]='\0';
  518. 		strcpy(msg->info.passwd, str3);
  519. 		break;
  520. 	case 5:
  521. 		msg->flags = 5;
  522. 		printf("please enter age:");
  523. 		scanf("%d", &tem);
  524. 		msg->info.age = tem;
  525. 		break;
  526. 	case 6:
  527. 		msg->flags = 6;
  528. 		printf("please enter phone:");
  529. 		fgets(str1,NAMELEN,stdin);
  530. 		str1[strlen(str1)-1]='\0';
  531. 		strcpy(msg->info.phone, str1);
  532. 		break;
  533. 	case 7:
  534. 		msg->flags = 7;
  535. 		printf("please enter addr:");
  536. 		fgets(str2,DATALEN,stdin);
  537. 		str2[strlen(str2)-1]='\0';
  538. 		strcpy(msg->info.addr, str2);
  539. 		break;
  540. 	case 8:
  541. 		msg->flags = 8;
  542. 		printf("please enter work:");
  543. 		fgets(str2,DATALEN,stdin);
  544. 		str2[strlen(str2)-1]='\0';
  545. 		strcpy(msg->info.work, str2);
  546. 		break;
  547. 	case 9:
  548. 		msg->flags = 9;
  549. 		printf("please enter date:");
  550. 		fgets(str2,DATALEN,stdin);
  551. 		str2[strlen(str2)-1]='\0';
  552. 		strcpy(msg->info.date, str2);
  553. 		break;
  554. 	case 10:
  555. 		msg->flags = 10;
  556. 		printf("please enter level:");
  557. 		scanf("%d", &tem);
  558. 		msg->info.level = tem;
  559. 		break;
  560. 	case 11:
  561. 		msg->flags = 11;
  562. 		printf("please enter salary:");
  563. 		scanf("%d", &tem);
  564. 		msg->info.salary = tem;
  565. 		break;
  566. 	default:
  567. 		printf("enter error\n");
  568. 		return;
  569. 	}
  570.  
  571. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  572. 	{
  573. 		printf("Sending the account to the server error\n");
  574. 		return;
  575. 	}
  576. 	
  577.  
  578. 	system("clear");
  579.  
  580. 	recv(sockfd, msg, sizeof(MSG), 0);
  581. 	if (!strncmp(msg->recvmsg, "ok", 2))
  582. 	{
  583. 		printf("user change success\n");
  584. 		return;
  585. 	}
  586. 	else if(!strncmp(msg->recvmsg, "no", 2))
  587. 	{
  588. 		printf("user change error\n");
  589. 		return;
  590. 	}
  591. }
  592.  
  593. /**************************************
  594.  *函数名：user_menu
  595.  *参   数：消息结构体
  596.  *功   能：用户菜单
  597.  ****************************************/
  598. void user_menu(int sockfd, MSG *msg)
  599. {
  600. 	int op = -1;
  601. 	printf(" ************ 1  find  ************\n");
  602. 	printf(" ************ 2 change ************\n");
  603. 	printf(" ************ 3 clean  ************\n");
  604. 	printf(" ************ 0  quit  ************\n");
  605. 	printf("please enter your option:");
  606. 	scanf("%d", &op);
  607. 	while(getchar()!='\n');
  608. 	if(op < 0 || op > 3)
  609. 	{
  610. 		system("clear");
  611. 		printf("输入错误 请重新输入\n");
  612. 		user_menu(sockfd,msg);
  613. 	}
  614. 	switch (op)
  615. 	{
  616. 	case 0:
  617. 		system("clear");
  618. 		do_login(sockfd);
  619. 		break;
  620. 	case 1:
  621. 		do_user_query(sockfd, msg);
  622. 		break;
  623. 	case 2:
  624. 		do_user_modification(sockfd, msg);
  625. 		break;
  626. 	case 3:
  627. 		system("clear");
  628. 		break;
  629. 	default:
  630. 		printf("enter error\n");
  631. 		break;
  632. 	}
  633. }
  634.  
  635. int admin_or_user_login(int sockfd, MSG *msg)
  636. {
  637. 	
  638. 	//输入用户名和密码
  639. 	memset(msg->username, 0, NAMELEN);
  640. 	printf("请输入用户名：");
  641. 	scanf("%s", msg->username);
  642. 	getchar();
  643.  
  644. 	memset(msg->passwd, 0, DATALEN);
  645. 	printf("请输入密码: ");
  646. 	scanf("%s", msg->passwd);
  647. 	getchar();
  648.  
  649. 	strcpy(user_name,msg->username);
  650. 	strcpy(user_passwd,msg->passwd);
  651.  
  652. 	//发送登陆请求
  653. 	if (send(sockfd, msg, sizeof(MSG), 0) < 0)
  654. 	{
  655. 		printf("Sending the account to the server error\n");
  656. 		return -1;
  657. 	}
  658.  
  659. 	//接受服务器响应
  660. 	recv(sockfd, msg, sizeof(MSG), 0);
  661.  
  662. 	//判断是否登陆成功
  663. 	if (strncmp(msg->recvmsg, "OK", 2) == 0)
  664. 	{
  665. 		if (msg->usertype == ADMIN)
  666. 		{
  667. 			system("clear");
  668. 			printf("亲爱的管理员，欢迎您登陆员工管理系统！\n");
  669. 			while (1)
  670. 			{
  671. 				admin_menu(sockfd, msg);
  672. 			}
  673. 		}
  674. 		else if (msg->usertype == USER)
  675. 		{
  676. 			system("clear");
  677. 			printf("亲爱的用户，欢迎您登陆员工管理系统！\n");
  678. 			while (1)
  679. 			{
  680. 				user_menu(sockfd, msg);
  681. 			}
  682. 		}
  683. 	}
  684. 	else
  685. 	{
  686. 		printf("登陆失败！%s\n", msg->recvmsg);
  687. 		admin_or_user_login(sockfd,msg);
  688. 	}
  689.  
  690. 	return 0;
  691. }
  692.  
  693. /************************************************
  694.  *函数名：do_login
  695.  *参   数：套接字、消息结构体
  696.  *返回值：是否登陆成功
  697.  *功   能：登陆
  698.  *************************************************/
  699. int do_login(int socketfd)
  700. {
  701. 	int n;
  702. 	MSG msg;
  703.  
  704. 	while (1)
  705. 	{
  706. 		printf("**********************************\n");
  707. 		printf("********  1: 管理员模式   ********\n");
  708. 		printf("********  2:普通用户模式  ********\n");
  709. 		printf("********  0:   退出       ********\n");
  710. 		printf("**********************************\n");
  711. 		printf("请输入您的选择（数字）>> ");
  712. 		scanf("%d", &n);
  713. 		while(getchar()!='\n');
  714. 		if(n < 0 || n > 2)
  715. 		{
  716. 			system("clear");
  717. 			printf("输入错误 请重新输入\n");
  718. 			do_login(socketfd);
  719. 		}
  720.  
  721. 		switch (n)
  722. 		{
  723. 		case 1:
  724. 			//管理员模式登录
  725. 			msg.msgtype = ADMIN_LOGIN; // 1
  726. 			msg.usertype = ADMIN;	   // 0
  727. 			break;
  728. 		case 2:
  729. 			//普通用户登录
  730. 			msg.msgtype = USER_LOGIN;
  731. 			msg.usertype = USER;
  732. 			break;
  733. 		case 0:
  734. 			//退出
  735. 			msg.msgtype = QUIT;
  736. 			if (send(socketfd, &msg, sizeof(MSG), 0) < 0)
  737. 			{
  738. 				perror("do_login send");
  739. 				return -1;
  740. 			}
  741. 			close(socketfd);
  742. 			exit(0);
  743. 		default:
  744. 			printf("您的输入有误，请重新输入\n");
  745. 		}
  746.  
  747. 		admin_or_user_login(socketfd, &msg);
  748. 	}
  749. }
  750.  
  751. int main(int argc, const char *argv[])
  752. {
  753. 	// socket->填充->绑定->监听->等待连接->数据交互->关闭
  754. 	system("clear");
  755. 	int socketfd;
  756. 	//创建网络通信的套接字 流式套接字
  757. 	if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0)))
  758. 	{
  759. 		printf("socket error\n");
  760. 		return -1;
  761. 	}
  762. 	printf("socket success\n");
  763.  
  764. 	//填充网络结构体
  765. 	//填充服务器网路信息结构体
  766. 	struct sockaddr_in sin;
  767. 	//填充为IPV4地址
  768. 	sin.sin_family = AF_INET;
  769. 	//填充服务器IP
  770. 	sin.sin_addr.s_addr = inet_addr(IP);
  771. 	//填充服务器端口号
  772. 	sin.sin_port = htons(atoi(PORT));
  773.  
  774. 	//连接服务器
  775. 	if (-1 == connect(socketfd, (struct sockaddr *)&sin, sizeof(sin)))
  776. 	{
  777. 		printf("connect error\n");
  778. 		return -1;
  779. 	}
  780. 	printf("connect suceess\n");
  781.  
  782. 	//登陆
  783. 	do_login(socketfd);
  784.  
  785. 	//关闭套接字
  786. 	close(socketfd);
  787.  
  788. 	return 0;
  789. }

员工信息管理系统 测试

原文链接:https://blog.csdn.net/weixin_43386810/article/details/127589253



所属网站分类: 技术文章 > 博客

作者：天天在家

链接：http://www.javaheidong.com/blog/article/597348/01f3fe87f35447dda1dd/

来源：java黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

23 0
收藏该文
已收藏

评论内容：(最多支持255个字符)




程序员的那些事(new) 更多>

2022年最受欢迎的8大编程语言

为什么都说程序员找不到女朋友，但是身边程序猿的却没一个单身的

程序员被开除，老板：“有你参与的项目全黄了！”

笑话：一个测试工程师走进一家酒吧

趣图：程序员头疼的4种原因

笑话：面试官：请拿出一段体现你水平的代码。我： sudo rm -rf /*面试官：这体现了你哪方面能力？

java精选：SSO单点登录】JWT入门概述&&残留的安全问题

程序人生：程序员如何实现财富自由？

找工作千万不要找外包？BAT互联网大厂外包亲身经历

程序员的工资这么高，为什么还会有人离职？

电子书(new)

java jdk8 学习笔记

深入剖析Tomcat pdf下载

Java与模式 pdf下载

深入理解Java虚拟机：JVM高级特性与最佳实践(第2版) pdf 下载

数据结构与算法分析：Java语言描述(原书第3版) pdf  下载

Java并发编程实战 中文版 PDF扫描版[9MB]

数据结构与算法分析：Java语言描述(原书第3版) 中文完整pdf扫描版[47MB] 附源码

Hadoop权威指南 pdf下载

重构 改善既有代码的设计 pdf下载

JAVA编程思想 pdf下载

脚本(new)

输入一个数据n，计算斐波那契数列(Fibonacci)的第n个值

求 a+aa+aaa+.......+aaaaaaaaa=?

输出所有的水仙花数，把谓水仙花数是指一个数3位数，其各各位数字立方和等于其本身，

利用for循环打印 9*9 表?

编写程序求 1+3+5+7+……+99 的和值。

给定一个百分制的分数，输出相应的等级

编写程序，判断给定的某个年份是否是闰年

一些有趣的java小程序

菱形的图形生成器，2到100以内的质数-java实用小程序

java代码游戏编写

博客(new)

【Java 22 | 7】 深入解析Java 22 ：密封类（Sealed Classes）增强详解

Java 多线程（三）—— 死锁

JSON parse error: Cannot deserialize value of type `java.util.Date` from String “2024-09-19 10:40:40

Java毕业设计：Java河南郑州景区景点买票购票系统毕业设计源代码作品和开题报告

Android Studio开发学习（一、用户登录）

华为OD机试 - 处理器问题（Java & JS & Python & C & C++）

C++之多态的深度剖析

Java 继承

JavaScript-sort()排序

【面试宝典】Java中创建线程池的几种方式以及区别

视频教程(new)

由浅入深，全面解析ThreadLocal

超全面讲解Spring Cloud Alibaba技术栈，java视频教程下载

三天全面系统学习ZooKeeper

2020年JavaSE强化系列教程泛型全剖析，java视频教程下载

详讲编码与解码，灵活解决乱码难题，java 视频教程下载

2020年抗疫之作java基础进阶13天

系统学习让你轻松定义java类加载器-java视频教程下载

真小白福音，完全从0带你掌握计算机与编程基础

java零基础入门到精通（2019版）

2020JAVA基础-深入系统的学习数据结构与算法

项目实战(new)

JSP+SSM+Mysql实现的学生成绩管理系统

JSP+Structs+JDBC+mysql实现的诚欣电子商城

JSP+SSH+Mysql+DBCP实现的租车系统

博客系统java项目

这是一个在线考试系统,java项目实战源码下载

简单状态机

Java Web编程课程中开发的项目

银行账户项目样本 用Java完成的一个简单项目

一个使用Java开发在线概述用户管理平台

JAVAWeb项目 JAVA-WEB开发的一些练手项目，这些也适合初学者进行练习

问答(new)

@XmlJavaTypeAdapter 不起作用

如何序列化 Java 对象 - 将对象转换为 InputStream

如何将公钥和签名值转换为人类可读的格式

如何在 jqplot 条形图中放置多个条形图

在服务器上录制

当工作台不可用时如何获取 ICommandService 对象

从 SpatialIndexFeatureCollection 渲染要素时抛出 UnsupportedOperationException

在 Java 中读取大型 tiff 图像的最快方法是什么？

Windows 服务无法访问某些信息

更改 YourKit 远程分析器临时目录

游戏(new)

2人对战游戏，java游戏

java小游戏-数学英雄

java游戏-蛙人

经典骰子游戏,java游戏源码下载

一些java小游戏

java小游戏-抓住这只球

二十一点，java小游戏源码下载

java小游戏集合下载

java五子棋游戏源码下载

java贪吃蛇游戏

其他资源(new)

某公司的雇员分为以下若干类： Employee：这是所有员工总的父类，属性：员工的姓名和生日月份。 方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，

判断随机整数是否是素数 产生100个0-999之间的随机整数，然后判断这100个随机整数哪些是素数，哪些不是？

完成九宫格程序

. 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值

歌德巴赫猜想,任何一个大于六的偶数可以拆分成两个质数的和

在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下

计算圆周率

利用程序输出如下图形:

求 2/1+3/2+5/3+8/5+13/8.....前20项之和？

Nutch入门教程 pdf下载