Tubes channels

## Tubes channels Tubes channels — client-side wrappers for the Tubes channel type |

## Synopsis

    #include <telepathy-glib/channel.h>

    gboolean            tp_cli_channel_type_tubes_run_accept_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             gchar **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_accept_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             guint in_Address_Type,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             GValue **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_close_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_get_available_stream_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GHashTable **out_Available_Stream_Tube_Types,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_get_available_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GArray **out_Available_Tube_Types,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_get_d_bus_names
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             GPtrArray **out_DBus_Names,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_get_d_bus_tube_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             gchar **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_get_stream_tube_socket_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             guint *out_Address_Type,
                                                             GValue **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_list_tubes
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GPtrArray **out_Tubes,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_offer_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             guint *out_Tube_ID,
                                                             GError **error,
                                                             GMainLoop **loop);
    gboolean            tp_cli_channel_type_tubes_run_offer_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             guint in_Address_Type,
                                                             const GValue *in_Address,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             guint *out_Tube_ID,
                                                             GError **error,
                                                             GMainLoop **loop);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_accept_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_accept_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             guint in_Address_Type,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             tp_cli_channel_type_tubes_callback_for_accept_stream_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_close_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_close_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_available_stream_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_tubes_callback_for_get_available_stream_tube_types callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_available_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_tubes_callback_for_get_available_tube_types callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_d_bus_names
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_get_d_bus_names callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_d_bus_tube_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_stream_tube_socket_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_list_tubes
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_tubes_callback_for_list_tubes callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_offer_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    TpProxyPendingCall * tp_cli_channel_type_tubes_call_offer_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             guint in_Address_Type,
                                                             const GValue *in_Address,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             tp_cli_channel_type_tubes_callback_for_offer_stream_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube)
                                                            (TpChannel *proxy,
                                                             const gchar *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_accept_stream_tube)
                                                            (TpChannel *proxy,
                                                             const GValue *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_close_tube)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_get_available_stream_tube_types)
                                                            (TpChannel *proxy,
                                                             GHashTable *out_Available_Stream_Tube_Types,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_get_available_tube_types)
                                                            (TpChannel *proxy,
                                                             const GArray *out_Available_Tube_Types,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_get_d_bus_names)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_DBus_Names,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address)
                                                            (TpChannel *proxy,
                                                             const gchar *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address)
                                                            (TpChannel *proxy,
                                                             guint out_Address_Type,
                                                             const GValue *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_list_tubes)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Tubes,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube)
                                                            (TpChannel *proxy,
                                                             guint out_Tube_ID,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_callback_for_offer_stream_tube)
                                                            (TpChannel *proxy,
                                                             guint out_Tube_ID,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_d_bus_names_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_new_tube
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_new_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_stream_tube_new_connection
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_tube_closed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_tube_closed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_tube_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_tube_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);
    void                (*tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             const GPtrArray *arg_Added,
                                                             const GArray *arg_Removed,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_signal_callback_new_tube)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             guint arg_Initiator,
                                                             guint arg_Type,
                                                             const gchar *arg_Service,
                                                             GHashTable *arg_Parameters,
                                                             guint arg_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             guint arg_Handle,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_signal_callback_tube_closed)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             gpointer user_data,
                                                             GObject *weak_object);
    void                (*tp_cli_channel_type_tubes_signal_callback_tube_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             guint arg_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

## Description

A "tube" is a mechanism for arbitrary data transfer. This section documents the auto-generated C wrappers for the Tubes channel type.

## Details

### tp_cli_channel_type_tubes_run_accept_d_bus_tube ()

    gboolean            tp_cli_channel_type_tubes_run_accept_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             gchar **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method AcceptDBusTube and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Accept a D-Bus tube that's in the &quot;local pending&quot; state. The connection manager will attempt to open the tube. The tube remains in the &quot;local pending&quot; state until the TubeStateChanged signal is emitted.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to accept.
`out_Address` : | Used to return an 'out' argument if `TRUE` is returned: The string describing the address of the private bus. The client should not attempt to connect to the address until the tube is open.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_accept_stream_tube ()

    gboolean            tp_cli_channel_type_tubes_run_accept_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             guint in_Address_Type,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             GValue **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method AcceptStreamTube and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Accept a stream tube that's in the &quot;local pending&quot; state. The connection manager will attempt to open the tube. The tube remains in the &quot;local pending&quot; state until the TubeStateChanged signal is emitted.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to accept.
`in_Address_Type` : | Used to pass an 'in' argument: The type of address the connection manager should listen on.
`in_Access_Control` : | Used to pass an 'in' argument: The type of access control the connection manager should apply to the socket.
`in_Access_Control_Param` : | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control enum.
`out_Address` : | Used to return an 'out' argument if `TRUE` is returned: The address on which the connection manager will listen for connections to this tube. The client should not attempt to connect to the address until the tube is open.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_close_tube ()

    gboolean            tp_cli_channel_type_tubes_run_close_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method CloseTube and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Close a tube.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to close.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_get_available_stream_tube_types ()

    gboolean            tp_cli_channel_type_tubes_run_get_available_stream_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GHashTable **out_Available_Stream_Tube_Types,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetAvailableStreamTubeTypes and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

List the available address types and access-control types for stream tubes.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`out_Available_Stream_Tube_Types` : | Used to return an 'out' argument if `TRUE` is returned: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A mapping from address types (members of Socket_Address_Type) to arrays of access-control type (members of Socket_Access_Control) that the connection manager supports for stream tubes with that address type. For simplicity, if a CM supports offering a particular type of tube, it is assumed to support accepting it.</p> <p>A typical value for a host without IPv6 support:</p> <pre> { Socket_Address_Type_IPv4: [Socket_Access_Control_Localhost, Socket_Access_Control_Port, Socket_Access_Control_Netmask], Socket_Address_Type_Unix: [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials] } </pre> <p>If stream tubes are not supported, this will be an empty dictionary.</p>
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_get_available_tube_types ()

    gboolean            tp_cli_channel_type_tubes_run_get_available_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GArray **out_Available_Tube_Types,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetAvailableTubeTypes and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

(Undocumented)

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`out_Available_Tube_Types` : | Used to return an 'out' argument if `TRUE` is returned: An array of the available tube types, as defined by the Tube_Type enum.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_get_d_bus_names ()

    gboolean            tp_cli_channel_type_tubes_run_get_d_bus_names
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             GPtrArray **out_DBus_Names,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetDBusNames and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

For a multi-user (i.e. Handle_Type_Room) D-Bus tube, obtain a mapping between contact handles and their unique bus names on this tube.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to get names for.
`out_DBus_Names` : | Used to return an 'out' argument if `TRUE` is returned: An array of structures, each containing a contact handle and a D-Bus bus name.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_get_d_bus_tube_address ()

    gboolean            tp_cli_channel_type_tubes_run_get_d_bus_tube_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             gchar **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetDBusTubeAddress and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

For a D-Bus tube, return a string describing the address of the private bus.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to get an address for.
`out_Address` : | Used to return an 'out' argument if `TRUE` is returned: The bus address.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_get_stream_tube_socket_address ()

    gboolean            tp_cli_channel_type_tubes_run_get_stream_tube_socket_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             guint *out_Address_Type,
                                                             GValue **out_Address,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method GetStreamTubeSocketAddress and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

For a stream tube, obtain the address of the socket used to communicate over this tube.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_ID` : | Used to pass an 'in' argument: The ID of the stream tube to get the socket for.
`out_Address_Type` : | Used to return an 'out' argument if `TRUE` is returned: The type of the listening address of the socket, as a member of Socket_Address_Type.
`out_Address` : | Used to return an 'out' argument if `TRUE` is returned: The listening address of the socket, as indicated by the address_type.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_list_tubes ()

    gboolean            tp_cli_channel_type_tubes_run_list_tubes
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             GPtrArray **out_Tubes,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method ListTubes and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

(Undocumented)

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`out_Tubes` : | Used to return an 'out' argument if `TRUE` is returned: Return an array of tuples, each representing a tube, with the following members: <ul> <li>the tube's ID</li> <li>the tube's initiator</li> <li>the tube's type</li> <li>the tube's service</li> <li>the tube's parameters</li> <li>the tube's state</li> </ul>
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_offer_d_bus_tube ()

    gboolean            tp_cli_channel_type_tubes_run_offer_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             guint *out_Tube_ID,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method OfferDBusTube and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Offers a D-Bus tube providing the service specified.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Service` : | Used to pass an 'in' argument: A string representing the service name that will be used over the tube. It should be a well-known D-Bus service name, of the form com.example.ServiceName.
`in_Parameters` : | Used to pass an 'in' argument: A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'.
`out_Tube_ID` : | Used to return an 'out' argument if `TRUE` is returned: The ID of the new tube.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_run_offer_stream_tube ()

    gboolean            tp_cli_channel_type_tubes_run_offer_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             guint in_Address_Type,
                                                             const GValue *in_Address,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             guint *out_Tube_ID,
                                                             GError **error,
                                                             GMainLoop **loop);

Call the method OfferStreamTube and run the main loop until it returns. Before calling this method, you must add a reference to any borrowed objects you need to keep, and generally ensure that everything is in a consistent state.

Offer a stream tube exporting the local socket specified.

`proxy` : | A TpChannel or subclass
`timeout_ms` : | Timeout in milliseconds, or -1 for default
`in_Service` : | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> A string representing the service name that will be used over the tube. It should be a well-known TCP service name as defined by <a href="http://www.iana.org/assignments/port-numbers"> http://www.iana.org/assignments/port-numbers</a> or <a href="http://www.dns-sd.org/ServiceTypes.html"> http://www.dns-sd.org/ServiceTypes.html</a>, for instance &quot;rsync&quot; or &quot;daap&quot;.
`in_Parameters` : | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'.</p> <p>These should usually be the same key-value pairs specified for use in the DNS-SD TXT record for that service.</p>
`in_Address_Type` : | Used to pass an 'in' argument: The type of the listening address of the local service, as a member of Socket_Address_Type.
`in_Address` : | Used to pass an 'in' argument: The listening address of the local service, as indicated by the address_type.
`in_Access_Control` : | Used to pass an 'in' argument: The access control the local service applies to the local socket, specified so the connection manager can behave appropriately when it connects.
`in_Access_Control_Param` : | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control enum.
`out_Tube_ID` : | Used to return an 'out' argument if `TRUE` is returned: The ID of the new tube.
`error` : | If not `NULL`, used to return errors if `FALSE` is returned
`loop` : | If not `NULL`, set before re-entering the main loop, to point to a GMainLoop which can be used to cancel this call with `g_main_loop_quit()`, causing a return of `FALSE` with `error` set to `TP_DBUS_ERROR_CANCELLED`
Returns : | TRUE on success, FALSE and sets `error` on error

### tp_cli_channel_type_tubes_call_accept_d_bus_tube ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_accept_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a AcceptDBusTube method call.

Accept a D-Bus tube that's in the &quot;local pending&quot; state. The connection manager will attempt to open the tube. The tube remains in the &quot;local pending&quot; state until the TubeStateChanged signal is emitted.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to accept.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_accept_stream_tube ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_accept_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             guint in_Address_Type,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             tp_cli_channel_type_tubes_callback_for_accept_stream_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a AcceptStreamTube method call.

Accept a stream tube that's in the &quot;local pending&quot; state. The connection manager will attempt to open the tube. The tube remains in the &quot;local pending&quot; state until the TubeStateChanged signal is emitted.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to accept.
`in_Address_Type` : | Used to pass an 'in' argument: The type of address the connection manager should listen on.
`in_Access_Control` : | Used to pass an 'in' argument: The type of access control the connection manager should apply to the socket.
`in_Access_Control_Param` : | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control enum.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_close_tube ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_close_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_close_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a CloseTube method call.

Close a tube.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to close.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_get_available_stream_tube_types ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_available_stream_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_tubes_callback_for_get_available_stream_tube_types callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetAvailableStreamTubeTypes method call.

List the available address types and access-control types for stream tubes.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_get_available_tube_types ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_available_tube_types
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_tubes_callback_for_get_available_tube_types callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetAvailableTubeTypes method call.

(Undocumented)

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_get_d_bus_names ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_d_bus_names
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_get_d_bus_names callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetDBusNames method call.

For a multi-user (i.e. Handle_Type_Room) D-Bus tube, obtain a mapping between contact handles and their unique bus names on this tube.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to get names for.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_get_d_bus_tube_address ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_d_bus_tube_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetDBusTubeAddress method call.

For a D-Bus tube, return a string describing the address of the private bus.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_ID` : | Used to pass an 'in' argument: The ID of the tube to get an address for.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_get_stream_tube_socket_address ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_get_stream_tube_socket_address
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             guint in_ID,
                                                             tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a GetStreamTubeSocketAddress method call.

For a stream tube, obtain the address of the socket used to communicate over this tube.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_ID` : | Used to pass an 'in' argument: The ID of the stream tube to get the socket for.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_list_tubes ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_list_tubes
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             tp_cli_channel_type_tubes_callback_for_list_tubes callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a ListTubes method call.

(Undocumented)

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_offer_d_bus_tube ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_offer_d_bus_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a OfferDBusTube method call.

Offers a D-Bus tube providing the service specified.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Service` : | Used to pass an 'in' argument: A string representing the service name that will be used over the tube. It should be a well-known D-Bus service name, of the form com.example.ServiceName.
`in_Parameters` : | Used to pass an 'in' argument: A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_call_offer_stream_tube ()

    TpProxyPendingCall * tp_cli_channel_type_tubes_call_offer_stream_tube
                                                            (TpChannel *proxy,
                                                             gint timeout_ms,
                                                             const gchar *in_Service,
                                                             GHashTable *in_Parameters,
                                                             guint in_Address_Type,
                                                             const GValue *in_Address,
                                                             guint in_Access_Control,
                                                             const GValue *in_Access_Control_Param,
                                                             tp_cli_channel_type_tubes_callback_for_offer_stream_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object);

Start a OfferStreamTube method call.

Offer a stream tube exporting the local socket specified.

`proxy` : | the TpProxy
`timeout_ms` : | the timeout in milliseconds, or -1 to use the default
`in_Service` : | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> A string representing the service name that will be used over the tube. It should be a well-known TCP service name as defined by <a href="http://www.iana.org/assignments/port-numbers"> http://www.iana.org/assignments/port-numbers</a> or <a href="http://www.dns-sd.org/ServiceTypes.html"> http://www.dns-sd.org/ServiceTypes.html</a>, for instance &quot;rsync&quot; or &quot;daap&quot;.
`in_Parameters` : | Used to pass an 'in' argument: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A dictionary of properties for the new tube; the allowable keys, types and values are defined by the service. Connection managers must support the value being any primitive (non-container) D-Bus type, or a byte array 'ay'.</p> <p>These should usually be the same key-value pairs specified for use in the DNS-SD TXT record for that service.</p>
`in_Address_Type` : | Used to pass an 'in' argument: The type of the listening address of the local service, as a member of Socket_Address_Type.
`in_Address` : | Used to pass an 'in' argument: The listening address of the local service, as indicated by the address_type.
`in_Access_Control` : | Used to pass an 'in' argument: The access control the local service applies to the local socket, specified so the connection manager can behave appropriately when it connects.
`in_Access_Control_Param` : | Used to pass an 'in' argument: A parameter for the access control type, to be interpreted as specified in the documentation for the Socket_Access_Control enum.
`callback` : | called when the method call succeeds or fails; may be `NULL` to make a "fire and forget" call with no reply tracking
`user_data` : | user-supplied data passed to the callback; must be `NULL` if `callback` is `NULL`
`destroy` : | called with the user_data as argument, after the call has succeeded, failed or been cancelled; must be `NULL` if `callback` is `NULL`
`weak_object` : | If not `NULL`, a GObject which will be weakly referenced; if it is destroyed, this call will automatically be cancelled. Must be `NULL` if `callback` is `NULL`
Returns : | a TpProxyPendingCall representing the call in progress. It is borrowed from the object, and will become invalid when the callback is called, the call is cancelled or the TpProxy becomes invalid.

### tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube ()

    void                (*tp_cli_channel_type_tubes_callback_for_accept_d_bus_tube)
                                                            (TpChannel *proxy,
                                                             const gchar *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a AcceptDBusTube method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Address` : | Used to return an 'out' argument if `error` is `NULL`: The string describing the address of the private bus. The client should not attempt to connect to the address until the tube is open.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_accept_stream_tube ()

    void                (*tp_cli_channel_type_tubes_callback_for_accept_stream_tube)
                                                            (TpChannel *proxy,
                                                             const GValue *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a AcceptStreamTube method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Address` : | Used to return an 'out' argument if `error` is `NULL`: The address on which the connection manager will listen for connections to this tube. The client should not attempt to connect to the address until the tube is open.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_close_tube ()

    void                (*tp_cli_channel_type_tubes_callback_for_close_tube)
                                                            (TpChannel *proxy,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a CloseTube method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_get_available_stream_tube_types ()

    void                (*tp_cli_channel_type_tubes_callback_for_get_available_stream_tube_types)
                                                            (TpChannel *proxy,
                                                             GHashTable *out_Available_Stream_Tube_Types,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetAvailableStreamTubeTypes method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Available_Stream_Tube_Types` : | Used to return an 'out' argument if `error` is `NULL`: <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> <p>A mapping from address types (members of Socket_Address_Type) to arrays of access-control type (members of Socket_Access_Control) that the connection manager supports for stream tubes with that address type. For simplicity, if a CM supports offering a particular type of tube, it is assumed to support accepting it.</p> <p>A typical value for a host without IPv6 support:</p> <pre> { Socket_Address_Type_IPv4: [Socket_Access_Control_Localhost, Socket_Access_Control_Port, Socket_Access_Control_Netmask], Socket_Address_Type_Unix: [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials] } </pre> <p>If stream tubes are not supported, this will be an empty dictionary.</p>
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_get_available_tube_types ()

    void                (*tp_cli_channel_type_tubes_callback_for_get_available_tube_types)
                                                            (TpChannel *proxy,
                                                             const GArray *out_Available_Tube_Types,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetAvailableTubeTypes method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Available_Tube_Types` : | Used to return an 'out' argument if `error` is `NULL`: An array of the available tube types, as defined by the Tube_Type enum.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_get_d_bus_names ()

    void                (*tp_cli_channel_type_tubes_callback_for_get_d_bus_names)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_DBus_Names,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetDBusNames method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_DBus_Names` : | Used to return an 'out' argument if `error` is `NULL`: An array of structures, each containing a contact handle and a D-Bus bus name.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address ()

    void                (*tp_cli_channel_type_tubes_callback_for_get_d_bus_tube_address)
                                                            (TpChannel *proxy,
                                                             const gchar *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetDBusTubeAddress method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Address` : | Used to return an 'out' argument if `error` is `NULL`: The bus address.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address ()

    void                (*tp_cli_channel_type_tubes_callback_for_get_stream_tube_socket_address)
                                                            (TpChannel *proxy,
                                                             guint out_Address_Type,
                                                             const GValue *out_Address,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a GetStreamTubeSocketAddress method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Address_Type` : | Used to return an 'out' argument if `error` is `NULL`: The type of the listening address of the socket, as a member of Socket_Address_Type.
`out_Address` : | Used to return an 'out' argument if `error` is `NULL`: The listening address of the socket, as indicated by the address_type.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_list_tubes ()

    void                (*tp_cli_channel_type_tubes_callback_for_list_tubes)
                                                            (TpChannel *proxy,
                                                             const GPtrArray *out_Tubes,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a ListTubes method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Tubes` : | Used to return an 'out' argument if `error` is `NULL`: Return an array of tuples, each representing a tube, with the following members: <ul> <li>the tube's ID</li> <li>the tube's initiator</li> <li>the tube's type</li> <li>the tube's service</li> <li>the tube's parameters</li> <li>the tube's state</li> </ul>
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube ()

    void                (*tp_cli_channel_type_tubes_callback_for_offer_d_bus_tube)
                                                            (TpChannel *proxy,
                                                             guint out_Tube_ID,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a OfferDBusTube method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Tube_ID` : | Used to return an 'out' argument if `error` is `NULL`: The ID of the new tube.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_callback_for_offer_stream_tube ()

    void                (*tp_cli_channel_type_tubes_callback_for_offer_stream_tube)
                                                            (TpChannel *proxy,
                                                             guint out_Tube_ID,
                                                             const GError *error,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Signature of the callback called when a OfferStreamTube method call succeeds or fails.

`proxy` : | the proxy on which the call was made
`out_Tube_ID` : | Used to return an 'out' argument if `error` is `NULL`: The ID of the new tube.
`error` : | `NULL` on success, or an error on failure
`user_data` : | user-supplied data
`weak_object` : | user-supplied object

### tp_cli_channel_type_tubes_connect_to_d_bus_names_changed ()

    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_d_bus_names_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal DBusNamesChanged.

Emitted on a multi-user (i.e. Handle_Type_Room) D-Bus tube when a participant opens or closes the tube.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_tubes_connect_to_new_tube ()

    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_new_tube
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_new_tube callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal NewTube.

Emitted when a tube is created.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_tubes_connect_to_stream_tube_new_connection ()

    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_stream_tube_new_connection
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal StreamTubeNewConnection.

Emitted on a stream tube when a participant opens a new connection to its socket.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_tubes_connect_to_tube_closed ()

    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_tube_closed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_tube_closed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal TubeClosed.

Emitted when a tube has been closed. The ID of a closed tube is no longer valid. The ID may later be reused for a new tube.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_tubes_connect_to_tube_state_changed ()

    TpProxySignalConnection * tp_cli_channel_type_tubes_connect_to_tube_state_changed
                                                            (TpChannel *proxy,
                                                             tp_cli_channel_type_tubes_signal_callback_tube_state_changed callback,
                                                             gpointer user_data,
                                                             GDestroyNotify destroy,
                                                             GObject *weak_object,
                                                             GError **error);

Connect a handler to the signal TubeStateChanged.

Emitted when the state of a tube changes.

`proxy` : | A TpChannel or subclass
`callback` : | Callback to be called when the signal is received
`user_data` : | User-supplied data for the callback
`destroy` : | Destructor for the user-supplied data, which will be called when this signal is disconnected, or before this function returns `NULL`
`weak_object` : | A GObject which will be weakly referenced; if it is destroyed, this callback will automatically be disconnected
`error` : | If not `NULL`, used to raise an error if `NULL` is returned
Returns : | a TpProxySignalConnection containing all of the above, which can be used to disconnect the signal; or `NULL` if the proxy does not have the desired interface or has become invalid.

### tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed ()

    void                (*tp_cli_channel_type_tubes_signal_callback_d_bus_names_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             const GPtrArray *arg_Added,
                                                             const GArray *arg_Removed,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal DBusNamesChanged.

`proxy` : | The proxy on which `tp_cli_channel_type_tubes_connect_to_d_bus_names_changed()` was called
`arg_ID` : | The ID of the tube whose names have changed.
`arg_Added` : | Array of handles and D-Bus names of new participants.
`arg_Removed` : | Array of handles of former participants.
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_tubes_signal_callback_new_tube ()

    void                (*tp_cli_channel_type_tubes_signal_callback_new_tube)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             guint arg_Initiator,
                                                             guint arg_Type,
                                                             const gchar *arg_Service,
                                                             GHashTable *arg_Parameters,
                                                             guint arg_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal NewTube.

`proxy` : | The proxy on which `tp_cli_channel_type_tubes_connect_to_new_tube()` was called
`arg_ID` : | The ID of the new tube.
`arg_Initiator` : | The handle of the contact who initiated the tube.
`arg_Type` : | The tube type, as defined by the Tube_Type enum.
`arg_Service` : | A string representing the service that will be used over the tube.
`arg_Parameters` : | The new tube's properties.
`arg_State` : | The new tube's state.
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection ()

    void                (*tp_cli_channel_type_tubes_signal_callback_stream_tube_new_connection)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             guint arg_Handle,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal StreamTubeNewConnection.

`proxy` : | The proxy on which `tp_cli_channel_type_tubes_connect_to_stream_tube_new_connection()` was called
`arg_ID` : | The ID of the tube
`arg_Handle` : | The handle of the participant who opened the new connection
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_tubes_signal_callback_tube_closed ()

    void                (*tp_cli_channel_type_tubes_signal_callback_tube_closed)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal TubeClosed.

`proxy` : | The proxy on which `tp_cli_channel_type_tubes_connect_to_tube_closed()` was called
`arg_ID` : | The ID of the tube that was closed.
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

### tp_cli_channel_type_tubes_signal_callback_tube_state_changed ()

    void                (*tp_cli_channel_type_tubes_signal_callback_tube_state_changed)
                                                            (TpChannel *proxy,
                                                             guint arg_ID,
                                                             guint arg_State,
                                                             gpointer user_data,
                                                             GObject *weak_object);

Represents the signature of a callback for the signal TubeStateChanged.

`proxy` : | The proxy on which `tp_cli_channel_type_tubes_connect_to_tube_state_changed()` was called
`arg_ID` : | The ID of the tube that changed state.
`arg_State` : | The new state of the tube; see the Tube_State enumeration.
`user_data` : | User-supplied data
`weak_object` : | User-supplied weakly referenced object

## See Also

channel-group