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 read/write operations (use send/recv or makefile instead)
  34
  35 Module interface:
  36
  37 - socket.error: exception raised for socket specific errors
  38 - socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
  39 - socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
  40 - socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
  41 - socket.getservbyname(servicename, protocolname) --> port number
  42 - socket.socket(family, type [, proto]) --> new socket object
  43 - socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
  44 - an Internet socket address is a pair (hostname, port)
  45   where hostname can be anything recognized by gethostbyname()
  46   (including the dd.dd.dd.dd notation) and port is in host byte order
  47 - where a hostname is returned, the dd.dd.dd.dd notation is used
  48 - a UNIX domain socket address is a string specifying the pathname
  49
  50 Socket methods:
  51
  52 - s.accept() --> new socket object, sockaddr
  53 - s.bind(sockaddr) --> None
  54 - s.close() --> None
  55 - s.connect(sockaddr) --> None
  56 - s.fileno() --> file descriptor
  57 - s.getpeername() --> sockaddr
  58 - s.getsockname() --> sockaddr
  59 - s.getsockopt(level, optname[, buflen]) --> int or string
  60 - s.listen(backlog) --> None
  61 - s.makefile([mode[, bufsize]]) --> file object
  62 - s.recv(buflen [,flags]) --> string
  63 - s.recvfrom(buflen [,flags]) --> string, sockaddr
  64 - s.send(string [,flags]) --> nbytes
  65 - s.sendto(string, [flags,] sockaddr) --> nbytes
  66 - s.setblocking(0 | 1) --> None
  67 - s.setsockopt(level, optname, value) --> None
  68 - s.shutdown(how) --> None
  69 - repr(s) --> "<socket object, fd=%d, family=%d, type=%d, protocol=%d>"
  70
  71 */
  72
  73 #include "Python.h"
  74
  75 #include <sys/types.h>
  76 #include "mytime.h"
  77
  78 #include <signal.h>
  79 #ifndef _MSC_VER
  80 #include <netdb.h>
  81 #include <sys/socket.h>
  82 #include <netinet/in.h>
  83 #include <fcntl.h>
  84 #else
  85 #include <winsock.h>
  86 #include <fcntl.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 #ifdef USE_GUSI
  99 /* fdopen() isn't declared in stdio.h (sigh) */
 100 #include <GUSI.h>
 101 #endif
 102
 103
 104 /* Here we have some hacks to choose between K&R or ANSI style function
 105    definitions.  For NT to build this as an extension module (ie, DLL)
 106    it must be compiled by the C++ compiler, as it takes the address of
 107    a static data item exported from the main Python DLL.
 108 */
 109 #ifdef NT
 110 /* seem to be a few differences in the API */
 111 #define close closesocket
 112 #define NO_DUP  /* Define for NT 3.1, Win3.1 and Win95, Undefine for NT3.5 */
 113 #define FORCE_ANSI_FUNC_DEFS
 114 #endif
 115
 116 #ifdef FORCE_ANSI_FUNC_DEFS
 117 #define BUILD_FUNC_DEF_1( fnname, arg1type, arg1name )  \
 118 fnname( arg1type arg1name )
 119
 120 #define BUILD_FUNC_DEF_2( fnname, arg1type, arg1name, arg2type, arg2name ) \
 121 fnname( arg1type arg1name, arg2type arg2name )
 122
 123 #define BUILD_FUNC_DEF_3( fnname, arg1type, arg1name, arg2type, arg2name , arg3type, arg3name ) \
 124 fnname( arg1type arg1name, arg2type arg2name, arg3type arg3name )
 125
 126 #define BUILD_FUNC_DEF_4( fnname, arg1type, arg1name, arg2type, arg2name , arg3type, arg3name, arg4type, arg4name )     \
 127 fnname( arg1type arg1name, arg2type arg2name, arg3type arg3name, arg4type arg4name )
 128
 129 #else /* !FORCE_ANSI_FN_DEFS */
 130 #define BUILD_FUNC_DEF_1( fnname, arg1type, arg1name )  \
 131 fnname( arg1name )      \
 132         arg1type arg1name;
 133
 134 #define BUILD_FUNC_DEF_2( fnname, arg1type, arg1name, arg2type, arg2name ) \
 135 fnname( arg1name, arg2name )    \
 136         arg1type arg1name;      \
 137         arg2type arg2name;
 138
 139 #define BUILD_FUNC_DEF_3( fnname, arg1type, arg1name, arg2type, arg2name, arg3type, arg3name ) \
 140 fnname( arg1name, arg2name, arg3name )  \
 141         arg1type arg1name;      \
 142         arg2type arg2name;      \
 143         arg3type arg3name;
 144
 145 #define BUILD_FUNC_DEF_4( fnname, arg1type, arg1name, arg2type, arg2name, arg3type, arg3name, arg4type, arg4name ) \
 146 fnname( arg1name, arg2name, arg3name, arg4name )        \
 147         arg1type arg1name;      \
 148         arg2type arg2name;      \
 149         arg3type arg3name;      \
 150         arg4type arg4name;
 151
 152 #endif /* !FORCE_ANSI_FN_DEFS */
 153
 154 /* Global variable holding the exception type for errors detected
 155    by this module (but not argument type or memory errors, etc.). */
 156
 157 static PyObject *PySocket_Error;
 158
 159
 160 /* Convenience function to raise an error according to errno
 161    and return a NULL pointer from a function. */
 162
 163 static PyObject *
 164 PySocket_Err()
 165 {
 166 #ifdef NT
 167         if (WSAGetLastError()) {
 168                 PyObject *v;
 169                 v = Py_BuildValue("(is)", WSAGetLastError(), "winsock error");
 170                 if (v != NULL) {
 171                         PyErr_SetObject(PySocket_Error, v);
 172                         Py_DECREF(v);
 173                 }
 174                 return NULL;
 175         }
 176         else
 177 #endif
 178         return PyErr_SetFromErrno(PySocket_Error);
 179 }
 180
 181
 182 /* The object holding a socket.  It holds some extra information,
 183    like the address family, which is used to decode socket address
 184    arguments properly. */
 185
 186 typedef struct {
 187         PyObject_HEAD
 188         int sock_fd;            /* Socket file descriptor */
 189         int sock_family;        /* Address family, e.g., AF_INET */
 190         int sock_type;          /* Socket type, e.g., SOCK_STREAM */
 191         int sock_proto;         /* Protocol type, usually 0 */
 192         union sock_addr {
 193                 struct sockaddr_in in;
 194 #ifdef AF_UNIX
 195                 struct sockaddr_un un;
 196 #endif
 197         } sock_addr;
 198 } PySocketSockObject;
 199
 200
 201 /* A forward reference to the Socktype type object.
 202    The Socktype variable contains pointers to various functions,
 203    some of which call newsockobject(), which uses Socktype, so
 204    there has to be a circular reference. */
 205
 206 staticforward PyTypeObject PySocketSock_Type;
 207
 208
 209 /* Create a new socket object.
 210    This just creates the object and initializes it.
 211    If the creation fails, return NULL and set an exception (implicit
 212    in NEWOBJ()). */
 213
 214 static PySocketSockObject *
 215 BUILD_FUNC_DEF_4(PySocketSock_New,int,fd, int,family, int,type, int,proto)
 216 {
 217         PySocketSockObject *s;
 218         PySocketSock_Type.ob_type = &PyType_Type;
 219         s = PyObject_NEW(PySocketSockObject, &PySocketSock_Type);
 220         if (s != NULL) {
 221                 s->sock_fd = fd;
 222                 s->sock_family = family;
 223                 s->sock_type = type;
 224                 s->sock_proto = proto;
 225         }
 226         return s;
 227 }
 228
 229
 230 /* Convert a string specifying a host name or one of a few symbolic
 231    names to a numeric IP address.  This usually calls gethostbyname()
 232    to do the work; the names "" and "<broadcast>" are special.
 233    Return the length (should always be 4 bytes), or negative if
 234    an error occurred; then an exception is raised. */
 235
 236 static int
 237 BUILD_FUNC_DEF_2(setipaddr, char*,name, struct sockaddr_in *,addr_ret)
 238 {
 239         struct hostent *hp;
 240         int d1, d2, d3, d4;
 241         char ch;
 242 #ifdef HAVE_GETHOSTBYNAME_R
 243         struct hostent hp_allocated;
 244         char buf[1001];
 245         int buf_len = (sizeof buf) - 1;
 246         int errnop;
 247 #endif /* HAVE_GETHOSTBYNAME_R */
 248
 249         if (name[0] == '\0') {
 250                 addr_ret->sin_addr.s_addr = INADDR_ANY;
 251                 return 4;
 252         }
 253         if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
 254                 addr_ret->sin_addr.s_addr = INADDR_BROADCAST;
 255                 return 4;
 256         }
 257         if (sscanf(name, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
 258             0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
 259             0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
 260                 addr_ret->sin_addr.s_addr = htonl(
 261                         ((long) d1 << 24) | ((long) d2 << 16) |
 262                         ((long) d3 << 8) | ((long) d4 << 0));
 263                 return 4;
 264         }
 265 #ifdef HAVE_GETHOSTBYNAME_R
 266         Py_BEGIN_ALLOW_THREADS
 267         hp = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
 268         Py_END_ALLOW_THREADS
 269 #else /* not HAVE_GETHOSTBYNAME_R */
 270         hp = gethostbyname(name);
 271 #endif /* HAVE_GETHOSTBYNAME_R */
 272
 273         if (hp == NULL) {
 274 #ifdef HAVE_HSTRERROR
 275                 /* Let's get real error message to return */
 276                 extern int h_errno;
 277                 PyErr_SetString(PySocket_Error, (char *)hstrerror(h_errno));
 278 #else
 279                 PyErr_SetString(PySocket_Error, "host not found");
 280 #endif
 281                 return -1;
 282         }
 283         memcpy((char *) &addr_ret->sin_addr, hp->h_addr, hp->h_length);
 284         return hp->h_length;
 285 }
 286
 287
 288 /* Create a string object representing an IP address.
 289    This is always a string of the form 'dd.dd.dd.dd' (with variable
 290    size numbers). */
 291
 292 static PyObject *
 293 BUILD_FUNC_DEF_1(makeipaddr, struct sockaddr_in *,addr)
 294 {
 295         long x = ntohl(addr->sin_addr.s_addr);
 296         char buf[100];
 297         sprintf(buf, "%d.%d.%d.%d",
 298                 (int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
 299                 (int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
 300         return PyString_FromString(buf);
 301 }
 302
 303
 304 /* Create an object representing the given socket address,
 305    suitable for passing it back to bind(), connect() etc.
 306    The family field of the sockaddr structure is inspected
 307    to determine what kind of address it really is. */
 308
 309 /*ARGSUSED*/
 310 static PyObject *
 311 BUILD_FUNC_DEF_2(makesockaddr,struct sockaddr *,addr, int,addrlen)
 312 {
 313         if (addrlen == 0) {
 314                 /* No address -- may be recvfrom() from known socket */
 315                 Py_INCREF(Py_None);
 316                 return Py_None;
 317         }
 318
 319         switch (addr->sa_family) {
 320
 321         case AF_INET:
 322         {
 323                 struct sockaddr_in *a = (struct sockaddr_in *) addr;
 324                 PyObject *addr = makeipaddr(a);
 325                 PyObject *ret = Py_BuildValue("Oi", addr, ntohs(a->sin_port));
 326                 Py_XDECREF(addr);
 327                 return ret;
 328         }
 329
 330 #ifdef AF_UNIX
 331         case AF_UNIX:
 332         {
 333                 struct sockaddr_un *a = (struct sockaddr_un *) addr;
 334                 return PyString_FromString(a->sun_path);
 335         }
 336 #endif /* AF_UNIX */
 337
 338         /* More cases here... */
 339
 340         default:
 341                 PyErr_SetString(PySocket_Error, "return unknown socket address type");
 342                 return NULL;
 343
 344         }
 345 }
 346
 347
 348 /* Parse a socket address argument according to the socket object's
 349    address family.  Return 1 if the address was in the proper format,
 350    0 of not.  The address is returned through addr_ret, its length
 351    through len_ret. */
 352
 353 static int
 354 BUILD_FUNC_DEF_4(
 355 getsockaddrarg,PySocketSockObject *,s, PyObject *,args, struct sockaddr **,addr_ret, int *,len_ret)
 356 {
 357         switch (s->sock_family) {
 358
 359 #ifdef AF_UNIX
 360         case AF_UNIX:
 361         {
 362                 struct sockaddr_un* addr;
 363                 char *path;
 364                 int len;
 365                 addr = (struct sockaddr_un* )&(s->sock_addr).un;
 366                 if (!PyArg_Parse(args, "s#", &path, &len))
 367                         return 0;
 368                 if (len > sizeof addr->sun_path) {
 369                         PyErr_SetString(PySocket_Error, "AF_UNIX path too long");
 370                         return 0;
 371                 }
 372                 addr->sun_family = AF_UNIX;
 373                 memcpy(addr->sun_path, path, len);
 374                 addr->sun_path[len] = 0;
 375                 *addr_ret = (struct sockaddr *) addr;
 376                 *len_ret = len + sizeof addr->sun_family;
 377                 return 1;
 378         }
 379 #endif /* AF_UNIX */
 380
 381         case AF_INET:
 382         {
 383                 struct sockaddr_in* addr;
 384                 char *host;
 385                 int port;
 386                 addr=(struct sockaddr_in*)&(s->sock_addr).in;
 387                 if (!PyArg_Parse(args, "(si)", &host, &port))
 388                         return 0;
 389                 if (setipaddr(host, addr) < 0)
 390                         return 0;
 391                 addr->sin_family = AF_INET;
 392                 addr->sin_port = htons(port);
 393                 *addr_ret = (struct sockaddr *) addr;
 394                 *len_ret = sizeof *addr;
 395                 return 1;
 396         }
 397
 398         /* More cases here... */
 399
 400         default:
 401                 PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
 402                 return 0;
 403
 404         }
 405 }
 406
 407
 408 /* Get the address length according to the socket object's address family.
 409    Return 1 if the family is known, 0 otherwise.  The length is returned
 410    through len_ret. */
 411
 412 static int
 413 BUILD_FUNC_DEF_2(getsockaddrlen,PySocketSockObject *,s, int *,len_ret)
 414 {
 415         switch (s->sock_family) {
 416
 417 #ifdef AF_UNIX
 418         case AF_UNIX:
 419         {
 420                 *len_ret = sizeof (struct sockaddr_un);
 421                 return 1;
 422         }
 423 #endif /* AF_UNIX */
 424
 425         case AF_INET:
 426         {
 427                 *len_ret = sizeof (struct sockaddr_in);
 428                 return 1;
 429         }
 430
 431         /* More cases here... */
 432
 433         default:
 434                 PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
 435                 return 0;
 436
 437         }
 438 }
 439
 440
 441 /* s.accept() method */
 442
 443 static PyObject *
 444 BUILD_FUNC_DEF_2(PySocketSock_accept,PySocketSockObject *,s, PyObject *,args)
 445 {
 446         char addrbuf[256];
 447         int addrlen, newfd;
 448         PyObject *sock, *addr, *res;
 449         if (!PyArg_NoArgs(args))
 450                 return NULL;
 451         if (!getsockaddrlen(s, &addrlen))
 452                 return NULL;
 453         Py_BEGIN_ALLOW_THREADS
 454         newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 455         Py_END_ALLOW_THREADS
 456         if (newfd < 0)
 457                 return PySocket_Err();
 458         /* Create the new object with unspecified family,
 459            to avoid calls to bind() etc. on it. */
 460         sock = (PyObject *) PySocketSock_New(newfd,
 461                                         s->sock_family,
 462                                         s->sock_type,
 463                                         s->sock_proto);
 464         if (sock == NULL)
 465                 close(newfd);
 466         addr = makesockaddr((struct sockaddr *) addrbuf, addrlen);
 467         res = Py_BuildValue("OO", sock, addr);
 468         Py_XDECREF(sock);
 469         Py_XDECREF(addr);
 470         return res;
 471 }
 472
 473
 474 #if 0
 475 /* s.allowbroadcast() method */
 476 /* XXX obsolete -- will disappear in next release */
 477
 478 static PyObject *
 479 BUILD_FUNC_DEF_2(PySocketSock_allowbroadcast,PySocketSockObject *,s, PyObject *,args)
 480 {
 481         int flag;
 482         int res;
 483         if (!PyArg_Parse(args, "i", &flag))
 484                 return NULL;
 485         res = setsockopt(s->sock_fd, SOL_SOCKET, SO_BROADCAST,
 486                          (ANY *)&flag, sizeof flag);
 487         if (res < 0)
 488                 return PySocket_Err();
 489         Py_INCREF(Py_None);
 490         return Py_None;
 491 }
 492 #endif
 493
 494
 495 /* s.setblocking(1 | 0) method */
 496
 497 static PyObject *
 498 BUILD_FUNC_DEF_2(PySocketSock_setblocking,PySocketSockObject*,s,PyObject*,args)
 499 {
 500         int block;
 501         int delay_flag;
 502         if (!PyArg_GetInt(args, &block))
 503                 return NULL;
 504         Py_BEGIN_ALLOW_THREADS
 505 #ifndef _MSC_VER
 506         delay_flag = fcntl (s->sock_fd, F_GETFL, 0);
 507         if (block)
 508                 delay_flag &= (~O_NDELAY);
 509         else
 510                 delay_flag |= O_NDELAY;
 511         fcntl (s->sock_fd, F_SETFL, delay_flag);
 512 #else
 513         block = !block;
 514         ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
 515 #endif
 516         Py_END_ALLOW_THREADS
 517
 518         Py_INCREF(Py_None);
 519         return Py_None;
 520 }
 521
 522
 523 /* s.setsockopt() method.
 524    With an integer third argument, sets an integer option.
 525    With a string third argument, sets an option from a buffer;
 526    use optional built-in module 'struct' to encode the string. */
 527
 528 static PyObject *
 529 BUILD_FUNC_DEF_2(PySocketSock_setsockopt,PySocketSockObject *,s, PyObject *,args)
 530 {
 531         int level;
 532         int optname;
 533         int res;
 534         char *buf;
 535         int buflen;
 536         int flag;
 537
 538         if (PyArg_Parse(args, "(iii)", &level, &optname, &flag)) {
 539                 buf = (char *) &flag;
 540                 buflen = sizeof flag;
 541         }
 542         else {
 543                 PyErr_Clear();
 544                 if (!PyArg_Parse(args, "(iis#)", &level, &optname, &buf, &buflen))
 545                         return NULL;
 546         }
 547         res = setsockopt(s->sock_fd, level, optname, (ANY *)buf, buflen);
 548         if (res < 0)
 549                 return PySocket_Err();
 550         Py_INCREF(Py_None);
 551         return Py_None;
 552 }
 553
 554
 555 /* s.getsockopt() method.
 556    With two arguments, retrieves an integer option.
 557    With a third integer argument, retrieves a string buffer of that size;
 558    use optional built-in module 'struct' to decode the string. */
 559
 560 static PyObject *
 561 BUILD_FUNC_DEF_2(PySocketSock_getsockopt,PySocketSockObject *,s, PyObject *,args)
 562 {
 563         int level;
 564         int optname;
 565         int res;
 566         PyObject *buf;
 567         int buflen;
 568
 569         if (PyArg_Parse(args, "(ii)", &level, &optname)) {
 570                 int flag = 0;
 571                 int flagsize = sizeof flag;
 572                 res = getsockopt(s->sock_fd, level, optname,
 573                                  (ANY *)&flag, &flagsize);
 574                 if (res < 0)
 575                         return PySocket_Err();
 576                 return PyInt_FromLong(flag);
 577         }
 578         PyErr_Clear();
 579         if (!PyArg_Parse(args, "(iii)", &level, &optname, &buflen))
 580                 return NULL;
 581         if (buflen <= 0 || buflen > 1024) {
 582                 PyErr_SetString(PySocket_Error, "getsockopt buflen out of range");
 583                 return NULL;
 584         }
 585         buf = PyString_FromStringAndSize((char *)NULL, buflen);
 586         if (buf == NULL)
 587                 return NULL;
 588         res = getsockopt(s->sock_fd, level, optname,
 589                          (ANY *)PyString_AsString(buf), &buflen);
 590         if (res < 0) {
 591                 Py_DECREF(buf);
 592                 return PySocket_Err();
 593         }
 594         _PyString_Resize(&buf, buflen);
 595         return buf;
 596 }
 597
 598
 599 /* s.bind(sockaddr) method */
 600
 601 static PyObject *
 602 BUILD_FUNC_DEF_2(PySocketSock_bind,PySocketSockObject *,s, PyObject *,args)
 603 {
 604         struct sockaddr *addr;
 605         int addrlen;
 606         int res;
 607         if (!getsockaddrarg(s, args, &addr, &addrlen))
 608                 return NULL;
 609         Py_BEGIN_ALLOW_THREADS
 610         res = bind(s->sock_fd, addr, addrlen);
 611         Py_END_ALLOW_THREADS
 612         if (res < 0)
 613                 return PySocket_Err();
 614         Py_INCREF(Py_None);
 615         return Py_None;
 616 }
 617
 618
 619 /* s.close() method.
 620    Set the file descriptor to -1 so operations tried subsequently
 621    will surely fail. */
 622
 623 static PyObject *
 624 BUILD_FUNC_DEF_2(PySocketSock_close,PySocketSockObject *,s, PyObject *,args)
 625 {
 626         if (!PyArg_NoArgs(args))
 627                 return NULL;
 628         Py_BEGIN_ALLOW_THREADS
 629         (void) close(s->sock_fd);
 630         Py_END_ALLOW_THREADS
 631         s->sock_fd = -1;
 632         Py_INCREF(Py_None);
 633         return Py_None;
 634 }
 635
 636
 637 /* s.connect(sockaddr) method */
 638
 639 static PyObject *
 640 BUILD_FUNC_DEF_2(PySocketSock_connect,PySocketSockObject *,s, PyObject *,args)
 641 {
 642         struct sockaddr *addr;
 643         int addrlen;
 644         int res;
 645         if (!getsockaddrarg(s, args, &addr, &addrlen))
 646                 return NULL;
 647         Py_BEGIN_ALLOW_THREADS
 648         res = connect(s->sock_fd, addr, addrlen);
 649         Py_END_ALLOW_THREADS
 650         if (res < 0)
 651                 return PySocket_Err();
 652         Py_INCREF(Py_None);
 653         return Py_None;
 654 }
 655
 656
 657 /* s.fileno() method */
 658
 659 static PyObject *
 660 BUILD_FUNC_DEF_2(PySocketSock_fileno,PySocketSockObject *,s, PyObject *,args)
 661 {
 662         if (!PyArg_NoArgs(args))
 663                 return NULL;
 664         return PyInt_FromLong((long) s->sock_fd);
 665 }
 666
 667
 668 /* s.getsockname() method */
 669
 670 static PyObject *
 671 BUILD_FUNC_DEF_2(PySocketSock_getsockname,PySocketSockObject *,s, PyObject *,args)
 672 {
 673         char addrbuf[256];
 674         int addrlen, res;
 675         if (!PyArg_NoArgs(args))
 676                 return NULL;
 677         if (!getsockaddrlen(s, &addrlen))
 678                 return NULL;
 679         memset(addrbuf, 0, addrlen);
 680         Py_BEGIN_ALLOW_THREADS
 681         res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 682         Py_END_ALLOW_THREADS
 683         if (res < 0)
 684                 return PySocket_Err();
 685         return makesockaddr((struct sockaddr *) addrbuf, addrlen);
 686 }
 687
 688
 689 #ifdef HAVE_GETPEERNAME         /* Cray APP doesn't have this :-( */
 690 /* s.getpeername() method */
 691
 692 static PyObject *
 693 BUILD_FUNC_DEF_2(PySocketSock_getpeername,PySocketSockObject *,s, PyObject *,args)
 694 {
 695         char addrbuf[256];
 696         int addrlen, res;
 697         if (!PyArg_NoArgs(args))
 698                 return NULL;
 699         if (!getsockaddrlen(s, &addrlen))
 700                 return NULL;
 701         Py_BEGIN_ALLOW_THREADS
 702         res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 703         Py_END_ALLOW_THREADS
 704         if (res < 0)
 705                 return PySocket_Err();
 706         return makesockaddr((struct sockaddr *) addrbuf, addrlen);
 707 }
 708 #endif /* HAVE_GETPEERNAME */
 709
 710
 711 /* s.listen(n) method */
 712
 713 static PyObject *
 714 BUILD_FUNC_DEF_2(PySocketSock_listen,PySocketSockObject *,s, PyObject *,args)
 715 {
 716         int backlog;
 717         int res;
 718         if (!PyArg_GetInt(args, &backlog))
 719                 return NULL;
 720         Py_BEGIN_ALLOW_THREADS
 721         if (backlog < 1)
 722                 backlog = 1;
 723         res = listen(s->sock_fd, backlog);
 724         Py_END_ALLOW_THREADS
 725         if (res < 0)
 726                 return PySocket_Err();
 727         Py_INCREF(Py_None);
 728         return Py_None;
 729 }
 730
 731 #ifndef NO_DUP
 732 /* s.makefile(mode) method.
 733    Create a new open file object referring to a dupped version of
 734    the socket's file descriptor.  (The dup() call is necessary so
 735    that the open file and socket objects may be closed independent
 736    of each other.)
 737    The mode argument specifies 'r' or 'w' passed to fdopen(). */
 738
 739 static PyObject *
 740 BUILD_FUNC_DEF_2(PySocketSock_makefile,PySocketSockObject *,s, PyObject *,args)
 741 {
 742         extern int fclose Py_PROTO((FILE *));
 743         char *mode = "r";
 744         int bufsize = -1;
 745         int fd;
 746         FILE *fp;
 747         PyObject *f;
 748
 749         if (!PyArg_ParseTuple(args, "|si", &mode, &bufsize))
 750                 return NULL;
 751 #ifdef NT
 752    if ( ((fd =  _open_osfhandle( s->sock_fd, _O_BINARY )) < 0) ||
 753         ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL)) {
 754 #else
 755         if ((fd = dup(s->sock_fd)) < 0 ||
 756             (fp = fdopen(fd, mode)) == NULL) {
 757 #endif
 758                 if (fd >= 0)
 759                         close(fd);
 760                 return PySocket_Err();
 761         }
 762         f = PyFile_FromFile(fp, "<socket>", mode, fclose);
 763         if (f != NULL)
 764                 PyFile_SetBufSize(f, bufsize);
 765         return f;
 766 }
 767 #endif /* NO_DUP */
 768
 769 /* s.recv(nbytes [,flags]) method */
 770
 771 static PyObject *
 772 BUILD_FUNC_DEF_2(PySocketSock_recv,PySocketSockObject *,s, PyObject *,args)
 773 {
 774         int len, n, flags;
 775         PyObject *buf;
 776         flags = 0;
 777         if (!PyArg_Parse(args, "i", &len)) {
 778                 PyErr_Clear();
 779                 if (!PyArg_Parse(args, "(ii)", &len, &flags))
 780                         return NULL;
 781         }
 782         buf = PyString_FromStringAndSize((char *) 0, len);
 783         if (buf == NULL)
 784                 return NULL;
 785         Py_BEGIN_ALLOW_THREADS
 786         n = recv(s->sock_fd, PyString_AsString(buf), len, flags);
 787         Py_END_ALLOW_THREADS
 788         if (n < 0) {
 789                 Py_DECREF(buf);
 790                 return PySocket_Err();
 791         }
 792         if (_PyString_Resize(&buf, n) < 0)
 793                 return NULL;
 794         return buf;
 795 }
 796
 797
 798 /* s.recvfrom(nbytes [,flags]) method */
 799
 800 static PyObject *
 801 BUILD_FUNC_DEF_2(PySocketSock_recvfrom,PySocketSockObject *,s, PyObject *,args)
 802 {
 803         char addrbuf[256];
 804         PyObject *buf, *addr, *ret;
 805         int addrlen, len, n, flags;
 806         flags = 0;
 807         if (!PyArg_Parse(args, "i", &len)) {
 808                 PyErr_Clear();
 809                 if (!PyArg_Parse(args, "(ii)", &len, &flags))
 810                     return NULL;
 811         }
 812         if (!getsockaddrlen(s, &addrlen))
 813                 return NULL;
 814         buf = PyString_FromStringAndSize((char *) 0, len);
 815         if (buf == NULL)
 816                 return NULL;
 817         Py_BEGIN_ALLOW_THREADS
 818         n = recvfrom(s->sock_fd, PyString_AsString(buf), len, flags,
 819 #ifndef NT
 820                      (ANY *)addrbuf, &addrlen);
 821 #else
 822                      (struct sockaddr *)addrbuf, &addrlen);
 823 #endif
 824         Py_END_ALLOW_THREADS
 825         if (n < 0) {
 826                 Py_DECREF(buf);
 827                 return PySocket_Err();
 828         }
 829         if (_PyString_Resize(&buf, n) < 0)
 830                 return NULL;
 831         addr = makesockaddr((struct sockaddr *)addrbuf, addrlen);
 832         ret = Py_BuildValue("OO", buf, addr);
 833         Py_XDECREF(addr);
 834         Py_XDECREF(buf);
 835         return ret;
 836 }
 837
 838
 839 /* s.send(data [,flags]) method */
 840
 841 static PyObject *
 842 BUILD_FUNC_DEF_2(PySocketSock_send,PySocketSockObject *,s, PyObject *,args)
 843 {
 844         char *buf;
 845         int len, n, flags;
 846         flags = 0;
 847         if (!PyArg_Parse(args, "s#", &buf, &len)) {
 848                 PyErr_Clear();
 849                 if (!PyArg_Parse(args, "(s#i)", &buf, &len, &flags))
 850                         return NULL;
 851         }
 852         Py_BEGIN_ALLOW_THREADS
 853         n = send(s->sock_fd, buf, len, flags);
 854         Py_END_ALLOW_THREADS
 855         if (n < 0)
 856                 return PySocket_Err();
 857         return PyInt_FromLong((long)n);
 858 }
 859
 860
 861 /* s.sendto(data, [flags,] sockaddr) method */
 862
 863 static PyObject *
 864 BUILD_FUNC_DEF_2(PySocketSock_sendto,PySocketSockObject *,s, PyObject *,args)
 865 {
 866         PyObject *addro;
 867         char *buf;
 868         struct sockaddr *addr;
 869         int addrlen, len, n, flags;
 870         flags = 0;
 871         if (!PyArg_Parse(args, "(s#O)", &buf, &len, &addro)) {
 872                 PyErr_Clear();
 873                 if (!PyArg_Parse(args, "(s#iO)", &buf, &len, &flags, &addro))
 874                         return NULL;
 875         }
 876         if (!getsockaddrarg(s, addro, &addr, &addrlen))
 877                 return NULL;
 878         Py_BEGIN_ALLOW_THREADS
 879         n = sendto(s->sock_fd, buf, len, flags, addr, addrlen);
 880         Py_END_ALLOW_THREADS
 881         if (n < 0)
 882                 return PySocket_Err();
 883         return PyInt_FromLong((long)n);
 884 }
 885
 886
 887 /* s.shutdown(how) method */
 888
 889 static PyObject *
 890 BUILD_FUNC_DEF_2(PySocketSock_shutdown,PySocketSockObject *,s, PyObject *,args)
 891 {
 892         int how;
 893         int res;
 894         if (!PyArg_GetInt(args, &how))
 895                 return NULL;
 896         Py_BEGIN_ALLOW_THREADS
 897         res = shutdown(s->sock_fd, how);
 898         Py_END_ALLOW_THREADS
 899         if (res < 0)
 900                 return PySocket_Err();
 901         Py_INCREF(Py_None);
 902         return Py_None;
 903 }
 904
 905
 906 /* List of methods for socket objects */
 907
 908 static PyMethodDef PySocketSock_methods[] = {
 909         {"accept",              (PyCFunction)PySocketSock_accept},
 910 #if 0
 911         {"allowbroadcast",      (PyCFunction)PySocketSock_allowbroadcast},
 912 #endif
 913         {"setblocking",         (PyCFunction)PySocketSock_setblocking},
 914         {"setsockopt",          (PyCFunction)PySocketSock_setsockopt},
 915         {"getsockopt",          (PyCFunction)PySocketSock_getsockopt},
 916         {"bind",                (PyCFunction)PySocketSock_bind},
 917         {"close",               (PyCFunction)PySocketSock_close},
 918         {"connect",             (PyCFunction)PySocketSock_connect},
 919         {"fileno",              (PyCFunction)PySocketSock_fileno},
 920         {"getsockname",         (PyCFunction)PySocketSock_getsockname},
 921 #ifdef HAVE_GETPEERNAME
 922         {"getpeername",         (PyCFunction)PySocketSock_getpeername},
 923 #endif
 924         {"listen",              (PyCFunction)PySocketSock_listen},
 925 #ifndef NO_DUP
 926         {"makefile",            (PyCFunction)PySocketSock_makefile, 1},
 927 #endif
 928         {"recv",                (PyCFunction)PySocketSock_recv},
 929         {"recvfrom",            (PyCFunction)PySocketSock_recvfrom},
 930         {"send",                (PyCFunction)PySocketSock_send},
 931         {"sendto",              (PyCFunction)PySocketSock_sendto},
 932         {"shutdown",            (PyCFunction)PySocketSock_shutdown},
 933         {NULL,                  NULL}           /* sentinel */
 934 };
 935
 936
 937 /* Deallocate a socket object in response to the last Py_DECREF().
 938    First close the file description. */
 939
 940 static void
 941 BUILD_FUNC_DEF_1(PySocketSock_dealloc,PySocketSockObject *,s)
 942 {
 943         (void) close(s->sock_fd);
 944         PyMem_DEL(s);
 945 }
 946
 947
 948 /* Return a socket object's named attribute. */
 949
 950 static PyObject *
 951 BUILD_FUNC_DEF_2(PySocketSock_getattr,PySocketSockObject *,s, char *,name)
 952 {
 953         return Py_FindMethod(PySocketSock_methods, (PyObject *) s, name);
 954 }
 955
 956
 957 static PyObject *
 958 BUILD_FUNC_DEF_1(PySocketSock_repr,PySocketSockObject *,s)
 959 {
 960         char buf[512];
 961         sprintf(buf,
 962                 "<socket object, fd=%d, family=%d, type=%d, protocol=%d>",
 963                 s->sock_fd, s->sock_family, s->sock_type, s->sock_proto);
 964         return PyString_FromString(buf);
 965 }
 966
 967
 968 /* Type object for socket objects. */
 969
 970 static PyTypeObject PySocketSock_Type = {
 971         PyObject_HEAD_INIT(0)   /* Must fill in type value later */
 972         0,
 973         "socket",
 974         sizeof(PySocketSockObject),
 975         0,
 976         (destructor)PySocketSock_dealloc, /*tp_dealloc*/
 977         0,              /*tp_print*/
 978         (getattrfunc)PySocketSock_getattr, /*tp_getattr*/
 979         0,              /*tp_setattr*/
 980         0,              /*tp_compare*/
 981         (reprfunc)PySocketSock_repr, /*tp_repr*/
 982         0,              /*tp_as_number*/
 983         0,              /*tp_as_sequence*/
 984         0,              /*tp_as_mapping*/
 985 };
 986
 987
 988 /* Python interface to gethostname(). */
 989
 990 /*ARGSUSED*/
 991 static PyObject *
 992 BUILD_FUNC_DEF_2(PySocket_gethostname,PyObject *,self, PyObject *,args)
 993 {
 994         char buf[1024];
 995         int res;
 996         if (!PyArg_NoArgs(args))
 997                 return NULL;
 998         Py_BEGIN_ALLOW_THREADS
 999         res = gethostname(buf, (int) sizeof buf - 1);
1000         Py_END_ALLOW_THREADS
1001         if (res < 0)
1002                 return PySocket_Err();
1003         buf[sizeof buf - 1] = '\0';
1004         return PyString_FromString(buf);
1005 }
1006
1007
1008 /* Python interface to gethostbyname(name). */
1009
1010 /*ARGSUSED*/
1011 static PyObject *
1012 BUILD_FUNC_DEF_2(PySocket_gethostbyname,PyObject *,self, PyObject *,args)
1013 {
1014         char *name;
1015         struct sockaddr_in addrbuf;
1016         if (!PyArg_Parse(args, "s", &name))
1017                 return NULL;
1018         if (setipaddr(name, &addrbuf) < 0)
1019                 return NULL;
1020         return makeipaddr(&addrbuf);
1021 }
1022
1023 /* Python interface to gethostbyaddr(IP). */
1024
1025 /*ARGSUSED*/
1026 static PyObject *
1027 BUILD_FUNC_DEF_2(PySocket_gethostbyaddr,PyObject *,self, PyObject *, args)
1028 {
1029         struct sockaddr_in addr;
1030         char *ip_num;
1031         struct hostent *h;
1032         char **pch;
1033         PyObject *rtn_tuple = (PyObject *)NULL;
1034         PyObject *name_list = (PyObject *)NULL;
1035         PyObject *addr_list = (PyObject *)NULL;
1036         PyObject *tmp;
1037
1038         if (!PyArg_Parse(args, "s", &ip_num))
1039                 return NULL;
1040         if (setipaddr(ip_num, &addr) < 0)
1041                 return NULL;
1042         h = gethostbyaddr((char *)&addr.sin_addr,
1043                           sizeof(addr.sin_addr),
1044                           AF_INET);
1045         if (h == NULL) {
1046 #ifdef HAVE_HSTRERROR
1047                 /* Let's get real error message to return */
1048                 extern int h_errno;
1049                 PyErr_SetString(PySocket_Error, (char *)hstrerror(h_errno));
1050 #else
1051                 PyErr_SetString(PySocket_Error, "host not found");
1052 #endif
1053                 return NULL;
1054         }
1055         if ((name_list = PyList_New(0)) == NULL)
1056                 goto err;
1057         if ((addr_list = PyList_New(0)) == NULL)
1058                 goto err;
1059         for (pch = h->h_aliases; *pch != NULL; pch++) {
1060                 tmp = PyString_FromString(*pch);
1061                 if (tmp == NULL)
1062                         goto err;
1063                 PyList_Append(name_list, tmp);
1064                 Py_DECREF(tmp);
1065         }
1066         for (pch = h->h_addr_list; *pch != NULL; pch++) {
1067                 memcpy((char *) &addr.sin_addr, *pch, h->h_length);
1068                 tmp = makeipaddr(&addr);
1069                 if (tmp == NULL)
1070                         goto err;
1071                 PyList_Append(addr_list, tmp);
1072                 Py_DECREF(tmp);
1073         }
1074         rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
1075  err:
1076         Py_XDECREF(name_list);
1077         Py_XDECREF(addr_list);
1078         return rtn_tuple;
1079 }
1080
1081
1082 /* Python interface to getservbyname(name).
1083    This only returns the port number, since the other info is already
1084    known or not useful (like the list of aliases). */
1085
1086 /*ARGSUSED*/
1087 static PyObject *
1088 BUILD_FUNC_DEF_2(PySocket_getservbyname,PyObject *,self, PyObject *,args)
1089 {
1090         char *name, *proto;
1091         struct servent *sp;
1092         if (!PyArg_Parse(args, "(ss)", &name, &proto))
1093                 return NULL;
1094         Py_BEGIN_ALLOW_THREADS
1095         sp = getservbyname(name, proto);
1096         Py_END_ALLOW_THREADS
1097         if (sp == NULL) {
1098                 PyErr_SetString(PySocket_Error, "service/proto not found");
1099                 return NULL;
1100         }
1101         return PyInt_FromLong((long) ntohs(sp->s_port));
1102 }
1103
1104
1105 /* Python interface to socket(family, type, proto).
1106    The third (protocol) argument is optional.
1107    Return a new socket object. */
1108
1109 /*ARGSUSED*/
1110 static PyObject *
1111 BUILD_FUNC_DEF_2(PySocket_socket,PyObject *,self, PyObject *,args)
1112 {
1113         PySocketSockObject *s;
1114         int fd, family, type, proto;
1115         proto = 0;
1116         if (!PyArg_Parse(args, "(ii)", &family, &type)) {
1117                 PyErr_Clear();
1118                 if (!PyArg_Parse(args, "(iii)", &family, &type, &proto))
1119                         return NULL;
1120         }
1121         Py_BEGIN_ALLOW_THREADS
1122         fd = socket(family, type, proto);
1123         Py_END_ALLOW_THREADS
1124         if (fd < 0)
1125                 return PySocket_Err();
1126         s = PySocketSock_New(fd, family, type, proto);
1127         /* If the object can't be created, don't forget to close the
1128            file descriptor again! */
1129         if (s == NULL)
1130                 (void) close(fd);
1131         /* From now on, ignore SIGPIPE and let the error checking
1132            do the work. */
1133 #ifdef SIGPIPE
1134         (void) signal(SIGPIPE, SIG_IGN);
1135 #endif
1136         return (PyObject *) s;
1137 }
1138
1139 #ifndef NO_DUP
1140 /* Create a socket object from a numeric file description.
1141    Useful e.g. if stdin is a socket.
1142    Additional arguments as for socket(). */
1143
1144 /*ARGSUSED*/
1145 static PyObject *
1146 BUILD_FUNC_DEF_2(PySocket_fromfd,PyObject *,self, PyObject *,args)
1147 {
1148         PySocketSockObject *s;
1149         int fd, family, type, proto;
1150         proto = 0;
1151         if (!PyArg_Parse(args, "(iii)", &fd, &family, &type)) {
1152                 PyErr_Clear();
1153                 if (!PyArg_Parse(args, "(iiii)", &fd, &family, &type, &proto))
1154                         return NULL;
1155         }
1156         /* Dup the fd so it and the socket can be closed independently */
1157         fd = dup(fd);
1158         if (fd < 0)
1159                 return PySocket_Err();
1160         s = PySocketSock_New(fd, family, type, proto);
1161         /* From now on, ignore SIGPIPE and let the error checking
1162            do the work. */
1163 #ifdef SIGPIPE
1164         (void) signal(SIGPIPE, SIG_IGN);
1165 #endif
1166         return (PyObject *) s;
1167 }
1168 #endif /* NO_DUP */
1169
1170 /* List of functions exported by this module. */
1171
1172 static PyMethodDef PySocket_methods[] = {
1173         {"gethostbyname",       PySocket_gethostbyname},
1174         {"gethostbyaddr",       PySocket_gethostbyaddr},
1175         {"gethostname",         PySocket_gethostname},
1176         {"getservbyname",       PySocket_getservbyname},
1177         {"socket",              PySocket_socket},
1178 #ifndef NO_DUP
1179         {"fromfd",              PySocket_fromfd},
1180 #endif
1181         {NULL,                  NULL}            /* Sentinel */
1182 };
1183
1184
1185 /* Convenience routine to export an integer value.
1186    For simplicity, errors (which are unlikely anyway) are ignored. */
1187
1188 static void
1189 BUILD_FUNC_DEF_3(insint,PyObject *,d, char *,name, int,value)
1190 {
1191         PyObject *v = PyInt_FromLong((long) value);
1192         if (v == NULL) {
1193                 /* Don't bother reporting this error */
1194                 PyErr_Clear();
1195         }
1196         else {
1197                 PyDict_SetItemString(d, name, v);
1198                 Py_DECREF(v);
1199         }
1200 }
1201
1202
1203 /* Initialize this module.
1204    This is called when the first 'import socket' is done,
1205    via a table in config.c, if config.c is compiled with USE_SOCKET
1206    defined. */
1207
1208 void
1209 initsocket()
1210 {
1211         PyObject *m, *d;
1212         m = Py_InitModule("socket", PySocket_methods);
1213         d = PyModule_GetDict(m);
1214         PySocket_Error = PyString_FromString("socket.error");
1215         if (PySocket_Error == NULL ||
1216             PyDict_SetItemString(d, "error", PySocket_Error) != 0)
1217                 Py_FatalError("can't define socket.error");
1218         insint(d, "AF_INET", AF_INET);
1219 #ifdef AF_UNIX
1220         insint(d, "AF_UNIX", AF_UNIX);
1221 #endif /* AF_UNIX */
1222         insint(d, "SOCK_STREAM", SOCK_STREAM);
1223         insint(d, "SOCK_DGRAM", SOCK_DGRAM);
1224         insint(d, "SOCK_RAW", SOCK_RAW);
1225         insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
1226         insint(d, "SOCK_RDM", SOCK_RDM);
1227
1228 #ifdef  SO_DEBUG
1229         insint(d, "SO_DEBUG", SO_DEBUG);
1230 #endif
1231 #ifdef  SO_ACCEPTCONN
1232         insint(d, "SO_ACCEPTCONN", SO_ACCEPTCONN);
1233 #endif
1234 #ifdef  SO_REUSEADDR
1235         insint(d, "SO_REUSEADDR", SO_REUSEADDR);
1236 #endif
1237 #ifdef  SO_KEEPALIVE
1238         insint(d, "SO_KEEPALIVE", SO_KEEPALIVE);
1239 #endif
1240 #ifdef  SO_DONTROUTE
1241         insint(d, "SO_DONTROUTE", SO_DONTROUTE);
1242 #endif
1243 #ifdef  SO_BROADCAST
1244         insint(d, "SO_BROADCAST", SO_BROADCAST);
1245 #endif
1246 #ifdef  SO_USELOOPBACK
1247         insint(d, "SO_USELOOPBACK", SO_USELOOPBACK);
1248 #endif
1249 #ifdef  SO_LINGER
1250         insint(d, "SO_LINGER", SO_LINGER);
1251 #endif
1252 #ifdef  SO_OOBINLINE
1253         insint(d, "SO_OOBINLINE", SO_OOBINLINE);
1254 #endif
1255 #ifdef  SO_REUSEPORT
1256         insint(d, "SO_REUSEPORT", SO_REUSEPORT);
1257 #endif
1258
1259 #ifdef  SO_SNDBUF
1260         insint(d, "SO_SNDBUF", SO_SNDBUF);
1261 #endif
1262 #ifdef  SO_RCVBUF
1263         insint(d, "SO_RCVBUF", SO_RCVBUF);
1264 #endif
1265 #ifdef  SO_SNDLOWAT
1266         insint(d, "SO_SNDLOWAT", SO_SNDLOWAT);
1267 #endif
1268 #ifdef  SO_RCVLOWAT
1269         insint(d, "SO_RCVLOWAT", SO_RCVLOWAT);
1270 #endif
1271 #ifdef  SO_SNDTIMEO
1272         insint(d, "SO_SNDTIMEO", SO_SNDTIMEO);
1273 #endif
1274 #ifdef  SO_RCVTIMEO
1275         insint(d, "SO_RCVTIMEO", SO_RCVTIMEO);
1276 #endif
1277 #ifdef  SO_ERROR
1278         insint(d, "SO_ERROR", SO_ERROR);
1279 #endif
1280 #ifdef  SO_TYPE
1281         insint(d, "SO_TYPE", SO_TYPE);
1282 #endif
1283
1284         /* Maximum number of connections for "listen" */
1285 #ifdef  SOMAXCONN
1286         insint(d, "SOMAXCONN", SOMAXCONN);
1287 #else
1288         insint(d, "SOMAXCONN", 5);      /* Common value */
1289 #endif
1290
1291         /* Flags for send, recv */
1292 #ifdef  MSG_OOB
1293         insint(d, "MSG_OOB", MSG_OOB);
1294 #endif
1295 #ifdef  MSG_PEEK
1296         insint(d, "MSG_PEEK", MSG_PEEK);
1297 #endif
1298 #ifdef  MSG_DONTROUTE
1299         insint(d, "MSG_DONTROUTE", MSG_DONTROUTE);
1300 #endif
1301 #ifdef  MSG_EOR
1302         insint(d, "MSG_EOR", MSG_EOR);
1303 #endif
1304 #ifdef  MSG_TRUNC
1305         insint(d, "MSG_TRUNC", MSG_TRUNC);
1306 #endif
1307 #ifdef  MSG_CTRUNC
1308         insint(d, "MSG_CTRUNC", MSG_CTRUNC);
1309 #endif
1310 #ifdef  MSG_WAITALL
1311         insint(d, "MSG_WAITALL", MSG_WAITALL);
1312 #endif
1313 #ifdef  MSG_BTAG
1314         insint(d, "MSG_BTAG", MSG_BTAG);
1315 #endif
1316 #ifdef  MSG_ETAG
1317         insint(d, "MSG_ETAG", MSG_ETAG);
1318 #endif
1319
1320         /* Protocol level and numbers, usable for [gs]etsockopt */
1321 #ifdef  SOL_SOCKET
1322         insint(d, "SOL_SOCKET", SOL_SOCKET);
1323 #endif
1324 #ifdef  IPPROTO_IP
1325         insint(d, "IPPROTO_IP", IPPROTO_IP);
1326 #endif
1327 #ifdef  IPPROTO_ICMP
1328         insint(d, "IPPROTO_ICMP", IPPROTO_ICMP);
1329 #endif
1330 #ifdef  IPPROTO_IGMP
1331         insint(d, "IPPROTO_IGMP", IPPROTO_IGMP);
1332 #endif
1333 #ifdef  IPPROTO_GGP
1334         insint(d, "IPPROTO_GGP", IPPROTO_GGP);
1335 #endif
1336 #ifdef  IPPROTO_TCP
1337         insint(d, "IPPROTO_TCP", IPPROTO_TCP);
1338 #endif
1339 #ifdef  IPPROTO_EGP
1340         insint(d, "IPPROTO_EGP", IPPROTO_EGP);
1341 #endif
1342 #ifdef  IPPROTO_PUP
1343         insint(d, "IPPROTO_PUP", IPPROTO_PUP);
1344 #endif
1345 #ifdef  IPPROTO_UDP
1346         insint(d, "IPPROTO_UDP", IPPROTO_UDP);
1347 #endif
1348 #ifdef  IPPROTO_IDP
1349         insint(d, "IPPROTO_IDP", IPPROTO_IDP);
1350 #endif
1351 #ifdef  IPPROTO_HELLO
1352         insint(d, "IPPROTO_HELLO", IPPROTO_HELLO);
1353 #endif
1354 #ifdef  IPPROTO_ND
1355         insint(d, "IPPROTO_ND", IPPROTO_ND);
1356 #endif
1357 #ifdef  IPPROTO_TP
1358         insint(d, "IPPROTO_TP", IPPROTO_TP);
1359 #endif
1360 #ifdef  IPPROTO_XTP
1361         insint(d, "IPPROTO_XTP", IPPROTO_XTP);
1362 #endif
1363 #ifdef  IPPROTO_EON
1364         insint(d, "IPPROTO_EON", IPPROTO_EON);
1365 #endif
1366 #ifdef  IPPROTO_BIP
1367         insint(d, "IPPROTO_BIP", IPPROTO_BIP);
1368 #endif
1369 /**/
1370 #ifdef  IPPROTO_RAW
1371         insint(d, "IPPROTO_RAW", IPPROTO_RAW);
1372 #endif
1373 #ifdef  IPPROTO_MAX
1374         insint(d, "IPPROTO_MAX", IPPROTO_MAX);
1375 #endif
1376
1377         /* Some port configuration */
1378 #ifdef  IPPORT_RESERVED
1379         insint(d, "IPPORT_RESERVED", IPPORT_RESERVED);
1380 #else
1381         insint(d, "IPPORT_RESERVED", 1024);
1382 #endif
1383 #ifdef  IPPORT_USERRESERVED
1384         insint(d, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
1385 #else
1386         insint(d, "IPPORT_USERRESERVED", 5000);
1387 #endif
1388
1389         /* Some reserved IP v.4 addresses */
1390 #ifdef  INADDR_ANY
1391         insint(d, "INADDR_ANY", INADDR_ANY);
1392 #else
1393         insint(d, "INADDR_ANY", 0x00000000);
1394 #endif
1395 #ifdef  INADDR_BROADCAST
1396         insint(d, "INADDR_BROADCAST", INADDR_BROADCAST);
1397 #else
1398         insint(d, "INADDR_BROADCAST", 0xffffffff);
1399 #endif
1400 #ifdef  INADDR_LOOPBACK
1401         insint(d, "INADDR_LOOPBACK", INADDR_LOOPBACK);
1402 #else
1403         insint(d, "INADDR_LOOPBACK", 0x7F000001);
1404 #endif
1405 #ifdef  INADDR_UNSPEC_GROUP
1406         insint(d, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
1407 #else
1408         insint(d, "INADDR_UNSPEC_GROUP", 0xe0000000);
1409 #endif
1410 #ifdef  INADDR_ALLHOSTS_GROUP
1411         insint(d, "INADDR_ALLHOSTS_GROUP", INADDR_ALLHOSTS_GROUP);
1412 #else
1413         insint(d, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
1414 #endif
1415 #ifdef  INADDR_MAX_LOCAL_GROUP
1416         insint(d, "INADDR_MAX_LOCAL_GROUP", INADDR_MAX_LOCAL_GROUP);
1417 #else
1418         insint(d, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
1419 #endif
1420 #ifdef  INADDR_NONE
1421         insint(d, "INADDR_NONE", INADDR_NONE);
1422 #else
1423         insint(d, "INADDR_NONE", 0xffffffff);
1424 #endif
1425
1426         /* IP [gs]etsockopt options */
1427 #ifdef  IP_OPTIONS
1428         insint(d, "IP_OPTIONS", IP_OPTIONS);
1429 #endif
1430 #ifdef  IP_HDRINCL
1431         insint(d, "IP_HDRINCL", IP_HDRINCL);
1432 #endif
1433 #ifdef  IP_TOS
1434         insint(d, "IP_TOS", IP_TOS);
1435 #endif
1436 #ifdef  IP_TTL
1437         insint(d, "IP_TTL", IP_TTL);
1438 #endif
1439 #ifdef  IP_RECVOPTS
1440         insint(d, "IP_RECVOPTS", IP_RECVOPTS);
1441 #endif
1442 #ifdef  IP_RECVRETOPTS
1443         insint(d, "IP_RECVRETOPTS", IP_RECVRETOPTS);
1444 #endif
1445 #ifdef  IP_RECVDSTADDR
1446         insint(d, "IP_RECVDSTADDR", IP_RECVDSTADDR);
1447 #endif
1448 #ifdef  IP_RETOPTS
1449         insint(d, "IP_RETOPTS", IP_RETOPTS);
1450 #endif
1451 #ifdef  IP_MULTICAST_IF
1452         insint(d, "IP_MULTICAST_IF", IP_MULTICAST_IF);
1453 #endif
1454 #ifdef  IP_MULTICAST_TTL
1455         insint(d, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
1456 #endif
1457 #ifdef  IP_MULTICAST_LOOP
1458         insint(d, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
1459 #endif
1460 #ifdef  IP_ADD_MEMBERSHIP
1461         insint(d, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
1462 #endif
1463 #ifdef  IP_DROP_MEMBERSHIP
1464         insint(d, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
1465 #endif
1466
1467 #ifdef MS_WIN16
1468 /* All windows sockets require a successful WSAStartup() before use */
1469         {
1470                 const int opt = SO_SYNCHRONOUS_NONALERT;
1471                 WSADATA WSAData;
1472                 int ret;
1473                 ret = WSAStartup(0x0101, &WSAData);     /* request version 1.1 */
1474                 switch(ret){
1475                 case WSASYSNOTREADY:
1476                         PyErr_SetString(PySocket_Error,
1477                                 "WSAStartup failed: Network not ready\n");
1478                         break;
1479                 case WSAVERNOTSUPPORTED:
1480                 case WSAEINVAL:
1481                         PyErr_SetString(PySocket_Error,
1482                                 "WSAStartup failed: Requested version not supported");
1483                         break;
1484                 case 0:
1485                         /* Setup sockets in non-overlapped mode by default */
1486                         if (setsockopt(INVALID_SOCKET,SOL_SOCKET,SO_OPENTYPE,
1487                         (const char *)&opt,sizeof(opt)) != 0)
1488                                 PyErr_SetString(PySocket_Error,
1489                                         "setsockopt failed in initsocket");
1490                         break;
1491                 default:
1492                         PyErr_SetString(PySocket_Error,
1493                                 "WSAStartup failed");
1494                         break;
1495                 }
1496         }
1497 #endif
1498 }
1499
1500 #ifdef NT
1501 BOOL    WINAPI  DllMain (HANDLE hInst,
1502                         ULONG ul_reason_for_call,
1503                         LPVOID lpReserved)
1504 {
1505         const int opt = SO_SYNCHRONOUS_NONALERT;
1506         switch (ul_reason_for_call)
1507         {
1508                 case DLL_PROCESS_ATTACH: {
1509                         WSADATA WSAData;
1510                         BOOL ok = TRUE;
1511                         char buf[100] = "Python can't initialize Windows Sockets Module!\n\r";
1512                         if (WSAStartup(MAKEWORD(1,1), &WSAData)) {
1513                                 wsprintf(buf+strlen(buf), "WSAStartup failed (%d)",WSAGetLastError());
1514                                 ok = FALSE;
1515                         }
1516                         /*
1517                         ** Setup sockets in non-overlapped mode by default
1518                         */
1519 //                      if (ok && setsockopt(INVALID_SOCKET,SOL_SOCKET,SO_OPENTYPE,(const char *)&opt,sizeof(opt)) != 0) {
1520 //                              wsprintf(buf+strlen(buf),"setsockopt failed (%d)",WSAGetLastError());
1521 //                              ok = FALSE;
1522 //                      }
1523                         if (!ok) {
1524                                 MessageBox(NULL,buf,"WinSock Error",MB_OK|MB_SETFOREGROUND);
1525                                 return FALSE;
1526                         }
1527                         break;
1528                 }
1529
1530                 case DLL_PROCESS_DETACH:
1531                         WSACleanup();
1532                         break;
1533
1534         }
1535         return TRUE;
1536 }
1537 #endif /* NT */