misc.c

   1 /* Miscellaneous generic support functions for GNU Make.
   2 Copyright (C) 1988,89,90,91,92,93,94,95,97 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Make is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Make; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 #include "make.h"
  20 #include "dep.h"
  21
  22
  23 /* Compare strings *S1 and *S2.
  24    Return negative if the first is less, positive if it is greater,
  25    zero if they are equal.  */
  26
  27 int
  28 alpha_compare (s1, s2)
  29      char **s1, **s2;
  30 {
  31   if (**s1 != **s2)
  32     return **s1 - **s2;
  33   return strcmp (*s1, *s2);
  34 }
  35 \f
  36 /* Discard each backslash-newline combination from LINE.
  37    Backslash-backslash-newline combinations become backslash-newlines.
  38    This is done by copying the text at LINE into itself.  */
  39
  40 void
  41 collapse_continuations (line)
  42      char *line;
  43 {
  44   register char *in, *out, *p;
  45   register int backslash;
  46   register unsigned int bs_write;
  47
  48   in = index (line, '\n');
  49   if (in == 0)
  50     return;
  51
  52   out = in;
  53   while (out > line && out[-1] == '\\')
  54     --out;
  55
  56   while (*in != '\0')
  57     {
  58       /* BS_WRITE gets the number of quoted backslashes at
  59          the end just before IN, and BACKSLASH gets nonzero
  60          if the next character is quoted.  */
  61       backslash = 0;
  62       bs_write = 0;
  63       for (p = in - 1; p >= line && *p == '\\'; --p)
  64         {
  65           if (backslash)
  66             ++bs_write;
  67           backslash = !backslash;
  68
  69           /* It should be impossible to go back this far without exiting,
  70              but if we do, we can't get the right answer.  */
  71           if (in == out - 1)
  72             abort ();
  73         }
  74
  75       /* Output the appropriate number of backslashes.  */
  76       while (bs_write-- > 0)
  77         *out++ = '\\';
  78
  79       /* Skip the newline.  */
  80       ++in;
  81
  82       /* If the newline is quoted, discard following whitespace
  83          and any preceding whitespace; leave just one space.  */
  84       if (backslash)
  85         {
  86           in = next_token (in);
  87           while (out > line && isblank (out[-1]))
  88             --out;
  89           *out++ = ' ';
  90         }
  91       else
  92         /* If the newline isn't quoted, put it in the output.  */
  93         *out++ = '\n';
  94
  95       /* Now copy the following line to the output.
  96          Stop when we find backslashes followed by a newline.  */
  97       while (*in != '\0')
  98         if (*in == '\\')
  99           {
 100             p = in + 1;
 101             while (*p == '\\')
 102               ++p;
 103             if (*p == '\n')
 104               {
 105                 in = p;
 106                 break;
 107               }
 108             while (in < p)
 109               *out++ = *in++;
 110           }
 111         else
 112           *out++ = *in++;
 113     }
 114
 115   *out = '\0';
 116 }
 117
 118
 119 /* Remove comments from LINE.
 120    This is done by copying the text at LINE onto itself.  */
 121
 122 void
 123 remove_comments (line)
 124      char *line;
 125 {
 126   char *comment;
 127
 128   comment = find_char_unquote (line, "#", 0);
 129
 130   if (comment != 0)
 131     /* Cut off the line at the #.  */
 132     *comment = '\0';
 133 }
 134 \f
 135 /* Print N spaces (used by DEBUGPR for target-depth).  */
 136
 137 void
 138 print_spaces (n)
 139      register unsigned int n;
 140 {
 141   while (n-- > 0)
 142     putchar (' ');
 143 }
 144
 145 \f
 146 /* Return a newly-allocated string whose contents
 147    concatenate those of s1, s2, s3.  */
 148
 149 char *
 150 concat (s1, s2, s3)
 151      register char *s1, *s2, *s3;
 152 {
 153   register unsigned int len1, len2, len3;
 154   register char *result;
 155
 156   len1 = *s1 != '\0' ? strlen (s1) : 0;
 157   len2 = *s2 != '\0' ? strlen (s2) : 0;
 158   len3 = *s3 != '\0' ? strlen (s3) : 0;
 159
 160   result = (char *) xmalloc (len1 + len2 + len3 + 1);
 161
 162   if (*s1 != '\0')
 163     bcopy (s1, result, len1);
 164   if (*s2 != '\0')
 165     bcopy (s2, result + len1, len2);
 166   if (*s3 != '\0')
 167     bcopy (s3, result + len1 + len2, len3);
 168   *(result + len1 + len2 + len3) = '\0';
 169
 170   return result;
 171 }
 172 \f
 173 /* Print a message on stdout.  */
 174
 175 void
 176 message (prefix, s1, s2, s3, s4, s5, s6)
 177      int prefix;
 178      char *s1, *s2, *s3, *s4, *s5, *s6;
 179 {
 180   log_working_directory (1);
 181
 182   if (s1 != 0)
 183     {
 184       if (prefix)
 185         {
 186           if (makelevel == 0)
 187             printf ("%s: ", program);
 188           else
 189             printf ("%s[%u]: ", program, makelevel);
 190         }
 191       printf (s1, s2, s3, s4, s5, s6);
 192       putchar ('\n');
 193     }
 194
 195   fflush (stdout);
 196 }
 197
 198 /* Print an error message and exit.  */
 199
 200 /* VARARGS1 */
 201 void
 202 fatal (s1, s2, s3, s4, s5, s6)
 203      char *s1, *s2, *s3, *s4, *s5, *s6;
 204 {
 205   log_working_directory (1);
 206
 207   if (makelevel == 0)
 208     fprintf (stderr, "%s: *** ", program);
 209   else
 210     fprintf (stderr, "%s[%u]: *** ", program, makelevel);
 211   fprintf (stderr, s1, s2, s3, s4, s5, s6);
 212   fputs (".  Stop.\n", stderr);
 213
 214   die (2);
 215 }
 216
 217 /* Print error message.  `s1' is printf control string, `s2' is arg for it. */
 218
 219 /* VARARGS1 */
 220
 221 void
 222 error (s1, s2, s3, s4, s5, s6)
 223      char *s1, *s2, *s3, *s4, *s5, *s6;
 224 {
 225   log_working_directory (1);
 226
 227   if (makelevel == 0)
 228     fprintf (stderr, "%s: ", program);
 229   else
 230     fprintf (stderr, "%s[%u]: ", program, makelevel);
 231   fprintf (stderr, s1, s2, s3, s4, s5, s6);
 232   putc ('\n', stderr);
 233   fflush (stderr);
 234 }
 235
 236 void
 237 makefile_error (file, lineno, s1, s2, s3, s4, s5, s6)
 238      char *file;
 239      unsigned int lineno;
 240      char *s1, *s2, *s3, *s4, *s5, *s6;
 241 {
 242   log_working_directory (1);
 243
 244   fprintf (stderr, "%s:%u: ", file, lineno);
 245   fprintf (stderr, s1, s2, s3, s4, s5, s6);
 246   putc ('\n', stderr);
 247   fflush (stderr);
 248 }
 249
 250 void
 251 makefile_fatal (file, lineno, s1, s2, s3, s4, s5, s6)
 252      char *file;
 253      unsigned int lineno;
 254      char *s1, *s2, *s3, *s4, *s5, *s6;
 255 {
 256   if (!file)
 257     fatal(s1, s2, s3, s4, s5, s6);
 258
 259   log_working_directory (1);
 260
 261   fprintf (stderr, "%s:%u: *** ", file, lineno);
 262   fprintf (stderr, s1, s2, s3, s4, s5, s6);
 263   fputs (".  Stop.\n", stderr);
 264
 265   die (2);
 266 }
 267
 268 #ifndef HAVE_STRERROR
 269
 270 #undef  strerror
 271
 272 char *
 273 strerror (errnum)
 274      int errnum;
 275 {
 276   extern int errno, sys_nerr;
 277 #ifndef __DECC
 278   extern char *sys_errlist[];
 279 #endif
 280   static char buf[] = "Unknown error 12345678901234567890";
 281
 282   if (errno < sys_nerr)
 283     return sys_errlist[errnum];
 284
 285   sprintf (buf, "Unknown error %d", errnum);
 286   return buf;
 287 }
 288 #endif
 289
 290 /* Print an error message from errno.  */
 291
 292 void
 293 perror_with_name (str, name)
 294      char *str, *name;
 295 {
 296   error ("%s%s: %s", str, name, strerror (errno));
 297 }
 298
 299 /* Print an error message from errno and exit.  */
 300
 301 void
 302 pfatal_with_name (name)
 303      char *name;
 304 {
 305   fatal ("%s: %s", name, strerror (errno));
 306
 307   /* NOTREACHED */
 308 }
 309 \f
 310 /* Like malloc but get fatal error if memory is exhausted.  */
 311
 312 #undef xmalloc
 313 #undef xrealloc
 314
 315 char *
 316 xmalloc (size)
 317      unsigned int size;
 318 {
 319   char *result = (char *) malloc (size);
 320   if (result == 0)
 321     fatal ("virtual memory exhausted");
 322   return result;
 323 }
 324
 325
 326 char *
 327 xrealloc (ptr, size)
 328      char *ptr;
 329      unsigned int size;
 330 {
 331   char *result = (char *) realloc (ptr, size);
 332   if (result == 0)
 333     fatal ("virtual memory exhausted");
 334   return result;
 335 }
 336
 337 char *
 338 savestring (str, length)
 339      char *str;
 340      unsigned int length;
 341 {
 342   register char *out = (char *) xmalloc (length + 1);
 343   if (length > 0)
 344     bcopy (str, out, length);
 345   out[length] = '\0';
 346   return out;
 347 }
 348 \f
 349 /* Search string BIG (length BLEN) for an occurrence of
 350    string SMALL (length SLEN).  Return a pointer to the
 351    beginning of the first occurrence, or return nil if none found.  */
 352
 353 char *
 354 sindex (big, blen, small, slen)
 355      char *big;
 356      unsigned int blen;
 357      char *small;
 358      unsigned int slen;
 359 {
 360   register unsigned int b;
 361
 362   if (blen < 1)
 363     blen = strlen (big);
 364   if (slen < 1)
 365     slen = strlen (small);
 366
 367   for (b = 0; b < blen; ++b)
 368     if (big[b] == *small && !strncmp (&big[b + 1], small + 1, slen - 1))
 369       return (&big[b]);
 370
 371   return 0;
 372 }
 373
 374 /* Limited INDEX:
 375    Search through the string STRING, which ends at LIMIT, for the character C.
 376    Returns a pointer to the first occurrence, or nil if none is found.
 377    Like INDEX except that the string searched ends where specified
 378    instead of at the first null.  */
 379
 380 char *
 381 lindex (s, limit, c)
 382      register char *s, *limit;
 383      int c;
 384 {
 385   while (s < limit)
 386     if (*s++ == c)
 387       return s - 1;
 388
 389   return 0;
 390 }
 391 \f
 392 /* Return the address of the first whitespace or null in the string S.  */
 393
 394 char *
 395 end_of_token (s)
 396      char *s;
 397 {
 398   while (*s != '\0' && !isblank (*s))
 399     ++s;
 400   return s;
 401 }
 402
 403 #ifdef WINDOWS32
 404 /*
 405  * Same as end_of_token, but take into account a stop character
 406  */
 407 char *
 408 end_of_token_w32 (s, stopchar)
 409      char *s;
 410      char stopchar;
 411 {
 412   register char *p = s;
 413   register int backslash = 0;
 414
 415   while (*p != '\0' && *p != stopchar && (backslash || !isblank (*p)))
 416     {
 417       if (*p++ == '\\')
 418         {
 419           backslash = !backslash;
 420           while (*p == '\\')
 421             {
 422               backslash = !backslash;
 423               ++p;
 424             }
 425         }
 426       else
 427         backslash = 0;
 428     }
 429
 430   return p;
 431 }
 432 #endif
 433
 434 /* Return the address of the first nonwhitespace or null in the string S.  */
 435
 436 char *
 437 next_token (s)
 438      char *s;
 439 {
 440   register char *p = s;
 441
 442   while (isblank (*p))
 443     ++p;
 444   return p;
 445 }
 446
 447 /* Find the next token in PTR; return the address of it, and store the
 448    length of the token into *LENGTHPTR if LENGTHPTR is not nil.  */
 449
 450 char *
 451 find_next_token (ptr, lengthptr)
 452      char **ptr;
 453      unsigned int *lengthptr;
 454 {
 455   char *p = next_token (*ptr);
 456   char *end;
 457
 458   if (*p == '\0')
 459     return 0;
 460
 461   *ptr = end = end_of_token (p);
 462   if (lengthptr != 0)
 463     *lengthptr = end - p;
 464   return p;
 465 }
 466 \f
 467 /* Copy a chain of `struct dep', making a new chain
 468    with the same contents as the old one.  */
 469
 470 struct dep *
 471 copy_dep_chain (d)
 472      register struct dep *d;
 473 {
 474   register struct dep *c;
 475   struct dep *firstnew = 0;
 476   struct dep *lastnew = 0;
 477
 478   while (d != 0)
 479     {
 480       c = (struct dep *) xmalloc (sizeof (struct dep));
 481       bcopy ((char *) d, (char *) c, sizeof (struct dep));
 482       if (c->name != 0)
 483         c->name = savestring (c->name, strlen (c->name));
 484       c->next = 0;
 485       if (firstnew == 0)
 486         firstnew = lastnew = c;
 487       else
 488         lastnew = lastnew->next = c;
 489
 490       d = d->next;
 491     }
 492
 493   return firstnew;
 494 }
 495 \f
 496 #ifdef  iAPX286
 497 /* The losing compiler on this machine can't handle this macro.  */
 498
 499 char *
 500 dep_name (dep)
 501      struct dep *dep;
 502 {
 503   return dep->name == 0 ? dep->file->name : dep->name;
 504 }
 505 #endif
 506 \f
 507 #ifdef  GETLOADAVG_PRIVILEGED
 508
 509 #ifdef POSIX
 510
 511 /* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
 512    functions, they work as POSIX.1 says.  Some systems (Alpha OSF/1 1.2,
 513    for example) which claim to be POSIX.1 also have the BSD setreuid and
 514    setregid functions, but they don't work as in BSD and only the POSIX.1
 515    way works.  */
 516
 517 #undef HAVE_SETREUID
 518 #undef HAVE_SETREGID
 519
 520 #else   /* Not POSIX.  */
 521
 522 /* Some POSIX.1 systems have the seteuid and setegid functions.  In a
 523    POSIX-like system, they are the best thing to use.  However, some
 524    non-POSIX systems have them too but they do not work in the POSIX style
 525    and we must use setreuid and setregid instead.  */
 526
 527 #undef HAVE_SETEUID
 528 #undef HAVE_SETEGID
 529
 530 #endif  /* POSIX.  */
 531
 532 #ifndef HAVE_UNISTD_H
 533 extern int getuid (), getgid (), geteuid (), getegid ();
 534 extern int setuid (), setgid ();
 535 #ifdef HAVE_SETEUID
 536 extern int seteuid ();
 537 #else
 538 #ifdef  HAVE_SETREUID
 539 extern int setreuid ();
 540 #endif  /* Have setreuid.  */
 541 #endif  /* Have seteuid.  */
 542 #ifdef HAVE_SETEGID
 543 extern int setegid ();
 544 #else
 545 #ifdef  HAVE_SETREGID
 546 extern int setregid ();
 547 #endif  /* Have setregid.  */
 548 #endif  /* Have setegid.  */
 549 #endif  /* No <unistd.h>.  */
 550
 551 /* Keep track of the user and group IDs for user- and make- access.  */
 552 static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
 553 #define access_inited   (user_uid != -1)
 554 static enum { make, user } current_access;
 555
 556
 557 /* Under -d, write a message describing the current IDs.  */
 558
 559 static void
 560 log_access (flavor)
 561      char *flavor;
 562 {
 563   if (! debug_flag)
 564     return;
 565
 566   /* All the other debugging messages go to stdout,
 567      but we write this one to stderr because it might be
 568      run in a child fork whose stdout is piped.  */
 569
 570   fprintf (stderr, "%s access: user %lu (real %lu), group %lu (real %lu)\n",
 571            flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
 572            (unsigned long) getegid (), (unsigned long) getgid ());
 573   fflush (stderr);
 574 }
 575
 576
 577 static void
 578 init_access ()
 579 {
 580 #ifndef VMS
 581   user_uid = getuid ();
 582   user_gid = getgid ();
 583
 584   make_uid = geteuid ();
 585   make_gid = getegid ();
 586
 587   /* Do these ever fail?  */
 588   if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
 589     pfatal_with_name ("get{e}[gu]id");
 590
 591   log_access ("Initialized");
 592
 593   current_access = make;
 594 #endif
 595 }
 596
 597 #endif  /* GETLOADAVG_PRIVILEGED */
 598
 599 /* Give the process appropriate permissions for access to
 600    user data (i.e., to stat files, or to spawn a child process).  */
 601 void
 602 user_access ()
 603 {
 604 #ifdef  GETLOADAVG_PRIVILEGED
 605
 606   if (!access_inited)
 607     init_access ();
 608
 609   if (current_access == user)
 610     return;
 611
 612   /* We are in "make access" mode.  This means that the effective user and
 613      group IDs are those of make (if it was installed setuid or setgid).
 614      We now want to set the effective user and group IDs to the real IDs,
 615      which are the IDs of the process that exec'd make.  */
 616
 617 #ifdef  HAVE_SETEUID
 618
 619   /* Modern systems have the seteuid/setegid calls which set only the
 620      effective IDs, which is ideal.  */
 621
 622   if (seteuid (user_uid) < 0)
 623     pfatal_with_name ("user_access: seteuid");
 624
 625 #else   /* Not HAVE_SETEUID.  */
 626
 627 #ifndef HAVE_SETREUID
 628
 629   /* System V has only the setuid/setgid calls to set user/group IDs.
 630      There is an effective ID, which can be set by setuid/setgid.
 631      It can be set (unless you are root) only to either what it already is
 632      (returned by geteuid/getegid, now in make_uid/make_gid),
 633      the real ID (return by getuid/getgid, now in user_uid/user_gid),
 634      or the saved set ID (what the effective ID was before this set-ID
 635      executable (make) was exec'd).  */
 636
 637   if (setuid (user_uid) < 0)
 638     pfatal_with_name ("user_access: setuid");
 639
 640 #else   /* HAVE_SETREUID.  */
 641
 642   /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
 643      They may be set to themselves or each other.  So you have two alternatives
 644      at any one time.  If you use setuid/setgid, the effective will be set to
 645      the real, leaving only one alternative.  Using setreuid/setregid, however,
 646      you can toggle between your two alternatives by swapping the values in a
 647      single setreuid or setregid call.  */
 648
 649   if (setreuid (make_uid, user_uid) < 0)
 650     pfatal_with_name ("user_access: setreuid");
 651
 652 #endif  /* Not HAVE_SETREUID.  */
 653 #endif  /* HAVE_SETEUID.  */
 654
 655 #ifdef  HAVE_SETEGID
 656   if (setegid (user_gid) < 0)
 657     pfatal_with_name ("user_access: setegid");
 658 #else
 659 #ifndef HAVE_SETREGID
 660   if (setgid (user_gid) < 0)
 661     pfatal_with_name ("user_access: setgid");
 662 #else
 663   if (setregid (make_gid, user_gid) < 0)
 664     pfatal_with_name ("user_access: setregid");
 665 #endif
 666 #endif
 667
 668   current_access = user;
 669
 670   log_access ("User");
 671
 672 #endif  /* GETLOADAVG_PRIVILEGED */
 673 }
 674
 675 /* Give the process appropriate permissions for access to
 676    make data (i.e., the load average).  */
 677 void
 678 make_access ()
 679 {
 680 #ifdef  GETLOADAVG_PRIVILEGED
 681
 682   if (!access_inited)
 683     init_access ();
 684
 685   if (current_access == make)
 686     return;
 687
 688   /* See comments in user_access, above.  */
 689
 690 #ifdef  HAVE_SETEUID
 691   if (seteuid (make_uid) < 0)
 692     pfatal_with_name ("make_access: seteuid");
 693 #else
 694 #ifndef HAVE_SETREUID
 695   if (setuid (make_uid) < 0)
 696     pfatal_with_name ("make_access: setuid");
 697 #else
 698   if (setreuid (user_uid, make_uid) < 0)
 699     pfatal_with_name ("make_access: setreuid");
 700 #endif
 701 #endif
 702
 703 #ifdef  HAVE_SETEGID
 704   if (setegid (make_gid) < 0)
 705     pfatal_with_name ("make_access: setegid");
 706 #else
 707 #ifndef HAVE_SETREGID
 708   if (setgid (make_gid) < 0)
 709     pfatal_with_name ("make_access: setgid");
 710 #else
 711   if (setregid (user_gid, make_gid) < 0)
 712     pfatal_with_name ("make_access: setregid");
 713 #endif
 714 #endif
 715
 716   current_access = make;
 717
 718   log_access ("Make");
 719
 720 #endif  /* GETLOADAVG_PRIVILEGED */
 721 }
 722
 723 /* Give the process appropriate permissions for a child process.
 724    This is like user_access, but you can't get back to make_access.  */
 725 void
 726 child_access ()
 727 {
 728 #ifdef  GETLOADAVG_PRIVILEGED
 729
 730   if (!access_inited)
 731     abort ();
 732
 733   /* Set both the real and effective UID and GID to the user's.
 734      They cannot be changed back to make's.  */
 735
 736 #ifndef HAVE_SETREUID
 737   if (setuid (user_uid) < 0)
 738     pfatal_with_name ("child_access: setuid");
 739 #else
 740   if (setreuid (user_uid, user_uid) < 0)
 741     pfatal_with_name ("child_access: setreuid");
 742 #endif
 743
 744 #ifndef HAVE_SETREGID
 745   if (setgid (user_gid) < 0)
 746     pfatal_with_name ("child_access: setgid");
 747 #else
 748   if (setregid (user_gid, user_gid) < 0)
 749     pfatal_with_name ("child_access: setregid");
 750 #endif
 751
 752   log_access ("Child");
 753
 754 #endif  /* GETLOADAVG_PRIVILEGED */
 755 }
 756 \f
 757 #ifdef NEED_GET_PATH_MAX
 758 unsigned int
 759 get_path_max ()
 760 {
 761   static unsigned int value;
 762
 763   if (value == 0)
 764     {
 765       long int x = pathconf ("/", _PC_PATH_MAX);
 766       if (x > 0)
 767         value = x;
 768       else
 769         return MAXPATHLEN;
 770     }
 771
 772   return value;
 773 }
 774 #endif