source: vendor/python/2.5/Lib/socket.py

Last change on this file was 3225, checked in by bird, 19 years ago

Python 2.5
File size: 12.9 KB
Line 
1# Wrapper module for _socket, providing some additional facilities
2# implemented in Python.
3
4"""\
5This module provides socket operations and some related functions.
6On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
7On other systems, it only supports IP. Functions specific for a
8socket are available as methods of the socket object.
9
10Functions:
11
12socket() -- create a new socket object
13socketpair() -- create a pair of new socket objects [*]
14fromfd() -- create a socket object from an open file descriptor [*]
15gethostname() -- return the current hostname
16gethostbyname() -- map a hostname to its IP number
17gethostbyaddr() -- map an IP number or hostname to DNS info
18getservbyname() -- map a service name and a protocol name to a port number
19getprotobyname() -- mape a protocol name (e.g. 'tcp') to a number
20ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
21htons(), htonl() -- convert 16, 32 bit int from host to network byte order
22inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
23inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
24ssl() -- secure socket layer support (only available if configured)
25socket.getdefaulttimeout() -- get the default timeout value
26socket.setdefaulttimeout() -- set the default timeout value
27
28 [*] not available on all platforms!
29
30Special objects:
31
32SocketType -- type object for socket objects
33error -- exception raised for I/O errors
34has_ipv6 -- boolean value indicating if IPv6 is supported
35
36Integer constants:
37
38AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
39SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
40
41Many other constants may be defined; these may be used in calls to
42the setsockopt() and getsockopt() methods.
43"""
44
45import _socket
46from _socket import *
47
48_have_ssl = False
49try:
50 import _ssl
51 from _ssl import *
52 _have_ssl = True
53except ImportError:
54 pass
55
56import os, sys
57
58try:
59 from errno import EBADF
60except ImportError:
61 EBADF = 9
62
63__all__ = ["getfqdn"]
64__all__.extend(os._get_exports_list(_socket))
65if _have_ssl:
66 __all__.extend(os._get_exports_list(_ssl))
67
68_realsocket = socket
69if _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
77if 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
98def 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 from 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_socketmethods = (
125 'bind', 'connect', 'connect_ex', 'fileno', 'listen',
126 'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
127 'sendall', 'setblocking',
128 'settimeout', 'gettimeout', 'shutdown')
129
130if sys.platform == "riscos":
131 _socketmethods = _socketmethods + ('sleeptaskw',)
132
133# All the method names that must be delegated to either the real socket
134# object or the _closedsocket object.
135_delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",
136 "send", "sendto")
137
138class _closedsocket(object):
139 __slots__ = []
140 def _dummy(*args):
141 raise error(EBADF, 'Bad file descriptor')
142 def close(self):
143 pass
144 # All _delegate_methods must also be initialized here.
145 send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
146 __getattr__ = _dummy
147
148class _socketobject(object):
149
150 __doc__ = _realsocket.__doc__
151
152 __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)
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 for method in _delegate_methods:
159 setattr(self, method, getattr(_sock, method))
160
161 def close(self):
162 self._sock.close()
163 self._sock = _closedsocket()
164 dummy = self._sock._dummy
165 for method in _delegate_methods:
166 setattr(self, method, dummy)
167 close.__doc__ = _realsocket.close.__doc__
168
169 def accept(self):
170 sock, addr = self._sock.accept()
171 return _socketobject(_sock=sock), addr
172 accept.__doc__ = _realsocket.accept.__doc__
173
174 def dup(self):
175 """dup() -> socket object
176
177 Return a new socket object connected to the same system resource."""
178 return _socketobject(_sock=self._sock)
179
180 def makefile(self, mode='r', bufsize=-1):
181 """makefile([mode[, bufsize]]) -> file object
182
183 Return a regular file object corresponding to the socket. The mode
184 and bufsize arguments are as for the built-in open() function."""
185 return _fileobject(self._sock, mode, bufsize)
186
187 family = property(lambda self: self._sock.family, doc="the socket family")
188 type = property(lambda self: self._sock.type, doc="the socket type")
189 proto = property(lambda self: self._sock.proto, doc="the socket protocol")
190
191 _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
192 "%s.__doc__ = _realsocket.%s.__doc__\n")
193 for _m in _socketmethods:
194 exec _s % (_m, _m, _m, _m)
195 del _m, _s
196
197socket = SocketType = _socketobject
198
199class _fileobject(object):
200 """Faux file object attached to a socket object."""
201
202 default_bufsize = 8192
203 name = "<socket>"
204
205 __slots__ = ["mode", "bufsize", "softspace",
206 # "closed" is a property, see below
207 "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf"]
208
209 def __init__(self, sock, mode='rb', bufsize=-1):
210 self._sock = sock
211 self.mode = mode # Not actually used in this version
212 if bufsize < 0:
213 bufsize = self.default_bufsize
214 self.bufsize = bufsize
215 self.softspace = False
216 if bufsize == 0:
217 self._rbufsize = 1
218 elif bufsize == 1:
219 self._rbufsize = self.default_bufsize
220 else:
221 self._rbufsize = bufsize
222 self._wbufsize = bufsize
223 self._rbuf = "" # A string
224 self._wbuf = [] # A list of strings
225
226 def _getclosed(self):
227 return self._sock is None
228 closed = property(_getclosed, doc="True if the file is closed")
229
230 def close(self):
231 try:
232 if self._sock:
233 self.flush()
234 finally:
235 self._sock = None
236
237 def __del__(self):
238 try:
239 self.close()
240 except:
241 # close() may fail if __init__ didn't complete
242 pass
243
244 def flush(self):
245 if self._wbuf:
246 buffer = "".join(self._wbuf)
247 self._wbuf = []
248 self._sock.sendall(buffer)
249
250 def fileno(self):
251 return self._sock.fileno()
252
253 def write(self, data):
254 data = str(data) # XXX Should really reject non-string non-buffers
255 if not data:
256 return
257 self._wbuf.append(data)
258 if (self._wbufsize == 0 or
259 self._wbufsize == 1 and '\n' in data or
260 self._get_wbuf_len() >= self._wbufsize):
261 self.flush()
262
263 def writelines(self, list):
264 # XXX We could do better here for very long lists
265 # XXX Should really reject non-string non-buffers
266 self._wbuf.extend(filter(None, map(str, list)))
267 if (self._wbufsize <= 1 or
268 self._get_wbuf_len() >= self._wbufsize):
269 self.flush()
270
271 def _get_wbuf_len(self):
272 buf_len = 0
273 for x in self._wbuf:
274 buf_len += len(x)
275 return buf_len
276
277 def read(self, size=-1):
278 data = self._rbuf
279 if size < 0:
280 # Read until EOF
281 buffers = []
282 if data:
283 buffers.append(data)
284 self._rbuf = ""
285 if self._rbufsize <= 1:
286 recv_size = self.default_bufsize
287 else:
288 recv_size = self._rbufsize
289 while True:
290 data = self._sock.recv(recv_size)
291 if not data:
292 break
293 buffers.append(data)
294 return "".join(buffers)
295 else:
296 # Read until size bytes or EOF seen, whichever comes first
297 buf_len = len(data)
298 if buf_len >= size:
299 self._rbuf = data[size:]
300 return data[:size]
301 buffers = []
302 if data:
303 buffers.append(data)
304 self._rbuf = ""
305 while True:
306 left = size - buf_len
307 recv_size = max(self._rbufsize, left)
308 data = self._sock.recv(recv_size)
309 if not data:
310 break
311 buffers.append(data)
312 n = len(data)
313 if n >= left:
314 self._rbuf = data[left:]
315 buffers[-1] = data[:left]
316 break
317 buf_len += n
318 return "".join(buffers)
319
320 def readline(self, size=-1):
321 data = self._rbuf
322 if size < 0:
323 # Read until \n or EOF, whichever comes first
324 if self._rbufsize <= 1:
325 # Speed up unbuffered case
326 assert data == ""
327 buffers = []
328 recv = self._sock.recv
329 while data != "\n":
330 data = recv(1)
331 if not data:
332 break
333 buffers.append(data)
334 return "".join(buffers)
335 nl = data.find('\n')
336 if nl >= 0:
337 nl += 1
338 self._rbuf = data[nl:]
339 return data[:nl]
340 buffers = []
341 if data:
342 buffers.append(data)
343 self._rbuf = ""
344 while True:
345 data = self._sock.recv(self._rbufsize)
346 if not data:
347 break
348 buffers.append(data)
349 nl = data.find('\n')
350 if nl >= 0:
351 nl += 1
352 self._rbuf = data[nl:]
353 buffers[-1] = data[:nl]
354 break
355 return "".join(buffers)
356 else:
357 # Read until size bytes or \n or EOF seen, whichever comes first
358 nl = data.find('\n', 0, size)
359 if nl >= 0:
360 nl += 1
361 self._rbuf = data[nl:]
362 return data[:nl]
363 buf_len = len(data)
364 if buf_len >= size:
365 self._rbuf = data[size:]
366 return data[:size]
367 buffers = []
368 if data:
369 buffers.append(data)
370 self._rbuf = ""
371 while True:
372 data = self._sock.recv(self._rbufsize)
373 if not data:
374 break
375 buffers.append(data)
376 left = size - buf_len
377 nl = data.find('\n', 0, left)
378 if nl >= 0:
379 nl += 1
380 self._rbuf = data[nl:]
381 buffers[-1] = data[:nl]
382 break
383 n = len(data)
384 if n >= left:
385 self._rbuf = data[left:]
386 buffers[-1] = data[:left]
387 break
388 buf_len += n
389 return "".join(buffers)
390
391 def readlines(self, sizehint=0):
392 total = 0
393 list = []
394 while True:
395 line = self.readline()
396 if not line:
397 break
398 list.append(line)
399 total += len(line)
400 if sizehint and total >= sizehint:
401 break
402 return list
403
404 # Iterator protocols
405
406 def __iter__(self):
407 return self
408
409 def next(self):
410 line = self.readline()
411 if not line:
412 raise StopIteration
413 return line
Note: See TracBrowser for help on using the repository browser.