示例#1
0
static GInputStream *
rsvg_acquire_gvfs_stream (const char *uri, 
                          const char *base_uri, 
                          char **out_mime_type,
                          GCancellable *cancellable,
                          GError **error)
{
    GFile *base, *file;
    GFileInputStream *stream;
    GError *err = NULL;

    file = g_file_new_for_uri (uri);

    stream = g_file_read (file, cancellable, &err);
    g_object_unref (file);

    if (stream == NULL &&
        g_error_matches (err, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
        g_clear_error (&err);

        base = g_file_new_for_uri (base_uri);
        file = g_file_resolve_relative_path (base, uri);
        g_object_unref (base);

        stream = g_file_read (file, cancellable, &err);
        g_object_unref (file);
    }

    if (stream == NULL) {
        g_propagate_error (error, err);
        return NULL;
    }

    if (out_mime_type) {
        GFileInfo *file_info;
        const char *content_type;

        file_info = g_file_input_stream_query_info (stream, 
                                                    G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
                                                    cancellable,
                                                    NULL /* error */);
        if (file_info &&
            (content_type = g_file_info_get_content_type (file_info)))
            *out_mime_type = g_content_type_get_mime_type (content_type);
        else
            *out_mime_type = NULL;

        if (file_info)
            g_object_unref (file_info);
    }

    return G_INPUT_STREAM (stream);
}
示例#2
0
/**
 * pk_package_sack_add_packages_from_file:
 * @sack: a valid #PkPackageSack instance
 * @file: a valid package-list file
 * @error: a %GError to put the error code and message in, or %NULL
 *
 * Adds packages from package-list file to a PkPackageSack.
 *
 * Return value: %TRUE if there were no errors.
 *
 **/
gboolean
pk_package_sack_add_packages_from_file (PkPackageSack *sack,
					GFile *file,
					GError **error)
{
	GError *error_local = NULL;
	g_autoptr(GFileInputStream) is = NULL;
	g_autoptr(GDataInputStream) input = NULL;

	g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE);

	is = g_file_read (file, NULL, &error_local);
	if (is == NULL) {
		g_propagate_error (error, error_local);
		return FALSE;
	}

	input = g_data_input_stream_new (G_INPUT_STREAM (is));

	/* read package info file line by line */
	while (TRUE) {
		gchar *line;
		line = g_data_input_stream_read_line (input, NULL, NULL, NULL);
		if (line == NULL)
			break;
		g_strstrip (line);
		if (!pk_package_sack_add_packages_from_line (sack, line, error))
			return FALSE;
	}
	return TRUE;
}
static void
read_file (GFile *scratch_file)
{
  GInputStream *input_stream;
  GError       *error = NULL;
  gint          i;

  input_stream = (GInputStream *) g_file_read (scratch_file, NULL, &error);
  if (!input_stream)
    {
      g_printerr ("Failed to open scratch file: %s\n", error->message);
      return;
    }

  for (i = 0; i < FILE_SIZE; i += BUFFER_SIZE)
    {
      gchar buffer [BUFFER_SIZE];
      gsize bytes_read;

      if (!g_input_stream_read_all (input_stream, buffer, BUFFER_SIZE, &bytes_read, NULL, &error) ||
          bytes_read < BUFFER_SIZE)
        {
          g_printerr ("Failed to read back scratch file: %s\n", error->message);
          g_input_stream_close (input_stream, NULL, NULL);
          g_object_unref (input_stream);
        }
    }

  g_object_unref (input_stream);
}
示例#4
0
static gboolean
do_hash_job_incoming (GIOSchedulerJob *job,
    GCancellable *cancellable,
    gpointer user_data)
{
  HashingData *hash_data = user_data;
  EmpathyFTHandler *handler = hash_data->handler;
  EmpathyFTHandlerPriv *priv = handler->priv;
  GError *error = NULL;

  DEBUG ("checking integrity for incoming handler");

  /* need to get the stream first */
  hash_data->stream =
    G_INPUT_STREAM (g_file_read (priv->gfile, cancellable, &error));

  if (error != NULL)
    {
      hash_data->error = error;
      #pragma GCC diagnostic push
      #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      g_io_scheduler_job_send_to_mainloop_async (job, hash_job_done,
          hash_data, NULL);
      #pragma GCC diagnostic pop
      return FALSE;
    }

  return do_hash_job (job, cancellable, user_data);
}
static gboolean
do_hash_job_incoming (GIOSchedulerJob *job,
    GCancellable *cancellable,
    gpointer user_data)
{
  HashingData *hash_data = user_data;
  EmpathyFTHandler *handler = hash_data->handler;
  EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
  GError *error = NULL;

  DEBUG ("checking integrity for incoming handler");

  /* need to get the stream first */
  hash_data->stream =
    G_INPUT_STREAM (g_file_read (priv->gfile, cancellable, &error));

  if (error != NULL)
    {
      hash_data->error = error;
      g_io_scheduler_job_send_to_mainloop_async (job, hash_job_done,
          hash_data, NULL);
      return FALSE;
    }

  return do_hash_job (job, cancellable, user_data);
}
示例#6
0
gboolean
_rpmostree_util_update_checksum_from_file (GChecksum    *checksum,
                                           GFile        *src,
                                           GCancellable *cancellable,
                                           GError      **error)
{
  gboolean ret = FALSE;
  gsize bytes_read;
  char buf[4096];
  gs_unref_object GInputStream *filein = NULL;

  filein = (GInputStream*)g_file_read (src, cancellable, error);
  if (!filein)
    goto out;

  do
    {
      if (!g_input_stream_read_all (filein, buf, sizeof(buf), &bytes_read,
                                    cancellable, error))
        goto out;

      g_checksum_update (checksum, (guint8*)buf, bytes_read);
    }
  while (bytes_read > 0);

  ret = TRUE;
 out:
  return ret;
}
示例#7
0
static GdkPixbuf *
about_dialog_load_logo (void)
{
  GdkPixbuf    *pixbuf = NULL;
  GFile        *file;
  GInputStream *input;

  file = gimp_data_directory_file ("images",
#ifdef GIMP_UNSTABLE
                                   "gimp-devel-logo.png",
#else
                                   "gimp-logo.png",
#endif
                                   NULL);

  input = G_INPUT_STREAM (g_file_read (file, NULL, NULL));
  g_object_unref (file);

  if (input)
    {
      pixbuf = gdk_pixbuf_new_from_stream (input, NULL, NULL);
      g_object_unref (input);
    }

  return pixbuf;
}
示例#8
0
/**
 * mongo_bson_stream_load_from_file:
 * @stream: (in): A #MongoBsonStream.
 * @file: (in): A #GFile containing the BSON stream.
 * @cancellable: (in) (allow-none): A #GCancellable or %NULL.
 * @error: (out): A location for a #GError, or %NULL.
 *
 * Load a #GFile containing a BSON stream to be used for iterating BSON
 * documents.
 *
 * Returns: %TRUE if successful; otherwise %FALSE and @error is set.
 */
gboolean
mongo_bson_stream_load_from_file (MongoBsonStream  *stream,
                                  GFile            *file,
                                  GCancellable     *cancellable,
                                  GError          **error)
{
   MongoBsonStreamPrivate *priv;
   GFileInputStream *file_stream;

   g_return_val_if_fail(MONGO_IS_BSON_STREAM(stream), FALSE);
   g_return_val_if_fail(G_IS_FILE(file), FALSE);
   g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);

   priv = stream->priv;

   if (priv->stream || priv->channel) {
      g_set_error(error, MONGO_BSON_STREAM_ERROR,
                  MONGO_BSON_STREAM_ERROR_ALREADY_LOADED,
                  _("Cannot load stream, one is already loaded."));
      return FALSE;
   }

   if (!(file_stream = g_file_read(file, cancellable, error))) {
      return FALSE;
   }

   priv->stream = G_INPUT_STREAM(file_stream);

   return TRUE;
}
示例#9
0
void
sourceview_io_open (SourceviewIO* sio, GFile* file)
{
	GFileInputStream* input_stream;
	GError* err = NULL;

	g_return_if_fail (file != NULL);

	if (sio->file)
		g_object_unref (sio->file);
	sio->file = file;
	g_object_ref (sio->file);
	set_display_name(sio);

	input_stream = g_file_read (file, NULL, &err);
	if (!input_stream)
	{
		g_signal_emit_by_name (sio, "open-failed", err);
		g_error_free (err);
		return;
	}
	sio->read_buffer = g_realloc (sio->read_buffer, READ_SIZE);
	g_input_stream_read_async (G_INPUT_STREAM (input_stream),
							   sio->read_buffer,
							   READ_SIZE,
							   G_PRIORITY_LOW,
							   sio->cancel,
							   on_read_finished,
							   sio);
}
IOChannel::IOChannel(const String& filePath, Type type)
    : m_path(filePath)
    , m_type(type)
{
    auto path = WebCore::fileSystemRepresentation(filePath);
    GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(path.data()));
    switch (m_type) {
    case Type::Create: {
        g_file_delete(file.get(), nullptr, nullptr);
        m_outputStream = adoptGRef(G_OUTPUT_STREAM(g_file_create(file.get(), static_cast<GFileCreateFlags>(G_FILE_CREATE_PRIVATE), nullptr, nullptr)));
        ASSERT(m_outputStream);
        GUniquePtr<char> birthtimeString(g_strdup_printf("%" G_GUINT64_FORMAT, std::chrono::system_clock::to_time_t(std::chrono::system_clock::now())));
        g_file_set_attribute_string(file.get(), "xattr::birthtime", birthtimeString.get(), G_FILE_QUERY_INFO_NONE, nullptr, nullptr);
        break;
    }
    case Type::Write: {
        m_ioStream = adoptGRef(g_file_open_readwrite(file.get(), nullptr, nullptr));
        ASSERT(m_ioStream);
        break;
    }
    case Type::Read:
        m_inputStream = adoptGRef(G_INPUT_STREAM(g_file_read(file.get(), nullptr, nullptr)));
        ASSERT(m_inputStream);
        break;
    }
}
示例#11
0
/**
 * Create file stream and set mime type for channel
 * @param info file info used to determine mime type
 * @return NS_OK when file stream created successfuly, error code otherwise
 */
nsresult
nsGIOInputStream::DoOpenFile(GFileInfo *info)
{
  GError *error = nullptr;

  mStream = g_file_read(mHandle, nullptr, &error);
  if (!mStream) {
    nsresult rv = MapGIOResult(error);
    g_warning("Cannot read from file: %s", error->message);
    g_error_free(error);
    return rv;
  }

  const char * content_type = g_file_info_get_content_type(info);
  if (content_type) {
    char *mime_type = g_content_type_get_mime_type(content_type);
    if (mime_type) {
      if (strcmp(mime_type, APPLICATION_OCTET_STREAM) != 0) {
        SetContentTypeOfChannel(mime_type);
      }
      g_free(mime_type);
    }
  } else {
    g_warning("Missing content type.");
  }

  mBytesRemaining = g_file_info_get_size(info);
  // Update the content length attribute on the channel.  We do this
  // synchronously without proxying.  This hack is not as bad as it looks!
  mChannel->SetContentLength(mBytesRemaining);

  return NS_OK;
}
示例#12
0
static GstylePalette *
gstyle_palette_new_from_gpl (GFile         *file,
                             GCancellable  *cancellable,
                             GError       **error)
{
  g_autoptr(GDataInputStream) data_stream = NULL;
  g_autoptr (GInputStream) stream = NULL;
  GstylePalette *palette = NULL;
  g_autofree gchar *palette_name = NULL;
  g_autofree gchar *id = NULL;
  GstyleColor *color;
  gchar *color_name;
  GdkRGBA rgba;
  GError *tmp_error = NULL;
  gint line_count = 1;
  gboolean has_colors = FALSE;

  g_assert (G_IS_FILE (file));

  if ((stream = G_INPUT_STREAM (g_file_read (file, cancellable, &tmp_error))))
    {
      data_stream = g_data_input_stream_new (stream);
      if (read_gpl_header (data_stream, &palette_name, &line_count, &tmp_error))
        {
          id = g_strcanon (g_strdup (palette_name), GSTYLE_PALETTE_ID_CHARSET, '_');
          palette = g_object_new (GSTYLE_TYPE_PALETTE,
                                 "id", id,
                                 "name", palette_name,
                                 "file", file,
                                 NULL);

          while (read_gpl_color_line (data_stream, &rgba, &color_name, &line_count, &tmp_error))
            {
              has_colors = TRUE;
              color = gstyle_color_new_from_rgba (color_name, GSTYLE_COLOR_KIND_RGB_HEX6, &rgba);
              gstyle_palette_add (palette, color, &tmp_error);
              g_object_unref (color);
              g_free (color_name);
              if (tmp_error != NULL)
                break;
            }
        }
    }

  if (tmp_error == NULL && !has_colors)
    {
      g_autofree gchar *uri = g_file_get_uri (file);

      g_set_error (&tmp_error, GSTYLE_PALETTE_ERROR, GSTYLE_PALETTE_ERROR_EMPTY,
                   _("%s: palette is empty\n"), uri);
    }

  if (tmp_error != NULL)
    {
      g_clear_object (&palette);
      g_propagate_error (error, tmp_error);
    }

  return palette;
}
示例#13
0
static void
load_file (GTask               *task,
           MetaBackgroundImage *image,
           gpointer             task_data,
           GCancellable        *cancellable)
{
  GError *error = NULL;
  GdkPixbuf *pixbuf;
  GFileInputStream *stream;

  stream = g_file_read (image->file, NULL, &error);
  if (stream == NULL)
    {
      g_task_return_error (task, error);
      return;
    }

  pixbuf = gdk_pixbuf_new_from_stream (G_INPUT_STREAM (stream), NULL, &error);
  g_object_unref (stream);

  if (pixbuf == NULL)
    {
      g_task_return_error (task, error);
      return;
    }

  g_task_return_pointer (task, pixbuf, (GDestroyNotify) g_object_unref);
}
示例#14
0
static GList *
parse_keyboards (const gchar *path, GError **error)
{
    KeyboardsParseData *data;
    GMarkupParseContext *pcontext;
    GFile *file;
    GFileInputStream *input;
    GList *keyboards;
    gboolean retval;

    file = g_file_new_for_path (path);

    input = g_file_read (file, NULL, error);
    g_object_unref (file);
    if (input == NULL)
        return NULL;

    data = keyboards_parse_data_new ();
    pcontext = g_markup_parse_context_new (&keyboards_parser,
                                           0,
                                           data,
                                           NULL);
    retval = parse (pcontext, G_INPUT_STREAM (input), error);
    g_object_unref (input);
    g_markup_parse_context_free (pcontext);
    if (!retval) {
        keyboards_parse_data_free (data);
        return NULL;
    }

    keyboards = data->keyboards;
    data->keyboards = NULL;
    keyboards_parse_data_free (data);
    return keyboards;
}
示例#15
0
static guint16 *
read_file_to_buffer (const gchar *name, gsize count, GError *e)
{
  GError *error = NULL;
  guint16 *depth = NULL;
  GFile *new_file = g_file_new_for_path (name);
  GFileInputStream *input_stream = g_file_read (new_file,
                                                NULL,
                                                &error);
  if (error != NULL)
    {
      g_debug ("ERROR: %s", error->message);
    }
  else
    {
      gsize bread = 0;
      depth = g_slice_alloc (count);
      g_input_stream_read_all ((GInputStream *) input_stream,
                               depth,
                               count,
                               &bread,
                               NULL,
                               &error);

      if (error != NULL)
        {
          g_debug ("ERROR: %s", error->message);
        }
    }
  return depth;
}
示例#16
0
static gboolean
parse_symbols (const gchar *path, EekKeyboard *keyboard, GError **error)
{
    SymbolsParseData *data;
    GMarkupParseContext *pcontext;
    GFile *file;
    GFileInputStream *input;
    gboolean retval;

    file = g_file_new_for_path (path);

    input = g_file_read (file, NULL, error);
    g_object_unref (file);
    if (input == NULL)
        return FALSE;

    data = symbols_parse_data_new (keyboard);
    pcontext = g_markup_parse_context_new (&symbols_parser,
                                           0,
                                           data,
                                           NULL);
    retval = parse (pcontext, G_INPUT_STREAM (input), error);
    g_markup_parse_context_free (pcontext);
    g_object_unref (input);
    if (!retval) {
        symbols_parse_data_free (data);
        return FALSE;
    }
    symbols_parse_data_free (data);
    return TRUE;
}
示例#17
0
static GList *
parse_prerequisites (const gchar *path, GError **error)
{
    PrerequisitesParseData *data;
    GMarkupParseContext *pcontext;
    GFile *file;
    GFileInputStream *input;
    GList *prerequisites;
    gboolean retval;

    file = g_file_new_for_path (path);

    input = g_file_read (file, NULL, error);
    g_object_unref (file);
    if (input == NULL)
        return FALSE;

    data = prerequisites_parse_data_new ();
    pcontext = g_markup_parse_context_new (&prerequisites_parser,
                                           0,
                                           data,
                                           NULL);
    retval = parse (pcontext, G_INPUT_STREAM (input), error);
    g_markup_parse_context_free (pcontext);
    g_object_unref (input);
    if (!retval) {
        prerequisites_parse_data_free (data);
        return NULL;
    }
    prerequisites = data->prerequisites;
    data->prerequisites = NULL;
    prerequisites_parse_data_free (data);
    return prerequisites;
}
示例#18
0
static gboolean
dump_data (GFile *file,
           struct archive *archive,
           GCancellable               *cancellable,
           GError                    **error)
{
  char buffer[32*1024];
  g_autoptr(GFileInputStream) in = NULL;
  gssize in_buffer;

  in = g_file_read (file, cancellable, error);
  if (in == NULL)
    return FALSE;

  while (TRUE)
    {
      in_buffer = g_input_stream_read (G_INPUT_STREAM (in), buffer, sizeof (buffer), cancellable, error);
      if (in_buffer == -1)
        return FALSE;

      if (in_buffer == 0)
        break;

      if (archive_write_data (archive, buffer, in_buffer) < ARCHIVE_OK)
        return xdg_app_fail (error, "Can't write tar data");
    }

  return TRUE;
}
示例#19
0
static gchar *readall(const gchar *path, GError **error)
{
    GFile *f = g_file_new_for_path(path);
    GFileInputStream *fis = NULL;
    GFileInfo *info;
    int len;
    gchar *ret = NULL;

    if (!(info = g_file_query_info(f, "standard::*",
                                   G_FILE_QUERY_INFO_NONE,
                                   NULL, error)))
        goto cleanup;

    len = g_file_info_get_size(info);
    ret = g_new0(gchar, len+1);
    if (!(fis = g_file_read(f, NULL, error)))
        goto cleanup;

    if (!g_input_stream_read_all(G_INPUT_STREAM(fis), ret, len, NULL, NULL, error))
        goto cleanup;
    ret[len] = '\0';

    *error = NULL;

cleanup:
    if (*error) {
        g_free(ret);
        ret = NULL;
    }
    g_object_unref(f);
    if (fis)
        g_object_unref(fis);
    return ret;
}
示例#20
0
int
main (int argc, char **argv)
{
    GConverter *converter;
    GFile *file;
    GFileInputStream *file_stream;
    GInputStream *stream;
    gchar buf[1024];
    gssize bytes;
        
    if (argc < 2) {
        g_printerr ("Usage: test-bz2 FILE\n");
        return 1;
    }

    file = g_file_new_for_path (argv[1]);
    file_stream = g_file_read (file, NULL, NULL);
    converter = G_CONVERTER (yelp_bz2_decompressor_new ());
    stream = g_converter_input_stream_new (G_INPUT_STREAM (file_stream),
                                           converter);

    while ((bytes = g_input_stream_read (stream, buf, 1024, NULL, NULL)) > 0) {
        gchar *out = g_strndup (buf, bytes);
        puts (out);
        g_free (out);
    }

    return 0;
}
示例#21
0
static void _configfile (CustomData *data, gboolean writemode) {
    gchar *filename = g_strdup_printf("file://%s/.4deckradio", g_get_home_dir());
    g_print ("config file: %s\n", filename);
    GFile *file = g_file_new_for_uri (filename);

    if (TRUE == writemode) {
        /* Save the last folder locations to ~/.4deckradio */
        GString *configstring = g_string_new("");
        for (int i=0; i < NUM_PLAYERS; i++) {
            g_print ("deck %i folder %s\n", i, data[i].last_folder_uri);
            g_string_append_printf (configstring, "%s\n", data[i].last_folder_uri);
        }

        g_file_replace_contents (file,
                configstring->str,
                configstring->len,
                NULL, /* old etag */
                FALSE, /* backup */
                G_FILE_CREATE_PRIVATE,
                NULL, /* new etag */
                NULL, /* cancellable */
                NULL);
        g_string_free (configstring, TRUE);
    } else {
        /* load config file */
        GFileInputStream *inputstream = g_file_read (file,
                NULL,
                NULL);
        if (NULL == inputstream) {
            return;
        }

        GDataInputStream *config = g_data_input_stream_new (G_INPUT_STREAM (inputstream));

        if (NULL == config) {
            return;
        }


        GError *error = NULL;

        for (int i = 0; i < NUM_PLAYERS; i++) {
            gsize length;
            data[i].last_folder_uri =
                g_data_input_stream_read_line_utf8(config, &length, NULL, &error);
            if (NULL != error) {
                g_print ("Error reading config file: %s\n", error->message);
            }
            g_clear_error (&error);
            g_print ("Will use %s for deck %i\n", data[i].last_folder_uri, i);
        }

        g_input_stream_close (G_INPUT_STREAM (config), NULL, NULL);
        g_input_stream_close (G_INPUT_STREAM (inputstream), NULL, NULL);
        g_object_unref (config);
        g_object_unref (inputstream);
    }
    g_free (filename);
    g_object_unref (file);
}
/**
 * camel_stream_vfs_new_with_uri:
 * @uri: a file uri
 * @mode: opening mode for the uri file
 *
 * Creates a new #CamelStreamVFS corresponding to the named file and mode.
 *
 * Returns the new stream, or %NULL on error.
 **/
CamelStream *
camel_stream_vfs_new_with_uri (const char *uri, CamelStreamVFSOpenMethod mode)
{
	GFile *file;
	GObject *stream;
	GError *error = NULL;

	file = g_file_new_for_uri (uri);

	switch (mode) {
		case CAMEL_STREAM_VFS_CREATE:
			stream = G_OBJECT (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error));
			break;
		case CAMEL_STREAM_VFS_APPEND:
			stream = G_OBJECT (g_file_append_to (file, G_FILE_CREATE_NONE, NULL, &error));
			break;
		case CAMEL_STREAM_VFS_READ:
			stream = G_OBJECT (g_file_read (file, NULL, &error));
			break;
		default:
			errno = EINVAL;
			g_return_val_if_reached (NULL);
	}

	g_object_unref (file);

	if (error) {
		errno = error->code;
		g_warning ("%s", error->message);
		g_error_free (error);
		return NULL;
	}

	return camel_stream_vfs_new_with_stream (stream);
}
示例#23
0
文件: gdktexture.c 项目: GNOME/gtk
/**
 * gdk_texture_new_from_file:
 * @file: #GFile to load
 * @error: Return location for an error
 *
 * Creates a new texture by loading an image from a file.  The file format is
 * detected automatically. If %NULL is returned, then @error will be set.
 *
 * Return value: A newly-created #GdkTexture or %NULL if an error occured.
 **/
GdkTexture *
gdk_texture_new_from_file (GFile   *file,
                           GError **error)
{
  GdkTexture *texture;
  GdkPixbuf *pixbuf;
  GInputStream *stream;

  g_return_val_if_fail (G_IS_FILE (file), NULL);
  g_return_val_if_fail (error == NULL || *error == NULL, NULL);

  stream = G_INPUT_STREAM (g_file_read (file, NULL, error));
  if (stream == NULL)
    return NULL;

  pixbuf = gdk_pixbuf_new_from_stream (stream, NULL, error);
  g_object_unref (stream);
  if (pixbuf == NULL)
    return NULL;

  texture = gdk_texture_new_for_pixbuf (pixbuf);
  g_object_unref (pixbuf);

  return texture;
}
gboolean
_ostree_static_delta_part_validate (OstreeRepo     *repo,
                                    GFile          *part_path,
                                    guint           part_offset,
                                    const char     *expected_checksum,
                                    GCancellable   *cancellable,
                                    GError        **error)
{
  gboolean ret = FALSE;
  gs_unref_object GInputStream *tmp_in = NULL;
  gs_free guchar *actual_checksum_bytes = NULL;
  gs_free gchar *actual_checksum = NULL;
  
  tmp_in = (GInputStream*)g_file_read (part_path, cancellable, error);
  if (!tmp_in)
    goto out;
  
  if (!ot_gio_checksum_stream (tmp_in, &actual_checksum_bytes,
                               cancellable, error))
    goto out;

  actual_checksum = ostree_checksum_from_bytes (actual_checksum_bytes);
  if (strcmp (actual_checksum, expected_checksum) != 0)
    {
      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                   "Checksum mismatch in static delta part %u; expected=%s actual=%s",
                   part_offset, expected_checksum, actual_checksum);
      goto out;
    }
  
  ret = TRUE;
 out:
  return ret;
}
示例#25
0
GdkPixbuf *
eel_gdk_pixbuf_load (const char *uri)
{
    GdkPixbuf *pixbuf;
    GFile *file;
    GFileInputStream *stream;

    g_return_val_if_fail (uri != NULL, NULL);

    file = g_file_new_for_uri (uri);

    stream = g_file_read (file, NULL, NULL);

    g_object_unref (file);

    if (stream == NULL)
    {
        return NULL;
    }

    pixbuf = eel_gdk_pixbuf_load_from_stream (G_INPUT_STREAM (stream));

    g_object_unref (stream);

    return pixbuf;
}
static gboolean send_files (NstPlugin *plugin, GtkWidget *contact_widget, GList *file_list)
{
	GList *l;
	for (l = file_list; l != NULL; l = l->next)
	{
		// Open file
		GError *error = NULL;
		GFile *source = g_file_new_for_commandline_arg (l->data);
		GFileInputStream *in = g_file_read (source, NULL, &error);
		if (!in)
		{
			handle_error(error, "could not get input stream for file");
			g_object_unref (source);
			return FALSE;
		}

		// Read file contents
		GByteArray *data = g_byte_array_new ();
		guint8 buffer[1024];
		gssize len = g_input_stream_read (G_INPUT_STREAM(in), buffer, 1024, NULL, &error);
		while (len > 0)
		{
			g_byte_array_append (data, buffer, len);
			len = g_input_stream_read (G_INPUT_STREAM(in), buffer, 1024, NULL, &error);
		}
		if (len < 0)
		{
			handle_error(error, "could not read file");
			g_byte_array_free (data, TRUE);
			g_object_unref (in);
			g_object_unref (source);
			return FALSE;
		}

		// XMLRPC request to attach the file to the ticket
		GValue result;
		gchar *err = send_xmlrpc(gtk_entry_get_text(GTK_ENTRY(url_field)), "ticket.putAttachment", &result,
				G_TYPE_INT, strtol(gtk_entry_get_text(GTK_ENTRY(ticket_field)), NULL, 10),
				G_TYPE_STRING, g_file_get_basename(source),
				G_TYPE_STRING, gtk_entry_get_text(GTK_ENTRY(description_field)),
				SOUP_TYPE_BYTE_ARRAY, data,
				G_TYPE_BOOLEAN, TRUE,
				G_TYPE_INVALID);

		g_byte_array_free (data, TRUE);
		g_object_unref (in);

		if (err)
		{
			handle_error(NULL, err);
			g_free (err);
			g_object_unref (source);
			return FALSE;
		}
		g_object_unref (source);
	}

	return TRUE;
}
示例#27
0
bool ImageHandler::insertImage(GFile * file, double x, double y) {
	XOJ_CHECK_TYPE(ImageHandler);

	GError * err = NULL;
	GFileInputStream * in = g_file_read(file, NULL, &err);

	g_object_unref(file);

	GdkPixbuf * pixbuf = NULL;

	if (!err) {
		pixbuf = gdk_pixbuf_new_from_stream(G_INPUT_STREAM(in), NULL, &err);
		g_input_stream_close(G_INPUT_STREAM(in), NULL, NULL);
	} else {
		GtkWidget * dialog = gtk_message_dialog_new((GtkWindow*) *control->getWindow(), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
				_("This image could not be loaded. Error message: %s"), err->message);
		gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(this->control->getWindow()->getWindow()));
		gtk_dialog_run(GTK_DIALOG(dialog));
		gtk_widget_destroy(dialog);
		g_error_free(err);
		return false;
	}

	Image * img = new Image();
	img->setX(x);
	img->setY(y);
	img->setImage(pixbuf);

	int width = gdk_pixbuf_get_width(pixbuf);
	int height = gdk_pixbuf_get_height(pixbuf);
	gdk_pixbuf_unref(pixbuf);

	double zoom = 1;

	PageRef page = view->getPage();

	if (x + width > page.getWidth() || y + height > page.getHeight()) {
		double maxZoomX = (page.getWidth() - x) / width;
		double maxZoomY = (page.getHeight() - y) / height;

		if (maxZoomX < maxZoomY) {
			zoom = maxZoomX;
		} else {
			zoom = maxZoomY;
		}
	}

	img->setWidth(width * zoom);
	img->setHeight(height * zoom);

	page.getSelectedLayer()->addElement(img);

	InsertUndoAction * insertUndo = new InsertUndoAction(page, page.getSelectedLayer(), img, view);
	control->getUndoRedoHandler()->addUndoAction(insertUndo);

	view->rerenderElement(img);

	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);
}
示例#29
0
/* send a chunk of the file from server to client */
static int 
clipboard_send_file_data(int streamId, int lindex,
                         int nPositionLow, int cbRequested)
{
    struct stream *s;
    int size;
    int rv;
    int fd;
    char full_fn[256];
    struct cb_file_info *cfi;

    if (g_files_list == 0)
    {
        LLOGLN(10, ("clipboard_send_file_data: error g_files_list is nil"));
        return 1;
    }
    cfi = (struct cb_file_info *)list_get_item(g_files_list, lindex);
    if (cfi == 0)
    {
        LLOGLN(10, ("clipboard_send_file_data: error cfi is nil"));
        return 1;
    }
    LLOGLN(10, ("clipboard_send_file_data: streamId %d lindex %d "
                "nPositionLow %d cbRequested %d", streamId, lindex,
                nPositionLow, cbRequested));
    g_snprintf(full_fn, 255, "%s/%s", cfi->pathname, cfi->filename);
    fd = g_file_open_ex(full_fn, 1, 0, 0, 0);
    if (fd == -1)
    {
        LLOGLN(0, ("clipboard_send_file_data: file open [%s] failed",
                   full_fn));
        return 1;
    }
    g_file_seek(fd, nPositionLow);
    make_stream(s);
    init_stream(s, cbRequested + 64);
    size = g_file_read(fd, s->data + 12, cbRequested);
    if (size < 1)
    {
        LLOGLN(0, ("clipboard_send_file_data: read error, want %d got %d",
                   cbRequested, size));
        free_stream(s);
        g_file_close(fd);
        return 1;
    }
    out_uint16_le(s, CB_FILECONTENTS_RESPONSE); /* 9 */
    out_uint16_le(s, CB_RESPONSE_OK); /* 1 status */
    out_uint32_le(s, size + 4);
    out_uint32_le(s, streamId);
    s->p += size;
    out_uint32_le(s, 0);
    s_mark_end(s);
    size = (int)(s->end - s->data);
    rv = send_channel_data(g_cliprdr_chan_id, s->data, size);
    free_stream(s);
    g_file_close(fd);
    return rv;
}
示例#30
0
static gpointer
stlink_gui_populate_filemem_view (STlinkGUI *gui)
{
	guchar        buffer[MEM_READ_SIZE];
	GFile        *file;
	GFileInfo    *file_info;
	GInputStream *input_stream;
	gint          off;
	GError       *err = NULL;

	g_return_val_if_fail (gui != NULL, NULL);
	g_return_val_if_fail (gui->filename != NULL, NULL);

	file = g_file_new_for_path (gui->filename);
	input_stream = G_INPUT_STREAM (g_file_read (file, NULL, &err));
	if (err) {
		stlink_gui_set_info_error_message (gui, err->message);
		g_error_free (err);
		goto out;
	}

	file_info = g_file_input_stream_query_info (G_FILE_INPUT_STREAM (input_stream),
	                                            G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &err);
	if (err) {
		stlink_gui_set_info_error_message (gui, err->message);
		g_error_free (err);
		goto out_input;
	}
	if (gui->file_mem.memory) {
		g_free (gui->file_mem.memory);
	}
	gui->file_mem.size   = g_file_info_get_size (file_info);
	gui->file_mem.memory = g_malloc (gui->file_mem.size);

	for (off = 0; off < gui->file_mem.size; off += MEM_READ_SIZE) {
		guint   n_read = MEM_READ_SIZE;

		if (off + MEM_READ_SIZE > gui->file_mem.size) {
			n_read = gui->file_mem.size - off;
		}

		if (g_input_stream_read (G_INPUT_STREAM (input_stream),
		                         &buffer, n_read, NULL, &err) == -1) {
			stlink_gui_set_info_error_message (gui, err->message);
			g_error_free (err);
			goto out_input;
		}
		memcpy (gui->file_mem.memory + off, buffer, n_read);
		gui->progress.fraction = (gdouble) (off + n_read) / gui->file_mem.size;
	}
	g_idle_add ((GSourceFunc) stlink_gui_update_filemem_view, gui);

 out_input:
	g_object_unref (input_stream);
 out:
	g_object_unref (file);
	return NULL;
}