Home | History | Annotate | Line # | Download | only in ksh
io.c revision 1.6 
      1 /*	$NetBSD: io.c,v 1.6 2001/09/16 16:34:23 wiz Exp $	*/
      2 
      3 /*
      4  * shell buffered IO and formatted output
      5  */
      6 
      7 #include <ctype.h>
      8 #include "sh.h"
      9 #include "ksh_stat.h"
     10 
     11 static int initio_done;
     12 
     13 /*
     14  * formatted output functions
     15  */
     16 
     17 
     18 /* A shell error occurred (eg, syntax error, etc.) */
     19 void
     20 #ifdef HAVE_PROTOTYPES
     21 errorf(const char *fmt, ...)
     22 #else
     23 errorf(fmt, va_alist)
     24 	const char *fmt;
     25 	va_dcl
     26 #endif
     27 {
     28 	va_list va;
     29 
     30 	shl_stdout_ok = 0;	/* debugging: note that stdout not valid */
     31 	exstat = 1;
     32 	if (*fmt) {
     33 		error_prefix(TRUE);
     34 		SH_VA_START(va, fmt);
     35 		shf_vfprintf(shl_out, fmt, va);
     36 		va_end(va);
     37 		shf_putchar('\n', shl_out);
     38 	}
     39 	shf_flush(shl_out);
     40 	unwind(LERROR);
     41 }
     42 
     43 /* like errorf(), but no unwind is done */
     44 void
     45 #ifdef HAVE_PROTOTYPES
     46 warningf(int fileline, const char *fmt, ...)
     47 #else
     48 warningf(fileline, fmt, va_alist)
     49 	int fileline;
     50 	const char *fmt;
     51 	va_dcl
     52 #endif
     53 {
     54 	va_list va;
     55 
     56 	error_prefix(fileline);
     57 	SH_VA_START(va, fmt);
     58 	shf_vfprintf(shl_out, fmt, va);
     59 	va_end(va);
     60 	shf_putchar('\n', shl_out);
     61 	shf_flush(shl_out);
     62 }
     63 
     64 /* Used by built-in utilities to prefix shell and utility name to message
     65  * (also unwinds environments for special builtins).
     66  */
     67 void
     68 #ifdef HAVE_PROTOTYPES
     69 bi_errorf(const char *fmt, ...)
     70 #else
     71 bi_errorf(fmt, va_alist)
     72 	const char *fmt;
     73 	va_dcl
     74 #endif
     75 {
     76 	va_list va;
     77 
     78 	shl_stdout_ok = 0;	/* debugging: note that stdout not valid */
     79 	exstat = 1;
     80 	if (*fmt) {
     81 		error_prefix(TRUE);
     82 		/* not set when main() calls parse_args() */
     83 		if (builtin_argv0)
     84 			shf_fprintf(shl_out, "%s: ", builtin_argv0);
     85 		SH_VA_START(va, fmt);
     86 		shf_vfprintf(shl_out, fmt, va);
     87 		va_end(va);
     88 		shf_putchar('\n', shl_out);
     89 	}
     90 	shf_flush(shl_out);
     91 	/* POSIX special builtins and ksh special builtins cause
     92 	 * non-interactive shells to exit.
     93 	 * XXX odd use of KEEPASN; also may not want LERROR here
     94 	 */
     95 	if ((builtin_flag & SPEC_BI)
     96 	    || (Flag(FPOSIX) && (builtin_flag & KEEPASN)))
     97 	{
     98 		builtin_argv0 = (char *) 0;
     99 		unwind(LERROR);
    100 	}
    101 }
    102 
    103 /* Called when something that shouldn't happen does */
    104 void
    105 #ifdef HAVE_PROTOTYPES
    106 internal_errorf(int jump, const char *fmt, ...)
    107 #else
    108 internal_errorf(jump, fmt, va_alist)
    109 	int jump;
    110 	const char *fmt;
    111 	va_dcl
    112 #endif
    113 {
    114 	va_list va;
    115 
    116 	error_prefix(TRUE);
    117 	shf_fprintf(shl_out, "internal error: ");
    118 	SH_VA_START(va, fmt);
    119 	shf_vfprintf(shl_out, fmt, va);
    120 	va_end(va);
    121 	shf_putchar('\n', shl_out);
    122 	shf_flush(shl_out);
    123 	if (jump)
    124 		unwind(LERROR);
    125 }
    126 
    127 /* used by error reporting functions to print "ksh: .kshrc[25]: " */
    128 void
    129 error_prefix(fileline)
    130 	int fileline;
    131 {
    132 	/* Avoid foo: foo[2]: ... */
    133 	if (!fileline || !source || !source->file
    134 	    || strcmp(source->file, kshname) != 0)
    135 		shf_fprintf(shl_out, "%s: ", kshname + (*kshname == '-'));
    136 	if (fileline && source && source->file != NULL) {
    137 		shf_fprintf(shl_out, "%s[%d]: ", source->file,
    138 			source->errline > 0 ? source->errline : source->line);
    139 		source->errline = 0;
    140 	}
    141 }
    142 
    143 /* printf to shl_out (stderr) with flush */
    144 void
    145 #ifdef HAVE_PROTOTYPES
    146 shellf(const char *fmt, ...)
    147 #else
    148 shellf(fmt, va_alist)
    149 	const char *fmt;
    150 	va_dcl
    151 #endif
    152 {
    153 	va_list va;
    154 
    155 	if (!initio_done) /* shl_out may not be set up yet... */
    156 		return;
    157 	SH_VA_START(va, fmt);
    158 	shf_vfprintf(shl_out, fmt, va);
    159 	va_end(va);
    160 	shf_flush(shl_out);
    161 }
    162 
    163 /* printf to shl_stdout (stdout) */
    164 void
    165 #ifdef HAVE_PROTOTYPES
    166 shprintf(const char *fmt, ...)
    167 #else
    168 shprintf(fmt, va_alist)
    169 	const char *fmt;
    170 	va_dcl
    171 #endif
    172 {
    173 	va_list va;
    174 
    175 	if (!shl_stdout_ok)
    176 		internal_errorf(1, "shl_stdout not valid");
    177 	SH_VA_START(va, fmt);
    178 	shf_vfprintf(shl_stdout, fmt, va);
    179 	va_end(va);
    180 }
    181 
    182 #ifdef KSH_DEBUG
    183 static struct shf *kshdebug_shf;
    184 
    185 void
    186 kshdebug_init_()
    187 {
    188 	if (kshdebug_shf)
    189 		shf_close(kshdebug_shf);
    190 	kshdebug_shf = shf_open("/tmp/ksh-debug.log",
    191 				O_WRONLY|O_APPEND|O_CREAT, 0600,
    192 				SHF_WR|SHF_MAPHI);
    193 	if (kshdebug_shf) {
    194 		shf_fprintf(kshdebug_shf, "\nNew shell[pid %d]\n", getpid());
    195 		shf_flush(kshdebug_shf);
    196 	}
    197 }
    198 
    199 /* print to debugging log */
    200 void
    201 # ifdef HAVE_PROTOTYPES
    202 kshdebug_printf_(const char *fmt, ...)
    203 # else
    204 kshdebug_printf_(fmt, va_alist)
    205 	const char *fmt;
    206 	va_dcl
    207 # endif
    208 {
    209 	va_list va;
    210 
    211 	if (!kshdebug_shf)
    212 		return;
    213 	SH_VA_START(va, fmt);
    214 	shf_fprintf(kshdebug_shf, "[%d] ", getpid());
    215 	shf_vfprintf(kshdebug_shf, fmt, va);
    216 	va_end(va);
    217 	shf_flush(kshdebug_shf);
    218 }
    219 
    220 void
    221 kshdebug_dump_(str, mem, nbytes)
    222 	const char *str;
    223 	const void *mem;
    224 	int nbytes;
    225 {
    226 	int i, j;
    227 	int nprow = 16;
    228 
    229 	if (!kshdebug_shf)
    230 		return;
    231 	shf_fprintf(kshdebug_shf, "[%d] %s:\n", getpid(), str);
    232 	for (i = 0; i < nbytes; i += nprow) {
    233 		char c = '\t';
    234 		for (j = 0; j < nprow && i + j < nbytes; j++) {
    235 			shf_fprintf(kshdebug_shf, "%c%02x",
    236 				c, ((const unsigned char *) mem)[i + j]);
    237 			c = ' ';
    238 		}
    239 		shf_fprintf(kshdebug_shf, "\n");
    240 	}
    241 	shf_flush(kshdebug_shf);
    242 }
    243 #endif /* KSH_DEBUG */
    244 
    245 /* test if we can seek backwards fd (returns 0 or SHF_UNBUF) */
    246 int
    247 can_seek(fd)
    248 	int fd;
    249 {
    250 	struct stat statb;
    251 
    252 	return fstat(fd, &statb) == 0 && !S_ISREG(statb.st_mode) ?
    253 		SHF_UNBUF : 0;
    254 }
    255 
    256 struct shf	shf_iob[3];
    257 
    258 void
    259 initio()
    260 {
    261 	shf_fdopen(1, SHF_WR, shl_stdout);	/* force buffer allocation */
    262 	shf_fdopen(2, SHF_WR, shl_out);
    263 	shf_fdopen(2, SHF_WR, shl_spare);	/* force buffer allocation */
    264 	initio_done = 1;
    265 	kshdebug_init();
    266 }
    267 
    268 /* A dup2() with error checking */
    269 int
    270 ksh_dup2(ofd, nfd, errok)
    271 	int ofd;
    272 	int nfd;
    273 	int errok;
    274 {
    275 	int ret = dup2(ofd, nfd);
    276 
    277 	if (ret < 0 && errno != EBADF && !errok)
    278 		errorf("too many files open in shell");
    279 
    280 #ifdef DUP2_BROKEN
    281 	/* Ultrix systems like to preserve the close-on-exec flag */
    282 	if (ret >= 0)
    283 		(void) fcntl(nfd, F_SETFD, 0);
    284 #endif /* DUP2_BROKEN */
    285 
    286 	return ret;
    287 }
    288 
    289 /*
    290  * move fd from user space (0<=fd<10) to shell space (fd>=10),
    291  * set close-on-exec flag.
    292  */
    293 int
    294 savefd(fd, noclose)
    295 	int fd;
    296 	int noclose;
    297 {
    298 	int nfd;
    299 
    300 	if (fd < FDBASE) {
    301 		nfd = ksh_dupbase(fd, FDBASE);
    302 		if (nfd < 0) {
    303 			if (errno == EBADF)
    304 				return -1;
    305 			else
    306 				errorf("too many files open in shell");
    307 		}
    308 		if (!noclose)
    309 			close(fd);
    310 	} else
    311 		nfd = fd;
    312 	fd_clexec(nfd);
    313 	return nfd;
    314 }
    315 
    316 void
    317 restfd(fd, ofd)
    318 	int fd, ofd;
    319 {
    320 	if (fd == 2)
    321 		shf_flush(&shf_iob[fd]);
    322 	if (ofd < 0)		/* original fd closed */
    323 		close(fd);
    324 	else {
    325 		ksh_dup2(ofd, fd, TRUE); /* XXX: what to do if this fails? */
    326 		close(ofd);
    327 	}
    328 }
    329 
    330 void
    331 openpipe(pv)
    332 	register int *pv;
    333 {
    334 	if (pipe(pv) < 0)
    335 		errorf("can't create pipe - try again");
    336 	pv[0] = savefd(pv[0], 0);
    337 	pv[1] = savefd(pv[1], 0);
    338 }
    339 
    340 void
    341 closepipe(pv)
    342 	register int *pv;
    343 {
    344 	close(pv[0]);
    345 	close(pv[1]);
    346 }
    347 
    348 /* Called by iosetup() (deals with 2>&4, etc.), c_read, c_print to turn
    349  * a string (the X in 2>&X, read -uX, print -uX) into a file descriptor.
    350  */
    351 int
    352 check_fd(name, mode, emsgp)
    353 	char *name;
    354 	int mode;
    355 	const char **emsgp;
    356 {
    357 	int fd, fl;
    358 
    359 	if (isdigit((unsigned char)name[0]) && !name[1]) {
    360 		fd = name[0] - '0';
    361 		if ((fl = fcntl(fd = name[0] - '0', F_GETFL, 0)) < 0) {
    362 			if (emsgp)
    363 				*emsgp = "bad file descriptor";
    364 			return -1;
    365 		}
    366 		fl &= O_ACCMODE;
    367 #ifdef OS2
    368 		if (mode == W_OK ) {
    369 		       if (setmode(fd, O_TEXT) == -1) {
    370 				if (emsgp)
    371 					*emsgp = "couldn't set write mode";
    372 				return -1;
    373 			}
    374 		 } else if (mode == R_OK)
    375 	      		if (setmode(fd, O_BINARY) == -1) {
    376 				if (emsgp)
    377 					*emsgp = "couldn't set read mode";
    378 				return -1;
    379 			}
    380 #else /* OS2 */
    381 		/* X_OK is a kludge to disable this check for dups (x<&1):
    382 		 * historical shells never did this check (XXX don't know what
    383 		 * posix has to say).
    384 		 */
    385 		if (!(mode & X_OK) && fl != O_RDWR
    386 		    && (((mode & R_OK) && fl != O_RDONLY)
    387 			|| ((mode & W_OK) && fl != O_WRONLY)))
    388 		{
    389 			if (emsgp)
    390 				*emsgp = (fl == O_WRONLY) ?
    391 						"fd not open for reading"
    392 					      : "fd not open for writing";
    393 			return -1;
    394 		}
    395 #endif /* OS2 */
    396 		return fd;
    397 	}
    398 #ifdef KSH
    399 	else if (name[0] == 'p' && !name[1])
    400 		return coproc_getfd(mode, emsgp);
    401 #endif /* KSH */
    402 	if (emsgp)
    403 		*emsgp = "illegal file descriptor name";
    404 	return -1;
    405 }
    406 
    407 #ifdef KSH
    408 /* Called once from main */
    409 void
    410 coproc_init()
    411 {
    412 	coproc.read = coproc.readw = coproc.write = -1;
    413 	coproc.njobs = 0;
    414 	coproc.id = 0;
    415 }
    416 
    417 /* Called by c_read() when eof is read - close fd if it is the co-process fd */
    418 void
    419 coproc_read_close(fd)
    420 	int fd;
    421 {
    422 	if (coproc.read >= 0 && fd == coproc.read) {
    423 		coproc_readw_close(fd);
    424 		close(coproc.read);
    425 		coproc.read = -1;
    426 	}
    427 }
    428 
    429 /* Called by c_read() and by iosetup() to close the other side of the
    430  * read pipe, so reads will actually terminate.
    431  */
    432 void
    433 coproc_readw_close(fd)
    434 	int fd;
    435 {
    436 	if (coproc.readw >= 0 && coproc.read >= 0 && fd == coproc.read) {
    437 		close(coproc.readw);
    438 		coproc.readw = -1;
    439 	}
    440 }
    441 
    442 /* Called by c_print when a write to a fd fails with EPIPE and by iosetup
    443  * when co-process input is dup'd
    444  */
    445 void
    446 coproc_write_close(fd)
    447 	int fd;
    448 {
    449 	if (coproc.write >= 0 && fd == coproc.write) {
    450 		close(coproc.write);
    451 		coproc.write = -1;
    452 	}
    453 }
    454 
    455 /* Called to check for existance of/value of the co-process file descriptor.
    456  * (Used by check_fd() and by c_read/c_print to deal with -p option).
    457  */
    458 int
    459 coproc_getfd(mode, emsgp)
    460 	int mode;
    461 	const char **emsgp;
    462 {
    463 	int fd = (mode & R_OK) ? coproc.read : coproc.write;
    464 
    465 	if (fd >= 0)
    466 		return fd;
    467 	if (emsgp)
    468 		*emsgp = "no coprocess";
    469 	return -1;
    470 }
    471 
    472 /* called to close file descriptors related to the coprocess (if any)
    473  * Should be called with SIGCHLD blocked.
    474  */
    475 void
    476 coproc_cleanup(reuse)
    477 	int reuse;
    478 {
    479 	/* This to allow co-processes to share output pipe */
    480 	if (!reuse || coproc.readw < 0 || coproc.read < 0) {
    481 		if (coproc.read >= 0) {
    482 			close(coproc.read);
    483 			coproc.read = -1;
    484 		}
    485 		if (coproc.readw >= 0) {
    486 			close(coproc.readw);
    487 			coproc.readw = -1;
    488 		}
    489 	}
    490 	if (coproc.write >= 0) {
    491 		close(coproc.write);
    492 		coproc.write = -1;
    493 	}
    494 }
    495 #endif /* KSH */
    496 
    497 
    498 /*
    499  * temporary files
    500  */
    501 
    502 struct temp *
    503 maketemp(ap, type, tlist)
    504 	Area *ap;
    505 	Temp_type type;
    506 	struct temp **tlist;
    507 {
    508 	static unsigned int inc;
    509 	struct temp *tp;
    510 	int len;
    511 	int fd;
    512 	char *path;
    513 	const char *dir;
    514 
    515 	dir = tmpdir ? tmpdir : "/tmp";
    516 	/* The 20 + 20 is a paranoid worst case for pid/inc */
    517 	len = strlen(dir) + 3 + 20 + 20 + 1;
    518 	tp = (struct temp *) alloc(sizeof(struct temp) + len, ap);
    519 	tp->name = path = (char *) &tp[1];
    520 	tp->shf = (struct shf *) 0;
    521 	tp->type = type;
    522 	while (1) {
    523 		/* Note that temp files need to fit 8.3 DOS limits */
    524 		shf_snprintf(path, len, "%s/sh%05u.%03x",
    525 			     dir, (unsigned) procpid, inc++);
    526 		/* Mode 0600 to be paranoid, O_TRUNC in case O_EXCL isn't
    527 		 * really there.
    528 		 */
    529 		fd = open(path, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0600);
    530 		if (fd >= 0) {
    531 			tp->shf = shf_fdopen(fd, SHF_WR, (struct shf *) 0);
    532 			break;
    533 		}
    534 		if (errno != EINTR
    535 #ifdef EEXIST
    536 		    && errno != EEXIST
    537 #endif /* EEXIST */
    538 #ifdef EISDIR
    539 		    && errno != EISDIR
    540 #endif /* EISDIR */
    541 			)
    542 			/* Error must be printed by caller: don't know here if
    543 			 * errorf() or bi_errorf() should be used.
    544 			 */
    545 			break;
    546 	}
    547 	tp->next = NULL;
    548 	tp->pid = procpid;
    549 
    550 	tp->next = *tlist;
    551 	*tlist = tp;
    552 
    553 	return tp;
    554 }
    555