/**
* seahorse_util_memory_output_length:
* @output: a stream
*
* A replacement for #g_memory_output_stream_get_data_size (since 2.18)
*
* Returns: The length of the stream
*/
gsize
seahorse_util_memory_output_length (GMemoryOutputStream *output)
{
GSeekable *seekable;
goffset offset, end;
/*
* This is a replacement for g_memory_output_stream_get_data_size()
* which is not available in current version of glib.
*/
g_return_val_if_fail (G_IS_MEMORY_OUTPUT_STREAM (output), 0);
g_return_val_if_fail (G_IS_SEEKABLE (output), 0);
seekable = G_SEEKABLE (output);
offset = g_seekable_tell (seekable);
if (!g_seekable_seek (seekable, 0, G_SEEK_END, NULL, NULL))
g_return_val_if_reached (0);
end = g_seekable_tell (seekable);
if (offset != end) {
if (!g_seekable_seek (seekable, offset, G_SEEK_SET, NULL, NULL))
g_return_val_if_reached (0);
}
return (gsize)end;
}
gint
test_message_compare (CamelMimeMessage *msg)
{
CamelMimeMessage *msg2;
CamelStream *stream1;
CamelStream *stream2;
GByteArray *byte_array1;
GByteArray *byte_array2;
byte_array1 = g_byte_array_new ();
stream1 = camel_stream_mem_new_with_byte_array (byte_array1);
check_msg (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg), stream1, NULL, NULL) != -1,
"write_to_stream 1 failed", NULL);
g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);
msg2 = camel_mime_message_new ();
check_msg (camel_data_wrapper_construct_from_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream1, NULL, NULL) != -1,
"construct_from_stream 1 failed");
g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);
byte_array2 = g_byte_array_new ();
stream2 = camel_stream_mem_new_with_byte_array (byte_array2);
check_msg (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream2, NULL, NULL) != -1,
"write_to_stream 2 failed");
g_seekable_seek (G_SEEKABLE (stream2), 0, G_SEEK_SET, NULL, NULL);
if (byte_array1->len != byte_array2->len) {
CamelDataWrapper *content;
printf ("stream1 stream:\n%.*s\n", byte_array1->len, byte_array1->data);
printf ("stream2 stream:\n%.*s\n\n", byte_array2->len, byte_array2->data);
printf ("msg1:\n");
test_message_dump_structure (msg);
printf ("msg2:\n");
test_message_dump_structure (msg2);
content = camel_medium_get_content ((CamelMedium *) msg);
}
check_unref (msg2, 1);
check_msg (
byte_array1->len == byte_array2->len,
"byte_array1->len = %d, byte_array2->len = %d",
byte_array1->len, byte_array2->len);
check_msg (memcmp (byte_array1->data, byte_array2->data, byte_array1->len) == 0, "msg/stream compare");
g_object_unref (stream1);
g_object_unref (stream2);
return 0;
}
static gboolean
try_seek_on_read (GVfsBackend *backend,
GVfsJobSeekRead *job,
GVfsBackendHandle handle,
goffset offset,
GSeekType type)
{
GInputStream *stream;
GError *error = NULL;
stream = G_INPUT_STREAM (handle);
if (!g_seekable_seek (G_SEEKABLE (stream), offset, type,
G_VFS_JOB (job)->cancellable, &error))
{
g_vfs_job_failed_literal (G_VFS_JOB (job),
error->domain,
error->code,
error->message);
g_error_free (error);
return FALSE;
}
else
{
g_vfs_job_seek_read_set_offset (job, g_seekable_tell (G_SEEKABLE (stream)));
g_vfs_job_succeeded (G_VFS_JOB (job));
}
return TRUE;
}
static gboolean
gimp_curves_tool_settings_import (GimpImageMapTool *image_map_tool,
GInputStream *input,
GError **error)
{
GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool);
gchar header[64];
gsize bytes_read;
if (! g_input_stream_read_all (input, header, sizeof (header),
&bytes_read, NULL, error) ||
bytes_read != sizeof (header))
{
g_prefix_error (error, _("Could not read header: "));
return FALSE;
}
g_seekable_seek (G_SEEKABLE (input), 0, G_SEEK_SET, NULL, NULL);
if (g_str_has_prefix (header, "# GIMP Curves File\n"))
return gimp_curves_config_load_cruft (tool->config, input, error);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (image_map_tool,
input,
error);
}
static int gio_fseek (VFSFile * file, int64_t offset, int whence)
{
FileData * data = vfs_get_handle (file);
GError * error = 0;
GSeekType gwhence;
switch (whence)
{
case SEEK_SET:
gwhence = G_SEEK_SET;
break;
case SEEK_CUR:
gwhence = G_SEEK_CUR;
break;
case SEEK_END:
gwhence = G_SEEK_END;
break;
default:
gio_error ("Cannot seek within %s: invalid whence.", vfs_get_filename (file));
return -1;
}
g_seekable_seek (data->seekable, offset, gwhence, NULL, & error);
CHECK_ERROR ("seek within", vfs_get_filename (file));
return 0;
FAILED:
return -1;
}
/**
* seahorse_util_read_to_memory:
* @input: Data to read. The #GInputStream is read till the end.
* @len: Length of the data read (out)
*
* Reads data from the input stream and returns them as #guchar
*
* Returns: The string read from data. The returned string should be freed
* with #g_free when no longer needed.
**/
guchar*
seahorse_util_read_to_memory (GInputStream *input, guint *len)
{
gsize size = 128;
gchar *buffer, *text;
gsize nread = 0;
GString *string;
GSeekable *seek;
if (G_IS_SEEKABLE (input)) {
seek = G_SEEKABLE (input);
g_seekable_seek (seek, 0, SEEK_SET, NULL, NULL);
}
string = g_string_new ("");
buffer = g_new (gchar, size);
while (g_input_stream_read_all (input, buffer, size, &nread, NULL, NULL)) {
string = g_string_append_len (string, buffer, nread);
if (nread != size)
break;
}
if (len)
*len = string->len;
text = g_string_free (string, FALSE);
g_free (buffer);
return (guchar*)text;
}
static unsigned long
vfs_stream_read (FT_Stream stream,
unsigned long offset,
unsigned char *buffer,
unsigned long count)
{
GFileInputStream *handle = stream->descriptor.pointer;
gssize bytes_read = 0;
if (!count && offset > stream->size)
return 1;
if (!g_seekable_seek (G_SEEKABLE (handle), offset, G_SEEK_SET, NULL, NULL))
return (count ? 0 : 1);
if (count > 0) {
bytes_read = g_input_stream_read (G_INPUT_STREAM (handle), buffer,
count, NULL, NULL);
if (bytes_read == -1)
return 0;
}
return bytes_read;
}
static void
cache_replace_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GFileOutputStream *cache_stream;
GError *error = NULL;
NemoPreviewCoverArtFetcher *self = user_data;
cache_stream = g_file_replace_finish (G_FILE (source),
res, &error);
if (error != NULL) {
g_warning ("Can't save the cover art image in the cache: %s\n", error->message);
g_error_free (error);
return;
}
g_seekable_seek (G_SEEKABLE (self->priv->input_stream), 0, G_SEEK_SET,
NULL, NULL);
g_output_stream_splice_async (G_OUTPUT_STREAM (cache_stream),
self->priv->input_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT,
NULL,
cache_splice_ready_cb, self);
g_object_unref (cache_stream);
}
static gint64
xmms_gvfs_seek (xmms_xform_t *xform, gint64 offset,
xmms_xform_seek_mode_t whence, xmms_error_t *error)
{
GSeekType type;
GError *err = NULL;
xmms_gvfs_data_t *data = xmms_xform_private_data_get (xform);
g_return_val_if_fail (data, -1);
g_return_val_if_fail (!g_input_stream_is_closed (data->handle), -1);
switch (whence) {
case XMMS_XFORM_SEEK_CUR:
type = G_SEEK_CUR;
break;
case XMMS_XFORM_SEEK_SET:
type = G_SEEK_SET;
break;
case XMMS_XFORM_SEEK_END:
type = G_SEEK_END;
break;
}
if (g_seekable_seek (G_SEEKABLE (data->handle), offset, type, NULL, &err)) {
return g_seekable_tell (G_SEEKABLE (data->handle));
}
xmms_error_set (error, XMMS_ERROR_GENERIC, err->message);
return -1;
}
static gboolean
gegl_tile_backend_file_write_header (GeglTileBackendFile *self)
{
gboolean success;
gegl_tile_backend_file_ensure_exist (self);
#if HAVE_GIO
success = g_seekable_seek (G_SEEKABLE (self->o), 0, G_SEEK_SET,
NULL, NULL);
#else
success = (lseek (self->o, 0, SEEK_SET) != -1);
#endif
if (success == FALSE)
{
g_warning ("unable to seek in buffer");
return FALSE;
}
#if HAVE_GIO
g_output_stream_write (self->o, &(self->header), 256, NULL, NULL);
#else
write (self->o, &(self->header), 256);
#endif
GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "Wrote header, next=%i", (gint)self->header.next);
return TRUE;
}
static void
extract_gibest_hash (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFile *file = source_object;
guint64 buffer[2][CHUNK_N_BYTES/8];
GInputStream *stream = NULL;
gssize n_bytes, file_size;
GError *error = NULL;
guint64 hash = 0;
gint i;
char *str;
ResolveData *resolve_data = task_data;
GrlLocalMetadataSourcePriv *priv;
priv = GRL_LOCAL_METADATA_SOURCE_GET_PRIVATE (resolve_data->source);
stream = G_INPUT_STREAM (g_file_read (file, cancellable, &error));
if (stream == NULL)
goto fail;
/* Extract start/end chunks of the file */
n_bytes = g_input_stream_read (stream, buffer[0], CHUNK_N_BYTES, cancellable, &error);
if (n_bytes == -1)
goto fail;
if (!g_seekable_seek (G_SEEKABLE (stream), -CHUNK_N_BYTES, G_SEEK_END, cancellable, &error))
goto fail;
n_bytes = g_input_stream_read (stream, buffer[1], CHUNK_N_BYTES, cancellable, &error);
if (n_bytes == -1)
goto fail;
for (i = 0; i < G_N_ELEMENTS (buffer[0]); i++)
hash += buffer[0][i] + buffer[1][i];
file_size = g_seekable_tell (G_SEEKABLE (stream));
if (file_size < CHUNK_N_BYTES)
goto fail;
/* Include file size */
hash += file_size;
g_object_unref (stream);
str = g_strdup_printf ("%" G_GINT64_FORMAT, hash);
grl_data_set_string (GRL_DATA (resolve_data->rs->media), priv->hash_keyid, str);
g_free (str);
g_task_return_boolean (task, TRUE);
return;
fail:
GRL_DEBUG ("Could not get file hash: %s\n", error ? error->message : "Unknown error");
g_task_return_error (task, error);
g_clear_object (&stream);
}
gint main (gint argc, gchar **argv)
{
struct dirent *dent;
DIR *dir;
gint fd;
camel_test_init (argc, argv);
camel_test_start ("Message Test Suite");
if (!(dir = opendir ("../data/messages")))
return 77;
while ((dent = readdir (dir)) != NULL) {
CamelMimeMessage *message;
CamelStream *stream;
gchar *filename;
struct stat st;
if (dent->d_name[0] == '.')
continue;
filename = g_strdup_printf ("../data/messages/%s", dent->d_name);
if (g_stat (filename, &st) == -1 || !S_ISREG (st.st_mode)) {
g_free (filename);
continue;
}
if ((fd = open (filename, O_RDONLY)) == -1) {
g_free (filename);
continue;
}
push ("testing message '%s'", filename);
g_free (filename);
stream = camel_stream_fs_new_with_fd (fd);
message = camel_mime_message_new ();
camel_data_wrapper_construct_from_stream_sync (
CAMEL_DATA_WRAPPER (message), stream, NULL, NULL);
g_seekable_seek (
G_SEEKABLE (stream), 0, G_SEEK_SET, NULL, NULL);
/*dump_mime_struct ((CamelMimePart *) message, 0);*/
test_message_compare (message);
g_object_unref (message);
g_object_unref (stream);
pull ();
}
closedir (dir);
camel_test_end ();
return 0;
}
static void
ddb_gvfs_rewind (DB_FILE *stream)
{
vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;
g_return_if_fail (data != NULL);
if (g_seekable_can_seek (G_SEEKABLE (data->handle)))
g_seekable_seek (G_SEEKABLE (data->handle), 0, G_SEEK_SET, NULL, NULL);
}
/* Called from gpgme to seek a file */
static off_t
vfs_data_seek (void *handle, off_t offset, int whence)
{
VfsAsyncHandle* ah = (VfsAsyncHandle*)handle;
GSeekable *seekable = NULL;
GSeekType wh;
/* If the file isn't open yet, then do that now */
if (!ah->ostream && !ah->istream && ah->state == VFS_ASYNC_READY)
vfs_data_open_helper (ah);
/* Just in case we have an operation, like open */
if (!vfs_data_wait_results(ah, TRUE))
return (off_t)-1;
g_assert (ah->state == VFS_ASYNC_READY);
if (ah->writer && G_IS_SEEKABLE (ah->ostream))
seekable = G_SEEKABLE (ah->ostream);
else
seekable = G_SEEKABLE (ah->istream);
if (!seekable || !g_seekable_can_seek (seekable)) {
errno = ENOTSUP;
return -1;
}
switch(whence)
{
case SEEK_SET:
wh = G_SEEK_SET;
break;
case SEEK_CUR:
wh = G_SEEK_CUR;
break;
case SEEK_END:
wh = G_SEEK_END;
break;
default:
g_assert_not_reached();
break;
}
/* All seek operations are not async */
g_clear_error (&ah->error);
g_seekable_seek (seekable, (goffset)offset, wh, ah->cancellable, &ah->error);
/* Start async operation */
ah->state = VFS_ASYNC_READY;
if (!vfs_data_wait_results (ah, TRUE))
return -1;
/* Return results */
ah->state = VFS_ASYNC_READY;
return offset;
}
static guint64 get_code( GbdEmitter* _self,gchar* key ) {
GbdX11emitter* const self = GBD_X11EMITTER( _self );
GbdX11emitterPrivate* const priv = self->priv;
if( !priv->srcdata ) {
GFile* file = g_file_new_for_path( GBD_X11EMITTER_SRC );
if( !load_file( self,file,NULL ) ) {
g_critical( "GBoard X11-Emitter could not parse X11 keysymdef.h at " GBD_X11EMITTER_SRC );
return 0;
}
g_object_unref( file );
}
guint64* code,symval = 0;
if( ( code = g_datalist_get_data( &priv->mapcache,key ) ) )
return *code;
else
code = g_malloc( sizeof( guint64 ) );
g_seekable_seek( G_SEEKABLE( priv->srcstream ),0,G_SEEK_SET,NULL,NULL );
GDataInputStream* dis = priv->srcdata;
gchar* line;
gsize len = strlen( key );
gchar* keytoken = g_malloc( sizeof( gchar )*len+sizeof( KEYDEF_PREFIX )+1 );
sprintf( keytoken,KEYDEF_PREFIX "%s",key );
len = strlen( keytoken );
GError* err = NULL;
while( line = g_data_input_stream_read_line( dis,NULL,NULL,&err ) ) {
if( !strncmp( keytoken,line,len )&& g_ascii_isspace( line[ len ] ) ) {
if( sscanf( line+len," %" G_GINT64_MODIFIER "x ",&symval ) ) {
g_free( line );
break;
}
}
g_free( line );
}
if( err ) {
g_error( "%s",err->message );
g_error_unref( &err );
}
if( symval ) {
guint64 codeval = XKeysymToKeycode( priv->dpy,symval );
*code = codeval;
g_datalist_set_data_full( &priv->mapcache,key,code,g_free );
if( !codeval )
g_warning( "Could not find code for key '%s', Keysym-Value " G_GINT64_FORMAT,key,symval );
return codeval;
}
return 0;
}
static gboolean
gsf_input_gio_seek (GsfInput *input, gsf_off_t offset, GSeekType whence)
{
GsfInputGio *gio = GSF_INPUT_GIO (input);
g_return_val_if_fail (gio != NULL, TRUE);
g_return_val_if_fail (gio->stream != NULL, TRUE);
g_return_val_if_fail (can_seek (gio->stream), TRUE);
return (g_seekable_seek (G_SEEKABLE (gio->stream), offset, whence, NULL, NULL) ? FALSE : TRUE);
}
static gboolean
read_head_data(GInputStream *stream, guchar *buffer, gsize buffer_size,
gsize *read_bytes)
{
GSeekable *seekable;
gsize original_position;
GError *error = NULL;
if (!G_IS_SEEKABLE(stream))
return FALSE;
seekable = G_SEEKABLE(stream);
original_position = g_seekable_tell(seekable);
g_seekable_seek(seekable, 0, G_SEEK_SET, NULL, &error);
if (error) {
chupa_error("failed to seek to the head to guess content-type: %s",
error->message);
g_error_free(error);
return FALSE;
}
*read_bytes = g_input_stream_read(stream, buffer, buffer_size, NULL, &error);
if (error) {
chupa_error("failed to read head data to guess content-type: %s",
error->message);
g_error_free(error);
g_seekable_seek(seekable, original_position, G_SEEK_SET, NULL, NULL);
return FALSE;
}
g_seekable_seek(seekable, original_position, G_SEEK_SET, NULL, &error);
if (error) {
chupa_error("failed to re-seek to the original position "
"to reset position to guess content-type: %s",
error->message);
g_error_free(error);
return FALSE;
}
return TRUE;
}
static inline void
gegl_tile_backend_file_file_entry_read (GeglTileBackendFile *self,
GeglBufferTile *entry,
guchar *dest)
{
gint to_be_read;
gboolean success;
gint tile_size = gegl_tile_backend_get_tile_size (GEGL_TILE_BACKEND (self));
goffset offset = entry->offset;
gegl_tile_backend_file_ensure_exist (self);
#if HAVE_GIO
success = g_seekable_seek (G_SEEKABLE (self->i),
offset, G_SEEK_SET,
NULL, NULL);
#else
success = (lseek (self->i, offset, SEEK_SET) >= 0);
#endif
if (success == FALSE)
{
g_warning ("unable to seek to tile in buffer: %s", g_strerror (errno));
return;
}
to_be_read = tile_size;
while (to_be_read > 0)
{
gint byte_read;
#if HAVE_GIO
byte_read = g_input_stream_read (G_INPUT_STREAM (self->i),
dest + tile_size - to_be_read, to_be_read,
NULL, NULL);
#else
byte_read = read (self->i, dest + tile_size - to_be_read, to_be_read);
#endif
if (byte_read <= 0)
{
g_message ("unable to read tile data from self: "
"%s (%d/%d bytes read)",
g_strerror (errno), byte_read, to_be_read);
return;
}
to_be_read -= byte_read;
}
GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "read entry %i,%i,%i at %i", entry->x, entry->y, entry->z, (gint)offset);
}
static inline void
gegl_tile_backend_file_file_entry_write (GeglTileBackendFile *self,
GeglBufferTile *entry,
guchar *source)
{
gint to_be_written;
gboolean success;
gint tile_size = gegl_tile_backend_get_tile_size (GEGL_TILE_BACKEND (self));
goffset offset = entry->offset;
gegl_tile_backend_file_ensure_exist (self);
#if HAVE_GIO
success = g_seekable_seek (G_SEEKABLE (self->o),
offset, G_SEEK_SET,
NULL, NULL);
#else
success = (lseek (self->o, offset, SEEK_SET) >= 0);
#endif
if (success == FALSE)
{
g_warning ("unable to seek to tile in buffer: %s", g_strerror (errno));
return;
}
to_be_written = tile_size;
while (to_be_written > 0)
{
gint wrote;
#if HAVE_GIO
wrote = g_output_stream_write (self->o,
source + tile_size - to_be_written,
to_be_written, NULL, NULL);
#else
wrote = write (self->o,
source + tile_size - to_be_written,
to_be_written);
#endif
if (wrote <= 0)
{
g_message ("unable to write tile data to self: "
"%s (%d/%d bytes written)",
g_strerror (errno), wrote, to_be_written);
return;
}
to_be_written -= wrote;
}
GEGL_NOTE (GEGL_DEBUG_TILE_BACKEND, "wrote entry %i,%i,%i at %i", entry->x, entry->y, entry->z, (gint)offset);
}
static toff_t
seek_in_stream(thandle_t handle,
toff_t offset,
int whence)
{
Priv *p = (Priv*) handle;
GError *error = NULL;
gboolean sought = FALSE;
goffset position = -1;
g_assert(p->stream);
if (p->can_seek)
{
sought = g_seekable_seek(G_SEEKABLE(p->stream),
(goffset) offset, lseek_to_seek_type(whence),
NULL, &error);
if (sought)
position = g_seekable_tell(G_SEEKABLE(p->stream));
else
{
g_warning("%s", error->message);
g_error_free(error);
}
}
else
{
switch (whence)
{
default:
case SEEK_SET:
if (offset <= p->allocated)
position = p->position = offset;
break;
case SEEK_CUR:
if (p->position + offset <= p->allocated)
position = p->position += offset;
break;
case G_SEEK_END:
position = p->position = p->allocated + offset;
break;
}
}
return (toff_t) position;
}
static VALUE
rg_seek(int argc, VALUE *argv, VALUE self)
{
VALUE offset, type, cancellable;
GError *error = NULL;
rb_scan_args(argc, argv, "12", &offset, &type, &cancellable);
if (!g_seekable_seek(_SELF(self),
RVAL2GOFFSET(offset),
RVAL2GSEEKTYPEDEFAULT(type),
RVAL2GCANCELLABLE(cancellable),
&error))
rbgio_raise_error(error);
return self;
}
static gboolean
data_wrapper_construct_from_stream_sync (CamelDataWrapper *data_wrapper,
CamelStream *stream,
GCancellable *cancellable,
GError **error)
{
CamelStream *memory_stream;
gssize bytes_written;
camel_data_wrapper_lock (
data_wrapper, CAMEL_DATA_WRAPPER_STREAM_LOCK);
/* Check for cancellation after locking. */
if (g_cancellable_set_error_if_cancelled (cancellable, error)) {
camel_data_wrapper_unlock (
data_wrapper, CAMEL_DATA_WRAPPER_STREAM_LOCK);
return FALSE;
}
if (G_IS_SEEKABLE (stream)) {
if (!g_seekable_seek (G_SEEKABLE (stream), 0, G_SEEK_SET, cancellable, error)) {
camel_data_wrapper_unlock (data_wrapper, CAMEL_DATA_WRAPPER_STREAM_LOCK);
return FALSE;
}
}
/* Wipe any previous contents from our byte array. */
g_byte_array_set_size (data_wrapper->priv->byte_array, 0);
memory_stream = camel_stream_mem_new ();
/* We retain ownership of the byte array. */
camel_stream_mem_set_byte_array (
CAMEL_STREAM_MEM (memory_stream),
data_wrapper->priv->byte_array);
/* Transfer incoming contents to our byte array. */
bytes_written = camel_stream_write_to_stream (
stream, memory_stream, cancellable, error);
g_object_unref (memory_stream);
camel_data_wrapper_unlock (
data_wrapper, CAMEL_DATA_WRAPPER_STREAM_LOCK);
return (bytes_written >= 0);
}
/**
* gel_ui_pixbuf_from_stream:
* @stream: (transfer none): A #GInputStream
*
* Creates a #GdkPixbuf from a #GInputStream
*
* Returns: (transfer full): The new #GdkPixbuf or %NULL
*/
GdkPixbuf*
gel_ui_pixbuf_from_stream(const GInputStream *stream)
{
g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL);
g_seekable_seek((GSeekable *) stream, 0, G_SEEK_SET, NULL, NULL);
GError *error = NULL;
GdkPixbuf *ret = gdk_pixbuf_new_from_stream((GInputStream *) stream, NULL, &error);
if (ret == NULL)
{
g_warning(_("Cannot load image from input stream %p: %s"), stream, error->message);
g_error_free(error);
return NULL;
}
return ret;
}
static gboolean
g_resource_file_input_stream_seek (GFileInputStream *stream,
goffset offset,
GSeekType type,
GCancellable *cancellable,
GError **error)
{
GResourceFileInputStream *file = G_RESOURCE_FILE_INPUT_STREAM (stream);
if (!G_IS_SEEKABLE (file->stream))
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("Input stream doesn't implement seek"));
return FALSE;
}
return g_seekable_seek (G_SEEKABLE (file->stream),
offset, type, cancellable, error);
}
GList *
gimp_palette_load_riff (GimpContext *context,
GFile *file,
GInputStream *input,
GError **error)
{
GimpPalette *palette;
gchar *palette_name;
guchar color_bytes[4];
gsize bytes_read;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
palette_name = g_path_get_basename (gimp_file_get_utf8_name (file));
palette = GIMP_PALETTE (gimp_palette_new (context, palette_name));
g_free (palette_name);
if (! g_seekable_seek (G_SEEKABLE (input), 28, G_SEEK_SET, NULL, error))
{
g_object_unref (palette);
return NULL;
}
while (g_input_stream_read_all (input, color_bytes, sizeof (color_bytes),
&bytes_read, NULL, NULL) &&
bytes_read == sizeof (color_bytes))
{
GimpRGB color;
gimp_rgba_set_uchar (&color,
color_bytes[0],
color_bytes[1],
color_bytes[2],
255);
gimp_palette_add_entry (palette, -1, NULL, &color);
}
return g_list_prepend (NULL, palette);
}
static void on_file_append_to_ready (GObject * object, GAsyncResult * res, gpointer data)
{
GError *error = NULL;
GDownloadable *download = G_DOWNLOADABLE (data);
GioDownload *gio_download = GIO_DOWNLOAD (data);
g_assert (download != NULL);
GFileOutputStream *out_stream = g_file_append_to_finish (G_FILE(object), res, &error);
handle_error (error);
if (out_stream != NULL) {
gio_download->priv->output = out_stream;
if (g_seekable_seek (G_SEEKABLE(gio_download->priv->input), download->priv->downloaded_size, G_SEEK_SET, NULL, NULL)) {
read_input_stream (download);
return;
}
}
g_file_replace_async (download->priv->local_file, NULL, FALSE, 0, G_PRIORITY_DEFAULT,
NULL, on_file_replace_ready, download);
}
/*
* et_ogg_seek_func:
* @datasource: the Ogg parser state
* @offset: the number of bytes to seek
* @whence: either %SEEK_SET, %SEEK_CUR or %SEEK_END
*
* Seek in the currently-open Ogg file.
*
* Returns: 0 on success, -1 and sets errno on error
*/
static int
et_ogg_seek_func (void *datasource, ogg_int64_t offset, int whence)
{
EtOggState *state = (EtOggState *)datasource;
GSeekType seektype;
if (!g_seekable_can_seek (G_SEEKABLE (state->istream)))
{
return -1;
}
else
{
switch (whence)
{
case SEEK_SET:
seektype = G_SEEK_SET;
break;
case SEEK_CUR:
seektype = G_SEEK_CUR;
break;
case SEEK_END:
seektype = G_SEEK_END;
break;
default:
errno = EINVAL;
return -1;
}
if (g_seekable_seek (G_SEEKABLE (state->istream), offset, seektype,
NULL, &state->error))
{
return 0;
}
else
{
errno = EBADF;
return -1;
}
}
}
static gboolean
trash_backend_seek_on_read (GVfsBackend *backend,
GVfsJobSeekRead *job,
GVfsBackendHandle handle,
goffset offset,
GSeekType type)
{
GError *error = NULL;
if (g_seekable_seek (handle, offset, type, NULL, &error))
{
g_vfs_job_seek_read_set_offset (job, g_seekable_tell (handle));
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
return TRUE;
}
static int
ddb_gvfs_seek (DB_FILE *stream, int64_t offset, int whence)
{
vfs_gvfs_data_t *data = (vfs_gvfs_data_t *) stream;
g_return_val_if_fail (data != NULL, -1);
if (!g_seekable_can_seek (G_SEEKABLE (data->handle)))
return -1;
g_return_val_if_fail (! g_input_stream_is_closed (data->handle), -1);
GSeekType seektype;
switch (whence) {
case SEEK_CUR:
seektype = G_SEEK_CUR;
break;
case SEEK_END:
seektype = G_SEEK_END;
break;
default:
seektype = G_SEEK_SET;
break;
}
GError *error = NULL;
if (g_seekable_seek (G_SEEKABLE (data->handle), offset, seektype, NULL, &error))
return 0;
g_warning ("Could not seek: %s", error->message);
g_error_free (error);
return -1;
}
/* Called from gpgme to seek a file */
static off_t
input_seek (void *handle, off_t offset, int whence)
{
GSeekable *seek;
GSeekType from;
GError *err = NULL;
GInputStream* input = handle;
g_return_val_if_fail (G_IS_INPUT_STREAM (input), -1);
if (!G_IS_SEEKABLE (input)) {
errno = EOPNOTSUPP;
return -1;
}
switch(whence)
{
case SEEK_SET:
from = G_SEEK_SET;
break;
case SEEK_CUR:
from = G_SEEK_CUR;
break;
case SEEK_END:
from = G_SEEK_END;
break;
default:
g_assert_not_reached();
break;
};
seek = G_SEEKABLE (input);
if (!g_seekable_seek (seek, offset, from, NULL, &err))
return handle_gio_error (err);
return offset;
}
