blob: d33e1902c4917e1b3f9568f2359bf8e08806e83a [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
97#elif defined(__sun__) || defined(__sgi)
98#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
Jeremy Hylton22308652001-02-02 03:23:09 +0000182#if defined(linux) && defined(AF_PACKET)
183#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"
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000214#endif /* USE_SSL */
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000215
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000216#ifndef HAVE_INET_PTON
Martin v. Löwisc925b1532001-07-21 09:42:15 +0000217int inet_pton (int af, const char *src, void *dst);
218const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
Martin v. Löwisb9ab1592001-06-24 21:18:26 +0000219#endif
220
Martin v. Löwis01dfdb32001-06-23 16:30:13 +0000221/* I know this is a bad practice, but it is the easiest... */
222#ifndef HAVE_GETADDRINFO
223#include "getaddrinfo.c"
224#endif
225#ifndef HAVE_GETNAMEINFO
226#include "getnameinfo.c"
227#endif
228
Guido van Rossumbcc20741998-08-04 22:53:56 +0000229#if defined(MS_WINDOWS) || defined(__BEOS__)
230/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000231/* seem to be a few differences in the API */
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000232#define SOCKETCLOSE closesocket
Guido van Rossumbe32c891996-06-20 16:25:29 +0000233#define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +0000234#endif
235
Fred Drakea04eaad2000-06-30 02:46:07 +0000236/* abstract the socket file descriptor type */
237#ifdef MS_WINDOWS
238typedef SOCKET SOCKET_T;
239# ifdef MS_WIN64
240# define SIZEOF_SOCKET_T 8
241# else
242# define SIZEOF_SOCKET_T 4
243# endif
244#else
245typedef int SOCKET_T;
246# define SIZEOF_SOCKET_T SIZEOF_INT
247#endif
248
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000249#ifdef MS_WIN32
250# define EAFNOSUPPORT WSAEAFNOSUPPORT
251# define snprintf _snprintf
252#endif
Fred Drakea04eaad2000-06-30 02:46:07 +0000253
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000254#if defined(PYOS_OS2)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000255#define SOCKETCLOSE soclose
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000256#define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000257#endif
258
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000259#ifndef SOCKETCLOSE
260#define SOCKETCLOSE close
261#endif
262
Guido van Rossum30a685f1991-06-27 15:51:29 +0000263/* Global variable holding the exception type for errors detected
264 by this module (but not argument type or memory errors, etc.). */
265
Guido van Rossum73624e91994-10-10 17:59:00 +0000266static PyObject *PySocket_Error;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000267static PyObject *PyH_Error;
268static PyObject *PyGAI_Error;
Guido van Rossum30a685f1991-06-27 15:51:29 +0000269
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000270#ifdef USE_SSL
271static PyObject *SSLErrorObject;
272#endif /* USE_SSL */
273
Guido van Rossum30a685f1991-06-27 15:51:29 +0000274
Guido van Rossum48a680c2001-03-02 06:34:14 +0000275#ifdef RISCOS
276/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
277static int taskwindow;
278#endif
279
280
Guido van Rossum30a685f1991-06-27 15:51:29 +0000281/* Convenience function to raise an error according to errno
282 and return a NULL pointer from a function. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000283
Guido van Rossum73624e91994-10-10 17:59:00 +0000284static PyObject *
Thomas Woutersf3f33dc2000-07-21 06:00:07 +0000285PySocket_Err(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000286{
Guido van Rossum8d665e61996-06-26 18:22:49 +0000287#ifdef MS_WINDOWS
Mark Hammond46a733d2000-07-24 01:45:11 +0000288 int err_no = WSAGetLastError();
289 if (err_no) {
290 static struct { int no; const char *msg; } *msgp, msgs[] = {
291 { WSAEINTR, "Interrupted system call" },
292 { WSAEBADF, "Bad file descriptor" },
293 { WSAEACCES, "Permission denied" },
294 { WSAEFAULT, "Bad address" },
295 { WSAEINVAL, "Invalid argument" },
296 { WSAEMFILE, "Too many open files" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000297 { WSAEWOULDBLOCK,
Mark Hammond46a733d2000-07-24 01:45:11 +0000298 "The socket operation could not complete "
299 "without blocking" },
300 { WSAEINPROGRESS, "Operation now in progress" },
301 { WSAEALREADY, "Operation already in progress" },
302 { WSAENOTSOCK, "Socket operation on non-socket" },
303 { WSAEDESTADDRREQ, "Destination address required" },
304 { WSAEMSGSIZE, "Message too long" },
305 { WSAEPROTOTYPE, "Protocol wrong type for socket" },
306 { WSAENOPROTOOPT, "Protocol not available" },
307 { WSAEPROTONOSUPPORT, "Protocol not supported" },
308 { WSAESOCKTNOSUPPORT, "Socket type not supported" },
309 { WSAEOPNOTSUPP, "Operation not supported" },
310 { WSAEPFNOSUPPORT, "Protocol family not supported" },
311 { WSAEAFNOSUPPORT, "Address family not supported" },
312 { WSAEADDRINUSE, "Address already in use" },
313 { WSAEADDRNOTAVAIL,
314 "Can't assign requested address" },
315 { WSAENETDOWN, "Network is down" },
316 { WSAENETUNREACH, "Network is unreachable" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000317 { WSAENETRESET,
Mark Hammond46a733d2000-07-24 01:45:11 +0000318 "Network dropped connection on reset" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000319 { WSAECONNABORTED,
Mark Hammond46a733d2000-07-24 01:45:11 +0000320 "Software caused connection abort" },
321 { WSAECONNRESET, "Connection reset by peer" },
322 { WSAENOBUFS, "No buffer space available" },
323 { WSAEISCONN, "Socket is already connected" },
324 { WSAENOTCONN, "Socket is not connected" },
325 { WSAESHUTDOWN, "Can't send after socket shutdown" },
326 { WSAETOOMANYREFS,
327 "Too many references: can't splice" },
328 { WSAETIMEDOUT, "Operation timed out" },
329 { WSAECONNREFUSED, "Connection refused" },
330 { WSAELOOP, "Too many levels of symbolic links" },
331 { WSAENAMETOOLONG, "File name too long" },
332 { WSAEHOSTDOWN, "Host is down" },
333 { WSAEHOSTUNREACH, "No route to host" },
334 { WSAENOTEMPTY, "Directory not empty" },
335 { WSAEPROCLIM, "Too many processes" },
336 { WSAEUSERS, "Too many users" },
337 { WSAEDQUOT, "Disc quota exceeded" },
338 { WSAESTALE, "Stale NFS file handle" },
339 { WSAEREMOTE, "Too many levels of remote in path" },
340 { WSASYSNOTREADY,
341 "Network subsystem is unvailable" },
342 { WSAVERNOTSUPPORTED,
343 "WinSock version is not supported" },
Guido van Rossum48a680c2001-03-02 06:34:14 +0000344 { WSANOTINITIALISED,
Mark Hammond46a733d2000-07-24 01:45:11 +0000345 "Successful WSAStartup() not yet performed" },
346 { WSAEDISCON, "Graceful shutdown in progress" },
347 /* Resolver errors */
348 { WSAHOST_NOT_FOUND, "No such host is known" },
349 { WSATRY_AGAIN, "Host not found, or server failed" },
350 { WSANO_RECOVERY,
351 "Unexpected server error encountered" },
352 { WSANO_DATA, "Valid name without requested data" },
353 { WSANO_ADDRESS, "No address, look for MX record" },
354 { 0, NULL }
355 };
Guido van Rossum73624e91994-10-10 17:59:00 +0000356 PyObject *v;
Mark Hammond46a733d2000-07-24 01:45:11 +0000357 const char *msg = "winsock error";
Guido van Rossum48a680c2001-03-02 06:34:14 +0000358
Mark Hammond46a733d2000-07-24 01:45:11 +0000359 for (msgp = msgs; msgp->msg; msgp++) {
360 if (err_no == msgp->no) {
361 msg = msgp->msg;
362 break;
363 }
364 }
365
366 v = Py_BuildValue("(is)", err_no, msg);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000367 if (v != NULL) {
Guido van Rossum73624e91994-10-10 17:59:00 +0000368 PyErr_SetObject(PySocket_Error, v);
369 Py_DECREF(v);
Guido van Rossum14ed0b21994-09-29 09:50:09 +0000370 }
371 return NULL;
372 }
373 else
374#endif
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000375
376#if defined(PYOS_OS2)
377 if (sock_errno() != NO_ERROR) {
378 APIRET rc;
379 ULONG msglen;
380 char outbuf[100];
381 int myerrorcode = sock_errno();
382
383 /* Retrieve Socket-Related Error Message from MPTN.MSG File */
384 rc = DosGetMessage(NULL, 0, outbuf, sizeof(outbuf),
385 myerrorcode - SOCBASEERR + 26, "mptn.msg", &msglen);
386 if (rc == NO_ERROR) {
387 PyObject *v;
388
389 outbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
390 if (strlen(outbuf) > 0) { /* If Non-Empty Msg, Trim CRLF */
391 char *lastc = &outbuf[ strlen(outbuf)-1 ];
392 while (lastc > outbuf && isspace(*lastc))
393 *lastc-- = '\0'; /* Trim Trailing Whitespace (CRLF) */
394 }
395 v = Py_BuildValue("(is)", myerrorcode, outbuf);
396 if (v != NULL) {
397 PyErr_SetObject(PySocket_Error, v);
398 Py_DECREF(v);
399 }
400 return NULL;
401 }
402 }
403#endif
404
Guido van Rossum73624e91994-10-10 17:59:00 +0000405 return PyErr_SetFromErrno(PySocket_Error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000406}
407
Guido van Rossum30a685f1991-06-27 15:51:29 +0000408
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000409static PyObject *
410PyH_Err(int h_error)
411{
412 PyObject *v;
413
414#ifdef HAVE_HSTRERROR
415 v = Py_BuildValue("(is)", h_error, (char *)hstrerror(h_error));
416#else
417 v = Py_BuildValue("(is)", h_error, "host not found");
418#endif
419 if (v != NULL) {
420 PyErr_SetObject(PyGAI_Error, v);
421 Py_DECREF(v);
422 }
423
424 return NULL;
425}
426
427
428static PyObject *
429PyGAI_Err(int error)
430{
431 PyObject *v;
432
433 if (error == EAI_SYSTEM)
434 return PySocket_Err();
435
436 v = Py_BuildValue("(is)", error, gai_strerror(error));
437 if (v != NULL) {
438 PyErr_SetObject(PyGAI_Error, v);
439 Py_DECREF(v);
440 }
441
442 return NULL;
443}
444
445
Guido van Rossum30a685f1991-06-27 15:51:29 +0000446/* The object holding a socket. It holds some extra information,
447 like the address family, which is used to decode socket address
448 arguments properly. */
449
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000450typedef struct {
Guido van Rossum73624e91994-10-10 17:59:00 +0000451 PyObject_HEAD
Fred Drakea04eaad2000-06-30 02:46:07 +0000452 SOCKET_T sock_fd; /* Socket file descriptor */
Guido van Rossum30a685f1991-06-27 15:51:29 +0000453 int sock_family; /* Address family, e.g., AF_INET */
454 int sock_type; /* Socket type, e.g., SOCK_STREAM */
455 int sock_proto; /* Protocol type, usually 0 */
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000456 union sock_addr {
457 struct sockaddr_in in;
458#ifdef AF_UNIX
459 struct sockaddr_un un;
460#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000461#ifdef INET6
462 struct sockaddr_in6 in6;
463 struct sockaddr_storage storage;
464#endif
Jeremy Hylton22308652001-02-02 03:23:09 +0000465#if defined(linux) && defined(AF_PACKET)
466 struct sockaddr_ll ll;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000467#endif
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000468 } sock_addr;
Guido van Rossum73624e91994-10-10 17:59:00 +0000469} PySocketSockObject;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000470
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000471#ifdef USE_SSL
Guido van Rossum30a685f1991-06-27 15:51:29 +0000472
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000473typedef struct {
474 PyObject_HEAD
475 PySocketSockObject *Socket; /* Socket on which we're layered */
476 PyObject *x_attr; /* Attributes dictionary */
477 SSL_CTX* ctx;
478 SSL* ssl;
479 X509* server_cert;
480 BIO* sbio;
481 char server[256];
482 char issuer[256];
483
484} SSLObject;
485
486staticforward PyTypeObject SSL_Type;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +0000487staticforward PyObject *SSL_SSLwrite(SSLObject *self, PyObject *args);
488staticforward PyObject *SSL_SSLread(SSLObject *self, PyObject *args);
489
490#define SSLObject_Check(v) ((v)->ob_type == &SSL_Type)
491
492#endif /* USE_SSL */
Guido van Rossum48a680c2001-03-02 06:34:14 +0000493
Guido van Rossum30a685f1991-06-27 15:51:29 +0000494/* A forward reference to the Socktype type object.
495 The Socktype variable contains pointers to various functions,
Guido van Rossum73624e91994-10-10 17:59:00 +0000496 some of which call newsockobject(), which uses Socktype, so
Guido van Rossum54ba21b1991-09-10 14:57:12 +0000497 there has to be a circular reference. */
Guido van Rossum30a685f1991-06-27 15:51:29 +0000498
Guido van Rossum73624e91994-10-10 17:59:00 +0000499staticforward PyTypeObject PySocketSock_Type;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000500
Guido van Rossum30a685f1991-06-27 15:51:29 +0000501
502/* Create a new socket object.
503 This just creates the object and initializes it.
504 If the creation fails, return NULL and set an exception (implicit
505 in NEWOBJ()). */
506
Guido van Rossum73624e91994-10-10 17:59:00 +0000507static PySocketSockObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +0000508PySocketSock_New(SOCKET_T fd, int family, int type, int proto)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000509{
Guido van Rossum48a680c2001-03-02 06:34:14 +0000510#ifdef RISCOS
511 int block = 1;
512#endif
Guido van Rossum73624e91994-10-10 17:59:00 +0000513 PySocketSockObject *s;
Guido van Rossum55558541996-05-23 22:54:50 +0000514 PySocketSock_Type.ob_type = &PyType_Type;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000515 s = PyObject_New(PySocketSockObject, &PySocketSock_Type);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000516 if (s != NULL) {
517 s->sock_fd = fd;
518 s->sock_family = family;
519 s->sock_type = type;
520 s->sock_proto = proto;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000521#ifdef RISCOS
522 if(taskwindow) {
523 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
524 }
525#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000526 }
527 return s;
528}
529
Guido van Rossum30a685f1991-06-27 15:51:29 +0000530
Guido van Rossum48a680c2001-03-02 06:34:14 +0000531/* Lock to allow python interpreter to continue, but only allow one
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000532 thread to be in gethostbyname */
Guido van Rossum3baaa131999-03-22 21:44:51 +0000533#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum65d5b571998-12-21 19:32:43 +0000534PyThread_type_lock gethostbyname_lock;
Guido van Rossum4f199ea1998-04-09 20:56:35 +0000535#endif
536
537
Guido van Rossum30a685f1991-06-27 15:51:29 +0000538/* Convert a string specifying a host name or one of a few symbolic
539 names to a numeric IP address. This usually calls gethostbyname()
540 to do the work; the names "" and "<broadcast>" are special.
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000541 Return the length (IPv4 should be 4 bytes), or negative if
Guido van Rossum30a685f1991-06-27 15:51:29 +0000542 an error occurred; then an exception is raised. */
543
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000544static int
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000545setipaddr(char* name, struct sockaddr * addr_ret, int af)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000546{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000547 struct addrinfo hints, *res;
548 int error;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000549
Guido van Rossuma376cc51996-12-05 23:43:35 +0000550 memset((void *) addr_ret, '\0', sizeof(*addr_ret));
Guido van Rossum30a685f1991-06-27 15:51:29 +0000551 if (name[0] == '\0') {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000552 int siz;
553 memset(&hints, 0, sizeof(hints));
554 hints.ai_family = af;
555 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
556 hints.ai_flags = AI_PASSIVE;
557 error = getaddrinfo(NULL, "0", &hints, &res);
558 if (error) {
559 PyGAI_Err(error);
560 return -1;
561 }
562 switch (res->ai_family) {
563 case AF_INET:
564 siz = 4;
565 break;
566#ifdef INET6
567 case AF_INET6:
568 siz = 16;
569 break;
570#endif
571 default:
572 freeaddrinfo(res);
573 PyErr_SetString(PySocket_Error,
574 "unsupported address family");
575 return -1;
576 }
577 if (res->ai_next) {
578 PyErr_SetString(PySocket_Error,
579 "wildcard resolved to multiple address");
580 return -1;
581 }
582 memcpy(addr_ret, res->ai_addr, res->ai_addrlen);
583 freeaddrinfo(res);
584 return siz;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000585 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000586 if (name[0] == '<' && strcmp(name, "<broadcast>") == 0) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000587 struct sockaddr_in *sin;
588 if (af != PF_INET && af != PF_UNSPEC) {
589 PyErr_SetString(PySocket_Error,
590 "address family mismatched");
591 return -1;
592 }
593 sin = (struct sockaddr_in *)addr_ret;
594 memset((void *) sin, '\0', sizeof(*sin));
595 sin->sin_family = AF_INET;
596#ifdef HAVE_SOCKADDR_SA_LEN
597 sin->sin_len = sizeof(*sin);
598#endif
599 sin->sin_addr.s_addr = INADDR_BROADCAST;
600 return sizeof(sin->sin_addr);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000601 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000602 memset(&hints, 0, sizeof(hints));
603 hints.ai_family = af;
604 error = getaddrinfo(name, NULL, &hints, &res);
605 if (error) {
606 PyGAI_Err(error);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000607 return -1;
608 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000609 memcpy((char *) addr_ret, res->ai_addr, res->ai_addrlen);
610 freeaddrinfo(res);
611 switch (addr_ret->sa_family) {
612 case AF_INET:
613 return 4;
614#ifdef INET6
615 case AF_INET6:
616 return 16;
Guido van Rossum955becc1999-03-22 20:14:53 +0000617#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000618 default:
619 PyErr_SetString(PySocket_Error, "unknown address family");
620 return -1;
621 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000622}
623
Guido van Rossum30a685f1991-06-27 15:51:29 +0000624
Guido van Rossum30a685f1991-06-27 15:51:29 +0000625/* Create a string object representing an IP address.
626 This is always a string of the form 'dd.dd.dd.dd' (with variable
627 size numbers). */
628
Guido van Rossum73624e91994-10-10 17:59:00 +0000629static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000630makeipaddr(struct sockaddr *addr, int addrlen)
Guido van Rossum30a685f1991-06-27 15:51:29 +0000631{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000632 char buf[NI_MAXHOST];
633 int error;
634
635 error = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
636 NI_NUMERICHOST);
637 if (error) {
638 PyGAI_Err(error);
639 return NULL;
640 }
Guido van Rossum73624e91994-10-10 17:59:00 +0000641 return PyString_FromString(buf);
Guido van Rossum30a685f1991-06-27 15:51:29 +0000642}
643
644
645/* Create an object representing the given socket address,
646 suitable for passing it back to bind(), connect() etc.
647 The family field of the sockaddr structure is inspected
648 to determine what kind of address it really is. */
649
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000650/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +0000651static PyObject *
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000652makesockaddr(int sockfd, struct sockaddr *addr, int addrlen)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000653{
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000654 if (addrlen == 0) {
655 /* No address -- may be recvfrom() from known socket */
Guido van Rossum73624e91994-10-10 17:59:00 +0000656 Py_INCREF(Py_None);
657 return Py_None;
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000658 }
659
Guido van Rossumbcc20741998-08-04 22:53:56 +0000660#ifdef __BEOS__
Guido van Rossum2c8bcb82000-04-25 21:34:53 +0000661 /* XXX: BeOS version of accept() doesn't set family correctly */
Guido van Rossumbcc20741998-08-04 22:53:56 +0000662 addr->sa_family = AF_INET;
663#endif
664
Guido van Rossum30a685f1991-06-27 15:51:29 +0000665 switch (addr->sa_family) {
666
667 case AF_INET:
668 {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000669 struct sockaddr_in *a;
670 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
Barry Warsaw752300b1997-01-03 17:18:10 +0000671 PyObject *ret = NULL;
672 if (addrobj) {
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000673 a = (struct sockaddr_in *)addr;
Barry Warsaw752300b1997-01-03 17:18:10 +0000674 ret = Py_BuildValue("Oi", addrobj, ntohs(a->sin_port));
675 Py_DECREF(addrobj);
676 }
Guido van Rossum6f5afc91993-02-05 09:46:15 +0000677 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000678 }
Guido van Rossum30a685f1991-06-27 15:51:29 +0000679
Guido van Rossumb6775db1994-08-01 11:34:53 +0000680#ifdef AF_UNIX
Guido van Rossum30a685f1991-06-27 15:51:29 +0000681 case AF_UNIX:
682 {
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000683 struct sockaddr_un *a = (struct sockaddr_un *) addr;
Guido van Rossum73624e91994-10-10 17:59:00 +0000684 return PyString_FromString(a->sun_path);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000685 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000686#endif /* AF_UNIX */
687
688#ifdef INET6
689 case AF_INET6:
690 {
691 struct sockaddr_in6 *a;
692 PyObject *addrobj = makeipaddr(addr, sizeof(*a));
693 PyObject *ret = NULL;
694 if (addrobj) {
695 a = (struct sockaddr_in6 *)addr;
696 ret = Py_BuildValue("Oiii", addrobj, ntohs(a->sin6_port),
697 a->sin6_flowinfo, a->sin6_scope_id);
698 Py_DECREF(addrobj);
699 }
700 return ret;
701 }
Jeremy Hylton22308652001-02-02 03:23:09 +0000702#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +0000703
Jeremy Hylton22308652001-02-02 03:23:09 +0000704#if defined(linux) && defined(AF_PACKET)
705 case AF_PACKET:
706 {
707 struct sockaddr_ll *a = (struct sockaddr_ll *)addr;
708 char *ifname = "";
709 struct ifreq ifr;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000710 /* need to look up interface name give index */
711 if (a->sll_ifindex) {
Jeremy Hylton22308652001-02-02 03:23:09 +0000712 ifr.ifr_ifindex = a->sll_ifindex;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000713 if (ioctl(sockfd, SIOCGIFNAME, &ifr) == 0)
Jeremy Hylton22308652001-02-02 03:23:09 +0000714 ifname = ifr.ifr_name;
Jeremy Hylton22308652001-02-02 03:23:09 +0000715 }
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000716 return Py_BuildValue("shbhs#", ifname, ntohs(a->sll_protocol),
Guido van Rossum48a680c2001-03-02 06:34:14 +0000717 a->sll_pkttype, a->sll_hatype,
718 a->sll_addr, a->sll_halen);
Jeremy Hylton22308652001-02-02 03:23:09 +0000719 }
720#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000721
Guido van Rossum30a685f1991-06-27 15:51:29 +0000722 /* More cases here... */
723
724 default:
Guido van Rossumaa948df1997-05-07 17:41:48 +0000725 /* If we don't know the address family, don't raise an
726 exception -- return it as a tuple. */
727 return Py_BuildValue("is#",
728 addr->sa_family,
729 addr->sa_data,
730 sizeof(addr->sa_data));
Guido van Rossum25bec8c1992-08-05 19:00:45 +0000731
Guido van Rossum30a685f1991-06-27 15:51:29 +0000732 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000733}
734
Guido van Rossum30a685f1991-06-27 15:51:29 +0000735
736/* Parse a socket address argument according to the socket object's
737 address family. Return 1 if the address was in the proper format,
738 0 of not. The address is returned through addr_ret, its length
739 through len_ret. */
740
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000741static int
Guido van Rossum48a680c2001-03-02 06:34:14 +0000742getsockaddrarg(PySocketSockObject *s, PyObject *args,
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000743 struct sockaddr **addr_ret, int *len_ret)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000744{
Guido van Rossum30a685f1991-06-27 15:51:29 +0000745 switch (s->sock_family) {
746
Guido van Rossumb6775db1994-08-01 11:34:53 +0000747#ifdef AF_UNIX
Guido van Rossum30a685f1991-06-27 15:51:29 +0000748 case AF_UNIX:
749 {
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000750 struct sockaddr_un* addr;
Guido van Rossumff4949e1992-08-05 19:58:53 +0000751 char *path;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000752 int len;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000753 addr = (struct sockaddr_un* )&(s->sock_addr).un;
Guido van Rossum7e488981998-10-08 02:25:24 +0000754 if (!PyArg_Parse(args, "t#", &path, &len))
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000755 return 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000756 if (len > sizeof addr->sun_path) {
Barry Warsaw752300b1997-01-03 17:18:10 +0000757 PyErr_SetString(PySocket_Error,
758 "AF_UNIX path too long");
Guido van Rossum30a685f1991-06-27 15:51:29 +0000759 return 0;
760 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000761 addr->sun_family = s->sock_family;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000762 memcpy(addr->sun_path, path, len);
Guido van Rossum30b6b2b1995-06-14 22:28:08 +0000763 addr->sun_path[len] = 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000764 *addr_ret = (struct sockaddr *) addr;
Guido van Rossum65af28a1996-06-11 18:36:33 +0000765 *len_ret = len + sizeof(*addr) - sizeof(addr->sun_path);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000766 return 1;
767 }
Guido van Rossumb6775db1994-08-01 11:34:53 +0000768#endif /* AF_UNIX */
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000769
Guido van Rossum30a685f1991-06-27 15:51:29 +0000770 case AF_INET:
771 {
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000772 struct sockaddr_in* addr;
Guido van Rossumff4949e1992-08-05 19:58:53 +0000773 char *host;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000774 int port;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000775 addr=(struct sockaddr_in*)&(s->sock_addr).in;
Guido van Rossume4dad902000-12-01 13:13:11 +0000776 if (!PyTuple_Check(args)) {
777 PyErr_Format(PyExc_TypeError,
778 "getsockaddrarg: AF_INET address must be tuple, not %.500s",
779 args->ob_type->tp_name);
780 return 0;
781 }
782 if (!PyArg_ParseTuple(args, "si:getsockaddrarg", &host, &port))
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000783 return 0;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000784 if (setipaddr(host, (struct sockaddr *)addr, AF_INET) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000785 return 0;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000786 addr->sin_family = AF_INET;
Guido van Rossum644a12b1997-04-09 19:24:53 +0000787 addr->sin_port = htons((short)port);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +0000788 *addr_ret = (struct sockaddr *) addr;
789 *len_ret = sizeof *addr;
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000790 return 1;
791 }
792
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000793#ifdef INET6
794 case AF_INET6:
795 {
796 struct sockaddr_in6* addr;
797 char *host;
798 int port, flowinfo, scope_id;
799 addr = (struct sockaddr_in6*)&(s->sock_addr).in6;
800 flowinfo = scope_id = 0;
801 if (!PyArg_ParseTuple(args, "si|ii", &host, &port, &flowinfo,
802 &scope_id)) {
803 return 0;
804 }
805 if (setipaddr(host, (struct sockaddr *)addr, AF_INET6) < 0)
806 return 0;
807 addr->sin6_family = s->sock_family;
808 addr->sin6_port = htons((short)port);
809 addr->sin6_flowinfo = flowinfo;
810 addr->sin6_scope_id = scope_id;
811 *addr_ret = (struct sockaddr *) addr;
812 *len_ret = sizeof *addr;
813 return 1;
814 }
815#endif
816
Jeremy Hylton22308652001-02-02 03:23:09 +0000817#if defined(linux) && defined(AF_PACKET)
818 case AF_PACKET:
819 {
820 struct sockaddr_ll* addr;
821 struct ifreq ifr;
822 char *interfaceName;
823 int protoNumber;
824 int hatype = 0;
825 int pkttype = 0;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000826 char *haddr;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000827
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000828 if (!PyArg_ParseTuple(args, "si|iis", &interfaceName,
829 &protoNumber, &pkttype, &hatype, &haddr))
Jeremy Hylton22308652001-02-02 03:23:09 +0000830 return 0;
831 strncpy(ifr.ifr_name, interfaceName, sizeof(ifr.ifr_name));
832 ifr.ifr_name[(sizeof(ifr.ifr_name))-1] = '\0';
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000833 if (ioctl(s->sock_fd, SIOCGIFINDEX, &ifr) < 0) {
834 PyErr_SetFromErrno(PySocket_Error);
Jeremy Hylton22308652001-02-02 03:23:09 +0000835 return 0;
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000836 }
Jeremy Hylton22308652001-02-02 03:23:09 +0000837 addr = &(s->sock_addr.ll);
838 addr->sll_family = AF_PACKET;
839 addr->sll_protocol = htons((short)protoNumber);
840 addr->sll_ifindex = ifr.ifr_ifindex;
841 addr->sll_pkttype = pkttype;
842 addr->sll_hatype = hatype;
843 *addr_ret = (struct sockaddr *) addr;
844 *len_ret = sizeof *addr;
845 return 1;
846 }
Guido van Rossum48a680c2001-03-02 06:34:14 +0000847#endif
848
Guido van Rossum30a685f1991-06-27 15:51:29 +0000849 /* More cases here... */
850
851 default:
Guido van Rossum73624e91994-10-10 17:59:00 +0000852 PyErr_SetString(PySocket_Error, "getsockaddrarg: bad family");
Guido van Rossum30a685f1991-06-27 15:51:29 +0000853 return 0;
854
855 }
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000856}
857
Guido van Rossum30a685f1991-06-27 15:51:29 +0000858
Guido van Rossum48a680c2001-03-02 06:34:14 +0000859/* Get the address length according to the socket object's address family.
Guido van Rossum710e1df1992-06-12 10:39:36 +0000860 Return 1 if the family is known, 0 otherwise. The length is returned
861 through len_ret. */
862
863static int
Peter Schneider-Kamp618e25d2000-07-11 23:00:12 +0000864getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)
Guido van Rossum710e1df1992-06-12 10:39:36 +0000865{
866 switch (s->sock_family) {
867
Guido van Rossumb6775db1994-08-01 11:34:53 +0000868#ifdef AF_UNIX
Guido van Rossum710e1df1992-06-12 10:39:36 +0000869 case AF_UNIX:
870 {
871 *len_ret = sizeof (struct sockaddr_un);
872 return 1;
873 }
Guido van Rossumb6775db1994-08-01 11:34:53 +0000874#endif /* AF_UNIX */
Guido van Rossum710e1df1992-06-12 10:39:36 +0000875
876 case AF_INET:
877 {
878 *len_ret = sizeof (struct sockaddr_in);
879 return 1;
880 }
881
Martin v. Löwis2d8d4272001-07-21 18:05:31 +0000882#ifdef INET6
883 case AF_INET6:
884 {
885 *len_ret = sizeof (struct sockaddr_in6);
886 return 1;
887 }
888#endif
889
Jeremy Hylton22308652001-02-02 03:23:09 +0000890#if defined(linux) && defined(AF_PACKET)
891 case AF_PACKET:
892 {
893 *len_ret = sizeof (struct sockaddr_ll);
894 return 1;
895 }
896#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000897
Guido van Rossum710e1df1992-06-12 10:39:36 +0000898 /* More cases here... */
899
900 default:
Guido van Rossum27fc3c02000-03-24 20:56:56 +0000901 PyErr_SetString(PySocket_Error, "getsockaddrlen: bad family");
Guido van Rossum710e1df1992-06-12 10:39:36 +0000902 return 0;
903
904 }
905}
906
907
Guido van Rossum30a685f1991-06-27 15:51:29 +0000908/* s.accept() method */
909
Guido van Rossum73624e91994-10-10 17:59:00 +0000910static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +0000911PySocketSock_accept(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000912{
913 char addrbuf[256];
Fred Drakea04eaad2000-06-30 02:46:07 +0000914 SOCKET_T newfd;
Guido van Rossumff3ab422000-04-24 15:16:03 +0000915 socklen_t addrlen;
Barry Warsaw752300b1997-01-03 17:18:10 +0000916 PyObject *sock = NULL;
917 PyObject *addr = NULL;
918 PyObject *res = NULL;
919
Guido van Rossum27fc3c02000-03-24 20:56:56 +0000920 if (!PyArg_ParseTuple(args, ":accept"))
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000921 return NULL;
Guido van Rossum710e1df1992-06-12 10:39:36 +0000922 if (!getsockaddrlen(s, &addrlen))
923 return NULL;
Fred Drakefd168342001-05-09 19:11:33 +0000924 memset(addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +0000925 Py_BEGIN_ALLOW_THREADS
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000926 newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +0000927 Py_END_ALLOW_THREADS
Fred Drakea04eaad2000-06-30 02:46:07 +0000928#ifdef MS_WINDOWS
929 if (newfd == INVALID_SOCKET)
930#else
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000931 if (newfd < 0)
Fred Drakea04eaad2000-06-30 02:46:07 +0000932#endif
Guido van Rossum73624e91994-10-10 17:59:00 +0000933 return PySocket_Err();
Barry Warsaw752300b1997-01-03 17:18:10 +0000934
Guido van Rossum30a685f1991-06-27 15:51:29 +0000935 /* Create the new object with unspecified family,
936 to avoid calls to bind() etc. on it. */
Guido van Rossum73624e91994-10-10 17:59:00 +0000937 sock = (PyObject *) PySocketSock_New(newfd,
Guido van Rossum6f5afc91993-02-05 09:46:15 +0000938 s->sock_family,
939 s->sock_type,
940 s->sock_proto);
Barry Warsaw752300b1997-01-03 17:18:10 +0000941 if (sock == NULL) {
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +0000942 SOCKETCLOSE(newfd);
Barry Warsaw752300b1997-01-03 17:18:10 +0000943 goto finally;
944 }
Guido van Rossum48a680c2001-03-02 06:34:14 +0000945 addr = makesockaddr(s->sock_fd, (struct sockaddr *)addrbuf,
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000946 addrlen);
947 if (addr == NULL)
Barry Warsaw752300b1997-01-03 17:18:10 +0000948 goto finally;
949
Jeremy Hyltondbfb6622001-02-02 19:55:17 +0000950 res = Py_BuildValue("OO", sock, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +0000951
952 finally:
Guido van Rossum73624e91994-10-10 17:59:00 +0000953 Py_XDECREF(sock);
954 Py_XDECREF(addr);
Guido van Rossum6574b3e1991-06-25 21:36:08 +0000955 return res;
956}
957
Guido van Rossum82a5c661998-07-07 20:45:43 +0000958static char accept_doc[] =
959"accept() -> (socket object, address info)\n\
960\n\
961Wait for an incoming connection. Return a new socket representing the\n\
962connection, and the address of the client. For IP sockets, the address\n\
963info is a pair (hostaddr, port).";
964
Guido van Rossum30a685f1991-06-27 15:51:29 +0000965
Guido van Rossume4485b01994-09-07 14:32:49 +0000966/* s.setblocking(1 | 0) method */
967
Guido van Rossum73624e91994-10-10 17:59:00 +0000968static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +0000969PySocketSock_setblocking(PySocketSockObject *s, PyObject *args)
Guido van Rossume4485b01994-09-07 14:32:49 +0000970{
971 int block;
Guido van Rossum48a680c2001-03-02 06:34:14 +0000972#ifndef RISCOS
Guido van Rossum644a12b1997-04-09 19:24:53 +0000973#ifndef MS_WINDOWS
Guido van Rossume4485b01994-09-07 14:32:49 +0000974 int delay_flag;
Guido van Rossum644a12b1997-04-09 19:24:53 +0000975#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +0000976#endif
Guido van Rossum27fc3c02000-03-24 20:56:56 +0000977 if (!PyArg_ParseTuple(args, "i:setblocking", &block))
Guido van Rossume4485b01994-09-07 14:32:49 +0000978 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +0000979 Py_BEGIN_ALLOW_THREADS
Guido van Rossumbcc20741998-08-04 22:53:56 +0000980#ifdef __BEOS__
981 block = !block;
982 setsockopt( s->sock_fd, SOL_SOCKET, SO_NONBLOCK,
983 (void *)(&block), sizeof( int ) );
984#else
Guido van Rossum48a680c2001-03-02 06:34:14 +0000985#ifndef RISCOS
Guido van Rossum6f489d91996-06-28 20:15:15 +0000986#ifndef MS_WINDOWS
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000987#ifdef PYOS_OS2
988 block = !block;
989 ioctl(s->sock_fd, FIONBIO, (caddr_t)&block, sizeof(block));
990#else /* !PYOS_OS2 */
Guido van Rossume4485b01994-09-07 14:32:49 +0000991 delay_flag = fcntl (s->sock_fd, F_GETFL, 0);
992 if (block)
993 delay_flag &= (~O_NDELAY);
994 else
995 delay_flag |= O_NDELAY;
996 fcntl (s->sock_fd, F_SETFL, delay_flag);
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +0000997#endif /* !PYOS_OS2 */
998#else /* MS_WINDOWS */
Guido van Rossum30b6b2b1995-06-14 22:28:08 +0000999 block = !block;
1000 ioctlsocket(s->sock_fd, FIONBIO, (u_long*)&block);
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00001001#endif /* MS_WINDOWS */
Guido van Rossumbcc20741998-08-04 22:53:56 +00001002#endif /* __BEOS__ */
Guido van Rossum48a680c2001-03-02 06:34:14 +00001003#endif /* RISCOS */
Guido van Rossum73624e91994-10-10 17:59:00 +00001004 Py_END_ALLOW_THREADS
Guido van Rossume4485b01994-09-07 14:32:49 +00001005
Guido van Rossum73624e91994-10-10 17:59:00 +00001006 Py_INCREF(Py_None);
1007 return Py_None;
Guido van Rossume4485b01994-09-07 14:32:49 +00001008}
Guido van Rossume4485b01994-09-07 14:32:49 +00001009
Guido van Rossum82a5c661998-07-07 20:45:43 +00001010static char setblocking_doc[] =
1011"setblocking(flag)\n\
1012\n\
1013Set the socket to blocking (flag is true) or non-blocking (false).\n\
1014This uses the FIONBIO ioctl with the O_NDELAY flag.";
1015
Guido van Rossume4485b01994-09-07 14:32:49 +00001016
Guido van Rossum48a680c2001-03-02 06:34:14 +00001017#ifdef RISCOS
1018/* s.sleeptaskw(1 | 0) method */
1019
1020static PyObject *
1021PySocketSock_sleeptaskw(PySocketSockObject *s,PyObject *args)
1022{
1023 int block;
1024 int delay_flag;
1025 if (!PyArg_GetInt(args, &block))
1026 return NULL;
1027 Py_BEGIN_ALLOW_THREADS
1028 socketioctl(s->sock_fd, 0x80046679, (u_long*)&block);
1029 Py_END_ALLOW_THREADS
1030
1031 Py_INCREF(Py_None);
1032 return Py_None;
1033}
1034static char sleeptaskw_doc[] =
1035"sleeptaskw(flag)\n\
1036\n\
1037Allow sleeps in taskwindows.";
1038#endif
1039
1040
Guido van Rossumaee08791992-09-08 09:05:33 +00001041/* s.setsockopt() method.
1042 With an integer third argument, sets an integer option.
1043 With a string third argument, sets an option from a buffer;
1044 use optional built-in module 'struct' to encode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001045
Guido van Rossum73624e91994-10-10 17:59:00 +00001046static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001047PySocketSock_setsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001048{
1049 int level;
1050 int optname;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001051 int res;
Guido van Rossumaee08791992-09-08 09:05:33 +00001052 char *buf;
1053 int buflen;
1054 int flag;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001055
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001056 if (PyArg_ParseTuple(args, "iii:setsockopt",
1057 &level, &optname, &flag)) {
Guido van Rossumaee08791992-09-08 09:05:33 +00001058 buf = (char *) &flag;
1059 buflen = sizeof flag;
1060 }
1061 else {
Guido van Rossum73624e91994-10-10 17:59:00 +00001062 PyErr_Clear();
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001063 if (!PyArg_ParseTuple(args, "iis#:setsockopt",
1064 &level, &optname, &buf, &buflen))
Guido van Rossumaee08791992-09-08 09:05:33 +00001065 return NULL;
1066 }
Thomas Wouters334fb892000-07-25 12:56:38 +00001067 res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001068 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001069 return PySocket_Err();
1070 Py_INCREF(Py_None);
1071 return Py_None;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001072}
1073
Guido van Rossum82a5c661998-07-07 20:45:43 +00001074static char setsockopt_doc[] =
1075"setsockopt(level, option, value)\n\
1076\n\
1077Set a socket option. See the Unix manual for level and option.\n\
1078The value argument can either be an integer or a string.";
1079
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001080
Guido van Rossumaee08791992-09-08 09:05:33 +00001081/* s.getsockopt() method.
1082 With two arguments, retrieves an integer option.
1083 With a third integer argument, retrieves a string buffer of that size;
1084 use optional built-in module 'struct' to decode the string. */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001085
Guido van Rossum73624e91994-10-10 17:59:00 +00001086static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001087PySocketSock_getsockopt(PySocketSockObject *s, PyObject *args)
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001088{
1089 int level;
1090 int optname;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001091 int res;
Guido van Rossum73624e91994-10-10 17:59:00 +00001092 PyObject *buf;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001093 socklen_t buflen = 0;
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001094
Guido van Rossumbcc20741998-08-04 22:53:56 +00001095#ifdef __BEOS__
Fred Drake564a6cc2001-05-11 20:12:26 +00001096 /* We have incomplete socket support. */
1097 PyErr_SetString(PySocket_Error, "getsockopt not supported");
Guido van Rossumbcc20741998-08-04 22:53:56 +00001098 return NULL;
1099#else
1100
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001101 if (!PyArg_ParseTuple(args, "ii|i:getsockopt",
1102 &level, &optname, &buflen))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001103 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001104
Guido van Rossumbe32c891996-06-20 16:25:29 +00001105 if (buflen == 0) {
Guido van Rossumaee08791992-09-08 09:05:33 +00001106 int flag = 0;
Guido van Rossumff3ab422000-04-24 15:16:03 +00001107 socklen_t flagsize = sizeof flag;
Guido van Rossumb376a4a1993-11-23 17:53:17 +00001108 res = getsockopt(s->sock_fd, level, optname,
Thomas Wouters334fb892000-07-25 12:56:38 +00001109 (void *)&flag, &flagsize);
Guido van Rossumaee08791992-09-08 09:05:33 +00001110 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001111 return PySocket_Err();
1112 return PyInt_FromLong(flag);
Guido van Rossumaee08791992-09-08 09:05:33 +00001113 }
Guido van Rossumaee08791992-09-08 09:05:33 +00001114 if (buflen <= 0 || buflen > 1024) {
Barry Warsaw752300b1997-01-03 17:18:10 +00001115 PyErr_SetString(PySocket_Error,
1116 "getsockopt buflen out of range");
Guido van Rossumaee08791992-09-08 09:05:33 +00001117 return NULL;
1118 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001119 buf = PyString_FromStringAndSize((char *)NULL, buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001120 if (buf == NULL)
1121 return NULL;
Guido van Rossumb376a4a1993-11-23 17:53:17 +00001122 res = getsockopt(s->sock_fd, level, optname,
Fred Drake564a6cc2001-05-11 20:12:26 +00001123 (void *)PyString_AS_STRING(buf), &buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001124 if (res < 0) {
Guido van Rossum73624e91994-10-10 17:59:00 +00001125 Py_DECREF(buf);
1126 return PySocket_Err();
Guido van Rossumaee08791992-09-08 09:05:33 +00001127 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001128 _PyString_Resize(&buf, buflen);
Guido van Rossumaee08791992-09-08 09:05:33 +00001129 return buf;
Guido van Rossumbcc20741998-08-04 22:53:56 +00001130#endif /* __BEOS__ */
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001131}
1132
Guido van Rossum82a5c661998-07-07 20:45:43 +00001133static char getsockopt_doc[] =
1134"getsockopt(level, option[, buffersize]) -> value\n\
1135\n\
1136Get a socket option. See the Unix manual for level and option.\n\
1137If a nonzero buffersize argument is given, the return value is a\n\
1138string of that length; otherwise it is an integer.";
1139
Guido van Rossum0e69587d1992-06-05 15:11:30 +00001140
Fred Drake728819a2000-07-01 03:40:12 +00001141/* s.bind(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001142
Guido van Rossum73624e91994-10-10 17:59:00 +00001143static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001144PySocketSock_bind(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001145{
1146 struct sockaddr *addr;
1147 int addrlen;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001148 int res;
Fred Drake728819a2000-07-01 03:40:12 +00001149 PyObject *addro;
1150 if (!PyArg_ParseTuple(args, "O:bind", &addro))
1151 return NULL;
1152 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001153 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001154 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001155 res = bind(s->sock_fd, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001156 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001157 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001158 return PySocket_Err();
1159 Py_INCREF(Py_None);
1160 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001161}
1162
Guido van Rossum82a5c661998-07-07 20:45:43 +00001163static char bind_doc[] =
1164"bind(address)\n\
1165\n\
1166Bind the socket to a local address. For IP sockets, the address is a\n\
Jeremy Hylton22308652001-02-02 03:23:09 +00001167pair (host, port); the host must refer to the local host. For raw packet\n\
1168sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])";
Guido van Rossum82a5c661998-07-07 20:45:43 +00001169
Guido van Rossum30a685f1991-06-27 15:51:29 +00001170
1171/* s.close() method.
1172 Set the file descriptor to -1 so operations tried subsequently
1173 will surely fail. */
1174
Guido van Rossum73624e91994-10-10 17:59:00 +00001175static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001176PySocketSock_close(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001177{
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001178 SOCKET_T fd;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001179 if (!PyArg_ParseTuple(args, ":close"))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001180 return NULL;
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001181 if ((fd = s->sock_fd) != -1) {
1182 s->sock_fd = -1;
Guido van Rossum08481461996-10-12 14:07:22 +00001183 Py_BEGIN_ALLOW_THREADS
Guido van Rossum20d3fc02000-12-18 22:23:44 +00001184 (void) SOCKETCLOSE(fd);
Guido van Rossum08481461996-10-12 14:07:22 +00001185 Py_END_ALLOW_THREADS
1186 }
Guido van Rossum73624e91994-10-10 17:59:00 +00001187 Py_INCREF(Py_None);
1188 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001189}
1190
Guido van Rossum82a5c661998-07-07 20:45:43 +00001191static char close_doc[] =
1192"close()\n\
1193\n\
1194Close the socket. It cannot be used after this call.";
1195
Guido van Rossum30a685f1991-06-27 15:51:29 +00001196
Fred Drake728819a2000-07-01 03:40:12 +00001197/* s.connect(sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001198
Guido van Rossum73624e91994-10-10 17:59:00 +00001199static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001200PySocketSock_connect(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001201{
1202 struct sockaddr *addr;
1203 int addrlen;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001204 int res;
Fred Drake728819a2000-07-01 03:40:12 +00001205 PyObject *addro;
1206 if (!PyArg_ParseTuple(args, "O:connect", &addro))
1207 return NULL;
1208 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001209 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001210 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001211 res = connect(s->sock_fd, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001212 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001213 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001214 return PySocket_Err();
1215 Py_INCREF(Py_None);
1216 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001217}
1218
Guido van Rossum82a5c661998-07-07 20:45:43 +00001219static char connect_doc[] =
1220"connect(address)\n\
1221\n\
1222Connect the socket to a remote address. For IP sockets, the address\n\
1223is a pair (host, port).";
1224
Guido van Rossum30a685f1991-06-27 15:51:29 +00001225
Fred Drake728819a2000-07-01 03:40:12 +00001226/* s.connect_ex(sockaddr) method */
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001227
1228static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001229PySocketSock_connect_ex(PySocketSockObject *s, PyObject *args)
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001230{
1231 struct sockaddr *addr;
1232 int addrlen;
1233 int res;
Fred Drake728819a2000-07-01 03:40:12 +00001234 PyObject *addro;
1235 if (!PyArg_ParseTuple(args, "O:connect_ex", &addro))
1236 return NULL;
1237 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001238 return NULL;
1239 Py_BEGIN_ALLOW_THREADS
1240 res = connect(s->sock_fd, addr, addrlen);
1241 Py_END_ALLOW_THREADS
1242 if (res != 0)
1243 res = errno;
1244 return PyInt_FromLong((long) res);
1245}
1246
Guido van Rossum82a5c661998-07-07 20:45:43 +00001247static char connect_ex_doc[] =
1248"connect_ex(address)\n\
1249\n\
1250This is like connect(address), but returns an error code (the errno value)\n\
1251instead of raising an exception when an error occurs.";
1252
Guido van Rossumfc4255d1997-11-19 18:57:13 +00001253
Guido van Rossumed233a51992-06-23 09:07:03 +00001254/* s.fileno() method */
1255
Guido van Rossum73624e91994-10-10 17:59:00 +00001256static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001257PySocketSock_fileno(PySocketSockObject *s, PyObject *args)
Guido van Rossumed233a51992-06-23 09:07:03 +00001258{
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001259 if (!PyArg_ParseTuple(args, ":fileno"))
Guido van Rossumed233a51992-06-23 09:07:03 +00001260 return NULL;
Fred Drakea04eaad2000-06-30 02:46:07 +00001261#if SIZEOF_SOCKET_T <= SIZEOF_LONG
Guido van Rossum73624e91994-10-10 17:59:00 +00001262 return PyInt_FromLong((long) s->sock_fd);
Fred Drakea04eaad2000-06-30 02:46:07 +00001263#else
1264 return PyLong_FromLongLong((LONG_LONG)s->sock_fd);
1265#endif
Guido van Rossumed233a51992-06-23 09:07:03 +00001266}
1267
Guido van Rossum82a5c661998-07-07 20:45:43 +00001268static char fileno_doc[] =
1269"fileno() -> integer\n\
1270\n\
1271Return the integer file descriptor of the socket.";
1272
Guido van Rossumed233a51992-06-23 09:07:03 +00001273
Guido van Rossumbe32c891996-06-20 16:25:29 +00001274#ifndef NO_DUP
1275/* s.dup() method */
1276
1277static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001278PySocketSock_dup(PySocketSockObject *s, PyObject *args)
Guido van Rossumbe32c891996-06-20 16:25:29 +00001279{
Fred Drakea04eaad2000-06-30 02:46:07 +00001280 SOCKET_T newfd;
Guido van Rossumbe32c891996-06-20 16:25:29 +00001281 PyObject *sock;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001282 if (!PyArg_ParseTuple(args, ":dup"))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001283 return NULL;
1284 newfd = dup(s->sock_fd);
1285 if (newfd < 0)
1286 return PySocket_Err();
1287 sock = (PyObject *) PySocketSock_New(newfd,
Barry Warsaw752300b1997-01-03 17:18:10 +00001288 s->sock_family,
1289 s->sock_type,
1290 s->sock_proto);
Guido van Rossumbe32c891996-06-20 16:25:29 +00001291 if (sock == NULL)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001292 SOCKETCLOSE(newfd);
Guido van Rossumbe32c891996-06-20 16:25:29 +00001293 return sock;
1294}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001295
1296static char dup_doc[] =
1297"dup() -> socket object\n\
1298\n\
1299Return a new socket object connected to the same system resource.";
1300
Guido van Rossumbe32c891996-06-20 16:25:29 +00001301#endif
1302
1303
Guido van Rossumc89705d1992-11-26 08:54:07 +00001304/* s.getsockname() method */
1305
Guido van Rossum73624e91994-10-10 17:59:00 +00001306static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001307PySocketSock_getsockname(PySocketSockObject *s, PyObject *args)
Guido van Rossumc89705d1992-11-26 08:54:07 +00001308{
1309 char addrbuf[256];
Guido van Rossumff3ab422000-04-24 15:16:03 +00001310 int res;
1311 socklen_t addrlen;
1312
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001313 if (!PyArg_ParseTuple(args, ":getsockname"))
Guido van Rossumc89705d1992-11-26 08:54:07 +00001314 return NULL;
1315 if (!getsockaddrlen(s, &addrlen))
1316 return NULL;
Guido van Rossumca42b161996-01-12 01:36:05 +00001317 memset(addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001318 Py_BEGIN_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001319 res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001320 Py_END_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001321 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001322 return PySocket_Err();
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001323 return makesockaddr(s->sock_fd, (struct sockaddr *) addrbuf, addrlen);
Guido van Rossumc89705d1992-11-26 08:54:07 +00001324}
1325
Guido van Rossum82a5c661998-07-07 20:45:43 +00001326static char getsockname_doc[] =
1327"getsockname() -> address info\n\
1328\n\
1329Return the address of the local endpoint. For IP sockets, the address\n\
1330info is a pair (hostaddr, port).";
1331
Guido van Rossumc89705d1992-11-26 08:54:07 +00001332
Guido van Rossumb6775db1994-08-01 11:34:53 +00001333#ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
Guido van Rossumc89705d1992-11-26 08:54:07 +00001334/* s.getpeername() method */
1335
Guido van Rossum73624e91994-10-10 17:59:00 +00001336static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001337PySocketSock_getpeername(PySocketSockObject *s, PyObject *args)
Guido van Rossumc89705d1992-11-26 08:54:07 +00001338{
1339 char addrbuf[256];
Guido van Rossumff3ab422000-04-24 15:16:03 +00001340 int res;
1341 socklen_t addrlen;
1342
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001343 if (!PyArg_ParseTuple(args, ":getpeername"))
Guido van Rossumc89705d1992-11-26 08:54:07 +00001344 return NULL;
1345 if (!getsockaddrlen(s, &addrlen))
1346 return NULL;
Fred Drakefd168342001-05-09 19:11:33 +00001347 memset(addrbuf, 0, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001348 Py_BEGIN_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001349 res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001350 Py_END_ALLOW_THREADS
Guido van Rossumc89705d1992-11-26 08:54:07 +00001351 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001352 return PySocket_Err();
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001353 return makesockaddr(s->sock_fd, (struct sockaddr *) addrbuf, addrlen);
Guido van Rossumc89705d1992-11-26 08:54:07 +00001354}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001355
1356static char getpeername_doc[] =
1357"getpeername() -> address info\n\
1358\n\
1359Return the address of the remote endpoint. For IP sockets, the address\n\
1360info is a pair (hostaddr, port).";
1361
Guido van Rossumb6775db1994-08-01 11:34:53 +00001362#endif /* HAVE_GETPEERNAME */
Guido van Rossumc89705d1992-11-26 08:54:07 +00001363
1364
Guido van Rossum30a685f1991-06-27 15:51:29 +00001365/* s.listen(n) method */
1366
Guido van Rossum73624e91994-10-10 17:59:00 +00001367static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001368PySocketSock_listen(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001369{
1370 int backlog;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001371 int res;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001372 if (!PyArg_ParseTuple(args, "i:listen", &backlog))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001373 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001374 Py_BEGIN_ALLOW_THREADS
Guido van Rossumb6775db1994-08-01 11:34:53 +00001375 if (backlog < 1)
1376 backlog = 1;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001377 res = listen(s->sock_fd, backlog);
Guido van Rossum73624e91994-10-10 17:59:00 +00001378 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001379 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001380 return PySocket_Err();
1381 Py_INCREF(Py_None);
1382 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001383}
1384
Guido van Rossum82a5c661998-07-07 20:45:43 +00001385static char listen_doc[] =
1386"listen(backlog)\n\
1387\n\
1388Enable a server to accept connections. The backlog argument must be at\n\
1389least 1; it specifies the number of unaccepted connection that the system\n\
1390will allow before refusing new connections.";
1391
1392
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001393#ifndef NO_DUP
Guido van Rossum30a685f1991-06-27 15:51:29 +00001394/* s.makefile(mode) method.
1395 Create a new open file object referring to a dupped version of
1396 the socket's file descriptor. (The dup() call is necessary so
1397 that the open file and socket objects may be closed independent
1398 of each other.)
1399 The mode argument specifies 'r' or 'w' passed to fdopen(). */
1400
Guido van Rossum73624e91994-10-10 17:59:00 +00001401static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001402PySocketSock_makefile(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001403{
Tim Petersdbd9ba62000-07-09 03:09:57 +00001404 extern int fclose(FILE *);
Guido van Rossum6b144911995-03-14 15:05:13 +00001405 char *mode = "r";
1406 int bufsize = -1;
Fred Drakea04eaad2000-06-30 02:46:07 +00001407#ifdef MS_WIN32
1408 intptr_t fd;
1409#else
Guido van Rossum30a685f1991-06-27 15:51:29 +00001410 int fd;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001411#endif
Guido van Rossum30a685f1991-06-27 15:51:29 +00001412 FILE *fp;
Guido van Rossum6b144911995-03-14 15:05:13 +00001413 PyObject *f;
1414
Guido van Rossum43713e52000-02-29 13:59:29 +00001415 if (!PyArg_ParseTuple(args, "|si:makefile", &mode, &bufsize))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001416 return NULL;
Guido van Rossum8d665e61996-06-26 18:22:49 +00001417#ifdef MS_WIN32
Guido van Rossum82a5c661998-07-07 20:45:43 +00001418 if (((fd = _open_osfhandle(s->sock_fd, _O_BINARY)) < 0) ||
1419 ((fd = dup(fd)) < 0) || ((fp = fdopen(fd, mode)) == NULL))
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00001420#else
Guido van Rossum82a5c661998-07-07 20:45:43 +00001421 if ((fd = dup(s->sock_fd)) < 0 || (fp = fdopen(fd, mode)) == NULL)
Guido van Rossum30b6b2b1995-06-14 22:28:08 +00001422#endif
Guido van Rossum82a5c661998-07-07 20:45:43 +00001423 {
Guido van Rossum6b144911995-03-14 15:05:13 +00001424 if (fd >= 0)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001425 SOCKETCLOSE(fd);
Guido van Rossum73624e91994-10-10 17:59:00 +00001426 return PySocket_Err();
Guido van Rossum6b144911995-03-14 15:05:13 +00001427 }
1428 f = PyFile_FromFile(fp, "<socket>", mode, fclose);
1429 if (f != NULL)
1430 PyFile_SetBufSize(f, bufsize);
1431 return f;
Guido van Rossum30a685f1991-06-27 15:51:29 +00001432}
Guido van Rossum82a5c661998-07-07 20:45:43 +00001433
1434static char makefile_doc[] =
1435"makefile([mode[, buffersize]]) -> file object\n\
1436\n\
1437Return a regular file object corresponding to the socket.\n\
1438The mode and buffersize arguments are as for the built-in open() function.";
1439
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001440#endif /* NO_DUP */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001441
Guido van Rossum48a680c2001-03-02 06:34:14 +00001442
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001443/* s.recv(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001444
Guido van Rossum73624e91994-10-10 17:59:00 +00001445static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001446PySocketSock_recv(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001447{
Guido van Rossumbe32c891996-06-20 16:25:29 +00001448 int len, n, flags = 0;
Guido van Rossum73624e91994-10-10 17:59:00 +00001449 PyObject *buf;
Guido van Rossum43713e52000-02-29 13:59:29 +00001450 if (!PyArg_ParseTuple(args, "i|i:recv", &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001451 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001452 buf = PyString_FromStringAndSize((char *) 0, len);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001453 if (buf == NULL)
1454 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001455 Py_BEGIN_ALLOW_THREADS
Guido van Rossuma597dde1995-01-10 20:56:29 +00001456 n = recv(s->sock_fd, PyString_AsString(buf), len, flags);
Guido van Rossum73624e91994-10-10 17:59:00 +00001457 Py_END_ALLOW_THREADS
Guido van Rossum7c53b771995-09-13 18:39:47 +00001458 if (n < 0) {
1459 Py_DECREF(buf);
Guido van Rossum73624e91994-10-10 17:59:00 +00001460 return PySocket_Err();
Guido van Rossum7c53b771995-09-13 18:39:47 +00001461 }
Guido van Rossum53a9bf81996-06-11 18:35:24 +00001462 if (n != len && _PyString_Resize(&buf, n) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001463 return NULL;
1464 return buf;
1465}
1466
Guido van Rossum82a5c661998-07-07 20:45:43 +00001467static char recv_doc[] =
1468"recv(buffersize[, flags]) -> data\n\
1469\n\
1470Receive up to buffersize bytes from the socket. For the optional flags\n\
1471argument, see the Unix manual. When no data is available, block until\n\
1472at least one byte is available or until the remote end is closed. When\n\
1473the remote end is closed and all data is read, return the empty string.";
1474
Guido van Rossum30a685f1991-06-27 15:51:29 +00001475
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001476/* s.recvfrom(nbytes [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001477
Guido van Rossum73624e91994-10-10 17:59:00 +00001478static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001479PySocketSock_recvfrom(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001480{
1481 char addrbuf[256];
Barry Warsaw752300b1997-01-03 17:18:10 +00001482 PyObject *buf = NULL;
1483 PyObject *addr = NULL;
1484 PyObject *ret = NULL;
1485
Guido van Rossumff3ab422000-04-24 15:16:03 +00001486 int len, n, flags = 0;
1487 socklen_t addrlen;
Guido van Rossum43713e52000-02-29 13:59:29 +00001488 if (!PyArg_ParseTuple(args, "i|i:recvfrom", &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001489 return NULL;
Guido van Rossum18c9a4f1993-05-25 12:16:29 +00001490 if (!getsockaddrlen(s, &addrlen))
1491 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001492 buf = PyString_FromStringAndSize((char *) 0, len);
Guido van Rossum18c9a4f1993-05-25 12:16:29 +00001493 if (buf == NULL)
1494 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001495 Py_BEGIN_ALLOW_THREADS
Fred Drakefd168342001-05-09 19:11:33 +00001496 memset(addrbuf, 0, addrlen);
1497 n = recvfrom(s->sock_fd, PyString_AS_STRING(buf), len, flags,
Guido van Rossum8d665e61996-06-26 18:22:49 +00001498#ifndef MS_WINDOWS
Guido van Rossum32c575d1997-12-02 20:37:32 +00001499#if defined(PYOS_OS2)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00001500 (struct sockaddr *)addrbuf, &addrlen
Guido van Rossum32c575d1997-12-02 20:37:32 +00001501#else
Thomas Wouters334fb892000-07-25 12:56:38 +00001502 (void *)addrbuf, &addrlen
Guido van Rossum32c575d1997-12-02 20:37:32 +00001503#endif
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001504#else
Barry Warsaw752300b1997-01-03 17:18:10 +00001505 (struct sockaddr *)addrbuf, &addrlen
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001506#endif
Barry Warsaw752300b1997-01-03 17:18:10 +00001507 );
Guido van Rossum73624e91994-10-10 17:59:00 +00001508 Py_END_ALLOW_THREADS
Guido van Rossum7c53b771995-09-13 18:39:47 +00001509 if (n < 0) {
1510 Py_DECREF(buf);
Guido van Rossum73624e91994-10-10 17:59:00 +00001511 return PySocket_Err();
Guido van Rossum7c53b771995-09-13 18:39:47 +00001512 }
Guido van Rossum53a9bf81996-06-11 18:35:24 +00001513 if (n != len && _PyString_Resize(&buf, n) < 0)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001514 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001515
Jeremy Hyltondbfb6622001-02-02 19:55:17 +00001516 if (!(addr = makesockaddr(s->sock_fd, (struct sockaddr *)addrbuf, addrlen)))
Barry Warsaw752300b1997-01-03 17:18:10 +00001517 goto finally;
1518
Guido van Rossum73624e91994-10-10 17:59:00 +00001519 ret = Py_BuildValue("OO", buf, addr);
Barry Warsaw752300b1997-01-03 17:18:10 +00001520 finally:
Guido van Rossum73624e91994-10-10 17:59:00 +00001521 Py_XDECREF(addr);
1522 Py_XDECREF(buf);
Guido van Rossum6f5afc91993-02-05 09:46:15 +00001523 return ret;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001524}
1525
Guido van Rossum82a5c661998-07-07 20:45:43 +00001526static char recvfrom_doc[] =
1527"recvfrom(buffersize[, flags]) -> (data, address info)\n\
1528\n\
1529Like recv(buffersize, flags) but also return the sender's address info.";
1530
Guido van Rossum30a685f1991-06-27 15:51:29 +00001531
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001532/* s.send(data [,flags]) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001533
Guido van Rossum73624e91994-10-10 17:59:00 +00001534static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001535PySocketSock_send(PySocketSockObject *s, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001536{
Guido van Rossumff4949e1992-08-05 19:58:53 +00001537 char *buf;
Guido van Rossumbe32c891996-06-20 16:25:29 +00001538 int len, n, flags = 0;
Guido van Rossum43713e52000-02-29 13:59:29 +00001539 if (!PyArg_ParseTuple(args, "s#|i:send", &buf, &len, &flags))
Guido van Rossumbe32c891996-06-20 16:25:29 +00001540 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001541 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001542 n = send(s->sock_fd, buf, len, flags);
Guido van Rossum73624e91994-10-10 17:59:00 +00001543 Py_END_ALLOW_THREADS
Guido van Rossum30a685f1991-06-27 15:51:29 +00001544 if (n < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001545 return PySocket_Err();
1546 return PyInt_FromLong((long)n);
Guido van Rossum30a685f1991-06-27 15:51:29 +00001547}
1548
Guido van Rossum82a5c661998-07-07 20:45:43 +00001549static char send_doc[] =
1550"send(data[, flags])\n\
1551\n\
1552Send a data string to the socket. For the optional flags\n\
1553argument, see the Unix manual.";
1554
Guido van Rossum30a685f1991-06-27 15:51:29 +00001555
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001556/* s.sendto(data, [flags,] sockaddr) method */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001557
Guido van Rossum73624e91994-10-10 17:59:00 +00001558static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001559PySocketSock_sendto(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001560{
Guido van Rossum73624e91994-10-10 17:59:00 +00001561 PyObject *addro;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001562 char *buf;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001563 struct sockaddr *addr;
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001564 int addrlen, len, n, flags;
1565 flags = 0;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001566 if (!PyArg_ParseTuple(args, "s#O:sendto", &buf, &len, &addro)) {
Guido van Rossum73624e91994-10-10 17:59:00 +00001567 PyErr_Clear();
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001568 if (!PyArg_ParseTuple(args, "s#iO:sendto",
1569 &buf, &len, &flags, &addro))
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001570 return NULL;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001571 }
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001572 if (!getsockaddrarg(s, addro, &addr, &addrlen))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001573 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001574 Py_BEGIN_ALLOW_THREADS
Guido van Rossumeb6b33a1993-05-25 09:38:27 +00001575 n = sendto(s->sock_fd, buf, len, flags, addr, addrlen);
Guido van Rossum73624e91994-10-10 17:59:00 +00001576 Py_END_ALLOW_THREADS
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001577 if (n < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001578 return PySocket_Err();
1579 return PyInt_FromLong((long)n);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001580}
1581
Guido van Rossum82a5c661998-07-07 20:45:43 +00001582static char sendto_doc[] =
1583"sendto(data[, flags], address)\n\
1584\n\
1585Like send(data, flags) but allows specifying the destination address.\n\
1586For IP sockets, the address is a pair (hostaddr, port).";
1587
Guido van Rossum30a685f1991-06-27 15:51:29 +00001588
1589/* s.shutdown(how) method */
1590
Guido van Rossum73624e91994-10-10 17:59:00 +00001591static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001592PySocketSock_shutdown(PySocketSockObject *s, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001593{
1594 int how;
Guido van Rossumff4949e1992-08-05 19:58:53 +00001595 int res;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001596 if (!PyArg_ParseTuple(args, "i:shutdown", &how))
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001597 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001598 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001599 res = shutdown(s->sock_fd, how);
Guido van Rossum73624e91994-10-10 17:59:00 +00001600 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001601 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001602 return PySocket_Err();
1603 Py_INCREF(Py_None);
1604 return Py_None;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001605}
1606
Guido van Rossum82a5c661998-07-07 20:45:43 +00001607static char shutdown_doc[] =
1608"shutdown(flag)\n\
1609\n\
1610Shut down the reading side of the socket (flag == 0), the writing side\n\
1611of the socket (flag == 1), or both ends (flag == 2).";
1612
Guido van Rossum30a685f1991-06-27 15:51:29 +00001613
1614/* List of methods for socket objects */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001615
Guido van Rossum73624e91994-10-10 17:59:00 +00001616static PyMethodDef PySocketSock_methods[] = {
Guido van Rossum48a680c2001-03-02 06:34:14 +00001617 {"accept", (PyCFunction)PySocketSock_accept, METH_VARARGS,
1618 accept_doc},
1619 {"bind", (PyCFunction)PySocketSock_bind, METH_VARARGS,
1620 bind_doc},
1621 {"close", (PyCFunction)PySocketSock_close, METH_VARARGS,
1622 close_doc},
1623 {"connect", (PyCFunction)PySocketSock_connect, METH_VARARGS,
1624 connect_doc},
1625 {"connect_ex", (PyCFunction)PySocketSock_connect_ex, METH_VARARGS,
1626 connect_ex_doc},
Guido van Rossumbe32c891996-06-20 16:25:29 +00001627#ifndef NO_DUP
Guido van Rossum48a680c2001-03-02 06:34:14 +00001628 {"dup", (PyCFunction)PySocketSock_dup, METH_VARARGS,
1629 dup_doc},
Guido van Rossumbe32c891996-06-20 16:25:29 +00001630#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001631 {"fileno", (PyCFunction)PySocketSock_fileno, METH_VARARGS,
1632 fileno_doc},
Guido van Rossumb6775db1994-08-01 11:34:53 +00001633#ifdef HAVE_GETPEERNAME
Guido van Rossum48a680c2001-03-02 06:34:14 +00001634 {"getpeername", (PyCFunction)PySocketSock_getpeername, METH_VARARGS,
1635 getpeername_doc},
Guido van Rossum9575a441993-04-07 14:06:14 +00001636#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001637 {"getsockname", (PyCFunction)PySocketSock_getsockname, METH_VARARGS,
1638 getsockname_doc},
1639 {"getsockopt", (PyCFunction)PySocketSock_getsockopt, METH_VARARGS,
1640 getsockopt_doc},
1641 {"listen", (PyCFunction)PySocketSock_listen, METH_VARARGS,
1642 listen_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001643#ifndef NO_DUP
Guido van Rossum48a680c2001-03-02 06:34:14 +00001644 {"makefile", (PyCFunction)PySocketSock_makefile, METH_VARARGS,
1645 makefile_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001646#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001647 {"recv", (PyCFunction)PySocketSock_recv, METH_VARARGS,
1648 recv_doc},
1649 {"recvfrom", (PyCFunction)PySocketSock_recvfrom, METH_VARARGS,
1650 recvfrom_doc},
1651 {"send", (PyCFunction)PySocketSock_send, METH_VARARGS,
1652 send_doc},
1653 {"sendto", (PyCFunction)PySocketSock_sendto, METH_VARARGS,
1654 sendto_doc},
1655 {"setblocking", (PyCFunction)PySocketSock_setblocking, METH_VARARGS,
1656 setblocking_doc},
1657 {"setsockopt", (PyCFunction)PySocketSock_setsockopt, METH_VARARGS,
1658 setsockopt_doc},
1659 {"shutdown", (PyCFunction)PySocketSock_shutdown, METH_VARARGS,
1660 shutdown_doc},
1661#ifdef RISCOS
1662 {"sleeptaskw", (PyCFunction)PySocketSock_sleeptaskw, METH_VARARGS,
1663 sleeptaskw_doc},
1664#endif
Guido van Rossumb6775db1994-08-01 11:34:53 +00001665 {NULL, NULL} /* sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001666};
1667
Guido van Rossum30a685f1991-06-27 15:51:29 +00001668
Guido van Rossum73624e91994-10-10 17:59:00 +00001669/* Deallocate a socket object in response to the last Py_DECREF().
Guido van Rossum30a685f1991-06-27 15:51:29 +00001670 First close the file description. */
1671
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001672static void
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001673PySocketSock_dealloc(PySocketSockObject *s)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001674{
Guido van Rossumfa972c92000-04-10 12:45:45 +00001675 if (s->sock_fd != -1)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00001676 (void) SOCKETCLOSE(s->sock_fd);
Guido van Rossumb18618d2000-05-03 23:44:39 +00001677 PyObject_Del(s);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001678}
1679
Guido van Rossum30a685f1991-06-27 15:51:29 +00001680
1681/* Return a socket object's named attribute. */
1682
Guido van Rossum73624e91994-10-10 17:59:00 +00001683static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001684PySocketSock_getattr(PySocketSockObject *s, char *name)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001685{
Guido van Rossum73624e91994-10-10 17:59:00 +00001686 return Py_FindMethod(PySocketSock_methods, (PyObject *) s, name);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001687}
1688
Guido van Rossum30a685f1991-06-27 15:51:29 +00001689
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001690static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001691PySocketSock_repr(PySocketSockObject *s)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001692{
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001693 char buf[512];
Fred Drakea04eaad2000-06-30 02:46:07 +00001694#if SIZEOF_SOCKET_T > SIZEOF_LONG
1695 if (s->sock_fd > LONG_MAX) {
1696 /* this can occur on Win64, and actually there is a special
1697 ugly printf formatter for decimal pointer length integer
1698 printing, only bother if necessary*/
1699 PyErr_SetString(PyExc_OverflowError,
1700 "no printf formatter to display the socket descriptor in decimal");
1701 return NULL;
1702 }
1703#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00001704 sprintf(buf,
1705 "<socket object, fd=%ld, family=%d, type=%d, protocol=%d>",
Fred Drakea04eaad2000-06-30 02:46:07 +00001706 (long)s->sock_fd, s->sock_family, s->sock_type, s->sock_proto);
Guido van Rossumdc1c64a1996-02-27 15:21:19 +00001707 return PyString_FromString(buf);
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001708}
1709
1710
Guido van Rossumb6775db1994-08-01 11:34:53 +00001711/* Type object for socket objects. */
Guido van Rossum30a685f1991-06-27 15:51:29 +00001712
Guido van Rossum73624e91994-10-10 17:59:00 +00001713static PyTypeObject PySocketSock_Type = {
Guido van Rossum55558541996-05-23 22:54:50 +00001714 PyObject_HEAD_INIT(0) /* Must fill in type value later */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001715 0,
1716 "socket",
Guido van Rossum73624e91994-10-10 17:59:00 +00001717 sizeof(PySocketSockObject),
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001718 0,
Guido van Rossum73624e91994-10-10 17:59:00 +00001719 (destructor)PySocketSock_dealloc, /*tp_dealloc*/
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001720 0, /*tp_print*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001721 (getattrfunc)PySocketSock_getattr, /*tp_getattr*/
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001722 0, /*tp_setattr*/
1723 0, /*tp_compare*/
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001724 (reprfunc)PySocketSock_repr, /*tp_repr*/
Guido van Rossum6574b3e1991-06-25 21:36:08 +00001725 0, /*tp_as_number*/
1726 0, /*tp_as_sequence*/
1727 0, /*tp_as_mapping*/
1728};
1729
Guido van Rossum30a685f1991-06-27 15:51:29 +00001730
Guido van Rossum81194471991-07-27 21:42:02 +00001731/* Python interface to gethostname(). */
1732
1733/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001734static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001735PySocket_gethostname(PyObject *self, PyObject *args)
Guido van Rossum81194471991-07-27 21:42:02 +00001736{
1737 char buf[1024];
Guido van Rossumff4949e1992-08-05 19:58:53 +00001738 int res;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001739 if (!PyArg_ParseTuple(args, ":gethostname"))
Guido van Rossum81194471991-07-27 21:42:02 +00001740 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00001741 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001742 res = gethostname(buf, (int) sizeof buf - 1);
Guido van Rossum73624e91994-10-10 17:59:00 +00001743 Py_END_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00001744 if (res < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00001745 return PySocket_Err();
Guido van Rossum81194471991-07-27 21:42:02 +00001746 buf[sizeof buf - 1] = '\0';
Guido van Rossum73624e91994-10-10 17:59:00 +00001747 return PyString_FromString(buf);
Guido van Rossum81194471991-07-27 21:42:02 +00001748}
Guido van Rossumff4949e1992-08-05 19:58:53 +00001749
Guido van Rossum82a5c661998-07-07 20:45:43 +00001750static char gethostname_doc[] =
1751"gethostname() -> string\n\
1752\n\
1753Return the current host name.";
1754
Guido van Rossumff4949e1992-08-05 19:58:53 +00001755
Guido van Rossum30a685f1991-06-27 15:51:29 +00001756/* Python interface to gethostbyname(name). */
1757
1758/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00001759static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001760PySocket_gethostbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001761{
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00001762 char *name;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001763 struct sockaddr_storage addrbuf;
1764
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001765 if (!PyArg_ParseTuple(args, "s:gethostbyname", &name))
Guido van Rossum30a685f1991-06-27 15:51:29 +00001766 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001767 if (setipaddr(name, (struct sockaddr *)&addrbuf, AF_INET) < 0)
Guido van Rossum30a685f1991-06-27 15:51:29 +00001768 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001769 return makeipaddr((struct sockaddr *)&addrbuf,
1770 sizeof(struct sockaddr_in));
Guido van Rossum30a685f1991-06-27 15:51:29 +00001771}
1772
Guido van Rossum82a5c661998-07-07 20:45:43 +00001773static char gethostbyname_doc[] =
1774"gethostbyname(host) -> address\n\
1775\n\
1776Return the IP address (a string of the form '255.255.255.255') for a host.";
1777
1778
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001779/* Convenience function common to gethostbyname_ex and gethostbyaddr */
1780
1781static PyObject *
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001782gethost_common(struct hostent *h, struct sockaddr *addr, int alen, int af)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001783{
1784 char **pch;
1785 PyObject *rtn_tuple = (PyObject *)NULL;
1786 PyObject *name_list = (PyObject *)NULL;
1787 PyObject *addr_list = (PyObject *)NULL;
1788 PyObject *tmp;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001789
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001790 if (h == NULL) {
Guido van Rossum48a680c2001-03-02 06:34:14 +00001791 /* Let's get real error message to return */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001792 PyH_Err(h_errno);
1793 return NULL;
1794 }
1795 if (h->h_addrtype != af) {
1796#ifdef HAVE_STRERROR
1797 /* Let's get real error message to return */
1798 PyErr_SetString(PySocket_Error, (char *)strerror(EAFNOSUPPORT));
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001799#else
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001800 PyErr_SetString(PySocket_Error,
1801 "Address family not supported by protocol family");
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001802#endif
1803 return NULL;
1804 }
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001805 switch (af) {
1806 case AF_INET:
1807 if (alen < sizeof(struct sockaddr_in))
1808 return NULL;
1809 break;
1810#ifdef INET6
1811 case AF_INET6:
1812 if (alen < sizeof(struct sockaddr_in6))
1813 return NULL;
1814 break;
1815#endif
1816 }
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001817 if ((name_list = PyList_New(0)) == NULL)
1818 goto err;
1819 if ((addr_list = PyList_New(0)) == NULL)
1820 goto err;
1821 for (pch = h->h_aliases; *pch != NULL; pch++) {
1822 int status;
1823 tmp = PyString_FromString(*pch);
1824 if (tmp == NULL)
1825 goto err;
1826 status = PyList_Append(name_list, tmp);
1827 Py_DECREF(tmp);
1828 if (status)
1829 goto err;
1830 }
1831 for (pch = h->h_addr_list; *pch != NULL; pch++) {
1832 int status;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001833 switch (af) {
1834 case AF_INET:
1835 {
1836 struct sockaddr_in sin;
1837 memset(&sin, 0, sizeof(sin));
1838 sin.sin_family = af;
1839#ifdef HAVE_SOCKADDR_SA_LEN
1840 sin.sin_len = sizeof(sin);
1841#endif
1842 memcpy(&sin.sin_addr, *pch, sizeof(sin.sin_addr));
1843 tmp = makeipaddr((struct sockaddr *)&sin, sizeof(sin));
1844 if (pch == h->h_addr_list && alen >= sizeof(sin))
1845 memcpy((char *) addr, &sin, sizeof(sin));
1846 break;
1847 }
1848#ifdef INET6
1849 case AF_INET6:
1850 {
1851 struct sockaddr_in6 sin6;
1852 memset(&sin6, 0, sizeof(sin6));
1853 sin6.sin6_family = af;
1854#ifdef HAVE_SOCKADDR_SA_LEN
1855 sin6.sin6_len = sizeof(sin6);
1856#endif
1857 memcpy(&sin6.sin6_addr, *pch, sizeof(sin6.sin6_addr));
1858 tmp = makeipaddr((struct sockaddr *)&sin6,
1859 sizeof(sin6));
1860 if (pch == h->h_addr_list && alen >= sizeof(sin6))
1861 memcpy((char *) addr, &sin6, sizeof(sin6));
1862 break;
1863 }
1864#endif
1865 default: /* can't happen */
1866 PyErr_SetString(PySocket_Error,
1867 "unsupported address family");
1868 return NULL;
1869 }
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001870 if (tmp == NULL)
1871 goto err;
1872 status = PyList_Append(addr_list, tmp);
1873 Py_DECREF(tmp);
1874 if (status)
1875 goto err;
1876 }
1877 rtn_tuple = Py_BuildValue("sOO", h->h_name, name_list, addr_list);
1878 err:
1879 Py_XDECREF(name_list);
1880 Py_XDECREF(addr_list);
1881 return rtn_tuple;
1882}
1883
1884
1885/* Python interface to gethostbyname_ex(name). */
1886
1887/*ARGSUSED*/
1888static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001889PySocket_gethostbyname_ex(PyObject *self, PyObject *args)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001890{
1891 char *name;
1892 struct hostent *h;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001893 struct sockaddr_storage addr;
Martin v. Löwis9db2f572001-07-23 01:30:10 +00001894 struct sockaddr *sa;
Guido van Rossum955becc1999-03-22 20:14:53 +00001895 PyObject *ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001896#ifdef HAVE_GETHOSTBYNAME_R
1897 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001898#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
1899 struct hostent_data data;
1900#else
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001901 char buf[16384];
1902 int buf_len = (sizeof buf) - 1;
1903 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001904#endif
1905#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001906 int result;
1907#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001908#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001909
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001910 if (!PyArg_ParseTuple(args, "s:gethostbyname_ex", &name))
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001911 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001912 if (setipaddr(name, (struct sockaddr *)&addr, PF_INET) < 0)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001913 return NULL;
1914 Py_BEGIN_ALLOW_THREADS
1915#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001916#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001917 result = gethostbyname_r(name, &hp_allocated, buf, buf_len, &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001918#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001919 h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001920#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Guido van Rossume7de2061999-03-24 17:24:33 +00001921 memset((void *) &data, '\0', sizeof(data));
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001922 result = gethostbyname_r(name, &hp_allocated, &data);
1923 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001924#endif
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001925#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00001926#ifdef USE_GETHOSTBYNAME_LOCK
1927 PyThread_acquire_lock(gethostbyname_lock, 1);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001928#endif
1929 h = gethostbyname(name);
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001930#endif /* HAVE_GETHOSTBYNAME_R */
1931 Py_END_ALLOW_THREADS
Martin v. Löwis9db2f572001-07-23 01:30:10 +00001932 /* Some C libraries would require addr.__ss_family instead of addr.ss_family.
1933 Therefore, we cast the sockaddr_storage into sockaddr to access sa_family. */
1934 sa = (struct sockaddr*)&addr;
1935 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), sa->sa_family);
Guido van Rossum3baaa131999-03-22 21:44:51 +00001936#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum955becc1999-03-22 20:14:53 +00001937 PyThread_release_lock(gethostbyname_lock);
1938#endif
1939 return ret;
Guido van Rossum7d896ab1998-08-04 22:16:43 +00001940}
1941
1942static char ghbn_ex_doc[] =
1943"gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\
1944\n\
1945Return the true host name, a list of aliases, and a list of IP addresses,\n\
1946for a host. The host argument is a string giving a host name or IP number.";
1947
1948
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001949/* Python interface to gethostbyaddr(IP). */
1950
1951/*ARGSUSED*/
1952static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00001953PySocket_gethostbyaddr(PyObject *self, PyObject *args)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001954{
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001955#ifdef INET6
1956 struct sockaddr_storage addr;
1957#else
Guido van Rossum48a680c2001-03-02 06:34:14 +00001958 struct sockaddr_in addr;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001959#endif
1960 struct sockaddr *sa = (struct sockaddr *)&addr;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001961 char *ip_num;
1962 struct hostent *h;
Guido van Rossum3baaa131999-03-22 21:44:51 +00001963 PyObject *ret;
Guido van Rossum4f199ea1998-04-09 20:56:35 +00001964#ifdef HAVE_GETHOSTBYNAME_R
1965 struct hostent hp_allocated;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001966#ifdef HAVE_GETHOSTBYNAME_R_3_ARG
1967 struct hostent_data data;
1968#else
Guido van Rossum4f199ea1998-04-09 20:56:35 +00001969 char buf[16384];
1970 int buf_len = (sizeof buf) - 1;
1971 int errnop;
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00001972#endif
1973#if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Guido van Rossume9cd07b1999-03-15 21:40:14 +00001974 int result;
1975#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00001976#endif /* HAVE_GETHOSTBYNAME_R */
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001977 char *ap;
1978 int al;
1979 int af;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001980
Guido van Rossum27fc3c02000-03-24 20:56:56 +00001981 if (!PyArg_ParseTuple(args, "s:gethostbyaddr", &ip_num))
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001982 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001983 af = PF_UNSPEC;
1984 if (setipaddr(ip_num, sa, af) < 0)
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00001985 return NULL;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00001986 af = sa->sa_family;
1987 ap = NULL;
1988 al = 0;
1989 switch (af) {
1990 case AF_INET:
1991 ap = (char *)&((struct sockaddr_in *)sa)->sin_addr;
1992 al = sizeof(((struct sockaddr_in *)sa)->sin_addr);
1993 break;
1994#ifdef INET6
1995 case AF_INET6:
1996 ap = (char *)&((struct sockaddr_in6 *)sa)->sin6_addr;
1997 al = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
1998 break;
1999#endif
2000 default:
2001 PyErr_SetString(PySocket_Error, "unsupported address family");
2002 return NULL;
2003 }
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002004 Py_BEGIN_ALLOW_THREADS
2005#ifdef HAVE_GETHOSTBYNAME_R
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002006#if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002007 result = gethostbyaddr_r(ap, al, af,
2008 &hp_allocated, buf, buf_len,
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002009 &h, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002010#elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002011 h = gethostbyaddr_r(ap, al, af,
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002012 &hp_allocated, buf, buf_len, &errnop);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002013#else /* HAVE_GETHOSTBYNAME_R_3_ARG */
Guido van Rossume7de2061999-03-24 17:24:33 +00002014 memset((void *) &data, '\0', sizeof(data));
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002015 result = gethostbyaddr_r(ap, al, af, &hp_allocated, &data);
Guido van Rossum7b6c71f1999-03-24 17:20:40 +00002016 h = (result != 0) ? NULL : &hp_allocated;
Guido van Rossume9cd07b1999-03-15 21:40:14 +00002017#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002018#else /* not HAVE_GETHOSTBYNAME_R */
Guido van Rossum3baaa131999-03-22 21:44:51 +00002019#ifdef USE_GETHOSTBYNAME_LOCK
2020 PyThread_acquire_lock(gethostbyname_lock, 1);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002021#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002022 h = gethostbyaddr(ap, al, af);
Guido van Rossum4f199ea1998-04-09 20:56:35 +00002023#endif /* HAVE_GETHOSTBYNAME_R */
2024 Py_END_ALLOW_THREADS
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002025 ret = gethost_common(h, (struct sockaddr *)&addr, sizeof(addr), af);
Guido van Rossum3baaa131999-03-22 21:44:51 +00002026#ifdef USE_GETHOSTBYNAME_LOCK
2027 PyThread_release_lock(gethostbyname_lock);
2028#endif
2029 return ret;
Guido van Rossum3bbc62e1995-01-02 19:30:30 +00002030}
2031
Guido van Rossum82a5c661998-07-07 20:45:43 +00002032static char gethostbyaddr_doc[] =
2033"gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\
2034\n\
2035Return the true host name, a list of aliases, and a list of IP addresses,\n\
2036for a host. The host argument is a string giving a host name or IP number.";
2037
Guido van Rossum30a685f1991-06-27 15:51:29 +00002038
2039/* Python interface to getservbyname(name).
2040 This only returns the port number, since the other info is already
2041 known or not useful (like the list of aliases). */
2042
2043/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002044static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002045PySocket_getservbyname(PyObject *self, PyObject *args)
Guido van Rossum30a685f1991-06-27 15:51:29 +00002046{
Guido van Rossumff4949e1992-08-05 19:58:53 +00002047 char *name, *proto;
Guido van Rossum30a685f1991-06-27 15:51:29 +00002048 struct servent *sp;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002049 if (!PyArg_ParseTuple(args, "ss:getservbyname", &name, &proto))
Guido van Rossum30a685f1991-06-27 15:51:29 +00002050 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002051 Py_BEGIN_ALLOW_THREADS
Guido van Rossumff4949e1992-08-05 19:58:53 +00002052 sp = getservbyname(name, proto);
Guido van Rossum73624e91994-10-10 17:59:00 +00002053 Py_END_ALLOW_THREADS
Guido van Rossum30a685f1991-06-27 15:51:29 +00002054 if (sp == NULL) {
Guido van Rossum73624e91994-10-10 17:59:00 +00002055 PyErr_SetString(PySocket_Error, "service/proto not found");
Guido van Rossum30a685f1991-06-27 15:51:29 +00002056 return NULL;
2057 }
Guido van Rossum73624e91994-10-10 17:59:00 +00002058 return PyInt_FromLong((long) ntohs(sp->s_port));
Guido van Rossum30a685f1991-06-27 15:51:29 +00002059}
2060
Guido van Rossum82a5c661998-07-07 20:45:43 +00002061static char getservbyname_doc[] =
2062"getservbyname(servicename, protocolname) -> integer\n\
2063\n\
2064Return a port number from a service name and protocol name.\n\
2065The protocol name should be 'tcp' or 'udp'.";
2066
Guido van Rossum30a685f1991-06-27 15:51:29 +00002067
Guido van Rossum3901d851996-12-19 16:35:04 +00002068/* Python interface to getprotobyname(name).
2069 This only returns the protocol number, since the other info is
2070 already known or not useful (like the list of aliases). */
2071
2072/*ARGSUSED*/
2073static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002074PySocket_getprotobyname(PyObject *self, PyObject *args)
Guido van Rossum3901d851996-12-19 16:35:04 +00002075{
2076 char *name;
2077 struct protoent *sp;
Guido van Rossumbcc20741998-08-04 22:53:56 +00002078#ifdef __BEOS__
2079/* Not available in BeOS yet. - [cjh] */
2080 PyErr_SetString( PySocket_Error, "getprotobyname not supported" );
2081 return NULL;
2082#else
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002083 if (!PyArg_ParseTuple(args, "s:getprotobyname", &name))
Guido van Rossum3901d851996-12-19 16:35:04 +00002084 return NULL;
2085 Py_BEGIN_ALLOW_THREADS
2086 sp = getprotobyname(name);
2087 Py_END_ALLOW_THREADS
2088 if (sp == NULL) {
2089 PyErr_SetString(PySocket_Error, "protocol not found");
2090 return NULL;
2091 }
2092 return PyInt_FromLong((long) sp->p_proto);
Guido van Rossumbcc20741998-08-04 22:53:56 +00002093#endif
Guido van Rossum3901d851996-12-19 16:35:04 +00002094}
2095
Guido van Rossum82a5c661998-07-07 20:45:43 +00002096static char getprotobyname_doc[] =
2097"getprotobyname(name) -> integer\n\
2098\n\
2099Return the protocol number for the named protocol. (Rarely used.)";
2100
Guido van Rossum3901d851996-12-19 16:35:04 +00002101
Guido van Rossum30a685f1991-06-27 15:51:29 +00002102/* Python interface to socket(family, type, proto).
2103 The third (protocol) argument is optional.
2104 Return a new socket object. */
2105
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002106/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002107static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002108PySocket_socket(PyObject *self, PyObject *args)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002109{
Guido van Rossum73624e91994-10-10 17:59:00 +00002110 PySocketSockObject *s;
Fred Drakea04eaad2000-06-30 02:46:07 +00002111 SOCKET_T fd;
Guido van Rossumbe32c891996-06-20 16:25:29 +00002112 int family, type, proto = 0;
Guido van Rossum43713e52000-02-29 13:59:29 +00002113 if (!PyArg_ParseTuple(args, "ii|i:socket", &family, &type, &proto))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002114 return NULL;
Guido van Rossum73624e91994-10-10 17:59:00 +00002115 Py_BEGIN_ALLOW_THREADS
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002116 fd = socket(family, type, proto);
Guido van Rossum73624e91994-10-10 17:59:00 +00002117 Py_END_ALLOW_THREADS
Guido van Rossum6f489d91996-06-28 20:15:15 +00002118#ifdef MS_WINDOWS
Guido van Rossumd639d4d1996-06-12 04:04:22 +00002119 if (fd == INVALID_SOCKET)
2120#else
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002121 if (fd < 0)
Guido van Rossumd639d4d1996-06-12 04:04:22 +00002122#endif
Guido van Rossum73624e91994-10-10 17:59:00 +00002123 return PySocket_Err();
2124 s = PySocketSock_New(fd, family, type, proto);
Guido van Rossum30a685f1991-06-27 15:51:29 +00002125 /* If the object can't be created, don't forget to close the
2126 file descriptor again! */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002127 if (s == NULL)
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00002128 (void) SOCKETCLOSE(fd);
Guido van Rossum81194471991-07-27 21:42:02 +00002129 /* From now on, ignore SIGPIPE and let the error checking
2130 do the work. */
Guido van Rossum48a680c2001-03-02 06:34:14 +00002131#ifdef SIGPIPE
Guido van Rossum81194471991-07-27 21:42:02 +00002132 (void) signal(SIGPIPE, SIG_IGN);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002133#endif
Guido van Rossum73624e91994-10-10 17:59:00 +00002134 return (PyObject *) s;
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002135}
2136
Guido van Rossum82a5c661998-07-07 20:45:43 +00002137static char socket_doc[] =
2138"socket(family, type[, proto]) -> socket object\n\
2139\n\
2140Open a socket of the given type. The family argument specifies the\n\
2141address family; it is normally AF_INET, sometimes AF_UNIX.\n\
2142The type argument specifies whether this is a stream (SOCK_STREAM)\n\
2143or datagram (SOCK_DGRAM) socket. The protocol argument defaults to 0,\n\
2144specifying the default protocol.";
2145
2146
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002147#ifndef NO_DUP
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002148/* Create a socket object from a numeric file description.
2149 Useful e.g. if stdin is a socket.
2150 Additional arguments as for socket(). */
2151
2152/*ARGSUSED*/
Guido van Rossum73624e91994-10-10 17:59:00 +00002153static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002154PySocket_fromfd(PyObject *self, PyObject *args)
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002155{
Guido van Rossum73624e91994-10-10 17:59:00 +00002156 PySocketSockObject *s;
Fred Drakea04eaad2000-06-30 02:46:07 +00002157 SOCKET_T fd;
2158 int family, type, proto = 0;
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002159 if (!PyArg_ParseTuple(args, "iii|i:fromfd",
2160 &fd, &family, &type, &proto))
Guido van Rossumbe32c891996-06-20 16:25:29 +00002161 return NULL;
Guido van Rossum5f59d601992-12-14 16:59:51 +00002162 /* Dup the fd so it and the socket can be closed independently */
2163 fd = dup(fd);
2164 if (fd < 0)
Guido van Rossum73624e91994-10-10 17:59:00 +00002165 return PySocket_Err();
2166 s = PySocketSock_New(fd, family, type, proto);
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002167 /* From now on, ignore SIGPIPE and let the error checking
2168 do the work. */
Guido van Rossum48a680c2001-03-02 06:34:14 +00002169#ifdef SIGPIPE
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002170 (void) signal(SIGPIPE, SIG_IGN);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002171#endif
Guido van Rossum73624e91994-10-10 17:59:00 +00002172 return (PyObject *) s;
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002173}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002174
2175static char fromfd_doc[] =
2176"fromfd(fd, family, type[, proto]) -> socket object\n\
2177\n\
2178Create a socket object from the given file descriptor.\n\
2179The remaining arguments are the same as for socket().";
2180
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002181#endif /* NO_DUP */
Guido van Rossum2a7178e1992-12-08 13:38:24 +00002182
Guido van Rossum82a5c661998-07-07 20:45:43 +00002183
Guido van Rossum006bf911996-06-12 04:04:55 +00002184static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002185PySocket_ntohs(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002186{
2187 int x1, x2;
2188
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002189 if (!PyArg_ParseTuple(args, "i:ntohs", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002190 return NULL;
2191 }
2192 x2 = (int)ntohs((short)x1);
2193 return PyInt_FromLong(x2);
2194}
2195
Guido van Rossum82a5c661998-07-07 20:45:43 +00002196static char ntohs_doc[] =
2197"ntohs(integer) -> integer\n\
2198\n\
2199Convert a 16-bit integer from network to host byte order.";
2200
2201
Guido van Rossum006bf911996-06-12 04:04:55 +00002202static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002203PySocket_ntohl(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002204{
2205 int x1, x2;
2206
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002207 if (!PyArg_ParseTuple(args, "i:ntohl", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002208 return NULL;
2209 }
2210 x2 = ntohl(x1);
2211 return PyInt_FromLong(x2);
2212}
2213
Guido van Rossum82a5c661998-07-07 20:45:43 +00002214static char ntohl_doc[] =
2215"ntohl(integer) -> integer\n\
2216\n\
2217Convert a 32-bit integer from network to host byte order.";
2218
2219
Guido van Rossum006bf911996-06-12 04:04:55 +00002220static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002221PySocket_htons(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002222{
2223 int x1, x2;
2224
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002225 if (!PyArg_ParseTuple(args, "i:htons", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002226 return NULL;
2227 }
2228 x2 = (int)htons((short)x1);
2229 return PyInt_FromLong(x2);
2230}
2231
Guido van Rossum82a5c661998-07-07 20:45:43 +00002232static char htons_doc[] =
2233"htons(integer) -> integer\n\
2234\n\
2235Convert a 16-bit integer from host to network byte order.";
2236
2237
Guido van Rossum006bf911996-06-12 04:04:55 +00002238static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002239PySocket_htonl(PyObject *self, PyObject *args)
Guido van Rossum006bf911996-06-12 04:04:55 +00002240{
2241 int x1, x2;
2242
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002243 if (!PyArg_ParseTuple(args, "i:htonl", &x1)) {
Guido van Rossum006bf911996-06-12 04:04:55 +00002244 return NULL;
2245 }
2246 x2 = htonl(x1);
2247 return PyInt_FromLong(x2);
2248}
2249
Guido van Rossum82a5c661998-07-07 20:45:43 +00002250static char htonl_doc[] =
2251"htonl(integer) -> integer\n\
2252\n\
2253Convert a 32-bit integer from host to network byte order.";
2254
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002255/*
2256 * socket.inet_aton() and socket.inet_ntoa() functions
2257 *
2258 * written 20 Aug 1999 by Ben Gertzfield <che@debian.org> <- blame him!
2259 *
2260 */
2261
Guido van Rossum48a680c2001-03-02 06:34:14 +00002262static char inet_aton_doc[] =
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002263"inet_aton(string) -> packed 32-bit IP representation\n\
2264\n\
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002265Convert an IP address in string format (123.45.67.89) to the 32-bit packed\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002266binary format used in low-level network functions.";
2267
2268static PyObject*
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002269PySocket_inet_aton(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002270{
Guido van Rossuma2e48551999-09-09 15:42:59 +00002271#ifndef INADDR_NONE
2272#define INADDR_NONE (-1)
2273#endif
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002274
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002275 /* Have to use inet_addr() instead */
2276 char *ip_addr;
Fred Drakee5065292001-07-19 21:16:41 +00002277 unsigned long packed_addr;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002278
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002279 if (!PyArg_ParseTuple(args, "s:inet_aton", &ip_addr)) {
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002280 return NULL;
2281 }
Guido van Rossumff3ab422000-04-24 15:16:03 +00002282#ifdef USE_GUSI1
Fred Drakee5065292001-07-19 21:16:41 +00002283 packed_addr = inet_addr(ip_addr).s_addr;
Guido van Rossum1b6e4631999-11-04 18:22:29 +00002284#else
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002285 packed_addr = inet_addr(ip_addr);
Guido van Rossum1b6e4631999-11-04 18:22:29 +00002286#endif
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002287
2288 if (packed_addr == INADDR_NONE) { /* invalid address */
2289 PyErr_SetString(PySocket_Error,
2290 "illegal IP address string passed to inet_aton");
2291 return NULL;
2292 }
2293
2294 return PyString_FromStringAndSize((char *) &packed_addr,
2295 sizeof(packed_addr));
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002296}
2297
Guido van Rossum48a680c2001-03-02 06:34:14 +00002298static char inet_ntoa_doc[] =
Fred Drakee0661342000-03-07 14:05:16 +00002299"inet_ntoa(packed_ip) -> ip_address_string\n\
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002300\n\
2301Convert an IP address from 32-bit packed binary format to string format";
2302
2303static PyObject*
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002304PySocket_inet_ntoa(PyObject *self, PyObject *args)
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002305{
2306 char *packed_str;
Guido van Rossumc6a164b1999-08-20 19:11:27 +00002307 int addr_len;
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002308 struct in_addr packed_addr;
2309
Guido van Rossum27fc3c02000-03-24 20:56:56 +00002310 if (!PyArg_ParseTuple(args, "s#:inet_ntoa", &packed_str, &addr_len)) {
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002311 return NULL;
2312 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00002313
Guido van Rossum5c9eb211999-08-20 18:21:51 +00002314 if (addr_len != sizeof(packed_addr)) {
2315 PyErr_SetString(PySocket_Error,
2316 "packed IP wrong length for inet_ntoa");
2317 return NULL;
2318 }
2319
2320 memcpy(&packed_addr, packed_str, addr_len);
2321
2322 return PyString_FromString(inet_ntoa(packed_addr));
2323}
Guido van Rossum82a5c661998-07-07 20:45:43 +00002324
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002325/* Python interface to getaddrinfo(host, port). */
2326
2327/*ARGSUSED*/
2328static PyObject *
2329PySocket_getaddrinfo(PyObject *self, PyObject *args)
2330{
2331 struct addrinfo hints, *res0, *res;
2332 PyObject *pobj = (PyObject *)NULL;
2333 char pbuf[10];
2334 char *hptr, *pptr;
2335 int family, socktype, protocol, flags;
2336 int error;
2337 PyObject *all = (PyObject *)NULL;
2338 PyObject *single = (PyObject *)NULL;
2339
2340 family = socktype = protocol = flags = 0;
2341 family = PF_UNSPEC;
2342 if (!PyArg_ParseTuple(args, "zO|iiii:getaddrinfo",
2343 &hptr, &pobj, &family, &socktype,
2344 &protocol, &flags)) {
2345 return NULL;
2346 }
2347 if (PyInt_Check(pobj)) {
Martin v. Löwis791bfda2001-07-24 06:33:08 +00002348#ifndef HAVE_SNPRINTF
2349 sprintf(pbuf, "%ld", PyInt_AsLong(pobj));
2350#else
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002351 snprintf(pbuf, sizeof(pbuf), "%ld", PyInt_AsLong(pobj));
Martin v. Löwis791bfda2001-07-24 06:33:08 +00002352#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002353 pptr = pbuf;
2354 } else if (PyString_Check(pobj)) {
2355 pptr = PyString_AsString(pobj);
2356 } else if (pobj == Py_None) {
2357 pptr = (char *)NULL;
2358 } else {
2359 PyErr_SetString(PySocket_Error, "Int or String expected");
2360 return NULL;
2361 }
2362 memset(&hints, 0, sizeof(hints));
2363 hints.ai_family = family;
2364 hints.ai_socktype = socktype;
2365 hints.ai_protocol = protocol;
2366 hints.ai_flags = flags;
2367 error = getaddrinfo(hptr, pptr, &hints, &res0);
2368 if (error) {
2369 PyGAI_Err(error);
2370 return NULL;
2371 }
2372
2373 if ((all = PyList_New(0)) == NULL)
2374 goto err;
2375 for (res = res0; res; res = res->ai_next) {
2376 single = Py_BuildValue("iiisO", res->ai_family,
2377 res->ai_socktype, res->ai_protocol,
2378 res->ai_canonname ? res->ai_canonname : "",
2379 makesockaddr(-1, res->ai_addr, res->ai_addrlen));
2380 if (single == NULL)
2381 goto err;
2382
2383 if (PyList_Append(all, single))
2384 goto err;
2385 Py_XDECREF(single);
2386 }
2387 Py_XDECREF(pobj);
2388 return all;
2389 err:
2390 Py_XDECREF(single);
2391 Py_XDECREF(all);
2392 Py_XDECREF(pobj);
2393 return (PyObject *)NULL;
2394}
2395
2396static char getaddrinfo_doc[] =
2397"socket.getaddrinfo(host, port [, family, socktype, proto, flags])\n\
2398 --> List of (family, socktype, proto, canonname, sockaddr)\n\
2399\n\
2400Resolve host and port into addrinfo struct.";
2401
2402/* Python interface to getnameinfo(sa, flags). */
2403
2404/*ARGSUSED*/
2405static PyObject *
2406PySocket_getnameinfo(PyObject *self, PyObject *args)
2407{
2408 PyObject *sa = (PyObject *)NULL;
2409 int flags;
2410 char *hostp;
2411 int n, port, flowinfo, scope_id;
2412 char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
2413 struct addrinfo hints, *res = NULL;
2414 int error;
2415 PyObject *ret = (PyObject *)NULL;
2416
2417 flags = flowinfo = scope_id = 0;
2418 if (PyArg_ParseTuple(args, "Oi:getnameinfo", &sa, &flags) == 0)
2419 return NULL;
2420 n = PyArg_ParseTuple(sa, "si|ii", &hostp, &port, &flowinfo, scope_id);
2421 if (n == 0)
2422 goto fail;
Thomas Wouters7aeb6ef2001-07-24 11:03:34 +00002423#ifdef HAVE_SNPRINTF
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002424 snprintf(pbuf, sizeof(pbuf), "%d", port);
Martin v. Löwis791bfda2001-07-24 06:33:08 +00002425#else
2426 sprintf(pbuf, "%d", port);
2427#endif
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002428 memset(&hints, 0, sizeof(hints));
2429 hints.ai_family = PF_UNSPEC;
2430 error = getaddrinfo(hostp, pbuf, &hints, &res);
2431 if (error) {
2432 PyGAI_Err(error);
2433 goto fail;
2434 }
2435 if (res->ai_next) {
2436 PyErr_SetString(PySocket_Error,
2437 "sockaddr resolved to multiple addresses");
2438 goto fail;
2439 }
2440 switch (res->ai_family) {
2441 case AF_INET:
2442 {
2443 char *t1;
2444 int t2;
2445 if (PyArg_ParseTuple(sa, "si", &t1, &t2) == 0) {
2446 PyErr_SetString(PySocket_Error,
2447 "IPv4 sockaddr must be 2 tuple");
2448 goto fail;
2449 }
2450 break;
2451 }
2452#ifdef INET6
2453 case AF_INET6:
2454 {
2455 struct sockaddr_in6 *sin6;
2456 sin6 = (struct sockaddr_in6 *)res->ai_addr;
2457 sin6->sin6_flowinfo = flowinfo;
2458 sin6->sin6_scope_id = scope_id;
2459 break;
2460 }
2461#endif
2462 }
2463 error = getnameinfo(res->ai_addr, res->ai_addrlen,
2464 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), flags);
2465 if (error) {
2466 PyGAI_Err(error);
2467 goto fail;
2468 }
2469 ret = Py_BuildValue("ss", hbuf, pbuf);
2470
2471fail:
2472 if (res)
2473 freeaddrinfo(res);
2474 Py_XDECREF(sa);
2475 return ret;
2476}
2477
2478static char getnameinfo_doc[] =
2479"socket.getnameinfo(sockaddr, flags) --> (host, port)\n\
2480\n\
2481Get host and port for a sockaddr.";
2482
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002483
2484#ifdef USE_SSL
2485
2486/* This is a C function to be called for new object initialization */
2487static SSLObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002488newSSLObject(PySocketSockObject *Sock, char *key_file, char *cert_file)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002489{
2490 SSLObject *self;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002491
Guido van Rossumb18618d2000-05-03 23:44:39 +00002492 self = PyObject_New(SSLObject, &SSL_Type); /* Create new object */
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002493 if (self == NULL){
2494 PyErr_SetObject(SSLErrorObject,
2495 PyString_FromString("newSSLObject error"));
2496 return NULL;
2497 }
Guido van Rossum2dd8ddd2000-04-21 20:33:00 +00002498 memset(self->server, '\0', sizeof(char) * 256);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002499 memset(self->issuer, '\0', sizeof(char) * 256);
2500
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002501 self->x_attr = PyDict_New();
2502 self->ctx = SSL_CTX_new(SSLv23_method()); /* Set up context */
2503 if (self->ctx == NULL) {
2504 PyErr_SetObject(SSLErrorObject,
2505 PyString_FromString("SSL_CTX_new error"));
Guido van Rossumb18618d2000-05-03 23:44:39 +00002506 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002507 return NULL;
2508 }
2509
2510 if ( (key_file && !cert_file) || (!key_file && cert_file) )
2511 {
2512 PyErr_SetObject(SSLErrorObject,
2513 PyString_FromString(
2514 "Both the key & certificate files must be specified"));
Guido van Rossumb18618d2000-05-03 23:44:39 +00002515 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002516 return NULL;
2517 }
2518
2519 if (key_file && cert_file)
2520 {
2521 if (SSL_CTX_use_PrivateKey_file(self->ctx, key_file,
2522 SSL_FILETYPE_PEM) < 1)
2523 {
2524 PyErr_SetObject(SSLErrorObject,
2525 PyString_FromString(
2526 "SSL_CTX_use_PrivateKey_file error"));
Guido van Rossumb18618d2000-05-03 23:44:39 +00002527 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002528 return NULL;
2529 }
2530
2531 if (SSL_CTX_use_certificate_chain_file(self->ctx,
2532 cert_file) < 1)
2533 {
2534 PyErr_SetObject(SSLErrorObject,
2535 PyString_FromString(
2536 "SSL_CTX_use_certificate_chain_file error"));
Guido van Rossumb18618d2000-05-03 23:44:39 +00002537 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002538 return NULL;
2539 }
2540 }
2541
2542 SSL_CTX_set_verify(self->ctx,
2543 SSL_VERIFY_NONE, NULL); /* set verify lvl */
2544 self->ssl = SSL_new(self->ctx); /* New ssl struct */
2545 SSL_set_fd(self->ssl, Sock->sock_fd); /* Set the socket for SSL */
2546 SSL_set_connect_state(self->ssl);
2547
2548 if ((SSL_connect(self->ssl)) == -1) {
2549 /* Actually negotiate SSL connection */
2550 PyErr_SetObject(SSLErrorObject,
2551 PyString_FromString("SSL_connect error"));
Guido van Rossumb18618d2000-05-03 23:44:39 +00002552 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002553 return NULL;
2554 }
2555 self->ssl->debug = 1;
2556
2557 if ((self->server_cert = SSL_get_peer_certificate(self->ssl))) {
2558 X509_NAME_oneline(X509_get_subject_name(self->server_cert),
2559 self->server, 256);
2560 X509_NAME_oneline(X509_get_issuer_name(self->server_cert),
2561 self->issuer, 256);
2562 }
2563 self->x_attr = NULL;
2564 self->Socket = Sock;
2565 Py_INCREF(self->Socket);
2566 return self;
2567}
2568
2569/* This is the Python function called for new object initialization */
2570static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002571PySocket_ssl(PyObject *self, PyObject *args)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002572{
2573 SSLObject *rv;
2574 PySocketSockObject *Sock;
2575 char *key_file;
2576 char *cert_file;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002577
Guido van Rossum43713e52000-02-29 13:59:29 +00002578 if (!PyArg_ParseTuple(args, "O!zz:ssl",
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002579 &PySocketSock_Type, (PyObject*)&Sock,
2580 &key_file, &cert_file) )
2581 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002582
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002583 rv = newSSLObject(Sock, key_file, cert_file);
2584 if ( rv == NULL )
2585 return NULL;
2586 return (PyObject *)rv;
2587}
2588
2589static char ssl_doc[] =
2590"ssl(socket, keyfile, certfile) -> sslobject";
2591
2592static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002593SSL_server(SSLObject *self, PyObject *args)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002594{
2595 return PyString_FromString(self->server);
2596}
2597
2598static PyObject *
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002599SSL_issuer(SSLObject *self, PyObject *args)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002600{
2601 return PyString_FromString(self->issuer);
2602}
2603
2604
2605/* SSL object methods */
2606
2607static PyMethodDef SSLMethods[] = {
2608 { "write", (PyCFunction)SSL_SSLwrite, 1 },
2609 { "read", (PyCFunction)SSL_SSLread, 1 },
2610 { "server", (PyCFunction)SSL_server, 1 },
2611 { "issuer", (PyCFunction)SSL_issuer, 1 },
2612 { NULL, NULL}
2613};
2614
2615static void SSL_dealloc(SSLObject *self)
2616{
2617 if (self->server_cert) /* Possible not to have one? */
2618 X509_free (self->server_cert);
2619 SSL_CTX_free(self->ctx);
2620 SSL_free(self->ssl);
2621 Py_XDECREF(self->x_attr);
2622 Py_XDECREF(self->Socket);
Guido van Rossumb18618d2000-05-03 23:44:39 +00002623 PyObject_Del(self);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002624}
2625
2626static PyObject *SSL_getattr(SSLObject *self, char *name)
2627{
2628 return Py_FindMethod(SSLMethods, (PyObject *)self, name);
2629}
2630
2631staticforward PyTypeObject SSL_Type = {
Guido van Rossuma120ffc2001-01-22 15:29:14 +00002632 PyObject_HEAD_INIT(NULL)
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002633 0, /*ob_size*/
2634 "SSL", /*tp_name*/
2635 sizeof(SSLObject), /*tp_basicsize*/
2636 0, /*tp_itemsize*/
2637 /* methods */
2638 (destructor)SSL_dealloc, /*tp_dealloc*/
2639 0, /*tp_print*/
2640 (getattrfunc)SSL_getattr, /*tp_getattr*/
2641 0, /*tp_setattr*/
2642 0, /*tp_compare*/
2643 0, /*tp_repr*/
2644 0, /*tp_as_number*/
2645 0, /*tp_as_sequence*/
2646 0, /*tp_as_mapping*/
2647 0, /*tp_hash*/
2648};
2649
2650
2651
2652static PyObject *SSL_SSLwrite(SSLObject *self, PyObject *args)
2653{
2654 char *data;
Andrew M. Kuchlingb38175e2001-02-07 20:41:17 +00002655 size_t len;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002656
Andrew M. Kuchlingb38175e2001-02-07 20:41:17 +00002657 if (!PyArg_ParseTuple(args, "s#:write", &data, &len))
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002658 return NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002659
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002660 len = SSL_write(self->ssl, data, len);
2661 return PyInt_FromLong((long)len);
2662}
2663
2664static PyObject *SSL_SSLread(SSLObject *self, PyObject *args)
2665{
2666 PyObject *buf;
2667 int count = 0;
2668 int len = 1024;
2669 int res;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002670
Guido van Rossum43713e52000-02-29 13:59:29 +00002671 PyArg_ParseTuple(args, "|i:read", &len);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002672
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002673 if (!(buf = PyString_FromStringAndSize((char *) 0, len)))
2674 return NULL; /* Error object should already be set */
Guido van Rossum48a680c2001-03-02 06:34:14 +00002675
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002676 count = SSL_read(self->ssl, PyString_AsString(buf), len);
2677 res = SSL_get_error(self->ssl, count);
2678
2679 switch (res) {
Jeremy Hylton42dd01a2001-02-01 23:35:20 +00002680 case SSL_ERROR_NONE:
2681 assert(count > 0);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002682 break;
Jeremy Hylton42dd01a2001-02-01 23:35:20 +00002683 case SSL_ERROR_ZERO_RETURN: /* normal EOF */
2684 assert(count == 0);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002685 break;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002686 default:
2687 return PyErr_SetFromErrno(SSLErrorObject);
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002688 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00002689
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002690 fflush(stderr);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002691
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002692 if (count < 0) {
2693 Py_DECREF(buf);
2694 return PyErr_SetFromErrno(SSLErrorObject);
2695 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00002696
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002697 if (count != len && _PyString_Resize(&buf, count) < 0)
2698 return NULL;
2699 return buf;
2700}
2701
2702#endif /* USE_SSL */
2703
2704
Guido van Rossum30a685f1991-06-27 15:51:29 +00002705/* List of functions exported by this module. */
2706
Guido van Rossum73624e91994-10-10 17:59:00 +00002707static PyMethodDef PySocket_methods[] = {
Guido van Rossum48a680c2001-03-02 06:34:14 +00002708 {"gethostbyname", PySocket_gethostbyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002709 METH_VARARGS, gethostbyname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002710 {"gethostbyname_ex", PySocket_gethostbyname_ex,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002711 METH_VARARGS, ghbn_ex_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002712 {"gethostbyaddr", PySocket_gethostbyaddr,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002713 METH_VARARGS, gethostbyaddr_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002714 {"gethostname", PySocket_gethostname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002715 METH_VARARGS, gethostname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002716 {"getservbyname", PySocket_getservbyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002717 METH_VARARGS, getservbyname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002718 {"getprotobyname", PySocket_getprotobyname,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002719 METH_VARARGS,getprotobyname_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002720 {"socket", PySocket_socket,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002721 METH_VARARGS, socket_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002722#ifndef NO_DUP
Guido van Rossum48a680c2001-03-02 06:34:14 +00002723 {"fromfd", PySocket_fromfd,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002724 METH_VARARGS, fromfd_doc},
Guido van Rossum6a3eb5f1994-08-18 15:42:46 +00002725#endif
Guido van Rossum48a680c2001-03-02 06:34:14 +00002726 {"ntohs", PySocket_ntohs,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002727 METH_VARARGS, ntohs_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002728 {"ntohl", PySocket_ntohl,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002729 METH_VARARGS, ntohl_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002730 {"htons", PySocket_htons,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002731 METH_VARARGS, htons_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002732 {"htonl", PySocket_htonl,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002733 METH_VARARGS, htonl_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002734 {"inet_aton", PySocket_inet_aton,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002735 METH_VARARGS, inet_aton_doc},
Guido van Rossum48a680c2001-03-02 06:34:14 +00002736 {"inet_ntoa", PySocket_inet_ntoa,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002737 METH_VARARGS, inet_ntoa_doc},
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002738 {"getaddrinfo", PySocket_getaddrinfo,
2739 METH_VARARGS, getaddrinfo_doc},
2740 {"getnameinfo", PySocket_getnameinfo,
2741 METH_VARARGS, getnameinfo_doc},
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002742#ifdef USE_SSL
Guido van Rossum48a680c2001-03-02 06:34:14 +00002743 {"ssl", PySocket_ssl,
Andrew M. Kuchlinge365fb82000-08-03 02:06:16 +00002744 METH_VARARGS, ssl_doc},
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002745#endif /* USE_SSL */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002746 {NULL, NULL} /* Sentinel */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002747};
2748
Guido van Rossum30a685f1991-06-27 15:51:29 +00002749
2750/* Convenience routine to export an integer value.
Barry Warsaw752300b1997-01-03 17:18:10 +00002751 *
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002752 * Errors are silently ignored, for better or for worse...
Barry Warsaw752300b1997-01-03 17:18:10 +00002753 */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002754static void
Fredrik Lundh3c5d43d2000-07-09 15:09:56 +00002755insint(PyObject *d, char *name, int value)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002756{
Guido van Rossum73624e91994-10-10 17:59:00 +00002757 PyObject *v = PyInt_FromLong((long) value);
Barry Warsaw752300b1997-01-03 17:18:10 +00002758 if (!v || PyDict_SetItemString(d, name, v))
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002759 PyErr_Clear();
Barry Warsaw752300b1997-01-03 17:18:10 +00002760
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002761 Py_XDECREF(v);
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002762}
2763
Guido van Rossum30a685f1991-06-27 15:51:29 +00002764
Guido van Rossum8d665e61996-06-26 18:22:49 +00002765#ifdef MS_WINDOWS
Guido van Rossumbe32c891996-06-20 16:25:29 +00002766
2767/* Additional initialization and cleanup for NT/Windows */
2768
2769static void
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002770NTcleanup(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00002771{
2772 WSACleanup();
Guido van Rossumbe32c891996-06-20 16:25:29 +00002773}
2774
2775static int
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002776NTinit(void)
Guido van Rossumbe32c891996-06-20 16:25:29 +00002777{
2778 WSADATA WSAData;
2779 int ret;
2780 char buf[100];
2781 ret = WSAStartup(0x0101, &WSAData);
2782 switch (ret) {
2783 case 0: /* no error */
2784 atexit(NTcleanup);
2785 return 1;
2786 case WSASYSNOTREADY:
2787 PyErr_SetString(PyExc_ImportError,
2788 "WSAStartup failed: network not ready");
2789 break;
2790 case WSAVERNOTSUPPORTED:
2791 case WSAEINVAL:
2792 PyErr_SetString(PyExc_ImportError,
2793 "WSAStartup failed: requested version not supported");
2794 break;
2795 default:
2796 sprintf(buf, "WSAStartup failed: error code %d", ret);
2797 PyErr_SetString(PyExc_ImportError, buf);
2798 break;
2799 }
2800 return 0;
2801}
2802
Guido van Rossum8d665e61996-06-26 18:22:49 +00002803#endif /* MS_WINDOWS */
Guido van Rossumbe32c891996-06-20 16:25:29 +00002804
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002805#if defined(PYOS_OS2)
2806
2807/* Additional initialization and cleanup for OS/2 */
2808
2809static void
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002810OS2cleanup(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002811{
2812 /* No cleanup is necessary for OS/2 Sockets */
2813}
2814
2815static int
Thomas Woutersf3f33dc2000-07-21 06:00:07 +00002816OS2init(void)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002817{
2818 char reason[64];
2819 int rc = sock_init();
2820
2821 if (rc == 0) {
Guido van Rossum32c575d1997-12-02 20:37:32 +00002822 atexit(OS2cleanup);
2823 return 1; /* Indicate Success */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002824 }
2825
2826 sprintf(reason, "OS/2 TCP/IP Error# %d", sock_errno());
2827 PyErr_SetString(PyExc_ImportError, reason);
2828
Guido van Rossum32c575d1997-12-02 20:37:32 +00002829 return 0; /* Indicate Failure */
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002830}
2831
2832#endif /* PYOS_OS2 */
2833
Guido van Rossum30a685f1991-06-27 15:51:29 +00002834/* Initialize this module.
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002835 * This is called when the first 'import socket' is done,
2836 * via a table in config.c, if config.c is compiled with USE_SOCKET
2837 * defined.
2838 *
2839 * For MS_WINDOWS (which means any Windows variant), this module
2840 * is actually called "_socket", and there's a wrapper "socket.py"
2841 * which implements some missing functionality (such as makefile(),
2842 * dup() and fromfd()). The import of "_socket" may fail with an
2843 * ImportError exception if initialization of WINSOCK fails. When
2844 * WINSOCK is initialized succesfully, a call to WSACleanup() is
2845 * scheduled to be made at exit time.
2846 *
2847 * For OS/2, this module is also called "_socket" and uses a wrapper
2848 * "socket.py" which implements that functionality that is missing
2849 * when PC operating systems don't put socket descriptors in the
2850 * operating system's filesystem layer.
2851 */
Guido van Rossum30a685f1991-06-27 15:51:29 +00002852
Guido van Rossum82a5c661998-07-07 20:45:43 +00002853static char module_doc[] =
Fred Drakea136d492000-08-16 14:18:30 +00002854"Implementation module for socket operations. See the socket module\n\
2855for documentation.";
Guido van Rossum82a5c661998-07-07 20:45:43 +00002856
2857static char sockettype_doc[] =
2858"A socket represents one endpoint of a network connection.\n\
2859\n\
2860Methods:\n\
2861\n\
2862accept() -- accept a connection, returning new socket and client address\n\
2863bind() -- bind the socket to a local address\n\
2864close() -- close the socket\n\
2865connect() -- connect the socket to a remote address\n\
2866connect_ex() -- connect, return an error code instead of an exception \n\
2867dup() -- return a new socket object identical to the current one (*)\n\
2868fileno() -- return underlying file descriptor\n\
2869getpeername() -- return remote address (*)\n\
2870getsockname() -- return local address\n\
2871getsockopt() -- get socket options\n\
2872listen() -- start listening for incoming connections\n\
2873makefile() -- return a file object corresponding tot the socket (*)\n\
2874recv() -- receive data\n\
2875recvfrom() -- receive data and sender's address\n\
2876send() -- send data\n\
2877sendto() -- send data to a given address\n\
2878setblocking() -- set or clear the blocking I/O flag\n\
2879setsockopt() -- set socket options\n\
2880shutdown() -- shut down traffic in one or both directions\n\
2881\n\
2882(*) not available on all platforms!)";
2883
Guido van Rossum3886bb61998-12-04 18:50:17 +00002884DL_EXPORT(void)
Thomas Wouters1e0c2f42000-07-24 16:06:23 +00002885init_socket(void)
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002886{
Guido van Rossum73624e91994-10-10 17:59:00 +00002887 PyObject *m, *d;
Guido van Rossum48a680c2001-03-02 06:34:14 +00002888#ifdef RISCOS
2889 _kernel_swi_regs r;
2890 r.r[0]=0;
2891 _kernel_swi(0x43380, &r, &r);
2892 taskwindow = r.r[0];
2893#else
Guido van Rossum8d665e61996-06-26 18:22:49 +00002894#ifdef MS_WINDOWS
Guido van Rossumbe32c891996-06-20 16:25:29 +00002895 if (!NTinit())
2896 return;
Guido van Rossumbe32c891996-06-20 16:25:29 +00002897#else
Guido van Rossum32c575d1997-12-02 20:37:32 +00002898#if defined(__TOS_OS2__)
Guido van Rossum8e9ebfd1997-11-22 21:53:48 +00002899 if (!OS2init())
2900 return;
Fred Drakea136d492000-08-16 14:18:30 +00002901#endif /* __TOS_OS2__ */
2902#endif /* MS_WINDOWS */
Guido van Rossum48a680c2001-03-02 06:34:14 +00002903#endif /* RISCOS */
Guido van Rossuma120ffc2001-01-22 15:29:14 +00002904#ifdef USE_SSL
2905 SSL_Type.ob_type = &PyType_Type;
2906#endif
Guido van Rossum82a5c661998-07-07 20:45:43 +00002907 m = Py_InitModule3("_socket", PySocket_methods, module_doc);
Guido van Rossum73624e91994-10-10 17:59:00 +00002908 d = PyModule_GetDict(m);
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002909 PySocket_Error = PyErr_NewException("socket.error", NULL, NULL);
2910 if (PySocket_Error == NULL)
2911 return;
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002912 PyH_Error = PyErr_NewException("socket.herror", PySocket_Error, NULL);
2913 if (PyH_Error == NULL)
2914 return;
2915 PyGAI_Error = PyErr_NewException("socket.gaierror", PySocket_Error,
2916 NULL);
2917 if (PyGAI_Error == NULL)
2918 return;
Guido van Rossum09c8b6c1999-12-07 21:37:17 +00002919#ifdef USE_SSL
2920 SSL_load_error_strings();
2921 SSLeay_add_ssl_algorithms();
2922 SSLErrorObject = PyErr_NewException("socket.sslerror", NULL, NULL);
2923 if (SSLErrorObject == NULL)
2924 return;
2925 PyDict_SetItemString(d, "sslerror", SSLErrorObject);
2926 Py_INCREF(&SSL_Type);
2927 if (PyDict_SetItemString(d, "SSLType",
2928 (PyObject *)&SSL_Type) != 0)
2929 return;
2930#endif /* USE_SSL */
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002931 PyDict_SetItemString(d, "error", PySocket_Error);
Guido van Rossum3b4b6fc1997-05-21 14:37:37 +00002932 PySocketSock_Type.ob_type = &PyType_Type;
Guido van Rossum82a5c661998-07-07 20:45:43 +00002933 PySocketSock_Type.tp_doc = sockettype_doc;
Guido van Rossum3b4b6fc1997-05-21 14:37:37 +00002934 Py_INCREF(&PySocketSock_Type);
Guido van Rossum91ba64d1997-06-02 22:18:09 +00002935 if (PyDict_SetItemString(d, "SocketType",
Guido van Rossum3b4b6fc1997-05-21 14:37:37 +00002936 (PyObject *)&PySocketSock_Type) != 0)
Guido van Rossum0cb96de1997-10-01 04:29:29 +00002937 return;
Guido van Rossum09be4091999-08-09 14:40:40 +00002938
2939 /* Address families (we only support AF_INET and AF_UNIX) */
2940#ifdef AF_UNSPEC
2941 insint(d, "AF_UNSPEC", AF_UNSPEC);
2942#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002943 insint(d, "AF_INET", AF_INET);
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00002944#ifdef AF_INET6
2945 insint(d, "AF_INET6", AF_INET6);
2946#endif /* AF_INET6 */
Guido van Rossumb6775db1994-08-01 11:34:53 +00002947#ifdef AF_UNIX
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002948 insint(d, "AF_UNIX", AF_UNIX);
Guido van Rossumb6775db1994-08-01 11:34:53 +00002949#endif /* AF_UNIX */
Guido van Rossum09be4091999-08-09 14:40:40 +00002950#ifdef AF_AX25
2951 insint(d, "AF_AX25", AF_AX25); /* Amateur Radio AX.25 */
2952#endif
2953#ifdef AF_IPX
2954 insint(d, "AF_IPX", AF_IPX); /* Novell IPX */
2955#endif
2956#ifdef AF_APPLETALK
2957 insint(d, "AF_APPLETALK", AF_APPLETALK); /* Appletalk DDP */
2958#endif
2959#ifdef AF_NETROM
2960 insint(d, "AF_NETROM", AF_NETROM); /* Amateur radio NetROM */
2961#endif
2962#ifdef AF_BRIDGE
2963 insint(d, "AF_BRIDGE", AF_BRIDGE); /* Multiprotocol bridge */
2964#endif
2965#ifdef AF_AAL5
2966 insint(d, "AF_AAL5", AF_AAL5); /* Reserved for Werner's ATM */
2967#endif
2968#ifdef AF_X25
2969 insint(d, "AF_X25", AF_X25); /* Reserved for X.25 project */
2970#endif
2971#ifdef AF_INET6
2972 insint(d, "AF_INET6", AF_INET6); /* IP version 6 */
2973#endif
2974#ifdef AF_ROSE
2975 insint(d, "AF_ROSE", AF_ROSE); /* Amateur Radio X.25 PLP */
2976#endif
Jeremy Hylton22308652001-02-02 03:23:09 +00002977#if defined(linux) && defined(AF_PACKET)
2978 insint(d, "AF_PACKET", AF_PACKET);
2979 insint(d, "PF_PACKET", PF_PACKET);
2980 insint(d, "PACKET_HOST", PACKET_HOST);
2981 insint(d, "PACKET_BROADCAST", PACKET_BROADCAST);
2982 insint(d, "PACKET_MULTICAST", PACKET_MULTICAST);
2983 insint(d, "PACKET_OTHERHOST", PACKET_OTHERHOST);
2984 insint(d, "PACKET_OUTGOING", PACKET_OUTGOING);
2985 insint(d, "PACKET_LOOPBACK", PACKET_LOOPBACK);
2986 insint(d, "PACKET_FASTROUTE", PACKET_FASTROUTE);
Guido van Rossum48a680c2001-03-02 06:34:14 +00002987#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00002988
2989 /* Socket types */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002990 insint(d, "SOCK_STREAM", SOCK_STREAM);
2991 insint(d, "SOCK_DGRAM", SOCK_DGRAM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00002992#ifndef __BEOS__
2993/* We have incomplete socket support. */
Guido van Rossum6574b3e1991-06-25 21:36:08 +00002994 insint(d, "SOCK_RAW", SOCK_RAW);
2995 insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
2996 insint(d, "SOCK_RDM", SOCK_RDM);
Guido van Rossumbcc20741998-08-04 22:53:56 +00002997#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00002998
2999#ifdef SO_DEBUG
3000 insint(d, "SO_DEBUG", SO_DEBUG);
3001#endif
3002#ifdef SO_ACCEPTCONN
3003 insint(d, "SO_ACCEPTCONN", SO_ACCEPTCONN);
3004#endif
3005#ifdef SO_REUSEADDR
3006 insint(d, "SO_REUSEADDR", SO_REUSEADDR);
3007#endif
3008#ifdef SO_KEEPALIVE
3009 insint(d, "SO_KEEPALIVE", SO_KEEPALIVE);
3010#endif
3011#ifdef SO_DONTROUTE
3012 insint(d, "SO_DONTROUTE", SO_DONTROUTE);
3013#endif
3014#ifdef SO_BROADCAST
3015 insint(d, "SO_BROADCAST", SO_BROADCAST);
3016#endif
3017#ifdef SO_USELOOPBACK
3018 insint(d, "SO_USELOOPBACK", SO_USELOOPBACK);
3019#endif
3020#ifdef SO_LINGER
3021 insint(d, "SO_LINGER", SO_LINGER);
3022#endif
3023#ifdef SO_OOBINLINE
3024 insint(d, "SO_OOBINLINE", SO_OOBINLINE);
3025#endif
3026#ifdef SO_REUSEPORT
3027 insint(d, "SO_REUSEPORT", SO_REUSEPORT);
3028#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003029#ifdef SO_SNDBUF
3030 insint(d, "SO_SNDBUF", SO_SNDBUF);
3031#endif
3032#ifdef SO_RCVBUF
3033 insint(d, "SO_RCVBUF", SO_RCVBUF);
3034#endif
3035#ifdef SO_SNDLOWAT
3036 insint(d, "SO_SNDLOWAT", SO_SNDLOWAT);
3037#endif
3038#ifdef SO_RCVLOWAT
3039 insint(d, "SO_RCVLOWAT", SO_RCVLOWAT);
3040#endif
3041#ifdef SO_SNDTIMEO
3042 insint(d, "SO_SNDTIMEO", SO_SNDTIMEO);
3043#endif
3044#ifdef SO_RCVTIMEO
3045 insint(d, "SO_RCVTIMEO", SO_RCVTIMEO);
3046#endif
3047#ifdef SO_ERROR
3048 insint(d, "SO_ERROR", SO_ERROR);
3049#endif
3050#ifdef SO_TYPE
3051 insint(d, "SO_TYPE", SO_TYPE);
3052#endif
3053
3054 /* Maximum number of connections for "listen" */
3055#ifdef SOMAXCONN
3056 insint(d, "SOMAXCONN", SOMAXCONN);
3057#else
3058 insint(d, "SOMAXCONN", 5); /* Common value */
3059#endif
3060
3061 /* Flags for send, recv */
3062#ifdef MSG_OOB
3063 insint(d, "MSG_OOB", MSG_OOB);
3064#endif
3065#ifdef MSG_PEEK
3066 insint(d, "MSG_PEEK", MSG_PEEK);
3067#endif
3068#ifdef MSG_DONTROUTE
3069 insint(d, "MSG_DONTROUTE", MSG_DONTROUTE);
3070#endif
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00003071#ifdef MSG_DONTWAIT
Guido van Rossum14f3f592000-04-25 21:53:58 +00003072 insint(d, "MSG_DONTWAIT", MSG_DONTWAIT);
Guido van Rossum2c8bcb82000-04-25 21:34:53 +00003073#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003074#ifdef MSG_EOR
3075 insint(d, "MSG_EOR", MSG_EOR);
3076#endif
3077#ifdef MSG_TRUNC
3078 insint(d, "MSG_TRUNC", MSG_TRUNC);
3079#endif
3080#ifdef MSG_CTRUNC
3081 insint(d, "MSG_CTRUNC", MSG_CTRUNC);
3082#endif
3083#ifdef MSG_WAITALL
3084 insint(d, "MSG_WAITALL", MSG_WAITALL);
3085#endif
3086#ifdef MSG_BTAG
3087 insint(d, "MSG_BTAG", MSG_BTAG);
3088#endif
3089#ifdef MSG_ETAG
3090 insint(d, "MSG_ETAG", MSG_ETAG);
3091#endif
3092
3093 /* Protocol level and numbers, usable for [gs]etsockopt */
3094#ifdef SOL_SOCKET
3095 insint(d, "SOL_SOCKET", SOL_SOCKET);
3096#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00003097#ifdef SOL_IP
3098 insint(d, "SOL_IP", SOL_IP);
3099#else
3100 insint(d, "SOL_IP", 0);
3101#endif
3102#ifdef SOL_IPX
3103 insint(d, "SOL_IPX", SOL_IPX);
3104#endif
3105#ifdef SOL_AX25
3106 insint(d, "SOL_AX25", SOL_AX25);
3107#endif
3108#ifdef SOL_ATALK
3109 insint(d, "SOL_ATALK", SOL_ATALK);
3110#endif
3111#ifdef SOL_NETROM
3112 insint(d, "SOL_NETROM", SOL_NETROM);
3113#endif
3114#ifdef SOL_ROSE
3115 insint(d, "SOL_ROSE", SOL_ROSE);
3116#endif
3117#ifdef SOL_TCP
3118 insint(d, "SOL_TCP", SOL_TCP);
3119#else
3120 insint(d, "SOL_TCP", 6);
3121#endif
3122#ifdef SOL_UDP
3123 insint(d, "SOL_UDP", SOL_UDP);
3124#else
3125 insint(d, "SOL_UDP", 17);
3126#endif
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003127#ifdef IPPROTO_IP
3128 insint(d, "IPPROTO_IP", IPPROTO_IP);
Guido van Rossum578de301998-05-28 20:18:18 +00003129#else
3130 insint(d, "IPPROTO_IP", 0);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003131#endif
3132#ifdef IPPROTO_ICMP
3133 insint(d, "IPPROTO_ICMP", IPPROTO_ICMP);
Guido van Rossum578de301998-05-28 20:18:18 +00003134#else
3135 insint(d, "IPPROTO_ICMP", 1);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003136#endif
3137#ifdef IPPROTO_IGMP
3138 insint(d, "IPPROTO_IGMP", IPPROTO_IGMP);
3139#endif
3140#ifdef IPPROTO_GGP
3141 insint(d, "IPPROTO_GGP", IPPROTO_GGP);
3142#endif
3143#ifdef IPPROTO_TCP
3144 insint(d, "IPPROTO_TCP", IPPROTO_TCP);
Guido van Rossum578de301998-05-28 20:18:18 +00003145#else
3146 insint(d, "IPPROTO_TCP", 6);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003147#endif
3148#ifdef IPPROTO_EGP
3149 insint(d, "IPPROTO_EGP", IPPROTO_EGP);
3150#endif
3151#ifdef IPPROTO_PUP
3152 insint(d, "IPPROTO_PUP", IPPROTO_PUP);
3153#endif
3154#ifdef IPPROTO_UDP
3155 insint(d, "IPPROTO_UDP", IPPROTO_UDP);
Guido van Rossum578de301998-05-28 20:18:18 +00003156#else
3157 insint(d, "IPPROTO_UDP", 17);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003158#endif
3159#ifdef IPPROTO_IDP
3160 insint(d, "IPPROTO_IDP", IPPROTO_IDP);
3161#endif
3162#ifdef IPPROTO_HELLO
3163 insint(d, "IPPROTO_HELLO", IPPROTO_HELLO);
3164#endif
3165#ifdef IPPROTO_ND
3166 insint(d, "IPPROTO_ND", IPPROTO_ND);
3167#endif
3168#ifdef IPPROTO_TP
3169 insint(d, "IPPROTO_TP", IPPROTO_TP);
3170#endif
3171#ifdef IPPROTO_XTP
3172 insint(d, "IPPROTO_XTP", IPPROTO_XTP);
3173#endif
3174#ifdef IPPROTO_EON
3175 insint(d, "IPPROTO_EON", IPPROTO_EON);
3176#endif
3177#ifdef IPPROTO_BIP
3178 insint(d, "IPPROTO_BIP", IPPROTO_BIP);
3179#endif
3180/**/
3181#ifdef IPPROTO_RAW
3182 insint(d, "IPPROTO_RAW", IPPROTO_RAW);
Guido van Rossum578de301998-05-28 20:18:18 +00003183#else
3184 insint(d, "IPPROTO_RAW", 255);
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003185#endif
3186#ifdef IPPROTO_MAX
3187 insint(d, "IPPROTO_MAX", IPPROTO_MAX);
3188#endif
3189
3190 /* Some port configuration */
3191#ifdef IPPORT_RESERVED
3192 insint(d, "IPPORT_RESERVED", IPPORT_RESERVED);
3193#else
3194 insint(d, "IPPORT_RESERVED", 1024);
3195#endif
3196#ifdef IPPORT_USERRESERVED
3197 insint(d, "IPPORT_USERRESERVED", IPPORT_USERRESERVED);
3198#else
3199 insint(d, "IPPORT_USERRESERVED", 5000);
3200#endif
3201
Guido van Rossum5f05eb41995-02-17 15:11:07 +00003202 /* Some reserved IP v.4 addresses */
3203#ifdef INADDR_ANY
3204 insint(d, "INADDR_ANY", INADDR_ANY);
3205#else
3206 insint(d, "INADDR_ANY", 0x00000000);
3207#endif
3208#ifdef INADDR_BROADCAST
3209 insint(d, "INADDR_BROADCAST", INADDR_BROADCAST);
3210#else
3211 insint(d, "INADDR_BROADCAST", 0xffffffff);
3212#endif
3213#ifdef INADDR_LOOPBACK
3214 insint(d, "INADDR_LOOPBACK", INADDR_LOOPBACK);
3215#else
3216 insint(d, "INADDR_LOOPBACK", 0x7F000001);
3217#endif
3218#ifdef INADDR_UNSPEC_GROUP
3219 insint(d, "INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
3220#else
3221 insint(d, "INADDR_UNSPEC_GROUP", 0xe0000000);
3222#endif
3223#ifdef INADDR_ALLHOSTS_GROUP
3224 insint(d, "INADDR_ALLHOSTS_GROUP", INADDR_ALLHOSTS_GROUP);
3225#else
3226 insint(d, "INADDR_ALLHOSTS_GROUP", 0xe0000001);
3227#endif
3228#ifdef INADDR_MAX_LOCAL_GROUP
3229 insint(d, "INADDR_MAX_LOCAL_GROUP", INADDR_MAX_LOCAL_GROUP);
3230#else
3231 insint(d, "INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
3232#endif
3233#ifdef INADDR_NONE
3234 insint(d, "INADDR_NONE", INADDR_NONE);
3235#else
3236 insint(d, "INADDR_NONE", 0xffffffff);
3237#endif
3238
Guido van Rossum3fdf58b1995-02-07 15:39:52 +00003239 /* IP [gs]etsockopt options */
3240#ifdef IP_OPTIONS
3241 insint(d, "IP_OPTIONS", IP_OPTIONS);
3242#endif
3243#ifdef IP_HDRINCL
3244 insint(d, "IP_HDRINCL", IP_HDRINCL);
3245#endif
3246#ifdef IP_TOS
3247 insint(d, "IP_TOS", IP_TOS);
3248#endif
3249#ifdef IP_TTL
3250 insint(d, "IP_TTL", IP_TTL);
3251#endif
3252#ifdef IP_RECVOPTS
3253 insint(d, "IP_RECVOPTS", IP_RECVOPTS);
3254#endif
3255#ifdef IP_RECVRETOPTS
3256 insint(d, "IP_RECVRETOPTS", IP_RECVRETOPTS);
3257#endif
3258#ifdef IP_RECVDSTADDR
3259 insint(d, "IP_RECVDSTADDR", IP_RECVDSTADDR);
3260#endif
3261#ifdef IP_RETOPTS
3262 insint(d, "IP_RETOPTS", IP_RETOPTS);
3263#endif
3264#ifdef IP_MULTICAST_IF
3265 insint(d, "IP_MULTICAST_IF", IP_MULTICAST_IF);
3266#endif
3267#ifdef IP_MULTICAST_TTL
3268 insint(d, "IP_MULTICAST_TTL", IP_MULTICAST_TTL);
3269#endif
3270#ifdef IP_MULTICAST_LOOP
3271 insint(d, "IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
3272#endif
3273#ifdef IP_ADD_MEMBERSHIP
3274 insint(d, "IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
3275#endif
3276#ifdef IP_DROP_MEMBERSHIP
3277 insint(d, "IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
3278#endif
Guido van Rossum09be4091999-08-09 14:40:40 +00003279#ifdef IP_DEFAULT_MULTICAST_TTL
3280 insint(d, "IP_DEFAULT_MULTICAST_TTL", IP_DEFAULT_MULTICAST_TTL);
3281#endif
3282#ifdef IP_DEFAULT_MULTICAST_LOOP
3283 insint(d, "IP_DEFAULT_MULTICAST_LOOP", IP_DEFAULT_MULTICAST_LOOP);
3284#endif
3285#ifdef IP_MAX_MEMBERSHIPS
3286 insint(d, "IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
3287#endif
3288
3289 /* TCP options */
3290#ifdef TCP_NODELAY
3291 insint(d, "TCP_NODELAY", TCP_NODELAY);
3292#endif
3293#ifdef TCP_MAXSEG
3294 insint(d, "TCP_MAXSEG", TCP_MAXSEG);
3295#endif
3296
3297 /* IPX options */
3298#ifdef IPX_TYPE
3299 insint(d, "IPX_TYPE", IPX_TYPE);
3300#endif
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003301
Martin v. Löwis2d8d4272001-07-21 18:05:31 +00003302 /* get{addr,name}info parameters */
3303#ifdef EAI_ADDRFAMILY
3304 insint(d, "EAI_ADDRFAMILY", EAI_ADDRFAMILY);
3305#endif
3306#ifdef EAI_AGAIN
3307 insint(d, "EAI_AGAIN", EAI_AGAIN);
3308#endif
3309#ifdef EAI_BADFLAGS
3310 insint(d, "EAI_BADFLAGS", EAI_BADFLAGS);
3311#endif
3312#ifdef EAI_FAIL
3313 insint(d, "EAI_FAIL", EAI_FAIL);
3314#endif
3315#ifdef EAI_FAMILY
3316 insint(d, "EAI_FAMILY", EAI_FAMILY);
3317#endif
3318#ifdef EAI_MEMORY
3319 insint(d, "EAI_MEMORY", EAI_MEMORY);
3320#endif
3321#ifdef EAI_NODATA
3322 insint(d, "EAI_NODATA", EAI_NODATA);
3323#endif
3324#ifdef EAI_NONAME
3325 insint(d, "EAI_NONAME", EAI_NONAME);
3326#endif
3327#ifdef EAI_SERVICE
3328 insint(d, "EAI_SERVICE", EAI_SERVICE);
3329#endif
3330#ifdef EAI_SOCKTYPE
3331 insint(d, "EAI_SOCKTYPE", EAI_SOCKTYPE);
3332#endif
3333#ifdef EAI_SYSTEM
3334 insint(d, "EAI_SYSTEM", EAI_SYSTEM);
3335#endif
3336#ifdef EAI_BADHINTS
3337 insint(d, "EAI_BADHINTS", EAI_BADHINTS);
3338#endif
3339#ifdef EAI_PROTOCOL
3340 insint(d, "EAI_PROTOCOL", EAI_PROTOCOL);
3341#endif
3342#ifdef EAI_MAX
3343 insint(d, "EAI_MAX", EAI_MAX);
3344#endif
3345#ifdef AI_PASSIVE
3346 insint(d, "AI_PASSIVE", AI_PASSIVE);
3347#endif
3348#ifdef AI_CANONNAME
3349 insint(d, "AI_CANONNAME", AI_CANONNAME);
3350#endif
3351#ifdef AI_NUMERICHOST
3352 insint(d, "AI_NUMERICHOST", AI_NUMERICHOST);
3353#endif
3354#ifdef AI_MASK
3355 insint(d, "AI_MASK", AI_MASK);
3356#endif
3357#ifdef AI_ALL
3358 insint(d, "AI_ALL", AI_ALL);
3359#endif
3360#ifdef AI_V4MAPPED_CFG
3361 insint(d, "AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
3362#endif
3363#ifdef AI_ADDRCONFIG
3364 insint(d, "AI_ADDRCONFIG", AI_ADDRCONFIG);
3365#endif
3366#ifdef AI_V4MAPPED
3367 insint(d, "AI_V4MAPPED", AI_V4MAPPED);
3368#endif
3369#ifdef AI_DEFAULT
3370 insint(d, "AI_DEFAULT", AI_DEFAULT);
3371#endif
3372#ifdef NI_MAXHOST
3373 insint(d, "NI_MAXHOST", NI_MAXHOST);
3374#endif
3375#ifdef NI_MAXSERV
3376 insint(d, "NI_MAXSERV", NI_MAXSERV);
3377#endif
3378#ifdef NI_NOFQDN
3379 insint(d, "NI_NOFQDN", NI_NOFQDN);
3380#endif
3381#ifdef NI_NUMERICHOST
3382 insint(d, "NI_NUMERICHOST", NI_NUMERICHOST);
3383#endif
3384#ifdef NI_NAMEREQD
3385 insint(d, "NI_NAMEREQD", NI_NAMEREQD);
3386#endif
3387#ifdef NI_NUMERICSERV
3388 insint(d, "NI_NUMERICSERV", NI_NUMERICSERV);
3389#endif
3390#ifdef NI_DGRAM
3391 insint(d, "NI_DGRAM", NI_DGRAM);
3392#endif
3393
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003394 /* Initialize gethostbyname lock */
Guido van Rossum3baaa131999-03-22 21:44:51 +00003395#ifdef USE_GETHOSTBYNAME_LOCK
Guido van Rossum65d5b571998-12-21 19:32:43 +00003396 gethostbyname_lock = PyThread_allocate_lock();
Guido van Rossum4f199ea1998-04-09 20:56:35 +00003397#endif
Guido van Rossum6574b3e1991-06-25 21:36:08 +00003398}
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00003399
3400/* Simplistic emulation code for inet_pton that only works for IPv4 */
3401#ifndef HAVE_INET_PTON
Martin v. Löwisa2ca1ae2001-06-24 21:35:43 +00003402int
Martin v. Löwisc925b1532001-07-21 09:42:15 +00003403inet_pton (int af, const char *src, void *dst)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00003404{
3405 if(af == AF_INET){
3406 long packed_addr;
3407#ifdef USE_GUSI1
3408 packed_addr = (long)inet_addr(src).s_addr;
3409#else
3410 packed_addr = inet_addr(src);
3411#endif
3412 if (packed_addr == INADDR_NONE)
3413 return 0;
3414 memcpy(dst, &packed_addr, 4);
3415 return 1;
3416 }
3417 /* Should set errno to EAFNOSUPPORT */
3418 return -1;
3419}
3420
Martin v. Löwisc925b1532001-07-21 09:42:15 +00003421const char *
3422inet_ntop(int af, const void *src, char *dst, socklen_t size)
Martin v. Löwisb9ab1592001-06-24 21:18:26 +00003423{
3424 if (af == AF_INET) {
3425 struct in_addr packed_addr;
3426 if (size < 16)
3427 /* Should set errno to ENOSPC. */
3428 return NULL;
3429 memcpy(&packed_addr, src, sizeof(packed_addr));
3430 return strncpy(dst, inet_ntoa(packed_addr), size);
3431 }
3432 /* Should set errno to EAFNOSUPPORT */
3433 return NULL;
3434}
3435#endif