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 quoted, discard following whitespace
116 and any preceding whitespace; leave just one space. */
119 in
= next_token (in
);
120 while (out
> line
&& isblank ((unsigned char)out
[-1]))
125 /* If the newline isn't quoted, put it in the output. */
128 /* Now copy the following line to the output.
129 Stop when we find backslashes followed by a newline. */
151 /* Print N spaces (used in debug for target-depth). */
154 print_spaces (unsigned int n
)
161 /* Return a string whose contents concatenate those of s1, s2, s3.
162 This string lives in static, re-used memory. */
165 concat (const char *s1
, const char *s2
, const char *s3
)
167 unsigned int len1
, len2
, len3
;
168 static unsigned int rlen
= 0;
169 static char *result
= NULL
;
171 len1
= (s1
&& *s1
!= '\0') ? strlen (s1
) : 0;
172 len2
= (s2
&& *s2
!= '\0') ? strlen (s2
) : 0;
173 len3
= (s3
&& *s3
!= '\0') ? strlen (s3
) : 0;
175 if (len1
+ len2
+ len3
+ 1 > rlen
)
176 result
= xrealloc (result
, (rlen
= len1
+ len2
+ len3
+ 10));
179 memcpy (result
, s1
, len1
);
181 memcpy (result
+ len1
, s2
, len2
);
183 memcpy (result
+ len1
+ len2
, s3
, len3
);
185 result
[len1
+len2
+len3
] = '\0';
190 /* Print a message on stdout. */
193 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
194 message (int prefix
, const char *fmt
, ...)
196 message (prefix
, fmt
, va_alist
)
206 log_working_directory (1);
213 printf ("%s: ", program
);
215 printf ("%s[%u]: ", program
, makelevel
);
217 VA_START (args
, fmt
);
218 VA_PRINTF (stdout
, fmt
, args
);
226 /* Print an error message. */
229 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
230 error (const struct floc
*flocp
, const char *fmt
, ...)
232 error (flocp
, fmt
, va_alist
)
233 const struct floc
*flocp
;
242 log_working_directory (1);
244 if (flocp
&& flocp
->filenm
)
245 fprintf (stderr
, "%s:%lu: ", flocp
->filenm
, flocp
->lineno
);
246 else if (makelevel
== 0)
247 fprintf (stderr
, "%s: ", program
);
249 fprintf (stderr
, "%s[%u]: ", program
, makelevel
);
252 VA_PRINTF (stderr
, fmt
, args
);
259 /* Print an error message and exit. */
262 #if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
263 fatal (const struct floc
*flocp
, const char *fmt
, ...)
265 fatal (flocp
, fmt
, va_alist
)
266 const struct floc
*flocp
;
275 log_working_directory (1);
277 if (flocp
&& flocp
->filenm
)
278 fprintf (stderr
, "%s:%lu: *** ", flocp
->filenm
, flocp
->lineno
);
279 else if (makelevel
== 0)
280 fprintf (stderr
, "%s: *** ", program
);
282 fprintf (stderr
, "%s[%u]: *** ", program
, makelevel
);
285 VA_PRINTF (stderr
, fmt
, args
);
288 fputs (_(". Stop.\n"), stderr
);
293 #ifndef HAVE_STRERROR
298 strerror (int errnum
)
300 extern int errno
, sys_nerr
;
302 extern char *sys_errlist
[];
304 static char buf
[] = "Unknown error 12345678901234567890";
306 if (errno
< sys_nerr
)
307 return sys_errlist
[errnum
];
309 sprintf (buf
, _("Unknown error %d"), errnum
);
314 /* Print an error message from errno. */
317 perror_with_name (const char *str
, const char *name
)
319 error (NILF
, _("%s%s: %s"), str
, name
, strerror (errno
));
322 /* Print an error message from errno and exit. */
325 pfatal_with_name (const char *name
)
327 fatal (NILF
, _("%s: %s"), name
, strerror (errno
));
332 /* Like malloc but get fatal error if memory is exhausted. */
333 /* Don't bother if we're using dmalloc; it provides these for us. */
335 #ifndef HAVE_DMALLOC_H
342 xmalloc (unsigned int size
)
344 /* Make sure we don't allocate 0, for pre-ANSI libraries. */
345 void *result
= malloc (size
? size
: 1);
347 fatal (NILF
, _("virtual memory exhausted"));
353 xrealloc (void *ptr
, unsigned int size
)
357 /* Some older implementations of realloc() don't conform to ANSI. */
360 result
= ptr
? realloc (ptr
, size
) : malloc (size
);
362 fatal (NILF
, _("virtual memory exhausted"));
368 xstrdup (const char *ptr
)
373 result
= strdup (ptr
);
375 result
= malloc (strlen (ptr
) + 1);
379 fatal (NILF
, _("virtual memory exhausted"));
384 return strcpy (result
, ptr
);
388 #endif /* HAVE_DMALLOC_H */
391 savestring (const char *str
, unsigned int length
)
393 char *out
= xmalloc (length
+ 1);
395 memcpy (out
, str
, length
);
402 Search through the string STRING, which ends at LIMIT, for the character C.
403 Returns a pointer to the first occurrence, or nil if none is found.
404 Like INDEX except that the string searched ends where specified
405 instead of at the first null. */
408 lindex (const char *s
, const char *limit
, int c
)
412 return (char *)(s
- 1);
417 /* Return the address of the first whitespace or null in the string S. */
420 end_of_token (const char *s
)
422 while (*s
!= '\0' && !isblank ((unsigned char)*s
))
429 * Same as end_of_token, but take into account a stop character
432 end_of_token_w32 (const char *s
, char stopchar
)
437 while (*p
!= '\0' && *p
!= stopchar
438 && (backslash
|| !isblank ((unsigned char)*p
)))
442 backslash
= !backslash
;
445 backslash
= !backslash
;
457 /* Return the address of the first nonwhitespace or null in the string S. */
460 next_token (const char *s
)
462 while (isblank ((unsigned char)*s
))
467 /* Find the next token in PTR; return the address of it, and store the length
468 of the token into *LENGTHPTR if LENGTHPTR is not nil. Set *PTR to the end
469 of the token, so this function can be called repeatedly in a loop. */
472 find_next_token (const char **ptr
, unsigned int *lengthptr
)
474 const char *p
= next_token (*ptr
);
479 *ptr
= end_of_token (p
);
481 *lengthptr
= *ptr
- p
;
487 /* Allocate a new `struct dep' with all fields initialized to 0. */
492 struct dep
*d
= xmalloc (sizeof (struct dep
));
493 memset (d
, '\0', sizeof (struct dep
));
498 /* Free `struct dep' along with `name' and `stem'. */
501 free_dep (struct dep
*d
)
506 /* Copy a chain of `struct dep', making a new chain
507 with the same contents as the old one. */
510 copy_dep_chain (const struct dep
*d
)
512 struct dep
*firstnew
= 0;
513 struct dep
*lastnew
= 0;
517 struct dep
*c
= xmalloc (sizeof (struct dep
));
518 memcpy (c
, d
, sizeof (struct dep
));
522 firstnew
= lastnew
= c
;
524 lastnew
= lastnew
->next
= c
;
532 /* Free a chain of 'struct dep'. */
535 free_dep_chain (struct dep
*d
)
545 /* Free a chain of struct nameseq.
546 For struct dep chains use free_dep_chain. */
549 free_ns_chain (struct nameseq
*ns
)
553 struct nameseq
*t
= ns
;
560 #if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
562 /* If we don't have strcasecmp() (from POSIX), or anything that can substitute
563 for it, define our own version. */
566 strcasecmp (const char *s1
, const char *s2
)
570 int c1
= (int) *(s1
++);
571 int c2
= (int) *(s2
++);
578 if (c1
!= '\0' && c1
== c2
)
586 #ifdef GETLOADAVG_PRIVILEGED
590 /* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
591 functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2,
592 for example) which claim to be POSIX.1 also have the BSD setreuid and
593 setregid functions, but they don't work as in BSD and only the POSIX.1
599 #else /* Not POSIX. */
601 /* Some POSIX.1 systems have the seteuid and setegid functions. In a
602 POSIX-like system, they are the best thing to use. However, some
603 non-POSIX systems have them too but they do not work in the POSIX style
604 and we must use setreuid and setregid instead. */
611 #ifndef HAVE_UNISTD_H
612 extern int getuid (), getgid (), geteuid (), getegid ();
613 extern int setuid (), setgid ();
615 extern int seteuid ();
618 extern int setreuid ();
619 #endif /* Have setreuid. */
620 #endif /* Have seteuid. */
622 extern int setegid ();
625 extern int setregid ();
626 #endif /* Have setregid. */
627 #endif /* Have setegid. */
628 #endif /* No <unistd.h>. */
630 /* Keep track of the user and group IDs for user- and make- access. */
631 static int user_uid
= -1, user_gid
= -1, make_uid
= -1, make_gid
= -1;
632 #define access_inited (user_uid != -1)
633 static enum { make
, user
} current_access
;
636 /* Under -d, write a message describing the current IDs. */
639 log_access (const char *flavor
)
641 if (! ISDB (DB_JOBS
))
644 /* All the other debugging messages go to stdout,
645 but we write this one to stderr because it might be
646 run in a child fork whose stdout is piped. */
648 fprintf (stderr
, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
649 flavor
, (unsigned long) geteuid (), (unsigned long) getuid (),
650 (unsigned long) getegid (), (unsigned long) getgid ());
659 user_uid
= getuid ();
660 user_gid
= getgid ();
662 make_uid
= geteuid ();
663 make_gid
= getegid ();
665 /* Do these ever fail? */
666 if (user_uid
== -1 || user_gid
== -1 || make_uid
== -1 || make_gid
== -1)
667 pfatal_with_name ("get{e}[gu]id");
669 log_access (_("Initialized access"));
671 current_access
= make
;
675 #endif /* GETLOADAVG_PRIVILEGED */
677 /* Give the process appropriate permissions for access to
678 user data (i.e., to stat files, or to spawn a child process). */
682 #ifdef GETLOADAVG_PRIVILEGED
687 if (current_access
== user
)
690 /* We are in "make access" mode. This means that the effective user and
691 group IDs are those of make (if it was installed setuid or setgid).
692 We now want to set the effective user and group IDs to the real IDs,
693 which are the IDs of the process that exec'd make. */
697 /* Modern systems have the seteuid/setegid calls which set only the
698 effective IDs, which is ideal. */
700 if (seteuid (user_uid
) < 0)
701 pfatal_with_name ("user_access: seteuid");
703 #else /* Not HAVE_SETEUID. */
705 #ifndef HAVE_SETREUID
707 /* System V has only the setuid/setgid calls to set user/group IDs.
708 There is an effective ID, which can be set by setuid/setgid.
709 It can be set (unless you are root) only to either what it already is
710 (returned by geteuid/getegid, now in make_uid/make_gid),
711 the real ID (return by getuid/getgid, now in user_uid/user_gid),
712 or the saved set ID (what the effective ID was before this set-ID
713 executable (make) was exec'd). */
715 if (setuid (user_uid
) < 0)
716 pfatal_with_name ("user_access: setuid");
718 #else /* HAVE_SETREUID. */
720 /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
721 They may be set to themselves or each other. So you have two alternatives
722 at any one time. If you use setuid/setgid, the effective will be set to
723 the real, leaving only one alternative. Using setreuid/setregid, however,
724 you can toggle between your two alternatives by swapping the values in a
725 single setreuid or setregid call. */
727 if (setreuid (make_uid
, user_uid
) < 0)
728 pfatal_with_name ("user_access: setreuid");
730 #endif /* Not HAVE_SETREUID. */
731 #endif /* HAVE_SETEUID. */
734 if (setegid (user_gid
) < 0)
735 pfatal_with_name ("user_access: setegid");
737 #ifndef HAVE_SETREGID
738 if (setgid (user_gid
) < 0)
739 pfatal_with_name ("user_access: setgid");
741 if (setregid (make_gid
, user_gid
) < 0)
742 pfatal_with_name ("user_access: setregid");
746 current_access
= user
;
748 log_access (_("User access"));
750 #endif /* GETLOADAVG_PRIVILEGED */
753 /* Give the process appropriate permissions for access to
754 make data (i.e., the load average). */
758 #ifdef GETLOADAVG_PRIVILEGED
763 if (current_access
== make
)
766 /* See comments in user_access, above. */
769 if (seteuid (make_uid
) < 0)
770 pfatal_with_name ("make_access: seteuid");
772 #ifndef HAVE_SETREUID
773 if (setuid (make_uid
) < 0)
774 pfatal_with_name ("make_access: setuid");
776 if (setreuid (user_uid
, make_uid
) < 0)
777 pfatal_with_name ("make_access: setreuid");
782 if (setegid (make_gid
) < 0)
783 pfatal_with_name ("make_access: setegid");
785 #ifndef HAVE_SETREGID
786 if (setgid (make_gid
) < 0)
787 pfatal_with_name ("make_access: setgid");
789 if (setregid (user_gid
, make_gid
) < 0)
790 pfatal_with_name ("make_access: setregid");
794 current_access
= make
;
796 log_access (_("Make access"));
798 #endif /* GETLOADAVG_PRIVILEGED */
801 /* Give the process appropriate permissions for a child process.
802 This is like user_access, but you can't get back to make_access. */
806 #ifdef GETLOADAVG_PRIVILEGED
811 /* Set both the real and effective UID and GID to the user's.
812 They cannot be changed back to make's. */
814 #ifndef HAVE_SETREUID
815 if (setuid (user_uid
) < 0)
816 pfatal_with_name ("child_access: setuid");
818 if (setreuid (user_uid
, user_uid
) < 0)
819 pfatal_with_name ("child_access: setreuid");
822 #ifndef HAVE_SETREGID
823 if (setgid (user_gid
) < 0)
824 pfatal_with_name ("child_access: setgid");
826 if (setregid (user_gid
, user_gid
) < 0)
827 pfatal_with_name ("child_access: setregid");
830 log_access (_("Child access"));
832 #endif /* GETLOADAVG_PRIVILEGED */
835 #ifdef NEED_GET_PATH_MAX
839 static unsigned int value
;
843 long int x
= pathconf ("/", _PC_PATH_MAX
);
855 /* This code is stolen from gnulib.
856 If/when we abandon the requirement to work with K&R compilers, we can
857 remove this (and perhaps other parts of GNU make!) and migrate to using
860 This is called only through atexit(), which means die() has already been
861 invoked. So, call exit() here directly. Apparently that works...?
864 /* Close standard output, exiting with status 'exit_failure' on failure.
865 If a program writes *anything* to stdout, that program should close
866 stdout and make sure that it succeeds before exiting. Otherwise,
867 suppose that you go to the extreme of checking the return status
868 of every function that does an explicit write to stdout. The last
869 printf can succeed in writing to the internal stream buffer, and yet
870 the fclose(stdout) could still fail (due e.g., to a disk full error)
871 when it tries to write out that buffered data. Thus, you would be
872 left with an incomplete output file and the offending program would
873 exit successfully. Even calling fflush is not always sufficient,
874 since some file systems (NFS and CODA) buffer written/flushed data
875 until an actual close call.
877 Besides, it's wasteful to check the return value from every call
878 that writes to stdout -- just let the internal stream state record
879 the failure. That's what the ferror test is checking below.
881 It's important to detect such failures and exit nonzero because many
882 tools (most notably `make' and other build-management systems) depend
883 on being able to detect failure in other tools via their exit status. */
888 int prev_fail
= ferror (stdout
);
889 int fclose_fail
= fclose (stdout
);
891 if (prev_fail
|| fclose_fail
)
894 error (NILF
, _("write error: %s"), strerror (errno
));
896 error (NILF
, _("write error"));