// bufwrite.c: functions for writing a buffer #include #include #include #include #include #include #include #include #include "auto/config.h" #include "nvim/ascii_defs.h" #include "nvim/autocmd.h" #include "nvim/buffer.h" #include "nvim/buffer_defs.h" #include "nvim/bufwrite.h" #include "nvim/change.h" #include "nvim/drawscreen.h" #include "nvim/eval.h" #include "nvim/eval/typval_defs.h" #include "nvim/ex_cmds.h" #include "nvim/ex_cmds_defs.h" #include "nvim/ex_eval.h" #include "nvim/fileio.h" #include "nvim/gettext.h" #include "nvim/globals.h" #include "nvim/highlight.h" #include "nvim/iconv_defs.h" #include "nvim/input.h" #include "nvim/macros_defs.h" #include "nvim/mbyte.h" #include "nvim/memline.h" #include "nvim/memory.h" #include "nvim/message.h" #include "nvim/option.h" #include "nvim/option_vars.h" #include "nvim/os/fs.h" #include "nvim/os/input.h" #include "nvim/path.h" #include "nvim/pos_defs.h" #include "nvim/sha256.h" #include "nvim/strings.h" #include "nvim/types_defs.h" #include "nvim/ui.h" #include "nvim/undo.h" #include "nvim/vim_defs.h" static const char *err_readonly = "is read-only (cannot override: \"W\" in 'cpoptions')"; static const char e_patchmode_cant_touch_empty_original_file[] = N_("E206: Patchmode: can't touch empty original file"); static const char e_write_error_conversion_failed_make_fenc_empty_to_override[] = N_("E513: Write error, conversion failed (make 'fenc' empty to override)"); static const char e_write_error_conversion_failed_in_line_nr_make_fenc_empty_to_override[] = N_("E513: Write error, conversion failed in line %" PRIdLINENR " (make 'fenc' empty to override)"); static const char e_write_error_file_system_full[] = N_("E514: Write error (file system full?)"); static const char e_no_matching_autocommands_for_buftype_str_buffer[] = N_("E676: No matching autocommands for buftype=%s buffer"); typedef struct { const char *num; char *msg; int arg; bool alloc; } Error_T; #define SMALLBUFSIZE 256 // size of emergency write buffer // Structure to pass arguments from buf_write() to buf_write_bytes(). struct bw_info { int bw_fd; // file descriptor char *bw_buf; // buffer with data to be written int bw_len; // length of data int bw_flags; // FIO_ flags uint8_t bw_rest[CONV_RESTLEN]; // not converted bytes int bw_restlen; // nr of bytes in bw_rest[] int bw_first; // first write call char *bw_conv_buf; // buffer for writing converted chars size_t bw_conv_buflen; // size of bw_conv_buf int bw_conv_error; // set for conversion error linenr_T bw_conv_error_lnum; // first line with error or zero linenr_T bw_start_lnum; // line number at start of buffer iconv_t bw_iconv_fd; // descriptor for iconv() or -1 }; #ifdef INCLUDE_GENERATED_DECLARATIONS # include "bufwrite.c.generated.h" #endif /// Convert a Unicode character to bytes. /// /// @param c character to convert /// @param[in,out] pp pointer to store the result at /// @param flags FIO_ flags that specify which encoding to use /// /// @return true for an error, false when it's OK. static bool ucs2bytes(unsigned c, char **pp, int flags) FUNC_ATTR_NONNULL_ALL { uint8_t *p = (uint8_t *)(*pp); bool error = false; if (flags & FIO_UCS4) { if (flags & FIO_ENDIAN_L) { *p++ = (uint8_t)c; *p++ = (uint8_t)(c >> 8); *p++ = (uint8_t)(c >> 16); *p++ = (uint8_t)(c >> 24); } else { *p++ = (uint8_t)(c >> 24); *p++ = (uint8_t)(c >> 16); *p++ = (uint8_t)(c >> 8); *p++ = (uint8_t)c; } } else if (flags & (FIO_UCS2 | FIO_UTF16)) { if (c >= 0x10000) { if (flags & FIO_UTF16) { // Make two words, ten bits of the character in each. First // word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff c -= 0x10000; if (c >= 0x100000) { error = true; } int cc = (int)(((c >> 10) & 0x3ff) + 0xd800); if (flags & FIO_ENDIAN_L) { *p++ = (uint8_t)cc; *p++ = (uint8_t)(cc >> 8); } else { *p++ = (uint8_t)(cc >> 8); *p++ = (uint8_t)cc; } c = (c & 0x3ff) + 0xdc00; } else { error = true; } } if (flags & FIO_ENDIAN_L) { *p++ = (uint8_t)c; *p++ = (uint8_t)(c >> 8); } else { *p++ = (uint8_t)(c >> 8); *p++ = (uint8_t)c; } } else { // Latin1 if (c >= 0x100) { error = true; *p++ = 0xBF; } else { *p++ = (uint8_t)c; } } *pp = (char *)p; return error; } static int buf_write_convert_with_iconv(struct bw_info *ip, char **bufp, int *lenp) { const char *from; size_t fromlen; size_t tolen; int len = *lenp; // Convert with iconv(). if (ip->bw_restlen > 0) { // Need to concatenate the remainder of the previous call and // the bytes of the current call. Use the end of the // conversion buffer for this. fromlen = (size_t)len + (size_t)ip->bw_restlen; char *fp = ip->bw_conv_buf + ip->bw_conv_buflen - fromlen; memmove(fp, ip->bw_rest, (size_t)ip->bw_restlen); memmove(fp + ip->bw_restlen, *bufp, (size_t)len); from = fp; tolen = ip->bw_conv_buflen - fromlen; } else { from = *bufp; fromlen = (size_t)len; tolen = ip->bw_conv_buflen; } char *to = ip->bw_conv_buf; if (ip->bw_first) { size_t save_len = tolen; // output the initial shift state sequence (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen); // There is a bug in iconv() on Linux (which appears to be // wide-spread) which sets "to" to NULL and messes up "tolen". if (to == NULL) { to = ip->bw_conv_buf; tolen = save_len; } ip->bw_first = false; } // If iconv() has an error or there is not enough room, fail. if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen) == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL) || fromlen > CONV_RESTLEN) { ip->bw_conv_error = true; return FAIL; } // copy remainder to ip->bw_rest[] to be used for the next call. if (fromlen > 0) { memmove(ip->bw_rest, (void *)from, fromlen); } ip->bw_restlen = (int)fromlen; *bufp = ip->bw_conv_buf; *lenp = (int)(to - ip->bw_conv_buf); return OK; } static int buf_write_convert(struct bw_info *ip, char **bufp, int *lenp) { int flags = ip->bw_flags; // extra flags if (flags & FIO_UTF8) { // Convert latin1 in the buffer to UTF-8 in the file. char *p = ip->bw_conv_buf; // translate to buffer for (int wlen = 0; wlen < *lenp; wlen++) { p += utf_char2bytes((uint8_t)(*bufp)[wlen], p); } *bufp = ip->bw_conv_buf; *lenp = (int)(p - ip->bw_conv_buf); } else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1)) { unsigned c; int n = 0; // Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or // Latin1 chars in the file. // translate in-place (can only get shorter) or to buffer char *p = flags & FIO_LATIN1 ? *bufp : ip->bw_conv_buf; for (int wlen = 0; wlen < *lenp; wlen += n) { if (wlen == 0 && ip->bw_restlen != 0) { // Use remainder of previous call. Append the start of // buf[] to get a full sequence. Might still be too // short! int l = MIN(*lenp, CONV_RESTLEN - ip->bw_restlen); memmove(ip->bw_rest + ip->bw_restlen, *bufp, (size_t)l); n = utf_ptr2len_len((char *)ip->bw_rest, ip->bw_restlen + l); if (n > ip->bw_restlen + *lenp) { // We have an incomplete byte sequence at the end to // be written. We can't convert it without the // remaining bytes. Keep them for the next call. if (ip->bw_restlen + *lenp > CONV_RESTLEN) { return FAIL; } ip->bw_restlen += *lenp; break; } if (n > 1) { c = (unsigned)utf_ptr2char((char *)ip->bw_rest); } else { c = ip->bw_rest[0]; } if (n >= ip->bw_restlen) { n -= ip->bw_restlen; ip->bw_restlen = 0; } else { ip->bw_restlen -= n; memmove(ip->bw_rest, ip->bw_rest + n, (size_t)ip->bw_restlen); n = 0; } } else { n = utf_ptr2len_len(*bufp + wlen, *lenp - wlen); if (n > *lenp - wlen) { // We have an incomplete byte sequence at the end to // be written. We can't convert it without the // remaining bytes. Keep them for the next call. if (*lenp - wlen > CONV_RESTLEN) { return FAIL; } ip->bw_restlen = *lenp - wlen; memmove(ip->bw_rest, *bufp + wlen, (size_t)ip->bw_restlen); break; } if (n > 1) { c = (unsigned)utf_ptr2char(*bufp + wlen); } else { c = (uint8_t)(*bufp)[wlen]; } } if (ucs2bytes(c, &p, flags) && !ip->bw_conv_error) { ip->bw_conv_error = true; ip->bw_conv_error_lnum = ip->bw_start_lnum; } if (c == NL) { ip->bw_start_lnum++; } } if (flags & FIO_LATIN1) { *lenp = (int)(p - *bufp); } else { *bufp = ip->bw_conv_buf; *lenp = (int)(p - ip->bw_conv_buf); } } if (ip->bw_iconv_fd != (iconv_t)-1) { if (buf_write_convert_with_iconv(ip, bufp, lenp) == FAIL) { return FAIL; } } return OK; } /// Call write() to write a number of bytes to the file. /// Handles 'encoding' conversion. /// /// @return FAIL for failure, OK otherwise. static int buf_write_bytes(struct bw_info *ip) { char *buf = ip->bw_buf; // data to write int len = ip->bw_len; // length of data int flags = ip->bw_flags; // extra flags // Skip conversion when writing the BOM. if (!(flags & FIO_NOCONVERT)) { if (buf_write_convert(ip, &buf, &len) == FAIL) { return FAIL; } } if (ip->bw_fd < 0) { // Only checking conversion, which is OK if we get here. return OK; } int wlen = write_eintr(ip->bw_fd, buf, (size_t)len); return (wlen < len) ? FAIL : OK; } /// Check modification time of file, before writing to it. /// The size isn't checked, because using a tool like "gzip" takes care of /// using the same timestamp but can't set the size. static int check_mtime(buf_T *buf, FileInfo *file_info) { if (buf->b_mtime_read != 0 && time_differs(file_info, buf->b_mtime_read, buf->b_mtime_read_ns)) { msg_scroll = true; // Don't overwrite messages here. msg_silent = 0; // Must give this prompt. // Don't use emsg() here, don't want to flush the buffers. msg(_("WARNING: The file has been changed since reading it!!!"), HL_ATTR(HLF_E)); if (ask_yesno(_("Do you really want to write to it"), true) == 'n') { return FAIL; } msg_scroll = false; // Always overwrite the file message now. } return OK; } /// Generate a BOM in "buf[4]" for encoding "name". /// /// @return the length of the BOM (zero when no BOM). static int make_bom(char *buf_in, char *name) { uint8_t *buf = (uint8_t *)buf_in; int flags = get_fio_flags(name); // Can't put a BOM in a non-Unicode file. if (flags == FIO_LATIN1 || flags == 0) { return 0; } if (flags == FIO_UTF8) { // UTF-8 buf[0] = 0xef; buf[1] = 0xbb; buf[2] = 0xbf; return 3; } char *p = (char *)buf; (void)ucs2bytes(0xfeff, &p, flags); return (int)((uint8_t *)p - buf); } static int buf_write_do_autocmds(buf_T *buf, char **fnamep, char **sfnamep, char **ffnamep, linenr_T start, linenr_T *endp, exarg_T *eap, bool append, bool filtering, bool reset_changed, bool overwriting, bool whole, const pos_T orig_start, const pos_T orig_end) { linenr_T old_line_count = buf->b_ml.ml_line_count; int msg_save = msg_scroll; aco_save_T aco; bool did_cmd = false; bool nofile_err = false; bool empty_memline = buf->b_ml.ml_mfp == NULL; bufref_T bufref; char *sfname = *sfnamep; // Apply PRE autocommands. // Set curbuf to the buffer to be written. // Careful: The autocommands may call buf_write() recursively! bool buf_ffname = *ffnamep == buf->b_ffname; bool buf_sfname = sfname == buf->b_sfname; bool buf_fname_f = *fnamep == buf->b_ffname; bool buf_fname_s = *fnamep == buf->b_sfname; // Set curwin/curbuf to buf and save a few things. aucmd_prepbuf(&aco, buf); set_bufref(&bufref, buf); if (append) { did_cmd = apply_autocmds_exarg(EVENT_FILEAPPENDCMD, sfname, sfname, false, curbuf, eap); if (!did_cmd) { if (overwriting && bt_nofilename(curbuf)) { nofile_err = true; } else { apply_autocmds_exarg(EVENT_FILEAPPENDPRE, sfname, sfname, false, curbuf, eap); } } } else if (filtering) { apply_autocmds_exarg(EVENT_FILTERWRITEPRE, NULL, sfname, false, curbuf, eap); } else if (reset_changed && whole) { bool was_changed = curbufIsChanged(); did_cmd = apply_autocmds_exarg(EVENT_BUFWRITECMD, sfname, sfname, false, curbuf, eap); if (did_cmd) { if (was_changed && !curbufIsChanged()) { // Written everything correctly and BufWriteCmd has reset // 'modified': Correct the undo information so that an // undo now sets 'modified'. u_unchanged(curbuf); u_update_save_nr(curbuf); } } else { if (overwriting && bt_nofilename(curbuf)) { nofile_err = true; } else { apply_autocmds_exarg(EVENT_BUFWRITEPRE, sfname, sfname, false, curbuf, eap); } } } else { did_cmd = apply_autocmds_exarg(EVENT_FILEWRITECMD, sfname, sfname, false, curbuf, eap); if (!did_cmd) { if (overwriting && bt_nofilename(curbuf)) { nofile_err = true; } else { apply_autocmds_exarg(EVENT_FILEWRITEPRE, sfname, sfname, false, curbuf, eap); } } } // restore curwin/curbuf and a few other things aucmd_restbuf(&aco); // In three situations we return here and don't write the file: // 1. the autocommands deleted or unloaded the buffer. // 2. The autocommands abort script processing. // 3. If one of the "Cmd" autocommands was executed. if (!bufref_valid(&bufref)) { buf = NULL; } if (buf == NULL || (buf->b_ml.ml_mfp == NULL && !empty_memline) || did_cmd || nofile_err || aborting()) { if (buf != NULL && (cmdmod.cmod_flags & CMOD_LOCKMARKS)) { // restore the original '[ and '] positions buf->b_op_start = orig_start; buf->b_op_end = orig_end; } no_wait_return--; msg_scroll = msg_save; if (nofile_err) { semsg(_(e_no_matching_autocommands_for_buftype_str_buffer), curbuf->b_p_bt); } if (nofile_err || aborting()) { // An aborting error, interrupt or exception in the // autocommands. return FAIL; } if (did_cmd) { if (buf == NULL) { // The buffer was deleted. We assume it was written // (can't retry anyway). return OK; } if (overwriting) { // Assume the buffer was written, update the timestamp. ml_timestamp(buf); if (append) { buf->b_flags &= ~BF_NEW; } else { buf->b_flags &= ~BF_WRITE_MASK; } } if (reset_changed && buf->b_changed && !append && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) { // Buffer still changed, the autocommands didn't work properly. return FAIL; } return OK; } if (!aborting()) { emsg(_("E203: Autocommands deleted or unloaded buffer to be written")); } return FAIL; } // The autocommands may have changed the number of lines in the file. // When writing the whole file, adjust the end. // When writing part of the file, assume that the autocommands only // changed the number of lines that are to be written (tricky!). if (buf->b_ml.ml_line_count != old_line_count) { if (whole) { // write all *endp = buf->b_ml.ml_line_count; } else if (buf->b_ml.ml_line_count > old_line_count) { // more lines *endp += buf->b_ml.ml_line_count - old_line_count; } else { // less lines *endp -= old_line_count - buf->b_ml.ml_line_count; if (*endp < start) { no_wait_return--; msg_scroll = msg_save; emsg(_("E204: Autocommand changed number of lines in unexpected way")); return FAIL; } } } // The autocommands may have changed the name of the buffer, which may // be kept in fname, ffname and sfname. if (buf_ffname) { *ffnamep = buf->b_ffname; } if (buf_sfname) { *sfnamep = buf->b_sfname; } if (buf_fname_f) { *fnamep = buf->b_ffname; } if (buf_fname_s) { *fnamep = buf->b_sfname; } return NOTDONE; } static void buf_write_do_post_autocmds(buf_T *buf, char *fname, exarg_T *eap, bool append, bool filtering, bool reset_changed, bool whole) { aco_save_T aco; curbuf->b_no_eol_lnum = 0; // in case it was set by the previous read // Apply POST autocommands. // Careful: The autocommands may call buf_write() recursively! aucmd_prepbuf(&aco, buf); if (append) { apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname, false, curbuf, eap); } else if (filtering) { apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname, false, curbuf, eap); } else if (reset_changed && whole) { apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname, false, curbuf, eap); } else { apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname, false, curbuf, eap); } // restore curwin/curbuf and a few other things aucmd_restbuf(&aco); } static inline Error_T set_err_num(const char *num, const char *msg) { return (Error_T){ .num = num, .msg = (char *)msg, .arg = 0 }; } static inline Error_T set_err(const char *msg) { return (Error_T){ .num = NULL, .msg = (char *)msg, .arg = 0 }; } static inline Error_T set_err_arg(const char *msg, int arg) { return (Error_T){ .num = NULL, .msg = (char *)msg, .arg = arg }; } static void emit_err(Error_T *e) { if (e->num != NULL) { if (e->arg != 0) { semsg("%s: %s%s: %s", e->num, IObuff, e->msg, os_strerror(e->arg)); } else { semsg("%s: %s%s", e->num, IObuff, e->msg); } } else if (e->arg != 0) { semsg(e->msg, os_strerror(e->arg)); } else { emsg(e->msg); } if (e->alloc) { xfree(e->msg); } } #if defined(UNIX) static int get_fileinfo_os(char *fname, FileInfo *file_info_old, bool overwriting, int *perm, bool *device, bool *newfile, Error_T *err) { *perm = -1; if (!os_fileinfo(fname, file_info_old)) { *newfile = true; } else { *perm = (int)file_info_old->stat.st_mode; if (!S_ISREG(file_info_old->stat.st_mode)) { // not a file if (S_ISDIR(file_info_old->stat.st_mode)) { *err = set_err_num("E502", _("is a directory")); return FAIL; } if (os_nodetype(fname) != NODE_WRITABLE) { *err = set_err_num("E503", _("is not a file or writable device")); return FAIL; } // It's a device of some kind (or a fifo) which we can write to // but for which we can't make a backup. *device = true; *newfile = true; *perm = -1; } } return OK; } #else static int get_fileinfo_os(char *fname, FileInfo *file_info_old, bool overwriting, int *perm, bool *device, bool *newfile, Error_T *err) { // Check for a writable device name. char nodetype = fname == NULL ? NODE_OTHER : (char)os_nodetype(fname); if (nodetype == NODE_OTHER) { *err = set_err_num("E503", _("is not a file or writable device")); return FAIL; } if (nodetype == NODE_WRITABLE) { *device = true; *newfile = true; *perm = -1; } else { *perm = os_getperm(fname); if (*perm < 0) { *newfile = true; } else if (os_isdir(fname)) { *err = set_err_num("E502", _("is a directory")); return FAIL; } if (overwriting) { os_fileinfo(fname, file_info_old); } } return OK; } #endif /// @param buf /// @param fname File name /// @param overwriting /// @param forceit /// @param[out] file_info_old /// @param[out] perm /// @param[out] device /// @param[out] newfile /// @param[out] readonly static int get_fileinfo(buf_T *buf, char *fname, bool overwriting, bool forceit, FileInfo *file_info_old, int *perm, bool *device, bool *newfile, bool *readonly, Error_T *err) { if (get_fileinfo_os(fname, file_info_old, overwriting, perm, device, newfile, err) == FAIL) { return FAIL; } *readonly = false; // overwritten file is read-only if (!*device && !*newfile) { // Check if the file is really writable (when renaming the file to // make a backup we won't discover it later). *readonly = !os_file_is_writable(fname); if (!forceit && *readonly) { if (vim_strchr(p_cpo, CPO_FWRITE) != NULL) { *err = set_err_num("E504", _(err_readonly)); } else { *err = set_err_num("E505", _("is read-only (add ! to override)")); } return FAIL; } // If 'forceit' is false, check if the timestamp hasn't changed since reading the file. if (overwriting && !forceit) { int retval = check_mtime(buf, file_info_old); if (retval == FAIL) { return FAIL; } } } return OK; } static int buf_write_make_backup(char *fname, bool append, FileInfo *file_info_old, vim_acl_T acl, int perm, unsigned bkc, bool file_readonly, bool forceit, int *backup_copyp, char **backupp, Error_T *err) { FileInfo file_info; const bool no_prepend_dot = false; if ((bkc & BKC_YES) || append) { // "yes" *backup_copyp = true; } else if ((bkc & BKC_AUTO)) { // "auto" // Don't rename the file when: // - it's a hard link // - it's a symbolic link // - we don't have write permission in the directory if (os_fileinfo_hardlinks(file_info_old) > 1 || !os_fileinfo_link(fname, &file_info) || !os_fileinfo_id_equal(&file_info, file_info_old)) { *backup_copyp = true; } else { // Check if we can create a file and set the owner/group to // the ones from the original file. // First find a file name that doesn't exist yet (use some // arbitrary numbers). xstrlcpy(IObuff, fname, IOSIZE); for (int i = 4913;; i += 123) { char *tail = path_tail(IObuff); size_t size = (size_t)(tail - IObuff); snprintf(tail, IOSIZE - size, "%d", i); if (!os_fileinfo_link(IObuff, &file_info)) { break; } } int fd = os_open(IObuff, O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, perm); if (fd < 0) { // can't write in directory *backup_copyp = true; } else { #ifdef UNIX os_fchown(fd, (uv_uid_t)file_info_old->stat.st_uid, (uv_gid_t)file_info_old->stat.st_gid); if (!os_fileinfo(IObuff, &file_info) || file_info.stat.st_uid != file_info_old->stat.st_uid || file_info.stat.st_gid != file_info_old->stat.st_gid || (int)file_info.stat.st_mode != perm) { *backup_copyp = true; } #endif // Close the file before removing it, on MS-Windows we // can't delete an open file. close(fd); os_remove(IObuff); } } } // Break symlinks and/or hardlinks if we've been asked to. if ((bkc & BKC_BREAKSYMLINK) || (bkc & BKC_BREAKHARDLINK)) { #ifdef UNIX bool file_info_link_ok = os_fileinfo_link(fname, &file_info); // Symlinks. if ((bkc & BKC_BREAKSYMLINK) && file_info_link_ok && !os_fileinfo_id_equal(&file_info, file_info_old)) { *backup_copyp = false; } // Hardlinks. if ((bkc & BKC_BREAKHARDLINK) && os_fileinfo_hardlinks(file_info_old) > 1 && (!file_info_link_ok || os_fileinfo_id_equal(&file_info, file_info_old))) { *backup_copyp = false; } #endif } // make sure we have a valid backup extension to use char *backup_ext = *p_bex == NUL ? ".bak" : p_bex; if (*backup_copyp) { int some_error = false; // Try to make the backup in each directory in the 'bdir' option. // // Unix semantics has it, that we may have a writable file, // that cannot be recreated with a simple open(..., O_CREAT, ) e.g: // - the directory is not writable, // - the file may be a symbolic link, // - the file may belong to another user/group, etc. // // For these reasons, the existing writable file must be truncated // and reused. Creation of a backup COPY will be attempted. char *dirp = p_bdir; while (*dirp) { // Isolate one directory name, using an entry in 'bdir'. size_t dir_len = copy_option_part(&dirp, IObuff, IOSIZE, ","); char *p = IObuff + dir_len; bool trailing_pathseps = after_pathsep(IObuff, p) && p[-1] == p[-2]; if (trailing_pathseps) { IObuff[dir_len - 2] = NUL; } if (*dirp == NUL && !os_isdir(IObuff)) { int ret; char *failed_dir; if ((ret = os_mkdir_recurse(IObuff, 0755, &failed_dir, NULL)) != 0) { semsg(_("E303: Unable to create directory \"%s\" for backup file: %s"), failed_dir, os_strerror(ret)); xfree(failed_dir); } } if (trailing_pathseps) { // Ends with '//', Use Full path if ((p = make_percent_swname(IObuff, fname)) != NULL) { *backupp = modname(p, backup_ext, no_prepend_dot); xfree(p); } } char *rootname = get_file_in_dir(fname, IObuff); if (rootname == NULL) { some_error = true; // out of memory goto nobackup; } FileInfo file_info_new; { // // Make the backup file name. // if (*backupp == NULL) { *backupp = modname(rootname, backup_ext, no_prepend_dot); } if (*backupp == NULL) { xfree(rootname); some_error = true; // out of memory goto nobackup; } // Check if backup file already exists. if (os_fileinfo(*backupp, &file_info_new)) { if (os_fileinfo_id_equal(&file_info_new, file_info_old)) { // // Backup file is same as original file. // May happen when modname() gave the same file back (e.g. silly // link). If we don't check here, we either ruin the file when // copying or erase it after writing. // XFREE_CLEAR(*backupp); // no backup file to delete } else if (!p_bk) { // We are not going to keep the backup file, so don't // delete an existing one, and try to use another name instead. // Change one character, just before the extension. // char *wp = *backupp + strlen(*backupp) - 1 - strlen(backup_ext); if (wp < *backupp) { // empty file name ??? wp = *backupp; } *wp = 'z'; while (*wp > 'a' && os_fileinfo(*backupp, &file_info_new)) { (*wp)--; } // They all exist??? Must be something wrong. if (*wp == 'a') { XFREE_CLEAR(*backupp); } } } } xfree(rootname); // Try to create the backup file if (*backupp != NULL) { // remove old backup, if present os_remove(*backupp); // set file protection same as original file, but // strip s-bit. (void)os_setperm(*backupp, perm & 0777); #ifdef UNIX // // Try to set the group of the backup same as the original file. If // this fails, set the protection bits for the group same as the // protection bits for others. // if (file_info_new.stat.st_gid != file_info_old->stat.st_gid && os_chown(*backupp, (uv_uid_t)-1, (uv_gid_t)file_info_old->stat.st_gid) != 0) { os_setperm(*backupp, (perm & 0707) | ((perm & 07) << 3)); } # ifdef HAVE_XATTR os_copy_xattr(fname, *backupp); # endif #endif // copy the file if (os_copy(fname, *backupp, UV_FS_COPYFILE_FICLONE) != 0) { *err = set_err(_("E509: Cannot create backup file (add ! to override)")); XFREE_CLEAR(*backupp); *backupp = NULL; continue; } #ifdef UNIX os_file_settime(*backupp, (double)file_info_old->stat.st_atim.tv_sec, (double)file_info_old->stat.st_mtim.tv_sec); #endif os_set_acl(*backupp, acl); #ifdef HAVE_XATTR os_copy_xattr(fname, *backupp); #endif *err = set_err(NULL); break; } } nobackup: if (*backupp == NULL && err->msg == NULL) { *err = set_err(_("E509: Cannot create backup file (add ! to override)")); } // Ignore errors when forceit is true. if ((some_error || err->msg != NULL) && !forceit) { return FAIL; } *err = set_err(NULL); } else { // Make a backup by renaming the original file. // If 'cpoptions' includes the "W" flag, we don't want to // overwrite a read-only file. But rename may be possible // anyway, thus we need an extra check here. if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL) { *err = set_err_num("E504", _(err_readonly)); return FAIL; } // Form the backup file name - change path/fo.o.h to // path/fo.o.h.bak Try all directories in 'backupdir', first one // that works is used. char *dirp = p_bdir; while (*dirp) { // Isolate one directory name and make the backup file name. size_t dir_len = copy_option_part(&dirp, IObuff, IOSIZE, ","); char *p = IObuff + dir_len; bool trailing_pathseps = after_pathsep(IObuff, p) && p[-1] == p[-2]; if (trailing_pathseps) { IObuff[dir_len - 2] = NUL; } if (*dirp == NUL && !os_isdir(IObuff)) { int ret; char *failed_dir; if ((ret = os_mkdir_recurse(IObuff, 0755, &failed_dir, NULL)) != 0) { semsg(_("E303: Unable to create directory \"%s\" for backup file: %s"), failed_dir, os_strerror(ret)); xfree(failed_dir); } } if (trailing_pathseps) { // path ends with '//', use full path if ((p = make_percent_swname(IObuff, fname)) != NULL) { *backupp = modname(p, backup_ext, no_prepend_dot); xfree(p); } } if (*backupp == NULL) { char *rootname = get_file_in_dir(fname, IObuff); if (rootname == NULL) { *backupp = NULL; } else { *backupp = modname(rootname, backup_ext, no_prepend_dot); xfree(rootname); } } if (*backupp != NULL) { // If we are not going to keep the backup file, don't // delete an existing one, try to use another name. // Change one character, just before the extension. if (!p_bk && os_path_exists(*backupp)) { p = *backupp + strlen(*backupp) - 1 - strlen(backup_ext); if (p < *backupp) { // empty file name ??? p = *backupp; } *p = 'z'; while (*p > 'a' && os_path_exists(*backupp)) { (*p)--; } // They all exist??? Must be something wrong! if (*p == 'a') { XFREE_CLEAR(*backupp); } } } if (*backupp != NULL) { // Delete any existing backup and move the current version // to the backup. For safety, we don't remove the backup // until the write has finished successfully. And if the // 'backup' option is set, leave it around. // If the renaming of the original file to the backup file // works, quit here. /// if (vim_rename(fname, *backupp) == 0) { break; } XFREE_CLEAR(*backupp); // don't do the rename below } } if (*backupp == NULL && !forceit) { *err = set_err(_("E510: Can't make backup file (add ! to override)")); return FAIL; } } return OK; } /// buf_write() - write to file "fname" lines "start" through "end" /// /// We do our own buffering here because fwrite() is so slow. /// /// If "forceit" is true, we don't care for errors when attempting backups. /// In case of an error everything possible is done to restore the original /// file. But when "forceit" is true, we risk losing it. /// /// When "reset_changed" is true and "append" == false and "start" == 1 and /// "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed. /// /// This function must NOT use NameBuff (because it's called by autowrite()). /// /// /// @param eap for forced 'ff' and 'fenc', can be NULL! /// @param append append to the file /// /// @return FAIL for failure, OK otherwise int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T end, exarg_T *eap, int append, int forceit, int reset_changed, int filtering) { int retval = OK; int msg_save = msg_scroll; int prev_got_int = got_int; // writing everything int whole = (start == 1 && end == buf->b_ml.ml_line_count); int write_undo_file = false; context_sha256_T sha_ctx; unsigned bkc = get_bkc_value(buf); if (fname == NULL || *fname == NUL) { // safety check return FAIL; } if (buf->b_ml.ml_mfp == NULL) { // This can happen during startup when there is a stray "w" in the // vimrc file. emsg(_(e_empty_buffer)); return FAIL; } // Disallow writing in secure mode. if (check_secure()) { return FAIL; } // Avoid a crash for a long name. if (strlen(fname) >= MAXPATHL) { emsg(_(e_longname)); return FAIL; } // must init bw_conv_buf and bw_iconv_fd before jumping to "fail" struct bw_info write_info; // info for buf_write_bytes() write_info.bw_conv_buf = NULL; write_info.bw_conv_error = false; write_info.bw_conv_error_lnum = 0; write_info.bw_restlen = 0; write_info.bw_iconv_fd = (iconv_t)-1; // After writing a file changedtick changes but we don't want to display // the line. ex_no_reprint = true; // If there is no file name yet, use the one for the written file. // BF_NOTEDITED is set to reflect this (in case the write fails). // Don't do this when the write is for a filter command. // Don't do this when appending. // Only do this when 'cpoptions' contains the 'F' flag. if (buf->b_ffname == NULL && reset_changed && whole && buf == curbuf && !bt_nofilename(buf) && !filtering && (!append || vim_strchr(p_cpo, CPO_FNAMEAPP) != NULL) && vim_strchr(p_cpo, CPO_FNAMEW) != NULL) { if (set_rw_fname(fname, sfname) == FAIL) { return FAIL; } buf = curbuf; // just in case autocmds made "buf" invalid } if (sfname == NULL) { sfname = fname; } // For Unix: Use the short file name whenever possible. // Avoids problems with networks and when directory names are changed. // Don't do this for Windows, a "cd" in a sub-shell may have moved us to // another directory, which we don't detect. char *ffname = fname; // remember full fname #ifdef UNIX fname = sfname; #endif // true if writing over original int overwriting = buf->b_ffname != NULL && path_fnamecmp(ffname, buf->b_ffname) == 0; no_wait_return++; // don't wait for return yet const pos_T orig_start = buf->b_op_start; const pos_T orig_end = buf->b_op_end; // Set '[ and '] marks to the lines to be written. buf->b_op_start.lnum = start; buf->b_op_start.col = 0; buf->b_op_end.lnum = end; buf->b_op_end.col = 0; int res = buf_write_do_autocmds(buf, &fname, &sfname, &ffname, start, &end, eap, append, filtering, reset_changed, overwriting, whole, orig_start, orig_end); if (res != NOTDONE) { return res; } if (cmdmod.cmod_flags & CMOD_LOCKMARKS) { // restore the original '[ and '] positions buf->b_op_start = orig_start; buf->b_op_end = orig_end; } if (shortmess(SHM_OVER) && !exiting) { msg_scroll = false; // overwrite previous file message } else { msg_scroll = true; // don't overwrite previous file message } if (!filtering) { // show that we are busy #ifndef UNIX filemess(buf, sfname, "", 0); #else filemess(buf, fname, "", 0); #endif } msg_scroll = false; // always overwrite the file message now char *buffer = verbose_try_malloc(WRITEBUFSIZE); int bufsize; char smallbuf[SMALLBUFSIZE]; // can't allocate big buffer, use small one (to be able to write when out of // memory) if (buffer == NULL) { buffer = smallbuf; bufsize = SMALLBUFSIZE; } else { bufsize = WRITEBUFSIZE; } Error_T err = { 0 }; int perm; // file permissions bool newfile = false; // true if file doesn't exist yet bool device = false; // writing to a device bool file_readonly = false; // overwritten file is read-only char *backup = NULL; char *fenc_tofree = NULL; // allocated "fenc" // Get information about original file (if there is one). FileInfo file_info_old; vim_acl_T acl = NULL; // ACL copied from original file to // backup or new file if (get_fileinfo(buf, fname, overwriting, forceit, &file_info_old, &perm, &device, &newfile, &file_readonly, &err) == FAIL) { goto fail; } // For systems that support ACL: get the ACL from the original file. if (!newfile) { acl = os_get_acl(fname); } // If 'backupskip' is not empty, don't make a backup for some files. bool dobackup = (p_wb || p_bk || *p_pm != NUL); if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, sfname, ffname)) { dobackup = false; } int backup_copy = false; // copy the original file? // Save the value of got_int and reset it. We don't want a previous // interruption cancel writing, only hitting CTRL-C while writing should // abort it. prev_got_int = got_int; got_int = false; // Mark the buffer as 'being saved' to prevent changed buffer warnings buf->b_saving = true; // If we are not appending or filtering, the file exists, and the // 'writebackup', 'backup' or 'patchmode' option is set, need a backup. // When 'patchmode' is set also make a backup when appending. // // Do not make any backup, if 'writebackup' and 'backup' are both switched // off. This helps when editing large files on almost-full disks. if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup) { if (buf_write_make_backup(fname, append, &file_info_old, acl, perm, bkc, file_readonly, forceit, &backup_copy, &backup, &err) == FAIL) { retval = FAIL; goto fail; } } #if defined(UNIX) int made_writable = false; // 'w' bit has been set // When using ":w!" and the file was read-only: make it writable if (forceit && perm >= 0 && !(perm & 0200) && file_info_old.stat.st_uid == getuid() && vim_strchr(p_cpo, CPO_FWRITE) == NULL) { perm |= 0200; (void)os_setperm(fname, perm); made_writable = true; } #endif // When using ":w!" and writing to the current file, 'readonly' makes no // sense, reset it, unless 'Z' appears in 'cpoptions'. if (forceit && overwriting && vim_strchr(p_cpo, CPO_KEEPRO) == NULL) { buf->b_p_ro = false; need_maketitle = true; // set window title later status_redraw_all(); // redraw status lines later } if (end > buf->b_ml.ml_line_count) { end = buf->b_ml.ml_line_count; } if (buf->b_ml.ml_flags & ML_EMPTY) { start = end + 1; } char *wfname = NULL; // name of file to write to // If the original file is being overwritten, there is a small chance that // we crash in the middle of writing. Therefore the file is preserved now. // This makes all block numbers positive so that recovery does not need // the original file. // Don't do this if there is a backup file and we are exiting. if (reset_changed && !newfile && overwriting && !(exiting && backup != NULL)) { ml_preserve(buf, false, !!p_fs); if (got_int) { err = set_err(_(e_interr)); goto restore_backup; } } // Default: write the file directly. May write to a temp file for // multi-byte conversion. wfname = fname; char *fenc; // effective 'fileencoding' // Check for forced 'fileencoding' from "++opt=val" argument. if (eap != NULL && eap->force_enc != 0) { fenc = eap->cmd + eap->force_enc; fenc = enc_canonize(fenc); fenc_tofree = fenc; } else { fenc = buf->b_p_fenc; } // Check if the file needs to be converted. int converted = need_conversion(fenc); int wb_flags = 0; // Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done. Or // Latin1 to Unicode conversion. This is handled in buf_write_bytes(). // Prepare the flags for it and allocate bw_conv_buf when needed. if (converted) { wb_flags = get_fio_flags(fenc); if (wb_flags & (FIO_UCS2 | FIO_UCS4 | FIO_UTF16 | FIO_UTF8)) { // Need to allocate a buffer to translate into. if (wb_flags & (FIO_UCS2 | FIO_UTF16 | FIO_UTF8)) { write_info.bw_conv_buflen = (size_t)bufsize * 2; } else { // FIO_UCS4 write_info.bw_conv_buflen = (size_t)bufsize * 4; } write_info.bw_conv_buf = verbose_try_malloc(write_info.bw_conv_buflen); if (!write_info.bw_conv_buf) { end = 0; } } } if (converted && wb_flags == 0) { // Use iconv() conversion when conversion is needed and it's not done // internally. write_info.bw_iconv_fd = (iconv_t)my_iconv_open(fenc, "utf-8"); if (write_info.bw_iconv_fd != (iconv_t)-1) { // We're going to use iconv(), allocate a buffer to convert in. write_info.bw_conv_buflen = (size_t)bufsize * ICONV_MULT; write_info.bw_conv_buf = verbose_try_malloc(write_info.bw_conv_buflen); if (!write_info.bw_conv_buf) { end = 0; } write_info.bw_first = true; } else { // When the file needs to be converted with 'charconvert' after // writing, write to a temp file instead and let the conversion // overwrite the original file. if (*p_ccv != NUL) { wfname = vim_tempname(); if (wfname == NULL) { // Can't write without a tempfile! err = set_err(_("E214: Can't find temp file for writing")); goto restore_backup; } } } } int notconverted = false; if (converted && wb_flags == 0 && write_info.bw_iconv_fd == (iconv_t)-1 && wfname == fname) { if (!forceit) { err = set_err(_("E213: Cannot convert (add ! to write without conversion)")); goto restore_backup; } notconverted = true; } int no_eol = false; // no end-of-line written int nchars; linenr_T lnum; int fileformat; int checking_conversion; int fd; // If conversion is taking place, we may first pretend to write and check // for conversion errors. Then loop again to write for real. // When not doing conversion this writes for real right away. for (checking_conversion = true;; checking_conversion = false) { // There is no need to check conversion when: // - there is no conversion // - we make a backup file, that can be restored in case of conversion // failure. if (!converted || dobackup) { checking_conversion = false; } if (checking_conversion) { // Make sure we don't write anything. fd = -1; write_info.bw_fd = fd; } else { // Open the file "wfname" for writing. // We may try to open the file twice: If we can't write to the file // and forceit is true we delete the existing file and try to // create a new one. If this still fails we may have lost the // original file! (this may happen when the user reached his // quotum for number of files). // Appending will fail if the file does not exist and forceit is // false. const int fflags = O_WRONLY | (append ? (forceit ? (O_APPEND | O_CREAT) : O_APPEND) : (O_CREAT | O_TRUNC)); const int mode = perm < 0 ? 0666 : (perm & 0777); while ((fd = os_open(wfname, fflags, mode)) < 0) { // A forced write will try to create a new file if the old one // is still readonly. This may also happen when the directory // is read-only. In that case the os_remove() will fail. if (err.msg == NULL) { #ifdef UNIX FileInfo file_info; // Don't delete the file when it's a hard or symbolic link. if ((!newfile && os_fileinfo_hardlinks(&file_info_old) > 1) || (os_fileinfo_link(fname, &file_info) && !os_fileinfo_id_equal(&file_info, &file_info_old))) { err = set_err(_("E166: Can't open linked file for writing")); } else { err = set_err_arg(_("E212: Can't open file for writing: %s"), fd); if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL && perm >= 0) { // we write to the file, thus it should be marked // writable after all if (!(perm & 0200)) { made_writable = true; } perm |= 0200; if (file_info_old.stat.st_uid != getuid() || file_info_old.stat.st_gid != getgid()) { perm &= 0777; } if (!append) { // don't remove when appending os_remove(wfname); } continue; } } #else err = set_err_arg(_("E212: Can't open file for writing: %s"), fd); if (forceit && vim_strchr(p_cpo, CPO_FWRITE) == NULL && perm >= 0) { if (!append) { // don't remove when appending os_remove(wfname); } continue; } #endif } restore_backup: { // If we failed to open the file, we don't need a backup. Throw it // away. If we moved or removed the original file try to put the // backup in its place. if (backup != NULL && wfname == fname) { if (backup_copy) { // There is a small chance that we removed the original, // try to move the copy in its place. // This may not work if the vim_rename() fails. // In that case we leave the copy around. // If file does not exist, put the copy in its place if (!os_path_exists(fname)) { vim_rename(backup, fname); } // if original file does exist throw away the copy if (os_path_exists(fname)) { os_remove(backup); } } else { // try to put the original file back vim_rename(backup, fname); } } // if original file no longer exists give an extra warning if (!newfile && !os_path_exists(fname)) { end = 0; } } if (wfname != fname) { xfree(wfname); } goto fail; } write_info.bw_fd = fd; } err = set_err(NULL); write_info.bw_buf = buffer; nchars = 0; // use "++bin", "++nobin" or 'binary' int write_bin; if (eap != NULL && eap->force_bin != 0) { write_bin = (eap->force_bin == FORCE_BIN); } else { write_bin = buf->b_p_bin; } // Skip the BOM when appending and the file already existed, the BOM // only makes sense at the start of the file. if (buf->b_p_bomb && !write_bin && (!append || perm < 0)) { write_info.bw_len = make_bom(buffer, fenc); if (write_info.bw_len > 0) { // don't convert write_info.bw_flags = FIO_NOCONVERT | wb_flags; if (buf_write_bytes(&write_info) == FAIL) { end = 0; } else { nchars += write_info.bw_len; } } } write_info.bw_start_lnum = start; write_undo_file = (buf->b_p_udf && overwriting && !append && !filtering && reset_changed && !checking_conversion); if (write_undo_file) { // Prepare for computing the hash value of the text. sha256_start(&sha_ctx); } write_info.bw_len = bufsize; write_info.bw_flags = wb_flags; fileformat = get_fileformat_force(buf, eap); char *s = buffer; int len = 0; for (lnum = start; lnum <= end; lnum++) { // The next while loop is done once for each character written. // Keep it fast! char *ptr = ml_get_buf(buf, lnum) - 1; if (write_undo_file) { sha256_update(&sha_ctx, (uint8_t *)ptr + 1, (uint32_t)(strlen(ptr + 1) + 1)); } char c; while ((c = *++ptr) != NUL) { if (c == NL) { *s = NUL; // replace newlines with NULs } else if (c == CAR && fileformat == EOL_MAC) { *s = NL; // Mac: replace CRs with NLs } else { *s = c; } s++; if (++len != bufsize) { continue; } if (buf_write_bytes(&write_info) == FAIL) { end = 0; // write error: break loop break; } nchars += bufsize; s = buffer; len = 0; write_info.bw_start_lnum = lnum; } // write failed or last line has no EOL: stop here if (end == 0 || (lnum == end && (write_bin || !buf->b_p_fixeol) && ((write_bin && lnum == buf->b_no_eol_lnum) || (lnum == buf->b_ml.ml_line_count && !buf->b_p_eol)))) { lnum++; // written the line, count it no_eol = true; break; } if (fileformat == EOL_UNIX) { *s++ = NL; } else { *s++ = CAR; // EOL_MAC or EOL_DOS: write CR if (fileformat == EOL_DOS) { // write CR-NL if (++len == bufsize) { if (buf_write_bytes(&write_info) == FAIL) { end = 0; // write error: break loop break; } nchars += bufsize; s = buffer; len = 0; } *s++ = NL; } } if (++len == bufsize) { if (buf_write_bytes(&write_info) == FAIL) { end = 0; // Write error: break loop. break; } nchars += bufsize; s = buffer; len = 0; os_breakcheck(); if (got_int) { end = 0; // Interrupted, break loop. break; } } } if (len > 0 && end > 0) { write_info.bw_len = len; if (buf_write_bytes(&write_info) == FAIL) { end = 0; // write error } nchars += len; } if (!buf->b_p_fixeol && buf->b_p_eof) { // write trailing CTRL-Z (void)write_eintr(write_info.bw_fd, "\x1a", 1); } // Stop when writing done or an error was encountered. if (!checking_conversion || end == 0) { break; } // If no error happened until now, writing should be ok, so loop to // really write the buffer. } // If we started writing, finish writing. Also when an error was // encountered. if (!checking_conversion) { // On many journalling file systems there is a bug that causes both the // original and the backup file to be lost when halting the system right // after writing the file. That's because only the meta-data is // journalled. Syncing the file slows down the system, but assures it has // been written to disk and we don't lose it. // For a device do try the fsync() but don't complain if it does not work // (could be a pipe). // If the 'fsync' option is false, don't fsync(). Useful for laptops. int error; if (p_fs && (error = os_fsync(fd)) != 0 && !device // fsync not supported on this storage. && error != UV_ENOTSUP) { err = set_err_arg(e_fsync, error); end = 0; } if (!backup_copy) { #ifdef HAVE_XATTR os_copy_xattr(backup, wfname); #endif } #ifdef UNIX // When creating a new file, set its owner/group to that of the original // file. Get the new device and inode number. if (backup != NULL && !backup_copy) { // don't change the owner when it's already OK, some systems remove // permission or ACL stuff FileInfo file_info; if (!os_fileinfo(wfname, &file_info) || file_info.stat.st_uid != file_info_old.stat.st_uid || file_info.stat.st_gid != file_info_old.stat.st_gid) { os_fchown(fd, (uv_uid_t)file_info_old.stat.st_uid, (uv_gid_t)file_info_old.stat.st_gid); if (perm >= 0) { // Set permission again, may have changed. (void)os_setperm(wfname, perm); } } buf_set_file_id(buf); } else if (!buf->file_id_valid) { // Set the file_id when creating a new file. buf_set_file_id(buf); } #endif if ((error = os_close(fd)) != 0) { err = set_err_arg(_("E512: Close failed: %s"), error); end = 0; } #ifdef UNIX if (made_writable) { perm &= ~0200; // reset 'w' bit for security reasons } #endif if (perm >= 0) { // Set perm. of new file same as old file. (void)os_setperm(wfname, perm); } // Probably need to set the ACL before changing the user (can't set the // ACL on a file the user doesn't own). if (!backup_copy) { os_set_acl(wfname, acl); } if (wfname != fname) { // The file was written to a temp file, now it needs to be converted // with 'charconvert' to (overwrite) the output file. if (end != 0) { if (eval_charconvert("utf-8", fenc, wfname, fname) == FAIL) { write_info.bw_conv_error = true; end = 0; } } os_remove(wfname); xfree(wfname); } } if (end == 0) { // Error encountered. if (err.msg == NULL) { if (write_info.bw_conv_error) { if (write_info.bw_conv_error_lnum == 0) { err = set_err(_(e_write_error_conversion_failed_make_fenc_empty_to_override)); } else { err = set_err(xmalloc(300)); err.alloc = true; vim_snprintf(err.msg, 300, // NOLINT(runtime/printf) _(e_write_error_conversion_failed_in_line_nr_make_fenc_empty_to_override), write_info.bw_conv_error_lnum); } } else if (got_int) { err = set_err(_(e_interr)); } else { err = set_err(_(e_write_error_file_system_full)); } } // If we have a backup file, try to put it in place of the new file, // because the new file is probably corrupt. This avoids losing the // original file when trying to make a backup when writing the file a // second time. // When "backup_copy" is set we need to copy the backup over the new // file. Otherwise rename the backup file. // If this is OK, don't give the extra warning message. if (backup != NULL) { if (backup_copy) { // This may take a while, if we were interrupted let the user // know we got the message. if (got_int) { msg(_(e_interr), 0); ui_flush(); } // copy the file. if (os_copy(backup, fname, UV_FS_COPYFILE_FICLONE) == 0) { end = 1; // success } } else { if (vim_rename(backup, fname) == 0) { end = 1; } } } goto fail; } lnum -= start; // compute number of written lines no_wait_return--; // may wait for return now #if !defined(UNIX) fname = sfname; // use shortname now, for the messages #endif if (!filtering) { add_quoted_fname(IObuff, IOSIZE, buf, fname); bool insert_space = false; if (write_info.bw_conv_error) { xstrlcat(IObuff, _(" CONVERSION ERROR"), IOSIZE); insert_space = true; if (write_info.bw_conv_error_lnum != 0) { vim_snprintf_add(IObuff, IOSIZE, _(" in line %" PRId64 ";"), (int64_t)write_info.bw_conv_error_lnum); } } else if (notconverted) { xstrlcat(IObuff, _("[NOT converted]"), IOSIZE); insert_space = true; } else if (converted) { xstrlcat(IObuff, _("[converted]"), IOSIZE); insert_space = true; } if (device) { xstrlcat(IObuff, _("[Device]"), IOSIZE); insert_space = true; } else if (newfile) { xstrlcat(IObuff, _("[New]"), IOSIZE); insert_space = true; } if (no_eol) { xstrlcat(IObuff, _("[noeol]"), IOSIZE); insert_space = true; } // may add [unix/dos/mac] if (msg_add_fileformat(fileformat)) { insert_space = true; } msg_add_lines(insert_space, lnum, nchars); // add line/char count if (!shortmess(SHM_WRITE)) { if (append) { xstrlcat(IObuff, shortmess(SHM_WRI) ? _(" [a]") : _(" appended"), IOSIZE); } else { xstrlcat(IObuff, shortmess(SHM_WRI) ? _(" [w]") : _(" written"), IOSIZE); } } set_keep_msg(msg_trunc(IObuff, false, 0), 0); } // When written everything correctly: reset 'modified'. Unless not // writing to the original file and '+' is not in 'cpoptions'. if (reset_changed && whole && !append && !write_info.bw_conv_error && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) { unchanged(buf, true, false); const varnumber_T changedtick = buf_get_changedtick(buf); if (buf->b_last_changedtick + 1 == changedtick) { // b:changedtick may be incremented in unchanged() but that should not // trigger a TextChanged event. buf->b_last_changedtick = changedtick; } u_unchanged(buf); u_update_save_nr(buf); } // If written to the current file, update the timestamp of the swap file // and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime. if (overwriting) { ml_timestamp(buf); if (append) { buf->b_flags &= ~BF_NEW; } else { buf->b_flags &= ~BF_WRITE_MASK; } } // If we kept a backup until now, and we are in patch mode, then we make // the backup file our 'original' file. if (*p_pm && dobackup) { char *const org = modname(fname, p_pm, false); if (backup != NULL) { // If the original file does not exist yet // the current backup file becomes the original file if (org == NULL) { emsg(_("E205: Patchmode: can't save original file")); } else if (!os_path_exists(org)) { vim_rename(backup, org); XFREE_CLEAR(backup); // don't delete the file #ifdef UNIX os_file_settime(org, (double)file_info_old.stat.st_atim.tv_sec, (double)file_info_old.stat.st_mtim.tv_sec); #endif } } else { // If there is no backup file, remember that a (new) file was // created. int empty_fd; if (org == NULL || (empty_fd = os_open(org, O_CREAT | O_EXCL | O_NOFOLLOW, perm < 0 ? 0666 : (perm & 0777))) < 0) { emsg(_(e_patchmode_cant_touch_empty_original_file)); } else { close(empty_fd); } } if (org != NULL) { os_setperm(org, os_getperm(fname) & 0777); xfree(org); } } // Remove the backup unless 'backup' option is set if (!p_bk && backup != NULL && !write_info.bw_conv_error && os_remove(backup) != 0) { emsg(_("E207: Can't delete backup file")); } goto nofail; // Finish up. We get here either after failure or success. fail: no_wait_return--; // may wait for return now nofail: // Done saving, we accept changed buffer warnings again buf->b_saving = false; xfree(backup); if (buffer != smallbuf) { xfree(buffer); } xfree(fenc_tofree); xfree(write_info.bw_conv_buf); if (write_info.bw_iconv_fd != (iconv_t)-1) { iconv_close(write_info.bw_iconv_fd); write_info.bw_iconv_fd = (iconv_t)-1; } os_free_acl(acl); if (err.msg != NULL) { // - 100 to save some space for further error message #ifndef UNIX add_quoted_fname(IObuff, IOSIZE - 100, buf, sfname); #else add_quoted_fname(IObuff, IOSIZE - 100, buf, fname); #endif emit_err(&err); retval = FAIL; if (end == 0) { const int attr = HL_ATTR(HLF_E); // Set highlight for error messages. msg_puts_attr(_("\nWARNING: Original file may be lost or damaged\n"), attr | MSG_HIST); msg_puts_attr(_("don't quit the editor until the file is successfully written!"), attr | MSG_HIST); // Update the timestamp to avoid an "overwrite changed file" // prompt when writing again. if (os_fileinfo(fname, &file_info_old)) { buf_store_file_info(buf, &file_info_old); buf->b_mtime_read = buf->b_mtime; buf->b_mtime_read_ns = buf->b_mtime_ns; } } } msg_scroll = msg_save; // When writing the whole file and 'undofile' is set, also write the undo // file. if (retval == OK && write_undo_file) { uint8_t hash[UNDO_HASH_SIZE]; sha256_finish(&sha_ctx, hash); u_write_undo(NULL, false, buf, hash); } if (!should_abort(retval)) { buf_write_do_post_autocmds(buf, fname, eap, append, filtering, reset_changed, whole); if (aborting()) { // autocmds may abort script processing retval = false; } } got_int |= prev_got_int; return retval; }