// -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- /* Copyright (C) 2010 Jonathon Jongsma * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include _DEFS(giomm,gio) _PINCLUDE(glibmm/private/object_p.h) namespace Gio { /** Helper for connecting to a network service. * * @see SocketConnection, SocketListener * * SocketClient is a high-level utility class for connecting to a * network host using a connection oriented socket type. * * You create a SocketClient object, set any options you want, then * call a sync or async connect operation, which returns a SocketConnection * subclass on success. * * The type of the SocketConnection object returned depends on the type of * the underlying socket that is in use. For instance, for a TCP/IP connection * it will be a TcpConnection. * * @newin{2,24} * @ingroup NetworkIO */ class SocketClient : public Glib::Object { _CLASS_GOBJECT(SocketClient, GSocketClient, G_SOCKET_CLIENT, Glib::Object, GObject) protected: _CTOR_DEFAULT public: _WRAP_CREATE() _WRAP_METHOD(SocketFamily get_family() const, g_socket_client_get_family) _WRAP_METHOD(void set_family(SocketFamily family), g_socket_client_set_family) _WRAP_METHOD(SocketType get_socket_type() const, g_socket_client_get_socket_type) _WRAP_METHOD(void set_socket_type(SocketType type), g_socket_client_set_socket_type) _WRAP_METHOD(SocketProtocol get_protocol() const, g_socket_client_get_protocol) _WRAP_METHOD(void set_protocol(SocketProtocol protocol), g_socket_client_set_protocol) _WRAP_METHOD(Glib::RefPtr get_local_address(), g_socket_client_get_local_address) _WRAP_METHOD(Glib::RefPtr get_local_address() const, g_socket_client_get_local_address, constversion) _WRAP_METHOD(void set_local_address(const Glib::RefPtr& address), g_socket_client_set_local_address) _WRAP_METHOD(Glib::RefPtr connect(const Glib::RefPtr& connectable, const Glib::RefPtr& cancellable), g_socket_client_connect, errthrow) Glib::RefPtr connect(const Glib::RefPtr& connectable); _WRAP_METHOD(Glib::RefPtr connect_to_host(const Glib::ustring& host_and_port, guint16 default_port, const Glib::RefPtr& cancellable), g_socket_client_connect_to_host, errthrow) /** This is a helper function for connect(). * This attempts to create a TCP connection to the named host. * * @a host_and_port may be in any of a number of recognised formats; an IPv6 address, an IPv4 address, or a domain name (in which case a DNS lookup is performed). Quoting with [] is supported for all address types. A port override may be specified in the usual way with a colon. Ports may be given as decimal numbers or symbolic names (in which case an /etc/services lookup is performed). * * If no port override is given in @a host_and_port then default_port will be used as the port number to connect to. * * In general, @a host_and_port is expected to be provided by the user (allowing them to give the hostname, and a port overide if necessary) and default_port is expected to be provided by the application. * * In the case that an IP address is given, a single connection attempt is made. In the case that a name is given, multiple connection attempts may be made, in turn and according to the number of address records in DNS, until a connection succeeds. * * Upon a successful connection, a new SocketConnection is constructed and returned. * * In the event of any failure (DNS error, service not found, no hosts connectable) an exception is thrown. * * @param host_and_port The name and optionally port of the host to connect to. * @param default_port The default port to connect to. */ Glib::RefPtr connect_to_host(const Glib::ustring& host_and_port, guint16 default_port); _WRAP_METHOD(Glib::RefPtr connect_to_service(const Glib::ustring& domain, const Glib::ustring& service, const Glib::RefPtr& cancellable), g_socket_client_connect_to_service, errthrow) Glib::RefPtr connect_to_service(const Glib::ustring& domain, const Glib::ustring& service); _WRAP_METHOD(Glib::RefPtr connect_to_uri(const Glib::ustring& uri, guint16 default_port, const Glib::RefPtr& cancellable), g_socket_client_connect_to_uri, errthrow) /** This is a helper function for connect(). * This attempts to create a TCP connection with a network URI. * * @a uri may be any valid URI containing an "authority" (hostname/port) component. If a port is not specified in the URI, default_port will be used. TLS will be negotiated if "tls" is true. (GSocketClient does not know to automatically assume TLS for certain URI schemes.) * * Using this rather than connect() or connect_to_host() allows SocketClient to determine when to use application-specific proxy protocols. * * Upon a successful connection, a new SocketConnection is constructed and returned. * * In the event of any failure (DNS error, service not found, no hosts connectable) an exception is thrown. * * @param uri A network URI * @param default_port The default port to connect to. */ Glib::RefPtr connect_to_uri(const Glib::ustring& uri, guint16 default_port); _WRAP_METHOD_DOCS_ONLY(g_socket_client_connect_async) void connect_async(const Glib::RefPtr& connectable, const Glib::RefPtr& cancellable, const SlotAsyncReady& slot); /** This is the asynchronous version of connect(). * When the operation is finished @a slot will be called. You can then call finish() to get the result of the operation. * * @param connectable A SocketConnectable specifying the remote address. * @param slot A callback slot to call after the operation completes. */ void connect_async(const Glib::RefPtr& connectable, const SlotAsyncReady& slot); _IGNORE(g_socket_client_connect_async) _WRAP_METHOD(Glib::RefPtr connect_finish(const Glib::RefPtr& result), g_socket_client_connect_finish, errthrow) _WRAP_METHOD_DOCS_ONLY(g_socket_client_connect_to_host_async) void connect_to_host_async(const Glib::ustring& host_and_port, guint16 default_port, const Glib::RefPtr& cancellable, const SlotAsyncReady& slot); /** This is the asynchronous version of connect_to_host(). * When the operation is finished @a slot will be called. You can then call connect_to_host_finish() to get the result of the operation. * * @param host_and_port The name and optionally the port of the host to connect to. * @param default_port The default port to connect to. * @param slot A callback slot to call after the opration completes. */ void connect_to_host_async(const Glib::ustring& host_and_port, guint16 default_port, const SlotAsyncReady& slot); _IGNORE(g_socket_client_connect_to_host_async) _WRAP_METHOD(Glib::RefPtr connect_to_host_finish(const Glib::RefPtr& result), g_socket_client_connect_to_host_finish, errthrow) _WRAP_METHOD_DOCS_ONLY(g_socket_client_connect_to_service_async) void connect_to_service_async(const Glib::ustring& domain, const Glib::ustring& service, const Glib::RefPtr& cancellable, const SlotAsyncReady& slot); /** This is the asynchronous version of connect_to_service(). * * @param domain A domain name. * @param service The name of the service to connect to * @param slot A callback slot to call after the opration completes. */ void connect_to_service_async(const Glib::ustring& domain, const Glib::ustring& service, const SlotAsyncReady& slot); _IGNORE(g_socket_client_connect_to_service_async) _WRAP_METHOD(Glib::RefPtr connect_to_service_finish(const Glib::RefPtr& result), g_socket_client_connect_to_service_finish, errthrow) _WRAP_METHOD_DOCS_ONLY(g_socket_client_connect_to_uri_async) void connect_to_uri_async(const Glib::ustring& uri, guint16 default_port, const Glib::RefPtr& cancellable, const SlotAsyncReady& slot); /** This is the asynchronous version of connect_to_uri(). * * @param uri A network URI. * @param default_port The default port to connect to. * @param slot A callback slot to call after the opration completes. */ void connect_to_uri_async(const Glib::ustring& uri, guint16 default_port, const SlotAsyncReady& slot); _IGNORE(g_socket_client_connect_to_uri_async) _WRAP_METHOD(Glib::RefPtr connect_to_uri_finish(const Glib::RefPtr& result), g_socket_client_connect_to_uri_finish, errthrow) _WRAP_METHOD(bool get_enable_proxy() const, g_socket_client_get_enable_proxy) _WRAP_METHOD(void set_enable_proxy(bool enable), g_socket_client_set_enable_proxy) _WRAP_METHOD(guint get_timeout() const, g_socket_client_get_timeout) _WRAP_METHOD(void set_timeout(guint enable), g_socket_client_set_timeout) _WRAP_METHOD(void add_application_proxy(const Glib::ustring& protocol), g_socket_client_add_application_proxy) _WRAP_PROPERTY("family", SocketFamily) _WRAP_PROPERTY("local-address", Glib::RefPtr) _WRAP_PROPERTY("protocol", SocketProtocol) _WRAP_PROPERTY("type", SocketType) }; } // namespace Gio