rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/socket.py

@@ -0,0 +1,902 @@
+"""
+This is an updated socket module for use on JVMs > 1.4; it is derived from the
+old jython socket module.
+The primary extra it provides is non-blocking support.
+
+XXX Restrictions:
+
+- Only INET sockets
+- No asynchronous behavior
+- No socket options
+- Can't do a very good gethostbyaddr() right...
+AMAK: 20050527: added socket timeouts
+AMAK: 20070515: Added non-blocking (asynchronous) support
+AMAK: 20070515: Added client-side SSL support
+"""
+
+_defaulttimeout = None
+
+import errno
+import jarray
+import string
+import sys
+import threading
+import time
+import types
+
+# Java.io classes 
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+# Java.io exceptions
+import java.io.InterruptedIOException
+import java.io.IOException
+
+# Java.lang classes
+import java.lang.String
+# Java.lang exceptions
+import java.lang.Exception
+
+# Java.net classes
+import java.net.DatagramPacket
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.Socket
+# Java.net exceptions
+import java.net.BindException
+import java.net.ConnectException
+import java.net.NoRouteToHostException
+import java.net.PortUnreachableException
+import java.net.ProtocolException
+import java.net.SocketException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+
+# Java.nio classes
+import java.nio.ByteBuffer
+import java.nio.channels.DatagramChannel
+import java.nio.channels.ServerSocketChannel
+import java.nio.channels.SocketChannel
+# Java.nio exceptions
+import java.nio.channels.AlreadyConnectedException
+import java.nio.channels.AsynchronousCloseException
+import java.nio.channels.CancelledKeyException
+import java.nio.channels.ClosedByInterruptException
+import java.nio.channels.ClosedChannelException
+import java.nio.channels.ClosedSelectorException
+import java.nio.channels.ConnectionPendingException
+import java.nio.channels.IllegalBlockingModeException
+import java.nio.channels.IllegalSelectorException
+import java.nio.channels.NoConnectionPendingException
+import java.nio.channels.NonReadableChannelException
+import java.nio.channels.NonWritableChannelException
+import java.nio.channels.NotYetBoundException
+import java.nio.channels.NotYetConnectedException
+import java.nio.channels.UnresolvedAddressException
+import java.nio.channels.UnsupportedAddressTypeException
+
+import javax.net.ssl.SSLSocketFactory
+import org.python.core.PyFile
+
+class error(Exception): pass
+class herror(error): pass
+class gaierror(error): pass
+class timeout(error): pass
+
+ALL = None
+
+_exception_map = {
+
+# (<javaexception>, <circumstance>) : lambda: <code that raises the python equivalent>
+
+(java.io.IOException, ALL)            : error(errno.ECONNRESET, 'Software caused connection abort'),
+(java.io.InterruptedIOException, ALL) : timeout('timed out'),
+
+(java.net.BindException, ALL)            : error(errno.EADDRINUSE, 'Address already in use'),
+(java.net.ConnectException, ALL)         : error(errno.ECONNREFUSED, 'Connection refused'),
+(java.net.NoRouteToHostException, ALL)   : error(-1, 'Unmapped exception: java.net.NoRouteToHostException'),
+(java.net.PortUnreachableException, ALL) : error(-1, 'Unmapped exception: java.net.PortUnreachableException'),
+(java.net.ProtocolException, ALL)        : error(-1, 'Unmapped exception: java.net.ProtocolException'),
+(java.net.SocketException, ALL)          : error(-1, 'Unmapped exception: java.net.SocketException'),
+(java.net.SocketTimeoutException, ALL)   : timeout('timed out'),
+(java.net.UnknownHostException, ALL)     : gaierror(errno.EGETADDRINFOFAILED, 'getaddrinfo failed'),
+
+(java.nio.channels.AlreadyConnectedException, ALL)       : error(errno.EISCONN, 'Socket is already connected'),
+(java.nio.channels.AsynchronousCloseException, ALL)      : error(-1, 'Unmapped exception: java.nio.AsynchronousCloseException'),
+(java.nio.channels.CancelledKeyException, ALL)           : error(-1, 'Unmapped exception: java.nio.CancelledKeyException'),
+(java.nio.channels.ClosedByInterruptException, ALL)      : error(-1, 'Unmapped exception: java.nio.ClosedByInterruptException'),
+(java.nio.channels.ClosedChannelException, ALL)          : error(errno.EPIPE, 'Socket closed'),
+(java.nio.channels.ClosedSelectorException, ALL)         : error(-1, 'Unmapped exception: java.nio.ClosedSelectorException'),
+(java.nio.channels.ConnectionPendingException, ALL)      : error(-1, 'Unmapped exception: java.nio.ConnectionPendingException'),
+(java.nio.channels.IllegalBlockingModeException, ALL)    : error(-1, 'Unmapped exception: java.nio.IllegalBlockingModeException'),
+(java.nio.channels.IllegalSelectorException, ALL)        : error(-1, 'Unmapped exception: java.nio.IllegalSelectorException'),
+(java.nio.channels.NoConnectionPendingException, ALL)    : error(-1, 'Unmapped exception: java.nio.NoConnectionPendingException'),
+(java.nio.channels.NonReadableChannelException, ALL)     : error(-1, 'Unmapped exception: java.nio.NonReadableChannelException'),
+(java.nio.channels.NonWritableChannelException, ALL)     : error(-1, 'Unmapped exception: java.nio.NonWritableChannelException'),
+(java.nio.channels.NotYetBoundException, ALL)            : error(-1, 'Unmapped exception: java.nio.NotYetBoundException'),
+(java.nio.channels.NotYetConnectedException, ALL)        : error(-1, 'Unmapped exception: java.nio.NotYetConnectedException'),
+(java.nio.channels.UnresolvedAddressException, ALL)      : gaierror(errno.EGETADDRINFOFAILED, 'getaddrinfo failed'),
+(java.nio.channels.UnsupportedAddressTypeException, ALL) : error(-1, 'Unmapped exception: java.nio.UnsupportedAddressTypeException'),
+
+}
+
+def would_block_error(exc=None):
+    return error(errno.EWOULDBLOCK, 'The socket operation could not complete without blocking')
+
+def _map_exception(exc, circumstance=ALL):
+#    print "Mapping exception: %s" % exc
+    try:
+        mapped_exception = _exception_map[(exc.__class__, circumstance)]
+        mapped_exception.java_exception = exc
+        return mapped_exception
+    except KeyError:
+        return error(-1, 'Unmapped java exception: <%s:%s>' % (exc.toString(), circumstance))
+
+MODE_BLOCKING    = 'block'
+MODE_NONBLOCKING = 'nonblock'
+MODE_TIMEOUT     = 'timeout'
+
+_permitted_modes = (MODE_BLOCKING, MODE_NONBLOCKING, MODE_TIMEOUT)
+
+SHUT_RD   = 0
+SHUT_WR   = 1
+SHUT_RDWR = 2
+
+class _nio_impl:
+
+    timeout = None
+    mode = MODE_BLOCKING
+
+    def read(self, buf):
+        bytebuf = java.nio.ByteBuffer.wrap(buf)
+        count = self.jchannel.read(bytebuf)
+        return count
+
+    def write(self, buf):
+        bytebuf = java.nio.ByteBuffer.wrap(buf)
+        count = self.jchannel.write(bytebuf)
+        return count
+
+    def _setreuseaddress(self, flag):
+        self.jsocket.setReuseAddress(flag)
+
+    def _getreuseaddress(self, flag):
+        return self.jsocket.getReuseAddress()
+
+    def getpeername(self):
+        return (self.jsocket.getInetAddress().getHostName(), self.jsocket.getPort() )
+
+    def config(self, mode, timeout):
+        self.mode = mode
+        if self.mode == MODE_BLOCKING:
+            self.jchannel.configureBlocking(1)
+        if self.mode == MODE_NONBLOCKING:
+            self.jchannel.configureBlocking(0)
+        if self.mode == MODE_TIMEOUT:
+            self._timeout_millis = int(timeout*1000)
+            self.jsocket.setSoTimeout(self._timeout_millis)
+
+    def close1(self):
+        self.jsocket.close()
+
+    def close2(self):
+        self.jchannel.close()
+
+    def close3(self):
+        if not self.jsocket.isClosed():
+            self.jsocket.close()
+
+    def close4(self):
+        if not self.jsocket.isClosed():
+            if hasattr(self.jsocket, 'shutdownInput') and not self.jsocket.isInputShutdown():
+                self.jsocket.shutdownInput()
+            if hasattr(self.jsocket, 'shutdownOutput') and not self.jsocket.isOutputShutdown():
+                self.jsocket.shutdownOutput()
+            self.jsocket.close()
+
+    close = close1
+#    close = close2
+#    close = close3
+#    close = close4
+
+    def shutdownInput(self):
+        self.jsocket.shutdownInput()
+
+    def shutdownOutput(self):
+        self.jsocket.shutdownOutput()
+
+    def getchannel(self):
+        return self.jchannel
+
+    fileno = getchannel
+
+class _client_socket_impl(_nio_impl):
+
+    def __init__(self, socket=None):
+        if socket:
+            self.jchannel = socket.getChannel()
+            self.host = socket.getInetAddress().getHostName()
+            self.port = socket.getPort()
+        else:
+            self.jchannel = java.nio.channels.SocketChannel.open()
+            self.host = None
+            self.port = None
+        self.jsocket = self.jchannel.socket()
+
+    def bind(self, host, port):
+        self.jsocket.bind(java.net.InetSocketAddress(host, port))
+
+    def connect(self, host, port):
+        self.host = host
+        self.port = port
+        if self.mode == MODE_TIMEOUT:
+            self.jsocket.connect(java.net.InetSocketAddress(self.host, self.port), self._timeout_millis)
+        else:
+            self.jchannel.connect(java.net.InetSocketAddress(self.host, self.port))
+
+    def finish_connect(self):
+        return self.jchannel.finishConnect()
+
+class _server_socket_impl(_nio_impl):
+
+    def __init__(self, host, port, backlog, reuse_addr):
+        self.jchannel = java.nio.channels.ServerSocketChannel.open()
+        self.jsocket = self.jchannel.socket()
+        if host:
+            bindaddr = java.net.InetSocketAddress(host, port)
+        else:
+            bindaddr = java.net.InetSocketAddress(port)
+        self._setreuseaddress(reuse_addr)
+        self.jsocket.bind(bindaddr, backlog)
+
+    def accept(self):
+        if self.mode in (MODE_BLOCKING, MODE_NONBLOCKING):
+            new_cli_chan = self.jchannel.accept()
+            if new_cli_chan != None:
+                return _client_socket_impl(new_cli_chan.socket())
+            else:
+                return None
+        else:
+            # In timeout mode now
+            new_cli_sock = self.jsocket.accept()
+            return _client_socket_impl(new_cli_sock)
+        
+class _datagram_socket_impl(_nio_impl):
+
+    def __init__(self, port=None, address=None, reuse_addr=0):
+        self.jchannel = java.nio.channels.DatagramChannel.open()
+        self.jsocket = self.jchannel.socket()
+        if port:
+            if address is not None:
+                local_address = java.net.InetSocketAddress(address, port)
+            else:
+                local_address = java.net.InetSocketAddress(port)
+            self.jsocket.bind(local_address)
+        self._setreuseaddress(reuse_addr)
+
+    def connect(self, host, port):
+        self.jchannel.connect(java.net.InetSocketAddress(host, port))
+
+    def finish_connect(self):
+        return self.jchannel.finishConnect()
+
+    def receive(self, packet):
+        self.jsocket.receive(packet)
+
+    def send(self, packet):
+        self.jsocket.send(packet)
+
+__all__ = [ 'AF_INET', 'SO_REUSEADDR', 'SOCK_DGRAM', 'SOCK_RAW',
+        'SOCK_RDM', 'SOCK_SEQPACKET', 'SOCK_STREAM', 'SOL_SOCKET',
+        'SocketType', 'SocketTypes', 'error', 'herror', 'gaierror', 'timeout',
+        'getfqdn', 'gethostbyaddr', 'gethostbyname', 'gethostname',
+        'socket', 'getaddrinfo', 'getdefaulttimeout', 'setdefaulttimeout',
+        'has_ipv6', 'htons', 'htonl', 'ntohs', 'ntohl',
+        'SHUT_RD', 'SHUT_WR', 'SHUT_RDWR',
+        ]
+
+AF_INET = 2
+
+SOCK_DGRAM = 1
+SOCK_STREAM = 2
+SOCK_RAW = 3 # not supported
+SOCK_RDM = 4 # not supported
+SOCK_SEQPACKET = 5 # not supported
+SOL_SOCKET = 0xFFFF
+SO_REUSEADDR = 4
+
+def _gethostbyaddr(name):
+    # This is as close as I can get; at least the types are correct...
+    addresses = java.net.InetAddress.getAllByName(gethostbyname(name))
+    names = []
+    addrs = []
+    for addr in addresses:
+      names.append(addr.getHostName())
+      addrs.append(addr.getHostAddress())
+    return (names, addrs)
+
+def getfqdn(name=None):
+    """
+    Return a fully qualified domain name for name. If name is omitted or empty
+    it is interpreted as the local host.  To find the fully qualified name,
+    the hostname returned by gethostbyaddr() is checked, then aliases for the
+    host, if available. The first name which includes a period is selected.
+    In case no fully qualified domain name is available, the hostname is retur
+    New in version 2.0.
+    """
+    if not name:
+        name = gethostname()
+    names, addrs = _gethostbyaddr(name)
+    for a in names:
+        if a.find(".") >= 0:
+            return a
+    return name
+
+def gethostname():
+    try:
+        return java.net.InetAddress.getLocalHost().getHostName()
+    except java.lang.Exception, jlx:
+        raise _map_exception(jlx)
+
+def gethostbyname(name):
+    try:
+        return java.net.InetAddress.getByName(name).getHostAddress()
+    except java.lang.Exception, jlx:
+        raise _map_exception(jlx)
+
+def gethostbyaddr(name):
+    names, addrs = _gethostbyaddr(name)
+    return (names[0], names, addrs)
+
+def getservbyname(servicename, protocolname=None):
+    # http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071389
+    # How complex is the structure of /etc/services?
+    raise NotImplementedError("getservbyname not yet supported on jython.")
+
+def getservbyport(port, protocolname=None):
+    # Same situation as above
+    raise NotImplementedError("getservbyport not yet supported on jython.")
+
+def getprotobyname(protocolname=None):
+    # Same situation as above
+    raise NotImplementedError("getprotobyname not yet supported on jython.")
+
+def socket(family = AF_INET, type = SOCK_STREAM, flags=0):
+    assert family == AF_INET
+    assert type in (SOCK_DGRAM, SOCK_STREAM)
+    assert flags == 0
+    if type == SOCK_STREAM:
+        return _tcpsocket()
+    else:
+        return _udpsocket()
+
+def getaddrinfo(host, port, family=0, socktype=SOCK_STREAM, proto=0, flags=0):
+    return ( (AF_INET, socktype, 0, "", (gethostbyname(host), port)), )
+
+has_ipv6 = 1
+
+def getnameinfo(sock_addr, flags):
+    raise NotImplementedError("getnameinfo not yet supported on jython.")
+
+def getdefaulttimeout():
+    return _defaulttimeout
+
+def _calctimeoutvalue(value):
+    if value is None:
+        return None
+    try:
+        floatvalue = float(value)
+    except:
+        raise TypeError('Socket timeout value must be a number or None')
+    if floatvalue < 0.0:
+        raise ValueError("Socket timeout value cannot be negative")
+    if floatvalue < 0.000001:
+        return 0.0
+    return floatvalue
+
+def setdefaulttimeout(timeout):
+    global _defaulttimeout
+    try:
+        _defaulttimeout = _calctimeoutvalue(timeout)
+    finally:
+        _nonblocking_api_mixin.timeout = _defaulttimeout
+
+def htons(x): return x
+def htonl(x): return x
+def ntohs(x): return x
+def ntohl(x): return x
+
+class _nonblocking_api_mixin:
+
+    timeout = _defaulttimeout
+    mode = MODE_BLOCKING
+
+    def gettimeout(self):
+        return self.timeout
+
+    def settimeout(self, timeout):
+        self.timeout = _calctimeoutvalue(timeout)
+        if self.timeout is None:
+            self.mode = MODE_BLOCKING
+        elif self.timeout < 0.000001:
+            self.mode = MODE_NONBLOCKING
+        else:
+            self.mode = MODE_TIMEOUT
+        self._config()
+
+    def setblocking(self, flag):
+        if flag:
+            self.mode = MODE_BLOCKING
+            self.timeout = None
+        else:
+            self.mode = MODE_NONBLOCKING
+            self.timeout = 0.0
+        self._config()
+
+    def getblocking(self):
+        return self.mode == MODE_BLOCKING
+
+    def _config(self):
+        assert self.mode in _permitted_modes
+        if self.sock_impl: self.sock_impl.config(self.mode, self.timeout)
+
+    def getchannel(self):
+        if not self.sock_impl:
+            return None
+        return self.sock_impl.getchannel()
+
+    fileno = getchannel
+
+    def _get_jsocket(self):
+        return self.sock_impl.jsocket
+
+def _unpack_address_tuple(address_tuple):
+    error_message = "Address must be a tuple of (hostname, port)"
+    if type(address_tuple) is not type( () ) \
+            or type(address_tuple[0]) is not type("") \
+            or type(address_tuple[1]) is not type(0):
+        raise TypeError(error_message)
+    return address_tuple[0], address_tuple[1]
+
+class _tcpsocket(_nonblocking_api_mixin):
+
+    sock_impl = None
+    istream = None
+    ostream = None
+    local_addr = None
+    server = 0
+    file_count = 0
+    reuse_addr = 0
+
+    def bind(self, addr):
+        assert not self.sock_impl
+        assert not self.local_addr
+        # Do the address format check
+        host, port = _unpack_address_tuple(addr)
+        self.local_addr = addr
+
+    def listen(self, backlog=50):
+        "This signifies a server socket"
+        try:
+            assert not self.sock_impl
+            self.server = 1
+            if self.local_addr:
+                host, port = self.local_addr
+            else:
+                host, port = "", 0
+            self.sock_impl = _server_socket_impl(host, port, backlog, self.reuse_addr)
+            self._config()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def accept(self):
+        "This signifies a server socket"
+        try:
+            if not self.sock_impl:
+                self.listen()
+            assert self.server
+            new_sock = self.sock_impl.accept()
+            if not new_sock:
+                raise would_block_error()
+            cliconn = _tcpsocket()
+            cliconn.reuse_addr = new_sock.jsocket.getReuseAddress()
+            cliconn.sock_impl = new_sock
+            cliconn._setup()
+            return cliconn, new_sock.getpeername()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def _get_host_port(self, addr):
+        host, port = _unpack_address_tuple(addr)
+        if host == "":
+            host = java.net.InetAddress.getLocalHost()
+        return host, port
+
+    def _do_connect(self, addr):
+        try:
+            assert not self.sock_impl
+            host, port = self._get_host_port(addr)
+            self.sock_impl = _client_socket_impl()
+            self.sock_impl._setreuseaddress(self.reuse_addr)
+            if self.local_addr: # Has the socket been bound to a local address?
+                bind_host, bind_port = self.local_addr
+                self.sock_impl.bind(bind_host, bind_port)
+            self._config() # Configure timeouts, etc, now that the socket exists
+            self.sock_impl.connect(host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def connect(self, addr):
+        "This signifies a client socket"
+        self._do_connect(addr)
+        self._setup()
+
+    def connect_ex(self, addr):
+        "This signifies a client socket"
+        self._do_connect(addr)
+        if self.sock_impl.finish_connect():
+            self._setup()
+            return 0
+        return errno.EINPROGRESS
+
+    def _setup(self):
+        if self.mode != MODE_NONBLOCKING:
+            self.istream = self.sock_impl.jsocket.getInputStream()
+            self.ostream = self.sock_impl.jsocket.getOutputStream()
+
+    def recv(self, n):
+        try:
+            if not self.sock_impl: raise error(errno.ENOTCONN, 'Socket is not connected')
+            if self.sock_impl.jchannel.isConnectionPending():
+                self.sock_impl.jchannel.finishConnect()
+            data = jarray.zeros(n, 'b')
+            m = self.sock_impl.read(data)
+            if m == -1:#indicates EOF has been reached, so we just return the empty string
+                return ""
+            elif m <= 0:
+                if self.mode == MODE_NONBLOCKING:
+                    raise would_block_error()
+                return ""
+            if m < n:
+                data = data[:m]
+            return data.tostring()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def recvfrom(self, n):
+        return self.recv(n), None
+
+    def send(self, s):
+        try:
+            if not self.sock_impl: raise error(errno.ENOTCONN, 'Socket is not connected')
+            if self.sock_impl.jchannel.isConnectionPending():
+                self.sock_impl.jchannel.finishConnect()
+            numwritten = self.sock_impl.write(s)
+            return numwritten
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    sendall = send
+
+    def getsockname(self):
+        try:
+            if not self.sock_impl:
+                host, port = self.local_addr or ("", 0)
+                host = java.net.InetAddress.getByName(host).getHostAddress()
+            else:
+                if self.server:
+                    host = self.sock_impl.jsocket.getInetAddress().getHostAddress()
+                else:
+                    host = self.sock_impl.jsocket.getLocalAddress().getHostAddress()
+                port = self.sock_impl.jsocket.getLocalPort()
+            return (host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def getpeername(self):
+        try:
+            assert self.sock_impl
+            assert not self.server
+            host = self.sock_impl.jsocket.getInetAddress().getHostAddress()
+            port = self.sock_impl.jsocket.getPort()
+            return (host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+        
+    def setsockopt(self, level, optname, value):
+        if optname == SO_REUSEADDR:
+            self.reuse_addr = value
+
+    def getsockopt(self, level, optname):
+        if optname == SO_REUSEADDR:
+            return self.reuse_addr
+
+    def makefile(self, mode="r", bufsize=-1):
+        file = None
+        if self.istream:
+            if self.ostream:
+                file = org.python.core.PyFile(self.istream, self.ostream,
+                                              "<socket>", mode)
+            else:
+                file = org.python.core.PyFile(self.istream, "<socket>", mode)
+        elif self.ostream:
+            file = org.python.core.PyFile(self.ostream, "<socket>", mode)
+        else:
+            raise IOError, "both istream and ostream have been shut down"
+        if file:
+            return _tcpsocket.FileWrapper(self, file)
+
+    class FileWrapper:
+        def __init__(self, socket, file):
+            self.socket  = socket
+            self.istream = socket.istream
+            self.ostream = socket.ostream
+
+            self.file       = file
+            self.read       = file.read
+            self.readline   = file.readline
+            self.readlines  = file.readlines
+            self.write      = file.write
+            self.writelines = file.writelines
+            self.flush      = file.flush
+            self.seek       = file.seek
+            self.tell       = file.tell
+            self.closed     = file.closed
+
+            self.socket.file_count += 1
+
+        def close(self):
+            if self.closed:
+                # Already closed
+                return
+
+            self.socket.file_count -= 1
+            # AMAK: 20070715: Cannot close the PyFile, because closing 
+            # it causes the InputStream and OutputStream to be closed.
+            # This in turn causes the underlying socket to be closed.
+            # This was always true for java.net sockets
+            # And continues to be true for java.nio sockets
+            # http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4717638
+#            self.file.close()
+            istream = self.istream
+            ostream = self.ostream
+            self.istream = None
+            self.ostream = None
+#            self.closed = self.file.closed
+            self.closed = 1
+
+            if self.socket.file_count == 0 and self.socket.sock_impl is None:
+                # This is the last file Only close the socket and streams 
+                # if there are no outstanding files left.
+                istream.close()
+                ostream.close()
+
+    def shutdown(self, how):
+        assert how in (SHUT_RD, SHUT_WR, SHUT_RDWR)
+        assert self.sock_impl
+        if how in (SHUT_RD, SHUT_RDWR):
+            self.sock_impl.shutdownInput()
+        if how in (SHUT_WR, SHUT_RDWR):
+            self.sock_impl.shutdownOutput()
+
+    def close(self):
+        try:
+            if not self.sock_impl:
+                return
+            sock_impl = self.sock_impl
+            istream = self.istream
+            ostream = self.ostream
+            self.sock_impl = None
+            self.istream = None
+            self.ostream = None
+            # Only close the socket and streams if there are no 
+            # outstanding files left.
+            if self.file_count == 0:
+                if istream:
+                    istream.close()
+                if ostream:
+                    ostream.close()
+                if sock_impl:
+                    sock_impl.close()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+        
+
+class _udpsocket(_nonblocking_api_mixin):
+
+    def __init__(self):
+        self.sock_impl = None
+        self.addr = None
+        self.reuse_addr = 0
+
+    def bind(self, addr):
+        try:
+            assert not self.sock_impl
+            host, port = _unpack_address_tuple(addr)
+            host_address = java.net.InetAddress.getByName(host)
+            self.sock_impl = _datagram_socket_impl(port, host_address, reuse_addr = self.reuse_addr)
+            self._config()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def _do_connect(self, addr):
+        try:
+            host, port = _unpack_address_tuple(addr)
+            assert not self.addr
+            self.addr = addr
+            if not self.sock_impl:
+                self.sock_impl = _datagram_socket_impl()
+                self._config()
+                self.sock_impl.connect(host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def connect(self, addr):
+        self._do_connect(addr)
+
+    def connect_ex(self, addr):
+        self._do_connect(addr)
+        if self.sock_impl.finish_connect():
+            return 0
+        return errno.EINPROGRESS
+
+    def sendto(self, data, p1, p2=None):
+        try:
+            if not p2:
+                flags, addr = 0, p1
+            else:
+                flags, addr = 0, p2
+            n = len(data)
+            if not self.sock_impl:
+                self.sock_impl = _datagram_socket_impl()
+            host, port = addr
+            bytes = java.lang.String(data).getBytes('iso-8859-1')
+            a = java.net.InetAddress.getByName(host)
+            packet = java.net.DatagramPacket(bytes, n, a, port)
+            self.sock_impl.send(packet)
+            return n
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def send(self, data):
+        if not self.addr: raise error(errno.ENOTCONN, "Socket is not connected")
+        return self.sendto(data, self.addr)
+
+    def recvfrom(self, n):
+        try:
+            assert self.sock_impl
+            bytes = jarray.zeros(n, 'b')
+            packet = java.net.DatagramPacket(bytes, n)
+            self.sock_impl.receive(packet)
+            host = None
+            if packet.getAddress():
+                host = packet.getAddress().getHostName()
+            port = packet.getPort()
+            m = packet.getLength()
+            if m < n:
+                bytes = bytes[:m]
+            return bytes.tostring(), (host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def recv(self, n):
+        try:
+            assert self.sock_impl
+            bytes = jarray.zeros(n, 'b')
+            packet = java.net.DatagramPacket(bytes, n)
+            self.sock_impl.receive(packet)
+            m = packet.getLength()
+            if m < n:
+                bytes = bytes[:m]
+            return bytes.tostring()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def getsockname(self):
+        try:
+            assert self.sock_impl
+            host = self.sock_impl.jsocket.getLocalAddress().getHostName()
+            port = self.sock_impl.jsocket.getLocalPort()
+            return (host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def getpeername(self):
+        try:
+            assert self.sock
+            host = self.sock_impl.jsocket.getInetAddress().getHostName()
+            port = self.sock_impl.jsocket.getPort()
+            return (host, port)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        try:
+            if not self.sock_impl:
+                return
+            sock = self.sock_impl
+            self.sock_impl = None
+            sock.close()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def setsockopt(self, level, optname, value):
+        try:
+            if optname == SO_REUSEADDR:
+                self.reuse_addr = value
+#                self.sock._setreuseaddress(value)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def getsockopt(self, level, optname):
+        try:
+            if optname == SO_REUSEADDR:
+                return self.sock_impl._getreuseaddress()
+            else:
+                return None
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+SocketType = _tcpsocket
+SocketTypes = [_tcpsocket, _udpsocket]
+
+# Define the SSL support
+
+class ssl:
+
+    def __init__(self, plain_sock, keyfile=None, certfile=None):
+        self.ssl_sock = self.make_ssl_socket(plain_sock)
+
+    def make_ssl_socket(self, plain_socket, auto_close=0):
+        java_net_socket = plain_socket._get_jsocket()
+        assert isinstance(java_net_socket, java.net.Socket)
+        host = java_net_socket.getInetAddress().getHostName()
+        port = java_net_socket.getPort()
+        factory = javax.net.ssl.SSLSocketFactory.getDefault();
+        ssl_socket = factory.createSocket(java_net_socket, host, port, auto_close)
+        ssl_socket.setEnabledCipherSuites(ssl_socket.getSupportedCipherSuites())
+        ssl_socket.startHandshake()
+        return ssl_socket
+
+    def read(self, n=4096):
+        # Probably needs some work on efficency
+        in_buf = java.io.BufferedInputStream(self.ssl_sock.getInputStream())
+        data = jarray.zeros(n, 'b')
+        m = in_buf.read(data, 0, n)
+        if m <= 0:
+            return ""
+        if m < n:
+            data = data[:m]
+        return data.tostring()
+
+    def write(self, s):
+        # Probably needs some work on efficency
+        out = java.io.BufferedOutputStream(self.ssl_sock.getOutputStream())
+        out.write(s)
+        out.flush()
+
+    def _get_server_cert(self):
+        return self.ssl_sock.getSession().getPeerCertificates()[0]
+
+    def server(self):
+        cert = self._get_server_cert()
+        return cert.getSubjectDN().toString()
+
+    def issuer(self):
+        cert = self._get_server_cert()
+        return cert.getIssuerDN().toString()
+
+def test():
+    s = socket(AF_INET, SOCK_STREAM)
+    s.connect(("", 80))
+    s.send("GET / HTTP/1.0\r\n\r\n")
+    while 1:
+        data = s.recv(2000)
+        print data
+        if not data:
+            break
+
+if __name__ == '__main__':
+    test()