void compare3_to(GtkAction* action, GtkWidget* window) { GList* files = g_list_first((GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::compare_to")); GList* saved = (GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::saved"); gchar* f1 = 0; gchar* f2 = 0; gchar* f3 = (gchar*)saved->data; gboolean keep_file = FALSE; gchar* uri; xdiff_ext_preferences* p = xdiff_ext_preferences_instance(); g_object_get(G_OBJECT(p), "keep-files-in-list", &keep_file, NULL); g_object_unref(p); uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data); f1 = g_filename_from_uri(uri, NULL, NULL); g_free(uri); files = g_list_next(files); uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data); f2 = g_filename_from_uri(uri, NULL, NULL); g_free(uri); diff3(f1, f2, f3); g_free(f1); g_free(f2); if(!keep_file) { clear_queue(_saved); } }
void compare3(GtkAction* action, GtkWidget* window) { GList* files = g_list_first((GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::compare3")); gchar* f1 = 0; gchar* f2 = 0; gchar* f3 = 0; gchar* uri; uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data); f1 = g_filename_from_uri(uri, NULL, NULL); g_free(uri); files = g_list_next(files); uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data); f2 = g_filename_from_uri(uri, NULL, NULL); g_free(uri); files = g_list_next(files); uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data); f3 = g_filename_from_uri(uri, NULL, NULL); g_free(uri); diff3(f1, f2, f3); g_free(f1); g_free(f2); g_free(f3); }
static void on_drag_data_received (GtkWidget * widget, GdkDragContext * context, int x, int y, GtkSelectionData * seldata, guint inf, guint time, gpointer data) { SourceData *userdata = g_new0 (SourceData, 1); #ifdef G_OS_WIN32 gchar *filename = g_filename_from_uri ((const gchar *) seldata->data, NULL, NULL); #else GdkPixbufFormat *format; gchar **uris = gtk_selection_data_get_uris (seldata); gchar *filename = NULL; g_return_if_fail (uris != NULL); filename = g_filename_from_uri (uris[0], NULL, NULL); g_return_if_fail (filename != NULL); format = gdk_pixbuf_get_file_info (filename, NULL, NULL); g_return_if_fail (format); g_print ("received %s image: %s\n", filename, gdk_pixbuf_format_get_name (format)); #endif userdata->nick = "location"; userdata->value = g_strdup (filename); userdata->data = data; saveddelay = delay; if (delay > 0) { g_print ("%d\n", delay); g_timeout_add_seconds (1, set_location_delayed, userdata); } else g_object_set (G_OBJECT (userdata->data), userdata->nick, userdata->value, NULL); g_free (filename); }
/// return current path if a directory, path to file if file, also handles x-caja-desktop /// on failure (smb:///, sftp, ...) returns empty string inline std::string get_path(CajaFileInfo* file_info){ if(caja_file_info_is_directory(file_info)){ const gchar_handle uri(caja_file_info_get_uri(file_info)); const std::size_t len = std::strlen(uri.get()); if(len >= caja_desktop.size() && caja_desktop.compare(0, caja_desktop.size(), uri.get(), caja_desktop.size()) == 0){ const char* home = g_get_home_dir(); return to_string(home); } const gchar_handle path(g_filename_from_uri(uri.get(), nullptr, nullptr)); return to_string(path.get()); } const gchar_handle uri(caja_file_info_get_parent_uri(file_info)); const gchar_handle path(g_filename_from_uri(uri.get(), nullptr, nullptr)); return to_string(path.get()); }
static GTokenType gimp_color_profile_store_load_profile (GimpColorProfileStore *store, GScanner *scanner, gint index) { GtkTreeIter iter; gchar *label = NULL; gchar *uri = NULL; if (gimp_scanner_parse_string (scanner, &label) && gimp_scanner_parse_string (scanner, &uri)) { gchar *filename = g_filename_from_uri (uri, NULL, NULL); if (filename && g_file_test (filename, G_FILE_TEST_IS_REGULAR)) { gimp_color_profile_store_history_insert (store, &iter, filename, label, index); } g_free (filename); g_free (label); g_free (uri); return G_TOKEN_RIGHT_PAREN; } g_free (label); g_free (uri); return G_TOKEN_STRING; }
NS_METHOD nsSound::Play(nsIURL *aURL) { if (!mInited) Init(); if (!libcanberra) return NS_ERROR_NOT_AVAILABLE; bool isFile; nsresult rv = aURL->SchemeIs("file", &isFile); if (NS_SUCCEEDED(rv) && isFile) { ca_context* ctx = ca_context_get_default(); if (!ctx) { return NS_ERROR_OUT_OF_MEMORY; } nsAutoCString spec; rv = aURL->GetSpec(spec); if (NS_FAILED(rv)) { return rv; } gchar *path = g_filename_from_uri(spec.get(), NULL, NULL); if (!path) { return NS_ERROR_FILE_UNRECOGNIZED_PATH; } ca_context_play(ctx, 0, "media.filename", path, NULL); g_free(path); } else { nsCOMPtr<nsIStreamLoader> loader; rv = NS_NewStreamLoader(getter_AddRefs(loader), aURL, this); } return rv; }
static void append_file_to_cmd(GFile* gf, GString* cmd) { char* file = g_file_get_path(gf); char* quote; if(file == NULL) /* trash:// gvfs is incomplete in resolving it */ { /* we can retrieve real path from GVFS >= 1.13.3 */ if(g_file_has_uri_scheme(gf, "trash")) { GFileInfo *inf; const char *orig_path; inf = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI, G_FILE_QUERY_INFO_NONE, NULL, NULL); if(inf == NULL) /* failed */ return; orig_path = g_file_info_get_attribute_string(inf, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI); if(orig_path != NULL) /* success */ file = g_filename_from_uri(orig_path, NULL, NULL); g_object_unref(inf); } if(file == NULL) return; } quote = g_shell_quote(file); g_string_append(cmd, quote); g_string_append_c(cmd, ' '); g_free(quote); g_free(file); }
/** * cadp_writer_iexporter_export_to_file: * @instance: this #NAIExporter instance. * @parms: a #NAIExporterFileParmsv2 structure. * * Export the specified 'item' to a newly created file. */ guint cadp_writer_iexporter_export_to_file( const NAIExporter *instance, NAIExporterFileParmsv2 *parms ) { static const gchar *thisfn = "cadp_writer_iexporter_export_to_file"; guint code, write_code; gchar *id, *folder_path, *dest_path; ExportFormatFn *fmt; CappDesktopFile *ndf; g_debug( "%s: instance=%p, parms=%p", thisfn, ( void * ) instance, ( void * ) parms ); parms->basename = NULL; code = NA_IEXPORTER_CODE_OK; if( !parms->exported || !NA_IS_OBJECT_ITEM( parms->exported )){ code = NA_IEXPORTER_CODE_INVALID_ITEM; } if( code == NA_IEXPORTER_CODE_OK ){ #ifdef NA_ENABLE_DEPRECATED if( parms->version == 1 ){ fmt = find_export_format_fn_from_quark((( NAIExporterFileParms * ) parms )->format ); } else { fmt = find_export_format_fn( parms->format ); } #else fmt = find_export_format_fn( parms->format ); #endif if( !fmt ){ code = NA_IEXPORTER_CODE_INVALID_FORMAT; } else { id = na_object_get_id( parms->exported ); parms->basename = g_strdup_printf( "%s%s", id, CADP_DESKTOP_FILE_SUFFIX ); g_free( id ); folder_path = g_filename_from_uri( parms->folder, NULL, NULL ); dest_path = g_strdup_printf( "%s/%s", folder_path, parms->basename ); g_free( folder_path ); ndf = cadp_desktop_file_new_for_write( dest_path ); write_code = na_ifactory_provider_write_item( NA_IFACTORY_PROVIDER( instance ), ndf, NA_IFACTORY_OBJECT( parms->exported ), &parms->messages ); if( write_code != NA_IIO_PROVIDER_CODE_OK ){ code = NA_IEXPORTER_CODE_ERROR; } else if( !cadp_desktop_file_write( ndf )){ code = NA_IEXPORTER_CODE_UNABLE_TO_WRITE; } g_free( dest_path ); g_object_unref( ndf ); } } g_debug( "%s: returning code=%u", thisfn, code ); return( code ); }
/* Setup the fileitem, depending uri's scheme * Return a string to search in. */ static gchar * fileitem_setup (FileItem *item) { gchar *scheme; gchar *filename; gchar *candidate = NULL; gchar *path; gchar *name; scheme = g_uri_parse_scheme (item->uri); if (g_strcmp0 (scheme, "file") == 0) { filename = g_filename_from_uri ((const gchar *)item->uri, NULL, NULL); if (filename) { path = g_path_get_dirname (filename); item->path = g_filename_to_utf8 (path, -1, NULL, NULL, NULL); g_free (path); name = g_path_get_basename (filename); item->name = g_filename_to_utf8 (name, -1, NULL, NULL, NULL); g_free (name); candidate = g_utf8_strdown (filename, -1); g_free (filename); } } g_free (scheme); return candidate; }
static void check_uri_for_location (GstElement * e, const gchar * location, const gchar * uri) { GstQuery *query; gchar *query_uri = NULL; g_object_set (e, "location", location, NULL); query = gst_query_new_uri (); fail_unless (gst_element_query (e, query)); gst_query_parse_uri (query, &query_uri); gst_query_unref (query); if (uri != NULL) { fail_unless_equals_string (query_uri, uri); } else { gchar *fn; fail_unless (gst_uri_is_valid (query_uri)); fn = g_filename_from_uri (query_uri, NULL, NULL); fail_unless (g_path_is_absolute (fn)); fail_unless (fn != NULL); g_free (fn); } g_free (query_uri); }
static gboolean save_to_uri (GESFormatter * formatter, GESTimeline * timeline, const gchar * uri) { gchar *location; GError *e = NULL; gboolean ret = TRUE; GESFormatterPrivate *priv = GES_FORMATTER (formatter)->priv; if (!(location = g_filename_from_uri (uri, NULL, NULL))) { return FALSE; } if (!ges_formatter_save (formatter, timeline)) { GST_ERROR ("couldn't serialize formatter"); } else { if (!g_file_set_contents (location, priv->data, priv->length, &e)) { GST_ERROR ("couldn't write file '%s': %s", location, e->message); ret = FALSE; } } if (e) g_error_free (e); g_free (location); return ret; }
GMount * totem_get_mount_for_media (const char *uri) { GMount *ret; char *mount_path; if (uri == NULL) return NULL; mount_path = NULL; if (g_str_has_prefix (uri, "dvd://") != FALSE) return totem_get_mount_for_dvd (uri); else if (g_str_has_prefix (uri, "vcd:") != FALSE) mount_path = totem_get_mountpoint_for_vcd (uri); else if (g_str_has_prefix (uri, "file:") != FALSE) mount_path = g_filename_from_uri (uri, NULL, NULL); if (mount_path == NULL) return NULL; ret = totem_get_mount_for_uri (mount_path); g_free (mount_path); return ret; }
static void _button_clicked_cb (MxButton *button, gpointer userdata) { PengeAppTilePrivate *priv = GET_PRIVATE (userdata); GError *error = NULL; gchar *path = NULL; path = g_filename_from_uri (priv->bookmark, NULL, &error); if (!path) { if (error) { g_warning (G_STRLOC ": Error getting path from uri: %s", error->message); g_clear_error (&error); } return; } if (penge_utils_launch_for_desktop_file ((ClutterActor *)button, path)) penge_utils_signal_activated ((ClutterActor *)button); else g_warning (G_STRLOC ": Unable to launch for desktop file: %s", path); g_free (path); }
static gboolean pitivi_can_load_uri (GESFormatter * dummy_instance, const gchar * uri, GError ** error) { xmlDocPtr doc; gboolean ret = TRUE; xmlXPathObjectPtr xpathObj; xmlXPathContextPtr xpathCtx; gchar *filename = g_filename_from_uri (uri, NULL, NULL); if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { g_free (filename); return FALSE; } g_free (filename); if (!(doc = xmlParseFile (uri))) { GST_ERROR ("The xptv file for uri %s was badly formed", uri); return FALSE; } xpathCtx = xmlXPathNewContext (doc); xpathObj = xmlXPathEvalExpression ((const xmlChar *) "/pitivi", xpathCtx); if (!xpathObj || !xpathObj->nodesetval || xpathObj->nodesetval->nodeNr == 0) ret = FALSE; xmlFreeDoc (doc); xmlXPathFreeObject (xpathObj); xmlXPathFreeContext (xpathCtx); return ret; }
void compare_later(GtkAction* action, GtkWidget* window) { GList* files = g_list_first((GList*)g_object_get_data(G_OBJECT(action), "xdiff-ext::save")); while(files) { gchar* uri; gchar* path; GList* link; uri = thunarx_file_info_get_uri((ThunarxFileInfo*)files->data); path = g_filename_from_uri(uri, NULL, NULL); g_free(uri); link = g_queue_find_custom(_saved, path, (GCompareFunc)strcmp); if(link == NULL) { g_queue_push_head(_saved, path); } else { g_queue_unlink(_saved, link); g_queue_push_head_link(_saved, link); } // g_free(path) ??? files = g_list_next(files); } }
gchar * get_package_name_from_desktop_item (MateDesktopItem * desktop_item) { gchar *argv[6]; gchar *package_name; gint retval; GError *error; argv[0] = "rpm"; argv[1] = "-qf"; argv[2] = "--qf"; argv[3] = "%{NAME}"; argv[4] = g_filename_from_uri (mate_desktop_item_get_location (desktop_item), NULL, NULL); argv[5] = NULL; error = NULL; if (!g_spawn_sync (NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &package_name, NULL, &retval, &error)) { g_warning ("error: [%s]\n", error->message); g_error_free (error); retval = -1; } g_free (argv[4]); if (!retval) return package_name; else return NULL; }
static void fm_ditem_page_url_drag_data_received (GtkWidget *widget, GdkDragContext *context, int x, int y, GtkSelectionData *selection_data, guint info, guint time, GtkEntry *entry) { char **uris; gboolean exactly_one; char *path; uris = g_strsplit (selection_data->data, "\r\n", 0); exactly_one = uris[0] != NULL && (uris[1] == NULL || uris[1][0] == '\0'); if (!exactly_one) { g_strfreev (uris); return; } path = g_filename_from_uri (uris[0], NULL, NULL); if (path != NULL) { gtk_entry_set_text (entry, path); g_free (path); } else { gtk_entry_set_text (entry, uris[0]); } g_strfreev (uris); }
/* Encode a "text/plain" selection; this is a broken URL -- just * "file:" with a path after it (no escaping or anything). We are * trying to make the old gnome_uri_list_extract_filenames function * happy, so this is coded to its idiosyncrasises. */ static void add_one_compatible_uri (const char *uri, int x, int y, int w, int h, gpointer data) { GString *result; char *local_path; result = (GString *) data; /* For URLs that do not have a file: scheme, there's no harm * in passing the real URL. But for URLs that do have a file: * scheme, we have to send a URL that will work with the old * gnome-libs function or nothing will be able to understand * it. */ if (!eel_istr_has_prefix (uri, "file:")) { g_string_append (result, uri); g_string_append (result, "\r\n"); } else { local_path = g_filename_from_uri (uri, NULL, NULL); /* Check for characters that confuse the old * gnome_uri_list_extract_filenames implementation, and just leave * out any paths with those in them. */ if (is_path_that_gnome_uri_list_extract_filenames_can_parse (local_path)) { g_string_append (result, "file:"); g_string_append (result, local_path); g_string_append (result, "\r\n"); } g_free (local_path); } }
void onDone(const boost::shared_ptr<Samoyed::Worker> &worker) { Samoyed::TextFileSaver *saver = static_cast<Samoyed::TextFileSaver *>(worker.get()); if (saver->error()) { printf("Text file saver error: %s.\n", saver->error()->message); return; } GError *error = NULL; char *fileName = g_filename_from_uri(saver->uri(), NULL, &error); if (!fileName) { printf("URI to file name conversion error: %s.\n", error->message); g_error_free(error); return; } char *text; if (!g_file_get_contents(fileName, &text, NULL, &error)) { printf("Text file read error: %s.\n", error->message); g_error_free(error); return; } if (strcmp(strrchr(saver->uri(), '.'), ".GBK") == 0) assert(strcmp(text, TEXT_GBK) == 0); else if (strcmp(strrchr(saver->uri(), '.'), ".UTF-8") == 0) assert(strcmp(text, TEXT_UTF8) == 0); else assert(0); g_unlink(fileName); g_free(text); g_free(fileName); }
static gchar * play_uri_get_display_name (GstPlay * play, const gchar * uri) { gchar *loc; if (gst_uri_has_protocol (uri, "file")) { loc = g_filename_from_uri (uri, NULL, NULL); } else if (gst_uri_has_protocol (uri, "pushfile")) { loc = g_filename_from_uri (uri + 4, NULL, NULL); } else { loc = g_strdup (uri); } /* Maybe additionally use glib's filename to display name function */ return loc; }
static void check_uri_for_uri (GstElement * e, const gchar * in_uri, const gchar * uri) { GstQuery *query; gchar *query_uri = NULL; gst_uri_handler_set_uri (GST_URI_HANDLER (e), in_uri, NULL); query = gst_query_new_uri (); fail_unless (gst_element_query (e, query)); gst_query_parse_uri (query, &query_uri); gst_query_unref (query); if (uri != NULL) { fail_unless_equals_string (query_uri, uri); } else { gchar *fn; fail_unless (gst_uri_is_valid (query_uri)); fn = g_filename_from_uri (query_uri, NULL, NULL); fail_unless (g_path_is_absolute (fn)); fail_unless (fn != NULL); g_free (fn); } g_free (query_uri); }
/** * file_utils_filename_from_uri: * @uri: a URI * * A utility function to be used as a replacement for * g_filename_from_uri(). It deals with file: URIs with hostname in a * platform-specific way. On Win32, a UNC path is created and * returned, on other platforms the URI is detected as non-local and * NULL is returned. * * Returns: newly allocated filename or %NULL if @uri is a remote file **/ gchar * file_utils_filename_from_uri (const gchar *uri) { gchar *filename; gchar *hostname; g_return_val_if_fail (uri != NULL, NULL); filename = g_filename_from_uri (uri, &hostname, NULL); if (!filename) return NULL; if (hostname) { /* we have a file: URI with a hostname */ #ifdef G_OS_WIN32 /* on Win32, create a valid UNC path and use it as the filename */ gchar *tmp = g_build_filename ("//", hostname, filename, NULL); g_free (filename); filename = tmp; #else /* otherwise return NULL, caller should use URI then */ g_free (filename); filename = NULL; #endif g_free (hostname); } return filename; }
GList * pragha_dnd_uri_list_get_mobj_list (GtkSelectionData *data) { PraghaMusicobject *mobj = NULL; gchar **uris = NULL, *filename = NULL; GList *list = NULL; gint i = 0; CDEBUG(DBG_VERBOSE, "Target: URI_LIST"); uris = gtk_selection_data_get_uris(data); if(uris){ for(i = 0; uris[i] != NULL; i++) { filename = g_filename_from_uri(uris[i], NULL, NULL); if (g_file_test(filename, G_FILE_TEST_IS_DIR)){ list = append_mobj_list_from_folder(list, filename); } else { mobj = new_musicobject_from_file(filename, NULL); if (G_LIKELY(mobj)) list = g_list_prepend(list, mobj); } /* Have to give control to GTK periodically ... */ pragha_process_gtk_events (); g_free(filename); } g_strfreev(uris); } return g_list_reverse (list); }
gchar * _rsvg_io_get_file_path (const gchar * filename, const gchar * base_uri) { gchar *absolute_filename; if (g_file_test (filename, G_FILE_TEST_EXISTS) || g_path_is_absolute (filename)) { absolute_filename = g_strdup (filename); } else { gchar *tmpcdir; gchar *base_filename; if (base_uri) { base_filename = g_filename_from_uri (base_uri, NULL, NULL); if (base_filename != NULL) { tmpcdir = g_path_get_dirname (base_filename); g_free (base_filename); } else return NULL; } else tmpcdir = g_get_current_dir (); absolute_filename = g_build_filename (tmpcdir, filename, NULL); g_free (tmpcdir); } return absolute_filename; }
static GSList * translate_document_list (EggDesktopFile *desktop_file, GSList *documents) { gboolean accepts_uris = egg_desktop_file_accepts_uris (desktop_file); GSList *ret, *d; for (d = documents, ret = NULL; d; d = d->next) { const char *document = d->data; gboolean is_uri = !g_path_is_absolute (document); char *translated; if (accepts_uris) { if (is_uri) translated = g_strdup (document); else translated = g_filename_to_uri (document, NULL, NULL); } else { if (is_uri) translated = g_filename_from_uri (document, NULL, NULL); else translated = g_strdup (document); } if (translated) ret = g_slist_prepend (ret, translated); } return g_slist_reverse (ret); }
static gboolean vcard_supported (EImport *ei, EImportTarget *target, EImportImporter *im) { EImportTargetURI *s; gchar *filename; gboolean retval; if (target->type != E_IMPORT_TARGET_URI) return FALSE; s = (EImportTargetURI *) target; if (s->uri_src == NULL) return TRUE; if (strncmp(s->uri_src, "file:///", 8) != 0) return FALSE; filename = g_filename_from_uri (s->uri_src, NULL, NULL); if (filename == NULL) return FALSE; retval = (guess_vcard_encoding (filename) != VCARD_ENCODING_NONE); g_free (filename); return retval; }
gchar * file_utils_any_to_uri (Gimp *gimp, const gchar *filename_or_uri, GError **error) { gchar *uri; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (filename_or_uri != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); /* first try if we got a file uri */ uri = g_filename_from_uri (filename_or_uri, NULL, NULL); if (uri) { g_free (uri); uri = g_strdup (filename_or_uri); } else { uri = file_utils_filename_to_uri (gimp, filename_or_uri, error); } return uri; }
static void set_resource_limits (const char *input) { struct rlimit limit; struct stat buf; rlim_t max; max = MAX_HELPER_MEMORY; /* Set the maximum virtual size depending on the size * of the file to process, as we wouldn't be able to * mmap it otherwise */ if (input == NULL) { max = MAX_HELPER_MEMORY; } else if (g_stat (input, &buf) == 0) { max = MAX_HELPER_MEMORY + buf.st_size; } else if (g_str_has_prefix (input, "file://") != FALSE) { char *file; file = g_filename_from_uri (input, NULL, NULL); if (file != NULL && g_stat (file, &buf) == 0) max = MAX_HELPER_MEMORY + buf.st_size; g_free (file); } limit.rlim_cur = max; limit.rlim_max = max; setrlimit (RLIMIT_DATA, &limit); limit.rlim_cur = MAX_HELPER_SECONDS; limit.rlim_max = MAX_HELPER_SECONDS; setrlimit (RLIMIT_CPU, &limit); }
static const char * shell_util_get_icon_for_uri_known_folders (const char *uri) { const char *icon; char *path; int len; icon = NULL; if (!g_str_has_prefix (uri, "file:")) return NULL; path = g_filename_from_uri (uri, NULL, NULL); len = strlen (path); if (path[len] == '/') path[len] = '\0'; if (strcmp (path, "/") == 0) icon = "drive-harddisk"; else if (strcmp (path, g_get_home_dir ()) == 0) icon = "user-home"; else if (strcmp (path, g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP)) == 0) icon = "user-desktop"; g_free (path); return icon; }
static gboolean check_file_size (GstValidateMediaInfo * mi) { GStatBuf statbuf; gchar *filepath; guint64 size = 0; gboolean ret = TRUE; GError *err = NULL; filepath = g_filename_from_uri (mi->uri, NULL, &err); if (!filepath) { g_error_free (err); return FALSE; } if (g_stat (filepath, &statbuf) == 0) { size = statbuf.st_size; } else { ret = FALSE; goto end; } mi->file_size = size; end: g_free (filepath); return ret; }