static AesCtrState *
setup_aes_decrypt()
{
/* NIST SP800-38a section F.5.2; CTR-AES128 Decrypt */
const guint8 Key[]={ 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
const guint8 IV[] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };
AesCtrState *state;
GstBuffer *gkey;
GBytes *giv;
gkey = gst_buffer_new_allocate (NULL,sizeof(Key),NULL);
fail_if(gkey==NULL);
gst_buffer_fill(gkey,0,Key,sizeof(Key));
giv = g_bytes_new_static(IV,sizeof(IV));
fail_if(giv==NULL);
state = gst_aes_ctr_decrypt_new(gkey, giv);
fail_if(state==NULL);
g_bytes_unref(giv);
gst_buffer_unref(gkey);
return state;
}
static void
cockpit_channel_real_close (CockpitChannel *self,
const gchar *problem)
{
const gchar *reason = problem;
JsonObject *object;
GBytes *message;
if (self->priv->closed)
return;
self->priv->closed = TRUE;
if (reason == NULL)
reason = "";
if (self->priv->close_options)
{
object = self->priv->close_options;
self->priv->close_options = NULL;
}
else
{
object = json_object_new ();
}
json_object_set_string_member (object, "command", "close");
json_object_set_string_member (object, "channel", self->priv->id);
json_object_set_string_member (object, "reason", reason);
message = cockpit_json_write_bytes (object);
json_object_unref (object);
cockpit_transport_send (self->priv->transport, 0, message);
g_bytes_unref (message);
g_signal_emit (self, cockpit_channel_sig_closed, 0, problem);
}
static void
inject_address (CockpitWebResponse *response,
const gchar *name,
const gchar *value)
{
GBytes *inject = NULL;
CockpitWebFilter *filter = NULL;
gchar *line = NULL;
if (value)
{
line = g_strconcat ("\nvar ", name, " = '", value, "';\n", NULL);
inject = g_bytes_new (line, strlen (line));
filter = cockpit_web_inject_new ("<script id='dbus-tests'>", inject);
g_bytes_unref (inject);
cockpit_web_response_add_filter (response, filter);
g_object_unref (filter);
}
g_free (line);
}
static gboolean
setup_dbus (ControlData *data)
{
GBytes *bytes;
bytes = g_resources_lookup_data ("/net/hadess/SwitcherooControl/net.hadess.SwitcherooControl.xml",
G_RESOURCE_LOOKUP_FLAGS_NONE,
NULL);
data->introspection_data = g_dbus_node_info_new_for_xml (g_bytes_get_data (bytes, NULL), NULL);
g_bytes_unref (bytes);
g_assert (data->introspection_data != NULL);
data->name_id = g_bus_own_name (G_BUS_TYPE_SYSTEM,
CONTROL_PROXY_DBUS_NAME,
G_BUS_NAME_OWNER_FLAGS_NONE,
bus_acquired_handler,
name_acquired_handler,
name_lost_handler,
data,
NULL);
return TRUE;
}
static void
auth_data_free (gpointer data)
{
AuthData *ad = data;
g_return_if_fail (ad->pending_result == NULL);
if (ad->auth_process) {
g_signal_handlers_disconnect_by_data (ad->auth_process, ad);
g_object_unref (ad->auth_process);
}
if (ad->authorization)
g_bytes_unref (ad->authorization);
g_free (ad->auth_type);
g_free (ad->application);
g_free (ad->remote_peer);
g_free (ad->id);
g_free (ad->response_data);
g_free (ad);
}
static void
register_lazy_static_resources_unlocked (void)
{
GStaticResource *list;
do
list = lazy_register_resources;
while (!g_atomic_pointer_compare_and_exchange (&lazy_register_resources, list, NULL));
while (list != NULL)
{
GBytes *bytes = g_bytes_new_static (list->data, list->data_len);
GResource *resource = g_resource_new_from_data (bytes, NULL);
if (resource)
{
g_resources_register_unlocked (resource);
g_atomic_pointer_set (&list->resource, resource);
}
g_bytes_unref (bytes);
list = list->next;
}
}
static void
gum_duk_debug_session_on_read_ready (GObject * source_object,
GAsyncResult * res,
GumDukDebugSession * self)
{
GBytes * bytes;
bytes = g_input_stream_read_bytes_finish (self->input, res, NULL);
if (bytes == NULL || g_bytes_get_size (bytes) == 0)
goto error_gone;
gum_duk_debug_channel_post (self->channel, bytes);
g_bytes_unref (bytes);
gum_duk_debug_session_read_next_chunk (self);
return;
error_gone:
if (self->cancellable != NULL)
gum_duk_debug_channel_remove_session (self->channel, self);
}
static gboolean
on_timeout_send (gpointer data)
{
CockpitWebResponse *response = data;
gint *at = g_object_get_data (data, "at");
gchar *string;
GBytes *bytes;
string = g_strdup_printf ("%d ", *at);
(*at) += 1;
bytes = g_bytes_new_take (string, strlen (string));
cockpit_web_response_queue (response, bytes);
g_bytes_unref (bytes);
if (*at == 10)
{
cockpit_web_response_complete (response);
return FALSE;
}
return TRUE;
}
static void
extract_resource (GResource *resource,
const gchar *path)
{
GBytes *bytes;
bytes = g_resource_lookup_data (resource, path, 0, NULL);
if (bytes != NULL)
{
gconstpointer data;
gsize size, written;
data = g_bytes_get_data (bytes, &size);
written = fwrite (data, 1, size, stdout);
if (written < size)
g_printerr ("Data truncated\n");
g_bytes_unref (bytes);
}
else
{
g_printerr ("Can't find resource path %s\n", path);
}
}
/* org.nemomobile.MmsEngine.receiveMessage */
static
gboolean
mms_engine_handle_receive_message(
OrgNemomobileMmsEngine* proxy,
GDBusMethodInvocation* call,
int database_id,
const char* imsi,
gboolean automatic,
GVariant* data,
MMSEngine* engine)
{
gsize len = 0;
const guint8* bytes = g_variant_get_fixed_array(data, &len, 1);
MMS_DEBUG("Processing push %u bytes from %s", (guint)len, imsi);
if (imsi && bytes && len) {
char* id = g_strdup_printf("%d", database_id);
GBytes* push = g_bytes_new(bytes, len);
GError* error = NULL;
if (mms_dispatcher_receive_message(engine->dispatcher, id, imsi,
automatic, push, &error)) {
if (mms_dispatcher_start(engine->dispatcher)) {
mms_engine_start_timeout_cancel(engine);
}
org_nemomobile_mms_engine_complete_receive_message(proxy, call);
} else {
g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
G_DBUS_ERROR_FAILED, "%s", MMS_ERRMSG(error));
g_error_free(error);
}
g_bytes_unref(push);
g_free(id);
} else {
g_dbus_method_invocation_return_error(call, G_DBUS_ERROR,
G_DBUS_ERROR_FAILED, "Invalid parameters");
}
return TRUE;
}
static void
test_asn1_oid (Test *test, gconstpointer unused)
{
GNode *asn;
GBytes *data;
gboolean ret;
GQuark source, target;
asn = egg_asn1x_create (test_asn1_tab, "TestOid");
g_assert ("asn test structure is null" && asn != NULL);
/* Create a OID Quark */
OID_ANSI_SECP256R1 = g_quark_from_static_string("1.2.840.10045.3.1.7");
source = OID_ANSI_SECP256R1;
/* Write the OID out */
ret = gkm_data_asn1_write_oid (egg_asn1x_node (asn, "oid", NULL), source);
g_assert ("couldn't write OID to asn1" && ret);
/* Now encode the whole caboodle */
data = egg_asn1x_encode (asn, NULL);
g_assert ("encoding asn1 didn't work" && data != NULL);
egg_asn1x_destroy (asn);
/* Now decode it all nicely */
asn = egg_asn1x_create_and_decode (test_asn1_tab, "TestOid", data);
g_assert (asn != NULL);
ret = gkm_data_asn1_read_oid (egg_asn1x_node (asn, "oid", NULL), &target);
egg_asn1x_destroy (asn);
g_assert ("couldn't read oid from asn1" && ret);
g_assert ("oid returned is 0" && target != 0);
g_assert ("mpi is wrong number" && source == target);
g_bytes_unref (data);
}
static void
send_login_response (CockpitWebResponse *response,
CockpitCreds *creds,
GHashTable *headers)
{
JsonObject *object;
JsonObject *login_data;
GBytes *content;
object = json_object_new ();
json_object_set_string_member (object, "user", cockpit_creds_get_user (creds));
json_object_set_string_member (object, "csrf-token", cockpit_creds_get_csrf_token (creds));
login_data = cockpit_creds_get_login_data (creds);
if (login_data)
json_object_set_object_member (object, "login-data", json_object_ref (login_data));
content = cockpit_json_write_bytes (object);
json_object_unref (object);
g_hash_table_replace (headers, g_strdup ("Content-Type"), g_strdup ("application/json"));
cockpit_web_response_content (response, headers, content, NULL);
g_bytes_unref (content);
}
static void
send_init_command (CockpitTransport *transport,
gboolean interactive)
{
const gchar *checksum;
JsonObject *object;
GBytes *bytes;
object = json_object_new ();
json_object_set_string_member (object, "command", "init");
json_object_set_int_member (object, "version", 1);
/*
* When in interactive mode pretend we received an init
* message, and don't print one out.
*/
if (interactive)
{
json_object_set_string_member (object, "host", "localhost");
}
else
{
checksum = cockpit_packages_get_checksum (packages);
if (checksum)
json_object_set_string_member (object, "checksum", checksum);
}
bytes = cockpit_json_write_bytes (object);
json_object_unref (object);
if (interactive)
cockpit_transport_emit_recv (transport, NULL, bytes);
else
cockpit_transport_send (transport, NULL, bytes);
g_bytes_unref (bytes);
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMSettingOlpcMeshPrivate *priv = NM_SETTING_OLPC_MESH_GET_PRIVATE (object);
switch (prop_id) {
case PROP_SSID:
if (priv->ssid)
g_bytes_unref (priv->ssid);
priv->ssid = g_value_dup_boxed (value);
break;
case PROP_CHANNEL:
priv->channel = g_value_get_uint (value);
break;
case PROP_DHCP_ANYCAST_ADDRESS:
g_free (priv->dhcp_anycast_addr);
priv->dhcp_anycast_addr = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
process_and_relay_open (CockpitWebService *self,
CockpitSocket *socket,
const gchar *channel,
JsonObject *options)
{
WebSocketDataType data_type = WEB_SOCKET_DATA_TEXT;
GBytes *payload;
if (self->closing)
{
g_debug ("Ignoring open command while web socket is closing");
return TRUE;
}
if (cockpit_socket_lookup_by_channel (&self->sockets, channel))
{
g_warning ("cannot open a channel %s with the same id as another channel", channel);
return FALSE;
}
if (!cockpit_web_service_parse_binary (options, &data_type))
return FALSE;
if (socket)
cockpit_socket_add_channel (&self->sockets, socket, channel, data_type);
if (!self->sent_done)
{
payload = cockpit_json_write_bytes (options);
cockpit_transport_send (self->transport, NULL, payload);
g_bytes_unref (payload);
}
return TRUE;
}
static GBytes *
gkm_xdg_trust_real_save (GkmSerializable *base, GkmSecret *login)
{
GkmXdgTrust *self = GKM_XDG_TRUST (base);
GBytes *bytes;
g_return_val_if_fail (GKM_XDG_IS_TRUST (self), FALSE);
g_return_val_if_fail (self->pv->asn, FALSE);
if (!save_assertions (self, self->pv->asn))
return FALSE;
bytes = egg_asn1x_encode (self->pv->asn, NULL);
if (bytes == NULL) {
g_warning ("encoding trust failed: %s", egg_asn1x_message (self->pv->asn));
return FALSE;
}
if (self->pv->bytes)
g_bytes_unref (self->pv->bytes);
self->pv->bytes = bytes;
return g_bytes_ref (bytes);
}
static void
gum_duk_debug_session_on_write_all_ready (GObject * source_object,
GAsyncResult * res,
GumDukDebugSession * self)
{
GBytes * bytes;
if (!g_output_stream_write_all_finish (self->output, res, NULL, NULL))
return; /* read will fail */
g_bytes_unref (g_queue_pop_head (self->outgoing));
bytes = g_queue_peek_head (self->outgoing);
if (bytes != NULL)
{
g_output_stream_write_all_async (self->output,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
G_PRIORITY_DEFAULT,
self->cancellable,
(GAsyncReadyCallback) gum_duk_debug_session_on_write_all_ready,
self);
}
}
/**
* gdk_pixbuf_buffer_queue_push:
* @queue: a #GdkPixbufBufferQueue
* @bytes: #GBytes to append to @queue
*
* Appends the given @bytes to the buffers already in @queue. This function
* will take ownership of the given @buffer. Use g_bytes_ref () before
* calling this function to keep a reference.
**/
void
gdk_pixbuf_buffer_queue_push (GdkPixbufBufferQueue *queue,
GBytes *bytes)
{
gsize size;
g_return_if_fail (queue != NULL);
g_return_if_fail (bytes != NULL);
size = g_bytes_get_size (bytes);
if (size == 0)
{
g_bytes_unref (bytes);
return;
}
queue->last_buffer = g_slist_append (queue->last_buffer, bytes);
if (queue->first_buffer == NULL)
queue->first_buffer = queue->last_buffer;
else
queue->last_buffer = queue->last_buffer->next;
queue->size += size;
}
/**
* cockpit_web_response_headers:
* @self: the response
* @status: the HTTP status code
* @reason: the HTTP reason
* @length: the combined length of data blocks to follow, or -1
* @headers: headers to include or NULL
*
* See cockpit_web_response_content() for an easy to use function.
*
* Queue the headers of the response. No data blocks must yet be
* queued on the response.
*
* Don't put Content-Length or Connection in @headers.
*
* If @length is zero or greater, then it must represent the
* number of queued blocks to follow.
*/
void
cockpit_web_response_headers_full (CockpitWebResponse *self,
guint status,
const gchar *reason,
gssize length,
GHashTable *headers)
{
GString *string;
GBytes *block;
if (self->count > 0)
{
g_critical ("Headers should be sent first. This is a programmer error.");
return;
}
string = begin_headers (self, status, reason);
block = finish_headers (self, string, length, status,
append_table (string, headers));
queue_bytes (self, block);
g_bytes_unref (block);
}
static void
add_dynamic_args_to_array (gchar ***key,
gchar **config_args,
JsonObject *options)
{
GPtrArray *arr = NULL;
gint length;
gint i;
g_assert (config_args != NULL);
g_assert (key != NULL);
arr = g_ptr_array_new ();
length = g_strv_length (config_args);
for (i = 0; i < length; i++)
{
GString *s = g_string_new ("");
GBytes *input = g_bytes_new_static (config_args[i], strlen(config_args[i]) + 1);
GList *output = cockpit_template_expand (input, substitute_json_string,
"${", "}", options);
GList *l;
for (l = output; l != NULL; l = g_list_next (l))
{
gsize size;
gconstpointer data = g_bytes_get_data (l->data, &size);
g_string_append_len (s, data, size);
}
g_ptr_array_add (arr, g_string_free (s, FALSE));
g_bytes_unref (input);
g_list_free_full (output, (GDestroyNotify) g_bytes_unref);
}
g_ptr_array_add (arr, NULL);
*key = (gchar **)g_ptr_array_free (arr, FALSE);
}
static gboolean
redirect_to_checksum_path (CockpitWebService *service,
CockpitWebResponse *response,
const gchar *checksum,
const gchar *path)
{
CockpitCreds *creds;
gchar *location;
const gchar *body;
GBytes *bytes;
gboolean ret;
gsize length;
creds = cockpit_web_service_get_creds (service);
location = g_strdup_printf ("/%s/$%s%s",
cockpit_creds_get_application (creds),
checksum, path);
body = "<html><head><title>Temporary redirect</title></head>"
"<body>Access via checksum</body></html>";
length = strlen (body);
cockpit_web_response_headers (response, 307, "Temporary Redirect", length,
"Content-Type", "text/html",
"Location", location,
NULL);
g_free (location);
bytes = g_bytes_new_static (body, length);
ret = cockpit_web_response_queue (response, bytes);
if (ret)
cockpit_web_response_complete (response);
g_bytes_unref (bytes);
return ret;
}
/**
* gcr_certificate_request_complete:
* @self: a certificate request
* @cancellable: a cancellation object
* @error: location to place an error on failure
*
* Complete and sign a certificate request, so that it can be encoded
* and sent to a certificate authority.
*
* This call may block as it signs the request using the private key.
*
* Returns: whether certificate request was successfully completed or not
*/
gboolean
gcr_certificate_request_complete (GcrCertificateRequest *self,
GCancellable *cancellable,
GError **error)
{
GNode *subject_public_key;
const gulong *mechanisms;
gsize n_mechanisms;
GckMechanism mechanism = { 0, };
GQuark algorithm = 0;
GBytes *tbs;
GckSession *session;
guchar *signature;
gsize n_signature;
gboolean ret;
g_return_val_if_fail (GCR_IS_CERTIFICATE_REQUEST (self), FALSE);
g_return_val_if_fail (cancellable == NULL || G_CANCELLABLE (cancellable), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
subject_public_key = _gcr_subject_public_key_load (self->private_key,
cancellable, error);
if (subject_public_key == NULL)
return FALSE;
ret = prepare_subject_public_key_and_mechanisms (self, subject_public_key,
&algorithm, &mechanisms,
&n_mechanisms, error);
if (!ret) {
egg_asn1x_destroy (subject_public_key);
return FALSE;
}
/* Figure out which mechanism to use */
mechanism.type = _gcr_key_mechanisms_check (self->private_key, mechanisms,
n_mechanisms, CKA_SIGN,
cancellable, NULL);
if (mechanism.type == GCK_INVALID) {
egg_asn1x_destroy (subject_public_key);
g_set_error (error, GCK_ERROR, CKR_KEY_TYPE_INCONSISTENT,
_("The key cannot be used to sign the request"));
return FALSE;
}
tbs = prepare_to_be_signed (self, &mechanism);
session = gck_object_get_session (self->private_key);
signature = gck_session_sign_full (session, self->private_key, &mechanism,
g_bytes_get_data (tbs, NULL),
g_bytes_get_size (tbs),
&n_signature, cancellable, error);
g_object_unref (session);
g_bytes_unref (tbs);
if (!signature) {
egg_asn1x_destroy (subject_public_key);
return FALSE;
}
encode_take_signature_into_request (self, algorithm, subject_public_key,
signature, n_signature);
egg_asn1x_destroy (subject_public_key);
return TRUE;
}
GList *
cockpit_template_expand (GBytes *input,
CockpitTemplateFunc func,
gpointer user_data)
{
GList *output = NULL;
const gchar *data;
const gchar *end;
const gchar *before;
const gchar *after;
GBytes *bytes;
gchar *name;
g_return_val_if_fail (func != NULL, NULL);
data = g_bytes_get_data (input, NULL);
end = data + g_bytes_get_size (input);
for (;;)
{
name = find_variable (data, end, &before, &after);
if (name == NULL)
break;
if (before != data)
{
g_assert (before > data);
bytes = g_bytes_new_with_free_func (data, before - data,
(GDestroyNotify)g_bytes_unref,
g_bytes_ref (input));
output = g_list_prepend (output, bytes);
}
bytes = (func) (name, user_data);
g_free (name);
if (!bytes)
{
g_assert (after > before);
bytes = g_bytes_new_with_free_func (before, after - before,
(GDestroyNotify)g_bytes_unref,
g_bytes_ref (input));
}
if (g_bytes_get_size (bytes) > 0)
output = g_list_prepend (output, bytes);
else
g_bytes_unref (bytes);
g_assert (after <= end);
data = after;
}
if (data != end)
{
g_assert (end > data);
bytes = g_bytes_new_with_free_func (data, end - data,
(GDestroyNotify)g_bytes_unref,
g_bytes_ref (input));
output = g_list_prepend (output, bytes);
}
return g_list_reverse (output);
}
static gboolean
dispatch_output (gint fd,
GIOCondition cond,
gpointer user_data)
{
CockpitPipe *self = (CockpitPipe *)user_data;
struct iovec iov[4];
gsize partial;
gssize ret;
gint i, count;
GList *l;
/* A non-blocking connect is processed here */
if (self->priv->connecting && !dispatch_connect (self))
return TRUE;
g_return_val_if_fail (self->priv->out_source, FALSE);
/* Note we fall through when nothing to write */
partial = self->priv->out_partial;
for (l = self->priv->out_queue->head, i = 0;
i < G_N_ELEMENTS (iov) && l != NULL;
i++, l = g_list_next (l))
{
iov[i].iov_base = (gpointer)g_bytes_get_data (l->data, &iov[i].iov_len);
if (partial)
{
g_assert (partial < iov[i].iov_len);
iov[i].iov_len -= partial;
iov[i].iov_base = ((gchar *)iov[i].iov_base) + partial;
partial = 0;
}
}
count = i;
if (count == 0)
ret = 0;
else
ret = writev (self->priv->out_fd, iov, count);
if (ret < 0)
{
if (errno != EAGAIN && errno != EINTR)
{
if (errno == EPIPE)
{
g_debug ("%s: couldn't write: %s", self->priv->name, g_strerror (errno));
close_immediately (self, "terminated");
}
else
{
set_problem_from_errno (self, "couldn't write", errno);
close_immediately (self, NULL); /* already set */
}
}
return FALSE;
}
/* Figure out what was written */
for (i = 0; ret > 0 && i < count; i++)
{
if (ret >= iov[i].iov_len)
{
g_debug ("%s: wrote %d bytes", self->priv->name, (int)iov[i].iov_len);
g_bytes_unref (g_queue_pop_head (self->priv->out_queue));
self->priv->out_partial = 0;
ret -= iov[i].iov_len;
}
else
{
g_debug ("%s: partial write %d of %d bytes", self->priv->name,
(int)ret, (int)iov[i].iov_len);
self->priv->out_partial += ret;
ret = 0;
}
}
if (self->priv->out_queue->head)
return TRUE;
g_debug ("%s: output queue empty", self->priv->name);
/* If all messages are done, then stop polling out fd */
stop_output (self);
if (self->priv->closing)
close_output (self);
else
close_maybe (self);
return TRUE;
}
static gboolean
gkm_gnome2_private_key_real_load (GkmSerializable *base,
GkmSecret *login,
GBytes *data)
{
GkmGnome2PrivateKey *self = GKM_GNOME2_PRIVATE_KEY (base);
GkmDataResult res;
gcry_sexp_t sexp, pub;
GkmSexp *wrapper;
const gchar *password;
gsize n_password;
if (g_bytes_get_size (data) == 0)
return FALSE;
res = gkm_data_der_read_private_pkcs8 (data, NULL, 0, &sexp);
/* An unencrypted pkcs8 file */
if (res == GKM_DATA_SUCCESS) {
self->is_encrypted = FALSE;
/* If it's locked, then use our token password */
} else if (res == GKM_DATA_LOCKED) {
self->is_encrypted = TRUE;
if (!login) {
g_message ("encountered private key but no private key present");
return FALSE;
}
password = gkm_secret_get_password (login, &n_password);
res = gkm_data_der_read_private_pkcs8 (data, password, n_password, &sexp);
}
switch (res) {
case GKM_DATA_LOCKED:
g_message ("private key is encrypted with wrong password");
return FALSE;
case GKM_DATA_FAILURE:
g_message ("couldn't parse private key");
return FALSE;
case GKM_DATA_UNRECOGNIZED:
g_message ("invalid or unrecognized private key");
return FALSE;
case GKM_DATA_SUCCESS:
break;
default:
g_assert_not_reached();
}
/* Calculate a public key as our 'base' */
if (!gkm_sexp_key_to_public (sexp, &pub))
g_return_val_if_reached (FALSE);
/* Keep the public part of the key around for answering queries */
wrapper = gkm_sexp_new (pub);
gkm_sexp_key_set_base (GKM_SEXP_KEY (self), wrapper);
gkm_sexp_unref (wrapper);
/* Encrypted private key, keep login and data */
if (self->is_encrypted) {
if (self->private_bytes)
g_bytes_unref (self->private_bytes);
self->private_bytes = g_bytes_ref (data);
g_object_ref (login);
if (self->login)
g_object_unref (self->login);
self->login = login;
/* Don't need the private key any more */
gcry_sexp_release (sexp);
/* Not encrypted, just keep the parsed key */
} else {
wrapper = gkm_sexp_new (sexp);
if (self->private_sexp)
gkm_sexp_unref (self->private_sexp);
self->private_sexp = wrapper;
if (self->login)
g_object_unref (login);
self->login = NULL;
}
return TRUE;
}
static void
dfu_patch_chunk_free (DfuPatchChunk *chunk)
{
g_bytes_unref (chunk->blob);
g_free (chunk);
}
static void
send_index_response (CockpitWebResponse *response,
CockpitWebService *service,
JsonObject *modules)
{
GHashTable *out_headers;
GError *error = NULL;
GMappedFile *file = NULL;
GBytes *body = NULL;
GBytes *prefix = NULL;
GBytes *environ = NULL;
GBytes *suffix = NULL;
gchar *index_html;
const gchar *needle;
const gchar *data;
const gchar *pos;
gsize needle_len;
gsize length;
gsize offset;
/*
* Since the index file cannot be properly cached, it can change on
* each request, so we include full environment information directly
* rather than making the client do another round trip later.
*
* If the caller is already logged in, then this is included in the
* environment.
*/
index_html = g_build_filename (cockpit_ws_static_directory, "index.html", NULL);
file = g_mapped_file_new (index_html, FALSE, &error);
if (file == NULL)
{
g_warning ("%s: %s", index_html, error->message);
cockpit_web_response_error (response, 500, NULL, NULL);
g_clear_error (&error);
goto out;
}
body = g_mapped_file_get_bytes (file);
data = g_bytes_get_data (body, &length);
needle = "cockpit_environment_info";
pos = g_strstr_len (data, length, needle);
if (!pos)
{
g_warning ("couldn't find 'cockpit_environment_info' string in index.html");
cockpit_web_response_error (response, 500, NULL, NULL);
goto out;
}
environ = build_environment (service, modules);
offset = (pos - data);
prefix = g_bytes_new_from_bytes (body, 0, offset);
needle_len = strlen (needle);
suffix = g_bytes_new_from_bytes (body, offset + needle_len,
length - (offset + needle_len));
out_headers = cockpit_web_server_new_table ();
g_hash_table_insert (out_headers, g_strdup ("Content-Type"), g_strdup ("text/html; charset=utf8"));
cockpit_web_response_content (response, out_headers, prefix, environ, suffix, NULL);
g_hash_table_unref (out_headers);
out:
g_free (index_html);
if (prefix)
g_bytes_unref (prefix);
if (body)
g_bytes_unref (body);
if (environ)
g_bytes_unref (environ);
if (suffix)
g_bytes_unref (suffix);
if (file)
g_mapped_file_unref (file);
}
static void
update_wireless_setting_from_if_block(NMConnection *connection,
if_block *block)
{
gint wpa_l= strlen("wpa-");
gint wireless_l= strlen("wireless-");
if_data *curr = block->info;
const gchar* value = ifparser_getkey (block, "inet");
struct _Mapping mapping[] = {
{"ssid", "ssid"},
{"essid", "ssid"},
{"mode", "mode"},
{ NULL, NULL}
};
NMSettingWireless *wireless_setting = NULL;
if(value && !strcmp("ppp", value)) {
return;
}
nm_log_info (LOGD_SETTINGS, "update wireless settings (%s).", block->name);
wireless_setting = NM_SETTING_WIRELESS(nm_setting_wireless_new());
while(curr) {
if(strlen(curr->key) > wireless_l &&
!strncmp("wireless-", curr->key, wireless_l)) {
const gchar* newkey = map_by_mapping(mapping, curr->key+wireless_l);
nm_log_info (LOGD_SETTINGS, "wireless setting key: %s='%s'", newkey, curr->data);
if(newkey && !strcmp("ssid", newkey)) {
GBytes *ssid;
gint len = strlen(curr->data);
ssid = g_bytes_new (curr->data, len);
g_object_set (wireless_setting, NM_SETTING_WIRELESS_SSID, ssid, NULL);
g_bytes_unref (ssid);
nm_log_info (LOGD_SETTINGS, "setting wireless ssid = %d", len);
} else if(newkey && !strcmp("mode", newkey)) {
if (!g_ascii_strcasecmp (curr->data, "Managed") || !g_ascii_strcasecmp (curr->data, "Auto"))
g_object_set (wireless_setting, NM_SETTING_WIRELESS_MODE, NM_SETTING_WIRELESS_MODE_INFRA, NULL);
else if (!g_ascii_strcasecmp (curr->data, "Ad-Hoc"))
g_object_set (wireless_setting, NM_SETTING_WIRELESS_MODE, NM_SETTING_WIRELESS_MODE_ADHOC, NULL);
else if (!g_ascii_strcasecmp (curr->data, "Master"))
g_object_set (wireless_setting, NM_SETTING_WIRELESS_MODE, NM_SETTING_WIRELESS_MODE_AP, NULL);
else
nm_log_warn (LOGD_SETTINGS, "Invalid mode '%s' (not 'Ad-Hoc', 'Ap', 'Managed', or 'Auto')", curr->data);
} else {
g_object_set(wireless_setting,
newkey, curr->data,
NULL);
}
} else if(strlen(curr->key) > wpa_l &&
!strncmp("wpa-", curr->key, wpa_l)) {
const gchar* newkey = map_by_mapping(mapping, curr->key+wpa_l);
if(newkey && !strcmp("ssid", newkey)) {
GBytes *ssid;
gint len = strlen(curr->data);
ssid = g_bytes_new (curr->data, len);
g_object_set (wireless_setting, NM_SETTING_WIRELESS_SSID, ssid, NULL);
g_bytes_unref (ssid);
nm_log_info (LOGD_SETTINGS, "setting wpa ssid = %d", len);
} else if(newkey) {
g_object_set(wireless_setting,
newkey, curr->data,
NULL);
nm_log_info (LOGD_SETTINGS, "setting wpa newkey(%s)=data(%s)", newkey, curr->data);
}
}
curr = curr->next;
}
nm_connection_add_setting(connection, (NMSetting*) wireless_setting);
}
static void
on_files_listed (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
JsonObject *options;
GList *files;
files = g_file_enumerator_next_files_finish (G_FILE_ENUMERATOR (source_object), res, &error);
if (error)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
CockpitFslist *self = COCKPIT_FSLIST (user_data);
g_message ("%s: couldn't process files %s", COCKPIT_FSLIST(user_data)->path, error->message);
options = cockpit_channel_close_options (COCKPIT_CHANNEL (self));
json_object_set_string_member (options, "message", error->message);
cockpit_channel_close (COCKPIT_CHANNEL (self), "internal-error");
}
g_clear_error (&error);
return;
}
CockpitFslist *self = COCKPIT_FSLIST (user_data);
if (files == NULL)
{
JsonObject *msg;
GBytes *msg_bytes;
msg = json_object_new ();
json_object_set_string_member (msg, "event", "present-done");
msg_bytes = cockpit_json_write_bytes (msg);
json_object_unref (msg);
cockpit_channel_send (COCKPIT_CHANNEL(self), msg_bytes, FALSE);
g_bytes_unref (msg_bytes);
g_clear_object (&self->cancellable);
g_object_unref (source_object);
if (self->monitor == NULL)
{
cockpit_channel_done (COCKPIT_CHANNEL (self));
cockpit_channel_close (COCKPIT_CHANNEL (self), NULL);
}
return;
}
for (GList *l = files; l; l = l->next)
{
GFileInfo *info = G_FILE_INFO (l->data);
JsonObject *msg;
GBytes *msg_bytes;
msg = json_object_new ();
json_object_set_string_member (msg, "event", "present");
json_object_set_string_member
(msg, "path", g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_STANDARD_NAME));
json_object_set_string_member
(msg, "type", cockpit_file_type_to_string (g_file_info_get_file_type (info)));
msg_bytes = cockpit_json_write_bytes (msg);
json_object_unref (msg);
cockpit_channel_send (COCKPIT_CHANNEL(self), msg_bytes, FALSE);
g_bytes_unref (msg_bytes);
}
g_list_free_full (files, g_object_unref);
g_file_enumerator_next_files_async (G_FILE_ENUMERATOR (source_object),
10,
G_PRIORITY_DEFAULT,
self->cancellable,
on_files_listed,
self);
}
GtkWidget *
do_listbox (GtkWidget *do_widget)
{
GtkWidget *scrolled, *listbox, *vbox, *label;
GtkMessage *message;
GtkMessageRow *row;
GBytes *data;
char **lines;
int i;
if (!window)
{
avatar_pixbuf_other = gdk_pixbuf_new_from_resource_at_scale ("/listbox/apple-red.png", 32, 32, FALSE, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "List Box");
gtk_window_set_default_size (GTK_WINDOW (window),
400, 600);
/* NULL window variable when window is closed */
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("Messages from Gtk+ and friends");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
listbox = gtk_list_box_new ();
gtk_container_add (GTK_CONTAINER (scrolled), listbox);
gtk_list_box_set_sort_func (GTK_LIST_BOX (listbox), (GtkListBoxSortFunc)gtk_message_row_sort, listbox, NULL);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (listbox), FALSE);
g_signal_connect (listbox, "row-activated", G_CALLBACK (row_activated), NULL);
gtk_widget_show_all (vbox);
data = g_resources_lookup_data ("/listbox/messages.txt", 0, NULL);
lines = g_strsplit (g_bytes_get_data (data, NULL), "\n", 0);
for (i = 0; lines[i] != NULL && *lines[i]; i++)
{
message = gtk_message_new (lines[i]);
row = gtk_message_row_new (message);
gtk_widget_show (GTK_WIDGET (row));
gtk_container_add (GTK_CONTAINER (listbox), GTK_WIDGET (row));
}
g_strfreev (lines);
g_bytes_unref (data);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
