source: EcnlProtoTool/trunk/mruby-2.1.1/mrbgems/mruby-io/src/io.c@ 439

Last change on this file since 439 was 439, checked in by coas-nagasima, 4 years ago

mrubyを2.1.1に更新
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 37.5 KB
Line 
1/*
2** io.c - IO class
3*/
4
5#include "mruby.h"
6#include "mruby/array.h"
7#include "mruby/class.h"
8#include "mruby/data.h"
9#include "mruby/hash.h"
10#include "mruby/string.h"
11#include "mruby/variable.h"
12#include "mruby/ext/io.h"
13#include "mruby/error.h"
14
15#if defined(AZURE_SPHERE)
16#define _GNU_SOURCE
17#include <stdlib.h>
18#endif
19#include <sys/types.h>
20#if !defined(AZURE_SPHERE)
21#include <sys/stat.h>
22#endif
23
24#if defined(_WIN32) || defined(_WIN64)
25 #include <winsock.h>
26 #include <io.h>
27 #define open _open
28 #define close _close
29 #define dup _dup
30 #define dup2 _dup2
31 #define read _read
32 #define write _write
33 #define lseek _lseek
34 #define isatty _isatty
35 #define WEXITSTATUS(x) (x)
36 typedef int fsize_t;
37#ifdef _WIN64
38 typedef signed __int64 ssize_t;
39#else /* _WIN64 */
40 typedef signed int ssize_t;
41#endif /* _WIN64 */
42 typedef long ftime_t;
43 typedef long fsuseconds_t;
44 typedef int fmode_t;
45 typedef int mrb_io_read_write_size;
46
47 #ifndef O_TMPFILE
48 #define O_TMPFILE O_TEMPORARY
49 #endif
50
51#else
52#if !defined(AZURE_SPHERE)
53 #include <sys/wait.h>
54#endif
55 #include <unistd.h>
56 typedef size_t fsize_t;
57 typedef time_t ftime_t;
58 typedef suseconds_t fsuseconds_t;
59 typedef mode_t fmode_t;
60 typedef ssize_t mrb_io_read_write_size;
61#endif
62
63#ifdef _MSC_VER
64typedef mrb_int pid_t;
65#endif
66
67#include <fcntl.h>
68
69#include <errno.h>
70#include <string.h>
71
72#if defined(AZURE_SPHERE)
73pid_t fork(void);
74int execl(const char *, const char *, ...);
75_Noreturn void _exit(int);
76int isatty(int);
77int open(const char *, int, ...);
78#define O_RDONLY 00
79#define O_WRONLY 01
80#define O_RDWR 02
81#define O_CREAT 0100
82#define O_EXCL 0200
83#define O_TRUNC 01000
84#define O_APPEND 02000
85
86pid_t waitpid(pid_t pid, int *status, int options);
87#endif
88
89#define OPEN_ACCESS_MODE_FLAGS (O_RDONLY | O_WRONLY | O_RDWR)
90#define OPEN_RDONLY_P(f) ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_RDONLY))
91#define OPEN_WRONLY_P(f) ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_WRONLY))
92#define OPEN_RDWR_P(f) ((mrb_bool)(((f) & OPEN_ACCESS_MODE_FLAGS) == O_RDWR))
93#define OPEN_READABLE_P(f) ((mrb_bool)(OPEN_RDONLY_P(f) || OPEN_RDWR_P(f)))
94#define OPEN_WRITABLE_P(f) ((mrb_bool)(OPEN_WRONLY_P(f) || OPEN_RDWR_P(f)))
95
96static void mrb_io_free(mrb_state *mrb, void *ptr);
97struct mrb_data_type mrb_io_type = { "IO", mrb_io_free };
98
99
100static struct mrb_io *io_get_open_fptr(mrb_state *mrb, mrb_value self);
101static int mrb_io_modestr_to_flags(mrb_state *mrb, const char *modestr);
102static int mrb_io_mode_to_flags(mrb_state *mrb, mrb_value mode);
103static void fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet);
104
105static struct mrb_io *
106io_get_open_fptr(mrb_state *mrb, mrb_value self)
107{
108 struct mrb_io *fptr;
109
110 fptr = (struct mrb_io *)mrb_data_get_ptr(mrb, self, &mrb_io_type);
111 if (fptr == NULL) {
112 mrb_raise(mrb, E_IO_ERROR, "uninitialized stream.");
113 }
114 if (fptr->fd < 0) {
115 mrb_raise(mrb, E_IO_ERROR, "closed stream.");
116 }
117 return fptr;
118}
119
120static void
121io_set_process_status(mrb_state *mrb, pid_t pid, int status)
122{
123 struct RClass *c_process, *c_status;
124 mrb_value v;
125
126 c_status = NULL;
127 if (mrb_class_defined(mrb, "Process")) {
128 c_process = mrb_module_get(mrb, "Process");
129 if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) {
130 c_status = mrb_class_get_under(mrb, c_process, "Status");
131 }
132 }
133 if (c_status != NULL) {
134 v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
135 } else {
136 v = mrb_fixnum_value(WEXITSTATUS(status));
137 }
138 mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$?"), v);
139}
140
141static int
142mrb_io_modestr_to_flags(mrb_state *mrb, const char *mode)
143{
144 int flags;
145 const char *m = mode;
146
147 switch (*m++) {
148 case 'r':
149 flags = O_RDONLY;
150 break;
151 case 'w':
152 flags = O_WRONLY | O_CREAT | O_TRUNC;
153 break;
154 case 'a':
155 flags = O_WRONLY | O_CREAT | O_APPEND;
156 break;
157 default:
158 mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %s", mode);
159 flags = 0; /* not reached */
160 }
161
162 while (*m) {
163 switch (*m++) {
164 case 'b':
165#ifdef O_BINARY
166 flags |= O_BINARY;
167#endif
168 break;
169 case '+':
170 flags = (flags & ~OPEN_ACCESS_MODE_FLAGS) | O_RDWR;
171 break;
172 case ':':
173 /* XXX: PASSTHROUGH*/
174 default:
175 mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %s", mode);
176 }
177 }
178
179 return flags;
180}
181
182static int
183mrb_io_mode_to_flags(mrb_state *mrb, mrb_value mode)
184{
185 if (mrb_nil_p(mode)) {
186 return mrb_io_modestr_to_flags(mrb, "r");
187 }
188 else if (mrb_string_p(mode)) {
189 return mrb_io_modestr_to_flags(mrb, RSTRING_CSTR(mrb, mode));
190 }
191 else {
192 int flags = 0;
193 mrb_int flags0 = mrb_int(mrb, mode);
194
195 switch (flags0 & MRB_O_ACCMODE) {
196 case MRB_O_RDONLY:
197 flags |= O_RDONLY;
198 break;
199 case MRB_O_WRONLY:
200 flags |= O_WRONLY;
201 break;
202 case MRB_O_RDWR:
203 flags |= O_RDWR;
204 break;
205 default:
206 mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %v", mode);
207 }
208
209 if (flags0 & MRB_O_APPEND) flags |= O_APPEND;
210 if (flags0 & MRB_O_CREAT) flags |= O_CREAT;
211 if (flags0 & MRB_O_EXCL) flags |= O_EXCL;
212 if (flags0 & MRB_O_TRUNC) flags |= O_TRUNC;
213#ifdef O_NONBLOCK
214 if (flags0 & MRB_O_NONBLOCK) flags |= O_NONBLOCK;
215#endif
216#ifdef O_NOCTTY
217 if (flags0 & MRB_O_NOCTTY) flags |= O_NOCTTY;
218#endif
219#ifdef O_BINARY
220 if (flags0 & MRB_O_BINARY) flags |= O_BINARY;
221#endif
222#ifdef O_SHARE_DELETE
223 if (flags0 & MRB_O_SHARE_DELETE) flags |= O_SHARE_DELETE;
224#endif
225#ifdef O_SYNC
226 if (flags0 & MRB_O_SYNC) flags |= O_SYNC;
227#endif
228#ifdef O_DSYNC
229 if (flags0 & MRB_O_DSYNC) flags |= O_DSYNC;
230#endif
231#ifdef O_RSYNC
232 if (flags0 & MRB_O_RSYNC) flags |= O_RSYNC;
233#endif
234#ifdef O_NOFOLLOW
235 if (flags0 & MRB_O_NOFOLLOW) flags |= O_NOFOLLOW;
236#endif
237#ifdef O_NOATIME
238 if (flags0 & MRB_O_NOATIME) flags |= O_NOATIME;
239#endif
240#ifdef O_DIRECT
241 if (flags0 & MRB_O_DIRECT) flags |= O_DIRECT;
242#endif
243#ifdef O_TMPFILE
244 if (flags0 & MRB_O_TMPFILE) flags |= O_TMPFILE;
245#endif
246
247 return flags;
248 }
249}
250
251static void
252mrb_fd_cloexec(mrb_state *mrb, int fd)
253{
254#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
255 int flags, flags2;
256
257 flags = fcntl(fd, F_GETFD);
258 if (flags == -1) {
259 mrb_bug(mrb, "mrb_fd_cloexec: fcntl(%d, F_GETFD) failed: %d", fd, errno);
260 }
261 if (fd <= 2) {
262 flags2 = flags & ~FD_CLOEXEC; /* Clear CLOEXEC for standard file descriptors: 0, 1, 2. */
263 }
264 else {
265 flags2 = flags | FD_CLOEXEC; /* Set CLOEXEC for non-standard file descriptors: 3, 4, 5, ... */
266 }
267 if (flags != flags2) {
268 if (fcntl(fd, F_SETFD, flags2) == -1) {
269 mrb_bug(mrb, "mrb_fd_cloexec: fcntl(%d, F_SETFD, %d) failed: %d", fd, flags2, errno);
270 }
271 }
272#endif
273}
274
275#if !defined(_WIN32) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
276static int
277mrb_cloexec_pipe(mrb_state *mrb, int fildes[2])
278{
279 int ret;
280 ret = pipe(fildes);
281 if (ret == -1)
282 return -1;
283 mrb_fd_cloexec(mrb, fildes[0]);
284 mrb_fd_cloexec(mrb, fildes[1]);
285 return ret;
286}
287
288static int
289mrb_pipe(mrb_state *mrb, int pipes[2])
290{
291 int ret;
292 ret = mrb_cloexec_pipe(mrb, pipes);
293 if (ret == -1) {
294 if (errno == EMFILE || errno == ENFILE) {
295 mrb_garbage_collect(mrb);
296 ret = mrb_cloexec_pipe(mrb, pipes);
297 }
298 }
299 return ret;
300}
301
302static int
303mrb_proc_exec(const char *pname)
304{
305 const char *s;
306 s = pname;
307
308 while (*s == ' ' || *s == '\t' || *s == '\n')
309 s++;
310
311 if (!*s) {
312 errno = ENOENT;
313 return -1;
314 }
315
316 execl("/bin/sh", "sh", "-c", pname, (char *)NULL);
317 return -1;
318}
319#endif
320
321static void
322mrb_io_free(mrb_state *mrb, void *ptr)
323{
324 struct mrb_io *io = (struct mrb_io *)ptr;
325 if (io != NULL) {
326 fptr_finalize(mrb, io, TRUE);
327 mrb_free(mrb, io);
328 }
329}
330
331static struct mrb_io *
332mrb_io_alloc(mrb_state *mrb)
333{
334 struct mrb_io *fptr;
335
336 fptr = (struct mrb_io *)mrb_malloc(mrb, sizeof(struct mrb_io));
337 fptr->fd = -1;
338 fptr->fd2 = -1;
339 fptr->pid = 0;
340 fptr->readable = 0;
341 fptr->writable = 0;
342 fptr->sync = 0;
343 fptr->is_socket = 0;
344 return fptr;
345}
346
347#ifndef NOFILE
348#define NOFILE 64
349#endif
350
351static int
352option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
353{
354 mrb_value opt;
355
356 if (!mrb_hash_p(hash)) return -1;
357 opt = mrb_hash_fetch(mrb, hash, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))), mrb_nil_value());
358 if (mrb_nil_p(opt)) return -1;
359
360 switch (mrb_type(opt)) {
361 case MRB_TT_DATA: /* IO */
362 return mrb_io_fileno(mrb, opt);
363 case MRB_TT_FIXNUM:
364 return (int)mrb_fixnum(opt);
365 default:
366 mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
367 break;
368 }
369 return -1; /* never reached */
370}
371
372#ifdef _WIN32
373mrb_value
374mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
375{
376 mrb_value cmd, io;
377 mrb_value mode = mrb_str_new_cstr(mrb, "r");
378 mrb_value opt = mrb_hash_new(mrb);
379
380 struct mrb_io *fptr;
381 const char *pname;
382 int pid = 0, flags;
383 STARTUPINFO si;
384 PROCESS_INFORMATION pi;
385 SECURITY_ATTRIBUTES saAttr;
386
387 HANDLE ifd[2];
388 HANDLE ofd[2];
389
390 int doexec;
391 int opt_in, opt_out, opt_err;
392
393 ifd[0] = INVALID_HANDLE_VALUE;
394 ifd[1] = INVALID_HANDLE_VALUE;
395 ofd[0] = INVALID_HANDLE_VALUE;
396 ofd[1] = INVALID_HANDLE_VALUE;
397
398 mrb_get_args(mrb, "S|oH", &cmd, &mode, &opt);
399 io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
400
401 pname = RSTRING_CSTR(mrb, cmd);
402 flags = mrb_io_mode_to_flags(mrb, mode);
403
404 doexec = (strcmp("-", pname) != 0);
405 opt_in = option_to_fd(mrb, opt, "in");
406 opt_out = option_to_fd(mrb, opt, "out");
407 opt_err = option_to_fd(mrb, opt, "err");
408
409 saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
410 saAttr.bInheritHandle = TRUE;
411 saAttr.lpSecurityDescriptor = NULL;
412
413 if (OPEN_READABLE_P(flags)) {
414 if (!CreatePipe(&ofd[0], &ofd[1], &saAttr, 0)
415 || !SetHandleInformation(ofd[0], HANDLE_FLAG_INHERIT, 0)) {
416 mrb_sys_fail(mrb, "pipe");
417 }
418 }
419
420 if (OPEN_WRITABLE_P(flags)) {
421 if (!CreatePipe(&ifd[0], &ifd[1], &saAttr, 0)
422 || !SetHandleInformation(ifd[1], HANDLE_FLAG_INHERIT, 0)) {
423 mrb_sys_fail(mrb, "pipe");
424 }
425 }
426
427 if (doexec) {
428 ZeroMemory(&pi, sizeof(pi));
429 ZeroMemory(&si, sizeof(si));
430 si.cb = sizeof(si);
431 si.dwFlags |= STARTF_USESHOWWINDOW;
432 si.wShowWindow = SW_HIDE;
433 si.dwFlags |= STARTF_USESTDHANDLES;
434 if (OPEN_READABLE_P(flags)) {
435 si.hStdOutput = ofd[1];
436 si.hStdError = ofd[1];
437 }
438 if (OPEN_WRITABLE_P(flags)) {
439 si.hStdInput = ifd[0];
440 }
441 if (!CreateProcess(
442 NULL, (char*)pname, NULL, NULL,
443 TRUE, CREATE_NEW_PROCESS_GROUP, NULL, NULL, &si, &pi)) {
444 CloseHandle(ifd[0]);
445 CloseHandle(ifd[1]);
446 CloseHandle(ofd[0]);
447 CloseHandle(ofd[1]);
448 mrb_raisef(mrb, E_IO_ERROR, "command not found: %v", cmd);
449 }
450 CloseHandle(pi.hThread);
451 CloseHandle(ifd[0]);
452 CloseHandle(ofd[1]);
453 pid = pi.dwProcessId;
454 }
455
456 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
457
458 fptr = mrb_io_alloc(mrb);
459 fptr->fd = _open_osfhandle((intptr_t)ofd[0], 0);
460 fptr->fd2 = _open_osfhandle((intptr_t)ifd[1], 0);
461 fptr->pid = pid;
462 fptr->readable = OPEN_READABLE_P(flags);
463 fptr->writable = OPEN_WRITABLE_P(flags);
464 fptr->sync = 0;
465
466 DATA_TYPE(io) = &mrb_io_type;
467 DATA_PTR(io) = fptr;
468 return io;
469}
470#elif defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
471mrb_value
472mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
473{
474 mrb_raise(mrb, E_NOTIMP_ERROR, "IO#popen is not supported on the platform");
475 return mrb_false_value();
476}
477#else
478mrb_value
479mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
480{
481 mrb_value cmd, io, result;
482 mrb_value mode = mrb_str_new_cstr(mrb, "r");
483 mrb_value opt = mrb_hash_new(mrb);
484
485 struct mrb_io *fptr;
486 const char *pname;
487 int pid, flags, fd, write_fd = -1;
488 int pr[2] = { -1, -1 };
489 int pw[2] = { -1, -1 };
490 int doexec;
491 int saved_errno;
492 int opt_in, opt_out, opt_err;
493
494 mrb_get_args(mrb, "S|oH", &cmd, &mode, &opt);
495 io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
496
497 pname = RSTRING_CSTR(mrb, cmd);
498 flags = mrb_io_mode_to_flags(mrb, mode);
499
500 doexec = (strcmp("-", pname) != 0);
501 opt_in = option_to_fd(mrb, opt, "in");
502 opt_out = option_to_fd(mrb, opt, "out");
503 opt_err = option_to_fd(mrb, opt, "err");
504
505 if (OPEN_READABLE_P(flags)) {
506 if (pipe(pr) == -1) {
507 mrb_sys_fail(mrb, "pipe");
508 }
509 mrb_fd_cloexec(mrb, pr[0]);
510 mrb_fd_cloexec(mrb, pr[1]);
511 }
512
513 if (OPEN_WRITABLE_P(flags)) {
514 if (pipe(pw) == -1) {
515 if (pr[0] != -1) close(pr[0]);
516 if (pr[1] != -1) close(pr[1]);
517 mrb_sys_fail(mrb, "pipe");
518 }
519 mrb_fd_cloexec(mrb, pw[0]);
520 mrb_fd_cloexec(mrb, pw[1]);
521 }
522
523 if (!doexec) {
524 // XXX
525 fflush(stdin);
526 fflush(stdout);
527 fflush(stderr);
528 }
529
530 result = mrb_nil_value();
531 switch (pid = fork()) {
532 case 0: /* child */
533 if (opt_in != -1) {
534 dup2(opt_in, 0);
535 }
536 if (opt_out != -1) {
537 dup2(opt_out, 1);
538 }
539 if (opt_err != -1) {
540 dup2(opt_err, 2);
541 }
542 if (OPEN_READABLE_P(flags)) {
543 close(pr[0]);
544 if (pr[1] != 1) {
545 dup2(pr[1], 1);
546 close(pr[1]);
547 }
548 }
549 if (OPEN_WRITABLE_P(flags)) {
550 close(pw[1]);
551 if (pw[0] != 0) {
552 dup2(pw[0], 0);
553 close(pw[0]);
554 }
555 }
556 if (doexec) {
557 for (fd = 3; fd < NOFILE; fd++) {
558 close(fd);
559 }
560 mrb_proc_exec(pname);
561 mrb_raisef(mrb, E_IO_ERROR, "command not found: %v", cmd);
562 _exit(127);
563 }
564 result = mrb_nil_value();
565 break;
566
567 default: /* parent */
568 if (OPEN_RDWR_P(flags)) {
569 close(pr[1]);
570 fd = pr[0];
571 close(pw[0]);
572 write_fd = pw[1];
573 } else if (OPEN_RDONLY_P(flags)) {
574 close(pr[1]);
575 fd = pr[0];
576 } else {
577 close(pw[0]);
578 fd = pw[1];
579 }
580
581 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
582
583 fptr = mrb_io_alloc(mrb);
584 fptr->fd = fd;
585 fptr->fd2 = write_fd;
586 fptr->pid = pid;
587 fptr->readable = OPEN_READABLE_P(flags);
588 fptr->writable = OPEN_WRITABLE_P(flags);
589 fptr->sync = 0;
590
591 DATA_TYPE(io) = &mrb_io_type;
592 DATA_PTR(io) = fptr;
593 result = io;
594 break;
595
596 case -1: /* error */
597 saved_errno = errno;
598 if (OPEN_READABLE_P(flags)) {
599 close(pr[0]);
600 close(pr[1]);
601 }
602 if (OPEN_WRITABLE_P(flags)) {
603 close(pw[0]);
604 close(pw[1]);
605 }
606 errno = saved_errno;
607 mrb_sys_fail(mrb, "pipe_open failed.");
608 break;
609 }
610 return result;
611}
612#endif
613
614static int
615mrb_dup(mrb_state *mrb, int fd, mrb_bool *failed)
616{
617 int new_fd;
618
619 *failed = TRUE;
620 if (fd < 0)
621 return fd;
622
623 new_fd = dup(fd);
624 if (new_fd > 0) *failed = FALSE;
625 return new_fd;
626}
627
628mrb_value
629mrb_io_initialize_copy(mrb_state *mrb, mrb_value copy)
630{
631 mrb_value orig;
632 mrb_value buf;
633 struct mrb_io *fptr_copy;
634 struct mrb_io *fptr_orig;
635 mrb_bool failed = TRUE;
636
637 mrb_get_args(mrb, "o", &orig);
638 fptr_orig = io_get_open_fptr(mrb, orig);
639 fptr_copy = (struct mrb_io *)DATA_PTR(copy);
640 if (fptr_orig == fptr_copy) return copy;
641 if (fptr_copy != NULL) {
642 fptr_finalize(mrb, fptr_copy, FALSE);
643 mrb_free(mrb, fptr_copy);
644 }
645 fptr_copy = (struct mrb_io *)mrb_io_alloc(mrb);
646
647 DATA_TYPE(copy) = &mrb_io_type;
648 DATA_PTR(copy) = fptr_copy;
649
650 buf = mrb_iv_get(mrb, orig, mrb_intern_cstr(mrb, "@buf"));
651 mrb_iv_set(mrb, copy, mrb_intern_cstr(mrb, "@buf"), buf);
652
653 fptr_copy->fd = mrb_dup(mrb, fptr_orig->fd, &failed);
654 if (failed) {
655 mrb_sys_fail(mrb, 0);
656 }
657 mrb_fd_cloexec(mrb, fptr_copy->fd);
658
659 if (fptr_orig->fd2 != -1) {
660 fptr_copy->fd2 = mrb_dup(mrb, fptr_orig->fd2, &failed);
661 if (failed) {
662 close(fptr_copy->fd);
663 mrb_sys_fail(mrb, 0);
664 }
665 mrb_fd_cloexec(mrb, fptr_copy->fd2);
666 }
667
668 fptr_copy->pid = fptr_orig->pid;
669 fptr_copy->readable = fptr_orig->readable;
670 fptr_copy->writable = fptr_orig->writable;
671 fptr_copy->sync = fptr_orig->sync;
672 fptr_copy->is_socket = fptr_orig->is_socket;
673
674 return copy;
675}
676
677mrb_value
678mrb_io_initialize(mrb_state *mrb, mrb_value io)
679{
680 struct mrb_io *fptr;
681 mrb_int fd;
682 mrb_value mode, opt;
683 int flags;
684
685 mode = opt = mrb_nil_value();
686
687 mrb_get_args(mrb, "i|oo", &fd, &mode, &opt);
688 if (mrb_nil_p(mode)) {
689 mode = mrb_str_new_cstr(mrb, "r");
690 }
691 if (mrb_nil_p(opt)) {
692 opt = mrb_hash_new(mrb);
693 }
694
695 flags = mrb_io_mode_to_flags(mrb, mode);
696
697 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
698
699 fptr = (struct mrb_io *)DATA_PTR(io);
700 if (fptr != NULL) {
701 fptr_finalize(mrb, fptr, TRUE);
702 mrb_free(mrb, fptr);
703 }
704 fptr = mrb_io_alloc(mrb);
705
706 DATA_TYPE(io) = &mrb_io_type;
707 DATA_PTR(io) = fptr;
708
709 fptr->fd = (int)fd;
710 fptr->readable = OPEN_READABLE_P(flags);
711 fptr->writable = OPEN_WRITABLE_P(flags);
712 fptr->sync = 0;
713 return io;
714}
715
716static void
717fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet)
718{
719 int saved_errno = 0;
720
721 if (fptr == NULL) {
722 return;
723 }
724
725 if (fptr->fd > 2) {
726#ifdef _WIN32
727 if (fptr->is_socket) {
728 if (closesocket(fptr->fd) != 0) {
729 saved_errno = WSAGetLastError();
730 }
731 fptr->fd = -1;
732 }
733#endif
734 if (fptr->fd != -1) {
735 if (close(fptr->fd) == -1) {
736 saved_errno = errno;
737 }
738 }
739 fptr->fd = -1;
740 }
741
742 if (fptr->fd2 > 2) {
743 if (close(fptr->fd2) == -1) {
744 if (saved_errno == 0) {
745 saved_errno = errno;
746 }
747 }
748 fptr->fd2 = -1;
749 }
750
751 if (fptr->pid != 0) {
752#if !defined(_WIN32) && !defined(_WIN64)
753 pid_t pid;
754 int status;
755 do {
756 pid = waitpid(fptr->pid, &status, 0);
757 } while (pid == -1 && errno == EINTR);
758 if (!quiet && pid == fptr->pid) {
759 io_set_process_status(mrb, pid, status);
760 }
761#else
762 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, fptr->pid);
763 DWORD status;
764 if (WaitForSingleObject(h, INFINITE) && GetExitCodeProcess(h, &status))
765 if (!quiet)
766 io_set_process_status(mrb, fptr->pid, (int)status);
767 CloseHandle(h);
768#endif
769 fptr->pid = 0;
770 /* Note: we don't raise an exception when waitpid(3) fails */
771 }
772
773 if (!quiet && saved_errno != 0) {
774 errno = saved_errno;
775 mrb_sys_fail(mrb, "fptr_finalize failed.");
776 }
777}
778
779mrb_value
780mrb_io_check_readable(mrb_state *mrb, mrb_value self)
781{
782 struct mrb_io *fptr = io_get_open_fptr(mrb, self);
783 if (! fptr->readable) {
784 mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
785 }
786 return mrb_nil_value();
787}
788
789mrb_value
790mrb_io_isatty(mrb_state *mrb, mrb_value self)
791{
792 struct mrb_io *fptr;
793
794 fptr = io_get_open_fptr(mrb, self);
795 if (isatty(fptr->fd) == 0)
796 return mrb_false_value();
797 return mrb_true_value();
798}
799
800mrb_value
801mrb_io_s_for_fd(mrb_state *mrb, mrb_value klass)
802{
803 struct RClass *c = mrb_class_ptr(klass);
804 enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
805 mrb_value obj;
806
807 /* copied from mrb_instance_alloc() */
808 if (ttype == 0) ttype = MRB_TT_OBJECT;
809 obj = mrb_obj_value((struct RObject*)mrb_obj_alloc(mrb, ttype, c));
810 return mrb_io_initialize(mrb, obj);
811}
812
813mrb_value
814mrb_io_s_sysclose(mrb_state *mrb, mrb_value klass)
815{
816 mrb_int fd;
817 mrb_get_args(mrb, "i", &fd);
818 if (close((int)fd) == -1) {
819 mrb_sys_fail(mrb, "close");
820 }
821 return mrb_fixnum_value(0);
822}
823
824int
825mrb_cloexec_open(mrb_state *mrb, const char *pathname, mrb_int flags, mrb_int mode)
826{
827 int fd, retry = FALSE;
828 char* fname = mrb_locale_from_utf8(pathname, -1);
829
830#ifdef O_CLOEXEC
831 /* O_CLOEXEC is available since Linux 2.6.23. Linux 2.6.18 silently ignore it. */
832 flags |= O_CLOEXEC;
833#elif defined O_NOINHERIT
834 flags |= O_NOINHERIT;
835#endif
836reopen:
837 fd = open(fname, (int)flags, (fmode_t)mode);
838 if (fd == -1) {
839 if (!retry) {
840 switch (errno) {
841 case ENFILE:
842 case EMFILE:
843 mrb_garbage_collect(mrb);
844 retry = TRUE;
845 goto reopen;
846 }
847 }
848
849 mrb_sys_fail(mrb, RSTRING_CSTR(mrb, mrb_format(mrb, "open %s", pathname)));
850 }
851 mrb_locale_free(fname);
852
853 if (fd <= 2) {
854 mrb_fd_cloexec(mrb, fd);
855 }
856 return fd;
857}
858
859mrb_value
860mrb_io_s_sysopen(mrb_state *mrb, mrb_value klass)
861{
862 mrb_value path = mrb_nil_value();
863 mrb_value mode = mrb_nil_value();
864 mrb_int fd, perm = -1;
865 const char *pat;
866 int flags;
867
868 mrb_get_args(mrb, "S|oi", &path, &mode, &perm);
869 if (perm < 0) {
870 perm = 0666;
871 }
872
873 pat = RSTRING_CSTR(mrb, path);
874 flags = mrb_io_mode_to_flags(mrb, mode);
875 fd = mrb_cloexec_open(mrb, pat, flags, perm);
876 return mrb_fixnum_value(fd);
877}
878
879static mrb_value mrb_io_sysread_common(mrb_state *mrb,
880 mrb_io_read_write_size (*readfunc)(int, void *, fsize_t, off_t),
881 mrb_value io, mrb_value buf, mrb_int maxlen, off_t offset);
882
883static mrb_io_read_write_size
884mrb_sysread_dummy(int fd, void *buf, fsize_t nbytes, off_t offset)
885{
886 return (mrb_io_read_write_size)read(fd, buf, nbytes);
887}
888
889mrb_value
890mrb_io_sysread(mrb_state *mrb, mrb_value io)
891{
892 mrb_value buf = mrb_nil_value();
893 mrb_int maxlen;
894
895 mrb_get_args(mrb, "i|S", &maxlen, &buf);
896
897 return mrb_io_sysread_common(mrb, mrb_sysread_dummy, io, buf, maxlen, 0);
898}
899
900static mrb_value
901mrb_io_sysread_common(mrb_state *mrb,
902 mrb_io_read_write_size (*readfunc)(int, void *, fsize_t, off_t),
903 mrb_value io, mrb_value buf, mrb_int maxlen, off_t offset)
904{
905 struct mrb_io *fptr;
906 int ret;
907
908 if (maxlen < 0) {
909 mrb_raise(mrb, E_ARGUMENT_ERROR, "negative expanding string size");
910 }
911 else if (maxlen == 0) {
912 return mrb_str_new(mrb, NULL, maxlen);
913 }
914
915 if (mrb_nil_p(buf)) {
916 buf = mrb_str_new(mrb, NULL, maxlen);
917 }
918
919 if (RSTRING_LEN(buf) != maxlen) {
920 buf = mrb_str_resize(mrb, buf, maxlen);
921 }
922 else {
923 mrb_str_modify(mrb, RSTRING(buf));
924 }
925
926 fptr = (struct mrb_io *)io_get_open_fptr(mrb, io);
927 if (!fptr->readable) {
928 mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
929 }
930 ret = readfunc(fptr->fd, RSTRING_PTR(buf), (fsize_t)maxlen, offset);
931 if (ret < 0) {
932 mrb_sys_fail(mrb, "sysread failed");
933 }
934 if (RSTRING_LEN(buf) != ret) {
935 buf = mrb_str_resize(mrb, buf, ret);
936 }
937 if (ret == 0 && maxlen > 0) {
938 mrb_raise(mrb, E_EOF_ERROR, "sysread failed: End of File");
939 }
940 return buf;
941}
942
943mrb_value
944mrb_io_sysseek(mrb_state *mrb, mrb_value io)
945{
946 struct mrb_io *fptr;
947 off_t pos;
948 mrb_int offset, whence = -1;
949
950 mrb_get_args(mrb, "i|i", &offset, &whence);
951 if (whence < 0) {
952 whence = 0;
953 }
954
955 fptr = io_get_open_fptr(mrb, io);
956 pos = lseek(fptr->fd, (off_t)offset, (int)whence);
957 if (pos == -1) {
958 mrb_sys_fail(mrb, "sysseek");
959 }
960 if (pos > MRB_INT_MAX) {
961#ifndef MRB_WITHOUT_FLOAT
962 return mrb_float_value(mrb, (mrb_float)pos);
963#else
964 mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT");
965#endif
966 } else {
967 return mrb_fixnum_value(pos);
968 }
969}
970
971static mrb_value
972mrb_io_syswrite_common(mrb_state *mrb,
973 mrb_io_read_write_size (*writefunc)(int, const void *, fsize_t, off_t),
974 mrb_value io, mrb_value buf, off_t offset)
975{
976 struct mrb_io *fptr;
977 int fd, length;
978
979 fptr = io_get_open_fptr(mrb, io);
980 if (! fptr->writable) {
981 mrb_raise(mrb, E_IO_ERROR, "not opened for writing");
982 }
983
984 if (fptr->fd2 == -1) {
985 fd = fptr->fd;
986 } else {
987 fd = fptr->fd2;
988 }
989 length = writefunc(fd, RSTRING_PTR(buf), (fsize_t)RSTRING_LEN(buf), offset);
990 if (length == -1) {
991 mrb_sys_fail(mrb, 0);
992 }
993
994 return mrb_fixnum_value(length);
995}
996
997static mrb_io_read_write_size
998mrb_syswrite_dummy(int fd, const void *buf, fsize_t nbytes, off_t offset)
999{
1000 return (mrb_io_read_write_size)write(fd, buf, nbytes);
1001}
1002
1003mrb_value
1004mrb_io_syswrite(mrb_state *mrb, mrb_value io)
1005{
1006 mrb_value buf;
1007
1008 mrb_get_args(mrb, "S", &buf);
1009
1010 return mrb_io_syswrite_common(mrb, mrb_syswrite_dummy, io, buf, 0);
1011}
1012
1013mrb_value
1014mrb_io_close(mrb_state *mrb, mrb_value self)
1015{
1016 struct mrb_io *fptr;
1017 fptr = io_get_open_fptr(mrb, self);
1018 fptr_finalize(mrb, fptr, FALSE);
1019 return mrb_nil_value();
1020}
1021
1022mrb_value
1023mrb_io_close_write(mrb_state *mrb, mrb_value self)
1024{
1025 struct mrb_io *fptr;
1026 fptr = io_get_open_fptr(mrb, self);
1027 if (close((int)fptr->fd2) == -1) {
1028 mrb_sys_fail(mrb, "close");
1029 }
1030 return mrb_nil_value();
1031}
1032
1033mrb_value
1034mrb_io_closed(mrb_state *mrb, mrb_value io)
1035{
1036 struct mrb_io *fptr;
1037 fptr = (struct mrb_io *)mrb_data_get_ptr(mrb, io, &mrb_io_type);
1038 if (fptr == NULL || fptr->fd >= 0) {
1039 return mrb_false_value();
1040 }
1041
1042 return mrb_true_value();
1043}
1044
1045mrb_value
1046mrb_io_pid(mrb_state *mrb, mrb_value io)
1047{
1048 struct mrb_io *fptr;
1049 fptr = io_get_open_fptr(mrb, io);
1050
1051 if (fptr->pid > 0) {
1052 return mrb_fixnum_value(fptr->pid);
1053 }
1054
1055 return mrb_nil_value();
1056}
1057
1058static struct timeval
1059time2timeval(mrb_state *mrb, mrb_value time)
1060{
1061 struct timeval t = { 0, 0 };
1062
1063 switch (mrb_type(time)) {
1064 case MRB_TT_FIXNUM:
1065 t.tv_sec = (ftime_t)mrb_fixnum(time);
1066 t.tv_usec = 0;
1067 break;
1068
1069#ifndef MRB_WITHOUT_FLOAT
1070 case MRB_TT_FLOAT:
1071 t.tv_sec = (ftime_t)mrb_float(time);
1072 t.tv_usec = (fsuseconds_t)((mrb_float(time) - t.tv_sec) * 1000000.0);
1073 break;
1074#endif
1075
1076 default:
1077 mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
1078 }
1079
1080 return t;
1081}
1082
1083static int
1084mrb_io_read_data_pending(mrb_state *mrb, mrb_value io)
1085{
1086 mrb_value buf = mrb_iv_get(mrb, io, mrb_intern_cstr(mrb, "@buf"));
1087 if (mrb_string_p(buf) && RSTRING_LEN(buf) > 0) {
1088 return 1;
1089 }
1090 return 0;
1091}
1092
1093#if !defined(_WIN32) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
1094static mrb_value
1095mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
1096{
1097 mrb_value r = mrb_nil_value();
1098 mrb_value w = mrb_nil_value();
1099 struct mrb_io *fptr_r;
1100 struct mrb_io *fptr_w;
1101 int pipes[2];
1102
1103 if (mrb_pipe(mrb, pipes) == -1) {
1104 mrb_sys_fail(mrb, "pipe");
1105 }
1106
1107 r = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
1108 mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
1109 fptr_r = mrb_io_alloc(mrb);
1110 fptr_r->fd = pipes[0];
1111 fptr_r->readable = 1;
1112 fptr_r->writable = 0;
1113 fptr_r->sync = 0;
1114 DATA_TYPE(r) = &mrb_io_type;
1115 DATA_PTR(r) = fptr_r;
1116
1117 w = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
1118 mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
1119 fptr_w = mrb_io_alloc(mrb);
1120 fptr_w->fd = pipes[1];
1121 fptr_w->readable = 0;
1122 fptr_w->writable = 1;
1123 fptr_w->sync = 1;
1124 DATA_TYPE(w) = &mrb_io_type;
1125 DATA_PTR(w) = fptr_w;
1126
1127 return mrb_assoc_new(mrb, r, w);
1128}
1129#endif
1130
1131static mrb_value
1132mrb_io_s_select(mrb_state *mrb, mrb_value klass)
1133{
1134 mrb_value *argv;
1135 mrb_int argc;
1136 mrb_value read, read_io, write, except, timeout, list;
1137 struct timeval *tp, timerec;
1138 fd_set pset, rset, wset, eset;
1139 fd_set *rp, *wp, *ep;
1140 struct mrb_io *fptr;
1141 int pending = 0;
1142 mrb_value result;
1143 int max = 0;
1144 int interrupt_flag = 0;
1145 int i, n;
1146
1147 mrb_get_args(mrb, "*", &argv, &argc);
1148
1149 if (argc < 1 || argc > 4) {
1150 mrb_argnum_error(mrb, argc, 1, 4);
1151 }
1152
1153 timeout = mrb_nil_value();
1154 except = mrb_nil_value();
1155 write = mrb_nil_value();
1156 if (argc > 3)
1157 timeout = argv[3];
1158 if (argc > 2)
1159 except = argv[2];
1160 if (argc > 1)
1161 write = argv[1];
1162 read = argv[0];
1163
1164 if (mrb_nil_p(timeout)) {
1165 tp = NULL;
1166 } else {
1167 timerec = time2timeval(mrb, timeout);
1168 tp = &timerec;
1169 }
1170
1171 FD_ZERO(&pset);
1172 if (!mrb_nil_p(read)) {
1173 mrb_check_type(mrb, read, MRB_TT_ARRAY);
1174 rp = &rset;
1175 FD_ZERO(rp);
1176 for (i = 0; i < RARRAY_LEN(read); i++) {
1177 read_io = RARRAY_PTR(read)[i];
1178 fptr = io_get_open_fptr(mrb, read_io);
1179 FD_SET(fptr->fd, rp);
1180 if (mrb_io_read_data_pending(mrb, read_io)) {
1181 pending++;
1182 FD_SET(fptr->fd, &pset);
1183 }
1184 if (max < fptr->fd)
1185 max = fptr->fd;
1186 }
1187 if (pending) {
1188 timerec.tv_sec = timerec.tv_usec = 0;
1189 tp = &timerec;
1190 }
1191 } else {
1192 rp = NULL;
1193 }
1194
1195 if (!mrb_nil_p(write)) {
1196 mrb_check_type(mrb, write, MRB_TT_ARRAY);
1197 wp = &wset;
1198 FD_ZERO(wp);
1199 for (i = 0; i < RARRAY_LEN(write); i++) {
1200 fptr = io_get_open_fptr(mrb, RARRAY_PTR(write)[i]);
1201 FD_SET(fptr->fd, wp);
1202 if (max < fptr->fd)
1203 max = fptr->fd;
1204 if (fptr->fd2 >= 0) {
1205 FD_SET(fptr->fd2, wp);
1206 if (max < fptr->fd2)
1207 max = fptr->fd2;
1208 }
1209 }
1210 } else {
1211 wp = NULL;
1212 }
1213
1214 if (!mrb_nil_p(except)) {
1215 mrb_check_type(mrb, except, MRB_TT_ARRAY);
1216 ep = &eset;
1217 FD_ZERO(ep);
1218 for (i = 0; i < RARRAY_LEN(except); i++) {
1219 fptr = io_get_open_fptr(mrb, RARRAY_PTR(except)[i]);
1220 FD_SET(fptr->fd, ep);
1221 if (max < fptr->fd)
1222 max = fptr->fd;
1223 if (fptr->fd2 >= 0) {
1224 FD_SET(fptr->fd2, ep);
1225 if (max < fptr->fd2)
1226 max = fptr->fd2;
1227 }
1228 }
1229 } else {
1230 ep = NULL;
1231 }
1232
1233 max++;
1234
1235retry:
1236 n = select(max, rp, wp, ep, tp);
1237 if (n < 0) {
1238 if (errno != EINTR)
1239 mrb_sys_fail(mrb, "select failed");
1240 if (tp == NULL)
1241 goto retry;
1242 interrupt_flag = 1;
1243 }
1244
1245 if (!pending && n == 0)
1246 return mrb_nil_value();
1247
1248 result = mrb_ary_new_capa(mrb, 3);
1249 mrb_ary_push(mrb, result, rp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
1250 mrb_ary_push(mrb, result, wp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
1251 mrb_ary_push(mrb, result, ep? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
1252
1253 if (interrupt_flag == 0) {
1254 if (rp) {
1255 list = RARRAY_PTR(result)[0];
1256 for (i = 0; i < RARRAY_LEN(read); i++) {
1257 fptr = io_get_open_fptr(mrb, RARRAY_PTR(read)[i]);
1258 if (FD_ISSET(fptr->fd, rp) ||
1259 FD_ISSET(fptr->fd, &pset)) {
1260 mrb_ary_push(mrb, list, RARRAY_PTR(read)[i]);
1261 }
1262 }
1263 }
1264
1265 if (wp) {
1266 list = RARRAY_PTR(result)[1];
1267 for (i = 0; i < RARRAY_LEN(write); i++) {
1268 fptr = io_get_open_fptr(mrb, RARRAY_PTR(write)[i]);
1269 if (FD_ISSET(fptr->fd, wp)) {
1270 mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
1271 } else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, wp)) {
1272 mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
1273 }
1274 }
1275 }
1276
1277 if (ep) {
1278 list = RARRAY_PTR(result)[2];
1279 for (i = 0; i < RARRAY_LEN(except); i++) {
1280 fptr = io_get_open_fptr(mrb, RARRAY_PTR(except)[i]);
1281 if (FD_ISSET(fptr->fd, ep)) {
1282 mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
1283 } else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, ep)) {
1284 mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
1285 }
1286 }
1287 }
1288 }
1289
1290 return result;
1291}
1292
1293int
1294mrb_io_fileno(mrb_state *mrb, mrb_value io)
1295{
1296 struct mrb_io *fptr;
1297 fptr = io_get_open_fptr(mrb, io);
1298 return fptr->fd;
1299}
1300
1301static mrb_value
1302mrb_io_fileno_m(mrb_state *mrb, mrb_value io)
1303{
1304 int fd = mrb_io_fileno(mrb, io);
1305 return mrb_fixnum_value(fd);
1306}
1307
1308mrb_value
1309mrb_io_close_on_exec_p(mrb_state *mrb, mrb_value self)
1310{
1311#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
1312 struct mrb_io *fptr;
1313 int ret;
1314
1315 fptr = io_get_open_fptr(mrb, self);
1316
1317 if (fptr->fd2 >= 0) {
1318 if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1319 if (!(ret & FD_CLOEXEC)) return mrb_false_value();
1320 }
1321
1322 if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1323 if (!(ret & FD_CLOEXEC)) return mrb_false_value();
1324 return mrb_true_value();
1325
1326#else
1327 mrb_raise(mrb, E_NOTIMP_ERROR, "IO#close_on_exec? is not supported on the platform");
1328 return mrb_false_value();
1329#endif
1330}
1331
1332mrb_value
1333mrb_io_set_close_on_exec(mrb_state *mrb, mrb_value self)
1334{
1335#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
1336 struct mrb_io *fptr;
1337 int flag, ret;
1338 mrb_bool b;
1339
1340 fptr = io_get_open_fptr(mrb, self);
1341 mrb_get_args(mrb, "b", &b);
1342 flag = b ? FD_CLOEXEC : 0;
1343
1344 if (fptr->fd2 >= 0) {
1345 if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1346 if ((ret & FD_CLOEXEC) != flag) {
1347 ret = (ret & ~FD_CLOEXEC) | flag;
1348 ret = fcntl(fptr->fd2, F_SETFD, ret);
1349
1350 if (ret == -1) mrb_sys_fail(mrb, "F_SETFD failed");
1351 }
1352 }
1353
1354 if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1355 if ((ret & FD_CLOEXEC) != flag) {
1356 ret = (ret & ~FD_CLOEXEC) | flag;
1357 ret = fcntl(fptr->fd, F_SETFD, ret);
1358 if (ret == -1) mrb_sys_fail(mrb, "F_SETFD failed");
1359 }
1360
1361 return mrb_bool_value(b);
1362#else
1363 mrb_raise(mrb, E_NOTIMP_ERROR, "IO#close_on_exec= is not supported on the platform");
1364 return mrb_nil_value();
1365#endif
1366}
1367
1368mrb_value
1369mrb_io_set_sync(mrb_state *mrb, mrb_value self)
1370{
1371 struct mrb_io *fptr;
1372 mrb_bool b;
1373
1374 fptr = io_get_open_fptr(mrb, self);
1375 mrb_get_args(mrb, "b", &b);
1376 fptr->sync = b;
1377 return mrb_bool_value(b);
1378}
1379
1380mrb_value
1381mrb_io_sync(mrb_state *mrb, mrb_value self)
1382{
1383 struct mrb_io *fptr;
1384 fptr = io_get_open_fptr(mrb, self);
1385 return mrb_bool_value(fptr->sync);
1386}
1387
1388#ifndef MRB_WITH_IO_PREAD_PWRITE
1389# define mrb_io_pread mrb_notimplement_m
1390# define mrb_io_pwrite mrb_notimplement_m
1391#else
1392static off_t
1393value2off(mrb_state *mrb, mrb_value offv)
1394{
1395 switch (mrb_type(offv)) {
1396#ifndef MRB_WITHOUT_FLOAT
1397 case MRB_TT_FLOAT:
1398 {
1399 mrb_float tmp = mrb_float(offv);
1400 if (tmp < INT64_MIN || tmp > INT64_MAX) {
1401 /* fall through to use convert by `mrb_int()` (and raise error if out of range) */
1402 } else {
1403 return (off_t)tmp;
1404 }
1405 }
1406 /* fall through */
1407#endif /* MRB_WITHOUT_FLOAT */
1408 default:
1409 return (off_t)mrb_int(mrb, offv);
1410 }
1411}
1412
1413/*
1414 * call-seq:
1415 * pread(maxlen, offset, outbuf = "") -> outbuf
1416 */
1417static mrb_value
1418mrb_io_pread(mrb_state *mrb, mrb_value io)
1419{
1420 mrb_value buf = mrb_nil_value();
1421 mrb_value off;
1422 mrb_int maxlen;
1423
1424 mrb_get_args(mrb, "io|S!", &maxlen, &off, &buf);
1425
1426 return mrb_io_sysread_common(mrb, pread, io, buf, maxlen, value2off(mrb, off));
1427}
1428
1429/*
1430 * call-seq:
1431 * pwrite(buffer, offset) -> wrote_bytes
1432 */
1433static mrb_value
1434mrb_io_pwrite(mrb_state *mrb, mrb_value io)
1435{
1436 mrb_value buf, off;
1437
1438 mrb_get_args(mrb, "So", &buf, &off);
1439
1440 return mrb_io_syswrite_common(mrb, pwrite, io, buf, value2off(mrb, off));
1441}
1442#endif /* MRB_WITH_IO_PREAD_PWRITE */
1443
1444static mrb_value
1445io_bufread(mrb_state *mrb, mrb_value str, mrb_int len)
1446{
1447 mrb_value str2;
1448 mrb_int newlen;
1449 struct RString *s;
1450 char *p;
1451
1452 s = RSTRING(str);
1453 mrb_str_modify(mrb, s);
1454 p = RSTR_PTR(s);
1455 str2 = mrb_str_new(mrb, p, len);
1456 newlen = RSTR_LEN(s)-len;
1457 memmove(p, p+len, newlen);
1458 p[newlen] = '\0';
1459 RSTR_SET_LEN(s, newlen);
1460
1461 return str2;
1462}
1463
1464static mrb_value
1465mrb_io_bufread(mrb_state *mrb, mrb_value self)
1466{
1467 mrb_value str;
1468 mrb_int len;
1469
1470 mrb_get_args(mrb, "Si", &str, &len);
1471 return io_bufread(mrb, str, len);
1472}
1473
1474static mrb_value
1475mrb_io_readchar(mrb_state *mrb, mrb_value self)
1476{
1477 mrb_value buf;
1478 mrb_int len = 1;
1479#ifdef MRB_UTF8_STRING
1480 unsigned char c;
1481#endif
1482
1483 mrb_get_args(mrb, "S", &buf);
1484 mrb_assert(RSTRING_PTR(buf) > 0);
1485 mrb_str_modify(mrb, RSTRING(buf));
1486#ifdef MRB_UTF8_STRING
1487 c = RSTRING_PTR(buf)[0];
1488 if (c & 0x80) {
1489 len = mrb_utf8len(RSTRING_PTR(buf), RSTRING_END(buf));
1490 if (len == 1 && RSTRING_LEN(buf) < 4) { /* partial UTF-8 */
1491 mrb_int blen = RSTRING_LEN(buf);
1492 ssize_t n;
1493
1494 struct mrb_io *fptr = (struct mrb_io*)io_get_open_fptr(mrb, self);
1495
1496 if (!fptr->readable) {
1497 mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
1498 }
1499 /* refill the buffer */
1500 mrb_str_resize(mrb, buf, 4096);
1501 n = read(fptr->fd, RSTRING_PTR(buf)+blen, 4096-blen);
1502 if (n < 0) mrb_sys_fail(mrb, "sysread failed");
1503 mrb_str_resize(mrb, buf, blen+n);
1504 }
1505 len = mrb_utf8len(RSTRING_PTR(buf), RSTRING_END(buf));
1506 }
1507#endif
1508 return io_bufread(mrb, buf, len);
1509}
1510
1511void
1512mrb_init_io(mrb_state *mrb)
1513{
1514 struct RClass *io;
1515
1516 io = mrb_define_class(mrb, "IO", mrb->object_class);
1517 MRB_SET_INSTANCE_TT(io, MRB_TT_DATA);
1518
1519 mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
1520 mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, MRB_ARGS_ARG(1,2));
1521 mrb_define_class_method(mrb, io, "_sysclose", mrb_io_s_sysclose, MRB_ARGS_REQ(1));
1522 mrb_define_class_method(mrb, io, "for_fd", mrb_io_s_for_fd, MRB_ARGS_ARG(1,2));
1523 mrb_define_class_method(mrb, io, "select", mrb_io_s_select, MRB_ARGS_ARG(1,3));
1524 mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ARG(1,2));
1525#if !defined(_WIN32) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
1526 mrb_define_class_method(mrb, io, "_pipe", mrb_io_s_pipe, MRB_ARGS_NONE());
1527#endif
1528
1529 mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ARG(1,2)); /* 15.2.20.5.21 (x)*/
1530 mrb_define_method(mrb, io, "initialize_copy", mrb_io_initialize_copy, MRB_ARGS_REQ(1));
1531 mrb_define_method(mrb, io, "_check_readable", mrb_io_check_readable, MRB_ARGS_NONE());
1532 mrb_define_method(mrb, io, "isatty", mrb_io_isatty, MRB_ARGS_NONE());
1533 mrb_define_method(mrb, io, "sync", mrb_io_sync, MRB_ARGS_NONE());
1534 mrb_define_method(mrb, io, "sync=", mrb_io_set_sync, MRB_ARGS_REQ(1));
1535 mrb_define_method(mrb, io, "sysread", mrb_io_sysread, MRB_ARGS_ARG(1,1));
1536 mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, MRB_ARGS_ARG(1,1));
1537 mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, MRB_ARGS_REQ(1));
1538 mrb_define_method(mrb, io, "close", mrb_io_close, MRB_ARGS_NONE()); /* 15.2.20.5.1 */
1539 mrb_define_method(mrb, io, "close_write", mrb_io_close_write, MRB_ARGS_NONE());
1540 mrb_define_method(mrb, io, "close_on_exec=", mrb_io_set_close_on_exec, MRB_ARGS_REQ(1));
1541 mrb_define_method(mrb, io, "close_on_exec?", mrb_io_close_on_exec_p, MRB_ARGS_NONE());
1542 mrb_define_method(mrb, io, "closed?", mrb_io_closed, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
1543 mrb_define_method(mrb, io, "pid", mrb_io_pid, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
1544 mrb_define_method(mrb, io, "fileno", mrb_io_fileno_m, MRB_ARGS_NONE());
1545 mrb_define_method(mrb, io, "pread", mrb_io_pread, MRB_ARGS_ANY()); /* ruby 2.5 feature */
1546 mrb_define_method(mrb, io, "pwrite", mrb_io_pwrite, MRB_ARGS_ANY()); /* ruby 2.5 feature */
1547
1548 mrb_define_method(mrb, io, "_readchar", mrb_io_readchar, MRB_ARGS_REQ(1));
1549 mrb_define_class_method(mrb, io, "_bufread", mrb_io_bufread, MRB_ARGS_REQ(2));
1550}
Note: See TracBrowser for help on using the repository browser.