资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/基于linux原生异步io创建的简易聊天程序

基于linux原生异步io创建的简易聊天程序

xcold / 596人阅读

摘要：分为两个独立的程序编译前先确定自己服务器的地址，比如想要在自己的下运行，先获取自己的地址，修改，里面的地址为自己的地址服务端编译运行客户端编译运行服务端先运行起来后，再启动客户端，可以在多态机器上启多个客户端，互相聊天

分为两个独立的程序
编译前先确定自己服务器的地址，比如想要在自己的ubuntu下运行，先ip addr获取自己的ip地址，修改chat_server.c，chat_client.c里面的ip地址为自己的ip地址

服务端chat_server.c
编译: gcc chat_server.c -o server
运行: ./server

</>复制代码 
  1. #include 
  2. #include 
  3. #include 
  4. #include 
  5. #include 
  6. #include 
  7. #include 
  8. #include 
  9. #include 
  10. #define    MAX_USER        500
  11. #define    MAX_MSG_LEN        1024
  12. #define MAX_IO_RETRY_TIMES    5
  13. int server_fd;
  14. int user_cnt = 0;
  15. int user_fds[MAX_USER];
  16. char msg_buffer[MAX_MSG_LEN];
  17. void down()
  18. {
  19.     int i;
  20.     for(i = 0; i < user_cnt; i++)
  21.     {
  22.         shutdown(user_fds[i], SHUT_RDWR);
  23.         close(user_fds[i]);
  24.         user_fds[i] = 0;
  25.     }
  26.     shutdown(server_fd, SHUT_RDWR);
  27.     close(server_fd);
  28.     server_fd = 0;
  29. }
  30. int go_on = 1;
  31. void sig_handler(int signal)
  32. {
  33.     go_on = 0;
  34. }
  35. int my_safe_read(int fd)
  36. {
  37.     int ret;
  38.     int i;
  39.     
  40.     for(i = 0; i < MAX_IO_RETRY_TIMES; i++)
  41.     {
  42.         errno = 0;
  43.         int ret = read(fd, msg_buffer, MAX_MSG_LEN);
  44.         if(ret < 0)
  45.         {
  46.             if(EAGAIN == errno || EWOULDBLOCK == errno)
  47.             {
  48.                 printf("Safe read [%d] cnt
  49. ", i + 1);
  50.                 continue;
  51.             }
  52.             else
  53.             {
  54.                 return ret;
  55.             }
  56.         }
  57.         else if(0 == ret)
  58.         {
  59.             return 0;
  60.         }
  61.         else
  62.         {
  63.             return ret;
  64.         }
  65.     }
  66.     return ret;
  67. }
  68. int my_safe_write(int fd)
  69. {
  70.     write(fd, msg_buffer, MAX_MSG_LEN);
  71. }
  72. int main(int argc, char *argv[])
  73. {
  74.     signal(SIGINT, sig_handler);
  75.     server_fd = socket(AF_INET, SOCK_STREAM, 0);
  76.     if(-1 == server_fd)
  77.     {
  78.         printf("socket err
  79. ");
  80.         return -1;
  81.     }
  82.     printf("socket ok
  83. ");
  84.     struct sockaddr_in server_addr;
  85.     bzero(&server_addr, sizeof(struct sockaddr_in));
  86.     server_addr.sin_family = AF_INET;
  87.     server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  88.     unsigned short portnum = 0x8888;
  89.     if(argc >= 2)
  90.     {
  91.         int port = atoi(argv[1]);
  92.         if(port > 20000)
  93.         {
  94.             portnum = port;
  95.         }
  96.     }
  97.     printf("port = %d
  98. ", portnum);
  99.     
  100.     server_addr.sin_port = portnum;
  101.     if(-1 == bind(server_fd, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr)))
  102.     {
  103.         printf("bind err
  104. ");
  105.         return -1;
  106.     }
  107.     printf("bind ok
  108. ");
  109.     if(-1 == listen(server_fd, MAX_USER))
  110.     {
  111.         printf("listen err
  112. ");
  113.         return -1;
  114.     }
  115.     printf("listen ok
  116. ");
  117.     int i;
  118.     fd_set fds;
  119.     struct timeval tv;
  120.     while(go_on)
  121.     {
  122.         FD_ZERO(&fds);
  123.         FD_SET(server_fd, &fds);
  124.         for(i = 0; i < user_cnt; i++)
  125.         {
  126.             printf("-%d
  127. ", user_fds[i]);
  128.             if(user_fds[i])
  129.             {
  130.                 FD_SET(user_fds[i], &fds);
  131.             }
  132.         }
  133.         int fd_cnt_to_selected = 0;
  134.         for(i = 0; i < user_cnt; i++)
  135.         {
  136.             if(user_fds[i] > fd_cnt_to_selected)
  137.             {
  138.                 fd_cnt_to_selected = user_fds[i];
  139.             }
  140.         }
  141.         fd_cnt_to_selected = (0 == user_cnt)? (server_fd + 1) : (fd_cnt_to_selected + 1);
  142.         tv.tv_sec = 2;
  143.         tv.tv_usec = 0;
  144.         int ret = select(fd_cnt_to_selected, &fds, 0, 0, &tv);
  145.         if(ret < 0)
  146.         {
  147.             printf("select err
  148. ");
  149.             break;
  150.         }
  151.         else if(0 == ret)
  152.         {
  153.             continue;
  154.         }
  155.         struct sockaddr_in client_addr;
  156.         for(i = 0; i < user_cnt; i++)
  157.         {
  158.             if(FD_ISSET(user_fds[i], &fds))
  159.             {
  160.                 bzero(msg_buffer, MAX_MSG_LEN);
  161.                 int ret = my_safe_read(user_fds[i]);
  162.                 if(ret <= 0)
  163.                 {
  164.                     int connection_state = 1; 
  165.                     int len_of_int = sizeof(int);
  166.                     getsockopt(user_fds[i], IPPROTO_TCP, SO_KEEPALIVE, (void*)&connection_state, &len_of_int); 
  167.                     printf("connection_state = %s
  168. ", (0 == connection_state)? "break" : "alive");
  169.                     if(0 == connection_state)
  170.                     {
  171.                         close(user_fds[i]);
  172.                         FD_CLR(user_fds[i], &fds);
  173.                         if(user_cnt - 1 == i)
  174.                         {
  175.                             user_cnt = user_cnt - 1;
  176.                             user_fds[i] = 0;
  177.                         }
  178.                         else
  179.                         {
  180.                             int j;
  181.                             for(j = i; j < user_cnt; j++)
  182.                             {
  183.                                 user_fds[j] = user_fds[j+1];
  184.                             }
  185.                             user_fds[j] = 0;
  186.                             user_cnt = user_cnt -1;
  187.                         }
  188.                     }
  189.                 }
  190.                 else
  191.                 {
  192.                     printf("receive[%s]
  193. ", msg_buffer);
  194.                     int j;
  195.                     for(j = 0; j < user_cnt; j++)
  196.                     {
  197.                         if(j == i)
  198.                         {
  199.                             continue;
  200.                         }
  201.                         my_safe_write(user_fds[j]);
  202.                     }
  203.                 }
  204.             }
  205.         }
  206.         if(FD_ISSET(server_fd, &fds))
  207.         {
  208.             int sin_size = sizeof(struct sockaddr);
  209.         
  210.             user_fds[user_cnt] = accept(server_fd, (struct sockaddr *)(&client_addr), &sin_size);
  211.             if(-1 == user_fds[user_cnt])
  212.             {
  213.                 printf("accept err
  214. ");
  215.                 return -1;
  216.             }
  217.             printf("accept ok!
  218. ");
  219.             printf("user_fds[user_cnt] = %d
  220. ", user_fds[user_cnt]);
  221.             user_cnt++;
  222.         }
  223.     }
  224.     
  225.     down();
  226.     return 0;
  227. }

客户端chat_client.c
编译: gcc chat_client -lpthread -o chat_client
运行: 服务端先运行起来后，再启动客户端，可以在多态机器上启多个客户端，互相聊天
./chat_client

</>复制代码 
  1. #include 
  2. #include 
  3. #include 
  4. #include 
  5. #include 
  6. #include 
  7. #include 
  8. #include 
  9. #include 
  10. #include 
  11. int cfd = 0;
  12. struct passwd *pwd;
  13. void sig_handler(int signal)
  14. {
  15.     char bye_msg[1024] = { 0 };
  16.     sprintf(bye_msg, "WARNING------>User[%s] have go, he said all is "SB"! Oh, what the fuck!", pwd->pw_name);
  17.     write(cfd, bye_msg, 1024);
  18.     
  19.     shutdown(cfd, SHUT_RDWR);
  20.     close(cfd);
  21.     cfd = 0;
  22.     exit(-1);
  23. }
  24. void* f(void* t)
  25. {
  26.     struct timeval tv;
  27.     fd_set fds;
  28.     while(1)
  29.     {
  30.         tv.tv_sec = 0;
  31.         tv.tv_usec = 100;
  32.         FD_ZERO(&fds);
  33.         FD_SET(cfd, &fds);
  34.         
  35.         int r = select(cfd + 1, &fds, 0, 0, &tv);
  36.         if(r<0)
  37.         {
  38.             printf("select err
  39. ");
  40.         }
  41.         else if(r==0)
  42.         {
  43.         }
  44.         
  45.         char buf[1024*10] = { 0 };
  46.         int n = read(cfd, buf, 1024*10);
  47.         if(buf[0] != 0)
  48.             printf("%s
  49. ", buf);
  50.     }    
  51. }
  52. int main(int argc, char * argv[])
  53. {
  54.     signal(SIGINT, sig_handler);
  55.     pwd = getpwuid(getuid());
  56.     int recbytes;
  57.     int sin_size;
  58.     char buffer[1024] ={0}; 
  59.     struct sockaddr_in s_add, c_add;
  60.     unsigned short portnum =0x8888;
  61.     if(argc >= 2)
  62.     {
  63.         int port = atoi(argv[1]);
  64.         if(port > 20000)
  65.         portnum = port;
  66.     }
  67.     printf("port = %d
  68. ", portnum);
  69.     
  70.     cfd = socket(AF_INET, SOCK_STREAM, 0);
  71.     if(-1 == cfd)
  72.     {
  73.         printf("socket err
  74. ");
  75.         return -1;
  76.     }
  77.     //printf("socket ok
  78. ");
  79.     bzero(&s_add, sizeof(struct sockaddr_in));
  80.     s_add.sin_family = AF_INET;
  81.     s_add.sin_addr.s_addr = inet_addr("192.168.60.104");
  82.     s_add.sin_port = htons(portnum);
  83.     
  84.     if(-1 == connect(cfd, (struct sockaddr *)(&s_add), sizeof(struct sockaddr)))
  85.     {
  86.         printf("connect err
  87. ");
  88.         return -1;
  89.     }
  90.     char personal_info[128] = { 0 };
  91.     sprintf(personal_info, "DouBi[%s] is comming!!!HaHaaa^-^", pwd->pw_name);
  92.     write(cfd, personal_info, 128);
  93.     //printf("connect ok
  94. ");
  95.     pthread_t th;
  96.     int rr = pthread_create((pthread_t *)&th, NULL, f, NULL);
  97.     
  98.     while(1)
  99.     {    
  100.         //printf("enter what you want to say:_
  101. ");
  102.         char b[10240] = { 0 };
  103.         sprintf(b, "[%s]: ", pwd->pw_name);
  104.         gets(b + strlen(b));
  105.         //printf("b = %s
  106. ", b);
  107.         if(-1 == (recbytes = write(cfd, b, 1024*10)))
  108.         {
  109.             printf("send data err
  110. ");
  111.             return -1;
  112.         }
  113.         //printf("send ok
  114. ");
  115.     }
  116.     
  117.     //close(cfd);
  118. //    sleep(100);
  119.     
  120.     return 0;
  121. }
云服务器 GPU云服务器 原生js简易日历 基于webrtc的多人视频聊天服务实例 简易网页聊天jsp js原生异步怎么写

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/25004.html

相关文章

  • 利用express+socket.io实现一个简易版聊天室

    摘要：用伪代码来模拟下长轮询的过程前端利用下面函数进行请求后端代码做如下更改利用随机数的大小来模拟是否有新数据有新数据来了长轮询的确减少了请求的次数，但是它也有着很大的问题，那就是耗费服务器的资源。 写在前面 最近由于利用node重构某个项目，项目中有一个实时聊天的功能，于是就研究了一下聊天室，在线demo|源码，欢迎大家反馈。这个聊天室的主要利用到了socket.io和express。这个...

    Chaz 评论0 收藏0

  • 基于express和socket.io的简易版聊天室

    摘要：简易版聊天室技术栈功能实现实时聊天创建房间表情包完善私聊效果登录服务端判断之前是否登录过聊天室，如果是则直接进入聊天室，否则跳转到登录页面。客户端发送创建房间和切换房间的事件给服务端。 Chat 简易版聊天室 技术栈 express socket.io 功能 实现 实时聊天 创建房间 表情包 完善 私聊 效果 登录 showImg(https://segmentfa...

    dendoink 评论0 收藏0

  • PHP并发IO编程之路

    摘要：下文如无特殊声明将使用进程同时表示进程线程。收到数据后服务器程序进行处理然后使用向客户端发送响应。现在各种高并发异步的服务器程序都是基于实现的，比如。 并发 IO 问题一直是服务器端编程中的技术难题，从最早的同步阻塞直接 Fork 进程，到 Worker 进程池/线程池，到现在的异步IO、协程。PHP 程序员因为有强大的 LAMP 框架，对这类底层方面的知识知之甚少，本文目的就是详细介...

    Riddler 评论0 收藏0

  • 微信小程序资源汇总

    awesome-github-wechat-weapp 是由OpenDigg整理并维护的微信小程序开源项目库集合。我们会定期同步上的项目到这里，也欢迎各位 UI组件开发框架实用库开发工具服务端项目实例Demo UI组件 weui-wxss ★1873 - 同微信原生视觉体验一致的基础样式库zanui-weapp ★794 - 好用易扩展的小程序 UI 库wx-charts ★449 - 微信小程...

    Olivia 评论0 收藏0

发表评论

登陆后可评论

0条评论

xcold

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<