1 /* Miscellaneous generic support functions for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
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. */
117 /* Backslash/newline handling:
118 In traditional GNU make all trailing whitespace, consecutive
119 backslash/newlines, and any leading whitespace on the next line
120 is reduced to a single space.
121 In POSIX, each backslash/newline and is replaced by a space. */
122 in
= next_token (in
);
123 if (! posix_pedantic
)
124 while (out
> line
&& isblank ((unsigned char)out
[-1]))
129 /* If the newline isn't quoted, put it in the output. */
132 /* Now copy the following line to the output.
133 Stop when we find backslashes followed by a newline. */
155 /* Print N spaces (used in debug for target-depth). */
158 print_spaces (unsigned int n
)
165 /* Return a string whose contents concatenate the NUM strings provided
166 This string lives in static, re-used memory. */
169 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
170 concat (unsigned int num
, ...)
172 concat (num
, va_alist
)
177 static unsigned int rlen
= 0;
178 static char *result
= NULL
;
185 VA_START (args
, num
);
189 const char *s
= va_arg (args
, const char *);
190 unsigned int l
= s
? strlen (s
) : 0;
197 rlen
= ((rlen
? rlen
: 60) + l
) * 2;
198 result
= xrealloc (result
, rlen
);
201 memcpy (result
+ ri
, s
, l
);
207 /* Get some more memory if we don't have enough space for the
211 rlen
= (rlen
? rlen
: 60) * 2;
212 result
= xrealloc (result
, rlen
);
220 /* Print a message on stdout. */
223 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
224 message (int prefix
, const char *fmt
, ...)
226 message (prefix
, fmt
, va_alist
)
236 log_working_directory (1);
243 printf ("%s: ", program
);
245 printf ("%s[%u]: ", program
, makelevel
);
247 VA_START (args
, fmt
);
248 VA_PRINTF (stdout
, fmt
, args
);
256 /* Print an error message. */
259 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
260 error (const struct floc
*flocp
, const char *fmt
, ...)
262 error (flocp
, fmt
, va_alist
)
263 const struct floc
*flocp
;
272 log_working_directory (1);
274 if (flocp
&& flocp
->filenm
)
275 fprintf (stderr
, "%s:%lu: ", flocp
->filenm
, flocp
->lineno
);
276 else if (makelevel
== 0)
277 fprintf (stderr
, "%s: ", program
);
279 fprintf (stderr
, "%s[%u]: ", program
, makelevel
);
282 VA_PRINTF (stderr
, fmt
, args
);
289 /* Print an error message and exit. */
292 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
293 fatal (const struct floc
*flocp
, const char *fmt
, ...)
295 fatal (flocp
, fmt
, va_alist
)
296 const struct floc
*flocp
;
305 log_working_directory (1);
307 if (flocp
&& flocp
->filenm
)
308 fprintf (stderr
, "%s:%lu: *** ", flocp
->filenm
, flocp
->lineno
);
309 else if (makelevel
== 0)
310 fprintf (stderr
, "%s: *** ", program
);
312 fprintf (stderr
, "%s[%u]: *** ", program
, makelevel
);
315 VA_PRINTF (stderr
, fmt
, args
);
318 fputs (_(". Stop.\n"), stderr
);
323 #ifndef HAVE_STRERROR
328 strerror (int errnum
)
330 extern int errno
, sys_nerr
;
332 extern char *sys_errlist
[];
334 static char buf
[] = "Unknown error 12345678901234567890";
336 if (errno
< sys_nerr
)
337 return sys_errlist
[errnum
];
339 sprintf (buf
, _("Unknown error %d"), errnum
);
344 /* Print an error message from errno. */
347 perror_with_name (const char *str
, const char *name
)
349 error (NILF
, _("%s%s: %s"), str
, name
, strerror (errno
));
352 /* Print an error message from errno and exit. */
355 pfatal_with_name (const char *name
)
357 fatal (NILF
, _("%s: %s"), name
, strerror (errno
));
362 /* Like malloc but get fatal error if memory is exhausted. */
363 /* Don't bother if we're using dmalloc; it provides these for us. */
365 #ifndef HAVE_DMALLOC_H
373 xmalloc (unsigned int size
)
375 /* Make sure we don't allocate 0, for pre-ISO implementations. */
376 void *result
= malloc (size
? size
: 1);
378 fatal (NILF
, _("virtual memory exhausted"));
384 xcalloc (unsigned int size
)
386 /* Make sure we don't allocate 0, for pre-ISO implementations. */
387 void *result
= calloc (size
? size
: 1, 1);
389 fatal (NILF
, _("virtual memory exhausted"));
395 xrealloc (void *ptr
, unsigned int size
)
399 /* Some older implementations of realloc() don't conform to ISO. */
402 result
= ptr
? realloc (ptr
, size
) : malloc (size
);
404 fatal (NILF
, _("virtual memory exhausted"));
410 xstrdup (const char *ptr
)
415 result
= strdup (ptr
);
417 result
= malloc (strlen (ptr
) + 1);
421 fatal (NILF
, _("virtual memory exhausted"));
426 return strcpy (result
, ptr
);
430 #endif /* HAVE_DMALLOC_H */
433 xstrndup (const char *str
, unsigned int length
)
438 result
= strndup (str
, length
);
440 fatal (NILF
, _("virtual memory exhausted"));
442 result
= xmalloc (length
+ 1);
444 strncpy (result
, str
, length
);
445 result
[length
] = '\0';
453 Search through the string STRING, which ends at LIMIT, for the character C.
454 Returns a pointer to the first occurrence, or nil if none is found.
455 Like INDEX except that the string searched ends where specified
456 instead of at the first null. */
459 lindex (const char *s
, const char *limit
, int c
)
463 return (char *)(s
- 1);
468 /* Return the address of the first whitespace or null in the string S. */
471 end_of_token (const char *s
)
473 while (*s
!= '\0' && !isblank ((unsigned char)*s
))
480 * Same as end_of_token, but take into account a stop character
483 end_of_token_w32 (const char *s
, char stopchar
)
488 while (*p
!= '\0' && *p
!= stopchar
489 && (backslash
|| !isblank ((unsigned char)*p
)))
493 backslash
= !backslash
;
496 backslash
= !backslash
;
508 /* Return the address of the first nonwhitespace or null in the string S. */
511 next_token (const char *s
)
513 while (isblank ((unsigned char)*s
))
518 /* Find the next token in PTR; return the address of it, and store the length
519 of the token into *LENGTHPTR if LENGTHPTR is not nil. Set *PTR to the end
520 of the token, so this function can be called repeatedly in a loop. */
523 find_next_token (const char **ptr
, unsigned int *lengthptr
)
525 const char *p
= next_token (*ptr
);
530 *ptr
= end_of_token (p
);
532 *lengthptr
= *ptr
- p
;
538 /* Copy a chain of 'struct dep'. For 2nd expansion deps, dup the name. */
541 copy_dep_chain (const struct dep
*d
)
543 struct dep
*firstnew
= 0;
544 struct dep
*lastnew
= 0;
548 struct dep
*c
= xmalloc (sizeof (struct dep
));
549 memcpy (c
, d
, sizeof (struct dep
));
551 if (c
->need_2nd_expansion
)
552 c
->name
= xstrdup (c
->name
);
556 firstnew
= lastnew
= c
;
558 lastnew
= lastnew
->next
= c
;
566 /* Free a chain of 'struct dep'. */
569 free_dep_chain (struct dep
*d
)
579 /* Free a chain of struct nameseq.
580 For struct dep chains use free_dep_chain. */
583 free_ns_chain (struct nameseq
*ns
)
587 struct nameseq
*t
= ns
;
594 #if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
596 /* If we don't have strcasecmp() (from POSIX), or anything that can substitute
597 for it, define our own version. */
600 strcasecmp (const char *s1
, const char *s2
)
604 int c1
= (int) *(s1
++);
605 int c2
= (int) *(s2
++);
612 if (c1
!= '\0' && c1
== c2
)
620 #if !HAVE_STRNCASECMP && !HAVE_STRNICMP && !HAVE_STRNCMPI
622 /* If we don't have strncasecmp() (from POSIX), or anything that can
623 substitute for it, define our own version. */
626 strncasecmp (const char *s1
, const char *s2
, int n
)
630 int c1
= (int) *(s1
++);
631 int c2
= (int) *(s2
++);
638 if (c1
!= '\0' && c1
== c2
)
648 #ifdef GETLOADAVG_PRIVILEGED
652 /* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
653 functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2,
654 for example) which claim to be POSIX.1 also have the BSD setreuid and
655 setregid functions, but they don't work as in BSD and only the POSIX.1
661 #else /* Not POSIX. */
663 /* Some POSIX.1 systems have the seteuid and setegid functions. In a
664 POSIX-like system, they are the best thing to use. However, some
665 non-POSIX systems have them too but they do not work in the POSIX style
666 and we must use setreuid and setregid instead. */
673 #ifndef HAVE_UNISTD_H
674 extern int getuid (), getgid (), geteuid (), getegid ();
675 extern int setuid (), setgid ();
677 extern int seteuid ();
680 extern int setreuid ();
681 #endif /* Have setreuid. */
682 #endif /* Have seteuid. */
684 extern int setegid ();
687 extern int setregid ();
688 #endif /* Have setregid. */
689 #endif /* Have setegid. */
690 #endif /* No <unistd.h>. */
692 /* Keep track of the user and group IDs for user- and make- access. */
693 static int user_uid
= -1, user_gid
= -1, make_uid
= -1, make_gid
= -1;
694 #define access_inited (user_uid != -1)
695 static enum { make
, user
} current_access
;
698 /* Under -d, write a message describing the current IDs. */
701 log_access (const char *flavor
)
703 if (! ISDB (DB_JOBS
))
706 /* All the other debugging messages go to stdout,
707 but we write this one to stderr because it might be
708 run in a child fork whose stdout is piped. */
710 fprintf (stderr
, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
711 flavor
, (unsigned long) geteuid (), (unsigned long) getuid (),
712 (unsigned long) getegid (), (unsigned long) getgid ());
721 user_uid
= getuid ();
722 user_gid
= getgid ();
724 make_uid
= geteuid ();
725 make_gid
= getegid ();
727 /* Do these ever fail? */
728 if (user_uid
== -1 || user_gid
== -1 || make_uid
== -1 || make_gid
== -1)
729 pfatal_with_name ("get{e}[gu]id");
731 log_access (_("Initialized access"));
733 current_access
= make
;
737 #endif /* GETLOADAVG_PRIVILEGED */
739 /* Give the process appropriate permissions for access to
740 user data (i.e., to stat files, or to spawn a child process). */
744 #ifdef GETLOADAVG_PRIVILEGED
749 if (current_access
== user
)
752 /* We are in "make access" mode. This means that the effective user and
753 group IDs are those of make (if it was installed setuid or setgid).
754 We now want to set the effective user and group IDs to the real IDs,
755 which are the IDs of the process that exec'd make. */
759 /* Modern systems have the seteuid/setegid calls which set only the
760 effective IDs, which is ideal. */
762 if (seteuid (user_uid
) < 0)
763 pfatal_with_name ("user_access: seteuid");
765 #else /* Not HAVE_SETEUID. */
767 #ifndef HAVE_SETREUID
769 /* System V has only the setuid/setgid calls to set user/group IDs.
770 There is an effective ID, which can be set by setuid/setgid.
771 It can be set (unless you are root) only to either what it already is
772 (returned by geteuid/getegid, now in make_uid/make_gid),
773 the real ID (return by getuid/getgid, now in user_uid/user_gid),
774 or the saved set ID (what the effective ID was before this set-ID
775 executable (make) was exec'd). */
777 if (setuid (user_uid
) < 0)
778 pfatal_with_name ("user_access: setuid");
780 #else /* HAVE_SETREUID. */
782 /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
783 They may be set to themselves or each other. So you have two alternatives
784 at any one time. If you use setuid/setgid, the effective will be set to
785 the real, leaving only one alternative. Using setreuid/setregid, however,
786 you can toggle between your two alternatives by swapping the values in a
787 single setreuid or setregid call. */
789 if (setreuid (make_uid
, user_uid
) < 0)
790 pfatal_with_name ("user_access: setreuid");
792 #endif /* Not HAVE_SETREUID. */
793 #endif /* HAVE_SETEUID. */
796 if (setegid (user_gid
) < 0)
797 pfatal_with_name ("user_access: setegid");
799 #ifndef HAVE_SETREGID
800 if (setgid (user_gid
) < 0)
801 pfatal_with_name ("user_access: setgid");
803 if (setregid (make_gid
, user_gid
) < 0)
804 pfatal_with_name ("user_access: setregid");
808 current_access
= user
;
810 log_access (_("User access"));
812 #endif /* GETLOADAVG_PRIVILEGED */
815 /* Give the process appropriate permissions for access to
816 make data (i.e., the load average). */
820 #ifdef GETLOADAVG_PRIVILEGED
825 if (current_access
== make
)
828 /* See comments in user_access, above. */
831 if (seteuid (make_uid
) < 0)
832 pfatal_with_name ("make_access: seteuid");
834 #ifndef HAVE_SETREUID
835 if (setuid (make_uid
) < 0)
836 pfatal_with_name ("make_access: setuid");
838 if (setreuid (user_uid
, make_uid
) < 0)
839 pfatal_with_name ("make_access: setreuid");
844 if (setegid (make_gid
) < 0)
845 pfatal_with_name ("make_access: setegid");
847 #ifndef HAVE_SETREGID
848 if (setgid (make_gid
) < 0)
849 pfatal_with_name ("make_access: setgid");
851 if (setregid (user_gid
, make_gid
) < 0)
852 pfatal_with_name ("make_access: setregid");
856 current_access
= make
;
858 log_access (_("Make access"));
860 #endif /* GETLOADAVG_PRIVILEGED */
863 /* Give the process appropriate permissions for a child process.
864 This is like user_access, but you can't get back to make_access. */
868 #ifdef GETLOADAVG_PRIVILEGED
873 /* Set both the real and effective UID and GID to the user's.
874 They cannot be changed back to make's. */
876 #ifndef HAVE_SETREUID
877 if (setuid (user_uid
) < 0)
878 pfatal_with_name ("child_access: setuid");
880 if (setreuid (user_uid
, user_uid
) < 0)
881 pfatal_with_name ("child_access: setreuid");
884 #ifndef HAVE_SETREGID
885 if (setgid (user_gid
) < 0)
886 pfatal_with_name ("child_access: setgid");
888 if (setregid (user_gid
, user_gid
) < 0)
889 pfatal_with_name ("child_access: setregid");
892 log_access (_("Child access"));
894 #endif /* GETLOADAVG_PRIVILEGED */
897 #ifdef NEED_GET_PATH_MAX
901 static unsigned int value
;
905 long int x
= pathconf ("/", _PC_PATH_MAX
);
917 /* This code is stolen from gnulib.
918 If/when we abandon the requirement to work with K&R compilers, we can
919 remove this (and perhaps other parts of GNU make!) and migrate to using
922 This is called only through atexit(), which means die() has already been
923 invoked. So, call exit() here directly. Apparently that works...?
926 /* Close standard output, exiting with status 'exit_failure' on failure.
927 If a program writes *anything* to stdout, that program should close
928 stdout and make sure that it succeeds before exiting. Otherwise,
929 suppose that you go to the extreme of checking the return status
930 of every function that does an explicit write to stdout. The last
931 printf can succeed in writing to the internal stream buffer, and yet
932 the fclose(stdout) could still fail (due e.g., to a disk full error)
933 when it tries to write out that buffered data. Thus, you would be
934 left with an incomplete output file and the offending program would
935 exit successfully. Even calling fflush is not always sufficient,
936 since some file systems (NFS and CODA) buffer written/flushed data
937 until an actual close call.
939 Besides, it's wasteful to check the return value from every call
940 that writes to stdout -- just let the internal stream state record
941 the failure. That's what the ferror test is checking below.
943 It's important to detect such failures and exit nonzero because many
944 tools (most notably 'make' and other build-management systems) depend
945 on being able to detect failure in other tools via their exit status. */
950 int prev_fail
= ferror (stdout
);
951 int fclose_fail
= fclose (stdout
);
953 if (prev_fail
|| fclose_fail
)
956 error (NILF
, _("write error: %s"), strerror (errno
));
958 error (NILF
, _("write error"));