static GBytes *
build_environment (GHashTable *os_release)
{
/*
* We don't include entirety of os-release into the
* environment for the login.html page. There could
* be unexpected things in here.
*
* However since we are displaying branding based on
* the OS name variant flavor and version, including
* the corresponding information is not a leak.
*/
static const gchar *release_fields[] = {
"NAME", "ID", "PRETTY_NAME", "VARIANT", "VARIANT_ID", "CPE_NAME",
};
static const gchar *prefix = "\n <script>\nvar environment = ";
static const gchar *suffix = ";\n </script>";
GByteArray *buffer;
GBytes *bytes;
JsonObject *object;
const gchar *value;
gchar *hostname;
JsonObject *osr;
gint i;
object = json_object_new ();
add_page_to_environment (object);
hostname = g_malloc0 (HOST_NAME_MAX + 1);
gethostname (hostname, HOST_NAME_MAX);
hostname[HOST_NAME_MAX] = '\0';
json_object_set_string_member (object, "hostname", hostname);
g_free (hostname);
if (os_release)
{
osr = json_object_new ();
for (i = 0; i < G_N_ELEMENTS (release_fields); i++)
{
value = g_hash_table_lookup (os_release, release_fields[i]);
if (value)
json_object_set_string_member (osr, release_fields[i], value);
}
json_object_set_object_member (object, "os-release", osr);
}
add_oauth_to_environment (object);
bytes = cockpit_json_write_bytes (object);
json_object_unref (object);
buffer = g_bytes_unref_to_array (bytes);
g_byte_array_prepend (buffer, (const guint8 *)prefix, strlen (prefix));
g_byte_array_append (buffer, (const guint8 *)suffix, strlen (suffix));
return g_byte_array_free_to_bytes (buffer);
}
static void
byte_array_ensure_array (ByteArrayInstance *priv)
{
if (priv->bytes) {
priv->array = g_bytes_unref_to_array(priv->bytes);
priv->bytes = NULL;
} else {
g_assert(priv->array);
}
}
static void
mock_case_channel_recv (CockpitChannel *channel,
GBytes *message)
{
MockCaseChannel *self = (MockCaseChannel *)channel;
GByteArray *array = g_bytes_unref_to_array (g_bytes_ref (message));
GBytes *bytes;
gsize i;
for (i = 0; i < array->len; i++)
array->data[i] = self->function(array->data[i]);
bytes = g_byte_array_free_to_bytes (array);
cockpit_channel_send (channel, bytes, FALSE);
g_bytes_unref (bytes);
}
static GBytes *
build_environment (GHashTable *os_release)
{
static const gchar *prefix = "\n <script>\nvar environment = ";
static const gchar *suffix = ";\n </script>";
GByteArray *buffer;
GHashTableIter iter;
GBytes *bytes;
JsonObject *object;
const gchar *title;
gchar *hostname;
gpointer key, value;
JsonObject *osr;
object = json_object_new ();
title = cockpit_conf_string ("WebService", "LoginTitle");
if (title)
json_object_set_string_member (object, "title", title);
hostname = g_malloc0 (HOST_NAME_MAX + 1);
gethostname (hostname, HOST_NAME_MAX);
hostname[HOST_NAME_MAX] = '\0';
json_object_set_string_member (object, "hostname", hostname);
g_free (hostname);
if (os_release)
{
osr = json_object_new ();
g_hash_table_iter_init (&iter, os_release);
while (g_hash_table_iter_next (&iter, &key, &value))
json_object_set_string_member (osr, key, value);
json_object_set_object_member (object, "os-release", osr);
}
add_oauth_to_environment (object);
bytes = cockpit_json_write_bytes (object);
json_object_unref (object);
buffer = g_bytes_unref_to_array (bytes);
g_byte_array_prepend (buffer, (const guint8 *)prefix, strlen (prefix));
g_byte_array_append (buffer, (const guint8 *)suffix, strlen (suffix));
return g_byte_array_free_to_bytes (buffer);
}
static void
on_echo_socket_message (WebSocketConnection *self,
WebSocketDataType type,
GBytes *message,
gpointer user_data)
{
GByteArray *array = g_bytes_unref_to_array (g_bytes_ref (message));
GBytes *payload;
guint i;
/* Capitalize and relay back */
for (i = 0; i < array->len; i++)
array->data[i] = g_ascii_toupper (array->data[i]);
payload = g_byte_array_free_to_bytes (array);
web_socket_connection_send (self, type, NULL, payload);
g_bytes_unref (payload);
}
/**
* cockpit_channel_send:
* @self: a pipe
* @payload: the message payload to send
* @trust_is_utf8: set to true if sure data is UTF8
*
* Called by implementations to send a message over the transport
* on the right channel.
*
* This message is queued, and sent once the transport can.
*/
void
cockpit_channel_send (CockpitChannel *self,
GBytes *payload,
gboolean trust_is_utf8)
{
const guint8 *data;
gsize length;
GBytes *send_data = payload;
GByteArray *combined;
if (self->priv->buffer_timeout)
g_source_remove(self->priv->buffer_timeout);
self->priv->buffer_timeout = 0;
if (self->priv->out_buffer)
{
combined = g_bytes_unref_to_array (self->priv->out_buffer);
self->priv->out_buffer = NULL;
data = g_bytes_get_data (payload, &length);
g_byte_array_append (combined, data, length);
send_data = g_byte_array_free_to_bytes (combined);
trust_is_utf8 = FALSE;
}
if (!trust_is_utf8 && !self->priv->binary_ok)
{
if (cockpit_unicode_has_incomplete_ending (send_data))
{
self->priv->out_buffer = g_bytes_ref (send_data);
self->priv->buffer_timeout = g_timeout_add (500, flush_buffer, self);
}
}
if (!self->priv->buffer_timeout)
cockpit_channel_actual_send (self, send_data, trust_is_utf8);
if (send_data != payload)
g_bytes_unref (send_data);
}
/**
* gcr_certificate_request_encode:
* @self: a certificate request
* @textual: whether to encode output as text
* @length: location to place length of returned data
*
* Encode the certificate request. It must have been completed with
* gcr_certificate_request_complete() or gcr_certificate_request_complete_async()
*
* If @textual is %FALSE, the output is a DER encoded certificate request.
*
* If @textual is %TRUE, the output is encoded as text. For PKCS\#10 requests this
* is done using the OpenSSL style PEM encoding.
*
* Returns: (transfer full) (array length=length): the encoded certificate request
*/
guchar *
gcr_certificate_request_encode (GcrCertificateRequest *self,
gboolean textual,
gsize *length)
{
GBytes *bytes;
gpointer encoded;
gpointer data;
gsize size;
g_return_val_if_fail (GCR_IS_CERTIFICATE_REQUEST (self), NULL);
g_return_val_if_fail (length != NULL, NULL);
bytes = egg_asn1x_encode (self->asn, NULL);
if (bytes == NULL) {
g_warning ("couldn't encode certificate request: %s",
egg_asn1x_message (self->asn));
return NULL;
}
size = g_bytes_get_size (bytes);
encoded = g_byte_array_free (g_bytes_unref_to_array (bytes), FALSE);
if (textual) {
data = egg_armor_write (encoded, size,
g_quark_from_static_string ("CERTIFICATE REQUEST"),
NULL, length);
g_free (encoded);
encoded = data;
} else {
*length = size;
}
return encoded;
}
