connectrequesthandler.java

这是linux下ssl vpn的实现程序

            return true;
        }
        return false;
    }

    public synchronized void releasePort(int port) {
        listeningPorts.remove(new Integer(port));
    }

    public synchronized boolean isAddressInUse(int port) {
        return listeningPorts.containsKey(new Integer(port));
    }

    public synchronized void addProxyHandlerListener(ConnectRequestHandlerListener listener) {
        if (listeners == null) {
            listeners = new ArrayList();
        }
        listeners.add(listener);
    }

    public synchronized void removeProxyHandlerListener(ConnectRequestHandlerListener listener) {
        if (listeners != null) {
            listeners.remove(listener);
        }
    }

    private VPNListeningSocket verifyTunnelCredentials(String ticket, String tunnel) throws IOException {
        if (listeners == null) {
            throw new IOException("No ProxyHandlerListener registered.");
        }
        for (int i = listeners.size() - 1; i >= 0; i--) {
            VPNListeningSocket t = ((ConnectRequestHandlerListener) listeners.get(i)).validateTunnel(ticket, tunnel);
            if (t != null) {
                return t;
            }
        }
        throw new IOException("Tunnel verification failed.");
    }

    protected void sendForbid(RequestHandlerRequest request, RequestHandlerResponse response) throws IOException {
    	if (log.isDebugEnabled())
    		log.debug("Sending forbidden");
        response.sendError(HttpConstants.RESP_403_FORBIDDEN, "Forbidden for Proxy");
    }

    void requestAuthentication(RequestHandlerResponse response) throws IOException {
        response.setField("Proxy-Authenticate", "Basic realm=\"SSL-Explorer/1.0\"");
        response.sendError(HttpConstants.RESP_407_PROXY_AUTHENTICATION_REQUIRED, "Authentication required");

    }

    void sendAuthorizationError(RequestHandlerResponse response) throws IOException {
    	if (log.isDebugEnabled())
    		log.debug("Sending invalid credentials");
        response.sendError(HttpConstants.RESP_401_UNAUTHORIZED, "Authentication creditials were invalid");
    }

    class UDPHttpTunnel extends LocalRequestHandlerTunnel implements ForwardingTunnel {
        InetAddress host;
        int port;
        DatagramSocket socket;
        DatagramPacket outPacket;
        DatagramPacket inPacket;
        byte[] outBuf;
        byte[] inBuf;
        int packetSize = 65536;
        DataInputStream tunnelDataInStream;
        DataOutputStream tunnelDataOutStream;
        HashMap datagramMap;

        UDPHttpTunnel(VPNListeningSocket vpnTunnel, InetAddress host, int port) throws SocketException {
            super(vpnTunnel, null, 0);
            this.host = host;
            this.port = port;
            datagramMap = new HashMap();

            // socket = new DatagramSocket();
            // outBuf = new byte[packetSize];
            // outPacket = new DatagramPacket(outBuf, packetSize, host, port);
            // inBuf = new byte[packetSize];
            // inPacket = new DatagramPacket(outBuf, packetSize, host, port);
        }

        protected synchronized DatagramSocket getDatagramSocket(final DataOutputStream tunnelDataOutStream,
                        final InetAddress srcAddress, final int srcPort) throws SocketException {
            String key = srcAddress.getHostAddress() + ":" + srcPort;
            DatagramSocket socket = (DatagramSocket) datagramMap.get(key);
            if (socket == null) {
                socket = new DatagramSocket();
                datagramMap.put(key, socket);
                final DatagramSocket finalSocket = socket;
                Thread thread = new Thread() {
                    public void run() {
                        byte[] buffer = new byte[65536];
                        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
                        while (true) {
                            try {
                                packet.setData(buffer);
                                packet.setLength(buffer.length);
                                finalSocket.receive(packet);
                                try {
                                    synchronized (tunnelDataOutStream) {
                                        tunnelDataOutStream.write(srcAddress.getAddress());
                                        tunnelDataOutStream.writeInt(srcPort);
                                        tunnelDataOutStream.writeInt(packet.getPort());
                                        tunnelDataOutStream.writeInt(packet.getLength());
                                        tunnelDataOutStream.write(packet.getData(), 0, packet.getLength());
                                        tunnelDataOutStream.flush();
                                    }

                                } catch (Throwable e) {
                                    log.error("Error writing UDP datagram to tunnel for " + host + ":" + port + ". ", e);
                                }
                            } catch (Throwable e) {
                                log.error("Error receiving UDP datagram for tunnel " + host + ":" + port + ". ", e);
                            }
                        }
                    }
                };
                thread.setDaemon(true);
                thread.start();
            }

            return (socket);
        }

        public void handle(InputStream in, OutputStream out) {
            try {

                _vpnTunnel.addActiveTunnel(this);

                tunnelDataInStream = new DataInputStream(in);
                tunnelDataOutStream = new DataOutputStream(out);

                while (true) {
                    byte[] srcAddrBytes = new byte[4];
                    tunnelDataInStream.readFully(srcAddrBytes);
                    InetAddress srcAddr = InetAddress.getByAddress(srcAddrBytes);
                    int srcPort = tunnelDataInStream.readInt();
                    int length = tunnelDataInStream.readInt();
                    byte[] data = new byte[length];
                    tunnelDataInStream.readFully(data);

                    try {
                        DatagramSocket udpSocket = getDatagramSocket(tunnelDataOutStream, srcAddr, srcPort);
                        DatagramPacket packet = new DatagramPacket(data, length, host, port);
                        udpSocket.send(packet);
                    } catch (Throwable e) {
                        log.error("Failed to send UDP datagram to " + host + ":" + port + ". ", e);
                    }
                }

                // Thread datagramInThread = new Thread() {
                // public void run() {
                // try {
                // int size = -1;
                // int read;
                // byte[] buf = new byte[packetSize];
                // while(true) {
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("Waiting for packet size from tunnel");}
                // size = tunnelDataInStream.readInt();
                // if(size == -1) {
                // break;
                // }
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("Got packet size - expecting " + size +
                // "
                // bytes");}
                //
                // read = tunnelDataInStream.read(buf, 0, size);
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("Received " + read + " bytes");}
                // if(read == -1) {
                // throw new EOFException();
                // }
                // if(read != size) {
                // throw new IOException("Received " + read + " bytes from a UDP
                // tunnel,
                // but expected " + packetSize +". ");
                // }
                // outPacket.setData(buf, 0, read);
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("Sending packet ["+ new String(buf, 0,
                // read) +
                // "]");}
                // socket.send(outPacket);
                // }
                // }
                // catch(EOFException e) {
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("EOF reading tunnel.");}
                //
                // }
                // catch(Exception e) {
                // /* DEBUG */ log.error("Error reading tunnel.", e);
                // }
                // finally {
                // /* DEBUG */ log.error("Closing socket.");
                // socket.close();
                // }
                // }
                // };
                // datagramInThread.start();
                //
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("Waiting for UDP packet from host");}
                // while(true) {
                // socket.receive(inPacket);
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("Received UDP packet from host (" +
                // inPacket.getLength() + " bytes, sending to tunnel");}
                // tunnelDataOutStream.writeInt(inPacket.getLength());
                // tunnelDataOutStream.write(inPacket.getData(),
                // inPacket.getOffset(),
                // inPacket.getLength());
                // /* DEBUG */ if (log.isDebugEnabled()) {log.debug("UDP packet of " + inPacket.getLength()
                // + "
                // bytes sent to tunnel ["+ new String(inPacket.getData(),
                // inPacket.getOffset(), inPacket.getLength()) + "]");}
                // tunnelDataOutStream.flush();
                // }
            } catch (Throwable ex) {
                log.error("UDP tunnel failed.", ex);
            } finally {
                socket.close();
                try {
                    tunnelDataInStream.close();
                } catch (Exception e) {
                }
                try {
                    tunnelDataOutStream.close();
                } catch (Exception e) {
                }
                CoreServlet.getServlet().fireCoreEvent(new CoreEvent(this,
                                CoreEventConstants.TUNNEL_CLOSED, _vpnTunnel, null));
                _vpnTunnel.removeActiveTunnel(this);
            }
        }
    }

    class UDPTunnelSocketFactory {

    }
}