/**
* Opens a server TCP connection to clients. Creates, binds, and listens
*
* @param port local TCP port to listen on
* @param backlog listen backlog.
* @return a native handle to the network connection.
* @throws IOException
*/
public int openServer(int port, int backlog) throws IOException {
int fd = -1;
fd = Socket.INSTANCE.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0);
if (fd < 0) {
throw newError(fd, "socket create");
}
set_blocking_flags(fd, /*is_blocking*/ false);
IntByReference option_val = new IntByReference(1);
if (sockets.setsockopt(fd, Socket.SOL_SOCKET, Socket.SO_REUSEADDR, option_val, 4) < 0) {
throw newError(fd, "setSockOpt");
}
option_val.free();
Socket.sockaddr_in local_sin = new Socket.sockaddr_in();
local_sin.sin_family = Socket.AF_INET;
local_sin.sin_port = Inet.htons((short) port);
local_sin.sin_addr = Socket.INADDR_ANY;
if (sockets.bind(fd, local_sin) < 0) {
throw newError(fd, "bind");
}
if (sockets.listen(fd, backlog) < 0) {
throw newError(fd, "listen");
}
return fd;
}
/**
* Takes an IPv4 Internet address and returns string representing the address in `.' notation
*
* @param in the opaque bytes of an IPv4 "struct in_addr"
* @return String
*/
public String inet_ntop(int in) {
Pointer charBuf = new Pointer(Socket.INET_ADDRSTRLEN);
IntByReference addrBuf = new IntByReference(in); // the addr is passed by value (to handle IPv6)
String result = sockets.inet_ntop(Socket.AF_INET, addrBuf, charBuf, Socket.INET_ADDRSTRLEN);
addrBuf.free();
charBuf.free();
return result;
}
/** @inheritDoc */
public void close(int fd) throws IOException {
// NOTE: this would block the VM. A real implementation should
// make this a async native method.
sockets.shutdown(fd, 2);
libc.close(fd);
if (DEBUG) {
System.out.println("close(" + fd + ")");
}
}
/** @inheritDoc */
public int open(String hostname, int port, int mode) throws IOException {
// init_sockets(); win32 only
int fd = -1;
fd = sockets.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0);
if (DEBUG) {
System.err.println("Socket.socket() = " + fd);
}
if (fd < 0) {
throw newError(fd, "socket create");
}
set_blocking_flags(fd, /*is_blocking*/ false);
NetDB.hostent phostent;
// hostname is always NUL terminated. See socket/Protocol.java for detail.
phostent = NetDB.INSTANCE.gethostbyname(hostname);
if (phostent == null) {
throw newError(fd, "gethostbyname (herrono = " + NetDB.INSTANCE.h_errno() + ")");
}
Socket.sockaddr_in destination_sin = new Socket.sockaddr_in();
destination_sin.sin_family = Socket.AF_INET;
destination_sin.sin_port = Inet.htons((short) port);
destination_sin.sin_addr = phostent.h_addr_list[0];
if (DEBUG) {
System.err.println("Socket.sockaddr_in: " + destination_sin);
System.err.println("connect: hostname: " + hostname + " port: " + port + " mode: " + mode);
}
if (sockets.connect(fd, destination_sin, destination_sin.size()) < 0) {
int err_code = LibCUtil.errno();
if (err_code == LibC.EINPROGRESS || err_code == LibC.EWOULDBLOCK) {
// When the socket is ready for connect, it becomes *writable*
// (according to BSD socket spec of select())
VMThread.getSystemEvents().waitForWriteEvent(fd);
} else {
throw newError(fd, "connect");
}
}
return fd;
}
/** Read errno, try to clean up fd, and create exception. */
private IOException newError(int fd, String msg) {
if (DEBUG) {
VM.print(msg);
VM.print(": errno: ");
}
int err_code = LibCUtil.errno();
if (DEBUG) {
VM.print(err_code);
VM.println();
}
sockets.shutdown(fd, 2);
libc.close(fd);
return new IOException(" errno: " + err_code + " on fd: " + fd + " during " + msg);
}
/**
* get a socket option
*
* @param socket socket descriptor
* @param option_name
* @throws IOException on error
*/
public int getSockOpt(int socket, int option_name) throws IOException {
IntByReference value = new IntByReference(0);
IntByReference opt_len = new IntByReference(4);
if (DEBUG) {
System.out.println("getsockopt(" + socket + ", " + option_name + ")");
}
int err = sockets.getsockopt(socket, Socket.SOL_SOCKET, option_name, value, opt_len);
int result = value.getValue();
value.free();
if (false) Assert.that(opt_len.getValue() == 4);
opt_len.free();
LibCUtil.errCheckNeg(err);
return result;
}
/**
* Accept client connections on server socket fd. Blocks until a client connects.
*
* @param fd open server socket. See {@link #openServer}.
* @return a native handle to the network connection.
* @throws IOException
*/
public int accept(int fd) throws IOException {
VMThread.getSystemEvents().waitForReadEvent(fd);
Socket.sockaddr_in remote_sin = new Socket.sockaddr_in();
IntByReference address_len = new IntByReference(4);
int newSocket = sockets.accept(fd, remote_sin, address_len);
if (newSocket < 0) {
throw newError(fd, "accept");
}
address_len.free();
set_blocking_flags(newSocket, /*is_blocking*/ false);
// we could read info about client from remote_sin, but don't need to.
return newSocket;
}
/**
* set a socket option
*
* @param socket socket descriptor
* @param option_name
* @param option_value new value
* @throws IOException on error
*/
public void setSockOpt(int socket, int option_name, int option_value) throws IOException {
IntByReference value = new IntByReference(option_value);
int err = sockets.setsockopt(socket, Socket.SOL_SOCKET, option_name, value, 4);
value.free();
LibCUtil.errCheckNeg(err);
}
