stdio.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622
  1. #include <AK/LogStream.h>
  2. #include <AK/PrintfImplementation.h>
  3. #include <AK/ScopedValueRollback.h>
  4. #include <AK/StdLibExtras.h>
  5. #include <Kernel/Syscall.h>
  6. #include <assert.h>
  7. #include <errno.h>
  8. #include <fcntl.h>
  9. #include <stdarg.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <sys/types.h>
  14. #include <unistd.h>
  15. extern "C" {
  16. static FILE __default_streams[4];
  17. FILE* stdin;
  18. FILE* stdout;
  19. FILE* stderr;
  20. void init_FILE(FILE& fp, int fd, int mode)
  21. {
  22. fp.fd = fd;
  23. fp.buffer = fp.default_buffer;
  24. fp.buffer_size = BUFSIZ;
  25. fp.mode = mode;
  26. }
  27. static FILE* make_FILE(int fd)
  28. {
  29. auto* fp = (FILE*)malloc(sizeof(FILE));
  30. memset(fp, 0, sizeof(FILE));
  31. init_FILE(*fp, fd, isatty(fd));
  32. return fp;
  33. }
  34. void __stdio_init()
  35. {
  36. stdin = &__default_streams[0];
  37. stdout = &__default_streams[1];
  38. stderr = &__default_streams[2];
  39. init_FILE(*stdin, 0, isatty(0) ? _IOLBF : _IOFBF);
  40. init_FILE(*stdout, 1, isatty(1) ? _IOLBF : _IOFBF);
  41. init_FILE(*stderr, 2, _IONBF);
  42. }
  43. int setvbuf(FILE* stream, char* buf, int mode, size_t size)
  44. {
  45. if (mode != _IONBF && mode != _IOLBF && mode != _IOFBF) {
  46. errno = EINVAL;
  47. return -1;
  48. }
  49. stream->mode = mode;
  50. if (buf) {
  51. stream->buffer = buf;
  52. stream->buffer_size = size;
  53. } else {
  54. stream->buffer = stream->default_buffer;
  55. stream->buffer_size = BUFSIZ;
  56. }
  57. stream->buffer_index = 0;
  58. return 0;
  59. }
  60. void setbuf(FILE* stream, char* buf)
  61. {
  62. setvbuf(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
  63. }
  64. void setlinebuf(FILE* stream)
  65. {
  66. setvbuf(stream, nullptr, _IOLBF, 0);
  67. }
  68. int fileno(FILE* stream)
  69. {
  70. assert(stream);
  71. return stream->fd;
  72. }
  73. int feof(FILE* stream)
  74. {
  75. assert(stream);
  76. return stream->eof;
  77. }
  78. int fflush(FILE* stream)
  79. {
  80. // FIXME: fflush(NULL) should flush all open output streams.
  81. ASSERT(stream);
  82. if (!stream->buffer_index)
  83. return 0;
  84. int rc = write(stream->fd, stream->buffer, stream->buffer_index);
  85. stream->buffer_index = 0;
  86. stream->error = 0;
  87. stream->eof = 0;
  88. stream->have_ungotten = false;
  89. stream->ungotten = 0;
  90. if (rc < 0) {
  91. stream->error = errno;
  92. return EOF;
  93. }
  94. return 0;
  95. }
  96. char* fgets(char* buffer, int size, FILE* stream)
  97. {
  98. ASSERT(stream);
  99. ASSERT(size);
  100. ssize_t nread = 0;
  101. while (nread < (size - 1)) {
  102. int ch = fgetc(stream);
  103. if (ch == EOF)
  104. break;
  105. buffer[nread++] = ch;
  106. if (ch == '\n')
  107. break;
  108. }
  109. if (nread) {
  110. buffer[nread] = '\0';
  111. return buffer;
  112. }
  113. return nullptr;
  114. }
  115. int fgetc(FILE* stream)
  116. {
  117. assert(stream);
  118. char ch;
  119. size_t nread = fread(&ch, sizeof(char), 1, stream);
  120. if (nread == 1)
  121. return ch;
  122. return EOF;
  123. }
  124. int getc(FILE* stream)
  125. {
  126. return fgetc(stream);
  127. }
  128. int getchar()
  129. {
  130. return getc(stdin);
  131. }
  132. ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream)
  133. {
  134. char *ptr, *eptr;
  135. if (*lineptr == nullptr || *n == 0) {
  136. *n = BUFSIZ;
  137. if ((*lineptr = static_cast<char*>(malloc(*n))) == nullptr) {
  138. return -1;
  139. }
  140. }
  141. for (ptr = *lineptr, eptr = *lineptr + *n;;) {
  142. int c = fgetc(stream);
  143. if (c == -1) {
  144. if (feof(stream)) {
  145. return ptr == *lineptr ? -1 : ptr - *lineptr;
  146. } else {
  147. return -1;
  148. }
  149. }
  150. *ptr++ = c;
  151. if (c == delim) {
  152. *ptr = '\0';
  153. return ptr - *lineptr;
  154. }
  155. if (ptr + 2 >= eptr) {
  156. char *nbuf;
  157. size_t nbuf_sz = *n * 2;
  158. ssize_t d = ptr - *lineptr;
  159. if ((nbuf = static_cast<char*>(realloc(*lineptr, nbuf_sz))) == nullptr) {
  160. return -1;
  161. }
  162. *lineptr = nbuf;
  163. *n = nbuf_sz;
  164. eptr = nbuf + nbuf_sz;
  165. ptr = nbuf + d;
  166. }
  167. }
  168. }
  169. ssize_t getline(char **lineptr, size_t *n, FILE *stream)
  170. {
  171. return getdelim(lineptr, n, '\n', stream);
  172. }
  173. int ungetc(int c, FILE* stream)
  174. {
  175. ASSERT(stream);
  176. if (c == EOF)
  177. return EOF;
  178. if (stream->have_ungotten)
  179. return EOF;
  180. stream->have_ungotten = true;
  181. stream->ungotten = c;
  182. stream->eof = false;
  183. return c;
  184. }
  185. int fputc(int ch, FILE* stream)
  186. {
  187. assert(stream);
  188. assert(stream->buffer_index < stream->buffer_size);
  189. stream->buffer[stream->buffer_index++] = ch;
  190. if (stream->buffer_index >= stream->buffer_size)
  191. fflush(stream);
  192. else if (stream->mode == _IONBF || (stream->mode == _IOLBF && ch == '\n'))
  193. fflush(stream);
  194. if (stream->eof || stream->error)
  195. return EOF;
  196. return (u8)ch;
  197. }
  198. int putc(int ch, FILE* stream)
  199. {
  200. return fputc(ch, stream);
  201. }
  202. int putchar(int ch)
  203. {
  204. return putc(ch, stdout);
  205. }
  206. int fputs(const char* s, FILE* stream)
  207. {
  208. for (; *s; ++s) {
  209. int rc = putc(*s, stream);
  210. if (rc == EOF)
  211. return EOF;
  212. }
  213. return 1;
  214. }
  215. int puts(const char* s)
  216. {
  217. int rc = fputs(s, stdout);
  218. if (rc == EOF)
  219. return EOF;
  220. return fputc('\n', stdout);
  221. }
  222. void clearerr(FILE* stream)
  223. {
  224. assert(stream);
  225. stream->eof = false;
  226. stream->error = 0;
  227. }
  228. int ferror(FILE* stream)
  229. {
  230. return stream->error;
  231. }
  232. size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream)
  233. {
  234. assert(stream);
  235. if (!size)
  236. return 0;
  237. ssize_t nread = 0;
  238. if (stream->have_ungotten) {
  239. // FIXME: Support ungotten character even if size != 1.
  240. ASSERT(size == 1);
  241. ((char*)ptr)[0] = stream->ungotten;
  242. stream->have_ungotten = false;
  243. --nmemb;
  244. if (!nmemb)
  245. return 1;
  246. ptr = &((char*)ptr)[1];
  247. ++nread;
  248. }
  249. ssize_t rc = read(stream->fd, ptr, nmemb * size);
  250. if (rc < 0) {
  251. stream->error = errno;
  252. return 0;
  253. }
  254. if (rc == 0)
  255. stream->eof = true;
  256. nread += rc;
  257. return nread / size;
  258. }
  259. size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream)
  260. {
  261. assert(stream);
  262. auto* bytes = (const u8*)ptr;
  263. ssize_t nwritten = 0;
  264. for (size_t i = 0; i < (size * nmemb); ++i) {
  265. int rc = fputc(bytes[i], stream);
  266. if (rc == EOF)
  267. break;
  268. ++nwritten;
  269. }
  270. return nwritten / size;
  271. }
  272. int fseek(FILE* stream, long offset, int whence)
  273. {
  274. assert(stream);
  275. fflush(stream);
  276. off_t off = lseek(stream->fd, offset, whence);
  277. if (off < 0)
  278. return off;
  279. stream->eof = false;
  280. stream->error = 0;
  281. stream->have_ungotten = false;
  282. stream->ungotten = 0;
  283. return 0;
  284. }
  285. long ftell(FILE* stream)
  286. {
  287. assert(stream);
  288. fflush(stream);
  289. return lseek(stream->fd, 0, SEEK_CUR);
  290. }
  291. void rewind(FILE* stream)
  292. {
  293. ASSERT(stream);
  294. int rc = fseek(stream, 0, SEEK_SET);
  295. ASSERT(rc == 0);
  296. }
  297. int dbgprintf(const char* fmt, ...)
  298. {
  299. va_list ap;
  300. va_start(ap, fmt);
  301. int ret = printf_internal([](char*&, char ch) { dbgputch(ch); }, nullptr, fmt, ap);
  302. va_end(ap);
  303. return ret;
  304. }
  305. static void stdout_putch(char*&, char ch)
  306. {
  307. putchar(ch);
  308. }
  309. static FILE* __current_stream = nullptr;
  310. static void stream_putch(char*&, char ch)
  311. {
  312. fputc(ch, __current_stream);
  313. }
  314. int vfprintf(FILE* stream, const char* fmt, va_list ap)
  315. {
  316. __current_stream = stream;
  317. return printf_internal(stream_putch, nullptr, fmt, ap);
  318. }
  319. int fprintf(FILE* stream, const char* fmt, ...)
  320. {
  321. va_list ap;
  322. va_start(ap, fmt);
  323. int ret = vfprintf(stream, fmt, ap);
  324. va_end(ap);
  325. return ret;
  326. }
  327. int vprintf(const char* fmt, va_list ap)
  328. {
  329. return printf_internal(stdout_putch, nullptr, fmt, ap);
  330. }
  331. int printf(const char* fmt, ...)
  332. {
  333. va_list ap;
  334. va_start(ap, fmt);
  335. int ret = vprintf(fmt, ap);
  336. va_end(ap);
  337. return ret;
  338. }
  339. static void buffer_putch(char*& bufptr, char ch)
  340. {
  341. *bufptr++ = ch;
  342. }
  343. int vsprintf(char* buffer, const char* fmt, va_list ap)
  344. {
  345. int ret = printf_internal(buffer_putch, buffer, fmt, ap);
  346. buffer[ret] = '\0';
  347. return ret;
  348. }
  349. int sprintf(char* buffer, const char* fmt, ...)
  350. {
  351. va_list ap;
  352. va_start(ap, fmt);
  353. int ret = vsprintf(buffer, fmt, ap);
  354. va_end(ap);
  355. return ret;
  356. }
  357. static size_t __vsnprintf_space_remaining;
  358. static void sized_buffer_putch(char*& bufptr, char ch)
  359. {
  360. if (__vsnprintf_space_remaining) {
  361. *bufptr++ = ch;
  362. --__vsnprintf_space_remaining;
  363. }
  364. }
  365. int vsnprintf(char* buffer, size_t size, const char* fmt, va_list ap)
  366. {
  367. __vsnprintf_space_remaining = size;
  368. int ret = printf_internal(sized_buffer_putch, buffer, fmt, ap);
  369. if (__vsnprintf_space_remaining) {
  370. buffer[ret] = '\0';
  371. }
  372. return ret;
  373. }
  374. int snprintf(char* buffer, size_t size, const char* fmt, ...)
  375. {
  376. va_list ap;
  377. va_start(ap, fmt);
  378. int ret = vsnprintf(buffer, size, fmt, ap);
  379. va_end(ap);
  380. return ret;
  381. }
  382. void perror(const char* s)
  383. {
  384. int saved_errno = errno;
  385. dbg() << "perror(): " << s << ": " << strerror(saved_errno);
  386. fprintf(stderr, "%s: %s\n", s, strerror(saved_errno));
  387. }
  388. FILE* fopen(const char* pathname, const char* mode)
  389. {
  390. int flags = 0;
  391. if (!strcmp(mode, "r") || !strcmp(mode, "rb"))
  392. flags = O_RDONLY;
  393. else if (!strcmp(mode, "r+") || !strcmp(mode, "rb+"))
  394. flags = O_RDWR;
  395. else if (!strcmp(mode, "w") || !strcmp(mode, "wb"))
  396. flags = O_WRONLY | O_CREAT | O_TRUNC;
  397. else if (!strcmp(mode, "w+") || !strcmp(mode, "wb+"))
  398. flags = O_RDWR | O_CREAT | O_TRUNC;
  399. else {
  400. fprintf(stderr, "FIXME(LibC): fopen('%s', '%s')\n", pathname, mode);
  401. ASSERT_NOT_REACHED();
  402. }
  403. int fd = open(pathname, flags, 0666);
  404. if (fd < 0)
  405. return nullptr;
  406. return make_FILE(fd);
  407. }
  408. FILE* freopen(const char* pathname, const char* mode, FILE* stream)
  409. {
  410. (void)pathname;
  411. (void)mode;
  412. (void)stream;
  413. ASSERT_NOT_REACHED();
  414. }
  415. FILE* fdopen(int fd, const char* mode)
  416. {
  417. UNUSED_PARAM(mode);
  418. // FIXME: Verify that the mode matches how fd is already open.
  419. if (fd < 0)
  420. return nullptr;
  421. return make_FILE(fd);
  422. }
  423. int fclose(FILE* stream)
  424. {
  425. fflush(stream);
  426. int rc = close(stream->fd);
  427. if (stream != &__default_streams[0] && stream != &__default_streams[1] && stream != &__default_streams[2] && stream != &__default_streams[3])
  428. free(stream);
  429. return rc;
  430. }
  431. int rename(const char* oldpath, const char* newpath)
  432. {
  433. int rc = syscall(SC_rename, oldpath, newpath);
  434. __RETURN_WITH_ERRNO(rc, rc, -1);
  435. }
  436. void dbgputch(char ch)
  437. {
  438. syscall(SC_dbgputch, ch);
  439. }
  440. int dbgputstr(const char* characters, int length)
  441. {
  442. int rc = syscall(SC_dbgputstr, characters, length);
  443. __RETURN_WITH_ERRNO(rc, rc, -1);
  444. }
  445. char* tmpnam(char*)
  446. {
  447. ASSERT_NOT_REACHED();
  448. }
  449. FILE* popen(const char* command, const char* type)
  450. {
  451. if (!type || (*type != 'r' && *type != 'w')) {
  452. errno = EINVAL;
  453. return nullptr;
  454. }
  455. int pipe_fds[2];
  456. int rc = pipe(pipe_fds);
  457. if (rc < 0) {
  458. ScopedValueRollback rollback(errno);
  459. perror("pipe");
  460. return nullptr;
  461. }
  462. pid_t child_pid = fork();
  463. if (!child_pid) {
  464. if (*type == 'r') {
  465. int rc = dup2(pipe_fds[1], STDOUT_FILENO);
  466. if (rc < 0) {
  467. perror("dup2");
  468. exit(1);
  469. }
  470. close(pipe_fds[0]);
  471. close(pipe_fds[1]);
  472. } else if (*type == 'w') {
  473. int rc = dup2(pipe_fds[0], STDIN_FILENO);
  474. if (rc < 0) {
  475. perror("dup2");
  476. exit(1);
  477. }
  478. close(pipe_fds[0]);
  479. close(pipe_fds[1]);
  480. }
  481. int rc = execl("/bin/sh", "sh", "-c", command, nullptr);
  482. if (rc < 0)
  483. perror("execl");
  484. exit(1);
  485. }
  486. FILE* fp = nullptr;
  487. if (*type == 'r') {
  488. fp = make_FILE(pipe_fds[0]);
  489. close(pipe_fds[1]);
  490. } else if (*type == 'w') {
  491. fp = make_FILE(pipe_fds[1]);
  492. close(pipe_fds[0]);
  493. }
  494. fp->popen_child = child_pid;
  495. return fp;
  496. }
  497. int pclose(FILE* fp)
  498. {
  499. ASSERT(fp);
  500. ASSERT(fp->popen_child != 0);
  501. int wstatus = 0;
  502. int rc = waitpid(fp->popen_child, &wstatus, 0);
  503. if (rc < 0)
  504. return rc;
  505. return wstatus;
  506. }
  507. int remove(const char* pathname)
  508. {
  509. int rc = unlink(pathname);
  510. if (rc < 0 && errno != EISDIR)
  511. return -1;
  512. return rmdir(pathname);
  513. }
  514. int scanf(const char* fmt, ...)
  515. {
  516. va_list ap;
  517. va_start(ap, fmt);
  518. int count = vfscanf(stdin, fmt, ap);
  519. va_end(ap);
  520. return count;
  521. }
  522. int fscanf(FILE* stream, const char* fmt, ...)
  523. {
  524. va_list ap;
  525. va_start(ap, fmt);
  526. int count = vfscanf(stream, fmt, ap);
  527. va_end(ap);
  528. return count;
  529. }
  530. int sscanf(const char* buffer, const char* fmt, ...)
  531. {
  532. va_list ap;
  533. va_start(ap, fmt);
  534. int count = vsscanf(buffer, fmt, ap);
  535. va_end(ap);
  536. return count;
  537. }
  538. int vfscanf(FILE* stream, const char* fmt, va_list ap)
  539. {
  540. char buffer[BUFSIZ];
  541. if (!fgets(buffer, sizeof(buffer) - 1, stream))
  542. return -1;
  543. return vsscanf(buffer, fmt, ap);
  544. }
  545. FILE* tmpfile()
  546. {
  547. dbgprintf("FIXME: Implement tmpfile()\n");
  548. ASSERT_NOT_REACHED();
  549. }
  550. }