static dlr_host_server_t *prv_host_server_new(const gchar *device_if,
guint port,
GError **error)
{
dlr_host_server_t *server = NULL;
SoupAddress *addr;
addr = soup_address_new(device_if, port);
if (soup_address_resolve_sync(addr, NULL) != SOUP_STATUS_OK) {
*error = g_error_new(DLEYNA_SERVER_ERROR,
DLEYNA_ERROR_HOST_FAILED,
"Unable to create host server on %s",
device_if);
goto on_error;
}
server = g_new(dlr_host_server_t, 1);
server->files = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, prv_host_file_delete);
server->soup_server = soup_server_new(SOUP_SERVER_INTERFACE, addr,
NULL);
soup_server_add_handler(server->soup_server, DLR_HOST_SERVICE_ROOT,
prv_soup_server_cb, server, NULL);
soup_server_run_async(server->soup_server);
server->counter = 0;
on_error:
g_object_unref(addr);
return server;
}
static void
resolved_proxy_uri (SoupProxyURIResolver *proxy_resolver,
guint status, SoupURI *proxy_uri, gpointer user_data)
{
SoupMessageQueueItem *item = user_data;
SoupSession *session = item->session;
if (item_failed (item, status))
return;
if (proxy_uri) {
SoupAddress *proxy_addr;
item->state = SOUP_MESSAGE_RESOLVING_PROXY_ADDRESS;
item->proxy_uri = soup_uri_copy (proxy_uri);
proxy_addr = soup_address_new (proxy_uri->host,
proxy_uri->port);
soup_address_resolve_async (proxy_addr,
soup_session_get_async_context (session),
item->cancellable,
resolved_proxy_addr, item);
g_object_unref (proxy_addr);
return;
}
item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
soup_message_queue_item_unref (item);
/* If we got here we know session still exists */
run_queue ((SoupSessionAsync *)session);
}
int
main (int argc, char **argv)
{
SoupAddress *addr;
int i;
if (argc < 2)
usage ();
g_thread_init (NULL);
g_type_init ();
for (i = 1; i < argc; i++) {
addr = soup_address_new (argv[i], 0);
if (!addr) {
fprintf (stderr, "Could not parse address %s\n", argv[1]);
exit (1);
}
soup_address_resolve_async (addr, NULL, NULL,
resolve_callback, NULL);
nlookups++;
}
loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
static SoupSessionHost *
soup_session_host_new (SoupSession *session, SoupURI *uri)
{
SoupSessionHost *host;
host = g_slice_new0 (SoupSessionHost);
host->uri = soup_uri_copy_host (uri);
host->addr = soup_address_new (host->uri->host, host->uri->port);
return host;
}
static void
do_ipv6_test (void)
{
SoupServer *ipv6_server;
SoupURI *ipv6_uri;
SoupAddress *ipv6_addr;
SoupSession *session;
SoupMessage *msg;
debug_printf (1, "\nIPv6 server test\n");
ipv6_addr = soup_address_new ("::1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (ipv6_addr, NULL);
ipv6_server = soup_server_new (SOUP_SERVER_INTERFACE, ipv6_addr,
NULL);
g_object_unref (ipv6_addr);
soup_server_add_handler (ipv6_server, NULL, ipv6_server_callback, NULL, NULL);
soup_server_run_async (ipv6_server);
ipv6_uri = soup_uri_new ("http://[::1]/");
soup_uri_set_port (ipv6_uri, soup_server_get_port (ipv6_server));
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
debug_printf (1, " HTTP/1.1\n");
msg = soup_message_new_from_uri ("GET", ipv6_uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " request failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
debug_printf (1, " HTTP/1.0\n");
msg = soup_message_new_from_uri ("GET", ipv6_uri);
soup_message_set_http_version (msg, SOUP_HTTP_1_0);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " request failed: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
soup_uri_free (ipv6_uri);
soup_test_session_abort_unref (session);
soup_test_server_quit_unref (ipv6_server);
}
SoupServer *
soupcut_server_take_new (GMainContext *context)
{
SoupServer *server;
SoupAddress *address;
address = soup_address_new("localhost", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync(address, NULL);
server = soup_server_new(SOUP_SERVER_INTERFACE, address,
SOUP_SERVER_ASYNC_CONTEXT, context,
NULL);
g_object_unref(address);
return soupcut_server_take(server);
}
static void
seahorse_ldap_source_connect_async (SeahorseLDAPSource *source,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *res;
source_connect_closure *closure;
gchar *server = NULL;
gchar *pos;
#ifdef WITH_SOUP
SoupAddress *address;
#endif
res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
seahorse_ldap_source_connect_async);
closure = g_new0 (source_connect_closure, 1);
closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
g_simple_async_result_set_op_res_gpointer (res, closure, source_connect_free);
g_object_get (source, "key-server", &server, NULL);
g_return_if_fail (server && server[0]);
if ((pos = strchr (server, ':')) != NULL)
*pos = 0;
seahorse_progress_prep_and_begin (cancellable, res, NULL);
/* If we have libsoup, try and resolve asynchronously */
#ifdef WITH_SOUP
address = soup_address_new (server, LDAP_PORT);
seahorse_progress_update (cancellable, res, _("Resolving server address: %s"), server);
soup_address_resolve_async (address, NULL, cancellable,
on_address_resolved_complete,
g_object_ref (res));
g_object_unref (address);
#else /* !WITH_SOUP */
once_resolved_start_connect (source, res, server);
#endif
g_free (server);
g_object_unref (res);
}
static SoupServer *
test_server_new (gboolean in_own_thread, gboolean ssl)
{
SoupServer *server;
GMainContext *async_context;
const char *ssl_cert_file, *ssl_key_file;
SoupAddress *addr;
async_context = in_own_thread ? g_main_context_new () : NULL;
if (ssl) {
ssl_cert_file = SRCDIR "/test-cert.pem";
ssl_key_file = SRCDIR "/test-key.pem";
} else
ssl_cert_file = ssl_key_file = NULL;
addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (addr, NULL);
server = soup_server_new (SOUP_SERVER_INTERFACE, addr,
SOUP_SERVER_ASYNC_CONTEXT, async_context,
SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
SOUP_SERVER_SSL_KEY_FILE, ssl_key_file,
NULL);
g_object_unref (addr);
if (async_context)
g_main_context_unref (async_context);
if (!server) {
fprintf (stderr, "Unable to create server\n");
exit (1);
}
if (in_own_thread) {
GThread *thread;
thread = g_thread_create (run_server_thread, server,
TRUE, NULL);
g_object_set_data (G_OBJECT (server), "thread", thread);
} else
soup_server_run_async (server);
return server;
}
WebKitTestServer::WebKitTestServer(ServerType type)
{
GUniquePtr<char> sslCertificateFile;
GUniquePtr<char> sslKeyFile;
if (type == ServerHTTPS) {
CString resourcesDir = Test::getResourcesDir();
sslCertificateFile.reset(g_build_filename(resourcesDir.data(), "test-cert.pem", NULL));
sslKeyFile.reset(g_build_filename(resourcesDir.data(), "test-key.pem", NULL));
}
GRefPtr<SoupAddress> address = adoptGRef(soup_address_new("127.0.0.1", SOUP_ADDRESS_ANY_PORT));
soup_address_resolve_sync(address.get(), 0);
m_soupServer = adoptGRef(soup_server_new(SOUP_SERVER_INTERFACE, address.get(),
SOUP_SERVER_SSL_CERT_FILE, sslCertificateFile.get(),
SOUP_SERVER_SSL_KEY_FILE, sslKeyFile.get(), nullptr));
m_baseURI = type == ServerHTTPS ? soup_uri_new("https://127.0.0.1/") : soup_uri_new("http://127.0.0.1/");
soup_uri_set_port(m_baseURI, soup_server_get_port(m_soupServer.get()));
}
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;
}
gboolean
rcd_rpc_remote_server_start (void)
{
SoupServerAuthContext auth_ctx = { 0 };
int port = rcd_prefs_get_remote_server_port ();
const char *bind_ip;
/* Server's already running... */
if (soup_server != NULL)
return TRUE;
rc_debug (RC_DEBUG_LEVEL_MESSAGE, "Starting remote server");
bind_ip = rcd_prefs_get_bind_ipaddress ();
if (bind_ip) {
SoupAddress *bind_address;
bind_address = soup_address_new (bind_ip, port);
if (!bind_address) {
rc_debug (RC_DEBUG_LEVEL_ERROR,
"Unable to bind remote server to '%s'", bind_ip);
return FALSE;
}
if (soup_address_resolve_sync (bind_address) != SOUP_STATUS_OK) {
rc_debug (RC_DEBUG_LEVEL_ERROR,
"Unable to bind remote server to '%s': Unable to "
"resolve address", bind_ip);
return FALSE;
}
soup_server = soup_server_new (SOUP_SERVER_INTERFACE, bind_address,
SOUP_SERVER_PORT, port,
SOUP_SERVER_SSL_CERT_FILE, SHAREDIR"/rcd.pem",
SOUP_SERVER_SSL_KEY_FILE, SHAREDIR"/rcd.pem",
NULL);
g_object_unref (bind_address);
} else {
soup_server = soup_server_new (SOUP_SERVER_PORT, port,
SOUP_SERVER_SSL_CERT_FILE, SHAREDIR"/rcd.pem",
SOUP_SERVER_SSL_KEY_FILE, SHAREDIR"/rcd.pem",
NULL);
}
if (!soup_server) {
rc_debug (RC_DEBUG_LEVEL_ERROR, "Could not start RPC server on port %d", port);
rc_debug (RC_DEBUG_LEVEL_ERROR, "(This may mean that another rcd process is already running, or that");
rc_debug (RC_DEBUG_LEVEL_ERROR, "you are not running as root and do not have the correct privileges");
rc_debug (RC_DEBUG_LEVEL_ERROR, "on this port.)");
return FALSE;
}
g_object_set (G_OBJECT (soup_server_get_listener (soup_server)),
SOUP_SOCKET_FLAG_CLOEXEC, TRUE,
NULL);
auth_ctx.types = SOUP_AUTH_TYPE_DIGEST;
auth_ctx.callback = soup_auth_callback;
auth_ctx.digest_info.realm = "RCD";
auth_ctx.digest_info.allow_algorithms = SOUP_ALGORITHM_MD5;
auth_ctx.digest_info.force_integrity = FALSE;
soup_server_add_handler (soup_server, "/RPC2", &auth_ctx,
soup_rpc_callback, NULL, NULL);
soup_server_add_handler (soup_server, NULL, NULL,
soup_default_callback, NULL, NULL);
soup_server_run_async (soup_server);
g_object_unref (soup_server);
notify_port_change (port);
return TRUE;
}
static void
do_callback_unref_test (void)
{
SoupServer *bad_server;
SoupAddress *addr;
SoupSession *session;
SoupMessage *one, *two;
GMainLoop *loop;
char *bad_uri;
debug_printf (1, "\nCallback unref handling\n");
/* Get a guaranteed-bad URI */
addr = soup_address_new ("127.0.0.1", SOUP_ADDRESS_ANY_PORT);
soup_address_resolve_sync (addr, NULL);
bad_server = soup_server_new (SOUP_SERVER_INTERFACE, addr,
NULL);
g_object_unref (addr);
bad_uri = g_strdup_printf ("http://127.0.0.1:%u/",
soup_server_get_port (bad_server));
g_object_unref (bad_server);
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_object_add_weak_pointer (G_OBJECT (session), (gpointer *)&session);
loop = g_main_loop_new (NULL, TRUE);
one = soup_message_new ("GET", bad_uri);
g_object_add_weak_pointer (G_OBJECT (one), (gpointer *)&one);
two = soup_message_new ("GET", bad_uri);
g_object_add_weak_pointer (G_OBJECT (two), (gpointer *)&two);
g_free (bad_uri);
soup_session_queue_message (session, one, cu_one_completed, loop);
soup_session_queue_message (session, two, cu_two_completed, loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
if (session) {
g_object_remove_weak_pointer (G_OBJECT (session), (gpointer *)&session);
debug_printf (1, " Session not destroyed?\n");
errors++;
g_object_unref (session);
}
if (one) {
g_object_remove_weak_pointer (G_OBJECT (one), (gpointer *)&one);
debug_printf (1, " Message 1 not destroyed?\n");
errors++;
g_object_unref (one);
}
if (two) {
g_object_remove_weak_pointer (G_OBJECT (two), (gpointer *)&two);
debug_printf (1, " Message 2 not destroyed?\n");
errors++;
g_object_unref (two);
}
/* Otherwise, if we haven't crashed, we're ok. */
}
//this will insert proxy in the session
//and queue the message to be sent
void
proxify_session_async(EProxy *proxy, STNET *stnet)
{
SoupURI *proxy_uri = NULL, *su;
#if EVOLUTION_VERSION < 30304
gint ptype = gconf_client_get_int (
rss_gconf, KEY_GCONF_EVO_PROXY_TYPE, NULL);
#else
GSettings *settings = g_settings_new(CONF_SCHEMA_EVO_NETWORK);
gint ptype = g_settings_get_int (
settings, CONF_EVO_PROXY_TYPE);
#endif
switch (ptype) {
#ifndef HAVE_LIBSOUP_GNOME
case 0:
#endif
case 2:
su = soup_uri_new (stnet->url);
stnet->host = su->host;
if (su) {
if (su->scheme == SOUP_URI_SCHEME_HTTPS) {
if (rss_ep_need_proxy_https (proxy, su->host)) {
#if (DATASERVER_VERSION >=2026000)
proxy_uri = e_proxy_peek_uri_for (proxy, stnet->url);
#else
g_print("WARN: e_proxy_peek_uri_for() requires evolution-data-server 2.26\n");
soup_uri_free(su);
return;
#endif
if (proxy_uri) {
d("proxified %s with %s:%d\n", stnet->url, proxy_uri->host, proxy_uri->port);
}
} else {
d("no PROXY-%s\n", stnet->url);
}
g_object_set (
G_OBJECT (stnet->ss),
SOUP_SESSION_PROXY_URI,
proxy_uri, NULL);
soup_uri_free(su);
goto out;
} else {
stnet->addr = soup_address_new (su->host, 0);
soup_uri_free(su);
soup_address_resolve_async (stnet->addr, NULL, NULL,
rss_resolve_callback, stnet);
return;
}
}
break;
#ifdef HAVE_LIBSOUP_GNOME
case 0:
soup_session_add_feature_by_type (
stnet->ss, SOUP_TYPE_PROXY_RESOLVER_DEFAULT);
break;
#endif
}
out: stnet->callback(stnet->data);
//free stnet
}
