Ruby » Ruby master

  * Signal.trap

    See above.

int rb_reserved_fd_p(int fd);

#define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd)

void rb_update_max_fd(int fd);

/* marshal.c */

VALUE rb_marshal_dump(VALUE, VALUE);

VALUE rb_marshal_load(VALUE);

	    if (err != 0) {

		rb_bug_errno("thread_timer: Failed to create communication pipe for timer thread", errno);

	    }

#if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(F_SETFL)

	    {

		int oflags;

    if (max_file_descriptor < fd) max_file_descriptor = fd;

}

#define argf_of(obj) (*(struct argf *)DATA_PTR(obj))

#define ARGF argf_of(argf)

	    rb_sys_fail(0);

	}

    }

    return fd;

}

    int fd;

    fd = (int)rb_thread_blocking_region(sysopen_func, data, RUBY_UBF_IO, 0);

    if (0 <= fd)

    return fd;

}

    }

#endif

    if (ret == 0) {

    }

    return ret;

}

	    /* need to keep FILE objects of stdin, stdout and stderr */

	    if (dup2(fd2, fd) < 0)

		rb_sys_fail_path(orig->pathv);

	}

	else {

            fclose(fptr->stdio_file);

            fptr->fd = -1;

            if (dup2(fd2, fd) < 0)

                rb_sys_fail_path(orig->pathv);

            fptr->fd = fd;

	}

	rb_thread_fd_close(fd);

    retval = (int)rb_thread_io_blocking_region(nogvl_io_cntl, &arg, fd);

#if defined(F_DUPFD)

    if (!io_p && retval != -1 && cmd == F_DUPFD) {

    }

#endif

    rb_exec_arg_init(argc, argv, TRUE, &earg);

    if (NIL_P(rb_ary_entry(earg.options, EXEC_OPTION_CLOSE_OTHERS)))

    rb_exec_arg_fixup(&earg);

    rb_exec_err(&earg, errmsg, sizeof(errmsg));

            ret = fcntl(fdp[i], F_DUPFD, min);

            if (ret == -1)

                return -1;

            close(fdp[i]);

            fdp[i] = ret;

        }

    chfunc = signal(SIGCHLD, SIG_DFL);

#endif

#if defined(HAVE_FORK) || defined(HAVE_SPAWNV)

    if (pid > 0) {

	rb_syswait(pid);

 *          integer : the file descriptor of specified the integer

 *          io      : the file descriptor specified as io.fileno

 *      file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not

 *

 *  If a hash is given as +env+, the environment is

 *  updated by +env+ before <code>exec(2)</code> in the child process.

    if (ret == -1) return -1;

    if ((fd = open("/dev/tty", O_RDWR)) >= 0) {

	ioctl(fd, TIOCNOTTY, NULL);

	close(fd);

    }

	err = chdir("/");

    if (!noclose && (n = open("/dev/null", O_RDWR, 0)) != -1) {

	(void)dup2(n, 0);

	(void)dup2(n, 1);

	(void)dup2(n, 2);

    {

        int i = open("/dev/tty", O_RDONLY);

        if (i < 0) ERROR_EXIT("/dev/tty");

        if (ioctl(i, TIOCNOTTY, (char *)0))

            ERROR_EXIT("ioctl(TIOCNOTTY)");

        close(i);

    if (slave < 0) {

        ERROR_EXIT("open: pty slave");

    }

    close(master);

#endif

    dup2(slave,0);

    sigemptyset(&dfl.sa_mask);

    if ((masterfd = posix_openpt(O_RDWR|O_NOCTTY)) == -1) goto error;

    if (sigaction(SIGCHLD, &dfl, &old) == -1) goto error;

    if (grantpt(masterfd) == -1) goto grantpt_error;

    if (sigaction(SIGCHLD, &old, NULL) == -1) goto error;

    if ((slavedevice = ptsname(masterfd)) == NULL) goto error;

    if (no_mesg(slavedevice, nomesg) == -1) goto error;

    if ((slavefd = open(slavedevice, O_RDWR|O_NOCTTY, 0)) == -1) goto error;

#if defined I_PUSH && !defined linux

    if (ioctl(slavefd, I_PUSH, "ptem") == -1) goto error;

	if (!fail) return -1;

	rb_raise(rb_eRuntimeError, "openpty() failed");

    }

    if (no_mesg(SlaveName, nomesg) == -1) {

	if (!fail) return -1;

	rb_raise(rb_eRuntimeError, "can't chmod slave pty");

	if (!fail) return -1;

	rb_raise(rb_eRuntimeError, "_getpty() failed");

    }

    *slave = open(name, O_RDWR);

    /* error check? */

    strlcpy(SlaveName, name, DEVICELEN);

    return 0;

    extern int grantpt(int);

    if((masterfd = open("/dev/ptmx", O_RDWR, 0)) == -1) goto error;

    s = signal(SIGCHLD, SIG_DFL);

    if(grantpt(masterfd) == -1) goto error;

    signal(SIGCHLD, s);

    if((slavedevice = ptsname(masterfd)) == NULL) goto error;

    if (no_mesg(slavedevice, nomesg) == -1) goto error;

    if((slavefd = open(slavedevice, O_RDWR, 0)) == -1) goto error;

#if defined I_PUSH && !defined linux

    if(ioctl(slavefd, I_PUSH, "ptem") == -1) goto error;

    if(ioctl(slavefd, I_PUSH, "ldterm") == -1) goto error;

    for (p = deviceNo; *p != NULL; p++) {

	snprintf(MasterName, sizeof MasterName, MasterDevice, *p);

	if ((masterfd = open(MasterName,O_RDWR,0)) >= 0) {

	    *master = masterfd;

	    snprintf(SlaveName, DEVICELEN, SlaveDevice, *p);

	    if ((slavefd = open(SlaveName,O_RDWR,0)) >= 0) {

		*slave = slavefd;

		if (chown(SlaveName, getuid(), getgid()) != 0) goto error;

		if (chmod(SlaveName, nomesg ? 0600 : 0622) != 0) goto error;

    wfptr->fd = dup(info.fd);

    if (wfptr->fd == -1)

        rb_sys_fail("dup()");

    wfptr->pathv = rfptr->pathv;

    res = rb_ary_new2(3);

	if ((fd = dup(FPTR_TO_FD(fptr))) < 0){

	    rb_sys_fail(0);

	}

	if (!(fp = fdopen(fd, "r"))){

	    close(fd);

	    rb_sys_fail(0);

	}

    }

    if (0 <= fd)

    return fd;

}

	}

        rb_sys_fail("accept(2)");

    }

    make_fd_nonblock(fd2);

    return rsock_init_sock(rb_obj_alloc(klass), fd2);

}

	}

	rb_sys_fail(0);

    }

    if (!klass) return INT2NUM(fd2);

    return rsock_init_sock(rb_obj_alloc(klass), fd2);

}

    if (ret < 0) {

	rb_sys_fail("socketpair(2)");

    }

    s1 = rsock_init_sock(rb_obj_alloc(klass), sp[0]);

    s2 = rsock_init_sock(rb_obj_alloc(klass), sp[1]);

        int *end = (int *)((char *)cmh + cmh->cmsg_len);

        while ((char *)fdp + sizeof(int) <= (char *)end &&

               (char *)fdp + sizeof(int) <= msg_end) {

            close(*fdp);

            fdp++;

        }

            VALUE io;

            if (fstat(fd, &stbuf) == -1)

                rb_raise(rb_eSocket, "invalid fd in SCM_RIGHTS");

            if (S_ISSOCK(stbuf.st_mode))

                io = rsock_init_sock(rb_obj_alloc(rb_cSocket), fd);

            else

#if FD_PASSING_BY_MSG_CONTROL

    memcpy(&fd, CMSG_DATA(&cmsg.hdr), sizeof(int));

#endif

    if (klass == Qnil)

	return INT2FIX(fd);

#ifdef CONSOLE_DEVICE_FOR_WRITING

	fd = open(CONSOLE_DEVICE_FOR_WRITING, O_WRONLY);

	if (fd < 0) return Qnil;

	args[1] = INT2FIX(O_WRONLY);

	args[0] = INT2NUM(fd);

	out = rb_class_new_instance(2, args, klass);

#endif

	    return Qnil;

	}

	args[1] = INT2FIX(O_RDWR);

	args[0] = INT2NUM(fd);

	con = rb_class_new_instance(2, args, klass);

	if ((fd = open(fname, mode)) < 0) {

	    rb_load_fail(fname);

	}

	f = rb_io_fdopen(fd, mode, fname);

    }

  def test_close_on_exec

    skip "IO\#close_on_exec is not implemented." unless have_close_on_exec?

    ruby do |f|

      assert_equal(false, f.close_on_exec?)

      f.close_on_exec = true

      assert_equal(true, f.close_on_exec?)

    end

    with_pipe do |r, w|

      assert_equal(false, r.close_on_exec?)

      r.close_on_exec = true

      assert_equal(true, r.close_on_exec?)

      r.close_on_exec = false

      assert_equal(false, r.close_on_exec?)

      assert_equal(false, w.close_on_exec?)

      w.close_on_exec = true

      assert_equal(true, w.close_on_exec?)

  def test_fd_inheritance

    skip "inheritance of fd other than stdin,stdout and stderr is not supported" if windows?

    with_pipe {|r, w|

      w.close

      assert_equal("ba\n", r.read)

    }

	write_file("s", <<-"End")

	  exec(#{RUBY.dump}, '-e',

	       'IO.new(ARGV[0].to_i, "w").puts("bu") rescue nil',

	End

	Process.wait spawn(RUBY, "s", :close_others=>false)

	w.close

	assert_equal("bu\n", r.read)

        File.unlink("err")

      }

      with_pipe {|r, w|

        Process.wait spawn(RUBY, '-e', 'IO.new(ARGV[0].to_i, "w").puts("bi")', w.fileno.to_s, :close_others=>false)

        w.close

        assert_equal("bi\n", r.read)

        Process.wait

      }

      with_pipe {|r, w|

        io = IO.popen([RUBY, "-e", "STDERR.reopen(STDOUT); IO.new(#{w.fileno}, 'w').puts('mo')", :close_others=>false])

        w.close

        errmsg = io.read

        Process.wait

      }

      with_pipe {|r, w|

        io = IO.popen([RUBY, "-e", "STDERR.reopen(STDOUT); IO.new(#{w.fileno}, 'w').puts('mo')", :close_others=>nil])

        w.close

        errmsg = io.read

	if ((tmpfd = open(StringValueCStr(path), 0)) < 0) {

	    rb_sys_fail(RSTRING_PTR(path));

	}

	if (chsize(tmpfd, pos) < 0) {

	    close(tmpfd);

	    rb_sys_fail(RSTRING_PTR(path));

    int ret = 1;

    int fd = open(path, O_RDONLY);

    if (fd == -1) return 0;

#if !defined DOSISH

    {

	struct stat st;

            |O_NOCTTY

#endif

            )) >= 0) {

        if (fstat(fd, &statbuf) == 0 && S_ISCHR(statbuf.st_mode)) {

	    if (read(fd, seed, DEFAULT_SEED_LEN) < DEFAULT_SEED_LEN) {

		/* abandon */;