[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / lib / python2.4 / socket.py

# Wrapper module for _socket, providing some additional facilities
# implemented in Python.

"""\
This module provides socket operations and some related functions.
On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
On other systems, it only supports IP. Functions specific for a
socket are available as methods of the socket object.

Functions:

socket() -- create a new socket object
socketpair() -- create a pair of new socket objects [*]
fromfd() -- create a socket object from an open file descriptor [*]
gethostname() -- return the current hostname
gethostbyname() -- map a hostname to its IP number
gethostbyaddr() -- map an IP number or hostname to DNS info
getservbyname() -- map a service name and a protocol name to a port number
getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
htons(), htonl() -- convert 16, 32 bit int from host to network byte order
inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
ssl() -- secure socket layer support (only available if configured)
socket.getdefaulttimeout() -- get the default timeout value
socket.setdefaulttimeout() -- set the default timeout value

 [*] not available on all platforms!

Special objects:

SocketType -- type object for socket objects
error -- exception raised for I/O errors
has_ipv6 -- boolean value indicating if IPv6 is supported

Integer constants:

AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)

Many other constants may be defined; these may be used in calls to
the setsockopt() and getsockopt() methods.
"""

import _socket
from _socket import *

_have_ssl = False
try:
    import _ssl
    from _ssl import *
    _have_ssl = True
except ImportError:
    pass

import os, sys

try:
    from errno import EBADF
except ImportError:
    EBADF = 9

__all__ = ["getfqdn"]
__all__.extend(os._get_exports_list(_socket))
if _have_ssl:
    __all__.extend(os._get_exports_list(_ssl))

_realsocket = socket
if _have_ssl:
    _realssl = ssl
    def ssl(sock, keyfile=None, certfile=None):
        if hasattr(sock, "_sock"):
            sock = sock._sock
        return _realssl(sock, keyfile, certfile)

# WSA error codes
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??" # WSAEFAULT
    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")


def getfqdn(name=''):
    """Get fully qualified domain name from name.

    An empty argument is interpreted as meaning the local host.

    First the hostname returned by gethostbyaddr() is checked, then
    possibly existing aliases. In case no FQDN is available, hostname
    as returned by gethostname() is returned.
    """
    name = name.strip()
    if not name or name == '0.0.0.0':
        name = gethostname()
    try:
        hostname, aliases, ipaddrs = gethostbyaddr(name)
    except error:
        pass
    else:
        aliases.insert(0, hostname)
        for name in aliases:
            if '.' in name:
                break
        else:
            name = hostname
    return name


#
# These classes are used by the socket() defined on Windows and BeOS
# platforms to provide a best-effort implementation of the cleanup
# semantics needed when sockets can't be dup()ed.
#
# These are not actually used on other platforms.
#

_socketmethods = (
    'bind', 'connect', 'connect_ex', 'fileno', 'listen',
    'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
    'sendall', 'setblocking',
    'settimeout', 'gettimeout', 'shutdown')

if sys.platform == "riscos":
    _socketmethods = _socketmethods + ('sleeptaskw',)

class _closedsocket(object):
    __slots__ = []
    def _dummy(*args):
        raise error(EBADF, 'Bad file descriptor')
    send = recv = sendto = recvfrom = __getattr__ = _dummy

class _socketobject(object):

    __doc__ = _realsocket.__doc__

    __slots__ = ["_sock", "send", "recv", "sendto", "recvfrom",
                 "__weakref__"]

    def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
        if _sock is None:
            _sock = _realsocket(family, type, proto)
        self._sock = _sock
        self.send = self._sock.send
        self.recv = self._sock.recv
        self.sendto = self._sock.sendto
        self.recvfrom = self._sock.recvfrom

    def close(self):
        self._sock = _closedsocket()
        self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
    close.__doc__ = _realsocket.close.__doc__

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

    def dup(self):
        """dup() -> socket object

        Return a new socket object connected to the same system resource."""
        return _socketobject(_sock=self._sock)

    def makefile(self, mode='r', bufsize=-1):
        """makefile([mode[, bufsize]]) -> file object

        Return a regular file object corresponding to the socket.  The mode
        and bufsize arguments are as for the built-in open() function."""
        return _fileobject(self._sock, mode, bufsize)

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

socket = SocketType = _socketobject

class _fileobject(object):
    """Faux file object attached to a socket object."""

    default_bufsize = 8192
    name = "<socket>"

    __slots__ = ["mode", "bufsize", "softspace",
                 # "closed" is a property, see below
                 "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]

    def __init__(self, sock, mode='rb', bufsize=-1):
        self._sock = sock
        self.mode = mode # Not actually used in this version
        if bufsize < 0:
            bufsize = self.default_bufsize
        self.bufsize = bufsize
        self.softspace = False
        if bufsize == 0:
            self._rbufsize = 1
        elif bufsize == 1:
            self._rbufsize = self.default_bufsize
        else:
            self._rbufsize = bufsize
        self._wbufsize = bufsize
        self._rbuf = "" # A string
        self._wbuf = [] # A list of strings

    def _getclosed(self):
        return self._sock is None
    closed = property(_getclosed, doc="True if the file is closed")

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

    def __del__(self):
        try:
            self.close()
        except:
            # close() may fail if __init__ didn't complete
            pass

    def flush(self):
        if self._wbuf:
            buffer = "".join(self._wbuf)
            self._wbuf = []
            self._sock.sendall(buffer)

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

    def write(self, data):
        data = str(data) # XXX Should really reject non-string non-buffers
        if not data:
            return
        self._wbuf.append(data)
        if (self._wbufsize == 0 or
            self._wbufsize == 1 and '\n' in data or
            self._get_wbuf_len() >= self._wbufsize):
            self.flush()

    def writelines(self, list):
        # XXX We could do better here for very long lists
        # XXX Should really reject non-string non-buffers
        self._wbuf.extend(filter(None, map(str, list)))
        if (self._wbufsize <= 1 or
            self._get_wbuf_len() >= self._wbufsize):
            self.flush()

    def _get_wbuf_len(self):
        buf_len = 0
        for x in self._wbuf:
            buf_len += len(x)
        return buf_len

    def read(self, size=-1):
        data = self._rbuf
        if size < 0:
            # Read until EOF
            buffers = []
            if data:
                buffers.append(data)
            self._rbuf = ""
            if self._rbufsize <= 1:
                recv_size = self.default_bufsize
            else:
                recv_size = self._rbufsize
            while True:
                data = self._sock.recv(recv_size)
                if not data:
                    break
                buffers.append(data)
            return "".join(buffers)
        else:
            # Read until size bytes or EOF seen, whichever comes first
            buf_len = len(data)
            if buf_len >= size:
                self._rbuf = data[size:]
                return data[:size]
            buffers = []
            if data:
                buffers.append(data)
            self._rbuf = ""
            while True:
                left = size - buf_len
                recv_size = max(self._rbufsize, left)
                data = self._sock.recv(recv_size)
                if not data:
                    break
                buffers.append(data)
                n = len(data)
                if n >= left:
                    self._rbuf = data[left:]
                    buffers[-1] = data[:left]
                    break
                buf_len += n
            return "".join(buffers)

    def readline(self, size=-1):
        data = self._rbuf
        if size < 0:
            # Read until \n or EOF, whichever comes first
            if self._rbufsize <= 1:
                # Speed up unbuffered case
                assert data == ""
                buffers = []
                recv = self._sock.recv
                while data != "\n":
                    data = recv(1)
                    if not data:
                        break
                    buffers.append(data)
                return "".join(buffers)
            nl = data.find('\n')
            if nl >= 0:
                nl += 1
                self._rbuf = data[nl:]
                return data[:nl]
            buffers = []
            if data:
                buffers.append(data)
            self._rbuf = ""
            while True:
                data = self._sock.recv(self._rbufsize)
                if not data:
                    break
                buffers.append(data)
                nl = data.find('\n')
                if nl >= 0:
                    nl += 1
                    self._rbuf = data[nl:]
                    buffers[-1] = data[:nl]
                    break
            return "".join(buffers)
        else:
            # Read until size bytes or \n or EOF seen, whichever comes first
            nl = data.find('\n', 0, size)
            if nl >= 0:
                nl += 1
                self._rbuf = data[nl:]
                return data[:nl]
            buf_len = len(data)
            if buf_len >= size:
                self._rbuf = data[size:]
                return data[:size]
            buffers = []
            if data:
                buffers.append(data)
            self._rbuf = ""
            while True:
                data = self._sock.recv(self._rbufsize)
                if not data:
                    break
                buffers.append(data)
                left = size - buf_len
                nl = data.find('\n', 0, left)
                if nl >= 0:
                    nl += 1
                    self._rbuf = data[nl:]
                    buffers[-1] = data[:nl]
                    break
                n = len(data)
                if n >= left:
                    self._rbuf = data[left:]
                    buffers[-1] = data[:left]
                    break
                buf_len += n
            return "".join(buffers)

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

    # Iterator protocols

    def __iter__(self):
        return self

    def next(self):
        line = self.readline()
        if not line:
            raise StopIteration
        return line
Commit	Line	Data
920dae64 AT	1	# Wrapper module for _socket, providing some additional facilities
	2	# implemented in Python.
	3
	4	"""\
	5	This module provides socket operations and some related functions.
	6	On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
	7	On other systems, it only supports IP. Functions specific for a
	8	socket are available as methods of the socket object.
	9
	10	Functions:
	11
	12	socket() -- create a new socket object
	13	socketpair() -- create a pair of new socket objects [*]
	14	fromfd() -- create a socket object from an open file descriptor [*]
	15	gethostname() -- return the current hostname
	16	gethostbyname() -- map a hostname to its IP number
	17	gethostbyaddr() -- map an IP number or hostname to DNS info
	18	getservbyname() -- map a service name and a protocol name to a port number
	19	getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
	20	ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
	21	htons(), htonl() -- convert 16, 32 bit int from host to network byte order
	22	inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
	23	inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
	24	ssl() -- secure socket layer support (only available if configured)
	25	socket.getdefaulttimeout() -- get the default timeout value
	26	socket.setdefaulttimeout() -- set the default timeout value
	27
	28	[*] not available on all platforms!
	29
	30	Special objects:
	31
	32	SocketType -- type object for socket objects
	33	error -- exception raised for I/O errors
	34	has_ipv6 -- boolean value indicating if IPv6 is supported
	35
	36	Integer constants:
	37
	38	AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
	39	SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
	40
	41	Many other constants may be defined; these may be used in calls to
	42	the setsockopt() and getsockopt() methods.
	43	"""
	44
	45	import _socket
	46	from _socket import *
	47
	48	_have_ssl = False
	49	try:
	50	import _ssl
	51	from _ssl import *
	52	_have_ssl = True
	53	except ImportError:
	54	pass
	55
	56	import os, sys
	57
	58	try:
	59	from errno import EBADF
	60	except ImportError:
	61	EBADF = 9
	62
	63	__all__ = ["getfqdn"]
	64	__all__.extend(os._get_exports_list(_socket))
65	if _have_ssl:
66	__all__.extend(os._get_exports_list(_ssl))
67
68	_realsocket = socket
69	if _have_ssl:
70	_realssl = ssl
71	def ssl(sock, keyfile=None, certfile=None):
72	if hasattr(sock, "_sock"):
73	sock = sock._sock
74	return _realssl(sock, keyfile, certfile)
75
76	# WSA error codes
77	if sys.platform.lower().startswith("win"):
78	errorTab = {}
79	errorTab[10004] = "The operation was interrupted."
80	errorTab[10009] = "A bad file handle was passed."
81	errorTab[10013] = "Permission denied."
82	errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
83	errorTab[10022] = "An invalid operation was attempted."
84	errorTab[10035] = "The socket operation would block"
85	errorTab[10036] = "A blocking operation is already in progress."
86	errorTab[10048] = "The network address is in use."
87	errorTab[10054] = "The connection has been reset."
88	errorTab[10058] = "The network has been shut down."
89	errorTab[10060] = "The operation timed out."
90	errorTab[10061] = "Connection refused."
91	errorTab[10063] = "The name is too long."
92	errorTab[10064] = "The host is down."
93	errorTab[10065] = "The host is unreachable."
94	__all__.append("errorTab")
95
96
97
98	def getfqdn(name=''):
99	"""Get fully qualified domain name from name.
100
101	An empty argument is interpreted as meaning the local host.
102
103	First the hostname returned by gethostbyaddr() is checked, then
104	possibly existing aliases. In case no FQDN is available, hostname
105	as returned by gethostname() is returned.
106	"""
107	name = name.strip()
108	if not name or name == '0.0.0.0':
109	name = gethostname()
110	try:
111	hostname, aliases, ipaddrs = gethostbyaddr(name)
112	except error:
113	pass
114	else:
115	aliases.insert(0, hostname)
116	for name in aliases:
117	if '.' in name:
118	break
119	else:
120	name = hostname
121	return name
122
123
124	#
125	# These classes are used by the socket() defined on Windows and BeOS
126	# platforms to provide a best-effort implementation of the cleanup
127	# semantics needed when sockets can't be dup()ed.
128	#
129	# These are not actually used on other platforms.
130	#
131
132	_socketmethods = (
133	'bind', 'connect', 'connect_ex', 'fileno', 'listen',
134	'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
135	'sendall', 'setblocking',
136	'settimeout', 'gettimeout', 'shutdown')
137
138	if sys.platform == "riscos":
139	_socketmethods = _socketmethods + ('sleeptaskw',)
140
141	class _closedsocket(object):
142	__slots__ = []
143	def _dummy(*args):
144	raise error(EBADF, 'Bad file descriptor')
145	send = recv = sendto = recvfrom = __getattr__ = _dummy
146
147	class _socketobject(object):
148
149	__doc__ = _realsocket.__doc__
150
151	__slots__ = ["_sock", "send", "recv", "sendto", "recvfrom",
152	"__weakref__"]
153
154	def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
155	if _sock is None:
156	_sock = _realsocket(family, type, proto)
157	self._sock = _sock
158	self.send = self._sock.send
159	self.recv = self._sock.recv
160	self.sendto = self._sock.sendto
161	self.recvfrom = self._sock.recvfrom
162
163	def close(self):
164	self._sock = _closedsocket()
165	self.send = self.recv = self.sendto = self.recvfrom = self._sock._dummy
166	close.__doc__ = _realsocket.close.__doc__
167
168	def accept(self):
169	sock, addr = self._sock.accept()
170	return _socketobject(_sock=sock), addr
171	accept.__doc__ = _realsocket.accept.__doc__
172
173	def dup(self):
174	"""dup() -> socket object
175
176	Return a new socket object connected to the same system resource."""
177	return _socketobject(_sock=self._sock)
178
179	def makefile(self, mode='r', bufsize=-1):
180	"""makefile([mode[, bufsize]]) -> file object
181
182	Return a regular file object corresponding to the socket. The mode
183	and bufsize arguments are as for the built-in open() function."""
184	return _fileobject(self._sock, mode, bufsize)
185
186	_s = ("def %s(self, args): return self._sock.%s(args)\n\n"
187	"%s.__doc__ = _realsocket.%s.__doc__\n")
188	for _m in _socketmethods:
189	exec _s % (_m, _m, _m, _m)
190	del _m, _s
191
192	socket = SocketType = _socketobject
193
194	class _fileobject(object):
195	"""Faux file object attached to a socket object."""
196
197	default_bufsize = 8192
198	name = "<socket>"
199
200	__slots__ = ["mode", "bufsize", "softspace",
201	# "closed" is a property, see below
202	"_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]
203
204	def __init__(self, sock, mode='rb', bufsize=-1):
205	self._sock = sock
206	self.mode = mode # Not actually used in this version
207	if bufsize < 0:
208	bufsize = self.default_bufsize
209	self.bufsize = bufsize
210	self.softspace = False
211	if bufsize == 0:
212	self._rbufsize = 1
213	elif bufsize == 1:
214	self._rbufsize = self.default_bufsize
215	else:
216	self._rbufsize = bufsize
217	self._wbufsize = bufsize
218	self._rbuf = "" # A string
219	self._wbuf = [] # A list of strings
220
221	def _getclosed(self):
222	return self._sock is None
223	closed = property(_getclosed, doc="True if the file is closed")
224
225	def close(self):
226	try:
227	if self._sock:
228	self.flush()
229	finally:
230	self._sock = None
231
232	def __del__(self):
233	try:
234	self.close()
235	except:
236	# close() may fail if __init__ didn't complete
237	pass
238
239	def flush(self):
240	if self._wbuf:
241	buffer = "".join(self._wbuf)
242	self._wbuf = []
243	self._sock.sendall(buffer)
244
245	def fileno(self):
246	return self._sock.fileno()
247
248	def write(self, data):
249	data = str(data) # XXX Should really reject non-string non-buffers
250	if not data:
251	return
252	self._wbuf.append(data)
253	if (self._wbufsize == 0 or
254	self._wbufsize == 1 and '\n' in data or
255	self._get_wbuf_len() >= self._wbufsize):
256	self.flush()
257
258	def writelines(self, list):
259	# XXX We could do better here for very long lists
260	# XXX Should really reject non-string non-buffers
261	self._wbuf.extend(filter(None, map(str, list)))
262	if (self._wbufsize <= 1 or
263	self._get_wbuf_len() >= self._wbufsize):
264	self.flush()
265
266	def _get_wbuf_len(self):
267	buf_len = 0
268	for x in self._wbuf:
269	buf_len += len(x)
270	return buf_len
271
272	def read(self, size=-1):
273	data = self._rbuf
274	if size < 0:
275	# Read until EOF
276	buffers = []
277	if data:
278	buffers.append(data)
279	self._rbuf = ""
280	if self._rbufsize <= 1:
281	recv_size = self.default_bufsize
282	else:
283	recv_size = self._rbufsize
284	while True:
285	data = self._sock.recv(recv_size)
286	if not data:
287	break
288	buffers.append(data)
289	return "".join(buffers)
290	else:
291	# Read until size bytes or EOF seen, whichever comes first
292	buf_len = len(data)
293	if buf_len >= size:
294	self._rbuf = data[size:]
295	return data[:size]
296	buffers = []
297	if data:
298	buffers.append(data)
299	self._rbuf = ""
300	while True:
301	left = size - buf_len
302	recv_size = max(self._rbufsize, left)
303	data = self._sock.recv(recv_size)
304	if not data:
305	break
306	buffers.append(data)
307	n = len(data)
308	if n >= left:
309	self._rbuf = data[left:]
310	buffers[-1] = data[:left]
311	break
312	buf_len += n
313	return "".join(buffers)
314
315	def readline(self, size=-1):
316	data = self._rbuf
317	if size < 0:
318	# Read until \n or EOF, whichever comes first
319	if self._rbufsize <= 1:
320	# Speed up unbuffered case
321	assert data == ""
322	buffers = []
323	recv = self._sock.recv
324	while data != "\n":
325	data = recv(1)
326	if not data:
327	break
328	buffers.append(data)
329	return "".join(buffers)
330	nl = data.find('\n')
331	if nl >= 0:
332	nl += 1
333	self._rbuf = data[nl:]
334	return data[:nl]
335	buffers = []
336	if data:
337	buffers.append(data)
338	self._rbuf = ""
339	while True:
340	data = self._sock.recv(self._rbufsize)
341	if not data:
342	break
343	buffers.append(data)
344	nl = data.find('\n')
345	if nl >= 0:
346	nl += 1
347	self._rbuf = data[nl:]
348	buffers[-1] = data[:nl]
349	break
350	return "".join(buffers)
351	else:
352	# Read until size bytes or \n or EOF seen, whichever comes first
353	nl = data.find('\n', 0, size)
354	if nl >= 0:
355	nl += 1
356	self._rbuf = data[nl:]
357	return data[:nl]
358	buf_len = len(data)
359	if buf_len >= size:
360	self._rbuf = data[size:]
361	return data[:size]
362	buffers = []
363	if data:
364	buffers.append(data)
365	self._rbuf = ""
366	while True:
367	data = self._sock.recv(self._rbufsize)
368	if not data:
369	break
370	buffers.append(data)
371	left = size - buf_len
372	nl = data.find('\n', 0, left)
373	if nl >= 0:
374	nl += 1
375	self._rbuf = data[nl:]
376	buffers[-1] = data[:nl]
377	break
378	n = len(data)
379	if n >= left:
380	self._rbuf = data[left:]
381	buffers[-1] = data[:left]
382	break
383	buf_len += n
384	return "".join(buffers)
385
386	def readlines(self, sizehint=0):
387	total = 0
388	list = []
389	while True:
390	line = self.readline()
391	if not line:
392	break
393	list.append(line)
394	total += len(line)
395	if sizehint and total >= sizehint:
396	break
397	return list
398
399	# Iterator protocols
400
401	def __iter__(self):
402	return self
403
404	def next(self):
405	line = self.readline()
406	if not line:
407	raise StopIteration
408	return line