+ private int sys_getdents(int fdn, int addr, int count, int seekptr) throws FaultException, ErrnoException {
+ count = Math.min(count,MAX_CHUNK);
+ if(fdn < 0 || fdn >= OPEN_MAX) return -EBADFD;
+ if(fds[fdn] == null) return -EBADFD;
+ byte[] buf = byteBuf(count);
+ int n = fds[fdn].getdents(buf,0,count);
+ copyout(buf,addr,n);
+ return n;
+ }
+
+ static class SocketFD extends FD {
+ public static final int TYPE_STREAM = 0;
+ public static final int TYPE_DGRAM = 1;
+ public static final int LISTEN = 2;
+ public int type() { return flags & 1; }
+ public boolean listen() { return (flags & 2) != 0; }
+
+ int flags;
+ int options;
+
+ Socket s;
+ ServerSocket ss;
+ DatagramSocket ds;
+
+ InetAddress bindAddr;
+ int bindPort = -1;
+ InetAddress connectAddr;
+ int connectPort = -1;
+
+ DatagramPacket dp;
+ InputStream is;
+ OutputStream os;
+
+ private static final byte[] EMPTY = new byte[0];
+ public SocketFD(int type) {
+ flags = type;
+ if(type == TYPE_DGRAM)
+ dp = new DatagramPacket(EMPTY,0);
+ }
+
+ public void setOptions() {
+ try {
+ if(s != null && type() == TYPE_STREAM && !listen()) {
+ Platform.socketSetKeepAlive(s,(options & SO_KEEPALIVE) != 0);
+ }
+ } catch(SocketException e) {
+ if(STDERR_DIAG) e.printStackTrace();
+ }
+ }
+
+ public void _close() {
+ try {
+ if(s != null) s.close();
+ if(ss != null) ss.close();
+ if(ds != null) ds.close();
+ } catch(IOException e) {
+ /* ignore */
+ }
+ }
+
+ public int read(byte[] a, int off, int length) throws ErrnoException {
+ if(type() == TYPE_DGRAM) return recvfrom(a,off,length,null,null);
+ if(is == null) throw new ErrnoException(EPIPE);
+ try {
+ int n = is.read(a,off,length);
+ return n < 0 ? 0 : n;
+ } catch(IOException e) {
+ throw new ErrnoException(EIO);
+ }
+ }
+
+ public int recvfrom(byte[] a, int off, int length, InetAddress[] sockAddr, int[] port) throws ErrnoException {
+ if(type() == TYPE_STREAM) return read(a,off,length);
+
+ if(off != 0) throw new IllegalArgumentException("off must be 0");
+ dp.setData(a);
+ dp.setLength(length);
+ try {
+ if(ds == null) ds = new DatagramSocket();
+ ds.receive(dp);
+ } catch(IOException e) {
+ if(STDERR_DIAG) e.printStackTrace();
+ throw new ErrnoException(EIO);
+ }
+ if(sockAddr != null) {
+ sockAddr[0] = dp.getAddress();
+ port[0] = dp.getPort();
+ }
+ return dp.getLength();
+ }
+
+ public int write(byte[] a, int off, int length) throws ErrnoException {
+ if(type() == TYPE_DGRAM) return sendto(a,off,length,null,-1);
+
+ if(os == null) throw new ErrnoException(EPIPE);
+ try {
+ os.write(a,off,length);
+ return length;
+ } catch(IOException e) {
+ throw new ErrnoException(EIO);
+ }
+ }
+
+ public int sendto(byte[] a, int off, int length, InetAddress destAddr, int destPort) throws ErrnoException {
+ if(off != 0) throw new IllegalArgumentException("off must be 0");
+ if(type() == TYPE_STREAM) return write(a,off,length);
+
+ if(destAddr == null) {
+ destAddr = connectAddr;
+ destPort = connectPort;
+
+ if(destAddr == null) throw new ErrnoException(ENOTCONN);
+ }
+
+ dp.setAddress(destAddr);
+ dp.setPort(destPort);
+ dp.setData(a);
+ dp.setLength(length);
+
+ try {
+ if(ds == null) ds = new DatagramSocket();
+ ds.send(dp);
+ } catch(IOException e) {
+ if(STDERR_DIAG) e.printStackTrace();
+ if("Network is unreachable".equals(e.getMessage())) throw new ErrnoException(EHOSTUNREACH);
+ throw new ErrnoException(EIO);
+ }
+ return dp.getLength();
+ }
+
+ public int flags() { return O_RDWR; }
+ public FStat _fstat() { return new SocketFStat(); }
+ }
+
+ private int sys_socket(int domain, int type, int proto) {
+ if(domain != AF_INET || (type != SOCK_STREAM && type != SOCK_DGRAM)) return -EPROTONOSUPPORT;
+ return addFD(new SocketFD(type == SOCK_STREAM ? SocketFD.TYPE_STREAM : SocketFD.TYPE_DGRAM));
+ }
+
+ private SocketFD getSocketFD(int fdn) throws ErrnoException {
+ if(fdn < 0 || fdn >= OPEN_MAX) throw new ErrnoException(EBADFD);
+ if(fds[fdn] == null) throw new ErrnoException(EBADFD);
+ if(!(fds[fdn] instanceof SocketFD)) throw new ErrnoException(ENOTSOCK);
+
+ return (SocketFD) fds[fdn];
+ }
+
+ private int sys_connect(int fdn, int addr, int namelen) throws ErrnoException, FaultException {
+ SocketFD fd = getSocketFD(fdn);
+
+ if(fd.type() == SocketFD.TYPE_STREAM && (fd.s != null || fd.ss != null)) return -EISCONN;
+ int word1 = memRead(addr);
+ if( ((word1 >>> 16)&0xff) != AF_INET) return -EAFNOSUPPORT;
+ int port = word1 & 0xffff;
+ byte[] ip = new byte[4];
+ copyin(addr+4,ip,4);
+
+ InetAddress inetAddr;
+ try {
+ inetAddr = Platform.inetAddressFromBytes(ip);
+ } catch(UnknownHostException e) {
+ return -EADDRNOTAVAIL;
+ }
+
+ fd.connectAddr = inetAddr;
+ fd.connectPort = port;
+
+ try {
+ switch(fd.type()) {
+ case SocketFD.TYPE_STREAM: {
+ Socket s = new Socket(inetAddr,port);
+ fd.s = s;
+ fd.setOptions();
+ fd.is = s.getInputStream();
+ fd.os = s.getOutputStream();
+ break;
+ }
+ case SocketFD.TYPE_DGRAM:
+ break;
+ default:
+ throw new Error("should never happen");
+ }
+ } catch(IOException e) {
+ return -ECONNREFUSED;
+ }
+
+ return 0;
+ }
+
+ private int sys_resolve_hostname(int chostname, int addr, int sizeAddr) throws FaultException {
+ String hostname = cstring(chostname);
+ int size = memRead(sizeAddr);
+ InetAddress[] inetAddrs;
+ try {
+ inetAddrs = InetAddress.getAllByName(hostname);
+ } catch(UnknownHostException e) {
+ return HOST_NOT_FOUND;
+ }
+ int count = min(size/4,inetAddrs.length);
+ for(int i=0;i<count;i++,addr+=4) {
+ byte[] b = inetAddrs[i].getAddress();
+ copyout(b,addr,4);
+ }
+ memWrite(sizeAddr,count*4);
+ return 0;
+ }
+
+ private int sys_setsockopt(int fdn, int level, int name, int valaddr, int len) throws ReadFaultException, ErrnoException {
+ SocketFD fd = getSocketFD(fdn);
+ switch(level) {
+ case SOL_SOCKET:
+ switch(name) {
+ case SO_REUSEADDR:
+ case SO_KEEPALIVE: {
+ if(len != 4) return -EINVAL;
+ int val = memRead(valaddr);
+ if(val != 0) fd.options |= name;
+ else fd.options &= ~name;
+ fd.setOptions();
+ return 0;
+ }
+ default:
+ if(STDERR_DIAG) System.err.println("Unknown setsockopt name passed: " + name);
+ return -ENOPROTOOPT;
+ }
+ default:
+ if(STDERR_DIAG) System.err.println("Unknown setsockopt leve passed: " + level);
+ return -ENOPROTOOPT;
+ }
+ }
+
+ private int sys_getsockopt(int fdn, int level, int name, int valaddr, int lenaddr) throws ErrnoException, FaultException {
+ SocketFD fd = getSocketFD(fdn);
+ switch(level) {
+ case SOL_SOCKET:
+ switch(name) {
+ case SO_REUSEADDR:
+ case SO_KEEPALIVE: {
+ int len = memRead(lenaddr);
+ if(len < 4) return -EINVAL;
+ int val = (fd.options & name) != 0 ? 1 : 0;
+ memWrite(valaddr,val);
+ memWrite(lenaddr,4);
+ return 0;
+ }
+ default:
+ if(STDERR_DIAG) System.err.println("Unknown setsockopt name passed: " + name);
+ return -ENOPROTOOPT;
+ }
+ default:
+ if(STDERR_DIAG) System.err.println("Unknown setsockopt leve passed: " + level);
+ return -ENOPROTOOPT;
+ }
+ }
+
+ private int sys_bind(int fdn, int addr, int namelen) throws FaultException, ErrnoException {
+ SocketFD fd = getSocketFD(fdn);
+
+ if(fd.type() == SocketFD.TYPE_STREAM && (fd.s != null || fd.ss != null)) return -EISCONN;
+ int word1 = memRead(addr);
+ if( ((word1 >>> 16)&0xff) != AF_INET) return -EAFNOSUPPORT;
+ int port = word1 & 0xffff;
+ InetAddress inetAddr = null;
+ if(memRead(addr+4) != 0) {
+ byte[] ip = new byte[4];
+ copyin(addr+4,ip,4);
+
+ try {
+ inetAddr = Platform.inetAddressFromBytes(ip);
+ } catch(UnknownHostException e) {
+ return -EADDRNOTAVAIL;
+ }
+ }
+
+ switch(fd.type()) {
+ case SocketFD.TYPE_STREAM: {
+ fd.bindAddr = inetAddr;
+ fd.bindPort = port;
+ return 0;
+ }
+ case SocketFD.TYPE_DGRAM: {
+ if(fd.ds != null) fd.ds.close();
+ try {
+ fd.ds = inetAddr != null ? new DatagramSocket(port,inetAddr) : new DatagramSocket(port);
+ } catch(IOException e) {
+ return -EADDRINUSE;
+ }
+ return 0;
+ }
+ default:
+ throw new Error("should never happen");
+ }
+ }
+
+ private int sys_listen(int fdn, int backlog) throws ErrnoException {
+ SocketFD fd = getSocketFD(fdn);
+ if(fd.type() != SocketFD.TYPE_STREAM) return -EOPNOTSUPP;
+ if(fd.ss != null || fd.s != null) return -EISCONN;
+ if(fd.bindPort < 0) return -EOPNOTSUPP;
+
+ try {
+ fd.ss = new ServerSocket(fd.bindPort,backlog,fd.bindAddr);
+ fd.flags |= SocketFD.LISTEN;
+ return 0;
+ } catch(IOException e) {
+ return -EADDRINUSE;
+ }
+
+ }
+
+ private int sys_accept(int fdn, int addr, int lenaddr) throws ErrnoException, FaultException {
+ SocketFD fd = getSocketFD(fdn);
+ if(fd.type() != SocketFD.TYPE_STREAM) return -EOPNOTSUPP;
+ if(!fd.listen()) return -EOPNOTSUPP;
+
+ int size = memRead(lenaddr);
+
+ ServerSocket s = fd.ss;
+ Socket client;
+ try {
+ client = s.accept();
+ } catch(IOException e) {
+ return -EIO;
+ }
+
+ if(size >= 8) {
+ memWrite(addr,(6 << 24) | (AF_INET << 16) | client.getPort());
+ byte[] b = client.getInetAddress().getAddress();
+ copyout(b,addr+4,4);
+ memWrite(lenaddr,8);
+ }
+
+ SocketFD clientFD = new SocketFD(SocketFD.TYPE_STREAM);
+ clientFD.s = client;
+ try {
+ clientFD.is = client.getInputStream();
+ clientFD.os = client.getOutputStream();
+ } catch(IOException e) {
+ return -EIO;
+ }
+ int n = addFD(clientFD);
+ if(n == -1) { clientFD.close(); return -ENFILE; }
+ return n;
+ }
+
+ private int sys_shutdown(int fdn, int how) throws ErrnoException {
+ SocketFD fd = getSocketFD(fdn);
+ if(fd.type() != SocketFD.TYPE_STREAM || fd.listen()) return -EOPNOTSUPP;
+ if(fd.s == null) return -ENOTCONN;
+
+ Socket s = fd.s;
+
+ try {
+ if(how == SHUT_RD || how == SHUT_RDWR) Platform.socketHalfClose(s,false);
+ if(how == SHUT_WR || how == SHUT_RDWR) Platform.socketHalfClose(s,true);
+ } catch(IOException e) {
+ return -EIO;
+ }
+
+ return 0;
+ }
+
+ private int sys_sendto(int fdn, int addr, int count, int flags, int destAddr, int socklen) throws ErrnoException,ReadFaultException {
+ SocketFD fd = getSocketFD(fdn);
+ if(flags != 0) throw new ErrnoException(EINVAL);
+
+ int word1 = memRead(destAddr);
+ if( ((word1 >>> 16)&0xff) != AF_INET) return -EAFNOSUPPORT;
+ int port = word1 & 0xffff;
+ InetAddress inetAddr;
+ byte[] ip = new byte[4];
+ copyin(destAddr+4,ip,4);
+ try {
+ inetAddr = Platform.inetAddressFromBytes(ip);
+ } catch(UnknownHostException e) {
+ return -EADDRNOTAVAIL;
+ }
+
+ count = Math.min(count,MAX_CHUNK);
+ byte[] buf = byteBuf(count);
+ copyin(addr,buf,count);
+ try {
+ return fd.sendto(buf,0,count,inetAddr,port);
+ } catch(ErrnoException e) {
+ if(e.errno == EPIPE) exit(128+13,true);
+ throw e;
+ }
+ }
+
+ private int sys_recvfrom(int fdn, int addr, int count, int flags, int sourceAddr, int socklenAddr) throws ErrnoException, FaultException {
+ SocketFD fd = getSocketFD(fdn);
+ if(flags != 0) throw new ErrnoException(EINVAL);
+
+ InetAddress[] inetAddr = sourceAddr == 0 ? null : new InetAddress[1];
+ int[] port = sourceAddr == 0 ? null : new int[1];
+
+ count = Math.min(count,MAX_CHUNK);
+ byte[] buf = byteBuf(count);
+ int n = fd.recvfrom(buf,0,count,inetAddr,port);
+ copyout(buf,addr,n);
+
+ if(sourceAddr != 0) {
+ memWrite(sourceAddr,(AF_INET << 16) | port[0]);
+ byte[] ip = inetAddr[0].getAddress();
+ copyout(ip,sourceAddr+4,4);
+ }
+
+ return n;
+ }
+
+ private int sys_select(int n, int readFDs, int writeFDs, int exceptFDs, int timevalAddr) throws ReadFaultException, ErrnoException {
+ return -ENOSYS;
+ }
+
+ private static String hostName() {
+ try {
+ return InetAddress.getLocalHost().getHostName();
+ } catch(UnknownHostException e) {
+ return "darkstar";
+ }
+ }
+
+ private int sys_sysctl(int nameaddr, int namelen, int oldp, int oldlenaddr, int newp, int newlen) throws FaultException {
+ if(newp != 0) return -EPERM;
+ if(namelen == 0) return -ENOENT;
+ if(oldp == 0) return 0;
+
+ Object o = null;
+ switch(memRead(nameaddr)) {
+ case CTL_KERN:
+ if(namelen != 2) break;
+ switch(memRead(nameaddr+4)) {
+ case KERN_OSTYPE: o = "NestedVM"; break;
+ case KERN_HOSTNAME: o = hostName(); break;
+ case KERN_OSRELEASE: o = VERSION; break;
+ case KERN_VERSION: o = "NestedVM Kernel Version " + VERSION; break;
+ }
+ break;
+ case CTL_HW:
+ if(namelen != 2) break;
+ switch(memRead(nameaddr+4)) {
+ case HW_MACHINE: o = "NestedVM Virtual Machine"; break;
+ }
+ break;
+ }
+ if(o == null) return -ENOENT;
+ int len = memRead(oldlenaddr);
+ if(o instanceof String) {
+ byte[] b = getNullTerminatedBytes((String)o);
+ if(len < b.length) return -ENOMEM;
+ len = b.length;
+ copyout(b,oldp,len);
+ memWrite(oldlenaddr,len);
+ } else if(o instanceof Integer) {
+ if(len < 4) return -ENOMEM;
+ memWrite(oldp,((Integer)o).intValue());
+ } else {
+ throw new Error("should never happen");
+ }
+ return 0;
+ }
+
+ public static final class GlobalState {
+ Hashtable execCache = new Hashtable();