Modules/socketmodule.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 /* Socket module */
  26
  27 /*
  28 This module provides an interface to Berkeley socket IPC.
  29
  30 Limitations:
  31
  32 - only AF_INET and AF_UNIX address families are supported
  33 - no asynchronous I/O (but you can use select() on sockets)
  34 - no read/write operations (use send/recv or makefile instead)
  35 - setsockopt() and getsockopt() only support integer options
  36
  37 Interface:
  38
  39 - socket.gethostname() --> host name (string)
  40 - socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
  41 - socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
  42 - socket.getservbyname(servername, protocolname) --> port number
  43 - socket.socket(family, type [, proto]) --> new socket object
  44 - family and type constants from <socket.h> are accessed as socket.AF_INET etc.
  45 - errors are reported as the exception socket.error
  46 - an Internet socket address is a pair (hostname, port)
  47   where hostname can be anything recognized by gethostbyname()
  48   (including the dd.dd.dd.dd notation) and port is in host byte order
  49 - where a hostname is returned, the dd.dd.dd.dd notation is used
  50 - a UNIX domain socket is a string specifying the pathname
  51
  52 Socket methods:
  53
  54 - s.accept() --> new socket object, sockaddr
  55 - s.setsockopt(level, optname, flag) --> Py_None
  56 - s.getsockopt(level, optname) --> flag
  57 - s.bind(sockaddr) --> Py_None
  58 - s.connect(sockaddr) --> Py_None
  59 - s.getsockname() --> sockaddr
  60 - s.getpeername() --> sockaddr
  61 - s.listen(n) --> Py_None
  62 - s.makefile(mode) --> file object
  63 - s.recv(nbytes [,flags]) --> string
  64 - s.recvfrom(nbytes [,flags]) --> string, sockaddr
  65 - s.send(string [,flags]) --> nbytes
  66 - s.sendto(string, [flags,] sockaddr) --> nbytes
  67 - s.setblocking(1 | 0) --> Py_None
  68 - s.shutdown(how) --> Py_None
  69 - s.close() --> Py_None
  70 - repr(s) --> "<socket object, fd=%d, family=%d, type=%d, protocol=%d>"
  71
  72 */
  73
  74 #include "Python.h"
  75
  76 #include <sys/types.h>
  77 #include "mytime.h"
  78
  79 #include <signal.h>
  80 #ifndef NT
  81 #include <netdb.h>
  82 #include <sys/socket.h>
  83 #include <netinet/in.h>
  84 #include <fcntl.h>
  85 #else
  86 #include <winsock.h>
  87 #endif
  88 #ifdef HAVE_SYS_UN_H
  89 #include <sys/un.h>
  90 #else
  91 #undef AF_UNIX
  92 #endif
  93
  94 #ifndef O_NDELAY
  95 #define O_NDELAY O_NONBLOCK     /* For QNX only? */
  96 #endif
  97
  98
  99 /* Here we have some hacks to choose between K&R or ANSI style function
 100    definitions.  For NT to build this as an extension module (ie, DLL)
 101    it must be compiled by the C++ compiler, as it takes the address of
 102    a static data item exported from the main Python DLL.
 103 */
 104 #ifdef NT
 105 /* seem to be a few differences in the API */
 106 #define close closesocket
 107 #define NO_DUP  /* I wont trust passing a socket to NT's RTL!!  */
 108 #define FORCE_ANSI_FUNC_DEFS
 109 #endif
 110
 111 #ifdef FORCE_ANSI_FUNC_DEFS
 112 #define BUILD_FUNC_DEF_1( fnname, arg1type, arg1name )  \
 113 fnname( arg1type arg1name )
 114
 115 #define BUILD_FUNC_DEF_2( fnname, arg1type, arg1name, arg2type, arg2name ) \
 116 fnname( arg1type arg1name, arg2type arg2name )
 117
 118 #define BUILD_FUNC_DEF_3( fnname, arg1type, arg1name, arg2type, arg2name , arg3type, arg3name ) \
 119 fnname( arg1type arg1name, arg2type arg2name, arg3type arg3name )
 120
 121 #define BUILD_FUNC_DEF_4( fnname, arg1type, arg1name, arg2type, arg2name , arg3type, arg3name, arg4type, arg4name )     \
 122 fnname( arg1type arg1name, arg2type arg2name, arg3type arg3name, arg4type arg4name )
 123
 124 #else /* !FORCE_ANSI_FN_DEFS */
 125 #define BUILD_FUNC_DEF_1( fnname, arg1type, arg1name )  \
 126 fnname( arg1name )      \
 127         arg1type arg1name;
 128
 129 #define BUILD_FUNC_DEF_2( fnname, arg1type, arg1name, arg2type, arg2name ) \
 130 fnname( arg1name, arg2name )    \
 131         arg1type arg1name;      \
 132         arg2type arg2name;
 133
 134 #define BUILD_FUNC_DEF_3( fnname, arg1type, arg1name, arg2type, arg2name, arg3type, arg3name ) \
 135 fnname( arg1name, arg2name, arg3name )  \
 136         arg1type arg1name;      \
 137         arg2type arg2name;      \
 138         arg3type arg3name;
 139
 140 #define BUILD_FUNC_DEF_4( fnname, arg1type, arg1name, arg2type, arg2name, arg3type, arg3name, arg4type, arg4name ) \
 141 fnname( arg1name, arg2name, arg3name, arg4name )        \
 142         arg1type arg1name;      \
 143         arg2type arg2name;      \
 144         arg3type arg3name;      \
 145         arg4type arg4name;
 146
 147 #endif /* !FORCE_ANSI_FN_DEFS */
 148
 149 /* Global variable holding the exception type for errors detected
 150    by this module (but not argument type or memory errors, etc.). */
 151
 152 static PyObject *PySocket_Error;
 153
 154
 155 /* Convenience function to raise an error according to errno
 156    and return a NULL pointer from a function. */
 157
 158 static PyObject *
 159 PySocket_Err()
 160 {
 161 #ifdef NT
 162         if (WSAGetLastError()) {
 163                 PyObject *v;
 164                 v = Py_BuildValue("(is)", WSAGetLastError(), "winsock error");
 165                 if (v != NULL) {
 166                         PyErr_SetObject(PySocket_Error, v);
 167                         Py_DECREF(v);
 168                 }
 169                 return NULL;
 170         }
 171         else
 172 #endif
 173         return PyErr_SetFromErrno(PySocket_Error);
 174 }
 175
 176
 177 /* The object holding a socket.  It holds some extra information,
 178    like the address family, which is used to decode socket address
 179    arguments properly. */
 180
 181 typedef struct {
 182         PyObject_HEAD
 183         int sock_fd;            /* Socket file descriptor */
 184         int sock_family;        /* Address family, e.g., AF_INET */
 185         int sock_type;          /* Socket type, e.g., SOCK_STREAM */
 186         int sock_proto;         /* Protocol type, usually 0 */
 187         union sock_addr {
 188                 struct sockaddr_in in;
 189 #ifdef AF_UNIX
 190                 struct sockaddr_un un;
 191 #endif
 192         } sock_addr;
 193 } PySocketSockObject;
 194
 195
 196 /* A forward reference to the Socktype type object.
 197    The Socktype variable contains pointers to various functions,
 198    some of which call newsockobject(), which uses Socktype, so
 199    there has to be a circular reference. */
 200
 201 staticforward PyTypeObject PySocketSock_Type;
 202
 203
 204 /* Create a new socket object.
 205    This just creates the object and initializes it.
 206    If the creation fails, return NULL and set an exception (implicit
 207    in NEWOBJ()). */
 208
 209 static PySocketSockObject *
 210 BUILD_FUNC_DEF_4(PySocketSock_New,int,fd, int,family, int,type, int,proto)
 211 {
 212         PySocketSockObject *s;
 213         s = PyObject_NEW(PySocketSockObject, &PySocketSock_Type);
 214         if (s != NULL) {
 215                 s->sock_fd = fd;
 216                 s->sock_family = family;
 217                 s->sock_type = type;
 218                 s->sock_proto = proto;
 219         }
 220         return s;
 221 }
 222
 223
 224 /* Convert a string specifying a host name or one of a few symbolic
 225    names to a numeric IP address.  This usually calls gethostbyname()
 226    to do the work; the names "" and "<broadcast>" are special.
 227    Return the length (should always be 4 bytes), or negative if
 228    an error occurred; then an exception is raised. */
 229
 230 static int
 231 BUILD_FUNC_DEF_2(setipaddr, char*,name, struct sockaddr_in *,addr_ret)
 232 {
 233         struct hostent *hp;
 234         int d1, d2, d3, d4;
 235         char ch;
 236 #ifdef HAVE_GETHOSTBYNAME_R
 237         struct hostent hp_allocated;
 238         char buf[1001];
 239         int buf_len = (sizeof buf) - 1;
 240         int errnop;
 241 #endif /* HAVE_GETHOSTBYNAME_R */
 242
 243         if (name[0] == '\0') {
 244                 addr_ret->sin_addr.s_addr = INADDR_ANY;
 245                 return 4;
 246         }
 247         if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
 248                 addr_ret->sin_addr.s_addr = INADDR_BROADCAST;
 249                 return 4;
 250         }
 251         if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
 252             0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
 253             0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
 254                 addr_ret->sin_addr.s_addr = htonl(
 255                         ((long) d1 << 24) | ((long) d2 << 16) |
 256                         ((long) d3 << 8) | ((long) d4 << 0));
 257                 return 4;
 258         }
 259 #ifdef HAVE_GETHOSTBYNAME_R
 260         Py_BEGIN_ALLOW_THREADS
 261         hp = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
 262         Py_END_ALLOW_THREADS
 263 #else /* not HAVE_GETHOSTBYNAME_R */
 264         hp = gethostbyname(name);
 265 #endif /* HAVE_GETHOSTBYNAME_R */
 266
 267         if (hp == NULL) {
 268 #ifdef HAVE_HSTRERROR
 269                 /* Let's get real error message to return */
 270                 extern int h_errno;
 271                 PyErr_SetString(PySocket_Error, (char *)hstrerror(h_errno));
 272 #else
 273                 PyErr_SetString(PySocket_Error, "host not found");
 274 #endif
 275                 return -1;
 276         }
 277         memcpy((char *) &addr_ret->sin_addr, hp->h_addr, hp->h_length);
 278         return hp->h_length;
 279 }
 280
 281
 282 /* Create a string object representing an IP address.
 283    This is always a string of the form 'dd.dd.dd.dd' (with variable
 284    size numbers). */
 285
 286 static PyObject *
 287 BUILD_FUNC_DEF_1(makeipaddr, struct sockaddr_in *,addr)
 288 {
 289         long x = ntohl(addr->sin_addr.s_addr);
 290         char buf[100];
 291         sprintf(buf, "%d.%d.%d.%d",
 292                 (int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
 293                 (int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
 294         return PyString_FromString(buf);
 295 }
 296
 297
 298 /* Create an object representing the given socket address,
 299    suitable for passing it back to bind(), connect() etc.
 300    The family field of the sockaddr structure is inspected
 301    to determine what kind of address it really is. */
 302
 303 /*ARGSUSED*/
 304 static PyObject *
 305 BUILD_FUNC_DEF_2(makesockaddr,struct sockaddr *,addr, int,addrlen)
 306 {
 307         if (addrlen == 0) {
 308                 /* No address -- may be recvfrom() from known socket */
 309                 Py_INCREF(Py_None);
 310                 return Py_None;
 311         }
 312
 313         switch (addr->sa_family) {
 314
 315         case AF_INET:
 316         {
 317                 struct sockaddr_in *a = (struct sockaddr_in *) addr;
 318                 PyObject *addr = makeipaddr(a);
 319                 PyObject *ret = Py_BuildValue("Oi", addr, ntohs(a->sin_port));
 320                 Py_XDECREF(addr);
 321                 return ret;
 322         }
 323
 324 #ifdef AF_UNIX
 325         case AF_UNIX:
 326         {
 327                 struct sockaddr_un *a = (struct sockaddr_un *) addr;
 328                 return PyString_FromString(a->sun_path);
 329         }
 330 #endif /* AF_UNIX */
 331
 332         /* More cases here... */
 333
 334         default:
 335                 PyErr_SetString(PySocket_Error, "return unknown socket address type");
 336                 return NULL;
 337
 338         }
 339 }
 340
 341
 342 /* Parse a socket address argument according to the socket object's
 343    address family.  Return 1 if the address was in the proper format,
 344    0 of not.  The address is returned through addr_ret, its length
 345    through len_ret. */
 346
 347 static int
 348 BUILD_FUNC_DEF_4(
 349 getsockaddrarg,PySocketSockObject *,s, PyObject *,args, struct sockaddr **,addr_ret, int *,len_ret)
 350 {
 351         switch (s->sock_family) {
 352
 353 #ifdef AF_UNIX
 354         case AF_UNIX:
 355         {
 356                 struct sockaddr_un* addr;
 357                 char *path;
 358                 int len;
 359                 addr = (struct sockaddr_un* )&(s->sock_addr).un;
 360                 if (!PyArg_Parse(args, "s#", &path, &len))
 361                         return 0;
 362                 if (len > sizeof addr->sun_path) {
 363                         PyErr_SetString(PySocket_Error, "AF_UNIX path too long");
 364                         return 0;
 365                 }
 366                 addr->sun_family = AF_UNIX;
 367                 memcpy(addr->sun_path, path, len);
 368                 *addr_ret = (struct sockaddr *) addr;
 369                 *len_ret = len + sizeof addr->sun_family;
 370                 return 1;
 371         }
 372 #endif /* AF_UNIX */
 373
 374         case AF_INET:
 375         {
 376                 struct sockaddr_in* addr;
 377                 char *host;
 378                 int port;
 379                 addr=(struct sockaddr_in*)&(s->sock_addr).in;
 380                 if (!PyArg_Parse(args, "(si)", &host, &port))
 381                         return 0;
 382                 if (setipaddr(host, addr) < 0)
 383                         return 0;
 384                 addr->sin_family = AF_INET;
 385                 addr->sin_port = htons(port);
 386                 *addr_ret = (struct sockaddr *) addr;
 387                 *len_ret = sizeof *addr;
 388                 return 1;
 389         }
 390
 391         /* More cases here... */
 392
 393         default:
 394                 PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
 395                 return 0;
 396
 397         }
 398 }
 399
 400
 401 /* Get the address length according to the socket object's address family.
 402    Return 1 if the family is known, 0 otherwise.  The length is returned
 403    through len_ret. */
 404
 405 static int
 406 BUILD_FUNC_DEF_2(getsockaddrlen,PySocketSockObject *,s, int *,len_ret)
 407 {
 408         switch (s->sock_family) {
 409
 410 #ifdef AF_UNIX
 411         case AF_UNIX:
 412         {
 413                 *len_ret = sizeof (struct sockaddr_un);
 414                 return 1;
 415         }
 416 #endif /* AF_UNIX */
 417
 418         case AF_INET:
 419         {
 420                 *len_ret = sizeof (struct sockaddr_in);
 421                 return 1;
 422         }
 423
 424         /* More cases here... */
 425
 426         default:
 427                 PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
 428                 return 0;
 429
 430         }
 431 }
 432
 433
 434 /* s.accept() method */
 435
 436 static PyObject *
 437 BUILD_FUNC_DEF_2(PySocketSock_accept,PySocketSockObject *,s, PyObject *,args)
 438 {
 439         char addrbuf[256];
 440         int addrlen, newfd;
 441         PyObject *sock, *addr, *res;
 442         if (!PyArg_NoArgs(args))
 443                 return NULL;
 444         if (!getsockaddrlen(s, &addrlen))
 445                 return NULL;
 446         Py_BEGIN_ALLOW_THREADS
 447         newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 448         Py_END_ALLOW_THREADS
 449         if (newfd < 0)
 450                 return PySocket_Err();
 451         /* Create the new object with unspecified family,
 452            to avoid calls to bind() etc. on it. */
 453         sock = (PyObject *) PySocketSock_New(newfd,
 454                                         s->sock_family,
 455                                         s->sock_type,
 456                                         s->sock_proto);
 457         if (sock == NULL)
 458                 close(newfd);
 459         addr = makesockaddr((struct sockaddr *) addrbuf, addrlen);
 460         res = Py_BuildValue("OO", sock, addr);
 461         Py_XDECREF(sock);
 462         Py_XDECREF(addr);
 463         return res;
 464 }
 465
 466
 467 #if 0
 468 /* s.allowbroadcast() method */
 469 /* XXX obsolete -- will disappear in next release */
 470
 471 static PyObject *
 472 BUILD_FUNC_DEF_2(PySocketSock_allowbroadcast,PySocketSockObject *,s, PyObject *,args)
 473 {
 474         int flag;
 475         int res;
 476         if (!PyArg_Parse(args, "i", &flag))
 477                 return NULL;
 478         res = setsockopt(s->sock_fd, SOL_SOCKET, SO_BROADCAST,
 479                          (ANY *)&flag, sizeof flag);
 480         if (res < 0)
 481                 return PySocket_Err();
 482         Py_INCREF(Py_None);
 483         return Py_None;
 484 }
 485 #endif
 486
 487
 488 #ifndef NT
 489
 490 /* s.setblocking(1 | 0) method */
 491
 492 static PyObject *
 493 PySocketSock_setblocking(s, args)
 494         PySocketSockObject *s;
 495         PyObject *args;
 496 {
 497         int block;
 498         int delay_flag;
 499         if (!PyArg_GetInt(args, &block))
 500                 return NULL;
 501         Py_BEGIN_ALLOW_THREADS
 502         delay_flag = fcntl (s->sock_fd, F_GETFL, 0);
 503         if (block)
 504                 delay_flag &= (~O_NDELAY);
 505         else
 506                 delay_flag |= O_NDELAY;
 507         fcntl (s->sock_fd, F_SETFL, delay_flag);
 508         Py_END_ALLOW_THREADS
 509
 510         Py_INCREF(Py_None);
 511         return Py_None;
 512 }
 513 #endif
 514
 515
 516 /* s.setsockopt() method.
 517    With an integer third argument, sets an integer option.
 518    With a string third argument, sets an option from a buffer;
 519    use optional built-in module 'struct' to encode the string. */
 520
 521 static PyObject *
 522 BUILD_FUNC_DEF_2(PySocketSock_setsockopt,PySocketSockObject *,s, PyObject *,args)
 523 {
 524         int level;
 525         int optname;
 526         int res;
 527         char *buf;
 528         int buflen;
 529         int flag;
 530
 531         if (PyArg_Parse(args, "(iii)", &level, &optname, &flag)) {
 532                 buf = (char *) &flag;
 533                 buflen = sizeof flag;
 534         }
 535         else {
 536                 PyErr_Clear();
 537                 if (!PyArg_Parse(args, "(iis#)", &level, &optname, &buf, &buflen))
 538                         return NULL;
 539         }
 540         res = setsockopt(s->sock_fd, level, optname, (ANY *)buf, buflen);
 541         if (res < 0)
 542                 return PySocket_Err();
 543         Py_INCREF(Py_None);
 544         return Py_None;
 545 }
 546
 547
 548 /* s.getsockopt() method.
 549    With two arguments, retrieves an integer option.
 550    With a third integer argument, retrieves a string buffer of that size;
 551    use optional built-in module 'struct' to decode the string. */
 552
 553 static PyObject *
 554 BUILD_FUNC_DEF_2(PySocketSock_getsockopt,PySocketSockObject *,s, PyObject *,args)
 555 {
 556         int level;
 557         int optname;
 558         int res;
 559         PyObject *buf;
 560         int buflen;
 561         int flag;
 562
 563         if (PyArg_Parse(args, "(ii)", &level, &optname)) {
 564                 int flag = 0;
 565                 int flagsize = sizeof flag;
 566                 res = getsockopt(s->sock_fd, level, optname,
 567                                  (ANY *)&flag, &flagsize);
 568                 if (res < 0)
 569                         return PySocket_Err();
 570                 return PyInt_FromLong(flag);
 571         }
 572         PyErr_Clear();
 573         if (!PyArg_Parse(args, "(iii)", &level, &optname, &buflen))
 574                 return NULL;
 575         if (buflen <= 0 || buflen > 1024) {
 576                 PyErr_SetString(PySocket_Error, "getsockopt buflen out of range");
 577                 return NULL;
 578         }
 579         buf = PyString_FromStringAndSize((char *)NULL, buflen);
 580         if (buf == NULL)
 581                 return NULL;
 582         res = getsockopt(s->sock_fd, level, optname,
 583                          (ANY *)PyString_AsString(buf), &buflen);
 584         if (res < 0) {
 585                 Py_DECREF(buf);
 586                 return PySocket_Err();
 587         }
 588         _PyString_Resize(&buf, buflen);
 589         return buf;
 590 }
 591
 592
 593 /* s.bind(sockaddr) method */
 594
 595 static PyObject *
 596 BUILD_FUNC_DEF_2(PySocketSock_bind,PySocketSockObject *,s, PyObject *,args)
 597 {
 598         struct sockaddr *addr;
 599         int addrlen;
 600         int res;
 601         if (!getsockaddrarg(s, args, &addr, &addrlen))
 602                 return NULL;
 603         Py_BEGIN_ALLOW_THREADS
 604         res = bind(s->sock_fd, addr, addrlen);
 605         Py_END_ALLOW_THREADS
 606         if (res < 0)
 607                 return PySocket_Err();
 608         Py_INCREF(Py_None);
 609         return Py_None;
 610 }
 611
 612
 613 /* s.close() method.
 614    Set the file descriptor to -1 so operations tried subsequently
 615    will surely fail. */
 616
 617 static PyObject *
 618 BUILD_FUNC_DEF_2(PySocketSock_close,PySocketSockObject *,s, PyObject *,args)
 619 {
 620         if (!PyArg_NoArgs(args))
 621                 return NULL;
 622         Py_BEGIN_ALLOW_THREADS
 623         (void) close(s->sock_fd);
 624         Py_END_ALLOW_THREADS
 625         s->sock_fd = -1;
 626         Py_INCREF(Py_None);
 627         return Py_None;
 628 }
 629
 630
 631 /* s.connect(sockaddr) method */
 632
 633 static PyObject *
 634 BUILD_FUNC_DEF_2(PySocketSock_connect,PySocketSockObject *,s, PyObject *,args)
 635 {
 636         struct sockaddr *addr;
 637         int addrlen;
 638         int res;
 639         if (!getsockaddrarg(s, args, &addr, &addrlen))
 640                 return NULL;
 641         Py_BEGIN_ALLOW_THREADS
 642         res = connect(s->sock_fd, addr, addrlen);
 643         Py_END_ALLOW_THREADS
 644         if (res < 0)
 645                 return PySocket_Err();
 646         Py_INCREF(Py_None);
 647         return Py_None;
 648 }
 649
 650
 651 /* s.fileno() method */
 652
 653 static PyObject *
 654 BUILD_FUNC_DEF_2(PySocketSock_fileno,PySocketSockObject *,s, PyObject *,args)
 655 {
 656         if (!PyArg_NoArgs(args))
 657                 return NULL;
 658         return PyInt_FromLong((long) s->sock_fd);
 659 }
 660
 661
 662 /* s.getsockname() method */
 663
 664 static PyObject *
 665 BUILD_FUNC_DEF_2(PySocketSock_getsockname,PySocketSockObject *,s, PyObject *,args)
 666 {
 667         char addrbuf[256];
 668         int addrlen, res;
 669         if (!PyArg_NoArgs(args))
 670                 return NULL;
 671         if (!getsockaddrlen(s, &addrlen))
 672                 return NULL;
 673         Py_BEGIN_ALLOW_THREADS
 674         res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 675         Py_END_ALLOW_THREADS
 676         if (res < 0)
 677                 return PySocket_Err();
 678         return makesockaddr((struct sockaddr *) addrbuf, addrlen);
 679 }
 680
 681
 682 #ifdef HAVE_GETPEERNAME         /* Cray APP doesn't have this :-( */
 683 /* s.getpeername() method */
 684
 685 static PyObject *
 686 BUILD_FUNC_DEF_2(PySocketSock_getpeername,PySocketSockObject *,s, PyObject *,args)
 687 {
 688         char addrbuf[256];
 689         int addrlen, res;
 690         if (!PyArg_NoArgs(args))
 691                 return NULL;
 692         if (!getsockaddrlen(s, &addrlen))
 693                 return NULL;
 694         Py_BEGIN_ALLOW_THREADS
 695         res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 696         Py_END_ALLOW_THREADS
 697         if (res < 0)
 698                 return PySocket_Err();
 699         return makesockaddr((struct sockaddr *) addrbuf, addrlen);
 700 }
 701 #endif /* HAVE_GETPEERNAME */
 702
 703
 704 /* s.listen(n) method */
 705
 706 static PyObject *
 707 BUILD_FUNC_DEF_2(PySocketSock_listen,PySocketSockObject *,s, PyObject *,args)
 708 {
 709         int backlog;
 710         int res;
 711         if (!PyArg_GetInt(args, &backlog))
 712                 return NULL;
 713         Py_BEGIN_ALLOW_THREADS
 714         if (backlog < 1)
 715                 backlog = 1;
 716         res = listen(s->sock_fd, backlog);
 717         Py_END_ALLOW_THREADS
 718         if (res < 0)
 719                 return PySocket_Err();
 720         Py_INCREF(Py_None);
 721         return Py_None;
 722 }
 723
 724 #ifndef NO_DUP
 725 /* s.makefile(mode) method.
 726    Create a new open file object referring to a dupped version of
 727    the socket's file descriptor.  (The dup() call is necessary so
 728    that the open file and socket objects may be closed independent
 729    of each other.)
 730    The mode argument specifies 'r' or 'w' passed to fdopen(). */
 731
 732 static PyObject *
 733 BUILD_FUNC_DEF_2(PySocketSock_makefile,PySocketSockObject *,s, PyObject *,args)
 734 {
 735         extern int fclose Py_PROTO((FILE *));
 736         char *mode;
 737         int fd;
 738         FILE *fp;
 739         if (!PyArg_Parse(args, "s", &mode))
 740                 return NULL;
 741         if ((fd = dup(s->sock_fd)) < 0 ||
 742             (fp = fdopen(fd, mode)) == NULL)
 743                 return PySocket_Err();
 744         return PyFile_FromFile(fp, "<socket>", mode, fclose);
 745 }
 746 #endif /* NO_DUP */
 747
 748 /* s.recv(nbytes [,flags]) method */
 749
 750 static PyObject *
 751 BUILD_FUNC_DEF_2(PySocketSock_recv,PySocketSockObject *,s, PyObject *,args)
 752 {
 753         int len, n, flags;
 754         PyObject *buf;
 755         flags = 0;
 756         if (!PyArg_Parse(args, "i", &len)) {
 757                 PyErr_Clear();
 758                 if (!PyArg_Parse(args, "(ii)", &len, &flags))
 759                         return NULL;
 760         }
 761         buf = PyString_FromStringAndSize((char *) 0, len);
 762         if (buf == NULL)
 763                 return NULL;
 764         Py_BEGIN_ALLOW_THREADS
 765         n = recv(s->sock_fd, PyString_AsString(buf), len, flags);
 766         Py_END_ALLOW_THREADS
 767         if (n < 0)
 768                 return PySocket_Err();
 769         if (_PyString_Resize(&buf, n) < 0)
 770                 return NULL;
 771         return buf;
 772 }
 773
 774
 775 /* s.recvfrom(nbytes [,flags]) method */
 776
 777 static PyObject *
 778 BUILD_FUNC_DEF_2(PySocketSock_recvfrom,PySocketSockObject *,s, PyObject *,args)
 779 {
 780         char addrbuf[256];
 781         PyObject *buf, *addr, *ret;
 782         int addrlen, len, n, flags;
 783         flags = 0;
 784         if (!PyArg_Parse(args, "i", &len)) {
 785                 PyErr_Clear();
 786                 if (!PyArg_Parse(args, "(ii)", &len, &flags))
 787                     return NULL;
 788         }
 789         if (!getsockaddrlen(s, &addrlen))
 790                 return NULL;
 791         buf = PyString_FromStringAndSize((char *) 0, len);
 792         if (buf == NULL)
 793                 return NULL;
 794         Py_BEGIN_ALLOW_THREADS
 795         n = recvfrom(s->sock_fd, PyString_AsString(buf), len, flags,
 796 #ifndef NT
 797                      (ANY *)addrbuf, &addrlen);
 798 #else
 799                      (struct sockaddr *)addrbuf, &addrlen);
 800 #endif
 801         Py_END_ALLOW_THREADS
 802         if (n < 0)
 803                 return PySocket_Err();
 804         if (_PyString_Resize(&buf, n) < 0)
 805                 return NULL;
 806         addr = makesockaddr((struct sockaddr *)addrbuf, addrlen);
 807         ret = Py_BuildValue("OO", buf, addr);
 808         Py_XDECREF(addr);
 809         Py_XDECREF(buf);
 810         return ret;
 811 }
 812
 813
 814 /* s.send(data [,flags]) method */
 815
 816 static PyObject *
 817 BUILD_FUNC_DEF_2(PySocketSock_send,PySocketSockObject *,s, PyObject *,args)
 818 {
 819         char *buf;
 820         int len, n, flags;
 821         flags = 0;
 822         if (!PyArg_Parse(args, "s#", &buf, &len)) {
 823                 PyErr_Clear();
 824                 if (!PyArg_Parse(args, "(s#i)", &buf, &len, &flags))
 825                         return NULL;
 826         }
 827         Py_BEGIN_ALLOW_THREADS
 828         n = send(s->sock_fd, buf, len, flags);
 829         Py_END_ALLOW_THREADS
 830         if (n < 0)
 831                 return PySocket_Err();
 832         return PyInt_FromLong((long)n);
 833 }
 834
 835
 836 /* s.sendto(data, [flags,] sockaddr) method */
 837
 838 static PyObject *
 839 BUILD_FUNC_DEF_2(PySocketSock_sendto,PySocketSockObject *,s, PyObject *,args)
 840 {
 841         PyObject *addro;
 842         char *buf;
 843         struct sockaddr *addr;
 844         int addrlen, len, n, flags;
 845         flags = 0;
 846         if (!PyArg_Parse(args, "(s#O)", &buf, &len, &addro)) {
 847                 PyErr_Clear();
 848                 if (!PyArg_Parse(args, "(s#iO)", &buf, &len, &flags, &addro))
 849                         return NULL;
 850         }
 851         if (!getsockaddrarg(s, addro, &addr, &addrlen))
 852                 return NULL;
 853         Py_BEGIN_ALLOW_THREADS
 854         n = sendto(s->sock_fd, buf, len, flags, addr, addrlen);
 855         Py_END_ALLOW_THREADS
 856         if (n < 0)
 857                 return PySocket_Err();
 858         return PyInt_FromLong((long)n);
 859 }
 860
 861
 862 /* s.shutdown(how) method */
 863
 864 static PyObject *
 865 BUILD_FUNC_DEF_2(PySocketSock_shutdown,PySocketSockObject *,s, PyObject *,args)
 866 {
 867         int how;
 868         int res;
 869         if (!PyArg_GetInt(args, &how))
 870                 return NULL;
 871         Py_BEGIN_ALLOW_THREADS
 872         res = shutdown(s->sock_fd, how);
 873         Py_END_ALLOW_THREADS
 874         if (res < 0)
 875                 return PySocket_Err();
 876         Py_INCREF(Py_None);
 877         return Py_None;
 878 }
 879
 880
 881 /* List of methods for socket objects */
 882
 883 static PyMethodDef PySocketSock_methods[] = {
 884         {"accept",              (PyCFunction)PySocketSock_accept},
 885 #if 0
 886         {"allowbroadcast",      (PyCFunction)PySocketSock_allowbroadcast},
 887 #endif
 888 #ifndef NT
 889         {"setblocking",         (PyCFunction)PySocketSock_setblocking},
 890 #endif
 891         {"setsockopt",          (PyCFunction)PySocketSock_setsockopt},
 892         {"getsockopt",          (PyCFunction)PySocketSock_getsockopt},
 893         {"bind",                (PyCFunction)PySocketSock_bind},
 894         {"close",               (PyCFunction)PySocketSock_close},
 895         {"connect",             (PyCFunction)PySocketSock_connect},
 896         {"fileno",              (PyCFunction)PySocketSock_fileno},
 897         {"getsockname",         (PyCFunction)PySocketSock_getsockname},
 898 #ifdef HAVE_GETPEERNAME
 899         {"getpeername",         (PyCFunction)PySocketSock_getpeername},
 900 #endif
 901         {"listen",              (PyCFunction)PySocketSock_listen},
 902 #ifndef NO_DUP
 903         {"makefile",            (PyCFunction)PySocketSock_makefile},
 904 #endif
 905         {"recv",                (PyCFunction)PySocketSock_recv},
 906         {"recvfrom",            (PyCFunction)PySocketSock_recvfrom},
 907         {"send",                (PyCFunction)PySocketSock_send},
 908         {"sendto",              (PyCFunction)PySocketSock_sendto},
 909         {"shutdown",            (PyCFunction)PySocketSock_shutdown},
 910         {NULL,                  NULL}           /* sentinel */
 911 };
 912
 913
 914 /* Deallocate a socket object in response to the last Py_DECREF().
 915    First close the file description. */
 916
 917 static void
 918 BUILD_FUNC_DEF_1(PySocketSock_dealloc,PySocketSockObject *,s)
 919 {
 920         (void) close(s->sock_fd);
 921         PyMem_DEL(s);
 922 }
 923
 924
 925 /* Return a socket object's named attribute. */
 926
 927 static PyObject *
 928 BUILD_FUNC_DEF_2(PySocketSock_getattr,PySocketSockObject *,s, char *,name)
 929 {
 930         return Py_FindMethod(PySocketSock_methods, (PyObject *) s, name);
 931 }
 932
 933
 934 static PyObject *
 935 BUILD_FUNC_DEF_1(PySocketSock_repr,PySocketSockObject *,s)
 936 {
 937         PyObject *addro;
 938         struct sockaddr *addr;
 939         char buf[512];
 940         PyObject *t, *comma, *v;
 941         int i, len;
 942         sprintf(buf,
 943                 "<socket object, fd=%d, family=%d, type=%d, protocol=%d>",
 944                 s->sock_fd, s->sock_family, s->sock_type, s->sock_proto);
 945         t = PyString_FromString(buf);
 946         return t;
 947 }
 948
 949
 950 /* Type object for socket objects. */
 951
 952 static PyTypeObject PySocketSock_Type = {
 953         PyObject_HEAD_INIT(&PyType_Type)
 954         0,
 955         "socket",
 956         sizeof(PySocketSockObject),
 957         0,
 958         (destructor)PySocketSock_dealloc, /*tp_dealloc*/
 959         0,              /*tp_print*/
 960         (getattrfunc)PySocketSock_getattr, /*tp_getattr*/
 961         0,              /*tp_setattr*/
 962         0,              /*tp_compare*/
 963         (reprfunc)PySocketSock_repr, /*tp_repr*/
 964         0,              /*tp_as_number*/
 965         0,              /*tp_as_sequence*/
 966         0,              /*tp_as_mapping*/
 967 };
 968
 969
 970 /* Python interface to gethostname(). */
 971
 972 /*ARGSUSED*/
 973 static PyObject *
 974 BUILD_FUNC_DEF_2(PySocket_gethostname,PyObject *,self, PyObject *,args)
 975 {
 976         char buf[1024];
 977         int res;
 978         if (!PyArg_NoArgs(args))
 979                 return NULL;
 980         Py_BEGIN_ALLOW_THREADS
 981         res = gethostname(buf, (int) sizeof buf - 1);
 982         Py_END_ALLOW_THREADS
 983         if (res < 0)
 984                 return PySocket_Err();
 985         buf[sizeof buf - 1] = '\0';
 986         return PyString_FromString(buf);
 987 }
 988
 989
 990 /* Python interface to gethostbyname(name). */
 991
 992 /*ARGSUSED*/
 993 static PyObject *
 994 BUILD_FUNC_DEF_2(PySocket_gethostbyname,PyObject *,self, PyObject *,args)
 995 {
 996         char *name;
 997         struct sockaddr_in addrbuf;
 998         if (!PyArg_Parse(args, "s", &name))
 999                 return NULL;
1000         if (setipaddr(name, &addrbuf) < 0)
1001                 return NULL;
1002         return makeipaddr(&addrbuf);
1003 }
1004
1005 /* Python interface to gethostbyaddr(IP). */
1006
1007 /*ARGSUSED*/
1008 static PyObject *
1009 BUILD_FUNC_DEF_2(PySocket_gethostbyaddr,PyObject *,self, PyObject *, args)
1010 {
1011         struct sockaddr_in addr;
1012         char *ip_num;
1013         struct hostent *h;
1014         int d1,d2,d3,d4;
1015         char ch, **pch;
1016         PyObject *rtn_tuple = (PyObject *)NULL;
1017         PyObject *name_list = (PyObject *)NULL;
1018         PyObject *addr_list = (PyObject *)NULL;
1019         PyObject *tmp;
1020
1021         if (!PyArg_Parse(args, "s", &ip_num))
1022                 return NULL;
1023         if (setipaddr(ip_num, &addr) < 0)
1024                 return NULL;
1025         h = gethostbyaddr((char *)&addr.sin_addr,
1026                           sizeof(addr.sin_addr),
1027                           AF_INET);
1028         if (h == NULL) {
1029 #ifdef HAVE_HSTRERROR
1030                 /* Let's get real error message to return */
1031                 extern int h_errno;
1032                 PyErr_SetString(PySocket_Error, (char *)hstrerror(h_errno));
1033 #else
1034                 PyErr_SetString(PySocket_Error, "host not found");
1035 #endif
1036                 return NULL;
1037         }
1038         if ((name_list = PyList_New(0)) == NULL)
1039                 goto err;
1040         if ((addr_list = PyList_New(0)) == NULL)
1041                 goto err;
1042         for (pch = h->h_aliases; *pch != NULL; pch++) {
1043                 tmp = PyString_FromString(*pch);
1044                 if (tmp == NULL)
1045                         goto err;
1046                 PyList_Append(name_list, tmp);
1047                 Py_DECREF(tmp);
1048         }
1049         for (pch = h->h_addr_list; *pch != NULL; pch++) {
1050                 memcpy((char *) &addr.sin_addr, *pch, h->h_length);
1051                 tmp = makeipaddr(&addr);
1052                 if (tmp == NULL)
1053                         goto err;
1054                 PyList_Append(addr_list, tmp);
1055                 Py_DECREF(tmp);
1056         }
1057         rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
1058  err:
1059         Py_XDECREF(name_list);
1060         Py_XDECREF(addr_list);
1061         return rtn_tuple;
1062 }
1063
1064
1065 /* Python interface to getservbyname(name).
1066    This only returns the port number, since the other info is already
1067    known or not useful (like the list of aliases). */
1068
1069 /*ARGSUSED*/
1070 static PyObject *
1071 BUILD_FUNC_DEF_2(PySocket_getservbyname,PyObject *,self, PyObject *,args)
1072 {
1073         char *name, *proto;
1074         struct servent *sp;
1075         if (!PyArg_Parse(args, "(ss)", &name, &proto))
1076                 return NULL;
1077         Py_BEGIN_ALLOW_THREADS
1078         sp = getservbyname(name, proto);
1079         Py_END_ALLOW_THREADS
1080         if (sp == NULL) {
1081                 PyErr_SetString(PySocket_Error, "service/proto not found");
1082                 return NULL;
1083         }
1084         return PyInt_FromLong((long) ntohs(sp->s_port));
1085 }
1086
1087
1088 /* Python interface to socket(family, type, proto).
1089    The third (protocol) argument is optional.
1090    Return a new socket object. */
1091
1092 /*ARGSUSED*/
1093 static PyObject *
1094 BUILD_FUNC_DEF_2(PySocket_socket,PyObject *,self, PyObject *,args)
1095 {
1096         PySocketSockObject *s;
1097         int fd, family, type, proto;
1098         proto = 0;
1099         if (!PyArg_Parse(args, "(ii)", &family, &type)) {
1100                 PyErr_Clear();
1101                 if (!PyArg_Parse(args, "(iii)", &family, &type, &proto))
1102                         return NULL;
1103         }
1104         Py_BEGIN_ALLOW_THREADS
1105         fd = socket(family, type, proto);
1106         Py_END_ALLOW_THREADS
1107         if (fd < 0)
1108                 return PySocket_Err();
1109         s = PySocketSock_New(fd, family, type, proto);
1110         /* If the object can't be created, don't forget to close the
1111            file descriptor again! */
1112         if (s == NULL)
1113                 (void) close(fd);
1114         /* From now on, ignore SIGPIPE and let the error checking
1115            do the work. */
1116 #ifdef SIGPIPE
1117         (void) signal(SIGPIPE, SIG_IGN);
1118 #endif
1119         return (PyObject *) s;
1120 }
1121
1122 #ifndef NO_DUP
1123 /* Create a socket object from a numeric file description.
1124    Useful e.g. if stdin is a socket.
1125    Additional arguments as for socket(). */
1126
1127 /*ARGSUSED*/
1128 static PyObject *
1129 BUILD_FUNC_DEF_2(PySocket_fromfd,PyObject *,self, PyObject *,args)
1130 {
1131         PySocketSockObject *s;
1132         int fd, family, type, proto;
1133         proto = 0;
1134         if (!PyArg_Parse(args, "(iii)", &fd, &family, &type)) {
1135                 PyErr_Clear();
1136                 if (!PyArg_Parse(args, "(iiii)", &fd, &family, &type, &proto))
1137                         return NULL;
1138         }
1139         /* Dup the fd so it and the socket can be closed independently */
1140         fd = dup(fd);
1141         if (fd < 0)
1142                 return PySocket_Err();
1143         s = PySocketSock_New(fd, family, type, proto);
1144         /* From now on, ignore SIGPIPE and let the error checking
1145            do the work. */
1146 #ifdef SIGPIPE
1147         (void) signal(SIGPIPE, SIG_IGN);
1148 #endif
1149         return (PyObject *) s;
1150 }
1151 #endif /* NO_DUP */
1152
1153 /* List of functions exported by this module. */
1154
1155 static PyMethodDef PySocket_methods[] = {
1156         {"gethostbyname",       PySocket_gethostbyname},
1157         {"gethostbyaddr",       PySocket_gethostbyaddr},
1158         {"gethostname",         PySocket_gethostname},
1159         {"getservbyname",       PySocket_getservbyname},
1160         {"socket",              PySocket_socket},
1161 #ifndef NO_DUP
1162         {"fromfd",              PySocket_fromfd},
1163 #endif
1164         {NULL,                  NULL}            /* Sentinel */
1165 };
1166
1167
1168 /* Convenience routine to export an integer value.
1169    For simplicity, errors (which are unlikely anyway) are ignored. */
1170
1171 static void
1172 BUILD_FUNC_DEF_3(insint,PyObject *,d, char *,name, int,value)
1173 {
1174         PyObject *v = PyInt_FromLong((long) value);
1175         if (v == NULL) {
1176                 /* Don't bother reporting this error */
1177                 PyErr_Clear();
1178         }
1179         else {
1180                 PyDict_SetItemString(d, name, v);
1181                 Py_DECREF(v);
1182         }
1183 }
1184
1185
1186 /* Initialize this module.
1187    This is called when the first 'import socket' is done,
1188    via a table in config.c, if config.c is compiled with USE_SOCKET
1189    defined. */
1190
1191 void
1192 initsocket()
1193 {
1194         PyObject *m, *d;
1195         m = Py_InitModule("socket", PySocket_methods);
1196         d = PyModule_GetDict(m);
1197         PySocket_Error = PyString_FromString("socket.error");
1198         if (PySocket_Error == NULL ||
1199             PyDict_SetItemString(d, "error", PySocket_Error) != 0)
1200                 Py_FatalError("can't define socket.error");
1201         insint(d, "AF_INET", AF_INET);
1202 #ifdef AF_UNIX
1203         insint(d, "AF_UNIX", AF_UNIX);
1204 #endif /* AF_UNIX */
1205         insint(d, "SOCK_STREAM", SOCK_STREAM);
1206         insint(d, "SOCK_DGRAM", SOCK_DGRAM);
1207         insint(d, "SOCK_RAW", SOCK_RAW);
1208         insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
1209         insint(d, "SOCK_RDM", SOCK_RDM);
1210 }
1211
1212 #ifdef NT
1213 BOOL    WINAPI  DllMain (HANDLE hInst,
1214                         ULONG ul_reason_for_call,
1215                         LPVOID lpReserved)
1216 {
1217         switch (ul_reason_for_call)
1218         {
1219                 case DLL_PROCESS_ATTACH:
1220                         WSADATA WSAData;
1221                         if (WSAStartup(MAKEWORD(2,0), &WSAData)) {
1222                                 OutputDebugString("Python can't initialize Windows Sockets DLL!");
1223                                 return FALSE;
1224                         }
1225                         break;
1226                 case DLL_PROCESS_DETACH:
1227                         WSACleanup();
1228                         break;
1229
1230         }
1231         return TRUE;
1232 }
1233 #endif /* NT */