home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / net / PlainSocketImpl.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  6.5 KB  |  374 lines
  1. package java.net;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.FileDescriptor;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.OutputStream;
  8. import java.security.AccessController;
  9. import sun.security.action.GetPropertyAction;
  10. import sun.security.action.LoadLibraryAction;
  11.  
  12. class PlainSocketImpl extends SocketImpl {
  13.    static int preferredConnectionTimeout = 0;
  14.    int timeout;
  15.    private static final int SOCKS_PROTO_VERS = 4;
  16.    private static final int SOCKS_REPLY_VERS = 4;
  17.    private static final int COMMAND_CONNECT = 1;
  18.    private static final int COMMAND_BIND = 2;
  19.    private static final int REQUEST_GRANTED = 90;
  20.    private static final int REQUEST_REJECTED = 91;
  21.    private static final int REQUEST_REJECTED_NO_IDENTD = 92;
  22.    private static final int REQUEST_REJECTED_DIFF_IDENTS = 93;
  23.    public static final String socksServerProp = "socksProxyHost";
  24.    public static final String socksPortProp = "socksProxyPort";
  25.    public static final String socksDefaultPortStr = "1080";
  26.    private boolean shut_rd = false;
  27.    private boolean shut_wr = false;
  28.    private SocketInputStream socketInputStream = null;
  29.    public static final int SHUT_RD = 0;
  30.    public static final int SHUT_WR = 1;
  31.  
  32.    protected synchronized void create(boolean var1) throws IOException {
  33.       super.fd = new FileDescriptor();
  34.       this.socketCreate(var1);
  35.    }
  36.  
  37.    protected void connect(String var1, int var2) throws UnknownHostException, IOException {
  38.       Object var3 = null;
  39.  
  40.       try {
  41.          InetAddress var4 = InetAddress.getByName(var1);
  42.  
  43.          try {
  44.             this.connectToAddress(var4, var2);
  45.             return;
  46.          } catch (IOException var6) {
  47.             var3 = var6;
  48.          }
  49.       } catch (UnknownHostException var7) {
  50.          var3 = var7;
  51.       }
  52.  
  53.       this.close();
  54.       throw var3;
  55.    }
  56.  
  57.    protected void connect(InetAddress var1, int var2) throws IOException {
  58.       super.port = var2;
  59.       super.address = var1;
  60.  
  61.       try {
  62.          this.connectToAddress(var1, var2);
  63.       } catch (IOException var4) {
  64.          this.close();
  65.          throw var4;
  66.       }
  67.    }
  68.  
  69.    private void connectToAddress(InetAddress var1, int var2) throws IOException {
  70.       if (this.usingSocks()) {
  71.          this.doSOCKSConnect(var1, var2);
  72.       } else {
  73.          this.doConnect(var1, var2);
  74.       }
  75.  
  76.    }
  77.  
  78.    public void setOption(int var1, Object var2) throws SocketException {
  79.       boolean var3 = true;
  80.       switch (var1) {
  81.          case 1:
  82.             if (var2 == null || !(var2 instanceof Boolean)) {
  83.                throw new SocketException("bad parameter for TCP_NODELAY");
  84.             }
  85.  
  86.             var3 = (Boolean)var2;
  87.             break;
  88.          case 8:
  89.             if (var2 == null || !(var2 instanceof Boolean)) {
  90.                throw new SocketException("bad parameter for SO_KEEPALIVE");
  91.             }
  92.  
  93.             var3 = (Boolean)var2;
  94.             break;
  95.          case 15:
  96.             throw new SocketException("Cannot re-bind socket");
  97.          case 128:
  98.             if (var2 == null || !(var2 instanceof Integer) && !(var2 instanceof Boolean)) {
  99.                throw new SocketException("Bad parameter for option");
  100.             }
  101.  
  102.             if (var2 instanceof Boolean) {
  103.                var3 = false;
  104.             }
  105.             break;
  106.          case 4097:
  107.          case 4098:
  108.             if (var2 == null || !(var2 instanceof Integer) || (Integer)var2 <= 0) {
  109.                throw new SocketException("bad parameter for SO_SNDBUF or SO_RCVBUF");
  110.             }
  111.             break;
  112.          case 4102:
  113.             if (var2 != null && var2 instanceof Integer) {
  114.                int var4 = (Integer)var2;
  115.                if (var4 < 0) {
  116.                   throw new IllegalArgumentException("timeout < 0");
  117.                }
  118.  
  119.                this.timeout = var4;
  120.                return;
  121.             }
  122.  
  123.             throw new SocketException("Bad parameter for SO_TIMEOUT");
  124.          default:
  125.             throw new SocketException("unrecognized TCP option: " + var1);
  126.       }
  127.  
  128.       this.socketSetOption(var1, var3, var2);
  129.    }
  130.  
  131.    public Object getOption(int var1) throws SocketException {
  132.       if (var1 == 4102) {
  133.          return new Integer(this.timeout);
  134.       } else {
  135.          int var2 = this.socketGetOption(var1);
  136.          switch (var1) {
  137.             case 1:
  138.                return var2 == -1 ? new Boolean(false) : new Boolean(true);
  139.             case 8:
  140.                return var2 == -1 ? new Boolean(false) : new Boolean(true);
  141.             case 15:
  142.                InetAddress var3 = new InetAddress();
  143.                var3.address = var2;
  144.                return var3;
  145.             case 128:
  146.                return var2 == -1 ? new Boolean(false) : new Integer(var2);
  147.             case 4097:
  148.             case 4098:
  149.                return new Integer(var2);
  150.             default:
  151.                return null;
  152.          }
  153.       }
  154.    }
  155.  
  156.    private void doSOCKSConnect(InetAddress var1, int var2) throws IOException {
  157.       this.connectToSocksServer();
  158.       this.sendSOCKSCommandPacket(1, var1, var2);
  159.       int var3 = this.getSOCKSReply();
  160.       switch (var3) {
  161.          case 90:
  162.             return;
  163.          case 91:
  164.          case 92:
  165.             throw new SocketException("SOCKS server cannot connect to identd");
  166.          case 93:
  167.             throw new SocketException("User name does not match identd name");
  168.          default:
  169.       }
  170.    }
  171.  
  172.    private int getSOCKSReply() throws IOException {
  173.       InputStream var1 = this.getInputStream();
  174.       byte[] var2 = new byte[8];
  175.       int var3 = 0;
  176.       int var4 = var2.length;
  177.  
  178.       for(int var5 = 0; var3 < var4 && var5 < 3; ++var5) {
  179.          int var6 = var1.read(var2, var3, var4 - var3);
  180.          if (var6 < 0) {
  181.             throw new SocketException("Malformed reply from SOCKS server");
  182.          }
  183.  
  184.          var3 += var6;
  185.       }
  186.  
  187.       if (var3 != var4) {
  188.          throw new SocketException("Reply from SOCKS server has bad length: " + var3);
  189.       } else if (var2[0] != 0) {
  190.          throw new SocketException("Reply from SOCKS server has bad version " + var2[0]);
  191.       } else {
  192.          return var2[1];
  193.       }
  194.    }
  195.  
  196.    private void connectToSocksServer() throws IOException {
  197.       Object var1 = null;
  198.       Object var2 = null;
  199.       String var7 = (String)AccessController.doPrivileged(new GetPropertyAction("socksProxyHost"));
  200.       String var8 = (String)AccessController.doPrivileged(new GetPropertyAction("socksProxyPort", "1080"));
  201.       if (var7 != null) {
  202.          InetAddress var3 = InetAddress.getByName(var7);
  203.  
  204.          int var4;
  205.          try {
  206.             var4 = Integer.parseInt(var8);
  207.          } catch (Exception var6) {
  208.             throw new SocketException("Bad port number format");
  209.          }
  210.  
  211.          this.doConnect(var3, var4);
  212.       }
  213.    }
  214.  
  215.    private void doConnect(InetAddress var1, int var2) throws IOException {
  216.       ProtocolException var3 = null;
  217.       int var4 = 0;
  218.  
  219.       while(var4 < 3) {
  220.          try {
  221.             this.socketConnect(var1, var2);
  222.             return;
  223.          } catch (ProtocolException var7) {
  224.             this.close();
  225.             super.fd = new FileDescriptor();
  226.             this.socketCreate(true);
  227.             var3 = var7;
  228.             ++var4;
  229.          } catch (IOException var8) {
  230.             this.close();
  231.             throw var8;
  232.          }
  233.       }
  234.  
  235.       this.close();
  236.       throw var3;
  237.    }
  238.  
  239.    private void sendSOCKSCommandPacket(int var1, InetAddress var2, int var3) throws IOException {
  240.       byte[] var4 = this.makeCommandPacket(var1, var2, var3);
  241.       OutputStream var5 = this.getOutputStream();
  242.       var5.write(var4);
  243.    }
  244.  
  245.    private byte[] makeCommandPacket(int var1, InetAddress var2, int var3) {
  246.       ByteArrayOutputStream var4 = new ByteArrayOutputStream(9);
  247.       var4.write(4);
  248.       var4.write(var1);
  249.       var4.write(var3 >> 8 & 255);
  250.       var4.write(var3 >> 0 & 255);
  251.       byte[] var5 = var2.getAddress();
  252.       var4.write(var5, 0, var5.length);
  253.       String var6 = (String)AccessController.doPrivileged(new GetPropertyAction("user.name"));
  254.       byte[] var7 = new byte[var6.length()];
  255.       var6.getBytes(0, var6.length(), var7, 0);
  256.       var4.write(var7, 0, var7.length);
  257.       var4.write(0);
  258.       return var4.toByteArray();
  259.    }
  260.  
  261.    private boolean usingSocks() {
  262.       String var1 = (String)AccessController.doPrivileged(new GetPropertyAction("socksProxyHost"));
  263.       return var1 != null;
  264.    }
  265.  
  266.    protected synchronized void bind(InetAddress var1, int var2) throws IOException {
  267.       this.socketBind(var1, var2);
  268.    }
  269.  
  270.    protected synchronized void listen(int var1) throws IOException {
  271.       this.socketListen(var1);
  272.    }
  273.  
  274.    protected synchronized void accept(SocketImpl var1) throws IOException {
  275.       this.socketAccept(var1);
  276.    }
  277.  
  278.    protected synchronized InputStream getInputStream() throws IOException {
  279.       if (super.fd == null) {
  280.          throw new IOException("Socket Closed");
  281.       } else if (this.shut_rd) {
  282.          throw new IOException("Socket input is shutdown");
  283.       } else {
  284.          if (this.socketInputStream == null) {
  285.             this.socketInputStream = new SocketInputStream(this);
  286.          }
  287.  
  288.          return this.socketInputStream;
  289.       }
  290.    }
  291.  
  292.    protected synchronized OutputStream getOutputStream() throws IOException {
  293.       if (super.fd == null) {
  294.          throw new IOException("Socket Closed");
  295.       } else if (this.shut_wr) {
  296.          throw new IOException("Socket output is shutdown");
  297.       } else {
  298.          return new SocketOutputStream(this);
  299.       }
  300.    }
  301.  
  302.    protected synchronized int available() throws IOException {
  303.       if (super.fd == null) {
  304.          throw new IOException("Stream closed.");
  305.       } else {
  306.          return this.socketAvailable();
  307.       }
  308.    }
  309.  
  310.    protected void close() throws IOException {
  311.       if (super.fd != null) {
  312.          this.socketClose();
  313.          super.fd = null;
  314.       }
  315.  
  316.    }
  317.  
  318.    protected void shutdownInput() throws IOException {
  319.       if (super.fd != null) {
  320.          this.socketShutdown(0);
  321.          if (this.socketInputStream != null) {
  322.             this.socketInputStream.setEOF(true);
  323.          }
  324.  
  325.          this.shut_rd = true;
  326.       }
  327.  
  328.    }
  329.  
  330.    protected void shutdownOutput() throws IOException {
  331.       if (super.fd != null) {
  332.          this.socketShutdown(1);
  333.          this.shut_wr = true;
  334.       }
  335.  
  336.    }
  337.  
  338.    protected void finalize() throws IOException {
  339.       this.close();
  340.    }
  341.  
  342.    private native void socketCreate(boolean var1) throws IOException;
  343.  
  344.    private native void socketConnect(InetAddress var1, int var2) throws IOException;
  345.  
  346.    private native void socketBind(InetAddress var1, int var2) throws IOException;
  347.  
  348.    private native void socketListen(int var1) throws IOException;
  349.  
  350.    private native void socketAccept(SocketImpl var1) throws IOException;
  351.  
  352.    private native int socketAvailable() throws IOException;
  353.  
  354.    private native void socketClose() throws IOException;
  355.  
  356.    private native void socketShutdown(int var1) throws IOException;
  357.  
  358.    private static native void initProto();
  359.  
  360.    private native void socketSetOption(int var1, boolean var2, Object var3) throws SocketException;
  361.  
  362.    private native int socketGetOption(int var1) throws SocketException;
  363.  
  364.    static {
  365.       AccessController.doPrivileged(new LoadLibraryAction("net"));
  366.       String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("java.net.connectiontimeout"));
  367.       if (var0 != null) {
  368.          preferredConnectionTimeout = Integer.parseInt(var0);
  369.       }
  370.  
  371.       initProto();
  372.    }
  373. }
  374.