socket.py

python s60 1.4.5版本的源代码

        for k in dir(self._internalsocket):
            if not k.startswith('__') and k != 'close':
                value=getattr(self._internalsocket,k)
                if callable(value):
                    setattr(self,k,raise_error)
        self._internalsocket=None
        self._sock=None

class _internalsocketobject:
    class _closedsocket:
        def __getattr__(self, name):
            raise error(9, 'Bad file descriptor')
    def __init__(self, sock, family=AF_UNSPEC):
        self._sock = sock
        self._blocking=True
        self._recvbuf=''
        self._sendbuf=''
        self._recv_callback_pending=False
        self._send_callback_pending=False
        self._recv_listener=None
        self._recvsizehint=8
        self._sendflags=0
        self._recvlock=e32.Ao_lock()
        self._family=family
        self._error=None
        self._connectname=None
        
    def close(self):
        self._sock = self.__class__._closedsocket()
        
    def setblocking(self, flag):
        self._blocking=flag
            
    def accept(self, cb=None):
        if cb == None:
            sock, addr = self._sock.accept()
            return _socketobject(sock, self._family), addr
        else:
            return self._sock.accept(cb)

    def connect(self, addr, cb=None):
        if not self._family == AF_INET or _isnumericipaddr(addr[0]):
            return self._sock.connect(addr, cb)
        else:
            # Store hostname so that it can be given to ssl().
            self._connectname=addr[0] 
            return self._sock.connect((gethostbyname(addr[0]), addr[1]), cb)

    def _getconnectname(self):
        return self._connectname

    def dup(self):
        return _socketobject(self._sock, self._family)

    def makefile(self, mode='r', bufsize=-1):
        return _fileobject(self.dup(), mode, bufsize)

    def read(self, n=1, cb=None):
        return self.recv(n,0,cb)

    def read_all(self, blocksize=1024):
        self._checkerror()
        data = ''
        while 1:
            fragment = self._sock.recv(blocksize)
            if not fragment:
                break
            data += fragment
        return data

    def recv(self, n, f=0, cb=None):
        self._recvsizehint=n
        self._checkerror()
        # if there's data in recvbuf, return data from there.
        if len(self._recvbuf)>0: 
            (data,self._recvbuf)=(self._recvbuf[:n], self._recvbuf[n:])
            return data
        # recvbuf is empty. try to receive some data.
        if self._blocking:
            if self._recv_callback_pending:
                self._recvlock.wait()
                (data,self._recvbuf)=(self._recvbuf[:n], self._recvbuf[n:])
            else:
                data=self._sock.recv(n, f, cb)
            return data
        else:
            if cb is not None:
                raise RuntimeError('Callback not supported in non-blocking mode')
            if not self._recv_callback_pending:
                self._sock.recv(n,f,self._recv_callback)
                self._recv_callback_pending=True
            return ''

    def _checkerror(self):
        if self._error:
            raise self._error[0],self._error[1]
        
    def _seterror(self,errortuple):
        self._error=errortuple

    def _recv_callback(self,data):
        if isinstance(data,tuple):
            print "error %s %s"%data
            self._seterror(data)
            return
        self._recvbuf += data
        self._recv_callback_pending=False
        if self._recv_listener:
            t=self._recv_listener
            self._recv_listener=None
            t()

    def _set_recv_listener(self,callback):
        self._recv_listener=callback

    def _recv_will_return_data_immediately(self):
        if len(self._recvbuf)>0:
            return True
        if not self._recv_callback_pending:
            # Here this function starts a recv as a side effect so
            # that some time in the future we may have data in the
            # buffer. This is done so that the typical select-recv
            # idiom will work properly with this implementation.
            # self._recvsizehint is used as a guess for the receive
            # block size so that the most common case where the read
            # after the select is always the same size will cause the
            # same size blocks to be used while doing the recv
            # here. (Except of course for the very first pass when
            # the default size is used)
            self._recv_callback_pending=True
            self._sock.recv(self._recvsizehint,0,self._recv_callback)
        return False

    def recvfrom(self, n, f=0, cb=None):
        return self._sock.recvfrom(n, f, cb)
                
    def send(self, data, f=0, cb=None):
        self._checkerror()
        if self._blocking:
            return self._sock.send(data, f, cb)
        else:
            if cb is not None:
                raise RuntimeError('Callback not supported in non-blocking mode')
            if self._send_callback_pending:
                self._sendbuf += data
            else:
                self._send_callback_pending=True
                self._sendflags=f
                self._sock.send(data,f,self._send_callback)
            return len(data)

    def _send_callback(self,n):
        if isinstance(n,tuple):
            print "error %s %s"%data
            self._seterror(n)
            return
        if len(self._sendbuf)>0:
            # More data was put in the sendbuf while we were waiting
            # for this callback to be called. Send that too.
            self._sock.send(self._sendbuf,self._sendflags,self._send_callback)
            self._sendbuf=''
        else:
            self._send_callback_pending=False
        
    _s = "def %s(self, *args): return self._sock.%s(*args)\n\n"
    for _m in _socketmethods:
        exec _s % (_m, _m)


class _fileobject(object):

    def __init__(self, sock, mode, bufsize):
        self._sock = sock
        self._mode = mode
        if bufsize < 0:
            bufsize = 512
        self._rbufsize = max(1, bufsize)
        self._wbufsize = bufsize
        self._wbuf = self._rbuf = ""

    def close(self):
        try:
            if self._sock:
                self.flush()
        finally:
            self._sock = 0

    def __del__(self):
        self.close()

    def flush(self):
        if self._wbuf:
            self._sock.sendall(self._wbuf)
            self._wbuf = ""

    def fileno(self):
        return self._sock._sock.fileno()

    def write(self, data):
        self._wbuf = self._wbuf + data
        if self._wbufsize == 1:
            if '\n' in data:
                self.flush()
        else:
            if len(self._wbuf) >= self._wbufsize:
                self.flush()

    def writelines(self, list):
        filter(self._sock.sendall, list)
        self.flush()

    def read(self, n=-1):
        if n >= 0:
            k = len(self._rbuf)
            if n <= k:
                data = self._rbuf[:n]
                self._rbuf = self._rbuf[n:]
                return data
            n = n - k
            L = [self._rbuf]
            self._rbuf = ""
            while n > 0:
                new = self._sock.recv(max(n, self._rbufsize))
                if not new: break
                k = len(new)
                if k > n:
                    L.append(new[:n])
                    self._rbuf = new[n:]
                    break
                L.append(new)
                n = n - k
            return "".join(L)
        k = max(512, self._rbufsize)
        L = [self._rbuf]
        self._rbuf = ""
        while 1:
            new = self._sock.recv(k)
            if not new: break
            L.append(new)
            k = min(k*2, 1024**2)
        return "".join(L)

    def readline(self, limit=-1):
        data = ""
        i = self._rbuf.find('\n')
        while i < 0 and not (0 < limit <= len(self._rbuf)):
            new = self._sock.recv(self._rbufsize)
            if not new: break
            i = new.find('\n')
            if i >= 0: i = i + len(self._rbuf)
            self._rbuf = self._rbuf + new
        if i < 0: i = len(self._rbuf)
        else: i = i+1
        if 0 <= limit < len(self._rbuf): i = limit
        data, self._rbuf = self._rbuf[:i], self._rbuf[i:]
        return data

    def readlines(self, sizehint = 0):
        total = 0
        list = []
        while 1:
            line = self.readline()
            if not line: break
            list.append(line)
            total += len(line)
            if sizehint and total >= sizehint:
                break
        return list