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));
}
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
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));
}
static void transmit_done() {
transmit_is_done = true;
if (wake_state == LPM_WAKE_W4_TX_DONE) {
wake_state = LPM_WAKE_W4_TIMEOUT;
start_idle_timer();
}
}
void
cur_proj_set (GttProject *proj)
{
/* Due to the way the widget callbacks work,
* we may be called recursively ... */
if (cur_proj == proj) return;
log_proj(NULL);
gtt_project_timer_stop (cur_proj);
gtt_status_icon_stop_timer (proj);
run_shell_command (cur_proj, FALSE);
GttProject *old_prj = cur_proj;
if (proj)
{
if (timer_is_running ())
{
stop_main_timer ();
}
cur_proj = proj;
gtt_project_timer_start (proj);
gtt_status_icon_start_timer (proj);
run_shell_command (cur_proj, TRUE);
start_idle_timer ();
start_main_timer ();
}
else
{
if (timer_is_running ())
{
stop_main_timer ();
}
cur_proj = NULL;
start_no_project_timer ();
}
log_proj(proj);
if (old_prj)
{
gtt_projects_tree_update_project_data (projects_tree, old_prj);
}
if (cur_proj)
{
gtt_projects_tree_update_project_data (projects_tree, cur_proj);
}
/* update GUI elements */
menu_set_states();
toolbar_set_states();
if (proj)
{
prop_dialog_set_project(proj);
notes_area_set_project (global_na, proj);
}
update_status_bar();
}
static void allow_device_sleep() {
if (state == LPM_ENABLED && wake_state == LPM_WAKE_ASSERTED) {
if (transmit_is_done) {
wake_state = LPM_WAKE_W4_TIMEOUT;
start_idle_timer();
} else {
wake_state = LPM_WAKE_W4_TX_DONE;
}
}
}
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;
}
/**
* 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;
}
static void
socket_connect_finished (GTask *task, SoupSocket *sock, GError *error)
{
SoupConnection *conn = g_task_get_source_object (task);
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
if (!error) {
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);
g_task_return_boolean (task, TRUE);
} else
g_task_return_error (task, error);
g_object_unref (task);
}
static void
clear_current_request (SoupConnection *conn)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
if (priv->state == SOUP_CONNECTION_IN_USE)
priv->state = SOUP_CONNECTION_IDLE;
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;
if (!soup_message_is_keepalive (cur_req))
soup_connection_disconnect (conn);
else {
priv->last_used = time (NULL);
soup_message_io_stop (cur_req);
}
}
}
