static DynamicPeer *
dynamic_peer_create (JsonObject *config)
{
DynamicPeer *p = g_new0 (DynamicPeer, 1);
p->peers = g_hash_table_new_full (dynamic_key_hash, dynamic_key_equal,
dynamic_key_free, g_object_unref);
p->config = json_object_ref (config);
if (!cockpit_json_get_strv (config, "environ", NULL, &p->env))
p->env = NULL;
if (!cockpit_json_get_strv (config, "spawn", NULL, &p->spawn))
p->spawn = NULL;
return p;
}
static gboolean
cockpit_channel_ensure_capable (CockpitChannel *channel,
JsonObject *options)
{
gchar **capabilities = NULL;
JsonObject *close_options = NULL; // owned by channel
gboolean missing = FALSE;
gboolean ret = FALSE;
gint len;
gint i;
if (!cockpit_json_get_strv (options, "capabilities", NULL, &capabilities))
{
g_message ("got invalid capabilities field in open message");
cockpit_channel_close (channel, "protocol-error");
goto out;
}
if (!capabilities)
{
ret = TRUE;
goto out;
}
len = g_strv_length (capabilities);
for (i = 0; i < len; i++)
{
if (channel->priv->capabilities == NULL ||
!strv_contains(channel->priv->capabilities, capabilities[i]))
{
g_message ("unsupported capability required: %s", capabilities[i]);
missing = TRUE;
}
}
if (missing)
{
JsonArray *arr = json_array_new (); // owned by closed options
if (channel->priv->capabilities != NULL)
{
len = g_strv_length (channel->priv->capabilities);
for (i = 0; i < len; i++)
json_array_add_string_element (arr, channel->priv->capabilities[i]);
}
close_options = cockpit_channel_close_options (channel);
json_object_set_array_member (close_options, "capabilities", arr);
cockpit_channel_close (channel, "not-supported");
}
ret = !missing;
out:
g_free (capabilities);
return ret;
}
static void
cockpit_internal_metrics_prepare (CockpitChannel *channel)
{
CockpitInternalMetrics *self = COCKPIT_INTERNAL_METRICS (channel);
JsonObject *options;
JsonArray *metrics;
int i;
COCKPIT_CHANNEL_CLASS (cockpit_internal_metrics_parent_class)->prepare (channel);
options = cockpit_channel_get_options (channel);
/* "instances" option */
if (!cockpit_json_get_strv (options, "instances", NULL, (gchar ***)&self->instances))
{
cockpit_channel_fail (channel, "protocol-error",
"invalid \"instances\" option (not an array of strings)");
return;
}
/* "omit-instances" option */
if (!cockpit_json_get_strv (options, "omit-instances", NULL, (gchar ***)&self->omit_instances))
{
cockpit_channel_fail (channel, "protocol-error",
"invalid \"omit-instances\" option (not an array of strings)");
return;
}
/* "metrics" option */
self->n_metrics = 0;
if (!cockpit_json_get_array (options, "metrics", NULL, &metrics))
{
cockpit_channel_fail (channel, "protocol-error",
"invalid \"metrics\" option was specified (not an array)");
return;
}
if (metrics)
self->n_metrics = json_array_get_length (metrics);
self->metrics = g_new0 (MetricInfo, self->n_metrics);
for (i = 0; i < self->n_metrics; i++)
{
MetricInfo *info = &self->metrics[i];
if (!convert_metric_description (self, json_array_get_element (metrics, i), info, i))
return;
if (!info->desc)
{
cockpit_channel_close (channel, "not-supported");
return;
}
}
/* "interval" option */
if (!cockpit_json_get_int (options, "interval", 1000, &self->interval))
{
cockpit_channel_fail (channel, "protocol-error", "invalid \"interval\" option");
return;
}
else if (self->interval <= 0 || self->interval > G_MAXINT)
{
cockpit_channel_fail (channel, "protocol-error",
"invalid \"interval\" value: %" G_GINT64_FORMAT, self->interval);
return;
}
self->need_meta = TRUE;
cockpit_metrics_metronome (COCKPIT_METRICS (self), self->interval);
cockpit_channel_ready (channel, NULL);
}
gboolean
cockpit_web_service_parse_external (JsonObject *options,
const gchar **content_type,
const gchar **content_encoding,
const gchar **content_disposition,
gchar ***protocols)
{
JsonObject *external;
const gchar *value;
JsonNode *node;
g_return_val_if_fail (options != NULL, FALSE);
if (!cockpit_json_get_string (options, "channel", NULL, &value) || value != NULL)
{
g_message ("don't specify \"channel\" on external channel");
return FALSE;
}
if (!cockpit_json_get_string (options, "command", NULL, &value) || value != NULL)
{
g_message ("don't specify \"command\" on external channel");
return FALSE;
}
node = json_object_get_member (options, "external");
if (node == NULL)
{
if (content_disposition)
*content_disposition = NULL;
if (content_type)
*content_type = NULL;
if (content_encoding)
*content_encoding = NULL;
if (protocols)
*protocols = NULL;
return TRUE;
}
if (!JSON_NODE_HOLDS_OBJECT (node))
{
g_message ("invalid \"external\" option");
return FALSE;
}
external = json_node_get_object (node);
if (!cockpit_json_get_string (external, "content-disposition", NULL, &value) ||
(value && !cockpit_web_response_is_header_value (value)))
{
g_message ("invalid \"content-disposition\" external option");
return FALSE;
}
if (content_disposition)
*content_disposition = value;
if (!cockpit_json_get_string (external, "content-type", NULL, &value) ||
(value && !cockpit_web_response_is_header_value (value)))
{
g_message ("invalid \"content-type\" external option");
return FALSE;
}
if (content_type)
*content_type = value;
if (!cockpit_json_get_string (external, "content-encoding", NULL, &value) ||
(value && !cockpit_web_response_is_header_value (value)))
{
g_message ("invalid \"content-encoding\" external option");
return FALSE;
}
if (content_encoding)
*content_encoding = value;
if (!cockpit_json_get_strv (external, "protocols", NULL, protocols))
{
g_message ("invalid \"protocols\" external option");
return FALSE;
}
return TRUE;
}
static void
on_socket_connect (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
CockpitWebSocketStream *self = COCKPIT_WEB_SOCKET_STREAM (user_data);
CockpitChannel *channel = COCKPIT_CHANNEL (self);
const gchar *problem = "protocol-error";
gchar **protocols = NULL;
GList *l, *names = NULL;
GError *error = NULL;
JsonObject *options;
JsonObject *headers;
const gchar *value;
JsonNode *node;
GIOStream *io;
io = cockpit_connect_stream_finish (result, &error);
if (error)
{
problem = cockpit_stream_problem (error, self->origin, "couldn't connect",
cockpit_channel_close_options (channel));
cockpit_channel_close (channel, problem);
goto out;
}
options = cockpit_channel_get_options (channel);
if (!cockpit_json_get_strv (options, "protocols", NULL, &protocols))
{
cockpit_channel_fail (channel, "protocol-error",
"%s: invalid \"protocol\" value in WebSocket stream request", self->origin);
goto out;
}
if (G_IS_TLS_CONNECTION (io))
{
self->sig_accept_cert = g_signal_connect (G_TLS_CONNECTION (io),
"accept-certificate",
G_CALLBACK (on_rejected_certificate),
self);
}
else
{
self->sig_accept_cert = 0;
}
self->client = web_socket_client_new_for_stream (self->url, self->origin, (const gchar **)protocols, io);
node = json_object_get_member (options, "headers");
if (node)
{
if (!JSON_NODE_HOLDS_OBJECT (node))
{
cockpit_channel_fail (channel, "protocol-error",
"%s: invalid \"headers\" field in WebSocket stream request", self->origin);
goto out;
}
headers = json_node_get_object (node);
names = json_object_get_members (headers);
for (l = names; l != NULL; l = g_list_next (l))
{
node = json_object_get_member (headers, l->data);
if (!node || !JSON_NODE_HOLDS_VALUE (node) || json_node_get_value_type (node) != G_TYPE_STRING)
{
cockpit_channel_fail (channel, "protocol-error",
"%s: invalid header value in WebSocket stream request: %s",
self->origin, (gchar *)l->data);
goto out;
}
value = json_node_get_string (node);
g_debug ("%s: sending header: %s %s", self->origin, (gchar *)l->data, value);
web_socket_client_include_header (WEB_SOCKET_CLIENT (self->client), l->data, value);
}
}
self->sig_open = g_signal_connect (self->client, "open", G_CALLBACK (on_web_socket_open), self);
self->sig_message = g_signal_connect (self->client, "message", G_CALLBACK (on_web_socket_message), self);
self->sig_closing = g_signal_connect (self->client, "closing", G_CALLBACK (on_web_socket_closing), self);
self->sig_close = g_signal_connect (self->client, "close", G_CALLBACK (on_web_socket_close), self);
self->sig_error = g_signal_connect (self->client, "error", G_CALLBACK (on_web_socket_error), self);
problem = NULL;
out:
g_clear_error (&error);
g_strfreev (protocols);
if (io)
g_object_unref (io);
g_list_free (names);
}