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); } } }