stdlib.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533
  1. #include <AK/String.h>
  2. #include <AK/Assertions.h>
  3. #include <AK/HashMap.h>
  4. #include <AK/StdLibExtras.h>
  5. #include <AK/Types.h>
  6. #include <Kernel/Syscall.h>
  7. #include <alloca.h>
  8. #include <assert.h>
  9. #include <ctype.h>
  10. #include <errno.h>
  11. #include <signal.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <sys/mman.h>
  16. #include <sys/stat.h>
  17. #include <sys/wait.h>
  18. #include <unistd.h>
  19. extern "C" {
  20. typedef void (*__atexit_handler)();
  21. static int __atexit_handler_count = 0;
  22. static __atexit_handler __atexit_handlers[32];
  23. void exit(int status)
  24. {
  25. for (int i = 0; i < __atexit_handler_count; ++i)
  26. __atexit_handlers[i]();
  27. extern void _fini();
  28. _fini();
  29. fflush(stdout);
  30. fflush(stderr);
  31. _exit(status);
  32. ASSERT_NOT_REACHED();
  33. }
  34. int atexit(void (*handler)())
  35. {
  36. ASSERT(__atexit_handler_count < 32);
  37. __atexit_handlers[__atexit_handler_count++] = handler;
  38. return 0;
  39. }
  40. void abort()
  41. {
  42. raise(SIGABRT);
  43. ASSERT_NOT_REACHED();
  44. }
  45. static HashTable<const char*> s_malloced_environment_variables;
  46. static void free_environment_variable_if_needed(const char* var)
  47. {
  48. if (!s_malloced_environment_variables.contains(var))
  49. return;
  50. free(const_cast<char*>(var));
  51. s_malloced_environment_variables.remove(var);
  52. }
  53. char* getenv(const char* name)
  54. {
  55. size_t vl = strlen(name);
  56. for (size_t i = 0; environ[i]; ++i) {
  57. const char* decl = environ[i];
  58. char* eq = strchr(decl, '=');
  59. if (!eq)
  60. continue;
  61. size_t varLength = eq - decl;
  62. if (vl != varLength)
  63. continue;
  64. if (strncmp(decl, name, varLength) == 0) {
  65. return eq + 1;
  66. }
  67. }
  68. return nullptr;
  69. }
  70. int unsetenv(const char* name)
  71. {
  72. auto new_var_len = strlen(name);
  73. size_t environ_size = 0;
  74. int skip = -1;
  75. for (; environ[environ_size]; ++environ_size) {
  76. char* old_var = environ[environ_size];
  77. char* old_eq = strchr(old_var, '=');
  78. ASSERT(old_eq);
  79. size_t old_var_len = old_eq - old_var;
  80. if (new_var_len != old_var_len)
  81. continue; // can't match
  82. if (strncmp(name, old_var, new_var_len) == 0)
  83. skip = environ_size;
  84. }
  85. if (skip == -1)
  86. return 0; // not found: no failure.
  87. // Shuffle the existing array down by one.
  88. memmove(&environ[skip], &environ[skip + 1], ((environ_size - 1) - skip) * sizeof(environ[0]));
  89. environ[environ_size - 1] = nullptr;
  90. free_environment_variable_if_needed(name);
  91. return 0;
  92. }
  93. int setenv(const char* name, const char* value, int overwrite)
  94. {
  95. if (!overwrite && !getenv(name))
  96. return 0;
  97. auto length = strlen(name) + strlen(value) + 2;
  98. auto* var = (char*)malloc(length);
  99. snprintf(var, length, "%s=%s", name, value);
  100. s_malloced_environment_variables.set(var);
  101. return putenv(var);
  102. }
  103. int putenv(char* new_var)
  104. {
  105. char* new_eq = strchr(new_var, '=');
  106. if (!new_eq)
  107. return unsetenv(new_var);
  108. auto new_var_len = new_eq - new_var;
  109. int environ_size = 0;
  110. for (; environ[environ_size]; ++environ_size) {
  111. char* old_var = environ[environ_size];
  112. char* old_eq = strchr(old_var, '=');
  113. ASSERT(old_eq);
  114. auto old_var_len = old_eq - old_var;
  115. if (new_var_len != old_var_len)
  116. continue; // can't match
  117. if (strncmp(new_var, old_var, new_var_len) == 0) {
  118. free_environment_variable_if_needed(old_var);
  119. environ[environ_size] = new_var;
  120. return 0;
  121. }
  122. }
  123. // At this point, we need to append the new var.
  124. // 2 here: one for the new var, one for the sentinel value.
  125. char** new_environ = (char**)malloc((environ_size + 2) * sizeof(char*));
  126. if (new_environ == nullptr) {
  127. errno = ENOMEM;
  128. return -1;
  129. }
  130. for (int i = 0; environ[i]; ++i) {
  131. new_environ[i] = environ[i];
  132. }
  133. new_environ[environ_size] = new_var;
  134. new_environ[environ_size + 1] = nullptr;
  135. // swap new and old
  136. // note that the initial environ is not heap allocated!
  137. extern bool __environ_is_malloced;
  138. if (__environ_is_malloced)
  139. free(environ);
  140. __environ_is_malloced = true;
  141. environ = new_environ;
  142. return 0;
  143. }
  144. }
  145. double strtod(const char* str, char** endptr)
  146. {
  147. (void)str;
  148. (void)endptr;
  149. dbgprintf("LibC: strtod: '%s'\n", str);
  150. ASSERT_NOT_REACHED();
  151. }
  152. long double strtold(const char* str, char** endptr)
  153. {
  154. (void)str;
  155. (void)endptr;
  156. dbgprintf("LibC: strtold: '%s'\n", str);
  157. ASSERT_NOT_REACHED();
  158. }
  159. float strtof(const char* str, char** endptr)
  160. {
  161. (void)str;
  162. (void)endptr;
  163. dbgprintf("LibC: strtof: '%s'\n", str);
  164. ASSERT_NOT_REACHED();
  165. }
  166. double atof(const char* str)
  167. {
  168. dbgprintf("LibC: atof: '%s'\n", str);
  169. ASSERT_NOT_REACHED();
  170. }
  171. int atoi(const char* str)
  172. {
  173. size_t len = strlen(str);
  174. int value = 0;
  175. bool isNegative = false;
  176. for (size_t i = 0; i < len; ++i) {
  177. if (i == 0 && str[0] == '-') {
  178. isNegative = true;
  179. continue;
  180. }
  181. if (str[i] < '0' || str[i] > '9')
  182. return value;
  183. value = value * 10;
  184. value += str[i] - '0';
  185. }
  186. return isNegative ? -value : value;
  187. }
  188. long atol(const char* str)
  189. {
  190. static_assert(sizeof(int) == sizeof(long));
  191. return atoi(str);
  192. }
  193. long long atoll(const char* str)
  194. {
  195. dbgprintf("FIXME(Libc): atoll('%s') passing through to atol()\n", str);
  196. return atol(str);
  197. }
  198. static char ptsname_buf[32];
  199. char* ptsname(int fd)
  200. {
  201. if (ptsname_r(fd, ptsname_buf, sizeof(ptsname_buf)) < 0)
  202. return nullptr;
  203. return ptsname_buf;
  204. }
  205. int ptsname_r(int fd, char* buffer, size_t size)
  206. {
  207. int rc = syscall(SC_ptsname_r, fd, buffer, size);
  208. __RETURN_WITH_ERRNO(rc, rc, -1);
  209. }
  210. static unsigned long s_next_rand = 1;
  211. int rand()
  212. {
  213. s_next_rand = s_next_rand * 1103515245 + 12345;
  214. return ((unsigned)(s_next_rand / ((RAND_MAX + 1) * 2)) % (RAND_MAX + 1));
  215. }
  216. void srand(unsigned seed)
  217. {
  218. s_next_rand = seed;
  219. }
  220. int abs(int i)
  221. {
  222. return i < 0 ? -i : i;
  223. }
  224. long int random()
  225. {
  226. return rand();
  227. }
  228. void srandom(unsigned seed)
  229. {
  230. srand(seed);
  231. }
  232. int system(const char* command)
  233. {
  234. if (!command)
  235. return 1;
  236. auto child = fork();
  237. if (child < 0)
  238. return -1;
  239. if (!child) {
  240. int rc = execl("/bin/sh", "sh", "-c", command, nullptr);
  241. ASSERT(rc < 0);
  242. perror("execl");
  243. exit(127);
  244. }
  245. int wstatus;
  246. waitpid(child, &wstatus, 0);
  247. return WEXITSTATUS(wstatus);
  248. }
  249. char* mktemp(char* pattern)
  250. {
  251. int length = strlen(pattern);
  252. if (length < 6 || !String(pattern).ends_with("XXXXXX")) {
  253. pattern[0] = '\0';
  254. errno = EINVAL;
  255. return pattern;
  256. }
  257. int start = length - 6;
  258. static constexpr char random_characters[] = "abcdefghijklmnopqrstuvwxyz0123456789";
  259. for (int attempt = 0; attempt < 100; ++attempt) {
  260. for (int i = 0; i < 6; ++i)
  261. pattern[start + i] = random_characters[(rand() % sizeof(random_characters))];
  262. struct stat st;
  263. int rc = lstat(pattern, &st);
  264. if (rc < 0 && errno == ENOENT)
  265. return pattern;
  266. }
  267. pattern[0] = '\0';
  268. errno = EEXIST;
  269. return pattern;
  270. }
  271. char* mkdtemp(char* pattern)
  272. {
  273. int length = strlen(pattern);
  274. if (length < 6 || !String(pattern).ends_with("XXXXXX")) {
  275. errno = EINVAL;
  276. return nullptr;
  277. }
  278. int start = length - 6;
  279. static constexpr char random_characters[] = "abcdefghijklmnopqrstuvwxyz0123456789";
  280. for (int attempt = 0; attempt < 100; ++attempt) {
  281. for (int i = 0; i < 6; ++i)
  282. pattern[start + i] = random_characters[(rand() % sizeof(random_characters))];
  283. struct stat st;
  284. int rc = lstat(pattern, &st);
  285. if (rc < 0 && errno == ENOENT) {
  286. if (mkdir(pattern, 0700) < 0)
  287. return nullptr;
  288. return pattern;
  289. }
  290. }
  291. errno = EEXIST;
  292. return nullptr;
  293. }
  294. void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*))
  295. {
  296. dbgprintf("FIXME(LibC): bsearch(%p, %p, %u, %u, %p)\n", key, base, nmemb, size, compar);
  297. ASSERT_NOT_REACHED();
  298. }
  299. div_t div(int numerator, int denominator)
  300. {
  301. div_t result;
  302. result.quot = numerator / denominator;
  303. result.rem = numerator % denominator;
  304. if (numerator >= 0 && result.rem < 0) {
  305. result.quot++;
  306. result.rem -= denominator;
  307. }
  308. return result;
  309. }
  310. ldiv_t ldiv(long numerator, long denominator)
  311. {
  312. ldiv_t result;
  313. result.quot = numerator / denominator;
  314. result.rem = numerator % denominator;
  315. if (numerator >= 0 && result.rem < 0) {
  316. result.quot++;
  317. result.rem -= denominator;
  318. }
  319. return result;
  320. }
  321. size_t mbstowcs(wchar_t*, const char*, size_t)
  322. {
  323. ASSERT_NOT_REACHED();
  324. }
  325. size_t mbtowc(wchar_t*, const char*, size_t)
  326. {
  327. ASSERT_NOT_REACHED();
  328. }
  329. int wctomb(char*, wchar_t)
  330. {
  331. ASSERT_NOT_REACHED();
  332. }
  333. template<typename T, T min_value, T max_value>
  334. static T strtol_impl(const char* nptr, char** endptr, int base)
  335. {
  336. errno = 0;
  337. if (base < 0 || base == 1 || base > 36) {
  338. errno = EINVAL;
  339. if (endptr)
  340. *endptr = const_cast<char*>(nptr);
  341. return 0;
  342. }
  343. const char* p = nptr;
  344. while (isspace(*p))
  345. ++p;
  346. bool is_negative = false;
  347. if (*p == '-') {
  348. is_negative = true;
  349. ++p;
  350. } else {
  351. if (*p == '+')
  352. ++p;
  353. }
  354. if (base == 0 || base == 16) {
  355. if (base == 0)
  356. base = 10;
  357. if (*p == '0') {
  358. if (*(p + 1) == 'X' || *(p + 1) == 'x') {
  359. p += 2;
  360. base = 16;
  361. } else if (base != 16) {
  362. base = 8;
  363. }
  364. }
  365. }
  366. long cutoff_point = is_negative ? (min_value / base) : (max_value / base);
  367. int max_valid_digit_at_cutoff_point = is_negative ? (min_value % base) : (max_value % base);
  368. long num = 0;
  369. bool has_overflowed = false;
  370. unsigned digits_consumed = 0;
  371. for (;;) {
  372. char ch = *(p++);
  373. int digit;
  374. if (isdigit(ch))
  375. digit = ch - '0';
  376. else if (islower(ch))
  377. digit = ch - ('a' - 10);
  378. else if (isupper(ch))
  379. digit = ch - ('A' - 10);
  380. else
  381. break;
  382. if (digit >= base)
  383. break;
  384. if (has_overflowed)
  385. continue;
  386. bool is_past_cutoff = is_negative ? num < cutoff_point : num > cutoff_point;
  387. if (is_past_cutoff || (num == cutoff_point && digit > max_valid_digit_at_cutoff_point)) {
  388. has_overflowed = true;
  389. num = is_negative ? min_value : max_value;
  390. errno = ERANGE;
  391. } else {
  392. num *= base;
  393. num += is_negative ? -digit : digit;
  394. ++digits_consumed;
  395. }
  396. }
  397. if (endptr) {
  398. if (has_overflowed || digits_consumed > 0)
  399. *endptr = const_cast<char*>(p - 1);
  400. else
  401. *endptr = const_cast<char*>(nptr);
  402. }
  403. return num;
  404. }
  405. long strtol(const char* str, char** endptr, int base)
  406. {
  407. return strtol_impl<long, LONG_MIN, LONG_MAX>(str, endptr, base);
  408. }
  409. unsigned long strtoul(const char* str, char** endptr, int base)
  410. {
  411. auto value = strtol(str, endptr, base);
  412. ASSERT(value >= 0);
  413. return value;
  414. }
  415. long long strtoll(const char* str, char** endptr, int base)
  416. {
  417. return strtol_impl<long long, LONG_LONG_MIN, LONG_LONG_MAX>(str, endptr, base);
  418. }
  419. unsigned long long strtoull(const char* str, char** endptr, int base)
  420. {
  421. auto value = strtoll(str, endptr, base);
  422. ASSERT(value >= 0);
  423. return value;
  424. }
  425. // Serenity's PRNG is not cryptographically secure. Do not rely on this for
  426. // any real crypto! These functions (for now) are for compatibility.
  427. // TODO: In the future, rand can be made determinstic and this not.
  428. uint32_t arc4random(void)
  429. {
  430. char buf[4];
  431. // XXX: RandomDevice does return a uint32_t but the syscall works with
  432. // a byte at a time. It could be better optimzied for this use case
  433. // while remaining generic.
  434. syscall(SC_getrandom, buf, 4, 0);
  435. return *(uint32_t*)buf;
  436. }
  437. void arc4random_buf(void* buffer, size_t buffer_size)
  438. {
  439. // arc4random_buf should never fail, but user supplied buffers could fail.
  440. // However, if the user passes a garbage buffer, that's on them.
  441. syscall(SC_getrandom, buffer, buffer_size, 0);
  442. }
  443. uint32_t arc4random_uniform(uint32_t max_bounds)
  444. {
  445. // XXX: Should actually apply special rules for uniformity; avoid what is
  446. // called "modulo bias".
  447. return arc4random() % max_bounds;
  448. }