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