src/shf.c

   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, 2012
   5  *      Thorsten Glaser <tg@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.56 2013/01/01 03:32:44 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 ((int)(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 #ifdef DEBUG
 769                 /* a NUL for LLVM/Clang scan-build */
 770                 + 1
 771 #endif
 772             ];
 773         /* this stuff for dealing with the buffer */
 774         ssize_t nwritten = 0;
 775
 776 #define VA(type) va_arg(args, type)
 777
 778         if (!fmt)
 779                 return (0);
 780
 781         while ((c = *fmt++)) {
 782                 if (c != '%') {
 783                         shf_putc(c, shf);
 784                         nwritten++;
 785                         continue;
 786                 }
 787                 /*
 788                  * This will accept flags/fields in any order - not just
 789                  * the order specified in printf(3), but this is the way
 790                  * _doprnt() seems to work (on BSD and SYSV). The only
 791                  * restriction is that the format character must come
 792                  * last :-).
 793                  */
 794                 flags = 0;
 795                 field = precision = 0;
 796                 for ( ; (c = *fmt++) ; ) {
 797                         switch (c) {
 798                         case '#':
 799                                 flags |= FL_HASH;
 800                                 continue;
 801
 802                         case '+':
 803                                 flags |= FL_PLUS;
 804                                 continue;
 805
 806                         case '-':
 807                                 flags |= FL_RIGHT;
 808                                 continue;
 809
 810                         case ' ':
 811                                 flags |= FL_BLANK;
 812                                 continue;
 813
 814                         case '0':
 815                                 if (!(flags & FL_DOT))
 816                                         flags |= FL_ZERO;
 817                                 continue;
 818
 819                         case '.':
 820                                 flags |= FL_DOT;
 821                                 precision = 0;
 822                                 continue;
 823
 824                         case '*':
 825                                 tmp = VA(int);
 826                                 if (flags & FL_DOT)
 827                                         precision = tmp;
 828                                 else if ((field = tmp) < 0) {
 829                                         field = -field;
 830                                         flags |= FL_RIGHT;
 831                                 }
 832                                 continue;
 833
 834                         case 'l':
 835                                 flags &= ~FM_SIZES;
 836                                 flags |= FL_LONG;
 837                                 continue;
 838
 839                         case 'h':
 840                                 flags &= ~FM_SIZES;
 841                                 flags |= FL_SHORT;
 842                                 continue;
 843
 844                         case 'z':
 845                                 flags &= ~FM_SIZES;
 846                                 flags |= FL_SIZET;
 847                                 continue;
 848                         }
 849                         if (ksh_isdigit(c)) {
 850                                 bool overflowed = false;
 851
 852                                 tmp = c - '0';
 853                                 while (c = *fmt++, ksh_isdigit(c)) {
 854                                         if (notok2mul(2147483647, tmp, 10))
 855                                                 overflowed = true;
 856                                         tmp = tmp * 10 + c - '0';
 857                                 }
 858                                 --fmt;
 859                                 if (overflowed)
 860                                         tmp = 0;
 861                                 if (flags & FL_DOT)
 862                                         precision = tmp;
 863                                 else
 864                                         field = tmp;
 865                                 continue;
 866                         }
 867                         break;
 868                 }
 869
 870                 if (precision < 0)
 871                         precision = 0;
 872
 873                 if (!c)
 874                         /* nasty format */
 875                         break;
 876
 877                 if (c >= 'A' && c <= 'Z') {
 878                         flags |= FL_UPPER;
 879                         c = ksh_tolower(c);
 880                 }
 881
 882                 switch (c) {
 883                 case 'd':
 884                 case 'i':
 885                         if (flags & FL_SIZET)
 886                                 lnum = (long)VA(ssize_t);
 887                         else if (flags & FL_LONG)
 888                                 lnum = VA(long);
 889                         else if (flags & FL_SHORT)
 890                                 lnum = (long)(short)VA(int);
 891                         else
 892                                 lnum = (long)VA(int);
 893                         goto integral;
 894
 895                 case 'o':
 896                 case 'u':
 897                 case 'x':
 898                         if (flags & FL_SIZET)
 899                                 lnum = VA(size_t);
 900                         else if (flags & FL_LONG)
 901                                 lnum = VA(unsigned long);
 902                         else if (flags & FL_SHORT)
 903                                 lnum = (unsigned long)(unsigned short)VA(int);
 904                         else
 905                                 lnum = (unsigned long)VA(unsigned int);
 906
 907  integral:
 908                         flags |= FL_NUMBER;
 909                         cp = numbuf + sizeof(numbuf);
 910 #ifdef DEBUG
 911                         /*
 912                          * this is necessary so Clang 3.2 realises
 913                          * utf_skipcols/shf_putc in the output loop
 914                          * terminate; these values are always ASCII
 915                          * so an out-of-bounds access cannot happen
 916                          * but Clang doesn't know that
 917                          */
 918                         *--cp = '\0';
 919 #endif
 920
 921                         switch (c) {
 922                         case 'd':
 923                         case 'i':
 924                                 if (0 > (long)lnum) {
 925                                         lnum = -(long)lnum;
 926                                         tmp = 1;
 927                                 } else
 928                                         tmp = 0;
 929                                 /* FALLTHROUGH */
 930                         case 'u':
 931                                 do {
 932                                         *--cp = lnum % 10 + '0';
 933                                         lnum /= 10;
 934                                 } while (lnum);
 935
 936                                 if (c != 'u') {
 937                                         if (tmp)
 938                                                 *--cp = '-';
 939                                         else if (flags & FL_PLUS)
 940                                                 *--cp = '+';
 941                                         else if (flags & FL_BLANK)
 942                                                 *--cp = ' ';
 943                                 }
 944                                 break;
 945
 946                         case 'o':
 947                                 do {
 948                                         *--cp = (lnum & 0x7) + '0';
 949                                         lnum >>= 3;
 950                                 } while (lnum);
 951
 952                                 if ((flags & FL_HASH) && *cp != '0')
 953                                         *--cp = '0';
 954                                 break;
 955
 956                         case 'x': {
 957                                 const char *digits = (flags & FL_UPPER) ?
 958                                     digits_uc : digits_lc;
 959                                 do {
 960                                         *--cp = digits[lnum & 0xf];
 961                                         lnum >>= 4;
 962                                 } while (lnum);
 963
 964                                 if (flags & FL_HASH) {
 965                                         *--cp = (flags & FL_UPPER) ? 'X' : 'x';
 966                                         *--cp = '0';
 967                                 }
 968                         }
 969                         }
 970                         len = numbuf + sizeof(numbuf) - (s = cp);
 971 #ifdef DEBUG
 972                         /* see above comment for Clang 3.2 */
 973                         --len;
 974 #endif
 975                         if (flags & FL_DOT) {
 976                                 if (precision > len) {
 977                                         field = precision;
 978                                         flags |= FL_ZERO;
 979                                 } else
 980                                         /* no loss */
 981                                         precision = len;
 982                         }
 983                         break;
 984
 985                 case 's':
 986                         if ((s = VA(const char *)) == NULL)
 987                                 s = "(null)";
 988                         len = utf_mbswidth(s);
 989                         break;
 990
 991                 case 'c':
 992                         flags &= ~FL_DOT;
 993                         c = (char)(VA(int));
 994                         /* FALLTHROUGH */
 995
 996                 case '%':
 997                 default:
 998                         numbuf[0] = c;
 999                         numbuf[1] = 0;
1000                         s = numbuf;
1001                         len = 1;
1002                         break;
1003                 }
1004
1005                 /*
1006                  * At this point s should point to a string that is to be
1007                  * formatted, and len should be the length of the string.
1008                  */
1009                 if (!(flags & FL_DOT) || len < precision)
1010                         precision = len;
1011                 if (field > precision) {
1012                         field -= precision;
1013                         if (!(flags & FL_RIGHT)) {
1014                                 field = -field;
1015                                 /* skip past sign or 0x when padding with 0 */
1016                                 if ((flags & FL_ZERO) && (flags & FL_NUMBER)) {
1017                                         if (*s == '+' || *s == '-' ||
1018                                             *s == ' ') {
1019                                                 shf_putc(*s, shf);
1020                                                 s++;
1021                                                 precision--;
1022                                                 nwritten++;
1023                                         } else if (*s == '0') {
1024                                                 shf_putc(*s, shf);
1025                                                 s++;
1026                                                 nwritten++;
1027                                                 if (--precision > 0 &&
1028                                                     (*s | 0x20) == 'x') {
1029                                                         shf_putc(*s, shf);
1030                                                         s++;
1031                                                         precision--;
1032                                                         nwritten++;
1033                                                 }
1034                                         }
1035                                         c = '0';
1036                                 } else
1037                                         c = flags & FL_ZERO ? '0' : ' ';
1038                                 if (field < 0) {
1039                                         nwritten += -field;
1040                                         for ( ; field < 0 ; field++)
1041                                                 shf_putc(c, shf);
1042                                 }
1043                         } else
1044                                 c = ' ';
1045                 } else
1046                         field = 0;
1047
1048                 if (precision > 0) {
1049                         const char *q;
1050
1051                         nwritten += precision;
1052                         q = utf_skipcols(s, precision);
1053                         do {
1054                                 shf_putc(*s, shf);
1055                         } while (++s < q);
1056                 }
1057                 if (field > 0) {
1058                         nwritten += field;
1059                         for ( ; field > 0 ; --field)
1060                                 shf_putc(c, shf);
1061                 }
1062         }
1063
1064         return (shf_error(shf) ? EOF : nwritten);
1065 }
1066
1067 #if defined(MKSH_SMALL) && !defined(MKSH_SMALL_BUT_FAST)
1068 int
1069 shf_getc(struct shf *shf)
1070 {
1071         return (shf_getc_i(shf));
1072 }
1073
1074 int
1075 shf_putc(int c, struct shf *shf)
1076 {
1077         return (shf_putc_i(c, shf));
1078 }
1079 #endif
1080
1081 #ifdef DEBUG
1082 const char *
1083 cstrerror(int errnum)
1084 {
1085 #undef strerror
1086         return (strerror(errnum));
1087 #define strerror dontuse_strerror /* poisoned */
1088 }
1089 #elif !HAVE_STRERROR
1090
1091 #if HAVE_SYS_ERRLIST
1092 #if !HAVE_SYS_ERRLIST_DECL
1093 extern const int sys_nerr;
1094 extern const char * const sys_errlist[];
1095 #endif
1096 #endif
1097
1098 const char *
1099 cstrerror(int errnum)
1100 {
1101         /* "Unknown error: " + sign + rough estimate + NUL */
1102         static char errbuf[15 + 1 + (8 * sizeof(int) + 2) / 3 + 1];
1103
1104 #if HAVE_SYS_ERRLIST
1105         if (errnum > 0 && errnum < sys_nerr && sys_errlist[errnum])
1106                 return (sys_errlist[errnum]);
1107 #endif
1108
1109         switch (errnum) {
1110         case 0:
1111                 return ("Undefined error: 0");
1112 #ifdef EPERM
1113         case EPERM:
1114                 return ("Operation not permitted");
1115 #endif
1116 #ifdef ENOENT
1117         case ENOENT:
1118                 return ("No such file or directory");
1119 #endif
1120 #ifdef ESRCH
1121         case ESRCH:
1122                 return ("No such process");
1123 #endif
1124 #ifdef E2BIG
1125         case E2BIG:
1126                 return ("Argument list too long");
1127 #endif
1128 #ifdef ENOEXEC
1129         case ENOEXEC:
1130                 return ("Exec format error");
1131 #endif
1132 #ifdef ENOMEM
1133         case ENOMEM:
1134                 return ("Cannot allocate memory");
1135 #endif
1136 #ifdef EACCES
1137         case EACCES:
1138                 return ("Permission denied");
1139 #endif
1140 #ifdef ENOTDIR
1141         case ENOTDIR:
1142                 return ("Not a directory");
1143 #endif
1144 #ifdef EINVAL
1145         case EINVAL:
1146                 return ("Invalid argument");
1147 #endif
1148 #ifdef ELOOP
1149         case ELOOP:
1150                 return ("Too many levels of symbolic links");
1151 #endif
1152         default:
1153                 shf_snprintf(errbuf, sizeof(errbuf),
1154                     "Unknown error: %d", errnum);
1155                 return (errbuf);
1156         }
1157 }
1158 #endif