nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GLib testing framework examples and tests
2 *
3 * Copyright (C) 2010 Collabora, Ltd.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Authors: Nicolas Dufresne <nicolas.dufresne@collabora.co.uk>
19 */
20  
21 #include "config.h"
22  
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26  
27 #include <gio/gio.h>
28 #include <glib.h>
29  
30 #include "glibintl.h"
31  
32 #ifdef G_OS_UNIX
33 #include "gio/gunixsocketaddress.h"
34 #endif
35  
36 static const gchar *info = NULL;
37 static GCancellable *cancellable = NULL;
38 static gint return_value = 0;
39  
40 static void G_GNUC_NORETURN
41 usage (void)
42 {
43 fprintf (stderr, "Usage: proxy [-s] (uri|host:port|ip:port|path|srv/protocol/domain)\n");
44 fprintf (stderr, " Use -t to enable threading.\n");
45 fprintf (stderr, " Use -s to do synchronous lookups.\n");
46 fprintf (stderr, " Use -c to cancel operation.\n");
47 fprintf (stderr, " Use -e to use enumerator.\n");
48 fprintf (stderr, " Use -inet to use GInetSocketAddress enumerator (ip:port).\n");
49 #ifdef G_OS_UNIX
50 fprintf (stderr, " Use -unix to use GUnixSocketAddress enumerator (path).\n");
51 #endif
52 fprintf (stderr, " Use -proxyaddr tp use GProxyAddress enumerator "
53 "(ip:port:protocol:dest_host:dest_port[:username[:password]]).\n");
54 fprintf (stderr, " Use -netaddr to use GNetworkAddress enumerator (host:port).\n");
55 fprintf (stderr, " Use -neturi to use GNetworkAddress enumerator (uri).\n");
56 fprintf (stderr, " Use -netsrv to use GNetworkService enumerator (srv/protocol/domain).\n");
57 fprintf (stderr, " Use -connect to create a connection using GSocketClient object (uri).\n");
58 exit (1);
59 }
60  
61 static void
62 print_and_free_error (GError *error)
63 {
64 fprintf (stderr, "Failed to obtain proxies: %s\n", error->message);
65 g_error_free (error);
66 return_value = 1;
67 }
68  
69 static void
70 print_proxies (const gchar *info, gchar **proxies)
71 {
72 printf ("Proxies for URI '%s' are:\n", info);
73  
74 if (proxies == NULL || proxies[0] == NULL)
75 printf ("\tnone\n");
76 else
77 for (; proxies[0]; proxies++)
78 printf ("\t%s\n", proxies[0]);
79 }
80  
81 static void
82 _proxy_lookup_cb (GObject *source_object,
83 GAsyncResult *result,
84 gpointer user_data)
85 {
86 GError *error = NULL;
87 gchar **proxies;
88 GMainLoop *loop = user_data;
89  
90 proxies = g_proxy_resolver_lookup_finish (G_PROXY_RESOLVER (source_object),
91 result,
92 &error);
93 if (error)
94 {
95 print_and_free_error (error);
96 }
97 else
98 {
99 print_proxies (info, proxies);
100 g_strfreev (proxies);
101 }
102  
103 g_main_loop_quit (loop);
104 }
105  
106 static void
107 use_resolver (gboolean synchronous)
108 {
109 GProxyResolver *resolver;
110  
111 resolver = g_proxy_resolver_get_default ();
112  
113 if (synchronous)
114 {
115 GError *error = NULL;
116 gchar **proxies;
117  
118 proxies = g_proxy_resolver_lookup (resolver, info, cancellable, &error);
119  
120 if (error)
121 print_and_free_error (error);
122 else
123 print_proxies (info, proxies);
124  
125 g_strfreev (proxies);
126 }
127 else
128 {
129 GMainLoop *loop = g_main_loop_new (NULL, FALSE);
130  
131 g_proxy_resolver_lookup_async (resolver,
132 info,
133 cancellable,
134 _proxy_lookup_cb,
135 loop);
136  
137 g_main_loop_run (loop);
138 g_main_loop_unref (loop);
139 }
140 }
141  
142 static void
143 print_proxy_address (GSocketAddress *sockaddr)
144 {
145 GProxyAddress *proxy = NULL;
146  
147 if (sockaddr == NULL)
148 {
149 printf ("\tdirect://\n");
150 return;
151 }
152  
153 if (G_IS_PROXY_ADDRESS (sockaddr))
154 {
155 proxy = G_PROXY_ADDRESS (sockaddr);
156 printf ("\t%s://", g_proxy_address_get_protocol(proxy));
157 }
158 else
159 {
160 printf ("\tdirect://");
161 }
162  
163 if (G_IS_INET_SOCKET_ADDRESS (sockaddr))
164 {
165 GInetAddress *inetaddr;
166 guint port;
167 gchar *addr;
168  
169 g_object_get (sockaddr,
170 "address", &inetaddr,
171 "port", &port,
172 NULL);
173  
174 addr = g_inet_address_to_string (inetaddr);
175  
176 printf ("%s:%u", addr, port);
177  
178 g_free (addr);
179 }
180  
181 if (proxy)
182 {
183 if (g_proxy_address_get_username(proxy))
184 printf (" (Username: %s Password: %s)",
185 g_proxy_address_get_username(proxy),
186 g_proxy_address_get_password(proxy));
187 printf (" (Hostname: %s, Port: %i)",
188 g_proxy_address_get_destination_hostname (proxy),
189 g_proxy_address_get_destination_port (proxy));
190 }
191  
192 printf ("\n");
193 }
194  
195 static void
196 _proxy_enumerate_cb (GObject *object,
197 GAsyncResult *result,
198 gpointer user_data)
199 {
200 GError *error = NULL;
201 GMainLoop *loop = user_data;
202 GSocketAddressEnumerator *enumerator = G_SOCKET_ADDRESS_ENUMERATOR (object);
203 GSocketAddress *sockaddr;
204  
205 sockaddr = g_socket_address_enumerator_next_finish (enumerator,
206 result,
207 &error);
208 if (sockaddr)
209 {
210 print_proxy_address (sockaddr);
211 g_socket_address_enumerator_next_async (enumerator,
212 cancellable,
213 _proxy_enumerate_cb,
214 loop);
215 g_object_unref (sockaddr);
216 }
217 else
218 {
219 if (error)
220 print_and_free_error (error);
221  
222 g_main_loop_quit (loop);
223 }
224 }
225  
226 static void
227 run_with_enumerator (gboolean synchronous, GSocketAddressEnumerator *enumerator)
228 {
229 GError *error = NULL;
230  
231 if (synchronous)
232 {
233 GSocketAddress *sockaddr;
234  
235 while ((sockaddr = g_socket_address_enumerator_next (enumerator,
236 cancellable,
237 &error)))
238 {
239 print_proxy_address (sockaddr);
240 g_object_unref (sockaddr);
241 }
242  
243 if (error)
244 print_and_free_error (error);
245 }
246 else
247 {
248 GMainLoop *loop = g_main_loop_new (NULL, FALSE);
249  
250 g_socket_address_enumerator_next_async (enumerator,
251 cancellable,
252 _proxy_enumerate_cb,
253 loop);
254 g_main_loop_run (loop);
255 g_main_loop_unref (loop);
256 }
257 }
258  
259 static void
260 use_enumerator (gboolean synchronous)
261 {
262 GSocketAddressEnumerator *enumerator;
263  
264 enumerator = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
265 "uri", info,
266 NULL);
267  
268 printf ("Proxies for URI '%s' are:\n", info);
269 run_with_enumerator (synchronous, enumerator);
270  
271 g_object_unref (enumerator);
272 }
273  
274 static void
275 use_inet_address (gboolean synchronous)
276 {
277 GSocketAddressEnumerator *enumerator;
278 GSocketAddress *sockaddr;
279 GInetAddress *addr = NULL;
280 guint port = 0;
281 gchar **ip_and_port;
282  
283 ip_and_port = g_strsplit (info, ":", 2);
284  
285 if (ip_and_port[0])
286 {
287 addr = g_inet_address_new_from_string (ip_and_port[0]);
288 if (ip_and_port [1])
289 port = strtoul (ip_and_port [1], NULL, 10);
290 }
291  
292 g_strfreev (ip_and_port);
293  
294 if (addr == NULL || port <= 0 || port >= 65535)
295 {
296 fprintf (stderr, "Bad 'ip:port' parameter '%s'\n", info);
297 if (addr)
298 g_object_unref (addr);
299 return_value = 1;
300 return;
301 }
302  
303 sockaddr = g_inet_socket_address_new (addr, port);
304 g_object_unref (addr);
305  
306 enumerator =
307 g_socket_connectable_proxy_enumerate (G_SOCKET_CONNECTABLE (sockaddr));
308 g_object_unref (sockaddr);
309  
310 printf ("Proxies for ip and port '%s' are:\n", info);
311 run_with_enumerator (synchronous, enumerator);
312  
313 g_object_unref (enumerator);
314 }
315  
316 #ifdef G_OS_UNIX
317 static void
318 use_unix_address (gboolean synchronous)
319 {
320 GSocketAddressEnumerator *enumerator;
321 GSocketAddress *sockaddr;
322  
323 sockaddr = g_unix_socket_address_new_with_type (info, -1, G_UNIX_SOCKET_ADDRESS_ABSTRACT);
324  
325 if (sockaddr == NULL)
326 {
327 fprintf (stderr, "Failed to create unix socket with name '%s'\n", info);
328 return_value = 1;
329 return;
330 }
331  
332 enumerator =
333 g_socket_connectable_proxy_enumerate (G_SOCKET_CONNECTABLE (sockaddr));
334 g_object_unref (sockaddr);
335  
336 printf ("Proxies for path '%s' are:\n", info);
337 run_with_enumerator (synchronous, enumerator);
338  
339 g_object_unref (enumerator);
340 }
341 #endif
342  
343 static void
344 use_proxy_address (gboolean synchronous)
345 {
346 GSocketAddressEnumerator *enumerator;
347 GSocketAddress *sockaddr;
348 GInetAddress *addr;
349 guint port = 0;
350 gchar *protocol;
351 gchar *dest_host;
352 guint dest_port;
353 gchar *username = NULL;
354 gchar *password = NULL;
355 gchar **split_info;
356  
357 split_info = g_strsplit (info, ":", 7);
358  
359 if (!split_info[0]
360 || !split_info[1]
361 || !split_info[2]
362 || !split_info[3]
363 || !split_info[4])
364 {
365 fprintf (stderr, "Bad 'ip:port:protocol:dest_host:dest_port' parameter '%s'\n", info);
366 return_value = 1;
367 return;
368 }
369  
370 addr = g_inet_address_new_from_string (split_info[0]);
371 port = strtoul (split_info [1], NULL, 10);
372 protocol = g_strdup (split_info[2]);
373 dest_host = g_strdup (split_info[3]);
374 dest_port = strtoul (split_info[4], NULL, 10);
375  
376 if (split_info[5])
377 {
378 username = g_strdup (split_info[5]);
379 if (split_info[6])
380 password = g_strdup (split_info[6]);
381 }
382  
383 g_strfreev (split_info);
384  
385 sockaddr = g_proxy_address_new (addr, port,
386 protocol, dest_host, dest_port,
387 username, password);
388  
389 g_object_unref (addr);
390 g_free (protocol);
391 g_free (dest_host);
392 g_free (username);
393 g_free (password);
394  
395 enumerator =
396 g_socket_connectable_proxy_enumerate (G_SOCKET_CONNECTABLE (sockaddr));
397 g_object_unref (sockaddr);
398  
399 printf ("Proxies for ip and port '%s' are:\n", info);
400 run_with_enumerator (synchronous, enumerator);
401  
402 g_object_unref (enumerator);
403 }
404  
405 static void
406 use_network_address (gboolean synchronous)
407 {
408 GError *error = NULL;
409 GSocketAddressEnumerator *enumerator;
410 GSocketConnectable *connectable;
411  
412 connectable = g_network_address_parse (info, -1, &error);
413  
414 if (error)
415 {
416 print_and_free_error (error);
417 return;
418 }
419  
420 enumerator = g_socket_connectable_proxy_enumerate (connectable);
421 g_object_unref (connectable);
422  
423 printf ("Proxies for hostname and port '%s' are:\n", info);
424 run_with_enumerator (synchronous, enumerator);
425  
426 g_object_unref (enumerator);
427 }
428  
429 static void
430 use_network_uri (gboolean synchronous)
431 {
432 GError *error = NULL;
433 GSocketAddressEnumerator *enumerator;
434 GSocketConnectable *connectable;
435  
436 connectable = g_network_address_parse_uri (info, 0, &error);
437  
438 if (error)
439 {
440 print_and_free_error (error);
441 return;
442 }
443  
444 enumerator = g_socket_connectable_proxy_enumerate (connectable);
445 g_object_unref (connectable);
446  
447 printf ("Proxies for URI '%s' are:\n", info);
448 run_with_enumerator (synchronous, enumerator);
449  
450 g_object_unref (enumerator);
451 }
452  
453 static void
454 use_network_service (gboolean synchronous)
455 {
456 GSocketAddressEnumerator *enumerator;
457 GSocketConnectable *connectable = NULL;
458 gchar **split;
459  
460 split = g_strsplit (info, "/", 3);
461  
462 if (split[0] && split[1] && split[2])
463 connectable = g_network_service_new (split[0], split[1], split[2]);
464  
465 g_strfreev (split);
466  
467 if (connectable == NULL)
468 {
469 fprintf (stderr, "Bad 'srv/protocol/domain' parameter '%s'\n", info);
470 return_value = 1;
471 return;
472 }
473  
474 enumerator = g_socket_connectable_proxy_enumerate (connectable);
475 g_object_unref (connectable);
476  
477 printf ("Proxies for hostname and port '%s' are:\n", info);
478 run_with_enumerator (synchronous, enumerator);
479  
480 g_object_unref (enumerator);
481 }
482  
483 static void
484 _socket_connect_cb (GObject *object,
485 GAsyncResult *result,
486 gpointer user_data)
487 {
488 GError *error = NULL;
489 GMainLoop *loop = user_data;
490 GSocketClient *client = G_SOCKET_CLIENT (object);
491 GSocketConnection *connection;
492  
493 connection = g_socket_client_connect_to_uri_finish (client,
494 result,
495 &error);
496 if (connection)
497 {
498 GSocketAddress *proxy_addr;
499 proxy_addr = g_socket_connection_get_remote_address (connection, NULL);
500 print_proxy_address (proxy_addr);
501 }
502 else
503 {
504 print_and_free_error (error);
505 }
506  
507 g_main_loop_quit (loop);
508 }
509  
510 static void
511 use_socket_client (gboolean synchronous)
512 {
513 GError *error = NULL;
514 GSocketClient *client;
515  
516 client = g_socket_client_new ();
517  
518 printf ("Proxies for URI '%s' are:\n", info);
519  
520 if (synchronous)
521 {
522 GSocketConnection *connection;
523 GSocketAddress *proxy_addr;
524  
525 connection = g_socket_client_connect_to_uri (client,
526 info,
527 0,
528 cancellable,
529 &error);
530  
531 if (connection)
532 {
533 proxy_addr = g_socket_connection_get_remote_address (connection, NULL);
534 print_proxy_address (proxy_addr);
535 }
536 else
537 {
538 print_and_free_error (error);
539 }
540 }
541 else
542 {
543 GMainLoop *loop = g_main_loop_new (NULL, FALSE);
544  
545 g_socket_client_connect_to_uri_async (client,
546 info,
547 0,
548 cancellable,
549 _socket_connect_cb,
550 loop);
551  
552 g_main_loop_run (loop);
553 g_main_loop_unref (loop);
554 }
555  
556 g_object_unref (client);
557 }
558  
559 typedef enum
560 {
561 USE_RESOLVER,
562 USE_ENUMERATOR,
563 #ifdef G_OS_UNIX
564 USE_UNIX_SOCKET_ADDRESS,
565 #endif
566 USE_INET_SOCKET_ADDRESS,
567 USE_PROXY_ADDRESS,
568 USE_NETWORK_ADDRESS,
569 USE_NETWORK_URI,
570 USE_NETWORK_SERVICE,
571 USE_SOCKET_CLIENT,
572 } ProxyTestType;
573  
574 gint
575 main (gint argc, gchar **argv)
576 {
577 gboolean synchronous = FALSE;
578 gboolean cancel = FALSE;
579 ProxyTestType type = USE_RESOLVER;
580  
581 while (argc >= 2 && argv[1][0] == '-')
582 {
583 if (!strcmp (argv[1], "-s"))
584 synchronous = TRUE;
585 else if (!strcmp (argv[1], "-c"))
586 cancel = TRUE;
587 else if (!strcmp (argv[1], "-e"))
588 type = USE_ENUMERATOR;
589 else if (!strcmp (argv[1], "-inet"))
590 type = USE_INET_SOCKET_ADDRESS;
591 #ifdef G_OS_UNIX
592 else if (!strcmp (argv[1], "-unix"))
593 type = USE_UNIX_SOCKET_ADDRESS;
594 #endif
595 else if (!strcmp (argv[1], "-proxyaddr"))
596 type = USE_PROXY_ADDRESS;
597 else if (!strcmp (argv[1], "-netaddr"))
598 type = USE_NETWORK_ADDRESS;
599 else if (!strcmp (argv[1], "-neturi"))
600 type = USE_NETWORK_URI;
601 else if (!strcmp (argv[1], "-netsrv"))
602 type = USE_NETWORK_SERVICE;
603 else if (!strcmp (argv[1], "-connect"))
604 type = USE_SOCKET_CLIENT;
605 else
606 usage ();
607  
608 argv++;
609 argc--;
610 }
611  
612 if (argc != 2)
613 usage ();
614  
615 /* Save URI for asynchronous callback */
616 info = argv[1];
617  
618 if (cancel)
619 {
620 cancellable = g_cancellable_new ();
621 g_cancellable_cancel (cancellable);
622 }
623  
624 switch (type)
625 {
626 case USE_RESOLVER:
627 use_resolver (synchronous);
628 break;
629 case USE_ENUMERATOR:
630 use_enumerator (synchronous);
631 break;
632 case USE_INET_SOCKET_ADDRESS:
633 use_inet_address (synchronous);
634 break;
635 #ifdef G_OS_UNIX
636 case USE_UNIX_SOCKET_ADDRESS:
637 use_unix_address (synchronous);
638 break;
639 #endif
640 case USE_PROXY_ADDRESS:
641 use_proxy_address (synchronous);
642 break;
643 case USE_NETWORK_ADDRESS:
644 use_network_address (synchronous);
645 break;
646 case USE_NETWORK_URI:
647 use_network_uri (synchronous);
648 break;
649 case USE_NETWORK_SERVICE:
650 use_network_service (synchronous);
651 break;
652 case USE_SOCKET_CLIENT:
653 use_socket_client (synchronous);
654 break;
655 }
656  
657 return return_value;
658 }