com!online 2005 April/com_0405_1.iso/opensource/BTpp-0.5.4-bin.exe/$INSTDIR/BT++.exe/socket.pyo

Python Compiled Bytecode | 2003-04-19 | 7.9 KB | 252 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.2)

from _socket import *
import os
import sys
__all__ = [
    'getfqdn']
import _socket
__all__.extend(os._get_exports_list(_socket))
if not sys.platform.lower().startswith('win'):
    if hasattr(os, 'uname') and os.uname()[0] == 'BeOS' or sys.platform == 'riscos':
        _realsocketcall = _socket.socket

        def socket(family, type, proto = 0):
            return _socketobject(_realsocketcall(family, type, proto))


        try:
            _realsslcall = _socket.ssl
        except AttributeError:
            pass


        def ssl(sock, keyfile = None, certfile = None):
            if hasattr(sock, '_sock'):
                sock = sock._sock

            return _realsslcall(sock, keyfile, certfile)


if sys.platform.lower().startswith('win'):
    errorTab = { }
    errorTab[10004] = 'The operation was interrupted.'
    errorTab[10009] = 'A bad file handle was passed.'
    errorTab[10013] = 'Permission denied.'
    errorTab[10014] = 'A fault occurred on the network??'
    errorTab[10022] = 'An invalid operation was attempted.'
    errorTab[10035] = 'The socket operation would block'
    errorTab[10036] = 'A blocking operation is already in progress.'
    errorTab[10048] = 'The network address is in use.'
    errorTab[10054] = 'The connection has been reset.'
    errorTab[10058] = 'The network has been shut down.'
    errorTab[10060] = 'The operation timed out.'
    errorTab[10061] = 'Connection refused.'
    errorTab[10063] = 'The name is too long.'
    errorTab[10064] = 'The host is down.'
    errorTab[10065] = 'The host is unreachable.'
    __all__.append('errorTab')

del os
del sys

def getfqdn(name = ''):
    name = name.strip()
    if not name or name == '0.0.0.0':
        name = gethostname()


    try:
        (hostname, aliases, ipaddrs) = gethostbyaddr(name)
    except error:
        pass

    aliases.insert(0, hostname)
    for name in aliases:
        if '.' in name:
            break

    else:
        name = hostname
    return name

_socketmethods = ('bind', 'connect', 'connect_ex', 'fileno', 'listen', 'getpeername', 'getsockname', 'getsockopt', 'setsockopt', 'recv', 'recvfrom', 'send', 'sendall', 'sendto', 'setblocking', 'shutdown')

class _socketobject:

    class _closedsocket:

        def __getattr__(self, name):
            raise error(9, 'Bad file descriptor')



    def __init__(self, sock):
        self._sock = sock


    def close(self):
        self._sock = self.__class__._closedsocket()


    def __del__(self):
        self.close()


    def accept(self):
        (sock, addr) = self._sock.accept()
        return (_socketobject(sock), addr)


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


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

    _s = 'def %s(self, *args): return self._sock.%s(*args)\n\n'
    for _m in _socketmethods:
        exec _s % (_m, _m)



class _fileobject:

    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.fileno()


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

        elif 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 None if limit < limit else 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 limit <= limit:
            pass
        elif 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