/* * The routines in this file read and write ASCII files from the disk. All of * the knowledge about files are here. * * $Header: /usr/build/vile/vile/RCS/fileio.c,v 1.179 2005/05/22 16:28:46 tom Exp $ * */ #include "estruct.h" #include "edef.h" #if SYS_VMS #include #endif #if SYS_WINNT || (SYS_OS2 && CC_CSETPP) || CC_DJGPP #include #include #endif #ifdef HAVE_SYS_IOCTL_H #include #endif #if CC_NEWDOSCC #include #endif #ifndef EISDIR #define EISDIR EACCES #endif /*--------------------------------------------------------------------------*/ static void free_fline(void) { beginDisplay(); FreeAndNull(fflinebuf); fflinelen = 0; endofDisplay(); } #if OPT_FILEBACK /* * Copy file when making a backup */ static int copy_file(const char *src, const char *dst) { FILE *ifp; FILE *ofp; int chr; int ok = FALSE; if ((ifp = fopen(SL_TO_BSL(src), FOPEN_READ)) != 0) { if ((ofp = fopen(SL_TO_BSL(dst), FOPEN_WRITE)) != 0) { ok = TRUE; for_ever { chr = getc(ifp); if (feof(ifp)) break; putc(chr, ofp); if (ferror(ifp) || ferror(ofp)) { ok = FALSE; break; } } (void) fclose(ofp); } (void) fclose(ifp); } return ok; } /* * Before overwriting a file, rename any existing version as a backup. * Copy-back to retain the modification-date of the original file. * * Note: for UNIX, the direction of file-copy should be reversed, if the * original file happens to be a symbolic link. */ #if SYS_UNIX # ifndef HAVE_LONG_FILE_NAMES # define MAX_FN_LEN 14 # else # define MAX_FN_LEN 255 # endif #endif static int write_backup_file(const char *orig, char *backup) { int s; struct stat ostat, bstat; if (file_stat(orig, &ostat) != 0) return FALSE; if (file_stat(backup, &bstat) == 0) { /* the backup file exists */ #if SYS_UNIX /* same file, somehow? */ if (bstat.st_dev == ostat.st_dev && bstat.st_ino == ostat.st_ino) { return FALSE; } #endif /* remove it */ if (unlink(SL_TO_BSL(backup)) != 0) return FALSE; } /* there are many reasons for copying, rather than renaming and writing a new file -- the file may have links, which will follow the rename, rather than stay with the real-name. additionally, if the write fails, we need to re-rename back to the original name, otherwise two successive failed writes will destroy the file. */ s = copy_file(orig, backup); if (s != TRUE) return s; /* change date and permissions to match original */ #ifdef HAVE_UTIMES /* we favor utimes over utime, since not all implementations (i.e. older ones) declare the utimbuf argument. NeXT, for example, declares it as an array of two timevals instead. we think utimes will be more standard, where it exists. what we really think is that it's probably BSD systems that got utime wrong, and those will have utimes to cover for it. :-) */ { struct timeval buf[2]; buf[0].tv_sec = ostat.st_atime; buf[0].tv_usec = 0; buf[1].tv_sec = ostat.st_mtime; buf[1].tv_usec = 0; s = utimes(SL_TO_BSL(backup), buf); if (s != 0) { (void) unlink(SL_TO_BSL(backup)); return FALSE; } } #else #ifdef HAVE_UTIME { struct utimbuf buf; buf.actime = ostat.st_atime; buf.modtime = ostat.st_mtime; s = utime(SL_TO_BSL(backup), &buf); if (s != 0) { (void) unlink(SL_TO_BSL(backup)); return FALSE; } } #endif #endif #if SYS_OS2 && CC_CSETPP s = chmod(SL_TO_BSL(backup), ostat.st_mode & (S_IREAD | S_IWRITE)); #else s = chmod(SL_TO_BSL(backup), ostat.st_mode & 0777); #endif if (s != 0) { (void) unlink(SL_TO_BSL(backup)); return FALSE; } return TRUE; } static int make_backup(char *fname) { int ok = TRUE; if (ffexists(fname)) { /* if the file exists, attempt a backup */ char tname[NFILEN]; char *s = pathleaf(strcpy(tname, fname)); char *t = strrchr(s, '.'); char *gvalfileback = global_g_val_ptr(GVAL_BACKUPSTYLE); if (strcmp(gvalfileback, ".bak") == 0) { if (t == 0 /* i.e. no '.' at all */ #if SYS_UNIX || t == s /* i.e. leading char is '.' */ #endif ) t = skip_string(s); /* then just append */ (void) strcpy(t, ".bak"); #if SYS_UNIX } else if (strcmp(gvalfileback, "tilde") == 0) { t = skip_string(s); #ifndef HAVE_LONG_FILE_NAMES if (t - s >= MAX_FN_LEN) { if (t - s == MAX_FN_LEN && s[MAX_FN_LEN - 2] == '.') s[MAX_FN_LEN - 2] = s[MAX_FN_LEN - 1]; t = &s[MAX_FN_LEN - 1]; } #endif (void) strcpy(t, "~"); #if VILE_SOMEDAY } else if (strcmp(gvalfileback, "tilde_N_existing")) { /* numbered backups if one exists, else simple */ } else if (strcmp(gvalfileback, "tilde_N")) { /* numbered backups of all files */ #endif #endif /* SYS_UNIX */ } else { mlforce("BUG: bad fileback value"); return FALSE; } ok = write_backup_file(fname, tname); } return ok; } #endif /* OPT_FILEBACK */ /* * Definitions for file_stat() */ typedef struct { int rc; char fn[NFILEN]; struct stat sb; } CACHE_STAT; #define MAX_CACHE_STAT 2 /* * Cache the most recent few stat() calls on the filesystem. If the 'sb' * pointer is null, purge our cache entry for the corresponding file. We * usually purge only when asking for the modification-time of a file, since * that may change externally. */ int file_stat(const char *fn, struct stat *sb) { static CACHE_STAT cache[MAX_CACHE_STAT]; int rc = 0; unsigned n; int found = FALSE; if (fn != 0) { for (n = 0; n < TABLESIZE(cache); ++n) { if (!strcmp(fn, cache[n].fn)) { found = TRUE; break; } } if (sb != 0) { if (!found) { for (n = TABLESIZE(cache) - 1; n != 0; --n) { if (strlen(cache[n].fn) == 0) break; } cache[n].rc = stat(SL_TO_BSL(strcpy(cache[n].fn, fn)), &(cache[n].sb)); } rc = cache[n].rc; *sb = cache[n].sb; } else if (found) { vl_strncpy(cache[n].fn, "", NFILEN); } } else { fn = ""; for (n = 0; n < TABLESIZE(cache); ++n) { vl_strncpy(cache[n].fn, fn, NFILEN); } } TRACE(("file_stat(%s) = %d%s\n", fn, rc, (found ? ((sb != 0) ? " cached" : " purged") : ""))); return rc; } /* * Open a file for reading. */ int ffropen(char *fn) { fileeof = FALSE; ffstatus = file_is_closed; TRACE(("ffropen(fn=%s)\n", fn)); #if OPT_SHELL if (isShellOrPipe(fn)) { ffp = 0; #if SYS_UNIX || SYS_MSDOS || SYS_OS2 || SYS_WINNT ffp = npopen(fn + 1, FOPEN_READ); #endif #if SYS_VMS ffp = vms_rpipe(fn + 1, 0, (char *) 0); /* really a temp-file, but we cannot fstat it to get size */ #endif if (ffp == 0) { mlerror("opening pipe for read"); return (FIOERR); } ffstatus = file_is_pipe; count_fline = 0; } else #endif if (is_directory(fn)) { #if COMPLETE_FILES || COMPLETE_DIRS ffstatus = file_is_internal; /* will store directory as buffer */ return (FIOSUC); #else set_errno(EISDIR); mlerror("opening directory"); return (FIOERR); #endif } else if (is_nonfile(fn)) { mlforce("[Not a file: %s]", fn); return (FIOERR); } else if ((ffp = fopen(SL_TO_BSL(fn), FOPEN_READ)) == NULL) { if (errno != ENOENT #if SYS_OS2 && CC_CSETPP && errno != ENOTEXIST && errno != EBADNAME #endif && errno != EINVAL) { /* a problem with Linux to DOS-files */ mlerror("opening for read"); return (FIOERR); } return (FIOFNF); } else { ffstatus = file_is_external; } TPRINTF(("** opened %s for read\n", fn)); return (FIOSUC); } /* * Open a file for writing. Return TRUE if all is well, and FALSE on error * (cannot create). */ int ffwopen(char *fn, int forced) { #if SYS_UNIX || SYS_MSDOS || SYS_OS2 || SYS_WINNT char *name; char *mode = FOPEN_WRITE; TRACE(("ffwopen(fn=%s, forced=%d)\n", fn, forced)); ffstatus = file_is_closed; if (i_am_dead) { if ((ffd = open(SL_TO_BSL(fn), O_WRONLY | O_CREAT, 0600)) < 0) { return (FIOERR); } ffstatus = file_is_unbuffered; } else #if OPT_SHELL if (isShellOrPipe(fn)) { if ((ffp = npopen(fn + 1, mode)) == NULL) { mlerror("opening pipe for write"); return (FIOERR); } ffstatus = file_is_pipe; } else #endif { if ((name = is_appendname(fn)) != NULL) { fn = name; mode = FOPEN_APPEND; } else if (is_directory(fn)) { set_errno(EISDIR); mlerror("opening directory"); return (FIOERR); } else if (is_nonfile(fn)) { mlforce("[Not a file: %s]", fn); return (FIOERR); } #if OPT_FILEBACK /* will we be able to write? (before attempting backup) */ if (ffexists(fn) && ffronly(fn)) { mlerror("accessing for write"); return (FIOERR); } if (*global_g_val_ptr(GVAL_BACKUPSTYLE) != 'o') { /* "off" ? */ if (!make_backup(fn)) { if (!forced) { mlerror("making backup file"); return (FIOERR); } } } #endif if ((ffp = fopen(SL_TO_BSL(fn), mode)) == NULL) { mlerror("opening for write"); return (FIOERR); } ffstatus = file_is_external; } #else #if SYS_VMS char temp[NFILEN]; int fd; strip_version(fn = strcpy(temp, fn)); if (is_appendname(fn) || is_directory(fn) || (fd = vms_creat(temp)) < 0 || (ffp = fdopen(fd, FOPEN_WRITE)) == NULL) { mlforce("[Cannot open file for writing]"); return (FIOERR); } #else if ((ffp = fopen(fn, FOPEN_WRITE)) == NULL) { mlerror("opening for write"); return (FIOERR); } #endif ffstatus = file_is_external; #endif TPRINTF(("** opened %s for write\n", fn)); return (FIOSUC); } /* wrapper for 'access()' */ int ffaccess(char *fn, UINT mode) { int status; #ifdef HAVE_ACCESS /* these were chosen to match the SYSV numbers, but we'd rather use * the symbols for portability. */ #ifndef X_OK #define X_OK 1 #endif #ifndef W_OK #define W_OK 2 #endif #ifndef R_OK #define R_OK 4 #endif int n = 0; if (mode & FL_EXECABLE) n |= X_OK; if (mode & FL_WRITEABLE) n |= W_OK; if (mode & FL_READABLE) n |= R_OK; status = (!isInternalName(fn) && access(SL_TO_BSL(fn), n) == 0); #else int fd; switch (mode) { case FL_EXECABLE: /* FALL-THRU */ case FL_READABLE: if (ffropen(fn) == FIOSUC) { ffclose(); status = TRUE; } else { status = FALSE; } break; case FL_WRITEABLE: if ((fd = open(SL_TO_BSL(fn), O_WRONLY | O_APPEND)) < 0) { status = FALSE; } else { (void) close(fd); status = TRUE; } break; default: status = ffexists(fn); break; } #endif TRACE(("ffaccess(fn=%s, mode=%d) = %d\n", SL_TO_BSL(fn), mode, status)); return (status); } /* is the file read-only? true or false */ int ffronly(char *fn) { int status; if (isShellOrPipe(fn)) { status = TRUE; } else { status = !ffaccess(fn, FL_WRITEABLE); } TRACE(("ffronly(fn=%s) = %d\n", fn, status)); return status; } #if OPT_ENCRYPT static int ffcrypting = FALSE; void ffdocrypt(int crypting) { ffcrypting = crypting; } #endif #if SYS_WINNT || (SYS_MSDOS && CC_DJGPP) #define FFSIZE_FTELL 1 #else #define FFSIZE_FTELL 0 #endif int ffsize(B_COUNT * have) { int result = -1; #if FFSIZE_FTELL long prev; prev = ftell(ffp); if (fseek(ffp, 0, SEEK_END) >= 0) { result = 0; *have = ftell(ffp); fseek(ffp, prev, SEEK_SET); } #else struct stat statbuf; if ((result = fstat(fileno(ffp), &statbuf)) == 0) { *have = (B_COUNT) statbuf.st_size; } #if SYS_VMS if (result == -1) { /* * Attempting to read a file size across DECNET via fstat() * doesn't work using (at least) VAXC and its runtime library. * So return 0 and let slowreadf() read the file. */ result = 0; } #endif /* SYS_VMS */ #endif /* FFSIZE_FTELL */ TRACE(("ffsize %s %lu\n", (result < 0) ? "failed" : "succeeded", *have)); return result; } int ffexists(char *p) { int status = FALSE; #if SYS_VMS if (!isInternalName(p)) status = vms_ffexists(p); #endif #if SYS_UNIX || SYS_OS2 || SYS_WINNT struct stat statbuf; if (!isInternalName(p) && file_stat(p, 0) == 0 && file_stat(p, &statbuf) == 0) { status = TRUE; } #endif #if SYS_MSDOS if (!isInternalName(p) && ffropen(SL_TO_BSL(p)) == FIOSUC) { ffclose(); status = TRUE; } #endif TRACE(("ffexists(fn=%s) = %d\n", p, status)); return (status); } /* * Not every system has read(). Use fread() for the others. * Also, do not use read() when we use ftell(), since the latter is * buffered and the former is not. */ #if CC_CSETPP #define FFREAD_FREAD 1 #else #define FFREAD_FREAD FFSIZE_FTELL #endif /* * fread() and read() return ssize_t, which may be a signed long. * But ssize_t is less common in header files, so simply use long. * Ditto for the limit - use LONG_MAX, which should appear in limits.h * but older headers may not). */ #ifndef LONG_MAX #define LONG_MAX (((unsigned long)(~0)) >> 1) #endif int ffread(char *buf, B_COUNT want, B_COUNT * have) { int result = 0; long got; *have = 0; if (want != 0) { /* * Depending on the system, a single read will not necessarily return * all of the data in one call. Also, since B_COUNT is unsigned, and * read()'s return-value is not, we have to limit the requests to * avoid overflow. */ while (want != 0) { long ask = (((want - *have) > LONG_MAX) ? LONG_MAX : (want - *have)); #if FFREAD_FREAD got = fread(buf + *have, 1, ask, ffp); #else got = read(fileno(ffp), buf + *have, ask); #endif if (got <= 0) break; *have += got; } if (*have == 0) result = -1; } TRACE(("ffread %s %lu\n", (result < 0) ? "failed" : "succeeded", *have)); return result; } void ffseek(B_COUNT n) { #if SYS_VMS ffrewind(); /* see below */ #endif fseek(ffp, n, SEEK_SET); } void ffrewind(void) { #if SYS_VMS /* VAX/VMS V5.4-2, VAX-C 3.2 'rewind()' does not work properly, because * no end-of-file condition is returned after rewinding. Reopening the * file seems to work. We can get away with this because we only * reposition in "permanent" files that we are reading. */ char temp[NFILEN]; fgetname(ffp, temp); (void) fclose(ffp); ffp = fopen(temp, FOPEN_READ); #else fseek(ffp, 0L, SEEK_SET); #endif } /* * Close a file. Should look at the status in all systems. */ int ffclose(void) { int s = 0; if (ffstatus == file_is_unbuffered) { if (fflinelen) { write(ffd, fflinebuf, fflinelen); fflinelen = 0; } close(ffd); } else { free_fline(); if (ffp != 0) { #if SYS_UNIX || SYS_MSDOS || SYS_OS2 || SYS_WINNT #if OPT_SHELL if (ffstatus == file_is_pipe) { npclose(ffp); mlwrite("[Read %d lines%s]", count_fline, interrupted()? "- Interrupted" : ""); #ifdef MDCHK_MODTIME (void) check_visible_files_changed(); #endif } else #endif { s = fclose(ffp); } if (s != 0) { mlerror("closing"); return (FIOERR); } #else (void) fclose(ffp); #endif } ffp = 0; ffbuffer = 0; } ffstatus = file_is_closed; return (FIOSUC); } /* * Write a line to the already opened file. The "buf" points to the buffer, * and the "nbuf" is its length, less the free newline. Return the status. */ int ffputline(const char *buf, int nbuf, const char *ending) { int i = 0; if (buf != 0) { for (i = 0; i < nbuf; ++i) if (ffputc(char2int(buf[i])) == FIOERR) return FIOERR; } if (ending != 0) { while (*ending != EOS) { if (*ending != '\r' || i == 0 || buf[i - 1] != '\r') ffputc(*ending); ending++; } } if (ffp != 0 && ferror(ffp)) { mlerror("writing"); return (FIOERR); } return (FIOSUC); } /* * Write a char to the already opened file. * Return the status. */ int ffputc(int c) { char d = (char) c; #if OPT_ENCRYPT if (ffcrypting && (ffstatus != file_is_pipe)) d = vl_encrypt_char(d); #endif if (i_am_dead) { fflinebuf[fflinelen++] = d; if (fflinelen >= NSTRING) { write(ffd, fflinebuf, fflinelen); fflinelen = 0; } } else { putc(d, ffp); if (ferror(ffp)) { mlerror("writing"); return (FIOERR); } } return (FIOSUC); } /* "Small" exponential growth - EJK */ static int alloc_linebuf(unsigned needed) { beginDisplay(); needed += 2; if (needed < NSTRING) needed = NSTRING; if (fflinebuf == 0) { fflinelen = needed; fflinebuf = castalloc(char, fflinelen); } else if (needed >= fflinelen) { fflinelen = needed + (needed >> 3); fflinebuf = castrealloc(char, fflinebuf, fflinelen); } if (fflinebuf == 0) fflinelen = 0; endofDisplay(); return (fflinebuf != 0); } #define ALLOC_LINEBUF(i) \ if (i >= fflinelen && !alloc_linebuf(i)) \ return (FIOMEM) /* * Read a line from a file, and store the bytes in an allocated buffer. * "fflinelen" is the length of the buffer. Reallocate and copy as necessary. * Check for I/O errors. Return status. The final length is returned via * the 'lenp' parameter. */ int ffgetline(int *lenp) { int c; size_t i; /* current index into fflinebuf */ int end_of_line = (global_b_val(VAL_RECORD_SEP) == RS_CR) ? '\r' : '\n'; if (fileeof) return (FIOEOF); ALLOC_LINEBUF(NSTRING); i = 0; #if COMPLETE_FILES || COMPLETE_DIRS if (ffstatus == file_is_internal) { if (ffcursor == buf_head(ffbuffer)) { ffcursor = 0; fileeof = TRUE; return (FIOEOF); } if (llength(ffcursor) > 0) { i = llength(ffcursor); ALLOC_LINEBUF(i); memcpy(fflinebuf, ffcursor->l_text, i); } ffcursor = lforw(ffcursor); ALLOC_LINEBUF(i); fflinebuf[i] = EOS; *lenp = i; /* return the length, not including final null */ } else #endif { /* accumulate to a newline */ for_ever { c = getc(ffp); if (feof(ffp) || ferror(ffp)) break; #if OPT_ENCRYPT if (ffcrypting && (ffstatus != file_is_pipe)) c = vl_encrypt_char(c); #endif if (c == end_of_line) break; if (interrupted()) { free_fline(); *lenp = 0; return FIOABRT; } ALLOC_LINEBUF(i); fflinebuf[i++] = (char) c; #if OPT_WORKING cur_working++; #endif } ALLOC_LINEBUF(i); *lenp = i; /* return the length, not including final null */ fflinebuf[i] = EOS; if (c == EOF) { /* problems? */ if (!feof(ffp) && ferror(ffp) #ifdef EPIPE /* fix for Borland - no point in warnings if we have EOF */ && (errno != EPIPE) #endif ) { mlerror("reading"); return (FIOERR); } if (i != 0) /* got something */ fileeof = TRUE; else return (FIOEOF); } } count_fline++; return (fileeof ? FIOBAD : FIOSUC); } /* * isready_c() * * This fairly non-portable addition to the stdio set of macros is used to * see if stdio has data for us, without actually reading it and possibly * blocking. If you have trouble building this, just define no_isready_c * below, so that ffhasdata() always returns FALSE. If you want to make it * work, figure out how your getc in stdio.h knows whether or not to call * _filbuf() (or the equivalent), and write isready_c so that it returns * true if the buffer has chars available now. The big win in getting it * to work is that reading the output of a pipe (e.g. ":e !co -p file.c") * is _much_much_ faster, and I don't have to futz with non-blocking * reads... */ #ifndef isready_c # if CC_TURBO # define isready_c(p) ( (p)->bsize > ((p)->curp - (p)->buffer) ) # endif # if SYS_OS2_EMX # define isready_c(p) ( (p)->_rcount > 0) # endif # if SYS_VMS # define isready_c(p) ( (*p)->_cnt > 0) # endif # if SYS_WINNT && !defined( __BORLANDC__ ) # define isready_c(p) ( (p)->_cnt > 0) # endif #endif int ffhasdata(void) { #ifdef isready_c if (isready_c(ffp)) return TRUE; #endif #if defined(FIONREAD) && !SYS_WINNT { long x; if ((ioctl(fileno(ffp), FIONREAD, (caddr_t) & x) >= 0) && x != 0) return TRUE; } #endif return FALSE; } #if NO_LEAKS void fileio_leaks(void) { free_fline(); } #endif