GLibJsonRpcServer *glib_jsonrpc_server_new(int port)
{
GLibJsonRpcServerPrivate *jsonrpc_server = g_new0(GLibJsonRpcServerPrivate, 1);
GError *error = NULL;
jsonrpc_server->service = g_threaded_socket_service_new (10);
jsonrpc_server->async_busy = FALSE;
jsonrpc_server->allow_non_loopback_connections = FALSE;
if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (jsonrpc_server->service),
port,
NULL,
&error))
{
// Silently ignore failed servers and return a NULL server.
// g_printerr ("%s\n", error->message);
g_error_free(error);
g_free(jsonrpc_server);
return NULL;
}
g_signal_connect (jsonrpc_server->service, "run", G_CALLBACK (handler), jsonrpc_server);
jsonrpc_server->command_hash = g_hash_table_new(g_str_hash,
g_str_equal);
return (GLibJsonRpcServer*)jsonrpc_server;
}
void
socket_listen(char *suffix)
{
GSocketService *sock;
GSocketAddress *sa;
GError *err = NULL;
char *name, *path;
name = g_strdup_printf("%s-%s", __NAME__, suffix);
path = g_build_filename(g_get_user_runtime_dir(), name, NULL);
g_free(name);
unlink(path);
sa = g_unix_socket_address_new(path);
g_free(path);
sock = g_threaded_socket_service_new(-1);
if (!g_socket_listener_add_address(G_SOCKET_LISTENER(sock), sa,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT,
NULL, NULL, &err))
{
fprintf(stderr, "Failed to set up socket: '%s'\n", err->message);
exit(EXIT_FAILURE);
}
g_signal_connect(G_OBJECT(sock), "run", G_CALLBACK(sock_incoming), NULL);
g_socket_service_start(sock);
}
int
main (int argc, char *argv[])
{
GSocketService *service;
GOptionContext *context;
GError *error = NULL;
context = g_option_context_new (" - Test GSocket server stuff");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
service = g_threaded_socket_service_new (10);
if (!g_socket_listener_add_inet_port (G_SOCKET_LISTENER (service),
port,
NULL,
&error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
g_print ("Echo service listening on port %d\n", port);
g_signal_connect (service, "run", G_CALLBACK (handler), NULL);
g_main_loop_run (g_main_loop_new (NULL, FALSE));
g_assert_not_reached ();
}
static VALUE
rg_initialize(VALUE self, VALUE max_threads)
{
G_INITIALIZE(self,
g_threaded_socket_service_new(RVAL2TYPE_WITH_DEFAULT(max_threads,
RVAL2GINT,
10)));
return Qnil;
}
static void owr_image_server_init(OwrImageServer *image_server)
{
OwrImageServerPrivate *priv;
image_server->priv = priv = OWR_IMAGE_SERVER_GET_PRIVATE(image_server);
priv->port = DEFAULT_PORT;
priv->image_renderers = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref);
g_mutex_init(&priv->image_renderers_mutex);
priv->socket_service = g_threaded_socket_service_new(8);
priv->socket_service_is_started = FALSE;
g_signal_connect(priv->socket_service, "run", G_CALLBACK(on_incoming_connection), image_server);
}
xr_server* xr_server_new(const char* cert, const char* privkey, int threads, GError** err)
{
xr_trace(XR_DEBUG_SERVER_TRACE, "(cert=%s, threads=%d, err=%p)", cert, threads, err);
GError* local_err = NULL;
g_return_val_if_fail(threads > 0 && threads < 1000, NULL);
g_return_val_if_fail (err == NULL || *err == NULL, NULL);
xr_init();
xr_server* server = g_new0(xr_server, 1);
server->secure = !!cert;
server->service = g_threaded_socket_service_new(threads);
g_signal_connect(server->service, "run", (GCallback)_xr_server_service_run, server);
if (cert)
{
gchar *cert_and_privkey = g_strconcat(cert, privkey, NULL);
server->cert = g_tls_certificate_new_from_pem(cert_and_privkey, -1, &local_err);
g_free(cert_and_privkey);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Certificate load failed: ");
goto err0;
}
}
server->sessions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)xr_servlet_free_fini);
g_static_rw_lock_init(&server->sessions_lock);
server->sessions_cleaner = g_thread_create((GThreadFunc)sessions_cleaner_func, server, TRUE, NULL);
if (server->sessions_cleaner == NULL)
goto err1;
return server;
err1:
g_hash_table_destroy(server->sessions);
g_static_rw_lock_free(&server->sessions_lock);
if (server->cert)
g_object_unref(server->cert);
err0:
g_object_unref(server->service);
g_free(server);
return NULL;
}
static gboolean
initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
GDBusServer *server = G_DBUS_SERVER (initable);
gboolean ret;
guint n;
gchar **addr_array;
GError *last_error;
ret = FALSE;
addr_array = NULL;
last_error = NULL;
if (!g_dbus_is_guid (server->guid))
{
g_set_error (&last_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("The string '%s' is not a valid D-Bus GUID"),
server->guid);
goto out;
}
server->listener = G_SOCKET_LISTENER (g_threaded_socket_service_new (-1));
addr_array = g_strsplit (server->address, ";", 0);
last_error = NULL;
for (n = 0; addr_array != NULL && addr_array[n] != NULL; n++)
{
const gchar *address_entry = addr_array[n];
GHashTable *key_value_pairs;
gchar *transport_name;
GError *this_error;
this_error = NULL;
if (g_dbus_is_supported_address (address_entry,
&this_error) &&
_g_dbus_address_parse_entry (address_entry,
&transport_name,
&key_value_pairs,
&this_error))
{
if (FALSE)
{
}
#ifdef G_OS_UNIX
else if (g_strcmp0 (transport_name, "unix") == 0)
ret = try_unix (server, address_entry, key_value_pairs, &this_error);
#endif
else if (g_strcmp0 (transport_name, "tcp") == 0)
ret = try_tcp (server, address_entry, key_value_pairs, FALSE, &this_error);
else if (g_strcmp0 (transport_name, "nonce-tcp") == 0)
ret = try_tcp (server, address_entry, key_value_pairs, TRUE, &this_error);
else
g_set_error (&this_error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Cannot listen on unsupported transport '%s'"),
transport_name);
g_free (transport_name);
if (key_value_pairs != NULL)
g_hash_table_unref (key_value_pairs);
if (ret)
{
g_assert (this_error == NULL);
goto out;
}
}
if (this_error != NULL)
{
if (last_error != NULL)
g_error_free (last_error);
last_error = this_error;
}
}
out:
g_strfreev (addr_array);
if (ret)
{
if (last_error != NULL)
g_error_free (last_error);
/* Right now we don't have any transport not using the listener... */
g_assert (server->is_using_listener);
server->run_signal_handler_id = g_signal_connect (G_SOCKET_SERVICE (server->listener),
"run",
G_CALLBACK (on_run),
server);
}
else
{
g_assert (last_error != NULL);
g_propagate_error (error, last_error);
}
return ret;
}
