static void test_type(const char *type) {
CVariant *cv;
GVariant *gv;
GBytes *cb, *gb;
const void *cd, *gd;
test_generate(type, &cv, &gv);
cb = test_cv_get_data_as_bytes(cv);
gb = g_variant_get_data_as_bytes(gv);
if (g_bytes_compare(cb, gb)) {
fprintf(stderr, "FAILED: %s\n", type);
cd = g_bytes_get_data(cb, NULL);
gd = g_bytes_get_data(gb, NULL);
fprintf(stderr, "Buffers: %p:%zu %p:%zu\n",
cd, g_bytes_get_size(cb),
gd, g_bytes_get_size(gb));
test_print_cv(cv);
assert(0);
}
test_compare(cv, gv);
g_bytes_unref(gb);
g_bytes_unref(cb);
g_variant_unref(gv);
c_variant_free(cv);
}
/**
* _g_bytes_compare_verbose:
**/
static gchar *
_g_bytes_compare_verbose (GBytes *bytes1, GBytes *bytes2)
{
const guint8 *data1;
const guint8 *data2;
gsize length1;
gsize length2;
guint i;
data1 = g_bytes_get_data (bytes1, &length1);
data2 = g_bytes_get_data (bytes2, &length2);
/* not the same length */
if (length1 != length2) {
return g_strdup_printf ("got %" G_GSIZE_FORMAT " bytes, "
"expected %" G_GSIZE_FORMAT,
length1, length2);
}
/* return 00 01 02 03 */
for (i = 0; i < length1; i++) {
if (data1[i] != data2[i]) {
return g_strdup_printf ("got 0x%02x, expected 0x%02x @ 0x%04x",
data1[i], data2[i], i);
}
}
return NULL;
}
static void
g_tls_client_connection_gnutls_begin_handshake (GTlsConnectionGnutls *conn)
{
GTlsClientConnectionGnutls *gnutls = G_TLS_CLIENT_CONNECTION_GNUTLS (conn);
/* Try to get a cached session */
if (gnutls->priv->session_data_override)
{
gnutls_session_set_data (g_tls_connection_gnutls_get_session (conn),
g_bytes_get_data (gnutls->priv->session_data, NULL),
g_bytes_get_size (gnutls->priv->session_data));
}
else if (gnutls->priv->session_id)
{
GBytes *session_data;
session_data = g_tls_backend_gnutls_lookup_session (GNUTLS_CLIENT, gnutls->priv->session_id);
if (session_data)
{
gnutls_session_set_data (g_tls_connection_gnutls_get_session (conn),
g_bytes_get_data (session_data, NULL),
g_bytes_get_size (session_data));
g_clear_pointer (&gnutls->priv->session_data, g_bytes_unref);
gnutls->priv->session_data = session_data;
}
}
gnutls->priv->cert_requested = FALSE;
}
void test_rsa(void)
{
// my keys
MegaAesKey* mk = mega_aes_key_new_from_ubase64(MY_MASTER_KEY);
MegaRsaKey* rk = mega_rsa_key_new();
g_assert(mega_rsa_key_load_enc_privk(rk, MY_PRIVK_ENC, mk));
g_assert(mega_rsa_key_load_pubk(rk, MY_PUBK));
GBytes* sid_bytes = mega_rsa_key_decrypt(rk, MY_CSID);
g_assert_cmpuint(g_bytes_get_size(sid_bytes), >=, 43);
gchar* sid = mega_base64urlencode(g_bytes_get_data(sid_bytes, NULL), 43);
g_assert_cmpstr(sid, ==, MY_SID);
g_assert_cmpstr(mega_rsa_key_get_pubk(rk), ==, MY_PUBK);
// last block can be different, because it's random padded
g_assert_cmpstr(trim_last_block(mega_rsa_key_get_enc_privk(rk, mk)), ==, trim_last_block(MY_PRIVK_ENC));
// test encryption
guchar plain[16] = {0xff};
gchar* cipher = mega_rsa_key_encrypt(rk, plain, 16);
GBytes* plain_bytes = mega_rsa_key_decrypt(rk, cipher);
g_assert(plain_bytes != NULL);
g_assert_cmpuint(g_bytes_get_size(plain_bytes), >, 16);
g_assert(memcmp(g_bytes_get_data(plain_bytes, NULL), plain, 16) == 0);
// Mega BUG: Plaintext can't start with zero!
memset(plain, 0, 16);
cipher = mega_rsa_key_encrypt(rk, plain, 16);
plain_bytes = mega_rsa_key_decrypt(rk, cipher);
g_assert(plain_bytes != NULL);
g_assert_cmpuint(g_bytes_get_size(plain_bytes), >, 16);
g_assert(memcmp(g_bytes_get_data(plain_bytes, NULL), plain, 16) == 0);
// generate key
g_assert(mega_rsa_key_generate(rk));
gchar* privk1 = mega_rsa_key_get_enc_privk(rk, mk);
gchar* pubk1 = mega_rsa_key_get_pubk(rk);
g_assert(mega_rsa_key_generate(rk));
gchar* privk2 = mega_rsa_key_get_enc_privk(rk, mk);
gchar* pubk2 = mega_rsa_key_get_pubk(rk);
g_assert_cmpstr(pubk1, !=, pubk2);
// last block can be different, because it's random padded
g_assert_cmpstr(trim_last_block(privk1), !=, trim_last_block(privk2));
// INVALID USES
g_assert(!mega_rsa_key_load_enc_privk(rk, MY_CSID, mk));
g_assert(!mega_rsa_key_load_pubk(rk, MY_CSID));
g_assert(!mega_rsa_key_load_enc_privk(rk, KEY_INVALID, mk));
g_assert(!mega_rsa_key_load_pubk(rk, KEY_INVALID));
g_assert(!mega_rsa_key_load_enc_privk(rk, KEY_NULL, mk));
g_assert(!mega_rsa_key_load_pubk(rk, KEY_NULL));
}
static gboolean
meta_monitor_manager_handle_set_crtc_gamma (MetaDBusDisplayConfig *skeleton,
GDBusMethodInvocation *invocation,
guint serial,
guint crtc_id,
GVariant *red_v,
GVariant *green_v,
GVariant *blue_v)
{
MetaMonitorManager *manager = META_MONITOR_MANAGER (skeleton);
MetaMonitorManagerClass *klass;
MetaCRTC *crtc;
gsize size, dummy;
unsigned short *red;
unsigned short *green;
unsigned short *blue;
GBytes *red_bytes, *green_bytes, *blue_bytes;
if (serial != manager->serial)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_ACCESS_DENIED,
"The requested configuration is based on stale information");
return TRUE;
}
if (crtc_id >= manager->n_crtcs)
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Invalid crtc id");
return TRUE;
}
crtc = &manager->crtcs[crtc_id];
red_bytes = g_variant_get_data_as_bytes (red_v);
green_bytes = g_variant_get_data_as_bytes (green_v);
blue_bytes = g_variant_get_data_as_bytes (blue_v);
size = g_bytes_get_size (red_bytes) / sizeof (unsigned short);
red = (unsigned short*) g_bytes_get_data (red_bytes, &dummy);
green = (unsigned short*) g_bytes_get_data (green_bytes, &dummy);
blue = (unsigned short*) g_bytes_get_data (blue_bytes, &dummy);
klass = META_MONITOR_MANAGER_GET_CLASS (manager);
if (klass->set_crtc_gamma)
klass->set_crtc_gamma (manager, crtc, size, red, green, blue);
meta_dbus_display_config_complete_set_crtc_gamma (skeleton, invocation);
g_bytes_unref (red_bytes);
g_bytes_unref (green_bytes);
g_bytes_unref (blue_bytes);
return TRUE;
}
static CK_RV
trust_get_hash (GkmXdgTrust *self, GChecksumType ctype, CK_ATTRIBUTE_PTR attr)
{
GNode *cert;
GBytes *element;
CK_RV rv;
cert = egg_asn1x_node (self->pv->asn, "reference", "certComplete", NULL);
g_return_val_if_fail (cert, CKR_GENERAL_ERROR);
/* If it's not stored, then this attribute is not present */
if (!egg_asn1x_have (cert)) {
gkm_debug ("CKR_ATTRIBUTE_TYPE_INVALID: %s wants certComplete which is not part of assertion",
gkm_log_attr_type (attr->type));
return CKR_ATTRIBUTE_TYPE_INVALID;
}
element = egg_asn1x_get_element_raw (cert);
g_return_val_if_fail (element != NULL, CKR_GENERAL_ERROR);
rv = gkm_attribute_set_checksum (attr, ctype,
g_bytes_get_data (element, NULL),
g_bytes_get_size (element));
g_bytes_unref (element);
return rv;
}
gboolean
tpaw_xml_validate_from_resource (xmlDoc *doc,
const gchar *dtd_resourcename)
{
GBytes *resourcecontents;
gconstpointer resourcedata;
gsize resourcesize;
xmlParserInputBufferPtr buffer;
xmlValidCtxt cvp;
xmlDtd *dtd;
GError *error = NULL;
gboolean ret;
DEBUG ("Loading dtd resource %s", dtd_resourcename);
resourcecontents = g_resources_lookup_data (dtd_resourcename, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (error != NULL)
{
g_warning ("Unable to load dtd resource '%s': %s", dtd_resourcename, error->message);
g_error_free (error);
return FALSE;
}
resourcedata = g_bytes_get_data (resourcecontents, &resourcesize);
buffer = xmlParserInputBufferCreateStatic (resourcedata, resourcesize, XML_CHAR_ENCODING_UTF8);
memset (&cvp, 0, sizeof (cvp));
dtd = xmlIOParseDTD (NULL, buffer, XML_CHAR_ENCODING_UTF8);
ret = xmlValidateDtd (&cvp, doc, dtd);
xmlFreeDtd (dtd);
g_bytes_unref (resourcecontents);
return ret;
}
static void on_sequence_complete(GIO_ASYNCSEQ_HANDLE async_seq_handle, gpointer previous_result)
{
READ_CONTEXT* context = (READ_CONTEXT*)GIO_Async_Seq_GetContext(async_seq_handle);
GBytes* data = (GBytes*)previous_result;
const unsigned char* buffer;
size_t size;
if (data != NULL)
{
buffer = g_bytes_get_data(data, &size);
}
else
{
buffer = NULL;
size = 0;
}
/*Codes_SRS_BLEIO_GATT_13_032: [ BLEIO_gatt_read_char_by_uuid shall invoke on_bleio_gatt_attrib_read_complete when the read operation completes. ]*/
/*Codes_SRS_BLEIO_GATT_13_033: [ BLEIO_gatt_read_char_by_uuid shall pass the value of the callback_context parameter to on_bleio_gatt_attrib_read_complete as the context parameter when it is invoked. ]*/
/*Codes_SRS_BLEIO_GATT_13_034: [BLEIO_gatt_read_char_by_uuid, when successful, shall supply the data that has been read to the on_bleio_gatt_attrib_read_complete callback along with the value BLEIO_GATT_OK for the result parameter.]*/
context->on_read_complete(
(BLEIO_GATT_HANDLE)context->handle_data,
context->callback_context,
BLEIO_GATT_OK,
buffer,
size
);
g_bytes_unref(data);
free_context(context);
}
static void
nmc_convert_bytes_to_string (const GValue *src_value, GValue *dest_value)
{
GBytes *bytes;
const guint8 *array;
gsize length;
GString *printable;
guint i = 0;
bytes = g_value_get_boxed (src_value);
printable = g_string_new ("[");
if (bytes) {
array = g_bytes_get_data (bytes, &length);
while (i < MIN (length, 35)) {
if (i > 0)
g_string_append_c (printable, ' ');
g_string_append_printf (printable, "0x%02X", array[i++]);
}
if (i < length)
g_string_append (printable, " ... ");
}
g_string_append_c (printable, ']');
g_value_take_string (dest_value, g_string_free (printable, FALSE));
}
static GBytes *
check_utf8_and_force_if_necessary (GBytes *input)
{
const gchar *data;
const gchar *end;
gsize length;
GString *string;
data = g_bytes_get_data (input, &length);
if (g_utf8_validate (data, length, &end))
return g_bytes_ref (input);
string = g_string_sized_new (length + 16);
do
{
/* Valid part of the string */
g_string_append_len (string, data, end - data);
/* Replacement character */
g_string_append (string, "\xef\xbf\xbd");
length -= (end - data) + 1;
data = end + 1;
}
while (!g_utf8_validate (data, length, &end));
if (length)
g_string_append_len (string, data, length);
return g_string_free_to_bytes (string);
}
/**
* CacheUtilHashPassword:
* @algorithm: Hash algorithm.
* @salt: Random data, usually stored with the hash.
* @password: Secret value to hash.
*
* Returns: (allow-none): Hash value of concatenated @salt and @password, or
* #NULL if an argument was invalid.
*/
GBytes *CacheUtilHashPassword(GChecksumType algorithm, GBytes *salt,
const char *password) {
GChecksum *checksum = NULL;
gssize checksum_len = -1;
guint8 *result = NULL;
gsize result_len = 0;
if (!salt || !password)
return NULL;
checksum_len = g_checksum_type_get_length(algorithm);
if (checksum_len <= 0)
return NULL;
checksum = g_checksum_new(algorithm);
if (!checksum)
return NULL;
g_checksum_update(
checksum, g_bytes_get_data(salt, NULL), g_bytes_get_size(salt));
g_checksum_update(checksum, (guint8 *) password, strlen(password));
result = g_malloc(checksum_len);
result_len = checksum_len;
g_checksum_get_digest(checksum, result, &result_len);
g_assert(checksum_len == result_len);
g_checksum_free(checksum);
return g_bytes_new_take(result, result_len);
}
void
mpid_read_device_file (MPIDDevice *device, const char *device_info_path)
{
GError *error = NULL;
GKeyFile *keyfile;
GBytes *bytes;
gsize len;
const void *data;
keyfile = g_key_file_new ();
bytes = g_resources_lookup_data (device_info_path, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (bytes != NULL) {
data = g_bytes_get_data (bytes, &len);
if (g_key_file_load_from_data (keyfile, data, len, G_KEY_FILE_NONE, &error) == FALSE) {
mpid_debug ("unable to read device info resource %s: %s\n", device_info_path, error->message);
g_clear_error (&error);
device->error = MPID_ERROR_DEVICE_INFO_MISSING;
g_bytes_unref (bytes);
return;
}
} else if (g_key_file_load_from_file (keyfile, device_info_path, G_KEY_FILE_NONE, &error) == FALSE) {
mpid_debug ("unable to read device info file %s: %s\n", device_info_path, error->message);
g_clear_error (&error);
device->error = MPID_ERROR_DEVICE_INFO_MISSING;
return;
}
mpid_read_keyfile (device, keyfile);
g_key_file_free (keyfile);
}
/**
* fu_sign_process_file_cab:
**/
static gboolean
fu_sign_process_file_cab (FuSignPrivate *priv,
const gchar *fn_src,
const gchar *fn_dst,
GError **error)
{
gsize fw_len = 0;
_cleanup_bytes_unref_ GBytes *fw = NULL;
_cleanup_bytes_unref_ GBytes *sig = NULL;
_cleanup_free_ gchar *fw_data = NULL;
_cleanup_free_ gchar *fn_bin_asc = NULL;
_cleanup_object_unref_ FuCab *cab = NULL;
_cleanup_object_unref_ GFile *src = NULL;
_cleanup_object_unref_ GFile *dst = NULL;
const gchar *fn_bin;
g_info ("processing %s", fn_src);
/* open the .cab file and extract firmware */
cab = fu_cab_new ();
src = g_file_new_for_path (fn_src);
if (!fu_cab_load_file (cab, src, NULL, error))
return FALSE;
if (!fu_cab_extract (cab, FU_CAB_EXTRACT_FLAG_ALL, error))
return FALSE;
/* sign the .bin */
fn_bin = fu_cab_get_filename_firmware (cab);
g_info ("signing %s with key %s", fn_bin, priv->key_id);
if (!g_file_get_contents (fn_bin, &fw_data, &fw_len, error))
return FALSE;
fw = g_bytes_new_static (fw_data, fw_len);
sig = fu_keyring_sign_data (priv->keyring, fw, error);
if (sig == NULL)
return FALSE;
/* write new detached signature */
fn_bin_asc = g_strdup_printf ("%s.asc", fn_bin);
g_debug ("writing to %s", fn_bin_asc);
if (!g_file_set_contents (fn_bin_asc,
g_bytes_get_data (sig, NULL),
g_bytes_get_size (sig),
error))
return FALSE;
/* add to file list */
fu_cab_add_file (cab, fn_bin_asc);
/* add the detached signature to the .cab file */
g_debug ("saving %s", fn_dst);
dst = g_file_new_for_path (fn_dst);
if (!fu_cab_save_file (cab, dst, NULL, error))
return FALSE;
/* delete the working space */
g_unlink (fn_bin_asc);
if (!fu_cab_delete_temp_files (cab, error))
return FALSE;
return TRUE;
}
/**
* fu_sign_process_file_xml:
**/
static gboolean
fu_sign_process_file_xml (FuSignPrivate *priv,
const gchar *fn_src,
const gchar *fn_dst,
GError **error)
{
gsize xml_len = 0;
_cleanup_bytes_unref_ GBytes *xml = NULL;
_cleanup_bytes_unref_ GBytes *sig = NULL;
_cleanup_free_ gchar *xml_data = NULL;
/* sign the firmware */
g_info ("signing %s with key %s", fn_src, priv->key_id);
if (!g_file_get_contents (fn_src, &xml_data, &xml_len, error))
return FALSE;
xml = g_bytes_new_static (xml_data, xml_len);
sig = fu_keyring_sign_data (priv->keyring, xml, error);
if (sig == NULL)
return FALSE;
/* write new detached signature */
g_debug ("writing to %s", fn_dst);
if (!g_file_set_contents (fn_dst,
g_bytes_get_data (sig, NULL),
g_bytes_get_size (sig),
error))
return FALSE;
return TRUE;
}
gboolean
_ostree_static_delta_part_execute (OstreeRepo *repo,
GVariant *header,
GBytes *part_bytes,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
gsize partlen;
const guint8*partdata;
gs_unref_bytes GBytes *part_payload_bytes = NULL;
gs_unref_bytes GBytes *payload_data = NULL;
gs_unref_variant GVariant *payload = NULL;
guint8 comptype;
partdata = g_bytes_get_data (part_bytes, &partlen);
if (partlen < 1)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Corrupted 0 length delta part");
goto out;
}
/* First byte is compression type */
comptype = partdata[0];
/* Then the rest may be compressed or uncompressed */
part_payload_bytes = g_bytes_new_from_bytes (part_bytes, 1, partlen - 1);
switch (comptype)
{
case 0:
/* No compression */
payload_data = g_bytes_ref (part_payload_bytes);
break;
case 'x':
{
gs_unref_object GConverter *decomp =
(GConverter*) _ostree_lzma_decompressor_new ();
if (!decompress_all (decomp, part_payload_bytes, &payload_data,
cancellable, error))
goto out;
}
break;
default:
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Invalid compression type '%u'", comptype);
goto out;
}
payload = g_variant_new_from_bytes (G_VARIANT_TYPE (OSTREE_STATIC_DELTA_PART_PAYLOAD_FORMAT_V0),
payload_data, FALSE);
if (!_ostree_static_delta_part_execute_raw (repo, header, payload,
cancellable, error))
goto out;
ret = TRUE;
out:
return ret;
}
static const GstCencKeyPair*
gst_cenc_decrypt_lookup_key (GstCencDecrypt * self, GstBuffer * kid)
{
GstMapInfo info;
const GstCencKeyPair *kp=NULL;
int i;
gsize sz;
/*
GstMapInfo info;
gchar *id_string;
gst_buffer_map (kid, &info, GST_MAP_READ);
id_string = gst_cenc_create_uuid_string (info.data);
GST_DEBUG_OBJECT (self, "Looking up key ID: %s", id_string);
g_free (id_string);
gst_buffer_unmap (kid, &info);
*/
for (i = 0; kp==NULL && i < self->keys->len; ++i) {
const GstCencKeyPair *k;
k = g_ptr_array_index (self->keys, i);
if(gst_buffer_memcmp (kid, 0, g_bytes_get_data (k->key_id, NULL), KEY_LENGTH)==0){
kp=k;
}
}
if (!kp) {
kp = gst_cenc_decrypt_get_key (self, kid);
}
return kp;
}
/**
* gcr_fingerprint_from_attributes:
* @attrs: attributes for key or certificate
* @checksum_type: the type of fingerprint to create
* @n_fingerprint: the length of fingerprint returned
*
* Create a key fingerprint for a certificate, public key or private key.
* Note that this is not a fingerprint of certificate data, which you would
* use gcr_certificate_get_fingerprint() for.
*
* Returns: (transfer full) (allow-none) (array length=n_fingerprint): the
* fingerprint or %NULL if the input was invalid.
*/
guchar *
gcr_fingerprint_from_attributes (GckAttributes *attrs,
GChecksumType checksum_type,
gsize *n_fingerprint)
{
gpointer fingerprint = NULL;
GBytes *info;
GNode *asn;
g_return_val_if_fail (attrs != NULL, NULL);
g_return_val_if_fail (n_fingerprint, NULL);
asn = _gcr_subject_public_key_for_attributes (attrs);
if (asn != NULL) {
info = egg_asn1x_encode (asn, NULL);
fingerprint = gcr_fingerprint_from_subject_public_key_info (g_bytes_get_data (info, NULL),
g_bytes_get_size (info),
checksum_type,
n_fingerprint);
g_bytes_unref (info);
}
egg_asn1x_destroy (asn);
return fingerprint;
}
static gboolean
is_binary_data (GBytes *bytes)
{
gsize length;
gconstpointer data = g_bytes_get_data (bytes, &length);
return (memchr (data, '\0', length) != NULL);
}
/**
* dfu_firmware_from_dfuse: (skip)
* @firmware: a #DfuFirmware
* @bytes: data to parse
* @flags: some #DfuFirmwareParseFlags
* @error: a #GError, or %NULL
*
* Unpacks into a firmware object from DfuSe data.
*
* Returns: %TRUE for success
**/
gboolean
dfu_firmware_from_dfuse (DfuFirmware *firmware,
GBytes *bytes,
DfuFirmwareParseFlags flags,
GError **error)
{
DfuSePrefix *prefix;
gsize len;
guint32 offset = sizeof(DfuSePrefix);
guint8 *data;
/* check the prefix (BE) */
data = (guint8 *) g_bytes_get_data (bytes, &len);
prefix = (DfuSePrefix *) data;
if (memcmp (prefix->sig, "DfuSe", 5) != 0) {
g_set_error_literal (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"invalid DfuSe prefix");
return FALSE;
}
/* check the version */
if (prefix->ver != 0x01) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"invalid DfuSe version, got %02x",
prefix->ver);
return FALSE;
}
/* check image size */
if (GUINT32_FROM_LE (prefix->image_size) != len) {
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_INTERNAL,
"invalid DfuSe image size, "
"got %" G_GUINT32_FORMAT ", "
"expected %" G_GSIZE_FORMAT,
GUINT32_FROM_LE (prefix->image_size),
len);
return FALSE;
}
/* parse the image targets */
len -= sizeof(DfuSePrefix);
for (guint i = 0; i < prefix->targets; i++) {
guint consumed;
g_autoptr(DfuImage) image = NULL;
image = dfu_image_from_dfuse (data + offset, (guint32) len,
&consumed, error);
if (image == NULL)
return FALSE;
dfu_firmware_add_image (firmware, image);
offset += consumed;
len -= consumed;
}
return TRUE;
}
/**
* g_variant_new_from_bytes:
* @type: a #GVariantType
* @bytes: a #GBytes
* @trusted: if the contents of @bytes are trusted
*
* Constructs a new serialised-mode #GVariant instance. This is the
* inner interface for creation of new serialised values that gets
* called from various functions in gvariant.c.
*
* A reference is taken on @bytes.
*
* Returns: a new #GVariant with a floating reference
*
* Since: 2.36
*/
GVariant *
g_variant_new_from_bytes (const GVariantType *type,
GBytes *bytes,
gboolean trusted)
{
GVariant *value;
guint alignment;
gsize size;
value = g_variant_alloc (type, TRUE, trusted);
value->contents.serialised.bytes = g_bytes_ref (bytes);
g_variant_type_info_query (value->type_info,
&alignment, &size);
if (size && g_bytes_get_size (bytes) != size)
{
/* Creating a fixed-sized GVariant with a bytes of the wrong
* size.
*
* We should do the equivalent of pulling a fixed-sized child out
* of a brozen container (ie: data is NULL size is equal to the correct
* fixed size).
*/
value->contents.serialised.data = NULL;
value->size = size;
}
else
{
value->contents.serialised.data = g_bytes_get_data (bytes, &value->size);
}
return value;
}
/**
* cockpit_transport_parse_frame:
* @message: message to parse
* @channel: location to return the channel
*
* Parse a message into a channel and payload.
* @channel will be set to NULL if a control channel
* message. @channel must be freed.
*
* Will return NULL if invalid message.
*
* Returns: (transfer full): the payload or NULL.
*/
GBytes *
cockpit_transport_parse_frame (GBytes *message,
gchar **channel)
{
const gchar *data;
gsize length;
const gchar *line;
gsize channel_len;
g_return_val_if_fail (message != NULL, NULL);
data = g_bytes_get_data (message, &length);
line = memchr (data, '\n', length);
if (!line)
{
g_warning ("Received invalid message without channel prefix");
return NULL;
}
channel_len = line - data;
if (memchr (data, '\0', channel_len) != NULL)
{
g_warning ("Received massage with invalid channel prefix");
return NULL;
}
if (channel_len)
*channel = g_strndup (data, channel_len);
else
*channel = NULL;
channel_len++;
return g_bytes_new_from_bytes (message, channel_len, length - channel_len);
}
guint32
fu_wac_calculate_checksum32le_bytes (GBytes *blob)
{
gsize len = 0;
const guint8 *data = g_bytes_get_data (blob, &len);
return fu_wac_calculate_checksum32le (data, len);
}
static GBytes *
base64_encode (GBytes *bytes)
{
gconstpointer data;
gchar *encoded;
gsize length;
gint state = 0;
gint save = 0;
data = g_bytes_get_data (bytes, &length);
if (length == 0)
return g_bytes_new_static ("", 0);
/* We can use a smaller limit here, since we know the saved state is 0,
+1 is needed for trailing \0, also check for unlikely integer overflow */
if (length >= ((G_MAXSIZE - 1) / 4 - 1) * 3)
g_error ("%s: input too large for Base64 encoding (%"G_GSIZE_FORMAT" chars)", G_STRLOC, length);
encoded = g_malloc ((length / 3 + 1) * 4 + 4);
length = g_base64_encode_step (data, length, FALSE, encoded, &state, &save);
length += g_base64_encode_close (FALSE, encoded + length, &state, &save);
return g_bytes_new_take (encoded, length);
}
static void
_gth_window_add_css_provider (GtkWidget *widget,
const char *path)
{
GBytes *bytes;
gconstpointer css_data;
gsize css_data_size;
GtkCssProvider *css_provider;
GError *error = NULL;
bytes = g_resources_lookup_data (path, 0, &error);
if (bytes == NULL) {
g_warning ("%s", error->message);
g_error_free (error);
return;
}
css_data = g_bytes_get_data (bytes, &css_data_size);
css_provider = gtk_css_provider_new ();
if (! gtk_css_provider_load_from_data (css_provider, css_data, css_data_size, &error)) {
g_warning ("%s", error->message);
g_error_free (error);
}
gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (widget),
GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
g_bytes_unref (bytes);
}
static void
on_web_socket_message(SoupWebsocketConnection *ws,
SoupWebsocketDataType type,
GBytes *message,
void *user_data)
{
const gchar *data;
gsize len;
data = g_bytes_get_data (message, &len);
imgflo_debug("RECV: %.*s\n", (int)len, data);
JsonParser *parser = json_parser_new();
gboolean success = json_parser_load_from_data(parser, data, len, NULL);
if (success) {
JsonNode *r = json_parser_get_root(parser);
g_assert(JSON_NODE_HOLDS_OBJECT(r));
JsonObject *root = json_node_get_object(r);
const gchar *protocol = json_object_get_string_member(root, "protocol");
const gchar *command = json_object_get_string_member(root, "command");
JsonNode *pnode = json_object_get_member(root, "payload");
JsonObject *payload = JSON_NODE_HOLDS_OBJECT(pnode) ? json_object_get_object_member(root, "payload") : NULL;
UiConnection *ui = (UiConnection *)user_data;
ui_connection_handle_message(ui, protocol, command, payload, ws);
} else {
imgflo_warning("Unable to parse WebSocket message as JSON");
}
g_object_unref(parser);
}
static void
on_mechanism_check (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
CompleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
closure->mechanism.type = _gcr_key_mechanisms_check_finish (closure->request->private_key,
result, NULL);
if (closure->mechanism.type == GCK_INVALID) {
g_simple_async_result_set_error (res, GCK_ERROR, CKR_KEY_TYPE_INCONSISTENT,
_("The key cannot be used to sign the request"));
g_simple_async_result_complete (res);
} else {
closure->tbs = prepare_to_be_signed (closure->request, &closure->mechanism);
gck_session_sign_async (closure->session,
closure->request->private_key,
&closure->mechanism,
g_bytes_get_data (closure->tbs, NULL),
g_bytes_get_size (closure->tbs),
closure->cancellable,
on_certificate_request_signed,
g_object_ref (res));
}
g_object_unref (res);
}
static gnutls_datum_t
g_tls_server_connection_gnutls_db_retrieve (void *user_data,
gnutls_datum_t key)
{
GBytes *session_id, *session_data;
gnutls_datum_t data;
session_id = g_bytes_new (key.data, key.size);
session_data = g_tls_backend_gnutls_lookup_session (GNUTLS_SERVER, session_id);
g_bytes_unref (session_id);
if (session_data)
{
data.size = g_bytes_get_size (session_data);
data.data = gnutls_malloc (data.size);
memcpy (data.data, g_bytes_get_data (session_data, NULL), data.size);
g_bytes_unref (session_data);
}
else
{
data.size = 0;
data.data = NULL;
}
return data;
}
static gboolean
add_wep_key (NMSupplicantConfig *self,
const char *key,
const char *name,
NMWepKeyType wep_type)
{
GBytes *bytes;
gboolean success = FALSE;
size_t key_len = key ? strlen (key) : 0;
if (!key || !key_len)
return TRUE;
if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN) {
if (nm_utils_wep_key_valid (key, NM_WEP_KEY_TYPE_KEY))
wep_type = NM_WEP_KEY_TYPE_KEY;
else if (nm_utils_wep_key_valid (key, NM_WEP_KEY_TYPE_PASSPHRASE))
wep_type = NM_WEP_KEY_TYPE_PASSPHRASE;
}
if ( (wep_type == NM_WEP_KEY_TYPE_UNKNOWN)
|| (wep_type == NM_WEP_KEY_TYPE_KEY)) {
if ((key_len == 10) || (key_len == 26)) {
bytes = nm_utils_hexstr2bin (key);
if (bytes) {
success = nm_supplicant_config_add_option (self,
name,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
TRUE);
g_bytes_unref (bytes);
}
if (!success) {
nm_log_warn (LOGD_SUPPLICANT, "Error adding %s to supplicant config.", name);
return FALSE;
}
} else if ((key_len == 5) || (key_len == 13)) {
if (!nm_supplicant_config_add_option (self, name, key, key_len, TRUE)) {
nm_log_warn (LOGD_SUPPLICANT, "Error adding %s to supplicant config.", name);
return FALSE;
}
} else {
nm_log_warn (LOGD_SUPPLICANT, "Invalid WEP key '%s'", name);
return FALSE;
}
} else if (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE) {
guint8 digest[16];
size_t digest_len = sizeof (digest);
success = wep128_passphrase_hash (key, key_len, digest, &digest_len);
if (success)
success = nm_supplicant_config_add_option (self, name, (const char *) digest, digest_len, TRUE);
if (!success) {
nm_log_warn (LOGD_SUPPLICANT, "Error adding %s to supplicant config.", name);
return FALSE;
}
}
return TRUE;
}
static void
on_istream_read_complete (GObject *src,
GAsyncResult *res,
gpointer user_data)
{
HotSshTab *self = user_data;
HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self);
gs_unref_bytes GBytes *result = NULL;
GError *local_error = NULL;
const guint8 *buf;
gsize len;
result = g_input_stream_read_bytes_finish ((GInputStream*)src, res, &local_error);
if (!result)
goto out;
buf = g_bytes_get_data (result, &len);
g_debug ("read %u bytes", (guint)len);
vte_terminal_feed ((VteTerminal*)priv->terminal, (char*)buf, len);
g_input_stream_read_bytes_async ((GInputStream*)src, 8192, G_PRIORITY_DEFAULT,
priv->cancellable, on_istream_read_complete, self);
out:
if (local_error)
page_transition_take_error (self, local_error);
}
/**
* dfu_utils_bytes_join_array:
* @chunks: (element-kind GBytes): bytes
*
* Creates a monolithic block of memory from an array of #GBytes.
*
* Return value: (transfer full): a new GBytes
**/
GBytes *
dfu_utils_bytes_join_array (GPtrArray *chunks)
{
gsize total_size = 0;
guint32 offset = 0;
guint8 *buffer;
/* get the size of all the chunks */
for (guint i = 0; i < chunks->len; i++) {
GBytes *chunk_tmp = g_ptr_array_index (chunks, i);
total_size += g_bytes_get_size (chunk_tmp);
}
/* copy them into a buffer */
buffer = g_malloc0 (total_size);
for (guint i = 0; i < chunks->len; i++) {
const guint8 *chunk_data;
gsize chunk_size = 0;
GBytes *chunk_tmp = g_ptr_array_index (chunks, i);
chunk_data = g_bytes_get_data (chunk_tmp, &chunk_size);
if (chunk_size == 0)
continue;
memcpy (buffer + offset, chunk_data, chunk_size);
offset += chunk_size;
}
return g_bytes_new_take (buffer, total_size);
}
