stdio.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618
  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. if (rc < 0) {
  89. stream->error = errno;
  90. return EOF;
  91. }
  92. return 0;
  93. }
  94. char* fgets(char* buffer, int size, FILE* stream)
  95. {
  96. assert(stream);
  97. ssize_t nread = 0;
  98. for (;;) {
  99. if (nread >= size)
  100. break;
  101. int ch = fgetc(stream);
  102. if (ch == EOF) {
  103. if (nread == 0)
  104. return nullptr;
  105. break;
  106. }
  107. buffer[nread++] = ch;
  108. if (!ch || ch == '\n')
  109. break;
  110. }
  111. if (nread < size)
  112. buffer[nread] = '\0';
  113. return buffer;
  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 (stream->have_ungotten)
  177. return EOF;
  178. stream->have_ungotten = true;
  179. stream->ungotten = c;
  180. stream->eof = false;
  181. return c;
  182. }
  183. int fputc(int ch, FILE* stream)
  184. {
  185. assert(stream);
  186. assert(stream->buffer_index < stream->buffer_size);
  187. stream->buffer[stream->buffer_index++] = ch;
  188. if (stream->buffer_index >= stream->buffer_size)
  189. fflush(stream);
  190. else if (stream->mode == _IONBF || (stream->mode == _IOLBF && ch == '\n'))
  191. fflush(stream);
  192. if (stream->eof || stream->error)
  193. return EOF;
  194. return (u8)ch;
  195. }
  196. int putc(int ch, FILE* stream)
  197. {
  198. return fputc(ch, stream);
  199. }
  200. int putchar(int ch)
  201. {
  202. return putc(ch, stdout);
  203. }
  204. int fputs(const char* s, FILE* stream)
  205. {
  206. for (; *s; ++s) {
  207. int rc = putc(*s, stream);
  208. if (rc == EOF)
  209. return EOF;
  210. }
  211. return 1;
  212. }
  213. int puts(const char* s)
  214. {
  215. int rc = fputs(s, stdout);
  216. if (rc == EOF)
  217. return EOF;
  218. return fputc('\n', stdout);
  219. }
  220. void clearerr(FILE* stream)
  221. {
  222. assert(stream);
  223. stream->eof = false;
  224. stream->error = 0;
  225. }
  226. int ferror(FILE* stream)
  227. {
  228. return stream->error;
  229. }
  230. size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream)
  231. {
  232. assert(stream);
  233. if (!size)
  234. return 0;
  235. ssize_t nread = 0;
  236. if (stream->have_ungotten) {
  237. // FIXME: Support ungotten character even if size != 1.
  238. ASSERT(size == 1);
  239. ((char*)ptr)[0] = stream->ungotten;
  240. stream->have_ungotten = false;
  241. --nmemb;
  242. if (!nmemb)
  243. return 1;
  244. ptr = &((char*)ptr)[1];
  245. ++nread;
  246. }
  247. ssize_t rc = read(stream->fd, ptr, nmemb * size);
  248. if (rc < 0) {
  249. stream->error = errno;
  250. return 0;
  251. }
  252. if (rc == 0)
  253. stream->eof = true;
  254. nread += rc;
  255. return nread / size;
  256. }
  257. size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream)
  258. {
  259. assert(stream);
  260. auto* bytes = (const u8*)ptr;
  261. ssize_t nwritten = 0;
  262. for (size_t i = 0; i < (size * nmemb); ++i) {
  263. int rc = fputc(bytes[i], stream);
  264. if (rc == EOF)
  265. break;
  266. ++nwritten;
  267. }
  268. return nwritten / size;
  269. }
  270. int fseek(FILE* stream, long offset, int whence)
  271. {
  272. assert(stream);
  273. fflush(stream);
  274. off_t off = lseek(stream->fd, offset, whence);
  275. if (off < 0)
  276. return off;
  277. stream->eof = false;
  278. stream->error = 0;
  279. stream->have_ungotten = false;
  280. stream->ungotten = 0;
  281. return 0;
  282. }
  283. long ftell(FILE* stream)
  284. {
  285. assert(stream);
  286. fflush(stream);
  287. return lseek(stream->fd, 0, SEEK_CUR);
  288. }
  289. void rewind(FILE* stream)
  290. {
  291. fseek(stream, 0, SEEK_SET);
  292. }
  293. int dbgprintf(const char* fmt, ...)
  294. {
  295. va_list ap;
  296. va_start(ap, fmt);
  297. int ret = printf_internal([](char*&, char ch) { dbgputch(ch); }, nullptr, fmt, ap);
  298. va_end(ap);
  299. return ret;
  300. }
  301. static void stdout_putch(char*&, char ch)
  302. {
  303. putchar(ch);
  304. }
  305. static FILE* __current_stream = nullptr;
  306. static void stream_putch(char*&, char ch)
  307. {
  308. fputc(ch, __current_stream);
  309. }
  310. int vfprintf(FILE* stream, const char* fmt, va_list ap)
  311. {
  312. __current_stream = stream;
  313. return printf_internal(stream_putch, nullptr, fmt, ap);
  314. }
  315. int fprintf(FILE* stream, const char* fmt, ...)
  316. {
  317. va_list ap;
  318. va_start(ap, fmt);
  319. int ret = vfprintf(stream, fmt, ap);
  320. va_end(ap);
  321. return ret;
  322. }
  323. int vprintf(const char* fmt, va_list ap)
  324. {
  325. return printf_internal(stdout_putch, nullptr, fmt, ap);
  326. }
  327. int printf(const char* fmt, ...)
  328. {
  329. va_list ap;
  330. va_start(ap, fmt);
  331. int ret = vprintf(fmt, ap);
  332. va_end(ap);
  333. return ret;
  334. }
  335. static void buffer_putch(char*& bufptr, char ch)
  336. {
  337. *bufptr++ = ch;
  338. }
  339. int vsprintf(char* buffer, const char* fmt, va_list ap)
  340. {
  341. int ret = printf_internal(buffer_putch, buffer, fmt, ap);
  342. buffer[ret] = '\0';
  343. return ret;
  344. }
  345. int sprintf(char* buffer, const char* fmt, ...)
  346. {
  347. va_list ap;
  348. va_start(ap, fmt);
  349. int ret = vsprintf(buffer, fmt, ap);
  350. buffer[ret] = '\0';
  351. va_end(ap);
  352. return ret;
  353. }
  354. static size_t __vsnprintf_space_remaining;
  355. static void sized_buffer_putch(char*& bufptr, char ch)
  356. {
  357. if (__vsnprintf_space_remaining) {
  358. *bufptr++ = ch;
  359. --__vsnprintf_space_remaining;
  360. }
  361. }
  362. int vsnprintf(char* buffer, size_t size, const char* fmt, va_list ap)
  363. {
  364. __vsnprintf_space_remaining = size;
  365. int ret = printf_internal(sized_buffer_putch, buffer, fmt, ap);
  366. buffer[ret] = '\0';
  367. return ret;
  368. }
  369. int snprintf(char* buffer, size_t size, const char* fmt, ...)
  370. {
  371. va_list ap;
  372. va_start(ap, fmt);
  373. int ret = vsnprintf(buffer, size, fmt, ap);
  374. buffer[ret] = '\0';
  375. va_end(ap);
  376. return ret;
  377. }
  378. void perror(const char* s)
  379. {
  380. int saved_errno = errno;
  381. dbg() << "perror(): " << strerror(saved_errno);
  382. fprintf(stderr, "%s: %s\n", s, strerror(saved_errno));
  383. }
  384. FILE* fopen(const char* pathname, const char* mode)
  385. {
  386. int flags = 0;
  387. if (!strcmp(mode, "r") || !strcmp(mode, "rb"))
  388. flags = O_RDONLY;
  389. else if (!strcmp(mode, "r+") || !strcmp(mode, "rb+"))
  390. flags = O_RDWR;
  391. else if (!strcmp(mode, "w") || !strcmp(mode, "wb"))
  392. flags = O_WRONLY | O_CREAT | O_TRUNC;
  393. else if (!strcmp(mode, "w+") || !strcmp(mode, "wb+"))
  394. flags = O_RDWR | O_CREAT | O_TRUNC;
  395. else {
  396. fprintf(stderr, "FIXME(LibC): fopen('%s', '%s')\n", pathname, mode);
  397. ASSERT_NOT_REACHED();
  398. }
  399. int fd = open(pathname, flags, 0666);
  400. if (fd < 0)
  401. return nullptr;
  402. return make_FILE(fd);
  403. }
  404. FILE* freopen(const char* pathname, const char* mode, FILE* stream)
  405. {
  406. (void)pathname;
  407. (void)mode;
  408. (void)stream;
  409. ASSERT_NOT_REACHED();
  410. }
  411. FILE* fdopen(int fd, const char* mode)
  412. {
  413. UNUSED_PARAM(mode);
  414. // FIXME: Verify that the mode matches how fd is already open.
  415. if (fd < 0)
  416. return nullptr;
  417. return make_FILE(fd);
  418. }
  419. int fclose(FILE* stream)
  420. {
  421. fflush(stream);
  422. int rc = close(stream->fd);
  423. if (stream != &__default_streams[0] && stream != &__default_streams[1] && stream != &__default_streams[2] && stream != &__default_streams[3])
  424. free(stream);
  425. return rc;
  426. }
  427. int rename(const char* oldpath, const char* newpath)
  428. {
  429. int rc = syscall(SC_rename, oldpath, newpath);
  430. __RETURN_WITH_ERRNO(rc, rc, -1);
  431. }
  432. void dbgputch(char ch)
  433. {
  434. syscall(SC_dbgputch, ch);
  435. }
  436. int dbgputstr(const char* characters, int length)
  437. {
  438. int rc = syscall(SC_dbgputstr, characters, length);
  439. __RETURN_WITH_ERRNO(rc, rc, -1);
  440. }
  441. char* tmpnam(char*)
  442. {
  443. ASSERT_NOT_REACHED();
  444. }
  445. FILE* popen(const char* command, const char* type)
  446. {
  447. if (!type || (*type != 'r' && *type != 'w')) {
  448. errno = EINVAL;
  449. return nullptr;
  450. }
  451. int pipe_fds[2];
  452. int rc = pipe(pipe_fds);
  453. if (rc < 0) {
  454. ScopedValueRollback rollback(errno);
  455. perror("pipe");
  456. return nullptr;
  457. }
  458. pid_t child_pid = fork();
  459. if (!child_pid) {
  460. if (*type == 'r') {
  461. int rc = dup2(pipe_fds[1], STDOUT_FILENO);
  462. if (rc < 0) {
  463. perror("dup2");
  464. exit(1);
  465. }
  466. close(pipe_fds[0]);
  467. close(pipe_fds[1]);
  468. } else if (*type == 'w') {
  469. int rc = dup2(pipe_fds[0], STDIN_FILENO);
  470. if (rc < 0) {
  471. perror("dup2");
  472. exit(1);
  473. }
  474. close(pipe_fds[0]);
  475. close(pipe_fds[1]);
  476. }
  477. int rc = execl("/bin/sh", "sh", "-c", command, nullptr);
  478. if (rc < 0)
  479. perror("execl");
  480. exit(1);
  481. }
  482. FILE* fp = nullptr;
  483. if (*type == 'r') {
  484. fp = make_FILE(pipe_fds[0]);
  485. close(pipe_fds[1]);
  486. } else if (*type == 'w') {
  487. fp = make_FILE(pipe_fds[1]);
  488. close(pipe_fds[0]);
  489. }
  490. fp->popen_child = child_pid;
  491. return fp;
  492. }
  493. int pclose(FILE* fp)
  494. {
  495. ASSERT(fp);
  496. ASSERT(fp->popen_child != 0);
  497. int wstatus = 0;
  498. int rc = waitpid(fp->popen_child, &wstatus, 0);
  499. if (rc < 0)
  500. return rc;
  501. return wstatus;
  502. }
  503. int remove(const char* pathname)
  504. {
  505. int rc = unlink(pathname);
  506. if (rc < 0 && errno != EISDIR)
  507. return -1;
  508. return rmdir(pathname);
  509. }
  510. int scanf(const char* fmt, ...)
  511. {
  512. va_list ap;
  513. va_start(ap, fmt);
  514. int count = vfscanf(stdin, fmt, ap);
  515. va_end(ap);
  516. return count;
  517. }
  518. int fscanf(FILE* stream, const char* fmt, ...)
  519. {
  520. va_list ap;
  521. va_start(ap, fmt);
  522. int count = vfscanf(stream, fmt, ap);
  523. va_end(ap);
  524. return count;
  525. }
  526. int sscanf(const char* buffer, const char* fmt, ...)
  527. {
  528. va_list ap;
  529. va_start(ap, fmt);
  530. int count = vsscanf(buffer, fmt, ap);
  531. va_end(ap);
  532. return count;
  533. }
  534. int vfscanf(FILE* stream, const char* fmt, va_list ap)
  535. {
  536. char buffer[BUFSIZ];
  537. if (!fgets(buffer, sizeof(buffer) - 1, stream))
  538. return -1;
  539. return vsscanf(buffer, fmt, ap);
  540. }
  541. FILE* tmpfile()
  542. {
  543. dbgprintf("FIXME: Implement tmpfile()\n");
  544. ASSERT_NOT_REACHED();
  545. }
  546. }