static void finalize (GObject *object) { SoupSession *session = SOUP_SESSION (object); SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); soup_message_queue_destroy (priv->queue); g_mutex_free (priv->host_lock); g_hash_table_destroy (priv->hosts); g_hash_table_destroy (priv->conns); g_free (priv->user_agent); if (priv->auth_manager) g_object_unref (priv->auth_manager); if (priv->ssl_creds) soup_ssl_free_client_credentials (priv->ssl_creds); if (priv->async_context) g_main_context_unref (priv->async_context); G_OBJECT_CLASS (soup_session_parent_class)->finalize (object); }
static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { SoupSession *session = SOUP_SESSION (object); SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupURI *uri; gboolean ca_file_changed = FALSE; const char *new_ca_file, *user_agent; switch (prop_id) { case PROP_PROXY_URI: uri = g_value_get_boxed (value); if (uri) { soup_session_remove_feature_by_type (session, SOUP_TYPE_PROXY_RESOLVER); priv->proxy_resolver = SOUP_PROXY_URI_RESOLVER (soup_proxy_resolver_static_new (uri)); soup_session_add_feature (session, SOUP_SESSION_FEATURE (priv->proxy_resolver)); g_object_unref (priv->proxy_resolver); } else if (priv->proxy_resolver && SOUP_IS_PROXY_RESOLVER_STATIC (priv->proxy_resolver)) soup_session_remove_feature_by_type (session, SOUP_TYPE_PROXY_RESOLVER); soup_session_abort (session); break; case PROP_MAX_CONNS: priv->max_conns = g_value_get_int (value); break; case PROP_MAX_CONNS_PER_HOST: priv->max_conns_per_host = g_value_get_int (value); break; case PROP_USE_NTLM: g_object_set_property (G_OBJECT (priv->auth_manager), SOUP_AUTH_MANAGER_NTLM_USE_NTLM, value); break; case PROP_SSL_CA_FILE: new_ca_file = g_value_get_string (value); if (!safe_str_equal (priv->ssl_ca_file, new_ca_file)) ca_file_changed = TRUE; g_free (priv->ssl_ca_file); priv->ssl_ca_file = g_strdup (new_ca_file); if (ca_file_changed && priv->ssl_creds) { soup_ssl_free_client_credentials (priv->ssl_creds); priv->ssl_creds = NULL; } break; case PROP_ASYNC_CONTEXT: priv->async_context = g_value_get_pointer (value); if (priv->async_context) g_main_context_ref (priv->async_context); break; case PROP_TIMEOUT: priv->io_timeout = g_value_get_uint (value); break; case PROP_USER_AGENT: g_free (priv->user_agent); user_agent = g_value_get_string (value); if (!user_agent) priv->user_agent = NULL; else if (!*user_agent) { priv->user_agent = g_strdup (SOUP_SESSION_USER_AGENT_BASE); } else if (g_str_has_suffix (user_agent, " ")) { priv->user_agent = g_strdup_printf ("%s%s", user_agent, SOUP_SESSION_USER_AGENT_BASE); } else priv->user_agent = g_strdup (user_agent); break; case PROP_IDLE_TIMEOUT: priv->idle_timeout = g_value_get_uint (value); break; case PROP_ADD_FEATURE: soup_session_add_feature (session, g_value_get_object (value)); break; case PROP_ADD_FEATURE_BY_TYPE: soup_session_add_feature_by_type (session, g_value_get_gtype (value)); break; case PROP_REMOVE_FEATURE_BY_TYPE: soup_session_remove_feature_by_type (session, g_value_get_gtype (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
int main (int argc, char **argv) { int opt, debug = 0, listener, sin_len, port, i; struct sockaddr_in sin; GThread *server; char writebuf[BUFSIZE], readbuf[BUFSIZE]; SoupAddress *addr; SoupSSLCredentials *creds; SoupSocket *sock; gsize n, total; SoupSocketIOStatus status; int connect_status; GError *error = NULL; g_thread_init (NULL); g_type_init (); /* On Windows, this will call WSAStartup() */ soup_socket_get_type (); while ((opt = getopt (argc, argv, "c:d:k:")) != -1) { switch (opt) { case 'c': ssl_cert_file = optarg; break; case 'd': debug = atoi (optarg); break; case 'k': ssl_key_file = optarg; break; case '?': fprintf (stderr, "Usage: %s [-d debuglevel] [-c ssl-cert-file] [-k ssl-key-file]\n", argv[0]); break; } } if (debug) { gnutls_global_set_log_function (debug_log); gnutls_global_set_log_level (debug); } /* Create server socket */ listener = socket (AF_INET, SOCK_STREAM, 0); if (listener == -1) { SOCKET_PRINT_ERROR ("creating listening socket"); exit (1); } memset (&sin, 0, sizeof (sin)); sin.sin_family = AF_INET; sin.sin_addr.s_addr = ntohl (INADDR_LOOPBACK); if (bind (listener, (struct sockaddr *) &sin, sizeof (sin)) == -1) { SOCKET_PRINT_ERROR ("binding listening socket"); exit (1); } if (listen (listener, 1) == -1) { SOCKET_PRINT_ERROR ("listening on socket"); exit (1); } sin_len = sizeof (sin); getsockname (listener, (struct sockaddr *)&sin, (void *)&sin_len); port = ntohs (sin.sin_port); /* Create the client */ addr = soup_address_new ("127.0.0.1", port); creds = soup_ssl_get_client_credentials (NULL); sock = soup_socket_new (SOUP_SOCKET_REMOTE_ADDRESS, addr, SOUP_SOCKET_FLAG_NONBLOCKING, FALSE, SOUP_SOCKET_SSL_CREDENTIALS, creds, NULL); g_object_unref (addr); connect_status = soup_socket_connect_sync (sock, NULL); if (connect_status != SOUP_STATUS_OK) { g_error ("Could not create client socket: %s", soup_status_get_phrase (connect_status)); } soup_socket_start_ssl (sock, NULL); /* Now spawn server thread */ server = g_thread_create (server_thread, GINT_TO_POINTER (listener), TRUE, NULL); /* Synchronous client test */ for (i = 0; i < BUFSIZE; i++) writebuf[i] = i & 0xFF; total = 0; while (total < BUFSIZE) { status = soup_socket_write (sock, writebuf + total, BUFSIZE - total, &n, NULL, &error); if (status != SOUP_SOCKET_OK) g_error ("Sync write got status %d: %s", status, error ? error->message : "(unknown)"); total += n; } total = 0; while (total < BUFSIZE) { status = soup_socket_read (sock, readbuf + total, BUFSIZE - total, &n, NULL, &error); if (status != SOUP_SOCKET_OK) g_error ("Sync read got status %d: %s", status, error ? error->message : "(unknown)"); total += n; } if (memcmp (writebuf, readbuf, BUFSIZE) != 0) g_error ("Sync read didn't match write"); printf ("SYNCHRONOUS SSL TEST PASSED\n"); /* Switch socket to async and do it again */ g_object_set (sock, SOUP_SOCKET_FLAG_NONBLOCKING, TRUE, NULL); g_idle_add (start_writing, sock); loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); g_main_loop_unref (loop); g_main_context_unref (g_main_context_default ()); printf ("ASYNCHRONOUS SSL TEST PASSED\n"); g_object_unref (sock); soup_ssl_free_client_credentials (creds); g_thread_join (server); /* Success */ return 0; }