Home | History | Annotate | Download | only in src
      1 /*	$OpenBSD: shf.c,v 1.16 2013/04/19 17:36:09 millert Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011,
      5  *		 2012, 2013
      6  *	Thorsten Glaser <tg (at) mirbsd.org>
      7  *
      8  * Provided that these terms and disclaimer and all copyright notices
      9  * are retained or reproduced in an accompanying document, permission
     10  * is granted to deal in this work without restriction, including un-
     11  * limited rights to use, publicly perform, distribute, sell, modify,
     12  * merge, give away, or sublicence.
     13  *
     14  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
     15  * the utmost extent permitted by applicable law, neither express nor
     16  * implied; without malicious intent or gross negligence. In no event
     17  * may a licensor, author or contributor be held liable for indirect,
     18  * direct, other damage, loss, or other issues arising in any way out
     19  * of dealing in the work, even if advised of the possibility of such
     20  * damage or existence of a defect, except proven that it results out
     21  * of said person's immediate fault when using the work as intended.
     22  *-
     23  * Use %zX instead of %p and floating point isn't supported at all.
     24  */
     25 
     26 #include "sh.h"
     27 
     28 __RCSID("$MirOS: src/bin/mksh/shf.c,v 1.62 2013/10/09 11:59:30 tg Exp $");
     29 
     30 /* flags to shf_emptybuf() */
     31 #define EB_READSW	0x01	/* about to switch to reading */
     32 #define EB_GROW		0x02	/* grow buffer if necessary (STRING+DYNAMIC) */
     33 
     34 /*
     35  * Replacement stdio routines. Stdio is too flakey on too many machines
     36  * to be useful when you have multiple processes using the same underlying
     37  * file descriptors.
     38  */
     39 
     40 static int shf_fillbuf(struct shf *);
     41 static int shf_emptybuf(struct shf *, int);
     42 
     43 /*
     44  * Open a file. First three args are for open(), last arg is flags for
     45  * this package. Returns NULL if file could not be opened, or if a dup
     46  * fails.
     47  */
     48 struct shf *
     49 shf_open(const char *name, int oflags, int mode, int sflags)
     50 {
     51 	struct shf *shf;
     52 	ssize_t bsize =
     53 	    /* at most 512 */
     54 	    sflags & SHF_UNBUF ? (sflags & SHF_RD ? 1 : 0) : SHF_BSIZE;
     55 	int fd, eno;
     56 
     57 	/* Done before open so if alloca fails, fd won't be lost. */
     58 	shf = alloc(sizeof(struct shf) + bsize, ATEMP);
     59 	shf->areap = ATEMP;
     60 	shf->buf = (unsigned char *)&shf[1];
     61 	shf->bsize = bsize;
     62 	shf->flags = SHF_ALLOCS;
     63 	/* Rest filled in by reopen. */
     64 
     65 	fd = open(name, oflags | O_BINARY, mode);
     66 	if (fd < 0) {
     67 		eno = errno;
     68 		afree(shf, shf->areap);
     69 		errno = eno;
     70 		return (NULL);
     71 	}
     72 	if ((sflags & SHF_MAPHI) && fd < FDBASE) {
     73 		int nfd;
     74 
     75 		nfd = fcntl(fd, F_DUPFD, FDBASE);
     76 		eno = errno;
     77 		close(fd);
     78 		if (nfd < 0) {
     79 			afree(shf, shf->areap);
     80 			errno = eno;
     81 			return (NULL);
     82 		}
     83 		fd = nfd;
     84 	}
     85 	sflags &= ~SHF_ACCMODE;
     86 	sflags |= (oflags & O_ACCMODE) == O_RDONLY ? SHF_RD :
     87 	    ((oflags & O_ACCMODE) == O_WRONLY ? SHF_WR : SHF_RDWR);
     88 
     89 	return (shf_reopen(fd, sflags, shf));
     90 }
     91 
     92 /* helper function for shf_fdopen and shf_reopen */
     93 static void
     94 shf_open_hlp(int fd, int *sflagsp, const char *where)
     95 {
     96 	int sflags = *sflagsp;
     97 
     98 	/* use fcntl() to figure out correct read/write flags */
     99 	if (sflags & SHF_GETFL) {
    100 		int flags = fcntl(fd, F_GETFL, 0);
    101 
    102 		if (flags < 0)
    103 			/* will get an error on first read/write */
    104 			sflags |= SHF_RDWR;
    105 		else {
    106 			switch (flags & O_ACCMODE) {
    107 			case O_RDONLY:
    108 				sflags |= SHF_RD;
    109 				break;
    110 			case O_WRONLY:
    111 				sflags |= SHF_WR;
    112 				break;
    113 			case O_RDWR:
    114 				sflags |= SHF_RDWR;
    115 				break;
    116 			}
    117 		}
    118 		*sflagsp = sflags;
    119 	}
    120 
    121 	if (!(sflags & (SHF_RD | SHF_WR)))
    122 		internal_errorf("%s: %s", where, "missing read/write");
    123 }
    124 
    125 /* Set up the shf structure for a file descriptor. Doesn't fail. */
    126 struct shf *
    127 shf_fdopen(int fd, int sflags, struct shf *shf)
    128 {
    129 	ssize_t bsize =
    130 	    /* at most 512 */
    131 	    sflags & SHF_UNBUF ? (sflags & SHF_RD ? 1 : 0) : SHF_BSIZE;
    132 
    133 	shf_open_hlp(fd, &sflags, "shf_fdopen");
    134 	if (shf) {
    135 		if (bsize) {
    136 			shf->buf = alloc(bsize, ATEMP);
    137 			sflags |= SHF_ALLOCB;
    138 		} else
    139 			shf->buf = NULL;
    140 	} else {
    141 		shf = alloc(sizeof(struct shf) + bsize, ATEMP);
    142 		shf->buf = (unsigned char *)&shf[1];
    143 		sflags |= SHF_ALLOCS;
    144 	}
    145 	shf->areap = ATEMP;
    146 	shf->fd = fd;
    147 	shf->rp = shf->wp = shf->buf;
    148 	shf->rnleft = 0;
    149 	shf->rbsize = bsize;
    150 	shf->wnleft = 0; /* force call to shf_emptybuf() */
    151 	shf->wbsize = sflags & SHF_UNBUF ? 0 : bsize;
    152 	shf->flags = sflags;
    153 	shf->errnosv = 0;
    154 	shf->bsize = bsize;
    155 	if (sflags & SHF_CLEXEC)
    156 		fcntl(fd, F_SETFD, FD_CLOEXEC);
    157 	return (shf);
    158 }
    159 
    160 /* Set up an existing shf (and buffer) to use the given fd */
    161 struct shf *
    162 shf_reopen(int fd, int sflags, struct shf *shf)
    163 {
    164 	ssize_t bsize =
    165 	    /* at most 512 */
    166 	    sflags & SHF_UNBUF ? (sflags & SHF_RD ? 1 : 0) : SHF_BSIZE;
    167 
    168 	shf_open_hlp(fd, &sflags, "shf_reopen");
    169 	if (!shf || !shf->buf || shf->bsize < bsize)
    170 		internal_errorf("%s: %s", "shf_reopen", "bad shf/buf/bsize");
    171 
    172 	/* assumes shf->buf and shf->bsize already set up */
    173 	shf->fd = fd;
    174 	shf->rp = shf->wp = shf->buf;
    175 	shf->rnleft = 0;
    176 	shf->rbsize = bsize;
    177 	shf->wnleft = 0; /* force call to shf_emptybuf() */
    178 	shf->wbsize = sflags & SHF_UNBUF ? 0 : bsize;
    179 	shf->flags = (shf->flags & (SHF_ALLOCS | SHF_ALLOCB)) | sflags;
    180 	shf->errnosv = 0;
    181 	if (sflags & SHF_CLEXEC)
    182 		fcntl(fd, F_SETFD, FD_CLOEXEC);
    183 	return (shf);
    184 }
    185 
    186 /*
    187  * Open a string for reading or writing. If reading, bsize is the number
    188  * of bytes that can be read. If writing, bsize is the maximum number of
    189  * bytes that can be written. If shf is not NULL, it is filled in and
    190  * returned, if it is NULL, shf is allocated. If writing and buf is NULL
    191  * and SHF_DYNAMIC is set, the buffer is allocated (if bsize > 0, it is
    192  * used for the initial size). Doesn't fail.
    193  * When writing, a byte is reserved for a trailing NUL - see shf_sclose().
    194  */
    195 struct shf *
    196 shf_sopen(char *buf, ssize_t bsize, int sflags, struct shf *shf)
    197 {
    198 	/* can't have a read+write string */
    199 	if (!(!(sflags & SHF_RD) ^ !(sflags & SHF_WR)))
    200 		internal_errorf("%s: flags 0x%X", "shf_sopen", sflags);
    201 
    202 	if (!shf) {
    203 		shf = alloc(sizeof(struct shf), ATEMP);
    204 		sflags |= SHF_ALLOCS;
    205 	}
    206 	shf->areap = ATEMP;
    207 	if (!buf && (sflags & SHF_WR) && (sflags & SHF_DYNAMIC)) {
    208 		if (bsize <= 0)
    209 			bsize = 64;
    210 		sflags |= SHF_ALLOCB;
    211 		buf = alloc(bsize, shf->areap);
    212 	}
    213 	shf->fd = -1;
    214 	shf->buf = shf->rp = shf->wp = (unsigned char *)buf;
    215 	shf->rnleft = bsize;
    216 	shf->rbsize = bsize;
    217 	shf->wnleft = bsize - 1;	/* space for a '\0' */
    218 	shf->wbsize = bsize;
    219 	shf->flags = sflags | SHF_STRING;
    220 	shf->errnosv = 0;
    221 	shf->bsize = bsize;
    222 
    223 	return (shf);
    224 }
    225 
    226 /* Flush and close file descriptor, free the shf structure */
    227 int
    228 shf_close(struct shf *shf)
    229 {
    230 	int ret = 0;
    231 
    232 	if (shf->fd >= 0) {
    233 		ret = shf_flush(shf);
    234 		if (close(shf->fd) < 0)
    235 			ret = EOF;
    236 	}
    237 	if (shf->flags & SHF_ALLOCS)
    238 		afree(shf, shf->areap);
    239 	else if (shf->flags & SHF_ALLOCB)
    240 		afree(shf->buf, shf->areap);
    241 
    242 	return (ret);
    243 }
    244 
    245 /* Flush and close file descriptor, don't free file structure */
    246 int
    247 shf_fdclose(struct shf *shf)
    248 {
    249 	int ret = 0;
    250 
    251 	if (shf->fd >= 0) {
    252 		ret = shf_flush(shf);
    253 		if (close(shf->fd) < 0)
    254 			ret = EOF;
    255 		shf->rnleft = 0;
    256 		shf->rp = shf->buf;
    257 		shf->wnleft = 0;
    258 		shf->fd = -1;
    259 	}
    260 
    261 	return (ret);
    262 }
    263 
    264 /*
    265  * Close a string - if it was opened for writing, it is NUL terminated;
    266  * returns a pointer to the string and frees shf if it was allocated
    267  * (does not free string if it was allocated).
    268  */
    269 char *
    270 shf_sclose(struct shf *shf)
    271 {
    272 	unsigned char *s = shf->buf;
    273 
    274 	/* NUL terminate */
    275 	if (shf->flags & SHF_WR) {
    276 		shf->wnleft++;
    277 		shf_putc('\0', shf);
    278 	}
    279 	if (shf->flags & SHF_ALLOCS)
    280 		afree(shf, shf->areap);
    281 	return ((char *)s);
    282 }
    283 
    284 /*
    285  * Un-read what has been read but not examined, or write what has been
    286  * buffered. Returns 0 for success, EOF for (write) error.
    287  */
    288 int
    289 shf_flush(struct shf *shf)
    290 {
    291 	if (shf->flags & SHF_STRING)
    292 		return ((shf->flags & SHF_WR) ? EOF : 0);
    293 
    294 	if (shf->fd < 0)
    295 		internal_errorf("%s: %s", "shf_flush", "no fd");
    296 
    297 	if (shf->flags & SHF_ERROR) {
    298 		errno = shf->errnosv;
    299 		return (EOF);
    300 	}
    301 
    302 	if (shf->flags & SHF_READING) {
    303 		shf->flags &= ~(SHF_EOF | SHF_READING);
    304 		if (shf->rnleft > 0) {
    305 			lseek(shf->fd, (off_t)-shf->rnleft, SEEK_CUR);
    306 			shf->rnleft = 0;
    307 			shf->rp = shf->buf;
    308 		}
    309 		return (0);
    310 	} else if (shf->flags & SHF_WRITING)
    311 		return (shf_emptybuf(shf, 0));
    312 
    313 	return (0);
    314 }
    315 
    316 /*
    317  * Write out any buffered data. If currently reading, flushes the read
    318  * buffer. Returns 0 for success, EOF for (write) error.
    319  */
    320 static int
    321 shf_emptybuf(struct shf *shf, int flags)
    322 {
    323 	int ret = 0;
    324 
    325 	if (!(shf->flags & SHF_STRING) && shf->fd < 0)
    326 		internal_errorf("%s: %s", "shf_emptybuf", "no fd");
    327 
    328 	if (shf->flags & SHF_ERROR) {
    329 		errno = shf->errnosv;
    330 		return (EOF);
    331 	}
    332 
    333 	if (shf->flags & SHF_READING) {
    334 		if (flags & EB_READSW)
    335 			/* doesn't happen */
    336 			return (0);
    337 		ret = shf_flush(shf);
    338 		shf->flags &= ~SHF_READING;
    339 	}
    340 	if (shf->flags & SHF_STRING) {
    341 		unsigned char *nbuf;
    342 
    343 		/*
    344 		 * Note that we assume SHF_ALLOCS is not set if
    345 		 * SHF_ALLOCB is set... (changing the shf pointer could
    346 		 * cause problems)
    347 		 */
    348 		if (!(flags & EB_GROW) || !(shf->flags & SHF_DYNAMIC) ||
    349 		    !(shf->flags & SHF_ALLOCB))
    350 			return (EOF);
    351 		/* allocate more space for buffer */
    352 		nbuf = aresize2(shf->buf, 2, shf->wbsize, shf->areap);
    353 		shf->rp = nbuf + (shf->rp - shf->buf);
    354 		shf->wp = nbuf + (shf->wp - shf->buf);
    355 		shf->rbsize += shf->wbsize;
    356 		shf->wnleft += shf->wbsize;
    357 		shf->wbsize <<= 1;
    358 		shf->buf = nbuf;
    359 	} else {
    360 		if (shf->flags & SHF_WRITING) {
    361 			ssize_t n, ntowrite = shf->wp - shf->buf;
    362 			unsigned char *buf = shf->buf;
    363 
    364 			while (ntowrite > 0) {
    365 				n = write(shf->fd, buf, ntowrite);
    366 				if (n < 0) {
    367 					if (errno == EINTR &&
    368 					    !(shf->flags & SHF_INTERRUPT))
    369 						continue;
    370 					shf->flags |= SHF_ERROR;
    371 					shf->errnosv = errno;
    372 					shf->wnleft = 0;
    373 					if (buf != shf->buf) {
    374 						/*
    375 						 * allow a second flush
    376 						 * to work
    377 						 */
    378 						memmove(shf->buf, buf,
    379 						    ntowrite);
    380 						shf->wp = shf->buf + ntowrite;
    381 					}
    382 					return (EOF);
    383 				}
    384 				buf += n;
    385 				ntowrite -= n;
    386 			}
    387 			if (flags & EB_READSW) {
    388 				shf->wp = shf->buf;
    389 				shf->wnleft = 0;
    390 				shf->flags &= ~SHF_WRITING;
    391 				return (0);
    392 			}
    393 		}
    394 		shf->wp = shf->buf;
    395 		shf->wnleft = shf->wbsize;
    396 	}
    397 	shf->flags |= SHF_WRITING;
    398 
    399 	return (ret);
    400 }
    401 
    402 /* Fill up a read buffer. Returns EOF for a read error, 0 otherwise. */
    403 static int
    404 shf_fillbuf(struct shf *shf)
    405 {
    406 	ssize_t n;
    407 
    408 	if (shf->flags & SHF_STRING)
    409 		return (0);
    410 
    411 	if (shf->fd < 0)
    412 		internal_errorf("%s: %s", "shf_fillbuf", "no fd");
    413 
    414 	if (shf->flags & (SHF_EOF | SHF_ERROR)) {
    415 		if (shf->flags & SHF_ERROR)
    416 			errno = shf->errnosv;
    417 		return (EOF);
    418 	}
    419 
    420 	if ((shf->flags & SHF_WRITING) && shf_emptybuf(shf, EB_READSW) == EOF)
    421 		return (EOF);
    422 
    423 	shf->flags |= SHF_READING;
    424 
    425 	shf->rp = shf->buf;
    426 	while (/* CONSTCOND */ 1) {
    427 		n = blocking_read(shf->fd, (char *)shf->buf, shf->rbsize);
    428 		if (n < 0 && errno == EINTR && !(shf->flags & SHF_INTERRUPT))
    429 			continue;
    430 		break;
    431 	}
    432 	if (n < 0) {
    433 		shf->flags |= SHF_ERROR;
    434 		shf->errnosv = errno;
    435 		shf->rnleft = 0;
    436 		shf->rp = shf->buf;
    437 		return (EOF);
    438 	}
    439 	if ((shf->rnleft = n) == 0)
    440 		shf->flags |= SHF_EOF;
    441 	return (0);
    442 }
    443 
    444 /*
    445  * Read a buffer from shf. Returns the number of bytes read into buf, if
    446  * no bytes were read, returns 0 if end of file was seen, EOF if a read
    447  * error occurred.
    448  */
    449 ssize_t
    450 shf_read(char *buf, ssize_t bsize, struct shf *shf)
    451 {
    452 	ssize_t ncopy, orig_bsize = bsize;
    453 
    454 	if (!(shf->flags & SHF_RD))
    455 		internal_errorf("%s: flags 0x%X", "shf_read", shf->flags);
    456 
    457 	if (bsize <= 0)
    458 		internal_errorf("%s: %s %zd", "shf_write", "bsize", bsize);
    459 
    460 	while (bsize > 0) {
    461 		if (shf->rnleft == 0 &&
    462 		    (shf_fillbuf(shf) == EOF || shf->rnleft == 0))
    463 			break;
    464 		ncopy = shf->rnleft;
    465 		if (ncopy > bsize)
    466 			ncopy = bsize;
    467 		memcpy(buf, shf->rp, ncopy);
    468 		buf += ncopy;
    469 		bsize -= ncopy;
    470 		shf->rp += ncopy;
    471 		shf->rnleft -= ncopy;
    472 	}
    473 	/* Note: fread(3S) returns 0 for errors - this doesn't */
    474 	return (orig_bsize == bsize ? (shf_error(shf) ? EOF : 0) :
    475 	    orig_bsize - bsize);
    476 }
    477 
    478 /*
    479  * Read up to a newline or EOF. The newline is put in buf; buf is always
    480  * NUL terminated. Returns NULL on read error or if nothing was read
    481  * before end of file, returns a pointer to the NUL byte in buf
    482  * otherwise.
    483  */
    484 char *
    485 shf_getse(char *buf, ssize_t bsize, struct shf *shf)
    486 {
    487 	unsigned char *end;
    488 	ssize_t ncopy;
    489 	char *orig_buf = buf;
    490 
    491 	if (!(shf->flags & SHF_RD))
    492 		internal_errorf("%s: flags 0x%X", "shf_getse", shf->flags);
    493 
    494 	if (bsize <= 0)
    495 		return (NULL);
    496 
    497 	/* save room for NUL */
    498 	--bsize;
    499 	do {
    500 		if (shf->rnleft == 0) {
    501 			if (shf_fillbuf(shf) == EOF)
    502 				return (NULL);
    503 			if (shf->rnleft == 0) {
    504 				*buf = '\0';
    505 				return (buf == orig_buf ? NULL : buf);
    506 			}
    507 		}
    508 		end = (unsigned char *)memchr((char *)shf->rp, '\n',
    509 		    shf->rnleft);
    510 		ncopy = end ? end - shf->rp + 1 : shf->rnleft;
    511 		if (ncopy > bsize)
    512 			ncopy = bsize;
    513 		memcpy(buf, (char *) shf->rp, ncopy);
    514 		shf->rp += ncopy;
    515 		shf->rnleft -= ncopy;
    516 		buf += ncopy;
    517 		bsize -= ncopy;
    518 	} while (!end && bsize);
    519 	*buf = '\0';
    520 	return (buf);
    521 }
    522 
    523 /* Returns the char read. Returns EOF for error and end of file. */
    524 int
    525 shf_getchar(struct shf *shf)
    526 {
    527 	if (!(shf->flags & SHF_RD))
    528 		internal_errorf("%s: flags 0x%X", "shf_getchar", shf->flags);
    529 
    530 	if (shf->rnleft == 0 && (shf_fillbuf(shf) == EOF || shf->rnleft == 0))
    531 		return (EOF);
    532 	--shf->rnleft;
    533 	return (*shf->rp++);
    534 }
    535 
    536 /*
    537  * Put a character back in the input stream. Returns the character if
    538  * successful, EOF if there is no room.
    539  */
    540 int
    541 shf_ungetc(int c, struct shf *shf)
    542 {
    543 	if (!(shf->flags & SHF_RD))
    544 		internal_errorf("%s: flags 0x%X", "shf_ungetc", shf->flags);
    545 
    546 	if ((shf->flags & SHF_ERROR) || c == EOF ||
    547 	    (shf->rp == shf->buf && shf->rnleft))
    548 		return (EOF);
    549 
    550 	if ((shf->flags & SHF_WRITING) && shf_emptybuf(shf, EB_READSW) == EOF)
    551 		return (EOF);
    552 
    553 	if (shf->rp == shf->buf)
    554 		shf->rp = shf->buf + shf->rbsize;
    555 	if (shf->flags & SHF_STRING) {
    556 		/*
    557 		 * Can unget what was read, but not something different;
    558 		 * we don't want to modify a string.
    559 		 */
    560 		if ((int)(shf->rp[-1]) != c)
    561 			return (EOF);
    562 		shf->flags &= ~SHF_EOF;
    563 		shf->rp--;
    564 		shf->rnleft++;
    565 		return (c);
    566 	}
    567 	shf->flags &= ~SHF_EOF;
    568 	*--(shf->rp) = c;
    569 	shf->rnleft++;
    570 	return (c);
    571 }
    572 
    573 /*
    574  * Write a character. Returns the character if successful, EOF if the
    575  * char could not be written.
    576  */
    577 int
    578 shf_putchar(int c, struct shf *shf)
    579 {
    580 	if (!(shf->flags & SHF_WR))
    581 		internal_errorf("%s: flags 0x%X", "shf_putchar", shf->flags);
    582 
    583 	if (c == EOF)
    584 		return (EOF);
    585 
    586 	if (shf->flags & SHF_UNBUF) {
    587 		unsigned char cc = (unsigned char)c;
    588 		ssize_t n;
    589 
    590 		if (shf->fd < 0)
    591 			internal_errorf("%s: %s", "shf_putchar", "no fd");
    592 		if (shf->flags & SHF_ERROR) {
    593 			errno = shf->errnosv;
    594 			return (EOF);
    595 		}
    596 		while ((n = write(shf->fd, &cc, 1)) != 1)
    597 			if (n < 0) {
    598 				if (errno == EINTR &&
    599 				    !(shf->flags & SHF_INTERRUPT))
    600 					continue;
    601 				shf->flags |= SHF_ERROR;
    602 				shf->errnosv = errno;
    603 				return (EOF);
    604 			}
    605 	} else {
    606 		/* Flush deals with strings and sticky errors */
    607 		if (shf->wnleft == 0 && shf_emptybuf(shf, EB_GROW) == EOF)
    608 			return (EOF);
    609 		shf->wnleft--;
    610 		*shf->wp++ = c;
    611 	}
    612 
    613 	return (c);
    614 }
    615 
    616 /*
    617  * Write a string. Returns the length of the string if successful, EOF
    618  * if the string could not be written.
    619  */
    620 ssize_t
    621 shf_puts(const char *s, struct shf *shf)
    622 {
    623 	if (!s)
    624 		return (EOF);
    625 
    626 	return (shf_write(s, strlen(s), shf));
    627 }
    628 
    629 /* Write a buffer. Returns nbytes if successful, EOF if there is an error. */
    630 ssize_t
    631 shf_write(const char *buf, ssize_t nbytes, struct shf *shf)
    632 {
    633 	ssize_t n, ncopy, orig_nbytes = nbytes;
    634 
    635 	if (!(shf->flags & SHF_WR))
    636 		internal_errorf("%s: flags 0x%X", "shf_write", shf->flags);
    637 
    638 	if (nbytes < 0)
    639 		internal_errorf("%s: %s %zd", "shf_write", "nbytes", nbytes);
    640 
    641 	/* Don't buffer if buffer is empty and we're writting a large amount. */
    642 	if ((ncopy = shf->wnleft) &&
    643 	    (shf->wp != shf->buf || nbytes < shf->wnleft)) {
    644 		if (ncopy > nbytes)
    645 			ncopy = nbytes;
    646 		memcpy(shf->wp, buf, ncopy);
    647 		nbytes -= ncopy;
    648 		buf += ncopy;
    649 		shf->wp += ncopy;
    650 		shf->wnleft -= ncopy;
    651 	}
    652 	if (nbytes > 0) {
    653 		if (shf->flags & SHF_STRING) {
    654 			/* resize buffer until there's enough space left */
    655 			while (nbytes > shf->wnleft)
    656 				if (shf_emptybuf(shf, EB_GROW) == EOF)
    657 					return (EOF);
    658 			/* then write everything into the buffer */
    659 		} else {
    660 			/* flush deals with sticky errors */
    661 			if (shf_emptybuf(shf, EB_GROW) == EOF)
    662 				return (EOF);
    663 			/* write chunks larger than window size directly */
    664 			if (nbytes > shf->wbsize) {
    665 				ncopy = nbytes;
    666 				if (shf->wbsize)
    667 					ncopy -= nbytes % shf->wbsize;
    668 				nbytes -= ncopy;
    669 				while (ncopy > 0) {
    670 					n = write(shf->fd, buf, ncopy);
    671 					if (n < 0) {
    672 						if (errno == EINTR &&
    673 						    !(shf->flags & SHF_INTERRUPT))
    674 							continue;
    675 						shf->flags |= SHF_ERROR;
    676 						shf->errnosv = errno;
    677 						shf->wnleft = 0;
    678 						/*
    679 						 * Note: fwrite(3) returns 0
    680 						 * for errors - this doesn't
    681 						 */
    682 						return (EOF);
    683 					}
    684 					buf += n;
    685 					ncopy -= n;
    686 				}
    687 			}
    688 			/* ... and buffer the rest */
    689 		}
    690 		if (nbytes > 0) {
    691 			/* write remaining bytes to buffer */
    692 			memcpy(shf->wp, buf, nbytes);
    693 			shf->wp += nbytes;
    694 			shf->wnleft -= nbytes;
    695 		}
    696 	}
    697 
    698 	return (orig_nbytes);
    699 }
    700 
    701 ssize_t
    702 shf_fprintf(struct shf *shf, const char *fmt, ...)
    703 {
    704 	va_list args;
    705 	ssize_t n;
    706 
    707 	va_start(args, fmt);
    708 	n = shf_vfprintf(shf, fmt, args);
    709 	va_end(args);
    710 
    711 	return (n);
    712 }
    713 
    714 ssize_t
    715 shf_snprintf(char *buf, ssize_t bsize, const char *fmt, ...)
    716 {
    717 	struct shf shf;
    718 	va_list args;
    719 	ssize_t n;
    720 
    721 	if (!buf || bsize <= 0)
    722 		internal_errorf("shf_snprintf: buf %zX, bsize %zd",
    723 		    (size_t)buf, bsize);
    724 
    725 	shf_sopen(buf, bsize, SHF_WR, &shf);
    726 	va_start(args, fmt);
    727 	n = shf_vfprintf(&shf, fmt, args);
    728 	va_end(args);
    729 	/* NUL terminates */
    730 	shf_sclose(&shf);
    731 	return (n);
    732 }
    733 
    734 char *
    735 shf_smprintf(const char *fmt, ...)
    736 {
    737 	struct shf shf;
    738 	va_list args;
    739 
    740 	shf_sopen(NULL, 0, SHF_WR|SHF_DYNAMIC, &shf);
    741 	va_start(args, fmt);
    742 	shf_vfprintf(&shf, fmt, args);
    743 	va_end(args);
    744 	/* NUL terminates */
    745 	return (shf_sclose(&shf));
    746 }
    747 
    748 #define	FL_HASH		0x001	/* '#' seen */
    749 #define FL_PLUS		0x002	/* '+' seen */
    750 #define FL_RIGHT	0x004	/* '-' seen */
    751 #define FL_BLANK	0x008	/* ' ' seen */
    752 #define FL_SHORT	0x010	/* 'h' seen */
    753 #define FL_LONG		0x020	/* 'l' seen */
    754 #define FL_ZERO		0x040	/* '0' seen */
    755 #define FL_DOT		0x080	/* '.' seen */
    756 #define FL_UPPER	0x100	/* format character was uppercase */
    757 #define FL_NUMBER	0x200	/* a number was formated %[douxefg] */
    758 #define FL_SIZET	0x400	/* 'z' seen */
    759 #define FM_SIZES	0x430	/* h/l/z mask */
    760 
    761 ssize_t
    762 shf_vfprintf(struct shf *shf, const char *fmt, va_list args)
    763 {
    764 	const char *s;
    765 	char c, *cp;
    766 	int tmp = 0, flags;
    767 	ssize_t field, precision, len;
    768 	unsigned long lnum;
    769 	/* %#o produces the longest output */
    770 	char numbuf[(8 * sizeof(long) + 2) / 3 + 1
    771 #ifdef DEBUG
    772 		/* a NUL for LLVM/Clang scan-build */
    773 		+ 1
    774 #endif
    775 	    ];
    776 	/* this stuff for dealing with the buffer */
    777 	ssize_t nwritten = 0;
    778 
    779 #define VA(type) va_arg(args, type)
    780 
    781 	if (!fmt)
    782 		return (0);
    783 
    784 	while ((c = *fmt++)) {
    785 		if (c != '%') {
    786 			shf_putc(c, shf);
    787 			nwritten++;
    788 			continue;
    789 		}
    790 		/*
    791 		 * This will accept flags/fields in any order - not just
    792 		 * the order specified in printf(3), but this is the way
    793 		 * _doprnt() seems to work (on BSD and SYSV). The only
    794 		 * restriction is that the format character must come
    795 		 * last :-).
    796 		 */
    797 		flags = 0;
    798 		field = precision = 0;
    799 		for ( ; (c = *fmt++) ; ) {
    800 			switch (c) {
    801 			case '#':
    802 				flags |= FL_HASH;
    803 				continue;
    804 
    805 			case '+':
    806 				flags |= FL_PLUS;
    807 				continue;
    808 
    809 			case '-':
    810 				flags |= FL_RIGHT;
    811 				continue;
    812 
    813 			case ' ':
    814 				flags |= FL_BLANK;
    815 				continue;
    816 
    817 			case '0':
    818 				if (!(flags & FL_DOT))
    819 					flags |= FL_ZERO;
    820 				continue;
    821 
    822 			case '.':
    823 				flags |= FL_DOT;
    824 				precision = 0;
    825 				continue;
    826 
    827 			case '*':
    828 				tmp = VA(int);
    829 				if (flags & FL_DOT)
    830 					precision = tmp;
    831 				else if ((field = tmp) < 0) {
    832 					field = -field;
    833 					flags |= FL_RIGHT;
    834 				}
    835 				continue;
    836 
    837 			case 'l':
    838 				flags &= ~FM_SIZES;
    839 				flags |= FL_LONG;
    840 				continue;
    841 
    842 			case 'h':
    843 				flags &= ~FM_SIZES;
    844 				flags |= FL_SHORT;
    845 				continue;
    846 
    847 			case 'z':
    848 				flags &= ~FM_SIZES;
    849 				flags |= FL_SIZET;
    850 				continue;
    851 			}
    852 			if (ksh_isdigit(c)) {
    853 				bool overflowed = false;
    854 
    855 				tmp = c - '0';
    856 				while (c = *fmt++, ksh_isdigit(c)) {
    857 					if (notok2mul(2147483647, tmp, 10))
    858 						overflowed = true;
    859 					tmp = tmp * 10 + c - '0';
    860 				}
    861 				--fmt;
    862 				if (overflowed)
    863 					tmp = 0;
    864 				if (flags & FL_DOT)
    865 					precision = tmp;
    866 				else
    867 					field = tmp;
    868 				continue;
    869 			}
    870 			break;
    871 		}
    872 
    873 		if (precision < 0)
    874 			precision = 0;
    875 
    876 		if (!c)
    877 			/* nasty format */
    878 			break;
    879 
    880 		if (c >= 'A' && c <= 'Z') {
    881 			flags |= FL_UPPER;
    882 			c = ksh_tolower(c);
    883 		}
    884 
    885 		switch (c) {
    886 		case 'd':
    887 		case 'i':
    888 			if (flags & FL_SIZET)
    889 				lnum = (long)VA(ssize_t);
    890 			else if (flags & FL_LONG)
    891 				lnum = VA(long);
    892 			else if (flags & FL_SHORT)
    893 				lnum = (long)(short)VA(int);
    894 			else
    895 				lnum = (long)VA(int);
    896 			goto integral;
    897 
    898 		case 'o':
    899 		case 'u':
    900 		case 'x':
    901 			if (flags & FL_SIZET)
    902 				lnum = VA(size_t);
    903 			else if (flags & FL_LONG)
    904 				lnum = VA(unsigned long);
    905 			else if (flags & FL_SHORT)
    906 				lnum = (unsigned long)(unsigned short)VA(int);
    907 			else
    908 				lnum = (unsigned long)VA(unsigned int);
    909 
    910  integral:
    911 			flags |= FL_NUMBER;
    912 			cp = numbuf + sizeof(numbuf);
    913 #ifdef DEBUG
    914 			/*
    915 			 * this is necessary so Clang 3.2 realises
    916 			 * utf_skipcols/shf_putc in the output loop
    917 			 * terminate; these values are always ASCII
    918 			 * so an out-of-bounds access cannot happen
    919 			 * but Clang doesn't know that
    920 			 */
    921 			*--cp = '\0';
    922 #endif
    923 
    924 			switch (c) {
    925 			case 'd':
    926 			case 'i':
    927 				if (0 > (long)lnum) {
    928 					lnum = -(long)lnum;
    929 					tmp = 1;
    930 				} else
    931 					tmp = 0;
    932 				/* FALLTHROUGH */
    933 			case 'u':
    934 				do {
    935 					*--cp = lnum % 10 + '0';
    936 					lnum /= 10;
    937 				} while (lnum);
    938 
    939 				if (c != 'u') {
    940 					if (tmp)
    941 						*--cp = '-';
    942 					else if (flags & FL_PLUS)
    943 						*--cp = '+';
    944 					else if (flags & FL_BLANK)
    945 						*--cp = ' ';
    946 				}
    947 				break;
    948 
    949 			case 'o':
    950 				do {
    951 					*--cp = (lnum & 0x7) + '0';
    952 					lnum >>= 3;
    953 				} while (lnum);
    954 
    955 				if ((flags & FL_HASH) && *cp != '0')
    956 					*--cp = '0';
    957 				break;
    958 
    959 			case 'x': {
    960 				const char *digits = (flags & FL_UPPER) ?
    961 				    digits_uc : digits_lc;
    962 				do {
    963 					*--cp = digits[lnum & 0xf];
    964 					lnum >>= 4;
    965 				} while (lnum);
    966 
    967 				if (flags & FL_HASH) {
    968 					*--cp = (flags & FL_UPPER) ? 'X' : 'x';
    969 					*--cp = '0';
    970 				}
    971 			}
    972 			}
    973 			len = numbuf + sizeof(numbuf) - (s = cp);
    974 #ifdef DEBUG
    975 			/* see above comment for Clang 3.2 */
    976 			--len;
    977 #endif
    978 			if (flags & FL_DOT) {
    979 				if (precision > len) {
    980 					field = precision;
    981 					flags |= FL_ZERO;
    982 				} else
    983 					/* no loss */
    984 					precision = len;
    985 			}
    986 			break;
    987 
    988 		case 's':
    989 			if ((s = VA(const char *)) == NULL)
    990 				s = "(null)";
    991 			else if (flags & FL_HASH) {
    992 				print_value_quoted(shf, s);
    993 				continue;
    994 			}
    995 			len = utf_mbswidth(s);
    996 			break;
    997 
    998 		case 'c':
    999 			flags &= ~FL_DOT;
   1000 			c = (char)(VA(int));
   1001 			/* FALLTHROUGH */
   1002 
   1003 		case '%':
   1004 		default:
   1005 			numbuf[0] = c;
   1006 			numbuf[1] = 0;
   1007 			s = numbuf;
   1008 			len = 1;
   1009 			break;
   1010 		}
   1011 
   1012 		/*
   1013 		 * At this point s should point to a string that is to be
   1014 		 * formatted, and len should be the length of the string.
   1015 		 */
   1016 		if (!(flags & FL_DOT) || len < precision)
   1017 			precision = len;
   1018 		if (field > precision) {
   1019 			field -= precision;
   1020 			if (!(flags & FL_RIGHT)) {
   1021 				field = -field;
   1022 				/* skip past sign or 0x when padding with 0 */
   1023 				if ((flags & FL_ZERO) && (flags & FL_NUMBER)) {
   1024 					if (*s == '+' || *s == '-' ||
   1025 					    *s == ' ') {
   1026 						shf_putc(*s, shf);
   1027 						s++;
   1028 						precision--;
   1029 						nwritten++;
   1030 					} else if (*s == '0') {
   1031 						shf_putc(*s, shf);
   1032 						s++;
   1033 						nwritten++;
   1034 						if (--precision > 0 &&
   1035 						    (*s | 0x20) == 'x') {
   1036 							shf_putc(*s, shf);
   1037 							s++;
   1038 							precision--;
   1039 							nwritten++;
   1040 						}
   1041 					}
   1042 					c = '0';
   1043 				} else
   1044 					c = flags & FL_ZERO ? '0' : ' ';
   1045 				if (field < 0) {
   1046 					nwritten += -field;
   1047 					for ( ; field < 0 ; field++)
   1048 						shf_putc(c, shf);
   1049 				}
   1050 			} else
   1051 				c = ' ';
   1052 		} else
   1053 			field = 0;
   1054 
   1055 		if (precision > 0) {
   1056 			const char *q;
   1057 
   1058 			nwritten += precision;
   1059 			q = utf_skipcols(s, precision);
   1060 			do {
   1061 				shf_putc(*s, shf);
   1062 			} while (++s < q);
   1063 		}
   1064 		if (field > 0) {
   1065 			nwritten += field;
   1066 			for ( ; field > 0 ; --field)
   1067 				shf_putc(c, shf);
   1068 		}
   1069 	}
   1070 
   1071 	return (shf_error(shf) ? EOF : nwritten);
   1072 }
   1073 
   1074 #if defined(MKSH_SMALL) && !defined(MKSH_SMALL_BUT_FAST)
   1075 int
   1076 shf_getc(struct shf *shf)
   1077 {
   1078 	return (shf_getc_i(shf));
   1079 }
   1080 
   1081 int
   1082 shf_putc(int c, struct shf *shf)
   1083 {
   1084 	return (shf_putc_i(c, shf));
   1085 }
   1086 #endif
   1087 
   1088 #ifdef DEBUG
   1089 const char *
   1090 cstrerror(int errnum)
   1091 {
   1092 #undef strerror
   1093 	return (strerror(errnum));
   1094 #define strerror dontuse_strerror /* poisoned */
   1095 }
   1096 #elif !HAVE_STRERROR
   1097 
   1098 #if HAVE_SYS_ERRLIST
   1099 #if !HAVE_SYS_ERRLIST_DECL
   1100 extern const int sys_nerr;
   1101 extern const char * const sys_errlist[];
   1102 #endif
   1103 #endif
   1104 
   1105 const char *
   1106 cstrerror(int errnum)
   1107 {
   1108 	/* "Unknown error: " + sign + rough estimate + NUL */
   1109 	static char errbuf[15 + 1 + (8 * sizeof(int) + 2) / 3 + 1];
   1110 
   1111 #if HAVE_SYS_ERRLIST
   1112 	if (errnum > 0 && errnum < sys_nerr && sys_errlist[errnum])
   1113 		return (sys_errlist[errnum]);
   1114 #endif
   1115 
   1116 	switch (errnum) {
   1117 	case 0:
   1118 		return ("Undefined error: 0");
   1119 #ifdef EPERM
   1120 	case EPERM:
   1121 		return ("Operation not permitted");
   1122 #endif
   1123 #ifdef ENOENT
   1124 	case ENOENT:
   1125 		return ("No such file or directory");
   1126 #endif
   1127 #ifdef ESRCH
   1128 	case ESRCH:
   1129 		return ("No such process");
   1130 #endif
   1131 #ifdef E2BIG
   1132 	case E2BIG:
   1133 		return ("Argument list too long");
   1134 #endif
   1135 #ifdef ENOEXEC
   1136 	case ENOEXEC:
   1137 		return ("Exec format error");
   1138 #endif
   1139 #ifdef ENOMEM
   1140 	case ENOMEM:
   1141 		return ("Cannot allocate memory");
   1142 #endif
   1143 #ifdef EACCES
   1144 	case EACCES:
   1145 		return ("Permission denied");
   1146 #endif
   1147 #ifdef ENOTDIR
   1148 	case ENOTDIR:
   1149 		return ("Not a directory");
   1150 #endif
   1151 #ifdef EINVAL
   1152 	case EINVAL:
   1153 		return ("Invalid argument");
   1154 #endif
   1155 #ifdef ELOOP
   1156 	case ELOOP:
   1157 		return ("Too many levels of symbolic links");
   1158 #endif
   1159 	default:
   1160 		shf_snprintf(errbuf, sizeof(errbuf),
   1161 		    "Unknown error: %d", errnum);
   1162 		return (errbuf);
   1163 	}
   1164 }
   1165 #endif
   1166