/Lib/socket.py

http://unladen-swallow.googlecode.com/ · Python · 514 lines · 435 code · 19 blank · 60 comment · 45 complexity · 54eb32c64ac61512f0e3f92567ab8241 MD5 · raw file

  1. # Wrapper module for _socket, providing some additional facilities
  2. # implemented in Python.
  3. """\
  4. This module provides socket operations and some related functions.
  5. On Unix, it supports IP (Internet Protocol) and Unix domain sockets.
  6. On other systems, it only supports IP. Functions specific for a
  7. socket are available as methods of the socket object.
  8. Functions:
  9. socket() -- create a new socket object
  10. socketpair() -- create a pair of new socket objects [*]
  11. fromfd() -- create a socket object from an open file descriptor [*]
  12. gethostname() -- return the current hostname
  13. gethostbyname() -- map a hostname to its IP number
  14. gethostbyaddr() -- map an IP number or hostname to DNS info
  15. getservbyname() -- map a service name and a protocol name to a port number
  16. getprotobyname() -- map a protocol name (e.g. 'tcp') to a number
  17. ntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order
  18. htons(), htonl() -- convert 16, 32 bit int from host to network byte order
  19. inet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format
  20. inet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)
  21. ssl() -- secure socket layer support (only available if configured)
  22. socket.getdefaulttimeout() -- get the default timeout value
  23. socket.setdefaulttimeout() -- set the default timeout value
  24. create_connection() -- connects to an address, with an optional timeout
  25. [*] not available on all platforms!
  26. Special objects:
  27. SocketType -- type object for socket objects
  28. error -- exception raised for I/O errors
  29. has_ipv6 -- boolean value indicating if IPv6 is supported
  30. Integer constants:
  31. AF_INET, AF_UNIX -- socket domains (first argument to socket() call)
  32. SOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)
  33. Many other constants may be defined; these may be used in calls to
  34. the setsockopt() and getsockopt() methods.
  35. """
  36. import _socket
  37. from _socket import *
  38. try:
  39. import _ssl
  40. except ImportError:
  41. # no SSL support
  42. pass
  43. else:
  44. def ssl(sock, keyfile=None, certfile=None):
  45. # we do an internal import here because the ssl
  46. # module imports the socket module
  47. import ssl as _realssl
  48. warnings.warn("socket.ssl() is deprecated. Use ssl.wrap_socket() instead.",
  49. DeprecationWarning, stacklevel=2)
  50. return _realssl.sslwrap_simple(sock, keyfile, certfile)
  51. # we need to import the same constants we used to...
  52. from _ssl import SSLError as sslerror
  53. from _ssl import \
  54. RAND_add, \
  55. RAND_egd, \
  56. RAND_status, \
  57. SSL_ERROR_ZERO_RETURN, \
  58. SSL_ERROR_WANT_READ, \
  59. SSL_ERROR_WANT_WRITE, \
  60. SSL_ERROR_WANT_X509_LOOKUP, \
  61. SSL_ERROR_SYSCALL, \
  62. SSL_ERROR_SSL, \
  63. SSL_ERROR_WANT_CONNECT, \
  64. SSL_ERROR_EOF, \
  65. SSL_ERROR_INVALID_ERROR_CODE
  66. import os, sys, warnings
  67. try:
  68. from cStringIO import StringIO
  69. except ImportError:
  70. from StringIO import StringIO
  71. try:
  72. from errno import EBADF
  73. except ImportError:
  74. EBADF = 9
  75. __all__ = ["getfqdn", "create_connection"]
  76. __all__.extend(os._get_exports_list(_socket))
  77. _realsocket = socket
  78. # WSA error codes
  79. if sys.platform.lower().startswith("win"):
  80. errorTab = {}
  81. errorTab[10004] = "The operation was interrupted."
  82. errorTab[10009] = "A bad file handle was passed."
  83. errorTab[10013] = "Permission denied."
  84. errorTab[10014] = "A fault occurred on the network??" # WSAEFAULT
  85. errorTab[10022] = "An invalid operation was attempted."
  86. errorTab[10035] = "The socket operation would block"
  87. errorTab[10036] = "A blocking operation is already in progress."
  88. errorTab[10048] = "The network address is in use."
  89. errorTab[10054] = "The connection has been reset."
  90. errorTab[10058] = "The network has been shut down."
  91. errorTab[10060] = "The operation timed out."
  92. errorTab[10061] = "Connection refused."
  93. errorTab[10063] = "The name is too long."
  94. errorTab[10064] = "The host is down."
  95. errorTab[10065] = "The host is unreachable."
  96. __all__.append("errorTab")
  97. def getfqdn(name=''):
  98. """Get fully qualified domain name from name.
  99. An empty argument is interpreted as meaning the local host.
  100. First the hostname returned by gethostbyaddr() is checked, then
  101. possibly existing aliases. In case no FQDN is available, hostname
  102. from gethostname() is returned.
  103. """
  104. name = name.strip()
  105. if not name or name == '0.0.0.0':
  106. name = gethostname()
  107. try:
  108. hostname, aliases, ipaddrs = gethostbyaddr(name)
  109. except error:
  110. pass
  111. else:
  112. aliases.insert(0, hostname)
  113. for name in aliases:
  114. if '.' in name:
  115. break
  116. else:
  117. name = hostname
  118. return name
  119. _socketmethods = (
  120. 'bind', 'connect', 'connect_ex', 'fileno', 'listen',
  121. 'getpeername', 'getsockname', 'getsockopt', 'setsockopt',
  122. 'sendall', 'setblocking',
  123. 'settimeout', 'gettimeout', 'shutdown')
  124. if os.name == "nt":
  125. _socketmethods = _socketmethods + ('ioctl',)
  126. if sys.platform == "riscos":
  127. _socketmethods = _socketmethods + ('sleeptaskw',)
  128. # All the method names that must be delegated to either the real socket
  129. # object or the _closedsocket object.
  130. _delegate_methods = ("recv", "recvfrom", "recv_into", "recvfrom_into",
  131. "send", "sendto")
  132. class _closedsocket(object):
  133. __slots__ = []
  134. def _dummy(*args):
  135. raise error(EBADF, 'Bad file descriptor')
  136. # All _delegate_methods must also be initialized here.
  137. send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
  138. __getattr__ = _dummy
  139. # Wrapper around platform socket objects. This implements
  140. # a platform-independent dup() functionality. The
  141. # implementation currently relies on reference counting
  142. # to close the underlying socket object.
  143. class _socketobject(object):
  144. __doc__ = _realsocket.__doc__
  145. __slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)
  146. def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
  147. if _sock is None:
  148. _sock = _realsocket(family, type, proto)
  149. self._sock = _sock
  150. for method in _delegate_methods:
  151. setattr(self, method, getattr(_sock, method))
  152. def close(self):
  153. self._sock = _closedsocket()
  154. dummy = self._sock._dummy
  155. for method in _delegate_methods:
  156. setattr(self, method, dummy)
  157. close.__doc__ = _realsocket.close.__doc__
  158. def accept(self):
  159. sock, addr = self._sock.accept()
  160. return _socketobject(_sock=sock), addr
  161. accept.__doc__ = _realsocket.accept.__doc__
  162. def dup(self):
  163. """dup() -> socket object
  164. Return a new socket object connected to the same system resource."""
  165. return _socketobject(_sock=self._sock)
  166. def makefile(self, mode='r', bufsize=-1):
  167. """makefile([mode[, bufsize]]) -> file object
  168. Return a regular file object corresponding to the socket. The mode
  169. and bufsize arguments are as for the built-in open() function."""
  170. return _fileobject(self._sock, mode, bufsize)
  171. family = property(lambda self: self._sock.family, doc="the socket family")
  172. type = property(lambda self: self._sock.type, doc="the socket type")
  173. proto = property(lambda self: self._sock.proto, doc="the socket protocol")
  174. _s = ("def %s(self, *args): return self._sock.%s(*args)\n\n"
  175. "%s.__doc__ = _realsocket.%s.__doc__\n")
  176. for _m in _socketmethods:
  177. exec _s % (_m, _m, _m, _m)
  178. del _m, _s
  179. socket = SocketType = _socketobject
  180. class _fileobject(object):
  181. """Faux file object attached to a socket object."""
  182. default_bufsize = 8192
  183. name = "<socket>"
  184. __slots__ = ["mode", "bufsize", "softspace",
  185. # "closed" is a property, see below
  186. "_sock", "_rbufsize", "_wbufsize", "_rbuf", "_wbuf", "_wbuf_len",
  187. "_close"]
  188. def __init__(self, sock, mode='rb', bufsize=-1, close=False):
  189. self._sock = sock
  190. self.mode = mode # Not actually used in this version
  191. if bufsize < 0:
  192. bufsize = self.default_bufsize
  193. self.bufsize = bufsize
  194. self.softspace = False
  195. # _rbufsize is the suggested recv buffer size. It is *strictly*
  196. # obeyed within readline() for recv calls. If it is larger than
  197. # default_bufsize it will be used for recv calls within read().
  198. if bufsize == 0:
  199. self._rbufsize = 1
  200. elif bufsize == 1:
  201. self._rbufsize = self.default_bufsize
  202. else:
  203. self._rbufsize = bufsize
  204. self._wbufsize = bufsize
  205. # We use StringIO for the read buffer to avoid holding a list
  206. # of variously sized string objects which have been known to
  207. # fragment the heap due to how they are malloc()ed and often
  208. # realloc()ed down much smaller than their original allocation.
  209. self._rbuf = StringIO()
  210. self._wbuf = [] # A list of strings
  211. self._wbuf_len = 0
  212. self._close = close
  213. def _getclosed(self):
  214. return self._sock is None
  215. closed = property(_getclosed, doc="True if the file is closed")
  216. def close(self):
  217. try:
  218. if self._sock:
  219. self.flush()
  220. finally:
  221. if self._close:
  222. self._sock.close()
  223. self._sock = None
  224. def __del__(self):
  225. try:
  226. self.close()
  227. except:
  228. # close() may fail if __init__ didn't complete
  229. pass
  230. def flush(self):
  231. if self._wbuf:
  232. buffer = "".join(self._wbuf)
  233. self._wbuf = []
  234. self._wbuf_len = 0
  235. self._sock.sendall(buffer)
  236. def fileno(self):
  237. return self._sock.fileno()
  238. def write(self, data):
  239. data = str(data) # XXX Should really reject non-string non-buffers
  240. if not data:
  241. return
  242. self._wbuf.append(data)
  243. self._wbuf_len += len(data)
  244. if (self._wbufsize == 0 or
  245. self._wbufsize == 1 and '\n' in data or
  246. self._wbuf_len >= self._wbufsize):
  247. self.flush()
  248. def writelines(self, list):
  249. # XXX We could do better here for very long lists
  250. # XXX Should really reject non-string non-buffers
  251. lines = filter(None, map(str, list))
  252. self._wbuf_len += sum(map(len, lines))
  253. self._wbuf.extend(lines)
  254. if (self._wbufsize <= 1 or
  255. self._wbuf_len >= self._wbufsize):
  256. self.flush()
  257. def _get_wbuf_len(self):
  258. return self._wbuf_len
  259. def read(self, size=-1):
  260. # Use max, disallow tiny reads in a loop as they are very inefficient.
  261. # We never leave read() with any leftover data from a new recv() call
  262. # in our internal buffer.
  263. rbufsize = max(self._rbufsize, self.default_bufsize)
  264. # Our use of StringIO rather than lists of string objects returned by
  265. # recv() minimizes memory usage and fragmentation that occurs when
  266. # rbufsize is large compared to the typical return value of recv().
  267. buf = self._rbuf
  268. buf.seek(0, 2) # seek end
  269. if size < 0:
  270. # Read until EOF
  271. self._rbuf = StringIO() # reset _rbuf. we consume it via buf.
  272. while True:
  273. data = self._sock.recv(rbufsize)
  274. if not data:
  275. break
  276. buf.write(data)
  277. return buf.getvalue()
  278. else:
  279. # Read until size bytes or EOF seen, whichever comes first
  280. buf_len = buf.tell()
  281. if buf_len >= size:
  282. # Already have size bytes in our buffer? Extract and return.
  283. buf.seek(0)
  284. rv = buf.read(size)
  285. self._rbuf = StringIO()
  286. self._rbuf.write(buf.read())
  287. return rv
  288. self._rbuf = StringIO() # reset _rbuf. we consume it via buf.
  289. while True:
  290. left = size - buf_len
  291. # recv() will malloc the amount of memory given as its
  292. # parameter even though it often returns much less data
  293. # than that. The returned data string is short lived
  294. # as we copy it into a StringIO and free it. This avoids
  295. # fragmentation issues on many platforms.
  296. data = self._sock.recv(left)
  297. if not data:
  298. break
  299. n = len(data)
  300. if n == size and not buf_len:
  301. # Shortcut. Avoid buffer data copies when:
  302. # - We have no data in our buffer.
  303. # AND
  304. # - Our call to recv returned exactly the
  305. # number of bytes we were asked to read.
  306. return data
  307. if n == left:
  308. buf.write(data)
  309. del data # explicit free
  310. break
  311. assert n <= left, "recv(%d) returned %d bytes" % (left, n)
  312. buf.write(data)
  313. buf_len += n
  314. del data # explicit free
  315. #assert buf_len == buf.tell()
  316. return buf.getvalue()
  317. def readline(self, size=-1):
  318. buf = self._rbuf
  319. buf.seek(0, 2) # seek end
  320. if buf.tell() > 0:
  321. # check if we already have it in our buffer
  322. buf.seek(0)
  323. bline = buf.readline(size)
  324. if bline.endswith('\n') or len(bline) == size:
  325. self._rbuf = StringIO()
  326. self._rbuf.write(buf.read())
  327. return bline
  328. del bline
  329. if size < 0:
  330. # Read until \n or EOF, whichever comes first
  331. if self._rbufsize <= 1:
  332. # Speed up unbuffered case
  333. buf.seek(0)
  334. buffers = [buf.read()]
  335. self._rbuf = StringIO() # reset _rbuf. we consume it via buf.
  336. data = None
  337. recv = self._sock.recv
  338. while data != "\n":
  339. data = recv(1)
  340. if not data:
  341. break
  342. buffers.append(data)
  343. return "".join(buffers)
  344. buf.seek(0, 2) # seek end
  345. self._rbuf = StringIO() # reset _rbuf. we consume it via buf.
  346. while True:
  347. data = self._sock.recv(self._rbufsize)
  348. if not data:
  349. break
  350. nl = data.find('\n')
  351. if nl >= 0:
  352. nl += 1
  353. buf.write(data[:nl])
  354. self._rbuf.write(data[nl:])
  355. del data
  356. break
  357. buf.write(data)
  358. return buf.getvalue()
  359. else:
  360. # Read until size bytes or \n or EOF seen, whichever comes first
  361. buf.seek(0, 2) # seek end
  362. buf_len = buf.tell()
  363. if buf_len >= size:
  364. buf.seek(0)
  365. rv = buf.read(size)
  366. self._rbuf = StringIO()
  367. self._rbuf.write(buf.read())
  368. return rv
  369. self._rbuf = StringIO() # reset _rbuf. we consume it via buf.
  370. while True:
  371. data = self._sock.recv(self._rbufsize)
  372. if not data:
  373. break
  374. left = size - buf_len
  375. # did we just receive a newline?
  376. nl = data.find('\n', 0, left)
  377. if nl >= 0:
  378. nl += 1
  379. # save the excess data to _rbuf
  380. self._rbuf.write(data[nl:])
  381. if buf_len:
  382. buf.write(data[:nl])
  383. break
  384. else:
  385. # Shortcut. Avoid data copy through buf when returning
  386. # a substring of our first recv().
  387. return data[:nl]
  388. n = len(data)
  389. if n == size and not buf_len:
  390. # Shortcut. Avoid data copy through buf when
  391. # returning exactly all of our first recv().
  392. return data
  393. if n >= left:
  394. buf.write(data[:left])
  395. self._rbuf.write(data[left:])
  396. break
  397. buf.write(data)
  398. buf_len += n
  399. #assert buf_len == buf.tell()
  400. return buf.getvalue()
  401. def readlines(self, sizehint=0):
  402. total = 0
  403. list = []
  404. while True:
  405. line = self.readline()
  406. if not line:
  407. break
  408. list.append(line)
  409. total += len(line)
  410. if sizehint and total >= sizehint:
  411. break
  412. return list
  413. # Iterator protocols
  414. def __iter__(self):
  415. return self
  416. def next(self):
  417. line = self.readline()
  418. if not line:
  419. raise StopIteration
  420. return line
  421. _GLOBAL_DEFAULT_TIMEOUT = object()
  422. def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT):
  423. """Connect to *address* and return the socket object.
  424. Convenience function. Connect to *address* (a 2-tuple ``(host,
  425. port)``) and return the socket object. Passing the optional
  426. *timeout* parameter will set the timeout on the socket instance
  427. before attempting to connect. If no *timeout* is supplied, the
  428. global default timeout setting returned by :func:`getdefaulttimeout`
  429. is used.
  430. """
  431. msg = "getaddrinfo returns an empty list"
  432. host, port = address
  433. for res in getaddrinfo(host, port, 0, SOCK_STREAM):
  434. af, socktype, proto, canonname, sa = res
  435. sock = None
  436. try:
  437. sock = socket(af, socktype, proto)
  438. if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
  439. sock.settimeout(timeout)
  440. sock.connect(sa)
  441. return sock
  442. except error, msg:
  443. if sock is not None:
  444. sock.close()
  445. raise error, msg