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