misc.c

   1 /* Miscellaneous generic support functions for GNU Make.
   2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 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   log_working_directory (1);
 257
 258   fprintf (stderr, "%s:%u: *** ", file, lineno);
 259   fprintf (stderr, s1, s2, s3, s4, s5, s6);
 260   fputs (".  Stop.\n", stderr);
 261
 262   die (2);
 263 }
 264
 265 #ifndef HAVE_STRERROR
 266
 267 #undef  strerror
 268
 269 char *
 270 strerror (errnum)
 271      int errnum;
 272 {
 273   extern int errno, sys_nerr;
 274   extern char *sys_errlist[];
 275   static char buf[] = "Unknown error 12345678901234567890";
 276
 277   if (errno < sys_nerr)
 278     return sys_errlist[errnum];
 279
 280   sprintf (buf, "Unknown error %d", errnum);
 281   return buf;
 282 }
 283 #endif
 284
 285 /* Print an error message from errno.  */
 286
 287 void
 288 perror_with_name (str, name)
 289      char *str, *name;
 290 {
 291   error ("%s%s: %s", str, name, strerror (errno));
 292 }
 293
 294 /* Print an error message from errno and exit.  */
 295
 296 void
 297 pfatal_with_name (name)
 298      char *name;
 299 {
 300   fatal ("%s: %s", name, strerror (errno));
 301
 302   /* NOTREACHED */
 303 }
 304 \f
 305 /* Like malloc but get fatal error if memory is exhausted.  */
 306
 307 #undef xmalloc
 308 #undef xrealloc
 309
 310 char *
 311 xmalloc (size)
 312      unsigned int size;
 313 {
 314   char *result = (char *) malloc (size);
 315   if (result == 0)
 316     fatal ("virtual memory exhausted");
 317   return result;
 318 }
 319
 320
 321 char *
 322 xrealloc (ptr, size)
 323      char *ptr;
 324      unsigned int size;
 325 {
 326   char *result = (char *) realloc (ptr, size);
 327   if (result == 0)
 328     fatal ("virtual memory exhausted");
 329   return result;
 330 }
 331
 332 char *
 333 savestring (str, length)
 334      char *str;
 335      unsigned int length;
 336 {
 337   register char *out = (char *) xmalloc (length + 1);
 338   if (length > 0)
 339     bcopy (str, out, length);
 340   out[length] = '\0';
 341   return out;
 342 }
 343 \f
 344 /* Search string BIG (length BLEN) for an occurrence of
 345    string SMALL (length SLEN).  Return a pointer to the
 346    beginning of the first occurrence, or return nil if none found.  */
 347
 348 char *
 349 sindex (big, blen, small, slen)
 350      char *big;
 351      unsigned int blen;
 352      char *small;
 353      unsigned int slen;
 354 {
 355   register unsigned int b;
 356
 357   if (blen < 1)
 358     blen = strlen (big);
 359   if (slen < 1)
 360     slen = strlen (small);
 361
 362   for (b = 0; b < blen; ++b)
 363     if (big[b] == *small && !strncmp (&big[b + 1], small + 1, slen - 1))
 364       return (&big[b]);
 365
 366   return 0;
 367 }
 368
 369 /* Limited INDEX:
 370    Search through the string STRING, which ends at LIMIT, for the character C.
 371    Returns a pointer to the first occurrence, or nil if none is found.
 372    Like INDEX except that the string searched ends where specified
 373    instead of at the first null.  */
 374
 375 char *
 376 lindex (s, limit, c)
 377      register char *s, *limit;
 378      int c;
 379 {
 380   while (s < limit)
 381     if (*s++ == c)
 382       return s - 1;
 383
 384   return 0;
 385 }
 386 \f
 387 /* Return the address of the first whitespace or null in the string S.  */
 388
 389 char *
 390 end_of_token (s)
 391      char *s;
 392 {
 393   while (*s != '\0' && !isblank (*s))
 394     ++s;
 395   return s;
 396 }
 397
 398 /* Return the address of the first nonwhitespace or null in the string S.  */
 399
 400 char *
 401 next_token (s)
 402      char *s;
 403 {
 404   register char *p = s;
 405
 406   while (isblank (*p))
 407     ++p;
 408   return p;
 409 }
 410
 411 /* Find the next token in PTR; return the address of it, and store the
 412    length of the token into *LENGTHPTR if LENGTHPTR is not nil.  */
 413
 414 char *
 415 find_next_token (ptr, lengthptr)
 416      char **ptr;
 417      unsigned int *lengthptr;
 418 {
 419   char *p = next_token (*ptr);
 420   char *end;
 421
 422   if (*p == '\0')
 423     return 0;
 424
 425   *ptr = end = end_of_token (p);
 426   if (lengthptr != 0)
 427     *lengthptr = end - p;
 428   return p;
 429 }
 430 \f
 431 /* Copy a chain of `struct dep', making a new chain
 432    with the same contents as the old one.  */
 433
 434 struct dep *
 435 copy_dep_chain (d)
 436      register struct dep *d;
 437 {
 438   register struct dep *c;
 439   struct dep *firstnew = 0;
 440   struct dep *lastnew;
 441
 442   while (d != 0)
 443     {
 444       c = (struct dep *) xmalloc (sizeof (struct dep));
 445       bcopy ((char *) d, (char *) c, sizeof (struct dep));
 446       if (c->name != 0)
 447         c->name = savestring (c->name, strlen (c->name));
 448       c->next = 0;
 449       if (firstnew == 0)
 450         firstnew = lastnew = c;
 451       else
 452         lastnew = lastnew->next = c;
 453
 454       d = d->next;
 455     }
 456
 457   return firstnew;
 458 }
 459 \f
 460 #ifdef  iAPX286
 461 /* The losing compiler on this machine can't handle this macro.  */
 462
 463 char *
 464 dep_name (dep)
 465      struct dep *dep;
 466 {
 467   return dep->name == 0 ? dep->file->name : dep->name;
 468 }
 469 #endif
 470 \f
 471 #ifdef  GETLOADAVG_PRIVILEGED
 472
 473 #ifdef POSIX
 474
 475 /* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
 476    functions, they work as POSIX.1 says.  Some systems (Alpha OSF/1 1.2,
 477    for example) which claim to be POSIX.1 also have the BSD setreuid and
 478    setregid functions, but they don't work as in BSD and only the POSIX.1
 479    way works.  */
 480
 481 #undef HAVE_SETREUID
 482 #undef HAVE_SETREGID
 483
 484 #else   /* Not POSIX.  */
 485
 486 /* Some POSIX.1 systems have the seteuid and setegid functions.  In a
 487    POSIX-like system, they are the best thing to use.  However, some
 488    non-POSIX systems have them too but they do not work in the POSIX style
 489    and we must use setreuid and setregid instead.  */
 490
 491 #undef HAVE_SETEUID
 492 #undef HAVE_SETEGID
 493
 494 #endif  /* POSIX.  */
 495
 496 #ifndef HAVE_UNISTD_H
 497 extern int getuid (), getgid (), geteuid (), getegid ();
 498 extern int setuid (), setgid ();
 499 #ifdef HAVE_SETEUID
 500 extern int seteuid ();
 501 #else
 502 #ifdef  HAVE_SETREUID
 503 extern int setreuid ();
 504 #endif  /* Have setreuid.  */
 505 #endif  /* Have seteuid.  */
 506 #ifdef HAVE_SETEGID
 507 extern int setegid ();
 508 #else
 509 #ifdef  HAVE_SETREGID
 510 extern int setregid ();
 511 #endif  /* Have setregid.  */
 512 #endif  /* Have setegid.  */
 513 #endif  /* No <unistd.h>.  */
 514
 515 /* Keep track of the user and group IDs for user- and make- access.  */
 516 static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
 517 #define access_inited   (user_uid != -1)
 518 static enum { make, user } current_access;
 519
 520
 521 /* Under -d, write a message describing the current IDs.  */
 522
 523 static void
 524 log_access (flavor)
 525      char *flavor;
 526 {
 527   if (! debug_flag)
 528     return;
 529
 530   /* All the other debugging messages go to stdout,
 531      but we write this one to stderr because it might be
 532      run in a child fork whose stdout is piped.  */
 533
 534   fprintf (stderr, "%s access: user %d (real %d), group %d (real %d)\n",
 535            flavor, geteuid (), getuid (), getegid (), getgid ());
 536   fflush (stderr);
 537 }
 538
 539
 540 static void
 541 init_access ()
 542 {
 543   user_uid = getuid ();
 544   user_gid = getgid ();
 545
 546   make_uid = geteuid ();
 547   make_gid = getegid ();
 548
 549   /* Do these ever fail?  */
 550   if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
 551     pfatal_with_name ("get{e}[gu]id");
 552
 553   log_access ("Initialized");
 554
 555   current_access = make;
 556 }
 557
 558 #endif  /* GETLOADAVG_PRIVILEGED */
 559
 560 /* Give the process appropriate permissions for access to
 561    user data (i.e., to stat files, or to spawn a child process).  */
 562 void
 563 user_access ()
 564 {
 565 #ifdef  GETLOADAVG_PRIVILEGED
 566
 567   if (!access_inited)
 568     init_access ();
 569
 570   if (current_access == user)
 571     return;
 572
 573   /* We are in "make access" mode.  This means that the effective user and
 574      group IDs are those of make (if it was installed setuid or setgid).
 575      We now want to set the effective user and group IDs to the real IDs,
 576      which are the IDs of the process that exec'd make.  */
 577
 578 #ifdef  HAVE_SETEUID
 579
 580   /* Modern systems have the seteuid/setegid calls which set only the
 581      effective IDs, which is ideal.  */
 582
 583   if (seteuid (user_uid) < 0)
 584     pfatal_with_name ("user_access: seteuid");
 585
 586 #else   /* Not HAVE_SETEUID.  */
 587
 588 #ifndef HAVE_SETREUID
 589
 590   /* System V has only the setuid/setgid calls to set user/group IDs.
 591      There is an effective ID, which can be set by setuid/setgid.
 592      It can be set (unless you are root) only to either what it already is
 593      (returned by geteuid/getegid, now in make_uid/make_gid),
 594      the real ID (return by getuid/getgid, now in user_uid/user_gid),
 595      or the saved set ID (what the effective ID was before this set-ID
 596      executable (make) was exec'd).  */
 597
 598   if (setuid (user_uid) < 0)
 599     pfatal_with_name ("user_access: setuid");
 600
 601 #else   /* HAVE_SETREUID.  */
 602
 603   /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
 604      They may be set to themselves or each other.  So you have two alternatives
 605      at any one time.  If you use setuid/setgid, the effective will be set to
 606      the real, leaving only one alternative.  Using setreuid/setregid, however,
 607      you can toggle between your two alternatives by swapping the values in a
 608      single setreuid or setregid call.  */
 609
 610   if (setreuid (make_uid, user_uid) < 0)
 611     pfatal_with_name ("user_access: setreuid");
 612
 613 #endif  /* Not HAVE_SETREUID.  */
 614 #endif  /* HAVE_SETEUID.  */
 615
 616 #ifdef  HAVE_SETEGID
 617   if (setegid (user_gid) < 0)
 618     pfatal_with_name ("user_access: setegid");
 619 #else
 620 #ifndef HAVE_SETREGID
 621   if (setgid (user_gid) < 0)
 622     pfatal_with_name ("user_access: setgid");
 623 #else
 624   if (setregid (make_gid, user_gid) < 0)
 625     pfatal_with_name ("user_access: setregid");
 626 #endif
 627 #endif
 628
 629   current_access = user;
 630
 631   log_access ("User");
 632
 633 #endif  /* GETLOADAVG_PRIVILEGED */
 634 }
 635
 636 /* Give the process appropriate permissions for access to
 637    make data (i.e., the load average).  */
 638 void
 639 make_access ()
 640 {
 641 #ifdef  GETLOADAVG_PRIVILEGED
 642
 643   if (!access_inited)
 644     init_access ();
 645
 646   if (current_access == make)
 647     return;
 648
 649   /* See comments in user_access, above.  */
 650
 651 #ifdef  HAVE_SETEUID
 652   if (seteuid (make_uid) < 0)
 653     pfatal_with_name ("make_access: seteuid");
 654 #else
 655 #ifndef HAVE_SETREUID
 656   if (setuid (make_uid) < 0)
 657     pfatal_with_name ("make_access: setuid");
 658 #else
 659   if (setreuid (user_uid, make_uid) < 0)
 660     pfatal_with_name ("make_access: setreuid");
 661 #endif
 662 #endif
 663
 664 #ifdef  HAVE_SETEGID
 665   if (setegid (make_gid) < 0)
 666     pfatal_with_name ("make_access: setegid");
 667 #else
 668 #ifndef HAVE_SETREGID
 669   if (setgid (make_gid) < 0)
 670     pfatal_with_name ("make_access: setgid");
 671 #else
 672   if (setregid (user_gid, make_gid) < 0)
 673     pfatal_with_name ("make_access: setregid");
 674 #endif
 675 #endif
 676
 677   current_access = make;
 678
 679   log_access ("Make");
 680
 681 #endif  /* GETLOADAVG_PRIVILEGED */
 682 }
 683
 684 /* Give the process appropriate permissions for a child process.
 685    This is like user_access, but you can't get back to make_access.  */
 686 void
 687 child_access ()
 688 {
 689 #ifdef  GETLOADAVG_PRIVILEGED
 690
 691   if (!access_inited)
 692     abort ();
 693
 694   /* Set both the real and effective UID and GID to the user's.
 695      They cannot be changed back to make's.  */
 696
 697 #ifndef HAVE_SETREUID
 698   if (setuid (user_uid) < 0)
 699     pfatal_with_name ("child_access: setuid");
 700 #else
 701   if (setreuid (user_uid, user_uid) < 0)
 702     pfatal_with_name ("child_access: setreuid");
 703 #endif
 704
 705 #ifndef HAVE_SETREGID
 706   if (setgid (user_gid) < 0)
 707     pfatal_with_name ("child_access: setgid");
 708 #else
 709   if (setregid (user_gid, user_gid) < 0)
 710     pfatal_with_name ("child_access: setregid");
 711 #endif
 712
 713   log_access ("Child");
 714
 715 #endif  /* GETLOADAVG_PRIVILEGED */
 716 }
 717 \f
 718 #ifdef NEED_GET_PATH_MAX
 719 unsigned int
 720 get_path_max ()
 721 {
 722   static unsigned int value;
 723
 724   if (value == 0)
 725     {
 726       long int x = pathconf ("/", _PC_PATH_MAX);
 727       if (x > 0)
 728         value = x;
 729       else
 730         return MAXPATHLEN;
 731     }
 732
 733   return value;
 734 }
 735 #endif