static int modfile_move( INSTANCE * my, int * params ) { int r = file_move( string_get( params[0] ), string_get( params[1] ) ) ; string_discard( params[1] ) ; string_discard( params[0] ) ; return r ; }
struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags) { struct file * f; struct inode *inode; int error; error = -ENFILE; f = get_empty_filp(); if (!f) goto cleanup_dentry; f->f_flags = flags; f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = get_write_access(inode); if (error) goto cleanup_file; } f->f_mapping = inode->i_mapping; f->f_dentry = dentry; f->f_vfsmnt = mnt; f->f_pos = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &inode->i_sb->s_files); if (f->f_op && f->f_op->open) { error = f->f_op->open(inode,f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping); /* NB: we're sure to have correct a_ops only after f_op->open */ if (f->f_flags & O_DIRECT) { if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO) { fput(f); f = ERR_PTR(-EINVAL); } } return f; cleanup_all: fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) put_write_access(inode); file_kill(f); f->f_dentry = NULL; f->f_vfsmnt = NULL; cleanup_file: put_filp(f); cleanup_dentry: dput(dentry); mntput(mnt); return ERR_PTR(error); }
bool Preferences_Save_Safe( PreferenceDictionary& preferences, const char* filename ){ Array<char> tmpName( filename, filename + strlen( filename ) + 1 + 3 ); *( tmpName.end() - 4 ) = 'T'; *( tmpName.end() - 3 ) = 'M'; *( tmpName.end() - 2 ) = 'P'; *( tmpName.end() - 1 ) = '\0'; return Preferences_Save( preferences, tmpName.data() ) && ( !file_exists( filename ) || file_remove( filename ) ) && file_move( tmpName.data(), filename ); }
static bool file_saveBackup (const std::string& path) { if (file_writeable(path)) { std::string backup = os::stripExtension(path) + ".bak"; return (!file_exists(backup) || file_remove(backup)) // remove backup && file_move(path, backup); // rename current to backup } globalErrorStream() << "ERROR: map path is not writeable: " << path << "\n"; return false; }
/** * Move a file. * * This function will first attempt to rename the file. If the rename * fails because the file is being moved across file systems, it will * be copied to the destination file and the source file deleted. MD5 * checking will be used if the file needs to be copied across file * systems. * * This function will also add a "moving file" message to the log file. * * If an error occurs in this function it will be appended to the log and * error mail messages, and the process status will be set appropriately. * * @param src_file - full path to the source file * @param dest_file - full path to the destination file * * @return * - 1 if the file was moved successfully * - 0 if an error occurred */ int dsproc_move_file(const char *src_file, const char *dest_file) { LOG( DSPROC_LIB_NAME, "Moving: %s\n" " -> to: %s\n", src_file, dest_file); if (!file_move(src_file, dest_file, FC_CHECK_MD5)) { dsproc_set_status(DSPROC_EFILEMOVE); return(0); } return(1); }
bool file_saveBackup(const char* path) { if(file_writeable(path)) { StringOutputStream backup(256); backup << StringRange(path, path_get_extension(path)) << "bak"; return (!file_exists(backup.c_str()) || file_remove(backup.c_str())) // remove backup && file_move(path, backup.c_str()); // rename current to backup } globalErrorStream() << "map path is not writeable: " << makeQuoted(path) << "\n"; return false; }
struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags) { struct file * f; struct inode *inode; int error; error = -ENFILE; f = get_empty_filp(); if (!f) goto cleanup_dentry; f->f_flags = flags; f->f_mode = (flags+1) & O_ACCMODE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = get_write_access(inode); if (error) goto cleanup_file; } f->f_dentry = dentry; f->f_vfsmnt = mnt; f->f_pos = 0; f->f_reada = 0; f->f_op = fops_get(inode->i_fop); if (inode->i_sb) file_move(f, &inode->i_sb->s_files); if (f->f_op && f->f_op->open) { error = f->f_op->open(inode,f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); return f; cleanup_all: fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) put_write_access(inode); f->f_dentry = NULL; f->f_vfsmnt = NULL; cleanup_file: put_filp(f); cleanup_dentry: dput(dentry); mntput(mnt); return ERR_PTR(error); }
static int __ptmx_open(struct inode *inode, struct file *filp) { struct tty_struct *tty; int retval; int index; nonseekable_open(inode, filp); /* find a device that is not in use. */ tty_lock(); index = devpts_new_index(inode); tty_unlock(); if (index < 0) return index; mutex_lock(&tty_mutex); tty_lock(); tty = tty_init_dev(ptm_driver, index, 1); mutex_unlock(&tty_mutex); if (IS_ERR(tty)) { retval = PTR_ERR(tty); goto out; } set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */ filp->private_data = tty; file_move(filp, &tty->tty_files); retval = devpts_pty_new(inode, tty->link); if (retval) goto out1; retval = ptm_driver->ops->open(tty, filp); if (!retval) return 0; out1: tty_unlock(); tty_release(inode, filp); return retval; out: devpts_kill_index(inode, index); tty_unlock(); return retval; }
int my_rename( const char *old_path, const char *new_path ) { DISABLE_ERRORS; int result = -1; auto told_path = tstr(old_path); auto tnew_path = tstr(new_path); LPCTSTR p_old = MRP(told_path.get()); LPCTSTR p_new = MRP2(tnew_path.get()); result = my_access(old_path,0); if(result < 0) { // my_errno already set } else { if(is_same_drive(p_old,p_new)) { result = _trename( p_old, p_new ); if(result != 0) { // by definition, rename may also return a positive value to indicate an error my_errno = errno; } else { my_errno = 0; } } else { if(is_dir(p_old)) { result = folder_copy( p_old, p_new ); // my_errno already set if(result >= 0) { if(myRemoveDirectory( p_old )) { my_errno = 0; result = 0; } else { // there is no proper error code for this failure. my_errno = EACCES; result = -1; } } } else { result = file_move( p_old, p_new ); // my_errno already set } } } D(bug(TEXT("rename(%s,%s,%s,%s) = %d\n"), told_path.get(), p_old, tnew_path.get(), p_new, result)); RESTORE_ERRORS; return result; }
void cache_move (const char *src, const char *dest) { char *cache_src; time_t dest_mtime = get_file_mtime (dest); cache_src = cache_get_nautilus_cache_name (src); if (path_is_file (cache_src)) { char *cache_dest = cache_get_nautilus_cache_name (dest); if (path_is_file (cache_dest)) file_unlink (cache_dest); if (file_move (cache_src, cache_dest)) set_file_mtime (cache_dest, dest_mtime); g_free (cache_dest); } g_free (cache_src); }
/* * Remove old lines from pref files * * If you are using setgid, make sure privileges were raised prior * to calling this. */ static void remove_old_dump(const char *cur_fname, const char *mark) { bool between_marks = FALSE; bool changed = FALSE; char buf[1024]; char start_line[1024]; char end_line[1024]; char new_fname[1024]; ang_file *new_file; ang_file *cur_file; /* Format up some filenames */ strnfmt(new_fname, sizeof(new_fname), "%s.new", cur_fname); /* Work out what we expect to find */ strnfmt(start_line, sizeof(start_line), "%s begin %s", dump_separator, mark); strnfmt(end_line, sizeof(end_line), "%s end %s", dump_separator, mark); /* Open current file */ cur_file = file_open(cur_fname, MODE_READ, -1); if (!cur_file) return; /* Open new file */ new_file = file_open(new_fname, MODE_WRITE, FTYPE_TEXT); if (!new_file) { msg("Failed to create file %s", new_fname); return; } /* Loop for every line */ while (file_getl(cur_file, buf, sizeof(buf))) { /* If we find the start line, turn on */ if (!strcmp(buf, start_line)) { between_marks = TRUE; } /* If we find the finish line, turn off */ else if (!strcmp(buf, end_line)) { between_marks = FALSE; changed = TRUE; } if (!between_marks) { /* Copy orginal line */ file_putf(new_file, "%s\n", buf); } } /* Close files */ file_close(cur_file); file_close(new_file); /* If there are changes, move things around */ if (changed) { char old_fname[1024]; strnfmt(old_fname, sizeof(old_fname), "%s.old", cur_fname); if (file_move(cur_fname, old_fname)) { file_move(new_fname, cur_fname); file_delete(old_fname); } } /* Otherwise just destroy the new file */ else { file_delete(new_fname); } }
static struct file *__dentry_open(struct _dentry *dentry, struct vfsmount *mnt, int flags, struct file *f, int (*open)(struct _inode *, struct file *)) { struct _inode *inode; int error; struct super_block *sb; struct _file *_f = tx_cache_get_file(f); _f->f_flags = flags; _f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE; inode = d_get_inode(dentry); sb = inode->i_sb; if (_f->f_mode & FMODE_WRITE) { error = get_write_access(parent(inode)); if (error) goto cleanup_file; } f->f_mapping = inode->i_mapping; _f->f_path.dentry = parent(dentry); _f->f_path.mnt = mnt; _f->f_pos = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &sb->s_files); if (!open && f->f_op) open = f->f_op->open; if (open) { error = open(inode, f); if (error) goto cleanup_all; } _f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); file_ra_state_init(&f->f_ra, tx_cache_get_inode(f->f_mapping->host)->i_mapping); /* NB: we're sure to have correct a_ops only after f_op->open */ if (_f->f_flags & O_DIRECT) { if (!f->f_mapping->a_ops || ((!f->f_mapping->a_ops->direct_IO) && (!f->f_mapping->a_ops->get_xip_page))) { fput(f); f = ERR_PTR(-EINVAL); } } return f; cleanup_all: fops_put(f->f_op); if (_f->f_mode & FMODE_WRITE) put_write_access(parent(inode)); file_kill(f); _f->f_path.dentry = NULL; _f->f_path.mnt = NULL; cleanup_file: /* Avoid issues if we recycle this object */ if(live_transaction()) early_release(&f->xobj, 1); put_filp(f); dput(parent(dentry)); mntput(mnt); return ERR_PTR(error); }
int ipkg_conf_write_status_files(ipkg_conf_t *conf) { pkg_dest_list_elt_t *iter; pkg_dest_t *dest; pkg_vec_t *all; pkg_t *pkg; register int i; int err; if (conf->noaction) return 0; for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) { dest = iter->data; dest->status_file = fopen(dest->status_file_tmp_name, "w"); if (dest->status_file == NULL) { fprintf(stderr, "%s: Can't open status file: %s for writing: %s\n", __FUNCTION__, dest->status_file_name, strerror(errno)); } } all = pkg_vec_alloc(); pkg_hash_fetch_available(&conf->pkg_hash, all); for(i = 0; i < all->len; i++) { pkg = all->pkgs[i]; /* We don't need most uninstalled packages in the status file */ if (pkg->state_status == SS_NOT_INSTALLED && (pkg->state_want == SW_UNKNOWN || pkg->state_want == SW_DEINSTALL || pkg->state_want == SW_PURGE)) { continue; } if (!pkg) { fprintf(stderr, "Null package\n"); } if (pkg->dest == NULL) { fprintf(stderr, "%s: ERROR: Can't write status for " "package %s since it has a NULL dest\n", __FUNCTION__, pkg->name); continue; } if (pkg->dest->status_file) { pkg_print_status(pkg, pkg->dest->status_file); } } pkg_vec_free(all); for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) { dest = iter->data; if (dest->status_file) { err = ferror(dest->status_file); fclose(dest->status_file); dest->status_file = NULL; if (!err) { file_move(dest->status_file_tmp_name, dest->status_file_name); } else { fprintf(stderr, "%s: ERROR: An error has occurred writing %s, " "retaining old %s\n", __FUNCTION__, dest->status_file_tmp_name, dest->status_file_name); } } } return 0; }
/** * Actually place an entry into the high score file * Return the location (0 is best) or -1 on "failure" */ static void highscore_write(const high_score scores[], size_t sz) { size_t n; ang_file *lok; ang_file *scorefile; char old_name[1024]; char cur_name[1024]; char new_name[1024]; char lok_name[1024]; path_build(old_name, sizeof(old_name), ANGBAND_DIR_SCORES, "scores.old"); path_build(cur_name, sizeof(cur_name), ANGBAND_DIR_SCORES, "scores.raw"); path_build(new_name, sizeof(new_name), ANGBAND_DIR_SCORES, "scores.new"); path_build(lok_name, sizeof(lok_name), ANGBAND_DIR_SCORES, "scores.lok"); /* Read in and add new score */ n = highscore_count(scores, sz); /* Lock scores */ if (file_exists(lok_name)) { msg("Lock file in place for scorefile; not writing."); return; } safe_setuid_grab(); lok = file_open(lok_name, MODE_WRITE, FTYPE_RAW); file_lock(lok); safe_setuid_drop(); if (!lok) { msg("Failed to create lock for scorefile; not writing."); return; } /* Open the new file for writing */ safe_setuid_grab(); scorefile = file_open(new_name, MODE_WRITE, FTYPE_RAW); safe_setuid_drop(); if (!scorefile) { msg("Failed to open new scorefile for writing."); file_close(lok); file_delete(lok_name); return; } file_write(scorefile, (const char *)scores, sizeof(high_score)*n); file_close(scorefile); /* Now move things around */ safe_setuid_grab(); if (file_exists(old_name) && !file_delete(old_name)) msg("Couldn't delete old scorefile"); if (file_exists(cur_name) && !file_move(cur_name, old_name)) msg("Couldn't move old scores.raw out of the way"); if (!file_move(new_name, cur_name)) msg("Couldn't rename new scorefile to scores.raw"); /* Remove the lock */ file_close(lok); file_delete(lok_name); safe_setuid_drop(); }
int opkg_download(const char *src, const char *dest_file_name, curl_progress_func cb, void *data, const short hide_error) { int err = 0; char *src_basec = xstrdup(src); char *src_base = basename(src_basec); char *tmp_file_location; opkg_msg(NOTICE,"Downloading %s.\n", src); if (str_starts_with(src, "file:")) { const char *file_src = src + 5; opkg_msg(INFO, "Copying %s to %s...", file_src, dest_file_name); err = file_copy(file_src, dest_file_name); opkg_msg(INFO, "Done.\n"); free(src_basec); return err; } sprintf_alloc(&tmp_file_location, "%s/%s", conf->tmp_dir, src_base); free(src_basec); err = unlink(tmp_file_location); if (err && errno != ENOENT) { opkg_perror(ERROR, "Failed to unlink %s", tmp_file_location); free(tmp_file_location); return -1; } if (conf->http_proxy) { opkg_msg(DEBUG, "Setting environment variable: http_proxy = %s.\n", conf->http_proxy); setenv("http_proxy", conf->http_proxy, 1); } if (conf->ftp_proxy) { opkg_msg(DEBUG, "Setting environment variable: ftp_proxy = %s.\n", conf->ftp_proxy); setenv("ftp_proxy", conf->ftp_proxy, 1); } if (conf->no_proxy) { opkg_msg(DEBUG,"Setting environment variable: no_proxy = %s.\n", conf->no_proxy); setenv("no_proxy", conf->no_proxy, 1); } #ifdef HAVE_CURL CURLcode res; FILE * file = fopen (tmp_file_location, "w"); curl = opkg_curl_init (cb, data); if (curl) { curl_easy_setopt (curl, CURLOPT_URL, src); curl_easy_setopt (curl, CURLOPT_WRITEDATA, file); res = curl_easy_perform (curl); fclose (file); if (res) { long error_code; curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &error_code); opkg_msg(hide_error?DEBUG2:ERROR, "Failed to download %s: %s.\n", src, curl_easy_strerror(res)); free(tmp_file_location); return -1; } } else { free(tmp_file_location); return -1; } #else { int res; const char *argv[8]; int i = 0; argv[i++] = "wget"; argv[i++] = "-q"; if (conf->http_proxy || conf->ftp_proxy) { argv[i++] = "-Y"; argv[i++] = "on"; } argv[i++] = "-O"; argv[i++] = tmp_file_location; argv[i++] = src; argv[i++] = NULL; res = xsystem(argv); if (res) { opkg_msg(ERROR, "Failed to download %s, wget returned %d.\n", src, res); free(tmp_file_location); return -1; } } #endif err = file_move(tmp_file_location, dest_file_name); free(tmp_file_location); return err; }
/** * Static: Rename a data file. * * This function will rename a raw data file into the datastream directory * using the datastream name and begin_time to give it a fully qualified * ARM name. * * The begin_time will be validated using: * * dsproc_validate_datastream_data_time() * * If the end_time is specified, this function will verify that it is greater * than the begin_time and is not in the future. If only one record was found * in the raw file, the end_time argument must be set to NULL. * * If the output file exists and has the same MD5 as the input file, * the input file will be removed and a warning message will be generated. * * If the output file exists and has a different MD5 than the input * file, the rename will fail. * * If an error occurs in this function it will be appended to the log and * error mail messages, and the process status will be set appropriately. * * @param ds_id - datastream ID * @param file_path - path to the directory the file is in * @param file_name - name of the file to rename * @param begin_time - time of the first record in the file * @param end_time - time of the last record in the file * @param extension - extension to use when renaming the file, or NULL to * use the default extension for the datastream format. * * @return * - 1 if successful * - 0 if an error occurred */ static int _dsproc_rename( int ds_id, const char *file_path, const char *file_name, const timeval_t *begin_time, const timeval_t *end_time, const char *extension) { DataStream *ds = _DSProc->datastreams[ds_id]; time_t now = time(NULL); int force_mode = dsproc_get_force_mode(); char src_file[PATH_MAX]; struct stat src_stats; char src_md5[64]; char done_dir[PATH_MAX]; char *dest_path; char dest_name[256]; char dest_file[PATH_MAX]; char dest_md5[64]; struct tm time_stamp_tm; char time_stamp[32]; char time_string1[32]; char time_string2[32]; const char *preserve; int dot_count; char rename_error[2*PATH_MAX]; int rename_file; memset(&time_stamp_tm, 0, sizeof(struct tm)); DEBUG_LV1( DSPROC_LIB_NAME, "%s: Renaming file: %s/%s\n", ds->name, file_path, file_name); /************************************************************ * Get source file stats *************************************************************/ snprintf(src_file, PATH_MAX, "%s/%s", file_path, file_name); if (access(src_file, F_OK) != 0) { if (errno == ENOENT) { ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> file does not exist\n", src_file); dsproc_set_status(DSPROC_ENOSRCFILE); } else { ERROR( DSPROC_LIB_NAME, "Could not access file: %s\n" " -> %s\n", src_file, strerror(errno)); dsproc_set_status(DSPROC_EACCESS); } return(0); } if (stat(src_file, &src_stats) < 0) { ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> stat error: %s\n", src_file, strerror(errno)); dsproc_set_status(DSPROC_EFILESTATS); return(0); } /************************************************************ * Validate datastream times *************************************************************/ /* validate begin time */ if (!force_mode) { if (!begin_time || !begin_time->tv_sec) { ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> file time not specified\n", src_file); dsproc_set_status(DSPROC_ENOFILETIME); return(0); } if (!dsproc_validate_datastream_data_time(ds_id, begin_time)) { ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> time validation error\n", src_file); return(0); } /* validate end time */ if (end_time && end_time->tv_sec) { if (TV_LTEQ(*end_time, *begin_time)) { format_timeval(begin_time, time_string2); format_timeval(end_time, time_string1); ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> end time '%s' <= begin time '%s'\n", src_file, time_string1, time_string2); dsproc_set_status(DSPROC_ETIMEORDER); return(0); } else if (end_time->tv_sec > now) { format_timeval(end_time, time_string1); format_secs1970(now, time_string2); ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> data time '%s' is in the future (current time is: %s)\n", src_file, time_string1, time_string2); dsproc_disable(DSPROC_EFUTURETIME); return(0); } } } /************************************************************ * Determine the portion of the original file name to preserve *************************************************************/ preserve = (const char *)NULL; if (ds->preserve_dots > 0) { dot_count = 0; for (preserve = file_name + strlen(file_name) - 1; preserve != file_name; preserve--) { if (*preserve == '.') { dot_count++; if (dot_count == ds->preserve_dots) { preserve++; break; } } } } /************************************************************ * Get the full path to the destination directory *************************************************************/ snprintf(done_dir, PATH_MAX, "%s/.done", file_path); if (access(done_dir, F_OK) == 0) { dest_path = done_dir; } else if (errno != ENOENT) { ERROR( DSPROC_LIB_NAME, "Could not access directory: %s\n" " -> %s\n", done_dir, strerror(errno)); dsproc_set_status(DSPROC_EACCESS); return(0); } else { dest_path = ds->dir->path; /* Make sure the destination directory exists */ if (!make_path(dest_path, 0775)) { ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> make_path failed for: %s\n", src_file, dest_path); dsproc_set_status(DSPROC_EDESTDIRMAKE); return(0); } } /************************************************************ * Create the time stamp for the destination file *************************************************************/ if (!gmtime_r(&begin_time->tv_sec, &time_stamp_tm)) { ERROR( DSPROC_LIB_NAME, "Could not rename file: %s\n" " -> gmtime error: %s\n", src_file, strerror(errno)); dsproc_set_status(DSPROC_ETIMECALC); return(0); } strftime(time_stamp, 32, "%Y%m%d.%H%M%S", &time_stamp_tm); /************************************************************ * Create the output file name *************************************************************/ if (!extension) { extension = ds->extension; } if (preserve) { snprintf(dest_name, 256, "%s.%s.%s.%s", ds->name, time_stamp, extension, preserve); } else { snprintf(dest_name, 256, "%s.%s.%s", ds->name, time_stamp, extension); } snprintf(dest_file, PATH_MAX, "%s/%s", dest_path, dest_name); /************************************************************ * Check if the output file already exists *************************************************************/ rename_file = 1; if (access(dest_file, F_OK) == 0) { sprintf(rename_error, "\n" "Found existing destination file while renaming source file:\n" " -> from: %s\n" " -> to: %s\n", src_file, dest_file); /* Check the MD5s */ if (!file_get_md5(src_file, src_md5)) { ERROR( DSPROC_LIB_NAME, "%s -> could not get source file MD5\n", rename_error); dsproc_set_status(DSPROC_EFILEMD5); return(0); } if (!file_get_md5(dest_file, dest_md5)) { ERROR( DSPROC_LIB_NAME, "%s -> could not get destination file MD5\n", rename_error); dsproc_set_status(DSPROC_EFILEMD5); return(0); } if (strcmp(src_md5, dest_md5) == 0) { /* The MD5s match so delete the input file */ if (unlink(src_file) < 0) { ERROR( DSPROC_LIB_NAME, "%s" " -> source and destination files have matching MD5s\n" " -> could not delete source file: %s\n", rename_error, strerror(errno)); dsproc_set_status(DSPROC_EUNLINK); return(0); } WARNING( DSPROC_LIB_NAME, "%s" " -> source and destination files have matching MD5s\n" " -> deleted source file\n", rename_error); rename_file = 0; } else { /* The MD5s do not match */ ERROR( DSPROC_LIB_NAME, "%s" " -> source and destination files have different MD5s\n", rename_error); dsproc_set_status(DSPROC_EMD5CHECK); return(0); } } else if (errno != ENOENT) { ERROR( DSPROC_LIB_NAME, "Could not access file: %s\n" " -> %s\n", dest_file, strerror(errno)); dsproc_set_status(DSPROC_EACCESS); return(0); } /************************************************************ * Rename the file *************************************************************/ if (rename_file) { LOG( DSPROC_LIB_NAME, "Renaming: %s\n" " -> to: %s\n", src_file, dest_file); if (!file_move(src_file, dest_file, FC_CHECK_MD5)) { dsproc_set_status(DSPROC_EFILEMOVE); return(0); } /* Update the access and modification times */ utime(dest_file, NULL); } /************************************************************ * Update the datastream file stats *************************************************************/ dsproc_update_datastream_file_stats( ds_id, (double)src_stats.st_size, begin_time, end_time); return(1); }
/* * Attempt to save the player in a savefile */ bool savefile_save(const char *path) { ang_file *file; char new_savefile[1024]; char old_savefile[1024]; /* New savefile */ strnfmt(new_savefile, sizeof(new_savefile), "%s.new", path); strnfmt(old_savefile, sizeof(old_savefile), "%s.old", path); /* Make sure that the savefile doesn't already exist */ safe_setuid_grab(); file_delete(new_savefile); file_delete(old_savefile); safe_setuid_drop(); /* Open the savefile */ safe_setuid_grab(); file = file_open(new_savefile, MODE_WRITE, FTYPE_SAVE); safe_setuid_drop(); if (file) { file_write(file, (char *) &savefile_magic, 4); file_write(file, (char *) &savefile_name, 4); character_saved = try_save(file); file_close(file); } if (character_saved) { bool err = FALSE; safe_setuid_grab(); if (file_exists(savefile) && !file_move(savefile, old_savefile)) err = TRUE; if (!err) { if (!file_move(new_savefile, savefile)) err = TRUE; if (err) file_move(old_savefile, savefile); else file_delete(old_savefile); } safe_setuid_drop(); return err ? FALSE : TRUE; } /* Delete temp file */ safe_setuid_grab(); file_delete(new_savefile); safe_setuid_drop(); return FALSE; }
struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags) { struct file * f; struct inode *inode; static LIST_HEAD(kill_list); int error; error = -ENFILE; f = get_empty_filp(); if (!f) goto cleanup_dentry; f->f_flags = flags; f->f_mode = (flags+1) & O_ACCMODE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = get_write_access(inode); if (error) goto cleanup_file; } f->f_dentry = dentry; f->f_vfsmnt = mnt; f->f_pos = 0; f->f_reada = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &inode->i_sb->s_files); /* preallocate kiobuf for O_DIRECT */ f->f_iobuf = NULL; f->f_iobuf_lock = 0; if (f->f_flags & O_DIRECT) { error = alloc_kiovec(1, &f->f_iobuf); if (error) goto cleanup_all; } if (f->f_op && f->f_op->open) { error = f->f_op->open(inode,f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); return f; cleanup_all: if (f->f_iobuf) free_kiovec(1, &f->f_iobuf); fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) put_write_access(inode); file_move(f, &kill_list); /* out of the way.. */ f->f_dentry = NULL; f->f_vfsmnt = NULL; cleanup_file: put_filp(f); cleanup_dentry: dput(dentry); mntput(mnt); return ERR_PTR(error); }
static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags, struct file *f, int (*open)(struct inode *, struct file *), const struct cred *cred) { struct inode *inode; int error; f->f_flags = flags; f->f_mode = (__force fmode_t)((flags+1) & O_ACCMODE) | FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = __get_file_write_access(inode, mnt); if (error) goto cleanup_file; if (!special_file(inode->i_mode)) file_take_write(f); } f->f_mapping = inode->i_mapping; f->f_path.dentry = dentry; f->f_path.mnt = mnt; f->f_pos = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &inode->i_sb->s_files); error = security_dentry_open(f, cred); if (error) goto cleanup_all; if (!open && f->f_op) open = f->f_op->open; if (open) { error = open(inode, f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping); /* NB: we're sure to have correct a_ops only after f_op->open */ if (f->f_flags & O_DIRECT) { if (!f->f_mapping->a_ops || ((!f->f_mapping->a_ops->direct_IO) && (!f->f_mapping->a_ops->get_xip_mem))) { fput(f); f = ERR_PTR(-EINVAL); } } return f; cleanup_all: fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) { put_write_access(inode); if (!special_file(inode->i_mode)) { /* * We don't consider this a real * mnt_want/drop_write() pair * because it all happenend right * here, so just reset the state. */ file_reset_write(f); mnt_drop_write(mnt); } } file_kill(f); f->f_path.dentry = NULL; f->f_path.mnt = NULL; cleanup_file: put_filp(f); dput(dentry); mntput(mnt); return ERR_PTR(error); }
/* * Attempt to save the player in a savefile */ bool savefile_save(const char *path) { ang_file *file; int count = 0; char new_savefile[1024]; char old_savefile[1024]; /* New savefile */ strnfmt(old_savefile, sizeof(old_savefile), "%s%u.old", path,Rand_simple(1000000)); while (file_exists(old_savefile) && (count++ < 100)) { strnfmt(old_savefile, sizeof(old_savefile), "%s%u%u.old", path,Rand_simple(1000000),count); } count = 0; /* Make sure that the savefile doesn't already exist */ /*safe_setuid_grab(); file_delete(new_savefile); file_delete(old_savefile); safe_setuid_drop();*/ /* Open the savefile */ safe_setuid_grab(); strnfmt(new_savefile, sizeof(new_savefile), "%s%u.new", path,Rand_simple(1000000)); while (file_exists(new_savefile) && (count++ < 100)) { strnfmt(new_savefile, sizeof(new_savefile), "%s%u%u.new", path,Rand_simple(1000000),count); } file = file_open(new_savefile, MODE_WRITE, FTYPE_SAVE); safe_setuid_drop(); if (file) { file_write(file, (char *) &savefile_magic, 4); file_write(file, (char *) &savefile_name, 4); character_saved = try_save(file); file_close(file); } if (character_saved) { bool err = FALSE; safe_setuid_grab(); if (file_exists(savefile) && !file_move(savefile, old_savefile)) err = TRUE; if (!err) { if (!file_move(new_savefile, savefile)) err = TRUE; if (err) file_move(old_savefile, savefile); else file_delete(old_savefile); } safe_setuid_drop(); return err ? FALSE : TRUE; } /* Delete temp file if the save failed */ if (file) { /* file is no longer valid, but it still points to a non zero * value if the file was created above */ safe_setuid_grab(); file_delete(new_savefile); safe_setuid_drop(); } return FALSE; }
static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags, struct file *f) { struct inode *inode; static LIST_HEAD(kill_list); int error; f->f_flags = flags; f->f_mode = (flags+1) & O_ACCMODE; inode = dentry->d_inode; if (f->f_mode & FMODE_WRITE) { error = get_write_access(inode); if (error) goto cleanup_file; } f->f_dentry = dentry; f->f_vfsmnt = mnt; f->f_pos = 0; f->f_reada = 0; f->f_op = fops_get(inode->i_fop); file_move(f, &inode->i_sb->s_files); /* preallocate kiobuf for O_DIRECT */ f->f_iobuf = NULL; f->f_iobuf_lock = 0; if (f->f_flags & O_DIRECT) { error = alloc_kiovec(1, &f->f_iobuf); if (error) goto cleanup_all; } if (f->f_op && f->f_op->open) { error = f->f_op->open(inode,f); if (error) goto cleanup_all; } f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); /* NB: we're sure to have correct a_ops only after f_op->open */ if (f->f_flags & O_DIRECT) { if (!inode->i_mapping || !inode->i_mapping->a_ops || !(inode->i_mapping->a_ops->direct_IO || inode->i_mapping->a_ops->direct_sector_IO)) { fput(f); f = ERR_PTR(-EINVAL); } } return f; cleanup_all: if (f->f_iobuf) free_kiovec(1, &f->f_iobuf); fops_put(f->f_op); if (f->f_mode & FMODE_WRITE) put_write_access(inode); file_move(f, &kill_list); /* out of the way.. */ f->f_dentry = NULL; f->f_vfsmnt = NULL; cleanup_file: put_filp(f); dput(dentry); mntput(mnt); return ERR_PTR(error); }