glib库实现socket功能的问题

lz_fine

我用glib库实现了一个socket的接收程序，流程是这样的，先是初始化一个socket：sfd然后对sfd进行listen，然后得到sfd的iochannel，接着对它的输入进行监视，用g_io_add_watch,回调函数是callback，如果有客户端进行了连接，会调用callback，callback里会根据传递进来的iochannel得到sfd，然后进行accept，再对新得到的connfd的输入进行监视，回调函数是callback1，同时增加一个超时回调函数，回调函数是timeoutCallback，如果这个客户端有数据传入，那么会调用callback1，这个函数中会用g_io_channel_read_chars读取传入的数据，如果接受到eof，或者超时，那么会关闭连接，回收资源，对应的函数是freeTerminalData，这个函数内会用g_source_remove remove接受source和超时source，close连接的fd，g_io_channel_shutdown shutdown对应的iochannel，最后再对iochannel进行g_io_channel_unref

现在有几个疑问：
1.这样的流程对不对，是否有什么问题
2.我看到一篇文章上说不能在回调函数中shutdown iochannel，请问这样说对不对，为什么
原文网址：http://blog.chinaunix.net/space.php?uid=796091&do=blog&id=2035372
3.g_io_channel_read_chars这个如果每次读一个字节，需要读的次数太多了，如果读很多字节的话没有读到这么多字节前这个函数会阻塞不会返回，请问怎么做才能像recv那样一次把所有缓冲区的数据都读出来
4.还有glib库上有一个结构体GIOFuncs，包含有很多函数指针，如io_read,io_write,io_seek,io_close,io_create_watch等等，请问这个应该怎么用，在什么地方用，同样对应于timeout，有一个结构体GSourceFuncs包含有很多函数指针，如prepare，check，dispatch，finalize这个应该怎么用呢？
5.g_io_channel_ref和g_io_channel_unref应该怎么用

1. #include <glib.h>
   
2. 
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. #include <sys/types.h>
   
7. #include <sys/socket.h>
   
8. #include <netdb.h>
   
9. #include <unistd.h>
   
10. 
    
11. #define SERVER_PORT        "30001"
    
12. #define BUF_SIZE        1024
    
13. #define TIME_OUT_SECONDS        (5)
    
14. 
    
15. GMainLoop * loop;
    
16. 
    
17. struct channelfd_s
    
18. {
    
19.         GIOChannel * channel;
    
20.         gint fd;
    
21.         gint timeout;
    
22.         guint recvSourceId;
    
23.         guint timeoutSourceId;
    
24. };
    
25. 
    
26. //struct channelfd_s globalchannelfd[10];
    
27. 
    
28. /*
    
29.         终端需要关闭时释放相关的资源
    
30. */
    
31. static void freeTerminalData(struct channelfd_s * newTerminal)
    
32. {
    
33.         printf("%s:%p\n", __func__, newTerminal);
    
34.         g_source_remove(newTerminal->recvSourceId);
    
35.         g_source_remove(newTerminal->timeoutSourceId);
    
36.         close(newTerminal->fd);
    
37.         g_io_channel_shutdown(newTerminal->channel, TRUE, NULL);
    
38.         g_io_channel_unref(newTerminal->channel);
    
39. }
    
40. 
    
41. /*
    
42.         用来收发数据的socket fd的超时回调函数
    
43.         超时后关闭连接
    
44. */
    
45. gboolean timeoutCallback(gpointer data)
    
46. {
    
47.         struct channelfd_s * newTerminal;
    
48.         
    
49.         newTerminal = (struct channelfd_s *)data;
    
50.         
    
51.         newTerminal->timeout++;
    
52.         printf("timeout:%d\n", newTerminal->timeout);
    
53.         if(newTerminal->timeout > TIME_OUT_SECONDS){
    
54.                 freeTerminalData(newTerminal);
    
55.                 return FALSE;
    
56.         }
    
57.    
    
58.         return TRUE;
    
59. }
    
60. 
    
61. /*
    
62.         用来收发数据的socket fd的接收回调函数
    
63. */
    
64. gboolean callback1(GIOChannel * source, GIOCondition condition, gpointer data)
    
65. {
    
66.     int retInt;
    
67.     char buf[BUF_SIZE];
    
68.         gsize bytes_read;
    
69.         GIOStatus gIoStatus;
    
70.         gsize offset = 0;
    
71.         gboolean breakFlag = FALSE;
    
72.         struct channelfd_s * newTerminal;
    
73.         
    
74.         newTerminal = (struct channelfd_s *)data;
    
75.    
    
76.     while(1)
    
77.     {
    
78.                 gIoStatus = g_io_channel_read_chars(source, buf + offset, 1, &bytes_read, NULL);
    
79.                 offset++;
    
80.                 switch (gIoStatus)
    
81.                 {
    
82.                         case G_IO_STATUS_ERROR:
    
83.                                 //出错，关闭连接
    
84.                                 printf("recv error\n");
    
85.                                 breakFlag = TRUE;
    
86.                                 freeTerminalData(newTerminal);
    
87.                                 break;
    
88.                         case G_IO_STATUS_NORMAL:
    
89.                                 //正常，存储到数据区
    
90.                                 printf("recv normal\n");
    
91.                                 if(buf[offset - 1] == '\0'){
    
92.                                         printf("recv:%s\n", buf);
    
93.                                         breakFlag = TRUE;
    
94.                                 }
    
95.                                 break;
    
96.                         case G_IO_STATUS_EOF:
    
97.                                 //结束，关闭连接
    
98.                                 printf("recv eof\n");
    
99.                                 freeTerminalData(newTerminal);
    
100.                                 breakFlag = TRUE;
     
101.                                 break;
     
102.                         case G_IO_STATUS_AGAIN:
     
103.                                 //重试，什么都不做
     
104.                                 printf("recv again\n");
     
105.                                 break;
     
106.                         default:
     
107.                                 break;
     
108.                 }
     
109.                 if(breakFlag == TRUE)
     
110.                         break;
     
111.         }
     
112.         printf("exit func:%s\n", __func__);
     
113.         return TRUE;
     
114. }
     
115. 
     
116. /*
     
117.         sfd的回调函数
     
118.         如果该函数被调用，说明有新的socket接入
     
119. */
     
120. gboolean callback(GIOChannel * source, GIOCondition condition, gpointer data)
     
121. {
     
122.         struct sockaddr addr;
     
123.         socklen_t addrlen = sizeof(struct sockaddr);
     
124.         struct channelfd_s * newTerminal;
     
125.         
     
126.         int listenfd;
     
127.         int connfd;
     
128.         
     
129.         //得到用来listen的fd
     
130.         listenfd = g_io_channel_unix_get_fd(source);
     
131.         
     
132.         //accept新的socket fd
     
133.         connfd = accept(listenfd, &addr, &addrlen);
     
134.         if(connfd <= 0){
     
135.                 perror("accept");
     
136.                 return FALSE;
     
137.         }
     
138.         printf("accept success:%d\n", connfd);
     
139.         
     
140.         //初始化一个channelfd结构
     
141.         newTerminal = g_new(struct channelfd_s, 1);
     
142.         //超时时间初始化为0
     
143.         newTerminal->timeout = 0;
     
144.         
     
145.         newTerminal->fd = connfd;
     
146.         newTerminal->channel = g_io_channel_unix_new(connfd);
     
147.         //设置iochannel的编码为NULL
     
148.         g_io_channel_set_encoding(newTerminal->channel, NULL, NULL);
     
149.         
     
150.         //增加对新的socket fd的监视
     
151.         newTerminal->recvSourceId = g_io_add_watch(newTerminal->channel, G_IO_IN, callback1, newTerminal);
     
152. 
     
153.         //增加对新的socket fd超时的监视
     
154.         newTerminal->timeoutSourceId = g_timeout_add_seconds(1, timeoutCallback, newTerminal);
     
155.         
     
156.         return TRUE;
     
157. }
     
158. 
     
159. int main(void)
     
160. {
     
161.     /*
     
162.         socket init
     
163.     */
     
164.     struct addrinfo hints;
     
165.     struct addrinfo *res, *rp;
     
166.     int retInt;
     
167.     int reuse;
     
168.         int sfd;
     
169.         int cfd;
     
170. 
     
171.     //get socket address information
     
172.     memset(&hints, 0, sizeof(hints));
     
173.     hints.ai_flags = AI_PASSIVE;
     
174.     hints.ai_family = AF_UNSPEC;
     
175.     hints.ai_socktype = SOCK_STREAM;
     
176.     hints.ai_protocol = 0;
     
177.     hints.ai_canonname = NULL;
     
178.     hints.ai_addr = NULL;
     
179.     hints.ai_next = NULL;
     
180. 
     
181.     retInt = getaddrinfo(NULL, SERVER_PORT, &hints, &res);
     
182.     if(retInt != 0)
     
183.     {
     
184.         printf("getaddrinfo:%s\n", gai_strerror(retInt));
     
185.         return -1;
     
186.     }
     
187. 
     
188.     //get socket & bind
     
189.     for (rp = res; rp != NULL; rp = rp->ai_next)
     
190.     {
     
191.             sfd = socket(rp->ai_family, rp->ai_socktype,
     
192.                        rp->ai_protocol);
     
193.         if (sfd < 0)
     
194.                 continue;
     
195. 
     
196.         //set socket fd reuse
     
197.         reuse = 1;
     
198.         retInt = setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse,
     
199.                                 sizeof(reuse));
     
200.         if (retInt < 0)
     
201.         {
     
202.             perror("setsockopt");
     
203.             return -2;
     
204.         }
     
205. 
     
206.         if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0)
     
207.                 break;
     
208.                
     
209.         close(sfd);
     
210.     }
     
211.     printf("sfd:%d\n", sfd);
     
212. 
     
213.     if (rp == NULL)
     
214.     {
     
215.             printf("could not bind\n");
     
216.             return -3;
     
217.     }
     
218. 
     
219.     printf("bind success\n");
     
220.     freeaddrinfo(res);
     
221. 
     
222.     //listen
     
223.     retInt = listen(sfd, 10);
     
224.     if (retInt < 0)
     
225.     {
     
226.             perror("listen");
     
227.             return -4;
     
228.     }
     
229.     printf("listen success\n");
     
230.    
     
231.         GIOChannel * channel;
     
232.         
     
233.         g_thread_init(NULL);
     
234.         
     
235.         //生产iochannel
     
236.         channel = g_io_channel_unix_new(sfd);
     
237.         //设置iochannel的编码为NULL
     
238.         g_io_channel_set_encoding(channel, NULL, NULL);
     
239.         //对sfd的iochannel监视
     
240.         g_io_add_watch(channel, G_IO_IN, callback, NULL);
     
241. 
     
242.         loop = g_main_loop_new(NULL, FALSE);
     
243.         g_main_loop_run(loop);
     
244.    
     
245.         return 0;
     
246. }

复制代码

lz_fine

没有人会吗？自己坐沙发

lz_fine

人工置顶一下，希望有人给个解答啊