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

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

ファイルを追加、更新。
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
  • Property svn:mime-type set to text/x-csrc
File size: 26.2 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
14#if MRUBY_RELEASE_NO < 10000
15#include "error.h"
16#else
17#include "mruby/error.h"
18#endif
19
20#include <sys/types.h>
21#include <sys/stat.h>
22
23#if defined(_WIN32) || defined(_WIN64)
24 #include <winsock.h>
25 #include <io.h>
26 #define open _open
27 #define close _close
28 #define read _read
29 #define write _write
30 #define lseek _lseek
31#else
32 #include <sys/wait.h>
33 #include <unistd.h>
34#endif
35
36#include <fcntl.h>
37
38#include <errno.h>
39#include <stdio.h>
40#include <string.h>
41
42
43static void mrb_io_free(mrb_state *mrb, void *ptr);
44struct mrb_data_type mrb_io_type = { "IO", mrb_io_free };
45
46
47static struct mrb_io *io_get_open_fptr(mrb_state *mrb, mrb_value self);
48static int mrb_io_modestr_to_flags(mrb_state *mrb, const char *modestr);
49static int mrb_io_flags_to_modenum(mrb_state *mrb, int flags);
50static void fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet);
51
52#if MRUBY_RELEASE_NO < 10000
53static struct RClass *
54mrb_module_get(mrb_state *mrb, const char *name)
55{
56 return mrb_class_get(mrb, name);
57}
58#endif
59
60static struct mrb_io *
61io_get_open_fptr(mrb_state *mrb, mrb_value self)
62{
63 struct mrb_io *fptr;
64
65 fptr = (struct mrb_io *)mrb_get_datatype(mrb, self, &mrb_io_type);
66 if (fptr->fd < 0) {
67 mrb_raise(mrb, E_IO_ERROR, "closed stream.");
68 }
69 return fptr;
70}
71
72#if !defined(_WIN32) && !defined(_WIN64)
73static void
74io_set_process_status(mrb_state *mrb, pid_t pid, int status)
75{
76 struct RClass *c_process, *c_status;
77 mrb_value v;
78
79 c_status = NULL;
80 if (mrb_class_defined(mrb, "Process")) {
81 c_process = mrb_module_get(mrb, "Process");
82 if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) {
83 c_status = mrb_class_get_under(mrb, c_process, "Status");
84 }
85 }
86 if (c_status != NULL) {
87 v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
88 } else {
89 v = mrb_fixnum_value(WEXITSTATUS(status));
90 }
91 mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$?"), v);
92}
93#endif
94
95static int
96mrb_io_modestr_to_flags(mrb_state *mrb, const char *mode)
97{
98 int flags = 0;
99 const char *m = mode;
100
101 switch (*m++) {
102 case 'r':
103 flags |= FMODE_READABLE;
104 break;
105 case 'w':
106 flags |= FMODE_WRITABLE | FMODE_CREATE | FMODE_TRUNC;
107 break;
108 case 'a':
109 flags |= FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE;
110 break;
111 default:
112 mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %S", mrb_str_new_cstr(mrb, mode));
113 }
114
115 while (*m) {
116 switch (*m++) {
117 case 'b':
118 flags |= FMODE_BINMODE;
119 break;
120 case '+':
121 flags |= FMODE_READWRITE;
122 break;
123 case ':':
124 /* XXX: PASSTHROUGH*/
125 default:
126 mrb_raisef(mrb, E_ARGUMENT_ERROR, "illegal access mode %S", mrb_str_new_cstr(mrb, mode));
127 }
128 }
129
130 return flags;
131}
132
133static int
134mrb_io_flags_to_modenum(mrb_state *mrb, int flags)
135{
136 int modenum = 0;
137
138 switch(flags & (FMODE_READABLE|FMODE_WRITABLE|FMODE_READWRITE)) {
139 case FMODE_READABLE:
140 modenum = O_RDONLY;
141 break;
142 case FMODE_WRITABLE:
143 modenum = O_WRONLY;
144 break;
145 case FMODE_READWRITE:
146 modenum = O_RDWR;
147 break;
148 }
149
150 if (flags & FMODE_APPEND) {
151 modenum |= O_APPEND;
152 }
153 if (flags & FMODE_TRUNC) {
154 modenum |= O_TRUNC;
155 }
156 if (flags & FMODE_CREATE) {
157 modenum |= O_CREAT;
158 }
159#ifdef O_BINARY
160 if (flags & FMODE_BINMODE) {
161 modenum |= O_BINARY;
162 }
163#endif
164
165 return modenum;
166}
167
168void
169mrb_fd_cloexec(mrb_state *mrb, int fd)
170{
171#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
172 int flags, flags2;
173
174 flags = fcntl(fd, F_GETFD);
175 if (flags == -1) {
176 mrb_sys_fail(mrb, "fcntl");
177 }
178 if (fd <= 2) {
179 flags2 = flags & ~FD_CLOEXEC; /* Clear CLOEXEC for standard file descriptors: 0, 1, 2. */
180 }
181 else {
182 flags2 = flags | FD_CLOEXEC; /* Set CLOEXEC for non-standard file descriptors: 3, 4, 5, ... */
183 }
184 if (flags != flags2) {
185 if (fcntl(fd, F_SETFD, flags2) == -1) {
186 mrb_sys_fail(mrb, "fcntl");
187 }
188 }
189#endif
190}
191
192#if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
193static int
194mrb_cloexec_pipe(mrb_state *mrb, int fildes[2])
195{
196 int ret;
197 ret = pipe(fildes);
198 if (ret == -1)
199 return -1;
200 mrb_fd_cloexec(mrb, fildes[0]);
201 mrb_fd_cloexec(mrb, fildes[1]);
202 return ret;
203}
204
205static int
206mrb_pipe(mrb_state *mrb, int pipes[2])
207{
208 int ret;
209 ret = mrb_cloexec_pipe(mrb, pipes);
210 if (ret == -1) {
211 if (errno == EMFILE || errno == ENFILE) {
212 mrb_garbage_collect(mrb);
213 ret = mrb_cloexec_pipe(mrb, pipes);
214 }
215 }
216 return ret;
217}
218
219static int
220mrb_proc_exec(const char *pname)
221{
222 const char *s;
223 s = pname;
224
225 while (*s == ' ' || *s == '\t' || *s == '\n')
226 s++;
227
228 if (!*s) {
229 errno = ENOENT;
230 return -1;
231 }
232
233 execl("/bin/sh", "sh", "-c", pname, (char *)NULL);
234 return -1;
235}
236#endif
237
238static void
239mrb_io_free(mrb_state *mrb, void *ptr)
240{
241 struct mrb_io *io = (struct mrb_io *)ptr;
242 if (io != NULL) {
243 fptr_finalize(mrb, io, TRUE);
244 mrb_free(mrb, io);
245 }
246}
247
248static struct mrb_io *
249mrb_io_alloc(mrb_state *mrb)
250{
251 struct mrb_io *fptr;
252
253 fptr = (struct mrb_io *)mrb_malloc(mrb, sizeof(struct mrb_io));
254 fptr->fd = -1;
255 fptr->fd2 = -1;
256 fptr->pid = 0;
257 fptr->readable = 0;
258 fptr->writable = 0;
259 fptr->sync = 0;
260 return fptr;
261}
262
263#ifndef NOFILE
264#define NOFILE 64
265#endif
266
267#if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
268static int
269option_to_fd(mrb_state *mrb, mrb_value obj, const char *key)
270{
271 mrb_value opt = mrb_funcall(mrb, obj, "[]", 1, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))));
272 if (mrb_nil_p(opt)) {
273 return -1;
274 }
275
276 switch (mrb_type(opt)) {
277 case MRB_TT_DATA: /* IO */
278 return mrb_fixnum(mrb_io_fileno(mrb, opt));
279 case MRB_TT_FIXNUM:
280 return mrb_fixnum(opt);
281 default:
282 mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
283 break;
284 }
285 return -1; /* never reached */
286}
287
288mrb_value
289mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
290{
291 mrb_value cmd, io, result;
292 mrb_value mode = mrb_str_new_cstr(mrb, "r");
293 mrb_value opt = mrb_hash_new(mrb);
294
295 struct mrb_io *fptr;
296 const char *pname;
297 int pid, flags, fd, write_fd = -1;
298 int pr[2] = { -1, -1 };
299 int pw[2] = { -1, -1 };
300 int doexec;
301 int saved_errno;
302 int opt_in, opt_out, opt_err;
303
304 mrb_get_args(mrb, "S|SH", &cmd, &mode, &opt);
305 io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
306
307 pname = mrb_string_value_cstr(mrb, &cmd);
308 flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode));
309
310 doexec = (strcmp("-", pname) != 0);
311 opt_in = option_to_fd(mrb, opt, "in");
312 opt_out = option_to_fd(mrb, opt, "out");
313 opt_err = option_to_fd(mrb, opt, "err");
314
315 if (flags & FMODE_READABLE) {
316 if (pipe(pr) == -1) {
317 mrb_sys_fail(mrb, "pipe");
318 }
319 mrb_fd_cloexec(mrb, pr[0]);
320 mrb_fd_cloexec(mrb, pr[1]);
321 }
322
323 if (flags & FMODE_WRITABLE) {
324 if (pipe(pw) == -1) {
325 if (pr[0] != -1) close(pr[0]);
326 if (pr[1] != -1) close(pr[1]);
327 mrb_sys_fail(mrb, "pipe");
328 }
329 mrb_fd_cloexec(mrb, pw[0]);
330 mrb_fd_cloexec(mrb, pw[1]);
331 }
332
333 if (!doexec) {
334 // XXX
335 fflush(stdin);
336 fflush(stdout);
337 fflush(stderr);
338 }
339
340 result = mrb_nil_value();
341 switch (pid = fork()) {
342 case 0: /* child */
343 if (opt_in != -1) {
344 dup2(opt_in, 0);
345 }
346 if (opt_out != -1) {
347 dup2(opt_out, 1);
348 }
349 if (opt_err != -1) {
350 dup2(opt_err, 2);
351 }
352 if (flags & FMODE_READABLE) {
353 close(pr[0]);
354 if (pr[1] != 1) {
355 dup2(pr[1], 1);
356 close(pr[1]);
357 }
358 }
359 if (flags & FMODE_WRITABLE) {
360 close(pw[1]);
361 if (pw[0] != 0) {
362 dup2(pw[0], 0);
363 close(pw[0]);
364 }
365 }
366 if (doexec) {
367 for (fd = 3; fd < NOFILE; fd++) {
368 close(fd);
369 }
370 mrb_proc_exec(pname);
371 mrb_raisef(mrb, E_IO_ERROR, "command not found: %S", cmd);
372 _exit(127);
373 }
374 result = mrb_nil_value();
375 break;
376
377 default: /* parent */
378 if ((flags & FMODE_READABLE) && (flags & FMODE_WRITABLE)) {
379 close(pr[1]);
380 fd = pr[0];
381 close(pw[0]);
382 write_fd = pw[1];
383 } else if (flags & FMODE_READABLE) {
384 close(pr[1]);
385 fd = pr[0];
386 } else {
387 close(pw[0]);
388 fd = pw[1];
389 }
390
391 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
392 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
393
394 fptr = mrb_io_alloc(mrb);
395 fptr->fd = fd;
396 fptr->fd2 = write_fd;
397 fptr->pid = pid;
398 fptr->readable = ((flags & FMODE_READABLE) != 0);
399 fptr->writable = ((flags & FMODE_WRITABLE) != 0);
400 fptr->sync = 0;
401
402 DATA_TYPE(io) = &mrb_io_type;
403 DATA_PTR(io) = fptr;
404 result = io;
405 break;
406
407 case -1: /* error */
408 saved_errno = errno;
409 if (flags & FMODE_READABLE) {
410 close(pr[0]);
411 close(pr[1]);
412 }
413 if (flags & FMODE_WRITABLE) {
414 close(pw[0]);
415 close(pw[1]);
416 }
417 errno = saved_errno;
418 mrb_sys_fail(mrb, "pipe_open failed.");
419 break;
420 }
421 return result;
422}
423#endif
424
425mrb_value
426mrb_io_initialize(mrb_state *mrb, mrb_value io)
427{
428 struct mrb_io *fptr;
429 mrb_int fd;
430 mrb_value mode, opt;
431 int flags;
432
433 mode = opt = mrb_nil_value();
434
435 mrb_get_args(mrb, "i|So", &fd, &mode, &opt);
436 if (mrb_nil_p(mode)) {
437 mode = mrb_str_new_cstr(mrb, "r");
438 }
439 if (mrb_nil_p(opt)) {
440 opt = mrb_hash_new(mrb);
441 }
442
443 flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode));
444
445 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
446 mrb_iv_set(mrb, io, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
447
448 fptr = (struct mrb_io *)DATA_PTR(io);
449 if (fptr != NULL) {
450 fptr_finalize(mrb, fptr, TRUE);
451 mrb_free(mrb, fptr);
452 }
453 fptr = mrb_io_alloc(mrb);
454
455 DATA_TYPE(io) = &mrb_io_type;
456 DATA_PTR(io) = fptr;
457
458 fptr->fd = fd;
459 fptr->readable = ((flags & FMODE_READABLE) != 0);
460 fptr->writable = ((flags & FMODE_WRITABLE) != 0);
461 fptr->sync = 0;
462 return io;
463}
464
465static void
466fptr_finalize(mrb_state *mrb, struct mrb_io *fptr, int quiet)
467{
468 int saved_errno = 0;
469
470 if (fptr == NULL) {
471 return;
472 }
473
474 if (fptr->fd > 2) {
475 if (close(fptr->fd) == -1) {
476 saved_errno = errno;
477 }
478 fptr->fd = -1;
479 }
480
481 if (fptr->fd2 > 2) {
482 if (close(fptr->fd2) == -1) {
483 if (saved_errno == 0) {
484 saved_errno = errno;
485 }
486 }
487 fptr->fd2 = -1;
488 }
489
490#if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
491 if (fptr->pid != 0) {
492 pid_t pid;
493 int status;
494 do {
495 pid = waitpid(fptr->pid, &status, 0);
496 } while (pid == -1 && errno == EINTR);
497 if (!quiet && pid == fptr->pid) {
498 io_set_process_status(mrb, pid, status);
499 }
500 fptr->pid = 0;
501 /* Note: we don't raise an exception when waitpid(3) fails */
502 }
503#endif
504
505 if (!quiet && saved_errno != 0) {
506 errno = saved_errno;
507 mrb_sys_fail(mrb, "fptr_finalize failed.");
508 }
509}
510
511mrb_value
512mrb_io_check_readable(mrb_state *mrb, mrb_value self)
513{
514 struct mrb_io *fptr = io_get_open_fptr(mrb, self);
515 if (! fptr->readable) {
516 mrb_raise(mrb, E_IO_ERROR, "not opened for reading");
517 }
518 return mrb_nil_value();
519}
520
521mrb_value
522mrb_io_isatty(mrb_state *mrb, mrb_value self)
523{
524 struct mrb_io *fptr;
525
526 fptr = io_get_open_fptr(mrb, self);
527 if (isatty(fptr->fd) == 0)
528 return mrb_false_value();
529 return mrb_true_value();
530}
531
532mrb_value
533mrb_io_s_for_fd(mrb_state *mrb, mrb_value klass)
534{
535 struct RClass *c = mrb_class_ptr(klass);
536 enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
537 mrb_value obj;
538
539 /* copied from mrb_instance_alloc() */
540 if (ttype == 0) ttype = MRB_TT_OBJECT;
541 obj = mrb_obj_value((struct RObject*)mrb_obj_alloc(mrb, ttype, c));
542 return mrb_io_initialize(mrb, obj);
543}
544
545mrb_value
546mrb_io_s_sysclose(mrb_state *mrb, mrb_value klass)
547{
548 mrb_int fd;
549 mrb_get_args(mrb, "i", &fd);
550 if (close(fd) == -1) {
551 mrb_sys_fail(mrb, "close");
552 }
553 return mrb_fixnum_value(0);
554}
555
556int
557mrb_cloexec_open(mrb_state *mrb, const char *pathname, mrb_int flags, mrb_int mode)
558{
559 int fd, retry = FALSE;
560
561#ifdef O_CLOEXEC
562 /* O_CLOEXEC is available since Linux 2.6.23. Linux 2.6.18 silently ignore it. */
563 flags |= O_CLOEXEC;
564#elif defined O_NOINHERIT
565 flags |= O_NOINHERIT;
566#endif
567reopen:
568 fd = open(pathname, flags, mode);
569 if (fd == -1) {
570 if (!retry) {
571 switch (errno) {
572 case ENFILE:
573 case EMFILE:
574 mrb_garbage_collect(mrb);
575 retry = TRUE;
576 goto reopen;
577 }
578 }
579 mrb_sys_fail(mrb, "open");
580 }
581
582 if (fd <= 2) {
583 mrb_fd_cloexec(mrb, fd);
584 }
585 return fd;
586}
587
588mrb_value
589mrb_io_s_sysopen(mrb_state *mrb, mrb_value klass)
590{
591 mrb_value path = mrb_nil_value();
592 mrb_value mode = mrb_nil_value();
593 mrb_int fd, flags, perm = -1;
594 const char *pat;
595 int modenum;
596
597 mrb_get_args(mrb, "S|Si", &path, &mode, &perm);
598 if (mrb_nil_p(mode)) {
599 mode = mrb_str_new_cstr(mrb, "r");
600 }
601 if (perm < 0) {
602 perm = 0666;
603 }
604
605 pat = mrb_string_value_cstr(mrb, &path);
606 flags = mrb_io_modestr_to_flags(mrb, mrb_string_value_cstr(mrb, &mode));
607 modenum = mrb_io_flags_to_modenum(mrb, flags);
608 fd = mrb_cloexec_open(mrb, pat, modenum, perm);
609 return mrb_fixnum_value(fd);
610}
611
612mrb_value
613mrb_io_sysread(mrb_state *mrb, mrb_value io)
614{
615 struct mrb_io *fptr;
616 mrb_value buf = mrb_nil_value();
617 mrb_int maxlen;
618 int ret;
619
620 mrb_get_args(mrb, "i|S", &maxlen, &buf);
621 if (maxlen < 0) {
622 return mrb_nil_value();
623 }
624
625 if (mrb_nil_p(buf)) {
626 buf = mrb_str_new(mrb, NULL, maxlen);
627 }
628 if (RSTRING_LEN(buf) != maxlen) {
629 buf = mrb_str_resize(mrb, buf, maxlen);
630 }
631
632 fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
633 ret = read(fptr->fd, RSTRING_PTR(buf), maxlen);
634 switch (ret) {
635 case 0: /* EOF */
636 if (maxlen == 0) {
637 buf = mrb_str_new_cstr(mrb, "");
638 } else {
639 mrb_raise(mrb, E_EOF_ERROR, "sysread failed: End of File");
640 }
641 break;
642 case -1: /* Error */
643 mrb_sys_fail(mrb, "sysread failed");
644 break;
645 default:
646 if (RSTRING_LEN(buf) != ret) {
647 buf = mrb_str_resize(mrb, buf, ret);
648 }
649 break;
650 }
651
652 return buf;
653}
654
655mrb_value
656mrb_io_sysseek(mrb_state *mrb, mrb_value io)
657{
658 struct mrb_io *fptr;
659 off_t pos;
660 mrb_int offset, whence = -1;
661
662 mrb_get_args(mrb, "i|i", &offset, &whence);
663 if (whence < 0) {
664 whence = 0;
665 }
666
667 fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
668 pos = lseek(fptr->fd, offset, whence);
669 if (pos == -1) {
670 mrb_sys_fail(mrb, "sysseek");
671 }
672 if (pos > MRB_INT_MAX) {
673 return mrb_float_value(mrb, (mrb_float)pos);
674 } else {
675 return mrb_fixnum_value(pos);
676 }
677}
678
679mrb_value
680mrb_io_syswrite(mrb_state *mrb, mrb_value io)
681{
682 struct mrb_io *fptr;
683 mrb_value str, buf;
684 int fd, length;
685
686 fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
687 if (! fptr->writable) {
688 mrb_raise(mrb, E_IO_ERROR, "not opened for writing");
689 }
690
691 mrb_get_args(mrb, "S", &str);
692 if (mrb_type(str) != MRB_TT_STRING) {
693 buf = mrb_funcall(mrb, str, "to_s", 0);
694 } else {
695 buf = str;
696 }
697
698 if (fptr->fd2 == -1) {
699 fd = fptr->fd;
700 } else {
701 fd = fptr->fd2;
702 }
703 length = write(fd, RSTRING_PTR(buf), RSTRING_LEN(buf));
704
705 return mrb_fixnum_value(length);
706}
707
708mrb_value
709mrb_io_close(mrb_state *mrb, mrb_value self)
710{
711 struct mrb_io *fptr;
712 fptr = io_get_open_fptr(mrb, self);
713 fptr_finalize(mrb, fptr, FALSE);
714 return mrb_nil_value();
715}
716
717mrb_value
718mrb_io_closed(mrb_state *mrb, mrb_value io)
719{
720 struct mrb_io *fptr;
721 fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
722 if (fptr->fd >= 0) {
723 return mrb_false_value();
724 }
725
726 return mrb_true_value();
727}
728
729mrb_value
730mrb_io_pid(mrb_state *mrb, mrb_value io)
731{
732 struct mrb_io *fptr;
733 fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
734
735 if (fptr->pid > 0) {
736 return mrb_fixnum_value(fptr->pid);
737 }
738
739 return mrb_nil_value();
740}
741
742static struct timeval
743time2timeval(mrb_state *mrb, mrb_value time)
744{
745 struct timeval t = { 0, 0 };
746
747 switch (mrb_type(time)) {
748 case MRB_TT_FIXNUM:
749 t.tv_sec = mrb_fixnum(time);
750 t.tv_usec = 0;
751 break;
752
753 case MRB_TT_FLOAT:
754 t.tv_sec = mrb_float(time);
755 t.tv_usec = (mrb_float(time) - t.tv_sec) * 1000000.0;
756 break;
757
758 default:
759 mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
760 }
761
762 return t;
763}
764
765static int
766mrb_io_read_data_pending(mrb_state *mrb, mrb_value io)
767{
768 mrb_value buf = mrb_iv_get(mrb, io, mrb_intern_cstr(mrb, "@buf"));
769 if (mrb_type(buf) == MRB_TT_STRING && RSTRING_LEN(buf) > 0) {
770 return 1;
771 }
772 return 0;
773}
774
775#if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
776static mrb_value
777mrb_io_s_pipe(mrb_state *mrb, mrb_value klass)
778{
779 mrb_value r = mrb_nil_value();
780 mrb_value w = mrb_nil_value();
781 struct mrb_io *fptr_r;
782 struct mrb_io *fptr_w;
783 int pipes[2];
784
785 if (mrb_pipe(mrb, pipes) == -1) {
786 mrb_sys_fail(mrb, "pipe");
787 }
788
789 r = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
790 mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
791 mrb_iv_set(mrb, r, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
792 fptr_r = mrb_io_alloc(mrb);
793 fptr_r->fd = pipes[0];
794 fptr_r->readable = 1;
795 fptr_r->writable = 0;
796 fptr_r->sync = 0;
797 DATA_TYPE(r) = &mrb_io_type;
798 DATA_PTR(r) = fptr_r;
799
800 w = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
801 mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@buf"), mrb_str_new_cstr(mrb, ""));
802 mrb_iv_set(mrb, w, mrb_intern_cstr(mrb, "@pos"), mrb_fixnum_value(0));
803 fptr_w = mrb_io_alloc(mrb);
804 fptr_w->fd = pipes[1];
805 fptr_w->readable = 0;
806 fptr_w->writable = 1;
807 fptr_w->sync = 1;
808 DATA_TYPE(w) = &mrb_io_type;
809 DATA_PTR(w) = fptr_w;
810
811 return mrb_assoc_new(mrb, r, w);
812}
813#endif
814
815static mrb_value
816mrb_io_s_select(mrb_state *mrb, mrb_value klass)
817{
818 mrb_value *argv;
819 mrb_int argc;
820 mrb_value read, read_io, write, except, timeout, list;
821 struct timeval *tp, timerec;
822 fd_set pset, rset, wset, eset;
823 fd_set *rp, *wp, *ep;
824 struct mrb_io *fptr;
825 int pending = 0;
826 mrb_value result;
827 int max = 0;
828 int interrupt_flag = 0;
829 int i, n;
830
831 mrb_get_args(mrb, "*", &argv, &argc);
832
833 if (argc < 1 || argc > 4) {
834 mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1..4)", mrb_fixnum_value(argc));
835 }
836
837 timeout = mrb_nil_value();
838 except = mrb_nil_value();
839 write = mrb_nil_value();
840 if (argc > 3)
841 timeout = argv[3];
842 if (argc > 2)
843 except = argv[2];
844 if (argc > 1)
845 write = argv[1];
846 read = argv[0];
847
848 if (mrb_nil_p(timeout)) {
849 tp = NULL;
850 } else {
851 timerec = time2timeval(mrb, timeout);
852 tp = &timerec;
853 }
854
855 FD_ZERO(&pset);
856 if (!mrb_nil_p(read)) {
857 mrb_check_type(mrb, read, MRB_TT_ARRAY);
858 rp = &rset;
859 FD_ZERO(rp);
860 for (i = 0; i < RARRAY_LEN(read); i++) {
861 read_io = RARRAY_PTR(read)[i];
862 fptr = (struct mrb_io *)mrb_get_datatype(mrb, read_io, &mrb_io_type);
863 FD_SET(fptr->fd, rp);
864 if (mrb_io_read_data_pending(mrb, read_io)) {
865 pending++;
866 FD_SET(fptr->fd, &pset);
867 }
868 if (max < fptr->fd)
869 max = fptr->fd;
870 }
871 if (pending) {
872 timerec.tv_sec = timerec.tv_usec = 0;
873 tp = &timerec;
874 }
875 } else {
876 rp = NULL;
877 }
878
879 if (!mrb_nil_p(write)) {
880 mrb_check_type(mrb, write, MRB_TT_ARRAY);
881 wp = &wset;
882 FD_ZERO(wp);
883 for (i = 0; i < RARRAY_LEN(write); i++) {
884 fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(write)[i], &mrb_io_type);
885 FD_SET(fptr->fd, wp);
886 if (max < fptr->fd)
887 max = fptr->fd;
888 if (fptr->fd2 >= 0) {
889 FD_SET(fptr->fd2, wp);
890 if (max < fptr->fd2)
891 max = fptr->fd2;
892 }
893 }
894 } else {
895 wp = NULL;
896 }
897
898 if (!mrb_nil_p(except)) {
899 mrb_check_type(mrb, except, MRB_TT_ARRAY);
900 ep = &eset;
901 FD_ZERO(ep);
902 for (i = 0; i < RARRAY_LEN(except); i++) {
903 fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(except)[i], &mrb_io_type);
904 FD_SET(fptr->fd, ep);
905 if (max < fptr->fd)
906 max = fptr->fd;
907 if (fptr->fd2 >= 0) {
908 FD_SET(fptr->fd2, ep);
909 if (max < fptr->fd2)
910 max = fptr->fd2;
911 }
912 }
913 } else {
914 ep = NULL;
915 }
916
917 max++;
918
919retry:
920 n = select(max, rp, wp, ep, tp);
921 if (n < 0) {
922 if (errno != EINTR)
923 mrb_sys_fail(mrb, "select failed");
924 if (tp == NULL)
925 goto retry;
926 interrupt_flag = 1;
927 }
928
929 if (!pending && n == 0)
930 return mrb_nil_value();
931
932 result = mrb_ary_new_capa(mrb, 3);
933 mrb_ary_push(mrb, result, rp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
934 mrb_ary_push(mrb, result, wp? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
935 mrb_ary_push(mrb, result, ep? mrb_ary_new(mrb) : mrb_ary_new_capa(mrb, 0));
936
937 if (interrupt_flag == 0) {
938 if (rp) {
939 list = RARRAY_PTR(result)[0];
940 for (i = 0; i < RARRAY_LEN(read); i++) {
941 fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(read)[i], &mrb_io_type);
942 if (FD_ISSET(fptr->fd, rp) ||
943 FD_ISSET(fptr->fd, &pset)) {
944 mrb_ary_push(mrb, list, RARRAY_PTR(read)[i]);
945 }
946 }
947 }
948
949 if (wp) {
950 list = RARRAY_PTR(result)[1];
951 for (i = 0; i < RARRAY_LEN(write); i++) {
952 fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(write)[i], &mrb_io_type);
953 if (FD_ISSET(fptr->fd, wp)) {
954 mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
955 } else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, wp)) {
956 mrb_ary_push(mrb, list, RARRAY_PTR(write)[i]);
957 }
958 }
959 }
960
961 if (ep) {
962 list = RARRAY_PTR(result)[2];
963 for (i = 0; i < RARRAY_LEN(except); i++) {
964 fptr = (struct mrb_io *)mrb_get_datatype(mrb, RARRAY_PTR(except)[i], &mrb_io_type);
965 if (FD_ISSET(fptr->fd, ep)) {
966 mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
967 } else if (fptr->fd2 >= 0 && FD_ISSET(fptr->fd2, ep)) {
968 mrb_ary_push(mrb, list, RARRAY_PTR(except)[i]);
969 }
970 }
971 }
972 }
973
974 return result;
975}
976
977mrb_value
978mrb_io_fileno(mrb_state *mrb, mrb_value io)
979{
980 struct mrb_io *fptr;
981 fptr = (struct mrb_io *)mrb_get_datatype(mrb, io, &mrb_io_type);
982 return mrb_fixnum_value(fptr->fd);
983}
984
985mrb_value
986mrb_io_close_on_exec_p(mrb_state *mrb, mrb_value self)
987{
988#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
989 struct mrb_io *fptr;
990 int ret;
991
992 fptr = io_get_open_fptr(mrb, self);
993
994 if (fptr->fd2 >= 0) {
995 if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
996 if (!(ret & FD_CLOEXEC)) return mrb_false_value();
997 }
998
999 if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1000 if (!(ret & FD_CLOEXEC)) return mrb_false_value();
1001 return mrb_true_value();
1002
1003#else
1004 mrb_raise(mrb, E_NOTIMP_ERROR, "IO#close_on_exec? is not supported on the platform");
1005 return mrb_false_value();
1006#endif
1007}
1008
1009mrb_value
1010mrb_io_set_close_on_exec(mrb_state *mrb, mrb_value self)
1011{
1012#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
1013 struct mrb_io *fptr;
1014 int flag, ret;
1015 mrb_bool b;
1016
1017 fptr = io_get_open_fptr(mrb, self);
1018 mrb_get_args(mrb, "b", &b);
1019 flag = b ? FD_CLOEXEC : 0;
1020
1021 if (fptr->fd2 >= 0) {
1022 if ((ret = fcntl(fptr->fd2, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1023 if ((ret & FD_CLOEXEC) != flag) {
1024 ret = (ret & ~FD_CLOEXEC) | flag;
1025 ret = fcntl(fptr->fd2, F_SETFD, ret);
1026
1027 if (ret == -1) mrb_sys_fail(mrb, "F_SETFD failed");
1028 }
1029 }
1030
1031 if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) mrb_sys_fail(mrb, "F_GETFD failed");
1032 if ((ret & FD_CLOEXEC) != flag) {
1033 ret = (ret & ~FD_CLOEXEC) | flag;
1034 ret = fcntl(fptr->fd, F_SETFD, ret);
1035 if (ret == -1) mrb_sys_fail(mrb, "F_SETFD failed");
1036 }
1037
1038 return mrb_bool_value(b);
1039#else
1040 mrb_raise(mrb, E_NOTIMP_ERROR, "IO#close_on_exec= is not supported on the platform");
1041 return mrb_nil_value();
1042#endif
1043}
1044
1045mrb_value
1046mrb_io_set_sync(mrb_state *mrb, mrb_value self)
1047{
1048 struct mrb_io *fptr;
1049 mrb_bool b;
1050
1051 fptr = io_get_open_fptr(mrb, self);
1052 mrb_get_args(mrb, "b", &b);
1053 fptr->sync = b;
1054 return mrb_bool_value(b);
1055}
1056
1057mrb_value
1058mrb_io_sync(mrb_state *mrb, mrb_value self)
1059{
1060 struct mrb_io *fptr;
1061 fptr = io_get_open_fptr(mrb, self);
1062 return mrb_bool_value(fptr->sync);
1063}
1064
1065void
1066mrb_init_io(mrb_state *mrb)
1067{
1068 struct RClass *io;
1069
1070 io = mrb_define_class(mrb, "IO", mrb->object_class);
1071 MRB_SET_INSTANCE_TT(io, MRB_TT_DATA);
1072
1073 mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
1074#if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
1075 mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, MRB_ARGS_ANY());
1076 mrb_define_class_method(mrb, io, "_sysclose", mrb_io_s_sysclose, MRB_ARGS_REQ(1));
1077#endif
1078 mrb_define_class_method(mrb, io, "for_fd", mrb_io_s_for_fd, MRB_ARGS_ANY());
1079 mrb_define_class_method(mrb, io, "select", mrb_io_s_select, MRB_ARGS_ANY());
1080 mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ANY());
1081#if !defined(_WIN32) && !defined(_WIN64) && !defined(__NEWLIB__)
1082 mrb_define_class_method(mrb, io, "_pipe", mrb_io_s_pipe, MRB_ARGS_NONE());
1083#endif
1084
1085 mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ANY()); /* 15.2.20.5.21 (x)*/
1086 mrb_define_method(mrb, io, "_check_readable", mrb_io_check_readable, MRB_ARGS_NONE());
1087 mrb_define_method(mrb, io, "isatty", mrb_io_isatty, MRB_ARGS_NONE());
1088 mrb_define_method(mrb, io, "sync", mrb_io_sync, MRB_ARGS_NONE());
1089 mrb_define_method(mrb, io, "sync=", mrb_io_set_sync, MRB_ARGS_REQ(1));
1090 mrb_define_method(mrb, io, "sysread", mrb_io_sysread, MRB_ARGS_ANY());
1091 mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, MRB_ARGS_REQ(1));
1092 mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, MRB_ARGS_REQ(1));
1093 mrb_define_method(mrb, io, "close", mrb_io_close, MRB_ARGS_NONE()); /* 15.2.20.5.1 */
1094 mrb_define_method(mrb, io, "close_on_exec=", mrb_io_set_close_on_exec, MRB_ARGS_REQ(1));
1095 mrb_define_method(mrb, io, "close_on_exec?", mrb_io_close_on_exec_p, MRB_ARGS_NONE());
1096 mrb_define_method(mrb, io, "closed?", mrb_io_closed, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
1097 mrb_define_method(mrb, io, "pid", mrb_io_pid, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
1098 mrb_define_method(mrb, io, "fileno", mrb_io_fileno, MRB_ARGS_NONE());
1099
1100
1101 mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$/"), mrb_str_new_cstr(mrb, "\n"));
1102}
Note: See TracBrowser for help on using the repository browser.