1 /* Miscellaneous generic support functions for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along with
17 this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Variadic functions. We go through contortions to allow proper function
24 prototypes for both ANSI and pre-ANSI C compilers, and also for those
25 which support stdarg.h vs. varargs.h, and finally those which have
26 vfprintf(), etc. and those who have _doprnt... or nothing.
28 This fancy stuff all came from GNU fileutils, except for the VA_PRINTF and
29 VA_END macros used here since we have multiple print functions. */
34 # define VA_START(args, lastarg) va_start(args, lastarg)
37 # define VA_START(args, lastarg) va_start(args)
40 # define VA_PRINTF(fp, lastarg, args) vfprintf((fp), (lastarg), (args))
42 # define VA_PRINTF(fp, lastarg, args) _doprnt((lastarg), (args), (fp))
44 # define VA_END(args) va_end(args)
46 /* We can't use any variadic interface! */
47 # define va_alist a1, a2, a3, a4, a5, a6, a7, a8
48 # define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
49 # define VA_START(args, lastarg)
50 # define VA_PRINTF(fp, lastarg, args) fprintf((fp), (lastarg), va_alist)
55 /* Compare strings *S1 and *S2.
56 Return negative if the first is less, positive if it is greater,
57 zero if they are equal. */
60 alpha_compare (const void *v1
, const void *v2
)
62 const char *s1
= *((char **)v1
);
63 const char *s2
= *((char **)v2
);
67 return strcmp (s1
, s2
);
70 /* Discard each backslash-newline combination from LINE.
71 Backslash-backslash-newline combinations become backslash-newlines.
72 This is done by copying the text at LINE into itself. */
75 collapse_continuations (char *line
)
77 register char *in
, *out
, *p
;
78 register int backslash
;
79 register unsigned int bs_write
;
81 in
= strchr (line
, '\n');
86 while (out
> line
&& out
[-1] == '\\')
91 /* BS_WRITE gets the number of quoted backslashes at
92 the end just before IN, and BACKSLASH gets nonzero
93 if the next character is quoted. */
96 for (p
= in
- 1; p
>= line
&& *p
== '\\'; --p
)
100 backslash
= !backslash
;
102 /* It should be impossible to go back this far without exiting,
103 but if we do, we can't get the right answer. */
108 /* Output the appropriate number of backslashes. */
109 while (bs_write
-- > 0)
112 /* Skip the newline. */
115 /* If the newline is escaped, discard following whitespace leaving just
116 one space. POSIX requires that each backslash/newline/following
117 whitespace sequence be reduced to a single space. */
120 in
= next_token (in
);
121 /* Removing this loop will fix Savannah bug #16670: do we want to? */
122 while (out
> line
&& isblank ((unsigned char)out
[-1]))
127 /* If the newline isn't quoted, put it in the output. */
130 /* Now copy the following line to the output.
131 Stop when we find backslashes followed by a newline. */
153 /* Print N spaces (used in debug for target-depth). */
156 print_spaces (unsigned int n
)
163 /* Return a string whose contents concatenate the NUM strings provided
164 This string lives in static, re-used memory. */
167 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
168 concat (unsigned int num
, ...)
170 concat (num
, va_alist
)
175 static unsigned int rlen
= 0;
176 static char *result
= NULL
;
183 VA_START (args
, num
);
187 const char *s
= va_arg (args
, const char *);
188 unsigned int l
= s
? strlen (s
) : 0;
195 rlen
= ((rlen
? rlen
: 60) + l
) * 2;
196 result
= xrealloc (result
, rlen
);
199 memcpy (result
+ ri
, s
, l
);
210 /* Print a message on stdout. */
213 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
214 message (int prefix
, const char *fmt
, ...)
216 message (prefix
, fmt
, va_alist
)
226 log_working_directory (1);
233 printf ("%s: ", program
);
235 printf ("%s[%u]: ", program
, makelevel
);
237 VA_START (args
, fmt
);
238 VA_PRINTF (stdout
, fmt
, args
);
246 /* Print an error message. */
249 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
250 error (const struct floc
*flocp
, const char *fmt
, ...)
252 error (flocp
, fmt
, va_alist
)
253 const struct floc
*flocp
;
262 log_working_directory (1);
264 if (flocp
&& flocp
->filenm
)
265 fprintf (stderr
, "%s:%lu: ", flocp
->filenm
, flocp
->lineno
);
266 else if (makelevel
== 0)
267 fprintf (stderr
, "%s: ", program
);
269 fprintf (stderr
, "%s[%u]: ", program
, makelevel
);
272 VA_PRINTF (stderr
, fmt
, args
);
279 /* Print an error message and exit. */
282 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
283 fatal (const struct floc
*flocp
, const char *fmt
, ...)
285 fatal (flocp
, fmt
, va_alist
)
286 const struct floc
*flocp
;
295 log_working_directory (1);
297 if (flocp
&& flocp
->filenm
)
298 fprintf (stderr
, "%s:%lu: *** ", flocp
->filenm
, flocp
->lineno
);
299 else if (makelevel
== 0)
300 fprintf (stderr
, "%s: *** ", program
);
302 fprintf (stderr
, "%s[%u]: *** ", program
, makelevel
);
305 VA_PRINTF (stderr
, fmt
, args
);
308 fputs (_(". Stop.\n"), stderr
);
313 #ifndef HAVE_STRERROR
318 strerror (int errnum
)
320 extern int errno
, sys_nerr
;
322 extern char *sys_errlist
[];
324 static char buf
[] = "Unknown error 12345678901234567890";
326 if (errno
< sys_nerr
)
327 return sys_errlist
[errnum
];
329 sprintf (buf
, _("Unknown error %d"), errnum
);
334 /* Print an error message from errno. */
337 perror_with_name (const char *str
, const char *name
)
339 error (NILF
, _("%s%s: %s"), str
, name
, strerror (errno
));
342 /* Print an error message from errno and exit. */
345 pfatal_with_name (const char *name
)
347 fatal (NILF
, _("%s: %s"), name
, strerror (errno
));
352 /* Like malloc but get fatal error if memory is exhausted. */
353 /* Don't bother if we're using dmalloc; it provides these for us. */
355 #ifndef HAVE_DMALLOC_H
363 xmalloc (unsigned int size
)
365 /* Make sure we don't allocate 0, for pre-ISO implementations. */
366 void *result
= malloc (size
? size
: 1);
368 fatal (NILF
, _("virtual memory exhausted"));
374 xcalloc (unsigned int size
)
376 /* Make sure we don't allocate 0, for pre-ISO implementations. */
377 void *result
= calloc (size
? size
: 1, 1);
379 fatal (NILF
, _("virtual memory exhausted"));
385 xrealloc (void *ptr
, unsigned int size
)
389 /* Some older implementations of realloc() don't conform to ISO. */
392 result
= ptr
? realloc (ptr
, size
) : malloc (size
);
394 fatal (NILF
, _("virtual memory exhausted"));
400 xstrdup (const char *ptr
)
405 result
= strdup (ptr
);
407 result
= malloc (strlen (ptr
) + 1);
411 fatal (NILF
, _("virtual memory exhausted"));
416 return strcpy (result
, ptr
);
420 #endif /* HAVE_DMALLOC_H */
423 xstrndup (const char *str
, unsigned int length
)
428 result
= strndup (str
, length
);
430 fatal (NILF
, _("virtual memory exhausted"));
432 result
= xmalloc (length
+ 1);
433 strncpy (result
, str
, length
);
434 result
[length
] = '\0';
442 Search through the string STRING, which ends at LIMIT, for the character C.
443 Returns a pointer to the first occurrence, or nil if none is found.
444 Like INDEX except that the string searched ends where specified
445 instead of at the first null. */
448 lindex (const char *s
, const char *limit
, int c
)
452 return (char *)(s
- 1);
457 /* Return the address of the first whitespace or null in the string S. */
460 end_of_token (const char *s
)
462 while (*s
!= '\0' && !isblank ((unsigned char)*s
))
469 * Same as end_of_token, but take into account a stop character
472 end_of_token_w32 (const char *s
, char stopchar
)
477 while (*p
!= '\0' && *p
!= stopchar
478 && (backslash
|| !isblank ((unsigned char)*p
)))
482 backslash
= !backslash
;
485 backslash
= !backslash
;
497 /* Return the address of the first nonwhitespace or null in the string S. */
500 next_token (const char *s
)
502 while (isblank ((unsigned char)*s
))
507 /* Find the next token in PTR; return the address of it, and store the length
508 of the token into *LENGTHPTR if LENGTHPTR is not nil. Set *PTR to the end
509 of the token, so this function can be called repeatedly in a loop. */
512 find_next_token (const char **ptr
, unsigned int *lengthptr
)
514 const char *p
= next_token (*ptr
);
519 *ptr
= end_of_token (p
);
521 *lengthptr
= *ptr
- p
;
527 /* Copy a chain of `struct dep', making a new chain
528 with the same contents as the old one. */
531 copy_dep_chain (const struct dep
*d
)
533 struct dep
*firstnew
= 0;
534 struct dep
*lastnew
= 0;
538 struct dep
*c
= xmalloc (sizeof (struct dep
));
539 memcpy (c
, d
, sizeof (struct dep
));
543 firstnew
= lastnew
= c
;
545 lastnew
= lastnew
->next
= c
;
553 /* Free a chain of 'struct dep'. */
556 free_dep_chain (struct dep
*d
)
566 /* Free a chain of struct nameseq.
567 For struct dep chains use free_dep_chain. */
570 free_ns_chain (struct nameseq
*ns
)
574 struct nameseq
*t
= ns
;
581 #if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
583 /* If we don't have strcasecmp() (from POSIX), or anything that can substitute
584 for it, define our own version. */
587 strcasecmp (const char *s1
, const char *s2
)
591 int c1
= (int) *(s1
++);
592 int c2
= (int) *(s2
++);
599 if (c1
!= '\0' && c1
== c2
)
607 #ifdef GETLOADAVG_PRIVILEGED
611 /* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
612 functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2,
613 for example) which claim to be POSIX.1 also have the BSD setreuid and
614 setregid functions, but they don't work as in BSD and only the POSIX.1
620 #else /* Not POSIX. */
622 /* Some POSIX.1 systems have the seteuid and setegid functions. In a
623 POSIX-like system, they are the best thing to use. However, some
624 non-POSIX systems have them too but they do not work in the POSIX style
625 and we must use setreuid and setregid instead. */
632 #ifndef HAVE_UNISTD_H
633 extern int getuid (), getgid (), geteuid (), getegid ();
634 extern int setuid (), setgid ();
636 extern int seteuid ();
639 extern int setreuid ();
640 #endif /* Have setreuid. */
641 #endif /* Have seteuid. */
643 extern int setegid ();
646 extern int setregid ();
647 #endif /* Have setregid. */
648 #endif /* Have setegid. */
649 #endif /* No <unistd.h>. */
651 /* Keep track of the user and group IDs for user- and make- access. */
652 static int user_uid
= -1, user_gid
= -1, make_uid
= -1, make_gid
= -1;
653 #define access_inited (user_uid != -1)
654 static enum { make
, user
} current_access
;
657 /* Under -d, write a message describing the current IDs. */
660 log_access (const char *flavor
)
662 if (! ISDB (DB_JOBS
))
665 /* All the other debugging messages go to stdout,
666 but we write this one to stderr because it might be
667 run in a child fork whose stdout is piped. */
669 fprintf (stderr
, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
670 flavor
, (unsigned long) geteuid (), (unsigned long) getuid (),
671 (unsigned long) getegid (), (unsigned long) getgid ());
680 user_uid
= getuid ();
681 user_gid
= getgid ();
683 make_uid
= geteuid ();
684 make_gid
= getegid ();
686 /* Do these ever fail? */
687 if (user_uid
== -1 || user_gid
== -1 || make_uid
== -1 || make_gid
== -1)
688 pfatal_with_name ("get{e}[gu]id");
690 log_access (_("Initialized access"));
692 current_access
= make
;
696 #endif /* GETLOADAVG_PRIVILEGED */
698 /* Give the process appropriate permissions for access to
699 user data (i.e., to stat files, or to spawn a child process). */
703 #ifdef GETLOADAVG_PRIVILEGED
708 if (current_access
== user
)
711 /* We are in "make access" mode. This means that the effective user and
712 group IDs are those of make (if it was installed setuid or setgid).
713 We now want to set the effective user and group IDs to the real IDs,
714 which are the IDs of the process that exec'd make. */
718 /* Modern systems have the seteuid/setegid calls which set only the
719 effective IDs, which is ideal. */
721 if (seteuid (user_uid
) < 0)
722 pfatal_with_name ("user_access: seteuid");
724 #else /* Not HAVE_SETEUID. */
726 #ifndef HAVE_SETREUID
728 /* System V has only the setuid/setgid calls to set user/group IDs.
729 There is an effective ID, which can be set by setuid/setgid.
730 It can be set (unless you are root) only to either what it already is
731 (returned by geteuid/getegid, now in make_uid/make_gid),
732 the real ID (return by getuid/getgid, now in user_uid/user_gid),
733 or the saved set ID (what the effective ID was before this set-ID
734 executable (make) was exec'd). */
736 if (setuid (user_uid
) < 0)
737 pfatal_with_name ("user_access: setuid");
739 #else /* HAVE_SETREUID. */
741 /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
742 They may be set to themselves or each other. So you have two alternatives
743 at any one time. If you use setuid/setgid, the effective will be set to
744 the real, leaving only one alternative. Using setreuid/setregid, however,
745 you can toggle between your two alternatives by swapping the values in a
746 single setreuid or setregid call. */
748 if (setreuid (make_uid
, user_uid
) < 0)
749 pfatal_with_name ("user_access: setreuid");
751 #endif /* Not HAVE_SETREUID. */
752 #endif /* HAVE_SETEUID. */
755 if (setegid (user_gid
) < 0)
756 pfatal_with_name ("user_access: setegid");
758 #ifndef HAVE_SETREGID
759 if (setgid (user_gid
) < 0)
760 pfatal_with_name ("user_access: setgid");
762 if (setregid (make_gid
, user_gid
) < 0)
763 pfatal_with_name ("user_access: setregid");
767 current_access
= user
;
769 log_access (_("User access"));
771 #endif /* GETLOADAVG_PRIVILEGED */
774 /* Give the process appropriate permissions for access to
775 make data (i.e., the load average). */
779 #ifdef GETLOADAVG_PRIVILEGED
784 if (current_access
== make
)
787 /* See comments in user_access, above. */
790 if (seteuid (make_uid
) < 0)
791 pfatal_with_name ("make_access: seteuid");
793 #ifndef HAVE_SETREUID
794 if (setuid (make_uid
) < 0)
795 pfatal_with_name ("make_access: setuid");
797 if (setreuid (user_uid
, make_uid
) < 0)
798 pfatal_with_name ("make_access: setreuid");
803 if (setegid (make_gid
) < 0)
804 pfatal_with_name ("make_access: setegid");
806 #ifndef HAVE_SETREGID
807 if (setgid (make_gid
) < 0)
808 pfatal_with_name ("make_access: setgid");
810 if (setregid (user_gid
, make_gid
) < 0)
811 pfatal_with_name ("make_access: setregid");
815 current_access
= make
;
817 log_access (_("Make access"));
819 #endif /* GETLOADAVG_PRIVILEGED */
822 /* Give the process appropriate permissions for a child process.
823 This is like user_access, but you can't get back to make_access. */
827 #ifdef GETLOADAVG_PRIVILEGED
832 /* Set both the real and effective UID and GID to the user's.
833 They cannot be changed back to make's. */
835 #ifndef HAVE_SETREUID
836 if (setuid (user_uid
) < 0)
837 pfatal_with_name ("child_access: setuid");
839 if (setreuid (user_uid
, user_uid
) < 0)
840 pfatal_with_name ("child_access: setreuid");
843 #ifndef HAVE_SETREGID
844 if (setgid (user_gid
) < 0)
845 pfatal_with_name ("child_access: setgid");
847 if (setregid (user_gid
, user_gid
) < 0)
848 pfatal_with_name ("child_access: setregid");
851 log_access (_("Child access"));
853 #endif /* GETLOADAVG_PRIVILEGED */
856 #ifdef NEED_GET_PATH_MAX
860 static unsigned int value
;
864 long int x
= pathconf ("/", _PC_PATH_MAX
);
876 /* This code is stolen from gnulib.
877 If/when we abandon the requirement to work with K&R compilers, we can
878 remove this (and perhaps other parts of GNU make!) and migrate to using
881 This is called only through atexit(), which means die() has already been
882 invoked. So, call exit() here directly. Apparently that works...?
885 /* Close standard output, exiting with status 'exit_failure' on failure.
886 If a program writes *anything* to stdout, that program should close
887 stdout and make sure that it succeeds before exiting. Otherwise,
888 suppose that you go to the extreme of checking the return status
889 of every function that does an explicit write to stdout. The last
890 printf can succeed in writing to the internal stream buffer, and yet
891 the fclose(stdout) could still fail (due e.g., to a disk full error)
892 when it tries to write out that buffered data. Thus, you would be
893 left with an incomplete output file and the offending program would
894 exit successfully. Even calling fflush is not always sufficient,
895 since some file systems (NFS and CODA) buffer written/flushed data
896 until an actual close call.
898 Besides, it's wasteful to check the return value from every call
899 that writes to stdout -- just let the internal stream state record
900 the failure. That's what the ferror test is checking below.
902 It's important to detect such failures and exit nonzero because many
903 tools (most notably `make' and other build-management systems) depend
904 on being able to detect failure in other tools via their exit status. */
909 int prev_fail
= ferror (stdout
);
910 int fclose_fail
= fclose (stdout
);
912 if (prev_fail
|| fclose_fail
)
915 error (NILF
, _("write error: %s"), strerror (errno
));
917 error (NILF
, _("write error"));