bin/sh/output.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Kenneth Almquist.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #ifndef lint
  36 #if 0
  37 static char sccsid[] = "@(#)output.c    8.2 (Berkeley) 5/4/95";
  38 #endif
  39 #endif /* not lint */
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD: head/bin/sh/output.c 344306 2019-02-19 21:27:30Z jilles $");
  42
  43 /*
  44  * Shell output routines.  We use our own output routines because:
  45  *      When a builtin command is interrupted we have to discard
  46  *              any pending output.
  47  *      When a builtin command appears in back quotes, we want to
  48  *              save the output of the command in a region obtained
  49  *              via malloc, rather than doing a fork and reading the
  50  *              output of the command via a pipe.
  51  */
  52
  53 #include <stdio.h>      /* defines BUFSIZ */
  54 #include <string.h>
  55 #include <stdarg.h>
  56 #include <errno.h>
  57 #include <unistd.h>
  58 #include <stdlib.h>
  59 #include <poll.h>
  60 #include <wchar.h>
  61 #include <wctype.h>
  62
  63 #include "shell.h"
  64 #include "syntax.h"
  65 #include "output.h"
  66 #include "memalloc.h"
  67 #include "error.h"
  68 #include "var.h"
  69
  70
  71 #define OUTBUFSIZ BUFSIZ
  72 #define MEM_OUT -2              /* output to dynamically allocated memory */
  73 #define OUTPUT_ERR 01           /* error occurred on output */
  74
  75 static int doformat_wr(void *, const char *, int);
  76
  77 struct output output = {NULL, NULL, NULL, OUTBUFSIZ, 1, 0};
  78 struct output errout = {NULL, NULL, NULL, 256, 2, 0};
  79 struct output memout = {NULL, NULL, NULL, 64, MEM_OUT, 0};
  80 struct output *out1 = &output;
  81 struct output *out2 = &errout;
  82
  83 void
  84 outcslow(int c, struct output *file)
  85 {
  86         outc(c, file);
  87 }
  88
  89 void
  90 out1str(const char *p)
  91 {
  92         outstr(p, out1);
  93 }
  94
  95 void
  96 out1qstr(const char *p)
  97 {
  98         outqstr(p, out1);
  99 }
 100
 101 void
 102 out2str(const char *p)
 103 {
 104         outstr(p, out2);
 105 }
 106
 107 void
 108 out2qstr(const char *p)
 109 {
 110         outqstr(p, out2);
 111 }
 112
 113 void
 114 outstr(const char *p, struct output *file)
 115 {
 116         outbin(p, strlen(p), file);
 117 }
 118
 119 static void
 120 byteseq(int ch, struct output *file)
 121 {
 122         char seq[4];
 123
 124         seq[0] = '\\';
 125         seq[1] = (ch >> 6 & 0x3) + '0';
 126         seq[2] = (ch >> 3 & 0x7) + '0';
 127         seq[3] = (ch & 0x7) + '0';
 128         outbin(seq, 4, file);
 129 }
 130
 131 static void
 132 outdqstr(const char *p, struct output *file)
 133 {
 134         const char *end;
 135         mbstate_t mbs;
 136         size_t clen;
 137         wchar_t wc;
 138
 139         memset(&mbs, '\0', sizeof(mbs));
 140         end = p + strlen(p);
 141         outstr("$'", file);
 142         while ((clen = mbrtowc(&wc, p, end - p + 1, &mbs)) != 0) {
 143                 if (clen == (size_t)-2) {
 144                         while (p < end)
 145                                 byteseq(*p++, file);
 146                         break;
 147                 }
 148                 if (clen == (size_t)-1) {
 149                         memset(&mbs, '\0', sizeof(mbs));
 150                         byteseq(*p++, file);
 151                         continue;
 152                 }
 153                 if (wc == L'\n')
 154                         outcslow('\n', file), p++;
 155                 else if (wc == L'\r')
 156                         outstr("\\r", file), p++;
 157                 else if (wc == L'\t')
 158                         outstr("\\t", file), p++;
 159                 else if (!iswprint(wc)) {
 160                         for (; clen > 0; clen--)
 161                                 byteseq(*p++, file);
 162                 } else {
 163                         if (wc == L'\'' || wc == L'\\')
 164                                 outcslow('\\', file);
 165                         outbin(p, clen, file);
 166                         p += clen;
 167                 }
 168         }
 169         outcslow('\'', file);
 170 }
 171
 172 /* Like outstr(), but quote for re-input into the shell. */
 173 void
 174 outqstr(const char *p, struct output *file)
 175 {
 176         int i;
 177
 178         if (p[0] == '\0') {
 179                 outstr("''", file);
 180                 return;
 181         }
 182         for (i = 0; p[i] != '\0'; i++) {
 183                 if ((p[i] > '\0' && p[i] < ' ' && p[i] != '\n') ||
 184                     (p[i] & 0x80) != 0 || p[i] == '\'') {
 185                         outdqstr(p, file);
 186                         return;
 187                 }
 188         }
 189
 190         if (p[strcspn(p, "|&;<>()$`\\\" \n*?[~#=")] == '\0' ||
 191                         strcmp(p, "[") == 0) {
 192                 outstr(p, file);
 193                 return;
 194         }
 195
 196         outcslow('\'', file);
 197         outstr(p, file);
 198         outcslow('\'', file);
 199 }
 200
 201 void
 202 outbin(const void *data, size_t len, struct output *file)
 203 {
 204         const char *p;
 205
 206         p = data;
 207         while (len-- > 0)
 208                 outc(*p++, file);
 209 }
 210
 211 void
 212 emptyoutbuf(struct output *dest)
 213 {
 214         int offset, newsize;
 215
 216         if (dest->buf == NULL) {
 217                 INTOFF;
 218                 dest->buf = ckmalloc(dest->bufsize);
 219                 dest->nextc = dest->buf;
 220                 dest->bufend = dest->buf + dest->bufsize;
 221                 INTON;
 222         } else if (dest->fd == MEM_OUT) {
 223                 offset = dest->nextc - dest->buf;
 224                 newsize = dest->bufsize << 1;
 225                 INTOFF;
 226                 dest->buf = ckrealloc(dest->buf, newsize);
 227                 dest->bufsize = newsize;
 228                 dest->bufend = dest->buf + newsize;
 229                 dest->nextc = dest->buf + offset;
 230                 INTON;
 231         } else {
 232                 flushout(dest);
 233         }
 234 }
 235
 236
 237 void
 238 flushall(void)
 239 {
 240         flushout(&output);
 241         flushout(&errout);
 242 }
 243
 244
 245 void
 246 flushout(struct output *dest)
 247 {
 248
 249         if (dest->buf == NULL || dest->nextc == dest->buf || dest->fd < 0)
 250                 return;
 251         if (xwrite(dest->fd, dest->buf, dest->nextc - dest->buf) < 0) {
 252                 dest->flags |= OUTPUT_ERR;
 253                 dest->error = errno;
 254         }
 255         dest->nextc = dest->buf;
 256 }
 257
 258
 259 void
 260 freestdout(void)
 261 {
 262         output.nextc = output.buf;
 263 }
 264
 265
 266 int
 267 outiserror(struct output *file)
 268 {
 269         return (file->flags & OUTPUT_ERR);
 270 }
 271
 272
 273 void
 274 outclearerror(struct output *file)
 275 {
 276         file->flags &= ~OUTPUT_ERR;
 277 }
 278
 279
 280 void
 281 outfmt(struct output *file, const char *fmt, ...)
 282 {
 283         va_list ap;
 284
 285         va_start(ap, fmt);
 286         doformat(file, fmt, ap);
 287         va_end(ap);
 288 }
 289
 290
 291 void
 292 out1fmt(const char *fmt, ...)
 293 {
 294         va_list ap;
 295
 296         va_start(ap, fmt);
 297         doformat(out1, fmt, ap);
 298         va_end(ap);
 299 }
 300
 301 void
 302 out2fmt_flush(const char *fmt, ...)
 303 {
 304         va_list ap;
 305
 306         va_start(ap, fmt);
 307         doformat(out2, fmt, ap);
 308         va_end(ap);
 309         flushout(out2);
 310 }
 311
 312 void
 313 fmtstr(char *outbuf, int length, const char *fmt, ...)
 314 {
 315         va_list ap;
 316
 317         INTOFF;
 318         va_start(ap, fmt);
 319         vsnprintf(outbuf, length, fmt, ap);
 320         va_end(ap);
 321         INTON;
 322 }
 323
 324 static int
 325 doformat_wr(void *cookie, const char *buf, int len)
 326 {
 327         struct output *o;
 328
 329         o = (struct output *)cookie;
 330         outbin(buf, len, o);
 331
 332         return (len);
 333 }
 334
 335 void
 336 doformat(struct output *dest, const char *f, va_list ap)
 337 {
 338         FILE *fp;
 339
 340         if ((fp = fwopen(dest, doformat_wr)) != NULL) {
 341                 vfprintf(fp, f, ap);
 342                 fclose(fp);
 343         }
 344 }
 345
 346 FILE *
 347 out1fp(void)
 348 {
 349         return fwopen(out1, doformat_wr);
 350 }
 351
 352 /*
 353  * Version of write which resumes after a signal is caught.
 354  */
 355
 356 int
 357 xwrite(int fd, const char *buf, int nbytes)
 358 {
 359         int ntry;
 360         int i;
 361         int n;
 362
 363         n = nbytes;
 364         ntry = 0;
 365         for (;;) {
 366                 i = write(fd, buf, n);
 367                 if (i > 0) {
 368                         if ((n -= i) <= 0)
 369                                 return nbytes;
 370                         buf += i;
 371                         ntry = 0;
 372                 } else if (i == 0) {
 373                         if (++ntry > 10)
 374                                 return nbytes - n;
 375                 } else {
 376                         struct pollfd pfd;
 377
 378                         switch(errno) {
 379                         case EINTR:
 380                                 /* retry */
 381                                 break;
 382                         case EAGAIN:
 383                                 /*
 384                                  * If stdout is non-blocking, use poll
 385                                  * to wait, then retry.
 386                                  */
 387                                 pfd.fd = fd;
 388                                 pfd.events = POLLOUT;
 389                                 pfd.revents = 0;
 390                                 poll(&pfd, 1, -1);
 391                                 if (pfd.revents & (POLLERR | POLLNVAL))
 392                                         return -1;
 393                                 /* retry */
 394                                 break;
 395                         default:
 396                                 return -1;
 397                                 /* not reached */
 398                         }
 399                 }
 400         }
 401 }