__uClibc_main.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294
  1. /*
  2. * Manuel Novoa III Feb 2001
  3. * Erik Andersen 2002-2004
  4. *
  5. * __uClibc_main is the routine to be called by all the arch-specific
  6. * versions of crt1.S in uClibc.
  7. *
  8. * It is meant to handle any special initialization needed by the library
  9. * such as setting the global variable(s) __environ (environ) and
  10. * initializing the stdio package. Using weak symbols, the latter is
  11. * avoided in the static library case.
  12. */
  13. #define _ERRNO_H
  14. #include <features.h>
  15. #include <unistd.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #include <elf.h>
  19. #include <link.h>
  20. #include <bits/uClibc_page.h>
  21. #include <paths.h>
  22. #include <unistd.h>
  23. #include <asm/errno.h>
  24. #include <fcntl.h>
  25. #include <sys/stat.h>
  26. #include <sys/sysmacros.h>
  27. #ifdef __UCLIBC_HAS_SSP__
  28. #include <ssp-internal.h>
  29. #include <stdint.h>
  30. /* for gcc-4.1 non-TLS */
  31. uintptr_t __stack_chk_guard attribute_relro;
  32. /* for gcc-3.x + Etoh ssp */
  33. strong_alias(__stack_chk_guard,__guard)
  34. #endif
  35. /*
  36. * Prototypes.
  37. */
  38. extern void *__libc_stack_end;
  39. extern void weak_function _stdio_init(void);
  40. extern int *weak_const_function __errno_location(void);
  41. extern int *weak_const_function __h_errno_location(void);
  42. #ifdef __UCLIBC_HAS_LOCALE__
  43. extern void weak_function _locale_init(void);
  44. #endif
  45. #ifdef __UCLIBC_HAS_THREADS__
  46. extern void weak_function __pthread_initialize_minimal(void);
  47. #endif
  48. /*
  49. * Declare the __environ global variable and create a weak alias environ.
  50. * Note: Apparently we must initialize __environ to ensure that the weak
  51. * environ symbol is also included.
  52. */
  53. char **__environ = 0;
  54. weak_alias(__environ, environ);
  55. size_t __pagesize = 0;
  56. const char *__progname = 0;
  57. #ifndef O_NOFOLLOW
  58. # define O_NOFOLLOW 0
  59. #endif
  60. extern int __libc_fcntl(int fd, int cmd, ...);
  61. extern int __libc_open(const char *file, int flags, ...);
  62. static void __check_one_fd(int fd, int mode)
  63. {
  64. /* Check if the specified fd is already open */
  65. if (unlikely(__libc_fcntl(fd, F_GETFD)==-1 && *(__errno_location())==EBADF))
  66. {
  67. /* The descriptor is probably not open, so try to use /dev/null */
  68. struct stat st;
  69. int nullfd = __libc_open(_PATH_DEVNULL, mode);
  70. /* /dev/null is major=1 minor=3. Make absolutely certain
  71. * that is in fact the device that we have opened and not
  72. * some other wierd file... */
  73. if ( (nullfd!=fd) || fstat(fd, &st) || !S_ISCHR(st.st_mode) ||
  74. (st.st_rdev != makedev(1, 3)))
  75. {
  76. /* Somebody is trying some trickery here... */
  77. while (1) {
  78. abort();
  79. }
  80. }
  81. }
  82. }
  83. static int __check_suid(void)
  84. {
  85. uid_t uid, euid;
  86. gid_t gid, egid;
  87. uid = getuid();
  88. euid = geteuid();
  89. gid = getgid();
  90. egid = getegid();
  91. if(uid == euid && gid == egid) {
  92. return 0;
  93. }
  94. return 1;
  95. }
  96. #ifdef __UCLIBC_HAS_SSP__
  97. static __always_inline uintptr_t _dl_guard_setup(void)
  98. {
  99. uintptr_t ret;
  100. #ifndef __SSP_QUICK_CANARY__
  101. {
  102. int fd = OPEN("/dev/urandom", O_RDONLY);
  103. if (fd >= 0) {
  104. size_t size = READ(fd, &ret, sizeof(ret));
  105. CLOSE(fd);
  106. if (size == (size_t) sizeof(ret))
  107. return ret;
  108. }
  109. }
  110. #endif /* ifndef __SSP_QUICK_CANARY__ */
  111. /* Start with the "terminator canary". */
  112. ret = 0xFF0A0D00UL;
  113. /* Everything failed? Or we are using a weakened model of the
  114. * terminator canary */
  115. {
  116. struct timeval tv;
  117. if (GETTIMEOFDAY(&tv, NULL) != (-1))
  118. ret ^= tv.tv_usec ^ tv.tv_sec;
  119. }
  120. return ret;
  121. }
  122. #endif /* __UCLIBC_HAS_SSP__ */
  123. /* __uClibc_init completely initialize uClibc so it is ready to use.
  124. *
  125. * On ELF systems (with a dynamic loader) this function must be called
  126. * from the dynamic loader (see TIS and ELF Specification), so that
  127. * constructors of shared libraries (which depend on libc) can use all
  128. * the libc code without restriction. For this we link the shared
  129. * version of the uClibc with -init __uClibc_init so DT_INIT for
  130. * uClibc is the address of __uClibc_init
  131. *
  132. * In all other cases we call it from the main stub
  133. * __uClibc_main.
  134. */
  135. void __uClibc_init(void)
  136. {
  137. static int been_there_done_that = 0;
  138. if (been_there_done_that)
  139. return;
  140. been_there_done_that++;
  141. /* Setup an initial value. This may not be perfect, but is
  142. * better than malloc using __pagesize=0 for atexit, ctors, etc. */
  143. __pagesize = PAGE_SIZE;
  144. #ifdef __UCLIBC_HAS_THREADS__
  145. /* Before we start initializing uClibc we have to call
  146. * __pthread_initialize_minimal so we can use pthread_locks
  147. * whenever they are needed.
  148. */
  149. if (likely(__pthread_initialize_minimal!=NULL))
  150. __pthread_initialize_minimal();
  151. #endif
  152. #ifdef __UCLIBC_HAS_SSP__
  153. uintptr_t stack_chk_guard = _dl_guard_setup();
  154. /* for gcc-4.1 non-TLS */
  155. __stack_chk_guard = stack_chk_guard;
  156. #endif
  157. #ifdef __UCLIBC_HAS_LOCALE__
  158. /* Initialize the global locale structure. */
  159. if (likely(_locale_init!=NULL))
  160. _locale_init();
  161. #endif
  162. /*
  163. * Initialize stdio here. In the static library case, this will
  164. * be bypassed if not needed because of the weak alias above.
  165. */
  166. if (likely(_stdio_init != NULL))
  167. _stdio_init();
  168. }
  169. #ifdef __UCLIBC_CTOR_DTOR__
  170. void attribute_hidden (*__app_fini)(void) = NULL;
  171. #endif
  172. void attribute_hidden (*__rtld_fini)(void) = NULL;
  173. /* __uClibc_main is the new main stub for uClibc. This function is
  174. * called from crt1 (version 0.9.28 or newer), after ALL shared libraries
  175. * are initialized, just before we call the application's main function.
  176. */
  177. void __attribute__ ((__noreturn__))
  178. __uClibc_main(int (*main)(int, char **, char **), int argc,
  179. char **argv, void (*app_init)(void), void (*app_fini)(void),
  180. void (*rtld_fini)(void), void *stack_end)
  181. {
  182. #ifdef __ARCH_HAS_MMU__
  183. unsigned long *aux_dat;
  184. ElfW(auxv_t) auxvt[AT_EGID + 1];
  185. #endif
  186. __libc_stack_end = stack_end;
  187. __rtld_fini = rtld_fini;
  188. /* The environment begins right after argv. */
  189. __environ = &argv[argc + 1];
  190. /* If the first thing after argv is the arguments
  191. * the the environment is empty. */
  192. if ((char *) __environ == *argv) {
  193. /* Make __environ point to the NULL at argv[argc] */
  194. __environ = &argv[argc];
  195. }
  196. /* Pull stuff from the ELF header when possible */
  197. #ifdef __ARCH_HAS_MMU__
  198. aux_dat = (unsigned long*)__environ;
  199. while (*aux_dat) {
  200. aux_dat++;
  201. }
  202. aux_dat++;
  203. while (*aux_dat) {
  204. ElfW(auxv_t) *auxv_entry = (ElfW(auxv_t) *) aux_dat;
  205. if (auxv_entry->a_type <= AT_EGID) {
  206. memcpy(&(auxvt[auxv_entry->a_type]), auxv_entry, sizeof(ElfW(auxv_t)));
  207. }
  208. aux_dat += 2;
  209. }
  210. /* We need to initialize uClibc. If we are dynamically linked this
  211. * may have already been completed by the shared lib loader. We call
  212. * __uClibc_init() regardless, to be sure the right thing happens. */
  213. __uClibc_init();
  214. /* Make certain getpagesize() gives the correct answer */
  215. __pagesize = (auxvt[AT_PAGESZ].a_un.a_val)? auxvt[AT_PAGESZ].a_un.a_val : PAGE_SIZE;
  216. /* Prevent starting SUID binaries where the stdin. stdout, and
  217. * stderr file descriptors are not already opened. */
  218. if ((auxvt[AT_UID].a_un.a_val==-1 && __check_suid()) ||
  219. (auxvt[AT_UID].a_un.a_val != -1 &&
  220. (auxvt[AT_UID].a_un.a_val != auxvt[AT_EUID].a_un.a_val ||
  221. auxvt[AT_GID].a_un.a_val != auxvt[AT_EGID].a_un.a_val)))
  222. {
  223. __check_one_fd (STDIN_FILENO, O_RDONLY | O_NOFOLLOW);
  224. __check_one_fd (STDOUT_FILENO, O_RDWR | O_NOFOLLOW);
  225. __check_one_fd (STDERR_FILENO, O_RDWR | O_NOFOLLOW);
  226. }
  227. #endif
  228. __progname = *argv;
  229. #ifdef __UCLIBC_CTOR_DTOR__
  230. /* Arrange for the application's dtors to run before we exit. */
  231. __app_fini = app_fini;
  232. /* Run all the application's ctors now. */
  233. if (app_init!=NULL) {
  234. app_init();
  235. }
  236. #endif
  237. /* Note: It is possible that any initialization done above could
  238. * have resulted in errno being set nonzero, so set it to 0 before
  239. * we call main.
  240. */
  241. if (likely(__errno_location!=NULL))
  242. *(__errno_location()) = 0;
  243. /* Set h_errno to 0 as well */
  244. if (likely(__h_errno_location!=NULL))
  245. *(__h_errno_location()) = 0;
  246. /*
  247. * Finally, invoke application's main and then exit.
  248. */
  249. exit(main(argc, argv, __environ));
  250. }