linux进程间通信--socket套接字

SOCKET是进程间通信的一种方式，这个时候socket的创建、绑定、连接时的参数是与网络上不同主机间的通信不同的，比如对于socketaddr的使用，进程间通信使用的是sockaddr_un。而主机间的通信使用的是sockadd_in。

  现贴出简单的未使用线程的进程间通信代码：

  server端：

点击(此处)折叠或打开

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <sys/socket.h>
   
5. #include <sys/un.h>
   
6. #include <unistd.h>
   
7. #define UNIX_DOMAIN "/tmp/UNIX.domain"
   
8. 
   
9. int main(void)
   
10. {
    
11.   int lsn_fd, apt_fd;
    
12.   struct sockaddr_un srv_addr;
    
13.   struct sockaddr_un clt_addr;
    
14.   socklen_t clt_len;
    
15.   int ret;
    
16.   int i;
    
17.   char recv_buf[1024];
    
18.   char send_buf[1024];
    
19.   
    
20.   //create socket to bind local IP and PORT
    
21.   lsn_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    
22.   if(lsn_fd < 0)
    
23.   {
    
24.     perror("can't create communication socket!");
    
25.     return 1;
    
26.   }
    
27.   
    
28.   //create local IP and PORT
    
29.   srv_addr.sun_family = AF_UNIX;
    
30.   strncpy(srv_addr.sun_path, UNIX_DOMAIN, sizeof(srv_addr.sun_path) - 1);
    
31.   unlink(UNIX_DOMAIN);
    
32.   
    
33.   //bind sockfd and sockaddr
    
34.   ret = bind(lsn_fd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));
    
35.   if(ret == -1)
    
36.   {
    
37.     perror("can't bind local sockaddr!");
    
38.     close(lsn_fd);
    
39.     unlink(UNIX_DOMAIN);
    
40.     return 1;
    
41.   }
    
42.   
    
43.   //listen lsn_fd, try listen 1
    
44.   ret = listen(lsn_fd, 1);
    
45.   if(ret == -1)
    
46.   {
    
47.     perror("can't listen client connect request");
    
48.     close(lsn_fd);
    
49.     unlink(UNIX_DOMAIN);
    
50.     return 1;
    
51.   }
    
52.   
    
53.   clt_len = sizeof(clt_addr);
    
54.   while(1)
    
55.   {
    
56.     apt_fd = accept(lsn_fd, (struct sockaddr*)&clt_addr, &clt_len);
    
57.     if(apt_fd < 0)
    
58.     {
    
59.       perror("can't listen client connect request");
    
60.       close(lsn_fd);
    
61.       unlink(UNIX_DOMAIN);
    
62.       return 1; 
    
63.     }
    
64.   
    
65.     printf("received a connection\n");
    
66.     printf("send message to client\n");
    
67.     memset(send_buf, 0, 1024);
    
68.     strcpy(send_buf, "Hello, you have connected to server succeed");
    
69.     
    
70.     int snd_num = write(apt_fd, send_buf, 1024);
    
71.     if(snd_num != 1024)
    
72.     {
    
73.       perror("send messge to client failed\n");
    
74.       close(apt_fd);
    
75.       close(lsn_fd);
    
76.       unlink(UNIX_DOMAIN);
    
77.       return 1;
    
78.     }
    
79.     //read and printf client info
    
80.     printf("============info=================\n");
    
81.     for(i = 0; i < 4; i++)
    
82.     {
    
83.       memset(recv_buf, 0, 1024);
    
84.       int rcv_num = read(apt_fd, recv_buf, sizeof(recv_buf));
    
85.       printf("Message from client (%d) :%s\n", rcv_num, recv_buf);
    
86.     }
    
87.   }
    
88.   close(apt_fd);
    
89.   close(lsn_fd);
    
90.   unlink(UNIX_DOMAIN);
    
91.   return 0;
    
92. }

client端：

点击(此处)折叠或打开

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <sys/socket.h>
   
4. #include <sys/un.h>
   
5. #include <unistd.h>
   
6. #define UNIX_DOMAIN "/tmp/UNIX.domain"
   
7. 
   
8. int main(void)
   
9. {
   
10.   int connect_fd;
    
11.   struct sockaddr_un srv_addr;
    
12.   char snd_buf[1024];
    
13.   char rcv_buf[1024];
    
14.   int ret;
    
15.   int i;
    
16.   
    
17.   //create client socket
    
18.   connect_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    
19.   if(connect_fd < 0)
    
20.   {
    
21.     perror("client create socket failed");
    
22.     return 1;
    
23.   }
    
24.   
    
25.   //set server sockaddr_un
    
26.   srv_addr.sun_family = AF_UNIX;
    
27.   strcpy(srv_addr.sun_path, UNIX_DOMAIN);
    
28.   
    
29.   //connect to server
    
30.   ret = connect(connect_fd, (struct sockaddr*)&srv_addr, sizeof(srv_addr));
    
31.   if(ret == -1)
    
32.   {
    
33.     perror("connect to server failed!");
    
34.     close(connect_fd);
    
35.     unlink(UNIX_DOMAIN);
    
36.     return 1;
    
37.   }
    
38.   
    
39.   //receive message from server
    
40.   memset(rcv_buf, 0, 1024);
    
41.   int rcv_num = read(connect_fd, rcv_buf, sizeof(rcv_buf));
    
42.   printf("receive message from server (%d) :%s\n", rcv_num, rcv_buf);
    
43.   //printf("\n");
    
44.   
    
45.   //send message to server
    
46.   memset(snd_buf, 0, 1024);
    
47.   strcpy(snd_buf, "message from client");
    
48.   printf("sizeof(snd_buf): %d\n", sizeof(snd_buf));
    
49.   sleep(2000);
    
50.   
    
51.   //send message to server
    
52.   for(i = 0; i < 4; i++)
    
53.   {
    
54.     write(connect_fd, snd_buf, sizeof(snd_buf));
    
55.   }
    
56.   close(connect_fd);
    
57.   return 0;
    
58. }

批注：如果想要实现多个客户端的登录，可以书写一个shell脚本，进行批处理连接。