(OK) server-client-pthread-c language

server.c

点击(此处)折叠或打开

  1. // gcc -lpthread server.c -o server
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <string.h>
  6. #include <netinet/in.h>
  7. #include <arpa/inet.h>
  8. #include <sys/socket.h>
  9. #include <pthread.h>


  12. //#endif
  13. #define BUF_SIZE 1024        //默认缓冲区
  14. #define SERVER_PORT 11111    //监听端口
  15. #define SERVER_HOST "127.0.0.1"    //服务器IP地址
  16. #define EPOLL_RUN_TIMEOUT -1    //epoll的超时时间
  17. #define EPOLL_SIZE 10000    //epoll监听的客户端的最大数目
  18. #define LISTEN_SIZE 10        //监听队列长度

  20. #define STR_WELCOME "Welcome to seChat! You ID is : Client #%d"
  21. #define STR_MESSAGE "Client #%d>> %s"
  22. #define STR_NOONE_CONNECTED "Noone connected to server expect you!"
  23. #define CMD_EXIT "EXIT"

  25. //两个有用的宏定义：检查和赋值并且检测
  26. #define CHK(eval) if(eval < 0){perror("eval"); exit(-1);}
  27. #define CHK2(res, eval) if((res = eval) < 0){perror("eval"); exit(-1);}

  29. void* handle_message(void *arg);

  31. int main(int argc, char *argv[])
  32. {
  33.     int listener;        //监听socket
  34.     struct sockaddr_in addr, peer;
  35.     addr.sin_family = PF_INET;
  36.     addr.sin_port = htons(SERVER_PORT);
  37.     addr.sin_addr.s_addr = inet_addr(SERVER_HOST);
  38.     socklen_t socklen;
  39.     socklen = sizeof(struct sockaddr_in);

  41.     int client;

  43.     CHK2(listener, socket(PF_INET, SOCK_STREAM, 0));    //初始化监听socket

  45.     // 设置套接字选项避免地址使用错误
  46.     int on=1;
  47.     if((setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)))<0)
  48.     {
  49.         perror("setsockopt failed");
  50.         exit(EXIT_FAILURE);
  51.     }

  53.     CHK(bind(listener, (struct sockaddr *)&addr, sizeof(addr)));    //绑定监听socket

  55.     //printf("listen ");
  56.     CHK(listen(listener, LISTEN_SIZE));    //设置监听
  57.     printf("listening ");

  59.     while (1) {
  60.         //printf("accept ");
  61.         CHK2(client, accept(listener, (struct sockaddr *)&peer, &socklen));
  62.         printf("accepted ");

  64.         pthread_t reader;
  65.         int rt = pthread_create(&reader, NULL, handle_message, (void *)&client);
  66.         if (-1 == rt) {
  67.             printf("thread creation error ");
  68.             return -1;
  69.         }
  70.     }
  71. }

  73. void* handle_message(void *arg)
  74. {
  75.     int client = *((int*)arg);
  76.     //sleep(5);
  77.     char buf[BUF_SIZE];
  78.     int len;

  80.     while(1){
  81.         bzero(buf, BUF_SIZE);
  82.         CHK2(len, recv(client, buf, BUF_SIZE, 0));    //接受客户端信息
  83.         if (len == 0)        //客户端关闭或出错，关闭socket，并从list移除socket
  84.         {
  85.             printf("close-client: %d ", client);
  86.             CHK(close(client));
  87.             return NULL;
  88.         } else            //向客户端发送信息
  89.         {
  90.             CHK(send(client, STR_NOONE_CONNECTED, strlen(STR_NOONE_CONNECTED), 0));
  91.             printf("receive: %s from %d ", buf, client);
  92.         }
  93.     }
  94.     //return len;
  95.     //return NULL;
  96. }
client.c

点击(此处)折叠或打开

  1. // gcc client.c -o client
  2. // gcc -lpthread client.c -o client
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <netinet/in.h>
  8. #include <arpa/inet.h>
  9. #include <sys/socket.h>
  10. #include <sys/epoll.h>

  12. //#endif
  13. #define BUF_SIZE 1024        //默认缓冲区
  14. #define SERVER_PORT 11111    //监听端口
  15. #define SERVER_HOST "127.0.0.1"    //服务器IP地址
  16. #define EPOLL_RUN_TIMEOUT -1    //epoll的超时时间
  17. #define EPOLL_SIZE 10000    //epoll监听的客户端的最大数目

  19. #define STR_WELCOME "Welcome to seChat! You ID is : Client #%d"
  20. #define STR_MESSAGE "Client #%d>> %s"
  21. #define STR_NOONE_CONNECTED "Noone connected to server expect you!"
  22. #define CMD_EXIT "EXIT"

  24. //两个有用的宏定义：检查和赋值并且检测
  25. #define CHK(eval) if(eval < 0){perror("eval"); exit(-1);}
  26. #define CHK2(res, eval) if((res = eval) < 0){perror("eval"); exit(-1);}

  28. char message[BUF_SIZE];

  30. /*
  31.     流程：
  32.         调用fork产生两个进程，两个进程通过管道进行通信
  33.         子进程：等待客户输入，并将客户输入的信息通过管道写给父进程
  34.         父进程：接受服务器的信息并显示，将从子进程接受到的信息发送给服务器
  35. */
  36. int main(int argc, char *argv[])
  37. {
  38.     int sock, pid, pipe_fd[2], epfd;

  40.     struct sockaddr_in addr;
  41.     addr.sin_family = PF_INET;
  42.     addr.sin_port = htons(SERVER_PORT);
  43.     addr.sin_addr.s_addr = inet_addr(SERVER_HOST);

  45.     static struct epoll_event ev, events[2];
  46.     ev.events = EPOLLIN | EPOLLET;

  48.     //退出标志
  49.     int continue_to_work = 1;

  51.     CHK2(sock, socket(PF_INET, SOCK_STREAM, 0));
  52.     CHK(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0);

  54.     CHK(pipe(pipe_fd));

  56.     CHK2(epfd, epoll_create(EPOLL_SIZE));

  58.     ev.data.fd = sock;
  59.     CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ev));

  61.     ev.data.fd = pipe_fd[0];
  62.     CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, pipe_fd[0], &ev));

  64.     // 调用fork产生两个进程
  65.     CHK2(pid, fork());
  66.     switch (pid) {
  67.     case 0:        // 子进程
  68.         close(pipe_fd[0]);    // 关闭读端
  69.         printf("Enter 'exit' to exit ");
  70.         while (continue_to_work) {
  71.             bzero(&message, BUF_SIZE);
  72.             fgets(message, BUF_SIZE, stdin);

  74.             // 当收到exit命令时，退出
  75.             if (strncasecmp(message, CMD_EXIT, strlen(CMD_EXIT)) == 0) {
  76.                 continue_to_work = 0;
  77.             } else {
  78.                 CHK(write(pipe_fd[1], message, strlen(message) - 1));
  79.             }
  80.         }
  81.         break;
  82.     default:        // 父进程
  83.         close(pipe_fd[1]);    // 关闭写端
  84.         int epoll_events_count, res;
  85.         while (continue_to_work) {
  86.             CHK2(epoll_events_count, epoll_wait(epfd, events, 2, EPOLL_RUN_TIMEOUT));

  88.             for (int i = 0; i < epoll_events_count; i++) {
  89.                 bzero(&message, BUF_SIZE);
  90.                 if (events[i].data.fd == sock)    //从服务器接受信息
  91.                 {
  92.                     CHK2(res, recv(sock, message, BUF_SIZE, 0));
  93.                     if (res == 0)    //服务器已关闭
  94.                     {
  95.                         CHK(close(sock));
  96.                         continue_to_work = 0;
  97.                     } else {
  98.                         printf("%s ", message);
  99.                     }
  100.                 } else    //从子进程接受信息
  101.                 {
  102.                     CHK2(res, read(events[i].data.fd, message, BUF_SIZE));
  103.                     if (res == 0) {
  104.                         continue_to_work = 0;
  105.                     } else {
  106.                         CHK(send(sock, message, BUF_SIZE, 0));
  107.                     }
  108.                 }
  109.             }
  110.         }
  111.     }
  112.     if (pid) {
  113.         close(pipe_fd[0]);
  114.         close(sock);
  115.     } else {
  116.         close(pipe_fd[1]);
  117.     }

  119.     return 0;
  120. }




【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ztguang/p/12647123.html