コード例 #1
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  /** @inheritDoc */
  public int writeBuf(int fd, byte buffer[], int off, int len) throws IOException {
    int result = 0;
    byte[] buf = buffer;
    if (off != 0) {
      buf = new byte[len];
      System.arraycopy(buffer, off, buf, 0, len);
    }

    if (DEBUG) {
      System.err.println("writeBuf(" + fd + ") before write.");
    }

    result = libc.write(fd, buf, len); // We rely on open0() for setting the socket to non-blocking

    if (result < 0) {
      int err_code = LibCUtil.errno();
      if (err_code == LibC.EWOULDBLOCK) {
        VMThread.getSystemEvents().waitForWriteEvent(fd);
        if (DEBUG) {
          System.err.println("writeBuf(" + fd + ") returned from select. retry.");
        }
        result =
            libc.write(fd, buf, len); // We rely on open0() for setting the socket to non-blocking
      }
      if (DEBUG) {
        System.err.println("writeBuf(" + fd + ") error:");
      }
      LibCUtil.errCheckNeg(result);
    }

    return result;
  }
コード例 #2
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  /**
   * set a socket option
   *
   * @param socket socket descriptor
   * @param level Socket.SOL_SOCKET, etc.
   * @param option_name
   * @param option_value new value
   * @throws IOException on error
   */
  public void setSockOpt(int socket, int level, int option_name, int option_value)
      throws IOException {
    IntByReference value = new IntByReference(option_value);
    if (false) Assert.that(option_value == value.getValue());
    if (DEBUG) {
      System.out.println(
          "setSockOpt(" + socket + ", " + level + ", " + option_name + ", " + option_value + ")");
    }
    int err = sockets.setsockopt(socket, level, option_name, value, 4);

    if (false) Assert.that(option_value == value.getValue());
    value.free();
    LibCUtil.errCheckNeg(err);

    if (DEBUG) {
      int newValue = getSockOpt(socket, level, option_name);
      if (option_value != newValue) {
        System.out.println(
            "FAILED: setSockOpt("
                + socket
                + ", "
                + level
                + ", "
                + option_name
                + ", "
                + option_value
                + ")");
        System.err.println("   Ended with: " + newValue);
      }
    }
  }
コード例 #3
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
 /** @inheritDoc */
 public int available(int fd) throws IOException {
   int err = ioctl.ioctl(fd, Ioctl.FIONREAD, availableBuf.address().toUWord().toPrimitive());
   int result = availableBuf.getInt(0);
   LibCUtil.errCheckNeg(err);
   if (DEBUG) {
     System.err.println("available(" + fd + ") = " + result);
   }
   return result;
 }
コード例 #4
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
 /** 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);
 }
コード例 #5
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  private void set_blocking_flags(int fd, boolean is_blocking) throws IOException {
    if (tryFcntl) {
      int flags = libc.fcntl(fd, LibC.F_GETFL, 0);
      if (DEBUG) {
        System.out.println("set_blocking_flags: fcntl F_GETFL = " + flags);
      }

      if (flags >= 0) {
        if (is_blocking == true) {
          flags &= ~LibC.O_NONBLOCK;
        } else {
          flags |= LibC.O_NONBLOCK;
        }
        if (DEBUG) {
          System.out.println("set_blocking_flags: calling fcntl F_SETFL flags: " + flags);
        }
        int res = libc.fcntl(fd, LibC.F_SETFL, flags);
        if (res != -1) {
          return;
        }
      } else if (LibCUtil.errno() == LibC.EOPNOTSUPP) {
        tryFcntl = false; // once this fails, don't try again
      }
    }

    if (!tryFcntl) {
      if (DEBUG) {
        System.out.println("set_blocking_flags: calling ioctl FIONBIO = " + !is_blocking);
      }
      IntByReference setting =
          new IntByReference(is_blocking ? 0 : 1); /* if "is_blocking"==true, NBIO = FALSE */
      int res = ioctl.ioctl(fd, Ioctl.FIONBIO, setting);
      setting.free();
      if (DEBUG) {
        System.out.println("set_blocking_flags: ioctl returned: " + res);
      }
      if (res >= 0) {
        return;
      }
    }
    throw newError(fd, "set_blocking_flags");
  }
コード例 #6
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  /**
   * get a socket option
   *
   * @param socket socket descriptor
   * @param level Socket.SOL_SOCKET, etc.
   * @param option_name
   * @return socket option value
   * @throws IOException on error
   */
  public int getSockOpt(int socket, int level, int option_name) throws IOException {
    IntByReference value = new IntByReference(0);
    IntByReference opt_len = new IntByReference(4);
    if (DEBUG) {
      System.out.println("getsockopt(" + socket + ", " + level + ", " + option_name + ")");
    }

    int err = sockets.getsockopt(socket, level, option_name, value, opt_len);
    if (DEBUG) {
      System.out.println(
          "    returned value: " + value.getValue() + ", size: " + opt_len.getValue());
    }

    int result = value.getValue();
    value.free();
    if (false) Assert.that(opt_len.getValue() == 4);
    opt_len.free();
    LibCUtil.errCheckNeg(err);
    return result;
  }
コード例 #7
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  /**
   * 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 {
    Socket.sockaddr_in remote_sin = new Socket.sockaddr_in();
    IntByReference address_len = new IntByReference(4);
    int newSocket;

    try {
      if (DEBUG) {
        System.err.println("Socket.accept(" + fd + ", " + remote_sin + ")...");
      }

      newSocket = sockets.accept(fd, remote_sin, address_len);

      if (newSocket < 0) {
        if (DEBUG) {
          System.err.println("Need to block for accept...");
        }

        int err_code = LibCUtil.errno();
        if (err_code == LibC.EAGAIN || err_code == LibC.EWOULDBLOCK) {
          VMThread.getSystemEvents().waitForReadEvent(fd);
          newSocket = sockets.accept(fd, remote_sin, address_len);
          if (newSocket < 0) {
            throw newError(fd, "accept");
          }
        } else {
          // BUG!
          throw newError(fd, "accept");
        }
      }
    } finally {
      address_len.free();
    }

    set_blocking_flags(newSocket, /*is_blocking*/ false);
    // we could read info about client from remote_sin, but don't need to.

    if (DEBUG) {
      System.err.println("    Socket.accept(...) = " + newSocket);
    }
    return newSocket;
  }
コード例 #8
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  /** @inheritDoc */
  public int readBuf(int fd, byte b[], int offset, int length) throws IOException {
    byte[] buf = b;
    int result;

    if (offset != 0) {
      if (DEBUG) {
        System.err.println("readBuf() into temp buf");
      }
      buf = new byte[length];
    }

    if (NBIO_WORKS) {
      result =
          libc.read(fd, buf, length); // We rely on open0() for setting the socket to non-blocking
      if (result < 0) {
        int err_code = LibCUtil.errno();
        if (err_code == LibC.EWOULDBLOCK) {
          if (DEBUG) {
            System.err.println("Wait for read in select...");
          }
          VMThread.getSystemEvents().waitForReadEvent(fd);
          result =
              libc.read(
                  fd, buf, length); // We rely on open0() for setting the socket to non-blocking
        }
        LibCUtil.errCheckNeg(result);
      }
    } else {
      // If non-blocking IO doesn't seems to be working, try this hack...

      int bAvail = available(fd); // may throw IOException

      if (bAvail == 0) {
        if (DEBUG) {
          System.err.println("Wait for read in select...");
        }
        VMThread.getSystemEvents().waitForReadEvent(fd);
        bAvail = available(fd);
        if (bAvail == 0) { // woke up because connection is closed
          if (DEBUG) {
            System.err.println("readBuf(" + fd + ") signalling EOF.");
          }
          return -1; // signal EOF
        }
      }
      if (DEBUG) {
        System.err.println("readBuf(" + fd + ") returned from select. retry.");
      }

      int n = Math.min(bAvail, length); // don't read more than is asked for...
      result = libc.read(fd, buf, n); // only read what we know is there...
      LibCUtil.errCheckNeg(result);
    }

    if (result == 0) {
      // If remote side has shut down the connection gracefully, and all
      // data has been received, recv() will complete immediately with
      // zero bytes received.
      //
      // This is true for Win32/CE and Linux
      if (DEBUG) {
        System.err.println("readBuf(" + fd + ") saw remote side shutdown.");
      }
      result = -1;
    }

    if (offset != 0 && result > 0) {
      System.arraycopy(buf, 0, b, offset, result);
    }
    if (DEBUG) {
      System.out.println("readBuf(" + fd + ") = " + result);
    }

    return result;
  }
コード例 #9
0
ファイル: GCFSocketsImpl.java プロジェクト: johangas/moped
  /** @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);

        int errno = getSockOpt(fd, Socket.SO_ERROR);
        if (errno != 0) {
          String msg;
          if (errno == LibC.ECONNREFUSED) {
            msg = "connect refused";
          } else {
            msg = String.valueOf(errno);
          }
          throw new IOException("ConnectException: " + msg);
        }

        if (DEBUG) {
          System.err.println("connect back fd = " + fd);
        }
      } else {
        throw newError(fd, "connect");
      }
    }

    try {
      setSockOpt(fd, Socket.IPPROTO_TCP, Socket.TCP_NODELAY, 1);
    } catch (IOException ex) {
    }

    return fd;
  }