首页 > 网页设计 > 站长在线 > Linux下IPC机制之Socket通信总结

Linux下IPC机制之Socket通信总结

孤风一剑 12月 16, 2013 270 0

Linux下IPC机制有很多种,Socket算得上比较广泛的一种,在不使用像D-Bus之类的重量级消息总线之前采用socket作为两个进程之间的通话算得上比较不错的选择,因此它的用途比较广泛.这里稍微做下总结吧.

1:常规用法

 

[cpp][/cpp] view plaincopy

  1. //初始化MyLink进程
  2. int initMylinkMsgServer()
  3. {
  4. #ifdef LINUX_EVN
  5.     pthread_mutex_init(&my_link_fd_mutex, NULL);
  6.     static pthread_t tServer;
  7.     if(pthread_create(&tServer, NULL, mylinkMsgServer,NULL) != 0)
  8.     {
  9.         pError(“\n initMylinkMsgServer error!\n”);
  10.         return -1;
  11.     }
  12. #endif
  13.     return 0;
  14. }

 

[cpp][/cpp] view plaincopy

  1. //MirrorLink线程
  2. void *mylinkMsgServer(void * arg)
  3. {
  4. #ifdef LINUX_EVN
  5.     socklen_t clt_addr_len;
  6.     int ret;
  7.     int len;
  8.     struct sockaddr_un clt_addr;
  9.     struct sockaddr_un srv_addr;
  10.     int server_sockfd;
  12.     //pthread_t rid;
  13.     int *cfd;
  15.     server_sockfd = socket(PF_UNIX, SOCK_STREAM, 0);<span style=”white-space:pre”>  </span>//创建本地SOCKET
  16.     if(server_sockfd < 0){
  17.         pError(“cannot create communication socket!\n”);
  18.         return ;
  19.     }
  21.     //set server addr_param
  22.     srv_addr.sun_family = AF_UNIX;
  23.     strncpy(srv_addr.sun_path, MY_SOCKET_PATH, sizeof(srv_addr.sun_path) – 1);
  24.     unlink(MY_SOCKET_PATH);
  26.     //bind sockfd & addr
  27.     ret = bind(server_sockfd, (struct sockaddr*)&srv_addr, sizeof(srv_addr)); //绑定SOCKET
  28.     if(ret == -1){
  29.         pError(“cannot bind server socket!\n”);
  30.         close(server_sockfd);
  31.         unlink(MY_SOCKET_PATH);
  32.         return ;
  33.     }
  35.     //listen sockfd
  36.     ret = listen(server_sockfd, 1);<span style=”white-space:pre”>               </span>//监听SOCKET事件
  37.     pError(“\nServer listen !\n”);
  38.     if(ret == -1){
  39.         pError(“cannot listen the client connect reques !\n”);
  40.         //perror(“cannot listen the client connect request\n”);
  41.         close(server_sockfd);
  42.         unlink(MY_SOCKET_PATH);
  43.         return ;
  44.     }
  46.     len = sizeof(clt_addr);
  48.     static int old_cli_fd = -1;
  50.     while(1)
  51.     {
  52.         pthread_t rid;
  53.         new_cli_fd = accept( server_sockfd, ( struct sockaddr * )&( clt_addr ), &len );//接受连接请求
  55.         if(new_cli_fd < 0){
  56.             new_cli_fd = -1;
  57.             pError(“fail to accpet!\n”);
  58.             continue;
  59.         }
  60.         pError(“new connect [%d]\n”,new_cli_fd);
  62.         if(old_cli_fd != -1)
  63.         {
  65.             old_cli_fd = -1;
  66.         }
  68.         int ret = pthread_create(&rid, NULL, &RecvFormClient, (void *)(&new_cli_fd));//需要针对这个连接创建一接收线程
  69.         if(ret != 0)
  70.         {
  71.             debug(“[%d][%s]\n”,ret,strerror(ret));
  72.             debug(“Client pthread_create error.\n”);
  73.         }
  75.         if(pthread_detach(rid))
  76.         {
  77.             debug(“Client pthread_detach error.\n”);
  78.         }
  79.         old_cli_fd = new_cli_fd;
  80.     }
  82.     close(server_sockfd);
  83.     unlink(MY_SOCKET_PATH);
  84.     pthread_exit((void *)1);
  85. #endif
  86.     return;
  87. }

这里:

 

 

[cpp][/cpp] view plaincopy

  1. #define MY_SOCKET_PATH  “/var/tmp/mylink.txt”

接收消息时采用单独线程:

 

 

[cpp][/cpp] view plaincopy
  1. //接收消息
  2. void *RecvFormClient(void *arg)
  3. {
  4. #ifdef LINUX_EVN
  5.     MsgInfo_t msg;
  7.     int s_fd = *(int *)arg;
  8.     int num;
  10.     //read and printf sent client info
  11.     while(s_fd > 0){
  12.         memset(&msg, 0, sizeof(MsgInfo_t));
  13.         num = recv(s_fd, &msg, sizeof(MsgInfo_t), 0);
  15.         if(-1 == num)
  16.         {
  17.             pError(“fail to receivel!\n”);
  18.             close(s_fd);
  19.             //*s_fd = -1;
  20.             break;
  21.         }
  22.         else if(0 == num)
  23.         {
  24.             pError(“the connect has been closed!\n”);
  25.             close(s_fd);
  26.             //*s_fd = -1;
  27.             break;
  28.         }
  29.         else
  30.         {
  31.             printf(“Server recv Event: [%d] dataLen:[%d]!\n”,msg.MsgType,num);
  32.             int msgType=msg.MsgType;
  33.             switch(msgType)
  34.             {
  35.                 case WM_START:
  36.                                      //…
  37.                                      break;
  38.                                 case xxx:
  39.                                      //…
  40.                                      break;
  41.                 default:
  42.                     //…
  43.                     break;
  44.             }
  45.         }
  46.     }
  47.     pthread_exit((void *)1);
  48. #endif
  49.     return;
  50. }

而发送消息时,则可以直接发送:

 

 

[cpp][/cpp] view plaincopy

  1. //发送消息给MyLink进程
  2. ssize_t sendMsgToClient(MsgInfo_t *msg)
  3. {
  4. #ifdef LINUX_EVN
  5.     ssize_t ret = 0;
  6.     pthread_mutex_lock(&my_link_fd_mutex);
  7.     if(-1 != new_cli_fd)
  8.     {
  9.         ret = send(new_cli_fd, msg, sizeof(MsgInfo_t), 0);
  10.     }
  11.     else
  12.     {
  13.         pError(“No MyLink\n”);
  14.     }
  15.     pthread_mutex_unlock(&my_link_fd_mutex);
  16.     return ret;
  17. #endif
  18. }

此方法在Linux下的使用得比较普遍.

 

 

 

2 抽象命名法:

上述方法很好,但是存在一个前提,收发双方都必须对做为文件路径的标志必须具有读写权限,但是在Android的中间件下采用上述方法有可能行不通,因此Android比较严格的权限控制很容易造成无法通信,虽然可以通信一些其它方式来解决,但还是不如直接像第一种方式通信来得痛快.下面介绍的这种抽象命名法就是解决这种问题.

 

服务端示例:

hmi_server.h:

 

[cpp][/cpp] view plaincopy

  1. #ifndef __HMI_SERVER_H__
  2. #define __HMI_SERVER_H__
  4. #define DEBUG_MODE
  5. #define SERVER_NAME “@server_socket”
  6. #define EPOLL_SIZE 1024
  7. #define BUF_SIZE 1024
  8. #define EPOLL_RUN_TIMEOUT -1
  10. // Macros – exit in any error (eval < 0) case
  11. #define CHK(eval) if(eval < 0){perror(“eval”); exit(-1);}
  12. // Macros – same as above, but save the result(res) of expression(eval)
  13. #define CHK2(res, eval) if((res = eval) < 0){perror(“eval”); exit(-1);}
  15. #endif

hmi_server.c:

 

 

[cpp][/cpp] view plaincopy

  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3. #include <stdio.h>
  4. #include <sys/un.h>
  5. #include <unistd.h>
  6. #include <stdlib.h>
  7. #include <stddef.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <sys/epoll.h>
  11. #include <fcntl.h>
  12. #include <errno.h>
  13. #include <time.h>
  14. #include “hmi_server.h”
  17. //int makeAddr(const char* name, struct sockaddr_un* pAddr, socklen_t* pSockLen)
  18. //{
  19. //    int nameLen = strlen(name);
  20. //    if (nameLen >= (int) sizeof(pAddr->sun_path) -1)  /* too long? */
  21. //        return -1;
  22. //    pAddr->sun_path[0] = ‘\0’;  /* abstract namespace */
  23. //    strcpy(pAddr->sun_path+1, name);
  24. //    pAddr->sun_family = AF_UNIX;
  25. //    *pSockLen = 1 + nameLen + offsetof(struct sockaddr_un, sun_path);
  26. //    return 0;
  27. //}
  28. static int setnonblocking(int sockfd)
  29. {
  30.     CHK(fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK));
  31.     return 0;
  32. }
  33. // *** Handle incoming message from clients
  34. static int handle_message(int client,struct epoll_event *ev)
  35. {
  36.     char buf[BUF_SIZE], message[BUF_SIZE];
  37.     int len;
  39.     bzero(buf, BUF_SIZE);
  40.     bzero(message, BUF_SIZE);
  43.     if(ev->events&EPOLLERR || ev->events&EPOLLHUP)
  44.     {
  45.         printf(“Client with fd: %d closed! \n”, client);
  46.         CHK(close(client));
  47.         return 0;
  48.     }
  49. #ifdef DEBUG_MODE
  50.         printf(“Try to read from fd(%d)\n”, client);
  51. #endif
  52.     CHK2(len,recv(client, buf, BUF_SIZE, 0));
  54.     // zero size of len mean the client closed connection
  55.     if(len == 0)
  56.     {
  57.         CHK(close(client));
  58. #ifdef DEBUG_MODE
  59.         printf(“Client with fd: %d closed! \n”, client);
  60. #endif
  61.     }
  62.     else
  63.     {
  64.         buf[len] =’\0′;
  65.         printf(“message:%s\n”, buf);
  66.     }
  67.     return 0;
  68. }
  69. int main()
  71. {
  72.     int listener, client_sockfd;
  73.     socklen_t server_len, client_len;
  74.     struct sockaddr_un server_addr;
  75.     struct sockaddr_un client_addr;
  78.     static struct epoll_event ev, events[EPOLL_SIZE];
  79.     ev.events = EPOLLIN | EPOLLET|EPOLLERR|EPOLLHUP;
  80.     char message[BUF_SIZE];
  81.     int epfd;
  82.     clock_t tStart;
  83.     int client, res, epoll_events_count;
  86.     //delete the old server socket
  87.     //unlink(“server_socket”);
  88.     //create socket
  89.      CHK2(listener, socket(AF_UNIX, SOCK_STREAM, 0));
  90.     setnonblocking(listener);
  91.     server_addr.sun_family = AF_UNIX;
  92.     strcpy(server_addr.sun_path, SERVER_NAME);
  93.     server_addr.sun_path[0]=0;
  94.     server_len = strlen(SERVER_NAME)  + offsetof(struct sockaddr_un, sun_path);
  95.     //makeAddr(“server_socket”, &server_addr, &server_len);
  96.     CHK(bind(listener, (struct sockaddr *)&server_addr, server_len));
  97.     CHK(listen(listener, 5));
  99.     CHK2(epfd,epoll_create(EPOLL_SIZE));
  100.     ev.data.fd = listener;
  101.     CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, listener, &ev));
  102.     while(1)
  103.     {
  104.         int i;
  105.         CHK2(epoll_events_count,epoll_wait(epfd, events, EPOLL_SIZE, EPOLL_RUN_TIMEOUT));
  106.         tStart = clock();
  107.         for(i = 0; i < epoll_events_count ; i++)
  108.         {
  109.             if(events[i].data.fd == listener)
  110.             {
  111.                 CHK2(client,accept(listener, (struct sockaddr *) &client_addr, &client_len));
  112.                 setnonblocking(client);
  113.                 ev.data.fd = client;
  114.                 CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, client, &ev));
  116.                 //clients_list.push_back(client);
  117.                 bzero(message, BUF_SIZE);
  118.                 res = sprintf(message, “my test”, client);
  119.                 CHK2(res, send(client, message, BUF_SIZE, 0));
  120.             }
  121.             else
  122.             {
  123.                 CHK2(res,handle_message(events[i].data.fd,&events[i]));
  124.             }
  125.         }
  126.         printf(“Statistics: %d events handled at: %.2f second(s)\n”, epoll_events_count, (double)(clock() – tStart)/CLOCKS_PER_SEC);
  127.     }
  129.     printf(“hmi_server stop\n”);
  130.     close(listener);
  131.     close(epfd);
  132.     return 0;
  133. }

客户端示例代码:

 

 

[cpp][/cpp] view plaincopy

  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3. #include <stdio.h>
  4. #include <sys/un.h>
  5. #include <unistd.h>
  6. #include <stdlib.h>
  7. #include <stddef.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <sys/epoll.h>
  11. #include <fcntl.h>
  12. #include <errno.h>
  13. #include <time.h>
  14. #include <pthread.h>
  16. #define SERVER_NAME “@server_socket”    //@为占位符
  17. #define EPOLL_SIZE 1024
  18. #define BUF_SIZE 1024
  19. #define EPOLL_RUN_TIMEOUT -1
  20. #define CLIENT_RECORD_MAX 5
  22. #define CHK(eval) if(eval < 0){perror(“eval”); exit(-1);}
  23. #define CHK2(res, eval) if((res = eval) < 0){perror(“eval”); exit(-1);}
  26. static int setnonblocking(int sockfd)
  27. {
  28.     CHK(fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK));
  29.     return 0;
  30. }
  32. static  int listener =-1;
  33. static void *send_thread(void *param)
  34. {
  35.     char send_buf[1024];
  36.     while(1)
  37.     {
  38.         printf(“[client] input content to send:”);
  39.         scanf(“%s”,send_buf);
  40.         strncat(send_buf,”\r\n”,sizeof(send_buf));
  41.         if(!strcmp(send_buf,”exit\r\n”))
  42.         {
  43.             exit(1);
  44.         }
  45.         if(listener >1)
  46.         {
  47.             write(listener, send_buf, strlen(send_buf));
  48.         }
  49.         else
  50.         {
  51.             printf(“[client] server already close!\r\n”);
  52.         }
  53.     }
  54. }
  55. int main()
  56. {
  58.     socklen_t len;
  59.     struct sockaddr_un address;
  60.     int result;
  61.     int epoll_events_count;
  62.     int epfd;
  65.     static struct epoll_event ev, events[EPOLL_SIZE];
  66.     ev.events = EPOLLIN | EPOLLET|EPOLLERR|EPOLLHUP;
  68.     CHK2(listener, socket(AF_UNIX, SOCK_STREAM, 0));
  69.     setnonblocking(listener);                                //设置为非阻塞线程
  70.     address.sun_family = AF_UNIX;
  71.     strcpy(address.sun_path, SERVER_NAME);
  72.     address.sun_path[0]=0;
  73.     len =  strlen(SERVER_NAME)  + offsetof(struct sockaddr_un, sun_path);
  74.     CHK(connect(listener, (struct sockaddr*)&address, len));
  76.     CHK2(epfd,epoll_create(EPOLL_SIZE));<span style=”white-space:pre”>          </span>//创建一epoll来监听socket事件
  77.     ev.data.fd = listener;
  78.     CHK(epoll_ctl(epfd, EPOLL_CTL_ADD, listener, &ev));
  79.     {
  80.         pthread_t mid;
  81.         int ret;
  83.         ret = pthread_create(&mid,NULL,send_thread,NULL);
  84.         if(ret != 0){
  85.             printf(“[client] can’t creat hmi_int %s\n”,strerror(ret));
  86.             exit(1);
  87.         }
  88.     }
  90.     char recv_buf[1024];
  91.     int nread =0;
  92.     int i,res;
  93.     while(1)
  94.     {
  95.         CHK2(epoll_events_count,epoll_wait(epfd, events, EPOLL_SIZE, EPOLL_RUN_TIMEOUT));
  96.         for(i = 0; i < epoll_events_count ; i++)
  97.         {
  98.             if(events[i].data.fd == listener)
  99.             {
  100. //              if(ev.events&EPOLLHUP)
  101. //              {
  102. //                  printf(“[client] server closed1!: %d  \n”, listener);
  103. //                  CHK(close(listener));
  104. //                  listener =-1;
  105. //                  return 0;
  106. //              }
  108.                 nread =recv(listener, recv_buf, sizeof(recv_buf), 0);
  109.                 if(nread <= 0)
  110.                 {
  111.                     printf(“[client] server closed2!: %d,nread=%d\n”, listener,nread);
  112.                     CHK(close(listener));
  113.                     listener =-1;
  114.                     return 0;
  115.                 }
  116.                 else
  117.                 {
  118.                     recv_buf[nread] =’\0′;
  119.                     printf(“[client] recv message:%s\n”, recv_buf);
  120.                 }
  121.             }
  122.         }
  123.     }
  124.     exit(0);
  125. }

 

3 MiniGUI的注册socket事件

这里之所以提出MiniGUI,那是因为在MiniGUI下可以将socket通信事件注册为窗口事件,利用窗口的消息队列来处理.

 

[cpp][/cpp] view plaincopy
  1. //导航socket初始化
  2. int NaviSocketInit(HWND hWnd)
  3. {
  4.     //监听导航socket
  5.     printf(“NaviSocketInit…\n”);
  6.     if (!listen_socket_navi(hWnd))
  7.     {
  8.         printf (“listen navi socket error!\n”);
  9.         return -1;
  10.     }
  11. }

 

[cpp][/cpp] view plaincopy

  1. //监听导航socket
  2. BOOL listen_socket_navi (HWND hwnd)
  3. {
  4. #ifdef _SOCKET
  5.     //创建一个监听socket,这里serv_listen是minigui API接口
  6.     if((listen_fd_navi = serv_listen (LISTEN_SOCKET_NAVI))<0)
  7.     {
  8.         printf(“serv_listen err!\n”);
  9.         return FALSE;
  10.     }
  11.     printf(“serv_listen OK\n”);
  12.     printf (“listen_fd_navi is %d\n”,listen_fd_navi);
  13.     //向miniGUI注册监听socket,RegisterListenFD是minigui接口
  14.     if(!RegisterListenFD (listen_fd_navi,POLLIN,hwnd, NULL))
  15.     {
  16.         printf(“RegisterListenFD failed\r\n”);
  17.         return FALSE;
  18.     }
  19.     printf(“RegisterListenFD OK!\r\n”);
  20. #endif
  21.     return TRUE;
  22. }

使用RegisterListenFD函数向MiniGUI系统注册监听Socket事件后, 每当产生 socket事件时,都会产生一个类型为MSG_FDEVENT事件:

 

 

[cpp][/cpp] view plaincopy

  1. case MSG_FDEVENT:
  2. NaviFdEventFunc(hWnd, message, wParam,lParam);
  3.  return 0;

 

[cpp][/cpp] view plaincopy在CODE上查看代码片派生到我的代码片

  1. //接收socket数据处理例程
  2. int NaviFdEventFunc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
  3. {
  4.     //printf(“receive navi socket event!flag_navi:%d,LOWORD(wParam):%d\r\n”,flag_navi,LOWORD (wParam));
  5. #ifdef _SOCKET
  6.     if(LOWORD(wParam) ==listen_fd_navi) /* 来自监听套接字 */
  7.     {
  8.         pid_t pid;
  9.         uid_t uid;
  10.         s_conn_fd_navi = serv_accept (listen_fd_navi, &pid, &uid);
  11.         if (s_conn_fd_navi >= 0)
  12.         {
  13.             RegisterListenFD (s_conn_fd_navi, POLLIN, hWnd, NULL);
  14.             printf(“navi new socket connect!:%d\n”,s_conn_fd_navi);
  15.         }
  16.     }
  17.     else/* 来自已连接套接字 */
  18.     {
  19.         int ret =0;
  21.         fd_recv = LOWORD(wParam);
  22.         memset(socket_str_c,0,sizeof(socket_str_c));
  23.         //printf(“try to read socket data,fd_recv:%d\r\n”,fd_recv);
  24.         /* 处理来自客户的数据 */
  26.         ret =sock_read_t (fd_recv,socket_str_c,sizeof(socket_str_c),0);
  27.         //printf(“sock_read_t ret=%d\n”,ret);
  28.         if(ret>0)
  29.         {
  30.             test_char_c[ret]=’\0′;
  31.             printf (“navi socket receive:%s,fd=%d\n”,socket_str_c,fd_recv);
  33.             if (!strcmp (socket_str_c,”Navi_To_HMI\r\n”))   //返回主界面
  34.             {
  35.                            //…
  36.             }
  37.             else if(!strcmp (socket_str_c,”Start_Success\r\n”))//启动成功
  38.             {
  39.                //…
  40.             }
  41.                         //else if(…)
  42.                         else
  43.                         {
  44.                             //…
  45.                         }
  47.         }
  49.     }
  50. #endif
  51.     return 0;
  52. }

三种socket本地通信方法,仅供参考.

标签

相关推荐

标签

.NET (32) ActiveMQ (34) AJAX (29) android (463) android开发 (34) ASP.NET (58) C# (153) CSS (21) eclipse (50) Hadoop (23) Hibernate (51) HTML (30) html5 (29) IOS (48) JAVA (378) JavaScript (87) JQuery (85) js (53) json (26) jsp (28) Linux (70) ListView (28) mvc (28) myeclipse (25) MySQL (151) oracle (181) PHP (158) spring (84) SQL (62) SQL Server (28) string (20) Struts2 (39) Tomcat (39) Ubuntu (20) WEB (28) webservice (29) Windows (27) XML (36) 多线程 (21) 存储过程 (22) 实例 (24) 数据库 (89) 服务器 (31) 算法 (34) 设计模式 (23)

文章归档