• 项目 - 员工信息管理系统

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

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

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

    项目名称：员工管理系统

    项目时间：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 
    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//根据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 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    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. }

    员工信息管理系统 测试

  • 相关阅读:
    微信小程序 - WXML 模板语法 - 条件渲染
    idea集成swagger创建接口文档
    vmware ubuntu 操作
    2023-10-25 精神分析-领悟新技术的错误做法-持续数年的错误做法-记录与分析
    rpmbuild时为什么会出现空的debugsourcefiles.list？
    【python】（八）python类型注解
    STM32注入通道
    常用百宝箱——日志处理
    简单大方的自我介绍 PPT 格式
    通过python实现分析出生日期辨识你的星座 出生日期判断星座
  • 原文地址：https://blog.csdn.net/weixin_43386810/article/details/127589253