1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD 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
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gio.SocketClient;
26 
27 private import gio.AsyncResultIF;
28 private import gio.Cancellable;
29 private import gio.IOStream;
30 private import gio.ProxyResolver;
31 private import gio.ProxyResolverIF;
32 private import gio.SocketAddress;
33 private import gio.SocketConnectable;
34 private import gio.SocketConnectableIF;
35 private import gio.SocketConnection;
36 private import glib.ConstructionException;
37 private import glib.ErrorG;
38 private import glib.GException;
39 private import glib.Str;
40 private import gobject.ObjectG;
41 private import gobject.Signals;
42 public  import gtkc.gdktypes;
43 private import gtkc.gio;
44 public  import gtkc.giotypes;
45 private import std.algorithm;
46 
47 
48 /**
49  * #GSocketClient is a lightweight high-level utility class for connecting to
50  * a network host using a connection oriented socket type.
51  * 
52  * You create a #GSocketClient object, set any options you want, and then
53  * call a sync or async connect operation, which returns a #GSocketConnection
54  * subclass on success.
55  * 
56  * The type of the #GSocketConnection object returned depends on the type of
57  * the underlying socket that is in use. For instance, for a TCP/IP connection
58  * it will be a #GTcpConnection.
59  * 
60  * As #GSocketClient is a lightweight object, you don't need to cache it. You
61  * can just create a new one any time you need one.
62  *
63  * Since: 2.22
64  */
65 public class SocketClient : ObjectG
66 {
67 	/** the main Gtk struct */
68 	protected GSocketClient* gSocketClient;
69 
70 	/** Get the main Gtk struct */
71 	public GSocketClient* getSocketClientStruct()
72 	{
73 		return gSocketClient;
74 	}
75 
76 	/** the main Gtk struct as a void* */
77 	protected override void* getStruct()
78 	{
79 		return cast(void*)gSocketClient;
80 	}
81 
82 	protected override void setStruct(GObject* obj)
83 	{
84 		gSocketClient = cast(GSocketClient*)obj;
85 		super.setStruct(obj);
86 	}
87 
88 	/**
89 	 * Sets our main struct and passes it to the parent class.
90 	 */
91 	public this (GSocketClient* gSocketClient, bool ownedRef = false)
92 	{
93 		this.gSocketClient = gSocketClient;
94 		super(cast(GObject*)gSocketClient, ownedRef);
95 	}
96 
97 
98 	/** */
99 	public static GType getType()
100 	{
101 		return g_socket_client_get_type();
102 	}
103 
104 	/**
105 	 * Creates a new #GSocketClient with the default options.
106 	 *
107 	 * Return: a #GSocketClient.
108 	 *     Free the returned object with g_object_unref().
109 	 *
110 	 * Since: 2.22
111 	 *
112 	 * Throws: ConstructionException GTK+ fails to create the object.
113 	 */
114 	public this()
115 	{
116 		auto p = g_socket_client_new();
117 		
118 		if(p is null)
119 		{
120 			throw new ConstructionException("null returned by new");
121 		}
122 		
123 		this(cast(GSocketClient*) p, true);
124 	}
125 
126 	/**
127 	 * Enable proxy protocols to be handled by the application. When the
128 	 * indicated proxy protocol is returned by the #GProxyResolver,
129 	 * #GSocketClient will consider this protocol as supported but will
130 	 * not try to find a #GProxy instance to handle handshaking. The
131 	 * application must check for this case by calling
132 	 * g_socket_connection_get_remote_address() on the returned
133 	 * #GSocketConnection, and seeing if it's a #GProxyAddress of the
134 	 * appropriate type, to determine whether or not it needs to handle
135 	 * the proxy handshaking itself.
136 	 *
137 	 * This should be used for proxy protocols that are dialects of
138 	 * another protocol such as HTTP proxy. It also allows cohabitation of
139 	 * proxy protocols that are reused between protocols. A good example
140 	 * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
141 	 * be use as generic socket proxy through the HTTP CONNECT method.
142 	 *
143 	 * When the proxy is detected as being an application proxy, TLS handshake
144 	 * will be skipped. This is required to let the application do the proxy
145 	 * specific handshake.
146 	 *
147 	 * Params:
148 	 *     protocol = The proxy protocol
149 	 */
150 	public void addApplicationProxy(string protocol)
151 	{
152 		g_socket_client_add_application_proxy(gSocketClient, Str.toStringz(protocol));
153 	}
154 
155 	/**
156 	 * Tries to resolve the @connectable and make a network connection to it.
157 	 *
158 	 * Upon a successful connection, a new #GSocketConnection is constructed
159 	 * and returned.  The caller owns this new object and must drop their
160 	 * reference to it when finished with it.
161 	 *
162 	 * The type of the #GSocketConnection object returned depends on the type of
163 	 * the underlying socket that is used. For instance, for a TCP/IP connection
164 	 * it will be a #GTcpConnection.
165 	 *
166 	 * The socket created will be the same family as the address that the
167 	 * @connectable resolves to, unless family is set with g_socket_client_set_family()
168 	 * or indirectly via g_socket_client_set_local_address(). The socket type
169 	 * defaults to %G_SOCKET_TYPE_STREAM but can be set with
170 	 * g_socket_client_set_socket_type().
171 	 *
172 	 * If a local address is specified with g_socket_client_set_local_address() the
173 	 * socket will be bound to this address before connecting.
174 	 *
175 	 * Params:
176 	 *     connectable = a #GSocketConnectable specifying the remote address.
177 	 *     cancellable = optional #GCancellable object, %NULL to ignore.
178 	 *
179 	 * Return: a #GSocketConnection on success, %NULL on error.
180 	 *
181 	 * Since: 2.22
182 	 *
183 	 * Throws: GException on failure.
184 	 */
185 	public SocketConnection connect(SocketConnectableIF connectable, Cancellable cancellable)
186 	{
187 		GError* err = null;
188 		
189 		auto p = g_socket_client_connect(gSocketClient, (connectable is null) ? null : connectable.getSocketConnectableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
190 		
191 		if (err !is null)
192 		{
193 			throw new GException( new ErrorG(err) );
194 		}
195 		
196 		if(p is null)
197 		{
198 			return null;
199 		}
200 		
201 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
202 	}
203 
204 	/**
205 	 * This is the asynchronous version of g_socket_client_connect().
206 	 *
207 	 * When the operation is finished @callback will be
208 	 * called. You can then call g_socket_client_connect_finish() to get
209 	 * the result of the operation.
210 	 *
211 	 * Params:
212 	 *     connectable = a #GSocketConnectable specifying the remote address.
213 	 *     cancellable = a #GCancellable, or %NULL
214 	 *     callback = a #GAsyncReadyCallback
215 	 *     userData = user data for the callback
216 	 *
217 	 * Since: 2.22
218 	 */
219 	public void connectAsync(SocketConnectableIF connectable, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
220 	{
221 		g_socket_client_connect_async(gSocketClient, (connectable is null) ? null : connectable.getSocketConnectableStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
222 	}
223 
224 	/**
225 	 * Finishes an async connect operation. See g_socket_client_connect_async()
226 	 *
227 	 * Params:
228 	 *     result = a #GAsyncResult.
229 	 *
230 	 * Return: a #GSocketConnection on success, %NULL on error.
231 	 *
232 	 * Since: 2.22
233 	 *
234 	 * Throws: GException on failure.
235 	 */
236 	public SocketConnection connectFinish(AsyncResultIF result)
237 	{
238 		GError* err = null;
239 		
240 		auto p = g_socket_client_connect_finish(gSocketClient, (result is null) ? null : result.getAsyncResultStruct(), &err);
241 		
242 		if (err !is null)
243 		{
244 			throw new GException( new ErrorG(err) );
245 		}
246 		
247 		if(p is null)
248 		{
249 			return null;
250 		}
251 		
252 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
253 	}
254 
255 	/**
256 	 * This is a helper function for g_socket_client_connect().
257 	 *
258 	 * Attempts to create a TCP connection to the named host.
259 	 *
260 	 * @host_and_port may be in any of a number of recognized formats; an IPv6
261 	 * address, an IPv4 address, or a domain name (in which case a DNS
262 	 * lookup is performed).  Quoting with [] is supported for all address
263 	 * types.  A port override may be specified in the usual way with a
264 	 * colon.  Ports may be given as decimal numbers or symbolic names (in
265 	 * which case an /etc/services lookup is performed).
266 	 *
267 	 * If no port override is given in @host_and_port then @default_port will be
268 	 * used as the port number to connect to.
269 	 *
270 	 * In general, @host_and_port is expected to be provided by the user (allowing
271 	 * them to give the hostname, and a port override if necessary) and
272 	 * @default_port is expected to be provided by the application.
273 	 *
274 	 * In the case that an IP address is given, a single connection
275 	 * attempt is made.  In the case that a name is given, multiple
276 	 * connection attempts may be made, in turn and according to the
277 	 * number of address records in DNS, until a connection succeeds.
278 	 *
279 	 * Upon a successful connection, a new #GSocketConnection is constructed
280 	 * and returned.  The caller owns this new object and must drop their
281 	 * reference to it when finished with it.
282 	 *
283 	 * In the event of any failure (DNS error, service not found, no hosts
284 	 * connectable) %NULL is returned and @error (if non-%NULL) is set
285 	 * accordingly.
286 	 *
287 	 * Params:
288 	 *     hostAndPort = the name and optionally port of the host to connect to
289 	 *     defaultPort = the default port to connect to
290 	 *     cancellable = a #GCancellable, or %NULL
291 	 *
292 	 * Return: a #GSocketConnection on success, %NULL on error.
293 	 *
294 	 * Since: 2.22
295 	 *
296 	 * Throws: GException on failure.
297 	 */
298 	public SocketConnection connectToHost(string hostAndPort, ushort defaultPort, Cancellable cancellable)
299 	{
300 		GError* err = null;
301 		
302 		auto p = g_socket_client_connect_to_host(gSocketClient, Str.toStringz(hostAndPort), defaultPort, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
303 		
304 		if (err !is null)
305 		{
306 			throw new GException( new ErrorG(err) );
307 		}
308 		
309 		if(p is null)
310 		{
311 			return null;
312 		}
313 		
314 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
315 	}
316 
317 	/**
318 	 * This is the asynchronous version of g_socket_client_connect_to_host().
319 	 *
320 	 * When the operation is finished @callback will be
321 	 * called. You can then call g_socket_client_connect_to_host_finish() to get
322 	 * the result of the operation.
323 	 *
324 	 * Params:
325 	 *     hostAndPort = the name and optionally the port of the host to connect to
326 	 *     defaultPort = the default port to connect to
327 	 *     cancellable = a #GCancellable, or %NULL
328 	 *     callback = a #GAsyncReadyCallback
329 	 *     userData = user data for the callback
330 	 *
331 	 * Since: 2.22
332 	 */
333 	public void connectToHostAsync(string hostAndPort, ushort defaultPort, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
334 	{
335 		g_socket_client_connect_to_host_async(gSocketClient, Str.toStringz(hostAndPort), defaultPort, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
336 	}
337 
338 	/**
339 	 * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
340 	 *
341 	 * Params:
342 	 *     result = a #GAsyncResult.
343 	 *
344 	 * Return: a #GSocketConnection on success, %NULL on error.
345 	 *
346 	 * Since: 2.22
347 	 *
348 	 * Throws: GException on failure.
349 	 */
350 	public SocketConnection connectToHostFinish(AsyncResultIF result)
351 	{
352 		GError* err = null;
353 		
354 		auto p = g_socket_client_connect_to_host_finish(gSocketClient, (result is null) ? null : result.getAsyncResultStruct(), &err);
355 		
356 		if (err !is null)
357 		{
358 			throw new GException( new ErrorG(err) );
359 		}
360 		
361 		if(p is null)
362 		{
363 			return null;
364 		}
365 		
366 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
367 	}
368 
369 	/**
370 	 * Attempts to create a TCP connection to a service.
371 	 *
372 	 * This call looks up the SRV record for @service at @domain for the
373 	 * "tcp" protocol.  It then attempts to connect, in turn, to each of
374 	 * the hosts providing the service until either a connection succeeds
375 	 * or there are no hosts remaining.
376 	 *
377 	 * Upon a successful connection, a new #GSocketConnection is constructed
378 	 * and returned.  The caller owns this new object and must drop their
379 	 * reference to it when finished with it.
380 	 *
381 	 * In the event of any failure (DNS error, service not found, no hosts
382 	 * connectable) %NULL is returned and @error (if non-%NULL) is set
383 	 * accordingly.
384 	 *
385 	 * Params:
386 	 *     domain = a domain name
387 	 *     service = the name of the service to connect to
388 	 *     cancellable = a #GCancellable, or %NULL
389 	 *
390 	 * Return: a #GSocketConnection if successful, or %NULL on error
391 	 *
392 	 * Throws: GException on failure.
393 	 */
394 	public SocketConnection connectToService(string domain, string service, Cancellable cancellable)
395 	{
396 		GError* err = null;
397 		
398 		auto p = g_socket_client_connect_to_service(gSocketClient, Str.toStringz(domain), Str.toStringz(service), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
399 		
400 		if (err !is null)
401 		{
402 			throw new GException( new ErrorG(err) );
403 		}
404 		
405 		if(p is null)
406 		{
407 			return null;
408 		}
409 		
410 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
411 	}
412 
413 	/**
414 	 * This is the asynchronous version of
415 	 * g_socket_client_connect_to_service().
416 	 *
417 	 * Params:
418 	 *     domain = a domain name
419 	 *     service = the name of the service to connect to
420 	 *     cancellable = a #GCancellable, or %NULL
421 	 *     callback = a #GAsyncReadyCallback
422 	 *     userData = user data for the callback
423 	 *
424 	 * Since: 2.22
425 	 */
426 	public void connectToServiceAsync(string domain, string service, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
427 	{
428 		g_socket_client_connect_to_service_async(gSocketClient, Str.toStringz(domain), Str.toStringz(service), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
429 	}
430 
431 	/**
432 	 * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
433 	 *
434 	 * Params:
435 	 *     result = a #GAsyncResult.
436 	 *
437 	 * Return: a #GSocketConnection on success, %NULL on error.
438 	 *
439 	 * Since: 2.22
440 	 *
441 	 * Throws: GException on failure.
442 	 */
443 	public SocketConnection connectToServiceFinish(AsyncResultIF result)
444 	{
445 		GError* err = null;
446 		
447 		auto p = g_socket_client_connect_to_service_finish(gSocketClient, (result is null) ? null : result.getAsyncResultStruct(), &err);
448 		
449 		if (err !is null)
450 		{
451 			throw new GException( new ErrorG(err) );
452 		}
453 		
454 		if(p is null)
455 		{
456 			return null;
457 		}
458 		
459 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
460 	}
461 
462 	/**
463 	 * This is a helper function for g_socket_client_connect().
464 	 *
465 	 * Attempts to create a TCP connection with a network URI.
466 	 *
467 	 * @uri may be any valid URI containing an "authority" (hostname/port)
468 	 * component. If a port is not specified in the URI, @default_port
469 	 * will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
470 	 * (#GSocketClient does not know to automatically assume TLS for
471 	 * certain URI schemes.)
472 	 *
473 	 * Using this rather than g_socket_client_connect() or
474 	 * g_socket_client_connect_to_host() allows #GSocketClient to
475 	 * determine when to use application-specific proxy protocols.
476 	 *
477 	 * Upon a successful connection, a new #GSocketConnection is constructed
478 	 * and returned.  The caller owns this new object and must drop their
479 	 * reference to it when finished with it.
480 	 *
481 	 * In the event of any failure (DNS error, service not found, no hosts
482 	 * connectable) %NULL is returned and @error (if non-%NULL) is set
483 	 * accordingly.
484 	 *
485 	 * Params:
486 	 *     uri = A network URI
487 	 *     defaultPort = the default port to connect to
488 	 *     cancellable = a #GCancellable, or %NULL
489 	 *
490 	 * Return: a #GSocketConnection on success, %NULL on error.
491 	 *
492 	 * Since: 2.26
493 	 *
494 	 * Throws: GException on failure.
495 	 */
496 	public SocketConnection connectToUri(string uri, ushort defaultPort, Cancellable cancellable)
497 	{
498 		GError* err = null;
499 		
500 		auto p = g_socket_client_connect_to_uri(gSocketClient, Str.toStringz(uri), defaultPort, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
501 		
502 		if (err !is null)
503 		{
504 			throw new GException( new ErrorG(err) );
505 		}
506 		
507 		if(p is null)
508 		{
509 			return null;
510 		}
511 		
512 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
513 	}
514 
515 	/**
516 	 * This is the asynchronous version of g_socket_client_connect_to_uri().
517 	 *
518 	 * When the operation is finished @callback will be
519 	 * called. You can then call g_socket_client_connect_to_uri_finish() to get
520 	 * the result of the operation.
521 	 *
522 	 * Params:
523 	 *     uri = a network uri
524 	 *     defaultPort = the default port to connect to
525 	 *     cancellable = a #GCancellable, or %NULL
526 	 *     callback = a #GAsyncReadyCallback
527 	 *     userData = user data for the callback
528 	 *
529 	 * Since: 2.26
530 	 */
531 	public void connectToUriAsync(string uri, ushort defaultPort, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
532 	{
533 		g_socket_client_connect_to_uri_async(gSocketClient, Str.toStringz(uri), defaultPort, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
534 	}
535 
536 	/**
537 	 * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
538 	 *
539 	 * Params:
540 	 *     result = a #GAsyncResult.
541 	 *
542 	 * Return: a #GSocketConnection on success, %NULL on error.
543 	 *
544 	 * Since: 2.26
545 	 *
546 	 * Throws: GException on failure.
547 	 */
548 	public SocketConnection connectToUriFinish(AsyncResultIF result)
549 	{
550 		GError* err = null;
551 		
552 		auto p = g_socket_client_connect_to_uri_finish(gSocketClient, (result is null) ? null : result.getAsyncResultStruct(), &err);
553 		
554 		if (err !is null)
555 		{
556 			throw new GException( new ErrorG(err) );
557 		}
558 		
559 		if(p is null)
560 		{
561 			return null;
562 		}
563 		
564 		return ObjectG.getDObject!(SocketConnection)(cast(GSocketConnection*) p, true);
565 	}
566 
567 	/**
568 	 * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
569 	 *
570 	 * Return: whether proxying is enabled
571 	 *
572 	 * Since: 2.26
573 	 */
574 	public bool getEnableProxy()
575 	{
576 		return g_socket_client_get_enable_proxy(gSocketClient) != 0;
577 	}
578 
579 	/**
580 	 * Gets the socket family of the socket client.
581 	 *
582 	 * See g_socket_client_set_family() for details.
583 	 *
584 	 * Return: a #GSocketFamily
585 	 *
586 	 * Since: 2.22
587 	 */
588 	public GSocketFamily getFamily()
589 	{
590 		return g_socket_client_get_family(gSocketClient);
591 	}
592 
593 	/**
594 	 * Gets the local address of the socket client.
595 	 *
596 	 * See g_socket_client_set_local_address() for details.
597 	 *
598 	 * Return: a #GSocketAddress or %NULL. Do not free.
599 	 *
600 	 * Since: 2.22
601 	 */
602 	public SocketAddress getLocalAddress()
603 	{
604 		auto p = g_socket_client_get_local_address(gSocketClient);
605 		
606 		if(p is null)
607 		{
608 			return null;
609 		}
610 		
611 		return ObjectG.getDObject!(SocketAddress)(cast(GSocketAddress*) p);
612 	}
613 
614 	/**
615 	 * Gets the protocol name type of the socket client.
616 	 *
617 	 * See g_socket_client_set_protocol() for details.
618 	 *
619 	 * Return: a #GSocketProtocol
620 	 *
621 	 * Since: 2.22
622 	 */
623 	public GSocketProtocol getProtocol()
624 	{
625 		return g_socket_client_get_protocol(gSocketClient);
626 	}
627 
628 	/**
629 	 * Gets the #GProxyResolver being used by @client. Normally, this will
630 	 * be the resolver returned by g_proxy_resolver_get_default(), but you
631 	 * can override it with g_socket_client_set_proxy_resolver().
632 	 *
633 	 * Return: The #GProxyResolver being used by
634 	 *     @client.
635 	 *
636 	 * Since: 2.36
637 	 */
638 	public ProxyResolverIF getProxyResolver()
639 	{
640 		auto p = g_socket_client_get_proxy_resolver(gSocketClient);
641 		
642 		if(p is null)
643 		{
644 			return null;
645 		}
646 		
647 		return ObjectG.getDObject!(ProxyResolver, ProxyResolverIF)(cast(GProxyResolver*) p);
648 	}
649 
650 	/**
651 	 * Gets the socket type of the socket client.
652 	 *
653 	 * See g_socket_client_set_socket_type() for details.
654 	 *
655 	 * Return: a #GSocketFamily
656 	 *
657 	 * Since: 2.22
658 	 */
659 	public GSocketType getSocketType()
660 	{
661 		return g_socket_client_get_socket_type(gSocketClient);
662 	}
663 
664 	/**
665 	 * Gets the I/O timeout time for sockets created by @client.
666 	 *
667 	 * See g_socket_client_set_timeout() for details.
668 	 *
669 	 * Return: the timeout in seconds
670 	 *
671 	 * Since: 2.26
672 	 */
673 	public uint getTimeout()
674 	{
675 		return g_socket_client_get_timeout(gSocketClient);
676 	}
677 
678 	/**
679 	 * Gets whether @client creates TLS connections. See
680 	 * g_socket_client_set_tls() for details.
681 	 *
682 	 * Return: whether @client uses TLS
683 	 *
684 	 * Since: 2.28
685 	 */
686 	public bool getTls()
687 	{
688 		return g_socket_client_get_tls(gSocketClient) != 0;
689 	}
690 
691 	/**
692 	 * Gets the TLS validation flags used creating TLS connections via
693 	 * @client.
694 	 *
695 	 * Return: the TLS validation flags
696 	 *
697 	 * Since: 2.28
698 	 */
699 	public GTlsCertificateFlags getTlsValidationFlags()
700 	{
701 		return g_socket_client_get_tls_validation_flags(gSocketClient);
702 	}
703 
704 	/**
705 	 * Sets whether or not @client attempts to make connections via a
706 	 * proxy server. When enabled (the default), #GSocketClient will use a
707 	 * #GProxyResolver to determine if a proxy protocol such as SOCKS is
708 	 * needed, and automatically do the necessary proxy negotiation.
709 	 *
710 	 * See also g_socket_client_set_proxy_resolver().
711 	 *
712 	 * Params:
713 	 *     enable = whether to enable proxies
714 	 *
715 	 * Since: 2.26
716 	 */
717 	public void setEnableProxy(bool enable)
718 	{
719 		g_socket_client_set_enable_proxy(gSocketClient, enable);
720 	}
721 
722 	/**
723 	 * Sets the socket family of the socket client.
724 	 * If this is set to something other than %G_SOCKET_FAMILY_INVALID
725 	 * then the sockets created by this object will be of the specified
726 	 * family.
727 	 *
728 	 * This might be useful for instance if you want to force the local
729 	 * connection to be an ipv4 socket, even though the address might
730 	 * be an ipv6 mapped to ipv4 address.
731 	 *
732 	 * Params:
733 	 *     family = a #GSocketFamily
734 	 *
735 	 * Since: 2.22
736 	 */
737 	public void setFamily(GSocketFamily family)
738 	{
739 		g_socket_client_set_family(gSocketClient, family);
740 	}
741 
742 	/**
743 	 * Sets the local address of the socket client.
744 	 * The sockets created by this object will bound to the
745 	 * specified address (if not %NULL) before connecting.
746 	 *
747 	 * This is useful if you want to ensure that the local
748 	 * side of the connection is on a specific port, or on
749 	 * a specific interface.
750 	 *
751 	 * Params:
752 	 *     address = a #GSocketAddress, or %NULL
753 	 *
754 	 * Since: 2.22
755 	 */
756 	public void setLocalAddress(SocketAddress address)
757 	{
758 		g_socket_client_set_local_address(gSocketClient, (address is null) ? null : address.getSocketAddressStruct());
759 	}
760 
761 	/**
762 	 * Sets the protocol of the socket client.
763 	 * The sockets created by this object will use of the specified
764 	 * protocol.
765 	 *
766 	 * If @protocol is %0 that means to use the default
767 	 * protocol for the socket family and type.
768 	 *
769 	 * Params:
770 	 *     protocol = a #GSocketProtocol
771 	 *
772 	 * Since: 2.22
773 	 */
774 	public void setProtocol(GSocketProtocol protocol)
775 	{
776 		g_socket_client_set_protocol(gSocketClient, protocol);
777 	}
778 
779 	/**
780 	 * Overrides the #GProxyResolver used by @client. You can call this if
781 	 * you want to use specific proxies, rather than using the system
782 	 * default proxy settings.
783 	 *
784 	 * Note that whether or not the proxy resolver is actually used
785 	 * depends on the setting of #GSocketClient:enable-proxy, which is not
786 	 * changed by this function (but which is %TRUE by default)
787 	 *
788 	 * Params:
789 	 *     proxyResolver = a #GProxyResolver, or %NULL for the
790 	 *         default.
791 	 *
792 	 * Since: 2.36
793 	 */
794 	public void setProxyResolver(ProxyResolverIF proxyResolver)
795 	{
796 		g_socket_client_set_proxy_resolver(gSocketClient, (proxyResolver is null) ? null : proxyResolver.getProxyResolverStruct());
797 	}
798 
799 	/**
800 	 * Sets the socket type of the socket client.
801 	 * The sockets created by this object will be of the specified
802 	 * type.
803 	 *
804 	 * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
805 	 * as GSocketClient is used for connection oriented services.
806 	 *
807 	 * Params:
808 	 *     type = a #GSocketType
809 	 *
810 	 * Since: 2.22
811 	 */
812 	public void setSocketType(GSocketType type)
813 	{
814 		g_socket_client_set_socket_type(gSocketClient, type);
815 	}
816 
817 	/**
818 	 * Sets the I/O timeout for sockets created by @client. @timeout is a
819 	 * time in seconds, or 0 for no timeout (the default).
820 	 *
821 	 * The timeout value affects the initial connection attempt as well,
822 	 * so setting this may cause calls to g_socket_client_connect(), etc,
823 	 * to fail with %G_IO_ERROR_TIMED_OUT.
824 	 *
825 	 * Params:
826 	 *     timeout = the timeout
827 	 *
828 	 * Since: 2.26
829 	 */
830 	public void setTimeout(uint timeout)
831 	{
832 		g_socket_client_set_timeout(gSocketClient, timeout);
833 	}
834 
835 	/**
836 	 * Sets whether @client creates TLS (aka SSL) connections. If @tls is
837 	 * %TRUE, @client will wrap its connections in a #GTlsClientConnection
838 	 * and perform a TLS handshake when connecting.
839 	 *
840 	 * Note that since #GSocketClient must return a #GSocketConnection,
841 	 * but #GTlsClientConnection is not a #GSocketConnection, this
842 	 * actually wraps the resulting #GTlsClientConnection in a
843 	 * #GTcpWrapperConnection when returning it. You can use
844 	 * g_tcp_wrapper_connection_get_base_io_stream() on the return value
845 	 * to extract the #GTlsClientConnection.
846 	 *
847 	 * If you need to modify the behavior of the TLS handshake (eg, by
848 	 * setting a client-side certificate to use, or connecting to the
849 	 * #GTlsConnection::accept-certificate signal), you can connect to
850 	 * @client's #GSocketClient::event signal and wait for it to be
851 	 * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you
852 	 * a chance to see the #GTlsClientConnection before the handshake
853 	 * starts.
854 	 *
855 	 * Params:
856 	 *     tls = whether to use TLS
857 	 *
858 	 * Since: 2.28
859 	 */
860 	public void setTls(bool tls)
861 	{
862 		g_socket_client_set_tls(gSocketClient, tls);
863 	}
864 
865 	/**
866 	 * Sets the TLS validation flags used when creating TLS connections
867 	 * via @client. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
868 	 *
869 	 * Params:
870 	 *     flags = the validation flags
871 	 *
872 	 * Since: 2.28
873 	 */
874 	public void setTlsValidationFlags(GTlsCertificateFlags flags)
875 	{
876 		g_socket_client_set_tls_validation_flags(gSocketClient, flags);
877 	}
878 
879 	protected class OnDelegateWrapper
880 	{
881 		void delegate(GSocketClientEvent, SocketConnectableIF, IOStream, SocketClient) dlg;
882 		gulong handlerId;
883 		ConnectFlags flags;
884 		this(void delegate(GSocketClientEvent, SocketConnectableIF, IOStream, SocketClient) dlg, gulong handlerId, ConnectFlags flags)
885 		{
886 			this.dlg = dlg;
887 			this.handlerId = handlerId;
888 			this.flags = flags;
889 		}
890 	}
891 	protected OnDelegateWrapper[] onListeners;
892 
893 	/**
894 	 * Emitted when @client's activity on @connectable changes state.
895 	 * Among other things, this can be used to provide progress
896 	 * information about a network connection in the UI. The meanings of
897 	 * the different @event values are as follows:
898 	 *
899 	 * - %G_SOCKET_CLIENT_RESOLVING: @client is about to look up @connectable
900 	 * in DNS. @connection will be %NULL.
901 	 *
902 	 * - %G_SOCKET_CLIENT_RESOLVED:  @client has successfully resolved
903 	 * @connectable in DNS. @connection will be %NULL.
904 	 *
905 	 * - %G_SOCKET_CLIENT_CONNECTING: @client is about to make a connection
906 	 * to a remote host; either a proxy server or the destination server
907 	 * itself. @connection is the #GSocketConnection, which is not yet
908 	 * connected.  Since GLib 2.40, you can access the remote
909 	 * address via g_socket_connection_get_remote_address().
910 	 *
911 	 * - %G_SOCKET_CLIENT_CONNECTED: @client has successfully connected
912 	 * to a remote host. @connection is the connected #GSocketConnection.
913 	 *
914 	 * - %G_SOCKET_CLIENT_PROXY_NEGOTIATING: @client is about to negotiate
915 	 * with a proxy to get it to connect to @connectable. @connection is
916 	 * the #GSocketConnection to the proxy server.
917 	 *
918 	 * - %G_SOCKET_CLIENT_PROXY_NEGOTIATED: @client has negotiated a
919 	 * connection to @connectable through a proxy server. @connection is
920 	 * the stream returned from g_proxy_connect(), which may or may not
921 	 * be a #GSocketConnection.
922 	 *
923 	 * - %G_SOCKET_CLIENT_TLS_HANDSHAKING: @client is about to begin a TLS
924 	 * handshake. @connection is a #GTlsClientConnection.
925 	 *
926 	 * - %G_SOCKET_CLIENT_TLS_HANDSHAKED: @client has successfully completed
927 	 * the TLS handshake. @connection is a #GTlsClientConnection.
928 	 *
929 	 * - %G_SOCKET_CLIENT_COMPLETE: @client has either successfully connected
930 	 * to @connectable (in which case @connection is the #GSocketConnection
931 	 * that it will be returning to the caller) or has failed (in which
932 	 * case @connection is %NULL and the client is about to return an error).
933 	 *
934 	 * Each event except %G_SOCKET_CLIENT_COMPLETE may be emitted
935 	 * multiple times (or not at all) for a given connectable (in
936 	 * particular, if @client ends up attempting to connect to more than
937 	 * one address). However, if @client emits the #GSocketClient::event
938 	 * signal at all for a given connectable, that it will always emit
939 	 * it with %G_SOCKET_CLIENT_COMPLETE when it is done.
940 	 *
941 	 * Note that there may be additional #GSocketClientEvent values in
942 	 * the future; unrecognized @event values should be ignored.
943 	 *
944 	 * Params:
945 	 *     event = the event that is occurring
946 	 *     connectable = the #GSocketConnectable that @event is occurring on
947 	 *     connection = the current representation of the connection
948 	 *
949 	 * Since: 2.32
950 	 */
951 	gulong addOn(void delegate(GSocketClientEvent, SocketConnectableIF, IOStream, SocketClient) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
952 	{
953 		onListeners ~= new OnDelegateWrapper(dlg, 0, connectFlags);
954 		onListeners[onListeners.length - 1].handlerId = Signals.connectData(
955 			this,
956 			"event",
957 			cast(GCallback)&callBack,
958 			cast(void*)onListeners[onListeners.length - 1],
959 			cast(GClosureNotify)&callBackDestroy,
960 			connectFlags);
961 		return onListeners[onListeners.length - 1].handlerId;
962 	}
963 	
964 	extern(C) static void callBack(GSocketClient* socketclientStruct, GSocketClientEvent event, GSocketConnectable* connectable, GIOStream* connection,OnDelegateWrapper wrapper)
965 	{
966 		wrapper.dlg(event, ObjectG.getDObject!(SocketConnectable, SocketConnectableIF)(connectable), ObjectG.getDObject!(IOStream)(connection), wrapper.outer);
967 	}
968 	
969 	extern(C) static void callBackDestroy(OnDelegateWrapper wrapper, GClosure* closure)
970 	{
971 		wrapper.outer.internalRemoveOn(wrapper);
972 	}
973 
974 	protected void internalRemoveOn(OnDelegateWrapper source)
975 	{
976 		foreach(index, wrapper; onListeners)
977 		{
978 			if (wrapper.dlg == source.dlg && wrapper.flags == source.flags && wrapper.handlerId == source.handlerId)
979 			{
980 				onListeners[index] = null;
981 				onListeners = std.algorithm.remove(onListeners, index);
982 				break;
983 			}
984 		}
985 	}
986 	
987 }