static void
gst_multi_file_sink_ensure_max_files (GstMultiFileSink * multifilesink)
{
guint max_files = multifilesink->max_files;
if (max_files == 0)
return;
while (g_queue_get_length (&multifilesink->old_files) >= max_files) {
gchar *filename;
filename = g_queue_pop_head (&multifilesink->old_files);
g_remove (filename);
g_free (filename);
}
}
/**
* a_babel_convert:
* @vt: The TRW layer to modify. All data will be deleted, and replaced by what gpsbabel outputs.
* @babelargs: A string containing gpsbabel command line filter options. No file types or names should
* be specified.
* @cb: A callback function.
* @user_data: passed along to cb
* @not_used: Must use NULL
*
* This function modifies data in a trw layer using gpsbabel filters. This routine is synchronous;
* that is, it will block the calling program until the conversion is done. To avoid blocking, call
* this routine from a worker thread.
*
* Returns: %TRUE on success
*/
gboolean a_babel_convert( VikTrwLayer *vt, const char *babelargs, BabelStatusFunc cb, gpointer user_data, gpointer not_used )
{
gboolean ret = FALSE;
gchar *bargs = g_strconcat(babelargs, " -i gpx", NULL);
gchar *name_src = a_gpx_write_tmp_file ( vt, NULL );
if ( name_src ) {
ProcessOptions po = { bargs, name_src, NULL, NULL, NULL };
ret = a_babel_convert_from ( vt, &po, cb, user_data, not_used );
(void)g_remove(name_src);
g_free(name_src);
}
g_free(bargs);
return ret;
}
static void _load_tile_thread(gpointer _tile, gpointer _sat)
{
GritsTile *tile = _tile;
GritsPluginSat *sat = _sat;
g_debug("GritsPluginSat: _load_tile_thread start %p - tile=%p",
g_thread_self(), tile);
if (sat->aborted) {
g_debug("GritsPluginSat: _load_tile_thread - aborted");
return;
}
/* Download tile */
gchar *path = grits_wms_fetch(sat->wms, tile, GRITS_ONCE, NULL, NULL);
if (!path) return; // Canceled/error
/* Load pixbuf */
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(path, NULL);
if (!pixbuf) {
g_warning("GritsPluginSat: _load_tile_thread - Error loading pixbuf %s", path);
g_remove(path);
g_free(path);
return;
}
g_free(path);
/* Draw a border */
#ifdef DRAW_TILE_BORDER
gint border = 10;
gint width = gdk_pixbuf_get_width(pixbuf);
gint height = gdk_pixbuf_get_height(pixbuf);
gint stride = gdk_pixbuf_get_rowstride(pixbuf);
guchar *pixels = gdk_pixbuf_get_pixels(pixbuf);
for (int i = 0; i < border; i++) {
memset(&pixels[( i)*stride], 0xff, stride);
memset(&pixels[(height-1-i)*stride], 0xff, stride);
}
for (int i = 0; i < height; i++) {
memset(&pixels[(i*stride) ], 0xff, border*4);
memset(&pixels[(i*stride)+((width-border)*4)], 0xff, border*4);
}
#endif
/* Load the GL texture from the main thread */
grits_tile_load_pixbuf(tile, pixbuf);
g_debug("GritsPluginSat: _load_tile_thread end %p", g_thread_self());
}
void rssyl_update_format()
{
RUpdateFormatCtx *ctx = NULL;
GSList *oldfeeds;
gchar *old_feeds_xml = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
RSSYL_DIR, G_DIR_SEPARATOR_S, "feeds.xml", NULL);
if (!g_file_test(old_feeds_xml,
G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
g_free(old_feeds_xml);
return;
}
debug_print("RSSyl: Old format found, updating.\n");
oldfeeds = rssyl_old_feed_metadata_parse(old_feeds_xml);
/* We find all rssyl root folders and perform magic on each */
ctx = g_new0(RUpdateFormatCtx, 1);
ctx->o_prev = NULL;
ctx->o_parent = NULL;
ctx->n_prev = NULL;
ctx->n_parent = NULL;
ctx->n_first = NULL;
ctx->oldfeeds = oldfeeds;
ctx->oldroots = NULL;
ctx->reached_first_new = FALSE;
folder_item_update_freeze();
/* Go through all RSSyl folders, making new copies */
folder_func_to_all_folders((FolderItemFunc)rssyl_update_format_func, ctx);
g_slist_foreach(ctx->oldroots, _delete_old_roots_func, NULL);
g_slist_free(ctx->oldroots);
prefs_matcher_write_config();
folder_write_list();
folder_item_update_thaw();
g_free(ctx);
g_remove(old_feeds_xml);
g_free(old_feeds_xml);
}
static void test_engine_ngspice_error_no_such_file_or_directory() {
TestEngineNgspiceResources *test_resources = test_engine_ngspice_resources_new();
// make sure that the given file does not exist
g_free(test_resources->resources->netlist_file);
gint fd = g_file_open_tmp(NULL, &test_resources->resources->netlist_file, NULL);
g_close(fd, NULL);
g_remove(test_resources->resources->netlist_file);
ngspice_watcher_build_and_launch(test_resources->resources);
g_main_loop_run(test_resources->loop);
g_assert_nonnull(test_resources->log_list);
g_assert_true(g_str_has_suffix(test_resources->log_list->data, " No such file or directory\n"));
test_engine_ngspice_resources_finalize(test_resources);
}
static void
brasero_project_type_chooser_last_unsaved_clicked_cb (GtkButton *button,
BraseroProjectTypeChooser *self)
{
const gchar *uri;
gchar *path;
uri = g_object_get_data (G_OBJECT (button), "BraseroButtonURI");
path = g_filename_from_uri (uri, NULL, NULL);
g_signal_emit (self,
brasero_project_type_chooser_signals [LAST_SAVED_CLICKED_SIGNAL],
0,
path);
g_remove (path);
g_free (path);
}
gboolean
delete_if_exists(gchar* path){
if(g_file_test(path, G_FILE_TEST_EXISTS)){
if(g_file_test(path, G_FILE_TEST_IS_DIR)){
GError *error = NULL;
GDir* dir = g_dir_open(path, 0, &error);
gchar* filename = NULL;
gchar* child = NULL;
while (filename = g_dir_read_name(dir)){
child = g_build_filename(path, filename, NULL);
delete_if_exists(child);
g_free(child);
}
}
if(g_remove(path) < 0)
g_warning("Could not remove %s", path);
}
}
void filesystem::g_copy(const char * src,const char * dst,abort_callback & p_abort) {
service_ptr_t<file> r_src,r_dst;
t_filesize size;
g_open(r_src,src,open_mode_read,p_abort);
size = r_src->get_size_ex(p_abort);
g_open(r_dst,dst,open_mode_write_new,p_abort);
if (size > 0) {
try {
file::g_transfer_object(r_src,r_dst,size,p_abort);
} catch(...) {
r_dst.release();
try {g_remove(dst,abort_callback_dummy());} catch(...) {}
throw;
}
}
}
static gchar *
generate_control_path (FlowSshMaster *ssh_master)
{
gchar *cache_dir;
gchar *path;
cache_dir = g_strdup_printf ("%s/flow", g_get_user_cache_dir ());
g_mkdir_with_parents (cache_dir, 0770);
path = g_strdup_printf ("%s/ssh-master-%d-%016" G_GINT64_MODIFIER "x",
cache_dir,
getpid (),
(guint64) ssh_master);
g_remove (path);
g_free (cache_dir);
return path;
}
static void
on_delete_clicked (GtkButton * button, gpointer user_data)
{
BtCrashRecoverDialog *self = BT_CRASH_RECOVER_DIALOG (user_data);
gchar *log_name = get_selected (self);
if (log_name) {
if (g_remove (log_name)) {
GST_WARNING ("failed removing '%s': %s", log_name, g_strerror (errno));
}
remove_selected (self);
g_free (log_name);
/* if that was the last entry, close dialog */
if (!check_selection (self, NULL, NULL)) {
gtk_dialog_response (GTK_DIALOG (self), GTK_RESPONSE_CLOSE);
}
}
}
gboolean utility_removeAll(const gchar* path) {
if(!path || !g_file_test(path, G_FILE_TEST_EXISTS)) {
return FALSE;
}
gboolean isSuccess = TRUE;
/* directories must be empty before we can remove them */
if(g_file_test(path, G_FILE_TEST_IS_DIR)) {
/* recurse into this directory and remove all files */
GError* err = NULL;
GDir* dir = g_dir_open(path, 0, &err);
if(err) {
warning("unable to open directory '%s': error %i: %s", path, err->code, err->message);
isSuccess = FALSE;
g_error_free(err);
} else {
const gchar* entry = NULL;
while((entry = g_dir_read_name(dir)) != NULL) {
gchar* childPath = g_build_filename(path, entry, NULL);
gboolean childSuccess = utility_removeAll(childPath);
g_free(childPath);
if(!childSuccess) {
isSuccess = FALSE;
break;
}
}
g_dir_close(dir);
}
}
/* now remove the empty directory, or the file */
if(g_remove(path) != 0) {
warning("unable to remove path '%s': error %i: %s", path, errno, strerror(errno));
isSuccess = FALSE;
} else {
info("removed path '%s' from filesystem", path);
isSuccess = TRUE;
}
return isSuccess;
}
int
main (int argc, char **argv)
{
gchar *current_dir;
gint result;
gint i;
/* Warning warning!!! We need to impose a proper LC_COLLATE here, so
* that the expected order in the test results is always the same! */
setlocale (LC_COLLATE, "en_US.utf8");
current_dir = g_get_current_dir ();
tests_data_dir = g_build_path (G_DIR_SEPARATOR_S, current_dir, "test-data", NULL);
g_free (current_dir);
g_test_init (&argc, &argv, NULL);
/* add test cases */
g_test_add ("/libtracker-data/ontology-init", TestInfo, GINT_TO_POINTER(0), setup_all_others, test_ontology_init, teardown);
for (i = 0; nie_tests[i].test_name; i++) {
gchar *testpath;
testpath = g_strconcat ("/libtracker-data/nie/", nie_tests[i].test_name, NULL);
g_test_add (testpath, TestInfo, GINT_TO_POINTER(i), setup_nie, test_query, teardown);
g_free (testpath);
}
for (i = 0; nmo_tests[i].test_name; i++) {
gchar *testpath;
testpath = g_strconcat ("/libtracker-data/nmo/", nmo_tests[i].test_name, NULL);
g_test_add (testpath, TestInfo, GINT_TO_POINTER(i), setup_nmo, test_query, teardown);
g_free (testpath);
}
/* run tests */
result = g_test_run ();
g_remove (tests_data_dir);
g_free (tests_data_dir);
return result;
}
static int geonames_search_get_coord(VikWindow *vw, VikViewport *vvp, gchar *srch_str, VikCoord *coord)
{
gchar *uri;
gchar *escaped_srch_str;
int ret = 1; /* OK */
struct LatLon ll;
gchar *tmpname;
g_debug("%s: raw search: %s", __FUNCTION__, srch_str);
escaped_srch_str = uri_escape(srch_str);
g_debug("%s: escaped search: %s", __FUNCTION__, escaped_srch_str);
//uri = g_strdup_printf(GEONAMES_SEARCH_URL_FMT, srch_str);
uri = g_strdup_printf(GEONAMES_SEARCH_URL_FMT, escaped_srch_str);
tmpname = download_url(uri);
if (!tmpname) {
ret = -1;
goto done;
}
ret = parse_file_for_latlon(vw, tmpname, &ll);
if (ret == 3) {
goto done;
}
vik_coord_load_from_latlon ( coord, vik_viewport_get_coord_mode(vvp), &ll );
if (last_coord)
g_free(last_coord);
last_coord = g_malloc(sizeof(VikCoord));
*last_coord = *coord;
if (last_successful_search_str)
g_free(last_successful_search_str);
last_successful_search_str = g_strdup(last_search_str);
done:
g_free(escaped_srch_str);
g_free(uri);
if (tmpname) {
g_remove(tmpname);
g_free(tmpname);
}
return ret;
}
/**
* a_babel_convert_from:
* @vt: The TRW layer to place data into. Duplicate items will be overwritten.
* @babelargs: A string containing gpsbabel command line options. In addition to any filters, this string
* must include the input file type (-i) option.
* @cb: Optional callback function. Same usage as in a_babel_convert().
* @user_data: passed along to cb
* @not_used: Must use NULL
*
* Loads data into a trw layer from a file, using gpsbabel. This routine is synchronous;
* that is, it will block the calling program until the conversion is done. To avoid blocking, call
* this routine from a worker thread.
*
* Returns: %TRUE on success
*/
gboolean a_babel_convert_from( VikTrwLayer *vt, const char *babelargs, const char *from, BabelStatusFunc cb, gpointer user_data, gpointer not_used )
{
int i,j;
int fd_dst;
gchar *name_dst = NULL;
gboolean ret = FALSE;
gchar *args[64];
if ((fd_dst = g_file_open_tmp("tmp-viking.XXXXXX", &name_dst, NULL)) >= 0) {
g_debug ("%s: temporary file: %s", __FUNCTION__, name_dst);
close(fd_dst);
if (gpsbabel_loc ) {
gchar **sub_args = g_strsplit(babelargs, " ", 0);
i = 0;
if (unbuffer_loc)
args[i++] = unbuffer_loc;
args[i++] = gpsbabel_loc;
for (j = 0; sub_args[j]; j++) {
/* some version of gpsbabel can not take extra blank arg */
if (sub_args[j][0] != '\0')
args[i++] = sub_args[j];
}
args[i++] = "-o";
args[i++] = "gpx";
args[i++] = "-f";
args[i++] = (char *)from;
args[i++] = "-F";
args[i++] = name_dst;
args[i] = NULL;
ret = babel_general_convert_from ( vt, cb, args, name_dst, user_data );
g_strfreev(sub_args);
} else
g_critical("gpsbabel not found in PATH");
g_remove(name_dst);
g_free(name_dst);
}
return ret;
}
void
deinit_upnp (void)
{
g_object_unref (context_manager);
g_hash_table_unref (nl_hash);
g_list_foreach (switch_proxies, (GFunc) g_object_unref, NULL);
g_list_foreach (dimming_proxies, (GFunc) g_object_unref, NULL);
/* Unref the descriptiont doc */
g_object_unref (doc);
if (g_remove (desc_location) != 0)
g_warning ("error removing %s\n", desc_location);
g_free (desc_location);
g_free (uuid);
uuid = NULL;
}
/**
* asb_utils_rmtree:
* @directory: utf8 directory name
* @error: A #GError or %NULL
*
* Removes a directory tree.
*
* Returns: %TRUE for success, %FALSE otherwise
*
* Since: 0.1.0
**/
gboolean
asb_utils_rmtree (const gchar *directory, GError **error)
{
gint rc;
gboolean ret;
ret = asb_utils_ensure_exists_and_empty (directory, error);
if (!ret)
return FALSE;
rc = g_remove (directory);
if (rc != 0) {
g_set_error (error,
ASB_PLUGIN_ERROR,
ASB_PLUGIN_ERROR_FAILED,
"Failed to delete: %s", directory);
return FALSE;
}
return TRUE;
}
static void dvr_clean (Gstreamill *gstreamill)
{
guint64 now, time;
gint i, j;
gchar *pattern;
glob_t pglob;
GSList *list;
Job *job;
now = g_get_real_time ();
if (now - gstreamill->last_dvr_clean_time < 600000000) {
return;
}
list = gstreamill->job_list;
while (list != NULL) {
job = list->data;
/* non live job need not clean dvr */
if (!job->is_live) {
list = list->next;
continue;
}
for (i = 0; i < job->output->encoder_count; i++) {
if (job->output->encoders[i].record_path == NULL) {
continue;
}
time = (now / 1000000 - job->output->encoders[i].dvr_duration) / 10;
while (time > 11) {
pattern = g_strdup_printf ("%s/%lu*.ts", job->output->encoders[i].record_path, time - 1);
GST_ERROR ("%s", pattern);
glob (pattern, 0, NULL, &pglob);
for (j = 0; j < pglob.gl_pathc; j++) {
g_remove (pglob.gl_pathv[j]);
}
globfree (&pglob);
g_free (pattern);
time = time / 10;
}
}
list = list->next;
}
gstreamill->last_dvr_clean_time = now;
}
int
main (int argc, char **argv)
{
gchar *current_dir;
gint result;
gint i;
setlocale (LC_COLLATE, "en_US.utf8");
current_dir = g_get_current_dir ();
tests_data_dir = g_build_path (G_DIR_SEPARATOR_S, current_dir, "test-data", NULL);
g_free (current_dir);
g_test_init (&argc, &argv, NULL);
/* add test cases */
for (i = 0; tests[i].test_name; i++) {
gchar *testpath;
#ifndef HAVE_LIBICU
/* Skip tests which fail collation tests and are known
* to do so. For more details see:
*
* https://bugzilla.gnome.org/show_bug.cgi?id=636074
*/
if (strcmp (tests[i].test_name, "functions/functions-xpath-2") == 0) {
continue;
}
#endif
testpath = g_strconcat ("/libtracker-data/sparql/", tests[i].test_name, NULL);
g_test_add (testpath, TestInfo, GINT_TO_POINTER(i), setup, test_sparql_query, teardown);
g_free (testpath);
}
/* run tests */
result = g_test_run ();
g_remove (tests_data_dir);
g_free (tests_data_dir);
return result;
}
/*
* Delete empty directory @path, with a retry loop if the system call is
* interrupted by an async signal. If @path does not exist, ignore.
*/
void
test_rmdir_if_exists (const gchar *path)
{
while (g_remove (path) != 0)
{
int saved_errno = errno;
if (saved_errno == ENOENT)
return;
#ifdef G_OS_UNIX
if (saved_errno == EINTR)
continue;
#endif
g_error ("Unable to remove directory \"%s\": %s", path,
g_strerror (saved_errno));
}
}
static BraseroBurnResult
brasero_cdrecord_post (BraseroJob *job)
{
BraseroCDRecordPrivate *priv;
GSList *iter;
priv = BRASERO_CD_RECORD_PRIVATE (job);
for (iter = priv->infs; iter; iter = iter->next) {
gchar *path;
path = iter->data;
g_remove (path);
g_free (path);
}
g_slist_free (priv->infs);
priv->infs = NULL;
return brasero_job_finished_session (job);
}
int latex_remove_auxfile(GuEditor* ec)
{
gchar* auxfile = NULL;
int res = -1;
// TODO: merge this into function with several other instances.
// for instance the lines in analyse_log
if (ec->filename == NULL) {
auxfile = g_strconcat(ec->basename, ".aux", NULL);
} else {
auxfile = g_strconcat(C_TMPDIR, C_DIRSEP,
g_path_get_basename(ec->basename), ".aux", NULL);
}
// TODO: extend for other build files
if (g_file_test(auxfile, G_FILE_TEST_EXISTS)) {
res = g_remove(auxfile);
}
g_free(auxfile);
return res;
}
gint saveIndividual(individual* program, gchar* filename){
if(!filename) g_printf("Function saveIndividual(): filename is not valid.\n");
//g_printf("Saving individual %s (address: %x)\n", filename, program);
if(!program){
g_printf("function saveIndividual(): *program is not valid.");
return 0;
}
if(g_file_test(filename, G_FILE_TEST_EXISTS)){
if(g_remove(filename)!=0){
g_printf("remove outdated file failed.");
return 0;
}
}
gchar* cmd=g_malloc0(512*sizeof(gchar));
if(program==ori){
g_snprintf(cmd, 512, "gcc %s -shared -fPIC -o %s -O3 malloc.c", GCC_M32, filename);
}
else{
g_snprintf(cmd, 512, "gcc %s -shared -fPIC -o %s -O3 malloc.c -D\'MALLOC_ALIGNMENT=((size_t)(%d*sizeof(void*)))\' -DFOOTERS=%d -DINSECURE=%d -DNO_SEGMENT_TRAVERSAL=%d -DMORECORE_CONTIGUOUS=%d -DDEFAULT_GRANULARITY=%d -DDEFAULT_TRIM_THRESHOLD=%d -DDEFAULT_MMAP_THRESHOLD=%d -DMAX_RELEASE_CHECK_RATE=%d -DTOP_FOOT_SIZE=%d -DLINE4114=%d -DLINE4353=%d -DLINE4059=%d", GCC_M32, filename,
program->chrom[0],
(program->chrom[1] & FOOTER_BIT)==0? 0:1,
(program->chrom[1] & INSECURE_BIT)==0? 0:1,
(program->chrom[1] & NO_SEGMENT_TRAVERSAL_BIT)==0? 0:1,
(program->chrom[1] & MORECORE_CONTIGUOUS_BIT)==0? 0:1,
program->chrom[2]*1024,
program->chrom[3]*1024,
program->chrom[4]*1024,
program->chrom[5],
program->chrom[6],
program->chrom[7],
program->chrom[8],
program->chrom[9]);
}
//g_spawn_command_line_sync(cmd, NULL, NULL, NULL, NULL);
system(cmd);
g_free(cmd);
if(!g_file_test(filename, G_FILE_TEST_EXISTS)){
return 0;
}
return 1;
}
static void latest_version_thread ( GtkWindow *window )
{
// Need to allow a few redirects, as SF file is often served from different server
DownloadMapOptions options = { FALSE, FALSE, NULL, 5, NULL, NULL, NULL };
gchar *filename = a_download_uri_to_tmp_file ( "http://sourceforge.net/projects/viking/files/VERSION", &options );
//gchar *filename = g_strdup ( "VERSION" );
if ( !filename ) {
return;
}
GMappedFile *mf = g_mapped_file_new ( filename, FALSE, NULL );
if ( !mf )
return;
gchar *text = g_mapped_file_get_contents ( mf );
gint latest_version = viking_version_to_number ( text );
gint my_version = viking_version_to_number ( VIKING_VERSION );
g_debug ( "The lastest version is: %s", text );
if ( my_version < latest_version ) {
new_version_thread_data *nvtd = g_malloc ( sizeof(new_version_thread_data) );
nvtd->window = window;
nvtd->version = g_strdup ( text );
gdk_threads_add_idle ( (GSourceFunc) new_version_available_message, nvtd );
}
else
g_debug ( "Running the lastest version: %s", VIKING_VERSION );
g_mapped_file_unref ( mf );
if ( filename ) {
g_remove ( filename );
g_free ( filename );
}
// Update last checked time
GTimeVal time;
g_get_current_time ( &time );
a_settings_set_string ( VIK_SETTINGS_VERSION_CHECKED_DATE, g_time_val_to_iso8601(&time) );
}
static void
idol_disc_recorder_plugin_burn (GtkAction *action,
IdolDiscRecorderPlugin *pi)
{
char *path;
char *error = NULL;
path = idol_disc_recorder_plugin_write_video_project (pi, &error);
if (!path) {
idol_interface_error (_("The movie could not be recorded."),
error,
idol_get_main_window (pi->idol));
g_free (error);
return;
}
if (!idol_disc_recorder_plugin_start_burning (pi, path, FALSE))
g_remove (path);
g_free (path);
}
static void
brasero_cdrecord_finalize (GObject *object)
{
BraseroCDRecordPrivate *priv;
GSList *iter;
priv = BRASERO_CD_RECORD_PRIVATE (object);
for (iter = priv->infs; iter; iter = iter->next) {
gchar *path;
path = iter->data;
g_remove (path);
g_free (path);
}
g_slist_free (priv->infs);
priv->infs = NULL;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
xplayer_disc_recorder_plugin_burn (GtkAction *action,
XplayerDiscRecorderPlugin *pi)
{
char *path;
char *error = NULL;
path = xplayer_disc_recorder_plugin_write_video_project (pi, &error);
if (!path) {
xplayer_interface_error (_("The movie could not be recorded."),
error,
xplayer_get_main_window (pi->priv->xplayer));
g_free (error);
return;
}
if (!xplayer_disc_recorder_plugin_start_burning (pi, path, FALSE))
g_remove (path);
g_free (path);
}
static void cleancache_r(gchar *path)
{
GDir *dir = g_dir_open(path, 0, NULL);
if (!dir)
return;
const gchar *child;
while ((child = g_dir_read_name(dir))) {
gchar *child_path = g_build_filename(path, child, NULL);
if (g_file_test(child_path, G_FILE_TEST_IS_DIR)) {
cleancache_r(child_path);
} else {
struct stat st;
g_stat(child_path, &st);
if (st.st_atime < time(NULL)-60*60*24)
g_remove(child_path);
}
g_free(child_path);
}
g_dir_close(dir);
g_rmdir(path);
}
/*
* ai_utils_directory_remove:
*
* Removes the contents of a directory, but not the directory itself
*/
static gboolean
ai_utils_directory_remove_contents (const gchar *directory)
{
gboolean ret = FALSE;
GDir *dir;
GError *error = NULL;
const gchar *filename;
gchar *src;
gint retval;
/* try to open */
dir = g_dir_open (directory, 0, &error);
if (dir == NULL) {
g_warning ("cannot open directory: %s", error->message);
g_error_free (error);
goto out;
}
/* find each */
while ((filename = g_dir_read_name (dir))) {
src = g_build_filename (directory, filename, NULL);
ret = g_file_test (src, G_FILE_TEST_IS_DIR);
if (ret) {
/* recurse */
ai_utils_directory_remove_contents (src);
retval = g_remove (src);
if (retval != 0)
g_warning ("failed to delete %s", src);
} else {
retval = g_unlink (src);
if (retval != 0)
g_warning ("failed to delete %s", src);
}
g_free (src);
}
g_dir_close (dir);
ret = TRUE;
out:
return ret;
}
sc_bool sc_fs_storage_write_to_path(sc_segment **segments)
{
sc_uint idx = 0;
const sc_segment *segment = 0;
gchar file_name[MAX_PATH_LENGTH + 1];
gchar segments_path[MAX_PATH_LENGTH + 1];
if (!g_file_test(repo_path, G_FILE_TEST_IS_DIR))
{
g_error("%s isn't a directory.", repo_path);
return SC_FALSE;
}
// check if segments directory exists, if it doesn't, then create one
g_snprintf(segments_path, MAX_PATH_LENGTH, "%s/%s", repo_path, seg_dir);
if (!g_file_test(segments_path, G_FILE_TEST_IS_DIR))
{
if (g_mkdir_with_parents(segments_path, SC_DIR_PERMISSIONS) < 0)
return SC_FALSE;
}
for (idx = 0; idx < SC_ADDR_SEG_MAX; idx++)
{
segment = segments[idx];
if (segment == nullptr) continue; // skip null segments
_get_segment_path(segments_path, idx, MAX_PATH_LENGTH, file_name);
g_file_set_contents(file_name, (gchar*)segment, sizeof(sc_segment), 0);
}
_get_segment_path(segments_path, idx, MAX_PATH_LENGTH, file_name);
while (g_file_test(file_name, G_FILE_TEST_EXISTS))
{
g_remove(file_name);
_get_segment_path(segments_path, ++idx, MAX_PATH_LENGTH, file_name);
}
return SC_TRUE;
}
void
set_user_icon_data (ActUser *user,
GdkPixbuf *pixbuf)
{
gchar *path;
gint fd;
GOutputStream *stream;
GError *error;
path = g_build_filename (g_get_tmp_dir (), "gnome-control-center-user-icon-XXXXXX", NULL);
fd = g_mkstemp (path);
if (fd == -1) {
g_warning ("failed to create temporary file for image data");
g_free (path);
return;
}
stream = g_unix_output_stream_new (fd, TRUE);
error = NULL;
if (!gdk_pixbuf_save_to_stream (pixbuf, stream, "png", NULL, &error, NULL)) {
g_warning ("failed to save image: %s", error->message);
g_error_free (error);
g_object_unref (stream);
return;
}
g_object_unref (stream);
act_user_set_icon_file (user, path);
/* if we ever make the dbus call async, the g_remove call needs
* to wait for its completion
*/
g_remove (path);
g_free (path);
}
