/MOULOpenSourceClientPlugin/Plasma20/SDKs/XPlatform/Cypython-2.3.3/Modules/socketmodule.c
C | 4151 lines | 3336 code | 486 blank | 329 comment | 445 complexity | 2f0c83c48857c1e4f744b8ba347759d8 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
1/* Socket module */ 2 3/* 4 5This module provides an interface to Berkeley socket IPC. 6 7Limitations: 8 9- Only AF_INET, AF_INET6 and AF_UNIX address families are supported in a 10 portable manner, though AF_PACKET is supported under Linux. 11- No read/write operations (use sendall/recv or makefile instead). 12- Additional restrictions apply on some non-Unix platforms (compensated 13 for by socket.py). 14 15Module interface: 16 17- socket.error: exception raised for socket specific errors 18- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors, 19 a subclass of socket.error 20- socket.herror: exception raised for gethostby* errors, 21 a subclass of socket.error 22- socket.fromfd(fd, family, type[, proto]) --> new socket object (created 23 from an existing file descriptor) 24- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd') 25- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...]) 26- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com') 27- socket.getprotobyname(protocolname) --> protocol number 28- socket.getservbyname(servicename, protocolname) --> port number 29- socket.socket([family[, type [, proto]]]) --> new socket object 30- socket.ntohs(16 bit value) --> new int object 31- socket.ntohl(32 bit value) --> new int object 32- socket.htons(16 bit value) --> new int object 33- socket.htonl(32 bit value) --> new int object 34- socket.getaddrinfo(host, port [, family, socktype, proto, flags]) 35 --> List of (family, socktype, proto, canonname, sockaddr) 36- socket.getnameinfo(sockaddr, flags) --> (host, port) 37- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h> 38- socket.has_ipv6: boolean value indicating if IPv6 is supported 39- socket.inet_aton(IP address) -> 32-bit packed IP representation 40- socket.inet_ntoa(packed IP) -> IP address string 41- socket.getdefaulttimeout() -> None | float 42- socket.setdefaulttimeout(None | float) 43- an Internet socket address is a pair (hostname, port) 44 where hostname can be anything recognized by gethostbyname() 45 (including the dd.dd.dd.dd notation) and port is in host byte order 46- where a hostname is returned, the dd.dd.dd.dd notation is used 47- a UNIX domain socket address is a string specifying the pathname 48- an AF_PACKET socket address is a tuple containing a string 49 specifying the ethernet interface and an integer specifying 50 the Ethernet protocol number to be received. For example: 51 ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple 52 specify packet-type and ha-type/addr -- these are ignored by 53 networking code, but accepted since they are returned by the 54 getsockname() method. 55 56Local naming conventions: 57 58- names starting with sock_ are socket object methods 59- names starting with socket_ are module-level functions 60- names starting with PySocket are exported through socketmodule.h 61 62*/ 63 64#include "Python.h" 65 66#undef MAX 67#define MAX(x, y) ((x) < (y) ? (y) : (x)) 68 69/* Socket object documentation */ 70PyDoc_STRVAR(sock_doc, 71"socket([family[, type[, proto]]]) -> socket object\n\ 72\n\ 73Open a socket of the given type. The family argument specifies the\n\ 74address family; it defaults to AF_INET. The type argument specifies\n\ 75whether this is a stream (SOCK_STREAM, this is the default)\n\ 76or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\ 77specifying the default protocol. Keyword arguments are accepted.\n\ 78\n\ 79A socket object represents one endpoint of a network connection.\n\ 80\n\ 81Methods of socket objects (keyword arguments not allowed):\n\ 82\n\ 83accept() -- accept a connection, returning new socket and client address\n\ 84bind(addr) -- bind the socket to a local address\n\ 85close() -- close the socket\n\ 86connect(addr) -- connect the socket to a remote address\n\ 87connect_ex(addr) -- connect, return an error code instead of an exception\n\ 88dup() -- return a new socket object identical to the current one [*]\n\ 89fileno() -- return underlying file descriptor\n\ 90getpeername() -- return remote address [*]\n\ 91getsockname() -- return local address\n\ 92getsockopt(level, optname[, buflen]) -- get socket options\n\ 93gettimeout() -- return timeout or None\n\ 94listen(n) -- start listening for incoming connections\n\ 95makefile([mode, [bufsize]]) -- return a file object for the socket [*]\n\ 96recv(buflen[, flags]) -- receive data\n\ 97recvfrom(buflen[, flags]) -- receive data and sender's address\n\ 98sendall(data[, flags]) -- send all data\n\ 99send(data[, flags]) -- send data, may not send all of it\n\ 100sendto(data[, flags], addr) -- send data to a given address\n\ 101setblocking(0 | 1) -- set or clear the blocking I/O flag\n\ 102setsockopt(level, optname, value) -- set socket options\n\ 103settimeout(None | float) -- set or clear the timeout\n\ 104shutdown(how) -- shut down traffic in one or both directions\n\ 105\n\ 106 [*] not available on all platforms!"); 107 108/* XXX This is a terrible mess of platform-dependent preprocessor hacks. 109 I hope some day someone can clean this up please... */ 110 111/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure 112 script doesn't get this right, so we hardcode some platform checks below. 113 On the other hand, not all Linux versions agree, so there the settings 114 computed by the configure script are needed! */ 115 116#ifndef linux 117# undef HAVE_GETHOSTBYNAME_R_3_ARG 118# undef HAVE_GETHOSTBYNAME_R_5_ARG 119# undef HAVE_GETHOSTBYNAME_R_6_ARG 120#endif 121 122#ifndef WITH_THREAD 123# undef HAVE_GETHOSTBYNAME_R 124#endif 125 126#ifdef HAVE_GETHOSTBYNAME_R 127# if defined(_AIX) || defined(__osf__) 128# define HAVE_GETHOSTBYNAME_R_3_ARG 129# elif defined(__sun) || defined(__sgi) 130# define HAVE_GETHOSTBYNAME_R_5_ARG 131# elif defined(linux) 132/* Rely on the configure script */ 133# else 134# undef HAVE_GETHOSTBYNAME_R 135# endif 136#endif 137 138#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \ 139 !defined(MS_WINDOWS) 140# define USE_GETHOSTBYNAME_LOCK 141#endif 142 143/* On systems on which getaddrinfo() is believed to not be thread-safe, 144 (this includes the getaddrinfo emulation) protect access with a lock. */ 145#if defined(WITH_THREAD) && (defined(__APPLE__) || defined(__FreeBSD__) || \ 146 defined(__OpenBSD__) || defined(__NetBSD__) || !defined(HAVE_GETADDRINFO)) 147#define USE_GETADDRINFO_LOCK 148#endif 149 150#ifdef USE_GETADDRINFO_LOCK 151#define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1); 152#define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock); 153#else 154#define ACQUIRE_GETADDRINFO_LOCK 155#define RELEASE_GETADDRINFO_LOCK 156#endif 157 158#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK) 159# include "pythread.h" 160#endif 161 162#if defined(PYCC_VACPP) 163# include <types.h> 164# include <io.h> 165# include <sys/ioctl.h> 166# include <utils.h> 167# include <ctype.h> 168#endif 169 170#if defined(__VMS) 171#if ! defined(_SOCKADDR_LEN) 172# ifdef getaddrinfo 173# undef getaddrinfo 174# endif 175# include "TCPIP_IOCTL_ROUTINE" 176#else 177# include <ioctl.h> 178#endif 179#endif 180 181#if defined(PYOS_OS2) 182# define INCL_DOS 183# define INCL_DOSERRORS 184# define INCL_NOPMAPI 185# include <os2.h> 186#endif 187 188#if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI 189/* make sure that the reentrant (gethostbyaddr_r etc) 190 functions are declared correctly if compiling with 191 MIPSPro 7.x in ANSI C mode (default) */ 192 193/* XXX Using _SGIAPI is the wrong thing, 194 but I don't know what the right thing is. */ 195#define _SGIAPI 1 196 197#define HAVE_INET_PTON 198#include <netdb.h> 199#endif 200 201/* Irix 6.5 fails to define this variable at all. This is needed 202 for both GCC and SGI's compiler. I'd say that the SGI headers 203 are just busted. */ 204#if defined(__sgi) && !defined(INET_ADDRSTRLEN) 205#define INET_ADDRSTRLEN 16 206#endif 207 208/* Generic includes */ 209#include <sys/types.h> 210#include <signal.h> 211 212/* Generic socket object definitions and includes */ 213#define PySocket_BUILDING_SOCKET 214#include "socketmodule.h" 215 216/* Addressing includes */ 217 218#ifndef MS_WINDOWS 219 220/* Non-MS WINDOWS includes */ 221# include <netdb.h> 222 223/* Headers needed for inet_ntoa() and inet_addr() */ 224# ifdef __BEOS__ 225# include <net/netdb.h> 226# elif defined(PYOS_OS2) && defined(PYCC_VACPP) 227# include <netdb.h> 228typedef size_t socklen_t; 229# else 230# include <arpa/inet.h> 231# endif 232 233# ifndef RISCOS 234# include <fcntl.h> 235# else 236# include <sys/ioctl.h> 237# include <socklib.h> 238# define NO_DUP 239int h_errno; /* not used */ 240# define INET_ADDRSTRLEN 16 241# endif 242 243#else 244 245/* MS_WINDOWS includes */ 246# include <fcntl.h> 247 248#endif 249 250#ifdef HAVE_STDDEF_H 251# include <stddef.h> 252#endif 253 254#ifndef offsetof 255# define offsetof(type, member) ((size_t)(&((type *)0)->member)) 256#endif 257 258#ifndef O_NONBLOCK 259# define O_NONBLOCK O_NDELAY 260#endif 261 262#include "addrinfo.h" 263 264#ifndef HAVE_INET_PTON 265int inet_pton(int af, const char *src, void *dst); 266const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); 267#endif 268 269#ifdef __APPLE__ 270/* On OS X, getaddrinfo returns no error indication of lookup 271 failure, so we must use the emulation instead of the libinfo 272 implementation. Unfortunately, performing an autoconf test 273 for this bug would require DNS access for the machine performing 274 the configuration, which is not acceptable. Therefore, we 275 determine the bug just by checking for __APPLE__. If this bug 276 gets ever fixed, perhaps checking for sys/version.h would be 277 appropriate, which is 10/0 on the system with the bug. */ 278#ifndef HAVE_GETNAMEINFO 279/* This bug seems to be fixed in Jaguar. Ths easiest way I could 280 Find to check for Jaguar is that it has getnameinfo(), which 281 older releases don't have */ 282#undef HAVE_GETADDRINFO 283#endif 284#endif 285 286/* I know this is a bad practice, but it is the easiest... */ 287#if !defined(HAVE_GETADDRINFO) 288/* avoid clashes with the C library definition of the symbol. */ 289#define getaddrinfo fake_getaddrinfo 290#define gai_strerror fake_gai_strerror 291#define freeaddrinfo fake_freeaddrinfo 292#include "getaddrinfo.c" 293#endif 294#if !defined(HAVE_GETNAMEINFO) 295#define getnameinfo fake_getnameinfo 296#include "getnameinfo.c" 297#endif 298 299#if defined(MS_WINDOWS) || defined(__BEOS__) 300/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */ 301/* seem to be a few differences in the API */ 302#define SOCKETCLOSE closesocket 303#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */ 304#endif 305 306#ifdef MS_WIN32 307#define EAFNOSUPPORT WSAEAFNOSUPPORT 308#define snprintf _snprintf 309#endif 310 311#if defined(PYOS_OS2) && !defined(PYCC_GCC) 312#define SOCKETCLOSE soclose 313#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */ 314#endif 315 316#ifndef SOCKETCLOSE 317#define SOCKETCLOSE close 318#endif 319 320#ifdef __VMS 321/* TCP/IP Services for VMS uses a maximum send/revc buffer length of 65535 */ 322#define SEGMENT_SIZE 65535 323#endif 324 325/* 326 * Constants for getnameinfo() 327 */ 328#if !defined(NI_MAXHOST) 329#define NI_MAXHOST 1025 330#endif 331#if !defined(NI_MAXSERV) 332#define NI_MAXSERV 32 333#endif 334 335/* XXX There's a problem here: *static* functions are not supposed to have 336 a Py prefix (or use CapitalizedWords). Later... */ 337 338/* Global variable holding the exception type for errors detected 339 by this module (but not argument type or memory errors, etc.). */ 340static PyObject *socket_error; 341static PyObject *socket_herror; 342static PyObject *socket_gaierror; 343static PyObject *socket_timeout; 344 345#ifdef RISCOS 346/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */ 347static int taskwindow; 348#endif 349 350/* A forward reference to the socket type object. 351 The sock_type variable contains pointers to various functions, 352 some of which call new_sockobject(), which uses sock_type, so 353 there has to be a circular reference. */ 354static PyTypeObject sock_type; 355 356/* Convenience function to raise an error according to errno 357 and return a NULL pointer from a function. */ 358 359static PyObject * 360set_error(void) 361{ 362#ifdef MS_WINDOWS 363 int err_no = WSAGetLastError(); 364 static struct { 365 int no; 366 const char *msg; 367 } *msgp, msgs[] = { 368 {WSAEINTR, "Interrupted system call"}, 369 {WSAEBADF, "Bad file descriptor"}, 370 {WSAEACCES, "Permission denied"}, 371 {WSAEFAULT, "Bad address"}, 372 {WSAEINVAL, "Invalid argument"}, 373 {WSAEMFILE, "Too many open files"}, 374 {WSAEWOULDBLOCK, 375 "The socket operation could not complete " 376 "without blocking"}, 377 {WSAEINPROGRESS, "Operation now in progress"}, 378 {WSAEALREADY, "Operation already in progress"}, 379 {WSAENOTSOCK, "Socket operation on non-socket"}, 380 {WSAEDESTADDRREQ, "Destination address required"}, 381 {WSAEMSGSIZE, "Message too long"}, 382 {WSAEPROTOTYPE, "Protocol wrong type for socket"}, 383 {WSAENOPROTOOPT, "Protocol not available"}, 384 {WSAEPROTONOSUPPORT, "Protocol not supported"}, 385 {WSAESOCKTNOSUPPORT, "Socket type not supported"}, 386 {WSAEOPNOTSUPP, "Operation not supported"}, 387 {WSAEPFNOSUPPORT, "Protocol family not supported"}, 388 {WSAEAFNOSUPPORT, "Address family not supported"}, 389 {WSAEADDRINUSE, "Address already in use"}, 390 {WSAEADDRNOTAVAIL, "Can't assign requested address"}, 391 {WSAENETDOWN, "Network is down"}, 392 {WSAENETUNREACH, "Network is unreachable"}, 393 {WSAENETRESET, "Network dropped connection on reset"}, 394 {WSAECONNABORTED, "Software caused connection abort"}, 395 {WSAECONNRESET, "Connection reset by peer"}, 396 {WSAENOBUFS, "No buffer space available"}, 397 {WSAEISCONN, "Socket is already connected"}, 398 {WSAENOTCONN, "Socket is not connected"}, 399 {WSAESHUTDOWN, "Can't send after socket shutdown"}, 400 {WSAETOOMANYREFS, "Too many references: can't splice"}, 401 {WSAETIMEDOUT, "Operation timed out"}, 402 {WSAECONNREFUSED, "Connection refused"}, 403 {WSAELOOP, "Too many levels of symbolic links"}, 404 {WSAENAMETOOLONG, "File name too long"}, 405 {WSAEHOSTDOWN, "Host is down"}, 406 {WSAEHOSTUNREACH, "No route to host"}, 407 {WSAENOTEMPTY, "Directory not empty"}, 408 {WSAEPROCLIM, "Too many processes"}, 409 {WSAEUSERS, "Too many users"}, 410 {WSAEDQUOT, "Disc quota exceeded"}, 411 {WSAESTALE, "Stale NFS file handle"}, 412 {WSAEREMOTE, "Too many levels of remote in path"}, 413 {WSASYSNOTREADY, "Network subsystem is unvailable"}, 414 {WSAVERNOTSUPPORTED, "WinSock version is not supported"}, 415 {WSANOTINITIALISED, 416 "Successful WSAStartup() not yet performed"}, 417 {WSAEDISCON, "Graceful shutdown in progress"}, 418 /* Resolver errors */ 419 {WSAHOST_NOT_FOUND, "No such host is known"}, 420 {WSATRY_AGAIN, "Host not found, or server failed"}, 421 {WSANO_RECOVERY, "Unexpected server error encountered"}, 422 {WSANO_DATA, "Valid name without requested data"}, 423 {WSANO_ADDRESS, "No address, look for MX record"}, 424 {0, NULL} 425 }; 426 if (err_no) { 427 PyObject *v; 428 const char *msg = "winsock error"; 429 430 for (msgp = msgs; msgp->msg; msgp++) { 431 if (err_no == msgp->no) { 432 msg = msgp->msg; 433 break; 434 } 435 } 436 437 v = Py_BuildValue("(is)", err_no, msg); 438 if (v != NULL) { 439 PyErr_SetObject(socket_error, v); 440 Py_DECREF(v); 441 } 442 return NULL; 443 } 444 else 445#endif 446 447#if defined(PYOS_OS2) && !defined(PYCC_GCC) 448 if (sock_errno() != NO_ERROR) { 449 APIRET rc; 450 ULONG msglen; 451 char outbuf[100]; 452 int myerrorcode = sock_errno(); 453 454 /* Retrieve socket-related error message from MPTN.MSG file */ 455 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf), 456 myerrorcode - SOCBASEERR + 26, 457 "mptn.msg", 458 &msglen); 459 if (rc == NO_ERROR) { 460 PyObject *v; 461 462 /* OS/2 doesn't guarantee a terminator */ 463 outbuf[msglen] = '\0'; 464 if (strlen(outbuf) > 0) { 465 /* If non-empty msg, trim CRLF */ 466 char *lastc = &outbuf[ strlen(outbuf)-1 ]; 467 while (lastc > outbuf && isspace(*lastc)) { 468 /* Trim trailing whitespace (CRLF) */ 469 *lastc-- = '\0'; 470 } 471 } 472 v = Py_BuildValue("(is)", myerrorcode, outbuf); 473 if (v != NULL) { 474 PyErr_SetObject(socket_error, v); 475 Py_DECREF(v); 476 } 477 return NULL; 478 } 479 } 480#endif 481 482#if defined(RISCOS) 483 if (_inet_error.errnum != NULL) { 484 PyObject *v; 485 v = Py_BuildValue("(is)", errno, _inet_err()); 486 if (v != NULL) { 487 PyErr_SetObject(socket_error, v); 488 Py_DECREF(v); 489 } 490 return NULL; 491 } 492#endif 493 494 return PyErr_SetFromErrno(socket_error); 495} 496 497 498static PyObject * 499set_herror(int h_error) 500{ 501 PyObject *v; 502 503#ifdef HAVE_HSTRERROR 504 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error)); 505#else 506 v = Py_BuildValue("(is)", h_error, "host not found"); 507#endif 508 if (v != NULL) { 509 PyErr_SetObject(socket_herror, v); 510 Py_DECREF(v); 511 } 512 513 return NULL; 514} 515 516 517static PyObject * 518set_gaierror(int error) 519{ 520 PyObject *v; 521 522#ifdef EAI_SYSTEM 523 /* EAI_SYSTEM is not available on Windows XP. */ 524 if (error == EAI_SYSTEM) 525 return set_error(); 526#endif 527 528#ifdef HAVE_GAI_STRERROR 529 v = Py_BuildValue("(is)", error, gai_strerror(error)); 530#else 531 v = Py_BuildValue("(is)", error, "getaddrinfo failed"); 532#endif 533 if (v != NULL) { 534 PyErr_SetObject(socket_gaierror, v); 535 Py_DECREF(v); 536 } 537 538 return NULL; 539} 540 541/* Function to perform the setting of socket blocking mode 542 internally. block = (1 | 0). */ 543static int 544internal_setblocking(PySocketSockObject *s, int block) 545{ 546#ifndef RISCOS 547#ifndef MS_WINDOWS 548 int delay_flag; 549#endif 550#endif 551 552 Py_BEGIN_ALLOW_THREADS 553#ifdef __BEOS__ 554 block = !block; 555 setsockopt(s->sock_fd, SOL_SOCKET, SO_NONBLOCK, 556 (void *)(&block), sizeof(int)); 557#else 558#ifndef RISCOS 559#ifndef MS_WINDOWS 560#if defined(PYOS_OS2) && !defined(PYCC_GCC) 561 block = !block; 562 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block)); 563#elif defined(__VMS) 564 block = !block; 565 ioctl(s->sock_fd, FIONBIO, (char *)&block); 566#else /* !PYOS_OS2 && !_VMS */ 567 delay_flag = fcntl(s->sock_fd, F_GETFL, 0); 568 if (block) 569 delay_flag &= (~O_NONBLOCK); 570 else 571 delay_flag |= O_NONBLOCK; 572 fcntl(s->sock_fd, F_SETFL, delay_flag); 573#endif /* !PYOS_OS2 */ 574#else /* MS_WINDOWS */ 575 block = !block; 576 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block); 577#endif /* MS_WINDOWS */ 578#else /* RISCOS */ 579 block = !block; 580 socketioctl(s->sock_fd, FIONBIO, (u_long*)&block); 581#endif /* RISCOS */ 582#endif /* __BEOS__ */ 583 Py_END_ALLOW_THREADS 584 585 /* Since these don't return anything */ 586 return 1; 587} 588 589/* Do a select() on the socket, if necessary (sock_timeout > 0). 590 The argument writing indicates the direction. 591 This does not raise an exception; we'll let our caller do that 592 after they've reacquired the interpreter lock. 593 Returns 1 on timeout, 0 otherwise. */ 594static int 595internal_select(PySocketSockObject *s, int writing) 596{ 597 fd_set fds; 598 struct timeval tv; 599 int n; 600 601 /* Nothing to do unless we're in timeout mode (not non-blocking) */ 602 if (s->sock_timeout <= 0.0) 603 return 0; 604 605 /* Guard against closed socket */ 606 if (s->sock_fd < 0) 607 return 0; 608 609 /* Construct the arguments to select */ 610 tv.tv_sec = (int)s->sock_timeout; 611 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6); 612 FD_ZERO(&fds); 613 FD_SET(s->sock_fd, &fds); 614 615 /* See if the socket is ready */ 616 if (writing) 617 n = select(s->sock_fd+1, NULL, &fds, NULL, &tv); 618 else 619 n = select(s->sock_fd+1, &fds, NULL, NULL, &tv); 620 if (n == 0) 621 return 1; 622 return 0; 623} 624 625/* Initialize a new socket object. */ 626 627static double defaulttimeout = -1.0; /* Default timeout for new sockets */ 628 629PyMODINIT_FUNC 630init_sockobject(PySocketSockObject *s, 631 SOCKET_T fd, int family, int type, int proto) 632{ 633#ifdef RISCOS 634 int block = 1; 635#endif 636 s->sock_fd = fd; 637 s->sock_family = family; 638 s->sock_type = type; 639 s->sock_proto = proto; 640 s->sock_timeout = defaulttimeout; 641 642 s->errorhandler = &set_error; 643 644 if (defaulttimeout >= 0.0) 645 internal_setblocking(s, 0); 646 647#ifdef RISCOS 648 if (taskwindow) 649 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block); 650#endif 651} 652 653 654/* Create a new socket object. 655 This just creates the object and initializes it. 656 If the creation fails, return NULL and set an exception (implicit 657 in NEWOBJ()). */ 658 659static PySocketSockObject * 660new_sockobject(SOCKET_T fd, int family, int type, int proto) 661{ 662 PySocketSockObject *s; 663 s = (PySocketSockObject *) 664 PyType_GenericNew(&sock_type, NULL, NULL); 665 if (s != NULL) 666 init_sockobject(s, fd, family, type, proto); 667 return s; 668} 669 670 671/* Lock to allow python interpreter to continue, but only allow one 672 thread to be in gethostbyname or getaddrinfo */ 673#if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK) 674PyThread_type_lock netdb_lock; 675#endif 676 677 678/* Convert a string specifying a host name or one of a few symbolic 679 names to a numeric IP address. This usually calls gethostbyname() 680 to do the work; the names "" and "<broadcast>" are special. 681 Return the length (IPv4 should be 4 bytes), or negative if 682 an error occurred; then an exception is raised. */ 683 684static int 685setipaddr(char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int af) 686{ 687 struct addrinfo hints, *res; 688 int error; 689 int d1, d2, d3, d4; 690 char ch; 691 692 memset((void *) addr_ret, '\0', sizeof(*addr_ret)); 693 if (name[0] == '\0') { 694 int siz; 695 memset(&hints, 0, sizeof(hints)); 696 hints.ai_family = af; 697 hints.ai_socktype = SOCK_DGRAM; /*dummy*/ 698 hints.ai_flags = AI_PASSIVE; 699 Py_BEGIN_ALLOW_THREADS 700 ACQUIRE_GETADDRINFO_LOCK 701 error = getaddrinfo(NULL, "0", &hints, &res); 702 Py_END_ALLOW_THREADS 703 /* We assume that those thread-unsafe getaddrinfo() versions 704 *are* safe regarding their return value, ie. that a 705 subsequent call to getaddrinfo() does not destroy the 706 outcome of the first call. */ 707 RELEASE_GETADDRINFO_LOCK 708 if (error) { 709 set_gaierror(error); 710 return -1; 711 } 712 switch (res->ai_family) { 713 case AF_INET: 714 siz = 4; 715 break; 716#ifdef ENABLE_IPV6 717 case AF_INET6: 718 siz = 16; 719 break; 720#endif 721 default: 722 freeaddrinfo(res); 723 PyErr_SetString(socket_error, 724 "unsupported address family"); 725 return -1; 726 } 727 if (res->ai_next) { 728 freeaddrinfo(res); 729 PyErr_SetString(socket_error, 730 "wildcard resolved to multiple address"); 731 return -1; 732 } 733 if (res->ai_addrlen < addr_ret_size) 734 addr_ret_size = res->ai_addrlen; 735 memcpy(addr_ret, res->ai_addr, addr_ret_size); 736 freeaddrinfo(res); 737 return siz; 738 } 739 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) { 740 struct sockaddr_in *sin; 741 if (af != AF_INET && af != AF_UNSPEC) { 742 PyErr_SetString(socket_error, 743 "address family mismatched"); 744 return -1; 745 } 746 sin = (struct sockaddr_in *)addr_ret; 747 memset((void *) sin, '\0', sizeof(*sin)); 748 sin->sin_family = AF_INET; 749#ifdef HAVE_SOCKADDR_SA_LEN 750 sin->sin_len = sizeof(*sin); 751#endif 752 sin->sin_addr.s_addr = INADDR_BROADCAST; 753 return sizeof(sin->sin_addr); 754 } 755 if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 && 756 0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 && 757 0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) { 758 struct sockaddr_in *sin; 759 sin = (struct sockaddr_in *)addr_ret; 760 sin->sin_addr.s_addr = htonl( 761 ((long) d1 << 24) | ((long) d2 << 16) | 762 ((long) d3 << 8) | ((long) d4 << 0)); 763 sin->sin_family = AF_INET; 764#ifdef HAVE_SOCKADDR_SA_LEN 765 sin->sin_len = sizeof(*sin); 766#endif 767 return 4; 768 } 769 memset(&hints, 0, sizeof(hints)); 770 hints.ai_family = af; 771 Py_BEGIN_ALLOW_THREADS 772 ACQUIRE_GETADDRINFO_LOCK 773 error = getaddrinfo(name, NULL, &hints, &res); 774#if defined(__digital__) && defined(__unix__) 775 if (error == EAI_NONAME && af == AF_UNSPEC) { 776 /* On Tru64 V5.1, numeric-to-addr conversion fails 777 if no address family is given. Assume IPv4 for now.*/ 778 hints.ai_family = AF_INET; 779 error = getaddrinfo(name, NULL, &hints, &res); 780 } 781#endif 782 Py_END_ALLOW_THREADS 783 RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */ 784 if (error) { 785 set_gaierror(error); 786 return -1; 787 } 788 if (res->ai_addrlen < addr_ret_size) 789 addr_ret_size = res->ai_addrlen; 790 memcpy((char *) addr_ret, res->ai_addr, addr_ret_size); 791 freeaddrinfo(res); 792 switch (addr_ret->sa_family) { 793 case AF_INET: 794 return 4; 795#ifdef ENABLE_IPV6 796 case AF_INET6: 797 return 16; 798#endif 799 default: 800 PyErr_SetString(socket_error, "unknown address family"); 801 return -1; 802 } 803} 804 805 806/* Create a string object representing an IP address. 807 This is always a string of the form 'dd.dd.dd.dd' (with variable 808 size numbers). */ 809 810static PyObject * 811makeipaddr(struct sockaddr *addr, int addrlen) 812{ 813 char buf[NI_MAXHOST]; 814 int error; 815 816 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0, 817 NI_NUMERICHOST); 818 if (error) { 819 set_gaierror(error); 820 return NULL; 821 } 822 return PyString_FromString(buf); 823} 824 825 826/* Create an object representing the given socket address, 827 suitable for passing it back to bind(), connect() etc. 828 The family field of the sockaddr structure is inspected 829 to determine what kind of address it really is. */ 830 831/*ARGSUSED*/ 832static PyObject * 833makesockaddr(int sockfd, struct sockaddr *addr, int addrlen) 834{ 835 if (addrlen == 0) { 836 /* No address -- may be recvfrom() from known socket */ 837 Py_INCREF(Py_None); 838 return Py_None; 839 } 840 841#ifdef __BEOS__ 842 /* XXX: BeOS version of accept() doesn't set family correctly */ 843 addr->sa_family = AF_INET; 844#endif 845 846 switch (addr->sa_family) { 847 848 case AF_INET: 849 { 850 struct sockaddr_in *a; 851 PyObject *addrobj = makeipaddr(addr, sizeof(*a)); 852 PyObject *ret = NULL; 853 if (addrobj) { 854 a = (struct sockaddr_in *)addr; 855 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port)); 856 Py_DECREF(addrobj); 857 } 858 return ret; 859 } 860 861#if defined(AF_UNIX) && !defined(PYOS_OS2) 862 case AF_UNIX: 863 { 864 struct sockaddr_un *a = (struct sockaddr_un *) addr; 865 return PyString_FromString(a->sun_path); 866 } 867#endif /* AF_UNIX */ 868 869#ifdef ENABLE_IPV6 870 case AF_INET6: 871 { 872 struct sockaddr_in6 *a; 873 PyObject *addrobj = makeipaddr(addr, sizeof(*a)); 874 PyObject *ret = NULL; 875 if (addrobj) { 876 a = (struct sockaddr_in6 *)addr; 877 ret = Py_BuildValue("Oiii", 878 addrobj, 879 ntohs(a->sin6_port), 880 a->sin6_flowinfo, 881 a->sin6_scope_id); 882 Py_DECREF(addrobj); 883 } 884 return ret; 885 } 886#endif 887 888#ifdef HAVE_NETPACKET_PACKET_H 889 case AF_PACKET: 890 { 891 struct sockaddr_ll *a = (struct sockaddr_ll *)addr; 892 char *ifname = ""; 893 struct ifreq ifr; 894 /* need to look up interface name give index */ 895 if (a->sll_ifindex) { 896 ifr.ifr_ifindex = a->sll_ifindex; 897 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0) 898 ifname = ifr.ifr_name; 899 } 900 return Py_BuildValue("shbhs#", 901 ifname, 902 ntohs(a->sll_protocol), 903 a->sll_pkttype, 904 a->sll_hatype, 905 a->sll_addr, 906 a->sll_halen); 907 } 908#endif 909 910 /* More cases here... */ 911 912 default: 913 /* If we don't know the address family, don't raise an 914 exception -- return it as a tuple. */ 915 return Py_BuildValue("is#", 916 addr->sa_family, 917 addr->sa_data, 918 sizeof(addr->sa_data)); 919 920 } 921} 922 923 924/* Parse a socket address argument according to the socket object's 925 address family. Return 1 if the address was in the proper format, 926 0 of not. The address is returned through addr_ret, its length 927 through len_ret. */ 928 929static int 930getsockaddrarg(PySocketSockObject *s, PyObject *args, 931 struct sockaddr **addr_ret, int *len_ret) 932{ 933 switch (s->sock_family) { 934 935#if defined(AF_UNIX) && !defined(PYOS_OS2) 936 case AF_UNIX: 937 { 938 struct sockaddr_un* addr; 939 char *path; 940 int len; 941 addr = (struct sockaddr_un*)&(s->sock_addr).un; 942 if (!PyArg_Parse(args, "t#", &path, &len)) 943 return 0; 944 if (len > sizeof addr->sun_path) { 945 PyErr_SetString(socket_error, 946 "AF_UNIX path too long"); 947 return 0; 948 } 949 addr->sun_family = s->sock_family; 950 memcpy(addr->sun_path, path, len); 951 addr->sun_path[len] = 0; 952 *addr_ret = (struct sockaddr *) addr; 953 *len_ret = len + sizeof(*addr) - sizeof(addr->sun_path); 954 return 1; 955 } 956#endif /* AF_UNIX */ 957 958 case AF_INET: 959 { 960 struct sockaddr_in* addr; 961 char *host; 962 int port, result; 963 addr=(struct sockaddr_in*)&(s->sock_addr).in; 964 if (!PyTuple_Check(args)) { 965 PyErr_Format( 966 PyExc_TypeError, 967 "getsockaddrarg: " 968 "AF_INET address must be tuple, not %.500s", 969 args->ob_type->tp_name); 970 return 0; 971 } 972 if (!PyArg_ParseTuple(args, "eti:getsockaddrarg", 973 "idna", &host, &port)) 974 return 0; 975 result = setipaddr(host, (struct sockaddr *)addr, 976 sizeof(*addr), AF_INET); 977 PyMem_Free(host); 978 if (result < 0) 979 return 0; 980 addr->sin_family = AF_INET; 981 addr->sin_port = htons((short)port); 982 *addr_ret = (struct sockaddr *) addr; 983 *len_ret = sizeof *addr; 984 return 1; 985 } 986 987#ifdef ENABLE_IPV6 988 case AF_INET6: 989 { 990 struct sockaddr_in6* addr; 991 char *host; 992 int port, flowinfo, scope_id, result; 993 addr = (struct sockaddr_in6*)&(s->sock_addr).in6; 994 flowinfo = scope_id = 0; 995 if (!PyArg_ParseTuple(args, "eti|ii", 996 "idna", &host, &port, &flowinfo, 997 &scope_id)) { 998 return 0; 999 } 1000 result = setipaddr(host, (struct sockaddr *)addr, 1001 sizeof(*addr), AF_INET6); 1002 PyMem_Free(host); 1003 if (result < 0) 1004 return 0; 1005 addr->sin6_family = s->sock_family; 1006 addr->sin6_port = htons((short)port); 1007 addr->sin6_flowinfo = flowinfo; 1008 addr->sin6_scope_id = scope_id; 1009 *addr_ret = (struct sockaddr *) addr; 1010 *len_ret = sizeof *addr; 1011 return 1; 1012 } 1013#endif 1014 1015#ifdef HAVE_NETPACKET_PACKET_H 1016 case AF_PACKET: 1017 { 1018 struct sockaddr_ll* addr; 1019 struct ifreq ifr; 1020 char *interfaceName; 1021 int protoNumber; 1022 int hatype = 0; 1023 int pkttype = 0; 1024 char *haddr; 1025 1026 if (!PyArg_ParseTuple(args, "si|iis", &interfaceName, 1027 &protoNumber, &pkttype, &hatype, &haddr)) 1028 return 0; 1029 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name)); 1030 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0'; 1031 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) { 1032 s->errorhandler(); 1033 return 0; 1034 } 1035 addr = &(s->sock_addr.ll); 1036 addr->sll_family = AF_PACKET; 1037 addr->sll_protocol = htons((short)protoNumber); 1038 addr->sll_ifindex = ifr.ifr_ifindex; 1039 addr->sll_pkttype = pkttype; 1040 addr->sll_hatype = hatype; 1041 *addr_ret = (struct sockaddr *) addr; 1042 *len_ret = sizeof *addr; 1043 return 1; 1044 } 1045#endif 1046 1047 /* More cases here... */ 1048 1049 default: 1050 PyErr_SetString(socket_error, "getsockaddrarg: bad family"); 1051 return 0; 1052 1053 } 1054} 1055 1056 1057/* Get the address length according to the socket object's address family. 1058 Return 1 if the family is known, 0 otherwise. The length is returned 1059 through len_ret. */ 1060 1061static int 1062getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret) 1063{ 1064 switch (s->sock_family) { 1065 1066#if defined(AF_UNIX) && !defined(PYOS_OS2) 1067 case AF_UNIX: 1068 { 1069 *len_ret = sizeof (struct sockaddr_un); 1070 return 1; 1071 } 1072#endif /* AF_UNIX */ 1073 1074 case AF_INET: 1075 { 1076 *len_ret = sizeof (struct sockaddr_in); 1077 return 1; 1078 } 1079 1080#ifdef ENABLE_IPV6 1081 case AF_INET6: 1082 { 1083 *len_ret = sizeof (struct sockaddr_in6); 1084 return 1; 1085 } 1086#endif 1087 1088#ifdef HAVE_NETPACKET_PACKET_H 1089 case AF_PACKET: 1090 { 1091 *len_ret = sizeof (struct sockaddr_ll); 1092 return 1; 1093 } 1094#endif 1095 1096 /* More cases here... */ 1097 1098 default: 1099 PyErr_SetString(socket_error, "getsockaddrlen: bad family"); 1100 return 0; 1101 1102 } 1103} 1104 1105 1106/* s.accept() method */ 1107 1108static PyObject * 1109sock_accept(PySocketSockObject *s) 1110{ 1111 char addrbuf[256]; 1112 SOCKET_T newfd; 1113 socklen_t addrlen; 1114 PyObject *sock = NULL; 1115 PyObject *addr = NULL; 1116 PyObject *res = NULL; 1117 int timeout; 1118 1119 if (!getsockaddrlen(s, &addrlen)) 1120 return NULL; 1121 memset(addrbuf, 0, addrlen); 1122 1123#ifdef MS_WINDOWS 1124 newfd = INVALID_SOCKET; 1125#else 1126 newfd = -1; 1127#endif 1128 1129 Py_BEGIN_ALLOW_THREADS 1130 timeout = internal_select(s, 0); 1131 if (!timeout) 1132 newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, 1133 &addrlen); 1134 Py_END_ALLOW_THREADS 1135 1136 if (timeout) { 1137 PyErr_SetString(socket_timeout, "timed out"); 1138 return NULL; 1139 } 1140 1141#ifdef MS_WINDOWS 1142 if (newfd == INVALID_SOCKET) 1143#else 1144 if (newfd < 0) 1145#endif 1146 return s->errorhandler(); 1147 1148 /* Create the new object with unspecified family, 1149 to avoid calls to bind() etc. on it. */ 1150 sock = (PyObject *) new_sockobject(newfd, 1151 s->sock_family, 1152 s->sock_type, 1153 s->sock_proto); 1154 1155 if (sock == NULL) { 1156 SOCKETCLOSE(newfd); 1157 goto finally; 1158 } 1159 addr = makesockaddr(s->sock_fd, (struct sockaddr *)addrbuf, 1160 addrlen); 1161 if (addr == NULL) 1162 goto finally; 1163 1164 res = Py_BuildValue("OO", sock, addr); 1165 1166finally: 1167 Py_XDECREF(sock); 1168 Py_XDECREF(addr); 1169 return res; 1170} 1171 1172PyDoc_STRVAR(accept_doc, 1173"accept() -> (socket object, address info)\n\ 1174\n\ 1175Wait for an incoming connection. Return a new socket representing the\n\ 1176connection, and the address of the client. For IP sockets, the address\n\ 1177info is a pair (hostaddr, port)."); 1178 1179/* s.setblocking(flag) method. Argument: 1180 False -- non-blocking mode; same as settimeout(0) 1181 True -- blocking mode; same as settimeout(None) 1182*/ 1183 1184static PyObject * 1185sock_setblocking(PySocketSockObject *s, PyObject *arg) 1186{ 1187 int block; 1188 1189 block = PyInt_AsLong(arg); 1190 if (block == -1 && PyErr_Occurred()) 1191 return NULL; 1192 1193 s->sock_timeout = block ? -1.0 : 0.0; 1194 internal_setblocking(s, block); 1195 1196 Py_INCREF(Py_None); 1197 return Py_None; 1198} 1199 1200PyDoc_STRVAR(setblocking_doc, 1201"setblocking(flag)\n\ 1202\n\ 1203Set the socket to blocking (flag is true) or non-blocking (false).\n\ 1204setblocking(True) is equivalent to settimeout(None);\n\ 1205setblocking(False) is equivalent to settimeout(0.0)."); 1206 1207/* s.settimeout(timeout) method. Argument: 1208 None -- no timeout, blocking mode; same as setblocking(True) 1209 0.0 -- non-blocking mode; same as setblocking(False) 1210 > 0 -- timeout mode; operations time out after timeout seconds 1211 < 0 -- illegal; raises an exception 1212*/ 1213static PyObject * 1214sock_settimeout(PySocketSockObject *s, PyObject *arg) 1215{ 1216 double timeout; 1217 1218 if (arg == Py_None) 1219 timeout = -1.0; 1220 else { 1221 timeout = PyFloat_AsDouble(arg); 1222 if (timeout < 0.0) { 1223 if (!PyErr_Occurred()) 1224 PyErr_SetString(PyExc_ValueError, 1225 "Timeout value out of range"); 1226 return NULL; 1227 } 1228 } 1229 1230 s->sock_timeout = timeout; 1231 internal_setblocking(s, timeout < 0.0); 1232 1233 Py_INCREF(Py_None); 1234 return Py_None; 1235} 1236 1237PyDoc_STRVAR(settimeout_doc, 1238"settimeout(timeout)\n\ 1239\n\ 1240Set a timeout on socket operations. 'timeout' can be a float,\n\ 1241giving in seconds, or None. Setting a timeout of None disables\n\ 1242the timeout feature and is equivalent to setblocking(1).\n\ 1243Setting a timeout of zero is the same as setblocking(0)."); 1244 1245/* s.gettimeout() method. 1246 Returns the timeout associated with a socket. */ 1247static PyObject * 1248sock_gettimeout(PySocketSockObject *s) 1249{ 1250 if (s->sock_timeout < 0.0) { 1251 Py_INCREF(Py_None); 1252 return Py_None; 1253 } 1254 else 1255 return PyFloat_FromDouble(s->sock_timeout); 1256} 1257 1258PyDoc_STRVAR(gettimeout_doc, 1259"gettimeout() -> timeout\n\ 1260\n\ 1261Returns the timeout in floating seconds associated with socket \n\ 1262operations. A timeout of None indicates that timeouts on socket \n\ 1263operations are disabled."); 1264 1265#ifdef RISCOS 1266/* s.sleeptaskw(1 | 0) method */ 1267 1268static PyObject * 1269sock_sleeptaskw(PySocketSockObject *s,PyObject *arg) 1270{ 1271 int block; 1272 block = PyInt_AsLong(arg); 1273 if (block == -1 && PyErr_Occurred()) 1274 return NULL; 1275 Py_BEGIN_ALLOW_THREADS 1276 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block); 1277 Py_END_ALLOW_THREADS 1278 1279 Py_INCREF(Py_None); 1280 return Py_None; 1281} 1282PyDoc_STRVAR(sleeptaskw_doc, 1283"sleeptaskw(flag)\n\ 1284\n\ 1285Allow sleeps in taskwindows."); 1286#endif 1287 1288 1289/* s.setsockopt() method. 1290 With an integer third argument, sets an integer option. 1291 With a string third argument, sets an option from a buffer; 1292 use optional built-in module 'struct' to encode the string. */ 1293 1294static PyObject * 1295sock_setsockopt(PySocketSockObject *s, PyObject *args) 1296{ 1297 int level; 1298 int optname; 1299 int res; 1300 char *buf; 1301 int buflen; 1302 int flag; 1303 1304 if (PyArg_ParseTuple(args, "iii:setsockopt", 1305 &level, &optname, &flag)) { 1306 buf = (char *) &flag; 1307 buflen = sizeof flag; 1308 } 1309 else { 1310 PyErr_Clear(); 1311 if (!PyArg_ParseTuple(args, "iis#:setsockopt", 1312 &level, &optname, &buf, &buflen)) 1313 return NULL; 1314 } 1315 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen); 1316 if (res < 0) 1317 return s->errorhandler(); 1318 Py_INCREF(Py_None); 1319 return Py_None; 1320} 1321 1322PyDoc_STRVAR(setsockopt_doc, 1323"setsockopt(level, option, value)\n\ 1324\n\ 1325Set a socket option. See the Unix manual for level and option.\n\ 1326The value argument can either be an integer or a string."); 1327 1328 1329/* s.getsockopt() method. 1330 With two arguments, retrieves an integer option. 1331 With a third integer argument, retrieves a string buffer of that size; 1332 use optional built-in module 'struct' to decode the string. */ 1333 1334static PyObject * 1335sock_getsockopt(PySocketSockObject *s, PyObject *args) 1336{ 1337 int level; 1338 int optname; 1339 int res; 1340 PyObject *buf; 1341 socklen_t buflen = 0; 1342 1343#ifdef __BEOS__ 1344 /* We have incomplete socket support. */ 1345 PyErr_SetString(socket_error, "getsockopt not supported"); 1346 return NULL; 1347#else 1348 1349 if (!PyArg_ParseTuple(args, "ii|i:getsockopt", 1350 &level, &optname, &buflen)) 1351 return NULL; 1352 1353 if (buflen == 0) { 1354 int flag = 0; 1355 socklen_t flagsize = sizeof flag; 1356 res = getsockopt(s->sock_fd, level, optname, 1357 (void *)&flag, &flagsize); 1358 if (res < 0) 1359 return s->errorhandler(); 1360 return PyInt_FromLong(flag); 1361 } 1362#ifdef __VMS 1363 if (buflen > 1024) { 1364#else 1365 if (buflen <= 0 || buflen > 1024) { 1366#endif 1367 PyErr_SetString(socket_error, 1368 "getsockopt buflen out of range"); 1369 return NULL; 1370 } 1371 buf = PyString_FromStringAndSize((char *)NULL, buflen); 1372 if (buf == NULL) 1373 return NULL; 1374 res = getsockopt(s->sock_fd, level, optname, 1375 (void *)PyString_AS_STRING(buf), &buflen); 1376 if (res < 0) { 1377 Py_DECREF(buf); 1378 return s->errorhandler(); 1379 } 1380 _PyString_Resize(&buf, buflen); 1381 return buf; 1382#endif /* __BEOS__ */ 1383} 1384 1385PyDoc_STRVAR(getsockopt_doc, 1386"getsockopt(level, option[, buffersize]) -> value\n\ 1387\n\ 1388Get a socket option. See the Unix manual for level and option.\n\ 1389If a nonzero buffersize argument is given, the return value is a\n\ 1390string of that length; otherwise it is an integer."); 1391 1392 1393/* s.bind(sockaddr) method */ 1394 1395static PyObject * 1396sock_bind(PySocketSockObject *s, PyObject *addro) 1397{ 1398 struct sockaddr *addr; 1399 int addrlen; 1400 int res; 1401 1402 if (!getsockaddrarg(s, addro, &addr, &addrlen)) 1403 return NULL; 1404 Py_BEGIN_ALLOW_THREADS 1405 res = bind(s->sock_fd, addr, addrlen); 1406 Py_END_ALLOW_THREADS 1407 if (res < 0) 1408 return s->errorhandler(); 1409 Py_INCREF(Py_None); 1410 return Py_None; 1411} 1412 1413PyDoc_STRVAR(bind_doc, 1414"bind(address)\n\ 1415\n\ 1416Bind the socket to a local address. For IP sockets, the address is a\n\ 1417pair (host, port); the host must refer to the local host. For raw packet\n\ 1418sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])"); 1419 1420 1421/* s.close() method. 1422 Set the file descriptor to -1 so operations tried subsequently 1423 will surely fail. */ 1424 1425static PyObject * 1426sock_close(PySocketSockObject *s) 1427{ 1428 SOCKET_T fd; 1429 1430 if ((fd = s->sock_fd) != -1) { 1431 s->sock_fd = -1; 1432 Py_BEGIN_ALLOW_THREADS 1433 (void) SOCKETCLOSE(fd); 1434 Py_END_ALLOW_THREADS 1435 } 1436 Py_INCREF(Py_None); 1437 return Py_None; 1438} 1439 1440PyDoc_STRVAR(close_doc, 1441"close()\n\ 1442\n\ 1443Close the socket. It cannot be used after this call."); 1444 1445static int 1446internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen, 1447 int *timeoutp) 1448{ 1449 int res, timeout; 1450 1451 timeout = 0; 1452 res = connect(s->sock_fd, addr, addrlen); 1453 1454#ifdef MS_WINDOWS 1455 1456 if (s->sock_timeout > 0.0) { 1457 if (res < 0 && WSAGetLastError() == WSAEWOULDBLOCK) { 1458 /* This is a mess. Best solution: trust select */ 1459 fd_set fds; 1460 struct timeval tv; 1461 tv.tv_sec = (int)s->sock_timeout; 1462 tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6); 1463 FD_ZERO(&fds); 1464 FD_SET(s->sock_fd, &fds); 1465 res = select(s->sock_fd+1, NULL, &fds, NULL, &tv); 1466 if (res == 0) { 1467 res = WSAEWOULDBLOCK; 1468 timeout = 1; 1469 } else if (res > 0) 1470 res = 0; 1471 /* else if (res < 0) an error occurred */ 1472 } 1473 } 1474 1475 if (res < 0) 1476 res = WSAGetLastError(); 1477 1478#else 1479 1480 if (s->sock_timeout > 0.0) { 1481 if (res < 0 && errno == EINPROGRESS) { 1482 timeout = internal_select(s, 1); 1483 res = connect(s->sock_fd, addr, addrlen); 1484 if (res < 0 && errno == EISCONN) 1485 res = 0; 1486 } 1487 } 1488 1489 if (res < 0) 1490 res = errno; 1491 1492#endif 1493 *timeoutp = timeout; 1494 1495 return res; 1496} 1497 1498/* s.connect(sockaddr) method */ 1499 1500static PyObject * 1501sock_connect(PySocketSockObject *s, PyObject *addro) 1502{ 1503 struct sockaddr *addr; 1504 int addrlen; 1505 int res; 1506 int timeout; 1507 1508 if (!getsockaddrarg(s, addro, &addr, &addrlen)) 1509 return NULL; 1510 1511 Py_BEGIN_ALLOW_THREADS 1512 res = internal_connect(s, addr, addrlen, &timeout); 1513 Py_END_ALLOW_THREADS 1514 1515 if (timeout) { 1516 PyErr_SetString(socket_timeout, "timed out"); 1517 return NULL; 1518 } 1519 if (res != 0) 1520 return s->errorhandler(); 1521 Py_INCREF(Py_None); 1522 return Py_None; 1523} 1524 1525PyDoc_STRVAR(connect_doc, 1526"connect(address)\n\ 1527\n\ 1528Connect the socket to a remote address. For IP sockets, the address\n\ 1529is a pair (host, port)."); 1530 1531 1532/* s.connect_ex(sockaddr) method */ 1533 1534static PyObject * 1535sock_connect_ex(PySocketSockObject *s, PyObject *addro) 1536{ 1537 struct sockaddr *addr; 1538 int addrlen; 1539 int res; 1540 int timeout; 1541 1542 if (!getsockaddrarg(s, addro, &addr, &addrlen)) 1543 return NULL; 1544 1545 Py_BEGIN_ALLOW_THREADS 1546 res = internal_connect(s, addr, addrlen, &timeout); 1547 Py_END_ALLOW_THREADS 1548 1549 return PyInt_FromLong((long) res); 1550} 1551 1552PyDoc_STRVAR(connect_ex_doc, 1553"connect_ex(address) -> errno\n\ 1554\n\ 1555This is like connect(address), but returns an error code (the errno value)\n\ 1556instead of raising an exception when an error occurs."); 1557 1558 1559/* s.fileno() method */ 1560 1561static PyObject * 1562sock_fileno(PySocketSockObject *s) 1563{ 1564#if SIZEOF_SOCKET_T <= SIZEOF_LONG 1565 return PyInt_FromLong((long) s->sock_fd); 1566#else 1567 return PyLong_FromLongLong((PY_LONG_LONG)s->sock_fd); 1568#endif 1569} 1570 1571PyDoc_STRVAR(fileno_doc, 1572"fileno() -> integer\n\ 1573\n\ 1574Return the integer file descriptor of the socket."); 1575 1576 1577#ifndef NO_DUP 1578/* s.dup() method */ 1579 1580static PyObject * 1581sock_dup(PySocketSockObject *s) 1582{ 1583 SOCKET_T newfd; 1584 PyObject *sock; 1585 1586 newfd = dup(s->sock_fd); 1587 if (newfd < 0) 1588 return s->errorhandler(); 1589 sock = (PyObject *) new_sockobject(newfd, 1590 s->sock_family, 1591 s->sock_type, 1592 s->sock_proto); 1593 if (sock == NULL) 1594 SOCKETCLOSE(newfd); 1595 return sock; 1596} 1597 1598PyDoc_STRVAR(dup_doc, 1599"dup() -> socket object\n\ 1600\n\ 1601Return a new socket object connected to the same system resource."); 1602 1603#endif 1604 1605 1606/* s.getsockname() method */ 1607 1608static PyObject * 1609sock_getsockname(PySocketSockObject *s) 1610{ 1611 char addrbuf[256]; 1612 int res; 1613 socklen_t addrlen; 1614 1615 if (!getsockaddrlen(s, &addrlen)) 1616 return NULL; 1617 memset(addrbuf, 0, addrlen); 1618 Py_BEGIN_ALLOW_THREADS 1619 res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen); 1620 Py_END_ALLOW_THREADS 1621 if (res < 0) 1622 return s->errorhandler(); 1623 return makesockaddr(s->sock_fd, (struct sockaddr *) addrbuf, addrlen); 1624} 1625 1626PyDoc_STRVAR(getsockname_doc, 1627"getsockname() -> address info\n\ 1628\n\ 1629Return the address of the local endpoint. For IP sockets, the address\n\ 1630info is a pair (hostaddr, port)."); 1631 1632 1633#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */ 1634/* s.getpeername() method */ 1635 1636static PyObject * 1637sock_getpeername(PySocketSockObject *s) 1638{ 1639 char addrbuf[256]; 1640 int res; 1641 socklen_t addrlen; 1642 1643 if (!getsockaddrlen(s, &addrlen)) 1644 return NULL; 1645 memset(addrbuf, 0, addrlen); 1646 Py_BEGIN_ALLOW_THREADS 1647 res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen); 1648 Py_END_ALLOW_THREADS 1649 if (res < 0) 1650 return s->errorhandler(); 1651 return makesockaddr(s->sock_fd, (struct sockaddr *) addrbuf, addrlen); 1652} 1653 1654PyDoc_STRVAR(getpeername_doc, 1655"getpeername() -> address info\n\ 1656\n\ 1657Return the address of the remote endpoint. For IP sockets, the address\n\ 1658info is a pair (hostaddr, port)."); 1659 1660#endif /* HAVE_GETPEERNAME */ 1661 1662 1663/* s.listen(n) method */ 1664 1665static PyObject * 1666sock_listen(PySocketSockObject *s, PyObject *arg) 1667{ 1668 int backlog; 1669 int res; 1670 1671 backlog = PyInt_AsLong(arg); 1672 if (backlog == -1 && PyErr_Occurred()) 1673 return NULL; 1674 Py_BEGIN_ALLOW_THREADS 1675 if (backlog < 1) 1676 backlog = 1; 1677 res = listen(s->sock_fd, backlog); 1678 Py_END_ALLOW_THREADS 1679 if (res < 0) 1680 return s->errorhandler(); 1681 Py_INCREF(Py_None); 1682 return Py_None; 1683} 1684 1685PyDoc_STRVAR(listen_doc, 1686"listen(backlog)\n\ 1687\n\ 1688Enable a server to accept connections. The backlog argument must be at\n\ 1689least 1; it specifies the number of unaccepted connection that the system\n\ 1690will allow before refusing new connections."); 1691 1692 1693#ifndef NO_DUP 1694/* s.makefile(mode) method. 1695 Create a new open file object referring to a dupped version of 1696 the socket's file descriptor. (The dup() call is necessary so 1697 that the open file and socket objects may be closed independent 1698 of each other.) 1699 The mode argument specifies 'r' or 'w' passed to fdopen(). */ 1700 1701static PyObject * 1702sock_makefile(PySocketSockObject *s, PyObject *args) 1703{ 1704 extern int fclose(FILE *); 1705 char *mode = "r"; 1706 int bufsize = -1; 1707#ifdef MS_WIN32 1708 Py_intptr_t fd; 1709#else 1710 int fd; 1711#endif 1712 FILE *fp; 1713 PyObject *f; 1714#ifdef __VMS 1715 char *mode_r = "r"; 1716 char *mode_w = "w"; 1717#endif 1718 1719 if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize)) 1720 return NULL; 1721#ifdef __VMS 1722 if (strcmp(mode,"rb") == 0) { 1723 mode = mode_r; 1724 } 1725 else { 1726 if (strcmp(mode,"wb") == 0) { 1727 mode = mode_w; 1728 } 1729 } 1730#endif 1731#ifdef MS_WIN32 1732 if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) || 1733 ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL)) 1734#else 1735 if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL) 1736#endif 1737 { 1738 if (fd >= 0) 1739 SOCKETCLOSE(fd); 1740 return s->errorhandler(); 1741 } 1742#ifdef USE_GUSI2 1743 /* Workaround for bug in Metrowerks MSL vs. GUSI I/O library */ 1744 if (strchr(mode, 'b') != NULL) 1745 bufsize = 0; 1746#endif 1747 f = PyFile_FromFile(fp, "<socket>", mode, fclose); 1748 if (f != NULL) 1749 PyFile_SetBufSize(f, bufsize); 1750 return f; 1751} 1752 1753PyDoc_STRVAR(makefile_doc, 1754"makefile([mode[, buffersize]]) -> file object\n\ 1755\n\ 1756Return a regular file object corresponding to the socket.\n\ 1757The mode and buffersize arguments are as for the built-in open() function."); 1758 1759#endif /* NO_DUP */ 1760 1761 1762/* s.recv(nbytes [,flags]) method */ 1763 1764static PyObject * 1765sock_recv(PySocketSockObject *s, PyObject *args) 1766{ 1767 int len, n = 0, flags = 0, timeout; 1768 PyObject *buf; 1769#ifdef __VMS 1770 int read_length; 1771 char *read_buf; 1772#endif 1773 1774 if (!PyArg_ParseTuple(args, "i|i:recv", &len, &flags)) 1775 return NULL; 1776 1777 if (len < 0) { 1778 PyErr_SetString(PyExc_ValueError, 1779 "negative buffersize in recv"); 1780 return NULL; 1781 } 1782 1783 buf = PyString_FromStringAndSize((char *) 0, len); 1784 if (buf == NULL) 1785 return NULL; 1786 1787#ifndef __VMS 1788 Py_BEGIN_ALLOW_THREADS 1789 timeout = internal_select(s, 0); 1790 if (!timeout) 1791 n = recv(s->sock_fd, PyString_AS_STRING(buf), len, flags); 1792 Py_END_ALLOW_THREADS 1793 1794 if (timeout) { 1795 Py_DECREF(buf); 1796 PyErr_SetString(socket_timeout, "timed out"); 1797 return NULL; 1798 } 1799 if (n < 0) { 1800 Py_DECREF(buf); 1801 return s->errorhandler(); 1802 } 1803 if (n != len) 1804 _PyString_Resize(&buf, n); 1805#else 1806 read_buf = PyString_AsString(buf); 1807 read_length = len; 1808 while (read_length != 0) { 1809 unsigned int segment; 1810 1811 segment = read_length /SEGMENT_SIZE; 1812 if (segment != 0) { 1813 segment = SEGMENT_SIZE; 1814 } 1815 else { 1816 segment = read_length; 1817 } 1818 1819 Py_BEGIN_ALLOW_THREADS 1820 timeout = internal_select(s, 0); 1821 if (!timeout) 1822 n = recv(s->sock_fd, read_buf, segment, flags); 1823 Py_END_ALLOW_THREADS 1824 1825 if (timeout) { 1826 Py_DECREF(buf); 1827 PyErr_SetString(socket_timeout, "timed out"); 1828 return NULL; 1829 } 1830 if (n < 0) { 1831 Py_DECREF(buf); 1832 return s->errorhandler(); 1833 } 1834 if (n != read_length) { 1835 read_buf += n; 1836 break; 1837 } 1838 1839 read_length -= segment; 1840 read_buf += segment; 1841 } 1842 if (_PyString_Resize(&buf, (read_buf - PyString_AsString(buf))) < 0) 1843 { 1844 return NULL; 1845 } 1846#endif /* !__VMS */ 1847 return buf; 1848} 1849 1850PyDoc_STRVAR(recv_doc, 1851"recv(buffersize[, flags]) -> data\n\ 1852\n\ 1853Receive up to buffersize bytes from the socket. For the optional flags\n\ 1854argument, see the Unix manual. When no data is available, block until\n\ 1855at least one byte is available or until the remote end is closed. When\n\ 1856the remote end is closed and all data is read, return the empty string."); 1857 1858 1859/* s.recvfrom(nbytes [,flags]) method */ 1860 1861static PyObject * 1862sock_recvfrom(PySocketSockObject *s, PyObject *args) 1863{ 1864 char addrbuf[256]; 1865 PyObject *buf = NULL; 1866 PyObject *addr = NULL; 1867 PyObject *ret = NULL; 1868 int len, n = 0, flags = 0, timeout; 1869 socklen_t addrlen; 1870 1871 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &len, &flags)) 1872 return NULL; 1873 1874 if (!getsockaddrlen(s, &addrlen)) 1875 return NULL; 1876 buf = PyString_FromStringAndSize((char *) 0, len); 1877 if (buf == NULL) 1878 return NULL; 1879 1880 Py_BEGIN_ALLOW_THREADS 1881 memset(addrbuf, 0, addrlen); 1882 timeout = internal_select(s, 0); 1883 if (!timeout) 1884 n = recvfrom(s->sock_fd, PyString_AS_STRING(buf), len, flags, 1885#ifndef MS_WINDOWS 1886#if defined(PYOS_OS2) && !defined(PYCC_GCC) 1887 (struct sockaddr *)addrbuf, &addrlen 1888#else 1889 (void *)addrbuf, &addrlen 1890#endif 1891#else 1892 (struct sockaddr *)addrbuf, &addrlen 1893#endif 1894 ); 1895 Py_END_ALLOW_THREADS 1896 1897 if (timeout) { 1898 Py_DECREF(buf); 1899 PyErr_SetString(socket_timeout, "timed out"); 1900 return NULL; 1901 } 1902 if (n < 0) { 1903 Py_DECREF(buf); 1904 return s->errorhandler(); 1905 } 1906 1907 if (n != len && _PyString_Resize(&buf, n) < 0) 1908 return NULL; 1909 1910 if (!(addr = makesockaddr(s->sock_fd, (struct sockaddr *)addrbuf, 1911 addrlen))) 1912 goto finally; 1913 1914 ret = Py_BuildValue("OO", buf, addr); 1915 1916f…
Large files files are truncated, but you can click here to view the full file