tests/gio-test.c

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