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