+
+ void _preCloseFD(FD fd) {
+ // release all fcntl locks on this file
+ Seekable s = fd.seekable();
+ if (s == null) return;
+
+ try {
+ for (int i=0; i < gs.locks.length; i++) {
+ Seekable.Lock l = gs.locks[i];
+ if (l == null) continue;
+ if (s.equals(l.seekable()) && l.getOwner() == this) {
+ l.release();
+ gs.locks[i] = null;
+ }
+ }
+ } catch (IOException e) { throw new RuntimeException(e); }
+ }
+
+ void _postCloseFD(FD fd) {
+ if (fd.isMarkedForDeleteOnClose()) {
+ try { gs.unlink(this, fd.getNormalizedPath()); }
+ catch (Throwable t) {}
+ }
+ }
+
+ /** Implements the F_GETLK and F_SETLK cases of fcntl syscall.
+ * If l_start = 0 and l_len = 0 the lock refers to the entire file.
+ * Uses GlobalState to ensure locking across processes in the same JVM.
+ struct flock {
+ short l_type; // lock type: F_UNLCK, F_RDLCK, F_WRLCK
+ short l_whence; // type of l_start: SEEK_SET, SEEK_CUR, SEEK_END
+ long l_start; // starting offset, bytes
+ long l_len; // len = 0 means until EOF
+ short l_pid; // lock owner
+ short l_xxx; // padding
+ };
+ */
+ private int sys_fcntl_lock(int fdn, int cmd, int arg) throws FaultException{
+ if (cmd != F_GETLK && cmd != F_SETLK) return sys_fcntl(fdn, cmd, arg);
+
+ if(fdn < 0 || fdn >= OPEN_MAX) return -EBADFD;
+ if(fds[fdn] == null) return -EBADFD;
+ FD fd = fds[fdn];
+
+ if (arg == 0) return -EINVAL;
+ int word = memRead(arg);
+ int l_start = memRead(arg+4);
+ int l_len = memRead(arg+8);
+ int l_type = word>>16;
+ int l_whence = word&0x00ff;
+
+ Seekable.Lock[] locks = gs.locks;
+ Seekable s = fd.seekable();
+ if (s == null) return -EINVAL;
+
+ try {
+
+ switch (l_whence) {
+ case SEEK_SET: break;
+ case SEEK_CUR: l_start += s.pos(); break;
+ case SEEK_END: l_start += s.length(); break;
+ default: return -1;
+ }
+
+ if (cmd == F_GETLK) {
+ // The simple Java file locking below will happily return
+ // a lock that overlaps one already held by the JVM. Thus
+ // we must check over all the locks held by other Runtimes
+ for (int i=0; i < locks.length; i++) {
+ if (locks[i] == null || !s.equals(locks[i].seekable()))
+ continue;
+ if (!locks[i].overlaps(l_start, l_len))
+ continue;
+ if (locks[i].getOwner() == this)
+ continue;
+ if (locks[i].isShared() && l_type == F_RDLCK)
+ continue;
+
+ // overlapping lock held by another process
+ return 0;
+ }
+
+ // check if an area is lockable by attempting to obtain a lock
+ Seekable.Lock lock = s.lock(l_start, l_len, l_type == F_RDLCK);
+
+ if (lock != null) { // no lock exists
+ memWrite(arg, SEEK_SET|(F_UNLCK<<16));
+ lock.release();
+ }
+
+ return 0;
+ }
+
+ // now processing F_SETLK
+ if (cmd != F_SETLK) return -EINVAL;
+
+ if (l_type == F_UNLCK) {
+ // release all locks that fall within the boundaries given
+ for (int i=0; i < locks.length; i++) {
+ if (locks[i] == null || !s.equals(locks[i].seekable()))
+ continue;
+ if (locks[i].getOwner() != this) continue;
+
+ int pos = (int)locks[i].position();
+ if (pos < l_start) continue;
+ if (l_start != 0 && l_len != 0) // start/len 0 means unlock all
+ if (pos + locks[i].size() > l_start + l_len)
+ continue;
+
+ locks[i].release();
+ locks[i] = null;
+ }
+ return 0;
+
+ } else if (l_type == F_RDLCK || l_type == F_WRLCK) {
+ // first see if a lock already exists
+ for (int i=0; i < locks.length; i++) {
+ if (locks[i] == null || !s.equals(locks[i].seekable()))
+ continue;
+
+ if (locks[i].getOwner() == this) {
+ // if this Runtime owns an overlapping lock work with it
+ if (locks[i].contained(l_start, l_len)) {
+ locks[i].release();
+ locks[i] = null;
+ } else if (locks[i].contains(l_start, l_len)) {
+ if (locks[i].isShared() == (l_type == F_RDLCK)) {
+ // return this more general lock
+ memWrite(arg+4, (int)locks[i].position());
+ memWrite(arg+8, (int)locks[i].size());
+ return 0;
+ } else {
+ locks[i].release();
+ locks[i] = null;
+ }
+ }
+ } else {
+ // if another Runtime has an lock and it is exclusive or
+ // we want an exclusive lock then fail
+ if (locks[i].overlaps(l_start, l_len)
+ && (!locks[i].isShared() || l_type == F_WRLCK))
+ return -EAGAIN;
+ }
+ }
+
+ // create the lock
+ Seekable.Lock lock = s.lock(l_start, l_len, l_type == F_RDLCK);
+ if (lock == null) return -EAGAIN;
+ lock.setOwner(this);
+
+ int i;
+ for (i=0; i < locks.length; i++)
+ if (locks[i] == null) break;
+ if (i == locks.length) return -ENOLCK;
+ locks[i] = lock;
+ return 0;
+
+ } else {
+ return -EINVAL;
+ }
+
+ } catch (IOException e) { throw new RuntimeException(e); }
+ }
+
+ 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;
+ }