static GkmXdgTrust* create_trust_for_reference (GkmModule *module, GkmManager *manager, CK_ATTRIBUTE_PTR serial, CK_ATTRIBUTE_PTR issuer) { GkmXdgTrust *trust; GNode *asn, *ref, *node; GBytes *bytes; asn = egg_asn1x_create (xdg_asn1_tab, "trust-1"); g_return_val_if_fail (asn, NULL); ref = egg_asn1x_node (asn, "reference", NULL); node = egg_asn1x_node (ref, "certReference", NULL); egg_asn1x_set_choice (ref, node); bytes = g_bytes_new (serial->pValue, serial->ulValueLen); egg_asn1x_set_integer_as_raw (egg_asn1x_node (node, "serialNumber", NULL), bytes); g_bytes_unref (bytes); bytes = g_bytes_new (issuer->pValue, issuer->ulValueLen); egg_asn1x_set_any_raw (egg_asn1x_node (node, "issuer", NULL), bytes); g_bytes_unref (bytes); trust = g_object_new (GKM_XDG_TYPE_TRUST, "module", module, "manager", manager, NULL); trust->pv->asn = asn; /* Encode it, so we have read access to all the data */ trust->pv->bytes = egg_asn1x_encode (asn, NULL); if (!trust->pv->bytes) { g_warning ("created invalid trust object: %s", egg_asn1x_message (asn)); return NULL; } return trust; }
static GBytes * substitute_json_string (const gchar *variable, gpointer user_data) { const gchar *value; JsonObject *options = user_data; if (options && cockpit_json_get_string (options, variable, "", &value)) return g_bytes_new (value, strlen (value)); else if (options) g_message ("Couldn't get argument for bridge: got invalid value for '%s'", variable); return g_bytes_new ("", 0); }
gboolean _gum_duk_parse_bytes (duk_context * ctx, duk_idx_t index, GBytes ** bytes) { gpointer data; duk_size_t size; data = duk_get_buffer_data (ctx, index, &size); if (data != NULL) { *bytes = g_bytes_new (data, size); return TRUE; } else if (duk_is_array (ctx, index)) { duk_size_t i; duk_get_prop_string (ctx, index, "length"); size = duk_get_uint (ctx, -1); duk_pop (ctx); if (size >= GUM_MAX_JS_BYTE_ARRAY_LENGTH) return FALSE; data = g_malloc (size); for (i = 0; i != size; i++) { duk_get_prop_index (ctx, index, (duk_uarridx_t) i); ((guint8 *) data)[i] = duk_get_uint (ctx, -1) & 0xff; duk_pop (ctx); } *bytes = g_bytes_new_take (data, size); return TRUE; } else if (duk_is_null_or_undefined (ctx, index) || duk_is_boolean (ctx, index) || duk_is_number (ctx, index) || duk_is_nan (ctx, index) || duk_is_string (ctx, index) || duk_is_function (ctx, index)) { return FALSE; } *bytes = g_bytes_new (NULL, 0); return TRUE; }
static int g_tls_server_connection_gnutls_db_store (void *user_data, gnutls_datum_t key, gnutls_datum_t data) { GBytes *session_id, *session_data; session_id = g_bytes_new (key.data, key.size); session_data = g_bytes_new (data.data, data.size); g_tls_backend_gnutls_store_session (GNUTLS_SERVER, session_id, session_data); g_bytes_unref (session_id); g_bytes_unref (session_data); return 0; }
static gboolean ssid_transform_from_entry (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer user_data) { NMSettingWireless *s_wireless = user_data; const char *text; GBytes *old_ssid, *ssid; char *utf8; text = g_value_get_string (source_value); old_ssid = nm_setting_wireless_get_ssid (s_wireless); if (old_ssid) utf8 = nm_utils_ssid_to_utf8 (g_bytes_get_data (old_ssid, NULL), g_bytes_get_size (old_ssid)); else utf8 = g_strdup (""); if (!g_strcmp0 (text, utf8)) { g_free (utf8); return FALSE; } g_free (utf8); ssid = g_bytes_new (text, strlen (text)); g_value_take_boxed (target_value, ssid); return TRUE; }
void wk_html_close(WkHtml *html) { if (!html->priv->initialised) { html->priv->initialised = TRUE; #ifndef USE_WEBKIT2 webkit_web_view_set_maintains_back_forward_list(WEBKIT_WEB_VIEW(html), FALSE); #endif } #ifdef USE_WEBKIT2 GBytes *html_bytes; html_bytes = g_bytes_new(html->priv->content, strlen(html->priv->content)); webkit_web_view_load_bytes(WEBKIT_WEB_VIEW(html), html_bytes, html->priv->mime, NULL, html->priv->base_uri); g_bytes_unref(html_bytes); #else webkit_web_view_load_string(WEBKIT_WEB_VIEW(html), html->priv->content, html->priv->mime, NULL, html->priv->base_uri); #endif g_free(html->priv->content); html->priv->content = NULL; g_free(html->priv->mime); html->priv->mime = NULL; }
/** * CacheUtilBytesFromString: * @value: String containing an even number of hex-digits. * @result: (out): Raw bytes used to encode the hex value. * * Returns: #TRUE if @result was modified or #FALSE if the string was not valid * hex-encoded bytes. */ gboolean CacheUtilBytesFromString(const gchar *value, GBytes **result) { g_assert(result); if (!value) return FALSE; gsize value_len = strlen(value); gsize result_len = value_len / 2; guint8 result_data[result_len]; // Hex strings must have a length that's a multiple of two. if (value_len & 0x01) return FALSE; for (guint i = 0; i < value_len; i += 2) { gint nibble1 = g_ascii_xdigit_value(value[i]); gint nibble2 = g_ascii_xdigit_value(value[i + 1]); if (nibble1 < 0 || nibble2 < 0) { return FALSE; } result_data[i >> 1] = (nibble1 << 4) | nibble2; } *result = g_bytes_new(result_data, result_len); return TRUE; }
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 handle_stdin (GIOChannel * ch, GIOCondition cond, gpointer d) { gchar *buf; GBytes *data; GError *err = NULL; switch (g_io_channel_read_line (ch, &buf, NULL, NULL, &err)) { case G_IO_STATUS_NORMAL: g_string_append (inbuf, buf); return TRUE; case G_IO_STATUS_ERROR: g_printerr ("yad_html_handle_stdin(): %s\n", err->message); g_error_free (err); return FALSE; case G_IO_STATUS_EOF: data = g_bytes_new (inbuf->str, inbuf->len); g_string_free (inbuf, TRUE); webkit_web_view_load_bytes (view, data, options.html_data.mime, options.html_data.encoding, NULL); g_bytes_unref (data); return FALSE; case G_IO_STATUS_AGAIN: return TRUE; } return FALSE; }
static GBytes * expand_variables (const gchar *variable, gpointer user_data) { ExpandInfo *expand = user_data; CockpitPackage *package; gchar *val; package = g_hash_table_lookup (expand->listing, variable); if (package) { if (package->checksum) { return g_bytes_new_with_free_func (package->checksum, strlen (package->checksum), cockpit_package_unref, cockpit_package_ref (package)); } else if (expand->host) { val = g_strdup_printf ("%s@%s", package->name, expand->host); return g_bytes_new_take (val, strlen (val)); } else { return g_bytes_new_with_free_func (package->name, strlen (package->name), cockpit_package_unref, cockpit_package_ref (package)); } } else { return g_bytes_new (variable, strlen (variable)); } }
void test_upload_ok (int errors, int size, ...) { GRID_DEBUG("++++++++++++++++ %s errors %d size %d", __FUNCTION__, errors, size); GError *err = NULL; gint64 content_length = size; struct http_put_s *p = http_put_create (NULL, NULL, content_length); g_assert (p != NULL); GSList *dests = NULL; va_list args; va_start(args, size); for (guint i=1; ; ++i) { struct http_put_dest_s *d; char *k = va_arg(args, char *); if (!k) break; d = http_put_add_dest (p, k, GINT_TO_POINTER(i)); dests = g_slist_prepend (dests, d); } va_end(args); if (size < 0) size = 128; int fed = 0; while (!http_put_done(p)) { if (fed < size) { http_put_feed (p, g_bytes_new((guint8*)"00000000", 8)); fed += 8; } else { http_put_feed (p, g_bytes_new((guint8*)"", 0)); } err = http_put_step (p); g_assert_no_error (err); err = http_put_step (p); g_assert_no_error (err); } g_slist_free (dests); int count_errors = http_put_get_failure_number (p); g_assert (count_errors == errors); http_put_destroy (p); }
static void emit_string (TestCase *tc, const gchar *channel, const gchar *string) { GBytes *bytes = g_bytes_new (string, strlen (string)); cockpit_transport_emit_recv (COCKPIT_TRANSPORT (tc->transport), channel, bytes); g_bytes_unref (bytes); }
static GBytes * substitute_message (const gchar *variable, gpointer user_data) { const gchar *message = user_data; if (g_str_equal (variable, "message")) return g_bytes_new (message, strlen (message)); return NULL; }
RdmaRmQP *rdma_rm_get_qp(RdmaDeviceResources *dev_res, uint32_t qpn) { GBytes *key = g_bytes_new(&qpn, sizeof(qpn)); RdmaRmQP *qp = g_hash_table_lookup(dev_res->qp_hash, key); g_bytes_unref(key); return qp; }
static GBytes *bytes_from_bio(BIO *bio) { long size; char *data; g_return_val_if_fail(bio != NULL, NULL); size = BIO_get_mem_data(bio, &data); return g_bytes_new(data, size); }
void *Thread_Start_Routine(void *arg) { struct Message *msg = (struct Message *)arg; #if !defined(NDEBUG) fprintf(stderr, "Origin : %s\n", msg->origin); fprintf(stderr, "Summary: %s\n", msg->summary); /* +1 to get rid of the prepended \r of the wall message. */ fprintf(stderr, "Body : \"%s\"\n", msg->body + 1); #endif GSubprocess *proc; gboolean success; GError *error; GBytes *buf; error = NULL; proc = g_subprocess_new(G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_SILENCE | G_SUBPROCESS_FLAGS_STDERR_SILENCE, &error, (char *)msg->argv0, "--origin", msg->origin, "--summary", msg->summary, NULL); if (UNLIKELY(!proc)) { PTYWATCH_ERROR("g_subprocess_new() failed: %s\n", error->message); g_error_free(error); } buf = g_bytes_new(msg->body, strlen(msg->body)); error = NULL; success = g_subprocess_communicate(proc, buf, NULL, NULL, NULL, &error); if (UNLIKELY((!success) && error)) { PTYWATCH_ERROR("g_subprocess_communicate() failed: %s\n", error->message); g_error_free(error); } g_object_unref(G_OBJECT(proc)); g_bytes_unref(buf); free(msg->argv0); free(msg->origin); free(msg->summary); free(msg->body); free(msg); return NULL; }
static gboolean as_icon_node_parse_embedded (AsIcon *icon, GNode *n, GError **error) { AsIconPrivate *priv = GET_PRIVATE (icon); GNode *c; gsize size; g_autofree guchar *data = NULL; g_autoptr(GdkPixbuf) pixbuf = NULL; g_autoptr(GInputStream) stream = NULL; /* get the icon name */ c = as_node_find (n, "name"); if (c == NULL) { g_set_error_literal (error, AS_ICON_ERROR, AS_ICON_ERROR_FAILED, "embedded icons needs <name>"); return FALSE; } g_free (priv->name); priv->name = as_node_take_data (c); /* parse the Base64 data */ c = as_node_find (n, "filecontent"); if (c == NULL) { g_set_error_literal (error, AS_ICON_ERROR, AS_ICON_ERROR_FAILED, "embedded icons needs <filecontent>"); return FALSE; } data = g_base64_decode (as_node_get_data (c), &size); stream = g_memory_input_stream_new_from_data (data, (gssize) size, NULL); if (stream == NULL) { g_set_error_literal (error, AS_ICON_ERROR, AS_ICON_ERROR_FAILED, "failed to load embedded data"); return FALSE; } /* load the image */ pixbuf = gdk_pixbuf_new_from_stream (stream, NULL, error); if (pixbuf == NULL) return FALSE; as_icon_set_pixbuf (icon, pixbuf); /* save the raw data */ if (priv->data != NULL) g_bytes_unref (priv->data); priv->data = g_bytes_new (data, size); return TRUE; }
/** * gdk_pixbuf_read_pixel_bytes: * @pixbuf: A pixbuf * * Returns: (transfer full): A new reference to a read-only copy of * the pixel data. Note that for mutable pixbufs, this function will * incur a one-time copy of the pixel data for conversion into the * returned #GBytes. * * Since: 2.32 */ GBytes * gdk_pixbuf_read_pixel_bytes (const GdkPixbuf *pixbuf) { g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); if (pixbuf->bytes) { return g_bytes_ref (pixbuf->bytes); } else { return g_bytes_new (pixbuf->pixels, gdk_pixbuf_get_byte_length (pixbuf)); } }
static int g_tls_server_connection_gnutls_db_remove (void *user_data, gnutls_datum_t key) { GBytes *session_id; session_id = g_bytes_new (key.data, key.size); g_tls_backend_gnutls_remove_session (GNUTLS_SERVER, session_id); g_bytes_unref (session_id); return 0; }
static void on_terminal_commit (VteTerminal *vteterminal, gchar *text, guint size, gpointer user_data) { HotSshTab *self = user_data; HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self); g_queue_push_tail (&priv->write_queue, g_bytes_new (text, size)); process_write_queue (self); }
/** * dfu_firmware_to_dfuse: (skip) * @firmware: a #DfuFirmware * @error: a #GError, or %NULL * * Packs a DfuSe firmware * * Returns: (transfer full): the packed data **/ GBytes * dfu_firmware_to_dfuse (DfuFirmware *firmware, GError **error) { DfuSePrefix *prefix; GPtrArray *images; guint32 image_size_total = 0; guint32 offset = sizeof (DfuSePrefix); g_autofree guint8 *buf = NULL; g_autoptr(GPtrArray) dfuse_images = NULL; /* get all the image data */ dfuse_images = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref); images = dfu_firmware_get_images (firmware); for (guint i = 0; i < images->len; i++) { DfuImage *im = g_ptr_array_index (images, i); GBytes *contents; contents = dfu_image_to_dfuse (im); image_size_total += (guint32) g_bytes_get_size (contents); g_ptr_array_add (dfuse_images, contents); } g_debug ("image_size_total: %" G_GUINT32_FORMAT, image_size_total); buf = g_malloc0 (sizeof (DfuSePrefix) + image_size_total); /* DfuSe header */ prefix = (DfuSePrefix *) buf; memcpy (prefix->sig, "DfuSe", 5); prefix->ver = 0x01; prefix->image_size = GUINT32_TO_LE (offset + image_size_total); if (images->len > G_MAXUINT8) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "too many (%u) images to write DfuSe file", images->len); return NULL; } prefix->targets = (guint8) images->len; /* copy images */ for (guint i = 0; i < dfuse_images->len; i++) { GBytes *contents = g_ptr_array_index (dfuse_images, i); gsize length; const guint8 *data; data = g_bytes_get_data (contents, &length); memcpy (buf + offset, data, length); offset += (guint32) length; } /* return blob */ return g_bytes_new (buf, sizeof (DfuSePrefix) + image_size_total); }
static gboolean link_set_address (NMPlatform *platform, int ifindex, gconstpointer addr, size_t len) { NMFakePlatformLink *device = link_get (platform, ifindex); if (device->address) g_bytes_unref (device->address); device->address = g_bytes_new (addr, len); link_changed (platform, link_get (platform, ifindex)); return TRUE; }
/** * dfu_element_from_dfuse: (skip) * @data: data buffer * @length: length of @data we can access * @consumed: (out): the number of bytes we consued * @error: a #GError, or %NULL * * Unpacks an element from DfuSe data. * * Returns: a #DfuElement, or %NULL for error **/ static DfuElement * dfu_element_from_dfuse (const guint8 *data, guint32 length, guint32 *consumed, GError **error) { DfuElement *element = NULL; DfuSeElementPrefix *el = (DfuSeElementPrefix *) data; guint32 size; g_autoptr(GBytes) contents = NULL; g_assert_cmpint(sizeof(DfuSeElementPrefix), ==, 8); /* check input buffer size */ if (length < sizeof(DfuSeElementPrefix)) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid element data size %u", (guint32) length); return NULL; } /* check size */ size = GUINT32_FROM_LE (el->size); if (size + sizeof(DfuSeElementPrefix) > length) { g_set_error (error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "invalid element size %u, only %u bytes left", size, (guint32) (length - sizeof(DfuSeElementPrefix))); return NULL; } /* create new element */ element = dfu_element_new (); dfu_element_set_address (element, GUINT32_FROM_LE (el->address)); contents = g_bytes_new (data + sizeof(DfuSeElementPrefix), size); dfu_element_set_contents (element, contents); /* return size */ if (consumed != NULL) *consumed = (guint32) sizeof(DfuSeElementPrefix) + size; return element; }
static gboolean fu_smbios_setup_from_data (FuSmbios *self, const guint8 *buf, gsize sz, GError **error) { /* go through each structure */ for (gsize i = 0; i < sz; i++) { FuSmbiosStructure *str = (FuSmbiosStructure *) &buf[i]; FuSmbiosItem *item; /* invalid */ if (str->len == 0x00) break; if (str->len >= sz) { g_set_error_literal (error, FWUPD_ERROR, FWUPD_ERROR_INVALID_FILE, "structure larger than available data"); return FALSE; } /* create a new result */ item = g_new0 (FuSmbiosItem, 1); item->type = str->type; item->handle = GUINT16_FROM_LE (str->handle); item->data = g_bytes_new (buf + i, str->len); item->strings = g_ptr_array_new_with_free_func (g_free); g_ptr_array_add (self->items, item); /* jump to the end of the struct */ i += str->len; if (buf[i] == '\0' && buf[i+1] == '\0') { i++; continue; } /* add strings from table */ for (gsize start_offset = i; i < sz; i++) { if (buf[i] == '\0') { if (start_offset == i) break; g_ptr_array_add (item->strings, g_strdup ((const gchar *) &buf[start_offset])); start_offset = i + 1; } } } return TRUE; }
/** * gdk_pixbuf_read_pixel_bytes: * @pixbuf: A pixbuf * * Provides a #GBytes buffer containing the raw pixel data; the data * must not be modified. This function allows skipping the implicit * copy that must be made if gdk_pixbuf_get_pixels() is called on a * read-only pixbuf. * * Returns: (transfer full): A new reference to a read-only copy of * the pixel data. Note that for mutable pixbufs, this function will * incur a one-time copy of the pixel data for conversion into the * returned #GBytes. * * Since: 2.32 */ GBytes * gdk_pixbuf_read_pixel_bytes (const GdkPixbuf *pixbuf) { g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); switch (pixbuf->storage) { case STORAGE_PIXELS: return g_bytes_new (pixbuf->s.pixels.pixels, gdk_pixbuf_get_byte_length (pixbuf)); case STORAGE_BYTES: return g_bytes_ref (pixbuf->s.bytes.bytes); default: g_assert_not_reached (); } }
/** * gdk_pixbuf_buffer_queue_peek: * @queue: a #GdkPixbufBufferQueue to read from * @length: amount of bytes to peek * * Creates a new buffer with the first @length bytes from @queue, but unlike * gdk_pixbuf_buffer_queue_pull(), does not remove them from @queue. * * Returns: NULL if the requested amount of data wasn't available or a new * #GBytes. Use g_bytes_unref() after use. **/ GBytes * gdk_pixbuf_buffer_queue_peek (GdkPixbufBufferQueue *queue, gsize length) { GSList *g; GBytes *result, *bytes; g_return_val_if_fail (queue != NULL, NULL); if (queue->size < length) return NULL; /* need to special case here, because the queue may be empty */ if (length == 0) return g_bytes_new (NULL, 0); g = queue->first_buffer; bytes = g->data; if (g_bytes_get_size (bytes) == length) { result = g_bytes_ref (bytes); } else if (g_bytes_get_size (bytes) > length) { result = g_bytes_new_from_bytes (bytes, 0, length); } else { guchar *data; gsize amount, offset; data = g_malloc (length); for (offset = 0; offset < length; offset += amount) { bytes = g->data; amount = MIN (length - offset, g_bytes_get_size (bytes)); memcpy (data + offset, g_bytes_get_data (bytes, NULL), amount); g = g->next; } result = g_bytes_new_take (data, length); } return result; }
GBytes * ce_page_wifi_get_ssid (CEPageWifi *self) { CEPageWifiPrivate *priv; const char *txt_ssid; GBytes *ssid; g_return_val_if_fail (CE_IS_PAGE_WIFI (self), NULL); priv = CE_PAGE_WIFI_GET_PRIVATE (self); txt_ssid = gtk_entry_get_text (priv->ssid); if (!txt_ssid || !strlen (txt_ssid)) return NULL; ssid = g_bytes_new (txt_ssid, strlen (txt_ssid)); return ssid; }
void rdma_rm_dealloc_qp(RdmaDeviceResources *dev_res, uint32_t qp_handle) { RdmaRmQP *qp; GBytes *key; key = g_bytes_new(&qp_handle, sizeof(qp_handle)); qp = g_hash_table_lookup(dev_res->qp_hash, key); g_hash_table_remove(dev_res->qp_hash, key); g_bytes_unref(key); if (!qp) { return; } rdma_backend_destroy_qp(&qp->backend_qp); res_tbl_dealloc(&dev_res->qp_tbl, qp->qpn); }
static void test_asn1_bit_string (Test *test, gconstpointer unused) { GNode *asn; GBytes *data; gboolean ret; GBytes *source, *target; gsize target_bits, source_bits; asn = egg_asn1x_create (test_asn1_tab, "TestBitString"); g_assert ("asn test structure is null" && asn != NULL); /* Create a string */ source = g_bytes_new (TEST_STRING, strlen(TEST_STRING)); g_return_if_fail (source); source_bits = g_bytes_get_size(source)*8; /* Write the string out */ ret = gkm_data_asn1_write_bit_string (egg_asn1x_node (asn, "data", NULL), source, source_bits); g_assert ("couldn't write string 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, "TestBitString", data); g_assert (asn != NULL); ret = gkm_data_asn1_read_bit_string (egg_asn1x_node (asn, "data", NULL), &target, &target_bits); egg_asn1x_destroy (asn); g_assert ("couldn't read bit string from asn1" && ret); g_assert ("bit string returned is null" && target != NULL); g_assert ("Source and target length differ" && target_bits == source_bits); g_assert ("Bit strings differ" && g_bytes_equal (source, target)); g_bytes_unref (data); g_bytes_unref (source); g_bytes_unref (target); }
/* org.nemomobile.MmsEngine.pushNotify */ static gboolean mms_engine_handle_push_notify( OrgNemomobileMmsEngine* proxy, GDBusMethodInvocation* call, const char* imsi, const char* type, GVariant* data, MMSEngine* engine) { gsize len = 0; const guint8* bytes = g_variant_get_fixed_array(data, &len, 1); MMS_DEBUG("Received %u bytes from %s", (guint)len, imsi); if (!type || g_ascii_strcasecmp(type, MMS_CONTENT_TYPE)) { MMS_ERR("Unsupported content type %s", type); g_dbus_method_invocation_return_error(call, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Unsupported content type"); } else if (!imsi || !imsi[0]) { MMS_ERR_("IMSI is missing"); g_dbus_method_invocation_return_error(call, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "IMSI is missing"); } else if (!bytes || !len) { MMS_ERR_("No data provided"); g_dbus_method_invocation_return_error(call, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "No data provided"); } else { GError* err = NULL; GBytes* msg = g_bytes_new(bytes, len); if (mms_dispatcher_handle_push(engine->dispatcher, imsi, msg, &err)) { if (mms_dispatcher_start(engine->dispatcher)) { mms_engine_start_timeout_cancel(engine); } org_nemomobile_mms_engine_complete_push(proxy, call); } else { g_dbus_method_invocation_return_error(call, G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "%s", MMS_ERRMSG(err)); g_error_free(err); } g_bytes_unref(msg); } return TRUE; }