src/shf.c

   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, 2015, 2016
   6  *      mirabilos <m@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.76 2016/07/25 00:04:47 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 = binopen3(name, oflags, 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(Tf_sD_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(Tf_sD_s, "shf_reopen", Tbad_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(Tf_flags, "shf_sopen",
 201                     (unsigned int)sflags);
 202
 203         if (!shf) {
 204                 shf = alloc(sizeof(struct shf), ATEMP);
 205                 sflags |= SHF_ALLOCS;
 206         }
 207         shf->areap = ATEMP;
 208         if (!buf && (sflags & SHF_WR) && (sflags & SHF_DYNAMIC)) {
 209                 if (bsize <= 0)
 210                         bsize = 64;
 211                 sflags |= SHF_ALLOCB;
 212                 buf = alloc(bsize, shf->areap);
 213         }
 214         shf->fd = -1;
 215         shf->buf = shf->rp = shf->wp = (unsigned char *)buf;
 216         shf->rnleft = bsize;
 217         shf->rbsize = bsize;
 218         shf->wnleft = bsize - 1;        /* space for a '\0' */
 219         shf->wbsize = bsize;
 220         shf->flags = sflags | SHF_STRING;
 221         shf->errnosv = 0;
 222         shf->bsize = bsize;
 223
 224         return (shf);
 225 }
 226
 227 /* Flush and close file descriptor, free the shf structure */
 228 int
 229 shf_close(struct shf *shf)
 230 {
 231         int ret = 0;
 232
 233         if (shf->fd >= 0) {
 234                 ret = shf_flush(shf);
 235                 if (close(shf->fd) < 0)
 236                         ret = -1;
 237         }
 238         if (shf->flags & SHF_ALLOCS)
 239                 afree(shf, shf->areap);
 240         else if (shf->flags & SHF_ALLOCB)
 241                 afree(shf->buf, shf->areap);
 242
 243         return (ret);
 244 }
 245
 246 /* Flush and close file descriptor, don't free file structure */
 247 int
 248 shf_fdclose(struct shf *shf)
 249 {
 250         int ret = 0;
 251
 252         if (shf->fd >= 0) {
 253                 ret = shf_flush(shf);
 254                 if (close(shf->fd) < 0)
 255                         ret = -1;
 256                 shf->rnleft = 0;
 257                 shf->rp = shf->buf;
 258                 shf->wnleft = 0;
 259                 shf->fd = -1;
 260         }
 261
 262         return (ret);
 263 }
 264
 265 /*
 266  * Close a string - if it was opened for writing, it is NUL terminated;
 267  * returns a pointer to the string and frees shf if it was allocated
 268  * (does not free string if it was allocated).
 269  */
 270 char *
 271 shf_sclose(struct shf *shf)
 272 {
 273         unsigned char *s = shf->buf;
 274
 275         /* NUL terminate */
 276         if (shf->flags & SHF_WR) {
 277                 shf->wnleft++;
 278                 shf_putc('\0', shf);
 279         }
 280         if (shf->flags & SHF_ALLOCS)
 281                 afree(shf, shf->areap);
 282         return ((char *)s);
 283 }
 284
 285 /*
 286  * Un-read what has been read but not examined, or write what has been
 287  * buffered. Returns 0 for success, -1 for (write) error.
 288  */
 289 int
 290 shf_flush(struct shf *shf)
 291 {
 292         if (shf->flags & SHF_STRING)
 293                 return ((shf->flags & SHF_WR) ? -1 : 0);
 294
 295         if (shf->fd < 0)
 296                 internal_errorf(Tf_sD_s, "shf_flush", "no fd");
 297
 298         if (shf->flags & SHF_ERROR) {
 299                 errno = shf->errnosv;
 300                 return (-1);
 301         }
 302
 303         if (shf->flags & SHF_READING) {
 304                 shf->flags &= ~(SHF_EOF | SHF_READING);
 305                 if (shf->rnleft > 0) {
 306                         lseek(shf->fd, (off_t)-shf->rnleft, SEEK_CUR);
 307                         shf->rnleft = 0;
 308                         shf->rp = shf->buf;
 309                 }
 310                 return (0);
 311         } else if (shf->flags & SHF_WRITING)
 312                 return (shf_emptybuf(shf, 0));
 313
 314         return (0);
 315 }
 316
 317 /*
 318  * Write out any buffered data. If currently reading, flushes the read
 319  * buffer. Returns 0 for success, -1 for (write) error.
 320  */
 321 static int
 322 shf_emptybuf(struct shf *shf, int flags)
 323 {
 324         int ret = 0;
 325
 326         if (!(shf->flags & SHF_STRING) && shf->fd < 0)
 327                 internal_errorf(Tf_sD_s, "shf_emptybuf", "no fd");
 328
 329         if (shf->flags & SHF_ERROR) {
 330                 errno = shf->errnosv;
 331                 return (-1);
 332         }
 333
 334         if (shf->flags & SHF_READING) {
 335                 if (flags & EB_READSW)
 336                         /* doesn't happen */
 337                         return (0);
 338                 ret = shf_flush(shf);
 339                 shf->flags &= ~SHF_READING;
 340         }
 341         if (shf->flags & SHF_STRING) {
 342                 unsigned char *nbuf;
 343
 344                 /*
 345                  * Note that we assume SHF_ALLOCS is not set if
 346                  * SHF_ALLOCB is set... (changing the shf pointer could
 347                  * cause problems)
 348                  */
 349                 if (!(flags & EB_GROW) || !(shf->flags & SHF_DYNAMIC) ||
 350                     !(shf->flags & SHF_ALLOCB))
 351                         return (-1);
 352                 /* allocate more space for buffer */
 353                 nbuf = aresize2(shf->buf, 2, shf->wbsize, shf->areap);
 354                 shf->rp = nbuf + (shf->rp - shf->buf);
 355                 shf->wp = nbuf + (shf->wp - shf->buf);
 356                 shf->rbsize += shf->wbsize;
 357                 shf->wnleft += shf->wbsize;
 358                 shf->wbsize <<= 1;
 359                 shf->buf = nbuf;
 360         } else {
 361                 if (shf->flags & SHF_WRITING) {
 362                         ssize_t n, ntowrite = shf->wp - shf->buf;
 363                         unsigned char *buf = shf->buf;
 364
 365                         while (ntowrite > 0) {
 366                                 n = write(shf->fd, buf, ntowrite);
 367                                 if (n < 0) {
 368                                         if (errno == EINTR &&
 369                                             !(shf->flags & SHF_INTERRUPT))
 370                                                 continue;
 371                                         shf->flags |= SHF_ERROR;
 372                                         shf->errnosv = errno;
 373                                         shf->wnleft = 0;
 374                                         if (buf != shf->buf) {
 375                                                 /*
 376                                                  * allow a second flush
 377                                                  * to work
 378                                                  */
 379                                                 memmove(shf->buf, buf,
 380                                                     ntowrite);
 381                                                 shf->wp = shf->buf + ntowrite;
 382                                         }
 383                                         return (-1);
 384                                 }
 385                                 buf += n;
 386                                 ntowrite -= n;
 387                         }
 388                         if (flags & EB_READSW) {
 389                                 shf->wp = shf->buf;
 390                                 shf->wnleft = 0;
 391                                 shf->flags &= ~SHF_WRITING;
 392                                 return (0);
 393                         }
 394                 }
 395                 shf->wp = shf->buf;
 396                 shf->wnleft = shf->wbsize;
 397         }
 398         shf->flags |= SHF_WRITING;
 399
 400         return (ret);
 401 }
 402
 403 /* Fill up a read buffer. Returns -1 for a read error, 0 otherwise. */
 404 static int
 405 shf_fillbuf(struct shf *shf)
 406 {
 407         ssize_t n;
 408
 409         if (shf->flags & SHF_STRING)
 410                 return (0);
 411
 412         if (shf->fd < 0)
 413                 internal_errorf(Tf_sD_s, "shf_fillbuf", "no fd");
 414
 415         if (shf->flags & (SHF_EOF | SHF_ERROR)) {
 416                 if (shf->flags & SHF_ERROR)
 417                         errno = shf->errnosv;
 418                 return (-1);
 419         }
 420
 421         if ((shf->flags & SHF_WRITING) && shf_emptybuf(shf, EB_READSW) == -1)
 422                 return (-1);
 423
 424         shf->flags |= SHF_READING;
 425
 426         shf->rp = shf->buf;
 427         while (/* CONSTCOND */ 1) {
 428                 n = blocking_read(shf->fd, (char *)shf->buf, shf->rbsize);
 429                 if (n < 0 && errno == EINTR && !(shf->flags & SHF_INTERRUPT))
 430                         continue;
 431                 break;
 432         }
 433         if (n < 0) {
 434                 shf->flags |= SHF_ERROR;
 435                 shf->errnosv = errno;
 436                 shf->rnleft = 0;
 437                 shf->rp = shf->buf;
 438                 return (-1);
 439         }
 440         if ((shf->rnleft = n) == 0)
 441                 shf->flags |= SHF_EOF;
 442         return (0);
 443 }
 444
 445 /*
 446  * Read a buffer from shf. Returns the number of bytes read into buf, if
 447  * no bytes were read, returns 0 if end of file was seen, -1 if a read
 448  * error occurred.
 449  */
 450 ssize_t
 451 shf_read(char *buf, ssize_t bsize, struct shf *shf)
 452 {
 453         ssize_t ncopy, orig_bsize = bsize;
 454
 455         if (!(shf->flags & SHF_RD))
 456                 internal_errorf(Tf_flags, Tshf_read,
 457                     (unsigned int)shf->flags);
 458
 459         if (bsize <= 0)
 460                 internal_errorf(Tf_szs, Tshf_read, bsize, Tbsize);
 461
 462         while (bsize > 0) {
 463                 if (shf->rnleft == 0 &&
 464                     (shf_fillbuf(shf) == -1 || shf->rnleft == 0))
 465                         break;
 466                 ncopy = shf->rnleft;
 467                 if (ncopy > bsize)
 468                         ncopy = bsize;
 469                 memcpy(buf, shf->rp, ncopy);
 470                 buf += ncopy;
 471                 bsize -= ncopy;
 472                 shf->rp += ncopy;
 473                 shf->rnleft -= ncopy;
 474         }
 475         /* Note: fread(3S) returns 0 for errors - this doesn't */
 476         return (orig_bsize == bsize ? (shf_error(shf) ? -1 : 0) :
 477             orig_bsize - bsize);
 478 }
 479
 480 /*
 481  * Read up to a newline or -1. The newline is put in buf; buf is always
 482  * NUL terminated. Returns NULL on read error or if nothing was read
 483  * before end of file, returns a pointer to the NUL byte in buf
 484  * otherwise.
 485  */
 486 char *
 487 shf_getse(char *buf, ssize_t bsize, struct shf *shf)
 488 {
 489         unsigned char *end;
 490         ssize_t ncopy;
 491         char *orig_buf = buf;
 492
 493         if (!(shf->flags & SHF_RD))
 494                 internal_errorf(Tf_flags, "shf_getse",
 495                     (unsigned int)shf->flags);
 496
 497         if (bsize <= 0)
 498                 return (NULL);
 499
 500         /* save room for NUL */
 501         --bsize;
 502         do {
 503                 if (shf->rnleft == 0) {
 504                         if (shf_fillbuf(shf) == -1)
 505                                 return (NULL);
 506                         if (shf->rnleft == 0) {
 507                                 *buf = '\0';
 508                                 return (buf == orig_buf ? NULL : buf);
 509                         }
 510                 }
 511                 end = (unsigned char *)memchr((char *)shf->rp, '\n',
 512                     shf->rnleft);
 513                 ncopy = end ? end - shf->rp + 1 : shf->rnleft;
 514                 if (ncopy > bsize)
 515                         ncopy = bsize;
 516                 memcpy(buf, (char *) shf->rp, ncopy);
 517                 shf->rp += ncopy;
 518                 shf->rnleft -= ncopy;
 519                 buf += ncopy;
 520                 bsize -= ncopy;
 521         } while (!end && bsize);
 522         *buf = '\0';
 523         return (buf);
 524 }
 525
 526 /* Returns the char read. Returns -1 for error and end of file. */
 527 int
 528 shf_getchar(struct shf *shf)
 529 {
 530         if (!(shf->flags & SHF_RD))
 531                 internal_errorf(Tf_flags, "shf_getchar",
 532                     (unsigned int)shf->flags);
 533
 534         if (shf->rnleft == 0 && (shf_fillbuf(shf) == -1 || shf->rnleft == 0))
 535                 return (-1);
 536         --shf->rnleft;
 537         return (*shf->rp++);
 538 }
 539
 540 /*
 541  * Put a character back in the input stream. Returns the character if
 542  * successful, -1 if there is no room.
 543  */
 544 int
 545 shf_ungetc(int c, struct shf *shf)
 546 {
 547         if (!(shf->flags & SHF_RD))
 548                 internal_errorf(Tf_flags, "shf_ungetc",
 549                     (unsigned int)shf->flags);
 550
 551         if ((shf->flags & SHF_ERROR) || c == -1 ||
 552             (shf->rp == shf->buf && shf->rnleft))
 553                 return (-1);
 554
 555         if ((shf->flags & SHF_WRITING) && shf_emptybuf(shf, EB_READSW) == -1)
 556                 return (-1);
 557
 558         if (shf->rp == shf->buf)
 559                 shf->rp = shf->buf + shf->rbsize;
 560         if (shf->flags & SHF_STRING) {
 561                 /*
 562                  * Can unget what was read, but not something different;
 563                  * we don't want to modify a string.
 564                  */
 565                 if ((int)(shf->rp[-1]) != c)
 566                         return (-1);
 567                 shf->flags &= ~SHF_EOF;
 568                 shf->rp--;
 569                 shf->rnleft++;
 570                 return (c);
 571         }
 572         shf->flags &= ~SHF_EOF;
 573         *--(shf->rp) = c;
 574         shf->rnleft++;
 575         return (c);
 576 }
 577
 578 /*
 579  * Write a character. Returns the character if successful, -1 if the
 580  * char could not be written.
 581  */
 582 int
 583 shf_putchar(int c, struct shf *shf)
 584 {
 585         if (!(shf->flags & SHF_WR))
 586                 internal_errorf(Tf_flags, "shf_putchar",
 587                     (unsigned int)shf->flags);
 588
 589         if (c == -1)
 590                 return (-1);
 591
 592         if (shf->flags & SHF_UNBUF) {
 593                 unsigned char cc = (unsigned char)c;
 594                 ssize_t n;
 595
 596                 if (shf->fd < 0)
 597                         internal_errorf(Tf_sD_s, "shf_putchar", "no fd");
 598                 if (shf->flags & SHF_ERROR) {
 599                         errno = shf->errnosv;
 600                         return (-1);
 601                 }
 602                 while ((n = write(shf->fd, &cc, 1)) != 1)
 603                         if (n < 0) {
 604                                 if (errno == EINTR &&
 605                                     !(shf->flags & SHF_INTERRUPT))
 606                                         continue;
 607                                 shf->flags |= SHF_ERROR;
 608                                 shf->errnosv = errno;
 609                                 return (-1);
 610                         }
 611         } else {
 612                 /* Flush deals with strings and sticky errors */
 613                 if (shf->wnleft == 0 && shf_emptybuf(shf, EB_GROW) == -1)
 614                         return (-1);
 615                 shf->wnleft--;
 616                 *shf->wp++ = c;
 617         }
 618
 619         return (c);
 620 }
 621
 622 /*
 623  * Write a string. Returns the length of the string if successful, -1
 624  * if the string could not be written.
 625  */
 626 ssize_t
 627 shf_puts(const char *s, struct shf *shf)
 628 {
 629         if (!s)
 630                 return (-1);
 631
 632         return (shf_write(s, strlen(s), shf));
 633 }
 634
 635 /* Write a buffer. Returns nbytes if successful, -1 if there is an error. */
 636 ssize_t
 637 shf_write(const char *buf, ssize_t nbytes, struct shf *shf)
 638 {
 639         ssize_t n, ncopy, orig_nbytes = nbytes;
 640
 641         if (!(shf->flags & SHF_WR))
 642                 internal_errorf(Tf_flags, Tshf_write,
 643                     (unsigned int)shf->flags);
 644
 645         if (nbytes < 0)
 646                 internal_errorf(Tf_szs, Tshf_write, nbytes, Tbytes);
 647
 648         /* Don't buffer if buffer is empty and we're writting a large amount. */
 649         if ((ncopy = shf->wnleft) &&
 650             (shf->wp != shf->buf || nbytes < shf->wnleft)) {
 651                 if (ncopy > nbytes)
 652                         ncopy = nbytes;
 653                 memcpy(shf->wp, buf, ncopy);
 654                 nbytes -= ncopy;
 655                 buf += ncopy;
 656                 shf->wp += ncopy;
 657                 shf->wnleft -= ncopy;
 658         }
 659         if (nbytes > 0) {
 660                 if (shf->flags & SHF_STRING) {
 661                         /* resize buffer until there's enough space left */
 662                         while (nbytes > shf->wnleft)
 663                                 if (shf_emptybuf(shf, EB_GROW) == -1)
 664                                         return (-1);
 665                         /* then write everything into the buffer */
 666                 } else {
 667                         /* flush deals with sticky errors */
 668                         if (shf_emptybuf(shf, EB_GROW) == -1)
 669                                 return (-1);
 670                         /* write chunks larger than window size directly */
 671                         if (nbytes > shf->wbsize) {
 672                                 ncopy = nbytes;
 673                                 if (shf->wbsize)
 674                                         ncopy -= nbytes % shf->wbsize;
 675                                 nbytes -= ncopy;
 676                                 while (ncopy > 0) {
 677                                         n = write(shf->fd, buf, ncopy);
 678                                         if (n < 0) {
 679                                                 if (errno == EINTR &&
 680                                                     !(shf->flags & SHF_INTERRUPT))
 681                                                         continue;
 682                                                 shf->flags |= SHF_ERROR;
 683                                                 shf->errnosv = errno;
 684                                                 shf->wnleft = 0;
 685                                                 /*
 686                                                  * Note: fwrite(3) returns 0
 687                                                  * for errors - this doesn't
 688                                                  */
 689                                                 return (-1);
 690                                         }
 691                                         buf += n;
 692                                         ncopy -= n;
 693                                 }
 694                         }
 695                         /* ... and buffer the rest */
 696                 }
 697                 if (nbytes > 0) {
 698                         /* write remaining bytes to buffer */
 699                         memcpy(shf->wp, buf, nbytes);
 700                         shf->wp += nbytes;
 701                         shf->wnleft -= nbytes;
 702                 }
 703         }
 704
 705         return (orig_nbytes);
 706 }
 707
 708 ssize_t
 709 shf_fprintf(struct shf *shf, const char *fmt, ...)
 710 {
 711         va_list args;
 712         ssize_t n;
 713
 714         va_start(args, fmt);
 715         n = shf_vfprintf(shf, fmt, args);
 716         va_end(args);
 717
 718         return (n);
 719 }
 720
 721 ssize_t
 722 shf_snprintf(char *buf, ssize_t bsize, const char *fmt, ...)
 723 {
 724         struct shf shf;
 725         va_list args;
 726         ssize_t n;
 727
 728         if (!buf || bsize <= 0)
 729                 internal_errorf("shf_snprintf: buf %zX, bsize %zd",
 730                     (size_t)buf, bsize);
 731
 732         shf_sopen(buf, bsize, SHF_WR, &shf);
 733         va_start(args, fmt);
 734         n = shf_vfprintf(&shf, fmt, args);
 735         va_end(args);
 736         /* NUL terminates */
 737         shf_sclose(&shf);
 738         return (n);
 739 }
 740
 741 char *
 742 shf_smprintf(const char *fmt, ...)
 743 {
 744         struct shf shf;
 745         va_list args;
 746
 747         shf_sopen(NULL, 0, SHF_WR|SHF_DYNAMIC, &shf);
 748         va_start(args, fmt);
 749         shf_vfprintf(&shf, fmt, args);
 750         va_end(args);
 751         /* NUL terminates */
 752         return (shf_sclose(&shf));
 753 }
 754
 755 #define FL_HASH         0x001   /* '#' seen */
 756 #define FL_PLUS         0x002   /* '+' seen */
 757 #define FL_RIGHT        0x004   /* '-' seen */
 758 #define FL_BLANK        0x008   /* ' ' seen */
 759 #define FL_SHORT        0x010   /* 'h' seen */
 760 #define FL_LONG         0x020   /* 'l' seen */
 761 #define FL_ZERO         0x040   /* '0' seen */
 762 #define FL_DOT          0x080   /* '.' seen */
 763 #define FL_UPPER        0x100   /* format character was uppercase */
 764 #define FL_NUMBER       0x200   /* a number was formated %[douxefg] */
 765 #define FL_SIZET        0x400   /* 'z' seen */
 766 #define FM_SIZES        0x430   /* h/l/z mask */
 767
 768 ssize_t
 769 shf_vfprintf(struct shf *shf, const char *fmt, va_list args)
 770 {
 771         const char *s;
 772         char c, *cp;
 773         int tmp = 0, flags;
 774         size_t field, precision, len;
 775         unsigned long lnum;
 776         /* %#o produces the longest output */
 777         char numbuf[(8 * sizeof(long) + 2) / 3 + 1 + /* NUL */ 1];
 778         /* this stuff for dealing with the buffer */
 779         ssize_t nwritten = 0;
 780
 781 #define VA(type) va_arg(args, type)
 782
 783         if (!fmt)
 784                 return (0);
 785
 786         while ((c = *fmt++)) {
 787                 if (c != '%') {
 788                         shf_putc(c, shf);
 789                         nwritten++;
 790                         continue;
 791                 }
 792                 /*
 793                  * This will accept flags/fields in any order - not just
 794                  * the order specified in printf(3), but this is the way
 795                  * _doprnt() seems to work (on BSD and SYSV). The only
 796                  * restriction is that the format character must come
 797                  * last :-).
 798                  */
 799                 flags = 0;
 800                 field = precision = 0;
 801                 while ((c = *fmt++)) {
 802                         switch (c) {
 803                         case '#':
 804                                 flags |= FL_HASH;
 805                                 continue;
 806
 807                         case '+':
 808                                 flags |= FL_PLUS;
 809                                 continue;
 810
 811                         case '-':
 812                                 flags |= FL_RIGHT;
 813                                 continue;
 814
 815                         case ' ':
 816                                 flags |= FL_BLANK;
 817                                 continue;
 818
 819                         case '0':
 820                                 if (!(flags & FL_DOT))
 821                                         flags |= FL_ZERO;
 822                                 continue;
 823
 824                         case '.':
 825                                 flags |= FL_DOT;
 826                                 precision = 0;
 827                                 continue;
 828
 829                         case '*':
 830                                 tmp = VA(int);
 831                                 if (tmp < 0) {
 832                                         if (flags & FL_DOT)
 833                                                 precision = 0;
 834                                         else {
 835                                                 field = (unsigned int)-tmp;
 836                                                 flags |= FL_RIGHT;
 837                                         }
 838                                 } else if (flags & FL_DOT)
 839                                         precision = (unsigned int)tmp;
 840                                 else
 841                                         field = (unsigned int)tmp;
 842                                 continue;
 843
 844                         case 'l':
 845                                 flags &= ~FM_SIZES;
 846                                 flags |= FL_LONG;
 847                                 continue;
 848
 849                         case 'h':
 850                                 flags &= ~FM_SIZES;
 851                                 flags |= FL_SHORT;
 852                                 continue;
 853
 854                         case 'z':
 855                                 flags &= ~FM_SIZES;
 856                                 flags |= FL_SIZET;
 857                                 continue;
 858                         }
 859                         if (ksh_isdigit(c)) {
 860                                 bool overflowed = false;
 861
 862                                 tmp = ksh_numdig(c);
 863                                 while (c = *fmt++, ksh_isdigit(c))
 864                                         if (notok2mul(2147483647, tmp, 10))
 865                                                 overflowed = true;
 866                                         else
 867                                                 tmp = tmp * 10 + ksh_numdig(c);
 868                                 --fmt;
 869                                 if (overflowed)
 870                                         tmp = 0;
 871                                 if (flags & FL_DOT)
 872                                         precision = (unsigned int)tmp;
 873                                 else
 874                                         field = (unsigned int)tmp;
 875                                 continue;
 876                         }
 877                         break;
 878                 }
 879
 880                 if (!c)
 881                         /* nasty format */
 882                         break;
 883
 884                 if (ksh_isupper(c)) {
 885                         flags |= FL_UPPER;
 886                         c = ksh_tolower(c);
 887                 }
 888
 889                 switch (c) {
 890                 case 'd':
 891                 case 'i':
 892                         if (flags & FL_SIZET)
 893                                 lnum = (long)VA(ssize_t);
 894                         else if (flags & FL_LONG)
 895                                 lnum = VA(long);
 896                         else if (flags & FL_SHORT)
 897                                 lnum = (long)(short)VA(int);
 898                         else
 899                                 lnum = (long)VA(int);
 900                         goto integral;
 901
 902                 case 'o':
 903                 case 'u':
 904                 case 'x':
 905                         if (flags & FL_SIZET)
 906                                 lnum = VA(size_t);
 907                         else if (flags & FL_LONG)
 908                                 lnum = VA(unsigned long);
 909                         else if (flags & FL_SHORT)
 910                                 lnum = (unsigned long)(unsigned short)VA(int);
 911                         else
 912                                 lnum = (unsigned long)VA(unsigned int);
 913
 914  integral:
 915                         flags |= FL_NUMBER;
 916                         cp = numbuf + sizeof(numbuf);
 917                         *--cp = '\0';
 918
 919                         switch (c) {
 920                         case 'd':
 921                         case 'i':
 922                                 if (0 > (long)lnum) {
 923                                         lnum = -(long)lnum;
 924                                         tmp = 1;
 925                                 } else
 926                                         tmp = 0;
 927                                 /* FALLTHROUGH */
 928                         case 'u':
 929                                 do {
 930                                         *--cp = digits_lc[lnum % 10];
 931                                         lnum /= 10;
 932                                 } while (lnum);
 933
 934                                 if (c != 'u') {
 935                                         if (tmp)
 936                                                 *--cp = '-';
 937                                         else if (flags & FL_PLUS)
 938                                                 *--cp = '+';
 939                                         else if (flags & FL_BLANK)
 940                                                 *--cp = ' ';
 941                                 }
 942                                 break;
 943
 944                         case 'o':
 945                                 do {
 946                                         *--cp = digits_lc[lnum & 0x7];
 947                                         lnum >>= 3;
 948                                 } while (lnum);
 949
 950                                 if ((flags & FL_HASH) && *cp != '0')
 951                                         *--cp = '0';
 952                                 break;
 953
 954                         case 'x': {
 955                                 const char *digits = (flags & FL_UPPER) ?
 956                                     digits_uc : digits_lc;
 957                                 do {
 958                                         *--cp = digits[lnum & 0xF];
 959                                         lnum >>= 4;
 960                                 } while (lnum);
 961
 962                                 if (flags & FL_HASH) {
 963                                         *--cp = (flags & FL_UPPER) ? 'X' : 'x';
 964                                         *--cp = '0';
 965                                 }
 966                             }
 967                         }
 968                         len = numbuf + sizeof(numbuf) - 1 - (s = cp);
 969                         if (flags & FL_DOT) {
 970                                 if (precision > len) {
 971                                         field = precision;
 972                                         flags |= FL_ZERO;
 973                                 } else
 974                                         /* no loss */
 975                                         precision = len;
 976                         }
 977                         break;
 978
 979                 case 's':
 980                         if ((s = VA(const char *)) == NULL)
 981                                 s = "(null)";
 982                         else if (flags & FL_HASH) {
 983                                 print_value_quoted(shf, s);
 984                                 continue;
 985                         }
 986                         len = utf_mbswidth(s);
 987                         break;
 988
 989                 case 'c':
 990                         flags &= ~FL_DOT;
 991                         c = (char)(VA(int));
 992                         /* FALLTHROUGH */
 993
 994                 case '%':
 995                 default:
 996                         numbuf[0] = c;
 997                         numbuf[1] = 0;
 998                         s = numbuf;
 999                         len = 1;
1000                         break;
1001                 }
1002
1003                 /*
1004                  * At this point s should point to a string that is to be
1005                  * formatted, and len should be the length of the string.
1006                  */
1007                 if (!(flags & FL_DOT) || len < precision)
1008                         precision = len;
1009                 if (field > precision) {
1010                         field -= precision;
1011                         if (!(flags & FL_RIGHT)) {
1012                                 /* skip past sign or 0x when padding with 0 */
1013                                 if ((flags & FL_ZERO) && (flags & FL_NUMBER)) {
1014                                         if (*s == '+' || *s == '-' ||
1015                                             *s == ' ') {
1016                                                 shf_putc(*s, shf);
1017                                                 s++;
1018                                                 precision--;
1019                                                 nwritten++;
1020                                         } else if (*s == '0') {
1021                                                 shf_putc(*s, shf);
1022                                                 s++;
1023                                                 nwritten++;
1024                                                 if (--precision &&
1025                                                     ksh_eq(*s, 'X', 'x')) {
1026                                                         shf_putc(*s, shf);
1027                                                         s++;
1028                                                         precision--;
1029                                                         nwritten++;
1030                                                 }
1031                                         }
1032                                         c = '0';
1033                                 } else
1034                                         c = flags & FL_ZERO ? '0' : ' ';
1035                                 nwritten += field;
1036                                 while (field--)
1037                                         shf_putc(c, shf);
1038                                 field = 0;
1039                         } else
1040                                 c = ' ';
1041                 } else
1042                         field = 0;
1043
1044                 nwritten += precision;
1045                 precision = utf_skipcols(s, precision, &tmp) - s;
1046                 while (precision--)
1047                         shf_putc(*s++, shf);
1048
1049                 nwritten += field;
1050                 while (field--)
1051                         shf_putc(c, shf);
1052         }
1053
1054         return (shf_error(shf) ? -1 : nwritten);
1055 }
1056
1057 #if defined(MKSH_SMALL) && !defined(MKSH_SMALL_BUT_FAST)
1058 int
1059 shf_getc(struct shf *shf)
1060 {
1061         return (shf_getc_i(shf));
1062 }
1063
1064 int
1065 shf_putc(int c, struct shf *shf)
1066 {
1067         return (shf_putc_i(c, shf));
1068 }
1069 #endif
1070
1071 #ifdef DEBUG
1072 const char *
1073 cstrerror(int errnum)
1074 {
1075 #undef strerror
1076         return (strerror(errnum));
1077 #define strerror dontuse_strerror /* poisoned */
1078 }
1079 #elif !HAVE_STRERROR
1080
1081 #if HAVE_SYS_ERRLIST
1082 #if !HAVE_SYS_ERRLIST_DECL
1083 extern const int sys_nerr;
1084 extern const char * const sys_errlist[];
1085 #endif
1086 #endif
1087
1088 const char *
1089 cstrerror(int errnum)
1090 {
1091         /* "Unknown error: " + sign + rough estimate + NUL */
1092         static char errbuf[15 + 1 + (8 * sizeof(int) + 2) / 3 + 1];
1093
1094 #if HAVE_SYS_ERRLIST
1095         if (errnum > 0 && errnum < sys_nerr && sys_errlist[errnum])
1096                 return (sys_errlist[errnum]);
1097 #endif
1098
1099         switch (errnum) {
1100         case 0:
1101                 return ("Undefined error: 0");
1102         case EPERM:
1103                 return ("Operation not permitted");
1104         case ENOENT:
1105                 return ("No such file or directory");
1106 #ifdef ESRCH
1107         case ESRCH:
1108                 return ("No such process");
1109 #endif
1110 #ifdef E2BIG
1111         case E2BIG:
1112                 return ("Argument list too long");
1113 #endif
1114         case ENOEXEC:
1115                 return ("Exec format error");
1116         case EBADF:
1117                 return ("Bad file descriptor");
1118 #ifdef ENOMEM
1119         case ENOMEM:
1120                 return ("Cannot allocate memory");
1121 #endif
1122         case EACCES:
1123                 return ("Permission denied");
1124         case EEXIST:
1125                 return ("File exists");
1126         case ENOTDIR:
1127                 return ("Not a directory");
1128 #ifdef EINVAL
1129         case EINVAL:
1130                 return ("Invalid argument");
1131 #endif
1132 #ifdef ELOOP
1133         case ELOOP:
1134                 return ("Too many levels of symbolic links");
1135 #endif
1136         default:
1137                 shf_snprintf(errbuf, sizeof(errbuf),
1138                     "Unknown error: %d", errnum);
1139                 return (errbuf);
1140         }
1141 }
1142 #endif