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 2012 Red Hat, Inc.
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  
19 #include <string.h>
20  
21 #define GLIB_VERSION_MIN_REQUIRED GLIB_VERSION_2_34
22 #include <gio/gio.h>
23  
24 /* Overview:
25 *
26 * We have an echo server, two proxy servers, two GProxy
27 * implementations, and two GProxyResolver implementations.
28 *
29 * The echo server runs at @server.server_addr (on
30 * @server.server_port).
31 *
32 * The two proxy servers, A and B, run on @proxy_a.port and
33 * @proxy_b.port, with @proxy_a.uri and @proxy_b.uri pointing to them.
34 * The "negotiation" with the two proxies is just sending the single
35 * letter "a" or "b" and receiving it back in uppercase; the proxy
36 * then connects to @server_addr.
37 *
38 * Proxy A supports "alpha://" URIs, and does not support hostname
39 * resolution, and Proxy B supports "beta://" URIs, and does support
40 * hostname resolution (but it just ignores the hostname and always
41 * connects to @server_addr anyway).
42 *
43 * The default GProxyResolver (GTestProxyResolver) looks at its URI
44 * and returns [ "direct://" ] for "simple://" URIs, and [
45 * proxy_a.uri, proxy_b.uri ] for other URIs. The other GProxyResolver
46 * (GTestAltProxyResolver) always returns [ proxy_a.uri ].
47 */
48  
49 typedef struct {
50 gchar *proxy_command;
51 gchar *supported_protocol;
52  
53 GSocket *server;
54 GThread *thread;
55 GCancellable *cancellable;
56 gchar *uri;
57 gushort port;
58  
59 GSocket *client_sock, *server_sock;
60 GMainLoop *loop;
61  
62 GError *last_error;
63 } ProxyData;
64  
65 static ProxyData proxy_a, proxy_b;
66  
67 typedef struct {
68 GSocket *server;
69 GThread *server_thread;
70 GCancellable *cancellable;
71 GSocketAddress *server_addr;
72 gushort server_port;
73 } ServerData;
74  
75 static ServerData server;
76  
77 static gchar **last_proxies;
78  
79 static GSocketClient *client;
80  
81  
82 /**************************************/
83 /* Test GProxyResolver implementation */
84 /**************************************/
85  
86 typedef struct {
87 GObject parent_instance;
88 } GTestProxyResolver;
89  
90 typedef struct {
91 GObjectClass parent_class;
92 } GTestProxyResolverClass;
93  
94 static void g_test_proxy_resolver_iface_init (GProxyResolverInterface *iface);
95  
96 static GType _g_test_proxy_resolver_get_type (void);
97 #define g_test_proxy_resolver_get_type _g_test_proxy_resolver_get_type
98 G_DEFINE_TYPE_WITH_CODE (GTestProxyResolver, g_test_proxy_resolver, G_TYPE_OBJECT,
99 G_IMPLEMENT_INTERFACE (G_TYPE_PROXY_RESOLVER,
100 g_test_proxy_resolver_iface_init)
101 g_io_extension_point_implement (G_PROXY_RESOLVER_EXTENSION_POINT_NAME,
102 g_define_type_id,
103 "test",
104 0))
105  
106 static void
107 g_test_proxy_resolver_init (GTestProxyResolver *resolver)
108 {
109 }
110  
111 static gboolean
112 g_test_proxy_resolver_is_supported (GProxyResolver *resolver)
113 {
114 return TRUE;
115 }
116  
117 static gchar **
118 g_test_proxy_resolver_lookup (GProxyResolver *resolver,
119 const gchar *uri,
120 GCancellable *cancellable,
121 GError **error)
122 {
123 gchar **proxies;
124  
125 g_assert (last_proxies == NULL);
126  
127 if (g_cancellable_set_error_if_cancelled (cancellable, error))
128 return NULL;
129  
130 proxies = g_new (gchar *, 3);
131  
132 if (!strncmp (uri, "simple://", 4))
133 {
134 proxies[0] = g_strdup ("direct://");
135 proxies[1] = NULL;
136 }
137 else
138 {
139 /* Proxy A can only deal with "alpha://" URIs, not
140 * "beta://", but we always return both URIs
141 * anyway so we can test error handling when the first
142 * fails.
143 */
144 proxies[0] = g_strdup (proxy_a.uri);
145 proxies[1] = g_strdup (proxy_b.uri);
146 proxies[2] = NULL;
147 }
148  
149 last_proxies = g_strdupv (proxies);
150  
151 return proxies;
152 }
153  
154 static void
155 g_test_proxy_resolver_lookup_async (GProxyResolver *resolver,
156 const gchar *uri,
157 GCancellable *cancellable,
158 GAsyncReadyCallback callback,
159 gpointer user_data)
160 {
161 GError *error = NULL;
162 GTask *task;
163 gchar **proxies;
164  
165 proxies = g_proxy_resolver_lookup (resolver, uri, cancellable, &error);
166  
167 task = g_task_new (resolver, NULL, callback, user_data);
168 if (proxies == NULL)
169 g_task_return_error (task, error);
170 else
171 g_task_return_pointer (task, proxies, (GDestroyNotify) g_strfreev);
172  
173 g_object_unref (task);
174 }
175  
176 static gchar **
177 g_test_proxy_resolver_lookup_finish (GProxyResolver *resolver,
178 GAsyncResult *result,
179 GError **error)
180 {
181 return g_task_propagate_pointer (G_TASK (result), error);
182 }
183  
184 static void
185 g_test_proxy_resolver_class_init (GTestProxyResolverClass *resolver_class)
186 {
187 }
188  
189 static void
190 g_test_proxy_resolver_iface_init (GProxyResolverInterface *iface)
191 {
192 iface->is_supported = g_test_proxy_resolver_is_supported;
193 iface->lookup = g_test_proxy_resolver_lookup;
194 iface->lookup_async = g_test_proxy_resolver_lookup_async;
195 iface->lookup_finish = g_test_proxy_resolver_lookup_finish;
196 }
197  
198 /****************************/
199 /* Alternate GProxyResolver */
200 /****************************/
201  
202 typedef GTestProxyResolver GTestAltProxyResolver;
203 typedef GTestProxyResolverClass GTestAltProxyResolverClass;
204  
205 static void g_test_alt_proxy_resolver_iface_init (GProxyResolverInterface *iface);
206  
207 static GType _g_test_alt_proxy_resolver_get_type (void);
208 #define g_test_alt_proxy_resolver_get_type _g_test_alt_proxy_resolver_get_type
209 G_DEFINE_TYPE_WITH_CODE (GTestAltProxyResolver, g_test_alt_proxy_resolver, g_test_proxy_resolver_get_type (),
210 G_IMPLEMENT_INTERFACE (G_TYPE_PROXY_RESOLVER,
211 g_test_alt_proxy_resolver_iface_init);
212 )
213  
214 static void
215 g_test_alt_proxy_resolver_init (GTestProxyResolver *resolver)
216 {
217 }
218  
219 static gchar **
220 g_test_alt_proxy_resolver_lookup (GProxyResolver *resolver,
221 const gchar *uri,
222 GCancellable *cancellable,
223 GError **error)
224 {
225 gchar **proxies;
226  
227 proxies = g_new (gchar *, 2);
228  
229 proxies[0] = g_strdup (proxy_a.uri);
230 proxies[1] = NULL;
231  
232 last_proxies = g_strdupv (proxies);
233  
234 return proxies;
235 }
236  
237 static void
238 g_test_alt_proxy_resolver_class_init (GTestProxyResolverClass *resolver_class)
239 {
240 }
241  
242 static void
243 g_test_alt_proxy_resolver_iface_init (GProxyResolverInterface *iface)
244 {
245 iface->lookup = g_test_alt_proxy_resolver_lookup;
246 }
247  
248  
249 /****************************************/
250 /* Test proxy implementation base class */
251 /****************************************/
252  
253 typedef struct {
254 GObject parent;
255  
256 ProxyData *proxy_data;
257 } GProxyBase;
258  
259 typedef struct {
260 GObjectClass parent_class;
261 } GProxyBaseClass;
262  
263 static GType _g_proxy_base_get_type (void);
264 #define g_proxy_base_get_type _g_proxy_base_get_type
265 G_DEFINE_ABSTRACT_TYPE (GProxyBase, g_proxy_base, G_TYPE_OBJECT)
266  
267 static void
268 g_proxy_base_init (GProxyBase *proxy)
269 {
270 }
271  
272 static GIOStream *
273 g_proxy_base_connect (GProxy *proxy,
274 GIOStream *io_stream,
275 GProxyAddress *proxy_address,
276 GCancellable *cancellable,
277 GError **error)
278 {
279 ProxyData *data = ((GProxyBase *) proxy)->proxy_data;
280 const gchar *protocol;
281 GOutputStream *ostream;
282 GInputStream *istream;
283 gchar response;
284  
285 g_assert_no_error (data->last_error);
286  
287 protocol = g_proxy_address_get_destination_protocol (proxy_address);
288 if (strcmp (protocol, data->supported_protocol) != 0)
289 {
290 g_set_error_literal (&data->last_error,
291 G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
292 "Unsupported protocol");
293 goto fail;
294 }
295  
296 ostream = g_io_stream_get_output_stream (io_stream);
297 if (g_output_stream_write (ostream, data->proxy_command, 1, cancellable,
298 &data->last_error) != 1)
299 goto fail;
300  
301 istream = g_io_stream_get_input_stream (io_stream);
302 if (g_input_stream_read (istream, &response, 1, cancellable,
303 &data->last_error) != 1)
304 goto fail;
305  
306 if (response != g_ascii_toupper (*data->proxy_command))
307 {
308 g_set_error_literal (&data->last_error,
309 G_IO_ERROR, G_IO_ERROR_FAILED,
310 "Failed");
311 goto fail;
312 }
313  
314 return g_object_ref (io_stream);
315  
316 fail:
317 g_propagate_error (error, g_error_copy (data->last_error));
318 return NULL;
319 }
320  
321 static void
322 g_proxy_base_connect_async (GProxy *proxy,
323 GIOStream *io_stream,
324 GProxyAddress *proxy_address,
325 GCancellable *cancellable,
326 GAsyncReadyCallback callback,
327 gpointer user_data)
328 {
329 GError *error = NULL;
330 GTask *task;
331 GIOStream *proxy_io_stream;
332  
333 task = g_task_new (proxy, NULL, callback, user_data);
334  
335 proxy_io_stream = g_proxy_connect (proxy, io_stream, proxy_address,
336 cancellable, &error);
337 if (proxy_io_stream)
338 g_task_return_pointer (task, proxy_io_stream, g_object_unref);
339 else
340 g_task_return_error (task, error);
341 g_object_unref (task);
342 }
343  
344 static GIOStream *
345 g_proxy_base_connect_finish (GProxy *proxy,
346 GAsyncResult *result,
347 GError **error)
348 {
349 return g_task_propagate_pointer (G_TASK (result), error);
350 }
351  
352 static void
353 g_proxy_base_class_init (GProxyBaseClass *class)
354 {
355 }
356  
357  
358 /********************************************/
359 /* Test proxy implementation #1 ("Proxy A") */
360 /********************************************/
361  
362 typedef GProxyBase GProxyA;
363 typedef GProxyBaseClass GProxyAClass;
364  
365 static void g_proxy_a_iface_init (GProxyInterface *proxy_iface);
366  
367 static GType _g_proxy_a_get_type (void);
368 #define g_proxy_a_get_type _g_proxy_a_get_type
369 G_DEFINE_TYPE_WITH_CODE (GProxyA, g_proxy_a, g_proxy_base_get_type (),
370 G_IMPLEMENT_INTERFACE (G_TYPE_PROXY,
371 g_proxy_a_iface_init)
372 g_io_extension_point_implement (G_PROXY_EXTENSION_POINT_NAME,
373 g_define_type_id,
374 "proxy-a",
375 0))
376  
377 static void
378 g_proxy_a_init (GProxyA *proxy)
379 {
380 ((GProxyBase *) proxy)->proxy_data = &proxy_a;
381 }
382  
383 static gboolean
384 g_proxy_a_supports_hostname (GProxy *proxy)
385 {
386 return FALSE;
387 }
388  
389 static void
390 g_proxy_a_class_init (GProxyAClass *class)
391 {
392 }
393  
394 static void
395 g_proxy_a_iface_init (GProxyInterface *proxy_iface)
396 {
397 proxy_iface->connect = g_proxy_base_connect;
398 proxy_iface->connect_async = g_proxy_base_connect_async;
399 proxy_iface->connect_finish = g_proxy_base_connect_finish;
400 proxy_iface->supports_hostname = g_proxy_a_supports_hostname;
401 }
402  
403 /********************************************/
404 /* Test proxy implementation #2 ("Proxy B") */
405 /********************************************/
406  
407 typedef GProxyBase GProxyB;
408 typedef GProxyBaseClass GProxyBClass;
409  
410 static void g_proxy_b_iface_init (GProxyInterface *proxy_iface);
411  
412 static GType _g_proxy_b_get_type (void);
413 #define g_proxy_b_get_type _g_proxy_b_get_type
414 G_DEFINE_TYPE_WITH_CODE (GProxyB, g_proxy_b, g_proxy_base_get_type (),
415 G_IMPLEMENT_INTERFACE (G_TYPE_PROXY,
416 g_proxy_b_iface_init)
417 g_io_extension_point_implement (G_PROXY_EXTENSION_POINT_NAME,
418 g_define_type_id,
419 "proxy-b",
420 0))
421  
422 static void
423 g_proxy_b_init (GProxyB *proxy)
424 {
425 ((GProxyBase *) proxy)->proxy_data = &proxy_b;
426 }
427  
428 static gboolean
429 g_proxy_b_supports_hostname (GProxy *proxy)
430 {
431 return TRUE;
432 }
433  
434 static void
435 g_proxy_b_class_init (GProxyBClass *class)
436 {
437 }
438  
439 static void
440 g_proxy_b_iface_init (GProxyInterface *proxy_iface)
441 {
442 proxy_iface->connect = g_proxy_base_connect;
443 proxy_iface->connect_async = g_proxy_base_connect_async;
444 proxy_iface->connect_finish = g_proxy_base_connect_finish;
445 proxy_iface->supports_hostname = g_proxy_b_supports_hostname;
446 }
447  
448  
449 /***********************************/
450 /* The proxy server implementation */
451 /***********************************/
452  
453 static gboolean
454 proxy_bytes (GSocket *socket,
455 GIOCondition condition,
456 gpointer user_data)
457 {
458 ProxyData *proxy = user_data;
459 gssize nread, nwrote, total;
460 gchar buffer[8];
461 GSocket *out_socket;
462 GError *error = NULL;
463  
464 nread = g_socket_receive_with_blocking (socket, buffer, sizeof (buffer),
465 TRUE, NULL, &error);
466 if (nread == -1)
467 {
468 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
469 return FALSE;
470 }
471 else
472 g_assert_no_error (error);
473  
474 if (nread == 0)
475 {
476 g_main_loop_quit (proxy->loop);
477 return FALSE;
478 }
479  
480 if (socket == proxy->client_sock)
481 out_socket = proxy->server_sock;
482 else
483 out_socket = proxy->client_sock;
484  
485 for (total = 0; total < nread; total += nwrote)
486 {
487 nwrote = g_socket_send_with_blocking (out_socket,
488 buffer + total, nread - total,
489 TRUE, NULL, &error);
490 g_assert_no_error (error);
491 }
492  
493 return TRUE;
494 }
495  
496 static gpointer
497 proxy_thread (gpointer user_data)
498 {
499 ProxyData *proxy = user_data;
500 GError *error = NULL;
501 gssize nread, nwrote;
502 gchar command[2] = { 0, 0 };
503 GMainContext *context;
504 GSource *read_source, *write_source;
505  
506 context = g_main_context_new ();
507 proxy->loop = g_main_loop_new (context, FALSE);
508  
509 while (TRUE)
510 {
511 proxy->client_sock = g_socket_accept (proxy->server, proxy->cancellable, &error);
512 if (!proxy->client_sock)
513 {
514 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
515 g_error_free (error);
516 break;
517 }
518 else
519 g_assert_no_error (error);
520  
521 nread = g_socket_receive (proxy->client_sock, command, 1, NULL, &error);
522 g_assert_no_error (error);
523  
524 if (nread == 0)
525 {
526 g_clear_object (&proxy->client_sock);
527 continue;
528 }
529  
530 g_assert_cmpint (nread, ==, 1);
531 g_assert_cmpstr (command, ==, proxy->proxy_command);
532  
533 *command = g_ascii_toupper (*command);
534 nwrote = g_socket_send (proxy->client_sock, command, 1, NULL, &error);
535 g_assert_no_error (error);
536 g_assert_cmpint (nwrote, ==, 1);
537  
538 proxy->server_sock = g_socket_new (G_SOCKET_FAMILY_IPV4,
539 G_SOCKET_TYPE_STREAM,
540 G_SOCKET_PROTOCOL_DEFAULT,
541 &error);
542 g_assert_no_error (error);
543 g_socket_connect (proxy->server_sock, server.server_addr, NULL, &error);
544 g_assert_no_error (error);
545  
546 read_source = g_socket_create_source (proxy->client_sock, G_IO_IN, NULL);
547 g_source_set_callback (read_source, (GSourceFunc)proxy_bytes, proxy, NULL);
548 g_source_attach (read_source, context);
549  
550 write_source = g_socket_create_source (proxy->server_sock, G_IO_IN, NULL);
551 g_source_set_callback (write_source, (GSourceFunc)proxy_bytes, proxy, NULL);
552 g_source_attach (write_source, context);
553  
554 g_main_loop_run (proxy->loop);
555  
556 g_socket_close (proxy->client_sock, &error);
557 g_assert_no_error (error);
558 g_clear_object (&proxy->client_sock);
559  
560 g_socket_close (proxy->server_sock, &error);
561 g_assert_no_error (error);
562 g_clear_object (&proxy->server_sock);
563  
564 g_source_destroy (read_source);
565 g_source_unref (read_source);
566 g_source_destroy (write_source);
567 g_source_unref (write_source);
568 }
569  
570 g_main_loop_unref (proxy->loop);
571 g_main_context_unref (context);
572  
573 g_object_unref (proxy->server);
574 g_object_unref (proxy->cancellable);
575  
576 g_free (proxy->proxy_command);
577 g_free (proxy->supported_protocol);
578 g_free (proxy->uri);
579  
580 return NULL;
581 }
582  
583 static void
584 create_proxy (ProxyData *proxy,
585 gchar proxy_protocol,
586 const gchar *destination_protocol,
587 GCancellable *cancellable)
588 {
589 GError *error = NULL;
590 GSocketAddress *addr;
591 GInetAddress *iaddr;
592  
593 proxy->proxy_command = g_strdup_printf ("%c", proxy_protocol);
594 proxy->supported_protocol = g_strdup (destination_protocol);
595 proxy->cancellable = g_object_ref (cancellable);
596  
597 proxy->server = g_socket_new (G_SOCKET_FAMILY_IPV4,
598 G_SOCKET_TYPE_STREAM,
599 G_SOCKET_PROTOCOL_DEFAULT,
600 &error);
601 g_assert_no_error (error);
602  
603 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
604 addr = g_inet_socket_address_new (iaddr, 0);
605 g_object_unref (iaddr);
606  
607 g_socket_bind (proxy->server, addr, TRUE, &error);
608 g_assert_no_error (error);
609 g_object_unref (addr);
610  
611 addr = g_socket_get_local_address (proxy->server, &error);
612 proxy->port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
613 proxy->uri = g_strdup_printf ("proxy-%c://127.0.0.1:%u",
614 g_ascii_tolower (proxy_protocol),
615 proxy->port);
616 g_object_unref (addr);
617  
618 g_socket_listen (proxy->server, &error);
619 g_assert_no_error (error);
620  
621 proxy->thread = g_thread_new ("proxy", proxy_thread, proxy);
622 }
623  
624  
625  
626 /**************************/
627 /* The actual echo server */
628 /**************************/
629  
630 static gpointer
631 echo_server_thread (gpointer user_data)
632 {
633 ServerData *data = user_data;
634 GSocket *sock;
635 GError *error = NULL;
636 gssize nread, nwrote;
637 gchar buf[128];
638  
639 while (TRUE)
640 {
641 sock = g_socket_accept (data->server, data->cancellable, &error);
642 if (!sock)
643 {
644 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
645 g_error_free (error);
646 break;
647 }
648 else
649 g_assert_no_error (error);
650  
651 while (TRUE)
652 {
653 nread = g_socket_receive (sock, buf, sizeof (buf), NULL, &error);
654 g_assert_no_error (error);
655 g_assert_cmpint (nread, >=, 0);
656  
657 if (nread == 0)
658 break;
659  
660 nwrote = g_socket_send (sock, buf, nread, NULL, &error);
661 g_assert_no_error (error);
662 g_assert_cmpint (nwrote, ==, nread);
663 }
664  
665 g_socket_close (sock, &error);
666 g_assert_no_error (error);
667 g_object_unref (sock);
668 }
669  
670 g_object_unref (data->server);
671 g_object_unref (data->server_addr);
672 g_object_unref (data->cancellable);
673  
674 return NULL;
675 }
676  
677 static void
678 create_server (ServerData *data, GCancellable *cancellable)
679 {
680 GError *error = NULL;
681 GSocketAddress *addr;
682 GInetAddress *iaddr;
683  
684 data->cancellable = g_object_ref (cancellable);
685  
686 data->server = g_socket_new (G_SOCKET_FAMILY_IPV4,
687 G_SOCKET_TYPE_STREAM,
688 G_SOCKET_PROTOCOL_DEFAULT,
689 &error);
690 g_assert_no_error (error);
691  
692 g_socket_set_blocking (data->server, TRUE);
693 iaddr = g_inet_address_new_loopback (G_SOCKET_FAMILY_IPV4);
694 addr = g_inet_socket_address_new (iaddr, 0);
695 g_object_unref (iaddr);
696  
697 g_socket_bind (data->server, addr, TRUE, &error);
698 g_assert_no_error (error);
699 g_object_unref (addr);
700  
701 data->server_addr = g_socket_get_local_address (data->server, &error);
702 g_assert_no_error (error);
703  
704 data->server_port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (data->server_addr));
705  
706 g_socket_listen (data->server, &error);
707 g_assert_no_error (error);
708  
709 data->server_thread = g_thread_new ("server", echo_server_thread, data);
710 }
711  
712  
713 /******************************************************************/
714 /* Now a GResolver implementation, so the can't-resolve test will */
715 /* pass even if you have an evil DNS-faking ISP. */
716 /******************************************************************/
717  
718 typedef GResolver GFakeResolver;
719 typedef GResolverClass GFakeResolverClass;
720  
721 static GType g_fake_resolver_get_type (void);
722 G_DEFINE_TYPE (GFakeResolver, g_fake_resolver, G_TYPE_RESOLVER)
723  
724 static void
725 g_fake_resolver_init (GFakeResolver *gtr)
726 {
727 }
728  
729 static GList *
730 g_fake_resolver_lookup_by_name (GResolver *resolver,
731 const gchar *hostname,
732 GCancellable *cancellable,
733 GError **error)
734 {
735 if (!strcmp (hostname, "example.com"))
736 return g_list_prepend (NULL, g_inet_address_new_from_string ("127.0.0.1"));
737 else
738 {
739 /* Anything else is expected to fail. */
740 g_set_error (error,
741 G_RESOLVER_ERROR,
742 G_RESOLVER_ERROR_NOT_FOUND,
743 "Not found");
744 return NULL;
745 }
746 }
747  
748 static void
749 g_fake_resolver_lookup_by_name_async (GResolver *resolver,
750 const gchar *hostname,
751 GCancellable *cancellable,
752 GAsyncReadyCallback callback,
753 gpointer user_data)
754 {
755 GTask *task;
756  
757 task = g_task_new (resolver, cancellable, callback, user_data);
758  
759 if (!strcmp (hostname, "example.com"))
760 {
761 GList *result;
762  
763 result = g_list_prepend (NULL, g_inet_address_new_from_string ("127.0.0.1"));
764 g_task_return_pointer (task, result, (GDestroyNotify) g_resolver_free_addresses);
765 }
766 else
767 {
768 g_task_return_new_error (task,
769 G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND,
770 "Not found");
771 }
772 g_object_unref (task);
773 }
774  
775 static GList *
776 g_fake_resolver_lookup_by_name_finish (GResolver *resolver,
777 GAsyncResult *result,
778 GError **error)
779 {
780 return g_task_propagate_pointer (G_TASK (result), error);
781 }
782  
783 static void
784 g_fake_resolver_class_init (GFakeResolverClass *fake_class)
785 {
786 GResolverClass *resolver_class = G_RESOLVER_CLASS (fake_class);
787  
788 resolver_class->lookup_by_name = g_fake_resolver_lookup_by_name;
789 resolver_class->lookup_by_name_async = g_fake_resolver_lookup_by_name_async;
790 resolver_class->lookup_by_name_finish = g_fake_resolver_lookup_by_name_finish;
791 }
792  
793  
794  
795 /****************************************/
796 /* We made it! Now for the actual test! */
797 /****************************************/
798  
799 static void
800 setup_test (gpointer fixture,
801 gconstpointer user_data)
802 {
803 }
804  
805 static void
806 teardown_test (gpointer fixture,
807 gconstpointer user_data)
808 {
809 if (last_proxies)
810 {
811 g_strfreev (last_proxies);
812 last_proxies = NULL;
813 }
814 g_clear_error (&proxy_a.last_error);
815 g_clear_error (&proxy_b.last_error);
816 }
817  
818  
819 static const gchar *testbuf = "0123456789abcdef";
820  
821 static void
822 do_echo_test (GSocketConnection *conn)
823 {
824 GIOStream *iostream = G_IO_STREAM (conn);
825 GInputStream *istream = g_io_stream_get_input_stream (iostream);
826 GOutputStream *ostream = g_io_stream_get_output_stream (iostream);
827 gssize nread, total;
828 gsize nwrote;
829 gchar buf[128];
830 GError *error = NULL;
831  
832 g_output_stream_write_all (ostream, testbuf, strlen (testbuf),
833 &nwrote, NULL, &error);
834 g_assert_no_error (error);
835 g_assert_cmpint (nwrote, ==, strlen (testbuf));
836  
837 for (total = 0; total < nwrote; total += nread)
838 {
839 nread = g_input_stream_read (istream,
840 buf + total, sizeof (buf) - total,
841 NULL, &error);
842 g_assert_no_error (error);
843 g_assert_cmpint (nread, >, 0);
844 }
845  
846 buf[total] = '\0';
847 g_assert_cmpstr (buf, ==, testbuf);
848 }
849  
850 static void
851 async_got_conn (GObject *source,
852 GAsyncResult *result,
853 gpointer user_data)
854 {
855 GSocketConnection **conn = user_data;
856 GError *error = NULL;
857  
858 *conn = g_socket_client_connect_finish (G_SOCKET_CLIENT (source),
859 result, &error);
860 g_assert_no_error (error);
861 }
862  
863 static void
864 async_got_error (GObject *source,
865 GAsyncResult *result,
866 gpointer user_data)
867 {
868 GError **error = user_data;
869  
870 g_assert (error != NULL && *error == NULL);
871 g_socket_client_connect_finish (G_SOCKET_CLIENT (source),
872 result, error);
873 g_assert (*error != NULL);
874 }
875  
876  
877 static void
878 assert_direct (GSocketConnection *conn)
879 {
880 GSocketAddress *addr;
881 GError *error = NULL;
882  
883 g_assert_cmpint (g_strv_length (last_proxies), ==, 1);
884 g_assert_cmpstr (last_proxies[0], ==, "direct://");
885 g_assert_no_error (proxy_a.last_error);
886 g_assert_no_error (proxy_b.last_error);
887  
888 addr = g_socket_connection_get_remote_address (conn, &error);
889 g_assert_no_error (error);
890 g_assert (addr != NULL && !G_IS_PROXY_ADDRESS (addr));
891 g_object_unref (addr);
892  
893 addr = g_socket_connection_get_local_address (conn, &error);
894 g_assert_no_error (error);
895 g_object_unref (addr);
896  
897 g_assert (g_socket_connection_is_connected (conn));
898 }
899  
900 static void
901 test_direct_sync (gpointer fixture,
902 gconstpointer user_data)
903 {
904 GSocketConnection *conn;
905 gchar *uri;
906 GError *error = NULL;
907  
908 /* The simple:// URI should not require any proxy. */
909  
910 uri = g_strdup_printf ("simple://127.0.0.1:%u", server.server_port);
911 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
912 g_free (uri);
913 g_assert_no_error (error);
914  
915 assert_direct (conn);
916 do_echo_test (conn);
917 g_object_unref (conn);
918 }
919  
920 static void
921 test_direct_async (gpointer fixture,
922 gconstpointer user_data)
923 {
924 GSocketConnection *conn;
925 gchar *uri;
926  
927 /* The simple:// URI should not require any proxy. */
928 uri = g_strdup_printf ("simple://127.0.0.1:%u", server.server_port);
929 conn = NULL;
930 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
931 async_got_conn, &conn);
932 g_free (uri);
933 while (conn == NULL)
934 g_main_context_iteration (NULL, TRUE);
935  
936 assert_direct (conn);
937 do_echo_test (conn);
938 g_object_unref (conn);
939 }
940  
941 static void
942 assert_single (GSocketConnection *conn)
943 {
944 GSocketAddress *addr;
945 const gchar *proxy_uri;
946 gushort proxy_port;
947 GError *error = NULL;
948  
949 g_assert_cmpint (g_strv_length (last_proxies), ==, 2);
950 g_assert_cmpstr (last_proxies[0], ==, proxy_a.uri);
951 g_assert_cmpstr (last_proxies[1], ==, proxy_b.uri);
952 g_assert_no_error (proxy_a.last_error);
953 g_assert_no_error (proxy_b.last_error);
954  
955 addr = g_socket_connection_get_remote_address (conn, &error);
956 g_assert_no_error (error);
957 g_assert (G_IS_PROXY_ADDRESS (addr));
958 proxy_uri = g_proxy_address_get_uri (G_PROXY_ADDRESS (addr));
959 g_assert_cmpstr (proxy_uri, ==, proxy_a.uri);
960 proxy_port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
961 g_assert_cmpint (proxy_port, ==, proxy_a.port);
962  
963 g_object_unref (addr);
964 }
965  
966 static void
967 test_single_sync (gpointer fixture,
968 gconstpointer user_data)
969 {
970 GSocketConnection *conn;
971 GError *error = NULL;
972 gchar *uri;
973  
974 /* The alpha:// URI should be proxied via Proxy A */
975 uri = g_strdup_printf ("alpha://127.0.0.1:%u", server.server_port);
976 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
977 g_free (uri);
978 g_assert_no_error (error);
979  
980 assert_single (conn);
981  
982 do_echo_test (conn);
983 g_object_unref (conn);
984 }
985  
986 static void
987 test_single_async (gpointer fixture,
988 gconstpointer user_data)
989 {
990 GSocketConnection *conn;
991 gchar *uri;
992  
993 /* The alpha:// URI should be proxied via Proxy A */
994 uri = g_strdup_printf ("alpha://127.0.0.1:%u", server.server_port);
995 conn = NULL;
996 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
997 async_got_conn, &conn);
998 g_free (uri);
999 while (conn == NULL)
1000 g_main_context_iteration (NULL, TRUE);
1001  
1002 assert_single (conn);
1003 do_echo_test (conn);
1004 g_object_unref (conn);
1005 }
1006  
1007 static void
1008 assert_multiple (GSocketConnection *conn)
1009 {
1010 GSocketAddress *addr;
1011 const gchar *proxy_uri;
1012 gushort proxy_port;
1013 GError *error = NULL;
1014  
1015 g_assert_cmpint (g_strv_length (last_proxies), ==, 2);
1016 g_assert_cmpstr (last_proxies[0], ==, proxy_a.uri);
1017 g_assert_cmpstr (last_proxies[1], ==, proxy_b.uri);
1018 g_assert_error (proxy_a.last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1019 g_assert_no_error (proxy_b.last_error);
1020  
1021 addr = g_socket_connection_get_remote_address (conn, &error);
1022 g_assert_no_error (error);
1023 g_assert (G_IS_PROXY_ADDRESS (addr));
1024 proxy_uri = g_proxy_address_get_uri (G_PROXY_ADDRESS (addr));
1025 g_assert_cmpstr (proxy_uri, ==, proxy_b.uri);
1026 proxy_port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
1027 g_assert_cmpint (proxy_port, ==, proxy_b.port);
1028  
1029 g_object_unref (addr);
1030 }
1031  
1032 static void
1033 test_multiple_sync (gpointer fixture,
1034 gconstpointer user_data)
1035 {
1036 GSocketConnection *conn;
1037 GError *error = NULL;
1038 gchar *uri;
1039  
1040 /* The beta:// URI should be proxied via Proxy B, after failing
1041 * via Proxy A.
1042 */
1043 uri = g_strdup_printf ("beta://127.0.0.1:%u", server.server_port);
1044 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1045 g_free (uri);
1046 g_assert_no_error (error);
1047  
1048 assert_multiple (conn);
1049 do_echo_test (conn);
1050 g_object_unref (conn);
1051 }
1052  
1053 static void
1054 test_multiple_async (gpointer fixture,
1055 gconstpointer user_data)
1056 {
1057 GSocketConnection *conn;
1058 gchar *uri;
1059  
1060 /* The beta:// URI should be proxied via Proxy B, after failing
1061 * via Proxy A.
1062 */
1063 uri = g_strdup_printf ("beta://127.0.0.1:%u", server.server_port);
1064 conn = NULL;
1065 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1066 async_got_conn, &conn);
1067 g_free (uri);
1068 while (conn == NULL)
1069 g_main_context_iteration (NULL, TRUE);
1070  
1071 assert_multiple (conn);
1072 do_echo_test (conn);
1073 g_object_unref (conn);
1074 }
1075  
1076 static void
1077 test_dns (gpointer fixture,
1078 gconstpointer user_data)
1079 {
1080 GSocketConnection *conn;
1081 GError *error = NULL;
1082 gchar *uri;
1083  
1084 /* The simple:// and alpha:// URIs should fail with a DNS error,
1085 * but the beta:// URI should succeed, because we pass it to
1086 * Proxy B without trying to resolve it first
1087 */
1088  
1089 /* simple */
1090 uri = g_strdup_printf ("simple://no-such-host.xx:%u", server.server_port);
1091 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1092 g_assert_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND);
1093 g_clear_error (&error);
1094  
1095 g_assert_no_error (proxy_a.last_error);
1096 g_assert_no_error (proxy_b.last_error);
1097 teardown_test (NULL, NULL);
1098  
1099 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1100 async_got_error, &error);
1101 while (error == NULL)
1102 g_main_context_iteration (NULL, TRUE);
1103 g_assert_error (error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND);
1104 g_clear_error (&error);
1105 g_free (uri);
1106  
1107 g_assert_no_error (proxy_a.last_error);
1108 g_assert_no_error (proxy_b.last_error);
1109 teardown_test (NULL, NULL);
1110  
1111 /* alpha */
1112 uri = g_strdup_printf ("alpha://no-such-host.xx:%u", server.server_port);
1113 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1114 /* Since Proxy A fails, @client will try Proxy B too, which won't
1115 * load an alpha:// URI.
1116 */
1117 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1118 g_clear_error (&error);
1119  
1120 g_assert_no_error (proxy_a.last_error);
1121 g_assert_error (proxy_b.last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1122 teardown_test (NULL, NULL);
1123  
1124 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1125 async_got_error, &error);
1126 while (error == NULL)
1127 g_main_context_iteration (NULL, TRUE);
1128 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1129 g_clear_error (&error);
1130 g_free (uri);
1131  
1132 g_assert_no_error (proxy_a.last_error);
1133 g_assert_error (proxy_b.last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1134 teardown_test (NULL, NULL);
1135  
1136 /* beta */
1137 uri = g_strdup_printf ("beta://no-such-host.xx:%u", server.server_port);
1138 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1139 g_assert_no_error (error);
1140  
1141 g_assert_no_error (proxy_a.last_error);
1142 g_assert_no_error (proxy_b.last_error);
1143  
1144 do_echo_test (conn);
1145 g_clear_object (&conn);
1146 teardown_test (NULL, NULL);
1147  
1148 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1149 async_got_conn, &conn);
1150 while (conn == NULL)
1151 g_main_context_iteration (NULL, TRUE);
1152 g_free (uri);
1153  
1154 g_assert_no_error (proxy_a.last_error);
1155 g_assert_no_error (proxy_b.last_error);
1156  
1157 do_echo_test (conn);
1158 g_clear_object (&conn);
1159 teardown_test (NULL, NULL);
1160 }
1161  
1162 static void
1163 assert_override (GSocketConnection *conn)
1164 {
1165 g_assert_cmpint (g_strv_length (last_proxies), ==, 1);
1166 g_assert_cmpstr (last_proxies[0], ==, proxy_a.uri);
1167  
1168 if (conn)
1169 g_assert_no_error (proxy_a.last_error);
1170 else
1171 g_assert_error (proxy_a.last_error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1172 }
1173  
1174 static void
1175 test_override (gpointer fixture,
1176 gconstpointer user_data)
1177 {
1178 GProxyResolver *alt_resolver;
1179 GSocketConnection *conn;
1180 GError *error = NULL;
1181 gchar *uri;
1182  
1183 g_assert (g_socket_client_get_proxy_resolver (client) == g_proxy_resolver_get_default ());
1184 alt_resolver = g_object_new (g_test_alt_proxy_resolver_get_type (), NULL);
1185 g_socket_client_set_proxy_resolver (client, alt_resolver);
1186 g_assert (g_socket_client_get_proxy_resolver (client) == alt_resolver);
1187  
1188 /* Alt proxy resolver always returns Proxy A, so alpha:// should
1189 * succeed, and simple:// and beta:// should fail.
1190 */
1191  
1192 /* simple */
1193 uri = g_strdup_printf ("simple://127.0.0.1:%u", server.server_port);
1194 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1195 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1196 g_clear_error (&error);
1197 assert_override (conn);
1198 teardown_test (NULL, NULL);
1199  
1200 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1201 async_got_error, &error);
1202 while (error == NULL)
1203 g_main_context_iteration (NULL, TRUE);
1204 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1205 g_clear_error (&error);
1206 assert_override (conn);
1207 g_free (uri);
1208 teardown_test (NULL, NULL);
1209  
1210 /* alpha */
1211 uri = g_strdup_printf ("alpha://127.0.0.1:%u", server.server_port);
1212 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1213 g_assert_no_error (error);
1214 assert_override (conn);
1215 do_echo_test (conn);
1216 g_clear_object (&conn);
1217 teardown_test (NULL, NULL);
1218  
1219 conn = NULL;
1220 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1221 async_got_conn, &conn);
1222 while (conn == NULL)
1223 g_main_context_iteration (NULL, TRUE);
1224 assert_override (conn);
1225 do_echo_test (conn);
1226 g_clear_object (&conn);
1227 g_free (uri);
1228 teardown_test (NULL, NULL);
1229  
1230 /* beta */
1231 uri = g_strdup_printf ("beta://127.0.0.1:%u", server.server_port);
1232 conn = g_socket_client_connect_to_uri (client, uri, 0, NULL, &error);
1233 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1234 g_clear_error (&error);
1235 assert_override (conn);
1236 teardown_test (NULL, NULL);
1237  
1238 g_socket_client_connect_to_uri_async (client, uri, 0, NULL,
1239 async_got_error, &error);
1240 while (error == NULL)
1241 g_main_context_iteration (NULL, TRUE);
1242 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED);
1243 g_clear_error (&error);
1244 assert_override (conn);
1245 g_free (uri);
1246 teardown_test (NULL, NULL);
1247  
1248 g_assert (g_socket_client_get_proxy_resolver (client) == alt_resolver);
1249 g_socket_client_set_proxy_resolver (client, NULL);
1250 g_assert (g_socket_client_get_proxy_resolver (client) == g_proxy_resolver_get_default ());
1251 g_object_unref (alt_resolver);
1252 }
1253  
1254 static void
1255 assert_destination_port (GSocketAddressEnumerator *etor,
1256 guint16 port)
1257 {
1258 GSocketAddress *addr;
1259 GProxyAddress *paddr;
1260 GError *error = NULL;
1261  
1262 while ((addr = g_socket_address_enumerator_next (etor, NULL, &error)))
1263 {
1264 g_assert_no_error (error);
1265  
1266 g_assert (G_IS_PROXY_ADDRESS (addr));
1267 paddr = G_PROXY_ADDRESS (addr);
1268 g_assert_cmpint (g_proxy_address_get_destination_port (paddr), ==, port);
1269 g_object_unref (addr);
1270 }
1271 g_assert_no_error (error);
1272 }
1273  
1274 static void
1275 test_proxy_enumerator_ports (void)
1276 {
1277 GSocketAddressEnumerator *etor;
1278  
1279 etor = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
1280 "uri", "http://example.com/",
1281 NULL);
1282 assert_destination_port (etor, 0);
1283 g_object_unref (etor);
1284  
1285 /* Have to call this to clear last_proxies so the next call to
1286 * g_test_proxy_resolver_lookup() won't assert.
1287 */
1288 teardown_test (NULL, NULL);
1289  
1290 etor = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
1291 "uri", "http://example.com:8080/",
1292 NULL);
1293 assert_destination_port (etor, 8080);
1294 g_object_unref (etor);
1295  
1296 teardown_test (NULL, NULL);
1297  
1298 etor = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
1299 "uri", "http://example.com/",
1300 "default-port", 80,
1301 NULL);
1302 assert_destination_port (etor, 80);
1303 g_object_unref (etor);
1304  
1305 teardown_test (NULL, NULL);
1306  
1307 etor = g_object_new (G_TYPE_PROXY_ADDRESS_ENUMERATOR,
1308 "uri", "http://example.com:8080/",
1309 "default-port", 80,
1310 NULL);
1311 assert_destination_port (etor, 8080);
1312 g_object_unref (etor);
1313  
1314 teardown_test (NULL, NULL);
1315 }
1316  
1317 int
1318 main (int argc,
1319 char *argv[])
1320 {
1321 GResolver *fake_resolver;
1322 GCancellable *cancellable;
1323 gint result;
1324  
1325 g_test_init (&argc, &argv, NULL);
1326  
1327 /* Register stuff. The dummy g_proxy_get_default_for_protocol() call
1328 * is to force _g_io_modules_ensure_extension_points_registered() to
1329 * get called, so we can then register a proxy resolver extension
1330 * point.
1331 */
1332 g_proxy_get_default_for_protocol ("foo");
1333 g_test_proxy_resolver_get_type ();
1334 g_proxy_a_get_type ();
1335 g_proxy_b_get_type ();
1336 g_setenv ("GIO_USE_PROXY_RESOLVER", "test", TRUE);
1337  
1338 fake_resolver = g_object_new (g_fake_resolver_get_type (), NULL);
1339 g_resolver_set_default (fake_resolver);
1340  
1341 cancellable = g_cancellable_new ();
1342 create_server (&server, cancellable);
1343 create_proxy (&proxy_a, 'a', "alpha", cancellable);
1344 create_proxy (&proxy_b, 'b', "beta", cancellable);
1345  
1346 client = g_socket_client_new ();
1347 g_assert_cmpint (g_socket_client_get_enable_proxy (client), ==, TRUE);
1348  
1349 g_test_add_vtable ("/proxy/direct_sync", 0, NULL, setup_test, test_direct_sync, teardown_test);
1350 g_test_add_vtable ("/proxy/direct_async", 0, NULL, setup_test, test_direct_async, teardown_test);
1351 g_test_add_vtable ("/proxy/single_sync", 0, NULL, setup_test, test_single_sync, teardown_test);
1352 g_test_add_vtable ("/proxy/single_async", 0, NULL, setup_test, test_single_async, teardown_test);
1353 g_test_add_vtable ("/proxy/multiple_sync", 0, NULL, setup_test, test_multiple_sync, teardown_test);
1354 g_test_add_vtable ("/proxy/multiple_async", 0, NULL, setup_test, test_multiple_async, teardown_test);
1355 g_test_add_vtable ("/proxy/dns", 0, NULL, setup_test, test_dns, teardown_test);
1356 g_test_add_vtable ("/proxy/override", 0, NULL, setup_test, test_override, teardown_test);
1357 g_test_add_func ("/proxy/enumerator-ports", test_proxy_enumerator_ports);
1358  
1359 result = g_test_run();
1360  
1361 g_object_unref (client);
1362  
1363 g_cancellable_cancel (cancellable);
1364 g_thread_join (proxy_a.thread);
1365 g_thread_join (proxy_b.thread);
1366 g_thread_join (server.server_thread);
1367  
1368 g_object_unref (cancellable);
1369  
1370 return result;
1371 }
1372