int create_table_file(uint32_t ip, int table, int resource_location) { char folder_path[512]; char file_path[512]; FILE *fp; memset(folder_path, 0, 512); ensure_dir_exists(RESOURCE_INTERFACE_PATH); strcpy(folder_path, RESOURCE_INTERFACE_PATH); switch(resource_location){ case DIRECT_RESOURCE: strcat(folder_path, RESOURCE_INTERFACE_PATH_DIRECT); break; case INDIRECT_RESOURCE: strcat(folder_path, RESOURCE_INTERFACE_PATH_INDIRECT); break; default: print_error("Unknown resource location\n"); return -1; } ensure_dir_exists(folder_path); sprintf(file_path, "%s%zu_table", folder_path, ip); fp = fopen(file_path, "w+"); fprintf(fp, "%d\n", table); fclose(fp); return 0; }
const gchar * eog_util_dot_dir (void) { if (dot_dir == NULL) { gboolean exists; dot_dir = g_build_filename (g_get_user_config_dir (), "eog", NULL); exists = ensure_dir_exists (dot_dir); if (G_UNLIKELY (!exists)) { static gboolean printed_warning = FALSE; if (!printed_warning) { g_warning ("EOG could not save some of your preferences in its settings directory due to a file with the same name (%s) blocking its creation. Please remove that file, or move it away.", dot_dir); printed_warning = TRUE; } g_free (dot_dir); dot_dir = NULL; return NULL; } } return dot_dir; }
static void ensure_dir_exists(char *dir) { struct stat stat_buf; char *parent; char *q; if (dir[0] == 0) { return; } parent = strdup(dir); q = strrchr(parent, '/'); if (q) { *q = 0; ensure_dir_exists(parent); } if (stat(dir, &stat_buf) < 0) { int res; #ifdef WINDOWS res = mkdir(dir); #endif #ifdef SOLARIS res = mkdir(dir, 0755); #endif if (res != 0) { fprintf(stderr, "Can't create directory: %s. Consider use the -jam -appsdir <other-dir> option.\n", dir); exit(1); } } browser_free(parent); }
const gchar * eom_util_dot_dir (void) { if (dot_dir == NULL) { gboolean exists; #if GLIB_CHECK_VERSION(2, 6, 0) dot_dir = g_build_filename(g_get_user_config_dir(), "mate", "eom", NULL); #else // glib version < 2.6.0 dot_dir = g_build_filename(g_get_home_dir(), ".config", "mate", "eom", NULL); #endif exists = ensure_dir_exists (dot_dir); if (G_UNLIKELY (!exists)) { static gboolean printed_warning = FALSE; if (!printed_warning) { g_warning ("EOM could not save some of your preferences in its settings directory due to a file with the same name (%s) blocking its creation. Please remove that file, or move it away.", dot_dir); printed_warning = TRUE; } dot_dir = NULL; return NULL; } } return dot_dir; }
const gchar * gsm_util_get_saved_session_dir (void) { if (_saved_session_dir == NULL) { gboolean exists; _saved_session_dir = g_build_filename (g_get_user_config_dir (), "mate-session", "saved-session", NULL); exists = ensure_dir_exists (_saved_session_dir); if (G_UNLIKELY (!exists)) { static gboolean printed_warning = FALSE; if (!printed_warning) { g_warning ("GsmSessionSave: could not create directory for saved session: %s", _saved_session_dir); printed_warning = TRUE; } _saved_session_dir = NULL; return NULL; } } return _saved_session_dir; }
gchar * gsm_util_get_empty_tmp_session_dir (void) { char *tmp; gboolean exists; tmp = g_build_filename (g_get_user_config_dir (), "mate-session", "saved-session.new", NULL); exists = ensure_dir_exists (tmp); if (G_UNLIKELY (!exists)) { g_warning ("GsmSessionSave: could not create directory for saved session: %s", tmp); g_free (tmp); return NULL; } else { /* make sure it's empty */ GDir *dir; const char *filename; dir = g_dir_open (tmp, 0, NULL); if (dir) { while ((filename = g_dir_read_name (dir))) { char *path = g_build_filename (tmp, filename, NULL); g_unlink (path); } g_dir_close (dir); } } return tmp; }
// mkpath - ensure all directories in path exist. // Returns 1 on success, 0 on failure. // Adapted from Jonathan Leffler http://stackoverflow.com/a/675193/431087 char mkpath(const char *path, mode_t mode) { char *copypath = strdup(path); size_t i = 0, j = 0; char status = 1; while(1) { while(path[i] == '.' || path[i] == '/') i++; j = i; while(path[j] != '.' && path[j] != '/' && path[j] != '\0') j++; if(i == j) break; char tmp = copypath[j]; copypath[j] = '\0'; if(!(status = ensure_dir_exists(copypath, mode))) break; if(tmp == '\0') break; copypath[j] = tmp; i = j + 1; } free(copypath); return status; }
// Save current picture as PNG void saveCurrentPic() { GdkPixbuf *scaledpb; GString *pngfilename; pngfilename = g_string_new(g_key_file_get_string(config,"slowrx","rxdir",NULL)); g_string_append_printf(pngfilename, "/%s_%s.png", CurrentPic.timestr, ModeSpec[CurrentPic.Mode].ShortName); printf(" Saving to %s\n", pngfilename->str); scaledpb = gdk_pixbuf_scale_simple (pixbuf_rx, ModeSpec[CurrentPic.Mode].ImgWidth, ModeSpec[CurrentPic.Mode].ImgHeight * ModeSpec[CurrentPic.Mode].YScale, GDK_INTERP_HYPER); ensure_dir_exists(g_key_file_get_string(config,"slowrx","rxdir",NULL)); gdk_pixbuf_savev(scaledpb, pngfilename->str, "png", NULL, NULL, NULL); g_object_unref(scaledpb); g_string_free(pngfilename, TRUE); }
static void convert_old_comment (char *real_file, char *rc_file, gpointer data) { char *comment_file; char *comment_dir; comment_file = comments_get_comment_filename (real_file, TRUE); comment_dir = remove_level_from_path (comment_file); ensure_dir_exists (comment_dir, 0755); file_copy (rc_file, comment_file); g_free (comment_dir); g_free (comment_file); }
/** * Change current working dir. */ bool change_dir(int sock,const char *parent_dir,char *current_dir,char *virtual_dir,char *data_buff) { DIR *dir = ensure_dir_exists(sock,data_buff); if(dir!=NULL) { closedir(dir); int status = chdir(current_dir); if(status==0) { int status = chdir(data_buff); if(status == 0) { if(getcwd(current_dir,MAXPATHLEN)!=NULL) { send_repl(sock,REPL_250); return TRUE; } } } } send_repl(sock,REPL_550); return FALSE; }
/** * Get and send the info for the current directory */ bool write_list(int sock, int client_sock, const char *current_dir) { if(client_sock>0) { if(sock!=client_sock) { send_repl(sock,REPL_150); } } else { if(sock!=client_sock) { send_repl(sock,REPL_425); } return FALSE; } DIR *dir = ensure_dir_exists(sock,current_dir); if(dir==NULL) { if(sock!=client_sock) { close(client_sock); send_repl(sock,REPL_451); } return FALSE; } char line[300]; while(1) { struct dirent *d_next = readdir(dir); if(d_next==NULL) break; line[0]='\0'; if(get_file_info(d_next->d_name,line)) { if(send_repl_client(client_sock,line)) { if(sock!=client_sock) send_repl(sock,REPL_451); } } } if(sock!=client_sock) { close(client_sock); send_repl(sock,REPL_226); //free(line); } //free(line); closedir(dir); return TRUE; }
static int ensure_dir_exists(td_engine *engine, td_file *dir) { int result; const td_stat *stat; td_file *parent_dir; if (engine->settings.dry_run) return 0; parent_dir = td_parent_dir(engine, dir); if (parent_dir) { if (0 != (result = ensure_dir_exists(engine, parent_dir))) return result; } stat = td_stat_file(engine, dir); if (TD_STAT_EXISTS & stat->flags) { if (0 == (stat->flags & TD_STAT_DIR)) { fprintf(stderr, "%s: couldn't create directory; file exists\n", dir->path); return 1; } else return 0; } else { if (0 != (result = td_mkdir(dir->path))) { fprintf(stderr, "%s: couldn't create directory\n", dir->path); return result; } /* could optimize to just set as a directory rather than stat again */ td_touch_file(engine, dir); return 0; } }
void JamInitializeStorage(char * dir) { strcpy(appsDir, dir); ensure_dir_exists(dir); #ifdef WINDOWS /* * Windows crashes if we have a mix of forward and backward slashes ... */ { char *p; for (p=appsDir; *p; p++) { if (*p == '\\') { *p = '/'; } } } #endif initTotalSpace(); }
static int run_job(td_job_queue *queue, td_node *node, int job_id) { double t1, mkdir_time, cmd_time; td_engine *engine = queue->engine; int i, count, result, was_signalled = 0; const char *command = node->action; if (!command || '\0' == command[0]) return 0; ++queue->jobs_run; pthread_mutex_unlock(&queue->mutex); t1 = td_timestamp(); /* ensure directories for output files exist */ for (i = 0, count = node->output_count; i < count; ++i) { td_file *dir = td_parent_dir(engine, node->outputs[i]); if (!dir) continue; if (0 != (result = ensure_dir_exists(engine, dir))) goto leave; } mkdir_time = td_timestamp() - t1; t1 = td_timestamp(); /* If the outputs of this node can't be overwritten; delete them now */ if (0 == (TD_NODE_OVERWRITE & node->flags)) { delete_outputs(node); touch_outputs(engine, node); } if (!engine->settings.dry_run) { result = td_exec( command, node->env_count, node->env, &was_signalled, job_id, td_verbosity_check(engine, 2), td_verbosity_check(engine, 1) ? node->annotation : NULL); } else result = 0; cmd_time = td_timestamp() - t1; if (0 != result) { td_mutex_lock_or_die(&queue->mutex); /* Maintain a fail count so we can track why we stopped building if * we're stopping after the first error. Otherwise it might appear as * we succeeded. */ ++queue->fail_count; /* If the command failed or was signalled (e.g. Ctrl+C), abort the build */ if (was_signalled) queue->siginfo.flag = -1; else if (!engine->settings.continue_on_error) queue->siginfo.flag = 1; td_mutex_unlock_or_die(&queue->mutex); } /* If the build failed, and the node isn't set to keep all its output files * in all possible cases (precious), then delete all output files as we * can't assume anything about their state. */ if (0 != result && 0 == (TD_NODE_PRECIOUS & node->flags)) delete_outputs(node); /* Mark all output files as dirty regardless of whether the build succeeded * or not. If it succeeded, we must assume the build overwrote them. * Otherwise, it's likely we've deleted them. In any case, touching them * again isn't going to hurt anything.*/ touch_outputs(engine, node); /* Update engine stats. */ if (td_debug_check(engine, TD_DEBUG_STATS)) { td_mutex_lock_or_die(engine->stats_lock); engine->stats.mkdir_time += mkdir_time; engine->stats.build_time += cmd_time; td_mutex_unlock_or_die(engine->stats_lock); } leave: td_mutex_lock_or_die(&queue->mutex); return result; }
struct index *index_new(const char *basedir, int max_mtbl_size, int tolog) { char dbfile[FILE_PATH_SIZE]; struct index *idx = malloc(sizeof(struct index)); struct idx_park *park = malloc(sizeof(struct idx_park)); ensure_dir_exists(basedir); idx->lsn = 0; idx->bloom_hits = 0; idx->bg_merge_count = 0; idx->max_mtbl = 1; idx->max_mtbl_size = max_mtbl_size; memset(idx->basedir, 0, FILE_PATH_SIZE); memcpy(idx->basedir, basedir, FILE_PATH_SIZE); /* sst */ idx->sst = sst_new(idx->basedir); idx->list = skiplist_new(max_mtbl_size); pthread_mutex_init(&idx->merge_mutex, NULL); /* container */ park->list = NULL; park->lsn = idx->lsn; idx->park = park; /* log */ idx->log = log_new(idx->basedir, idx->lsn, tolog); /* * Log Recovery Processes : * 1) read old log file and add entries to memtable * 2) read new log file abd add entries to memtable * 3) merge the current active log's memtable * 4) remove old log file, new log file * 5) create new memtable and log file */ if (log_recovery(idx->log, idx->list)) { __DEBUG(LEVEL_DEBUG, "prepare to merge logs, merge count #%d....", idx->list->count); sst_merge(idx->sst, idx->list, 1); remove(idx->log->log_new); remove(idx->log->log_old); idx->list = skiplist_new(idx->max_mtbl_size); } /* Create new log : 0.log */ log_next(idx->log, 0); memset(dbfile, 0, FILE_PATH_SIZE); snprintf(dbfile, FILE_PATH_SIZE, "%s/ness.db", idx->basedir); idx->db_rfd = open(dbfile, LSM_OPEN_FLAGS, 0644); /* Detached thread attr */ pthread_attr_init(&idx->attr); pthread_attr_setdetachstate(&idx->attr, PTHREAD_CREATE_DETACHED); return idx; }
static int extract_cb (GtkWidget *w, DialogData *data) { FrWindow *window = data->window; gboolean do_not_extract = FALSE; char *extract_to_dir; gboolean overwrite; gboolean skip_newer; gboolean selected_files; gboolean pattern_files; gboolean junk_paths; GList *file_list; char *base_dir = NULL; GError *error = NULL; data->extract_clicked = TRUE; /* collect extraction options. */ extract_to_dir = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->dialog)); /* check directory existence. */ if (! uri_is_dir (extract_to_dir)) { if (! ForceDirectoryCreation) { GtkWidget *d; int r; char *folder_name; char *msg; folder_name = g_filename_display_name (extract_to_dir); msg = g_strdup_printf (_("Destination folder \"%s\" does not exist.\n\nDo you want to create it?"), folder_name); g_free (folder_name); d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog), GTK_DIALOG_MODAL, GTK_STOCK_DIALOG_QUESTION, msg, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Create _Folder"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES); r = gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (msg); if (r != GTK_RESPONSE_YES) do_not_extract = TRUE; } if (! do_not_extract && ! ensure_dir_exists (extract_to_dir, 0755, &error)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Extraction not performed"), _("Could not create the destination folder: %s."), error->message); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_error_free (error); return FALSE; } } if (do_not_extract) { GtkWidget *d; d = _gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_DIALOG_WARNING, _("Extraction not performed"), NULL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); if (fr_window_is_batch_mode (data->window)) gtk_widget_destroy (data->dialog); return FALSE; } /* check extraction directory permissions. */ if (uri_is_dir (extract_to_dir) && ! check_permissions (extract_to_dir, R_OK | W_OK)) { GtkWidget *d; char *utf8_path; utf8_path = g_filename_display_name (extract_to_dir); d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Extraction not performed"), _("You don't have the right permissions to extract archives in the folder \"%s\""), utf8_path); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (utf8_path); g_free (extract_to_dir); return FALSE; } fr_window_set_extract_default_dir (window, extract_to_dir, TRUE); overwrite = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_overwrite_checkbutton)); skip_newer = ! gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton)) && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton)); junk_paths = ! gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_recreate_dir_checkbutton)); g_settings_set_boolean (data->settings, PREF_EXTRACT_OVERWRITE, overwrite); if (! gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (data->e_not_newer_checkbutton))) g_settings_set_boolean (data->settings, PREF_EXTRACT_SKIP_NEWER, skip_newer); g_settings_set_boolean (data->settings, PREF_EXTRACT_RECREATE_FOLDERS, ! junk_paths); selected_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_selected_radiobutton)); pattern_files = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (data->e_files_radiobutton)); /* create the file list. */ file_list = NULL; if (selected_files) { file_list = data->selected_files; data->selected_files = NULL; /* do not the list when destroying the dialog. */ } else if (pattern_files) { const char *pattern; pattern = gtk_entry_get_text (GTK_ENTRY (data->e_files_entry)); file_list = fr_window_get_file_list_pattern (window, pattern); if (file_list == NULL) { gtk_widget_destroy (data->dialog); g_free (extract_to_dir); return FALSE; } } if (selected_files) { base_dir = data->base_dir_for_selection; data->base_dir_for_selection = NULL; } else base_dir = NULL; /* close the dialog. */ gtk_widget_destroy (data->dialog); /* extract ! */ fr_window_archive_extract (window, file_list, extract_to_dir, base_dir, skip_newer, overwrite ? FR_OVERWRITE_YES : FR_OVERWRITE_NO, junk_paths, TRUE); path_list_free (file_list); g_free (extract_to_dir); g_free (base_dir); return TRUE; }
static void add_clicked_cb (GtkWidget *widget, DialogData *data) { FrWindow *window = data->window; char *archive_name; char *archive_dir; char *archive_file; char *tmp; const char *archive_ext; gboolean do_not_add = FALSE; GError *error = NULL; data->add_clicked = TRUE; /* Collect data */ archive_name = g_uri_escape_string (gtk_entry_get_text (GTK_ENTRY (data->a_add_to_entry)), NULL, FALSE); /* Check whether the user entered a valid archive name. */ if ((archive_name == NULL) || (*archive_name == '\0')) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), "%s", _("You have to specify an archive name.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_name); return; } else if (strchrs (archive_name, BAD_CHARS)) { GtkWidget *d; char *utf8_name = g_filename_display_name (archive_name); d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), _("The name \"%s\" is not valid because it cannot contain the characters: %s\n\n%s"), utf8_name, BAD_CHARS, _("Please use a different name.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (utf8_name); g_free (archive_name); return; } /* Check directory existence. */ archive_dir = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->a_location_filechooserbutton)); if (archive_dir == NULL) { g_free (archive_dir); g_free (archive_name); return; } if (! check_permissions (archive_dir, R_OK|W_OK|X_OK)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), "%s", _("You don't have the right permissions to create an archive in the destination folder.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_dir); g_free (archive_name); return; } if (! uri_is_dir (archive_dir)) { GtkWidget *d; int r; char *folder_name; char *msg; folder_name = g_filename_display_name (archive_dir); msg = g_strdup_printf (_("Destination folder \"%s\" does not exist.\n\nDo you want to create it?"), folder_name); g_free (folder_name); d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog), GTK_DIALOG_MODAL, GTK_STOCK_DIALOG_QUESTION, msg, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Create _Folder"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES); r = gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (msg); do_not_add = (r != GTK_RESPONSE_YES); } if (! do_not_add && ! ensure_dir_exists (archive_dir, 0755, &error)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), _("Could not create the destination folder: %s."), error->message); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_error_free (error); g_free (archive_dir); g_free (archive_name); return; } if (do_not_add) { GtkWidget *d; d = _gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_DIALOG_WARNING, _("Archive not created"), NULL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_dir); g_free (archive_name); return; } /**/ archive_ext = get_ext (data); tmp = archive_name; archive_name = g_strconcat (tmp, archive_ext, NULL); g_free (tmp); archive_file = g_strconcat (archive_dir, "/", archive_name, NULL); if (uri_is_dir (archive_file)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), "%s", _("You have to specify an archive name.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_name); g_free (archive_dir); g_free (archive_file); return; } if (uri_exists (archive_file)) { GtkWidget *d; int r; d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog), GTK_DIALOG_MODAL, GTK_STOCK_DIALOG_QUESTION, _("The archive is already present. Do you want to overwrite it?"), NULL, GTK_STOCK_NO, GTK_RESPONSE_NO, _("_Overwrite"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES); r = gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); if (r == GTK_RESPONSE_YES) { GFile *file; GError *err = NULL; /* FIXME: convert this code in a function in file-utils.c */ file = g_file_new_for_uri (archive_file); g_file_delete (file, NULL, &err); if (err != NULL) { g_warning ("Failed to delete file %s: %s", archive_file, err->message); g_clear_error (&err); } g_object_unref (file); } else { g_free (archive_name); g_free (archive_dir); g_free (archive_file); return; } } set_archive_options (data); gtk_widget_destroy (data->dialog); fr_window_archive_new (window, archive_file); g_free (archive_name); g_free (archive_dir); g_free (archive_file); }