#ifdef __MINGW32__

unsigned long value = 1;

return (ioctlsocket(_get_osfhandle(fd), FIONBIO, &value) == 0);

#else // __POSIX__

return (fcntl(fd, F_SETFL, O_NONBLOCK) != -1);

#endif

#ifdef __MINGW32__

BOOL flags = TRUE;

setsockopt(_get_osfhandle(fd), SOL_SOCKET, SO_REUSEADDR, (const char *)&flags, sizeof(flags));

return SetNonBlock(fd);

#else // __POSIX__

int flags = 1;

setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));

return SetNonBlock(fd) && SetCloseOnExec(fd);

#endif

HandleScope scope;

int fds[2];

if (pipe(fds) < 0) return ThrowException(ErrnoException(errno, "pipe"));

if (!SetSockFlags(fds[0]) || !SetSockFlags(fds[1])) {

int fcntl_errno = errno;

close(fds[0]);

close(fds[1]);

return ThrowException(ErrnoException(fcntl_errno, "fcntl"));

}

Local<Array> a = Array::New(2);

a->Set(Integer::New(0), Integer::New(fds[0]));

a->Set(Integer::New(1), Integer::New(fds[1]));

return scope.Close(a);

HandleScope scope;

int fds[2];

// XXX support SOCK_DGRAM?

if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {

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

}

if (!SetSockFlags(fds[0]) || !SetSockFlags(fds[1])) {

int fcntl_errno = errno;

close(fds[0]);

close(fds[1]);

return ThrowException(ErrnoException(fcntl_errno, "fcntl"));

}

Local<Array> a = Array::New(2);

a->Set(Integer::New(0), Integer::New(fds[0]));

a->Set(Integer::New(1), Integer::New(fds[1]));

return scope.Close(a);

HandleScope scope;

// default to TCP

int domain = PF_INET;

int type = SOCK_STREAM;

#ifdef SO_REUSEPORT

bool set_reuseport = false;

#endif

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

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

// FIXME optimize this cascade.

if (0 == strcasecmp(*t, "TCP")) {

domain = PF_INET;

type = SOCK_STREAM;

} else if (0 == strcasecmp(*t, "TCP4")) {

domain = PF_INET;

type = SOCK_STREAM;

} else if (0 == strcasecmp(*t, "TCP6")) {

domain = PF_INET6;

type = SOCK_STREAM;

} else if (0 == strcasecmp(*t, "UNIX")) {

domain = PF_UNIX;

type = SOCK_STREAM;

} else if (0 == strcasecmp(*t, "UNIX_DGRAM")) {

domain = PF_UNIX;

type = SOCK_DGRAM;

} else if (0 == strcasecmp(*t, "UDP")) {

domain = PF_INET;

type = SOCK_DGRAM;

#ifdef SO_REUSEPORT

set_reuseport = true;

#endif

} else if (0 == strcasecmp(*t, "UDP4")) {

domain = PF_INET;

type = SOCK_DGRAM;

#ifdef SO_REUSEPORT

set_reuseport = true;

#endif

} else if (0 == strcasecmp(*t, "UDP6")) {

domain = PF_INET6;

type = SOCK_DGRAM;

#ifdef SO_REUSEPORT

set_reuseport = true;

#endif

} else {

return ThrowException(Exception::Error(

String::New("Unknown socket type.")));

}

}

#ifdef __POSIX__

int fd = socket(domain, type, 0);

#else // __MINGW32__

int fd = _open_osfhandle(socket(domain, type, 0), 0);

#endif

if (fd < 0) return ThrowException(ErrnoException(errno, "socket"));

if (!SetSockFlags(fd)) {

int fcntl_errno = errno;

close(fd);

return ThrowException(ErrnoException(fcntl_errno, "fcntl"));

}

#ifdef SO_REUSEPORT

// needed for datagrams to be able to have multiple processes listening to

// e.g. broadcasted datagrams.

if (set_reuseport) {

int flags = 1;

setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, (const char *)&flags,

sizeof(flags));

}

#endif

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

Handle<Value> second,

bool is_bind) {

static struct sockaddr_in in;

static struct sockaddr_in6 in6;

#ifdef __POSIX__ // No unix sockets on windows

static struct sockaddr_un un;

if (first->IsString() && !second->IsString()) {

// UNIX

String::Utf8Value path(first->ToString());

if ((size_t) path.length() >= ARRAY_SIZE(un.sun_path)) {

return Exception::Error(String::New("Socket path too long"));

}

memset(&un, 0, sizeof un);

un.sun_family = AF_UNIX;

memcpy(un.sun_path, *path, path.length());

addr = (struct sockaddr*)&un;

addrlen = sizeof(un) - sizeof(un.sun_path) + path.length() + 1;

} else {

#else // __MINGW32__

if (first->IsString() && !second->IsString()) {

return ErrnoException(errno, "ParseAddressArgs", "Unix sockets are not supported on windows");

} else {

#endif

// TCP or UDP

memset(&in, 0, sizeof in);

memset(&in6, 0, sizeof in6);

int port = first->Int32Value();

in.sin_port = in6.sin6_port = htons(port);

in.sin_family = AF_INET;

in6.sin6_family = AF_INET6;

bool is_ipv4 = true;

if (!second->IsString()) {

in.sin_addr.s_addr = htonl(is_bind ? INADDR_ANY : INADDR_LOOPBACK);

in6.sin6_addr = is_bind ? in6addr_any : in6addr_loopback;

} else {

String::Utf8Value ip(second->ToString());

if (inet_pton(AF_INET, *ip, &(in.sin_addr)) <= 0) {

is_ipv4 = false;

if (inet_pton(AF_INET6, *ip, &(in6.sin6_addr)) <= 0) {

return ErrnoException(errno, "inet_pton", "Invalid IP Address");

}

}

}

addr = is_ipv4 ? (struct sockaddr*)&in : (struct sockaddr*)&in6;

addrlen = is_ipv4 ? sizeof in : sizeof in6;

}

return Handle<Value>();

}

static Handle<Value> Bind(const Arguments& args) {

HandleScope scope;

if (args.Length() < 2) {

return ThrowException(Exception::TypeError(

String::New("Must have at least two args")));

}

FD_ARG(args[0])

Handle<Value> error = ParseAddressArgs(args[1], args[2], true);

if (!error.IsEmpty()) return ThrowException(error);

int flags = 1;

#ifdef __POSIX__

setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&flags, sizeof(flags));

if (0 > bind(fd, addr, addrlen)) {

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

}

#else // __MINGW32__

SOCKET handle = _get_osfhandle(fd);

setsockopt(handle, SOL_SOCKET, SO_REUSEADDR, (char *)&flags, sizeof(flags));

if (SOCKET_ERROR == bind(handle, addr, addrlen)) {

return ThrowException(ErrnoException(WSAGetLastError(), "bind"));

}

#endif // __MINGW32__

return Undefined();

}

static Handle<Value> Close(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

// Windows: this is not a winsock operation, don't use _get_osfhandle here!

if (0 > close(fd)) {

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

}

return Undefined();

}

static Handle<Value> Shutdown(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

int how = SHUT_WR;

if (args[1]->IsString()) {

String::Utf8Value t(args[1]->ToString());

if (0 == strcasecmp(*t, "write")) {

how = SHUT_WR;

} else if (0 == strcasecmp(*t, "read")) {

how = SHUT_RD;

} else if (0 == strcasecmp(*t, "readwrite")) {

how = SHUT_RDWR;

} else {

return ThrowException(Exception::Error(String::New(

"Unknown shutdown method. (Use 'read', 'write', or 'readwrite'.)")));

}

}

#ifdef __POSIX__

if (0 > shutdown(fd, how)) {

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

}

#else // __MINGW32__

if (SOCKET_ERROR == shutdown(_get_osfhandle(fd), how)) {

return ThrowException(ErrnoException(WSAGetLastError(), "shutdown"));

}

#endif // __MINGW32__

return Undefined();

}

static Handle<Value> Connect(const Arguments& args) {

HandleScope scope;

if (args.Length() < 2) {

return ThrowException(Exception::TypeError(

String::New("Must have at least two args")));

}

FD_ARG(args[0])

Handle<Value> error = ParseAddressArgs(args[1], args[2], false);

if (!error.IsEmpty()) return ThrowException(error);

#ifdef __POSIX__

int r = connect(fd, addr, addrlen);

if (r < 0 && errno != EINPROGRESS) {

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

}

#else // __MINGW32__

int r = connect(_get_osfhandle(fd), addr, addrlen);

if (r == SOCKET_ERROR) {

int wsaErrno = WSAGetLastError();

if (wsaErrno != WSAEWOULDBLOCK && wsaErrno != WSAEINPROGRESS) {

return ThrowException(ErrnoException(wsaErrno, "connect"));

}

}

#endif // __MINGW32__

return Undefined();

}

#ifdef __POSIX__

#define ADDRESS_TO_JS(info, address_storage, addrlen) \

do { \

char ip[INET6_ADDRSTRLEN]; \

int port; \

struct sockaddr_in *a4; \

struct sockaddr_in6 *a6; \

struct sockaddr_un *au; \

if (addrlen == 0) { \

(info)->Set(address_symbol, String::Empty()); \

} else { \

switch ((address_storage).ss_family) { \

case AF_INET6: \

a6 = (struct sockaddr_in6*)&(address_storage); \

inet_ntop(AF_INET6, &(a6->sin6_addr), ip, INET6_ADDRSTRLEN); \

port = ntohs(a6->sin6_port); \

(info)->Set(address_symbol, String::New(ip)); \

(info)->Set(port_symbol, Integer::New(port)); \

break; \

case AF_INET: \

a4 = (struct sockaddr_in*)&(address_storage); \

inet_ntop(AF_INET, &(a4->sin_addr), ip, INET6_ADDRSTRLEN); \

port = ntohs(a4->sin_port); \

(info)->Set(address_symbol, String::New(ip)); \

(info)->Set(port_symbol, Integer::New(port)); \

break; \

case AF_UNIX: \

/*

*/ \

au = (struct sockaddr_un*)&(address_storage); \

if (addrlen == sizeof(sa_family_t)) { \

(info)->Set(address_symbol, String::Empty()); \

} else if (addrlen == sizeof(struct sockaddr_un)) { \

/* first byte is '\0' and all remaining bytes are name;

* it is not NUL-terminated and may contain embedded NULs */ \

(info)->Set(address_symbol, String::New(au->sun_path + 1, sizeof(au->sun_path - 1))); \

} else { \

(info)->Set(address_symbol, String::New(au->sun_path)); \

} \

break; \

default: \

(info)->Set(address_symbol, String::Empty()); \

} \

} \

} while (0)

#else // __MINGW32__

#define ADDRESS_TO_JS(info, address_storage, addrlen) \

do { \

char ip[INET6_ADDRSTRLEN]; \

int port; \

struct sockaddr_in *a4; \

struct sockaddr_in6 *a6; \

if (addrlen == 0) { \

(info)->Set(address_symbol, String::Empty()); \

} else { \

switch ((address_storage).ss_family) { \

case AF_INET6: \

a6 = (struct sockaddr_in6*)&(address_storage); \

inet_ntop(AF_INET6, &(a6->sin6_addr), ip, INET6_ADDRSTRLEN); \

port = ntohs(a6->sin6_port); \

(info)->Set(address_symbol, String::New(ip)); \

(info)->Set(port_symbol, Integer::New(port)); \

break; \

case AF_INET: \

a4 = (struct sockaddr_in*)&(address_storage); \

inet_ntop(AF_INET, &(a4->sin_addr), ip, INET6_ADDRSTRLEN); \

port = ntohs(a4->sin_port); \

(info)->Set(address_symbol, String::New(ip)); \

(info)->Set(port_symbol, Integer::New(port)); \

break; \

default: \

(info)->Set(address_symbol, String::Empty()); \

} \

} \

} while (0)

#endif // __MINGW32__

static Handle<Value> GetSockName(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

struct sockaddr_storage address_storage;

socklen_t len = sizeof(struct sockaddr_storage);

#ifdef __POSIX__

if (0 > getsockname(fd, (struct sockaddr *) &address_storage, &len)) {

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

}

#else // __MINGW32__

if (SOCKET_ERROR == getsockname(_get_osfhandle(fd),

(struct sockaddr *) &address_storage, &len)) {

return ThrowException(ErrnoException(WSAGetLastError(), "getsockname"));

}

#endif // __MINGW32__

Local<Object> info = Object::New();

ADDRESS_TO_JS(info, address_storage, len);

return scope.Close(info);

}

static Handle<Value> GetPeerName(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

struct sockaddr_storage address_storage;

socklen_t len = sizeof(struct sockaddr_storage);

#ifdef __POSIX__

if (0 > getpeername(fd, (struct sockaddr *) &address_storage, &len)) {

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

}

#else // __MINGW32__

if (SOCKET_ERROR == getpeername(_get_osfhandle(fd),

(struct sockaddr *) &address_storage, &len)) {

return ThrowException(ErrnoException(WSAGetLastError(), "getpeername"));

}

#endif // __MINGW32__

Local<Object> info = Object::New();

ADDRESS_TO_JS(info, address_storage, len);

return scope.Close(info);

}

static Handle<Value> Listen(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

int backlog = args[1]->IsInt32() ? args[1]->Int32Value() : 128;

#ifdef __POSIX__

if (0 > listen(fd, backlog)) {

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

}

#else // __MINGW32__

if (SOCKET_ERROR == listen(_get_osfhandle(fd), backlog)) {

return ThrowException(ErrnoException(WSAGetLastError(), "listen"));

}

#endif

return Undefined();

}

static Handle<Value> Accept(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

struct sockaddr_storage address_storage;

socklen_t len = sizeof(struct sockaddr_storage);

#ifdef __POSIX__

int peer_fd = accept(fd, (struct sockaddr*) &address_storage, &len);

if (peer_fd < 0) {

if (errno == EAGAIN) return scope.Close(Null());

if (errno == ECONNABORTED) return scope.Close(Null());

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

}

#else // __MINGW32__

SOCKET peer_handle = accept(_get_osfhandle(fd), (struct sockaddr*) &address_storage, &len);

if (peer_handle == INVALID_SOCKET) {

int wsaErrno = WSAGetLastError();

if (wsaErrno == WSAEWOULDBLOCK) return scope.Close(Null());

return ThrowException(ErrnoException(wsaErrno, "accept"));

}

int peer_fd = _open_osfhandle(peer_handle, 0);

#endif // __MINGW32__

if (!SetSockFlags(peer_fd)) {

#ifdef __POSIX__

int fcntl_errno = errno;

#else // __MINGW32__

int fcntl_errno = WSAGetLastError();

#endif // __MINGW32__

close(peer_fd);

return ThrowException(ErrnoException(fcntl_errno, "fcntl"));

}

Local<Object> peer_info = Object::New();

peer_info->Set(fd_symbol, Integer::New(peer_fd));

ADDRESS_TO_JS(peer_info, address_storage, len);

return scope.Close(peer_info);

}

static Handle<Value> SocketError(const Arguments& args) {

HandleScope scope;

FD_ARG(args[0])

int error;

socklen_t len = sizeof(int);

#ifdef __POSIX__

int r = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);

if (r < 0) {

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

}

#else // __MINGW32__

int r = getsockopt(_get_osfhandle(fd), SOL_SOCKET, SO_ERROR, (char*)&error, &len);

if (r < 0) {

return ThrowException(ErrnoException(WSAGetLastError(), "getsockopt"));

}

#endif

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

}

static Handle<Value> Read(const Arguments& args) {

HandleScope scope;

if (args.Length() < 4) {

return ThrowException(Exception::TypeError(

String::New("Takes 4 parameters")));

}

FD_ARG(args[0])

if (!Buffer::HasInstance(args[1])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[1]->ToObject();

char *buffer_data = Buffer::Data(buffer_obj);

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[2]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[3]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

#ifdef __POSIX__

ssize_t bytes_read = read(fd, (char*)buffer_data + off, len);

if (bytes_read < 0) {

if (errno == EAGAIN || errno == EINTR) return Null();

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

}

#else // __MINGW32__

// read() doesn't work for overlapped sockets (the only usable

// type of sockets) so recv() is used here.

ssize_t bytes_read = recv(_get_osfhandle(fd), (char*)buffer_data + off, len, 0);

if (bytes_read < 0) {

int wsaErrno = WSAGetLastError();

if (wsaErrno == WSAEWOULDBLOCK || wsaErrno == WSAEINTR) return Null();

return ThrowException(ErrnoException(wsaErrno, "read"));

}

#endif

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

}

static Handle<Value> RecvFrom(const Arguments& args) {

HandleScope scope;

if (args.Length() < 5) {

return ThrowException(Exception::TypeError(

String::New("Takes 5 parameters")));

}

FD_ARG(args[0])

if (!Buffer::HasInstance(args[1])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[1]->ToObject();

char *buffer_data = Buffer::Data(buffer_obj);

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[2]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[3]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

int flags = args[4]->Int32Value();

struct sockaddr_storage address_storage;

socklen_t addrlen = sizeof(struct sockaddr_storage);

#ifdef __POSIX__

ssize_t bytes_read = recvfrom(fd, (char*)buffer_data + off, len, flags,

(struct sockaddr*) &address_storage, &addrlen);

if (bytes_read < 0) {

if (errno == EAGAIN || errno == EINTR) return Null();

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

}

#else // __MINGW32__

ssize_t bytes_read = recvfrom(_get_osfhandle(fd), (char*)buffer_data + off,

len, flags, (struct sockaddr*) &address_storage, &addrlen);

if (bytes_read == SOCKET_ERROR) {

int wsaErrno = WSAGetLastError();

if (wsaErrno == WSAEWOULDBLOCK || wsaErrno == WSAEINTR) return Null();

return ThrowException(ErrnoException(wsaErrno, "read"));

}

#endif

Local<Object> info = Object::New();

info->Set(size_symbol, Integer::New(bytes_read));

ADDRESS_TO_JS(info, address_storage, addrlen);

return scope.Close(info);

}

#ifdef __POSIX__

static Handle<Value> RecvMsg(const Arguments& args) {

HandleScope scope;

if (args.Length() < 4) {

return ThrowException(Exception::TypeError(

String::New("Takes 4 parameters")));

}

FD_ARG(args[0])

if (!Buffer::HasInstance(args[1])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[1]->ToObject();

char *buffer_data = Buffer::Data(buffer_obj);

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[2]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[3]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

struct iovec iov[1];

iov[0].iov_base = (char*)buffer_data + off;

iov[0].iov_len = len;

struct msghdr msg;

msg.msg_flags = 0;

msg.msg_iov = iov;

msg.msg_iovlen = 1;

msg.msg_name = NULL;

msg.msg_namelen = 0;

/* Set up to receive a descriptor even if one isn't in the message */

char cmsg_space[64]; // should be big enough

msg.msg_controllen = 64;

msg.msg_control = (void *) cmsg_space;

ssize_t bytes_read = recvmsg(fd, &msg, 0);

if (bytes_read < 0) {

if (errno == EAGAIN || errno == EINTR) return Null();

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

}

// Why not return a two element array here [bytesRead, fd]? Because

// creating an object for each recvmsg() action is heavy. Instead we just

// assign the recved fd to a globalally accessable variable (recvMsg.fd)

// that the wrapper can pick up. Since we're single threaded, this is not

// a problem - just make sure to copy out that variable before the next

// call to recvmsg().

//

// XXX: Some implementations can send multiple file descriptors in a

// single message. We should be using CMSG_NXTHDR() to walk the

// chain to get at them all. This would require changing the

// API to hand these back up the caller, is a pain.

int received_fd = -1;

for (struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);

msg.msg_controllen > 0 && cmsg != NULL;

cmsg = CMSG_NXTHDR(&msg, cmsg)) {

if (cmsg->cmsg_type == SCM_RIGHTS) {

if (received_fd != -1) {

fprintf(stderr, "ignoring extra FD received: %d\n", received_fd);

}

received_fd = *(int *) CMSG_DATA(cmsg);

} else {

fprintf(stderr, "ignoring non-SCM_RIGHTS ancillary data: %d\n",

cmsg->cmsg_type

);

}

}

recv_msg_template->GetFunction()->Set(

fd_symbol,

(received_fd != -1) ?

Integer::New(received_fd) :

Null()

);

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

}

#endif // __POSIX__

static Handle<Value> Write(const Arguments& args) {

HandleScope scope;

if (args.Length() < 4) {

return ThrowException(Exception::TypeError(

String::New("Takes 4 parameters")));

}

FD_ARG(args[0])

if (!Buffer::HasInstance(args[1])) {

return ThrowException(Exception::TypeError(

String::New("Second argument should be a buffer")));

}

Local<Object> buffer_obj = args[1]->ToObject();

char *buffer_data = Buffer::Data(buffer_obj);

size_t buffer_length = Buffer::Length(buffer_obj);

size_t off = args[2]->Int32Value();

if (off >= buffer_length) {

return ThrowException(Exception::Error(

String::New("Offset is out of bounds")));

}

size_t len = args[3]->Int32Value();

if (off + len > buffer_length) {

return ThrowException(Exception::Error(

String::New("Length is extends beyond buffer")));

}

#ifdef __POSIX__

ssize_t written = write(fd, buffer_data + off, len);

if (written < 0) {

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

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

}

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

}

#else // __MINGW32__

// write() doesn't work for overlapped sockets (the only usable

// type of sockets) so send() is used.

ssize_t written = send(_get_osfhandle(fd), buffer_data + off, len, 0);

if (written < 0) {

int wsaErrno = WSAGetLastError();

if (wsaErrno == WSAEWOULDBLOCK || wsaErrno == WSAEINTR) {

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

}

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

}

#endif // __MINGW32__

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

}

#ifdef __POSIX__