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