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