blob: f700e9c4e3c2c6b8d1a5e4a9674aee47874cc3a1 [file] [log] [blame]
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001/* Socket module */
2
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00003/* SSL support based on patches by Brian E Gallew and Laszlo Kovacs */
4
Guido van Rossum6574b3e1991-06-25 21:36:08 +00005/*
6This module provides an interface to Berkeley socket IPC.
7
8Limitations:
9
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000010- only AF_INET, AF_INET6 and AF_UNIX address families are supported in a
Jeremy Hylton22308652001-02-02 03:23:09 +000011 portable manner, though AF_PACKET is supported under Linux.
Guido van Rossum81194471991-07-27 21:42:02 +000012- no read/write operations (use send/recv or makefile instead)
Guido van Rossumbe32c891996-06-20 16:25:29 +000013- additional restrictions apply on Windows
Guido van Rossum6574b3e1991-06-25 21:36:08 +000014
Guido van Rossum27e177d1995-03-16 15:43:47 +000015Module interface:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000016
Guido van Rossum27e177d1995-03-16 15:43:47 +000017- socket.error: exception raised for socket specific errors
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000018- socket.gaierror: exception raised for getaddrinfo/getnameinfo errors,
19 a subclass of socket.error
20- socket.herror: exception raised for gethostby* errors,
21 a subclass of socket.error
Guido van Rossum30a685f1991-06-27 15:51:29 +000022- socket.gethostbyname(hostname) --> host IP address (string: 'dd.dd.dd.dd')
Guido van Rossum3bbc62e1995-01-02 19:30:30 +000023- socket.gethostbyaddr(IP address) --> (hostname, [alias, ...], [IP addr, ...])
Guido van Rossum27e177d1995-03-16 15:43:47 +000024- socket.gethostname() --> host name (string: 'spam' or 'spam.domain.com')
Guido van Rossum25405c71996-12-19 16:42:52 +000025- socket.getprotobyname(protocolname) --> protocol number
Guido van Rossum27e177d1995-03-16 15:43:47 +000026- socket.getservbyname(servicename, protocolname) --> port number
Guido van Rossum4dd2a7e1991-07-01 18:51:33 +000027- socket.socket(family, type [, proto]) --> new socket object
Guido van Rossum006bf911996-06-12 04:04:55 +000028- socket.ntohs(16 bit value) --> new int object
29- socket.ntohl(32 bit value) --> new int object
30- socket.htons(16 bit value) --> new int object
31- socket.htonl(32 bit value) --> new int object
Martin v. Löwis2d8d4272001-07-21 18:05:31 +000032- socket.getaddrinfo(host, port [, family, socktype, proto, flags])
33 --> List of (family, socktype, proto, canonname, sockaddr)
34- socket.getnameinfo(sockaddr, flags) --> (host, port)
Guido van Rossum27e177d1995-03-16 15:43:47 +000035- socket.AF_INET, socket.SOCK_STREAM, etc.: constants from <socket.h>
Guido van Rossum5c9eb211999-08-20 18:21:51 +000036- socket.inet_aton(IP address) -> 32-bit packed IP representation
37- socket.inet_ntoa(packed IP) -> IP address string
Guido van Rossum09c8b6c1999-12-07 21:37:17 +000038- socket.ssl(socket, keyfile, certfile) -> new ssl object
Guido van Rossum6574b3e1991-06-25 21:36:08 +000039- an Internet socket address is a pair (hostname, port)
40 where hostname can be anything recognized by gethostbyname()
41 (including the dd.dd.dd.dd notation) and port is in host byte order
42- where a hostname is returned, the dd.dd.dd.dd notation is used
Guido van Rossum27e177d1995-03-16 15:43:47 +000043- a UNIX domain socket address is a string specifying the pathname
Jeremy Hylton22308652001-02-02 03:23:09 +000044- an AF_PACKET socket address is a tuple containing a string
45 specifying the ethernet interface and an integer specifying
46 the Ethernet protocol number to be received. For example:
Jeremy Hyltondbfb6622001-02-02 19:55:17 +000047 ("eth0",0x1234). Optional 3rd,4th,5th elements in the tuple
48 specify packet-type and ha-type/addr -- these are ignored by
Jeremy Hylton22308652001-02-02 03:23:09 +000049 networking code, but accepted since they are returned by the
50 getsockname() method.
Guido van Rossum6574b3e1991-06-25 21:36:08 +000051
Guido van Rossum30a685f1991-06-27 15:51:29 +000052Socket methods:
Guido van Rossum6574b3e1991-06-25 21:36:08 +000053
Guido van Rossum81194471991-07-27 21:42:02 +000054- s.accept() --> new socket object, sockaddr
Fred Drake728819a2000-07-01 03:40:12 +000055- s.bind(sockaddr) --> None
Guido van Rossum27e177d1995-03-16 15:43:47 +000056- s.close() --> None
Fred Drake728819a2000-07-01 03:40:12 +000057- s.connect(sockaddr) --> None
58- s.connect_ex(sockaddr) --> 0 or errno (handy for e.g. async connect)
Guido van Rossum27e177d1995-03-16 15:43:47 +000059- s.fileno() --> file descriptor
Guido van Rossumbe32c891996-06-20 16:25:29 +000060- s.dup() --> same as socket.fromfd(os.dup(s.fileno(), ...)
Guido van Rossumc89705d1992-11-26 08:54:07 +000061- s.getpeername() --> sockaddr
Guido van Rossum27e177d1995-03-16 15:43:47 +000062- s.getsockname() --> sockaddr
63- s.getsockopt(level, optname[, buflen]) --> int or string
64- s.listen(backlog) --> None
Guido van Rossum6b144911995-03-14 15:05:13 +000065- s.makefile([mode[, bufsize]]) --> file object
Guido van Rossum27e177d1995-03-16 15:43:47 +000066- s.recv(buflen [,flags]) --> string
67- s.recvfrom(buflen [,flags]) --> string, sockaddr
Guido van Rossumb6775db1994-08-01 11:34:53 +000068- s.send(string [,flags]) --> nbytes
69- s.sendto(string, [flags,] sockaddr) --> nbytes
Guido van Rossum27e177d1995-03-16 15:43:47 +000070- s.setblocking(0 | 1) --> None
71- s.setsockopt(level, optname, value) --> None
72- s.shutdown(how) --> None
Guido van Rossum3bbc62e1995-01-02 19:30:30 +000073- repr(s) --> "<socket object, fd=%d, family=%d, type=%d, protocol=%d>"
Guido van Rossum30a685f1991-06-27 15:51:29 +000074
Guido van Rossum6574b3e1991-06-25 21:36:08 +000075*/
76
Guido van Rossum73624e91994-10-10 17:59:00 +000077#include "Python.h"
Guido van Rossum3baaa131999-03-22 21:44:51 +000078
Guido van Rossum9376b741999-09-15 22:01:40 +000079/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
80 script doesn't get this right, so we hardcode some platform checks below.
81 On the other hand, not all Linux versions agree, so there the settings
82 computed by the configure script are needed! */
83
84#ifndef linux
Guido van Rossume7de2061999-03-24 17:24:33 +000085#undef HAVE_GETHOSTBYNAME_R_3_ARG
86#undef HAVE_GETHOSTBYNAME_R_5_ARG
87#undef HAVE_GETHOSTBYNAME_R_6_ARG
Guido van Rossum9376b741999-09-15 22:01:40 +000088#endif
Guido van Rossume7de2061999-03-24 17:24:33 +000089
Guido van Rossum7a122991999-04-13 04:07:32 +000090#ifndef WITH_THREAD
91#undef HAVE_GETHOSTBYNAME_R
92#endif
93
Guido van Rossume7de2061999-03-24 17:24:33 +000094#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7a122991999-04-13 04:07:32 +000095#if defined(_AIX) || defined(__osf__)
Guido van Rossume7de2061999-03-24 17:24:33 +000096#define HAVE_GETHOSTBYNAME_R_3_ARG
Martin v. Löwis1c07b4b2001-10-13 09:00:42 +000097#elif defined(__sun) || defined(__sgi)
Guido van Rossume7de2061999-03-24 17:24:33 +000098#define HAVE_GETHOSTBYNAME_R_5_ARG
99#elif defined(linux)
Guido van Rossum9376b741999-09-15 22:01:40 +0000100/* Rely on the configure script */
Guido van Rossume7de2061999-03-24 17:24:33 +0000101#else
102#undef HAVE_GETHOSTBYNAME_R
103#endif
104#endif
105
Guido van Rossum3baaa131999-03-22 21:44:51 +0000106#if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && !defined(MS_WINDOWS)
107#define USE_GETHOSTBYNAME_LOCK
108#endif
109
110#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum49b56061998-10-01 20:42:43 +0000111#include "pythread.h"
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000112#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000113
Guido van Rossuma376cc51996-12-05 23:43:35 +0000114#ifdef HAVE_UNISTD_H
115#include <unistd.h>
116#endif
117
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000118#if defined(PYCC_VACPP)
119#include <types.h>
120#include <io.h>
121#include <sys/ioctl.h>
122#include <utils.h>
123#include <ctype.h>
124#endif
125
126#if defined(PYOS_OS2)
127#define INCL_DOS
128#define INCL_DOSERRORS
129#define INCL_NOPMAPI
130#include <os2.h>
131#endif
132
Guido van Rossum48a680c2001-03-02 06:34:14 +0000133#ifdef RISCOS
134#define NO_DUP
135#undef off_t
136#undef uid_t
137#undef gid_t
138#undef errno
139#include <signal.h>
140#include "socklib.h"
141#include "inetlib.h"
142#include "netdb.h"
143#include "unixlib.h"
144#include "netinet/in.h"
145#include "sys/ioctl.h"
146#else /*RISCOS*/
147
Guido van Rossumb6775db1994-08-01 11:34:53 +0000148#include <sys/types.h>
Guido van Rossumed233a51992-06-23 09:07:03 +0000149
Guido van Rossum81194471991-07-27 21:42:02 +0000150#include <signal.h>
Guido van Rossum6f489d91996-06-28 20:15:15 +0000151#ifndef MS_WINDOWS
Guido van Rossumb6775db1994-08-01 11:34:53 +0000152#include <netdb.h>
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000153#include <sys/socket.h>
154#include <netinet/in.h>
Fred Drake51d90362000-10-06 15:37:06 +0000155#if !(defined(__BEOS__) || defined(__CYGWIN__))
Andrew M. Kuchling52a644c2000-03-31 17:24:30 +0000156#include <netinet/tcp.h>
Fred Drake11b09362000-05-16 13:30:12 +0000157#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000158
Guido van Rossum9376b741999-09-15 22:01:40 +0000159/* Headers needed for inet_ntoa() and inet_addr() */
160#ifdef __BEOS__
161#include <net/netdb.h>
162#else
Guido van Rossumff3ab422000-04-24 15:16:03 +0000163#ifndef USE_GUSI1
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000164#include <arpa/inet.h>
Guido van Rossum9376b741999-09-15 22:01:40 +0000165#endif
Guido van Rossum1b6e4631999-11-04 18:22:29 +0000166#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +0000167
Guido van Rossume4485b01994-09-07 14:32:49 +0000168#include <fcntl.h>
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000169#else
170#include <winsock.h>
Guido van Rossum30b6b2b1995-06-14 22:28:08 +0000171#include <fcntl.h>
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000172#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000173
174#endif /*RISCOS*/
175
Guido van Rossumb6775db1994-08-01 11:34:53 +0000176#ifdef HAVE_SYS_UN_H
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000177#include <sys/un.h>
Guido van Rossumb6775db1994-08-01 11:34:53 +0000178#else
179#undef AF_UNIX
Guido van Rossum9575a441993-04-07 14:06:14 +0000180#endif
181
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +0000182#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +0000183#include <sys/ioctl.h>
184#include <net/if.h>
185#include <netpacket/packet.h>
186#endif
187
Martin v. Löwisa45ecae2001-06-24 21:28:42 +0000188#ifdef HAVE_STDDEF_H
189#include <stddef.h>
190#endif
191
192#ifndef offsetof
193#define offsetof(type, member) ((size_t)(&((type *)0)->member))
194#endif
195
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000196#ifndef O_NDELAY
197#define O_NDELAY O_NONBLOCK /* For QNX only? */
198#endif
199
Guido van Rossumff3ab422000-04-24 15:16:03 +0000200#ifdef USE_GUSI1
Jack Jansen508537b1996-02-14 15:57:45 +0000201/* fdopen() isn't declared in stdio.h (sigh) */
202#include <GUSI.h>
203#endif
204
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000205#include "addrinfo.h"
206
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000207#ifdef USE_SSL
Andrew M. Kuchling697a0b02001-01-18 17:41:41 +0000208#include "openssl/rsa.h"
209#include "openssl/crypto.h"
210#include "openssl/x509.h"
211#include "openssl/pem.h"
212#include "openssl/ssl.h"
213#include "openssl/err.h"
Jeremy Hyltonde80f2e2001-10-18 00:28:50 +0000214#include "openssl/rand.h"
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000215#endif /* USE_SSL */
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000216
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000217#ifndef HAVE_INET_PTON
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000218int inet_pton (int af, const char *src, void *dst);
219const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000220#endif
221
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000222#ifdef __APPLE__
223/* On OS X, getaddrinfo returns no error indication of lookup
224 failure, so we must use the emulation instead of the libinfo
225 implementation. Unfortunately, performing an autoconf test
226 for this bug would require DNS access for the machine performing
227 the configuration, which is not acceptable. Therefore, we
228 determine the bug just by checking for __APPLE__. If this bug
229 gets ever fixed, perhaps checking for sys/version.h would be
230 appropriate, which is 10/0 on the system with the bug. */
231#undef HAVE_GETADDRINFO
232/* avoid clashes with the C library definition of the symbol. */
233#define getaddrinfo fake_getaddrinfo
234#endif
235
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000236/* I know this is a bad practice, but it is the easiest... */
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000237#if !defined(HAVE_GETADDRINFO)
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000238#include "getaddrinfo.c"
239#endif
Martin v. Löwisae26dc22001-08-03 10:02:29 +0000240#if !defined(HAVE_GETNAMEINFO)
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000241#include "getnameinfo.c"
242#endif
243
Guido van Rossumbcc20741998-08-04 22:53:56 +0000244#if defined(MS_WINDOWS) || defined(__BEOS__)
245/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000246/* seem to be a few differences in the API */
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000247#define SOCKETCLOSE closesocket
Guido van Rossumbe32c891996-06-20 16:25:29 +0000248#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000249#endif
250
Fred Drakea04eaad2000-06-30 02:46:07 +0000251/* abstract the socket file descriptor type */
252#ifdef MS_WINDOWS
253typedef SOCKET SOCKET_T;
254# ifdef MS_WIN64
255# define SIZEOF_SOCKET_T 8
256# else
257# define SIZEOF_SOCKET_T 4
258# endif
259#else
260typedef int SOCKET_T;
261# define SIZEOF_SOCKET_T SIZEOF_INT
262#endif
263
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000264#ifdef MS_WIN32
265# define EAFNOSUPPORT WSAEAFNOSUPPORT
266# define snprintf _snprintf
267#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000268
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000269#if defined(PYOS_OS2)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000270#define SOCKETCLOSE soclose
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000271#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000272#endif
273
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000274#ifndef SOCKETCLOSE
275#define SOCKETCLOSE close
276#endif
277
Guido van Rossum30a685f1991-06-27 15:51:29 +0000278/* Global variable holding the exception type for errors detected
279 by this module (but not argument type or memory errors, etc.). */
280
Guido van Rossum73624e91994-10-10 17:59:00 +0000281static PyObject *PySocket_Error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000282static PyObject *PyH_Error;
283static PyObject *PyGAI_Error;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000284
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000285#ifdef USE_SSL
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +0000286static PyObject *PySSLErrorObject;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000287#endif /* USE_SSL */
288
Guido van Rossum30a685f1991-06-27 15:51:29 +0000289
Guido van Rossum48a680c2001-03-02 06:34:14 +0000290#ifdef RISCOS
291/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
292static int taskwindow;
293#endif
294
295
Guido van Rossum30a685f1991-06-27 15:51:29 +0000296/* Convenience function to raise an error according to errno
297 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000298
Guido van Rossum73624e91994-10-10 17:59:00 +0000299static PyObject *
Thomas Woutersf3f33dc2000-07-21 06:00:07 +0000300PySocket_Err(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000301{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000302#ifdef MS_WINDOWS
Mark Hammond46a733d2000-07-24 01:45:11 +0000303 int err_no = WSAGetLastError();
304 if (err_no) {
305 static struct { int no; const char *msg; } *msgp, msgs[] = {
306 { WSAEINTR, "Interrupted system call" },
307 { WSAEBADF, "Bad file descriptor" },
308 { WSAEACCES, "Permission denied" },
309 { WSAEFAULT, "Bad address" },
310 { WSAEINVAL, "Invalid argument" },
311 { WSAEMFILE, "Too many open files" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000312 { WSAEWOULDBLOCK,
Mark Hammond46a733d2000-07-24 01:45:11 +0000313 "The socket operation could not complete "
314 "without blocking" },
315 { WSAEINPROGRESS, "Operation now in progress" },
316 { WSAEALREADY, "Operation already in progress" },
317 { WSAENOTSOCK, "Socket operation on non-socket" },
318 { WSAEDESTADDRREQ, "Destination address required" },
319 { WSAEMSGSIZE, "Message too long" },
320 { WSAEPROTOTYPE, "Protocol wrong type for socket" },
321 { WSAENOPROTOOPT, "Protocol not available" },
322 { WSAEPROTONOSUPPORT, "Protocol not supported" },
323 { WSAESOCKTNOSUPPORT, "Socket type not supported" },
324 { WSAEOPNOTSUPP, "Operation not supported" },
325 { WSAEPFNOSUPPORT, "Protocol family not supported" },
326 { WSAEAFNOSUPPORT, "Address family not supported" },
327 { WSAEADDRINUSE, "Address already in use" },
328 { WSAEADDRNOTAVAIL,
329 "Can't assign requested address" },
330 { WSAENETDOWN, "Network is down" },
331 { WSAENETUNREACH, "Network is unreachable" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000332 { WSAENETRESET,
Mark Hammond46a733d2000-07-24 01:45:11 +0000333 "Network dropped connection on reset" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000334 { WSAECONNABORTED,
Mark Hammond46a733d2000-07-24 01:45:11 +0000335 "Software caused connection abort" },
336 { WSAECONNRESET, "Connection reset by peer" },
337 { WSAENOBUFS, "No buffer space available" },
338 { WSAEISCONN, "Socket is already connected" },
339 { WSAENOTCONN, "Socket is not connected" },
340 { WSAESHUTDOWN, "Can't send after socket shutdown" },
341 { WSAETOOMANYREFS,
342 "Too many references: can't splice" },
343 { WSAETIMEDOUT, "Operation timed out" },
344 { WSAECONNREFUSED, "Connection refused" },
345 { WSAELOOP, "Too many levels of symbolic links" },
346 { WSAENAMETOOLONG, "File name too long" },
347 { WSAEHOSTDOWN, "Host is down" },
348 { WSAEHOSTUNREACH, "No route to host" },
349 { WSAENOTEMPTY, "Directory not empty" },
350 { WSAEPROCLIM, "Too many processes" },
351 { WSAEUSERS, "Too many users" },
352 { WSAEDQUOT, "Disc quota exceeded" },
353 { WSAESTALE, "Stale NFS file handle" },
354 { WSAEREMOTE, "Too many levels of remote in path" },
355 { WSASYSNOTREADY,
356 "Network subsystem is unvailable" },
357 { WSAVERNOTSUPPORTED,
358 "WinSock version is not supported" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000359 { WSANOTINITIALISED,
Mark Hammond46a733d2000-07-24 01:45:11 +0000360 "Successful WSAStartup() not yet performed" },
361 { WSAEDISCON, "Graceful shutdown in progress" },
362 /* Resolver errors */
363 { WSAHOST_NOT_FOUND, "No such host is known" },
364 { WSATRY_AGAIN, "Host not found, or server failed" },
365 { WSANO_RECOVERY,
366 "Unexpected server error encountered" },
367 { WSANO_DATA, "Valid name without requested data" },
368 { WSANO_ADDRESS, "No address, look for MX record" },
369 { 0, NULL }
370 };
Guido van Rossum73624e91994-10-10 17:59:00 +0000371 PyObject *v;
Mark Hammond46a733d2000-07-24 01:45:11 +0000372 const char *msg = "winsock error";
Guido van Rossum48a680c2001-03-02 06:34:14 +0000373
Mark Hammond46a733d2000-07-24 01:45:11 +0000374 for (msgp = msgs; msgp->msg; msgp++) {
375 if (err_no == msgp->no) {
376 msg = msgp->msg;
377 break;
378 }
379 }
380
381 v = Py_BuildValue("(is)", err_no, msg);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000382 if (v != NULL) {
Guido van Rossum73624e91994-10-10 17:59:00 +0000383 PyErr_SetObject(PySocket_Error, v);
384 Py_DECREF(v);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000385 }
386 return NULL;
387 }
388 else
389#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000390
391#if defined(PYOS_OS2)
392 if (sock_errno() != NO_ERROR) {
393 APIRET rc;
394 ULONG msglen;
395 char outbuf[100];
396 int myerrorcode = sock_errno();
397
398 /* Retrieve Socket-Related Error Message from MPTN.MSG File */
399 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
400 myerrorcode - SOCBASEERR + 26, "mptn.msg", &msglen);
401 if (rc == NO_ERROR) {
402 PyObject *v;
403
404 outbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
405 if (strlen(outbuf) > 0) { /* If Non-Empty Msg, Trim CRLF */
406 char *lastc = &outbuf[ strlen(outbuf)-1 ];
407 while (lastc > outbuf && isspace(*lastc))
408 *lastc-- = '\0'; /* Trim Trailing Whitespace (CRLF) */
409 }
410 v = Py_BuildValue("(is)", myerrorcode, outbuf);
411 if (v != NULL) {
412 PyErr_SetObject(PySocket_Error, v);
413 Py_DECREF(v);
414 }
415 return NULL;
416 }
417 }
418#endif
419
Guido van Rossum73624e91994-10-10 17:59:00 +0000420 return PyErr_SetFromErrno(PySocket_Error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000421}
422
Guido van Rossum30a685f1991-06-27 15:51:29 +0000423
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000424static PyObject *
425PyH_Err(int h_error)
426{
427 PyObject *v;
428
429#ifdef HAVE_HSTRERROR
430 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
431#else
432 v = Py_BuildValue("(is)", h_error, "host not found");
433#endif
434 if (v != NULL) {
Martin v. Löwis864e9ff2001-08-04 22:32:03 +0000435 PyErr_SetObject(PyH_Error, v);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000436 Py_DECREF(v);
437 }
438
439 return NULL;
440}
441
442
443static PyObject *
444PyGAI_Err(int error)
445{
446 PyObject *v;
447
448 if (error == EAI_SYSTEM)
449 return PySocket_Err();
450
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000451#ifdef HAVE_GAI_STRERROR
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000452 v = Py_BuildValue("(is)", error, gai_strerror(error));
Martin v. Löwisf95dd0a2001-08-15 17:14:33 +0000453#else
454 v = Py_BuildValue("(is)", error, "getaddrinfo failed");
455#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000456 if (v != NULL) {
457 PyErr_SetObject(PyGAI_Error, v);
458 Py_DECREF(v);
459 }
460
461 return NULL;
462}
463
464
Guido van Rossum30a685f1991-06-27 15:51:29 +0000465/* The object holding a socket. It holds some extra information,
466 like the address family, which is used to decode socket address
467 arguments properly. */
468
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000469typedef struct {
Guido van Rossum73624e91994-10-10 17:59:00 +0000470 PyObject_HEAD
Fred Drakea04eaad2000-06-30 02:46:07 +0000471 SOCKET_T sock_fd; /* Socket file descriptor */
Guido van Rossum30a685f1991-06-27 15:51:29 +0000472 int sock_family; /* Address family, e.g., AF_INET */
473 int sock_type; /* Socket type, e.g., SOCK_STREAM */
474 int sock_proto; /* Protocol type, usually 0 */
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000475 union sock_addr {
476 struct sockaddr_in in;
477#ifdef AF_UNIX
478 struct sockaddr_un un;
479#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000480#ifdef INET6
481 struct sockaddr_in6 in6;
482 struct sockaddr_storage storage;
483#endif
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +0000484#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +0000485 struct sockaddr_ll ll;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000486#endif
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000487 } sock_addr;
Guido van Rossum73624e91994-10-10 17:59:00 +0000488} PySocketSockObject;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000489
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000490#ifdef USE_SSL
Guido van Rossum30a685f1991-06-27 15:51:29 +0000491
Jeremy Hyltonba699362001-10-11 17:23:34 +0000492#define X509_NAME_MAXLEN 256
493
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000494typedef struct {
495 PyObject_HEAD
496 PySocketSockObject *Socket; /* Socket on which we're layered */
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000497 SSL_CTX* ctx;
498 SSL* ssl;
499 X509* server_cert;
500 BIO* sbio;
Jeremy Hyltonba699362001-10-11 17:23:34 +0000501 char server[X509_NAME_MAXLEN];
502 char issuer[X509_NAME_MAXLEN];
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000503
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +0000504} PySSLObject;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000505
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +0000506staticforward PyTypeObject PySSL_Type;
507staticforward PyObject *PySSL_SSLwrite(PySSLObject *self, PyObject *args);
508staticforward PyObject *PySSL_SSLread(PySSLObject *self, PyObject *args);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000509
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +0000510#define PySSLObject_Check(v) ((v)->ob_type == &PySSL_Type)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000511
512#endif /* USE_SSL */
Guido van Rossum48a680c2001-03-02 06:34:14 +0000513
Guido van Rossum30a685f1991-06-27 15:51:29 +0000514/* A forward reference to the Socktype type object.
515 The Socktype variable contains pointers to various functions,
Guido van Rossum73624e91994-10-10 17:59:00 +0000516 some of which call newsockobject(), which uses Socktype, so
Guido van Rossum54ba21b1991-09-10 14:57:12 +0000517 there has to be a circular reference. */
Guido van Rossum30a685f1991-06-27 15:51:29 +0000518
Guido van Rossum73624e91994-10-10 17:59:00 +0000519staticforward PyTypeObject PySocketSock_Type;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000520
Guido van Rossum30a685f1991-06-27 15:51:29 +0000521
522/* Create a new socket object.
523 This just creates the object and initializes it.
524 If the creation fails, return NULL and set an exception (implicit
525 in NEWOBJ()). */
526
Guido van Rossum73624e91994-10-10 17:59:00 +0000527static PySocketSockObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +0000528PySocketSock_New(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000529{
Guido van Rossum48a680c2001-03-02 06:34:14 +0000530#ifdef RISCOS
531 int block = 1;
532#endif
Guido van Rossum73624e91994-10-10 17:59:00 +0000533 PySocketSockObject *s;
Guido van Rossum55558541996-05-23 22:54:50 +0000534 PySocketSock_Type.ob_type = &PyType_Type;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000535 s = PyObject_New(PySocketSockObject, &PySocketSock_Type);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000536 if (s != NULL) {
537 s->sock_fd = fd;
538 s->sock_family = family;
539 s->sock_type = type;
540 s->sock_proto = proto;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000541#ifdef RISCOS
542 if(taskwindow) {
543 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
544 }
545#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000546 }
547 return s;
548}
549
Guido van Rossum30a685f1991-06-27 15:51:29 +0000550
Guido van Rossum48a680c2001-03-02 06:34:14 +0000551/* Lock to allow python interpreter to continue, but only allow one
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000552 thread to be in gethostbyname */
Guido van Rossum3baaa131999-03-22 21:44:51 +0000553#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum65d5b571998-12-21 19:32:43 +0000554PyThread_type_lock gethostbyname_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000555#endif
556
557
Guido van Rossum30a685f1991-06-27 15:51:29 +0000558/* Convert a string specifying a host name or one of a few symbolic
559 names to a numeric IP address. This usually calls gethostbyname()
560 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000561 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000562 an error occurred; then an exception is raised. */
563
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000564static int
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000565setipaddr(char* name, struct sockaddr * addr_ret, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000566{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000567 struct addrinfo hints, *res;
568 int error;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000569
Guido van Rossuma376cc51996-12-05 23:43:35 +0000570 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
Guido van Rossum30a685f1991-06-27 15:51:29 +0000571 if (name[0] == '\0') {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000572 int siz;
573 memset(&hints, 0, sizeof(hints));
574 hints.ai_family = af;
575 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
576 hints.ai_flags = AI_PASSIVE;
577 error = getaddrinfo(NULL, "0", &hints, &res);
578 if (error) {
579 PyGAI_Err(error);
580 return -1;
581 }
582 switch (res->ai_family) {
583 case AF_INET:
584 siz = 4;
585 break;
586#ifdef INET6
587 case AF_INET6:
588 siz = 16;
589 break;
590#endif
591 default:
592 freeaddrinfo(res);
593 PyErr_SetString(PySocket_Error,
594 "unsupported address family");
595 return -1;
596 }
597 if (res->ai_next) {
598 PyErr_SetString(PySocket_Error,
599 "wildcard resolved to multiple address");
600 return -1;
601 }
602 memcpy(addr_ret, res->ai_addr, res->ai_addrlen);
603 freeaddrinfo(res);
604 return siz;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000605 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000606 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000607 struct sockaddr_in *sin;
608 if (af != PF_INET && af != PF_UNSPEC) {
609 PyErr_SetString(PySocket_Error,
610 "address family mismatched");
611 return -1;
612 }
613 sin = (struct sockaddr_in *)addr_ret;
614 memset((void *) sin, '\0', sizeof(*sin));
615 sin->sin_family = AF_INET;
616#ifdef HAVE_SOCKADDR_SA_LEN
617 sin->sin_len = sizeof(*sin);
618#endif
619 sin->sin_addr.s_addr = INADDR_BROADCAST;
620 return sizeof(sin->sin_addr);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000621 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000622 memset(&hints, 0, sizeof(hints));
623 hints.ai_family = af;
624 error = getaddrinfo(name, NULL, &hints, &res);
Martin v. Löwis861a65b2001-10-24 14:36:00 +0000625 if (error = EAI_NONAME && af == AF_UNSPEC) {
626 /* On OSF/1 V5.1, numeric-to-addr conversion
627 fails if no address family is given. Assume IPv4 for now.*/
628 hints.ai_family = AF_INET;
629 error = getaddrinfo(name, NULL, &hints, &res);
630 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000631 if (error) {
632 PyGAI_Err(error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000633 return -1;
634 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000635 memcpy((char *) addr_ret, res->ai_addr, res->ai_addrlen);
636 freeaddrinfo(res);
637 switch (addr_ret->sa_family) {
638 case AF_INET:
639 return 4;
640#ifdef INET6
641 case AF_INET6:
642 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +0000643#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000644 default:
645 PyErr_SetString(PySocket_Error, "unknown address family");
646 return -1;
647 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000648}
649
Guido van Rossum30a685f1991-06-27 15:51:29 +0000650
Guido van Rossum30a685f1991-06-27 15:51:29 +0000651/* Create a string object representing an IP address.
652 This is always a string of the form 'dd.dd.dd.dd' (with variable
653 size numbers). */
654
Guido van Rossum73624e91994-10-10 17:59:00 +0000655static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000656makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000657{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000658 char buf[NI_MAXHOST];
659 int error;
660
661 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
662 NI_NUMERICHOST);
663 if (error) {
664 PyGAI_Err(error);
665 return NULL;
666 }
Guido van Rossum73624e91994-10-10 17:59:00 +0000667 return PyString_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +0000668}
669
670
671/* Create an object representing the given socket address,
672 suitable for passing it back to bind(), connect() etc.
673 The family field of the sockaddr structure is inspected
674 to determine what kind of address it really is. */
675
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000676/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +0000677static PyObject *
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000678makesockaddr(int sockfd, struct sockaddr *addr, int addrlen)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000679{
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000680 if (addrlen == 0) {
681 /* No address -- may be recvfrom() from known socket */
Guido van Rossum73624e91994-10-10 17:59:00 +0000682 Py_INCREF(Py_None);
683 return Py_None;
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000684 }
685
Guido van Rossumbcc20741998-08-04 22:53:56 +0000686#ifdef __BEOS__
Guido van Rossum2c8bcb82000-04-25 21:34:53 +0000687 /* XXX: BeOS version of accept() doesn't set family correctly */
Guido van Rossumbcc20741998-08-04 22:53:56 +0000688 addr->sa_family = AF_INET;
689#endif
690
Guido van Rossum30a685f1991-06-27 15:51:29 +0000691 switch (addr->sa_family) {
692
693 case AF_INET:
694 {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000695 struct sockaddr_in *a;
696 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
Barry Warsaw752300b1997-01-03 17:18:10 +0000697 PyObject *ret = NULL;
698 if (addrobj) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000699 a = (struct sockaddr_in *)addr;
Barry Warsaw752300b1997-01-03 17:18:10 +0000700 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
701 Py_DECREF(addrobj);
702 }
Guido van Rossum6f5afc91993-02-05 09:46:15 +0000703 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000704 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000705
Guido van Rossumb6775db1994-08-01 11:34:53 +0000706#ifdef AF_UNIX
Guido van Rossum30a685f1991-06-27 15:51:29 +0000707 case AF_UNIX:
708 {
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000709 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Guido van Rossum73624e91994-10-10 17:59:00 +0000710 return PyString_FromString(a->sun_path);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000711 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000712#endif /* AF_UNIX */
713
714#ifdef INET6
715 case AF_INET6:
716 {
717 struct sockaddr_in6 *a;
718 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
719 PyObject *ret = NULL;
720 if (addrobj) {
721 a = (struct sockaddr_in6 *)addr;
722 ret = Py_BuildValue("Oiii", addrobj, ntohs(a->sin6_port),
723 a->sin6_flowinfo, a->sin6_scope_id);
724 Py_DECREF(addrobj);
725 }
726 return ret;
727 }
Jeremy Hylton22308652001-02-02 03:23:09 +0000728#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +0000729
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +0000730#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +0000731 case AF_PACKET:
732 {
733 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
734 char *ifname = "";
735 struct ifreq ifr;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000736 /* need to look up interface name give index */
737 if (a->sll_ifindex) {
Jeremy Hylton22308652001-02-02 03:23:09 +0000738 ifr.ifr_ifindex = a->sll_ifindex;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000739 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
Jeremy Hylton22308652001-02-02 03:23:09 +0000740 ifname = ifr.ifr_name;
Jeremy Hylton22308652001-02-02 03:23:09 +0000741 }
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000742 return Py_BuildValue("shbhs#", ifname, ntohs(a->sll_protocol),
Guido van Rossum48a680c2001-03-02 06:34:14 +0000743 a->sll_pkttype, a->sll_hatype,
744 a->sll_addr, a->sll_halen);
Jeremy Hylton22308652001-02-02 03:23:09 +0000745 }
746#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000747
Guido van Rossum30a685f1991-06-27 15:51:29 +0000748 /* More cases here... */
749
750 default:
Guido van Rossumaa948df1997-05-07 17:41:48 +0000751 /* If we don't know the address family, don't raise an
752 exception -- return it as a tuple. */
753 return Py_BuildValue("is#",
754 addr->sa_family,
755 addr->sa_data,
756 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000757
Guido van Rossum30a685f1991-06-27 15:51:29 +0000758 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000759}
760
Guido van Rossum30a685f1991-06-27 15:51:29 +0000761
762/* Parse a socket address argument according to the socket object's
763 address family. Return 1 if the address was in the proper format,
764 0 of not. The address is returned through addr_ret, its length
765 through len_ret. */
766
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000767static int
Guido van Rossum48a680c2001-03-02 06:34:14 +0000768getsockaddrarg(PySocketSockObject *s, PyObject *args,
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000769 struct sockaddr **addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000770{
Guido van Rossum30a685f1991-06-27 15:51:29 +0000771 switch (s->sock_family) {
772
Guido van Rossumb6775db1994-08-01 11:34:53 +0000773#ifdef AF_UNIX
Guido van Rossum30a685f1991-06-27 15:51:29 +0000774 case AF_UNIX:
775 {
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000776 struct sockaddr_un* addr;
Guido van Rossumff4949e1992-08-05 19:58:53 +0000777 char *path;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000778 int len;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000779 addr = (struct sockaddr_un* )&(s->sock_addr).un;
Guido van Rossum7e488981998-10-08 02:25:24 +0000780 if (!PyArg_Parse(args, "t#", &path, &len))
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000781 return 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000782 if (len > sizeof addr->sun_path) {
Barry Warsaw752300b1997-01-03 17:18:10 +0000783 PyErr_SetString(PySocket_Error,
784 "AF_UNIX path too long");
Guido van Rossum30a685f1991-06-27 15:51:29 +0000785 return 0;
786 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000787 addr->sun_family = s->sock_family;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000788 memcpy(addr->sun_path, path, len);
Guido van Rossum30b6b2b1995-06-14 22:28:08 +0000789 addr->sun_path[len] = 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000790 *addr_ret = (struct sockaddr *) addr;
Guido van Rossum65af28a1996-06-11 18:36:33 +0000791 *len_ret = len + sizeof(*addr) - sizeof(addr->sun_path);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000792 return 1;
793 }
Guido van Rossumb6775db1994-08-01 11:34:53 +0000794#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000795
Guido van Rossum30a685f1991-06-27 15:51:29 +0000796 case AF_INET:
797 {
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000798 struct sockaddr_in* addr;
Guido van Rossumff4949e1992-08-05 19:58:53 +0000799 char *host;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000800 int port;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000801 addr=(struct sockaddr_in*)&(s->sock_addr).in;
Guido van Rossume4dad902000-12-01 13:13:11 +0000802 if (!PyTuple_Check(args)) {
803 PyErr_Format(PyExc_TypeError,
804 "getsockaddrarg: AF_INET address must be tuple, not %.500s",
805 args->ob_type->tp_name);
806 return 0;
807 }
808 if (!PyArg_ParseTuple(args, "si:getsockaddrarg", &host, &port))
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000809 return 0;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000810 if (setipaddr(host, (struct sockaddr *)addr, AF_INET) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000811 return 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000812 addr->sin_family = AF_INET;
Guido van Rossum644a12b1997-04-09 19:24:53 +0000813 addr->sin_port = htons((short)port);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000814 *addr_ret = (struct sockaddr *) addr;
815 *len_ret = sizeof *addr;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000816 return 1;
817 }
818
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000819#ifdef INET6
820 case AF_INET6:
821 {
822 struct sockaddr_in6* addr;
823 char *host;
824 int port, flowinfo, scope_id;
825 addr = (struct sockaddr_in6*)&(s->sock_addr).in6;
826 flowinfo = scope_id = 0;
827 if (!PyArg_ParseTuple(args, "si|ii", &host, &port, &flowinfo,
828 &scope_id)) {
829 return 0;
830 }
831 if (setipaddr(host, (struct sockaddr *)addr, AF_INET6) < 0)
832 return 0;
833 addr->sin6_family = s->sock_family;
834 addr->sin6_port = htons((short)port);
835 addr->sin6_flowinfo = flowinfo;
836 addr->sin6_scope_id = scope_id;
837 *addr_ret = (struct sockaddr *) addr;
838 *len_ret = sizeof *addr;
839 return 1;
840 }
841#endif
842
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +0000843#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +0000844 case AF_PACKET:
845 {
846 struct sockaddr_ll* addr;
847 struct ifreq ifr;
848 char *interfaceName;
849 int protoNumber;
850 int hatype = 0;
851 int pkttype = 0;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000852 char *haddr;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000853
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000854 if (!PyArg_ParseTuple(args, "si|iis", &interfaceName,
855 &protoNumber, &pkttype, &hatype, &haddr))
Jeremy Hylton22308652001-02-02 03:23:09 +0000856 return 0;
857 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
858 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000859 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
Jeremy Hyltone2adc6c2001-10-11 17:27:58 +0000860 PySocket_Err();
Jeremy Hylton22308652001-02-02 03:23:09 +0000861 return 0;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000862 }
Jeremy Hylton22308652001-02-02 03:23:09 +0000863 addr = &(s->sock_addr.ll);
864 addr->sll_family = AF_PACKET;
865 addr->sll_protocol = htons((short)protoNumber);
866 addr->sll_ifindex = ifr.ifr_ifindex;
867 addr->sll_pkttype = pkttype;
868 addr->sll_hatype = hatype;
869 *addr_ret = (struct sockaddr *) addr;
870 *len_ret = sizeof *addr;
871 return 1;
872 }
Guido van Rossum48a680c2001-03-02 06:34:14 +0000873#endif
874
Guido van Rossum30a685f1991-06-27 15:51:29 +0000875 /* More cases here... */
876
877 default:
Guido van Rossum73624e91994-10-10 17:59:00 +0000878 PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
Guido van Rossum30a685f1991-06-27 15:51:29 +0000879 return 0;
880
881 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000882}
883
Guido van Rossum30a685f1991-06-27 15:51:29 +0000884
Guido van Rossum48a680c2001-03-02 06:34:14 +0000885/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +0000886 Return 1 if the family is known, 0 otherwise. The length is returned
887 through len_ret. */
888
889static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +0000890getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +0000891{
892 switch (s->sock_family) {
893
Guido van Rossumb6775db1994-08-01 11:34:53 +0000894#ifdef AF_UNIX
Guido van Rossum710e1df1992-06-12 10:39:36 +0000895 case AF_UNIX:
896 {
897 *len_ret = sizeof (struct sockaddr_un);
898 return 1;
899 }
Guido van Rossumb6775db1994-08-01 11:34:53 +0000900#endif /* AF_UNIX */
Guido van Rossum710e1df1992-06-12 10:39:36 +0000901
902 case AF_INET:
903 {
904 *len_ret = sizeof (struct sockaddr_in);
905 return 1;
906 }
907
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000908#ifdef INET6
909 case AF_INET6:
910 {
911 *len_ret = sizeof (struct sockaddr_in6);
912 return 1;
913 }
914#endif
915
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +0000916#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +0000917 case AF_PACKET:
918 {
919 *len_ret = sizeof (struct sockaddr_ll);
920 return 1;
921 }
922#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000923
Guido van Rossum710e1df1992-06-12 10:39:36 +0000924 /* More cases here... */
925
926 default:
Guido van Rossum27fc3c02000-03-24 20:56:56 +0000927 PyErr_SetString(PySocket_Error, "getsockaddrlen: bad family");
Guido van Rossum710e1df1992-06-12 10:39:36 +0000928 return 0;
929
930 }
931}
932
933
Guido van Rossum30a685f1991-06-27 15:51:29 +0000934/* s.accept() method */
935
Guido van Rossum73624e91994-10-10 17:59:00 +0000936static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +0000937PySocketSock_accept(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000938{
939 char addrbuf[256];
Fred Drakea04eaad2000-06-30 02:46:07 +0000940 SOCKET_T newfd;
Guido van Rossumff3ab422000-04-24 15:16:03 +0000941 socklen_t addrlen;
Barry Warsaw752300b1997-01-03 17:18:10 +0000942 PyObject *sock = NULL;
943 PyObject *addr = NULL;
944 PyObject *res = NULL;
945
Guido van Rossum710e1df1992-06-12 10:39:36 +0000946 if (!getsockaddrlen(s, &addrlen))
947 return NULL;
Fred Drakefd168342001-05-09 19:11:33 +0000948 memset(addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +0000949 Py_BEGIN_ALLOW_THREADS
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000950 newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +0000951 Py_END_ALLOW_THREADS
Fred Drakea04eaad2000-06-30 02:46:07 +0000952#ifdef MS_WINDOWS
953 if (newfd == INVALID_SOCKET)
954#else
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000955 if (newfd < 0)
Fred Drakea04eaad2000-06-30 02:46:07 +0000956#endif
Guido van Rossum73624e91994-10-10 17:59:00 +0000957 return PySocket_Err();
Barry Warsaw752300b1997-01-03 17:18:10 +0000958
Guido van Rossum30a685f1991-06-27 15:51:29 +0000959 /* Create the new object with unspecified family,
960 to avoid calls to bind() etc. on it. */
Guido van Rossum73624e91994-10-10 17:59:00 +0000961 sock = (PyObject *) PySocketSock_New(newfd,
Guido van Rossum6f5afc91993-02-05 09:46:15 +0000962 s->sock_family,
963 s->sock_type,
964 s->sock_proto);
Barry Warsaw752300b1997-01-03 17:18:10 +0000965 if (sock == NULL) {
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000966 SOCKETCLOSE(newfd);
Barry Warsaw752300b1997-01-03 17:18:10 +0000967 goto finally;
968 }
Guido van Rossum48a680c2001-03-02 06:34:14 +0000969 addr = makesockaddr(s->sock_fd, (struct sockaddr *)addrbuf,
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000970 addrlen);
971 if (addr == NULL)
Barry Warsaw752300b1997-01-03 17:18:10 +0000972 goto finally;
973
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000974 res = Py_BuildValue("OO", sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +0000975
976 finally:
Guido van Rossum73624e91994-10-10 17:59:00 +0000977 Py_XDECREF(sock);
978 Py_XDECREF(addr);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000979 return res;
980}
981
Guido van Rossum82a5c661998-07-07 20:45:43 +0000982static char accept_doc[] =
983"accept() -> (socket object, address info)\n\
984\n\
985Wait for an incoming connection. Return a new socket representing the\n\
986connection, and the address of the client. For IP sockets, the address\n\
987info is a pair (hostaddr, port).";
988
Guido van Rossum30a685f1991-06-27 15:51:29 +0000989
Guido van Rossume4485b01994-09-07 14:32:49 +0000990/* s.setblocking(1 | 0) method */
991
Guido van Rossum73624e91994-10-10 17:59:00 +0000992static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +0000993PySocketSock_setblocking(PySocketSockObject *s, PyObject *arg)
Guido van Rossume4485b01994-09-07 14:32:49 +0000994{
995 int block;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000996#ifndef RISCOS
Guido van Rossum644a12b1997-04-09 19:24:53 +0000997#ifndef MS_WINDOWS
Guido van Rossume4485b01994-09-07 14:32:49 +0000998 int delay_flag;
Guido van Rossum644a12b1997-04-09 19:24:53 +0000999#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001000#endif
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001001 block = PyInt_AsLong(arg);
1002 if (block == -1 && PyErr_Occurred())
Guido van Rossume4485b01994-09-07 14:32:49 +00001003 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001004 Py_BEGIN_ALLOW_THREADS
Guido van Rossumbcc20741998-08-04 22:53:56 +00001005#ifdef __BEOS__
1006 block = !block;
1007 setsockopt( s->sock_fd, SOL_SOCKET, SO_NONBLOCK,
1008 (void *)(&block), sizeof( int ) );
1009#else
Guido van Rossum48a680c2001-03-02 06:34:14 +00001010#ifndef RISCOS
Guido van Rossum6f489d91996-06-28 20:15:15 +00001011#ifndef MS_WINDOWS
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00001012#ifdef PYOS_OS2
1013 block = !block;
1014 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
1015#else /* !PYOS_OS2 */
Guido van Rossume4485b01994-09-07 14:32:49 +00001016 delay_flag = fcntl (s->sock_fd, F_GETFL, 0);
1017 if (block)
1018 delay_flag &= (~O_NDELAY);
1019 else
1020 delay_flag |= O_NDELAY;
1021 fcntl (s->sock_fd, F_SETFL, delay_flag);
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00001022#endif /* !PYOS_OS2 */
1023#else /* MS_WINDOWS */
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00001024 block = !block;
1025 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00001026#endif /* MS_WINDOWS */
Guido van Rossumbcc20741998-08-04 22:53:56 +00001027#endif /* __BEOS__ */
Guido van Rossum48a680c2001-03-02 06:34:14 +00001028#endif /* RISCOS */
Guido van Rossum73624e91994-10-10 17:59:00 +00001029 Py_END_ALLOW_THREADS
Guido van Rossume4485b01994-09-07 14:32:49 +00001030
Guido van Rossum73624e91994-10-10 17:59:00 +00001031 Py_INCREF(Py_None);
1032 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00001033}
Guido van Rossume4485b01994-09-07 14:32:49 +00001034
Guido van Rossum82a5c661998-07-07 20:45:43 +00001035static char setblocking_doc[] =
1036"setblocking(flag)\n\
1037\n\
1038Set the socket to blocking (flag is true) or non-blocking (false).\n\
1039This uses the FIONBIO ioctl with the O_NDELAY flag.";
1040
Guido van Rossume4485b01994-09-07 14:32:49 +00001041
Guido van Rossum48a680c2001-03-02 06:34:14 +00001042#ifdef RISCOS
1043/* s.sleeptaskw(1 | 0) method */
1044
1045static PyObject *
1046PySocketSock_sleeptaskw(PySocketSockObject *s,PyObject *args)
1047{
1048 int block;
1049 int delay_flag;
1050 if (!PyArg_GetInt(args, &block))
1051 return NULL;
1052 Py_BEGIN_ALLOW_THREADS
1053 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
1054 Py_END_ALLOW_THREADS
1055
1056 Py_INCREF(Py_None);
1057 return Py_None;
1058}
1059static char sleeptaskw_doc[] =
1060"sleeptaskw(flag)\n\
1061\n\
1062Allow sleeps in taskwindows.";
1063#endif
1064
1065
Guido van Rossumaee08791992-09-08 09:05:33 +00001066/* s.setsockopt() method.
1067 With an integer third argument, sets an integer option.
1068 With a string third argument, sets an option from a buffer;
1069 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001070
Guido van Rossum73624e91994-10-10 17:59:00 +00001071static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001072PySocketSock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001073{
1074 int level;
1075 int optname;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001076 int res;
Guido van Rossumaee08791992-09-08 09:05:33 +00001077 char *buf;
1078 int buflen;
1079 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001080
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001081 if (PyArg_ParseTuple(args, "iii:setsockopt",
1082 &level, &optname, &flag)) {
Guido van Rossumaee08791992-09-08 09:05:33 +00001083 buf = (char *) &flag;
1084 buflen = sizeof flag;
1085 }
1086 else {
Guido van Rossum73624e91994-10-10 17:59:00 +00001087 PyErr_Clear();
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001088 if (!PyArg_ParseTuple(args, "iis#:setsockopt",
1089 &level, &optname, &buf, &buflen))
Guido van Rossumaee08791992-09-08 09:05:33 +00001090 return NULL;
1091 }
Thomas Wouters334fb892000-07-25 12:56:38 +00001092 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001093 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001094 return PySocket_Err();
1095 Py_INCREF(Py_None);
1096 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001097}
1098
Guido van Rossum82a5c661998-07-07 20:45:43 +00001099static char setsockopt_doc[] =
1100"setsockopt(level, option, value)\n\
1101\n\
1102Set a socket option. See the Unix manual for level and option.\n\
1103The value argument can either be an integer or a string.";
1104
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001105
Guido van Rossumaee08791992-09-08 09:05:33 +00001106/* s.getsockopt() method.
1107 With two arguments, retrieves an integer option.
1108 With a third integer argument, retrieves a string buffer of that size;
1109 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001110
Guido van Rossum73624e91994-10-10 17:59:00 +00001111static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001112PySocketSock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001113{
1114 int level;
1115 int optname;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001116 int res;
Guido van Rossum73624e91994-10-10 17:59:00 +00001117 PyObject *buf;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001118 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001119
Guido van Rossumbcc20741998-08-04 22:53:56 +00001120#ifdef __BEOS__
Fred Drake564a6cc2001-05-11 20:12:26 +00001121 /* We have incomplete socket support. */
1122 PyErr_SetString(PySocket_Error, "getsockopt not supported");
Guido van Rossumbcc20741998-08-04 22:53:56 +00001123 return NULL;
1124#else
1125
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001126 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1127 &level, &optname, &buflen))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001128 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001129
Guido van Rossumbe32c891996-06-20 16:25:29 +00001130 if (buflen == 0) {
Guido van Rossumaee08791992-09-08 09:05:33 +00001131 int flag = 0;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001132 socklen_t flagsize = sizeof flag;
Guido van Rossumb376a4a1993-11-23 17:53:17 +00001133 res = getsockopt(s->sock_fd, level, optname,
Thomas Wouters334fb892000-07-25 12:56:38 +00001134 (void *)&flag, &flagsize);
Guido van Rossumaee08791992-09-08 09:05:33 +00001135 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001136 return PySocket_Err();
1137 return PyInt_FromLong(flag);
Guido van Rossumaee08791992-09-08 09:05:33 +00001138 }
Guido van Rossumaee08791992-09-08 09:05:33 +00001139 if (buflen <= 0 || buflen > 1024) {
Barry Warsaw752300b1997-01-03 17:18:10 +00001140 PyErr_SetString(PySocket_Error,
1141 "getsockopt buflen out of range");
Guido van Rossumaee08791992-09-08 09:05:33 +00001142 return NULL;
1143 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001144 buf = PyString_FromStringAndSize((char *)NULL, buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001145 if (buf == NULL)
1146 return NULL;
Guido van Rossumb376a4a1993-11-23 17:53:17 +00001147 res = getsockopt(s->sock_fd, level, optname,
Fred Drake564a6cc2001-05-11 20:12:26 +00001148 (void *)PyString_AS_STRING(buf), &buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001149 if (res < 0) {
Guido van Rossum73624e91994-10-10 17:59:00 +00001150 Py_DECREF(buf);
1151 return PySocket_Err();
Guido van Rossumaee08791992-09-08 09:05:33 +00001152 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001153 _PyString_Resize(&buf, buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001154 return buf;
Guido van Rossumbcc20741998-08-04 22:53:56 +00001155#endif /* __BEOS__ */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001156}
1157
Guido van Rossum82a5c661998-07-07 20:45:43 +00001158static char getsockopt_doc[] =
1159"getsockopt(level, option[, buffersize]) -> value\n\
1160\n\
1161Get a socket option. See the Unix manual for level and option.\n\
1162If a nonzero buffersize argument is given, the return value is a\n\
1163string of that length; otherwise it is an integer.";
1164
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001165
Fred Drake728819a2000-07-01 03:40:12 +00001166/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001167
Guido van Rossum73624e91994-10-10 17:59:00 +00001168static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001169PySocketSock_bind(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001170{
1171 struct sockaddr *addr;
1172 int addrlen;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001173 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001174
Fred Drake728819a2000-07-01 03:40:12 +00001175 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001176 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001177 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001178 res = bind(s->sock_fd, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001179 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001180 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001181 return PySocket_Err();
1182 Py_INCREF(Py_None);
1183 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001184}
1185
Guido van Rossum82a5c661998-07-07 20:45:43 +00001186static char bind_doc[] =
1187"bind(address)\n\
1188\n\
1189Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00001190pair (host, port); the host must refer to the local host. For raw packet\n\
1191sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])";
Guido van Rossum82a5c661998-07-07 20:45:43 +00001192
Guido van Rossum30a685f1991-06-27 15:51:29 +00001193
1194/* s.close() method.
1195 Set the file descriptor to -1 so operations tried subsequently
1196 will surely fail. */
1197
Guido van Rossum73624e91994-10-10 17:59:00 +00001198static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001199PySocketSock_close(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001200{
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001201 SOCKET_T fd;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001202
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001203 if ((fd = s->sock_fd) != -1) {
1204 s->sock_fd = -1;
Guido van Rossum08481461996-10-12 14:07:22 +00001205 Py_BEGIN_ALLOW_THREADS
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001206 (void) SOCKETCLOSE(fd);
Guido van Rossum08481461996-10-12 14:07:22 +00001207 Py_END_ALLOW_THREADS
1208 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001209 Py_INCREF(Py_None);
1210 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001211}
1212
Guido van Rossum82a5c661998-07-07 20:45:43 +00001213static char close_doc[] =
1214"close()\n\
1215\n\
1216Close the socket. It cannot be used after this call.";
1217
Guido van Rossum30a685f1991-06-27 15:51:29 +00001218
Fred Drake728819a2000-07-01 03:40:12 +00001219/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001220
Guido van Rossum73624e91994-10-10 17:59:00 +00001221static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001222PySocketSock_connect(PySocketSockObject *s, PyObject *addro)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001223{
1224 struct sockaddr *addr;
1225 int addrlen;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001226 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001227
Fred Drake728819a2000-07-01 03:40:12 +00001228 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001229 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001230 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001231 res = connect(s->sock_fd, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001232 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001233 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001234 return PySocket_Err();
1235 Py_INCREF(Py_None);
1236 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001237}
1238
Guido van Rossum82a5c661998-07-07 20:45:43 +00001239static char connect_doc[] =
1240"connect(address)\n\
1241\n\
1242Connect the socket to a remote address. For IP sockets, the address\n\
1243is a pair (host, port).";
1244
Guido van Rossum30a685f1991-06-27 15:51:29 +00001245
Fred Drake728819a2000-07-01 03:40:12 +00001246/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001247
1248static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001249PySocketSock_connect_ex(PySocketSockObject *s, PyObject *addro)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001250{
1251 struct sockaddr *addr;
1252 int addrlen;
1253 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001254
Fred Drake728819a2000-07-01 03:40:12 +00001255 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001256 return NULL;
1257 Py_BEGIN_ALLOW_THREADS
1258 res = connect(s->sock_fd, addr, addrlen);
1259 Py_END_ALLOW_THREADS
1260 if (res != 0)
1261 res = errno;
1262 return PyInt_FromLong((long) res);
1263}
1264
Guido van Rossum82a5c661998-07-07 20:45:43 +00001265static char connect_ex_doc[] =
1266"connect_ex(address)\n\
1267\n\
1268This is like connect(address), but returns an error code (the errno value)\n\
1269instead of raising an exception when an error occurs.";
1270
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001271
Guido van Rossumed233a51992-06-23 09:07:03 +00001272/* s.fileno() method */
1273
Guido van Rossum73624e91994-10-10 17:59:00 +00001274static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001275PySocketSock_fileno(PySocketSockObject *s)
Guido van Rossumed233a51992-06-23 09:07:03 +00001276{
Fred Drakea04eaad2000-06-30 02:46:07 +00001277#if SIZEOF_SOCKET_T <= SIZEOF_LONG
Guido van Rossum73624e91994-10-10 17:59:00 +00001278 return PyInt_FromLong((long) s->sock_fd);
Fred Drakea04eaad2000-06-30 02:46:07 +00001279#else
1280 return PyLong_FromLongLong((LONG_LONG)s->sock_fd);
1281#endif
Guido van Rossumed233a51992-06-23 09:07:03 +00001282}
1283
Guido van Rossum82a5c661998-07-07 20:45:43 +00001284static char fileno_doc[] =
1285"fileno() -> integer\n\
1286\n\
1287Return the integer file descriptor of the socket.";
1288
Guido van Rossumed233a51992-06-23 09:07:03 +00001289
Guido van Rossumbe32c891996-06-20 16:25:29 +00001290#ifndef NO_DUP
1291/* s.dup() method */
1292
1293static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001294PySocketSock_dup(PySocketSockObject *s)
Guido van Rossumbe32c891996-06-20 16:25:29 +00001295{
Fred Drakea04eaad2000-06-30 02:46:07 +00001296 SOCKET_T newfd;
Guido van Rossumbe32c891996-06-20 16:25:29 +00001297 PyObject *sock;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001298
Guido van Rossumbe32c891996-06-20 16:25:29 +00001299 newfd = dup(s->sock_fd);
1300 if (newfd < 0)
1301 return PySocket_Err();
1302 sock = (PyObject *) PySocketSock_New(newfd,
Barry Warsaw752300b1997-01-03 17:18:10 +00001303 s->sock_family,
1304 s->sock_type,
1305 s->sock_proto);
Guido van Rossumbe32c891996-06-20 16:25:29 +00001306 if (sock == NULL)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001307 SOCKETCLOSE(newfd);
Guido van Rossumbe32c891996-06-20 16:25:29 +00001308 return sock;
1309}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001310
1311static char dup_doc[] =
1312"dup() -> socket object\n\
1313\n\
1314Return a new socket object connected to the same system resource.";
1315
Guido van Rossumbe32c891996-06-20 16:25:29 +00001316#endif
1317
1318
Guido van Rossumc89705d1992-11-26 08:54:07 +00001319/* s.getsockname() method */
1320
Guido van Rossum73624e91994-10-10 17:59:00 +00001321static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001322PySocketSock_getsockname(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00001323{
1324 char addrbuf[256];
Guido van Rossumff3ab422000-04-24 15:16:03 +00001325 int res;
1326 socklen_t addrlen;
1327
Guido van Rossumc89705d1992-11-26 08:54:07 +00001328 if (!getsockaddrlen(s, &addrlen))
1329 return NULL;
Guido van Rossumca42b161996-01-12 01:36:05 +00001330 memset(addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001331 Py_BEGIN_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001332 res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001333 Py_END_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001334 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001335 return PySocket_Err();
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001336 return makesockaddr(s->sock_fd, (struct sockaddr *) addrbuf, addrlen);
Guido van Rossumc89705d1992-11-26 08:54:07 +00001337}
1338
Guido van Rossum82a5c661998-07-07 20:45:43 +00001339static char getsockname_doc[] =
1340"getsockname() -> address info\n\
1341\n\
1342Return the address of the local endpoint. For IP sockets, the address\n\
1343info is a pair (hostaddr, port).";
1344
Guido van Rossumc89705d1992-11-26 08:54:07 +00001345
Guido van Rossumb6775db1994-08-01 11:34:53 +00001346#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00001347/* s.getpeername() method */
1348
Guido van Rossum73624e91994-10-10 17:59:00 +00001349static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001350PySocketSock_getpeername(PySocketSockObject *s)
Guido van Rossumc89705d1992-11-26 08:54:07 +00001351{
1352 char addrbuf[256];
Guido van Rossumff3ab422000-04-24 15:16:03 +00001353 int res;
1354 socklen_t addrlen;
1355
Guido van Rossumc89705d1992-11-26 08:54:07 +00001356 if (!getsockaddrlen(s, &addrlen))
1357 return NULL;
Fred Drakefd168342001-05-09 19:11:33 +00001358 memset(addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001359 Py_BEGIN_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001360 res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001361 Py_END_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001362 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001363 return PySocket_Err();
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001364 return makesockaddr(s->sock_fd, (struct sockaddr *) addrbuf, addrlen);
Guido van Rossumc89705d1992-11-26 08:54:07 +00001365}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001366
1367static char getpeername_doc[] =
1368"getpeername() -> address info\n\
1369\n\
1370Return the address of the remote endpoint. For IP sockets, the address\n\
1371info is a pair (hostaddr, port).";
1372
Guido van Rossumb6775db1994-08-01 11:34:53 +00001373#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00001374
1375
Guido van Rossum30a685f1991-06-27 15:51:29 +00001376/* s.listen(n) method */
1377
Guido van Rossum73624e91994-10-10 17:59:00 +00001378static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001379PySocketSock_listen(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001380{
1381 int backlog;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001382 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001383
1384 backlog = PyInt_AsLong(arg);
1385 if (backlog == -1 && PyErr_Occurred())
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001386 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001387 Py_BEGIN_ALLOW_THREADS
Guido van Rossumb6775db1994-08-01 11:34:53 +00001388 if (backlog < 1)
1389 backlog = 1;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001390 res = listen(s->sock_fd, backlog);
Guido van Rossum73624e91994-10-10 17:59:00 +00001391 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001392 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001393 return PySocket_Err();
1394 Py_INCREF(Py_None);
1395 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001396}
1397
Guido van Rossum82a5c661998-07-07 20:45:43 +00001398static char listen_doc[] =
1399"listen(backlog)\n\
1400\n\
1401Enable a server to accept connections. The backlog argument must be at\n\
1402least 1; it specifies the number of unaccepted connection that the system\n\
1403will allow before refusing new connections.";
1404
1405
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001406#ifndef NO_DUP
Guido van Rossum30a685f1991-06-27 15:51:29 +00001407/* s.makefile(mode) method.
1408 Create a new open file object referring to a dupped version of
1409 the socket's file descriptor. (The dup() call is necessary so
1410 that the open file and socket objects may be closed independent
1411 of each other.)
1412 The mode argument specifies 'r' or 'w' passed to fdopen(). */
1413
Guido van Rossum73624e91994-10-10 17:59:00 +00001414static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001415PySocketSock_makefile(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001416{
Tim Petersdbd9ba62000-07-09 03:09:57 +00001417 extern int fclose(FILE *);
Guido van Rossum6b144911995-03-14 15:05:13 +00001418 char *mode = "r";
1419 int bufsize = -1;
Fred Drakea04eaad2000-06-30 02:46:07 +00001420#ifdef MS_WIN32
Tim Peters79248aa2001-08-29 21:37:10 +00001421 Py_intptr_t fd;
Fred Drakea04eaad2000-06-30 02:46:07 +00001422#else
Guido van Rossum30a685f1991-06-27 15:51:29 +00001423 int fd;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001424#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001425 FILE *fp;
Guido van Rossum6b144911995-03-14 15:05:13 +00001426 PyObject *f;
1427
Guido van Rossum43713e52000-02-29 13:59:29 +00001428 if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001429 return NULL;
Guido van Rossum8d665e61996-06-26 18:22:49 +00001430#ifdef MS_WIN32
Guido van Rossum82a5c661998-07-07 20:45:43 +00001431 if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) ||
1432 ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL))
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00001433#else
Guido van Rossum82a5c661998-07-07 20:45:43 +00001434 if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL)
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00001435#endif
Guido van Rossum82a5c661998-07-07 20:45:43 +00001436 {
Guido van Rossum6b144911995-03-14 15:05:13 +00001437 if (fd >= 0)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001438 SOCKETCLOSE(fd);
Guido van Rossum73624e91994-10-10 17:59:00 +00001439 return PySocket_Err();
Guido van Rossum6b144911995-03-14 15:05:13 +00001440 }
1441 f = PyFile_FromFile(fp, "<socket>", mode, fclose);
1442 if (f != NULL)
1443 PyFile_SetBufSize(f, bufsize);
1444 return f;
Guido van Rossum30a685f1991-06-27 15:51:29 +00001445}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001446
1447static char makefile_doc[] =
1448"makefile([mode[, buffersize]]) -> file object\n\
1449\n\
1450Return a regular file object corresponding to the socket.\n\
1451The mode and buffersize arguments are as for the built-in open() function.";
1452
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001453#endif /* NO_DUP */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001454
Guido van Rossum48a680c2001-03-02 06:34:14 +00001455
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001456/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001457
Guido van Rossum73624e91994-10-10 17:59:00 +00001458static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001459PySocketSock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001460{
Guido van Rossumbe32c891996-06-20 16:25:29 +00001461 int len, n, flags = 0;
Guido van Rossum73624e91994-10-10 17:59:00 +00001462 PyObject *buf;
Guido van Rossum43713e52000-02-29 13:59:29 +00001463 if (!PyArg_ParseTuple(args, "i|i:recv", &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001464 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001465 buf = PyString_FromStringAndSize((char *) 0, len);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001466 if (buf == NULL)
1467 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001468 Py_BEGIN_ALLOW_THREADS
Jeremy Hylton1ba6bad2001-08-20 19:06:36 +00001469 n = recv(s->sock_fd, PyString_AS_STRING(buf), len, flags);
Guido van Rossum73624e91994-10-10 17:59:00 +00001470 Py_END_ALLOW_THREADS
Guido van Rossum7c53b771995-09-13 18:39:47 +00001471 if (n < 0) {
1472 Py_DECREF(buf);
Guido van Rossum73624e91994-10-10 17:59:00 +00001473 return PySocket_Err();
Guido van Rossum7c53b771995-09-13 18:39:47 +00001474 }
Guido van Rossum53a9bf81996-06-11 18:35:24 +00001475 if (n != len && _PyString_Resize(&buf, n) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001476 return NULL;
1477 return buf;
1478}
1479
Guido van Rossum82a5c661998-07-07 20:45:43 +00001480static char recv_doc[] =
1481"recv(buffersize[, flags]) -> data\n\
1482\n\
1483Receive up to buffersize bytes from the socket. For the optional flags\n\
1484argument, see the Unix manual. When no data is available, block until\n\
1485at least one byte is available or until the remote end is closed. When\n\
1486the remote end is closed and all data is read, return the empty string.";
1487
Guido van Rossum30a685f1991-06-27 15:51:29 +00001488
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001489/* s.recvfrom(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001490
Guido van Rossum73624e91994-10-10 17:59:00 +00001491static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001492PySocketSock_recvfrom(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001493{
1494 char addrbuf[256];
Barry Warsaw752300b1997-01-03 17:18:10 +00001495 PyObject *buf = NULL;
1496 PyObject *addr = NULL;
1497 PyObject *ret = NULL;
1498
Guido van Rossumff3ab422000-04-24 15:16:03 +00001499 int len, n, flags = 0;
1500 socklen_t addrlen;
Guido van Rossum43713e52000-02-29 13:59:29 +00001501 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001502 return NULL;
Guido van Rossum18c9a4f1993-05-25 12:16:29 +00001503 if (!getsockaddrlen(s, &addrlen))
1504 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001505 buf = PyString_FromStringAndSize((char *) 0, len);
Guido van Rossum18c9a4f1993-05-25 12:16:29 +00001506 if (buf == NULL)
1507 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001508 Py_BEGIN_ALLOW_THREADS
Fred Drakefd168342001-05-09 19:11:33 +00001509 memset(addrbuf, 0, addrlen);
1510 n = recvfrom(s->sock_fd, PyString_AS_STRING(buf), len, flags,
Guido van Rossum8d665e61996-06-26 18:22:49 +00001511#ifndef MS_WINDOWS
Guido van Rossum32c575d1997-12-02 20:37:32 +00001512#if defined(PYOS_OS2)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00001513 (struct sockaddr *)addrbuf, &addrlen
Guido van Rossum32c575d1997-12-02 20:37:32 +00001514#else
Thomas Wouters334fb892000-07-25 12:56:38 +00001515 (void *)addrbuf, &addrlen
Guido van Rossum32c575d1997-12-02 20:37:32 +00001516#endif
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001517#else
Barry Warsaw752300b1997-01-03 17:18:10 +00001518 (struct sockaddr *)addrbuf, &addrlen
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001519#endif
Barry Warsaw752300b1997-01-03 17:18:10 +00001520 );
Guido van Rossum73624e91994-10-10 17:59:00 +00001521 Py_END_ALLOW_THREADS
Guido van Rossum7c53b771995-09-13 18:39:47 +00001522 if (n < 0) {
1523 Py_DECREF(buf);
Guido van Rossum73624e91994-10-10 17:59:00 +00001524 return PySocket_Err();
Guido van Rossum7c53b771995-09-13 18:39:47 +00001525 }
Guido van Rossum53a9bf81996-06-11 18:35:24 +00001526 if (n != len && _PyString_Resize(&buf, n) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001527 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001528
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001529 if (!(addr = makesockaddr(s->sock_fd, (struct sockaddr *)addrbuf, addrlen)))
Barry Warsaw752300b1997-01-03 17:18:10 +00001530 goto finally;
1531
Guido van Rossum73624e91994-10-10 17:59:00 +00001532 ret = Py_BuildValue("OO", buf, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00001533 finally:
Guido van Rossum73624e91994-10-10 17:59:00 +00001534 Py_XDECREF(addr);
1535 Py_XDECREF(buf);
Guido van Rossum6f5afc91993-02-05 09:46:15 +00001536 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001537}
1538
Guido van Rossum82a5c661998-07-07 20:45:43 +00001539static char recvfrom_doc[] =
1540"recvfrom(buffersize[, flags]) -> (data, address info)\n\
1541\n\
1542Like recv(buffersize, flags) but also return the sender's address info.";
1543
Guido van Rossum30a685f1991-06-27 15:51:29 +00001544
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001545/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001546
Guido van Rossum73624e91994-10-10 17:59:00 +00001547static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001548PySocketSock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001549{
Guido van Rossumff4949e1992-08-05 19:58:53 +00001550 char *buf;
Guido van Rossumbe32c891996-06-20 16:25:29 +00001551 int len, n, flags = 0;
Guido van Rossum43713e52000-02-29 13:59:29 +00001552 if (!PyArg_ParseTuple(args, "s#|i:send", &buf, &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001553 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001554 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001555 n = send(s->sock_fd, buf, len, flags);
Guido van Rossum73624e91994-10-10 17:59:00 +00001556 Py_END_ALLOW_THREADS
Guido van Rossum30a685f1991-06-27 15:51:29 +00001557 if (n < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001558 return PySocket_Err();
1559 return PyInt_FromLong((long)n);
Guido van Rossum30a685f1991-06-27 15:51:29 +00001560}
1561
Guido van Rossum82a5c661998-07-07 20:45:43 +00001562static char send_doc[] =
1563"send(data[, flags])\n\
1564\n\
1565Send a data string to the socket. For the optional flags\n\
1566argument, see the Unix manual.";
1567
Guido van Rossum30a685f1991-06-27 15:51:29 +00001568
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001569/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001570
Guido van Rossum73624e91994-10-10 17:59:00 +00001571static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001572PySocketSock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001573{
Guido van Rossum73624e91994-10-10 17:59:00 +00001574 PyObject *addro;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001575 char *buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001576 struct sockaddr *addr;
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001577 int addrlen, len, n, flags;
1578 flags = 0;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001579 if (!PyArg_ParseTuple(args, "s#O:sendto", &buf, &len, &addro)) {
Guido van Rossum73624e91994-10-10 17:59:00 +00001580 PyErr_Clear();
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001581 if (!PyArg_ParseTuple(args, "s#iO:sendto",
1582 &buf, &len, &flags, &addro))
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001583 return NULL;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001584 }
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001585 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001586 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001587 Py_BEGIN_ALLOW_THREADS
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001588 n = sendto(s->sock_fd, buf, len, flags, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001589 Py_END_ALLOW_THREADS
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001590 if (n < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001591 return PySocket_Err();
1592 return PyInt_FromLong((long)n);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001593}
1594
Guido van Rossum82a5c661998-07-07 20:45:43 +00001595static char sendto_doc[] =
1596"sendto(data[, flags], address)\n\
1597\n\
1598Like send(data, flags) but allows specifying the destination address.\n\
1599For IP sockets, the address is a pair (hostaddr, port).";
1600
Guido van Rossum30a685f1991-06-27 15:51:29 +00001601
1602/* s.shutdown(how) method */
1603
Guido van Rossum73624e91994-10-10 17:59:00 +00001604static PyObject *
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001605PySocketSock_shutdown(PySocketSockObject *s, PyObject *arg)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001606{
1607 int how;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001608 int res;
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001609
1610 how = PyInt_AsLong(arg);
1611 if (how == -1 && PyErr_Occurred())
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001612 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001613 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001614 res = shutdown(s->sock_fd, how);
Guido van Rossum73624e91994-10-10 17:59:00 +00001615 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001616 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001617 return PySocket_Err();
1618 Py_INCREF(Py_None);
1619 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001620}
1621
Guido van Rossum82a5c661998-07-07 20:45:43 +00001622static char shutdown_doc[] =
1623"shutdown(flag)\n\
1624\n\
1625Shut down the reading side of the socket (flag == 0), the writing side\n\
1626of the socket (flag == 1), or both ends (flag == 2).";
1627
Guido van Rossum30a685f1991-06-27 15:51:29 +00001628
1629/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001630
Guido van Rossum73624e91994-10-10 17:59:00 +00001631static PyMethodDef PySocketSock_methods[] = {
Guido van Rossum17209fc2001-10-15 21:12:54 +00001632 {"accept", (PyCFunction)PySocketSock_accept, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001633 accept_doc},
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001634 {"bind", (PyCFunction)PySocketSock_bind, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001635 bind_doc},
Guido van Rossum17209fc2001-10-15 21:12:54 +00001636 {"close", (PyCFunction)PySocketSock_close, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001637 close_doc},
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001638 {"connect", (PyCFunction)PySocketSock_connect, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001639 connect_doc},
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001640 {"connect_ex", (PyCFunction)PySocketSock_connect_ex, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001641 connect_ex_doc},
Guido van Rossumbe32c891996-06-20 16:25:29 +00001642#ifndef NO_DUP
Guido van Rossum17209fc2001-10-15 21:12:54 +00001643 {"dup", (PyCFunction)PySocketSock_dup, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001644 dup_doc},
Guido van Rossumbe32c891996-06-20 16:25:29 +00001645#endif
Guido van Rossum17209fc2001-10-15 21:12:54 +00001646 {"fileno", (PyCFunction)PySocketSock_fileno, METH_NOARGS,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001647 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00001648#ifdef HAVE_GETPEERNAME
Guido van Rossum17209fc2001-10-15 21:12:54 +00001649 {"getpeername", (PyCFunction)PySocketSock_getpeername,
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001650 METH_NOARGS, getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00001651#endif
Guido van Rossum17209fc2001-10-15 21:12:54 +00001652 {"getsockname", (PyCFunction)PySocketSock_getsockname,
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001653 METH_NOARGS, getsockname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00001654 {"getsockopt", (PyCFunction)PySocketSock_getsockopt, METH_VARARGS,
1655 getsockopt_doc},
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001656 {"listen", (PyCFunction)PySocketSock_listen, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001657 listen_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001658#ifndef NO_DUP
Guido van Rossum48a680c2001-03-02 06:34:14 +00001659 {"makefile", (PyCFunction)PySocketSock_makefile, METH_VARARGS,
1660 makefile_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001661#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001662 {"recv", (PyCFunction)PySocketSock_recv, METH_VARARGS,
1663 recv_doc},
1664 {"recvfrom", (PyCFunction)PySocketSock_recvfrom, METH_VARARGS,
1665 recvfrom_doc},
1666 {"send", (PyCFunction)PySocketSock_send, METH_VARARGS,
1667 send_doc},
1668 {"sendto", (PyCFunction)PySocketSock_sendto, METH_VARARGS,
1669 sendto_doc},
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001670 {"setblocking", (PyCFunction)PySocketSock_setblocking, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001671 setblocking_doc},
1672 {"setsockopt", (PyCFunction)PySocketSock_setsockopt, METH_VARARGS,
1673 setsockopt_doc},
Jeremy Hyltonae0013d2001-10-11 16:36:35 +00001674 {"shutdown", (PyCFunction)PySocketSock_shutdown, METH_O,
Guido van Rossum48a680c2001-03-02 06:34:14 +00001675 shutdown_doc},
1676#ifdef RISCOS
1677 {"sleeptaskw", (PyCFunction)PySocketSock_sleeptaskw, METH_VARARGS,
1678 sleeptaskw_doc},
1679#endif
Guido van Rossumb6775db1994-08-01 11:34:53 +00001680 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001681};
1682
Guido van Rossum30a685f1991-06-27 15:51:29 +00001683
Guido van Rossum73624e91994-10-10 17:59:00 +00001684/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00001685 First close the file description. */
1686
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001687static void
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001688PySocketSock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001689{
Guido van Rossumfa972c92000-04-10 12:45:45 +00001690 if (s->sock_fd != -1)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001691 (void) SOCKETCLOSE(s->sock_fd);
Guido van Rossumb18618d2000-05-03 23:44:39 +00001692 PyObject_Del(s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001693}
1694
Guido van Rossum30a685f1991-06-27 15:51:29 +00001695
1696/* Return a socket object's named attribute. */
1697
Guido van Rossum73624e91994-10-10 17:59:00 +00001698static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001699PySocketSock_getattr(PySocketSockObject *s, char *name)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001700{
Guido van Rossum73624e91994-10-10 17:59:00 +00001701 return Py_FindMethod(PySocketSock_methods, (PyObject *) s, name);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001702}
1703
Guido van Rossum30a685f1991-06-27 15:51:29 +00001704
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001705static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001706PySocketSock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001707{
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001708 char buf[512];
Fred Drakea04eaad2000-06-30 02:46:07 +00001709#if SIZEOF_SOCKET_T > SIZEOF_LONG
1710 if (s->sock_fd > LONG_MAX) {
1711 /* this can occur on Win64, and actually there is a special
1712 ugly printf formatter for decimal pointer length integer
1713 printing, only bother if necessary*/
1714 PyErr_SetString(PyExc_OverflowError,
1715 "no printf formatter to display the socket descriptor in decimal");
1716 return NULL;
1717 }
1718#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001719 sprintf(buf,
1720 "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",
Fred Drakea04eaad2000-06-30 02:46:07 +00001721 (long)s->sock_fd, s->sock_family, s->sock_type, s->sock_proto);
Guido van Rossumdc1c64a1996-02-27 15:21:19 +00001722 return PyString_FromString(buf);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001723}
1724
1725
Guido van Rossumb6775db1994-08-01 11:34:53 +00001726/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001727
Guido van Rossum73624e91994-10-10 17:59:00 +00001728static PyTypeObject PySocketSock_Type = {
Guido van Rossum55558541996-05-23 22:54:50 +00001729 PyObject_HEAD_INIT(0) /* Must fill in type value later */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001730 0,
1731 "socket",
Guido van Rossum73624e91994-10-10 17:59:00 +00001732 sizeof(PySocketSockObject),
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001733 0,
Guido van Rossum73624e91994-10-10 17:59:00 +00001734 (destructor)PySocketSock_dealloc, /*tp_dealloc*/
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001735 0, /*tp_print*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001736 (getattrfunc)PySocketSock_getattr, /*tp_getattr*/
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001737 0, /*tp_setattr*/
1738 0, /*tp_compare*/
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001739 (reprfunc)PySocketSock_repr, /*tp_repr*/
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001740 0, /*tp_as_number*/
1741 0, /*tp_as_sequence*/
1742 0, /*tp_as_mapping*/
1743};
1744
Guido van Rossum30a685f1991-06-27 15:51:29 +00001745
Guido van Rossum81194471991-07-27 21:42:02 +00001746/* Python interface to gethostname(). */
1747
1748/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001749static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001750PySocket_gethostname(PyObject *self, PyObject *args)
Guido van Rossum81194471991-07-27 21:42:02 +00001751{
1752 char buf[1024];
Guido van Rossumff4949e1992-08-05 19:58:53 +00001753 int res;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001754 if (!PyArg_ParseTuple(args, ":gethostname"))
Guido van Rossum81194471991-07-27 21:42:02 +00001755 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001756 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001757 res = gethostname(buf, (int) sizeof buf - 1);
Guido van Rossum73624e91994-10-10 17:59:00 +00001758 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001759 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001760 return PySocket_Err();
Guido van Rossum81194471991-07-27 21:42:02 +00001761 buf[sizeof buf - 1] = '\0';
Guido van Rossum73624e91994-10-10 17:59:00 +00001762 return PyString_FromString(buf);
Guido van Rossum81194471991-07-27 21:42:02 +00001763}
Guido van Rossumff4949e1992-08-05 19:58:53 +00001764
Guido van Rossum82a5c661998-07-07 20:45:43 +00001765static char gethostname_doc[] =
1766"gethostname() -> string\n\
1767\n\
1768Return the current host name.";
1769
Guido van Rossumff4949e1992-08-05 19:58:53 +00001770
Guido van Rossum30a685f1991-06-27 15:51:29 +00001771/* Python interface to gethostbyname(name). */
1772
1773/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001774static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001775PySocket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001776{
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001777 char *name;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001778 struct sockaddr_storage addrbuf;
1779
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001780 if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
Guido van Rossum30a685f1991-06-27 15:51:29 +00001781 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001782 if (setipaddr(name, (struct sockaddr *)&addrbuf, AF_INET) < 0)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001783 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001784 return makeipaddr((struct sockaddr *)&addrbuf,
1785 sizeof(struct sockaddr_in));
Guido van Rossum30a685f1991-06-27 15:51:29 +00001786}
1787
Guido van Rossum82a5c661998-07-07 20:45:43 +00001788static char gethostbyname_doc[] =
1789"gethostbyname(host) -> address\n\
1790\n\
1791Return the IP address (a string of the form '255.255.255.255') for a host.";
1792
1793
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001794/* Convenience function common to gethostbyname_ex and gethostbyaddr */
1795
1796static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001797gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001798{
1799 char **pch;
1800 PyObject *rtn_tuple = (PyObject *)NULL;
1801 PyObject *name_list = (PyObject *)NULL;
1802 PyObject *addr_list = (PyObject *)NULL;
1803 PyObject *tmp;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001804
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001805 if (h == NULL) {
Guido van Rossum48a680c2001-03-02 06:34:14 +00001806 /* Let's get real error message to return */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001807 PyH_Err(h_errno);
1808 return NULL;
1809 }
1810 if (h->h_addrtype != af) {
1811#ifdef HAVE_STRERROR
1812 /* Let's get real error message to return */
1813 PyErr_SetString(PySocket_Error, (char *)strerror(EAFNOSUPPORT));
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001814#else
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001815 PyErr_SetString(PySocket_Error,
1816 "Address family not supported by protocol family");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001817#endif
1818 return NULL;
1819 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001820 switch (af) {
1821 case AF_INET:
1822 if (alen < sizeof(struct sockaddr_in))
1823 return NULL;
1824 break;
1825#ifdef INET6
1826 case AF_INET6:
1827 if (alen < sizeof(struct sockaddr_in6))
1828 return NULL;
1829 break;
1830#endif
1831 }
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001832 if ((name_list = PyList_New(0)) == NULL)
1833 goto err;
1834 if ((addr_list = PyList_New(0)) == NULL)
1835 goto err;
1836 for (pch = h->h_aliases; *pch != NULL; pch++) {
1837 int status;
1838 tmp = PyString_FromString(*pch);
1839 if (tmp == NULL)
1840 goto err;
1841 status = PyList_Append(name_list, tmp);
1842 Py_DECREF(tmp);
1843 if (status)
1844 goto err;
1845 }
1846 for (pch = h->h_addr_list; *pch != NULL; pch++) {
1847 int status;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001848 switch (af) {
1849 case AF_INET:
1850 {
1851 struct sockaddr_in sin;
1852 memset(&sin, 0, sizeof(sin));
1853 sin.sin_family = af;
1854#ifdef HAVE_SOCKADDR_SA_LEN
1855 sin.sin_len = sizeof(sin);
1856#endif
1857 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
1858 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
1859 if (pch == h->h_addr_list && alen >= sizeof(sin))
1860 memcpy((char *) addr, &sin, sizeof(sin));
1861 break;
1862 }
1863#ifdef INET6
1864 case AF_INET6:
1865 {
1866 struct sockaddr_in6 sin6;
1867 memset(&sin6, 0, sizeof(sin6));
1868 sin6.sin6_family = af;
1869#ifdef HAVE_SOCKADDR_SA_LEN
1870 sin6.sin6_len = sizeof(sin6);
1871#endif
1872 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
1873 tmp = makeipaddr((struct sockaddr *)&sin6,
1874 sizeof(sin6));
1875 if (pch == h->h_addr_list && alen >= sizeof(sin6))
1876 memcpy((char *) addr, &sin6, sizeof(sin6));
1877 break;
1878 }
1879#endif
1880 default: /* can't happen */
1881 PyErr_SetString(PySocket_Error,
1882 "unsupported address family");
1883 return NULL;
1884 }
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001885 if (tmp == NULL)
1886 goto err;
1887 status = PyList_Append(addr_list, tmp);
1888 Py_DECREF(tmp);
1889 if (status)
1890 goto err;
1891 }
1892 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
1893 err:
1894 Py_XDECREF(name_list);
1895 Py_XDECREF(addr_list);
1896 return rtn_tuple;
1897}
1898
1899
1900/* Python interface to gethostbyname_ex(name). */
1901
1902/*ARGSUSED*/
1903static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001904PySocket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001905{
1906 char *name;
1907 struct hostent *h;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001908 struct sockaddr_storage addr;
Martin v. Löwis9db2f572001-07-23 01:30:10 +00001909 struct sockaddr *sa;
Guido van Rossum955becc1999-03-22 20:14:53 +00001910 PyObject *ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001911#ifdef HAVE_GETHOSTBYNAME_R
1912 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001913#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
1914 struct hostent_data data;
1915#else
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001916 char buf[16384];
1917 int buf_len = (sizeof buf) - 1;
1918 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001919#endif
1920#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001921 int result;
1922#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001923#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001924
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001925 if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001926 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001927 if (setipaddr(name, (struct sockaddr *)&addr, PF_INET) < 0)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001928 return NULL;
1929 Py_BEGIN_ALLOW_THREADS
1930#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001931#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001932 result = gethostbyname_r(name, &hp_allocated, buf, buf_len, &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001933#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001934 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001935#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Guido van Rossume7de2061999-03-24 17:24:33 +00001936 memset((void *) &data, '\0', sizeof(data));
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001937 result = gethostbyname_r(name, &hp_allocated, &data);
1938 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001939#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001940#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00001941#ifdef USE_GETHOSTBYNAME_LOCK
1942 PyThread_acquire_lock(gethostbyname_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001943#endif
1944 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001945#endif /* HAVE_GETHOSTBYNAME_R */
1946 Py_END_ALLOW_THREADS
Martin v. Löwis9db2f572001-07-23 01:30:10 +00001947 /* Some C libraries would require addr.__ss_family instead of addr.ss_family.
1948 Therefore, we cast the sockaddr_storage into sockaddr to access sa_family. */
1949 sa = (struct sockaddr*)&addr;
1950 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00001951#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum955becc1999-03-22 20:14:53 +00001952 PyThread_release_lock(gethostbyname_lock);
1953#endif
1954 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001955}
1956
1957static char ghbn_ex_doc[] =
1958"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
1959\n\
1960Return the true host name, a list of aliases, and a list of IP addresses,\n\
1961for a host. The host argument is a string giving a host name or IP number.";
1962
1963
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001964/* Python interface to gethostbyaddr(IP). */
1965
1966/*ARGSUSED*/
1967static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001968PySocket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001969{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001970#ifdef INET6
1971 struct sockaddr_storage addr;
1972#else
Guido van Rossum48a680c2001-03-02 06:34:14 +00001973 struct sockaddr_in addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001974#endif
1975 struct sockaddr *sa = (struct sockaddr *)&addr;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001976 char *ip_num;
1977 struct hostent *h;
Guido van Rossum3baaa131999-03-22 21:44:51 +00001978 PyObject *ret;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00001979#ifdef HAVE_GETHOSTBYNAME_R
1980 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001981#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
1982 struct hostent_data data;
1983#else
Guido van Rossum4f199ea1998-04-09 20:56:35 +00001984 char buf[16384];
1985 int buf_len = (sizeof buf) - 1;
1986 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001987#endif
1988#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001989 int result;
1990#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00001991#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001992 char *ap;
1993 int al;
1994 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001995
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001996 if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001997 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001998 af = PF_UNSPEC;
1999 if (setipaddr(ip_num, sa, af) < 0)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002000 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002001 af = sa->sa_family;
2002 ap = NULL;
2003 al = 0;
2004 switch (af) {
2005 case AF_INET:
2006 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
2007 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
2008 break;
2009#ifdef INET6
2010 case AF_INET6:
2011 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
2012 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
2013 break;
2014#endif
2015 default:
2016 PyErr_SetString(PySocket_Error, "unsupported address family");
2017 return NULL;
2018 }
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002019 Py_BEGIN_ALLOW_THREADS
2020#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002021#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002022 result = gethostbyaddr_r(ap, al, af,
2023 &hp_allocated, buf, buf_len,
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002024 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002025#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002026 h = gethostbyaddr_r(ap, al, af,
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002027 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002028#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Guido van Rossume7de2061999-03-24 17:24:33 +00002029 memset((void *) &data, '\0', sizeof(data));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002030 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002031 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002032#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002033#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00002034#ifdef USE_GETHOSTBYNAME_LOCK
2035 PyThread_acquire_lock(gethostbyname_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002036#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002037 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002038#endif /* HAVE_GETHOSTBYNAME_R */
2039 Py_END_ALLOW_THREADS
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002040 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00002041#ifdef USE_GETHOSTBYNAME_LOCK
2042 PyThread_release_lock(gethostbyname_lock);
2043#endif
2044 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002045}
2046
Guido van Rossum82a5c661998-07-07 20:45:43 +00002047static char gethostbyaddr_doc[] =
2048"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
2049\n\
2050Return the true host name, a list of aliases, and a list of IP addresses,\n\
2051for a host. The host argument is a string giving a host name or IP number.";
2052
Guido van Rossum30a685f1991-06-27 15:51:29 +00002053
2054/* Python interface to getservbyname(name).
2055 This only returns the port number, since the other info is already
2056 known or not useful (like the list of aliases). */
2057
2058/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002059static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002060PySocket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002061{
Guido van Rossumff4949e1992-08-05 19:58:53 +00002062 char *name, *proto;
Guido van Rossum30a685f1991-06-27 15:51:29 +00002063 struct servent *sp;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002064 if (!PyArg_ParseTuple(args, "ss:getservbyname", &name, &proto))
Guido van Rossum30a685f1991-06-27 15:51:29 +00002065 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002066 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002067 sp = getservbyname(name, proto);
Guido van Rossum73624e91994-10-10 17:59:00 +00002068 Py_END_ALLOW_THREADS
Guido van Rossum30a685f1991-06-27 15:51:29 +00002069 if (sp == NULL) {
Guido van Rossum73624e91994-10-10 17:59:00 +00002070 PyErr_SetString(PySocket_Error, "service/proto not found");
Guido van Rossum30a685f1991-06-27 15:51:29 +00002071 return NULL;
2072 }
Guido van Rossum73624e91994-10-10 17:59:00 +00002073 return PyInt_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00002074}
2075
Guido van Rossum82a5c661998-07-07 20:45:43 +00002076static char getservbyname_doc[] =
2077"getservbyname(servicename, protocolname) -> integer\n\
2078\n\
2079Return a port number from a service name and protocol name.\n\
2080The protocol name should be 'tcp' or 'udp'.";
2081
Guido van Rossum30a685f1991-06-27 15:51:29 +00002082
Guido van Rossum3901d851996-12-19 16:35:04 +00002083/* Python interface to getprotobyname(name).
2084 This only returns the protocol number, since the other info is
2085 already known or not useful (like the list of aliases). */
2086
2087/*ARGSUSED*/
2088static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002089PySocket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00002090{
2091 char *name;
2092 struct protoent *sp;
Guido van Rossumbcc20741998-08-04 22:53:56 +00002093#ifdef __BEOS__
2094/* Not available in BeOS yet. - [cjh] */
2095 PyErr_SetString( PySocket_Error, "getprotobyname not supported" );
2096 return NULL;
2097#else
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002098 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
Guido van Rossum3901d851996-12-19 16:35:04 +00002099 return NULL;
2100 Py_BEGIN_ALLOW_THREADS
2101 sp = getprotobyname(name);
2102 Py_END_ALLOW_THREADS
2103 if (sp == NULL) {
2104 PyErr_SetString(PySocket_Error, "protocol not found");
2105 return NULL;
2106 }
2107 return PyInt_FromLong((long) sp->p_proto);
Guido van Rossumbcc20741998-08-04 22:53:56 +00002108#endif
Guido van Rossum3901d851996-12-19 16:35:04 +00002109}
2110
Guido van Rossum82a5c661998-07-07 20:45:43 +00002111static char getprotobyname_doc[] =
2112"getprotobyname(name) -> integer\n\
2113\n\
2114Return the protocol number for the named protocol. (Rarely used.)";
2115
Guido van Rossum3901d851996-12-19 16:35:04 +00002116
Guido van Rossum30a685f1991-06-27 15:51:29 +00002117/* Python interface to socket(family, type, proto).
2118 The third (protocol) argument is optional.
2119 Return a new socket object. */
2120
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002121/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002122static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002123PySocket_socket(PyObject *self, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002124{
Guido van Rossum73624e91994-10-10 17:59:00 +00002125 PySocketSockObject *s;
Fred Drakea04eaad2000-06-30 02:46:07 +00002126 SOCKET_T fd;
Guido van Rossumbe32c891996-06-20 16:25:29 +00002127 int family, type, proto = 0;
Guido van Rossum43713e52000-02-29 13:59:29 +00002128 if (!PyArg_ParseTuple(args, "ii|i:socket", &family, &type, &proto))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002129 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002130 Py_BEGIN_ALLOW_THREADS
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002131 fd = socket(family, type, proto);
Guido van Rossum73624e91994-10-10 17:59:00 +00002132 Py_END_ALLOW_THREADS
Guido van Rossum6f489d91996-06-28 20:15:15 +00002133#ifdef MS_WINDOWS
Guido van Rossumd639d4d1996-06-12 04:04:22 +00002134 if (fd == INVALID_SOCKET)
2135#else
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002136 if (fd < 0)
Guido van Rossumd639d4d1996-06-12 04:04:22 +00002137#endif
Guido van Rossum73624e91994-10-10 17:59:00 +00002138 return PySocket_Err();
2139 s = PySocketSock_New(fd, family, type, proto);
Guido van Rossum30a685f1991-06-27 15:51:29 +00002140 /* If the object can't be created, don't forget to close the
2141 file descriptor again! */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002142 if (s == NULL)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00002143 (void) SOCKETCLOSE(fd);
Guido van Rossum81194471991-07-27 21:42:02 +00002144 /* From now on, ignore SIGPIPE and let the error checking
2145 do the work. */
Guido van Rossum48a680c2001-03-02 06:34:14 +00002146#ifdef SIGPIPE
Guido van Rossum81194471991-07-27 21:42:02 +00002147 (void) signal(SIGPIPE, SIG_IGN);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002148#endif
Guido van Rossum73624e91994-10-10 17:59:00 +00002149 return (PyObject *) s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002150}
2151
Guido van Rossum82a5c661998-07-07 20:45:43 +00002152static char socket_doc[] =
2153"socket(family, type[, proto]) -> socket object\n\
2154\n\
2155Open a socket of the given type. The family argument specifies the\n\
2156address family; it is normally AF_INET, sometimes AF_UNIX.\n\
2157The type argument specifies whether this is a stream (SOCK_STREAM)\n\
2158or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
2159specifying the default protocol.";
2160
2161
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002162#ifndef NO_DUP
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002163/* Create a socket object from a numeric file description.
2164 Useful e.g. if stdin is a socket.
2165 Additional arguments as for socket(). */
2166
2167/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002168static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002169PySocket_fromfd(PyObject *self, PyObject *args)
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002170{
Guido van Rossum73624e91994-10-10 17:59:00 +00002171 PySocketSockObject *s;
Fred Drakea04eaad2000-06-30 02:46:07 +00002172 SOCKET_T fd;
2173 int family, type, proto = 0;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002174 if (!PyArg_ParseTuple(args, "iii|i:fromfd",
2175 &fd, &family, &type, &proto))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002176 return NULL;
Guido van Rossum5f59d601992-12-14 16:59:51 +00002177 /* Dup the fd so it and the socket can be closed independently */
2178 fd = dup(fd);
2179 if (fd < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00002180 return PySocket_Err();
2181 s = PySocketSock_New(fd, family, type, proto);
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002182 /* From now on, ignore SIGPIPE and let the error checking
2183 do the work. */
Guido van Rossum48a680c2001-03-02 06:34:14 +00002184#ifdef SIGPIPE
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002185 (void) signal(SIGPIPE, SIG_IGN);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002186#endif
Guido van Rossum73624e91994-10-10 17:59:00 +00002187 return (PyObject *) s;
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002188}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002189
2190static char fromfd_doc[] =
2191"fromfd(fd, family, type[, proto]) -> socket object\n\
2192\n\
2193Create a socket object from the given file descriptor.\n\
2194The remaining arguments are the same as for socket().";
2195
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002196#endif /* NO_DUP */
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002197
Guido van Rossum82a5c661998-07-07 20:45:43 +00002198
Guido van Rossum006bf911996-06-12 04:04:55 +00002199static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002200PySocket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002201{
2202 int x1, x2;
2203
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002204 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002205 return NULL;
2206 }
2207 x2 = (int)ntohs((short)x1);
2208 return PyInt_FromLong(x2);
2209}
2210
Guido van Rossum82a5c661998-07-07 20:45:43 +00002211static char ntohs_doc[] =
2212"ntohs(integer) -> integer\n\
2213\n\
2214Convert a 16-bit integer from network to host byte order.";
2215
2216
Guido van Rossum006bf911996-06-12 04:04:55 +00002217static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002218PySocket_ntohl(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002219{
2220 int x1, x2;
2221
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002222 if (!PyArg_ParseTuple(args, "i:ntohl", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002223 return NULL;
2224 }
2225 x2 = ntohl(x1);
2226 return PyInt_FromLong(x2);
2227}
2228
Guido van Rossum82a5c661998-07-07 20:45:43 +00002229static char ntohl_doc[] =
2230"ntohl(integer) -> integer\n\
2231\n\
2232Convert a 32-bit integer from network to host byte order.";
2233
2234
Guido van Rossum006bf911996-06-12 04:04:55 +00002235static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002236PySocket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002237{
2238 int x1, x2;
2239
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002240 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002241 return NULL;
2242 }
2243 x2 = (int)htons((short)x1);
2244 return PyInt_FromLong(x2);
2245}
2246
Guido van Rossum82a5c661998-07-07 20:45:43 +00002247static char htons_doc[] =
2248"htons(integer) -> integer\n\
2249\n\
2250Convert a 16-bit integer from host to network byte order.";
2251
2252
Guido van Rossum006bf911996-06-12 04:04:55 +00002253static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002254PySocket_htonl(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002255{
2256 int x1, x2;
2257
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002258 if (!PyArg_ParseTuple(args, "i:htonl", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002259 return NULL;
2260 }
2261 x2 = htonl(x1);
2262 return PyInt_FromLong(x2);
2263}
2264
Guido van Rossum82a5c661998-07-07 20:45:43 +00002265static char htonl_doc[] =
2266"htonl(integer) -> integer\n\
2267\n\
2268Convert a 32-bit integer from host to network byte order.";
2269
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002270/*
2271 * socket.inet_aton() and socket.inet_ntoa() functions
2272 *
2273 * written 20 Aug 1999 by Ben Gertzfield <che@debian.org> <- blame him!
2274 *
2275 */
2276
Guido van Rossum48a680c2001-03-02 06:34:14 +00002277static char inet_aton_doc[] =
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002278"inet_aton(string) -> packed 32-bit IP representation\n\
2279\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002280Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002281binary format used in low-level network functions.";
2282
2283static PyObject*
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002284PySocket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002285{
Guido van Rossuma2e48551999-09-09 15:42:59 +00002286#ifndef INADDR_NONE
2287#define INADDR_NONE (-1)
2288#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002289
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002290 /* Have to use inet_addr() instead */
2291 char *ip_addr;
Fred Drakee5065292001-07-19 21:16:41 +00002292 unsigned long packed_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002293
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002294 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr)) {
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002295 return NULL;
2296 }
Guido van Rossumff3ab422000-04-24 15:16:03 +00002297#ifdef USE_GUSI1
Fred Drakee5065292001-07-19 21:16:41 +00002298 packed_addr = inet_addr(ip_addr).s_addr;
Guido van Rossum1b6e4631999-11-04 18:22:29 +00002299#else
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002300 packed_addr = inet_addr(ip_addr);
Guido van Rossum1b6e4631999-11-04 18:22:29 +00002301#endif
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002302
2303 if (packed_addr == INADDR_NONE) { /* invalid address */
2304 PyErr_SetString(PySocket_Error,
2305 "illegal IP address string passed to inet_aton");
2306 return NULL;
2307 }
2308
2309 return PyString_FromStringAndSize((char *) &packed_addr,
2310 sizeof(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002311}
2312
Guido van Rossum48a680c2001-03-02 06:34:14 +00002313static char inet_ntoa_doc[] =
Fred Drakee0661342000-03-07 14:05:16 +00002314"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002315\n\
2316Convert an IP address from 32-bit packed binary format to string format";
2317
2318static PyObject*
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002319PySocket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002320{
2321 char *packed_str;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002322 int addr_len;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002323 struct in_addr packed_addr;
2324
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002325 if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) {
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002326 return NULL;
2327 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00002328
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002329 if (addr_len != sizeof(packed_addr)) {
2330 PyErr_SetString(PySocket_Error,
2331 "packed IP wrong length for inet_ntoa");
2332 return NULL;
2333 }
2334
2335 memcpy(&packed_addr, packed_str, addr_len);
2336
2337 return PyString_FromString(inet_ntoa(packed_addr));
2338}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002339
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002340/* Python interface to getaddrinfo(host, port). */
2341
2342/*ARGSUSED*/
2343static PyObject *
2344PySocket_getaddrinfo(PyObject *self, PyObject *args)
2345{
2346 struct addrinfo hints, *res0, *res;
2347 PyObject *pobj = (PyObject *)NULL;
Martin v. Löwisf65b1a12001-08-12 09:28:40 +00002348 char pbuf[30];
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002349 char *hptr, *pptr;
2350 int family, socktype, protocol, flags;
2351 int error;
2352 PyObject *all = (PyObject *)NULL;
2353 PyObject *single = (PyObject *)NULL;
2354
2355 family = socktype = protocol = flags = 0;
2356 family = PF_UNSPEC;
2357 if (!PyArg_ParseTuple(args, "zO|iiii:getaddrinfo",
2358 &hptr, &pobj, &family, &socktype,
2359 &protocol, &flags)) {
2360 return NULL;
2361 }
2362 if (PyInt_Check(pobj)) {
Marc-André Lemburg03d1b182001-07-31 18:05:33 +00002363 PyOS_snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002364 pptr = pbuf;
2365 } else if (PyString_Check(pobj)) {
2366 pptr = PyString_AsString(pobj);
2367 } else if (pobj == Py_None) {
2368 pptr = (char *)NULL;
2369 } else {
2370 PyErr_SetString(PySocket_Error, "Int or String expected");
2371 return NULL;
2372 }
2373 memset(&hints, 0, sizeof(hints));
2374 hints.ai_family = family;
2375 hints.ai_socktype = socktype;
2376 hints.ai_protocol = protocol;
2377 hints.ai_flags = flags;
2378 error = getaddrinfo(hptr, pptr, &hints, &res0);
2379 if (error) {
2380 PyGAI_Err(error);
2381 return NULL;
2382 }
2383
2384 if ((all = PyList_New(0)) == NULL)
2385 goto err;
2386 for (res = res0; res; res = res->ai_next) {
Guido van Rossum716aac02001-10-12 18:59:27 +00002387 PyObject *addr =
2388 makesockaddr(-1, res->ai_addr, res->ai_addrlen);
2389 if (addr == NULL)
2390 goto err;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002391 single = Py_BuildValue("iiisO", res->ai_family,
2392 res->ai_socktype, res->ai_protocol,
2393 res->ai_canonname ? res->ai_canonname : "",
Guido van Rossum716aac02001-10-12 18:59:27 +00002394 addr);
2395 Py_DECREF(addr);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002396 if (single == NULL)
2397 goto err;
2398
2399 if (PyList_Append(all, single))
2400 goto err;
2401 Py_XDECREF(single);
2402 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002403 return all;
2404 err:
2405 Py_XDECREF(single);
2406 Py_XDECREF(all);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002407 return (PyObject *)NULL;
2408}
2409
2410static char getaddrinfo_doc[] =
2411"socket.getaddrinfo(host, port [, family, socktype, proto, flags])\n\
2412 --> List of (family, socktype, proto, canonname, sockaddr)\n\
2413\n\
2414Resolve host and port into addrinfo struct.";
2415
2416/* Python interface to getnameinfo(sa, flags). */
2417
2418/*ARGSUSED*/
2419static PyObject *
2420PySocket_getnameinfo(PyObject *self, PyObject *args)
2421{
2422 PyObject *sa = (PyObject *)NULL;
2423 int flags;
2424 char *hostp;
2425 int n, port, flowinfo, scope_id;
2426 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
2427 struct addrinfo hints, *res = NULL;
2428 int error;
2429 PyObject *ret = (PyObject *)NULL;
2430
2431 flags = flowinfo = scope_id = 0;
2432 if (PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags) == 0)
2433 return NULL;
2434 n = PyArg_ParseTuple(sa, "si|ii", &hostp, &port, &flowinfo, scope_id);
2435 if (n == 0)
2436 goto fail;
Marc-André Lemburg03d1b182001-07-31 18:05:33 +00002437 PyOS_snprintf(pbuf, sizeof(pbuf), "%d", port);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002438 memset(&hints, 0, sizeof(hints));
2439 hints.ai_family = PF_UNSPEC;
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00002440 hints.ai_socktype = SOCK_DGRAM; /* make numeric port happy */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002441 error = getaddrinfo(hostp, pbuf, &hints, &res);
2442 if (error) {
2443 PyGAI_Err(error);
2444 goto fail;
2445 }
2446 if (res->ai_next) {
2447 PyErr_SetString(PySocket_Error,
2448 "sockaddr resolved to multiple addresses");
2449 goto fail;
2450 }
2451 switch (res->ai_family) {
2452 case AF_INET:
2453 {
2454 char *t1;
2455 int t2;
2456 if (PyArg_ParseTuple(sa, "si", &t1, &t2) == 0) {
2457 PyErr_SetString(PySocket_Error,
2458 "IPv4 sockaddr must be 2 tuple");
2459 goto fail;
2460 }
2461 break;
2462 }
2463#ifdef INET6
2464 case AF_INET6:
2465 {
2466 struct sockaddr_in6 *sin6;
2467 sin6 = (struct sockaddr_in6 *)res->ai_addr;
2468 sin6->sin6_flowinfo = flowinfo;
2469 sin6->sin6_scope_id = scope_id;
2470 break;
2471 }
2472#endif
2473 }
2474 error = getnameinfo(res->ai_addr, res->ai_addrlen,
2475 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
2476 if (error) {
2477 PyGAI_Err(error);
2478 goto fail;
2479 }
2480 ret = Py_BuildValue("ss", hbuf, pbuf);
2481
2482fail:
2483 if (res)
2484 freeaddrinfo(res);
2485 Py_XDECREF(sa);
2486 return ret;
2487}
2488
2489static char getnameinfo_doc[] =
2490"socket.getnameinfo(sockaddr, flags) --> (host, port)\n\
2491\n\
2492Get host and port for a sockaddr.";
2493
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002494/* XXX It might be helpful to augment the error message generated
2495 below with the name of the SSL function that generated the error.
2496 I expect it's obvious most of the time.
2497*/
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002498
2499#ifdef USE_SSL
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002500static PyObject *
2501PySSL_SetError(SSL *ssl, int ret)
2502{
2503 PyObject *v, *n, *s;
2504 char *errstr;
2505 int err;
2506
2507 assert(ret <= 0);
2508
2509 err = SSL_get_error(ssl, ret);
2510 n = PyInt_FromLong(err);
2511 if (n == NULL)
2512 return NULL;
2513 v = PyTuple_New(2);
2514 if (v == NULL) {
2515 Py_DECREF(n);
2516 return NULL;
2517 }
2518
2519 switch (SSL_get_error(ssl, ret)) {
2520 case SSL_ERROR_ZERO_RETURN:
2521 errstr = "TLS/SSL connection has been closed";
2522 break;
2523 case SSL_ERROR_WANT_READ:
2524 errstr = "The operation did not complete (read)";
2525 break;
2526 case SSL_ERROR_WANT_WRITE:
2527 errstr = "The operation did not complete (write)";
2528 break;
2529 case SSL_ERROR_WANT_X509_LOOKUP:
2530 errstr = "The operation did not complete (X509 lookup)";
2531 break;
2532 case SSL_ERROR_SYSCALL:
2533 case SSL_ERROR_SSL:
2534 {
2535 unsigned long e = ERR_get_error();
2536 if (e == 0) {
2537 /* an EOF was observed that violates the protocol */
2538 errstr = "EOF occurred in violation of protocol";
2539 } else if (e == -1) {
2540 /* the underlying BIO reported an I/O error */
2541 Py_DECREF(v);
2542 Py_DECREF(n);
Jeremy Hyltone2adc6c2001-10-11 17:27:58 +00002543 return PySocket_Err();
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002544 } else {
2545 /* XXX Protected by global interpreter lock */
2546 errstr = ERR_error_string(e, NULL);
2547 }
2548 break;
2549 }
2550 default:
2551 errstr = "Invalid error code";
2552 }
2553 s = PyString_FromString(errstr);
2554 if (s == NULL) {
2555 Py_DECREF(v);
2556 Py_DECREF(n);
2557 }
2558 PyTuple_SET_ITEM(v, 0, n);
2559 PyTuple_SET_ITEM(v, 1, s);
2560 PyErr_SetObject(PySSLErrorObject, v);
2561 return NULL;
2562}
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002563
2564/* This is a C function to be called for new object initialization */
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002565static PySSLObject *
2566newPySSLObject(PySocketSockObject *Sock, char *key_file, char *cert_file)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002567{
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002568 PySSLObject *self;
Jeremy Hyltonb0b0bd62001-10-10 22:33:32 +00002569 char *errstr = NULL;
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002570 int ret;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002571
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002572 self = PyObject_New(PySSLObject, &PySSL_Type); /* Create new object */
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002573 if (self == NULL){
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002574 errstr = "newPySSLObject error";
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002575 goto fail;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002576 }
Jeremy Hyltonba699362001-10-11 17:23:34 +00002577 memset(self->server, '\0', sizeof(char) * X509_NAME_MAXLEN);
2578 memset(self->issuer, '\0', sizeof(char) * X509_NAME_MAXLEN);
Jeremy Hyltonec4b5452001-10-10 03:37:05 +00002579 self->server_cert = NULL;
2580 self->ssl = NULL;
2581 self->ctx = NULL;
2582 self->Socket = NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002583
Jeremy Hylton22738b92001-10-10 22:37:48 +00002584 if ((key_file && !cert_file) || (!key_file && cert_file)) {
2585 errstr = "Both the key & certificate files must be specified";
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002586 goto fail;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002587 }
2588
Jeremy Hylton22738b92001-10-10 22:37:48 +00002589 self->ctx = SSL_CTX_new(SSLv23_method()); /* Set up context */
2590 if (self->ctx == NULL) {
2591 errstr = "SSL_CTX_new error";
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002592 goto fail;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002593 }
2594
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002595 if (key_file) {
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002596 if (SSL_CTX_use_PrivateKey_file(self->ctx, key_file,
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002597 SSL_FILETYPE_PEM) < 1) {
Jeremy Hyltonb0b0bd62001-10-10 22:33:32 +00002598 errstr = "SSL_CTX_use_PrivateKey_file error";
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002599 goto fail;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002600 }
2601
2602 if (SSL_CTX_use_certificate_chain_file(self->ctx,
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002603 cert_file) < 1) {
Jeremy Hyltonb0b0bd62001-10-10 22:33:32 +00002604 errstr = "SSL_CTX_use_certificate_chain_file error";
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002605 goto fail;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002606 }
2607 }
2608
2609 SSL_CTX_set_verify(self->ctx,
2610 SSL_VERIFY_NONE, NULL); /* set verify lvl */
2611 self->ssl = SSL_new(self->ctx); /* New ssl struct */
2612 SSL_set_fd(self->ssl, Sock->sock_fd); /* Set the socket for SSL */
2613 SSL_set_connect_state(self->ssl);
2614
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002615 /* Actually negotiate SSL connection */
2616 /* XXX If SSL_connect() returns 0, it's also a failure. */
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002617 ret = SSL_connect(self->ssl);
2618 if (ret <= 0) {
2619 PySSL_SetError(self->ssl, ret);
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002620 goto fail;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002621 }
2622 self->ssl->debug = 1;
2623
2624 if ((self->server_cert = SSL_get_peer_certificate(self->ssl))) {
2625 X509_NAME_oneline(X509_get_subject_name(self->server_cert),
Jeremy Hyltonba699362001-10-11 17:23:34 +00002626 self->server, X509_NAME_MAXLEN);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002627 X509_NAME_oneline(X509_get_issuer_name(self->server_cert),
Jeremy Hyltonba699362001-10-11 17:23:34 +00002628 self->issuer, X509_NAME_MAXLEN);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002629 }
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002630 self->Socket = Sock;
2631 Py_INCREF(self->Socket);
2632 return self;
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002633 fail:
Jeremy Hyltonb0b0bd62001-10-10 22:33:32 +00002634 if (errstr)
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002635 PyErr_SetString(PySSLErrorObject, errstr);
Jeremy Hyltonf86d63e2001-10-10 03:19:39 +00002636 Py_DECREF(self);
2637 return NULL;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002638}
2639
2640/* This is the Python function called for new object initialization */
2641static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002642PySocket_ssl(PyObject *self, PyObject *args)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002643{
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002644 PySSLObject *rv;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002645 PySocketSockObject *Sock;
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002646 char *key_file = NULL;
2647 char *cert_file = NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002648
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002649 if (!PyArg_ParseTuple(args, "O!|zz:ssl",
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002650 &PySocketSock_Type, (PyObject*)&Sock,
Jeremy Hyltonab006452001-10-10 03:33:24 +00002651 &key_file, &cert_file))
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002652 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002653
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002654 rv = newPySSLObject(Sock, key_file, cert_file);
Jeremy Hyltonab006452001-10-10 03:33:24 +00002655 if (rv == NULL)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002656 return NULL;
2657 return (PyObject *)rv;
2658}
2659
2660static char ssl_doc[] =
Jeremy Hyltonba699362001-10-11 17:23:34 +00002661"ssl(socket, [keyfile, certfile]) -> sslobject";
2662
2663/* SSL object methods */
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002664
2665static PyObject *
Jeremy Hyltonba699362001-10-11 17:23:34 +00002666PySSL_server(PySSLObject *self)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002667{
2668 return PyString_FromString(self->server);
2669}
2670
2671static PyObject *
Jeremy Hyltonba699362001-10-11 17:23:34 +00002672PySSL_issuer(PySSLObject *self)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002673{
2674 return PyString_FromString(self->issuer);
2675}
2676
2677
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002678static void PySSL_dealloc(PySSLObject *self)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002679{
2680 if (self->server_cert) /* Possible not to have one? */
2681 X509_free (self->server_cert);
Jeremy Hyltonec4b5452001-10-10 03:37:05 +00002682 if (self->ssl)
2683 SSL_free(self->ssl);
2684 if (self->ctx)
2685 SSL_CTX_free(self->ctx);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002686 Py_XDECREF(self->Socket);
Guido van Rossumb18618d2000-05-03 23:44:39 +00002687 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002688}
2689
Jeremy Hyltonba699362001-10-11 17:23:34 +00002690static PyObject *PySSL_SSLwrite(PySSLObject *self, PyObject *args)
2691{
2692 char *data;
2693 int len;
2694
2695 if (!PyArg_ParseTuple(args, "s#:write", &data, &len))
2696 return NULL;
2697
2698 len = SSL_write(self->ssl, data, len);
2699 if (len > 0)
2700 return PyInt_FromLong(len);
2701 else
2702 return PySSL_SetError(self->ssl, len);
2703}
2704
2705static char PySSL_SSLwrite_doc[] =
2706"write(s) -> len\n\
2707\n\
2708Writes the string s into the SSL object. Returns the number\n\
2709of bytes written.";
2710
2711static PyObject *PySSL_SSLread(PySSLObject *self, PyObject *args)
2712{
2713 PyObject *buf;
2714 int count = 0;
2715 int len = 1024;
2716
2717 if (!PyArg_ParseTuple(args, "|i:read", &len))
2718 return NULL;
2719
2720 if (!(buf = PyString_FromStringAndSize((char *) 0, len)))
2721 return NULL;
2722
2723 count = SSL_read(self->ssl, PyString_AsString(buf), len);
2724 if (count <= 0) {
2725 Py_DECREF(buf);
2726 return PySSL_SetError(self->ssl, count);
2727 }
2728 if (count != len && _PyString_Resize(&buf, count) < 0)
2729 return NULL;
2730 return buf;
2731}
2732
2733static char PySSL_SSLread_doc[] =
2734"read([len]) -> string\n\
2735\n\
2736Read up to len bytes from the SSL socket.";
2737
2738static PyMethodDef PySSLMethods[] = {
2739 {"write", (PyCFunction)PySSL_SSLwrite, 1,
2740 PySSL_SSLwrite_doc},
2741 {"read", (PyCFunction)PySSL_SSLread, 1,
2742 PySSL_SSLread_doc},
Guido van Rossum17209fc2001-10-15 21:12:54 +00002743 {"server", (PyCFunction)PySSL_server, METH_NOARGS},
2744 {"issuer", (PyCFunction)PySSL_issuer, METH_NOARGS},
Jeremy Hyltonba699362001-10-11 17:23:34 +00002745 {NULL, NULL}
2746};
2747
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002748static PyObject *PySSL_getattr(PySSLObject *self, char *name)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002749{
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002750 return Py_FindMethod(PySSLMethods, (PyObject *)self, name);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002751}
2752
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002753staticforward PyTypeObject PySSL_Type = {
Guido van Rossuma120ffc2001-01-22 15:29:14 +00002754 PyObject_HEAD_INIT(NULL)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002755 0, /*ob_size*/
2756 "SSL", /*tp_name*/
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002757 sizeof(PySSLObject), /*tp_basicsize*/
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002758 0, /*tp_itemsize*/
2759 /* methods */
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002760 (destructor)PySSL_dealloc, /*tp_dealloc*/
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002761 0, /*tp_print*/
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00002762 (getattrfunc)PySSL_getattr, /*tp_getattr*/
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002763 0, /*tp_setattr*/
2764 0, /*tp_compare*/
2765 0, /*tp_repr*/
2766 0, /*tp_as_number*/
2767 0, /*tp_as_sequence*/
2768 0, /*tp_as_mapping*/
2769 0, /*tp_hash*/
2770};
2771
Jeremy Hyltonde80f2e2001-10-18 00:28:50 +00002772/* helper routines for seeding the SSL PRNG */
2773static PyObject *
2774PySSL_RAND_add(PyObject *self, PyObject *args)
2775{
2776 char *buf;
2777 int len;
2778 double entropy;
2779
2780 if (!PyArg_ParseTuple(args, "s#d:RAND_add", &buf, &len, &entropy))
2781 return NULL;
2782 RAND_add(buf, len, entropy);
2783 Py_INCREF(Py_None);
2784 return Py_None;
2785}
2786
2787static char PySSL_RAND_add_doc[] =
2788"RAND_add(string, entropy)\n\
2789\n\
2790Mix string into the OpenSSL PRNG state. entropy (a float) is a lower\n\
2791bound on the entropy contained in string.";
2792
2793static PyObject *
2794PySSL_RAND_status(PyObject *self)
2795{
2796 return PyInt_FromLong(RAND_status());
2797}
2798
2799static char PySSL_RAND_status_doc[] =
2800"RAND_status() -> 0 or 1\n\
2801\n\
2802Returns 1 if the OpenSSL PRNG has been seeded with enough data and 0 if not.\n\
2803It is necessary to seed the PRNG with RAND_add() on some platforms before\n\
2804using the ssl() function.";
2805
2806static PyObject *
2807PySSL_RAND_egd(PyObject *self, PyObject *arg)
2808{
2809 int bytes;
2810
2811 if (!PyString_Check(arg))
2812 return PyErr_Format(PyExc_TypeError,
2813 "RAND_egd() expected string, found %s",
2814 arg->ob_type->tp_name);
2815 bytes = RAND_egd(PyString_AS_STRING(arg));
2816 if (bytes == -1) {
2817 PyErr_SetString(PySSLErrorObject,
2818 "EGD connection failed or EGD did not return "
2819 "enough data to seed the PRNG");
2820 return NULL;
2821 }
2822 return PyInt_FromLong(bytes);
2823}
2824
2825static char PySSL_RAND_egd_doc[] =
Guido van Rossumcad8fa12001-10-19 12:40:40 +00002826"RAND_egd(path) -> bytes\n\
Jeremy Hyltonde80f2e2001-10-18 00:28:50 +00002827\n\
2828Queries the entropy gather daemon (EGD) on socket path. Returns number\n\
2829of bytes read. Raises socket.sslerror if connection to EGD fails or\n\
2830if it does provide enough data to seed PRNG.";
2831
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002832#endif /* USE_SSL */
2833
2834
Guido van Rossum30a685f1991-06-27 15:51:29 +00002835/* List of functions exported by this module. */
2836
Guido van Rossum73624e91994-10-10 17:59:00 +00002837static PyMethodDef PySocket_methods[] = {
Guido van Rossum48a680c2001-03-02 06:34:14 +00002838 {"gethostbyname", PySocket_gethostbyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002839 METH_VARARGS, gethostbyname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002840 {"gethostbyname_ex", PySocket_gethostbyname_ex,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002841 METH_VARARGS, ghbn_ex_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002842 {"gethostbyaddr", PySocket_gethostbyaddr,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002843 METH_VARARGS, gethostbyaddr_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002844 {"gethostname", PySocket_gethostname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002845 METH_VARARGS, gethostname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002846 {"getservbyname", PySocket_getservbyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002847 METH_VARARGS, getservbyname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002848 {"getprotobyname", PySocket_getprotobyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002849 METH_VARARGS,getprotobyname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002850 {"socket", PySocket_socket,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002851 METH_VARARGS, socket_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002852#ifndef NO_DUP
Guido van Rossum48a680c2001-03-02 06:34:14 +00002853 {"fromfd", PySocket_fromfd,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002854 METH_VARARGS, fromfd_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002855#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00002856 {"ntohs", PySocket_ntohs,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002857 METH_VARARGS, ntohs_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002858 {"ntohl", PySocket_ntohl,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002859 METH_VARARGS, ntohl_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002860 {"htons", PySocket_htons,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002861 METH_VARARGS, htons_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002862 {"htonl", PySocket_htonl,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002863 METH_VARARGS, htonl_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002864 {"inet_aton", PySocket_inet_aton,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002865 METH_VARARGS, inet_aton_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002866 {"inet_ntoa", PySocket_inet_ntoa,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002867 METH_VARARGS, inet_ntoa_doc},
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002868 {"getaddrinfo", PySocket_getaddrinfo,
2869 METH_VARARGS, getaddrinfo_doc},
2870 {"getnameinfo", PySocket_getnameinfo,
2871 METH_VARARGS, getnameinfo_doc},
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002872#ifdef USE_SSL
Guido van Rossum48a680c2001-03-02 06:34:14 +00002873 {"ssl", PySocket_ssl,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002874 METH_VARARGS, ssl_doc},
Jeremy Hyltonde80f2e2001-10-18 00:28:50 +00002875 {"RAND_add", PySSL_RAND_add, METH_VARARGS,
2876 PySSL_RAND_add_doc},
2877 {"RAND_egd", PySSL_RAND_egd, METH_O,
2878 PySSL_RAND_egd_doc},
2879 {"RAND_status", (PyCFunction)PySSL_RAND_status, METH_NOARGS,
2880 PySSL_RAND_status_doc},
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002881#endif /* USE_SSL */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002882 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002883};
2884
Guido van Rossum30a685f1991-06-27 15:51:29 +00002885
2886/* Convenience routine to export an integer value.
Barry Warsaw752300b1997-01-03 17:18:10 +00002887 *
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002888 * Errors are silently ignored, for better or for worse...
Barry Warsaw752300b1997-01-03 17:18:10 +00002889 */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002890static void
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002891insint(PyObject *d, char *name, int value)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002892{
Guido van Rossum73624e91994-10-10 17:59:00 +00002893 PyObject *v = PyInt_FromLong((long) value);
Barry Warsaw752300b1997-01-03 17:18:10 +00002894 if (!v || PyDict_SetItemString(d, name, v))
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002895 PyErr_Clear();
Barry Warsaw752300b1997-01-03 17:18:10 +00002896
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002897 Py_XDECREF(v);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002898}
2899
Guido van Rossum30a685f1991-06-27 15:51:29 +00002900
Guido van Rossum8d665e61996-06-26 18:22:49 +00002901#ifdef MS_WINDOWS
Guido van Rossumbe32c891996-06-20 16:25:29 +00002902
2903/* Additional initialization and cleanup for NT/Windows */
2904
2905static void
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002906NTcleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00002907{
2908 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00002909}
2910
2911static int
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002912NTinit(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00002913{
2914 WSADATA WSAData;
2915 int ret;
2916 char buf[100];
2917 ret = WSAStartup(0x0101, &WSAData);
2918 switch (ret) {
2919 case 0: /* no error */
2920 atexit(NTcleanup);
2921 return 1;
2922 case WSASYSNOTREADY:
2923 PyErr_SetString(PyExc_ImportError,
2924 "WSAStartup failed: network not ready");
2925 break;
2926 case WSAVERNOTSUPPORTED:
2927 case WSAEINVAL:
2928 PyErr_SetString(PyExc_ImportError,
2929 "WSAStartup failed: requested version not supported");
2930 break;
2931 default:
2932 sprintf(buf, "WSAStartup failed: error code %d", ret);
2933 PyErr_SetString(PyExc_ImportError, buf);
2934 break;
2935 }
2936 return 0;
2937}
2938
Guido van Rossum8d665e61996-06-26 18:22:49 +00002939#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00002940
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002941#if defined(PYOS_OS2)
2942
2943/* Additional initialization and cleanup for OS/2 */
2944
2945static void
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002946OS2cleanup(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002947{
2948 /* No cleanup is necessary for OS/2 Sockets */
2949}
2950
2951static int
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002952OS2init(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002953{
2954 char reason[64];
2955 int rc = sock_init();
2956
2957 if (rc == 0) {
Guido van Rossum32c575d1997-12-02 20:37:32 +00002958 atexit(OS2cleanup);
2959 return 1; /* Indicate Success */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002960 }
2961
2962 sprintf(reason, "OS/2 TCP/IP Error# %d", sock_errno());
2963 PyErr_SetString(PyExc_ImportError, reason);
2964
Guido van Rossum32c575d1997-12-02 20:37:32 +00002965 return 0; /* Indicate Failure */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002966}
2967
2968#endif /* PYOS_OS2 */
2969
Guido van Rossum30a685f1991-06-27 15:51:29 +00002970/* Initialize this module.
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002971 * This is called when the first 'import socket' is done,
2972 * via a table in config.c, if config.c is compiled with USE_SOCKET
2973 * defined.
2974 *
2975 * For MS_WINDOWS (which means any Windows variant), this module
2976 * is actually called "_socket", and there's a wrapper "socket.py"
2977 * which implements some missing functionality (such as makefile(),
2978 * dup() and fromfd()). The import of "_socket" may fail with an
2979 * ImportError exception if initialization of WINSOCK fails. When
2980 * WINSOCK is initialized succesfully, a call to WSACleanup() is
2981 * scheduled to be made at exit time.
2982 *
2983 * For OS/2, this module is also called "_socket" and uses a wrapper
2984 * "socket.py" which implements that functionality that is missing
2985 * when PC operating systems don't put socket descriptors in the
2986 * operating system's filesystem layer.
2987 */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002988
Guido van Rossum82a5c661998-07-07 20:45:43 +00002989static char module_doc[] =
Fred Drakea136d492000-08-16 14:18:30 +00002990"Implementation module for socket operations. See the socket module\n\
2991for documentation.";
Guido van Rossum82a5c661998-07-07 20:45:43 +00002992
2993static char sockettype_doc[] =
2994"A socket represents one endpoint of a network connection.\n\
2995\n\
2996Methods:\n\
2997\n\
2998accept() -- accept a connection, returning new socket and client address\n\
2999bind() -- bind the socket to a local address\n\
3000close() -- close the socket\n\
3001connect() -- connect the socket to a remote address\n\
3002connect_ex() -- connect, return an error code instead of an exception \n\
3003dup() -- return a new socket object identical to the current one (*)\n\
3004fileno() -- return underlying file descriptor\n\
3005getpeername() -- return remote address (*)\n\
3006getsockname() -- return local address\n\
3007getsockopt() -- get socket options\n\
3008listen() -- start listening for incoming connections\n\
3009makefile() -- return a file object corresponding tot the socket (*)\n\
3010recv() -- receive data\n\
3011recvfrom() -- receive data and sender's address\n\
3012send() -- send data\n\
3013sendto() -- send data to a given address\n\
3014setblocking() -- set or clear the blocking I/O flag\n\
3015setsockopt() -- set socket options\n\
3016shutdown() -- shut down traffic in one or both directions\n\
3017\n\
3018(*) not available on all platforms!)";
3019
Guido van Rossum3886bb61998-12-04 18:50:17 +00003020DL_EXPORT(void)
Thomas Wouters1e0c2f42000-07-24 16:06:23 +00003021init_socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003022{
Guido van Rossum73624e91994-10-10 17:59:00 +00003023 PyObject *m, *d;
Guido van Rossum48a680c2001-03-02 06:34:14 +00003024#ifdef RISCOS
3025 _kernel_swi_regs r;
3026 r.r[0]=0;
3027 _kernel_swi(0x43380, &r, &r);
3028 taskwindow = r.r[0];
3029#else
Guido van Rossum8d665e61996-06-26 18:22:49 +00003030#ifdef MS_WINDOWS
Guido van Rossumbe32c891996-06-20 16:25:29 +00003031 if (!NTinit())
3032 return;
Guido van Rossumbe32c891996-06-20 16:25:29 +00003033#else
Guido van Rossum32c575d1997-12-02 20:37:32 +00003034#if defined(__TOS_OS2__)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00003035 if (!OS2init())
3036 return;
Fred Drakea136d492000-08-16 14:18:30 +00003037#endif /* __TOS_OS2__ */
3038#endif /* MS_WINDOWS */
Guido van Rossum48a680c2001-03-02 06:34:14 +00003039#endif /* RISCOS */
Guido van Rossuma120ffc2001-01-22 15:29:14 +00003040#ifdef USE_SSL
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00003041 PySSL_Type.ob_type = &PyType_Type;
Guido van Rossuma120ffc2001-01-22 15:29:14 +00003042#endif
Guido van Rossum82a5c661998-07-07 20:45:43 +00003043 m = Py_InitModule3("_socket", PySocket_methods, module_doc);
Guido van Rossum73624e91994-10-10 17:59:00 +00003044 d = PyModule_GetDict(m);
Guido van Rossum0cb96de1997-10-01 04:29:29 +00003045 PySocket_Error = PyErr_NewException("socket.error", NULL, NULL);
3046 if (PySocket_Error == NULL)
3047 return;
Martin v. Löwis864e9ff2001-08-04 22:32:03 +00003048 PyDict_SetItemString(d, "error", PySocket_Error);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003049 PyH_Error = PyErr_NewException("socket.herror", PySocket_Error, NULL);
3050 if (PyH_Error == NULL)
3051 return;
Martin v. Löwis864e9ff2001-08-04 22:32:03 +00003052 PyDict_SetItemString(d, "herror", PyH_Error);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003053 PyGAI_Error = PyErr_NewException("socket.gaierror", PySocket_Error,
3054 NULL);
3055 if (PyGAI_Error == NULL)
3056 return;
Martin v. Löwis864e9ff2001-08-04 22:32:03 +00003057 PyDict_SetItemString(d, "gaierror", PyGAI_Error);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00003058#ifdef USE_SSL
3059 SSL_load_error_strings();
3060 SSLeay_add_ssl_algorithms();
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00003061 PySSLErrorObject = PyErr_NewException("socket.sslerror", NULL, NULL);
3062 if (PySSLErrorObject == NULL)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00003063 return;
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00003064 PyDict_SetItemString(d, "sslerror", PySSLErrorObject);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00003065 if (PyDict_SetItemString(d, "SSLType",
Jeremy Hylton5b6ce5a2001-10-10 23:55:43 +00003066 (PyObject *)&PySSL_Type) != 0)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00003067 return;
Jeremy Hylton57ca8732001-10-11 00:00:17 +00003068 PyModule_AddIntConstant(m, "SSL_ERROR_ZERO_RETURN",
3069 SSL_ERROR_ZERO_RETURN);
3070 PyModule_AddIntConstant(m, "SSL_ERROR_WANT_READ",
3071 SSL_ERROR_WANT_READ);
3072 PyModule_AddIntConstant(m, "SSL_ERROR_WANT_WRITE",
3073 SSL_ERROR_WANT_WRITE);
3074 PyModule_AddIntConstant(m, "SSL_ERROR_WANT_X509_LOOKUP",
3075 SSL_ERROR_WANT_X509_LOOKUP);
3076 PyModule_AddIntConstant(m, "SSL_ERROR_SYSCALL",
3077 SSL_ERROR_SYSCALL);
3078 PyModule_AddIntConstant(m, "SSL_ERROR_SSL",
3079 SSL_ERROR_SSL);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00003080#endif /* USE_SSL */
Guido van Rossum3b4b6fc1997-05-21 14:37:37 +00003081 PySocketSock_Type.ob_type = &PyType_Type;
Guido van Rossum82a5c661998-07-07 20:45:43 +00003082 PySocketSock_Type.tp_doc = sockettype_doc;
Guido van Rossum91ba64d1997-06-02 22:18:09 +00003083 if (PyDict_SetItemString(d, "SocketType",
Guido van Rossum3b4b6fc1997-05-21 14:37:37 +00003084 (PyObject *)&PySocketSock_Type) != 0)
Guido van Rossum0cb96de1997-10-01 04:29:29 +00003085 return;
Guido van Rossum09be4091999-08-09 14:40:40 +00003086
3087 /* Address families (we only support AF_INET and AF_UNIX) */
3088#ifdef AF_UNSPEC
3089 insint(d, "AF_UNSPEC", AF_UNSPEC);
3090#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003091 insint(d, "AF_INET", AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003092#ifdef AF_INET6
3093 insint(d, "AF_INET6", AF_INET6);
3094#endif /* AF_INET6 */
Guido van Rossumb6775db1994-08-01 11:34:53 +00003095#ifdef AF_UNIX
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003096 insint(d, "AF_UNIX", AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00003097#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00003098#ifdef AF_AX25
3099 insint(d, "AF_AX25", AF_AX25); /* Amateur Radio AX.25 */
3100#endif
3101#ifdef AF_IPX
3102 insint(d, "AF_IPX", AF_IPX); /* Novell IPX */
3103#endif
3104#ifdef AF_APPLETALK
3105 insint(d, "AF_APPLETALK", AF_APPLETALK); /* Appletalk DDP */
3106#endif
3107#ifdef AF_NETROM
3108 insint(d, "AF_NETROM", AF_NETROM); /* Amateur radio NetROM */
3109#endif
3110#ifdef AF_BRIDGE
3111 insint(d, "AF_BRIDGE", AF_BRIDGE); /* Multiprotocol bridge */
3112#endif
3113#ifdef AF_AAL5
3114 insint(d, "AF_AAL5", AF_AAL5); /* Reserved for Werner's ATM */
3115#endif
3116#ifdef AF_X25
3117 insint(d, "AF_X25", AF_X25); /* Reserved for X.25 project */
3118#endif
3119#ifdef AF_INET6
3120 insint(d, "AF_INET6", AF_INET6); /* IP version 6 */
3121#endif
3122#ifdef AF_ROSE
3123 insint(d, "AF_ROSE", AF_ROSE); /* Amateur Radio X.25 PLP */
3124#endif
Martin v. Löwis1ba3fd52001-08-10 20:29:40 +00003125#ifdef HAVE_NETPACKET_PACKET_H
Jeremy Hylton22308652001-02-02 03:23:09 +00003126 insint(d, "AF_PACKET", AF_PACKET);
3127 insint(d, "PF_PACKET", PF_PACKET);
3128 insint(d, "PACKET_HOST", PACKET_HOST);
3129 insint(d, "PACKET_BROADCAST", PACKET_BROADCAST);
3130 insint(d, "PACKET_MULTICAST", PACKET_MULTICAST);
3131 insint(d, "PACKET_OTHERHOST", PACKET_OTHERHOST);
3132 insint(d, "PACKET_OUTGOING", PACKET_OUTGOING);
3133 insint(d, "PACKET_LOOPBACK", PACKET_LOOPBACK);
3134 insint(d, "PACKET_FASTROUTE", PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00003135#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00003136
3137 /* Socket types */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003138 insint(d, "SOCK_STREAM", SOCK_STREAM);
3139 insint(d, "SOCK_DGRAM", SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00003140#ifndef __BEOS__
3141/* We have incomplete socket support. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003142 insint(d, "SOCK_RAW", SOCK_RAW);
3143 insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
3144 insint(d, "SOCK_RDM", SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00003145#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003146
3147#ifdef SO_DEBUG
3148 insint(d, "SO_DEBUG", SO_DEBUG);
3149#endif
3150#ifdef SO_ACCEPTCONN
3151 insint(d, "SO_ACCEPTCONN", SO_ACCEPTCONN);
3152#endif
3153#ifdef SO_REUSEADDR
3154 insint(d, "SO_REUSEADDR", SO_REUSEADDR);
3155#endif
3156#ifdef SO_KEEPALIVE
3157 insint(d, "SO_KEEPALIVE", SO_KEEPALIVE);
3158#endif
3159#ifdef SO_DONTROUTE
3160 insint(d, "SO_DONTROUTE", SO_DONTROUTE);
3161#endif
3162#ifdef SO_BROADCAST
3163 insint(d, "SO_BROADCAST", SO_BROADCAST);
3164#endif
3165#ifdef SO_USELOOPBACK
3166 insint(d, "SO_USELOOPBACK", SO_USELOOPBACK);
3167#endif
3168#ifdef SO_LINGER
3169 insint(d, "SO_LINGER", SO_LINGER);
3170#endif
3171#ifdef SO_OOBINLINE
3172 insint(d, "SO_OOBINLINE", SO_OOBINLINE);
3173#endif
3174#ifdef SO_REUSEPORT
3175 insint(d, "SO_REUSEPORT", SO_REUSEPORT);
3176#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003177#ifdef SO_SNDBUF
3178 insint(d, "SO_SNDBUF", SO_SNDBUF);
3179#endif
3180#ifdef SO_RCVBUF
3181 insint(d, "SO_RCVBUF", SO_RCVBUF);
3182#endif
3183#ifdef SO_SNDLOWAT
3184 insint(d, "SO_SNDLOWAT", SO_SNDLOWAT);
3185#endif
3186#ifdef SO_RCVLOWAT
3187 insint(d, "SO_RCVLOWAT", SO_RCVLOWAT);
3188#endif
3189#ifdef SO_SNDTIMEO
3190 insint(d, "SO_SNDTIMEO", SO_SNDTIMEO);
3191#endif
3192#ifdef SO_RCVTIMEO
3193 insint(d, "SO_RCVTIMEO", SO_RCVTIMEO);
3194#endif
3195#ifdef SO_ERROR
3196 insint(d, "SO_ERROR", SO_ERROR);
3197#endif
3198#ifdef SO_TYPE
3199 insint(d, "SO_TYPE", SO_TYPE);
3200#endif
3201
3202 /* Maximum number of connections for "listen" */
3203#ifdef SOMAXCONN
3204 insint(d, "SOMAXCONN", SOMAXCONN);
3205#else
3206 insint(d, "SOMAXCONN", 5); /* Common value */
3207#endif
3208
3209 /* Flags for send, recv */
3210#ifdef MSG_OOB
3211 insint(d, "MSG_OOB", MSG_OOB);
3212#endif
3213#ifdef MSG_PEEK
3214 insint(d, "MSG_PEEK", MSG_PEEK);
3215#endif
3216#ifdef MSG_DONTROUTE
3217 insint(d, "MSG_DONTROUTE", MSG_DONTROUTE);
3218#endif
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00003219#ifdef MSG_DONTWAIT
Guido van Rossum14f3f592000-04-25 21:53:58 +00003220 insint(d, "MSG_DONTWAIT", MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00003221#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003222#ifdef MSG_EOR
3223 insint(d, "MSG_EOR", MSG_EOR);
3224#endif
3225#ifdef MSG_TRUNC
3226 insint(d, "MSG_TRUNC", MSG_TRUNC);
3227#endif
3228#ifdef MSG_CTRUNC
3229 insint(d, "MSG_CTRUNC", MSG_CTRUNC);
3230#endif
3231#ifdef MSG_WAITALL
3232 insint(d, "MSG_WAITALL", MSG_WAITALL);
3233#endif
3234#ifdef MSG_BTAG
3235 insint(d, "MSG_BTAG", MSG_BTAG);
3236#endif
3237#ifdef MSG_ETAG
3238 insint(d, "MSG_ETAG", MSG_ETAG);
3239#endif
3240
3241 /* Protocol level and numbers, usable for [gs]etsockopt */
3242#ifdef SOL_SOCKET
3243 insint(d, "SOL_SOCKET", SOL_SOCKET);
3244#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00003245#ifdef SOL_IP
3246 insint(d, "SOL_IP", SOL_IP);
3247#else
3248 insint(d, "SOL_IP", 0);
3249#endif
3250#ifdef SOL_IPX
3251 insint(d, "SOL_IPX", SOL_IPX);
3252#endif
3253#ifdef SOL_AX25
3254 insint(d, "SOL_AX25", SOL_AX25);
3255#endif
3256#ifdef SOL_ATALK
3257 insint(d, "SOL_ATALK", SOL_ATALK);
3258#endif
3259#ifdef SOL_NETROM
3260 insint(d, "SOL_NETROM", SOL_NETROM);
3261#endif
3262#ifdef SOL_ROSE
3263 insint(d, "SOL_ROSE", SOL_ROSE);
3264#endif
3265#ifdef SOL_TCP
3266 insint(d, "SOL_TCP", SOL_TCP);
3267#else
3268 insint(d, "SOL_TCP", 6);
3269#endif
3270#ifdef SOL_UDP
3271 insint(d, "SOL_UDP", SOL_UDP);
3272#else
3273 insint(d, "SOL_UDP", 17);
3274#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003275#ifdef IPPROTO_IP
3276 insint(d, "IPPROTO_IP", IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00003277#else
3278 insint(d, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003279#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003280#ifdef IPPROTO_HOPOPTS
3281 insint(d, "IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
3282#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003283#ifdef IPPROTO_ICMP
3284 insint(d, "IPPROTO_ICMP", IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00003285#else
3286 insint(d, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003287#endif
3288#ifdef IPPROTO_IGMP
3289 insint(d, "IPPROTO_IGMP", IPPROTO_IGMP);
3290#endif
3291#ifdef IPPROTO_GGP
3292 insint(d, "IPPROTO_GGP", IPPROTO_GGP);
3293#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003294#ifdef IPPROTO_IPV4
3295 insint(d, "IPPROTO_IPV4", IPPROTO_IPV4);
3296#endif
3297#ifdef IPPROTO_IPIP
3298 insint(d, "IPPROTO_IPIP", IPPROTO_IPIP);
3299#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003300#ifdef IPPROTO_TCP
3301 insint(d, "IPPROTO_TCP", IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00003302#else
3303 insint(d, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003304#endif
3305#ifdef IPPROTO_EGP
3306 insint(d, "IPPROTO_EGP", IPPROTO_EGP);
3307#endif
3308#ifdef IPPROTO_PUP
3309 insint(d, "IPPROTO_PUP", IPPROTO_PUP);
3310#endif
3311#ifdef IPPROTO_UDP
3312 insint(d, "IPPROTO_UDP", IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00003313#else
3314 insint(d, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003315#endif
3316#ifdef IPPROTO_IDP
3317 insint(d, "IPPROTO_IDP", IPPROTO_IDP);
3318#endif
3319#ifdef IPPROTO_HELLO
3320 insint(d, "IPPROTO_HELLO", IPPROTO_HELLO);
3321#endif
3322#ifdef IPPROTO_ND
3323 insint(d, "IPPROTO_ND", IPPROTO_ND);
3324#endif
3325#ifdef IPPROTO_TP
3326 insint(d, "IPPROTO_TP", IPPROTO_TP);
3327#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003328#ifdef IPPROTO_IPV6
3329 insint(d, "IPPROTO_IPV6", IPPROTO_IPV6);
3330#endif
3331#ifdef IPPROTO_ROUTING
3332 insint(d, "IPPROTO_ROUTING", IPPROTO_ROUTING);
3333#endif
3334#ifdef IPPROTO_FRAGMENT
3335 insint(d, "IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
3336#endif
3337#ifdef IPPROTO_RSVP
3338 insint(d, "IPPROTO_RSVP", IPPROTO_RSVP);
3339#endif
3340#ifdef IPPROTO_GRE
3341 insint(d, "IPPROTO_GRE", IPPROTO_GRE);
3342#endif
3343#ifdef IPPROTO_ESP
3344 insint(d, "IPPROTO_ESP", IPPROTO_ESP);
3345#endif
3346#ifdef IPPROTO_AH
3347 insint(d, "IPPROTO_AH", IPPROTO_AH);
3348#endif
3349#ifdef IPPROTO_MOBILE
3350 insint(d, "IPPROTO_MOBILE", IPPROTO_MOBILE);
3351#endif
3352#ifdef IPPROTO_ICMPV6
3353 insint(d, "IPPROTO_ICMPV6", IPPROTO_ICMPV6);
3354#endif
3355#ifdef IPPROTO_NONE
3356 insint(d, "IPPROTO_NONE", IPPROTO_NONE);
3357#endif
3358#ifdef IPPROTO_DSTOPTS
3359 insint(d, "IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
3360#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003361#ifdef IPPROTO_XTP
3362 insint(d, "IPPROTO_XTP", IPPROTO_XTP);
3363#endif
3364#ifdef IPPROTO_EON
3365 insint(d, "IPPROTO_EON", IPPROTO_EON);
3366#endif
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003367#ifdef IPPROTO_PIM
3368 insint(d, "IPPROTO_PIM", IPPROTO_PIM);
3369#endif
3370#ifdef IPPROTO_IPCOMP
3371 insint(d, "IPPROTO_IPCOMP", IPPROTO_IPCOMP);
3372#endif
3373#ifdef IPPROTO_VRRP
3374 insint(d, "IPPROTO_VRRP", IPPROTO_VRRP);
3375#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003376#ifdef IPPROTO_BIP
3377 insint(d, "IPPROTO_BIP", IPPROTO_BIP);
3378#endif
3379/**/
3380#ifdef IPPROTO_RAW
3381 insint(d, "IPPROTO_RAW", IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00003382#else
3383 insint(d, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003384#endif
3385#ifdef IPPROTO_MAX
3386 insint(d, "IPPROTO_MAX", IPPROTO_MAX);
3387#endif
3388
3389 /* Some port configuration */
3390#ifdef IPPORT_RESERVED
3391 insint(d, "IPPORT_RESERVED", IPPORT_RESERVED);
3392#else
3393 insint(d, "IPPORT_RESERVED", 1024);
3394#endif
3395#ifdef IPPORT_USERRESERVED
3396 insint(d, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
3397#else
3398 insint(d, "IPPORT_USERRESERVED", 5000);
3399#endif
3400
Guido van Rossum5f05eb41995-02-17 15:11:07 +00003401 /* Some reserved IP v.4 addresses */
3402#ifdef INADDR_ANY
3403 insint(d, "INADDR_ANY", INADDR_ANY);
3404#else
3405 insint(d, "INADDR_ANY", 0x00000000);
3406#endif
3407#ifdef INADDR_BROADCAST
3408 insint(d, "INADDR_BROADCAST", INADDR_BROADCAST);
3409#else
3410 insint(d, "INADDR_BROADCAST", 0xffffffff);
3411#endif
3412#ifdef INADDR_LOOPBACK
3413 insint(d, "INADDR_LOOPBACK", INADDR_LOOPBACK);
3414#else
3415 insint(d, "INADDR_LOOPBACK", 0x7F000001);
3416#endif
3417#ifdef INADDR_UNSPEC_GROUP
3418 insint(d, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
3419#else
3420 insint(d, "INADDR_UNSPEC_GROUP", 0xe0000000);
3421#endif
3422#ifdef INADDR_ALLHOSTS_GROUP
3423 insint(d, "INADDR_ALLHOSTS_GROUP", INADDR_ALLHOSTS_GROUP);
3424#else
3425 insint(d, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
3426#endif
3427#ifdef INADDR_MAX_LOCAL_GROUP
3428 insint(d, "INADDR_MAX_LOCAL_GROUP", INADDR_MAX_LOCAL_GROUP);
3429#else
3430 insint(d, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
3431#endif
3432#ifdef INADDR_NONE
3433 insint(d, "INADDR_NONE", INADDR_NONE);
3434#else
3435 insint(d, "INADDR_NONE", 0xffffffff);
3436#endif
3437
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003438 /* IPv4 [gs]etsockopt options */
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003439#ifdef IP_OPTIONS
3440 insint(d, "IP_OPTIONS", IP_OPTIONS);
3441#endif
3442#ifdef IP_HDRINCL
3443 insint(d, "IP_HDRINCL", IP_HDRINCL);
3444#endif
3445#ifdef IP_TOS
3446 insint(d, "IP_TOS", IP_TOS);
3447#endif
3448#ifdef IP_TTL
3449 insint(d, "IP_TTL", IP_TTL);
3450#endif
3451#ifdef IP_RECVOPTS
3452 insint(d, "IP_RECVOPTS", IP_RECVOPTS);
3453#endif
3454#ifdef IP_RECVRETOPTS
3455 insint(d, "IP_RECVRETOPTS", IP_RECVRETOPTS);
3456#endif
3457#ifdef IP_RECVDSTADDR
3458 insint(d, "IP_RECVDSTADDR", IP_RECVDSTADDR);
3459#endif
3460#ifdef IP_RETOPTS
3461 insint(d, "IP_RETOPTS", IP_RETOPTS);
3462#endif
3463#ifdef IP_MULTICAST_IF
3464 insint(d, "IP_MULTICAST_IF", IP_MULTICAST_IF);
3465#endif
3466#ifdef IP_MULTICAST_TTL
3467 insint(d, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
3468#endif
3469#ifdef IP_MULTICAST_LOOP
3470 insint(d, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
3471#endif
3472#ifdef IP_ADD_MEMBERSHIP
3473 insint(d, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
3474#endif
3475#ifdef IP_DROP_MEMBERSHIP
3476 insint(d, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
3477#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00003478#ifdef IP_DEFAULT_MULTICAST_TTL
3479 insint(d, "IP_DEFAULT_MULTICAST_TTL", IP_DEFAULT_MULTICAST_TTL);
3480#endif
3481#ifdef IP_DEFAULT_MULTICAST_LOOP
3482 insint(d, "IP_DEFAULT_MULTICAST_LOOP", IP_DEFAULT_MULTICAST_LOOP);
3483#endif
3484#ifdef IP_MAX_MEMBERSHIPS
3485 insint(d, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
3486#endif
3487
Martin v. Löwisbcf4b352001-08-04 22:37:23 +00003488 /* IPv6 [gs]etsockopt options, defined in RFC2553 */
3489#ifdef IPV6_JOIN_GROUP
3490 insint(d, "IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
3491#endif
3492#ifdef IPV6_LEAVE_GROUP
3493 insint(d, "IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
3494#endif
3495#ifdef IPV6_MULTICAST_HOPS
3496 insint(d, "IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
3497#endif
3498#ifdef IPV6_MULTICAST_IF
3499 insint(d, "IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
3500#endif
3501#ifdef IPV6_MULTICAST_LOOP
3502 insint(d, "IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
3503#endif
3504#ifdef IPV6_UNICAST_HOPS
3505 insint(d, "IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
3506#endif
3507
Guido van Rossum09be4091999-08-09 14:40:40 +00003508 /* TCP options */
3509#ifdef TCP_NODELAY
3510 insint(d, "TCP_NODELAY", TCP_NODELAY);
3511#endif
3512#ifdef TCP_MAXSEG
3513 insint(d, "TCP_MAXSEG", TCP_MAXSEG);
3514#endif
3515
3516 /* IPX options */
3517#ifdef IPX_TYPE
3518 insint(d, "IPX_TYPE", IPX_TYPE);
3519#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003520
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003521 /* get{addr,name}info parameters */
3522#ifdef EAI_ADDRFAMILY
3523 insint(d, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
3524#endif
3525#ifdef EAI_AGAIN
3526 insint(d, "EAI_AGAIN", EAI_AGAIN);
3527#endif
3528#ifdef EAI_BADFLAGS
3529 insint(d, "EAI_BADFLAGS", EAI_BADFLAGS);
3530#endif
3531#ifdef EAI_FAIL
3532 insint(d, "EAI_FAIL", EAI_FAIL);
3533#endif
3534#ifdef EAI_FAMILY
3535 insint(d, "EAI_FAMILY", EAI_FAMILY);
3536#endif
3537#ifdef EAI_MEMORY
3538 insint(d, "EAI_MEMORY", EAI_MEMORY);
3539#endif
3540#ifdef EAI_NODATA
3541 insint(d, "EAI_NODATA", EAI_NODATA);
3542#endif
3543#ifdef EAI_NONAME
3544 insint(d, "EAI_NONAME", EAI_NONAME);
3545#endif
3546#ifdef EAI_SERVICE
3547 insint(d, "EAI_SERVICE", EAI_SERVICE);
3548#endif
3549#ifdef EAI_SOCKTYPE
3550 insint(d, "EAI_SOCKTYPE", EAI_SOCKTYPE);
3551#endif
3552#ifdef EAI_SYSTEM
3553 insint(d, "EAI_SYSTEM", EAI_SYSTEM);
3554#endif
3555#ifdef EAI_BADHINTS
3556 insint(d, "EAI_BADHINTS", EAI_BADHINTS);
3557#endif
3558#ifdef EAI_PROTOCOL
3559 insint(d, "EAI_PROTOCOL", EAI_PROTOCOL);
3560#endif
3561#ifdef EAI_MAX
3562 insint(d, "EAI_MAX", EAI_MAX);
3563#endif
3564#ifdef AI_PASSIVE
3565 insint(d, "AI_PASSIVE", AI_PASSIVE);
3566#endif
3567#ifdef AI_CANONNAME
3568 insint(d, "AI_CANONNAME", AI_CANONNAME);
3569#endif
3570#ifdef AI_NUMERICHOST
3571 insint(d, "AI_NUMERICHOST", AI_NUMERICHOST);
3572#endif
3573#ifdef AI_MASK
3574 insint(d, "AI_MASK", AI_MASK);
3575#endif
3576#ifdef AI_ALL
3577 insint(d, "AI_ALL", AI_ALL);
3578#endif
3579#ifdef AI_V4MAPPED_CFG
3580 insint(d, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
3581#endif
3582#ifdef AI_ADDRCONFIG
3583 insint(d, "AI_ADDRCONFIG", AI_ADDRCONFIG);
3584#endif
3585#ifdef AI_V4MAPPED
3586 insint(d, "AI_V4MAPPED", AI_V4MAPPED);
3587#endif
3588#ifdef AI_DEFAULT
3589 insint(d, "AI_DEFAULT", AI_DEFAULT);
3590#endif
3591#ifdef NI_MAXHOST
3592 insint(d, "NI_MAXHOST", NI_MAXHOST);
3593#endif
3594#ifdef NI_MAXSERV
3595 insint(d, "NI_MAXSERV", NI_MAXSERV);
3596#endif
3597#ifdef NI_NOFQDN
3598 insint(d, "NI_NOFQDN", NI_NOFQDN);
3599#endif
3600#ifdef NI_NUMERICHOST
3601 insint(d, "NI_NUMERICHOST", NI_NUMERICHOST);
3602#endif
3603#ifdef NI_NAMEREQD
3604 insint(d, "NI_NAMEREQD", NI_NAMEREQD);
3605#endif
3606#ifdef NI_NUMERICSERV
3607 insint(d, "NI_NUMERICSERV", NI_NUMERICSERV);
3608#endif
3609#ifdef NI_DGRAM
3610 insint(d, "NI_DGRAM", NI_DGRAM);
3611#endif
3612
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003613 /* Initialize gethostbyname lock */
Guido van Rossum3baaa131999-03-22 21:44:51 +00003614#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum65d5b571998-12-21 19:32:43 +00003615 gethostbyname_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003616#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003617}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00003618
3619/* Simplistic emulation code for inet_pton that only works for IPv4 */
3620#ifndef HAVE_INET_PTON
Martin v. Löwisa2ca1ae2001-06-24 21:35:43 +00003621int
Martin v. Löwisc925b1532001-07-21 09:42:15 +00003622inet_pton (int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00003623{
3624 if(af == AF_INET){
3625 long packed_addr;
3626#ifdef USE_GUSI1
3627 packed_addr = (long)inet_addr(src).s_addr;
3628#else
3629 packed_addr = inet_addr(src);
3630#endif
3631 if (packed_addr == INADDR_NONE)
3632 return 0;
3633 memcpy(dst, &packed_addr, 4);
3634 return 1;
3635 }
3636 /* Should set errno to EAFNOSUPPORT */
3637 return -1;
3638}
3639
Martin v. Löwisc925b1532001-07-21 09:42:15 +00003640const char *
3641inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00003642{
3643 if (af == AF_INET) {
3644 struct in_addr packed_addr;
3645 if (size < 16)
3646 /* Should set errno to ENOSPC. */
3647 return NULL;
3648 memcpy(&packed_addr, src, sizeof(packed_addr));
3649 return strncpy(dst, inet_ntoa(packed_addr), size);
3650 }
3651 /* Should set errno to EAFNOSUPPORT */
3652 return NULL;
3653}
3654#endif