请教有关localsocket的问题 android与linux程序本地通信

sithui

一个android程序需要与linux的守护进程进行通信，打算采用localsocket的方式，试验中发现linux的收发程序可以正常工作，android程序之间也可以正常工作，但linux与android相互不能通信。
发现一个问题，localsocket中要用到一个文件来发送，android把通信文件放在/data/data/目录下，linux程序放在当前的运行目录下。
不知道还有没有别的问题，有谁做过的帮我讲讲怎么回事。

client

1. 
   
2. #include <stdio.h>
   
3. #include <stddef.h>
   
4. #include <sys/stat.h>
   
5. #include <sys/socket.h>
   
6. #include <sys/un.h>
   
7. #include <errno.h>
   
8. #include <string.h>
   
9. 
   
10. /* Create a client endpoint and connect to a server.   Returns fd if all OK, <0 on error. */
    
11. int unix_socket_conn(const char *servername)
    
12. {
    
13.     int fd;
    
14.     if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)    /* create a UNIX domain stream socket */
    
15.     {
    
16.         return(-1);
    
17.     }
    
18.     int len, rval;
    
19.     struct sockaddr_un un;         
    
20.     memset(&un, 0, sizeof(un));            /* fill socket address structure with our address */
    
21.     un.sun_family = AF_UNIX;
    
22.     sprintf(un.sun_path, "scktmp%05d", getpid());
    
23.     len = offsetof(struct sockaddr_un, sun_path) + strlen(un.sun_path);
    
24.     unlink(un.sun_path);               /* in case it already exists */
    
25.     if (bind(fd, (struct sockaddr *)&un, len) < 0)
    
26.     {
    
27.         rval=  -2;
    
28.     }
    
29.     else
    
30.     {
    
31.         /* fill socket address structure with server's address */
    
32.         memset(&un, 0, sizeof(un));
    
33.         un.sun_family = AF_UNIX;
    
34.         strcpy(un.sun_path, servername);
    
35.         len = offsetof(struct sockaddr_un, sun_path) + strlen(servername);
    
36.         if (connect(fd, (struct sockaddr *)&un, len) < 0)
    
37.         {
    
38.             rval= -4;
    
39.         }
    
40.         else
    
41.         {
    
42.             return (fd);
    
43.         }
    
44.     }
    
45.     int err;
    
46.     err = errno;
    
47.     close(fd);
    
48.     errno = err;
    
49.     return rval;          
    
50. }
    
51. 
    
52. void unix_socket_close(int fd)
    
53. {
    
54.     close(fd);     
    
55. }
    
56. 
    
57. 
    
58. int main(void)
    
59. {
    
60.     srand((int)time(0));
    
61.     int connfd;
    
62.     connfd = unix_socket_conn("foo.sock");
    
63.     if(connfd<0)
    
64.     {
    
65.         printf("Error[%d] when connecting...",errno);
    
66.         return 0;
    
67.     }
    
68.     printf("Begin to recv/send...\n");  
    
69.     int i,n,size;
    
70.     char rvbuf[4096];
    
71.     for(i=0;i<10;i++)
    
72.     {
    
73.         /*
    
74.         //=========接收=====================
    
75.         size = recv(connfd, rvbuf, 800, 0);   //MSG_DONTWAIT
    
76.         if(size>=0)
    
77.         {
    
78.         printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]);
    
79.         }
    
80.         if(size==-1)
    
81.         {
    
82.         printf("Error[%d] when recieving Data.\n",errno);         
    
83.         break;               
    
84.         }
    
85.         if(size < 800) break;
    
86.         */
    
87.         //=========发送======================
    
88.         memset(rvbuf,'a',2048);
    
89.         rvbuf[2047]='b';
    
90.         size = send(connfd, rvbuf, 2048, 0);
    
91.         if(size>=0)
    
92.         {
    
93.             printf("Data[%d] Sended:%c.\n",size,rvbuf[0]);
    
94.         }
    
95.         if(size==-1)
    
96.         {
    
97.             printf("Error[%d] when Sending Data:%s.\n",errno,strerror(errno));         
    
98.             break;               
    
99.         }
    
100.         sleep(1);
     
101.     }
     
102.     unix_socket_close(connfd);
     
103.     printf("Client exited.\n");   
     
104. }
     

复制代码

server

1. 
   
2. #include <stdio.h>
   
3. #include <sys/stat.h>
   
4. #include <sys/socket.h>
   
5. #include <sys/un.h>
   
6. #include <errno.h>
   
7. #include <stddef.h>
   
8. #include <string.h>
   
9. 
   
10. // the max connection number of the server
    
11. #define MAX_CONNECTION_NUMBER 5
    
12. 
    
13. /* * Create a server endpoint of a connection. * Returns fd if all OK, <0 on error. */
    
14. int unix_socket_listen(const char *servername)
    
15. {
    
16.     int fd;
    
17.     struct sockaddr_un un;
    
18.     if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
    
19.     {
    
20.         return(-1);
    
21.     }
    
22.     int len, rval;
    
23.     unlink(servername);               /* in case it already exists */
    
24.     memset(&un, 0, sizeof(un));
    
25.     un.sun_family = AF_UNIX;
    
26.     strcpy(un.sun_path, servername);
    
27.     len = offsetof(struct sockaddr_un, sun_path) + strlen(servername);
    
28.     /* bind the name to the descriptor */
    
29.     if (bind(fd, (struct sockaddr *)&un, len) < 0)
    
30.     {
    
31.         rval = -2;
    
32.     }
    
33.     else
    
34.     {
    
35.         if (listen(fd, MAX_CONNECTION_NUMBER) < 0)   
    
36.         {
    
37.             rval =  -3;
    
38.         }
    
39.         else
    
40.         {
    
41.             return fd;
    
42.         }
    
43.     }
    
44.     int err;
    
45.     err = errno;
    
46.     close(fd);
    
47.     errno = err;
    
48.     return rval;       
    
49. }
    
50. 
    
51. int unix_socket_accept(int listenfd, uid_t *uidptr)
    
52. {
    
53.     int clifd, len, rval;
    
54.     time_t staletime;
    
55.     struct sockaddr_un un;
    
56.     struct stat statbuf;
    
57.     len = sizeof(un);
    
58.     if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0)
    
59.     {
    
60.         return(-1);     
    
61.     }
    
62.     /* obtain the client's uid from its calling address */
    
63.     len -= offsetof(struct sockaddr_un, sun_path);  /* len of pathname */
    
64.     un.sun_path[len] = 0; /* null terminate */
    
65.     if (stat(un.sun_path, &statbuf) < 0)
    
66.     {
    
67.         rval = -2;
    
68.     }
    
69.     else
    
70.     {
    
71.         if (S_ISSOCK(statbuf.st_mode) )
    
72.         {
    
73.             if (uidptr != NULL) *uidptr = statbuf.st_uid;    /* return uid of caller */
    
74.             unlink(un.sun_path);       /* we're done with pathname now */
    
75.             return clifd;                 
    
76.         }
    
77.         else
    
78.         {
    
79.             rval = -3;     /* not a socket */
    
80.         }
    
81.     }
    
82.     int err;
    
83.     err = errno;
    
84.     close(clifd);
    
85.     errno = err;
    
86.     return(rval);
    
87. }
    
88. 
    
89. void unix_socket_close(int fd)
    
90. {
    
91.     close(fd);     
    
92. }
    
93. 
    
94. int main(void)
    
95. {
    
96.     int listenfd,connfd;
    
97.     listenfd = unix_socket_listen("foo.sock");
    
98.     if(listenfd<0)
    
99.     {
    
100.         printf("Error[%d] when listening...\n",errno);
     
101.         return 0;
     
102.     }
     
103.     printf("Finished listening...\n",errno);
     
104.     uid_t uid;
     
105.     connfd = unix_socket_accept(listenfd, &uid);
     
106.     unix_socket_close(listenfd);  
     
107.     if(connfd<0)
     
108.     {
     
109.         printf("Error[%d] when accepting...\n",errno);
     
110.         return 0;
     
111.     }  
     
112.     printf("Begin to recv/send...\n");  
     
113.     int i,n,size;
     
114.     char rvbuf[2048];
     
115.     for(i=0;i<200;i++)
     
116.     {
     
117.         //===========接收==============
     
118.         memset(rvbuf, 0x00, sizeof(rvbuf));
     
119.         size = recv(connfd, rvbuf, 2048, 0);   
     
120.         if(size>=0)
     
121.         {
     
122.             // rvbuf[size]='\0';
     
123.             printf("Recieved Data[%d]:%c...%c\n",size,rvbuf[0],rvbuf[size-1]);
     
124.         }
     
125.         if(size==-1)
     
126.         {
     
127.             printf("Error[%d] when recieving Data:%s.\n",errno,strerror(errno));         
     
128.             break;               
     
129.         }
     
130.         /*
     
131.         //===========发送==============
     
132.         memset(rvbuf, 'c', 2048);
     
133.         size = send(connfd, rvbuf, 2048, 0);
     
134.         if(size>=0)
     
135.         {
     
136.         printf("Data[%d] Sended.\n",size);
     
137.         }
     
138.         if(size==-1)
     
139.         {
     
140.         printf("Error[%d] when Sending Data.\n",errno);         
     
141.         break;               
     
142.         }
     
143.         */
     
144.         sleep(1);
     
145.     }
     
146.     unix_socket_close(connfd);
     
147.     printf("Server exited.\n");   
     
148. }
     

复制代码

windoze

啥叫“localsocket”？

sithui

回复 2# windoze
其实socket一样的。。。。

刚刚又试了，client和server之间如果不是在同一目录下也不能通信


   

windoze

回复 3# sithui

我的意思是说，Unix下没有一个叫“localsocket”的东西。
你用的要么是Unix Domain Socket，要么是TCP loopback socket，总之你要说清楚。
如果是TCP loopback socket，不通就是你程序写错了；如果是Unix domain socket，你要看看对应的文件是不是两边的进程都有正确的权限，否则肯定通不了。

sithui

回复 4# windoze


    看到我贴的代码没，foo.sock这个文件就是了，如果不是同一目录下执行server和client就会有问题。

windoze

回复 5# sithui

你的代码我没看，犯懒。
话说你有没有检查你这个foo.sock文件的权限？

sithui

回复 6# windoze
文件权限是

    srwxrwxrwx root     root
其实我是在嵌入式系统中做的，放到PC上也试了下，一样的问题。权限是用户权限，而不是root：
   srwxrwxr-x 1 carlton carlton

windoze

你改用TCP Loopback socket试试？

sithui

回复 8# windoze


    loopback肯定不会有问题的。
以前没有用过unix domain sock

windoze

回复 9# sithui

晕死，刚看了一眼你的程序，你难道没发现你没用绝对路径么？两个程序打开的不是同一个foo.sock当然连不上了……