gboolean ostree_zlib_file_header_parse (GVariant *metadata, GFileInfo **out_file_info, GVariant **out_xattrs, GError **error) { gboolean ret = FALSE; guint64 size; guint32 uid, gid, mode, rdev; const char *symlink_target; ot_lobj GFileInfo *ret_file_info = NULL; ot_lvariant GVariant *ret_xattrs = NULL; g_variant_get (metadata, "(tuuuu&s@a(ayay))", &size, &uid, &gid, &mode, &rdev, &symlink_target, &ret_xattrs); size = GUINT64_FROM_BE (size); uid = GUINT32_FROM_BE (uid); gid = GUINT32_FROM_BE (gid); mode = GUINT32_FROM_BE (mode); rdev = GUINT32_FROM_BE (rdev); ret_file_info = g_file_info_new (); g_file_info_set_size (ret_file_info, size); g_file_info_set_attribute_uint32 (ret_file_info, "standard::type", ot_gfile_type_for_mode (mode)); g_file_info_set_attribute_boolean (ret_file_info, "standard::is-symlink", S_ISLNK (mode)); g_file_info_set_attribute_uint32 (ret_file_info, "unix::uid", uid); g_file_info_set_attribute_uint32 (ret_file_info, "unix::gid", gid); g_file_info_set_attribute_uint32 (ret_file_info, "unix::mode", mode); if (S_ISREG (mode)) { ; } else if (S_ISLNK (mode)) { g_file_info_set_attribute_byte_string (ret_file_info, "standard::symlink-target", symlink_target); } else if (S_ISCHR (mode) || S_ISBLK (mode)) { g_file_info_set_attribute_uint32 (ret_file_info, "unix::rdev", rdev); } else if (S_ISFIFO (mode)) { ; } else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Corrupted archive file; invalid mode %u", mode); goto out; } ret = TRUE; ot_transfer_out_value(out_file_info, &ret_file_info); ot_transfer_out_value(out_xattrs, &ret_xattrs); out: return ret; }
static GConverterResult g_zlib_decompressor_convert (GConverter *converter, const void *inbuf, gsize inbuf_size, void *outbuf, gsize outbuf_size, GConverterFlags flags, gsize *bytes_read, gsize *bytes_written, GError **error) { GZlibDecompressor *decompressor; int res; decompressor = G_ZLIB_DECOMPRESSOR (converter); decompressor->zstream.next_in = (void *)inbuf; decompressor->zstream.avail_in = inbuf_size; decompressor->zstream.next_out = outbuf; decompressor->zstream.avail_out = outbuf_size; res = inflate (&decompressor->zstream, Z_NO_FLUSH); if (res == Z_DATA_ERROR || res == Z_NEED_DICT) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, _("Invalid compressed data")); return G_CONVERTER_ERROR; } if (res == Z_MEM_ERROR) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Not enough memory")); return G_CONVERTER_ERROR; } if (res == Z_STREAM_ERROR) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Internal error: %s"), decompressor->zstream.msg); return G_CONVERTER_ERROR; } if (res == Z_BUF_ERROR) { if (flags & G_CONVERTER_FLUSH) return G_CONVERTER_FLUSHED; /* Z_FINISH not set, so this means no progress could be made */ /* We do have output space, so this should only happen if we have no input but need some */ g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PARTIAL_INPUT, _("Need more input")); return G_CONVERTER_ERROR; } g_assert (res == Z_OK || res == Z_STREAM_END); *bytes_read = inbuf_size - decompressor->zstream.avail_in; *bytes_written = outbuf_size - decompressor->zstream.avail_out; #if !defined (G_OS_WIN32) || ZLIB_VERNUM >= 0x1240 if (decompressor->header_data != NULL && decompressor->header_data->gzheader.done == 1) { HeaderData *data = decompressor->header_data; /* So we don't notify again */ data->gzheader.done = 2; data->file_info = g_file_info_new (); g_file_info_set_attribute_uint64 (data->file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED, data->gzheader.time); g_file_info_set_attribute_uint32 (data->file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC, 0); if (data->filename[0] != '\0') g_file_info_set_attribute_byte_string (data->file_info, G_FILE_ATTRIBUTE_STANDARD_NAME, data->filename); g_object_notify (G_OBJECT (decompressor), "file-info"); } #endif /* !G_OS_WIN32 || ZLIB >= 1.2.4 */ if (res == Z_STREAM_END) return G_CONVERTER_FINISHED; return G_CONVERTER_CONVERTED; }
static void trash_backend_add_info (TrashItem *item, GFileInfo *info, gboolean is_toplevel) { if (is_toplevel) { const gchar *delete_date; GFile *original, *real; g_assert (item != NULL); original = trash_item_get_original (item); if (original) { gchar *edit_name, *path; path = g_file_get_path (original); edit_name = gvfs_file_info_populate_names_as_local (info, path); g_file_info_set_attribute_byte_string (info, G_FILE_ATTRIBUTE_TRASH_ORIG_PATH, path); g_free (edit_name); g_free (path); } real = trash_item_get_file (item); if (real) { char *uri; uri = g_file_get_uri (real); g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI, uri); g_free (uri); } delete_date = trash_item_get_delete_date (item); if (delete_date) g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_TRASH_DELETION_DATE, delete_date); } g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, FALSE); g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE, FALSE); g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME, FALSE); g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH, FALSE); g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE, is_toplevel); }
GFileInfo * gvfs_file_info_demarshal (char *data, gsize size) { guint32 num_attrs, i; GInputStream *memstream; GDataInputStream *in; GFileInfo *info; char *attr, *str, **strv; GFileAttributeType type; GFileAttributeStatus status; GObject *obj; int objtype; memstream = g_memory_input_stream_new_from_data (data, size, NULL); in = g_data_input_stream_new (memstream); g_object_unref (memstream); info = g_file_info_new (); num_attrs = g_data_input_stream_read_uint32 (in, NULL, NULL); for (i = 0; i < num_attrs; i++) { attr = read_string (in); type = g_data_input_stream_read_byte (in, NULL, NULL); status = g_data_input_stream_read_byte (in, NULL, NULL); switch (type) { case G_FILE_ATTRIBUTE_TYPE_STRING: str = read_string (in); g_file_info_set_attribute_string (info, attr, str); g_free (str); break; case G_FILE_ATTRIBUTE_TYPE_BYTE_STRING: str = read_string (in); g_file_info_set_attribute_byte_string (info, attr, str); g_free (str); break; case G_FILE_ATTRIBUTE_TYPE_STRINGV: strv = read_stringv (in); g_file_info_set_attribute_stringv (info, attr, strv); g_strfreev (strv); break; case G_FILE_ATTRIBUTE_TYPE_BOOLEAN: g_file_info_set_attribute_boolean (info, attr, g_data_input_stream_read_byte (in, NULL, NULL)); break; case G_FILE_ATTRIBUTE_TYPE_UINT32: g_file_info_set_attribute_uint32 (info, attr, g_data_input_stream_read_uint32 (in, NULL, NULL)); break; case G_FILE_ATTRIBUTE_TYPE_INT32: g_file_info_set_attribute_int32 (info, attr, g_data_input_stream_read_int32 (in, NULL, NULL)); break; case G_FILE_ATTRIBUTE_TYPE_UINT64: g_file_info_set_attribute_uint64 (info, attr, g_data_input_stream_read_uint64 (in, NULL, NULL)); break; case G_FILE_ATTRIBUTE_TYPE_INT64: g_file_info_set_attribute_int64 (info, attr, g_data_input_stream_read_int64 (in, NULL, NULL)); break; case G_FILE_ATTRIBUTE_TYPE_OBJECT: objtype = g_data_input_stream_read_byte (in, NULL, NULL); obj = NULL; if (objtype == 1) { char *icon_str; icon_str = read_string (in); obj = (GObject *)g_icon_new_for_string (icon_str, NULL); g_free (icon_str); } else { g_warning ("Unsupported GFileInfo object type %d\n", objtype); g_free (attr); goto out; } g_file_info_set_attribute_object (info, attr, obj); if (obj) g_object_unref (obj); break; case G_FILE_ATTRIBUTE_TYPE_INVALID: break; default: g_warning ("Unsupported GFileInfo attribute type %d\n", type); g_free (attr); goto out; break; } g_file_info_set_attribute_status (info, attr, status); g_free (attr); } out: g_object_unref (in); return info; }