update from main archive 960827
[kopensolaris-gnu/glibc.git] / sysdeps / generic / dl-sysdep.c
1 /* Operating system support for run-time dynamic linker.  Generic Unix version.
2 Copyright (C) 1995, 96 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 The GNU C Library 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 GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB.  If
17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
18 Cambridge, MA 02139, USA.  */
19
20 #include <elf.h>
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <sys/mman.h>
24 #include <fcntl.h>
25 #include <link.h>
26 #include <unistd.h>
27 #include <stdarg.h>
28 #include <string.h>
29
30
31 extern int _dl_argc;
32 extern char **_dl_argv;
33 extern char **_environ;
34 extern void _end;
35 extern void _start (void);
36
37 int __libc_enable_secure;
38 int __libc_multiple_libcs;      /* Defining this here avoids the inclusion
39                                    of init-first.  */
40
41 ElfW(Addr)
42 _dl_sysdep_start (void **start_argptr,
43                   void (*dl_main) (const ElfW(Phdr) *phdr, ElfW(Word) phnum,
44                                    ElfW(Addr) *user_entry))
45 {
46   const ElfW(Phdr) *phdr = NULL;
47   ElfW(Word) phnum = 0;
48   ElfW(Addr) user_entry;
49   ElfW(auxv_t) *av;
50   uid_t uid = 0;
51   uid_t euid = 0;
52   gid_t gid = 0;
53   gid_t egid = 0;
54   unsigned int seen;
55
56   user_entry = (ElfW(Addr)) &_start;
57   _dl_argc = *(long *) start_argptr;
58   _dl_argv = (char **) start_argptr + 1;
59   _environ = &_dl_argv[_dl_argc + 1];
60   start_argptr = (void **) _environ;
61   while (*start_argptr)
62     ++start_argptr;
63
64   seen = 0;
65 #define M(type) (1 << (type))
66
67   for (av = (void *) ++start_argptr;
68        av->a_type != AT_NULL;
69        seen |= M ((++av)->a_type))
70     switch (av->a_type)
71       {
72       case AT_PHDR:
73         phdr = av->a_un.a_ptr;
74         break;
75       case AT_PHNUM:
76         phnum = av->a_un.a_val;
77         break;
78       case AT_ENTRY:
79         user_entry = av->a_un.a_val;
80         break;
81       case AT_UID:
82         uid = av->a_un.a_val;
83         break;
84       case AT_GID:
85         gid = av->a_un.a_val;
86         break;
87       case AT_EUID:
88         euid = av->a_un.a_val;
89         break;
90       case AT_EGID:
91         egid = av->a_un.a_val;
92         break;
93       }
94
95   /* Linux doesn't provide us with any of these values on the stack
96      when the dynamic linker is run directly as a program.  */
97
98 #define SEE(UID, uid) if ((seen & M (AT_##UID)) == 0) uid = __get##uid ()
99   SEE (UID, uid);
100   SEE (GID, gid);
101   SEE (EUID, euid);
102   SEE (EGID, egid);
103
104
105   __libc_enable_secure = uid != euid || gid != egid;
106
107 #ifdef DL_SYSDEP_INIT
108   DL_SYSDEP_INIT;
109 #endif
110
111   if (__sbrk (0) == &_end)
112     {
113       /* The dynamic linker was run as a program, and so the initial break
114          starts just after our bss, at &_end.  The malloc in dl-minimal.c
115          will consume the rest of this page, so tell the kernel to move the
116          break up that far.  When the user program examines its break, it
117          will see this new value and not clobber our data.  */
118       size_t pg = __getpagesize ();
119
120       __sbrk (pg - ((&_end - (void *) 0) & (pg - 1)));
121     }
122
123   (*dl_main) (phdr, phnum, &user_entry);
124   return user_entry;
125 }
126
127 void
128 _dl_sysdep_start_cleanup (void)
129 {
130 }
131 \f
132 #ifndef MAP_ANON
133 /* This is only needed if the system doesn't support MAP_ANON.  */
134
135 int
136 _dl_sysdep_open_zero_fill (void)
137 {
138   return __open ("/dev/zero", O_RDONLY);
139 }
140 #endif
141
142 /* Read the whole contents of FILE into new mmap'd space with given
143    protections.  *SIZEP gets the size of the file.  */
144
145 void *
146 _dl_sysdep_read_whole_file (const char *file, size_t *sizep, int prot)
147 {
148   void *result;
149   struct stat st;
150   int fd = __open (file, O_RDONLY);
151   if (fd < 0)
152     return NULL;
153   if (__fstat (fd, &st) < 0)
154     result = NULL;
155   else
156     {
157       /* Map a copy of the file contents.  */
158       result = __mmap (0, st.st_size, prot,
159 #ifdef MAP_COPY
160                        MAP_COPY
161 #else
162                        MAP_PRIVATE
163 #endif
164 #ifdef MAP_FILE
165                        | MAP_FILE
166 #endif
167                        , fd, 0);
168       if (result == (void *) -1)
169         result = NULL;
170       else
171         *sizep = st.st_size;
172     }
173   __close (fd);
174   return result;
175 }
176
177 void
178 _dl_sysdep_fatal (const char *msg, ...)
179 {
180   va_list ap;
181
182   va_start (ap, msg);
183   do
184     {
185       size_t len = strlen (msg);
186       __write (STDERR_FILENO, msg, len);
187       msg = va_arg (ap, const char *);
188     } while (msg);
189   va_end (ap);
190
191   _exit (127);
192 }
193
194
195 void
196 _dl_sysdep_message (const char *msg, ...)
197 {
198   va_list ap;
199
200   va_start (ap, msg);
201   do
202     {
203       size_t len = strlen (msg);
204       __write (STDOUT_FILENO, msg, len);
205       msg = va_arg (ap, const char *);
206     } while (msg);
207   va_end (ap);
208 }