学习笔记：UDP实现进程心跳检测

思路：

UDP服务器端：服务器维护一个client链表，当有client连接创建新节点保存客户主机名和地址，并保存心跳时间heart_beat_time。

当客户端发起一次心跳，服务器收到心跳包更新client节点的心跳时间。服务定时去检测client链表里的每个client的心跳时间，如果心跳时间和当前时间的时间差超过一定的时间间隔，就认为该client已经掉线。

UDP客户端：定时发送心跳包。

服务端代码:

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <sys/types.h>

5. #include <sys/socket.h>

6. #include <arpa/inet.h>

7. #include <unistd.h>

8. #include <signal.h>

9. #include <time.h>

10. #include <sys/timerfd.h>

11. #include <pthread.h>

12. #include <sys/epoll.h>

14. #define UDP_PORT_NUM (8888)

16. #define CLIENT_LOGIN 100

17. #define CLIENT_CHAT 200

18. #define CLIENT_QUIT 300

20. #define SERVER_CHAT 400

21. #define SERVER_QUIT 500

23. #define PRINT_ONLINE 600

24. #define PRIVATE_CHAT 700

26. #define HEART_BEAT 800

28. static int s_epoll_fd = -1;

30. typedef enum

31. {

32. E_CLIENT_OFF_LINE = 0,

33. E_CLIENT_ON_LINE

34. }eClientSatus;

36. struct node

37. {

38. char name[20]; // client name

39. struct sockaddr_in client_addr; // client addr

40. eClientSatus client_status; // client status

41. struct timespec heart_beat_time; // each heart beat update this time

42. struct node *next;

43. };

45. struct message

46. {

47. long type;

48. char name[20];

49. char peer_name[20];

50. char mtext[512];

51. };

53. struct node *create_list(void);

54. void insert_list(struct node *, char *, struct sockaddr_in *);

55. void delete_list(struct node *, char *);

57. void recv_message(int , struct node *);

58. void send_message(int , struct sockaddr_in *, pid_t );

60. void client_login(int , struct node *, struct message *, struct sockaddr_in *);

61. void client_chat(int , struct node *, struct message *);

62. void client_quit(int , struct node *, struct message *);

63. void server_chat(int , struct node *, struct message *);

64. void server_quit(int , struct node *, struct message *);

66. void brocast_msg(int , struct node *, struct message *);

67. void print_online(int , struct node *, struct message *);

68. void private_chat(int , struct node *, struct message *);

70. void father_func(int sig_no)

71. {

72. return ;

73. }

75. /* return ms */

76. static int calcProcessTime(int *pStartMs)

77. {

78. struct timespec endTime;

79. clock_gettime(CLOCK_REALTIME, &endTime);

80. if(pStartMs){

81. return endTime.tv_sec * 1000 + endTime.tv_nsec / 1000000 - *pStartMs;

82. }

83. return endTime.tv_sec * 1000 + endTime.tv_nsec / 1000000;

84. }

86. static void epollAddEvent(int epollFd, int addFd, int state)

87. {

88. struct epoll_event ev;

89. ev.events = state;

90. ev.data.fd = addFd;

91. epoll_ctl(epollFd, EPOLL_CTL_ADD, addFd, &ev);

92. return;

93. }

95. void* monitor_thread(void* user)

96. {

97. struct node *head = (struct node *)user;

98. struct epoll_event events[1] = {0};

99. int cnt = 0;

100. while(1)

101. {

102. int ms = 0;

103. ms = calcProcessTime(NULL);

104. int fireEvents = epoll_wait(s_epoll_fd, events, 1, -1);

105. ms = calcProcessTime(&ms);

106. if(fireEvents > 0){

107. printf("monitor time out: %d ms\n", ms);

108. uint64_t exp;

109. ssize_t size = read(events[0].data.fd, &exp, sizeof(uint64_t));

110. if(size != sizeof(uint64_t)) {

111. printf("read error!\n");

112. }

114. struct node *p = head;

115. struct timespec nowTime;

116. clock_gettime(CLOCK_REALTIME, &nowTime);

118. while (p != NULL){

119. /* if 10 second not receive client heart beat, we think the client is offline */

120. if(p->client_status == E_CLIENT_ON_LINE) {

121. int duration = (nowTime.tv_sec * 1000 + nowTime.tv_nsec / 1000000) - (p->heart_beat_time.tv_sec * 1000 + p->heart_beat_time.tv_nsec / 1000000);

122. if (duration > 10000) {

123. p->client_status = E_CLIENT_OFF_LINE;

124. printf("client: %s had off line\n", p->name);

125. }

126. }

127. p = p->next;

128. }

129. printf("All client check finished\n");

131. }

132. else{

133. printf("fireEvents = %d", fireEvents);

134. }

135. }

136. }

138. int main(int argc, const char *argv[])

139. {

140. int socket_fd;

141. pid_t pid;

142. struct sockaddr_in server_addr;

143. struct node *head;

145. if (argc < 2){

146. fprintf(stderr, "usages : %s ip\n", argv[0]);

147. exit(-1);

148. }

150. /* create UDP socket */

151. if ((socket_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){

152. perror("failed to create socket");

153. exit(-1);

154. }

156. /* create client list */

157. head = create_list();

159. server_addr.sin_family = AF_INET;

160. server_addr.sin_port = htons(UDP_PORT_NUM);

161. server_addr.sin_addr.s_addr = inet_addr(argv[1]);

163. if (bind(socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0){

164. perror("failed to bind");

165. exit(-1);

166. }

168. if ((pid = fork()) < 0){

169. perror("failed to fork pid");

170. exit(-1);

171. }

174. if (pid == 0){

175. /* create epoll */

176. int epollFd = -1;

177. epollFd = epoll_create(1);

178. s_epoll_fd = epollFd;

179. /* create timer */

180. int timerFd = -1;

181. timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);

183. /* add timer fd to epoll monitor event */

184. epollAddEvent(epollFd, timerFd, EPOLLIN);

186. /* create thread to monitor */

187. pthread_t threadId = -1;

188. pthread_create(&threadId, NULL, &monitor_thread, (void*)head);

190. /* create timer, time out is 10 seconds */

191. struct itimerspec its;

192. its.it_interval.tv_sec = 10; // 10 seconds

193. its.it_interval.tv_nsec = 0;

194. its.it_value.tv_sec = 10;

195. its.it_value.tv_nsec = 0;

196. if (timerfd_settime(timerFd, 0, &its, NULL) < 0) {

197. fprintf(stderr, "timerfd_settime error\n");

198. }

200. printf("udp server <receive message> running......\n");

201. recv_message(socket_fd, head);

202. }

203. else{

204. printf("udp server <send message> running......\n");

205. send_message(socket_fd, &server_addr, pid);

206. }

208. return 0;

209. }

212. struct node *create_list(void)

213. {

214. struct node *head;

216. head = (struct node *)malloc(sizeof(struct node));

217. head->next = NULL;

219. return head;

220. }

222. void insert_list(struct node *head, char *name, struct sockaddr_in *client_addr)

223. {

224. if(!head) return;

225. struct node *new;

227. new = (struct node *)malloc(sizeof(struct node));

228. strcpy(new->name, name);

229. new->client_addr = *client_addr;

230. new->client_status = E_CLIENT_ON_LINE;

231. clock_gettime(CLOCK_REALTIME, &new->heart_beat_time);

232. new->next = head->next;

233. head->next = new;

235. return ;

236. }

238. void delete_list(struct node *head, char *name)

239. {

240. if(!head) return;

241. struct node *p = head->next;

242. struct node *q = head;

244. while (p != NULL){

245. if (strcmp(p->name, name) == 0)

246. break;

248. p = p->next;

249. q = q->next;

250. }

252. q->next = p->next;

253. p->next = NULL;

254. free(p);

256. return ;

257. }

259. void recv_message(int socket_fd, struct node *head)

260. {

261. struct message msg;

262. struct sockaddr_in client_addr;

263. int client_addrlen = sizeof(struct sockaddr);

265. while (1)

266. {

267. memset(&msg, 0, sizeof(msg));

268. if (recvfrom(socket_fd, &msg, sizeof(msg), 0, (struct sockaddr *)&client_addr, &client_addrlen) < 0){

269. perror("failed to recvform client");

270. exit(-1);

271. }

273. switch(msg.type)

274. {

275. case CLIENT_LOGIN:

276. client_login(socket_fd, head, &msg, &client_addr);

277. break;

279. case CLIENT_CHAT:

280. client_chat(socket_fd, head, &msg);

281. break;

283. case CLIENT_QUIT:

284. client_quit(socket_fd, head, &msg);

285. break;

287. case SERVER_CHAT:

288. server_chat(socket_fd, head, &msg);

289. break;

291. case SERVER_QUIT:

292. server_quit(socket_fd, head, &msg);

293. break;

295. case PRINT_ONLINE:

296. print_online(socket_fd, head, &msg);

297. break;

299. case PRIVATE_CHAT:

300. private_chat(socket_fd, head, &msg);

301. break;

303. case HEART_BEAT:

304. heart_beat(socket_fd, head, &msg);

305. break;

307. default:

308. break;

309. }

310. }

312. return ;

313. }

315. void send_message(int socket_fd, struct sockaddr_in *server_addr, pid_t pid)

316. {

317. struct message msg;

318. char buf[512];

320. signal(getppid(), father_func);

322. while (1)

323. {

324. usleep(500);

325. printf(">");

326. fgets(buf, sizeof(buf), stdin);

327. buf[strlen(buf) - 1] = 0;

329. strcpy(msg.mtext, buf);

330. strcpy(msg.name , "server");

331. msg.type = SERVER_CHAT;

333. if (strncmp(buf, "quit", 4) == 0){

334. msg.type = SERVER_QUIT;

336. printf("udp server will quit, socket_fd = %d!!!!!\n", socket_fd);

337. if (sendto(socket_fd, &msg, sizeof(msg), 0,

338. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

339. perror("failed to send server_quit message");

340. exit(-1);

341. }

343. //pause();

345. kill(pid, SIGKILL);

346. waitpid(pid, NULL, 0);

347. close(socket_fd);

348. exit(-1);

349. }

351. if (sendto(socket_fd, &msg, sizeof(msg), 0, (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

352. perror("failed to send server_chat message");

353. exit(-1);

354. }

355. }

357. return ;

358. }

360. void client_login(int socket_fd, struct node *head, struct message *msg, struct sockaddr_in *client_addr)

361. {

362. printf("********Login In Notice********\n");

363. printf("%s has Login In, you can talk to him/her.\n", msg->name);

364. printf("****************************\n");

366. insert_list(head, msg->name, client_addr);

367. brocast_msg(socket_fd, head, msg);

369. return ;

370. }

372. void client_chat(int socket_fd, struct node *head, struct message *msg)

373. {

374. printf("********Group Chat********\n");

375. printf("name: %s\n", msg->name);

376. printf("msg: %s\n", msg->mtext);

377. printf("**************************\n");

379. brocast_msg(socket_fd, head, msg);

381. return ;

382. }

384. void client_quit(int socket_fd, struct node *head, struct message *msg)

385. {

386. printf("*********Quit Msg********\n");

387. printf("%s is Quit\n", msg->name);

388. printf("*************************\n");

390. delete_list(head, msg->name);

391. brocast_msg(socket_fd, head, msg);

393. return ;

394. }

396. void server_chat(int socket_fd, struct node *head, struct message *msg)

397. {

398. printf("********Server Msg*********\n");

399. printf("msg: %s\n", msg->mtext);

400. printf("***************************\n");

402. brocast_msg(socket_fd, head, msg);

404. return ;

405. }

407. void server_quit(int socket_fd, struct node *head, struct message *msg)

408. {

409. brocast_msg(socket_fd, head, msg);

410. kill(getppid(), SIGUSR1);

412. return ;

413. }

415. void print_online(int socket_fd, struct node *head, struct message *msg)

416. {

417. struct node *p = head->next;

418. struct sockaddr_in my_addr;

419. char buf[512];

421. printf("%s is request to print online client\n", msg->name);

422. memset(buf, 0, sizeof(buf));

424. while (p != NULL)

425. {

426. if (strcmp(p->name, msg->name) == 0){

427. my_addr = p->client_addr;

428. p = p->next;

429. continue;

430. }

432. strcat(buf, p->name);

433. strcat(buf, " ");

435. p = p->next;

436. }

438. strcpy(msg->mtext, buf);

439. msg->type = PRINT_ONLINE;

441. if (sendto(socket_fd, msg, sizeof(struct message), 0,

442. (struct sockaddr *)&my_addr, sizeof(my_addr)) < 0){

443. perror("failed to send print_online message");

444. exit(-1);

445. }

447. return ;

448. }

450. void private_chat(int socket_fd, struct node *head, struct message *msg)

451. {

452. struct node *p = head->next;

453. struct sockaddr_in *peer_addr = NULL;

455. printf("******** Private Msg ********\n");

456. printf("from %s\n", msg->name);

457. printf("to %s\n", msg->peer_name);

458. printf("msg: %s\n", msg->mtext);

459. printf("*****************************\n");

461. while (p != NULL)

462. {

463. if (strcmp(p->name, msg->peer_name) == 0){

464. peer_addr = &(p->client_addr);

465. break;

466. }

468. p = p->next;

469. }

471. if(!peer_addr){

472. printf("[Udp server] user %s is not in online list!!\n", msg->peer_name);

473. msg->type = SERVER_CHAT;

474. sprintf(msg->mtext, "The one of %s who you want to talk is not exist!!!\n", msg->peer_name);

475. p = head->next;

476. while (p != NULL){

477. if (strcmp(p->name, msg->name) == 0){

478. peer_addr = &(p->client_addr);

479. break;

480. }

481. p = p->next;

482. }

483. }

485. if(peer_addr){

486. if (sendto(socket_fd, msg, sizeof(struct message), 0,

487. (struct sockaddr *)peer_addr, sizeof(struct sockaddr_in)) < 0){

488. perror("failed to send private message");

489. exit(-1);

490. }

491. }

493. return ;

494. }

496. void heart_beat(int socket_fd, struct node *head, struct message *msg)

497. {

498. struct node *p = head->next;

499. printf("%s heart beat ^^^\n", msg->name);

501. while (p != NULL)

502. {

503. if (strcmp(p->name, msg->name) == 0){

504. p->client_status = E_CLIENT_ON_LINE;

505. clock_gettime(CLOCK_REALTIME, &p->heart_beat_time);

506. }

508. p = p->next;

509. }

511. return ;

512. }

514. void brocast_msg(int socket_fd, struct node *head, struct message *msg)

515. {

516. struct node *p = head->next;

518. while(p != NULL)

519. {

520. if (msg->type == CLIENT_LOGIN){

521. if (strcmp(p->name, msg->name) == 0){

522. p = p->next;

523. continue;

524. }

525. }

527. sendto(socket_fd, msg, sizeof(struct message), 0, (struct sockaddr *)&(p->client_addr), sizeof(struct sockaddr));

528. p = p->next;

529. }

531. return ;

532. }

客户端代码：

1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <string.h>

4. #include <sys/types.h>

5. #include <sys/socket.h>

6. #include <arpa/inet.h>

7. #include <unistd.h>

8. #include <signal.h>

9. #include <pthread.h>

10. #include <sys/timerfd.h>

11. #include <sys/epoll.h>

13. #define UDP_PORT_NUM (8888)

15. #define CLIENT_LOGIN 100

16. #define CLIENT_CHAT 200

17. #define CLIENT_QUIT 300

19. #define SERVER_CHAT 400

20. #define SERVER_QUIT 500

22. #define PRINT_ONLINE 600

23. #define PRIVATE_CHAT 700

25. #define HEART_BEAT 800

27. static char s_my_name[20];

28. static int s_server_fd;

29. static int s_epoll_fd = -1;

31. struct message

32. {

33. long type;

34. char name[20];

35. char peer_name[20];

36. char mtext[512];

37. };

39. void recv_message(int );

40. void send_message(int , struct sockaddr_in *, char *, pid_t);

42. void login_msg(struct message *);

43. void group_msg(struct message *);

44. void quit_msg(struct message *);

45. void server_msg(struct message *);

46. void server_quit(void);

47. void online_msg(struct message *);

48. void private_msg(struct message *);

50. void print_online(int , struct message *, struct sockaddr_in *);

51. void group_chat(int , struct message *, struct sockaddr_in *);

52. void private_chat(int ,struct message *, struct sockaddr_in *);

53. void client_quit(int , struct message *, struct sockaddr_in *, pid_t );

55. static void epollAddEvent(int epollFd, int addFd, int state)

56. {

57. struct epoll_event ev;

58. ev.events = state;

59. ev.data.fd = addFd;

60. epoll_ctl(epollFd, EPOLL_CTL_ADD, addFd, &ev);

61. return;

62. }

64. void heart_beat(struct sockaddr_in *server_addr)

65. {

66. struct message msg;

67. msg.type = HEART_BEAT;

68. strcpy(msg.name, s_my_name);

70. if (sendto(s_server_fd, &msg, sizeof(struct message), 0,

71. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

72. perror("failed to send online message");

73. return;

74. }

76. return ;

77. }

79. void* heart_beat_thread(void* user)

80. {

81. struct sockaddr_in *server_addr = (struct sockaddr_in*)user;

82. struct epoll_event events[1] = {0};

83. int cnt = 0;

84. while(1)

85. {

86. int fireEvents = epoll_wait(s_epoll_fd, events, 1, -1);

87. if(fireEvents > 0){

88. printf("I heart beat\n");

89. uint64_t exp;

90. ssize_t size = read(events[0].data.fd, &exp, sizeof(uint64_t));

91. if(size != sizeof(uint64_t)) {

92. printf("read error!\n");

93. }

95. heart_beat(server_addr);

96. }

97. else{

98. printf("fireEvents = %d", fireEvents);

99. }

100. }

101. return NULL;

102. }

104. int main(int argc, char *argv[])

105. {

106. pid_t pid;

107. int server_fd;

108. struct sockaddr_in server_addr;

110. if (argc < 4){

111. fprintf(stderr, "usages: %s ip name heart_beat(seconds)\n", argv[0]);

112. exit(-1);

113. }

115. int heart_beat_period = atoi(argv[3]);

117. if ((server_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){

118. perror("failed to create server_fd");

119. exit(-1);

120. }

121. s_server_fd = server_fd;

123. server_addr.sin_family = AF_INET;

124. server_addr.sin_port = htons(UDP_PORT_NUM);

125. server_addr.sin_addr.s_addr = inet_addr(argv[1]);

127. if ((pid = fork()) < 0){

128. perror("failed to fork pid");

129. exit(-1);

130. }

132. memset(s_my_name, '\0', 20);

133. memcpy(s_my_name, argv[2], sizeof(char) * (strlen(argv[2]) + 1));

135. if (pid == 0) {

136. /* create epoll */

137. int epollFd = -1;

138. epollFd = epoll_create(1);

139. s_epoll_fd = epollFd;

140. /* create timer */

141. int timerFd = -1;

142. timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);

144. /* add timer fd to epoll monitor event */

145. epollAddEvent(epollFd, timerFd, EPOLLIN);

147. /* create heart beat thread */

148. pthread_t threadId = -1;

149. pthread_create(&threadId, NULL, &heart_beat_thread, (void*)&server_addr);

151. /* create timer, time out is heart beat seconds */

152. struct itimerspec its;

153. its.it_interval.tv_sec = heart_beat_period;

154. its.it_interval.tv_nsec = 0;

155. its.it_value.tv_sec = heart_beat_period;

156. its.it_value.tv_nsec = 0;

157. if (timerfd_settime(timerFd, 0, &its, NULL) < 0) {

158. fprintf(stderr, "timerfd_settime error\n");

159. }

161. recv_message(server_fd);

162. }

163. else {

164. send_message(server_fd, &server_addr, argv[2], pid);

165. }

167. return 0;

168. }

170. void recv_message(int server_fd)

171. {

172. struct message msg;

174. while (1)

175. {

176. memset(&msg, 0, sizeof(msg));

178. int nbytes = 0;

179. if ((nbytes = recvfrom(server_fd, &msg, sizeof(msg), 0, NULL, NULL)) < 0){

180. perror("failed to recv server message");

181. exit(-1);

182. }

184. switch(msg.type)

185. {

186. case CLIENT_LOGIN:

187. login_msg(&msg);

188. break;

190. case CLIENT_CHAT:

191. group_msg(&msg);

192. break;

194. case CLIENT_QUIT:

195. quit_msg(&msg);

196. break;

198. case SERVER_CHAT:

199. server_msg(&msg);

200. break;

202. case SERVER_QUIT:

203. server_quit();

204. break;

206. case PRINT_ONLINE:

207. online_msg(&msg);

208. break;

210. case PRIVATE_CHAT:

211. private_msg(&msg);

212. break;

213. default:

214. break;

215. }

216. }

218. return ;

219. }

221. void send_message(int server_fd, struct sockaddr_in *server_addr, char *name, pid_t pid)

222. {

223. struct message msg;

224. char buf[512];

225. int c;

227. msg.type = CLIENT_LOGIN;

228. strcpy(msg.name, name);

230. if (sendto(server_fd, &msg, sizeof(msg), 0,

231. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

232. perror("failed to send login message");

233. exit(-1);

234. }

236. while(1)

237. {

238. usleep(500);

239. printf("#####################################\n");

240. printf("the following options can be choose:\n");

241. printf("input 1 is to print online client\n");

242. printf("input 2 is to chat to all the client\n");

243. printf("input 3 is to chat to only one client\n");

244. printf("input q is to quit\n");

245. printf("#####################################\n");

247. printf(">");

248. c = getchar();

249. while (getchar() != '\n');

251. switch(c)

252. {

253. case '1':

254. print_online(server_fd, &msg, server_addr);

255. break;

257. case '2':

258. printf("[Notice:]you can input <quit> cmd to close group chat....\n");

259. group_chat(server_fd, &msg, server_addr);

260. break;

262. case '3':

263. printf("[Notice:]you can input <quit> cmd to close private chat....\n");

264. private_chat(server_fd, &msg, server_addr);

265. break;

267. case 'q':

268. client_quit(server_fd, &msg, server_addr, pid);

269. break;

271. default:

272. break;

273. }

274. }

276. return ;

277. }

279. void login_msg(struct message *msg)

280. {

281. printf("********Login In Notice********\n");

282. printf("%s has Login In, you can talk to him/her.\n", msg->name);

283. printf("****************************\n");

285. return ;

286. }

288. void group_msg(struct message *msg)

289. {

290. printf("******** Group Msg ********\n");

291. printf("name: %s\n", msg->name);

292. printf("msg: %s\n", msg->mtext);

293. printf("******** Group Msg ********\n");

295. return ;

296. }

298. void quit_msg(struct message *msg)

299. {

300. printf("######## Quit Msg ########\n");

301. printf("%s is Quit\n", msg->name);

302. printf("######## Quit Msg ########\n");

304. return ;

305. }

307. void server_msg(struct message *msg)

308. {

309. printf("******** Server Msg ********\n");

310. printf("msg: %s\n", msg->mtext);

311. printf("******** Server Msg ********\n");

313. return ;

314. }

316. void server_quit(void )

317. {

318. kill(getppid(), SIGKILL);

319. exit(0);

320. }

322. void online_msg(struct message *msg)

323. {

324. printf("******** Clients you can talk to. ********\n");

325. printf("Clients: %s\n", msg->mtext);

326. printf("******** Clients you can talk to. ********\n");

328. return ;

329. }

331. void private_msg(struct message *msg)

332. {

333. printf("******** Private Msg ********\n");

334. printf("[%s] say: %s\n", msg->name, msg->mtext);

335. printf("******** Private Msg ********\n");

337. return ;

338. }

340. void print_online(int server_fd, struct message *msg, struct sockaddr_in *server_addr)

341. {

342. msg->type = PRINT_ONLINE;

344. if (sendto(server_fd, msg, sizeof(struct message), 0,

345. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

346. perror("failed to send online message");

347. exit(-1);

348. }

350. return ;

351. }

353. void group_chat(int server_fd, struct message *msg, struct sockaddr_in *server_addr)

354. {

355. char buf[512];

357. memset(buf, 0, sizeof(buf));

358. printf("*********** Group Chat Room ***********\n");

359. printf("****** Welcome to group chat room ******\n");

360. printf("* if you want to quit, please input quit\n");

361. printf("****************************************\n");

363. while(1)

364. {

365. memset(buf, 0, sizeof(buf));

366. usleep(500);

367. printf(">");

368. fgets(buf, sizeof(buf), stdin);

369. buf[strlen(buf) - 1] = 0;

371. msg->type = CLIENT_CHAT;

372. strcpy(msg->mtext, buf);

374. if (strncmp(buf, "quit", 4) == 0)

375. break;

377. if (sendto(server_fd, msg, sizeof(struct message), 0,

378. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

379. perror("failed to send group message");

380. exit(-1);

381. }

382. }

384. return ;

385. }

387. void private_chat(int server_fd, struct message *msg, struct sockaddr_in *server_addr)

388. {

389. char name[20];

390. char buf[512];

392. memset(name, 0, sizeof(name));

393. printf("please input the peer_name\n");

394. printf(">");

395. fgets(name, sizeof(name), stdin);

396. name[strlen(name) - 1] = 0;

398. if(strncmp(s_my_name, name, strlen(name)) == 0){

399. printf("you can not talk with yourself!!!!!\n");

400. return;

401. }

403. strcpy(msg->peer_name, name);

404. msg->type = PRIVATE_CHAT;

406. printf("you want to talk to %s!\n", msg->peer_name);

408. while(1)

409. {

410. usleep(500);

411. printf(">");

412. fgets(buf, sizeof(buf), stdin);

413. buf[strlen(buf) - 1] = 0;

415. strcpy(msg->mtext, buf);

417. if (strncmp(buf, "quit", 4) == 0)

418. break;

420. if (sendto(server_fd, msg, sizeof(struct message), 0,

421. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

422. perror("failed to send private message");

423. exit(-1);

424. }

425. }

427. return ;

428. }

430. void client_quit(int server_fd, struct message *msg, struct sockaddr_in *server_addr, pid_t pid)

431. {

432. msg->type = CLIENT_QUIT;

434. if (sendto(server_fd, msg, sizeof(struct message), 0,

435. (struct sockaddr *)server_addr, sizeof(struct sockaddr)) < 0){

436. perror("failed to send quit message");

437. exit(-1);

438. }

440. kill(pid, SIGKILL);

441. waitpid(pid, NULL, 0);

442. exit(0);

443. }

(58条消息) 学习笔记：UDP实现进程心跳检测_fanchenxinok的专栏-CSDN博客_udp 心跳包