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