struct termios raw;

if (rawmode) return 0;

//if (!isatty(fd)) goto fatal;

if (tcgetattr(fd, &orig_termios) == -1) goto fatal;

raw = orig_termios; /* modify the original mode */

/* input modes: no break, no CR to NL, no parity check, no strip char,

raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);

/* output modes - disable post processing */

raw.c_oflag &= ~(OPOST);

/* control modes - set 8 bit chars */

raw.c_cflag |= (CS8);

/* local modes - choing off, canonical off, no extended functions,

raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);

/* control chars - set return condition: min number of bytes and timer.

raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */

/* put terminal in raw mode after flushing */

if (tcsetattr(fd, TCSAFLUSH, &raw) < 0) goto fatal;

rawmode = 1;

return 0;

fatal:

errno = ENOTTY;

return -1;

/* Don't even check the return value as it's too late. */

if (rawmode && tcsetattr(fd, TCSAFLUSH, &orig_termios) != -1) {

rawmode = 0;

}

HandleScope scope;

if (args[0]->IsFalse()) {

Stdio::DisableRawMode(STDIN_FILENO);

} else {

if (0 != EnableRawMode(STDIN_FILENO)) {

return ThrowException(ErrnoException(errno, "EnableRawMode"));

}

}

return rawmode ? True() : False();

HandleScope scope;

struct winsize ws;

if (ioctl(1, TIOCGWINSZ, &ws) == -1) {

return scope.Close(Integer::New(80));

}

return scope.Close(Integer::NewFromUnsigned(ws.ws_col));

HandleScope scope;

struct winsize ws;

if (ioctl(1, TIOCGWINSZ, &ws) == -1) {

return scope.Close(Integer::New(132));

}

return scope.Close(Integer::NewFromUnsigned(ws.ws_row));

{

HandleScope scope;

if (args.Length() < 1)

return Undefined();

String::Utf8Value msg(args[0]->ToString());

ssize_t r;

size_t written = 0;

while (written < msg.length()) {

r = write(STDERR_FILENO, (*msg) + written, msg.length() - written);

if (r < 0) {

if (errno == EAGAIN || errno == EIO) {

usleep(100);

continue;

}

return ThrowException(ErrnoException(errno, "write"));

}

written += (size_t)r;

}

return Undefined();

HandleScope scope;

if (isatty(STDIN_FILENO)) {

// XXX selecting on tty fds wont work in windows.

// Must ALWAYS make a coupling on shitty platforms.

stdin_flags = fcntl(STDIN_FILENO, F_GETFL, 0);

if (stdin_flags == -1) {

// TODO DRY

return ThrowException(Exception::Error(String::New("fcntl error!")));

}

int r = fcntl(STDIN_FILENO, F_SETFL, stdin_flags | O_NONBLOCK);

if (r == -1) {

// TODO DRY

return ThrowException(Exception::Error(String::New("fcntl error!")));

}

}

return scope.Close(Integer::New(STDIN_FILENO));

if (isatty(fd)) return false;

struct stat s;

if (fstat(fd, &s)) {

perror("fstat");

return true;

}

if (s.st_mode & S_IFSOCK == S_IFSOCK) return false;

if (s.st_mode & S_IFIFO == S_IFIFO) return false;

return true;

if (stdin_flags != -1) {

fcntl(STDIN_FILENO, F_SETFL, stdin_flags & ~O_NONBLOCK);

}

if (stdout_flags != -1) {

fcntl(STDOUT_FILENO, F_SETFL, stdout_flags & ~O_NONBLOCK);

}

fflush(stdout);

fflush(stderr);

if (rawmode) {

rawmode = 0;

EnableRawMode(STDIN_FILENO);

}

HandleScope scope;

if (isatty(STDOUT_FILENO)) {

// XXX selecting on tty fds wont work in windows.

// Must ALWAYS make a coupling on shitty platforms.

stdout_flags = fcntl(STDOUT_FILENO, F_GETFL, 0);

int r = fcntl(STDOUT_FILENO, F_SETFL, stdout_flags | O_NONBLOCK);

}

target->Set(String::NewSymbol("stdoutFD"), Integer::New(STDOUT_FILENO));

target->Set(String::NewSymbol("stderrFD"), Integer::New(STDERR_FILENO));

target->Set(String::NewSymbol("stdinFD"), Integer::New(STDIN_FILENO));

NODE_SET_METHOD(target, "writeError", WriteError);

NODE_SET_METHOD(target, "openStdin", OpenStdin);

NODE_SET_METHOD(target, "isStdoutBlocking", IsStdoutBlocking);

NODE_SET_METHOD(target, "isStdinBlocking", IsStdinBlocking);

NODE_SET_METHOD(target, "setRawMode", SetRawMode);

NODE_SET_METHOD(target, "getColumns", GetColumns);

NODE_SET_METHOD(target, "getRows", GetRows);

struct sigaction sa = {0};

sa.sa_handler = HandleSIGCONT;

sigaction(SIGCONT, &sa, NULL);