nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 2000 Tor Lillqvist
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 */
17  
18 /* A test program for the main loop and IO channel code.
19 * Just run it. Optional parameter is number of sub-processes.
20 */
21  
22 #undef G_DISABLE_ASSERT
23 #undef G_LOG_DOMAIN
24  
25 #include "config.h"
26  
27 #include <glib.h>
28  
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <math.h>
32 #include <time.h>
33  
34 #ifdef G_OS_WIN32
35 #include <io.h>
36 #include <fcntl.h>
37 #include <process.h>
38 #define STRICT
39 #include <windows.h>
40 #define pipe(fds) _pipe(fds, 4096, _O_BINARY)
41 #endif
42  
43 #ifdef G_OS_UNIX
44 #include <unistd.h>
45 #endif
46  
47 static int nrunning;
48 static GMainLoop *main_loop;
49  
50 #define BUFSIZE 5000 /* Larger than the circular buffer in
51 * giowin32.c on purpose.
52 */
53  
54 static int nkiddies;
55  
56 static struct {
57 int fd;
58 int seq;
59 } *seqtab;
60  
61 static GIOError
62 read_all (int fd,
63 GIOChannel *channel,
64 char *buffer,
65 guint nbytes,
66 guint *bytes_read)
67 {
68 guint left = nbytes;
69 gsize nb;
70 GIOError error = G_IO_ERROR_NONE;
71 char *bufp = buffer;
72  
73 /* g_io_channel_read() doesn't necessarily return all the
74 * data we want at once.
75 */
76 *bytes_read = 0;
77 while (left)
78 {
79 error = g_io_channel_read (channel, bufp, left, &nb);
80  
81 if (error != G_IO_ERROR_NONE)
82 {
83 g_print ("gio-test: ...from %d: %d\n", fd, error);
84 if (error == G_IO_ERROR_AGAIN)
85 continue;
86 break;
87 }
88 if (nb == 0)
89 return error;
90 left -= nb;
91 bufp += nb;
92 *bytes_read += nb;
93 }
94 return error;
95 }
96  
97 static void
98 shutdown_source (gpointer data)
99 {
100 if (g_source_remove (*(guint *) data))
101 {
102 nrunning--;
103 if (nrunning == 0)
104 g_main_loop_quit (main_loop);
105 }
106 }
107  
108 static gboolean
109 recv_message (GIOChannel *channel,
110 GIOCondition cond,
111 gpointer data)
112 {
113 gint fd = g_io_channel_unix_get_fd (channel);
114 gboolean retval = TRUE;
115  
116 #ifdef VERBOSE
117 g_print ("gio-test: ...from %d:%s%s%s%s\n", fd,
118 (cond & G_IO_ERR) ? " ERR" : "",
119 (cond & G_IO_HUP) ? " HUP" : "",
120 (cond & G_IO_IN) ? " IN" : "",
121 (cond & G_IO_PRI) ? " PRI" : "");
122 #endif
123  
124 if (cond & (G_IO_ERR | G_IO_HUP))
125 {
126 shutdown_source (data);
127 retval = FALSE;
128 }
129  
130 if (cond & G_IO_IN)
131 {
132 char buf[BUFSIZE];
133 guint nbytes;
134 guint nb;
135 int i, j, seq;
136 GIOError error;
137  
138 error = read_all (fd, channel, (gchar *) &seq, sizeof (seq), &nb);
139 if (error == G_IO_ERROR_NONE)
140 {
141 if (nb == 0)
142 {
143 #ifdef VERBOSE
144 g_print ("gio-test: ...from %d: EOF\n", fd);
145 #endif
146 shutdown_source (data);
147 return FALSE;
148 }
149  
150 g_assert (nb == sizeof (nbytes));
151  
152 for (i = 0; i < nkiddies; i++)
153 if (seqtab[i].fd == fd)
154 {
155 g_assert_cmpint (seq, ==, seqtab[i].seq);
156 seqtab[i].seq++;
157 break;
158 }
159  
160 error = read_all (fd, channel, (gchar *) &nbytes, sizeof (nbytes), &nb);
161 }
162  
163 if (error != G_IO_ERROR_NONE)
164 return FALSE;
165  
166 if (nb == 0)
167 {
168 #ifdef VERBOSE
169 g_print ("gio-test: ...from %d: EOF\n", fd);
170 #endif
171 shutdown_source (data);
172 return FALSE;
173 }
174  
175 g_assert (nb == sizeof (nbytes));
176  
177 g_assert_cmpint (nbytes, <, BUFSIZE);
178 g_assert (nbytes >= 0 && nbytes < BUFSIZE);
179 #ifdef VERBOSE
180 g_print ("gio-test: ...from %d: %d bytes\n", fd, nbytes);
181 #endif
182 if (nbytes > 0)
183 {
184 error = read_all (fd, channel, buf, nbytes, &nb);
185  
186 if (error != G_IO_ERROR_NONE)
187 return FALSE;
188  
189 if (nb == 0)
190 {
191 #ifdef VERBOSE
192 g_print ("gio-test: ...from %d: EOF\n", fd);
193 #endif
194 shutdown_source (data);
195 return FALSE;
196 }
197  
198 for (j = 0; j < nbytes; j++)
199 g_assert (buf[j] == ' ' + ((nbytes + j) % 95));
200 #ifdef VERBOSE
201 g_print ("gio-test: ...from %d: OK\n", fd);
202 #endif
203 }
204 }
205 return retval;
206 }
207  
208 #ifdef G_OS_WIN32
209  
210 static gboolean
211 recv_windows_message (GIOChannel *channel,
212 GIOCondition cond,
213 gpointer data)
214 {
215 GIOError error;
216 MSG msg;
217 guint nb;
218  
219 while (1)
220 {
221 error = g_io_channel_read (channel, &msg, sizeof (MSG), &nb);
222  
223 if (error != G_IO_ERROR_NONE)
224 {
225 g_print ("gio-test: ...reading Windows message: G_IO_ERROR_%s\n",
226 (error == G_IO_ERROR_AGAIN ? "AGAIN" :
227 (error == G_IO_ERROR_INVAL ? "INVAL" :
228 (error == G_IO_ERROR_UNKNOWN ? "UNKNOWN" : "???"))));
229 if (error == G_IO_ERROR_AGAIN)
230 continue;
231 }
232 break;
233 }
234  
235 g_print ("gio-test: ...Windows message for %#x: %d,%d,%d\n",
236 msg.hwnd, msg.message, msg.wParam, msg.lParam);
237  
238 return TRUE;
239 }
240  
241 LRESULT CALLBACK
242 window_procedure (HWND hwnd,
243 UINT message,
244 WPARAM wparam,
245 LPARAM lparam)
246 {
247 g_print ("gio-test: window_procedure for %#x: %d,%d,%d\n",
248 hwnd, message, wparam, lparam);
249 return DefWindowProc (hwnd, message, wparam, lparam);
250 }
251  
252 #endif
253  
254 int
255 main (int argc,
256 char **argv)
257 {
258 if (argc < 3)
259 {
260 /* Parent */
261  
262 GIOChannel *my_read_channel;
263 gchar *cmdline;
264 guint *id;
265 int i;
266 #ifdef G_OS_WIN32
267 GTimeVal start, end;
268 GPollFD pollfd;
269 int pollresult;
270 ATOM klass;
271 static WNDCLASS wcl;
272 HWND hwnd;
273 GIOChannel *windows_messages_channel;
274 #endif
275  
276 nkiddies = (argc == 1 ? 1 : atoi(argv[1]));
277 seqtab = g_malloc (nkiddies * 2 * sizeof (int));
278  
279 #ifdef G_OS_WIN32
280 wcl.style = 0;
281 wcl.lpfnWndProc = window_procedure;
282 wcl.cbClsExtra = 0;
283 wcl.cbWndExtra = 0;
284 wcl.hInstance = GetModuleHandle (NULL);
285 wcl.hIcon = NULL;
286 wcl.hCursor = NULL;
287 wcl.hbrBackground = NULL;
288 wcl.lpszMenuName = NULL;
289 wcl.lpszClassName = "gio-test";
290  
291 klass = RegisterClass (&wcl);
292  
293 if (!klass)
294 {
295 g_print ("gio-test: RegisterClass failed\n");
296 exit (1);
297 }
298  
299 hwnd = CreateWindow (MAKEINTATOM(klass), "gio-test", 0, 0, 0, 10, 10,
300 NULL, NULL, wcl.hInstance, NULL);
301 if (!hwnd)
302 {
303 g_print ("gio-test: CreateWindow failed\n");
304 exit (1);
305 }
306  
307 windows_messages_channel = g_io_channel_win32_new_messages ((guint)hwnd);
308 g_io_add_watch (windows_messages_channel, G_IO_IN, recv_windows_message, 0);
309 #endif
310  
311 for (i = 0; i < nkiddies; i++)
312 {
313 int pipe_to_sub[2], pipe_from_sub[2];
314  
315 if (pipe (pipe_to_sub) == -1 ||
316 pipe (pipe_from_sub) == -1)
317 perror ("pipe"), exit (1);
318  
319 seqtab[i].fd = pipe_from_sub[0];
320 seqtab[i].seq = 0;
321  
322 my_read_channel = g_io_channel_unix_new (pipe_from_sub[0]);
323  
324 id = g_new (guint, 1);
325 *id =
326 g_io_add_watch (my_read_channel,
327 G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP,
328 recv_message,
329 id);
330  
331 nrunning++;
332  
333 #ifdef G_OS_WIN32
334 cmdline = g_strdup_printf ("%d:%d:%d",
335 pipe_to_sub[0],
336 pipe_from_sub[1],
337 hwnd);
338 _spawnl (_P_NOWAIT, argv[0], argv[0], "--child", cmdline, NULL);
339 #else
340 cmdline = g_strdup_printf ("%s --child %d:%d &", argv[0],
341 pipe_to_sub[0], pipe_from_sub[1]);
342  
343 system (cmdline);
344 g_free (cmdline);
345 #endif
346 close (pipe_to_sub[0]);
347 close (pipe_from_sub [1]);
348  
349 #ifdef G_OS_WIN32
350 g_get_current_time (&start);
351 g_io_channel_win32_make_pollfd (my_read_channel, G_IO_IN, &pollfd);
352 pollresult = g_io_channel_win32_poll (&pollfd, 1, 100);
353 g_get_current_time (&end);
354 if (end.tv_usec < start.tv_usec)
355 end.tv_sec--, end.tv_usec += 1000000;
356 g_print ("gio-test: had to wait %ld.%03ld s, result:%d\n",
357 end.tv_sec - start.tv_sec,
358 (end.tv_usec - start.tv_usec) / 1000,
359 pollresult);
360 #endif
361 g_io_channel_unref (my_read_channel);
362 }
363  
364 main_loop = g_main_loop_new (NULL, FALSE);
365  
366 g_main_loop_run (main_loop);
367  
368 g_main_loop_unref (main_loop);
369 g_free (seqtab);
370 g_free (id);
371 }
372 else if (argc == 3)
373 {
374 /* Child */
375  
376 int readfd, writefd;
377 #ifdef G_OS_WIN32
378 HWND hwnd;
379 #endif
380 int i, j;
381 char buf[BUFSIZE];
382 int buflen;
383 GTimeVal tv;
384 int n;
385  
386 g_get_current_time (&tv);
387  
388 sscanf (argv[2], "%d:%d%n", &readfd, &writefd, &n);
389  
390 #ifdef G_OS_WIN32
391 sscanf (argv[2] + n, ":%d", &hwnd);
392 #endif
393  
394 srand (tv.tv_sec ^ (tv.tv_usec / 1000) ^ readfd ^ (writefd << 4));
395  
396 for (i = 0; i < 20 + rand() % 20; i++)
397 {
398 g_usleep (100 + (rand() % 10) * 5000);
399 buflen = rand() % BUFSIZE;
400 for (j = 0; j < buflen; j++)
401 buf[j] = ' ' + ((buflen + j) % 95);
402 #ifdef VERBOSE
403 g_print ("gio-test: child writing %d+%d bytes to %d\n",
404 (int)(sizeof(i) + sizeof(buflen)), buflen, writefd);
405 #endif
406 write (writefd, &i, sizeof (i));
407 write (writefd, &buflen, sizeof (buflen));
408 write (writefd, buf, buflen);
409  
410 #ifdef G_OS_WIN32
411 if (rand() % 100 < 5)
412 {
413 int msg = WM_USER + (rand() % 100);
414 WPARAM wparam = rand ();
415 LPARAM lparam = rand ();
416 g_print ("gio-test: child posting message %d,%d,%d to %#x\n",
417 msg, wparam, lparam, hwnd);
418 PostMessage (hwnd, msg, wparam, lparam);
419 }
420 #endif
421 }
422 #ifdef VERBOSE
423 g_print ("gio-test: child exiting, closing %d\n", writefd);
424 #endif
425 close (writefd);
426 }
427 else
428 g_print ("Huh?\n");
429  
430 return 0;
431 }
432