gboolean
cockpit_web_server_add_socket (CockpitWebServer *self,
GSocket *socket,
GError **error)
{
return g_socket_listener_add_socket (G_SOCKET_LISTENER (self->socket_service), socket, NULL, error);
}
/**
* g_socket_listener_add_address:
* @listener: a #GSocketListener
* @address: a #GSocketAddress
* @type: a #GSocketType
* @protocol: a #GSocketProtocol
* @source_object: (allow-none): Optional #GObject identifying this source
* @effective_address: (out) (allow-none): location to store the address that was bound to, or %NULL.
* @error: #GError for error reporting, or %NULL to ignore.
*
* Creates a socket of type @type and protocol @protocol, binds
* it to @address and adds it to the set of sockets we're accepting
* sockets from.
*
* Note that adding an IPv6 address, depending on the platform,
* may or may not result in a listener that also accepts IPv4
* connections. For more deterministic behavior, see
* g_socket_listener_add_inet_port().
*
* @source_object will be passed out in the various calls
* to accept to identify this particular source, which is
* useful if you're listening on multiple addresses and do
* different things depending on what address is connected to.
*
* If successful and @effective_address is non-%NULL then it will
* be set to the address that the binding actually occurred at. This
* is helpful for determining the port number that was used for when
* requesting a binding to port 0 (ie: "any port"). This address, if
* requested, belongs to the caller and must be freed.
*
* Returns: %TRUE on success, %FALSE on error.
*
* Since: 2.22
*/
gboolean
g_socket_listener_add_address (GSocketListener *listener,
GSocketAddress *address,
GSocketType type,
GSocketProtocol protocol,
GObject *source_object,
GSocketAddress **effective_address,
GError **error)
{
GSocketAddress *local_address;
GSocketFamily family;
GSocket *socket;
if (!check_listener (listener, error))
return FALSE;
family = g_socket_address_get_family (address);
socket = g_socket_new (family, type, protocol, error);
if (socket == NULL)
return FALSE;
g_socket_set_listen_backlog (socket, listener->priv->listen_backlog);
if (!g_socket_bind (socket, address, TRUE, error) ||
!g_socket_listen (socket, error))
{
g_object_unref (socket);
return FALSE;
}
local_address = NULL;
if (effective_address)
{
local_address = g_socket_get_local_address (socket, error);
if (local_address == NULL)
{
g_object_unref (socket);
return FALSE;
}
}
if (!g_socket_listener_add_socket (listener, socket,
source_object,
error))
{
if (local_address)
g_object_unref (local_address);
g_object_unref (socket);
return FALSE;
}
if (effective_address)
*effective_address = local_address;
g_object_unref (socket); /* add_socket refs this */
return TRUE;
}
static void
_j4status_io_add_systemd(J4statusIOContext *self)
{
#ifdef ENABLE_SYSTEMD
gint fds = sd_listen_fds(TRUE);
if ( fds < 0 )
{
g_warning("Failed to acquire systemd sockets: %s", g_strerror(-fds));
return;
}
if ( fds == 0 )
return;
gboolean socket_added = FALSE;
_j4status_io_add_server(self);
GError *error = NULL;
gint fd;
for ( fd = SD_LISTEN_FDS_START ; fd < SD_LISTEN_FDS_START + fds ; ++fd )
{
gint r;
r = sd_is_socket(fd, AF_UNSPEC, SOCK_STREAM, 1);
if ( r < 0 )
{
g_warning("Failed to verify systemd socket type: %s", g_strerror(-r));
continue;
}
if ( r == 0 )
continue;
GSocket *socket;
socket = g_socket_new_from_fd(fd, &error);
if ( socket == NULL )
{
g_warning("Failed to take a socket from systemd: %s", error->message);
g_clear_error(&error);
continue;
}
if ( ! g_socket_listener_add_socket(G_SOCKET_LISTENER(self->server), socket, NULL, &error) )
{
g_warning("Failed to add systemd socket to server: %s", error->message);
g_clear_error(&error);
continue;
}
socket_added = TRUE;
}
if ( ! socket_added )
{
g_object_unref(self->server);
self->server = NULL;
}
#endif /* ENABLE_SYSTEMD */
}
static GList *
_eventd_evp_add_socket(GList *used_sockets, EventdPluginContext *context, const gchar * const *binds)
{
GList *sockets;
sockets = libeventd_core_get_sockets(context->core, context->core_interface, binds);
GList *socket_;
for ( socket_ = sockets ; socket_ != NULL ; socket_ = g_list_next(socket_) )
{
GError *error = NULL;
if ( ! g_socket_listener_add_socket(G_SOCKET_LISTENER(context->service), socket_->data, NULL, &error) )
{
g_warning("Unable to add socket: %s", error->message);
g_clear_error(&error);
}
else
used_sockets = g_list_prepend(used_sockets, g_object_ref(socket_->data));
}
g_list_free_full(sockets, g_object_unref);
return used_sockets;
}
static gboolean
cockpit_web_server_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
CockpitWebServer *server = COCKPIT_WEB_SERVER (initable);
gboolean ret = FALSE;
gboolean failed;
int n, fd;
server->socket_service = g_socket_service_new ();
n = sd_listen_fds (0);
if (n > 0)
{
/* We got file descriptors passed in, use those. */
for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START + n; fd++)
{
GSocket *s = NULL;
gboolean b;
s = g_socket_new_from_fd (fd, error);
if (s == NULL)
{
g_prefix_error (error, "Failed to acquire passed socket %i: ", fd);
goto out;
}
b = g_socket_listener_add_socket (G_SOCKET_LISTENER (server->socket_service),
s,
NULL,
error);
g_object_unref (s);
if (!b)
{
g_prefix_error (error, "Failed to add listener for socket %i: ", fd);
goto out;
}
}
server->socket_activated = TRUE;
}
else
{
/* No fds passed in, let's listen on our own. */
if (server->port == 0)
{
server->port = g_socket_listener_add_any_inet_port (G_SOCKET_LISTENER (server->socket_service),
NULL, error);
failed = (server->port == 0);
}
else
{
failed = !g_socket_listener_add_inet_port (G_SOCKET_LISTENER (server->socket_service),
server->port, NULL, error);
}
if (failed)
{
g_prefix_error (error, "Failed to bind to port %d: ", server->port);
goto out;
}
}
g_signal_connect (server->socket_service,
"incoming",
G_CALLBACK (on_incoming),
server);
ret = TRUE;
out:
return ret;
}
static void
create_channel_cb (GObject *acr,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
CreateTubeData *data;
GSocketListener *listener = NULL;
gchar *dir;
GSocket *socket = NULL;
GSocketAddress *socket_address = NULL;
GValue *address;
GHashTable *parameters;
GError *error = NULL;
data = g_simple_async_result_get_op_res_gpointer (simple);
if (g_cancellable_is_cancelled (data->op_cancellable))
{
g_object_unref (simple);
return;
}
data->channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (acr), res, NULL, &error);
if (data->channel == NULL)
goto OUT;
data->invalidated_id = g_signal_connect (data->channel, "invalidated",
G_CALLBACK (create_tube_channel_invalidated_cb), simple);
/* We are client side, but we have to offer a socket... So we offer an unix
* socket on which the service side can connect. We also create an IPv4 socket
* on which the ssh client can connect. When both sockets are connected,
* we can forward all communications between them. */
listener = g_socket_listener_new ();
/* Create temporary file for our unix socket */
dir = g_build_filename (g_get_tmp_dir (), "telepathy-ssh-XXXXXX", NULL);
dir = mkdtemp (dir);
data->unix_path = g_build_filename (dir, "unix-socket", NULL);
g_free (dir);
/* Create the unix socket, and listen for connection on it */
socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT, &error);
if (socket == NULL)
goto OUT;
socket_address = g_unix_socket_address_new (data->unix_path);
if (!g_socket_bind (socket, socket_address, FALSE, &error))
goto OUT;
if (!g_socket_listen (socket, &error))
goto OUT;
if (!g_socket_listener_add_socket (listener, socket, NULL, &error))
goto OUT;
g_socket_listener_accept_async (listener, data->op_cancellable,
create_tube_socket_connected_cb, g_object_ref (simple));
/* Offer the socket */
address = tp_address_variant_from_g_socket_address (socket_address,
TP_SOCKET_ADDRESS_TYPE_UNIX, &error);
if (address == NULL)
goto OUT;
parameters = g_hash_table_new (NULL, NULL);
data->offer_call = tp_cli_channel_type_stream_tube_call_offer (data->channel,
-1,
TP_SOCKET_ADDRESS_TYPE_UNIX, address,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST, parameters,
create_tube_offer_cb, g_object_ref (simple), g_object_unref, NULL);
tp_g_value_slice_free (address);
g_hash_table_unref (parameters);
OUT:
if (error != NULL)
create_tube_complete (simple, error);
tp_clear_object (&listener);
tp_clear_object (&socket);
tp_clear_object (&socket_address);
g_clear_error (&error);
g_object_unref (simple);
}
