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);
}
