contrib/tcsh/sh.misc.c

   1 /*
   2  * sh.misc.c: Miscelaneous functions
   3  */
   4 /*-
   5  * Copyright (c) 1980, 1991 The Regents of the University of California.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32 #include "sh.h"
  33
  34 static  int     renum   (int, int);
  35 static  Char  **blkend  (Char **);
  36 static  Char  **blkcat  (Char **, Char **);
  37 static  int     xdup2   (int, int);
  38
  39 /*
  40  * C Shell
  41  */
  42
  43 int
  44 any(const char *s, Char c)
  45 {
  46     if (!s)
  47         return (0);             /* Check for nil pointer */
  48     while (*s)
  49         if ((Char)*s++ == c)
  50             return (1);
  51     return (0);
  52 }
  53
  54 void
  55 setzero(void *p, size_t size)
  56 {
  57     memset(p, 0, size);
  58 }
  59
  60 #ifndef SHORT_STRINGS
  61 char *
  62 strnsave(const char *s, size_t len)
  63 {
  64     char *r;
  65
  66     r = xmalloc(len + 1);
  67     memcpy(r, s, len);
  68     r[len] = '\0';
  69     return r;
  70 }
  71 #endif
  72
  73 char   *
  74 strsave(const char *s)
  75 {
  76     char   *r;
  77     size_t size;
  78
  79     if (s == NULL)
  80         s = "";
  81     size = strlen(s) + 1;
  82     r = xmalloc(size);
  83     memcpy(r, s, size);
  84     return (r);
  85 }
  86
  87 static Char  **
  88 blkend(Char **up)
  89 {
  90
  91     while (*up)
  92         up++;
  93     return (up);
  94 }
  95
  96
  97 void
  98 blkpr(Char *const *av)
  99 {
 100
 101     for (; *av; av++) {
 102         xprintf("%S", *av);
 103         if (av[1])
 104             xprintf(" ");
 105     }
 106 }
 107
 108 Char *
 109 blkexpand(Char *const *av)
 110 {
 111     struct Strbuf buf = Strbuf_INIT;
 112
 113     for (; *av; av++) {
 114         Strbuf_append(&buf, *av);
 115         if (av[1])
 116             Strbuf_append1(&buf, ' ');
 117     }
 118     return Strbuf_finish(&buf);
 119 }
 120
 121 int
 122 blklen(Char **av)
 123 {
 124     int i = 0;
 125
 126     while (*av++)
 127         i++;
 128     return (i);
 129 }
 130
 131 Char  **
 132 blkcpy(Char **oav, Char **bv)
 133 {
 134     Char **av = oav;
 135
 136     while ((*av++ = *bv++) != NULL)
 137         continue;
 138     return (oav);
 139 }
 140
 141 static Char  **
 142 blkcat(Char **up, Char **vp)
 143 {
 144
 145     (void) blkcpy(blkend(up), vp);
 146     return (up);
 147 }
 148
 149 void
 150 blkfree(Char **av0)
 151 {
 152     Char **av = av0;
 153
 154     if (!av0)
 155         return;
 156     for (; *av; av++)
 157         xfree(*av);
 158     xfree(av0);
 159 }
 160
 161 void
 162 blk_cleanup(void *ptr)
 163 {
 164     blkfree(ptr);
 165 }
 166
 167 void
 168 blk_indirect_cleanup(void *xptr)
 169 {
 170     Char ***ptr;
 171
 172     ptr = xptr;
 173     blkfree(*ptr);
 174     xfree(ptr);
 175 }
 176
 177 Char  **
 178 saveblk(Char **v)
 179 {
 180     Char **newv, **onewv;
 181
 182     if (v == NULL)
 183         return NULL;
 184
 185     onewv = newv = xcalloc(blklen(v) + 1, sizeof(Char **));
 186
 187     while (*v)
 188         *newv++ = Strsave(*v++);
 189     return (onewv);
 190 }
 191
 192 #ifndef HAVE_STRSTR
 193 char   *
 194 strstr(const char *s, const char *t)
 195 {
 196     do {
 197         const char *ss = s;
 198         const char *tt = t;
 199
 200         do
 201             if (*tt == '\0')
 202                 return (s);
 203         while (*ss++ == *tt++);
 204     } while (*s++ != '\0');
 205     return (NULL);
 206 }
 207 #endif /* !HAVE_STRSTR */
 208
 209 char   *
 210 strspl(const char *cp, const char *dp)
 211 {
 212     char   *ep;
 213     size_t cl, dl;
 214
 215     if (!cp)
 216         cp = "";
 217     if (!dp)
 218         dp = "";
 219     cl = strlen(cp);
 220     dl = strlen(dp);
 221     ep = xmalloc((cl + dl + 1) * sizeof(char));
 222     memcpy(ep, cp, cl);
 223     memcpy(ep + cl, dp, dl + 1);
 224     return (ep);
 225 }
 226
 227 Char  **
 228 blkspl(Char **up, Char **vp)
 229 {
 230     Char **wp = xcalloc(blklen(up) + blklen(vp) + 1, sizeof(Char **));
 231
 232     (void) blkcpy(wp, up);
 233     return (blkcat(wp, vp));
 234 }
 235
 236 Char
 237 lastchr(Char *cp)
 238 {
 239
 240     if (!cp)
 241         return (0);
 242     if (!*cp)
 243         return (0);
 244     while (cp[1])
 245         cp++;
 246     return (*cp);
 247 }
 248
 249 /*
 250  * This routine is called after an error to close up
 251  * any units which may have been left open accidentally.
 252  */
 253 void
 254 closem(void)
 255 {
 256     int f, num_files;
 257 #ifdef S_ISSOCK
 258     struct stat st;
 259 #endif /*S_ISSOCK*/
 260
 261 #ifdef NLS_BUGS
 262 #ifdef NLS_CATALOGS
 263     nlsclose();
 264 #endif /* NLS_CATALOGS */
 265 #endif /* NLS_BUGS */
 266 #ifdef YPBUGS
 267     /* suggested by Justin Bur; thanks to Karl Kleinpaste */
 268     fix_yp_bugs();
 269 #endif /* YPBUGS */
 270     num_files = NOFILE;
 271     for (f = 0; f < num_files; f++)
 272         if (f != SHIN && f != SHOUT && f != SHDIAG && f != OLDSTD &&
 273             f != FSHTTY
 274 #ifdef MALLOC_TRACE
 275             && f != 25
 276 #endif /* MALLOC_TRACE */
 277 #ifdef S_ISSOCK
 278             /* NSS modules (e.g. Linux nss_ldap) might keep sockets open.
 279              * If we close such a socket, both the NSS module and tcsh think
 280              * they "own" the descriptor.
 281              *
 282              * Not closing sockets does not make the cleanup use of closem()
 283              * less reliable because tcsh never creates sockets.
 284              */
 285             && fstat(f, &st) == 0 && !S_ISSOCK(st.st_mode)
 286 #endif
 287             )
 288           {
 289             xclose(f);
 290 #ifdef NISPLUS
 291             if(f < 3)
 292                 (void) xopen(_PATH_DEVNULL, O_RDONLY|O_LARGEFILE);
 293 #endif /* NISPLUS */
 294           }
 295 #ifdef NLS_BUGS
 296 #ifdef NLS_CATALOGS
 297     nlsinit();
 298 #endif /* NLS_CATALOGS */
 299 #endif /* NLS_BUGS */
 300 }
 301
 302 #ifndef CLOSE_ON_EXEC
 303 /*
 304  * Close files before executing a file.
 305  * We could be MUCH more intelligent, since (on a version 7 system)
 306  * we need only close files here during a source, the other
 307  * shell fd's being in units 16-19 which are closed automatically!
 308  */
 309 void
 310 closech(void)
 311 {
 312     int f, num_files;
 313
 314     if (didcch)
 315         return;
 316     didcch = 1;
 317     SHIN = 0;
 318     SHOUT = 1;
 319     SHDIAG = 2;
 320     OLDSTD = 0;
 321     isoutatty = isatty(SHOUT);
 322     isdiagatty = isatty(SHDIAG);
 323     num_files = NOFILE;
 324     for (f = 3; f < num_files; f++)
 325         xclose(f);
 326 }
 327
 328 #endif /* CLOSE_ON_EXEC */
 329
 330 void
 331 donefds(void)
 332 {
 333
 334     xclose(0);
 335     xclose(1);
 336     xclose(2);
 337     didfds = 0;
 338 #ifdef NISPLUS
 339     {
 340         int fd = xopen(_PATH_DEVNULL, O_RDONLY|O_LARGEFILE);
 341         (void)dcopy(fd, 1);
 342         (void)dcopy(fd, 2);
 343         (void)dmove(fd, 0);
 344     }
 345 #endif /*NISPLUS*/
 346 }
 347
 348 /*
 349  * Move descriptor i to j.
 350  * If j is -1 then we just want to get i to a safe place,
 351  * i.e. to a unit > FSAFE.  This also happens in dcopy.
 352  */
 353 int
 354 dmove(int i, int j)
 355 {
 356
 357     if (i == j || i < 0)
 358         return (i);
 359 #ifdef HAVE_DUP2
 360     if (j >= 0) {
 361         (void) xdup2(i, j);
 362         if (j != i)
 363             xclose(i);
 364         return (j);
 365     }
 366 #endif
 367     j = dcopy(i, j);
 368     if (j != i)
 369         xclose(i);
 370     return (j);
 371 }
 372
 373 int
 374 dcopy(int i, int j)
 375 {
 376
 377     if (i == j || i < 0 || (j < 0 && i > FSAFE))
 378         return (i);
 379     if (j >= 0) {
 380 #ifdef HAVE_DUP2
 381         (void) xdup2(i, j);
 382         return (j);
 383 #else
 384         xclose(j);
 385 #endif
 386     }
 387     return (renum(i, j));
 388 }
 389
 390 static int
 391 renum(int i, int j)
 392 {
 393     int k = dup(i);
 394
 395     if (k < 0)
 396         return (-1);
 397     if (j == -1 && k > FSAFE)
 398         return (k);
 399     if (k != j) {
 400         j = renum(k, j);
 401         xclose(k);
 402         return (j);
 403     }
 404     return (k);
 405 }
 406
 407 /*
 408  * Left shift a command argument list, discarding
 409  * the first c arguments.  Used in "shift" commands
 410  * as well as by commands like "repeat".
 411  */
 412 void
 413 lshift(Char **v, int c)
 414 {
 415     Char **u;
 416
 417     for (u = v; *u && --c >= 0; u++)
 418         xfree(*u);
 419     (void) blkcpy(v, u);
 420 }
 421
 422 int
 423 number(Char *cp)
 424 {
 425     if (!cp)
 426         return (0);
 427     if (*cp == '-') {
 428         cp++;
 429         if (!Isdigit(*cp))
 430             return (0);
 431         cp++;
 432     }
 433     while (*cp && Isdigit(*cp))
 434         cp++;
 435     return (*cp == 0);
 436 }
 437
 438 Char  **
 439 copyblk(Char **v)
 440 {
 441     Char **nv = xcalloc(blklen(v) + 1, sizeof(Char **));
 442
 443     return (blkcpy(nv, v));
 444 }
 445
 446 char   *
 447 strend(const char *cp)
 448 {
 449     if (!cp)
 450         return ((char *)(intptr_t)cp);
 451     while (*cp)
 452         cp++;
 453     return ((char *)(intptr_t)cp);
 454 }
 455
 456 Char   *
 457 strip(Char *cp)
 458 {
 459     Char *dp = cp;
 460
 461     if (!cp)
 462         return (cp);
 463     while (*dp != '\0') {
 464 #if INVALID_BYTE != 0
 465         if ((*dp & INVALID_BYTE) != INVALID_BYTE)    /* *dp < INVALID_BYTE */
 466 #endif
 467                 *dp &= TRIM;
 468         dp++;
 469     }
 470     return (cp);
 471 }
 472
 473 Char   *
 474 quote(Char *cp)
 475 {
 476     Char *dp = cp;
 477
 478     if (!cp)
 479         return (cp);
 480     while (*dp != '\0') {
 481 #ifdef WIDE_STRINGS
 482         if ((*dp & 0xffffff80) == 0)    /* *dp < 0x80 */
 483 #elif defined SHORT_STRINGS
 484         if ((*dp & 0xff80) == 0)        /* *dp < 0x80 */
 485 #else
 486         if ((*dp & 0x80) == 0)          /* *dp < 0x80 */
 487 #endif
 488             *dp |= QUOTE;
 489         dp++;
 490     }
 491     return (cp);
 492 }
 493
 494 const Char *
 495 quote_meta(struct Strbuf *buf, const Char *s)
 496 {
 497     buf->len = 0;
 498     while (*s != '\0') {
 499         if (cmap(*s, _META | _DOL | _QF | _QB | _ESC | _GLOB))
 500             Strbuf_append1(buf, '\\');
 501         Strbuf_append1(buf, *s++);
 502     }
 503     Strbuf_terminate(buf);
 504     return buf->s;
 505 }
 506
 507 void
 508 udvar(Char *name)
 509 {
 510     setname(short2str(name));
 511     stderror(ERR_NAME | ERR_UNDVAR);
 512 }
 513
 514 int
 515 prefix(const Char *sub, const Char *str)
 516 {
 517
 518     for (;;) {
 519         if (*sub == 0)
 520             return (1);
 521         if (*str == 0)
 522             return (0);
 523         if ((*sub++ & TRIM) != (*str++ & TRIM))
 524             return (0);
 525     }
 526 }
 527 #ifndef WINNT_NATIVE
 528 char *
 529 areadlink(const char *path)
 530 {
 531     char *buf;
 532     size_t size;
 533     ssize_t res;
 534
 535     size = MAXPATHLEN + 1;
 536     buf = xmalloc(size);
 537     while ((size_t)(res = readlink(path, buf, size)) == size) {
 538         size *= 2;
 539         buf = xrealloc(buf, size);
 540     }
 541     if (res == -1) {
 542         int err;
 543
 544         err = errno;
 545         xfree(buf);
 546         errno = err;
 547         return NULL;
 548     }
 549     buf[res] = '\0';
 550     return xrealloc(buf, res + 1);
 551 }
 552 #endif /*!WINNT_NATIVE*/
 553
 554 void
 555 xclose(int fildes)
 556 {
 557     if (fildes < 0)
 558         return;
 559     while (close(fildes) == -1 && errno == EINTR)
 560         if (handle_pending_signals())
 561             break;
 562 }
 563
 564 void
 565 xclosedir(DIR *dirp)
 566 {
 567     while (closedir(dirp) == -1 && errno == EINTR)
 568         if (handle_pending_signals())
 569             break;
 570 }
 571
 572 int
 573 xcreat(const char *path, mode_t mode)
 574 {
 575     int res;
 576
 577     while ((res = creat(path, mode)) == -1 && errno == EINTR)
 578         if (handle_pending_signals())
 579             break;
 580     return res;
 581 }
 582
 583 #ifdef HAVE_DUP2
 584 static int
 585 xdup2(int fildes, int fildes2)
 586 {
 587     int res;
 588
 589     while ((res = dup2(fildes, fildes2)) == -1 && errno == EINTR)
 590         if (handle_pending_signals())
 591             break;
 592     return res;
 593 }
 594 #endif
 595
 596 struct group *
 597 xgetgrgid(gid_t xgid)
 598 {
 599     struct group *res;
 600
 601     errno = 0;
 602     while ((res = getgrgid(xgid)) == NULL && errno == EINTR) {
 603         if (handle_pending_signals())
 604             break;
 605         errno = 0;
 606     }
 607     return res;
 608 }
 609
 610 struct passwd *
 611 xgetpwnam(const char *name)
 612 {
 613     struct passwd *res;
 614
 615     errno = 0;
 616     while ((res = getpwnam(name)) == NULL && errno == EINTR) {
 617         if (handle_pending_signals())
 618             break;
 619         errno = 0;
 620     }
 621     return res;
 622 }
 623
 624 struct passwd *
 625 xgetpwuid(uid_t xuid)
 626 {
 627     struct passwd *res;
 628
 629     errno = 0;
 630     while ((res = getpwuid(xuid)) == NULL && errno == EINTR) {
 631         if (handle_pending_signals())
 632             break;
 633         errno = 0;
 634     }
 635     return res;
 636 }
 637
 638 int
 639 xopen(const char *path, int oflag, ...)
 640 {
 641     int res;
 642
 643     if ((oflag & O_CREAT) == 0) {
 644         while ((res = open(path, oflag)) == -1 && errno == EINTR)
 645             if (handle_pending_signals())
 646                 break;
 647     } else {
 648         va_list ap;
 649         mode_t mode;
 650
 651         va_start(ap, oflag);
 652         /* "int" should actually be "mode_t after default argument
 653            promotions". "int" is the best guess we have, "mode_t" used to be
 654            "unsigned short", which we obviously can't use. */
 655         mode = va_arg(ap, int);
 656         va_end(ap);
 657         while ((res = open(path, oflag, mode)) == -1 && errno == EINTR)
 658             if (handle_pending_signals())
 659                 break;
 660     }
 661     return res;
 662 }
 663
 664 ssize_t
 665 xread(int fildes, void *buf, size_t nbyte)
 666 {
 667     ssize_t res = -1;
 668
 669     /* This is where we will be blocked most of the time, so handle signals
 670        that didn't interrupt any system call. */
 671     do
 672       if (handle_pending_signals())
 673           break;
 674     while ((res = read(fildes, buf, nbyte)) == -1 && errno == EINTR);
 675     return res;
 676 }
 677
 678 #ifdef POSIX
 679 int
 680 xtcsetattr(int fildes, int optional_actions, const struct termios *termios_p)
 681 {
 682     int res;
 683
 684     while ((res = tcsetattr(fildes, optional_actions, termios_p)) == -1 &&
 685            errno == EINTR)
 686         if (handle_pending_signals())
 687             break;
 688     return res;
 689 }
 690 #endif
 691
 692 ssize_t
 693 xwrite(int fildes, const void *buf, size_t nbyte)
 694 {
 695     ssize_t res = -1;
 696
 697     /* This is where we will be blocked most of the time, so handle signals
 698        that didn't interrupt any system call. */
 699     do
 700       if (handle_pending_signals())
 701           break;
 702     while ((res = write(fildes, buf, nbyte)) == -1 && errno == EINTR);
 703     return res;
 704 }