int profibus_serial_open(const char *device, unsigned int rate, GError **err) { int fd = open(device, O_RDWR); if (fd < 0) { g_set_error(err, G_FILE_ERROR, g_file_error_from_errno(errno), "open failed: %s", strerror(errno)); return -1; } if (!set_termios(fd, rate, err)) { close(fd); return -1; } return fd; }
static gboolean save_to_fd (const gchar *buf, gsize count, GError **error, gpointer data) { int fd = GPOINTER_TO_INT (data); gssize written; written = write (fd, buf, count); if (written != (gssize) count) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), "%s", g_strerror (errno)); return FALSE; } return TRUE; }
/* coverity[ -tainted_string_sink_content : arg-0 ] */ GsfInput * gsf_input_stdio_new (char const *filename, GError **err) { GsfInputStdio *input; struct stat st; FILE *file; gsf_off_t size; g_return_val_if_fail (filename != NULL, NULL); file = g_fopen (filename, "rb"); if (file == NULL) { if (err) { int save_errno = errno; char *utf8name = g_filename_display_name (filename); g_set_error (err, G_FILE_ERROR, g_file_error_from_errno (save_errno), "%s: %s", utf8name, g_strerror (save_errno)); g_free (utf8name); } return NULL; } if (fstat (fileno (file), &st) < 0 || !S_ISREG (st.st_mode)) { GsfInput *res = make_local_copy (file, filename, err); fclose (file); return res; } size = st.st_size; input = (GsfInputStdio *)g_object_new (GSF_INPUT_STDIO_TYPE, NULL); if (G_UNLIKELY (NULL == input)) { fclose (file); return NULL; } input->file = file; input->filename = g_strdup (filename); input->buf = NULL; input->buf_size = 0; input->keep_open = FALSE; gsf_input_set_size (GSF_INPUT (input), size); gsf_input_set_name_from_filename (GSF_INPUT (input), filename); return GSF_INPUT (input); }
/** * xfce_posix_signal_handler_set_handler: * @signal_id: A POSIX signal id number. * @handler: A callback function. * @user_data: Arbitrary data that will be passed to @handler. * @error: Location of a #GError to store any possible errors. * * Sets @handler to be called whenever @signal is caught by the * application. The @user_data parameter will be passed as an argument * to @handler. * * Returns: %TRUE on success, %FALSE otherwise, in which case * @error will be set. **/ gboolean xfce_posix_signal_handler_set_handler(gint signal_id, XfcePosixSignalHandler handler, gpointer user_data, GError **error) { XfcePosixSignalHandlerData *hdata; struct sigaction sa; if(G_UNLIKELY(!__inited)) { if(error) { g_set_error(error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("xfce_posix_signal_handler_init() must be called first")); } return FALSE; } if(!handler) { g_warning("NULL signal handler supplied; removing existing handler"); xfce_posix_signal_handler_restore_handler(signal_id); return TRUE; } if(g_hash_table_lookup(__handlers, GINT_TO_POINTER(signal_id))) xfce_posix_signal_handler_restore_handler(signal_id); hdata = g_new0(XfcePosixSignalHandlerData, 1); hdata->signal_id = signal_id; hdata->handler = handler; hdata->user_data = user_data; memset(&sa, 0, sizeof(sa)); sa.sa_handler = xfce_posix_signal_handler; sa.sa_flags = SA_RESTART; if(sigaction(signal_id, &sa, &hdata->old_sa)) { if(error) { g_set_error(error, G_FILE_ERROR, g_file_error_from_errno(errno), _("sigaction() failed: %s\n"), strerror(errno)); } g_free(hdata); return FALSE; } g_hash_table_insert(__handlers, GINT_TO_POINTER(signal_id), hdata); return TRUE; }
/* Creates the certificate directory if it doesn't exist, * returns TRUE if it's successful or it already exists, * returns FALSE if there was an error. */ static gboolean ensure_certificate_dir(GError **error) { gchar *dir = make_certificate_path(NULL); gboolean ret = TRUE; if (purple_build_dir(dir, 0700) != 0) { g_set_error_literal(error, G_FILE_ERROR, g_file_error_from_errno(errno), g_strerror(errno)); ret = FALSE; } g_free(dir); return ret; }
/** * xfae_model_edit: * @model : a #XfaeModel. * @iter : the #GtkTreeIter referring to the item that should be removed. * @name : the user visible name of the new item. * @description : the description for the new item. * @command : the command for the new item. * @error : return locations for errors or %NULL. * * Attempts to edit an item with the given parameters * to @model. * * Return value: %TRUE if successfull, else %FALSE. **/ gboolean xfae_model_edit (XfaeModel *model, GtkTreeIter *iter, const gchar *name, const gchar *description, const gchar *command, GError **error) { GtkTreePath *path; XfaeItem *item; XfceRc *rc; GList *lp; g_return_val_if_fail (XFAE_IS_MODEL (model), FALSE); g_return_val_if_fail (iter->stamp == model->stamp, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); lp = iter->user_data; item = lp->data; /* try to open the resource config */ rc = xfce_rc_config_open (XFCE_RESOURCE_CONFIG, item->relpath, FALSE); if (G_UNLIKELY (rc == NULL)) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (EIO), _("Failed to open %s for writing"), item->relpath); return FALSE; } item->name = g_strdup (name); item->comment = g_strdup (description); /* write the result */ xfce_rc_set_group (rc, "Desktop Entry"); xfce_rc_write_entry (rc, "Name", name); xfce_rc_write_entry (rc, "Comment", description); xfce_rc_write_entry (rc, "Exec", command); xfce_rc_close (rc); /* tell the view that we have most probably a new state */ path = gtk_tree_path_new_from_indices (g_list_position (model->items, lp), -1); gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, iter); gtk_tree_path_free (path); return TRUE; }
/** * xfae_model_get: * @model : a #XfaeModel. * @name : the user visible name of the new item. * @description : the description for the new item. * @command : the command for the new item. * @error : return locations for errors or %NULL. * * Attempts to add a new item with the given parameters * to @model. * * Return value: %TRUE if successfull, else %FALSE. **/ gboolean xfae_model_get (XfaeModel *model, GtkTreeIter *iter, gchar **name, gchar **description, gchar **command, GError **error) { XfaeItem *item; GList *lp; XfceRc *rc; const gchar *value; g_return_val_if_fail (XFAE_IS_MODEL (model), FALSE); g_return_val_if_fail (iter->stamp == model->stamp, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); lp = iter->user_data; item = lp->data; /* try to open the resource config */ rc = xfce_rc_config_open (XFCE_RESOURCE_CONFIG, item->relpath, FALSE); if (G_UNLIKELY (rc == NULL)) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (EIO), _("Failed to open %s for reading"), item->relpath); return FALSE; } /* read the resource config */ value = xfce_rc_read_entry (rc, "Name", NULL); if (name != NULL) *name = g_strdup (value); value = xfce_rc_read_entry (rc, "Comment", NULL); if (description != NULL) *description = g_strdup (value); value = xfce_rc_read_entry (rc, "Exec", NULL); if (command != NULL) *command = g_strdup (value); xfce_rc_close (rc); return TRUE; }
GList * gimp_palette_load_riff (const gchar *filename, GError **error) { GimpPalette *palette; gchar *palette_name; gint fd; guchar color_bytes[4]; g_return_val_if_fail (filename != NULL, NULL); g_return_val_if_fail (g_path_is_absolute (filename), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); fd = g_open (filename, O_RDONLY | _O_BINARY, 0); if (! fd) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), g_strerror (errno)); return NULL; } palette_name = g_filename_display_basename (filename); palette = GIMP_PALETTE (gimp_palette_new (palette_name)); g_free (palette_name); lseek (fd, 28, SEEK_SET); while (read (fd, color_bytes, sizeof (color_bytes)) == 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); } close (fd); return g_list_prepend (NULL, palette); }
/* Utility function */ void psd_set_error (const gboolean file_eof, const gint err_no, GError **error) { if (file_eof) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", _("Unexpected end of file")); } else { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (err_no), "%s", g_strerror (err_no)); } return; }
LJEntry* lj_entry_new_from_filename(const char *filename, LJEntryFileType type, LJEntryFileType *typeret, GError **err) { LJEntry *entry; FILE *f; f = fopen(filename, "r"); if (!f) { g_set_error(err, G_FILE_ERROR, g_file_error_from_errno(errno), _("Error reading file '%s': %s"), filename, g_strerror(errno)); return NULL; } entry = lj_entry_new_from_file(f, type, typeret, err); fclose(f); return entry; }
static GFile * create_snapshot_file (EMsgComposer *composer, GError **error) { GFile *snapshot_file; const gchar *user_data_dir; gchar *path; gint fd; snapshot_file = e_composer_get_snapshot_file (composer); if (G_IS_FILE (snapshot_file)) return snapshot_file; user_data_dir = e_get_user_data_dir (); path = g_build_filename (user_data_dir, SNAPSHOT_FILE_SEED, NULL); /* g_mkstemp() modifies the XXXXXX part of the * template string to form the actual filename. */ errno = 0; fd = g_mkstemp (path); if (fd == -1) { g_set_error ( error, G_FILE_ERROR, g_file_error_from_errno (errno), "%s", g_strerror (errno)); g_free (path); return NULL; } close (fd); snapshot_file = g_file_new_for_path (path); /* Save the GFile for subsequent snapshots. */ g_object_set_data_full ( G_OBJECT (composer), SNAPSHOT_FILE_KEY, snapshot_file, (GDestroyNotify) delete_snapshot_file); g_free (path); return snapshot_file; }
static GdkPixbuf * icns_image_load (FILE *f, GError ** error) { GByteArray *data; GdkPixbuf *pixbuf = NULL; guint i; data = g_byte_array_new (); while (!feof (f)) { gint save_errno; guchar buf[4096]; gsize bytes; bytes = fread (buf, 1, sizeof (buf), f); save_errno = errno; data = g_byte_array_append (data, buf, bytes); if (ferror (f)) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Error reading ICNS image: %s"), g_strerror (save_errno)); g_byte_array_free (data, TRUE); return NULL; } } for (i = 0; i < G_N_ELEMENTS(sizes) && !pixbuf; i++) pixbuf = load_icon (sizes[i], data->data, data->len); g_byte_array_free (data, TRUE); if (!pixbuf) g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Could not decode ICNS file")); return pixbuf; }
gboolean xcf_seek_pos (XcfInfo *info, guint pos, GError **error) { if (info->cp != pos) { info->cp = pos; if (fseek (info->fp, info->cp, SEEK_SET) == -1) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not seek in XCF file: %s"), g_strerror (errno)); return FALSE; } } return TRUE; }
static gboolean clutter_md2_data_seek (FILE *file, size_t offset, const gchar *display_name, GError **error) { if (fseek (file, offset, SEEK_SET)) { gint save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), "Error reading '%s': %s", display_name, g_strerror (save_errno)); return FALSE; } else return TRUE; }
static GIOStatus g_io_win32_set_flags (GIOChannel *channel, GIOFlags flags, GError **err) { GIOWin32Channel *win32_channel = (GIOWin32Channel *)channel; if (win32_channel->debug) { g_print ("g_io_win32_set_flags: "); g_win32_print_gioflags (flags); g_print ("\n"); } g_set_error (err, G_IO_CHANNEL_ERROR, g_file_error_from_errno (EACCES), _("Channel set flags unsupported")); return G_IO_STATUS_ERROR; }
gboolean conf_rename_host(JamHost *host, const char *newname, GError **err) { char *oldpath, *newpath; /* disallow: * [empty string] * . * .. * ./../foo * /foo * allow: * .lAmE.sErVeR. */ if ((newname[0] == 0) || (newname[0] == '.' && (newname[1] == '.' || newname[1] == '/' || newname[1] == 0)) || (newname[0] == '/')) { g_set_error(err, 0, 0, _("new host name is invalid")); return FALSE; } oldpath = g_build_filename(app.conf_dir, "servers", host->name, NULL); if (!g_file_test(oldpath, G_FILE_TEST_EXISTS)) { string_replace(&host->name, g_strdup(newname)); g_free(oldpath); return TRUE; } newpath = g_build_filename(app.conf_dir, "servers", newname, NULL); if (rename(oldpath, newpath) < 0) { g_set_error(err, G_FILE_ERROR, g_file_error_from_errno(errno), _("renaming '%s' to '%s': %s"), oldpath, newpath, g_strerror(errno)); g_free(oldpath); g_free(newpath); return FALSE; } string_replace(&host->name, g_strdup(newname)); g_free(oldpath); g_free(newpath); return TRUE; }
static gboolean gdk_pixbuf__xpm_image_load_increment (gpointer data, const guchar *buf, guint size, GError **error) { XPMContext *context = (XPMContext *) data; g_return_val_if_fail (data != NULL, FALSE); if (fwrite (buf, sizeof (guchar), size, context->file) != size) { gint save_errno = errno; context->all_okay = FALSE; g_set_error_literal (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Failed to write to temporary file when loading XPM image")); return FALSE; } return TRUE; }
gboolean gdip_save_to_file_callback (const gchar *buf, gsize count, GError **error, gpointer data) { FILE *filehandle = data; gsize n; n = fwrite (buf, 1, count, filehandle); if (n != count) { gint save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Error writing to image file: %s"), g_strerror (save_errno)); return FALSE; } return TRUE; }
static gchar * create_temp_file (const gchar *directory, const gchar *templ, GError **error) { gchar *path; gint fd; path = g_build_filename (directory, templ, NULL); fd = g_mkstemp (path); if (fd < 0) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), "Couldn't create temporary file: %s: %m", path); g_free (path); return NULL; } close (fd); return path; }
gboolean gimp_contexts_clear (Gimp *gimp, GError **error) { gchar *filename; gboolean success = TRUE; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); filename = gimp_personal_rc_file ("contextrc"); if (g_unlink (filename) != 0 && errno != ENOENT) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Deleting \"%s\" failed: %s"), gimp_filename_to_utf8 (filename), g_strerror (errno)); success = FALSE; } g_free (filename); return success; }
gboolean purple_tls_certificate_distrust(const gchar *id, GError **error) { gchar *path; gboolean ret = TRUE; g_return_val_if_fail(id != NULL && id[0] != '\0', FALSE); /* Delete certificate file if it exists */ path = make_certificate_path(id); if (g_unlink(path) != 0) { g_set_error_literal(error, G_FILE_ERROR, g_file_error_from_errno(errno), g_strerror(errno)); ret = FALSE; } g_free(path); return ret; }
static gboolean composer_autosave_state_open (AutosaveState *state, GError **error) { if (state->filename != NULL) return TRUE; state->filename = g_build_filename ( e_get_user_data_dir (), AUTOSAVE_SEED, NULL); errno = 0; if ((state->fd = g_mkstemp (state->filename)) >= 0) return TRUE; g_set_error ( error, G_FILE_ERROR, g_file_error_from_errno (errno), "%s: %s", state->filename, g_strerror (errno)); g_free (state->filename); state->filename = NULL; return FALSE; }
GDir * g_dir_open (const gchar *path, guint flags, GError **gerror) { GDir *dir; g_return_val_if_fail (path != NULL, NULL); g_return_val_if_fail (gerror == NULL || *gerror == NULL, NULL); (void) flags; /* this is not used */ dir = g_new (GDir, 1); dir->dir = opendir (path); if (dir->dir == NULL) { if (gerror) { gint err = errno; *gerror = g_error_new (G_LOG_DOMAIN, g_file_error_from_errno (err), strerror (err)); } g_free (dir); return NULL; } #ifndef HAVE_REWINDDIR dir->path = g_strdup (path); #endif return dir; }
static gboolean xfae_item_remove (XfaeItem *item, GError **error) { gboolean succeed = TRUE; gchar **files; guint n; /* remove all files that belong to this item */ files = xfce_resource_lookup_all (XFCE_RESOURCE_CONFIG, item->relpath); for (n = 0; files[n] != NULL; ++n) { if (unlink (files[n]) < 0 && errno != ENOENT) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Failed to unlink %s: %s"), files[n], g_strerror (errno)); succeed = FALSE; break; } } g_strfreev (files); return succeed; }
static gboolean get_contents_posix (const gchar *filename, gchar **contents, gsize *length, GError **error) { struct stat stat_buf; gint fd; gchar *display_filename = g_filename_display_name (filename); /* O_BINARY useful on Cygwin */ fd = open (filename, O_RDONLY|O_BINARY); if (fd < 0) { int save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Failed to open file '%s': %s"), display_filename, g_strerror (save_errno)); g_free (display_filename); return FALSE; } /* I don't think this will ever fail, aside from ENOMEM, but. */ if (fstat (fd, &stat_buf) < 0) { int save_errno = errno; close (fd); g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Failed to get attributes of file '%s': fstat() failed: %s"), display_filename, g_strerror (save_errno)); g_free (display_filename); return FALSE; } if (stat_buf.st_size > 0 && S_ISREG (stat_buf.st_mode)) { gboolean retval = get_contents_regfile (display_filename, &stat_buf, fd, contents, length, error); g_free (display_filename); return retval; } else { FILE *f; gboolean retval; f = fdopen (fd, "r"); if (f == NULL) { int save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Failed to open file '%s': fdopen() failed: %s"), display_filename, g_strerror (save_errno)); g_free (display_filename); return FALSE; } retval = get_contents_stdio (display_filename, f, contents, length, error); g_free (display_filename); return retval; } }
static gboolean get_contents_regfile (const gchar *display_filename, struct stat *stat_buf, gint fd, gchar **contents, gsize *length, GError **error) { gchar *buf; gsize bytes_read; gsize size; gsize alloc_size; size = stat_buf->st_size; alloc_size = size + 1; buf = g_try_malloc (alloc_size); if (buf == NULL) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_NOMEM, _("Could not allocate %lu bytes to read file \"%s\""), (gulong) alloc_size, display_filename); goto error; } bytes_read = 0; while (bytes_read < size) { gssize rc; rc = read (fd, buf + bytes_read, size - bytes_read); if (rc < 0) { if (errno != EINTR) { int save_errno = errno; g_free (buf); g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Failed to read from file '%s': %s"), display_filename, g_strerror (save_errno)); goto error; } } else if (rc == 0) break; else bytes_read += rc; } buf[bytes_read] = '\0'; if (length) *length = bytes_read; *contents = buf; close (fd); return TRUE; error: close (fd); return FALSE; }
static gboolean get_contents_stdio (const gchar *display_filename, FILE *f, gchar **contents, gsize *length, GError **error) { gchar buf[4096]; gsize bytes; gchar *str = NULL; gsize total_bytes = 0; gsize total_allocated = 0; gchar *tmp; g_assert (f != NULL); while (!feof (f)) { gint save_errno; bytes = fread (buf, 1, sizeof (buf), f); save_errno = errno; while ((total_bytes + bytes + 1) > total_allocated) { if (str) total_allocated *= 2; else total_allocated = MIN (bytes + 1, sizeof (buf)); tmp = g_try_realloc (str, total_allocated); if (tmp == NULL) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_NOMEM, _("Could not allocate %lu bytes to read file \"%s\""), (gulong) total_allocated, display_filename); goto error; } str = tmp; } if (ferror (f)) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Error reading file '%s': %s"), display_filename, g_strerror (save_errno)); goto error; } memcpy (str + total_bytes, buf, bytes); total_bytes += bytes; } fclose (f); if (total_allocated == 0) str = g_new (gchar, 1); str[total_bytes] = '\0'; if (length) *length = total_bytes; *contents = str; return TRUE; error: g_free (str); fclose (f); return FALSE; }
static GimpValueArray * xcf_save_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { XcfInfo info; GimpValueArray *return_vals; GimpImage *image; const gchar *filename; gboolean success = FALSE; gimp_set_busy (gimp); image = gimp_value_get_image (gimp_value_array_index (args, 1), gimp); filename = g_value_get_string (gimp_value_array_index (args, 3)); info.fp = g_fopen (filename, "wb"); if (info.fp) { info.gimp = gimp; info.progress = progress; info.cp = 0; info.filename = filename; info.active_layer = NULL; info.active_channel = NULL; info.floating_sel_drawable = NULL; info.floating_sel = NULL; info.floating_sel_offset = 0; info.swap_num = 0; info.ref_count = NULL; info.compression = COMPRESS_RLE; if (progress) { gchar *name = g_filename_display_name (filename); gchar *msg = g_strdup_printf (_("Saving '%s'"), name); gimp_progress_start (progress, msg, FALSE); g_free (msg); g_free (name); } xcf_save_choose_format (&info, image); success = xcf_save_image (&info, image, error); if (success) { if (fclose (info.fp) == EOF) { int save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Error saving XCF file: %s"), g_strerror (save_errno)); success = FALSE; } } else { fclose (info.fp); } if (progress) gimp_progress_end (progress); } else { int save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Could not open '%s' for writing: %s"), gimp_filename_to_utf8 (filename), g_strerror (save_errno)); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); gimp_unset_busy (gimp); return return_vals; }
static GimpValueArray * xcf_load_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { XcfInfo info; GimpValueArray *return_vals; GimpImage *image = NULL; const gchar *filename; gboolean success = FALSE; gchar id[14]; gimp_set_busy (gimp); filename = g_value_get_string (gimp_value_array_index (args, 1)); info.fp = g_fopen (filename, "rb"); if (info.fp) { info.gimp = gimp; info.progress = progress; info.cp = 0; info.filename = filename; info.tattoo_state = 0; info.active_layer = NULL; info.active_channel = NULL; info.floating_sel_drawable = NULL; info.floating_sel = NULL; info.floating_sel_offset = 0; info.swap_num = 0; info.ref_count = NULL; info.compression = COMPRESS_NONE; if (progress) { gchar *name = g_filename_display_name (filename); gchar *msg = g_strdup_printf (_("Opening '%s'"), name); gimp_progress_start (progress, msg, FALSE); g_free (msg); g_free (name); } success = TRUE; info.cp += xcf_read_int8 (info.fp, (guint8 *) id, 14); if (! g_str_has_prefix (id, "gimp xcf ")) { success = FALSE; } else if (strcmp (id + 9, "file") == 0) { info.file_version = 0; } else if (id[9] == 'v') { info.file_version = atoi (id + 10); } else { success = FALSE; } if (success) { if (info.file_version >= 0 && info.file_version < G_N_ELEMENTS (xcf_loaders)) { image = (*(xcf_loaders[info.file_version])) (gimp, &info, error); if (! image) success = FALSE; } else { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("XCF error: unsupported XCF file version %d " "encountered"), info.file_version); success = FALSE; } } fclose (info.fp); if (progress) gimp_progress_end (progress); } else { int save_errno = errno; g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (save_errno), _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), g_strerror (save_errno)); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) gimp_value_set_image (gimp_value_array_index (return_vals, 1), image); gimp_unset_busy (gimp); return return_vals; }
bool XojPopplerDocument::load(const char * filename, const char * password, GError ** error) { XOJ_CHECK_TYPE(XojPopplerDocument); PDFDoc * newDoc; GooString * filename_g; GooString * password_g; if (!globalParams) { globalParams = new GlobalParams(); } if (!filename) { return false; } password_g = NULL; if (password != NULL) { if (g_utf8_validate(password, -1, NULL)) { gchar *password_latin; password_latin = g_convert(password, -1, "ISO-8859-1", "UTF-8", NULL, NULL, NULL); password_g = new GooString(password_latin); g_free(password_latin); } else { password_g = new GooString(password); } } #ifdef G_OS_WIN32 wchar_t *filenameW; int wlen; wlen = MultiByteToWideChar(CP_UTF8, 0, filename, -1, NULL, 0); filenameW = new WCHAR[wlen]; if (!filenameW) return NULL; wlen = MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, wlen); newDoc = new PDFDoc(filenameW, wlen, password_g, password_g); delete filenameW; #else filename_g = new GooString(filename); newDoc = new PDFDoc(filename_g, password_g, password_g); #endif delete password_g; if (!newDoc->isOk()) { int fopen_errno; switch (newDoc->getErrorCode()) { case errOpenFile: // If there was an error opening the file, count it as a G_FILE_ERROR // and set the GError parameters accordingly. (this assumes that the // only way to get an errOpenFile error is if newDoc was created using // a filename and thus fopen was called, which right now is true. fopen_errno = newDoc->getFopenErrno(); g_set_error(error, G_FILE_ERROR, g_file_error_from_errno(fopen_errno), "%s", g_strerror(fopen_errno)); break; case errBadCatalog: g_set_error(error, 0, 0, "Failed to read the document catalog"); break; case errDamaged: g_set_error(error, 0, 0, "PDF document is damaged"); break; case errEncrypted: g_set_error(error, 0, 0, "Document is encrypted"); break; default: g_set_error(error, 0, 0, "Failed to load document"); } delete newDoc; return false; } if (this->data) { this->data->unreference(); } this->data = new _IntPopplerDocument(newDoc); return true; }