END_TEST START_TEST(test_store_empty_01) { ip_map_t map; ip_map_t *read_map; ipmap_init(&map, 0); GOutputStream *ostream = g_memory_output_stream_new(NULL, 0, g_realloc, g_free); GMemoryOutputStream *mostream = G_MEMORY_OUTPUT_STREAM(ostream); fail_unless(ipmap_save(ostream, &map, NULL), "Could not save map"); GInputStream *istream = g_memory_input_stream_new_from_data (g_memory_output_stream_get_data(mostream), g_memory_output_stream_get_data_size(mostream), NULL); read_map = ipmap_load(istream, NULL); fail_if(read_map == NULL, "Could not read map"); fail_unless(ipmap_is_equal(&map, read_map), "Map not same after saving/loading"); g_object_unref(ostream); g_object_unref(istream); ipmap_done(&map); ipmap_free(read_map); }
END_TEST START_TEST(test_store_empty) { ip_set_t set; ip_set_t *read_set; ipset_init(&set); GOutputStream *ostream = g_memory_output_stream_new(NULL, 0, g_realloc, g_free); GMemoryOutputStream *mostream = G_MEMORY_OUTPUT_STREAM(ostream); fail_unless(ipset_save(ostream, &set, NULL), "Could not save set"); GInputStream *istream = g_memory_input_stream_new_from_data (g_memory_output_stream_get_data(mostream), g_memory_output_stream_get_data_size(mostream), NULL); read_set = ipset_load(istream, NULL); fail_if(read_set == NULL, "Could not read set"); fail_unless(ipset_is_equal(&set, read_set), "Set not same after saving/loading"); g_object_unref(ostream); g_object_unref(istream); ipset_done(&set); ipset_free(read_set); }
/** * Read all input from @src, allocating a new #GVariant from it into * output variable @out_variant. @src will be closed as a result. * * Note the returned @out_variant is not floating. */ gboolean ot_util_variant_from_stream (GInputStream *src, const GVariantType *type, gboolean trusted, GVariant **out_variant, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gs_unref_object GMemoryOutputStream *data_stream = NULL; gs_unref_variant GVariant *ret_variant = NULL; data_stream = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free); if (g_output_stream_splice ((GOutputStream*)data_stream, src, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, cancellable, error) < 0) goto out; ret_variant = g_variant_new_from_data (type, g_memory_output_stream_get_data (data_stream), g_memory_output_stream_get_data_size (data_stream), trusted, (GDestroyNotify) g_object_unref, data_stream); data_stream = NULL; /* Transfer ownership */ g_variant_ref_sink (ret_variant); ret = TRUE; ot_transfer_out_value (out_variant, &ret_variant); out: return ret; }
/** * tmpl_template_expand_string: * @self: A #TmplTemplate. * @scope: (nullable): A #TmplScope or %NULL. * @error: A location for a #GError, or %NULL * * Expands the template and returns the result as a string. * * Returns: A newly allocated string, or %NULL upon failure. */ gchar * tmpl_template_expand_string (TmplTemplate *self, TmplScope *scope, GError **error) { GOutputStream *stream; gchar zero = 0; gchar *ret; g_return_val_if_fail (TMPL_IS_TEMPLATE (self), NULL); stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); if (!tmpl_template_expand (self, stream, scope, NULL, error) || !g_output_stream_write_all (stream, &zero, 1, NULL, NULL, error) || !g_output_stream_close (stream, NULL, error)) { g_object_unref (stream); return NULL; } ret = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (stream)); g_object_unref (stream); return ret; }
void test_int_set_serialize_failure_noncanon(void) { GOutputStream *stream = g_memory_output_stream_new(NULL, 0, g_realloc, g_free); GDataOutputStream *datastream = g_data_output_stream_new(stream); g_data_output_stream_set_byte_order(datastream, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN); data_stream_put_string0(datastream, "GwyIntSet", NULL, NULL); g_data_output_stream_put_uint64(datastream, 0, NULL, NULL); guint len = 8; data_stream_put_string0(datastream, "ranges", NULL, NULL); g_data_output_stream_put_byte(datastream, GWY_SERIALIZABLE_INT32_ARRAY, NULL, NULL); g_data_output_stream_put_uint64(datastream, len, NULL, NULL); for (guint i = 0; i < len; i++) g_data_output_stream_put_uint32(datastream, i/3, NULL, NULL); GwyErrorList *error_list = NULL; gwy_error_list_add(&error_list, GWY_DESERIALIZE_ERROR, GWY_DESERIALIZE_ERROR_INVALID, "GwyIntSet ranges are not in canonical form."); deserialize_assert_failure(G_MEMORY_OUTPUT_STREAM(stream), error_list); gwy_error_list_clear(&error_list); g_object_unref(datastream); g_object_unref(stream); }
void test_int_set_serialize_failure_odd(void) { GOutputStream *stream = g_memory_output_stream_new(NULL, 0, g_realloc, g_free); GDataOutputStream *datastream = g_data_output_stream_new(stream); g_data_output_stream_set_byte_order(datastream, G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN); data_stream_put_string0(datastream, "GwyIntSet", NULL, NULL); g_data_output_stream_put_uint64(datastream, 0, NULL, NULL); guint len = 5; data_stream_put_string0(datastream, "ranges", NULL, NULL); g_data_output_stream_put_byte(datastream, GWY_SERIALIZABLE_INT32_ARRAY, NULL, NULL); g_data_output_stream_put_uint64(datastream, len, NULL, NULL); for (guint i = 0; i < len; i++) g_data_output_stream_put_uint32(datastream, i, NULL, NULL); GwyErrorList *error_list = NULL; gwy_error_list_add(&error_list, GWY_DESERIALIZE_ERROR, GWY_DESERIALIZE_ERROR_INVALID, "Data length of ‘GwyIntSet’ is %lu which is not " "a multiple of 2.", (gulong)len); deserialize_assert_failure(G_MEMORY_OUTPUT_STREAM(stream), error_list); gwy_error_list_clear(&error_list); g_object_unref(datastream); g_object_unref(stream); }
void lsm_dom_document_save_to_memory (LsmDomDocument *document, void **buffer, int *size, GError **error) { GOutputStream *stream; if (buffer != NULL) *buffer = NULL; if (size != NULL) *size = 0; g_return_if_fail (document != NULL); g_return_if_fail (buffer != NULL); stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); if (stream == NULL) { *buffer = NULL; if (size != NULL) *size = 0; return; } lsm_dom_document_save_to_stream (document, G_OUTPUT_STREAM (stream), error); g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, error); if (size != NULL) *size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (stream)); *buffer = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (stream)); g_object_unref (stream); }
static gboolean decompress_all (GConverter *converter, GBytes *data, GBytes **out_uncompressed, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; g_autoptr(GMemoryInputStream) memin = (GMemoryInputStream*)g_memory_input_stream_new_from_bytes (data); g_autoptr(GMemoryOutputStream) memout = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free); g_autoptr(GInputStream) convin = g_converter_input_stream_new ((GInputStream*)memin, converter); { gssize n_bytes_written = g_output_stream_splice ((GOutputStream*)memout, convin, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, cancellable, error); if (n_bytes_written < 0) goto out; } ret = TRUE; *out_uncompressed = g_memory_output_stream_steal_as_bytes (memout); out: return ret; }
static gboolean fetch_uri_contents_utf8_sync (OtPullData *pull_data, SoupURI *uri, char **out_contents, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; const guint8 nulchar = 0; gs_free char *ret_contents = NULL; gs_unref_object GMemoryOutputStream *buf = NULL; OstreeFetchUriSyncData fetch_data = { 0, }; if (g_cancellable_set_error_if_cancelled (cancellable, error)) return FALSE; fetch_data.pull_data = pull_data; pull_data->fetching_sync_uri = uri; ostree_fetcher_stream_uri_async (pull_data->fetcher, uri, cancellable, fetch_uri_sync_on_complete, &fetch_data); run_mainloop_monitor_fetcher (pull_data); if (!fetch_data.result_stream) goto out; buf = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free); if (g_output_stream_splice ((GOutputStream*)buf, fetch_data.result_stream, G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE, cancellable, error) < 0) goto out; /* Add trailing NUL */ if (!g_output_stream_write ((GOutputStream*)buf, &nulchar, 1, cancellable, error)) goto out; if (!g_output_stream_close ((GOutputStream*)buf, cancellable, error)) goto out; ret_contents = g_memory_output_stream_steal_data (buf); if (!g_utf8_validate (ret_contents, -1, NULL)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Invalid UTF-8"); goto out; } ret = TRUE; ot_transfer_out_value (out_contents, &ret_contents); out: g_clear_object (&(fetch_data.result_stream)); return ret; }
gboolean ostree_raw_file_to_content_stream (GInputStream *input, GFileInfo *file_info, GVariant *xattrs, GInputStream **out_input, guint64 *out_length, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gpointer header_data; gsize header_size; ot_lobj GInputStream *ret_input = NULL; ot_lvariant GVariant *file_header = NULL; ot_lptrarray GPtrArray *streams = NULL; ot_lobj GOutputStream *header_out_stream = NULL; ot_lobj GInputStream *header_in_stream = NULL; file_header = ostree_file_header_new (file_info, xattrs); header_out_stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); if (!ostree_write_variant_with_size (header_out_stream, file_header, 0, NULL, NULL, cancellable, error)) goto out; if (!g_output_stream_close (header_out_stream, cancellable, error)) goto out; header_size = g_memory_output_stream_get_data_size ((GMemoryOutputStream*) header_out_stream); header_data = g_memory_output_stream_steal_data ((GMemoryOutputStream*) header_out_stream); header_in_stream = g_memory_input_stream_new_from_data (header_data, header_size, g_free); streams = g_ptr_array_new_with_free_func ((GDestroyNotify)g_object_unref); g_ptr_array_add (streams, g_object_ref (header_in_stream)); if (input) g_ptr_array_add (streams, g_object_ref (input)); ret_input = (GInputStream*)ostree_chain_input_stream_new (streams); ret = TRUE; ot_transfer_out_value (out_input, &ret_input); if (out_length) *out_length = header_size + g_file_info_get_size (file_info); out: return ret; }
GVfsAfpCommand * g_vfs_afp_command_new (AfpCommandType type) { GOutputStream *mem_stream; GVfsAfpCommand *comm; mem_stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); comm = g_object_new (G_VFS_TYPE_AFP_COMMAND, "base-stream", mem_stream, NULL); g_object_unref (mem_stream); comm->type = type; g_vfs_afp_command_put_byte (comm, type); return comm; }
static void ekg_gnutls_async_handshake(struct ekg_gnutls_connection_starter *gcs) { gint ret = gnutls_handshake(gcs->conn->session); switch (ret) { case GNUTLS_E_SUCCESS: { struct ekg_gnutls_connection *gc = gcs->conn; struct ekg_connection_starter *cs = gcs->parent; GInputStream *mi = g_memory_input_stream_new(); GOutputStream *mo = g_memory_output_stream_new( NULL, 0, g_realloc, g_free); /* set streams */ gc->instream = G_MEMORY_INPUT_STREAM(mi); gc->outstream = G_MEMORY_OUTPUT_STREAM(mo); /* switch handlers */ gc->connection->callback = ekg_gnutls_handle_data; gc->connection->failure_callback = ekg_gnutls_handle_data_failure; gc->connection->priv_data = gc; gc->connection->flush_handler = ekg_gnutls_flush; /* this cleans up the socket, and cs */ succeeded_async_connect(gcs->sockclient, gc->connection->conn, cs, mi, mo); /* and this cleans up gcs */ ekg_gnutls_free_connection_starter(gcs); } break; case GNUTLS_E_AGAIN: case GNUTLS_E_INTERRUPTED: break; default: { GError *err = g_error_new_literal(EKG_GNUTLS_ERROR, ret, gnutls_strerror(ret)); ekg_gnutls_handle_handshake_failure(NULL, err, gcs); g_error_free(err); } } }
static void run_test (gconstpointer data) { GFileInputStream *stream; gchar contents[1024]; gsize bytes; gchar *curi, *newline; gchar **uriv; GFile *file = G_FILE (data); YelpUri *uri; GOutputStream *outstream; gchar *out; stream = g_file_read (file, NULL, NULL); g_assert (g_input_stream_read_all (G_INPUT_STREAM (stream), contents, 1024, &bytes, NULL, NULL)); newline = strchr (contents, '\n'); curi = g_strndup (contents, newline - contents); uriv = g_strsplit (curi, " ", 2); uri = yelp_uri_new (uriv[0]); if (uriv[1] != NULL) uri = yelp_uri_new_relative (uri, uriv[1]); g_strfreev (uriv); yelp_uri_resolve (uri); while (!yelp_uri_is_resolved (uri)) while (g_main_context_pending (NULL)) g_main_context_iteration (NULL, FALSE); outstream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); print_uri (curi, uri, outstream); out = (gchar *) g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (outstream)); g_free (curi); g_assert (!strncmp (out, contents, bytes)); }
/** * as_get_yml_data_origin: * * Extract the data origin from the AppStream YAML file. * We don't use the #AsYAMLData loader, because it is much * slower than just loading the initial parts of the file and * extracting the origin manually. */ static gchar* as_get_yml_data_origin (const gchar *fname) { const gchar *data; GZlibDecompressor *zdecomp; g_autoptr(GFileInputStream) fistream = NULL; g_autoptr(GMemoryOutputStream) mem_os = NULL; g_autoptr(GInputStream) conv_stream = NULL; g_autoptr(GFile) file = NULL; g_autofree gchar *str = NULL; g_auto(GStrv) strv = NULL; GError *err; guint i; gchar *start, *end; gchar *origin = NULL; file = g_file_new_for_path (fname); fistream = g_file_read (file, NULL, &err); if (!fistream) { g_critical ("Unable to open file '%s' for reading: %s, skipping.", fname, err->message); g_error_free (err); return NULL; } mem_os = (GMemoryOutputStream*) g_memory_output_stream_new (NULL, 0, g_realloc, g_free); zdecomp = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP); conv_stream = g_converter_input_stream_new (G_INPUT_STREAM (fistream), G_CONVERTER (zdecomp)); g_object_unref (zdecomp); g_output_stream_splice (G_OUTPUT_STREAM (mem_os), conv_stream, 0, NULL, NULL); data = (const gchar*) g_memory_output_stream_get_data (mem_os); /* faster than a regular expression? * Get the first YAML document, then extract the origin string. */ if (data == NULL) return NULL; /* start points to the start of the document, i.e. "File:" normally */ start = g_strstr_len (data, 400, YAML_SEPARATOR) + YAML_SEPARATOR_LEN; if (start == NULL) return NULL; /* Find the end of the first document - can be NULL if there is only one, * for example if we're given YAML for an empty archive */ end = g_strstr_len (start, -1, YAML_SEPARATOR); str = g_strndup (start, strlen(start) - (end ? strlen(end) : 0)); strv = g_strsplit (str, "\n", -1); for (i = 0; strv[i] != NULL; i++) { g_auto(GStrv) strv2 = NULL; if (!g_str_has_prefix (strv[i], "Origin:")) continue; strv2 = g_strsplit (strv[i], ":", 2); g_strstrip (strv2[1]); origin = g_strdup (strv2[1]); /* remove quotes, in case the string is quoted */ if ((g_str_has_prefix (origin, "\"")) && (g_str_has_suffix (origin, "\""))) { g_autofree gchar *tmp = NULL; tmp = origin; origin = g_strndup (tmp + 1, strlen (tmp) - 2); } break; } return origin; }
static void end_element (GMarkupParseContext *context, const gchar *element_name, gpointer user_data, GError **error) { ParseState *state = user_data; GError *my_error = NULL; if (strcmp (element_name, "gresource") == 0) { g_free (state->prefix); state->prefix = NULL; } else if (strcmp (element_name, "file") == 0) { gchar *file, *real_file; gchar *key; FileData *data; char *tmp_file = NULL; char *tmp_file2 = NULL; file = state->string->str; key = file; if (state->alias) key = state->alias; if (state->prefix) key = g_build_path ("/", "/", state->prefix, key, NULL); else key = g_build_path ("/", "/", key, NULL); if (g_hash_table_lookup (state->table, key) != NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("File %s appears multiple times in the resource"), key); return; } data = g_new0 (FileData, 1); if (sourcedirs != NULL) { real_file = find_file (file); if (real_file == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Failed to locate '%s' in any source directory"), file); return; } } else { gboolean exists; exists = g_file_test (file, G_FILE_TEST_EXISTS); if (!exists) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Failed to locate '%s' in current directory"), file); return; } real_file = g_strdup (file); } data->filename = g_strdup (real_file); if (!state->collect_data) goto done; if (state->preproc_options) { gchar **options; guint i; gboolean xml_stripblanks = FALSE; gboolean to_pixdata = FALSE; options = g_strsplit (state->preproc_options, ",", -1); for (i = 0; options[i]; i++) { if (!strcmp (options[i], "xml-stripblanks")) xml_stripblanks = TRUE; else if (!strcmp (options[i], "to-pixdata")) to_pixdata = TRUE; else { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Unknown processing option \"%s\""), options[i]); g_strfreev (options); goto cleanup; } } g_strfreev (options); if (xml_stripblanks && xmllint != NULL) { gchar *argv[8]; int status, fd, argc; tmp_file = g_strdup ("resource-XXXXXXXX"); if ((fd = g_mkstemp (tmp_file)) == -1) { int errsv = errno; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv), _("Failed to create temp file: %s"), g_strerror (errsv)); g_free (tmp_file); tmp_file = NULL; goto cleanup; } close (fd); argc = 0; argv[argc++] = (gchar *) xmllint; argv[argc++] = "--nonet"; argv[argc++] = "--noblanks"; argv[argc++] = "--output"; argv[argc++] = tmp_file; argv[argc++] = real_file; argv[argc++] = NULL; g_assert (argc <= G_N_ELEMENTS (argv)); if (!g_spawn_sync (NULL /* cwd */, argv, NULL /* envv */, G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, NULL, NULL, &status, &my_error)) { g_propagate_error (error, my_error); goto cleanup; } #ifdef HAVE_SYS_WAIT_H if (!WIFEXITED (status) || WEXITSTATUS (status) != 0) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Error processing input file with xmllint")); goto cleanup; } #endif g_free (real_file); real_file = g_strdup (tmp_file); } if (to_pixdata) { gchar *argv[4]; int status, fd, argc; if (gdk_pixbuf_pixdata == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "to-pixbuf preprocessing requested but GDK_PIXBUF_PIXDATA " "not set and gdk-pixbuf-pixdata not found in path"); goto cleanup; } tmp_file2 = g_strdup ("resource-XXXXXXXX"); if ((fd = g_mkstemp (tmp_file2)) == -1) { int errsv = errno; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv), _("Failed to create temp file: %s"), g_strerror (errsv)); g_free (tmp_file2); tmp_file2 = NULL; goto cleanup; } close (fd); argc = 0; argv[argc++] = (gchar *) gdk_pixbuf_pixdata; argv[argc++] = real_file; argv[argc++] = tmp_file2; argv[argc++] = NULL; g_assert (argc <= G_N_ELEMENTS (argv)); if (!g_spawn_sync (NULL /* cwd */, argv, NULL /* envv */, G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, NULL, NULL, &status, &my_error)) { g_propagate_error (error, my_error); goto cleanup; } #ifdef HAVE_SYS_WAIT_H if (!WIFEXITED (status) || WEXITSTATUS (status) != 0) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Error processing input file with to-pixdata")); goto cleanup; } #endif g_free (real_file); real_file = g_strdup (tmp_file2); } } if (!g_file_get_contents (real_file, &data->content, &data->size, &my_error)) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Error reading file %s: %s"), real_file, my_error->message); g_clear_error (&my_error); goto cleanup; } /* Include zero termination in content_size for uncompressed files (but not in size) */ data->content_size = data->size + 1; if (state->compressed) { GOutputStream *out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); GZlibCompressor *compressor = g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 9); GOutputStream *out2 = g_converter_output_stream_new (out, G_CONVERTER (compressor)); if (!g_output_stream_write_all (out2, data->content, data->size, NULL, NULL, NULL) || !g_output_stream_close (out2, NULL, NULL)) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Error compressing file %s"), real_file); goto cleanup; } g_free (data->content); data->content_size = g_memory_output_stream_get_size (G_MEMORY_OUTPUT_STREAM (out)); data->content = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out)); g_object_unref (compressor); g_object_unref (out); g_object_unref (out2); data->flags |= G_RESOURCE_FLAGS_COMPRESSED; } done: g_hash_table_insert (state->table, key, data); cleanup: /* Cleanup */ g_free (state->alias); state->alias = NULL; g_string_free (state->string, TRUE); state->string = NULL; g_free (state->preproc_options); state->preproc_options = NULL; g_free (real_file); if (tmp_file) { unlink (tmp_file); g_free (tmp_file); } if (tmp_file2) { unlink (tmp_file2); g_free (tmp_file2); } } }
static void end_element (GMarkupParseContext *context, const gchar *element_name, gpointer user_data, GError **error) { ParseState *state = user_data; GError *my_error = NULL; if (strcmp (element_name, "gresource") == 0) { g_free (state->prefix); state->prefix = NULL; } else if (strcmp (element_name, "file") == 0) { gchar *file; gchar *real_file = NULL; gchar *key; FileData *data = NULL; char *tmp_file = NULL; char *tmp_file2 = NULL; file = state->string->str; key = file; if (state->alias) key = state->alias; if (state->prefix) key = g_build_path ("/", "/", state->prefix, key, NULL); else key = g_build_path ("/", "/", key, NULL); if (g_hash_table_lookup (state->table, key) != NULL) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("File %s appears multiple times in the resource"), key); return; } if (sourcedirs != NULL) { real_file = find_file (file); if (real_file == NULL && state->collect_data) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Failed to locate “%s” in any source directory"), file); return; } } else { gboolean exists; exists = g_file_test (file, G_FILE_TEST_EXISTS); if (!exists && state->collect_data) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Failed to locate “%s” in current directory"), file); return; } } if (real_file == NULL) real_file = g_strdup (file); data = g_new0 (FileData, 1); data->filename = g_strdup (real_file); if (!state->collect_data) goto done; if (state->preproc_options) { gchar **options; guint i; gboolean xml_stripblanks = FALSE; gboolean to_pixdata = FALSE; options = g_strsplit (state->preproc_options, ",", -1); for (i = 0; options[i]; i++) { if (!strcmp (options[i], "xml-stripblanks")) xml_stripblanks = TRUE; else if (!strcmp (options[i], "to-pixdata")) to_pixdata = TRUE; else { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Unknown processing option “%s”"), options[i]); g_strfreev (options); goto cleanup; } } g_strfreev (options); if (xml_stripblanks && xmllint != NULL) { int fd; GSubprocess *proc; tmp_file = g_strdup ("resource-XXXXXXXX"); if ((fd = g_mkstemp (tmp_file)) == -1) { int errsv = errno; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv), _("Failed to create temp file: %s"), g_strerror (errsv)); g_free (tmp_file); tmp_file = NULL; goto cleanup; } close (fd); proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error, xmllint, "--nonet", "--noblanks", "--output", tmp_file, real_file, NULL); g_free (real_file); real_file = NULL; if (!proc) goto cleanup; if (!g_subprocess_wait_check (proc, NULL, error)) { g_object_unref (proc); goto cleanup; } g_object_unref (proc); real_file = g_strdup (tmp_file); } if (to_pixdata) { int fd; GSubprocess *proc; if (gdk_pixbuf_pixdata == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "to-pixbuf preprocessing requested but GDK_PIXBUF_PIXDATA " "not set and gdk-pixbuf-pixdata not found in path"); goto cleanup; } tmp_file2 = g_strdup ("resource-XXXXXXXX"); if ((fd = g_mkstemp (tmp_file2)) == -1) { int errsv = errno; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv), _("Failed to create temp file: %s"), g_strerror (errsv)); g_free (tmp_file2); tmp_file2 = NULL; goto cleanup; } close (fd); proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDOUT_SILENCE, error, gdk_pixbuf_pixdata, real_file, tmp_file2, NULL); g_free (real_file); real_file = NULL; if (!g_subprocess_wait_check (proc, NULL, error)) { g_object_unref (proc); goto cleanup; } g_object_unref (proc); real_file = g_strdup (tmp_file2); } } if (!g_file_get_contents (real_file, &data->content, &data->size, &my_error)) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Error reading file %s: %s"), real_file, my_error->message); g_clear_error (&my_error); goto cleanup; } /* Include zero termination in content_size for uncompressed files (but not in size) */ data->content_size = data->size + 1; if (state->compressed) { GOutputStream *out = g_memory_output_stream_new (NULL, 0, g_realloc, g_free); GZlibCompressor *compressor = g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB, 9); GOutputStream *out2 = g_converter_output_stream_new (out, G_CONVERTER (compressor)); if (!g_output_stream_write_all (out2, data->content, data->size, NULL, NULL, NULL) || !g_output_stream_close (out2, NULL, NULL)) { g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, _("Error compressing file %s"), real_file); goto cleanup; } g_free (data->content); data->content_size = g_memory_output_stream_get_size (G_MEMORY_OUTPUT_STREAM (out)); data->content = g_memory_output_stream_steal_data (G_MEMORY_OUTPUT_STREAM (out)); g_object_unref (compressor); g_object_unref (out); g_object_unref (out2); data->flags |= G_RESOURCE_FLAGS_COMPRESSED; } done: g_hash_table_insert (state->table, key, data); data = NULL; cleanup: /* Cleanup */ g_free (state->alias); state->alias = NULL; g_string_free (state->string, TRUE); state->string = NULL; g_free (state->preproc_options); state->preproc_options = NULL; g_free (real_file); if (tmp_file) { unlink (tmp_file); g_free (tmp_file); } if (tmp_file2) { unlink (tmp_file2); g_free (tmp_file2); } if (data != NULL) file_data_free (data); } }
char * gvfs_file_info_marshal (GFileInfo *info, gsize *size) { GOutputStream *memstream; GDataOutputStream *out; GFileAttributeType type; GFileAttributeStatus status; GObject *obj; char **attrs, *attr; char *data; int i; memstream = g_memory_output_stream_new (NULL, 0, g_realloc, NULL); out = g_data_output_stream_new (memstream); g_object_unref (memstream); attrs = g_file_info_list_attributes (info, NULL); g_data_output_stream_put_uint32 (out, g_strv_length (attrs), NULL, NULL); for (i = 0; attrs[i] != NULL; i++) { attr = attrs[i]; type = g_file_info_get_attribute_type (info, attr); status = g_file_info_get_attribute_status (info, attr); put_string (out, attr); g_data_output_stream_put_byte (out, type, NULL, NULL); g_data_output_stream_put_byte (out, status, NULL, NULL); switch (type) { case G_FILE_ATTRIBUTE_TYPE_STRING: put_string (out, g_file_info_get_attribute_string (info, attr)); break; case G_FILE_ATTRIBUTE_TYPE_BYTE_STRING: put_string (out, g_file_info_get_attribute_byte_string (info, attr)); break; case G_FILE_ATTRIBUTE_TYPE_STRINGV: put_stringv (out, g_file_info_get_attribute_stringv (info, attr)); break; case G_FILE_ATTRIBUTE_TYPE_BOOLEAN: g_data_output_stream_put_byte (out, g_file_info_get_attribute_boolean (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_UINT32: g_data_output_stream_put_uint32 (out, g_file_info_get_attribute_uint32 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_INT32: g_data_output_stream_put_int32 (out, g_file_info_get_attribute_int32 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_UINT64: g_data_output_stream_put_uint64 (out, g_file_info_get_attribute_uint64 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_INT64: g_data_output_stream_put_int64 (out, g_file_info_get_attribute_int64 (info, attr), NULL, NULL); break; case G_FILE_ATTRIBUTE_TYPE_OBJECT: obj = g_file_info_get_attribute_object (info, attr); if (obj == NULL) { g_data_output_stream_put_byte (out, 0, NULL, NULL); } else if (G_IS_ICON (obj)) { char *icon_str; icon_str = g_icon_to_string (G_ICON (obj)); g_data_output_stream_put_byte (out, 1, NULL, NULL); put_string (out, icon_str); g_free (icon_str); } else { g_warning ("Unsupported GFileInfo object type %s\n", g_type_name_from_instance ((GTypeInstance *)obj)); g_data_output_stream_put_byte (out, 0, NULL, NULL); } break; case G_FILE_ATTRIBUTE_TYPE_INVALID: default: break; } } data = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (memstream)); *size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (memstream)); g_object_unref (out); g_strfreev (attrs); return data; }