libpurple/connection.h

/* purple
 *
 * Purple is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 */

#if !defined(PURPLE_GLOBAL_HEADER_INSIDE) && !defined(PURPLE_COMPILATION)
# error "only <purple.h> may be included directly"
#endif

#ifndef PURPLE_CONNECTION_H
#define PURPLE_CONNECTION_H
/**
 * SECTION:connection
 * @section_id: libpurple-connection
 * @short_description: <filename>connection.h</filename>
 * @title: Connection API
 * @see_also: <link linkend="chapter-signals-connection">Connection signals</link>
 */

#include <glib.h>

#define PURPLE_TYPE_CONNECTION  purple_connection_get_type()

typedef struct _PurpleConnection PurpleConnection;

#define PURPLE_TYPE_CONNECTION_UI_OPS  (purple_connection_ui_ops_get_type())

typedef struct _PurpleConnectionUiOps PurpleConnectionUiOps;

#define PURPLE_TYPE_CONNECTION_ERROR_INFO  (purple_connection_error_info_get_type())

typedef struct _PurpleConnectionErrorInfo PurpleConnectionErrorInfo;

/* This is meant to track use-after-free errors.
 * TODO: it should be disabled in released code. */
#define PURPLE_ASSERT_CONNECTION_IS_VALID(gc) \
	_purple_assert_connection_is_valid(gc, __FILE__, __LINE__)


/**
 * PurpleConnectionFlags:
 * @PURPLE_CONNECTION_FLAG_HTML: Connection sends/receives in 'HTML'
 * @PURPLE_CONNECTION_FLAG_NO_BGCOLOR: Connection does not send/receive
 *                                     background colors
 * @PURPLE_CONNECTION_FLAG_AUTO_RESP: Send auto responses when away
 * @PURPLE_CONNECTION_FLAG_FORMATTING_WBFO: The text buffer must be formatted
 *                                          as a whole
 * @PURPLE_CONNECTION_FLAG_NO_NEWLINES: No new lines are allowed in outgoing
 *                                      messages
 * @PURPLE_CONNECTION_FLAG_NO_FONTSIZE: Connection does not send/receive font
 *                                      sizes
 * @PURPLE_CONNECTION_FLAG_NO_URLDESC: Connection does not support descriptions
 *                                     with links
 * @PURPLE_CONNECTION_FLAG_NO_IMAGES: Connection does not support sending of
 *                                    images
 * @PURPLE_CONNECTION_FLAG_ALLOW_CUSTOM_SMILEY: Connection supports sending
 *                                              and receiving custom smileys
 * @PURPLE_CONNECTION_FLAG_SUPPORT_MOODS: Connection supports setting moods
 * @PURPLE_CONNECTION_FLAG_SUPPORT_MOOD_MESSAGES: Connection supports setting
 *                                                a message on moods
 *
 * Flags to change behavior of the client for a given connection.
 */
typedef enum /*< flags >*/
{
	PURPLE_CONNECTION_FLAG_HTML       = 0x0001,
	PURPLE_CONNECTION_FLAG_NO_BGCOLOR = 0x0002,
	PURPLE_CONNECTION_FLAG_AUTO_RESP  = 0x0004,
	PURPLE_CONNECTION_FLAG_FORMATTING_WBFO = 0x0008,
	PURPLE_CONNECTION_FLAG_NO_NEWLINES = 0x0010,
	PURPLE_CONNECTION_FLAG_NO_FONTSIZE = 0x0020,
	PURPLE_CONNECTION_FLAG_NO_URLDESC = 0x0040,
	PURPLE_CONNECTION_FLAG_NO_IMAGES = 0x0080,
	PURPLE_CONNECTION_FLAG_ALLOW_CUSTOM_SMILEY = 0x0100,
	PURPLE_CONNECTION_FLAG_SUPPORT_MOODS = 0x0200,
	PURPLE_CONNECTION_FLAG_SUPPORT_MOOD_MESSAGES = 0x0400
} PurpleConnectionFlags;

/**
 * PurpleConnectionState:
 * @PURPLE_CONNECTION_DISCONNECTED: Disconnected.
 * @PURPLE_CONNECTION_CONNECTED:    Connected.
 * @PURPLE_CONNECTION_CONNECTING:   Connecting.
 */
typedef enum
{
	PURPLE_CONNECTION_DISCONNECTED = 0,
	PURPLE_CONNECTION_CONNECTED,
	PURPLE_CONNECTION_CONNECTING
} PurpleConnectionState;

#define PURPLE_CONNECTION_ERROR purple_connection_error_quark()

/**
 * purple_connection_error_quark:
 *
 * Error domain for Purple connection errors. Errors in this domain will be
 * from the #PurpleConnectionError enum.
 */
GQuark purple_connection_error_quark(void);

/**
 * PurpleConnectionError:
 * @PURPLE_CONNECTION_ERROR_NETWORK_ERROR: There was an error sending or
 *         receiving on the network socket, or there was some protocol error
 *         (such as the server sending malformed data).
 * @PURPLE_CONNECTION_ERROR_INVALID_USERNAME: The username supplied was not
 *         valid.
 * @PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED: The username, password or
 *         some other credential was incorrect.  Use
 *         #PURPLE_CONNECTION_ERROR_INVALID_USERNAME instead if the username
 *         is known to be invalid.
 * @PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE: libpurple doesn't speak
 *         any of the authentication methods the server offered.
 * @PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT: libpurple was built without SSL
 *         support, and the connection needs SSL.
 * @PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR: There was an error negotiating
 *         SSL on this connection, or the server does not support encryption
 *         but an account option was set to require it.
 * @PURPLE_CONNECTION_ERROR_NAME_IN_USE: Someone is already connected to the
 *         server using the name you are trying to connect with.
 * @PURPLE_CONNECTION_ERROR_INVALID_SETTINGS: The username/server/other
 *         preference for the account isn't valid.  For instance, on IRC the
 *         username cannot contain white space.  This reason should not be used
 *         for incorrect passwords etc: use
 *         #PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED for that.
 * @PURPLE_CONNECTION_ERROR_CERT_NOT_PROVIDED: The server did not provide a
 *         SSL certificate.
 * @PURPLE_CONNECTION_ERROR_CERT_UNTRUSTED: The server's SSL certificate could
 *         not be trusted.
 * @PURPLE_CONNECTION_ERROR_CERT_EXPIRED: The server's SSL certificate has
 *         expired.
 * @PURPLE_CONNECTION_ERROR_CERT_NOT_ACTIVATED: The server's SSL certificate is
 *         not yet valid.
 * @PURPLE_CONNECTION_ERROR_CERT_HOSTNAME_MISMATCH: The server's SSL
 *         certificate did not match its hostname.
 * @PURPLE_CONNECTION_ERROR_CERT_FINGERPRINT_MISMATCH: The server's SSL
 *         certificate does not have the expected fingerprint.
 * @PURPLE_CONNECTION_ERROR_CERT_SELF_SIGNED: The server's SSL certificate is
 *         self-signed.
 * @PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR: There was some other error
 *         validating the server's SSL certificate.
 * @PURPLE_CONNECTION_ERROR_OTHER_ERROR: Some other error occurred which fits
 *         into none of the other categories.
 *
 * Possible errors that can cause a connection to be closed.
 */
typedef enum
{
	PURPLE_CONNECTION_ERROR_NETWORK_ERROR = 0,
	PURPLE_CONNECTION_ERROR_INVALID_USERNAME = 1,
	PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED = 2,
	PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE = 3,
	PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT = 4,
	PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR = 5,
	PURPLE_CONNECTION_ERROR_NAME_IN_USE = 6,

	/* TODO This reason really shouldn't be necessary. Usernames and
	 *      other account preferences should be validated when the
	 *      account is created. */
	PURPLE_CONNECTION_ERROR_INVALID_SETTINGS = 7,

	PURPLE_CONNECTION_ERROR_CERT_NOT_PROVIDED = 8,
	PURPLE_CONNECTION_ERROR_CERT_UNTRUSTED = 9,
	PURPLE_CONNECTION_ERROR_CERT_EXPIRED = 10,
	PURPLE_CONNECTION_ERROR_CERT_NOT_ACTIVATED = 11,
	PURPLE_CONNECTION_ERROR_CERT_HOSTNAME_MISMATCH = 12,
	PURPLE_CONNECTION_ERROR_CERT_FINGERPRINT_MISMATCH = 13,
	PURPLE_CONNECTION_ERROR_CERT_SELF_SIGNED = 14,
	PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR = 15,

	/* purple_connection_error() in connection.c uses the fact that
	 * this is the last member of the enum when sanity-checking; if other
	 * reasons are added after it, the check must be updated.
	 */
	PURPLE_CONNECTION_ERROR_OTHER_ERROR = 16
} PurpleConnectionError;

/**
 * PurpleConnectionErrorInfo:
 * @type: The type of error.
 * @description: A localised, human-readable description of the error.
 *
 * Holds the type of an error along with its description.
 */
struct _PurpleConnectionErrorInfo
{
	PurpleConnectionError type;
	char *description;
};

/**
 * PurpleSslErrorType:
 * @PURPLE_SSL_HANDSHAKE_FAILED: The handshake failed
 * @PURPLE_SSL_CONNECT_FAILED: The connection failed
 * @PURPLE_SSL_CERTIFICATE_INVALID: The certificated is invalid
 *
 * Possible SSL errors.
 */
typedef enum
{
	PURPLE_SSL_HANDSHAKE_FAILED = 1,
	PURPLE_SSL_CONNECT_FAILED = 2,
	PURPLE_SSL_CERTIFICATE_INVALID = 3
} PurpleSslErrorType;

#include <time.h>

#include "account.h"
#include "protocol.h"
#include "status.h"

/**
 * PurpleConnectionUiOps:
 * @connect_progress: When an account is connecting, this operation is called to
 *                    notify the UI of what is happening, as well as which @step
 *                    out of @step_count has been reached (which might be
 *                    displayed as a progress bar).
 *                    <sbr/>See purple_connection_update_progress().
 * @connected: Called when a connection is established (just before the
 *   <link linkend="connections-signed-on"><literal>"signed-on"</literal></link>
 *             signal).
 * @disconnected: Called when a connection is ended (between the
 *   <link linkend="connections-signing-off"><literal>"signing-off"</literal></link>
 *   and <link linkend="connections-signed-off"><literal>"signed-off"</literal></link>
 *                signals).
 * @notice: Used to display connection-specific notices. (Pidgin's Gtk user
 *          interface implements this as a no-op; purple_connection_notice(),
 *          which uses this operation, is not used by any of the protocols
 *          shipped with libpurple.)
 * @network_connected: Called when libpurple discovers that the computer's
 *                     network connection is active.  On Linux, this uses
 *                     Network Manager if available; on Windows, it uses
 *                     Win32's network change notification infrastructure.
 * @network_disconnected: Called when libpurple discovers that the computer's
 *                        network connection has gone away.
 * @report_disconnect: Called when an error causes a connection to be
 *                     disconnected. Called before @disconnected.
 *                     <sbr/>See purple_connection_error().
 *                     <sbr/>@reason: why the connection ended, if known, or
 *                                 #PURPLE_CONNECTION_ERROR_OTHER_ERROR, if not.
 *                     <sbr/>@text:   a localized message describing the
 *                                 disconnection in more detail to the user.
 *
 * Connection UI operations.  Used to notify the user of changes to
 * connections, such as being disconnected, and to respond to the
 * underlying network connection appearing and disappearing.  UIs should
 * call #purple_connections_set_ui_ops() with an instance of this struct.
 *
 * See <link linkend="chapter-ui-ops">List of <literal>UiOps</literal> Structures</link>
 */
struct _PurpleConnectionUiOps
{
	void (*connect_progress)(PurpleConnection *gc,
	                         const char *text,
	                         size_t step,
	                         size_t step_count);

	void (*connected)(PurpleConnection *gc);
	void (*disconnected)(PurpleConnection *gc);

	void (*notice)(PurpleConnection *gc, const char *text);

	void (*network_connected)(void);
	void (*network_disconnected)(void);

	void (*report_disconnect)(PurpleConnection *gc,
	                          PurpleConnectionError reason,
	                          const char *text);

	/*< private >*/
	void (*_purple_reserved1)(void);
	void (*_purple_reserved2)(void);
	void (*_purple_reserved3)(void);
	void (*_purple_reserved4)(void);
};

G_BEGIN_DECLS

/******************************************************************************
 * To be deleted in the future
 *****************************************************************************/
void
_purple_assert_connection_is_valid(PurpleConnection *gc,
	const gchar *file, int line);

/**************************************************************************/
/* Connection API                                                         */
/**************************************************************************/

/**
 * purple_connection_get_type:
 *
 * Returns: The #GType for the Connection object.
 */
G_DECLARE_FINAL_TYPE(PurpleConnection, purple_connection, PURPLE, CONNECTION, GObject)

/**
 * purple_connection_error_info_get_type:
 *
 * Returns: The #GType for the #PurpleConnectionErrorInfo boxed structure.
 */
GType purple_connection_error_info_get_type(void);

/**
 * purple_connection_set_state:
 * @gc:    The connection.
 * @state: The connection state.
 *
 * Sets the connection state.  Protocols should call this and pass in
 * the state #PURPLE_CONNECTION_CONNECTED when the account is completely
 * signed on.  What does it mean to be completely signed on?  If
 * the core can call protocol's set_status, and it successfully changes
 * your status, then the account is online.
 */
void purple_connection_set_state(PurpleConnection *gc, PurpleConnectionState state);

/**
 * purple_connection_set_flags:
 * @gc:    The connection.
 * @flags: The flags.
 *
 * Sets the connection flags.
 *
 * Since: 3.0.0
 */
void purple_connection_set_flags(PurpleConnection *gc, PurpleConnectionFlags flags);

/**
 * purple_connection_set_display_name:
 * @gc:   The connection.
 * @name: The displayed name.
 *
 * Sets the connection's displayed name.
 */
void purple_connection_set_display_name(PurpleConnection *gc, const char *name);

/**
 * purple_connection_set_protocol_data:
 * @connection: The PurpleConnection.
 * @proto_data: The protocol data to set for the connection.
 *
 * Sets the protocol data for a connection.
 */
void purple_connection_set_protocol_data(PurpleConnection *connection, void *proto_data);

/**
 * purple_connection_get_state:
 * @gc: The connection.
 *
 * Returns the connection state.
 *
 * Returns: The connection state.
 */
PurpleConnectionState purple_connection_get_state(PurpleConnection *gc);

/**
 * purple_connection_get_flags:
 * @gc: The connection.
 *
 * Returns the connection flags.
 *
 * Returns: The connection flags.
 *
 * Since: 3.0.0
 */
PurpleConnectionFlags purple_connection_get_flags(PurpleConnection *gc);

/**
 * PURPLE_CONNECTION_IS_CONNECTED:
 *
 * Returns TRUE if the account is connected, otherwise returns FALSE.
 *
 * Returns: TRUE if the account is connected, otherwise returns FALSE.
 */
#define PURPLE_CONNECTION_IS_CONNECTED(gc) \
	(purple_connection_get_state(gc) == PURPLE_CONNECTION_CONNECTED)

/**
 * purple_connection_is_disconnecting:
 * @gc: The connection.
 *
 * Checks, if connection is in disconnecting state.
 *
 * Returns: %TRUE, if the account is disconnecting.
 */
gboolean
purple_connection_is_disconnecting(PurpleConnection *gc);

/**
 * purple_connection_get_account:
 * @gc: The connection.
 *
 * Returns the connection's account.
 *
 * Returns: (transfer none): The connection's account.
 */
PurpleAccount *purple_connection_get_account(PurpleConnection *gc);

/**
 * purple_connection_get_protocol:
 * @gc: The connection.
 *
 * Returns the protocol managing a connection.
 *
 * Returns: (transfer none): The protocol.
 */
PurpleProtocol *purple_connection_get_protocol(PurpleConnection *gc);

/**
 * purple_connection_get_password:
 * @gc: The connection.
 *
 * Returns the connection's password.
 *
 * Returns: The connection's password.
 */
const char *purple_connection_get_password(PurpleConnection *gc);

/**
 * purple_connection_get_active_chats:
 * @gc: The connection.
 *
 * Returns a list of active chat conversations on a connection.
 *
 * Returns: (element-type PurpleChatConversation) (transfer none): The active
 *          chats on the connection.
 *
 * Since: 3.0.0
 */
GSList *purple_connection_get_active_chats(PurpleConnection *gc);

/**
 * purple_connection_get_display_name:
 * @gc: The connection.
 *
 * Returns the connection's displayed name.
 *
 * Returns: The connection's displayed name.
 */
const char *purple_connection_get_display_name(PurpleConnection *gc);

/**
 * purple_connection_get_protocol_data:
 * @gc: The PurpleConnection.
 *
 * Gets the protocol data from a connection.
 *
 * Returns: The protocol data for the connection.
 */
void *purple_connection_get_protocol_data(PurpleConnection *gc);

/**
 * purple_connection_update_progress:
 * @gc:    The connection.
 * @text:  Information on the current step.
 * @step:  The current step.
 * @count: The total number of steps.
 *
 * Updates the connection progress.
 */
void purple_connection_update_progress(PurpleConnection *gc, const char *text,
									 size_t step, size_t count);

/**
 * purple_connection_notice:
 * @gc:   The connection.
 * @text: The notice text.
 *
 * Displays a connection-specific notice.
 */
void purple_connection_notice(PurpleConnection *gc, const char *text);

/**
 * purple_connection_error:
 * @gc:          the connection which is closing.
 * @reason:      why the connection is closing.
 * @description: a localized description of the error (not %NULL ).
 *
 * Closes a connection with an error and a human-readable description of the
 * error.
 */
void
purple_connection_error(PurpleConnection *gc,
                        PurpleConnectionError reason,
                        const char *description);

/**
 * purple_connection_get_error_info:
 * @gc: The connection.
 *
 * Returns the #PurpleConnectionErrorInfo instance of a connection if an
 * error exists.
 *
 * Returns: The #PurpleConnectionErrorInfo instance of the connection if an
 *          error exists, %NULL otherwise.
 *
 * Since: 3.0.0
 */
PurpleConnectionErrorInfo *
purple_connection_get_error_info(PurpleConnection *gc);

/**
 * purple_connection_ssl_error:
 * @gc: The connection.
 * @ssl_error: The SSL error type.
 *
 * Closes a connection due to an SSL error; this is basically a shortcut to
 * turning the #PurpleSslErrorType into a #PurpleConnectionError and a
 * human-readable string and then calling purple_connection_error().
 */
void
purple_connection_ssl_error (PurpleConnection *gc,
                             PurpleSslErrorType ssl_error);

/*
 * purple_connection_g_error
 * @gc: Connection the error is associated with
 * @error: Error information
 *
 * Closes a connection similar to purple_connection_error(), but
 * takes a GError which is then converted to purple error codes.
 *
 * This function ignores G_IO_ERROR_CANCELLED, returning without
 * closing the connection. This can be used as a shortcut when
 * cancelling connections, as this is commonly done when shutting
 * down a connection. If G_IO_ERROR_CANCELLED needs to be caught,
 * do so with g_error_matches() prior to calling this function.
 */
void
purple_connection_g_error(PurpleConnection *pc,
                          const GError *error);

/*
 * purple_connection_take_error
 * @gc: Connection the error is associated with
 * @error: (transfer full): Error information
 *
 * Closes a connection similar to purple_connection_error(), but
 * takes a GError which is then converted to purple error codes.
 *
 * This function is equivalent to purple_connection_g_error(),
 * except that it takes ownership of the GError.
 */
void
purple_connection_take_error(PurpleConnection *pc,
                             GError *error);

/**
 * purple_connection_error_is_fatal:
 * @reason: The connection error to check.
 *
 * Reports whether a disconnection reason is fatal (in which case the account
 * should probably not be automatically reconnected) or transient (so
 * auto-reconnection is a good idea).
 *
 * For instance, #PURPLE_CONNECTION_ERROR_NETWORK_ERROR is a temporary error,
 * which might be caused by losing the network connection, so <code>
 * purple_connection_error_is_fatal(PURPLE_CONNECTION_ERROR_NETWORK_ERROR)
 * </code> is %FALSE.
 *
 * On the other hand, #PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED probably
 * indicates a misconfiguration of the account which needs the user to go fix
 * it up, so <code>
 * purple_connection_error_is_fatal(PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED)
 * </code> is %TRUE.
 *
 * Returns: %TRUE if the account should not be automatically reconnected, and
 *         %FALSE otherwise.
 */
gboolean
purple_connection_error_is_fatal (PurpleConnectionError reason);

/**
 * purple_connection_update_last_received:
 * @gc:   The connection.
 *
 * Indicate that a packet was received on the connection.
 * Set by the protocol to avoid sending unneeded keepalives.
 *
 * Since: 3.0.0
 */
void purple_connection_update_last_received(PurpleConnection *gc);

/**************************************************************************/
/* Connections API                                                        */
/**************************************************************************/

/**
 * purple_connections_disconnect_all:
 *
 * Disconnects from all connections.
 */
void purple_connections_disconnect_all(void);

/**
 * purple_connections_get_all:
 *
 * Returns a list of all active connections.  This does not
 * include connections that are in the process of connecting.
 *
 * Returns: (element-type PurpleConnection) (transfer none): A list of all
 *          active connections.
 */
GList *purple_connections_get_all(void);

/**
 * purple_connections_get_connecting:
 *
 * Returns a list of all connections in the process of connecting.
 *
 * Returns: (element-type PurpleConnection) (transfer none): A list of
 *          connecting connections.
 */
GList *purple_connections_get_connecting(void);

/**
 * purple_connections_is_online:
 *
 * Checks if at least one account is online.
 *
 * Returns: %TRUE if at least one account is online.
 */
gboolean purple_connections_is_online(void);

/**************************************************************************/
/* UI Registration Functions                                              */
/**************************************************************************/

/**
 * purple_connection_ui_ops_get_type:
 *
 * Returns: The #GType for the #PurpleConnectionUiOps boxed structure.
 */
GType purple_connection_ui_ops_get_type(void);

/**
 * purple_connections_set_ui_ops:
 * @ops: The UI operations structure.
 *
 * Sets the UI operations structure to be used for connections.
 */
void purple_connections_set_ui_ops(PurpleConnectionUiOps *ops);

/**
 * purple_connections_get_ui_ops:
 *
 * Returns the UI operations structure used for connections.
 *
 * Returns: The UI operations structure in use.
 */
PurpleConnectionUiOps *purple_connections_get_ui_ops(void);

/**************************************************************************/
/* Connections Subsystem                                                  */
/**************************************************************************/

/**
 * purple_connections_init:
 *
 * Initializes the connections subsystem.
 */
void purple_connections_init(void);

/**
 * purple_connections_uninit:
 *
 * Uninitializes the connections subsystem.
 */
void purple_connections_uninit(void);

/**
 * purple_connections_get_handle:
 *
 * Returns the handle to the connections subsystem.
 *
 * Returns: The connections subsystem handle.
 */
void *purple_connections_get_handle(void);


G_END_DECLS

#endif /* PURPLE_CONNECTION_H */