/*
* ex_writefp --
* Write a range of lines to a FILE *.
*
* PUBLIC: int ex_writefp __P((SCR *,
* PUBLIC: char *, FILE *, MARK *, MARK *, u_long *, u_long *, int));
*/
int
ex_writefp(SCR *sp, char *name, FILE *fp, MARK *fm, MARK *tm, u_long *nlno, u_long *nch, int silent)
{
struct stat sb;
GS *gp;
u_long ccnt; /* XXX: can't print off_t portably. */
recno_t fline, tline, lcnt;
size_t len;
int rval;
char *msg;
CHAR_T *p;
char *f;
size_t flen;
int isutf16;
gp = sp->gp;
fline = fm->lno;
tline = tm->lno;
if (nlno != NULL) {
*nch = 0;
*nlno = 0;
}
/*
* The vi filter code has multiple processes running simultaneously,
* and one of them calls ex_writefp(). The "unsafe" function calls
* in this code are to db_get() and msgq(). Db_get() is safe, see
* the comment in ex_filter.c:ex_filter() for details. We don't call
* msgq if the multiple process bit in the EXF is set.
*
* !!!
* Historic vi permitted files of 0 length to be written. However,
* since the way vi got around dealing with "empty" files was to
* always have a line in the file no matter what, it wrote them as
* files of a single, empty line. We write empty files.
*
* "Alex, I'll take vi trivia for $1000."
*/
ccnt = 0;
lcnt = 0;
msg = "253|Writing...";
if (O_ISSET(sp, O_FILEENCODING)) {
isutf16 = !strncasecmp(O_STR(sp, O_FILEENCODING), "utf-16", 6);
isutf16 += !strncasecmp(O_STR(sp, O_FILEENCODING), "utf-16le", 8);
} else isutf16 = 0;
if (tline != 0) {
if (isutf16 == 1 && fwrite("\xfe\xff", 1, 2, fp) != 2)
goto err;
if (isutf16 == 2 && fwrite("\xff\xfe", 1, 2, fp) != 2)
goto err;
for (; fline <= tline; ++fline, ++lcnt) {
/* Caller has to provide any interrupt message. */
if ((lcnt + 1) % INTERRUPT_CHECK == 0) {
if (INTERRUPTED(sp))
break;
if (!silent) {
gp->scr_busy(sp, msg, msg == NULL ?
BUSY_UPDATE : BUSY_ON);
msg = NULL;
}
}
if (db_get(sp, fline, DBG_FATAL, &p, &len))
goto err;
INT2FILE(sp, p, len, f, flen);
if (fwrite(f, 1, flen, fp) != flen)
goto err;
ccnt += len;
/* UTF-16 w/o BOM is big-endian */
switch (isutf16) {
case 1: /* UTF-16BE */
if (fwrite("\0\x0a", 1, 2, fp) != 2)
goto done;
break;
case 2: /* UTF-16LE */
if (fwrite("\x0a\0", 1, 2, fp) != 2)
goto done;
break;
default:
if (putc('\n', fp) != '\n')
goto done;
}
++ccnt;
}
}
done: if (fflush(fp))
goto err;
/*
* XXX
* I don't trust NFS -- check to make sure that we're talking to
* a regular file and sync so that NFS is forced to flush.
*/
if (!fstat(fileno(fp), &sb) &&
S_ISREG(sb.st_mode) && fsync(fileno(fp)))
goto err;
if (fclose(fp))
goto err;
rval = 0;
if (0) {
err: if (!F_ISSET(sp->ep, F_MULTILOCK))
msgq_str(sp, M_SYSERR, name, "%s");
(void)fclose(fp);
rval = 1;
}
if (!silent)
gp->scr_busy(sp, NULL, BUSY_OFF);
/* Report the possibly partial transfer. */
if (nlno != NULL) {
*nch = ccnt;
*nlno = lcnt;
}
return (rval);
}
/*
* ex_mkexrc -- :mkexrc[!] [file]
*
* Create (or overwrite) a .exrc file with the current info.
*
* PUBLIC: int ex_mkexrc __P((SCR *, EXCMD *));
*/
int
ex_mkexrc(SCR *sp, EXCMD *cmdp)
{
struct stat sb;
FILE *fp;
int fd, sverrno;
char *fname;
size_t flen;
switch (cmdp->argc) {
case 0:
fname = _PATH_EXRC;
break;
case 1:
INT2CHAR(sp, cmdp->argv[0]->bp, cmdp->argv[0]->len + 1,
fname, flen);
set_alt_name(sp, fname);
break;
default:
abort();
}
if (!FL_ISSET(cmdp->iflags, E_C_FORCE) && !stat(fname, &sb)) {
msgq_str(sp, M_ERR, fname,
"137|%s exists, not written; use ! to override");
return (1);
}
/* Create with max permissions of rw-r--r--. */
if ((fd = open(fname, O_CREAT | O_TRUNC | O_WRONLY,
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) < 0) {
msgq_str(sp, M_SYSERR, fname, "%s");
return (1);
}
if ((fp = fdopen(fd, "w")) == NULL) {
sverrno = errno;
(void)close(fd);
goto e2;
}
if (seq_save(sp, fp, "abbreviate ", SEQ_ABBREV) || ferror(fp))
goto e1;
if (seq_save(sp, fp, "map ", SEQ_COMMAND) || ferror(fp))
goto e1;
if (seq_save(sp, fp, "map! ", SEQ_INPUT) || ferror(fp))
goto e1;
if (opts_save(sp, fp) || ferror(fp))
goto e1;
if (fclose(fp)) {
sverrno = errno;
goto e2;
}
msgq_str(sp, M_INFO, fname, "138|New exrc file: %s");
return (0);
e1: sverrno = errno;
(void)fclose(fp);
e2: errno = sverrno;
msgq_str(sp, M_SYSERR, fname, "%s");
return (1);
}
/*
* sscr_init --
* Create a pty setup for a shell.
*/
static int
sscr_init(SCR *sp)
{
SCRIPT *sc;
const char *sh, *sh_path;
/* We're going to need a shell. */
if (opts_empty(sp, O_SHELL, 0))
return (1);
MALLOC_RET(sp, sc, SCRIPT *, sizeof(SCRIPT));
sp->script = sc;
sc->sh_prompt = NULL;
sc->sh_prompt_len = 0;
/*
* There are two different processes running through this code.
* They are the shell and the parent.
*/
sc->sh_master = sc->sh_slave = -1;
if (tcgetattr(STDIN_FILENO, &sc->sh_term) == -1) {
msgq(sp, M_SYSERR, "tcgetattr");
goto err;
}
/*
* Turn off output postprocessing and echo.
*/
sc->sh_term.c_oflag &= ~OPOST;
sc->sh_term.c_cflag &= ~(ECHO|ECHOE|ECHONL|ECHOK);
#ifdef TIOCGWINSZ
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &sc->sh_win) == -1) {
msgq(sp, M_SYSERR, "tcgetattr");
goto err;
}
if (sscr_pty(&sc->sh_master,
&sc->sh_slave, sc->sh_name, &sc->sh_term, &sc->sh_win) == -1) {
msgq(sp, M_SYSERR, "pty");
goto err;
}
#else
if (sscr_pty(&sc->sh_master,
&sc->sh_slave, sc->sh_name, &sc->sh_term, NULL) == -1) {
msgq(sp, M_SYSERR, "pty");
goto err;
}
#endif
/*
* __TK__ huh?
* Don't use vfork() here, because the signal semantics differ from
* implementation to implementation.
*/
switch (sc->sh_pid = fork()) {
case -1: /* Error. */
msgq(sp, M_SYSERR, "fork");
err: if (sc->sh_master != -1)
(void)close(sc->sh_master);
if (sc->sh_slave != -1)
(void)close(sc->sh_slave);
return (1);
case 0: /* Utility. */
/*
* XXX
* So that shells that do command line editing turn it off.
*/
(void)setenv("TERM", "emacs", 1);
(void)setenv("TERMCAP", "emacs:", 1);
(void)setenv("EMACS", "t", 1);
(void)setsid();
#ifdef TIOCSCTTY
/*
* 4.4BSD allocates a controlling terminal using the TIOCSCTTY
* ioctl, not by opening a terminal device file. POSIX 1003.1
* doesn't define a portable way to do this. If TIOCSCTTY is
* not available, hope that the open does it.
*/
(void)ioctl(sc->sh_slave, TIOCSCTTY, 0);
#endif
(void)close(sc->sh_master);
(void)dup2(sc->sh_slave, STDIN_FILENO);
(void)dup2(sc->sh_slave, STDOUT_FILENO);
(void)dup2(sc->sh_slave, STDERR_FILENO);
(void)close(sc->sh_slave);
/* Assumes that all shells have -i. */
sh_path = O_STR(sp, O_SHELL);
if ((sh = strrchr(sh_path, '/')) == NULL)
sh = sh_path;
else
++sh;
execl(sh_path, sh, "-i", NULL);
msgq_str(sp, M_SYSERR, sh_path, "execl: %s");
_exit(127);
default: /* Parent. */
break;
}
if (sscr_getprompt(sp))
return (1);
F_SET(sp, SC_SCRIPT);
F_SET(sp->gp, G_SCRWIN);
return (0);
}
