static void
soup_connection_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
switch (prop_id) {
case PROP_REMOTE_URI:
priv->remote_uri = g_value_dup_boxed (value);
if (priv->remote_uri)
priv->ssl = (priv->remote_uri->scheme == SOUP_URI_SCHEME_HTTPS);
else
priv->ssl = FALSE;
break;
break;
case PROP_SSL_FALLBACK:
priv->ssl_fallback = g_value_get_boolean (value);
break;
case PROP_SOCKET_PROPERTIES:
priv->socket_props = g_value_dup_boxed (value);
break;
case PROP_STATE:
soup_connection_set_state (SOUP_CONNECTION (object), g_value_get_uint (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
switch (prop_id) {
case PROP_REMOTE_ADDRESS:
g_value_set_object (value, priv->remote_addr);
break;
case PROP_TUNNEL_ADDRESS:
g_value_set_object (value, priv->tunnel_addr);
break;
case PROP_PROXY_URI:
g_value_set_boxed (value, priv->proxy_uri);
break;
case PROP_SSL_CREDS:
g_value_set_pointer (value, priv->ssl_creds);
break;
case PROP_ASYNC_CONTEXT:
g_value_set_pointer (value, priv->async_context ? g_main_context_ref (priv->async_context) : NULL);
break;
case PROP_TIMEOUT:
g_value_set_uint (value, priv->io_timeout);
break;
case PROP_IDLE_TIMEOUT:
g_value_set_uint (value, priv->idle_timeout);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
SoupConnectionState
soup_connection_get_state (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn),
SOUP_CONNECTION_DISCONNECTED);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
#ifdef G_OS_UNIX
if (priv->state == SOUP_CONNECTION_IDLE) {
GPollFD pfd;
pfd.fd = soup_socket_get_fd (priv->socket);
pfd.events = G_IO_IN;
pfd.revents = 0;
if (g_poll (&pfd, 1, 0) == 1)
soup_connection_set_state (conn, SOUP_CONNECTION_REMOTE_DISCONNECTED);
}
#endif
if (priv->state == SOUP_CONNECTION_IDLE &&
priv->unused_timeout && priv->unused_timeout < time (NULL))
soup_connection_set_state (conn, SOUP_CONNECTION_REMOTE_DISCONNECTED);
return priv->state;
}
SoupSocket *
soup_connection_get_socket (SoupConnection *conn)
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), NULL);
return SOUP_CONNECTION_GET_PRIVATE (conn)->socket;
}
static void
set_current_msg (SoupConnection *conn, SoupMessage *msg)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_return_if_fail (priv->state == SOUP_CONNECTION_IN_USE);
g_object_freeze_notify (G_OBJECT (conn));
if (priv->current_msg) {
g_return_if_fail (priv->current_msg->method == SOUP_METHOD_CONNECT);
clear_current_msg (conn);
}
stop_idle_timer (priv);
priv->current_msg = g_object_ref (msg);
priv->reusable = FALSE;
g_signal_connect (msg, "got-body",
G_CALLBACK (current_msg_got_body), conn);
if (priv->proxy_uri && msg->method == SOUP_METHOD_CONNECT)
soup_connection_event (conn, G_SOCKET_CLIENT_PROXY_NEGOTIATING, NULL);
g_object_thaw_notify (G_OBJECT (conn));
}
static void
clear_current_request (SoupConnection *conn)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_object_freeze_notify (G_OBJECT (conn));
if (priv->state == SOUP_CONNECTION_IN_USE) {
/* We don't use soup_connection_set_state here since
* it may call clear_current_request()...
*/
priv->state = SOUP_CONNECTION_IDLE;
g_object_notify (G_OBJECT (conn), "state");
}
start_idle_timer (conn);
if (priv->cur_req) {
SoupMessage *cur_req = priv->cur_req;
g_object_remove_weak_pointer (G_OBJECT (priv->cur_req),
(gpointer)&priv->cur_req);
priv->cur_req = NULL;
g_object_notify (G_OBJECT (conn), "message");
if (!soup_message_is_keepalive (cur_req))
soup_connection_disconnect (conn);
else
soup_message_io_stop (cur_req);
}
g_object_thaw_notify (G_OBJECT (conn));
}
/**
* soup_connection_last_used:
* @conn: a #SoupConnection.
*
* Returns the last time a response was received on @conn.
*
* Return value: the last time a response was received on @conn, or 0
* if @conn has not been used yet.
*/
time_t
soup_connection_last_used (SoupConnection *conn)
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
return SOUP_CONNECTION_GET_PRIVATE (conn)->last_used;
}
SoupURI *
soup_connection_get_proxy_uri (SoupConnection *conn)
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), NULL);
return SOUP_CONNECTION_GET_PRIVATE (conn)->proxy_uri;
}
/**
* soup_connection_disconnect:
* @conn: a connection
*
* Disconnects @conn's socket and emits a %disconnected signal.
* After calling this, @conn will be essentially useless.
**/
void
soup_connection_disconnect (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
g_return_if_fail (SOUP_IS_CONNECTION (conn));
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
if (!priv->socket)
return;
g_signal_handlers_disconnect_by_func (priv->socket,
socket_disconnected, conn);
soup_socket_disconnect (priv->socket);
g_object_unref (priv->socket);
priv->socket = NULL;
/* Don't emit "disconnected" if we aren't yet connected */
if (priv->state < SOUP_CONNECTION_IDLE)
return;
soup_connection_set_state (conn, SOUP_CONNECTION_DISCONNECTED);
/* NB: this might cause conn to be destroyed. */
g_signal_emit (conn, signals[DISCONNECTED], 0);
}
/**
* soup_connection_disconnect:
* @conn: a connection
*
* Disconnects @conn's socket and emits a %disconnected signal.
* After calling this, @conn will be essentially useless.
**/
void
soup_connection_disconnect (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
SoupConnectionState old_state;
g_return_if_fail (SOUP_IS_CONNECTION (conn));
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
old_state = priv->state;
if (old_state != SOUP_CONNECTION_DISCONNECTED)
soup_connection_set_state (conn, SOUP_CONNECTION_DISCONNECTED);
if (priv->socket) {
SoupSocket *socket = priv->socket;
g_signal_handlers_disconnect_by_func (socket, G_CALLBACK (re_emit_socket_event), conn);
priv->socket = NULL;
soup_socket_disconnect (socket);
g_object_unref (socket);
}
if (old_state != SOUP_CONNECTION_DISCONNECTED)
g_signal_emit (conn, signals[DISCONNECTED], 0);
}
gboolean
soup_connection_get_ever_used (SoupConnection *conn)
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
return SOUP_CONNECTION_GET_PRIVATE (conn)->unused_timeout == 0;
}
void
soup_connection_set_state (SoupConnection *conn, SoupConnectionState state)
{
SoupConnectionPrivate *priv;
g_return_if_fail (SOUP_IS_CONNECTION (conn));
g_return_if_fail (state >= SOUP_CONNECTION_NEW &&
state <= SOUP_CONNECTION_DISCONNECTED);
g_object_freeze_notify (G_OBJECT (conn));
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
if (priv->current_msg) {
g_warn_if_fail (state == SOUP_CONNECTION_IDLE ||
state == SOUP_CONNECTION_DISCONNECTED);
clear_current_msg (conn);
}
if (state == SOUP_CONNECTION_IDLE && !priv->reusable) {
/* This will recursively call set_state() */
soup_connection_disconnect (conn);
} else {
priv->state = state;
if (priv->state == SOUP_CONNECTION_IDLE)
start_idle_timer (conn);
g_object_notify (G_OBJECT (conn), "state");
}
g_object_thaw_notify (G_OBJECT (conn));
}
/**
* soup_connection_connect_async:
* @conn: the connection
* @callback: callback to call when the connection succeeds or fails
* @user_data: data for @callback
*
* Asynchronously connects @conn.
**/
void
soup_connection_connect_async (SoupConnection *conn,
SoupConnectionCallback callback,
gpointer user_data)
{
SoupConnectionAsyncConnectData *data;
SoupConnectionPrivate *priv;
g_return_if_fail (SOUP_IS_CONNECTION (conn));
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_return_if_fail (priv->socket == NULL);
soup_connection_set_state (conn, SOUP_CONNECTION_CONNECTING);
data = g_slice_new (SoupConnectionAsyncConnectData);
data->conn = conn;
data->callback = callback;
data->callback_data = user_data;
priv->socket =
soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, priv->remote_addr,
SOUP_SOCKET_SSL_CREDENTIALS, priv->ssl_creds,
SOUP_SOCKET_ASYNC_CONTEXT, priv->async_context,
SOUP_SOCKET_TIMEOUT, priv->io_timeout,
NULL);
soup_socket_connect_async (priv->socket, NULL,
socket_connect_result, data);
}
static void
socket_connect_result (SoupSocket *sock, guint status, gpointer user_data)
{
SoupConnectionAsyncConnectData *data = user_data;
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (data->conn);
if (!SOUP_STATUS_IS_SUCCESSFUL (status))
goto done;
if (priv->ssl_creds && !priv->tunnel_addr) {
if (!soup_socket_start_ssl (sock, NULL)) {
status = SOUP_STATUS_SSL_FAILED;
goto done;
}
}
g_signal_connect (priv->socket, "disconnected",
G_CALLBACK (socket_disconnected), data->conn);
soup_connection_set_state (data->conn, SOUP_CONNECTION_IDLE);
priv->unused_timeout = time (NULL) + SOUP_CONNECTION_UNUSED_TIMEOUT;
start_idle_timer (data->conn);
done:
if (data->callback) {
if (priv->proxy_uri != NULL)
status = soup_status_proxify (status);
data->callback (data->conn, status, data->callback_data);
}
g_slice_free (SoupConnectionAsyncConnectData, data);
}
static void
socket_connect_complete (GObject *object, GAsyncResult *result, gpointer user_data)
{
SoupSocket *sock = SOUP_SOCKET (object);
GTask *task = user_data;
SoupConnection *conn = g_task_get_source_object (task);
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
GError *error = NULL;
if (!soup_socket_connect_finish_internal (sock, result, &error)) {
socket_connect_finished (task, sock, error);
return;
}
priv->proxy_uri = soup_socket_get_http_proxy_uri (sock);
if (priv->ssl && !priv->proxy_uri) {
soup_socket_handshake_async (sock, priv->remote_uri->host,
g_task_get_cancellable (task),
socket_handshake_complete, task);
return;
}
socket_connect_finished (task, sock, NULL);
}
gboolean
soup_connection_is_via_proxy (SoupConnection *conn)
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
return SOUP_CONNECTION_GET_PRIVATE (conn)->proxy_uri != NULL;
}
SoupConnectionState
soup_connection_get_state (SoupConnection *conn)
{
g_return_val_if_fail (SOUP_IS_CONNECTION (conn),
SOUP_CONNECTION_DISCONNECTED);
return SOUP_CONNECTION_GET_PRIVATE (conn)->state;
}
SoupAddress *
soup_connection_get_tunnel_addr (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), NULL);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
return priv->tunnel_addr;
}
static void
soup_connection_dispose (GObject *object)
{
SoupConnection *conn = SOUP_CONNECTION (object);
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
stop_idle_timer (priv);
G_OBJECT_CLASS (soup_connection_parent_class)->dispose (object);
}
gboolean
soup_connection_is_tunnelled (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
return priv->ssl && priv->proxy_uri != NULL;
}
gboolean
soup_connection_connect_sync (SoupConnection *conn,
GCancellable *cancellable,
GError **error)
{
SoupConnectionPrivate *priv;
SoupAddress *remote_addr;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_return_val_if_fail (priv->socket == NULL, FALSE);
soup_connection_set_state (conn, SOUP_CONNECTION_CONNECTING);
/* Set the protocol to ensure correct proxy resolution. */
remote_addr =
g_object_new (SOUP_TYPE_ADDRESS,
SOUP_ADDRESS_NAME, priv->remote_uri->host,
SOUP_ADDRESS_PORT, priv->remote_uri->port,
SOUP_ADDRESS_PROTOCOL, priv->remote_uri->scheme,
NULL);
priv->socket =
soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, remote_addr,
SOUP_SOCKET_SSL_FALLBACK, priv->ssl_fallback,
SOUP_SOCKET_SOCKET_PROPERTIES, priv->socket_props,
SOUP_SOCKET_FLAG_NONBLOCKING, FALSE,
NULL);
g_object_unref (remote_addr);
g_signal_connect (priv->socket, "event",
G_CALLBACK (re_emit_socket_event), conn);
if (!soup_socket_connect_sync_internal (priv->socket, cancellable, error))
return FALSE;
priv->proxy_uri = soup_socket_get_http_proxy_uri (priv->socket);
if (priv->ssl && !priv->proxy_uri) {
if (!soup_socket_handshake_sync (priv->socket,
priv->remote_uri->host,
cancellable, error))
return FALSE;
}
if (!priv->ssl || !priv->proxy_uri) {
soup_connection_event (conn,
G_SOCKET_CLIENT_COMPLETE,
NULL);
}
soup_connection_set_state (conn, SOUP_CONNECTION_IN_USE);
priv->unused_timeout = time (NULL) + SOUP_CONNECTION_UNUSED_TIMEOUT;
start_idle_timer (conn);
return TRUE;
}
void
soup_connection_set_state (SoupConnection *conn, SoupConnectionState state)
{
g_return_if_fail (SOUP_IS_CONNECTION (conn));
g_return_if_fail (state > SOUP_CONNECTION_NEW &&
state < SOUP_CONNECTION_DISCONNECTED);
SOUP_CONNECTION_GET_PRIVATE (conn)->state = state;
if (state == SOUP_CONNECTION_IDLE)
clear_current_request (conn);
}
static void
start_idle_timer (SoupConnection *conn)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
if (priv->socket_props->idle_timeout > 0 && !priv->idle_timeout_src) {
priv->idle_timeout_src =
soup_add_timeout (priv->socket_props->async_context,
priv->socket_props->idle_timeout * 1000,
idle_timeout, conn);
}
}
static void
clear_current_msg (SoupConnection *conn)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
SoupMessage *msg;
msg = priv->current_msg;
priv->current_msg = NULL;
g_signal_handlers_disconnect_by_func (msg, G_CALLBACK (current_msg_got_body), conn);
g_object_unref (msg);
}
static void
soup_connection_event (SoupConnection *conn,
GSocketClientEvent event,
GIOStream *connection)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
if (!connection && priv->socket)
connection = soup_socket_get_connection (priv->socket);
g_signal_emit (conn, signals[EVENT], 0,
event, connection);
}
/**
* soup_connection_connect_sync:
* @conn: the connection
*
* Synchronously connects @conn.
*
* Return value: the soup status
**/
guint
soup_connection_connect_sync (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
guint status;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), SOUP_STATUS_MALFORMED);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_return_val_if_fail (priv->socket == NULL, SOUP_STATUS_MALFORMED);
soup_connection_set_state (conn, SOUP_CONNECTION_CONNECTING);
priv->socket =
soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, priv->remote_addr,
SOUP_SOCKET_SSL_CREDENTIALS, priv->ssl_creds,
SOUP_SOCKET_FLAG_NONBLOCKING, FALSE,
SOUP_SOCKET_TIMEOUT, priv->io_timeout,
NULL);
status = soup_socket_connect_sync (priv->socket, NULL);
if (!SOUP_STATUS_IS_SUCCESSFUL (status))
goto fail;
g_signal_connect (priv->socket, "disconnected",
G_CALLBACK (socket_disconnected), conn);
if (priv->ssl_creds && !priv->tunnel_addr) {
if (!soup_socket_start_ssl (priv->socket, NULL)) {
status = SOUP_STATUS_SSL_FAILED;
goto fail;
}
}
if (SOUP_STATUS_IS_SUCCESSFUL (status)) {
soup_connection_set_state (conn, SOUP_CONNECTION_IDLE);
priv->unused_timeout = time (NULL) + SOUP_CONNECTION_UNUSED_TIMEOUT;
start_idle_timer (conn);
} else {
fail:
if (priv->socket) {
g_object_unref (priv->socket);
priv->socket = NULL;
}
}
if (priv->proxy_uri != NULL)
status = soup_status_proxify (status);
return status;
}
gboolean
soup_connection_start_ssl (SoupConnection *conn)
{
SoupConnectionPrivate *priv;
const char *server_name;
g_return_val_if_fail (SOUP_IS_CONNECTION (conn), FALSE);
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
server_name = soup_address_get_name (priv->tunnel_addr ?
priv->tunnel_addr :
priv->remote_addr);
return soup_socket_start_proxy_ssl (priv->socket, server_name, NULL);
}
static void
dispose (GObject *object)
{
SoupConnection *conn = SOUP_CONNECTION (object);
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
stop_idle_timer (priv);
/* Make sure clear_current_request doesn't re-establish the timeout */
priv->idle_timeout = 0;
clear_current_request (conn);
soup_connection_disconnect (conn);
G_OBJECT_CLASS (soup_connection_parent_class)->dispose (object);
}
/**
* soup_connection_send_request:
* @conn: a #SoupConnection
* @req: a #SoupMessage
*
* Sends @req on @conn. This is a low-level function, intended for use
* by #SoupSession.
**/
void
soup_connection_send_request (SoupConnection *conn, SoupMessage *req)
{
SoupConnectionPrivate *priv;
g_return_if_fail (SOUP_IS_CONNECTION (conn));
g_return_if_fail (SOUP_IS_MESSAGE (req));
priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_return_if_fail (priv->state != SOUP_CONNECTION_NEW && priv->state != SOUP_CONNECTION_DISCONNECTED);
if (req != priv->cur_req)
set_current_request (conn, req);
soup_message_send_request (req, priv->socket, conn,
priv->proxy_uri != NULL);
}
static void
start_ssl_completed (GObject *object, GAsyncResult *result, gpointer user_data)
{
GTask *task = user_data;
SoupConnection *conn = g_task_get_source_object (task);
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
GError *error = NULL;
if (soup_socket_handshake_finish (priv->socket, result, &error)) {
soup_connection_event (conn, G_SOCKET_CLIENT_COMPLETE, NULL);
g_task_return_boolean (task, TRUE);
} else
g_task_return_error (task, error);
g_object_unref (task);
}
