misc.c

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