GIOStream *
soup_socket_get_connection (SoupSocket *sock)
{
g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
return SOUP_SOCKET_GET_PRIVATE (sock)->conn;
}
GIOStream *
soup_socket_get_iostream (SoupSocket *sock)
{
g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
return SOUP_SOCKET_GET_PRIVATE (sock)->iostream;
}
GSocket *
soup_socket_get_gsocket (SoupSocket *sock)
{
g_return_val_if_fail (SOUP_IS_SOCKET (sock), NULL);
return SOUP_SOCKET_GET_PRIVATE (sock)->gsock;
}
/**
* soup_socket_get_fd:
* @sock: a #SoupSocket
*
* Gets @sock's underlying file descriptor.
*
* Note that fiddling with the file descriptor may break the
* #SoupSocket.
*
* Return value: @sock's file descriptor.
*/
int
soup_socket_get_fd (SoupSocket *sock)
{
g_return_val_if_fail (SOUP_IS_SOCKET (sock), -1);
return g_socket_get_fd (SOUP_SOCKET_GET_PRIVATE (sock)->gsock);
}
/**
* soup_socket_connect_sync:
* @sock: a client #SoupSocket (which must not already be connected)
* @cancellable: a #GCancellable, or %NULL
*
* Attempt to synchronously connect @sock to its remote address.
*
* If @cancellable is non-%NULL, it can be used to cancel the
* connection, in which case soup_socket_connect_sync() will return
* %SOUP_STATUS_CANCELLED.
*
* Return value: a success or failure code.
**/
guint
soup_socket_connect_sync (SoupSocket *sock, GCancellable *cancellable)
{
SoupSocketPrivate *priv;
GSocketClient *client;
GSocketConnection *conn;
GError *error = NULL;
g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_STATUS_MALFORMED);
priv = SOUP_SOCKET_GET_PRIVATE (sock);
g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED);
g_return_val_if_fail (priv->gsock == NULL, SOUP_STATUS_MALFORMED);
g_return_val_if_fail (priv->remote_addr != NULL, SOUP_STATUS_MALFORMED);
if (cancellable)
g_object_ref (cancellable);
else
cancellable = g_cancellable_new ();
priv->connect_cancel = cancellable;
client = new_socket_client (sock);
conn = g_socket_client_connect (client,
G_SOCKET_CONNECTABLE (priv->remote_addr),
priv->connect_cancel, &error);
g_object_unref (client);
return socket_connected (sock, conn, error);
}
/**
* soup_socket_connect_async:
* @sock: a client #SoupSocket (which must not already be connected)
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to call after connecting
* @user_data: data to pass to @callback
*
* Begins asynchronously connecting to @sock's remote address. The
* socket will call @callback when it succeeds or fails (but not
* before returning from this function).
*
* If @cancellable is non-%NULL, it can be used to cancel the
* connection. @callback will still be invoked in this case, with a
* status of %SOUP_STATUS_CANCELLED.
**/
void
soup_socket_connect_async (SoupSocket *sock, GCancellable *cancellable,
SoupSocketCallback callback, gpointer user_data)
{
SoupSocketPrivate *priv;
SoupSocketAsyncConnectData *sacd;
GSocketClient *client;
g_return_if_fail (SOUP_IS_SOCKET (sock));
priv = SOUP_SOCKET_GET_PRIVATE (sock);
g_return_if_fail (priv->remote_addr != NULL);
sacd = g_slice_new0 (SoupSocketAsyncConnectData);
sacd->sock = g_object_ref (sock);
sacd->callback = callback;
sacd->user_data = user_data;
priv->connect_cancel = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
if (priv->async_context && !priv->use_thread_context)
g_main_context_push_thread_default (priv->async_context);
client = new_socket_client (sock);
g_socket_client_connect_async (client,
G_SOCKET_CONNECTABLE (priv->remote_addr),
priv->connect_cancel,
async_connected, sacd);
g_object_unref (client);
}
static void
soup_logger_request_started (SoupSessionFeature *feature,
SoupSession *session,
SoupMessage *msg,
SoupSocket *socket)
{
SoupLogger *logger = SOUP_LOGGER (feature);
gboolean restarted;
guint msg_id;
g_return_if_fail (SOUP_IS_SESSION (session));
g_return_if_fail (SOUP_IS_MESSAGE (msg));
g_return_if_fail (SOUP_IS_SOCKET (socket));
msg_id = soup_logger_get_id (logger, msg);
if (msg_id)
restarted = TRUE;
else {
soup_logger_set_id (logger, msg);
restarted = FALSE;
}
if (!soup_logger_get_id (logger, session))
soup_logger_set_id (logger, session);
if (!soup_logger_get_id (logger, socket))
soup_logger_set_id (logger, socket);
print_request (logger, msg, session, socket, restarted);
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, ' ', "");
}
