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