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; }