1991-06-25 18:36:08 -03:00
/* Socket module */
/*
2002-06-07 00:19:37 -03:00
1991-06-25 18:36:08 -03:00
This module provides an interface to Berkeley socket IPC .
Limitations :
2002-06-07 00:19:37 -03:00
- Only AF_INET , AF_INET6 and AF_UNIX address families are supported in a
2008-01-07 12:12:44 -04:00
portable manner , though AF_PACKET , AF_NETLINK and AF_TIPC are supported
under Linux .
2002-06-07 00:19:37 -03:00
- No read / write operations ( use sendall / recv or makefile instead ) .
- Additional restrictions apply on some non - Unix platforms ( compensated
for by socket . py ) .
1991-06-25 18:36:08 -03:00
1995-03-16 11:43:47 -04:00
Module interface :
1991-06-25 18:36:08 -03:00
1995-03-16 11:43:47 -04:00
- socket . error : exception raised for socket specific errors
2001-07-21 15:05:31 -03:00
- socket . gaierror : exception raised for getaddrinfo / getnameinfo errors ,
a subclass of socket . error
- socket . herror : exception raised for gethostby * errors ,
a subclass of socket . error
2002-09-03 16:10:18 -03:00
- socket . fromfd ( fd , family , type [ , proto ] ) - - > new socket object ( created
from an existing file descriptor )
1991-06-27 12:51:29 -03:00
- socket . gethostbyname ( hostname ) - - > host IP address ( string : ' dd . dd . dd . dd ' )
1995-01-02 15:30:30 -04:00
- socket . gethostbyaddr ( IP address ) - - > ( hostname , [ alias , . . . ] , [ IP addr , . . . ] )
1995-03-16 11:43:47 -04:00
- socket . gethostname ( ) - - > host name ( string : ' spam ' or ' spam . domain . com ' )
1996-12-19 12:42:52 -04:00
- socket . getprotobyname ( protocolname ) - - > protocol number
2004-06-27 21:50:43 -03:00
- socket . getservbyname ( servicename [ , protocolname ] ) - - > port number
- socket . getservbyport ( portnumber [ , protocolname ] ) - - > service name
2002-09-03 16:10:18 -03:00
- socket . socket ( [ family [ , type [ , proto ] ] ] ) - - > new socket object
2004-08-09 01:51:41 -03:00
- socket . socketpair ( [ family [ , type [ , proto ] ] ] ) - - > ( socket , socket )
1996-06-12 01:04:55 -03:00
- socket . ntohs ( 16 bit value ) - - > new int object
- socket . ntohl ( 32 bit value ) - - > new int object
- socket . htons ( 16 bit value ) - - > new int object
- socket . htonl ( 32 bit value ) - - > new int object
2001-07-21 15:05:31 -03:00
- socket . getaddrinfo ( host , port [ , family , socktype , proto , flags ] )
- - > List of ( family , socktype , proto , canonname , sockaddr )
- socket . getnameinfo ( sockaddr , flags ) - - > ( host , port )
1995-03-16 11:43:47 -04:00
- socket . AF_INET , socket . SOCK_STREAM , etc . : constants from < socket . h >
2003-04-25 02:48:32 -03:00
- socket . has_ipv6 : boolean value indicating if IPv6 is supported
1999-08-20 15:21:51 -03:00
- socket . inet_aton ( IP address ) - > 32 - bit packed IP representation
- socket . inet_ntoa ( packed IP ) - > IP address string
2002-07-18 14:08:35 -03:00
- socket . getdefaulttimeout ( ) - > None | float
- socket . setdefaulttimeout ( None | float )
1991-06-25 18:36:08 -03:00
- an Internet socket address is a pair ( hostname , port )
where hostname can be anything recognized by gethostbyname ( )
( including the dd . dd . dd . dd notation ) and port is in host byte order
- where a hostname is returned , the dd . dd . dd . dd notation is used
1995-03-16 11:43:47 -04:00
- a UNIX domain socket address is a string specifying the pathname
2001-02-01 23:23:09 -04:00
- an AF_PACKET socket address is a tuple containing a string
specifying the ethernet interface and an integer specifying
the Ethernet protocol number to be received . For example :
2001-02-02 15:55:17 -04:00
( " eth0 " , 0x1234 ) . Optional 3 rd , 4 th , 5 th elements in the tuple
2004-07-10 20:39:35 -03:00
specify packet - type and ha - type / addr .
2008-01-07 12:12:44 -04:00
- an AF_TIPC socket address is expressed as
( addr_type , v1 , v2 , v3 [ , scope ] ) ; where addr_type can be one of :
TIPC_ADDR_NAMESEQ , TIPC_ADDR_NAME , and TIPC_ADDR_ID ;
and scope can be one of :
TIPC_ZONE_SCOPE , TIPC_CLUSTER_SCOPE , and TIPC_NODE_SCOPE .
The meaning of v1 , v2 and v3 depends on the value of addr_type :
if addr_type is TIPC_ADDR_NAME :
v1 is the server type
v2 is the port identifier
v3 is ignored
if addr_type is TIPC_ADDR_NAMESEQ :
v1 is the server type
v2 is the lower port number
v3 is the upper port number
if addr_type is TIPC_ADDR_ID :
v1 is the node
v2 is the ref
v3 is ignored
1991-06-25 18:36:08 -03:00
2002-06-07 00:19:37 -03:00
Local naming conventions :
- names starting with sock_ are socket object methods
- names starting with socket_ are module - level functions
- names starting with PySocket are exported through socketmodule . h
1991-06-25 18:36:08 -03:00
*/
2006-04-23 08:59:25 -03:00
# ifdef __APPLE__
/*
* inet_aton is not available on OSX 10.3 , yet we want to use a binary
* that was build on 10.4 or later to work on that release , weak linking
* comes to the rescue .
*/
# pragma weak inet_aton
# endif
2002-06-13 17:33:02 -03:00
# include "Python.h"
2006-03-17 15:17:34 -04:00
# include "structmember.h"
2002-06-13 17:33:02 -03:00
2003-04-25 02:48:32 -03:00
# undef MAX
# define MAX(x, y) ((x) < (y) ? (y) : (x))
2002-06-07 00:19:37 -03:00
/* Socket object documentation */
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( sock_doc ,
2002-06-07 00:19:37 -03:00
" socket([family[, type[, proto]]]) -> socket object \n \
\ n \
Open a socket of the given type . The family argument specifies the \ n \
address family ; it defaults to AF_INET . The type argument specifies \ n \
whether this is a stream ( SOCK_STREAM , this is the default ) \ n \
or datagram ( SOCK_DGRAM ) socket . The protocol argument defaults to 0 , \ n \
specifying the default protocol . Keyword arguments are accepted . \ n \
\ n \
A socket object represents one endpoint of a network connection . \ n \
\ n \
Methods of socket objects ( keyword arguments not allowed ) : \ n \
\ n \
accept ( ) - - accept a connection , returning new socket and client address \ n \
bind ( addr ) - - bind the socket to a local address \ n \
close ( ) - - close the socket \ n \
connect ( addr ) - - connect the socket to a remote address \ n \
connect_ex ( addr ) - - connect , return an error code instead of an exception \ n \
dup ( ) - - return a new socket object identical to the current one [ * ] \ n \
fileno ( ) - - return underlying file descriptor \ n \
getpeername ( ) - - return remote address [ * ] \ n \
getsockname ( ) - - return local address \ n \
getsockopt ( level , optname [ , buflen ] ) - - get socket options \ n \
gettimeout ( ) - - return timeout or None \ n \
listen ( n ) - - start listening for incoming connections \ n \
makefile ( [ mode , [ bufsize ] ] ) - - return a file object for the socket [ * ] \ n \
recv ( buflen [ , flags ] ) - - receive data \ n \
2006-06-04 10:49:49 -03:00
recv_into ( buffer [ , nbytes [ , flags ] ] ) - - receive data ( into a buffer ) \ n \
2006-05-26 09:03:27 -03:00
recvfrom ( buflen [ , flags ] ) - - receive data and sender \ ' s address \ n \
2006-06-04 10:49:49 -03:00
recvfrom_into ( buffer [ , nbytes , [ , flags ] ) \ n \
2006-05-26 09:03:27 -03:00
- - receive data and sender \ ' s address ( into a buffer ) \ n \
2002-06-07 00:19:37 -03:00
sendall ( data [ , flags ] ) - - send all data \ n \
send ( data [ , flags ] ) - - send data , may not send all of it \ n \
sendto ( data [ , flags ] , addr ) - - send data to a given address \ n \
setblocking ( 0 | 1 ) - - set or clear the blocking I / O flag \ n \
setsockopt ( level , optname , value ) - - set socket options \ n \
settimeout ( None | float ) - - set or clear the timeout \ n \
shutdown ( how ) - - shut down traffic in one or both directions \ n \
\ n \
2002-06-13 17:33:02 -03:00
[ * ] not available on all platforms ! " );
1999-03-22 17:44:51 -04:00
2003-10-20 11:01:56 -03:00
/* XXX This is a terrible mess of platform-dependent preprocessor hacks.
2001-10-27 19:20:47 -03:00
I hope some day someone can clean this up please . . . */
1999-09-15 19:01:40 -03:00
/* Hacks for gethostbyname_r(). On some non-Linux platforms, the configure
script doesn ' t get this right , so we hardcode some platform checks below .
On the other hand , not all Linux versions agree , so there the settings
computed by the configure script are needed ! */
# ifndef linux
2002-02-16 14:23:30 -04:00
# undef HAVE_GETHOSTBYNAME_R_3_ARG
# undef HAVE_GETHOSTBYNAME_R_5_ARG
# undef HAVE_GETHOSTBYNAME_R_6_ARG
1999-09-15 19:01:40 -03:00
# endif
1999-03-24 13:24:33 -04:00
1999-04-13 01:07:32 -03:00
# ifndef WITH_THREAD
2002-02-16 14:23:30 -04:00
# undef HAVE_GETHOSTBYNAME_R
1999-04-13 01:07:32 -03:00
# endif
1999-03-24 13:24:33 -04:00
# ifdef HAVE_GETHOSTBYNAME_R
2002-02-16 14:23:30 -04:00
# if defined(_AIX) || defined(__osf__)
# define HAVE_GETHOSTBYNAME_R_3_ARG
# elif defined(__sun) || defined(__sgi)
# define HAVE_GETHOSTBYNAME_R_5_ARG
# elif defined(linux)
1999-09-15 19:01:40 -03:00
/* Rely on the configure script */
2002-02-16 14:23:30 -04:00
# else
# undef HAVE_GETHOSTBYNAME_R
# endif
1999-03-24 13:24:33 -04:00
# endif
2002-06-06 23:08:35 -03:00
# if !defined(HAVE_GETHOSTBYNAME_R) && defined(WITH_THREAD) && \
! defined ( MS_WINDOWS )
2002-02-16 14:23:30 -04:00
# define USE_GETHOSTBYNAME_LOCK
1999-03-22 17:44:51 -04:00
# endif
2005-09-24 11:58:47 -03:00
/* To use __FreeBSD_version */
# ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
# endif
2003-05-09 04:53:18 -03:00
/* On systems on which getaddrinfo() is believed to not be thread-safe,
2003-05-09 05:03:44 -03:00
( this includes the getaddrinfo emulation ) protect access with a lock . */
2005-09-24 11:58:47 -03:00
# if defined(WITH_THREAD) && (defined(__APPLE__) || \
( defined ( __FreeBSD__ ) & & __FreeBSD_version + 0 < 503000 ) | | \
2006-07-09 22:18:57 -03:00
defined ( __OpenBSD__ ) | | defined ( __NetBSD__ ) | | \
defined ( __VMS ) | | ! defined ( HAVE_GETADDRINFO ) )
2003-05-09 04:53:18 -03:00
# define USE_GETADDRINFO_LOCK
# endif
# ifdef USE_GETADDRINFO_LOCK
# define ACQUIRE_GETADDRINFO_LOCK PyThread_acquire_lock(netdb_lock, 1);
# define RELEASE_GETADDRINFO_LOCK PyThread_release_lock(netdb_lock);
# else
# define ACQUIRE_GETADDRINFO_LOCK
# define RELEASE_GETADDRINFO_LOCK
# endif
# if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
2002-02-16 14:23:30 -04:00
# include "pythread.h"
1998-04-09 17:56:35 -03:00
# endif
1991-06-25 18:36:08 -03:00
1997-11-22 17:53:48 -04:00
# if defined(PYCC_VACPP)
2002-02-16 14:23:30 -04:00
# include <types.h>
# include <io.h>
# include <sys / ioctl.h>
# include <utils.h>
# include <ctype.h>
1997-11-22 17:53:48 -04:00
# endif
2002-12-06 08:57:26 -04:00
# if defined(__VMS)
2002-12-06 08:48:53 -04:00
# include <ioctl.h>
# endif
1997-11-22 17:53:48 -04:00
# if defined(PYOS_OS2)
2002-02-16 14:23:30 -04:00
# define INCL_DOS
# define INCL_DOSERRORS
# define INCL_NOPMAPI
# include <os2.h>
1997-11-22 17:53:48 -04:00
# endif
2003-07-17 13:58:48 -03:00
# if defined(__sgi) && _COMPILER_VERSION>700 && !_SGIAPI
2002-09-19 05:03:21 -03:00
/* make sure that the reentrant (gethostbyaddr_r etc)
functions are declared correctly if compiling with
MIPSPro 7. x in ANSI C mode ( default ) */
2003-07-17 13:58:48 -03:00
2006-05-26 09:03:27 -03:00
/* XXX Using _SGIAPI is the wrong thing,
2003-07-17 13:58:48 -03:00
but I don ' t know what the right thing is . */
2004-09-13 14:48:41 -03:00
# undef _SGIAPI /* to avoid warning */
2002-09-19 05:03:21 -03:00
# define _SGIAPI 1
2003-07-17 13:58:48 -03:00
2004-09-13 14:48:41 -03:00
# undef _XOPEN_SOURCE
# include <sys/socket.h>
# include <sys/types.h>
# include <netinet/in.h>
# ifdef _SS_ALIGNSIZE
# define HAVE_GETADDRINFO 1
# define HAVE_GETNAMEINFO 1
# endif
2003-07-17 13:58:48 -03:00
# define HAVE_INET_PTON
# include <netdb.h>
2002-09-19 05:03:21 -03:00
# endif
2006-05-26 09:03:27 -03:00
/* Irix 6.5 fails to define this variable at all. This is needed
for both GCC and SGI ' s compiler . I ' d say that the SGI headers
2006-02-20 05:42:33 -04:00
are just busted . Same thing for Solaris . */
# if (defined(__sgi) || defined(sun)) && !defined(INET_ADDRSTRLEN)
2003-10-04 05:00:49 -03:00
# define INET_ADDRSTRLEN 16
# endif
2002-02-16 14:23:30 -04:00
/* Generic includes */
2006-06-10 09:23:46 -03:00
# ifdef HAVE_SYS_TYPES_H
1994-08-01 08:34:53 -03:00
# include <sys/types.h>
2006-06-10 09:23:46 -03:00
# endif
2002-02-16 14:23:30 -04:00
2002-02-16 14:47:07 -04:00
/* Generic socket object definitions and includes */
2002-02-16 14:23:30 -04:00
# define PySocket_BUILDING_SOCKET
2002-02-16 14:44:52 -04:00
# include "socketmodule.h"
2002-02-16 14:23:30 -04:00
/* Addressing includes */
1996-06-28 17:15:15 -03:00
# ifndef MS_WINDOWS
2002-02-16 14:23:30 -04:00
/* Non-MS WINDOWS includes */
# include <netdb.h>
1999-08-20 15:21:51 -03:00
1999-09-15 19:01:40 -03:00
/* Headers needed for inet_ntoa() and inet_addr() */
2002-02-16 14:23:30 -04:00
# ifdef __BEOS__
# include <net / netdb.h>
# elif defined(PYOS_OS2) && defined(PYCC_VACPP)
# include <netdb.h>
2001-11-04 22:45:59 -04:00
typedef size_t socklen_t ;
2002-02-16 14:23:30 -04:00
# else
# include <arpa / inet.h>
# endif
# ifndef RISCOS
# include <fcntl.h>
# else
2003-05-10 04:36:56 -03:00
# include <sys / ioctl.h>
# include <socklib.h>
2002-02-16 14:23:30 -04:00
# define NO_DUP
2001-10-24 17:42:55 -03:00
int h_errno ; /* not used */
2003-05-10 04:36:56 -03:00
# define INET_ADDRSTRLEN 16
2002-02-16 14:23:30 -04:00
# endif
2001-03-02 02:34:14 -04:00
1994-08-01 08:34:53 -03:00
# else
1993-04-07 11:06:14 -03:00
2002-02-16 14:23:30 -04:00
/* MS_WINDOWS includes */
2006-06-10 09:23:46 -03:00
# ifdef HAVE_FCNTL_H
# include <fcntl.h>
# endif
2002-02-16 14:23:30 -04:00
2001-02-01 23:23:09 -04:00
# endif
2004-02-10 12:50:21 -04:00
# include <stddef.h>
2001-06-24 18:28:42 -03:00
# ifndef offsetof
2002-02-16 14:23:30 -04:00
# define offsetof(type, member) ((size_t)(&((type *)0)->member))
2001-06-24 18:28:42 -03:00
# endif
2002-11-02 15:55:21 -04:00
# ifndef O_NONBLOCK
# define O_NONBLOCK O_NDELAY
1995-01-02 15:30:30 -04:00
# endif
2004-09-07 14:48:26 -03:00
/* include Python's addrinfo.h unless it causes trouble */
# if defined(__sgi) && _COMPILER_VERSION>700 && defined(_SS_ALIGNSIZE)
/* Do not include addinfo.h on some newer IRIX versions.
* _SS_ALIGNSIZE is defined in sys / socket . h by 6.5 .21 ,
* for example , but not by 6.5 .10 .
*/
2006-06-10 09:23:46 -03:00
# elif defined(_MSC_VER) && _MSC_VER>1201
2004-09-07 14:48:26 -03:00
/* Do not include addrinfo.h for MSVC7 or greater. 'addrinfo' and
* EAI_ * constants are defined in ( the already included ) ws2tcpip . h .
*/
# else
# include "addrinfo.h"
# endif
2004-08-03 05:52:46 -03:00
2001-06-24 18:18:26 -03:00
# ifndef HAVE_INET_PTON
2007-11-22 07:21:16 -04:00
# if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
2002-06-06 23:08:35 -03:00
int inet_pton ( int af , const char * src , void * dst ) ;
2001-07-21 06:42:15 -03:00
const char * inet_ntop ( int af , const void * src , char * dst , socklen_t size ) ;
2001-06-24 18:18:26 -03:00
# endif
2007-11-22 07:21:16 -04:00
# endif
2001-06-24 18:18:26 -03:00
2001-08-03 07:02:29 -03:00
# ifdef __APPLE__
/* On OS X, getaddrinfo returns no error indication of lookup
failure , so we must use the emulation instead of the libinfo
implementation . Unfortunately , performing an autoconf test
for this bug would require DNS access for the machine performing
the configuration , which is not acceptable . Therefore , we
determine the bug just by checking for __APPLE__ . If this bug
gets ever fixed , perhaps checking for sys / version . h would be
appropriate , which is 10 / 0 on the system with the bug . */
2002-07-02 11:40:42 -03:00
# ifndef HAVE_GETNAMEINFO
/* This bug seems to be fixed in Jaguar. Ths easiest way I could
Find to check for Jaguar is that it has getnameinfo ( ) , which
older releases don ' t have */
2001-08-03 07:02:29 -03:00
# undef HAVE_GETADDRINFO
# endif
2006-04-23 08:59:25 -03:00
# ifdef HAVE_INET_ATON
# define USE_INET_ATON_WEAKLINK
# endif
2002-07-02 11:40:42 -03:00
# endif
2001-08-03 07:02:29 -03:00
2001-06-23 13:30:13 -03:00
/* I know this is a bad practice, but it is the easiest... */
2001-08-03 07:02:29 -03:00
# if !defined(HAVE_GETADDRINFO)
2003-05-01 02:20:46 -03:00
/* avoid clashes with the C library definition of the symbol. */
# define getaddrinfo fake_getaddrinfo
# define gai_strerror fake_gai_strerror
# define freeaddrinfo fake_freeaddrinfo
2001-06-23 13:30:13 -03:00
# include "getaddrinfo.c"
# endif
2001-08-03 07:02:29 -03:00
# if !defined(HAVE_GETNAMEINFO)
2003-05-01 02:20:46 -03:00
# define getnameinfo fake_getnameinfo
2001-06-23 13:30:13 -03:00
# include "getnameinfo.c"
# endif
1998-08-04 19:53:56 -03:00
# if defined(MS_WINDOWS) || defined(__BEOS__)
/* BeOS suffers from the same socket dichotomy as Win32... - [cjh] */
1994-08-18 12:42:46 -03:00
/* seem to be a few differences in the API */
2000-04-21 17:33:00 -03:00
# define SOCKETCLOSE closesocket
1996-06-20 13:25:29 -03:00
# define NO_DUP /* Actually it exists on NT 3.5, but what the heck... */
1994-08-18 12:42:46 -03:00
# endif
2001-07-21 15:05:31 -03:00
# ifdef MS_WIN32
2002-06-06 23:08:35 -03:00
# define EAFNOSUPPORT WSAEAFNOSUPPORT
# define snprintf _snprintf
2001-07-21 15:05:31 -03:00
# endif
2000-06-29 23:46:07 -03:00
2002-03-02 23:03:52 -04:00
# if defined(PYOS_OS2) && !defined(PYCC_GCC)
2000-04-21 17:33:00 -03:00
# define SOCKETCLOSE soclose
1997-11-22 17:53:48 -04:00
# define NO_DUP /* Sockets are Not Actual File Handles under OS/2 */
# endif
2000-04-21 17:33:00 -03:00
# ifndef SOCKETCLOSE
# define SOCKETCLOSE close
# endif
2004-02-02 02:05:24 -04:00
# if defined(HAVE_BLUETOOTH_H) || defined(HAVE_BLUETOOTH_BLUETOOTH_H)
# define USE_BLUETOOTH 1
# if defined(__FreeBSD__)
# define BTPROTO_L2CAP BLUETOOTH_PROTO_L2CAP
# define BTPROTO_RFCOMM BLUETOOTH_PROTO_RFCOMM
2007-02-14 06:07:37 -04:00
# define BTPROTO_HCI BLUETOOTH_PROTO_HCI
2007-06-05 15:16:52 -03:00
# define SOL_HCI SOL_HCI_RAW
# define HCI_FILTER SO_HCI_RAW_FILTER
2004-02-02 02:05:24 -04:00
# define sockaddr_l2 sockaddr_l2cap
# define sockaddr_rc sockaddr_rfcomm
2007-06-05 15:16:52 -03:00
# define hci_dev hci_node
2004-02-02 02:05:24 -04:00
# define _BT_L2_MEMB(sa, memb) ((sa)->l2cap_##memb)
# define _BT_RC_MEMB(sa, memb) ((sa)->rfcomm_##memb)
2007-02-14 06:07:37 -04:00
# define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
2006-07-28 08:27:27 -03:00
# elif defined(__NetBSD__)
# define sockaddr_l2 sockaddr_bt
# define sockaddr_rc sockaddr_bt
2007-02-14 06:07:37 -04:00
# define sockaddr_hci sockaddr_bt
2006-07-28 08:27:27 -03:00
# define sockaddr_sco sockaddr_bt
# define _BT_L2_MEMB(sa, memb) ((sa)->bt_##memb)
# define _BT_RC_MEMB(sa, memb) ((sa)->bt_##memb)
2007-02-14 06:07:37 -04:00
# define _BT_HCI_MEMB(sa, memb) ((sa)->bt_##memb)
2006-07-28 08:27:27 -03:00
# define _BT_SCO_MEMB(sa, memb) ((sa)->bt_##memb)
2004-02-02 02:05:24 -04:00
# else
# define _BT_L2_MEMB(sa, memb) ((sa)->l2_##memb)
# define _BT_RC_MEMB(sa, memb) ((sa)->rc_##memb)
2007-02-14 06:07:37 -04:00
# define _BT_HCI_MEMB(sa, memb) ((sa)->hci_##memb)
2004-02-02 02:05:24 -04:00
# define _BT_SCO_MEMB(sa, memb) ((sa)->sco_##memb)
# endif
# endif
2006-07-09 22:18:57 -03:00
# ifdef __VMS
/* TCP/IP Services for VMS uses a maximum send/recv buffer length */
# define SEGMENT_SIZE (32 * 1024 -1)
# endif
2006-12-03 07:23:45 -04:00
# define SAS2SA(x) ((struct sockaddr *)(x))
2003-05-03 07:12:45 -03:00
/*
* Constants for getnameinfo ( )
*/
# if !defined(NI_MAXHOST)
# define NI_MAXHOST 1025
# endif
# if !defined(NI_MAXSERV)
# define NI_MAXSERV 32
# endif
2001-10-27 19:20:47 -03:00
/* XXX There's a problem here: *static* functions are not supposed to have
a Py prefix ( or use CapitalizedWords ) . Later . . . */
1991-06-27 12:51:29 -03:00
/* Global variable holding the exception type for errors detected
by this module ( but not argument type or memory errors , etc . ) . */
2002-06-07 00:19:37 -03:00
static PyObject * socket_error ;
static PyObject * socket_herror ;
static PyObject * socket_gaierror ;
2003-06-29 00:08:05 -03:00
static PyObject * socket_timeout ;
1991-06-27 12:51:29 -03:00
2001-03-02 02:34:14 -04:00
# ifdef RISCOS
/* Global variable which is !=0 if Python is running in a RISC OS taskwindow */
static int taskwindow ;
# endif
2002-02-17 00:13:21 -04:00
/* A forward reference to the socket type object.
2002-06-07 00:19:37 -03:00
The sock_type variable contains pointers to various functions ,
some of which call new_sockobject ( ) , which uses sock_type , so
2002-02-17 00:13:21 -04:00
there has to be a circular reference . */
2002-07-17 13:30:39 -03:00
static PyTypeObject sock_type ;
2001-03-02 02:34:14 -04:00
2006-07-10 23:04:09 -03:00
# if defined(HAVE_POLL_H)
# include <poll.h>
# elif defined(HAVE_SYS_POLL_H)
# include <sys/poll.h>
# endif
2006-02-11 05:27:05 -04:00
# ifdef Py_SOCKET_FD_CAN_BE_GE_FD_SETSIZE
/* Platform can select file descriptors beyond FD_SETSIZE */
# define IS_SELECTABLE(s) 1
2006-07-10 23:04:09 -03:00
# elif defined(HAVE_POLL)
/* Instead of select(), we'll use poll() since poll() works on any fd. */
# define IS_SELECTABLE(s) 1
/* Can we call select() with this socket without a buffer overrun? */
2006-02-11 05:27:05 -04:00
# else
/* POSIX says selecting file descriptors beyond FD_SETSIZE
2006-07-10 23:04:09 -03:00
has undefined behaviour . If there ' s no timeout left , we don ' t have to
call select , so it ' s a safe , little white lie . */
# define IS_SELECTABLE(s) ((s)->sock_fd < FD_SETSIZE || s->sock_timeout <= 0.0)
2006-02-11 05:27:05 -04:00
# endif
2006-02-07 03:04:46 -04:00
static PyObject *
select_error ( void )
{
PyErr_SetString ( socket_error , " unable to select on socket " ) ;
return NULL ;
}
1991-06-27 12:51:29 -03:00
/* Convenience function to raise an error according to errno
and return a NULL pointer from a function . */
1991-06-25 18:36:08 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
set_error ( void )
1991-06-25 18:36:08 -03:00
{
1996-06-26 15:22:49 -03:00
# ifdef MS_WINDOWS
2000-07-23 22:45:11 -03:00
int err_no = WSAGetLastError ( ) ;
2007-11-15 20:24:44 -04:00
/* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
recognizes the error codes used by both GetLastError ( ) and
WSAGetLastError */
if ( err_no )
return PyErr_SetExcFromWindowsErr ( socket_error , err_no ) ;
1994-09-29 06:50:09 -03:00
# endif
1997-11-22 17:53:48 -04:00
2002-03-02 23:03:52 -04:00
# if defined(PYOS_OS2) && !defined(PYCC_GCC)
2002-06-06 23:08:35 -03:00
if ( sock_errno ( ) ! = NO_ERROR ) {
APIRET rc ;
ULONG msglen ;
char outbuf [ 100 ] ;
int myerrorcode = sock_errno ( ) ;
/* Retrieve socket-related error message from MPTN.MSG file */
rc = DosGetMessage ( NULL , 0 , outbuf , sizeof ( outbuf ) ,
myerrorcode - SOCBASEERR + 26 ,
" mptn.msg " ,
& msglen ) ;
if ( rc = = NO_ERROR ) {
PyObject * v ;
/* OS/2 doesn't guarantee a terminator */
outbuf [ msglen ] = ' \0 ' ;
if ( strlen ( outbuf ) > 0 ) {
/* If non-empty msg, trim CRLF */
char * lastc = & outbuf [ strlen ( outbuf ) - 1 ] ;
2005-12-19 02:05:18 -04:00
while ( lastc > outbuf & &
isspace ( Py_CHARMASK ( * lastc ) ) ) {
2002-06-06 23:08:35 -03:00
/* Trim trailing whitespace (CRLF) */
* lastc - - = ' \0 ' ;
}
}
v = Py_BuildValue ( " (is) " , myerrorcode , outbuf ) ;
if ( v ! = NULL ) {
2002-06-07 00:19:37 -03:00
PyErr_SetObject ( socket_error , v ) ;
2002-06-06 23:08:35 -03:00
Py_DECREF ( v ) ;
}
return NULL ;
}
}
1997-11-22 17:53:48 -04:00
# endif
2003-05-10 04:36:56 -03:00
# if defined(RISCOS)
if ( _inet_error . errnum ! = NULL ) {
PyObject * v ;
v = Py_BuildValue ( " (is) " , errno , _inet_err ( ) ) ;
if ( v ! = NULL ) {
PyErr_SetObject ( socket_error , v ) ;
Py_DECREF ( v ) ;
}
return NULL ;
}
# endif
2002-06-07 00:19:37 -03:00
return PyErr_SetFromErrno ( socket_error ) ;
1991-06-25 18:36:08 -03:00
}
1991-06-27 12:51:29 -03:00
2001-07-21 15:05:31 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
set_herror ( int h_error )
2001-07-21 15:05:31 -03:00
{
PyObject * v ;
# ifdef HAVE_HSTRERROR
v = Py_BuildValue ( " (is) " , h_error , ( char * ) hstrerror ( h_error ) ) ;
# else
v = Py_BuildValue ( " (is) " , h_error , " host not found " ) ;
# endif
if ( v ! = NULL ) {
2002-06-07 00:19:37 -03:00
PyErr_SetObject ( socket_herror , v ) ;
2001-07-21 15:05:31 -03:00
Py_DECREF ( v ) ;
}
return NULL ;
}
static PyObject *
2002-06-07 00:19:37 -03:00
set_gaierror ( int error )
2001-07-21 15:05:31 -03:00
{
PyObject * v ;
2002-03-01 04:31:07 -04:00
# ifdef EAI_SYSTEM
/* EAI_SYSTEM is not available on Windows XP. */
2001-07-21 15:05:31 -03:00
if ( error = = EAI_SYSTEM )
2002-06-07 00:19:37 -03:00
return set_error ( ) ;
2002-03-01 04:31:07 -04:00
# endif
2001-07-21 15:05:31 -03:00
2001-08-15 14:14:33 -03:00
# ifdef HAVE_GAI_STRERROR
2001-07-21 15:05:31 -03:00
v = Py_BuildValue ( " (is) " , error , gai_strerror ( error ) ) ;
2001-08-15 14:14:33 -03:00
# else
v = Py_BuildValue ( " (is) " , error , " getaddrinfo failed " ) ;
# endif
2001-07-21 15:05:31 -03:00
if ( v ! = NULL ) {
2002-06-07 00:19:37 -03:00
PyErr_SetObject ( socket_gaierror , v ) ;
2001-07-21 15:05:31 -03:00
Py_DECREF ( v ) ;
}
return NULL ;
}
2006-07-09 22:18:57 -03:00
# ifdef __VMS
/* Function to send in segments */
static int
sendsegmented ( int sock_fd , char * buf , int len , int flags )
{
int n = 0 ;
int remaining = len ;
while ( remaining > 0 ) {
unsigned int segment ;
segment = ( remaining > = SEGMENT_SIZE ? SEGMENT_SIZE : remaining ) ;
n = send ( sock_fd , buf , segment , flags ) ;
if ( n < 0 ) {
return n ;
}
remaining - = segment ;
buf + = segment ;
} /* end while */
return len ;
}
# endif
2002-06-06 23:08:35 -03:00
/* Function to perform the setting of socket blocking mode
internally . block = ( 1 | 0 ) . */
2002-06-06 18:08:16 -03:00
static int
internal_setblocking ( PySocketSockObject * s , int block )
{
# ifndef RISCOS
# ifndef MS_WINDOWS
int delay_flag ;
# endif
# endif
Py_BEGIN_ALLOW_THREADS
# ifdef __BEOS__
block = ! block ;
2002-06-06 23:08:35 -03:00
setsockopt ( s - > sock_fd , SOL_SOCKET , SO_NONBLOCK ,
( void * ) ( & block ) , sizeof ( int ) ) ;
2002-06-06 18:08:16 -03:00
# else
# ifndef RISCOS
# ifndef MS_WINDOWS
# if defined(PYOS_OS2) && !defined(PYCC_GCC)
block = ! block ;
ioctl ( s - > sock_fd , FIONBIO , ( caddr_t ) & block , sizeof ( block ) ) ;
2002-12-06 08:48:53 -04:00
# elif defined(__VMS)
block = ! block ;
2006-07-09 22:18:57 -03:00
ioctl ( s - > sock_fd , FIONBIO , ( unsigned int * ) & block ) ;
# else /* !PYOS_OS2 && !__VMS */
2002-06-06 18:08:16 -03:00
delay_flag = fcntl ( s - > sock_fd , F_GETFL , 0 ) ;
if ( block )
2002-11-02 15:55:21 -04:00
delay_flag & = ( ~ O_NONBLOCK ) ;
2002-06-06 18:08:16 -03:00
else
2002-11-02 15:55:21 -04:00
delay_flag | = O_NONBLOCK ;
2002-06-06 18:08:16 -03:00
fcntl ( s - > sock_fd , F_SETFL , delay_flag ) ;
# endif /* !PYOS_OS2 */
# else /* MS_WINDOWS */
block = ! block ;
ioctlsocket ( s - > sock_fd , FIONBIO , ( u_long * ) & block ) ;
# endif /* MS_WINDOWS */
2003-05-10 04:36:56 -03:00
# else /* RISCOS */
block = ! block ;
socketioctl ( s - > sock_fd , FIONBIO , ( u_long * ) & block ) ;
2002-06-06 18:08:16 -03:00
# endif /* RISCOS */
2003-05-10 04:36:56 -03:00
# endif /* __BEOS__ */
2002-06-06 18:08:16 -03:00
Py_END_ALLOW_THREADS
/* Since these don't return anything */
return 1 ;
}
2006-07-10 23:04:09 -03:00
/* Do a select()/poll() on the socket, if necessary (sock_timeout > 0).
2002-06-13 12:07:44 -03:00
The argument writing indicates the direction .
2003-06-29 00:08:05 -03:00
This does not raise an exception ; we ' ll let our caller do that
after they ' ve reacquired the interpreter lock .
2006-08-02 03:46:21 -03:00
Returns 1 on timeout , - 1 on error , 0 otherwise . */
2003-06-29 00:08:05 -03:00
static int
2002-06-06 22:42:47 -03:00
internal_select ( PySocketSockObject * s , int writing )
2002-06-06 18:08:16 -03:00
{
2003-06-29 00:08:05 -03:00
int n ;
2002-06-13 12:07:44 -03:00
2002-07-19 09:44:59 -03:00
/* Nothing to do unless we're in timeout mode (not non-blocking) */
2002-06-13 12:07:44 -03:00
if ( s - > sock_timeout < = 0.0 )
2003-06-29 00:08:05 -03:00
return 0 ;
2002-06-06 18:08:16 -03:00
2002-07-19 09:44:59 -03:00
/* Guard against closed socket */
if ( s - > sock_fd < 0 )
2003-06-29 00:08:05 -03:00
return 0 ;
2002-07-19 09:44:59 -03:00
2006-07-10 23:04:09 -03:00
/* Prefer poll, if available, since you can poll() any fd
* which can ' t be done with select ( ) . */
# ifdef HAVE_POLL
{
struct pollfd pollfd ;
int timeout ;
2002-06-06 18:08:16 -03:00
2006-07-10 23:04:09 -03:00
pollfd . fd = s - > sock_fd ;
pollfd . events = writing ? POLLOUT : POLLIN ;
/* s->sock_timeout is in seconds, timeout in ms */
timeout = ( int ) ( s - > sock_timeout * 1000 + 0.5 ) ;
n = poll ( & pollfd , 1 , timeout ) ;
}
# else
{
/* Construct the arguments to select */
fd_set fds ;
struct timeval tv ;
tv . tv_sec = ( int ) s - > sock_timeout ;
tv . tv_usec = ( int ) ( ( s - > sock_timeout - tv . tv_sec ) * 1e6 ) ;
FD_ZERO ( & fds ) ;
FD_SET ( s - > sock_fd , & fds ) ;
/* See if the socket is ready */
if ( writing )
n = select ( s - > sock_fd + 1 , NULL , & fds , NULL , & tv ) ;
else
n = select ( s - > sock_fd + 1 , & fds , NULL , NULL , & tv ) ;
}
# endif
2006-08-02 03:46:21 -03:00
if ( n < 0 )
return - 1 ;
2003-06-29 00:08:05 -03:00
if ( n = = 0 )
return 1 ;
return 0 ;
2002-06-06 18:08:16 -03:00
}
2001-10-27 19:20:47 -03:00
/* Initialize a new socket object. */
2002-07-18 19:38:44 -03:00
static double defaulttimeout = - 1.0 ; /* Default timeout for new sockets */
2002-07-18 14:08:35 -03:00
2002-07-23 03:31:15 -03:00
PyMODINIT_FUNC
2001-10-27 19:20:47 -03:00
init_sockobject ( PySocketSockObject * s ,
SOCKET_T fd , int family , int type , int proto )
{
# ifdef RISCOS
int block = 1 ;
# endif
s - > sock_fd = fd ;
s - > sock_family = family ;
s - > sock_type = type ;
s - > sock_proto = proto ;
2002-07-18 14:08:35 -03:00
s - > sock_timeout = defaulttimeout ;
2002-06-06 18:08:16 -03:00
2002-06-07 00:19:37 -03:00
s - > errorhandler = & set_error ;
2002-07-18 14:08:35 -03:00
if ( defaulttimeout > = 0.0 )
internal_setblocking ( s , 0 ) ;
2001-10-27 19:20:47 -03:00
# ifdef RISCOS
2002-06-06 23:08:35 -03:00
if ( taskwindow )
2001-10-27 19:20:47 -03:00
socketioctl ( s - > sock_fd , 0x80046679 , ( u_long * ) & block ) ;
# endif
}
1991-06-27 12:51:29 -03:00
/* Create a new socket object.
This just creates the object and initializes it .
If the creation fails , return NULL and set an exception ( implicit
in NEWOBJ ( ) ) . */
1994-10-10 14:59:00 -03:00
static PySocketSockObject *
2002-06-07 00:19:37 -03:00
new_sockobject ( SOCKET_T fd , int family , int type , int proto )
1991-06-25 18:36:08 -03:00
{
1994-10-10 14:59:00 -03:00
PySocketSockObject * s ;
2001-10-27 19:20:47 -03:00
s = ( PySocketSockObject * )
2002-06-07 00:19:37 -03:00
PyType_GenericNew ( & sock_type , NULL , NULL ) ;
2001-10-27 19:20:47 -03:00
if ( s ! = NULL )
init_sockobject ( s , fd , family , type , proto ) ;
1991-06-25 18:36:08 -03:00
return s ;
}
1991-06-27 12:51:29 -03:00
2001-03-02 02:34:14 -04:00
/* Lock to allow python interpreter to continue, but only allow one
2003-05-09 04:53:18 -03:00
thread to be in gethostbyname or getaddrinfo */
# if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
PyThread_type_lock netdb_lock ;
1998-04-09 17:56:35 -03:00
# endif
1991-06-27 12:51:29 -03:00
/* Convert a string specifying a host name or one of a few symbolic
names to a numeric IP address . This usually calls gethostbyname ( )
to do the work ; the names " " and " <broadcast> " are special .
2001-07-21 15:05:31 -03:00
Return the length ( IPv4 should be 4 bytes ) , or negative if
1991-06-27 12:51:29 -03:00
an error occurred ; then an exception is raised . */
1991-06-25 18:36:08 -03:00
static int
2002-07-28 13:10:31 -03:00
setipaddr ( char * name , struct sockaddr * addr_ret , size_t addr_ret_size , int af )
1991-06-25 18:36:08 -03:00
{
2001-07-21 15:05:31 -03:00
struct addrinfo hints , * res ;
int error ;
2003-05-02 12:40:46 -03:00
int d1 , d2 , d3 , d4 ;
char ch ;
1991-06-25 18:36:08 -03:00
1996-12-05 19:43:35 -04:00
memset ( ( void * ) addr_ret , ' \0 ' , sizeof ( * addr_ret ) ) ;
1991-06-27 12:51:29 -03:00
if ( name [ 0 ] = = ' \0 ' ) {
2001-07-21 15:05:31 -03:00
int siz ;
memset ( & hints , 0 , sizeof ( hints ) ) ;
hints . ai_family = af ;
hints . ai_socktype = SOCK_DGRAM ; /*dummy*/
hints . ai_flags = AI_PASSIVE ;
2003-05-09 04:53:18 -03:00
Py_BEGIN_ALLOW_THREADS
ACQUIRE_GETADDRINFO_LOCK
2001-07-21 15:05:31 -03:00
error = getaddrinfo ( NULL , " 0 " , & hints , & res ) ;
2003-05-09 04:53:18 -03:00
Py_END_ALLOW_THREADS
/* We assume that those thread-unsafe getaddrinfo() versions
* are * safe regarding their return value , ie . that a
subsequent call to getaddrinfo ( ) does not destroy the
outcome of the first call . */
RELEASE_GETADDRINFO_LOCK
2001-07-21 15:05:31 -03:00
if ( error ) {
2002-06-07 00:19:37 -03:00
set_gaierror ( error ) ;
2001-07-21 15:05:31 -03:00
return - 1 ;
}
switch ( res - > ai_family ) {
case AF_INET :
siz = 4 ;
break ;
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
siz = 16 ;
break ;
# endif
default :
freeaddrinfo ( res ) ;
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2001-07-21 15:05:31 -03:00
" unsupported address family " ) ;
return - 1 ;
}
if ( res - > ai_next ) {
2001-11-07 04:31:03 -04:00
freeaddrinfo ( res ) ;
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2001-07-21 15:05:31 -03:00
" wildcard resolved to multiple address " ) ;
return - 1 ;
}
2002-07-28 13:10:31 -03:00
if ( res - > ai_addrlen < addr_ret_size )
addr_ret_size = res - > ai_addrlen ;
memcpy ( addr_ret , res - > ai_addr , addr_ret_size ) ;
2001-07-21 15:05:31 -03:00
freeaddrinfo ( res ) ;
return siz ;
1991-06-25 18:36:08 -03:00
}
1991-06-27 12:51:29 -03:00
if ( name [ 0 ] = = ' < ' & & strcmp ( name , " <broadcast> " ) = = 0 ) {
2001-07-21 15:05:31 -03:00
struct sockaddr_in * sin ;
2002-12-11 09:10:57 -04:00
if ( af ! = AF_INET & & af ! = AF_UNSPEC ) {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2001-07-21 15:05:31 -03:00
" address family mismatched " ) ;
return - 1 ;
}
sin = ( struct sockaddr_in * ) addr_ret ;
memset ( ( void * ) sin , ' \0 ' , sizeof ( * sin ) ) ;
sin - > sin_family = AF_INET ;
# ifdef HAVE_SOCKADDR_SA_LEN
sin - > sin_len = sizeof ( * sin ) ;
# endif
sin - > sin_addr . s_addr = INADDR_BROADCAST ;
return sizeof ( sin - > sin_addr ) ;
1991-06-25 18:36:08 -03:00
}
2003-05-02 12:40:46 -03:00
if ( sscanf ( name , " %d.%d.%d.%d%c " , & d1 , & d2 , & d3 , & d4 , & ch ) = = 4 & &
0 < = d1 & & d1 < = 255 & & 0 < = d2 & & d2 < = 255 & &
0 < = d3 & & d3 < = 255 & & 0 < = d4 & & d4 < = 255 ) {
struct sockaddr_in * sin ;
sin = ( struct sockaddr_in * ) addr_ret ;
sin - > sin_addr . s_addr = htonl (
( ( long ) d1 < < 24 ) | ( ( long ) d2 < < 16 ) |
( ( long ) d3 < < 8 ) | ( ( long ) d4 < < 0 ) ) ;
sin - > sin_family = AF_INET ;
# ifdef HAVE_SOCKADDR_SA_LEN
sin - > sin_len = sizeof ( * sin ) ;
# endif
return 4 ;
}
2001-07-21 15:05:31 -03:00
memset ( & hints , 0 , sizeof ( hints ) ) ;
hints . ai_family = af ;
2003-05-09 04:53:18 -03:00
Py_BEGIN_ALLOW_THREADS
ACQUIRE_GETADDRINFO_LOCK
2001-07-21 15:05:31 -03:00
error = getaddrinfo ( name , NULL , & hints , & res ) ;
2001-10-25 06:04:03 -03:00
# if defined(__digital__) && defined(__unix__)
2002-06-06 23:08:35 -03:00
if ( error = = EAI_NONAME & & af = = AF_UNSPEC ) {
/* On Tru64 V5.1, numeric-to-addr conversion fails
if no address family is given . Assume IPv4 for now . */
hints . ai_family = AF_INET ;
error = getaddrinfo ( name , NULL , & hints , & res ) ;
}
2001-10-25 06:04:03 -03:00
# endif
2003-05-09 04:53:18 -03:00
Py_END_ALLOW_THREADS
RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
2001-07-21 15:05:31 -03:00
if ( error ) {
2002-06-07 00:19:37 -03:00
set_gaierror ( error ) ;
2001-07-21 15:05:31 -03:00
return - 1 ;
1991-06-27 12:51:29 -03:00
}
2002-07-28 13:10:31 -03:00
if ( res - > ai_addrlen < addr_ret_size )
addr_ret_size = res - > ai_addrlen ;
memcpy ( ( char * ) addr_ret , res - > ai_addr , addr_ret_size ) ;
2001-07-21 15:05:31 -03:00
freeaddrinfo ( res ) ;
switch ( addr_ret - > sa_family ) {
case AF_INET :
return 4 ;
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
return 16 ;
1995-01-02 15:30:30 -04:00
# endif
2001-07-21 15:05:31 -03:00
default :
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " unknown address family " ) ;
1991-06-25 18:36:08 -03:00
return - 1 ;
}
}
1991-06-27 12:51:29 -03:00
/* Create a string object representing an IP address.
This is always a string of the form ' dd . dd . dd . dd ' ( with variable
size numbers ) . */
1994-10-10 14:59:00 -03:00
static PyObject *
2001-07-21 15:05:31 -03:00
makeipaddr ( struct sockaddr * addr , int addrlen )
1991-06-27 12:51:29 -03:00
{
2001-07-21 15:05:31 -03:00
char buf [ NI_MAXHOST ] ;
int error ;
error = getnameinfo ( addr , addrlen , buf , sizeof ( buf ) , NULL , 0 ,
NI_NUMERICHOST ) ;
if ( error ) {
2002-06-07 00:19:37 -03:00
set_gaierror ( error ) ;
2001-07-21 15:05:31 -03:00
return NULL ;
}
1994-10-10 14:59:00 -03:00
return PyString_FromString ( buf ) ;
1991-06-27 12:51:29 -03:00
}
2004-06-03 06:24:42 -03:00
# ifdef USE_BLUETOOTH
/* Convert a string representation of a Bluetooth address into a numeric
address . Returns the length ( 6 ) , or raises an exception and returns - 1 if
an error occurred . */
static int
setbdaddr ( char * name , bdaddr_t * bdaddr )
{
unsigned int b0 , b1 , b2 , b3 , b4 , b5 ;
char ch ;
int n ;
n = sscanf ( name , " %X:%X:%X:%X:%X:%X%c " ,
& b5 , & b4 , & b3 , & b2 , & b1 , & b0 , & ch ) ;
if ( n = = 6 & & ( b0 | b1 | b2 | b3 | b4 | b5 ) < 256 ) {
bdaddr - > b [ 0 ] = b0 ;
bdaddr - > b [ 1 ] = b1 ;
bdaddr - > b [ 2 ] = b2 ;
bdaddr - > b [ 3 ] = b3 ;
bdaddr - > b [ 4 ] = b4 ;
bdaddr - > b [ 5 ] = b5 ;
return 6 ;
} else {
PyErr_SetString ( socket_error , " bad bluetooth address " ) ;
return - 1 ;
}
}
/* Create a string representation of the Bluetooth address. This is always a
string of the form ' XX : XX : XX : XX : XX : XX ' where XX is a two digit hexadecimal
value ( zero padded if necessary ) . */
static PyObject *
makebdaddr ( bdaddr_t * bdaddr )
{
char buf [ ( 6 * 2 ) + 5 + 1 ] ;
sprintf ( buf , " %02X:%02X:%02X:%02X:%02X:%02X " ,
bdaddr - > b [ 5 ] , bdaddr - > b [ 4 ] , bdaddr - > b [ 3 ] ,
bdaddr - > b [ 2 ] , bdaddr - > b [ 1 ] , bdaddr - > b [ 0 ] ) ;
return PyString_FromString ( buf ) ;
}
# endif
1991-06-27 12:51:29 -03:00
/* Create an object representing the given socket address,
suitable for passing it back to bind ( ) , connect ( ) etc .
The family field of the sockaddr structure is inspected
to determine what kind of address it really is . */
1991-06-25 18:36:08 -03:00
/*ARGSUSED*/
1994-10-10 14:59:00 -03:00
static PyObject *
2004-06-03 06:24:42 -03:00
makesockaddr ( int sockfd , struct sockaddr * addr , int addrlen , int proto )
1991-06-25 18:36:08 -03:00
{
1992-08-05 16:00:45 -03:00
if ( addrlen = = 0 ) {
/* No address -- may be recvfrom() from known socket */
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1992-08-05 16:00:45 -03:00
}
1998-08-04 19:53:56 -03:00
# ifdef __BEOS__
2000-04-25 18:34:53 -03:00
/* XXX: BeOS version of accept() doesn't set family correctly */
1998-08-04 19:53:56 -03:00
addr - > sa_family = AF_INET ;
# endif
1991-06-27 12:51:29 -03:00
switch ( addr - > sa_family ) {
case AF_INET :
{
2001-07-21 15:05:31 -03:00
struct sockaddr_in * a ;
PyObject * addrobj = makeipaddr ( addr , sizeof ( * a ) ) ;
1997-01-03 13:18:10 -04:00
PyObject * ret = NULL ;
if ( addrobj ) {
2001-07-21 15:05:31 -03:00
a = ( struct sockaddr_in * ) addr ;
1997-01-03 13:18:10 -04:00
ret = Py_BuildValue ( " Oi " , addrobj , ntohs ( a - > sin_port ) ) ;
Py_DECREF ( addrobj ) ;
}
1993-02-05 05:46:15 -04:00
return ret ;
1991-06-25 18:36:08 -03:00
}
1991-06-27 12:51:29 -03:00
2004-04-04 04:13:49 -03:00
# if defined(AF_UNIX)
1991-06-27 12:51:29 -03:00
case AF_UNIX :
{
1991-06-25 18:36:08 -03:00
struct sockaddr_un * a = ( struct sockaddr_un * ) addr ;
2006-04-19 08:50:27 -03:00
# ifdef linux
if ( a - > sun_path [ 0 ] = = 0 ) { /* Linux abstract namespace */
addrlen - = ( sizeof ( * a ) - sizeof ( a - > sun_path ) ) ;
return PyString_FromStringAndSize ( a - > sun_path ,
addrlen ) ;
}
else
# endif /* linux */
{
/* regular NULL-terminated string */
return PyString_FromString ( a - > sun_path ) ;
}
1991-06-25 18:36:08 -03:00
}
2001-07-21 15:05:31 -03:00
# endif /* AF_UNIX */
2006-01-14 14:12:57 -04:00
# if defined(AF_NETLINK)
case AF_NETLINK :
{
struct sockaddr_nl * a = ( struct sockaddr_nl * ) addr ;
2006-01-15 03:49:20 -04:00
return Py_BuildValue ( " II " , a - > nl_pid , a - > nl_groups ) ;
2006-01-14 14:12:57 -04:00
}
# endif /* AF_NETLINK */
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
{
struct sockaddr_in6 * a ;
PyObject * addrobj = makeipaddr ( addr , sizeof ( * a ) ) ;
PyObject * ret = NULL ;
if ( addrobj ) {
a = ( struct sockaddr_in6 * ) addr ;
2002-06-06 23:08:35 -03:00
ret = Py_BuildValue ( " Oiii " ,
addrobj ,
ntohs ( a - > sin6_port ) ,
a - > sin6_flowinfo ,
a - > sin6_scope_id ) ;
2001-07-21 15:05:31 -03:00
Py_DECREF ( addrobj ) ;
}
return ret ;
}
2001-02-01 23:23:09 -04:00
# endif
1991-06-27 12:51:29 -03:00
2004-06-03 06:24:42 -03:00
# ifdef USE_BLUETOOTH
case AF_BLUETOOTH :
switch ( proto ) {
case BTPROTO_L2CAP :
{
struct sockaddr_l2 * a = ( struct sockaddr_l2 * ) addr ;
PyObject * addrobj = makebdaddr ( & _BT_L2_MEMB ( a , bdaddr ) ) ;
PyObject * ret = NULL ;
if ( addrobj ) {
ret = Py_BuildValue ( " Oi " ,
addrobj ,
_BT_L2_MEMB ( a , psm ) ) ;
Py_DECREF ( addrobj ) ;
}
return ret ;
}
case BTPROTO_RFCOMM :
{
struct sockaddr_rc * a = ( struct sockaddr_rc * ) addr ;
PyObject * addrobj = makebdaddr ( & _BT_RC_MEMB ( a , bdaddr ) ) ;
PyObject * ret = NULL ;
if ( addrobj ) {
ret = Py_BuildValue ( " Oi " ,
addrobj ,
_BT_RC_MEMB ( a , channel ) ) ;
Py_DECREF ( addrobj ) ;
}
return ret ;
}
2007-02-14 06:07:37 -04:00
case BTPROTO_HCI :
{
struct sockaddr_hci * a = ( struct sockaddr_hci * ) addr ;
PyObject * ret = NULL ;
ret = Py_BuildValue ( " i " , _BT_HCI_MEMB ( a , dev ) ) ;
return ret ;
}
2004-06-03 06:24:42 -03:00
# if !defined(__FreeBSD__)
case BTPROTO_SCO :
{
struct sockaddr_sco * a = ( struct sockaddr_sco * ) addr ;
return makebdaddr ( & _BT_SCO_MEMB ( a , bdaddr ) ) ;
}
# endif
}
# endif
2001-08-10 17:29:40 -03:00
# ifdef HAVE_NETPACKET_PACKET_H
2001-02-01 23:23:09 -04:00
case AF_PACKET :
{
struct sockaddr_ll * a = ( struct sockaddr_ll * ) addr ;
char * ifname = " " ;
struct ifreq ifr ;
2001-02-02 15:55:17 -04:00
/* need to look up interface name give index */
if ( a - > sll_ifindex ) {
2001-02-01 23:23:09 -04:00
ifr . ifr_ifindex = a - > sll_ifindex ;
2001-02-02 15:55:17 -04:00
if ( ioctl ( sockfd , SIOCGIFNAME , & ifr ) = = 0 )
2001-02-01 23:23:09 -04:00
ifname = ifr . ifr_name ;
}
2002-06-06 23:08:35 -03:00
return Py_BuildValue ( " shbhs# " ,
ifname ,
ntohs ( a - > sll_protocol ) ,
a - > sll_pkttype ,
a - > sll_hatype ,
a - > sll_addr ,
a - > sll_halen ) ;
2001-02-01 23:23:09 -04:00
}
# endif
2001-03-02 02:34:14 -04:00
2008-01-07 12:12:44 -04:00
# ifdef HAVE_LINUX_TIPC_H
case AF_TIPC :
{
struct sockaddr_tipc * a = ( struct sockaddr_tipc * ) addr ;
if ( a - > addrtype = = TIPC_ADDR_NAMESEQ ) {
return Py_BuildValue ( " IIIII " ,
a - > addrtype ,
a - > addr . nameseq . type ,
a - > addr . nameseq . lower ,
a - > addr . nameseq . upper ,
a - > scope ) ;
} else if ( a - > addrtype = = TIPC_ADDR_NAME ) {
return Py_BuildValue ( " IIIII " ,
a - > addrtype ,
a - > addr . name . name . type ,
a - > addr . name . name . instance ,
a - > addr . name . name . instance ,
a - > scope ) ;
} else if ( a - > addrtype = = TIPC_ADDR_ID ) {
return Py_BuildValue ( " IIIII " ,
a - > addrtype ,
a - > addr . id . node ,
a - > addr . id . ref ,
0 ,
a - > scope ) ;
} else {
PyErr_SetString ( PyExc_TypeError ,
" Invalid address type " ) ;
return NULL ;
}
}
# endif
1991-06-27 12:51:29 -03:00
/* More cases here... */
default :
1997-05-07 14:41:48 -03:00
/* If we don't know the address family, don't raise an
exception - - return it as a tuple . */
return Py_BuildValue ( " is# " ,
addr - > sa_family ,
addr - > sa_data ,
sizeof ( addr - > sa_data ) ) ;
1992-08-05 16:00:45 -03:00
1991-06-27 12:51:29 -03:00
}
1991-06-25 18:36:08 -03:00
}
1991-06-27 12:51:29 -03:00
/* Parse a socket address argument according to the socket object's
address family . Return 1 if the address was in the proper format ,
0 of not . The address is returned through addr_ret , its length
through len_ret . */
1991-06-25 18:36:08 -03:00
static int
2001-03-02 02:34:14 -04:00
getsockaddrarg ( PySocketSockObject * s , PyObject * args ,
2006-12-03 07:23:45 -04:00
struct sockaddr * addr_ret , int * len_ret )
1991-06-25 18:36:08 -03:00
{
1991-06-27 12:51:29 -03:00
switch ( s - > sock_family ) {
2004-04-04 04:13:49 -03:00
# if defined(AF_UNIX)
1991-06-27 12:51:29 -03:00
case AF_UNIX :
{
1995-01-02 15:30:30 -04:00
struct sockaddr_un * addr ;
1992-08-05 16:58:53 -03:00
char * path ;
1991-06-25 18:36:08 -03:00
int len ;
1998-10-07 23:25:24 -03:00
if ( ! PyArg_Parse ( args , " t# " , & path , & len ) )
1991-06-25 18:36:08 -03:00
return 0 ;
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_un * ) addr_ret ;
2006-04-19 08:50:27 -03:00
# ifdef linux
if ( len > 0 & & path [ 0 ] = = 0 ) {
/* Linux abstract namespace extension */
if ( len > sizeof addr - > sun_path ) {
PyErr_SetString ( socket_error ,
" AF_UNIX path too long " ) ;
return 0 ;
}
}
else
# endif /* linux */
{
/* regular NULL-terminated string */
if ( len > = sizeof addr - > sun_path ) {
PyErr_SetString ( socket_error ,
" AF_UNIX path too long " ) ;
return 0 ;
}
addr - > sun_path [ len ] = 0 ;
1991-06-27 12:51:29 -03:00
}
2001-07-21 15:05:31 -03:00
addr - > sun_family = s - > sock_family ;
1995-01-02 15:30:30 -04:00
memcpy ( addr - > sun_path , path , len ) ;
2004-04-11 09:03:57 -03:00
# if defined(PYOS_OS2)
* len_ret = sizeof ( * addr ) ;
# else
1996-06-11 15:36:33 -03:00
* len_ret = len + sizeof ( * addr ) - sizeof ( addr - > sun_path ) ;
2004-04-11 09:03:57 -03:00
# endif
1991-06-25 18:36:08 -03:00
return 1 ;
}
1994-08-01 08:34:53 -03:00
# endif /* AF_UNIX */
1991-06-25 18:36:08 -03:00
2006-01-14 14:12:57 -04:00
# if defined(AF_NETLINK)
case AF_NETLINK :
{
struct sockaddr_nl * addr ;
int pid , groups ;
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_nl * ) addr_ret ;
2006-01-14 14:12:57 -04:00
if ( ! PyTuple_Check ( args ) ) {
PyErr_Format (
PyExc_TypeError ,
" getsockaddrarg: "
" AF_NETLINK address must be tuple, not %.500s " ,
2007-12-18 22:37:44 -04:00
Py_TYPE ( args ) - > tp_name ) ;
2006-01-14 14:12:57 -04:00
return 0 ;
}
if ( ! PyArg_ParseTuple ( args , " II:getsockaddrarg " , & pid , & groups ) )
return 0 ;
addr - > nl_family = AF_NETLINK ;
addr - > nl_pid = pid ;
addr - > nl_groups = groups ;
* len_ret = sizeof ( * addr ) ;
return 1 ;
}
# endif
1991-06-27 12:51:29 -03:00
case AF_INET :
{
1995-01-02 15:30:30 -04:00
struct sockaddr_in * addr ;
1992-08-05 16:58:53 -03:00
char * host ;
2003-08-07 08:55:15 -03:00
int port , result ;
2000-12-01 09:13:11 -04:00
if ( ! PyTuple_Check ( args ) ) {
2002-06-06 23:08:35 -03:00
PyErr_Format (
PyExc_TypeError ,
" getsockaddrarg: "
" AF_INET address must be tuple, not %.500s " ,
2007-12-18 22:37:44 -04:00
Py_TYPE ( args ) - > tp_name ) ;
2000-12-01 09:13:11 -04:00
return 0 ;
}
2006-05-26 09:03:27 -03:00
if ( ! PyArg_ParseTuple ( args , " eti:getsockaddrarg " ,
2003-04-18 07:39:54 -03:00
" idna " , & host , & port ) )
1991-06-25 18:36:08 -03:00
return 0 ;
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_in * ) addr_ret ;
2006-05-26 09:03:27 -03:00
result = setipaddr ( host , ( struct sockaddr * ) addr ,
2003-08-07 08:55:15 -03:00
sizeof ( * addr ) , AF_INET ) ;
PyMem_Free ( host ) ;
if ( result < 0 )
1991-06-25 18:36:08 -03:00
return 0 ;
1995-01-02 15:30:30 -04:00
addr - > sin_family = AF_INET ;
1997-04-09 16:24:53 -03:00
addr - > sin_port = htons ( ( short ) port ) ;
1995-01-02 15:30:30 -04:00
* len_ret = sizeof * addr ;
1991-06-25 18:36:08 -03:00
return 1 ;
}
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
{
struct sockaddr_in6 * addr ;
char * host ;
2003-08-07 08:55:15 -03:00
int port , flowinfo , scope_id , result ;
2001-07-21 15:05:31 -03:00
flowinfo = scope_id = 0 ;
2006-04-25 12:08:10 -03:00
if ( ! PyTuple_Check ( args ) ) {
PyErr_Format (
PyExc_TypeError ,
" getsockaddrarg: "
" AF_INET6 address must be tuple, not %.500s " ,
2007-12-18 22:37:44 -04:00
Py_TYPE ( args ) - > tp_name ) ;
2006-04-25 12:08:10 -03:00
return 0 ;
}
2006-05-26 09:03:27 -03:00
if ( ! PyArg_ParseTuple ( args , " eti|ii " ,
2003-04-18 07:39:54 -03:00
" idna " , & host , & port , & flowinfo ,
2002-06-06 23:08:35 -03:00
& scope_id ) ) {
2001-07-21 15:05:31 -03:00
return 0 ;
}
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_in6 * ) addr_ret ;
2006-05-26 09:03:27 -03:00
result = setipaddr ( host , ( struct sockaddr * ) addr ,
2003-08-07 08:55:15 -03:00
sizeof ( * addr ) , AF_INET6 ) ;
PyMem_Free ( host ) ;
if ( result < 0 )
2001-07-21 15:05:31 -03:00
return 0 ;
addr - > sin6_family = s - > sock_family ;
addr - > sin6_port = htons ( ( short ) port ) ;
addr - > sin6_flowinfo = flowinfo ;
addr - > sin6_scope_id = scope_id ;
* len_ret = sizeof * addr ;
return 1 ;
}
# endif
2004-02-02 02:05:24 -04:00
# ifdef USE_BLUETOOTH
2004-01-31 08:34:17 -04:00
case AF_BLUETOOTH :
{
2004-06-03 06:24:42 -03:00
switch ( s - > sock_proto ) {
case BTPROTO_L2CAP :
2004-01-31 08:34:17 -04:00
{
2006-12-03 07:23:45 -04:00
struct sockaddr_l2 * addr ;
2004-06-03 06:24:42 -03:00
char * straddr ;
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_l2 * ) addr_ret ;
2004-06-03 06:24:42 -03:00
_BT_L2_MEMB ( addr , family ) = AF_BLUETOOTH ;
if ( ! PyArg_ParseTuple ( args , " si " , & straddr ,
& _BT_L2_MEMB ( addr , psm ) ) ) {
PyErr_SetString ( socket_error , " getsockaddrarg: "
" wrong format " ) ;
return 0 ;
2004-01-31 08:34:17 -04:00
}
2004-06-03 06:24:42 -03:00
if ( setbdaddr ( straddr , & _BT_L2_MEMB ( addr , bdaddr ) ) < 0 )
return 0 ;
2004-01-31 08:34:17 -04:00
2004-06-03 06:24:42 -03:00
* len_ret = sizeof * addr ;
return 1 ;
}
case BTPROTO_RFCOMM :
{
2006-12-03 07:23:45 -04:00
struct sockaddr_rc * addr ;
2004-06-03 06:24:42 -03:00
char * straddr ;
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_rc * ) addr_ret ;
2004-06-03 06:24:42 -03:00
_BT_RC_MEMB ( addr , family ) = AF_BLUETOOTH ;
if ( ! PyArg_ParseTuple ( args , " si " , & straddr ,
& _BT_RC_MEMB ( addr , channel ) ) ) {
PyErr_SetString ( socket_error , " getsockaddrarg: "
" wrong format " ) ;
return 0 ;
2004-01-31 08:34:17 -04:00
}
2004-06-03 06:24:42 -03:00
if ( setbdaddr ( straddr , & _BT_RC_MEMB ( addr , bdaddr ) ) < 0 )
return 0 ;
2004-01-31 08:34:17 -04:00
2004-06-03 06:24:42 -03:00
* len_ret = sizeof * addr ;
return 1 ;
}
2007-02-14 06:07:37 -04:00
case BTPROTO_HCI :
{
2007-02-14 07:30:07 -04:00
struct sockaddr_hci * addr = ( struct sockaddr_hci * ) addr_ret ;
2007-02-14 06:07:37 -04:00
_BT_HCI_MEMB ( addr , family ) = AF_BLUETOOTH ;
if ( ! PyArg_ParseTuple ( args , " i " , & _BT_HCI_MEMB ( addr , dev ) ) ) {
PyErr_SetString ( socket_error , " getsockaddrarg: "
" wrong format " ) ;
return 0 ;
}
* len_ret = sizeof * addr ;
return 1 ;
}
2004-06-03 06:24:42 -03:00
# if !defined(__FreeBSD__)
case BTPROTO_SCO :
{
2006-12-03 07:23:45 -04:00
struct sockaddr_sco * addr ;
2004-06-03 06:24:42 -03:00
char * straddr ;
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_sco * ) addr_ret ;
2004-06-03 06:24:42 -03:00
_BT_SCO_MEMB ( addr , family ) = AF_BLUETOOTH ;
straddr = PyString_AsString ( args ) ;
if ( straddr = = NULL ) {
PyErr_SetString ( socket_error , " getsockaddrarg: "
" wrong format " ) ;
2004-01-31 08:34:17 -04:00
return 0 ;
}
2004-06-03 06:24:42 -03:00
if ( setbdaddr ( straddr , & _BT_SCO_MEMB ( addr , bdaddr ) ) < 0 )
return 0 ;
* len_ret = sizeof * addr ;
return 1 ;
}
# endif
default :
PyErr_SetString ( socket_error , " getsockaddrarg: unknown Bluetooth protocol " ) ;
return 0 ;
2004-01-31 08:34:17 -04:00
}
}
# endif
2001-08-10 17:29:40 -03:00
# ifdef HAVE_NETPACKET_PACKET_H
2001-02-01 23:23:09 -04:00
case AF_PACKET :
{
struct sockaddr_ll * addr ;
struct ifreq ifr ;
char * interfaceName ;
int protoNumber ;
int hatype = 0 ;
int pkttype = 0 ;
2004-07-10 20:39:35 -03:00
char * haddr = NULL ;
unsigned int halen = 0 ;
2001-03-02 02:34:14 -04:00
2006-04-25 12:08:10 -03:00
if ( ! PyTuple_Check ( args ) ) {
PyErr_Format (
PyExc_TypeError ,
" getsockaddrarg: "
" AF_PACKET address must be tuple, not %.500s " ,
2007-12-18 22:37:44 -04:00
Py_TYPE ( args ) - > tp_name ) ;
2006-04-25 12:08:10 -03:00
return 0 ;
}
2004-07-10 20:39:35 -03:00
if ( ! PyArg_ParseTuple ( args , " si|iis# " , & interfaceName ,
& protoNumber , & pkttype , & hatype ,
& haddr , & halen ) )
2001-02-01 23:23:09 -04:00
return 0 ;
strncpy ( ifr . ifr_name , interfaceName , sizeof ( ifr . ifr_name ) ) ;
ifr . ifr_name [ ( sizeof ( ifr . ifr_name ) ) - 1 ] = ' \0 ' ;
2001-02-02 15:55:17 -04:00
if ( ioctl ( s - > sock_fd , SIOCGIFINDEX , & ifr ) < 0 ) {
2002-02-16 14:23:30 -04:00
s - > errorhandler ( ) ;
2001-02-01 23:23:09 -04:00
return 0 ;
2001-02-02 15:55:17 -04:00
}
2004-07-10 20:39:35 -03:00
if ( halen > 8 ) {
PyErr_SetString ( PyExc_ValueError ,
" Hardware address must be 8 bytes or less " ) ;
return 0 ;
}
2006-12-03 07:23:45 -04:00
addr = ( struct sockaddr_ll * ) addr_ret ;
addr - > sll_family = AF_PACKET ;
addr - > sll_protocol = htons ( ( short ) protoNumber ) ;
addr - > sll_ifindex = ifr . ifr_ifindex ;
addr - > sll_pkttype = pkttype ;
addr - > sll_hatype = hatype ;
2004-07-10 20:39:35 -03:00
if ( halen ! = 0 ) {
memcpy ( & addr - > sll_addr , haddr , halen ) ;
}
addr - > sll_halen = halen ;
2001-02-01 23:23:09 -04:00
* len_ret = sizeof * addr ;
return 1 ;
}
2001-03-02 02:34:14 -04:00
# endif
2008-01-07 12:12:44 -04:00
# ifdef HAVE_LINUX_TIPC_H
case AF_TIPC :
{
unsigned int atype , v1 , v2 , v3 ;
unsigned int scope = TIPC_CLUSTER_SCOPE ;
struct sockaddr_tipc * addr ;
if ( ! PyTuple_Check ( args ) ) {
PyErr_Format (
PyExc_TypeError ,
" getsockaddrarg: "
" AF_TIPC address must be tuple, not %.500s " ,
Py_TYPE ( args ) - > tp_name ) ;
return 0 ;
}
if ( ! PyArg_ParseTuple ( args ,
" IIII|I;Invalid TIPC address format " ,
& atype , & v1 , & v2 , & v3 , & scope ) )
return 0 ;
addr = ( struct sockaddr_tipc * ) addr_ret ;
memset ( addr , 0 , sizeof ( struct sockaddr_tipc ) ) ;
addr - > family = AF_TIPC ;
addr - > scope = scope ;
addr - > addrtype = atype ;
if ( atype = = TIPC_ADDR_NAMESEQ ) {
addr - > addr . nameseq . type = v1 ;
addr - > addr . nameseq . lower = v2 ;
addr - > addr . nameseq . upper = v3 ;
} else if ( atype = = TIPC_ADDR_NAME ) {
addr - > addr . name . name . type = v1 ;
addr - > addr . name . name . instance = v2 ;
} else if ( atype = = TIPC_ADDR_ID ) {
addr - > addr . id . node = v1 ;
addr - > addr . id . ref = v2 ;
} else {
/* Shouldn't happen */
PyErr_SetString ( PyExc_TypeError , " Invalid address type " ) ;
return 0 ;
}
* len_ret = sizeof ( * addr ) ;
return 1 ;
}
# endif
1991-06-27 12:51:29 -03:00
/* More cases here... */
default :
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " getsockaddrarg: bad family " ) ;
1991-06-27 12:51:29 -03:00
return 0 ;
}
1991-06-25 18:36:08 -03:00
}
1991-06-27 12:51:29 -03:00
2001-03-02 02:34:14 -04:00
/* Get the address length according to the socket object's address family.
1992-06-12 07:39:36 -03:00
Return 1 if the family is known , 0 otherwise . The length is returned
through len_ret . */
static int
2000-07-11 20:00:12 -03:00
getsockaddrlen ( PySocketSockObject * s , socklen_t * len_ret )
1992-06-12 07:39:36 -03:00
{
switch ( s - > sock_family ) {
2004-04-04 04:13:49 -03:00
# if defined(AF_UNIX)
1992-06-12 07:39:36 -03:00
case AF_UNIX :
{
* len_ret = sizeof ( struct sockaddr_un ) ;
return 1 ;
}
1994-08-01 08:34:53 -03:00
# endif /* AF_UNIX */
2006-01-14 14:12:57 -04:00
# if defined(AF_NETLINK)
case AF_NETLINK :
{
* len_ret = sizeof ( struct sockaddr_nl ) ;
return 1 ;
}
# endif
1992-06-12 07:39:36 -03:00
case AF_INET :
{
* len_ret = sizeof ( struct sockaddr_in ) ;
return 1 ;
}
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
{
* len_ret = sizeof ( struct sockaddr_in6 ) ;
return 1 ;
}
# endif
2004-02-02 02:05:24 -04:00
# ifdef USE_BLUETOOTH
2004-01-31 08:34:17 -04:00
case AF_BLUETOOTH :
{
switch ( s - > sock_proto )
{
2004-06-03 06:24:42 -03:00
case BTPROTO_L2CAP :
* len_ret = sizeof ( struct sockaddr_l2 ) ;
return 1 ;
case BTPROTO_RFCOMM :
* len_ret = sizeof ( struct sockaddr_rc ) ;
return 1 ;
2007-02-14 06:07:37 -04:00
case BTPROTO_HCI :
* len_ret = sizeof ( struct sockaddr_hci ) ;
return 1 ;
2004-02-02 02:05:24 -04:00
# if !defined(__FreeBSD__)
2004-06-03 06:24:42 -03:00
case BTPROTO_SCO :
* len_ret = sizeof ( struct sockaddr_sco ) ;
return 1 ;
2004-02-02 02:05:24 -04:00
# endif
2004-06-03 06:24:42 -03:00
default :
PyErr_SetString ( socket_error , " getsockaddrlen: "
" unknown BT protocol " ) ;
return 0 ;
2004-01-31 08:34:17 -04:00
}
}
# endif
2001-08-10 17:29:40 -03:00
# ifdef HAVE_NETPACKET_PACKET_H
2001-02-01 23:23:09 -04:00
case AF_PACKET :
{
* len_ret = sizeof ( struct sockaddr_ll ) ;
return 1 ;
}
# endif
2001-03-02 02:34:14 -04:00
2008-01-07 12:12:44 -04:00
# ifdef HAVE_LINUX_TIPC_H
case AF_TIPC :
{
* len_ret = sizeof ( struct sockaddr_tipc ) ;
return 1 ;
}
# endif
1992-06-12 07:39:36 -03:00
/* More cases here... */
default :
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " getsockaddrlen: bad family " ) ;
1992-06-12 07:39:36 -03:00
return 0 ;
}
}
1991-06-27 12:51:29 -03:00
/* s.accept() method */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_accept ( PySocketSockObject * s )
1991-06-25 18:36:08 -03:00
{
2005-09-14 15:09:42 -03:00
sock_addr_t addrbuf ;
2000-06-29 23:46:07 -03:00
SOCKET_T newfd ;
2000-04-24 12:16:03 -03:00
socklen_t addrlen ;
1997-01-03 13:18:10 -04:00
PyObject * sock = NULL ;
PyObject * addr = NULL ;
PyObject * res = NULL ;
2003-06-29 00:08:05 -03:00
int timeout ;
1997-01-03 13:18:10 -04:00
1992-06-12 07:39:36 -03:00
if ( ! getsockaddrlen ( s , & addrlen ) )
return NULL ;
2005-09-14 15:09:42 -03:00
memset ( & addrbuf , 0 , addrlen ) ;
2002-06-06 18:08:16 -03:00
2003-06-29 00:08:05 -03:00
# ifdef MS_WINDOWS
newfd = INVALID_SOCKET ;
# else
newfd = - 1 ;
# endif
2006-02-07 03:04:46 -04:00
if ( ! IS_SELECTABLE ( s ) )
return select_error ( ) ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 0 ) ;
if ( ! timeout )
2006-12-03 07:23:45 -04:00
newfd = accept ( s - > sock_fd , SAS2SA ( & addrbuf ) , & addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
return NULL ;
}
2000-06-29 23:46:07 -03:00
# ifdef MS_WINDOWS
if ( newfd = = INVALID_SOCKET )
# else
1991-06-25 18:36:08 -03:00
if ( newfd < 0 )
2000-06-29 23:46:07 -03:00
# endif
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1997-01-03 13:18:10 -04:00
1991-06-27 12:51:29 -03:00
/* Create the new object with unspecified family,
to avoid calls to bind ( ) etc . on it . */
2002-06-07 00:19:37 -03:00
sock = ( PyObject * ) new_sockobject ( newfd ,
s - > sock_family ,
s - > sock_type ,
s - > sock_proto ) ;
2002-06-06 18:08:16 -03:00
1997-01-03 13:18:10 -04:00
if ( sock = = NULL ) {
2000-04-21 17:33:00 -03:00
SOCKETCLOSE ( newfd ) ;
1997-01-03 13:18:10 -04:00
goto finally ;
}
2006-12-03 07:23:45 -04:00
addr = makesockaddr ( s - > sock_fd , SAS2SA ( & addrbuf ) ,
2004-06-03 06:24:42 -03:00
addrlen , s - > sock_proto ) ;
2001-02-02 15:55:17 -04:00
if ( addr = = NULL )
1997-01-03 13:18:10 -04:00
goto finally ;
2003-10-12 16:09:37 -03:00
res = PyTuple_Pack ( 2 , sock , addr ) ;
1997-01-03 13:18:10 -04:00
2002-06-06 18:08:16 -03:00
finally :
1994-10-10 14:59:00 -03:00
Py_XDECREF ( sock ) ;
Py_XDECREF ( addr ) ;
1991-06-25 18:36:08 -03:00
return res ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( accept_doc ,
1998-07-07 17:45:43 -03:00
" accept() -> (socket object, address info) \n \
\ n \
Wait for an incoming connection . Return a new socket representing the \ n \
connection , and the address of the client . For IP sockets , the address \ n \
2002-06-13 17:33:02 -03:00
info is a pair ( hostaddr , port ) . " ) ;
1998-07-07 17:45:43 -03:00
2002-06-13 12:07:44 -03:00
/* s.setblocking(flag) method. Argument:
False - - non - blocking mode ; same as settimeout ( 0 )
True - - blocking mode ; same as settimeout ( None )
*/
1994-09-07 11:32:49 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_setblocking ( PySocketSockObject * s , PyObject * arg )
1994-09-07 11:32:49 -03:00
{
int block ;
2002-06-06 18:08:16 -03:00
2001-10-11 13:36:35 -03:00
block = PyInt_AsLong ( arg ) ;
if ( block = = - 1 & & PyErr_Occurred ( ) )
1994-09-07 11:32:49 -03:00
return NULL ;
2002-06-06 18:08:16 -03:00
2002-06-13 12:07:44 -03:00
s - > sock_timeout = block ? - 1.0 : 0.0 ;
2002-06-07 00:36:20 -03:00
internal_setblocking ( s , block ) ;
1994-09-07 11:32:49 -03:00
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1994-09-07 11:32:49 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( setblocking_doc ,
1998-07-07 17:45:43 -03:00
" setblocking(flag) \n \
\ n \
Set the socket to blocking ( flag is true ) or non - blocking ( false ) . \ n \
2002-06-13 12:07:44 -03:00
setblocking ( True ) is equivalent to settimeout ( None ) ; \ n \
2002-06-13 17:33:02 -03:00
setblocking ( False ) is equivalent to settimeout ( 0.0 ) . " );
2002-06-13 12:07:44 -03:00
/* s.settimeout(timeout) method. Argument:
None - - no timeout , blocking mode ; same as setblocking ( True )
0.0 - - non - blocking mode ; same as setblocking ( False )
> 0 - - timeout mode ; operations time out after timeout seconds
< 0 - - illegal ; raises an exception
*/
2002-06-06 18:08:16 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_settimeout ( PySocketSockObject * s , PyObject * arg )
2002-06-06 18:08:16 -03:00
{
2002-06-13 12:07:44 -03:00
double timeout ;
2002-06-06 18:08:16 -03:00
if ( arg = = Py_None )
2002-06-13 12:07:44 -03:00
timeout = - 1.0 ;
2002-06-06 18:08:16 -03:00
else {
2002-06-13 12:07:44 -03:00
timeout = PyFloat_AsDouble ( arg ) ;
if ( timeout < 0.0 ) {
2002-06-06 18:08:16 -03:00
if ( ! PyErr_Occurred ( ) )
PyErr_SetString ( PyExc_ValueError ,
2002-06-13 12:07:44 -03:00
" Timeout value out of range " ) ;
2002-06-06 18:08:16 -03:00
return NULL ;
}
}
2002-06-13 12:07:44 -03:00
s - > sock_timeout = timeout ;
internal_setblocking ( s , timeout < 0.0 ) ;
2002-06-06 18:08:16 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( settimeout_doc ,
2002-06-06 23:08:35 -03:00
" settimeout(timeout) \n \
2002-06-06 18:08:16 -03:00
\ n \
2002-06-13 12:07:44 -03:00
Set a timeout on socket operations . ' timeout ' can be a float , \ n \
giving in seconds , or None . Setting a timeout of None disables \ n \
the timeout feature and is equivalent to setblocking ( 1 ) . \ n \
2002-06-13 17:33:02 -03:00
Setting a timeout of zero is the same as setblocking ( 0 ) . " ) ;
2002-06-06 23:08:35 -03:00
/* s.gettimeout() method.
Returns the timeout associated with a socket . */
2002-06-06 18:08:16 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_gettimeout ( PySocketSockObject * s )
2002-06-06 18:08:16 -03:00
{
if ( s - > sock_timeout < 0.0 ) {
Py_INCREF ( Py_None ) ;
return Py_None ;
}
else
return PyFloat_FromDouble ( s - > sock_timeout ) ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( gettimeout_doc ,
2002-08-08 17:37:08 -03:00
" gettimeout() -> timeout \n \
2002-06-06 18:08:16 -03:00
\ n \
Returns the timeout in floating seconds associated with socket \ n \
operations . A timeout of None indicates that timeouts on socket \ n \
2002-06-13 17:33:02 -03:00
operations are disabled . " );
1994-09-07 11:32:49 -03:00
2001-03-02 02:34:14 -04:00
# ifdef RISCOS
/* s.sleeptaskw(1 | 0) method */
static PyObject *
2003-05-10 04:36:56 -03:00
sock_sleeptaskw ( PySocketSockObject * s , PyObject * arg )
2001-03-02 02:34:14 -04:00
{
2002-06-06 18:08:16 -03:00
int block ;
2003-05-10 04:36:56 -03:00
block = PyInt_AsLong ( arg ) ;
if ( block = = - 1 & & PyErr_Occurred ( ) )
2002-06-06 18:08:16 -03:00
return NULL ;
Py_BEGIN_ALLOW_THREADS
socketioctl ( s - > sock_fd , 0x80046679 , ( u_long * ) & block ) ;
Py_END_ALLOW_THREADS
Py_INCREF ( Py_None ) ;
return Py_None ;
2001-03-02 02:34:14 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( sleeptaskw_doc ,
2001-03-02 02:34:14 -04:00
" sleeptaskw(flag) \n \
\ n \
2002-06-13 17:33:02 -03:00
Allow sleeps in taskwindows . " );
2001-03-02 02:34:14 -04:00
# endif
1992-09-08 06:05:33 -03:00
/* s.setsockopt() method.
With an integer third argument , sets an integer option .
With a string third argument , sets an option from a buffer ;
use optional built - in module ' struct ' to encode the string . */
1992-06-05 12:11:30 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_setsockopt ( PySocketSockObject * s , PyObject * args )
1992-06-05 12:11:30 -03:00
{
int level ;
int optname ;
int res ;
1992-09-08 06:05:33 -03:00
char * buf ;
int buflen ;
int flag ;
1992-06-05 12:11:30 -03:00
2000-03-24 16:56:56 -04:00
if ( PyArg_ParseTuple ( args , " iii:setsockopt " ,
& level , & optname , & flag ) ) {
1992-09-08 06:05:33 -03:00
buf = ( char * ) & flag ;
buflen = sizeof flag ;
}
else {
1994-10-10 14:59:00 -03:00
PyErr_Clear ( ) ;
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " iis#:setsockopt " ,
& level , & optname , & buf , & buflen ) )
1992-09-08 06:05:33 -03:00
return NULL ;
}
2000-07-25 09:56:38 -03:00
res = setsockopt ( s - > sock_fd , level , optname , ( void * ) buf , buflen ) ;
1992-06-05 12:11:30 -03:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1992-06-05 12:11:30 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( setsockopt_doc ,
1998-07-07 17:45:43 -03:00
" setsockopt(level, option, value) \n \
\ n \
Set a socket option . See the Unix manual for level and option . \ n \
2002-06-13 17:33:02 -03:00
The value argument can either be an integer or a string . " );
1998-07-07 17:45:43 -03:00
1992-06-05 12:11:30 -03:00
1992-09-08 06:05:33 -03:00
/* s.getsockopt() method.
With two arguments , retrieves an integer option .
With a third integer argument , retrieves a string buffer of that size ;
use optional built - in module ' struct ' to decode the string . */
1992-06-05 12:11:30 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_getsockopt ( PySocketSockObject * s , PyObject * args )
1992-06-05 12:11:30 -03:00
{
int level ;
int optname ;
int res ;
1994-10-10 14:59:00 -03:00
PyObject * buf ;
2000-04-24 12:16:03 -03:00
socklen_t buflen = 0 ;
1992-06-05 12:11:30 -03:00
1998-08-04 19:53:56 -03:00
# ifdef __BEOS__
2001-05-11 17:12:26 -03:00
/* We have incomplete socket support. */
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " getsockopt not supported " ) ;
1998-08-04 19:53:56 -03:00
return NULL ;
# else
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " ii|i:getsockopt " ,
& level , & optname , & buflen ) )
1996-06-20 13:25:29 -03:00
return NULL ;
2001-03-02 02:34:14 -04:00
1996-06-20 13:25:29 -03:00
if ( buflen = = 0 ) {
1992-09-08 06:05:33 -03:00
int flag = 0 ;
2000-04-24 12:16:03 -03:00
socklen_t flagsize = sizeof flag ;
1993-11-23 13:53:17 -04:00
res = getsockopt ( s - > sock_fd , level , optname ,
2000-07-25 09:56:38 -03:00
( void * ) & flag , & flagsize ) ;
1992-09-08 06:05:33 -03:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
return PyInt_FromLong ( flag ) ;
1992-09-08 06:05:33 -03:00
}
2002-12-06 08:48:53 -04:00
# ifdef __VMS
2006-07-09 22:18:57 -03:00
/* socklen_t is unsigned so no negative test is needed,
test buflen = = 0 is previously done */
2002-12-06 08:48:53 -04:00
if ( buflen > 1024 ) {
# else
1992-09-08 06:05:33 -03:00
if ( buflen < = 0 | | buflen > 1024 ) {
2002-12-06 08:48:53 -04:00
# endif
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
1997-01-03 13:18:10 -04:00
" getsockopt buflen out of range " ) ;
1992-09-08 06:05:33 -03:00
return NULL ;
}
1994-10-10 14:59:00 -03:00
buf = PyString_FromStringAndSize ( ( char * ) NULL , buflen ) ;
1992-09-08 06:05:33 -03:00
if ( buf = = NULL )
return NULL ;
1993-11-23 13:53:17 -04:00
res = getsockopt ( s - > sock_fd , level , optname ,
2001-05-11 17:12:26 -03:00
( void * ) PyString_AS_STRING ( buf ) , & buflen ) ;
1992-09-08 06:05:33 -03:00
if ( res < 0 ) {
1994-10-10 14:59:00 -03:00
Py_DECREF ( buf ) ;
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1992-09-08 06:05:33 -03:00
}
1994-10-10 14:59:00 -03:00
_PyString_Resize ( & buf , buflen ) ;
1992-09-08 06:05:33 -03:00
return buf ;
1998-08-04 19:53:56 -03:00
# endif /* __BEOS__ */
1992-06-05 12:11:30 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getsockopt_doc ,
1998-07-07 17:45:43 -03:00
" getsockopt(level, option[, buffersize]) -> value \n \
\ n \
Get a socket option . See the Unix manual for level and option . \ n \
If a nonzero buffersize argument is given , the return value is a \ n \
2002-06-13 17:33:02 -03:00
string of that length ; otherwise it is an integer . " );
1998-07-07 17:45:43 -03:00
1992-06-05 12:11:30 -03:00
2000-07-01 00:40:12 -03:00
/* s.bind(sockaddr) method */
1991-06-27 12:51:29 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_bind ( PySocketSockObject * s , PyObject * addro )
1991-06-25 18:36:08 -03:00
{
2006-12-03 07:23:45 -04:00
sock_addr_t addrbuf ;
1991-06-25 18:36:08 -03:00
int addrlen ;
1992-08-05 16:58:53 -03:00
int res ;
2001-10-11 13:36:35 -03:00
2006-12-03 07:23:45 -04:00
if ( ! getsockaddrarg ( s , addro , SAS2SA ( & addrbuf ) , & addrlen ) )
1991-06-25 18:36:08 -03:00
return NULL ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2006-12-03 07:23:45 -04:00
res = bind ( s - > sock_fd , SAS2SA ( & addrbuf ) , addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( bind_doc ,
1998-07-07 17:45:43 -03:00
" bind(address) \n \
\ n \
Bind the socket to a local address . For IP sockets , the address is a \ n \
2001-02-01 23:23:09 -04:00
pair ( host , port ) ; the host must refer to the local host . For raw packet \ n \
2002-06-13 17:33:02 -03:00
sockets the address is a tuple ( ifname , proto [ , pkttype [ , hatype ] ] ) " ) ;
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
/* s.close() method.
Set the file descriptor to - 1 so operations tried subsequently
will surely fail . */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_close ( PySocketSockObject * s )
1991-06-25 18:36:08 -03:00
{
2000-12-18 18:23:44 -04:00
SOCKET_T fd ;
2001-10-11 13:36:35 -03:00
2000-12-18 18:23:44 -04:00
if ( ( fd = s - > sock_fd ) ! = - 1 ) {
s - > sock_fd = - 1 ;
1996-10-12 11:07:22 -03:00
Py_BEGIN_ALLOW_THREADS
2000-12-18 18:23:44 -04:00
( void ) SOCKETCLOSE ( fd ) ;
1996-10-12 11:07:22 -03:00
Py_END_ALLOW_THREADS
}
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( close_doc ,
1998-07-07 17:45:43 -03:00
" close() \n \
\ n \
2002-06-13 17:33:02 -03:00
Close the socket . It cannot be used after this call . " );
1998-07-07 17:45:43 -03:00
2002-06-13 13:07:04 -03:00
static int
2003-06-29 00:08:05 -03:00
internal_connect ( PySocketSockObject * s , struct sockaddr * addr , int addrlen ,
int * timeoutp )
2002-06-13 13:07:04 -03:00
{
2003-06-29 00:08:05 -03:00
int res , timeout ;
2002-06-13 13:07:04 -03:00
2003-06-29 00:08:05 -03:00
timeout = 0 ;
2002-06-13 13:07:04 -03:00
res = connect ( s - > sock_fd , addr , addrlen ) ;
# ifdef MS_WINDOWS
if ( s - > sock_timeout > 0.0 ) {
2006-02-07 03:04:46 -04:00
if ( res < 0 & & WSAGetLastError ( ) = = WSAEWOULDBLOCK & &
IS_SELECTABLE ( s ) ) {
2003-02-19 13:50:16 -04:00
/* This is a mess. Best solution: trust select */
fd_set fds ;
2004-08-03 02:06:26 -03:00
fd_set fds_exc ;
2003-02-19 13:50:16 -04:00
struct timeval tv ;
tv . tv_sec = ( int ) s - > sock_timeout ;
tv . tv_usec = ( int ) ( ( s - > sock_timeout - tv . tv_sec ) * 1e6 ) ;
FD_ZERO ( & fds ) ;
FD_SET ( s - > sock_fd , & fds ) ;
2004-08-03 02:06:26 -03:00
FD_ZERO ( & fds_exc ) ;
FD_SET ( s - > sock_fd , & fds_exc ) ;
res = select ( s - > sock_fd + 1 , NULL , & fds , & fds_exc , & tv ) ;
2003-06-29 00:08:05 -03:00
if ( res = = 0 ) {
2003-02-19 13:50:16 -04:00
res = WSAEWOULDBLOCK ;
2003-06-29 00:08:05 -03:00
timeout = 1 ;
2004-08-03 02:06:26 -03:00
} else if ( res > 0 ) {
if ( FD_ISSET ( s - > sock_fd , & fds ) )
/* The socket is in the writeable set - this
means connected */
res = 0 ;
else {
/* As per MS docs, we need to call getsockopt()
to get the underlying error */
int res_size = sizeof res ;
/* It must be in the exception set */
assert ( FD_ISSET ( s - > sock_fd , & fds_exc ) ) ;
2006-05-26 09:03:27 -03:00
if ( 0 = = getsockopt ( s - > sock_fd , SOL_SOCKET , SO_ERROR ,
2004-08-03 02:06:26 -03:00
( char * ) & res , & res_size ) )
/* getsockopt also clears WSAGetLastError,
so reset it back . */
WSASetLastError ( res ) ;
else
res = WSAGetLastError ( ) ;
}
}
2003-02-19 13:50:16 -04:00
/* else if (res < 0) an error occurred */
2002-06-13 13:07:04 -03:00
}
}
if ( res < 0 )
res = WSAGetLastError ( ) ;
# else
if ( s - > sock_timeout > 0.0 ) {
2006-02-07 03:04:46 -04:00
if ( res < 0 & & errno = = EINPROGRESS & & IS_SELECTABLE ( s ) ) {
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 1 ) ;
2006-08-02 03:46:21 -03:00
if ( timeout = = 0 ) {
res = connect ( s - > sock_fd , addr , addrlen ) ;
if ( res < 0 & & errno = = EISCONN )
res = 0 ;
}
else if ( timeout = = - 1 )
res = errno ; /* had error */
else
res = EWOULDBLOCK ; /* timed out */
2002-06-13 13:07:04 -03:00
}
}
if ( res < 0 )
res = errno ;
# endif
2003-06-29 00:08:05 -03:00
* timeoutp = timeout ;
2002-06-13 13:07:04 -03:00
return res ;
}
1991-06-27 12:51:29 -03:00
2000-07-01 00:40:12 -03:00
/* s.connect(sockaddr) method */
1991-06-27 12:51:29 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_connect ( PySocketSockObject * s , PyObject * addro )
1991-06-25 18:36:08 -03:00
{
2006-12-03 07:23:45 -04:00
sock_addr_t addrbuf ;
1991-06-25 18:36:08 -03:00
int addrlen ;
1992-08-05 16:58:53 -03:00
int res ;
2003-06-29 00:08:05 -03:00
int timeout ;
2001-10-11 13:36:35 -03:00
2006-12-03 07:23:45 -04:00
if ( ! getsockaddrarg ( s , addro , SAS2SA ( & addrbuf ) , & addrlen ) )
1991-06-25 18:36:08 -03:00
return NULL ;
2002-06-06 18:08:16 -03:00
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2006-12-03 07:23:45 -04:00
res = internal_connect ( s , SAS2SA ( & addrbuf ) , addrlen , & timeout ) ;
2002-06-13 12:07:44 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
return NULL ;
}
2002-06-13 13:07:04 -03:00
if ( res ! = 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( connect_doc ,
1998-07-07 17:45:43 -03:00
" connect(address) \n \
\ n \
Connect the socket to a remote address . For IP sockets , the address \ n \
2002-06-13 17:33:02 -03:00
is a pair ( host , port ) . " ) ;
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
2000-07-01 00:40:12 -03:00
/* s.connect_ex(sockaddr) method */
1997-11-19 14:57:13 -04:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_connect_ex ( PySocketSockObject * s , PyObject * addro )
1997-11-19 14:57:13 -04:00
{
2006-12-03 07:23:45 -04:00
sock_addr_t addrbuf ;
1997-11-19 14:57:13 -04:00
int addrlen ;
int res ;
2003-06-29 00:08:05 -03:00
int timeout ;
2001-10-11 13:36:35 -03:00
2006-12-03 07:23:45 -04:00
if ( ! getsockaddrarg ( s , addro , SAS2SA ( & addrbuf ) , & addrlen ) )
1997-11-19 14:57:13 -04:00
return NULL ;
2002-06-06 18:08:16 -03:00
1997-11-19 14:57:13 -04:00
Py_BEGIN_ALLOW_THREADS
2006-12-03 07:23:45 -04:00
res = internal_connect ( s , SAS2SA ( & addrbuf ) , addrlen , & timeout ) ;
2002-06-13 12:07:44 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
/* Signals are not errors (though they may raise exceptions). Adapted
from PyErr_SetFromErrnoWithFilenameObject ( ) . */
# ifdef EINTR
if ( res = = EINTR & & PyErr_CheckSignals ( ) )
return NULL ;
# endif
1997-11-19 14:57:13 -04:00
return PyInt_FromLong ( ( long ) res ) ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( connect_ex_doc ,
2002-08-08 17:37:08 -03:00
" connect_ex(address) -> errno \n \
1998-07-07 17:45:43 -03:00
\ n \
This is like connect ( address ) , but returns an error code ( the errno value ) \ n \
2002-06-13 17:33:02 -03:00
instead of raising an exception when an error occurs . " );
1998-07-07 17:45:43 -03:00
1997-11-19 14:57:13 -04:00
1992-06-23 06:07:03 -03:00
/* s.fileno() method */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_fileno ( PySocketSockObject * s )
1992-06-23 06:07:03 -03:00
{
2000-06-29 23:46:07 -03:00
# if SIZEOF_SOCKET_T <= SIZEOF_LONG
1994-10-10 14:59:00 -03:00
return PyInt_FromLong ( ( long ) s - > sock_fd ) ;
2000-06-29 23:46:07 -03:00
# else
2003-03-29 06:06:18 -04:00
return PyLong_FromLongLong ( ( PY_LONG_LONG ) s - > sock_fd ) ;
2000-06-29 23:46:07 -03:00
# endif
1992-06-23 06:07:03 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( fileno_doc ,
1998-07-07 17:45:43 -03:00
" fileno() -> integer \n \
\ n \
2002-06-13 17:33:02 -03:00
Return the integer file descriptor of the socket . " );
1998-07-07 17:45:43 -03:00
1992-06-23 06:07:03 -03:00
1996-06-20 13:25:29 -03:00
# ifndef NO_DUP
/* s.dup() method */
static PyObject *
2002-06-07 00:19:37 -03:00
sock_dup ( PySocketSockObject * s )
1996-06-20 13:25:29 -03:00
{
2000-06-29 23:46:07 -03:00
SOCKET_T newfd ;
1996-06-20 13:25:29 -03:00
PyObject * sock ;
2001-10-11 13:36:35 -03:00
1996-06-20 13:25:29 -03:00
newfd = dup ( s - > sock_fd ) ;
if ( newfd < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
2002-06-07 00:19:37 -03:00
sock = ( PyObject * ) new_sockobject ( newfd ,
s - > sock_family ,
s - > sock_type ,
s - > sock_proto ) ;
1996-06-20 13:25:29 -03:00
if ( sock = = NULL )
2000-04-21 17:33:00 -03:00
SOCKETCLOSE ( newfd ) ;
1996-06-20 13:25:29 -03:00
return sock ;
}
1998-07-07 17:45:43 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( dup_doc ,
1998-07-07 17:45:43 -03:00
" dup() -> socket object \n \
\ n \
2002-06-13 17:33:02 -03:00
Return a new socket object connected to the same system resource . " );
1998-07-07 17:45:43 -03:00
1996-06-20 13:25:29 -03:00
# endif
1992-11-26 04:54:07 -04:00
/* s.getsockname() method */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_getsockname ( PySocketSockObject * s )
1992-11-26 04:54:07 -04:00
{
2005-09-14 15:09:42 -03:00
sock_addr_t addrbuf ;
2000-04-24 12:16:03 -03:00
int res ;
socklen_t addrlen ;
1992-11-26 04:54:07 -04:00
if ( ! getsockaddrlen ( s , & addrlen ) )
return NULL ;
2005-09-14 15:09:42 -03:00
memset ( & addrbuf , 0 , addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2006-12-03 07:23:45 -04:00
res = getsockname ( s - > sock_fd , SAS2SA ( & addrbuf ) , & addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1992-11-26 04:54:07 -04:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
2006-12-03 07:23:45 -04:00
return makesockaddr ( s - > sock_fd , SAS2SA ( & addrbuf ) , addrlen ,
2004-06-03 06:24:42 -03:00
s - > sock_proto ) ;
1992-11-26 04:54:07 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getsockname_doc ,
1998-07-07 17:45:43 -03:00
" getsockname() -> address info \n \
\ n \
Return the address of the local endpoint . For IP sockets , the address \ n \
2002-06-13 17:33:02 -03:00
info is a pair ( hostaddr , port ) . " ) ;
1998-07-07 17:45:43 -03:00
1992-11-26 04:54:07 -04:00
1994-08-01 08:34:53 -03:00
# ifdef HAVE_GETPEERNAME /* Cray APP doesn't have this :-( */
1992-11-26 04:54:07 -04:00
/* s.getpeername() method */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_getpeername ( PySocketSockObject * s )
1992-11-26 04:54:07 -04:00
{
2005-09-14 15:09:42 -03:00
sock_addr_t addrbuf ;
2000-04-24 12:16:03 -03:00
int res ;
socklen_t addrlen ;
1992-11-26 04:54:07 -04:00
if ( ! getsockaddrlen ( s , & addrlen ) )
return NULL ;
2005-09-14 15:09:42 -03:00
memset ( & addrbuf , 0 , addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2006-12-03 07:23:45 -04:00
res = getpeername ( s - > sock_fd , SAS2SA ( & addrbuf ) , & addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1992-11-26 04:54:07 -04:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
2006-12-03 07:23:45 -04:00
return makesockaddr ( s - > sock_fd , SAS2SA ( & addrbuf ) , addrlen ,
2004-06-03 06:24:42 -03:00
s - > sock_proto ) ;
1992-11-26 04:54:07 -04:00
}
1998-07-07 17:45:43 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getpeername_doc ,
1998-07-07 17:45:43 -03:00
" getpeername() -> address info \n \
\ n \
Return the address of the remote endpoint . For IP sockets , the address \ n \
2002-06-13 17:33:02 -03:00
info is a pair ( hostaddr , port ) . " ) ;
1998-07-07 17:45:43 -03:00
1994-08-01 08:34:53 -03:00
# endif /* HAVE_GETPEERNAME */
1992-11-26 04:54:07 -04:00
1991-06-27 12:51:29 -03:00
/* s.listen(n) method */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_listen ( PySocketSockObject * s , PyObject * arg )
1991-06-25 18:36:08 -03:00
{
int backlog ;
1992-08-05 16:58:53 -03:00
int res ;
2001-10-11 13:36:35 -03:00
backlog = PyInt_AsLong ( arg ) ;
if ( backlog = = - 1 & & PyErr_Occurred ( ) )
1991-06-25 18:36:08 -03:00
return NULL ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
1994-08-01 08:34:53 -03:00
if ( backlog < 1 )
backlog = 1 ;
1992-08-05 16:58:53 -03:00
res = listen ( s - > sock_fd , backlog ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( listen_doc ,
1998-07-07 17:45:43 -03:00
" listen(backlog) \n \
\ n \
Enable a server to accept connections . The backlog argument must be at \ n \
least 1 ; it specifies the number of unaccepted connection that the system \ n \
2002-06-13 17:33:02 -03:00
will allow before refusing new connections . " );
1998-07-07 17:45:43 -03:00
1994-08-18 12:42:46 -03:00
# ifndef NO_DUP
1991-06-27 12:51:29 -03:00
/* s.makefile(mode) method.
Create a new open file object referring to a dupped version of
the socket ' s file descriptor . ( The dup ( ) call is necessary so
that the open file and socket objects may be closed independent
of each other . )
The mode argument specifies ' r ' or ' w ' passed to fdopen ( ) . */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_makefile ( PySocketSockObject * s , PyObject * args )
1991-06-25 18:36:08 -03:00
{
2000-07-09 00:09:57 -03:00
extern int fclose ( FILE * ) ;
1995-03-14 11:05:13 -04:00
char * mode = " r " ;
int bufsize = - 1 ;
2000-06-29 23:46:07 -03:00
# ifdef MS_WIN32
2001-08-29 18:37:10 -03:00
Py_intptr_t fd ;
2000-06-29 23:46:07 -03:00
# else
1991-06-27 12:51:29 -03:00
int fd ;
2001-03-02 02:34:14 -04:00
# endif
1991-06-27 12:51:29 -03:00
FILE * fp ;
1995-03-14 11:05:13 -04:00
PyObject * f ;
2002-12-06 08:48:53 -04:00
# ifdef __VMS
char * mode_r = " r " ;
char * mode_w = " w " ;
# endif
1995-03-14 11:05:13 -04:00
2000-02-29 09:59:29 -04:00
if ( ! PyArg_ParseTuple ( args , " |si:makefile " , & mode , & bufsize ) )
1991-06-25 18:36:08 -03:00
return NULL ;
2002-12-06 08:48:53 -04:00
# ifdef __VMS
if ( strcmp ( mode , " rb " ) = = 0 ) {
mode = mode_r ;
}
else {
if ( strcmp ( mode , " wb " ) = = 0 ) {
mode = mode_w ;
}
}
# endif
1996-06-26 15:22:49 -03:00
# ifdef MS_WIN32
1998-07-07 17:45:43 -03:00
if ( ( ( fd = _open_osfhandle ( s - > sock_fd , _O_BINARY ) ) < 0 ) | |
( ( fd = dup ( fd ) ) < 0 ) | | ( ( fp = fdopen ( fd , mode ) ) = = NULL ) )
1995-06-14 19:28:08 -03:00
# else
1998-07-07 17:45:43 -03:00
if ( ( fd = dup ( s - > sock_fd ) ) < 0 | | ( fp = fdopen ( fd , mode ) ) = = NULL )
1995-06-14 19:28:08 -03:00
# endif
1998-07-07 17:45:43 -03:00
{
1995-03-14 11:05:13 -04:00
if ( fd > = 0 )
2000-04-21 17:33:00 -03:00
SOCKETCLOSE ( fd ) ;
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1995-03-14 11:05:13 -04:00
}
f = PyFile_FromFile ( fp , " <socket> " , mode , fclose ) ;
if ( f ! = NULL )
PyFile_SetBufSize ( f , bufsize ) ;
return f ;
1991-06-27 12:51:29 -03:00
}
1998-07-07 17:45:43 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( makefile_doc ,
1998-07-07 17:45:43 -03:00
" makefile([mode[, buffersize]]) -> file object \n \
\ n \
Return a regular file object corresponding to the socket . \ n \
2002-06-13 17:33:02 -03:00
The mode and buffersize arguments are as for the built - in open ( ) function . " );
1998-07-07 17:45:43 -03:00
1994-08-18 12:42:46 -03:00
# endif /* NO_DUP */
1991-06-27 12:51:29 -03:00
2006-05-26 09:03:27 -03:00
/*
2006-06-04 10:49:49 -03:00
* This is the guts of the recv ( ) and recv_into ( ) methods , which reads into a
2006-12-19 10:29:04 -04:00
* char buffer . If you have any inc / dec ref to do to the objects that contain
2006-05-26 09:03:27 -03:00
* the buffer , do it in the caller . This function returns the number of bytes
* succesfully read . If there was an error , it returns - 1. Note that it is
* also possible that we return a number of bytes smaller than the request
* bytes .
*/
2006-06-04 10:49:49 -03:00
static ssize_t
2006-05-26 09:03:27 -03:00
sock_recv_guts ( PySocketSockObject * s , char * cbuf , int len , int flags )
1991-06-27 12:51:29 -03:00
{
2006-08-02 03:46:21 -03:00
ssize_t outlen = - 1 ;
2006-06-04 10:49:49 -03:00
int timeout ;
2002-12-06 08:48:53 -04:00
# ifdef __VMS
2006-08-02 03:46:21 -03:00
int remaining ;
2002-12-06 08:48:53 -04:00
char * read_buf ;
# endif
2002-06-06 18:08:16 -03:00
2006-05-26 09:03:27 -03:00
if ( ! IS_SELECTABLE ( s ) ) {
select_error ( ) ;
return - 1 ;
2001-11-19 06:41:26 -04:00
}
2002-06-06 18:08:16 -03:00
2002-12-06 08:48:53 -04:00
# ifndef __VMS
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 0 ) ;
if ( ! timeout )
2006-05-26 09:03:27 -03:00
outlen = recv ( s - > sock_fd , cbuf , len , flags ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
2006-05-26 09:03:27 -03:00
return - 1 ;
2003-06-29 00:08:05 -03:00
}
2006-05-26 09:03:27 -03:00
if ( outlen < 0 ) {
/* Note: the call to errorhandler() ALWAYS indirectly returned
NULL , so ignore its return value */
s - > errorhandler ( ) ;
return - 1 ;
1995-09-13 15:39:47 -03:00
}
2002-12-06 08:48:53 -04:00
# else
2006-05-26 09:03:27 -03:00
read_buf = cbuf ;
remaining = len ;
while ( remaining ! = 0 ) {
2002-12-06 08:48:53 -04:00
unsigned int segment ;
2006-08-02 03:46:21 -03:00
int nread = - 1 ;
2002-12-06 08:48:53 -04:00
2006-05-26 09:03:27 -03:00
segment = remaining / SEGMENT_SIZE ;
2002-12-06 08:48:53 -04:00
if ( segment ! = 0 ) {
segment = SEGMENT_SIZE ;
}
else {
2006-05-26 09:03:27 -03:00
segment = remaining ;
2002-12-06 08:48:53 -04:00
}
Py_BEGIN_ALLOW_THREADS
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 0 ) ;
if ( ! timeout )
2006-05-26 09:03:27 -03:00
nread = recv ( s - > sock_fd , read_buf , segment , flags ) ;
2002-12-06 08:48:53 -04:00
Py_END_ALLOW_THREADS
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
2006-05-26 09:03:27 -03:00
return - 1 ;
2003-06-29 00:08:05 -03:00
}
2006-05-26 09:03:27 -03:00
if ( nread < 0 ) {
s - > errorhandler ( ) ;
return - 1 ;
2002-12-06 08:48:53 -04:00
}
2006-05-26 09:03:27 -03:00
if ( nread ! = remaining ) {
read_buf + = nread ;
2002-12-06 08:48:53 -04:00
break ;
}
2006-05-26 09:03:27 -03:00
remaining - = segment ;
2002-12-06 08:48:53 -04:00
read_buf + = segment ;
}
2006-05-26 09:03:27 -03:00
outlen = read_buf - cbuf ;
2002-12-06 08:48:53 -04:00
# endif /* !__VMS */
2006-05-26 09:03:27 -03:00
return outlen ;
}
/* s.recv(nbytes [,flags]) method */
static PyObject *
sock_recv ( PySocketSockObject * s , PyObject * args )
{
2006-06-04 10:49:49 -03:00
int recvlen , flags = 0 ;
ssize_t outlen ;
2006-05-26 09:03:27 -03:00
PyObject * buf ;
if ( ! PyArg_ParseTuple ( args , " i|i:recv " , & recvlen , & flags ) )
return NULL ;
if ( recvlen < 0 ) {
PyErr_SetString ( PyExc_ValueError ,
" negative buffersize in recv " ) ;
return NULL ;
}
/* Allocate a new string. */
buf = PyString_FromStringAndSize ( ( char * ) 0 , recvlen ) ;
if ( buf = = NULL )
return NULL ;
/* Call the guts */
2006-06-04 10:49:49 -03:00
outlen = sock_recv_guts ( s , PyString_AS_STRING ( buf ) , recvlen , flags ) ;
2006-05-26 09:03:27 -03:00
if ( outlen < 0 ) {
2006-07-28 15:36:01 -03:00
/* An error occurred, release the string and return an
2006-05-26 09:03:27 -03:00
error . */
Py_DECREF ( buf ) ;
return NULL ;
}
if ( outlen ! = recvlen ) {
/* We did not read as many bytes as we anticipated, resize the
string if possible and be succesful . */
if ( _PyString_Resize ( & buf , outlen ) < 0 )
/* Oopsy, not so succesful after all. */
return NULL ;
}
1991-06-25 18:36:08 -03:00
return buf ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( recv_doc ,
1998-07-07 17:45:43 -03:00
" recv(buffersize[, flags]) -> data \n \
\ n \
Receive up to buffersize bytes from the socket . For the optional flags \ n \
argument , see the Unix manual . When no data is available , block until \ n \
at least one byte is available or until the remote end is closed . When \ n \
2002-06-13 17:33:02 -03:00
the remote end is closed and all data is read , return the empty string . " );
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
2006-06-04 10:49:49 -03:00
/* s.recv_into(buffer, [nbytes [,flags]]) method */
1991-06-27 12:51:29 -03:00
2006-05-26 09:03:27 -03:00
static PyObject *
2006-06-04 10:49:49 -03:00
sock_recv_into ( PySocketSockObject * s , PyObject * args , PyObject * kwds )
1991-06-25 18:36:08 -03:00
{
2006-05-26 09:03:27 -03:00
static char * kwlist [ ] = { " buffer " , " nbytes " , " flags " , 0 } ;
2002-06-06 18:08:16 -03:00
2006-06-04 10:49:49 -03:00
int recvlen = 0 , flags = 0 ;
ssize_t readlen ;
2006-05-26 09:03:27 -03:00
char * buf ;
int buflen ;
/* Get the buffer's memory */
2007-03-31 15:54:18 -03:00
if ( ! PyArg_ParseTupleAndKeywords ( args , kwds , " w#|ii:recv_into " , kwlist ,
2006-05-26 09:03:27 -03:00
& buf , & buflen , & recvlen , & flags ) )
1996-06-20 13:25:29 -03:00
return NULL ;
2006-05-26 09:03:27 -03:00
assert ( buf ! = 0 & & buflen > 0 ) ;
2002-06-06 18:08:16 -03:00
2006-05-26 09:03:27 -03:00
if ( recvlen < 0 ) {
PyErr_SetString ( PyExc_ValueError ,
2007-03-28 00:45:20 -03:00
" negative buffersize in recv_into " ) ;
1993-05-25 09:16:29 -03:00
return NULL ;
2006-05-26 09:03:27 -03:00
}
if ( recvlen = = 0 ) {
/* If nbytes was not specified, use the buffer's length */
recvlen = buflen ;
}
/* Check if the buffer is large enough */
if ( buflen < recvlen ) {
PyErr_SetString ( PyExc_ValueError ,
" buffer too small for requested bytes " ) ;
1993-05-25 09:16:29 -03:00
return NULL ;
2006-05-26 09:03:27 -03:00
}
2002-06-06 18:08:16 -03:00
2006-05-26 09:03:27 -03:00
/* Call the guts */
readlen = sock_recv_guts ( s , buf , recvlen , flags ) ;
if ( readlen < 0 ) {
/* Return an error. */
return NULL ;
}
/* Return the number of bytes read. Note that we do not do anything
special here in the case that readlen < recvlen . */
2006-06-04 10:49:49 -03:00
return PyInt_FromSsize_t ( readlen ) ;
2006-05-26 09:03:27 -03:00
}
2006-06-04 10:49:49 -03:00
PyDoc_STRVAR ( recv_into_doc ,
" recv_into(buffer, [nbytes[, flags]]) -> nbytes_read \n \
2006-05-26 09:03:27 -03:00
\ n \
A version of recv ( ) that stores its data into a buffer rather than creating \ n \
a new string . Receive up to buffersize bytes from the socket . If buffersize \ n \
is not specified ( or 0 ) , receive up to the size available in the given buffer . \ n \
\ n \
See recv ( ) for documentation about the flags . " ) ;
/*
2007-12-18 16:10:42 -04:00
* This is the guts of the recvfrom ( ) and recvfrom_into ( ) methods , which reads
* into a char buffer . If you have any inc / def ref to do to the objects that
* contain the buffer , do it in the caller . This function returns the number
* of bytes succesfully read . If there was an error , it returns - 1. Note
* that it is also possible that we return a number of bytes smaller than the
* request bytes .
2006-05-26 09:03:27 -03:00
*
* ' addr ' is a return value for the address object . Note that you must decref
* it yourself .
*/
2006-06-04 10:49:49 -03:00
static ssize_t
2006-05-26 09:03:27 -03:00
sock_recvfrom_guts ( PySocketSockObject * s , char * cbuf , int len , int flags ,
PyObject * * addr )
{
sock_addr_t addrbuf ;
2006-06-04 10:49:49 -03:00
int timeout ;
2006-08-02 03:46:21 -03:00
ssize_t n = - 1 ;
2006-05-26 09:03:27 -03:00
socklen_t addrlen ;
* addr = NULL ;
if ( ! getsockaddrlen ( s , & addrlen ) )
return - 1 ;
if ( ! IS_SELECTABLE ( s ) ) {
select_error ( ) ;
return - 1 ;
}
2006-02-07 03:04:46 -04:00
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2005-09-14 15:09:42 -03:00
memset ( & addrbuf , 0 , addrlen ) ;
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 0 ) ;
2006-04-15 05:35:59 -03:00
if ( ! timeout ) {
1996-06-26 15:22:49 -03:00
# ifndef MS_WINDOWS
2002-03-02 23:03:52 -04:00
# if defined(PYOS_OS2) && !defined(PYCC_GCC)
2006-05-26 09:03:27 -03:00
n = recvfrom ( s - > sock_fd , cbuf , len , flags ,
2006-12-03 07:23:45 -04:00
SAS2SA ( & addrbuf ) , & addrlen ) ;
1997-12-02 16:37:32 -04:00
# else
2006-05-26 09:03:27 -03:00
n = recvfrom ( s - > sock_fd , cbuf , len , flags ,
2006-04-15 05:35:59 -03:00
( void * ) & addrbuf , & addrlen ) ;
1997-12-02 16:37:32 -04:00
# endif
1994-08-18 12:42:46 -03:00
# else
2006-05-26 09:03:27 -03:00
n = recvfrom ( s - > sock_fd , cbuf , len , flags ,
2006-12-03 07:23:45 -04:00
SAS2SA ( & addrbuf ) , & addrlen ) ;
1994-08-18 12:42:46 -03:00
# endif
2006-04-15 05:35:59 -03:00
}
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
2006-05-26 09:03:27 -03:00
return - 1 ;
2003-06-29 00:08:05 -03:00
}
1995-09-13 15:39:47 -03:00
if ( n < 0 ) {
2006-05-26 09:03:27 -03:00
s - > errorhandler ( ) ;
return - 1 ;
1995-09-13 15:39:47 -03:00
}
2002-06-06 18:08:16 -03:00
2006-12-03 07:23:45 -04:00
if ( ! ( * addr = makesockaddr ( s - > sock_fd , SAS2SA ( & addrbuf ) ,
2006-05-26 09:03:27 -03:00
addrlen , s - > sock_proto ) ) )
return - 1 ;
return n ;
}
/* s.recvfrom(nbytes [,flags]) method */
static PyObject *
sock_recvfrom ( PySocketSockObject * s , PyObject * args )
{
PyObject * buf = NULL ;
PyObject * addr = NULL ;
PyObject * ret = NULL ;
2006-06-04 10:49:49 -03:00
int recvlen , flags = 0 ;
ssize_t outlen ;
2006-05-26 09:03:27 -03:00
if ( ! PyArg_ParseTuple ( args , " i|i:recvfrom " , & recvlen , & flags ) )
return NULL ;
2007-03-28 00:45:20 -03:00
if ( recvlen < 0 ) {
PyErr_SetString ( PyExc_ValueError ,
" negative buffersize in recvfrom " ) ;
return NULL ;
}
2006-05-26 09:03:27 -03:00
buf = PyString_FromStringAndSize ( ( char * ) 0 , recvlen ) ;
if ( buf = = NULL )
1991-06-25 18:36:08 -03:00
return NULL ;
2001-03-02 02:34:14 -04:00
2006-05-26 09:03:27 -03:00
outlen = sock_recvfrom_guts ( s , PyString_AS_STRING ( buf ) ,
recvlen , flags , & addr ) ;
if ( outlen < 0 ) {
1997-01-03 13:18:10 -04:00
goto finally ;
2006-05-26 09:03:27 -03:00
}
if ( outlen ! = recvlen ) {
/* We did not read as many bytes as we anticipated, resize the
string if possible and be succesful . */
if ( _PyString_Resize ( & buf , outlen ) < 0 )
/* Oopsy, not so succesful after all. */
goto finally ;
}
1997-01-03 13:18:10 -04:00
2003-10-12 16:09:37 -03:00
ret = PyTuple_Pack ( 2 , buf , addr ) ;
2002-06-06 18:08:16 -03:00
finally :
1994-10-10 14:59:00 -03:00
Py_XDECREF ( buf ) ;
2006-05-26 09:03:27 -03:00
Py_XDECREF ( addr ) ;
1993-02-05 05:46:15 -04:00
return ret ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( recvfrom_doc ,
1998-07-07 17:45:43 -03:00
" recvfrom(buffersize[, flags]) -> (data, address info) \n \
\ n \
2002-06-13 17:33:02 -03:00
Like recv ( buffersize , flags ) but also return the sender ' s address info . " ) ;
1998-07-07 17:45:43 -03:00
2006-05-26 09:03:27 -03:00
2006-06-04 10:49:49 -03:00
/* s.recvfrom_into(buffer[, nbytes [,flags]]) method */
2006-05-26 09:03:27 -03:00
static PyObject *
2006-06-04 10:49:49 -03:00
sock_recvfrom_into ( PySocketSockObject * s , PyObject * args , PyObject * kwds )
2006-05-26 09:03:27 -03:00
{
static char * kwlist [ ] = { " buffer " , " nbytes " , " flags " , 0 } ;
2006-06-04 10:49:49 -03:00
int recvlen = 0 , flags = 0 ;
ssize_t readlen ;
2006-05-26 09:03:27 -03:00
char * buf ;
int buflen ;
PyObject * addr = NULL ;
2007-03-31 15:54:18 -03:00
if ( ! PyArg_ParseTupleAndKeywords ( args , kwds , " w#|ii:recvfrom_into " ,
kwlist , & buf , & buflen ,
& recvlen , & flags ) )
2006-05-26 09:03:27 -03:00
return NULL ;
assert ( buf ! = 0 & & buflen > 0 ) ;
if ( recvlen < 0 ) {
PyErr_SetString ( PyExc_ValueError ,
2007-03-28 00:45:20 -03:00
" negative buffersize in recvfrom_into " ) ;
2006-05-26 09:03:27 -03:00
return NULL ;
}
if ( recvlen = = 0 ) {
/* If nbytes was not specified, use the buffer's length */
recvlen = buflen ;
}
readlen = sock_recvfrom_guts ( s , buf , recvlen , flags , & addr ) ;
if ( readlen < 0 ) {
/* Return an error */
2006-06-04 10:49:49 -03:00
Py_XDECREF ( addr ) ;
return NULL ;
2006-05-26 09:03:27 -03:00
}
/* Return the number of bytes read and the address. Note that we do
not do anything special here in the case that readlen < recvlen . */
2006-06-08 02:12:45 -03:00
return Py_BuildValue ( " lN " , readlen , addr ) ;
2006-05-26 09:03:27 -03:00
}
2006-06-04 10:49:49 -03:00
PyDoc_STRVAR ( recvfrom_into_doc ,
" recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info) \n \
2006-05-26 09:03:27 -03:00
\ n \
2006-06-04 10:49:49 -03:00
Like recv_into ( buffer [ , nbytes [ , flags ] ] ) but also return the sender ' s address info . " ) ;
2006-05-26 09:03:27 -03:00
1993-05-25 06:38:27 -03:00
/* s.send(data [,flags]) method */
1991-06-27 12:51:29 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_send ( PySocketSockObject * s , PyObject * args )
1991-06-27 12:51:29 -03:00
{
1992-08-05 16:58:53 -03:00
char * buf ;
2006-08-02 03:46:21 -03:00
int len , n = - 1 , flags = 0 , timeout ;
2002-06-06 18:08:16 -03:00
2000-02-29 09:59:29 -04:00
if ( ! PyArg_ParseTuple ( args , " s#|i:send " , & buf , & len , & flags ) )
1996-06-20 13:25:29 -03:00
return NULL ;
2002-06-06 18:08:16 -03:00
2006-02-07 03:04:46 -04:00
if ( ! IS_SELECTABLE ( s ) )
return select_error ( ) ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 1 ) ;
if ( ! timeout )
2006-07-09 22:18:57 -03:00
# ifdef __VMS
n = sendsegmented ( s - > sock_fd , buf , len , flags ) ;
# else
2003-06-29 00:08:05 -03:00
n = send ( s - > sock_fd , buf , len , flags ) ;
2006-07-09 22:18:57 -03:00
# endif
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
return NULL ;
}
1991-06-27 12:51:29 -03:00
if ( n < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
return PyInt_FromLong ( ( long ) n ) ;
1991-06-27 12:51:29 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( send_doc ,
2001-10-26 00:25:00 -03:00
" send(data[, flags]) -> count \n \
1998-07-07 17:45:43 -03:00
\ n \
Send a data string to the socket . For the optional flags \ n \
2001-10-26 00:25:00 -03:00
argument , see the Unix manual . Return the number of bytes \ n \
2002-06-13 17:33:02 -03:00
sent ; this may be less than len ( data ) if the network is busy . " ) ;
2001-10-26 00:25:00 -03:00
/* s.sendall(data [,flags]) method */
static PyObject *
2002-06-07 00:19:37 -03:00
sock_sendall ( PySocketSockObject * s , PyObject * args )
2001-10-26 00:25:00 -03:00
{
char * buf ;
2006-08-02 03:46:21 -03:00
int len , n = - 1 , flags = 0 , timeout ;
2002-06-06 18:08:16 -03:00
2001-10-26 00:25:00 -03:00
if ( ! PyArg_ParseTuple ( args , " s#|i:sendall " , & buf , & len , & flags ) )
return NULL ;
2002-06-06 18:08:16 -03:00
2006-02-07 03:04:46 -04:00
if ( ! IS_SELECTABLE ( s ) )
return select_error ( ) ;
2001-10-26 00:25:00 -03:00
Py_BEGIN_ALLOW_THREADS
do {
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 1 ) ;
2006-08-02 03:46:21 -03:00
n = - 1 ;
2003-06-29 00:08:05 -03:00
if ( timeout )
break ;
2006-07-09 22:18:57 -03:00
# ifdef __VMS
n = sendsegmented ( s - > sock_fd , buf , len , flags ) ;
# else
2001-10-26 00:25:00 -03:00
n = send ( s - > sock_fd , buf , len , flags ) ;
2006-07-09 22:18:57 -03:00
# endif
2001-10-26 00:25:00 -03:00
if ( n < 0 )
break ;
buf + = n ;
len - = n ;
} while ( len > 0 ) ;
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
return NULL ;
}
2001-10-26 00:25:00 -03:00
if ( n < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
2002-06-06 18:08:16 -03:00
2001-10-26 00:25:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( sendall_doc ,
2001-10-26 00:25:00 -03:00
" sendall(data[, flags]) \n \
\ n \
Send a data string to the socket . For the optional flags \ n \
argument , see the Unix manual . This calls send ( ) repeatedly \ n \
until all data is sent . If an error occurs , it ' s impossible \ n \
2002-06-13 17:33:02 -03:00
to tell how much data has been sent . " );
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
1993-05-25 06:38:27 -03:00
/* s.sendto(data, [flags,] sockaddr) method */
1991-06-27 12:51:29 -03:00
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_sendto ( PySocketSockObject * s , PyObject * args )
1991-06-25 18:36:08 -03:00
{
1994-10-10 14:59:00 -03:00
PyObject * addro ;
1992-08-05 16:58:53 -03:00
char * buf ;
2006-12-03 07:23:45 -04:00
sock_addr_t addrbuf ;
2006-08-02 03:46:21 -03:00
int addrlen , len , n = - 1 , flags , timeout ;
2002-06-06 18:08:16 -03:00
1993-05-25 06:38:27 -03:00
flags = 0 ;
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s#O:sendto " , & buf , & len , & addro ) ) {
1994-10-10 14:59:00 -03:00
PyErr_Clear ( ) ;
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s#iO:sendto " ,
& buf , & len , & flags , & addro ) )
1993-05-25 06:38:27 -03:00
return NULL ;
1991-06-25 18:36:08 -03:00
}
2002-06-06 18:08:16 -03:00
2006-02-07 03:04:46 -04:00
if ( ! IS_SELECTABLE ( s ) )
return select_error ( ) ;
2006-12-03 07:23:45 -04:00
if ( ! getsockaddrarg ( s , addro , SAS2SA ( & addrbuf ) , & addrlen ) )
return NULL ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
2003-06-29 00:08:05 -03:00
timeout = internal_select ( s , 1 ) ;
if ( ! timeout )
2006-12-03 07:23:45 -04:00
n = sendto ( s - > sock_fd , buf , len , flags , SAS2SA ( & addrbuf ) , addrlen ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2006-08-02 03:46:21 -03:00
if ( timeout = = 1 ) {
2003-06-29 00:08:05 -03:00
PyErr_SetString ( socket_timeout , " timed out " ) ;
return NULL ;
}
1991-06-25 18:36:08 -03:00
if ( n < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
return PyInt_FromLong ( ( long ) n ) ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( sendto_doc ,
2002-08-08 17:37:08 -03:00
" sendto(data[, flags], address) -> count \n \
1998-07-07 17:45:43 -03:00
\ n \
Like send ( data , flags ) but allows specifying the destination address . \ n \
2002-06-13 17:33:02 -03:00
For IP sockets , the address is a pair ( hostaddr , port ) . " );
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
/* s.shutdown(how) method */
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_shutdown ( PySocketSockObject * s , PyObject * arg )
1991-06-25 18:36:08 -03:00
{
int how ;
1992-08-05 16:58:53 -03:00
int res ;
2001-10-11 13:36:35 -03:00
how = PyInt_AsLong ( arg ) ;
if ( how = = - 1 & & PyErr_Occurred ( ) )
1991-06-25 18:36:08 -03:00
return NULL ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
res = shutdown ( s - > sock_fd , how ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
if ( res < 0 )
2002-02-16 14:23:30 -04:00
return s - > errorhandler ( ) ;
1994-10-10 14:59:00 -03:00
Py_INCREF ( Py_None ) ;
return Py_None ;
1991-06-25 18:36:08 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( shutdown_doc ,
1998-07-07 17:45:43 -03:00
" shutdown(flag) \n \
\ n \
2003-11-27 15:40:22 -04:00
Shut down the reading side of the socket ( flag = = SHUT_RD ) , the writing side \ n \
of the socket ( flag = = SHUT_WR ) , or both ends ( flag = = SHUT_RDWR ) . " ) ;
1998-07-07 17:45:43 -03:00
2008-01-04 11:23:30 -04:00
# ifdef MS_WINDOWS
static PyObject *
sock_ioctl ( PySocketSockObject * s , PyObject * arg )
{
unsigned long cmd = SIO_RCVALL ;
unsigned int option = RCVALL_ON ;
DWORD recv ;
if ( ! PyArg_ParseTuple ( arg , " kI:ioctl " , & cmd , & option ) )
return NULL ;
if ( WSAIoctl ( s - > sock_fd , cmd , & option , sizeof ( option ) ,
NULL , 0 , & recv , NULL , NULL ) = = SOCKET_ERROR ) {
return set_error ( ) ;
}
return PyLong_FromUnsignedLong ( recv ) ;
}
PyDoc_STRVAR ( sock_ioctl_doc ,
" ioctl(cmd, option) -> long \n \
\ n \
Control the socket with WSAIoctl syscall . Currently only socket . SIO_RCVALL \ n \
is supported as control . Options must be one of the socket . RCVALL_ * \ n \
constants . " );
# endif
1991-06-27 12:51:29 -03:00
/* List of methods for socket objects */
1991-06-25 18:36:08 -03:00
2002-06-07 00:19:37 -03:00
static PyMethodDef sock_methods [ ] = {
2006-05-26 09:03:27 -03:00
{ " accept " , ( PyCFunction ) sock_accept , METH_NOARGS ,
accept_doc } ,
{ " bind " , ( PyCFunction ) sock_bind , METH_O ,
bind_doc } ,
{ " close " , ( PyCFunction ) sock_close , METH_NOARGS ,
close_doc } ,
{ " connect " , ( PyCFunction ) sock_connect , METH_O ,
connect_doc } ,
{ " connect_ex " , ( PyCFunction ) sock_connect_ex , METH_O ,
connect_ex_doc } ,
1996-06-20 13:25:29 -03:00
# ifndef NO_DUP
2006-05-26 09:03:27 -03:00
{ " dup " , ( PyCFunction ) sock_dup , METH_NOARGS ,
dup_doc } ,
1996-06-20 13:25:29 -03:00
# endif
2006-05-26 09:03:27 -03:00
{ " fileno " , ( PyCFunction ) sock_fileno , METH_NOARGS ,
fileno_doc } ,
1994-08-01 08:34:53 -03:00
# ifdef HAVE_GETPEERNAME
2006-05-26 09:03:27 -03:00
{ " getpeername " , ( PyCFunction ) sock_getpeername ,
METH_NOARGS , getpeername_doc } ,
# endif
{ " getsockname " , ( PyCFunction ) sock_getsockname ,
METH_NOARGS , getsockname_doc } ,
{ " getsockopt " , ( PyCFunction ) sock_getsockopt , METH_VARARGS ,
getsockopt_doc } ,
2008-01-04 11:23:30 -04:00
# ifdef MS_WINDOWS
{ " ioctl " , ( PyCFunction ) sock_ioctl , METH_VARARGS ,
sock_ioctl_doc } ,
# endif
2006-05-26 09:03:27 -03:00
{ " listen " , ( PyCFunction ) sock_listen , METH_O ,
listen_doc } ,
1994-08-18 12:42:46 -03:00
# ifndef NO_DUP
2006-05-26 09:03:27 -03:00
{ " makefile " , ( PyCFunction ) sock_makefile , METH_VARARGS ,
makefile_doc } ,
# endif
{ " recv " , ( PyCFunction ) sock_recv , METH_VARARGS ,
recv_doc } ,
2006-06-04 10:49:49 -03:00
{ " recv_into " , ( PyCFunction ) sock_recv_into , METH_VARARGS | METH_KEYWORDS ,
recv_into_doc } ,
2006-05-26 09:03:27 -03:00
{ " recvfrom " , ( PyCFunction ) sock_recvfrom , METH_VARARGS ,
recvfrom_doc } ,
2006-06-04 10:49:49 -03:00
{ " recvfrom_into " , ( PyCFunction ) sock_recvfrom_into , METH_VARARGS | METH_KEYWORDS ,
recvfrom_into_doc } ,
2006-05-26 09:03:27 -03:00
{ " send " , ( PyCFunction ) sock_send , METH_VARARGS ,
send_doc } ,
{ " sendall " , ( PyCFunction ) sock_sendall , METH_VARARGS ,
sendall_doc } ,
{ " sendto " , ( PyCFunction ) sock_sendto , METH_VARARGS ,
sendto_doc } ,
{ " setblocking " , ( PyCFunction ) sock_setblocking , METH_O ,
setblocking_doc } ,
{ " settimeout " , ( PyCFunction ) sock_settimeout , METH_O ,
settimeout_doc } ,
{ " gettimeout " , ( PyCFunction ) sock_gettimeout , METH_NOARGS ,
gettimeout_doc } ,
{ " setsockopt " , ( PyCFunction ) sock_setsockopt , METH_VARARGS ,
setsockopt_doc } ,
{ " shutdown " , ( PyCFunction ) sock_shutdown , METH_O ,
shutdown_doc } ,
2001-03-02 02:34:14 -04:00
# ifdef RISCOS
2006-05-26 09:03:27 -03:00
{ " sleeptaskw " , ( PyCFunction ) sock_sleeptaskw , METH_O ,
sleeptaskw_doc } ,
2001-03-02 02:34:14 -04:00
# endif
1994-08-01 08:34:53 -03:00
{ NULL , NULL } /* sentinel */
1991-06-25 18:36:08 -03:00
} ;
2006-03-17 15:17:34 -04:00
/* SockObject members */
static PyMemberDef sock_memberlist [ ] = {
{ " family " , T_INT , offsetof ( PySocketSockObject , sock_family ) , READONLY , " the socket family " } ,
{ " type " , T_INT , offsetof ( PySocketSockObject , sock_type ) , READONLY , " the socket type " } ,
{ " proto " , T_INT , offsetof ( PySocketSockObject , sock_proto ) , READONLY , " the socket protocol " } ,
{ " timeout " , T_DOUBLE , offsetof ( PySocketSockObject , sock_timeout ) , READONLY , " the socket timeout " } ,
{ 0 } ,
} ;
1991-06-27 12:51:29 -03:00
1994-10-10 14:59:00 -03:00
/* Deallocate a socket object in response to the last Py_DECREF().
1991-06-27 12:51:29 -03:00
First close the file description . */
1991-06-25 18:36:08 -03:00
static void
2002-06-07 00:19:37 -03:00
sock_dealloc ( PySocketSockObject * s )
1991-06-25 18:36:08 -03:00
{
2000-04-10 09:45:45 -03:00
if ( s - > sock_fd ! = - 1 )
2000-04-21 17:33:00 -03:00
( void ) SOCKETCLOSE ( s - > sock_fd ) ;
2007-12-18 22:37:44 -04:00
Py_TYPE ( s ) - > tp_free ( ( PyObject * ) s ) ;
1991-06-25 18:36:08 -03:00
}
1991-06-27 12:51:29 -03:00
1995-01-02 15:30:30 -04:00
static PyObject *
2002-06-07 00:19:37 -03:00
sock_repr ( PySocketSockObject * s )
1995-01-02 15:30:30 -04:00
{
char buf [ 512 ] ;
2000-06-29 23:46:07 -03:00
# if SIZEOF_SOCKET_T > SIZEOF_LONG
if ( s - > sock_fd > LONG_MAX ) {
/* this can occur on Win64, and actually there is a special
ugly printf formatter for decimal pointer length integer
printing , only bother if necessary */
PyErr_SetString ( PyExc_OverflowError ,
2002-06-06 23:08:35 -03:00
" no printf formatter to display "
" the socket descriptor in decimal " ) ;
2000-06-29 23:46:07 -03:00
return NULL ;
}
# endif
2002-06-06 23:08:35 -03:00
PyOS_snprintf (
buf , sizeof ( buf ) ,
" <socket object, fd=%ld, family=%d, type=%d, protocol=%d> " ,
( long ) s - > sock_fd , s - > sock_family ,
s - > sock_type ,
s - > sock_proto ) ;
1996-02-27 11:21:19 -04:00
return PyString_FromString ( buf ) ;
1995-01-02 15:30:30 -04:00
}
2001-10-27 19:20:47 -03:00
/* Create a new, uninitialized socket object. */
static PyObject *
2002-06-07 00:19:37 -03:00
sock_new ( PyTypeObject * type , PyObject * args , PyObject * kwds )
2001-10-27 19:20:47 -03:00
{
PyObject * new ;
new = type - > tp_alloc ( type , 0 ) ;
2002-06-06 17:08:25 -03:00
if ( new ! = NULL ) {
2001-10-27 19:20:47 -03:00
( ( PySocketSockObject * ) new ) - > sock_fd = - 1 ;
2002-06-06 18:08:16 -03:00
( ( PySocketSockObject * ) new ) - > sock_timeout = - 1.0 ;
2002-06-07 00:19:37 -03:00
( ( PySocketSockObject * ) new ) - > errorhandler = & set_error ;
2002-06-06 17:08:25 -03:00
}
2001-10-27 19:20:47 -03:00
return new ;
}
/* Initialize a new socket object. */
/*ARGSUSED*/
static int
2002-06-13 08:53:52 -03:00
sock_initobj ( PyObject * self , PyObject * args , PyObject * kwds )
2001-10-27 19:20:47 -03:00
{
PySocketSockObject * s = ( PySocketSockObject * ) self ;
SOCKET_T fd ;
int family = AF_INET , type = SOCK_STREAM , proto = 0 ;
2006-02-27 13:20:04 -04:00
static char * keywords [ ] = { " family " , " type " , " proto " , 0 } ;
2001-10-27 19:20:47 -03:00
if ( ! PyArg_ParseTupleAndKeywords ( args , kwds ,
" |iii:socket " , keywords ,
& family , & type , & proto ) )
return - 1 ;
2002-06-06 18:08:16 -03:00
2001-10-27 19:20:47 -03:00
Py_BEGIN_ALLOW_THREADS
fd = socket ( family , type , proto ) ;
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
2001-10-27 19:20:47 -03:00
# ifdef MS_WINDOWS
if ( fd = = INVALID_SOCKET )
# else
if ( fd < 0 )
# endif
{
2002-06-07 00:19:37 -03:00
set_error ( ) ;
2001-10-27 19:20:47 -03:00
return - 1 ;
}
init_sockobject ( s , fd , family , type , proto ) ;
2002-06-06 18:08:16 -03:00
2001-10-27 19:20:47 -03:00
return 0 ;
2002-06-06 18:08:16 -03:00
2001-10-27 19:20:47 -03:00
}
1994-08-01 08:34:53 -03:00
/* Type object for socket objects. */
1991-06-27 12:51:29 -03:00
2002-06-07 00:19:37 -03:00
static PyTypeObject sock_type = {
2007-07-21 03:55:02 -03:00
PyVarObject_HEAD_INIT ( 0 , 0 ) /* Must fill in type value later */
2001-10-28 08:31:33 -04:00
" _socket.socket " , /* tp_name */
2001-10-27 19:20:47 -03:00
sizeof ( PySocketSockObject ) , /* tp_basicsize */
0 , /* tp_itemsize */
2002-06-07 00:19:37 -03:00
( destructor ) sock_dealloc , /* tp_dealloc */
2001-10-27 19:20:47 -03:00
0 , /* tp_print */
0 , /* tp_getattr */
0 , /* tp_setattr */
0 , /* tp_compare */
2002-06-07 00:19:37 -03:00
( reprfunc ) sock_repr , /* tp_repr */
2001-10-27 19:20:47 -03:00
0 , /* tp_as_number */
0 , /* tp_as_sequence */
0 , /* tp_as_mapping */
0 , /* tp_hash */
0 , /* tp_call */
0 , /* tp_str */
2003-01-06 08:41:26 -04:00
PyObject_GenericGetAttr , /* tp_getattro */
2001-10-27 19:20:47 -03:00
0 , /* tp_setattro */
0 , /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE , /* tp_flags */
2002-06-07 00:19:37 -03:00
sock_doc , /* tp_doc */
2001-10-27 19:20:47 -03:00
0 , /* tp_traverse */
0 , /* tp_clear */
0 , /* tp_richcompare */
0 , /* tp_weaklistoffset */
0 , /* tp_iter */
0 , /* tp_iternext */
2002-06-07 00:19:37 -03:00
sock_methods , /* tp_methods */
2006-03-17 15:17:34 -04:00
sock_memberlist , /* tp_members */
2001-10-27 19:20:47 -03:00
0 , /* tp_getset */
0 , /* tp_base */
0 , /* tp_dict */
0 , /* tp_descr_get */
0 , /* tp_descr_set */
0 , /* tp_dictoffset */
2002-06-13 08:53:52 -03:00
sock_initobj , /* tp_init */
2003-01-06 08:41:26 -04:00
PyType_GenericAlloc , /* tp_alloc */
2002-06-07 00:19:37 -03:00
sock_new , /* tp_new */
2003-01-06 08:41:26 -04:00
PyObject_Del , /* tp_free */
1991-06-25 18:36:08 -03:00
} ;
1991-06-27 12:51:29 -03:00
1991-07-27 18:42:02 -03:00
/* Python interface to gethostname(). */
/*ARGSUSED*/
1994-10-10 14:59:00 -03:00
static PyObject *
2006-05-29 18:04:52 -03:00
socket_gethostname ( PyObject * self , PyObject * unused )
1991-07-27 18:42:02 -03:00
{
char buf [ 1024 ] ;
1992-08-05 16:58:53 -03:00
int res ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
res = gethostname ( buf , ( int ) sizeof buf - 1 ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
if ( res < 0 )
2002-06-07 00:19:37 -03:00
return set_error ( ) ;
1991-07-27 18:42:02 -03:00
buf [ sizeof buf - 1 ] = ' \0 ' ;
1994-10-10 14:59:00 -03:00
return PyString_FromString ( buf ) ;
1991-07-27 18:42:02 -03:00
}
1992-08-05 16:58:53 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( gethostname_doc ,
1998-07-07 17:45:43 -03:00
" gethostname() -> string \n \
\ n \
2002-06-13 17:33:02 -03:00
Return the current host name . " );
1998-07-07 17:45:43 -03:00
1992-08-05 16:58:53 -03:00
1991-06-27 12:51:29 -03:00
/* Python interface to gethostbyname(name). */
/*ARGSUSED*/
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_gethostbyname ( PyObject * self , PyObject * args )
1991-06-27 12:51:29 -03:00
{
1994-08-18 12:42:46 -03:00
char * name ;
2005-09-14 15:09:42 -03:00
sock_addr_t addrbuf ;
2001-07-21 15:05:31 -03:00
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s:gethostbyname " , & name ) )
1991-06-27 12:51:29 -03:00
return NULL ;
2006-12-03 07:23:45 -04:00
if ( setipaddr ( name , SAS2SA ( & addrbuf ) , sizeof ( addrbuf ) , AF_INET ) < 0 )
1991-06-27 12:51:29 -03:00
return NULL ;
2006-12-03 07:23:45 -04:00
return makeipaddr ( SAS2SA ( & addrbuf ) , sizeof ( struct sockaddr_in ) ) ;
1991-06-27 12:51:29 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( gethostbyname_doc ,
1998-07-07 17:45:43 -03:00
" gethostbyname(host) -> address \n \
\ n \
2002-06-13 17:33:02 -03:00
Return the IP address ( a string of the form ' 255.255 .255 .255 ' ) for a host . " ) ;
1998-07-07 17:45:43 -03:00
1998-08-04 19:16:43 -03:00
/* Convenience function common to gethostbyname_ex and gethostbyaddr */
1995-01-02 15:30:30 -04:00
static PyObject *
2001-07-21 15:05:31 -03:00
gethost_common ( struct hostent * h , struct sockaddr * addr , int alen , int af )
1998-08-04 19:16:43 -03:00
{
1996-02-27 11:21:19 -04:00
char * * pch ;
1995-01-02 15:30:30 -04:00
PyObject * rtn_tuple = ( PyObject * ) NULL ;
PyObject * name_list = ( PyObject * ) NULL ;
PyObject * addr_list = ( PyObject * ) NULL ;
PyObject * tmp ;
2001-07-21 15:05:31 -03:00
1995-01-02 15:30:30 -04:00
if ( h = = NULL ) {
2001-03-02 02:34:14 -04:00
/* Let's get real error message to return */
2001-10-24 17:42:55 -03:00
# ifndef RISCOS
2002-06-07 00:19:37 -03:00
set_herror ( h_errno ) ;
2001-10-24 17:42:55 -03:00
# else
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " host not found " ) ;
2001-10-24 17:42:55 -03:00
# endif
2001-07-21 15:05:31 -03:00
return NULL ;
}
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
if ( h - > h_addrtype ! = af ) {
# ifdef HAVE_STRERROR
2002-06-06 23:08:35 -03:00
/* Let's get real error message to return */
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2002-06-06 23:08:35 -03:00
( char * ) strerror ( EAFNOSUPPORT ) ) ;
# else
PyErr_SetString (
2002-06-07 00:19:37 -03:00
socket_error ,
2002-06-06 23:08:35 -03:00
" Address family not supported by protocol family " ) ;
1995-01-02 15:30:30 -04:00
# endif
return NULL ;
}
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
switch ( af ) {
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
case AF_INET :
if ( alen < sizeof ( struct sockaddr_in ) )
return NULL ;
break ;
2002-06-06 18:08:16 -03:00
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
if ( alen < sizeof ( struct sockaddr_in6 ) )
return NULL ;
break ;
# endif
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
}
2002-06-06 18:08:16 -03:00
1995-01-02 15:30:30 -04:00
if ( ( name_list = PyList_New ( 0 ) ) = = NULL )
goto err ;
2002-06-06 18:08:16 -03:00
1995-01-02 15:30:30 -04:00
if ( ( addr_list = PyList_New ( 0 ) ) = = NULL )
goto err ;
2002-06-06 18:08:16 -03:00
2006-08-14 19:10:24 -03:00
/* SF #1511317: h_aliases can be NULL */
if ( h - > h_aliases ) {
for ( pch = h - > h_aliases ; * pch ! = NULL ; pch + + ) {
int status ;
tmp = PyString_FromString ( * pch ) ;
if ( tmp = = NULL )
goto err ;
status = PyList_Append ( name_list , tmp ) ;
Py_DECREF ( tmp ) ;
if ( status )
goto err ;
}
1995-01-02 15:30:30 -04:00
}
2002-06-06 18:08:16 -03:00
1995-01-02 15:30:30 -04:00
for ( pch = h - > h_addr_list ; * pch ! = NULL ; pch + + ) {
1997-01-03 13:18:10 -04:00
int status ;
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
switch ( af ) {
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
case AF_INET :
{
struct sockaddr_in sin ;
memset ( & sin , 0 , sizeof ( sin ) ) ;
sin . sin_family = af ;
# ifdef HAVE_SOCKADDR_SA_LEN
sin . sin_len = sizeof ( sin ) ;
# endif
memcpy ( & sin . sin_addr , * pch , sizeof ( sin . sin_addr ) ) ;
tmp = makeipaddr ( ( struct sockaddr * ) & sin , sizeof ( sin ) ) ;
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
if ( pch = = h - > h_addr_list & & alen > = sizeof ( sin ) )
memcpy ( ( char * ) addr , & sin , sizeof ( sin ) ) ;
break ;
}
2002-06-06 18:08:16 -03:00
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
{
struct sockaddr_in6 sin6 ;
memset ( & sin6 , 0 , sizeof ( sin6 ) ) ;
sin6 . sin6_family = af ;
# ifdef HAVE_SOCKADDR_SA_LEN
sin6 . sin6_len = sizeof ( sin6 ) ;
# endif
memcpy ( & sin6 . sin6_addr , * pch , sizeof ( sin6 . sin6_addr ) ) ;
tmp = makeipaddr ( ( struct sockaddr * ) & sin6 ,
sizeof ( sin6 ) ) ;
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
if ( pch = = h - > h_addr_list & & alen > = sizeof ( sin6 ) )
memcpy ( ( char * ) addr , & sin6 , sizeof ( sin6 ) ) ;
break ;
}
# endif
2002-06-06 18:08:16 -03:00
2001-07-21 15:05:31 -03:00
default : /* can't happen */
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2002-06-06 23:08:35 -03:00
" unsupported address family " ) ;
2001-07-21 15:05:31 -03:00
return NULL ;
}
2002-06-06 18:08:16 -03:00
1995-01-02 15:30:30 -04:00
if ( tmp = = NULL )
goto err ;
2002-06-06 18:08:16 -03:00
1997-01-03 13:18:10 -04:00
status = PyList_Append ( addr_list , tmp ) ;
1995-01-02 15:30:30 -04:00
Py_DECREF ( tmp ) ;
2002-06-06 18:08:16 -03:00
1997-01-03 13:18:10 -04:00
if ( status )
goto err ;
1995-01-02 15:30:30 -04:00
}
2002-06-06 18:08:16 -03:00
1995-01-02 15:30:30 -04:00
rtn_tuple = Py_BuildValue ( " sOO " , h - > h_name , name_list , addr_list ) ;
2002-06-06 18:08:16 -03:00
1995-01-02 15:30:30 -04:00
err :
Py_XDECREF ( name_list ) ;
Py_XDECREF ( addr_list ) ;
return rtn_tuple ;
}
1998-08-04 19:16:43 -03:00
/* Python interface to gethostbyname_ex(name). */
/*ARGSUSED*/
static PyObject *
2002-06-07 00:19:37 -03:00
socket_gethostbyname_ex ( PyObject * self , PyObject * args )
1998-08-04 19:16:43 -03:00
{
char * name ;
struct hostent * h ;
2003-05-03 06:14:54 -03:00
# ifdef ENABLE_IPV6
struct sockaddr_storage addr ;
# else
struct sockaddr_in addr ;
# endif
2001-07-22 22:30:10 -03:00
struct sockaddr * sa ;
1999-03-22 16:14:53 -04:00
PyObject * ret ;
1998-08-04 19:16:43 -03:00
# ifdef HAVE_GETHOSTBYNAME_R
struct hostent hp_allocated ;
1999-03-24 13:20:40 -04:00
# ifdef HAVE_GETHOSTBYNAME_R_3_ARG
struct hostent_data data ;
# else
1998-08-04 19:16:43 -03:00
char buf [ 16384 ] ;
int buf_len = ( sizeof buf ) - 1 ;
int errnop ;
1999-03-24 13:20:40 -04:00
# endif
# if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
1999-03-15 17:40:14 -04:00
int result ;
# endif
1998-08-04 19:16:43 -03:00
# endif /* HAVE_GETHOSTBYNAME_R */
2001-07-21 15:05:31 -03:00
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s:gethostbyname_ex " , & name ) )
1998-08-04 19:16:43 -03:00
return NULL ;
2002-12-11 09:10:57 -04:00
if ( setipaddr ( name , ( struct sockaddr * ) & addr , sizeof ( addr ) , AF_INET ) < 0 )
1998-08-04 19:16:43 -03:00
return NULL ;
Py_BEGIN_ALLOW_THREADS
# ifdef HAVE_GETHOSTBYNAME_R
1999-03-24 13:20:40 -04:00
# if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
2002-06-06 23:08:35 -03:00
result = gethostbyname_r ( name , & hp_allocated , buf , buf_len ,
& h , & errnop ) ;
1999-03-24 13:20:40 -04:00
# elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
1998-08-04 19:16:43 -03:00
h = gethostbyname_r ( name , & hp_allocated , buf , buf_len , & errnop ) ;
1999-03-24 13:20:40 -04:00
# else /* HAVE_GETHOSTBYNAME_R_3_ARG */
1999-03-24 13:24:33 -04:00
memset ( ( void * ) & data , ' \0 ' , sizeof ( data ) ) ;
1999-03-24 13:20:40 -04:00
result = gethostbyname_r ( name , & hp_allocated , & data ) ;
h = ( result ! = 0 ) ? NULL : & hp_allocated ;
1999-03-15 17:40:14 -04:00
# endif
1998-08-04 19:16:43 -03:00
# else /* not HAVE_GETHOSTBYNAME_R */
1999-03-22 17:44:51 -04:00
# ifdef USE_GETHOSTBYNAME_LOCK
2003-05-09 04:53:18 -03:00
PyThread_acquire_lock ( netdb_lock , 1 ) ;
1998-08-04 19:16:43 -03:00
# endif
h = gethostbyname ( name ) ;
# endif /* HAVE_GETHOSTBYNAME_R */
Py_END_ALLOW_THREADS
2002-06-06 18:08:16 -03:00
/* Some C libraries would require addr.__ss_family instead of
2002-06-06 23:08:35 -03:00
addr . ss_family .
Therefore , we cast the sockaddr_storage into sockaddr to
access sa_family . */
2001-07-22 22:30:10 -03:00
sa = ( struct sockaddr * ) & addr ;
2002-06-06 18:08:16 -03:00
ret = gethost_common ( h , ( struct sockaddr * ) & addr , sizeof ( addr ) ,
2002-06-06 23:08:35 -03:00
sa - > sa_family ) ;
1999-03-22 17:44:51 -04:00
# ifdef USE_GETHOSTBYNAME_LOCK
2003-05-09 04:53:18 -03:00
PyThread_release_lock ( netdb_lock ) ;
1999-03-22 16:14:53 -04:00
# endif
return ret ;
1998-08-04 19:16:43 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( ghbn_ex_doc ,
1998-08-04 19:16:43 -03:00
" gethostbyname_ex(host) -> (name, aliaslist, addresslist) \n \
\ n \
Return the true host name , a list of aliases , and a list of IP addresses , \ n \
2002-06-13 17:33:02 -03:00
for a host . The host argument is a string giving a host name or IP number . " );
1998-08-04 19:16:43 -03:00
/* Python interface to gethostbyaddr(IP). */
/*ARGSUSED*/
static PyObject *
2002-06-07 00:19:37 -03:00
socket_gethostbyaddr ( PyObject * self , PyObject * args )
1998-08-04 19:16:43 -03:00
{
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2002-06-06 23:08:35 -03:00
struct sockaddr_storage addr ;
2001-07-21 15:05:31 -03:00
# else
2001-03-02 02:34:14 -04:00
struct sockaddr_in addr ;
2001-07-21 15:05:31 -03:00
# endif
struct sockaddr * sa = ( struct sockaddr * ) & addr ;
1998-08-04 19:16:43 -03:00
char * ip_num ;
struct hostent * h ;
1999-03-22 17:44:51 -04:00
PyObject * ret ;
1998-08-04 19:16:43 -03:00
# ifdef HAVE_GETHOSTBYNAME_R
struct hostent hp_allocated ;
1999-03-24 13:20:40 -04:00
# ifdef HAVE_GETHOSTBYNAME_R_3_ARG
struct hostent_data data ;
# else
1998-08-04 19:16:43 -03:00
char buf [ 16384 ] ;
int buf_len = ( sizeof buf ) - 1 ;
int errnop ;
1999-03-24 13:20:40 -04:00
# endif
# if defined(HAVE_GETHOSTBYNAME_R_3_ARG) || defined(HAVE_GETHOSTBYNAME_R_6_ARG)
1999-03-15 17:40:14 -04:00
int result ;
# endif
1998-08-04 19:16:43 -03:00
# endif /* HAVE_GETHOSTBYNAME_R */
2001-07-21 15:05:31 -03:00
char * ap ;
int al ;
int af ;
1998-08-04 19:16:43 -03:00
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s:gethostbyaddr " , & ip_num ) )
1998-08-04 19:16:43 -03:00
return NULL ;
2002-12-11 09:10:57 -04:00
af = AF_UNSPEC ;
2002-07-28 13:10:31 -03:00
if ( setipaddr ( ip_num , sa , sizeof ( addr ) , af ) < 0 )
2001-07-21 15:05:31 -03:00
return NULL ;
af = sa - > sa_family ;
ap = NULL ;
al = 0 ;
switch ( af ) {
case AF_INET :
ap = ( char * ) & ( ( struct sockaddr_in * ) sa ) - > sin_addr ;
al = sizeof ( ( ( struct sockaddr_in * ) sa ) - > sin_addr ) ;
break ;
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
ap = ( char * ) & ( ( struct sockaddr_in6 * ) sa ) - > sin6_addr ;
al = sizeof ( ( ( struct sockaddr_in6 * ) sa ) - > sin6_addr ) ;
break ;
# endif
default :
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " unsupported address family " ) ;
1998-08-04 19:16:43 -03:00
return NULL ;
2001-07-21 15:05:31 -03:00
}
1998-08-04 19:16:43 -03:00
Py_BEGIN_ALLOW_THREADS
# ifdef HAVE_GETHOSTBYNAME_R
1999-03-24 13:20:40 -04:00
# if defined(HAVE_GETHOSTBYNAME_R_6_ARG)
2001-07-21 15:05:31 -03:00
result = gethostbyaddr_r ( ap , al , af ,
& hp_allocated , buf , buf_len ,
1999-03-15 17:40:14 -04:00
& h , & errnop ) ;
1999-03-24 13:20:40 -04:00
# elif defined(HAVE_GETHOSTBYNAME_R_5_ARG)
2001-07-21 15:05:31 -03:00
h = gethostbyaddr_r ( ap , al , af ,
1998-08-04 19:16:43 -03:00
& hp_allocated , buf , buf_len , & errnop ) ;
1999-03-24 13:20:40 -04:00
# else /* HAVE_GETHOSTBYNAME_R_3_ARG */
1999-03-24 13:24:33 -04:00
memset ( ( void * ) & data , ' \0 ' , sizeof ( data ) ) ;
2001-07-21 15:05:31 -03:00
result = gethostbyaddr_r ( ap , al , af , & hp_allocated , & data ) ;
1999-03-24 13:20:40 -04:00
h = ( result ! = 0 ) ? NULL : & hp_allocated ;
1999-03-15 17:40:14 -04:00
# endif
1998-08-04 19:16:43 -03:00
# else /* not HAVE_GETHOSTBYNAME_R */
1999-03-22 17:44:51 -04:00
# ifdef USE_GETHOSTBYNAME_LOCK
2003-05-09 04:53:18 -03:00
PyThread_acquire_lock ( netdb_lock , 1 ) ;
1998-08-04 19:16:43 -03:00
# endif
2001-07-21 15:05:31 -03:00
h = gethostbyaddr ( ap , al , af ) ;
1998-08-04 19:16:43 -03:00
# endif /* HAVE_GETHOSTBYNAME_R */
Py_END_ALLOW_THREADS
2001-07-21 15:05:31 -03:00
ret = gethost_common ( h , ( struct sockaddr * ) & addr , sizeof ( addr ) , af ) ;
1999-03-22 17:44:51 -04:00
# ifdef USE_GETHOSTBYNAME_LOCK
2003-05-09 04:53:18 -03:00
PyThread_release_lock ( netdb_lock ) ;
1999-03-22 17:44:51 -04:00
# endif
return ret ;
1998-08-04 19:16:43 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( gethostbyaddr_doc ,
1998-07-07 17:45:43 -03:00
" gethostbyaddr(host) -> (name, aliaslist, addresslist) \n \
\ n \
Return the true host name , a list of aliases , and a list of IP addresses , \ n \
2002-06-13 17:33:02 -03:00
for a host . The host argument is a string giving a host name or IP number . " );
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
/* Python interface to getservbyname(name).
This only returns the port number , since the other info is already
known or not useful ( like the list of aliases ) . */
/*ARGSUSED*/
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_getservbyname ( PyObject * self , PyObject * args )
1991-06-27 12:51:29 -03:00
{
2004-06-27 21:50:43 -03:00
char * name , * proto = NULL ;
1991-06-27 12:51:29 -03:00
struct servent * sp ;
2004-06-27 21:50:43 -03:00
if ( ! PyArg_ParseTuple ( args , " s|s:getservbyname " , & name , & proto ) )
1991-06-27 12:51:29 -03:00
return NULL ;
1994-10-10 14:59:00 -03:00
Py_BEGIN_ALLOW_THREADS
1992-08-05 16:58:53 -03:00
sp = getservbyname ( name , proto ) ;
1994-10-10 14:59:00 -03:00
Py_END_ALLOW_THREADS
1991-06-27 12:51:29 -03:00
if ( sp = = NULL ) {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " service/proto not found " ) ;
1991-06-27 12:51:29 -03:00
return NULL ;
}
1994-10-10 14:59:00 -03:00
return PyInt_FromLong ( ( long ) ntohs ( sp - > s_port ) ) ;
1991-06-27 12:51:29 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getservbyname_doc ,
2004-06-27 21:50:43 -03:00
" getservbyname(servicename[, protocolname]) -> integer \n \
1998-07-07 17:45:43 -03:00
\ n \
Return a port number from a service name and protocol name . \ n \
2004-06-27 21:50:43 -03:00
The optional protocol name , if given , should be ' tcp ' or ' udp ' , \ n \
otherwise any protocol will match . " );
1998-07-07 17:45:43 -03:00
1991-06-27 12:51:29 -03:00
2004-06-27 21:50:43 -03:00
/* Python interface to getservbyport(port).
This only returns the service name , since the other info is already
known or not useful ( like the list of aliases ) . */
/*ARGSUSED*/
static PyObject *
socket_getservbyport ( PyObject * self , PyObject * args )
{
2004-09-27 23:19:40 -03:00
unsigned short port ;
2004-06-27 21:50:43 -03:00
char * proto = NULL ;
struct servent * sp ;
2004-09-27 23:19:40 -03:00
if ( ! PyArg_ParseTuple ( args , " H|s:getservbyport " , & port , & proto ) )
2004-06-27 21:50:43 -03:00
return NULL ;
Py_BEGIN_ALLOW_THREADS
sp = getservbyport ( htons ( port ) , proto ) ;
Py_END_ALLOW_THREADS
if ( sp = = NULL ) {
PyErr_SetString ( socket_error , " port/proto not found " ) ;
return NULL ;
}
return PyString_FromString ( sp - > s_name ) ;
}
PyDoc_STRVAR ( getservbyport_doc ,
" getservbyport(port[, protocolname]) -> string \n \
\ n \
Return the service name from a port number and protocol name . \ n \
The optional protocol name , if given , should be ' tcp ' or ' udp ' , \ n \
otherwise any protocol will match . " );
1996-12-19 12:35:04 -04:00
/* Python interface to getprotobyname(name).
This only returns the protocol number , since the other info is
already known or not useful ( like the list of aliases ) . */
/*ARGSUSED*/
static PyObject *
2002-06-07 00:19:37 -03:00
socket_getprotobyname ( PyObject * self , PyObject * args )
1996-12-19 12:35:04 -04:00
{
char * name ;
struct protoent * sp ;
1998-08-04 19:53:56 -03:00
# ifdef __BEOS__
/* Not available in BeOS yet. - [cjh] */
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " getprotobyname not supported " ) ;
1998-08-04 19:53:56 -03:00
return NULL ;
# else
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s:getprotobyname " , & name ) )
1996-12-19 12:35:04 -04:00
return NULL ;
Py_BEGIN_ALLOW_THREADS
sp = getprotobyname ( name ) ;
Py_END_ALLOW_THREADS
if ( sp = = NULL ) {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " protocol not found " ) ;
1996-12-19 12:35:04 -04:00
return NULL ;
}
return PyInt_FromLong ( ( long ) sp - > p_proto ) ;
1998-08-04 19:53:56 -03:00
# endif
1996-12-19 12:35:04 -04:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getprotobyname_doc ,
1998-07-07 17:45:43 -03:00
" getprotobyname(name) -> integer \n \
\ n \
2002-06-13 17:33:02 -03:00
Return the protocol number for the named protocol . ( Rarely used . ) " );
1998-07-07 17:45:43 -03:00
1996-12-19 12:35:04 -04:00
2004-08-09 01:51:41 -03:00
# ifdef HAVE_SOCKETPAIR
/* Create a pair of sockets using the socketpair() function.
2004-08-23 02:16:23 -03:00
Arguments as for socket ( ) except the default family is AF_UNIX if
2004-08-25 21:51:16 -03:00
defined on the platform ; otherwise , the default is AF_INET . */
2004-08-09 01:51:41 -03:00
/*ARGSUSED*/
static PyObject *
socket_socketpair ( PyObject * self , PyObject * args )
{
PySocketSockObject * s0 = NULL , * s1 = NULL ;
SOCKET_T sv [ 2 ] ;
int family , type = SOCK_STREAM , proto = 0 ;
PyObject * res = NULL ;
# if defined(AF_UNIX)
family = AF_UNIX ;
# else
family = AF_INET ;
# endif
if ( ! PyArg_ParseTuple ( args , " |iii:socketpair " ,
& family , & type , & proto ) )
return NULL ;
/* Create a pair of socket fds */
if ( socketpair ( family , type , proto , sv ) < 0 )
return set_error ( ) ;
s0 = new_sockobject ( sv [ 0 ] , family , type , proto ) ;
if ( s0 = = NULL )
goto finally ;
s1 = new_sockobject ( sv [ 1 ] , family , type , proto ) ;
if ( s1 = = NULL )
goto finally ;
res = PyTuple_Pack ( 2 , s0 , s1 ) ;
finally :
if ( res = = NULL ) {
if ( s0 = = NULL )
SOCKETCLOSE ( sv [ 0 ] ) ;
if ( s1 = = NULL )
SOCKETCLOSE ( sv [ 1 ] ) ;
}
Py_XDECREF ( s0 ) ;
Py_XDECREF ( s1 ) ;
return res ;
}
PyDoc_STRVAR ( socketpair_doc ,
" socketpair([family[, type[, proto]]]) -> (socket object, socket object) \n \
\ n \
Create a pair of socket objects from the sockets returned by the platform \ n \
socketpair ( ) function . \ n \
2004-08-23 02:16:23 -03:00
The arguments are the same as for socket ( ) except the default family is \ n \
2004-08-25 21:51:16 -03:00
AF_UNIX if defined on the platform ; otherwise , the default is AF_INET . " );
2004-08-09 01:51:41 -03:00
# endif /* HAVE_SOCKETPAIR */
1994-08-18 12:42:46 -03:00
# ifndef NO_DUP
1992-12-08 09:38:24 -04:00
/* Create a socket object from a numeric file description.
Useful e . g . if stdin is a socket .
Additional arguments as for socket ( ) . */
/*ARGSUSED*/
1994-10-10 14:59:00 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_fromfd ( PyObject * self , PyObject * args )
1992-12-08 09:38:24 -04:00
{
1994-10-10 14:59:00 -03:00
PySocketSockObject * s ;
2000-06-29 23:46:07 -03:00
SOCKET_T fd ;
int family , type , proto = 0 ;
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " iii|i:fromfd " ,
& fd , & family , & type , & proto ) )
1996-06-20 13:25:29 -03:00
return NULL ;
* mymalloc.h: always allocate one extra byte, since some malloc's
return NULL for malloc(0) or realloc(p, 0). (This should be done
differently than wasting one byte, but alas...)
* Moved "add'l libraries" option in Makefile to an earlier place.
* Remove argument compatibility hacks (b) and (c).
* Add grey2mono, dither2mono and mono2grey to imageop.
* Dup the fd in socket.fromfd().
* Added new modules mpz, md5 (by JH, requiring GNU MP 1.2). Affects
Makefile and config.c.
* socketmodule.c: added socket.fromfd(fd, family, type, [proto]),
converted socket() to use of getargs().
1992-12-14 12:59:51 -04:00
/* Dup the fd so it and the socket can be closed independently */
fd = dup ( fd ) ;
if ( fd < 0 )
2002-06-07 00:19:37 -03:00
return set_error ( ) ;
s = new_sockobject ( fd , family , type , proto ) ;
1994-10-10 14:59:00 -03:00
return ( PyObject * ) s ;
1992-12-08 09:38:24 -04:00
}
1998-07-07 17:45:43 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( fromfd_doc ,
1998-07-07 17:45:43 -03:00
" fromfd(fd, family, type[, proto]) -> socket object \n \
\ n \
2006-04-01 03:33:08 -04:00
Create a socket object from a duplicate of the given \ n \
file descriptor . \ n \
2002-06-13 17:33:02 -03:00
The remaining arguments are the same as for socket ( ) . " ) ;
1998-07-07 17:45:43 -03:00
1994-08-18 12:42:46 -03:00
# endif /* NO_DUP */
1992-12-08 09:38:24 -04:00
1998-07-07 17:45:43 -03:00
1996-06-12 01:04:55 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_ntohs ( PyObject * self , PyObject * args )
1996-06-12 01:04:55 -03:00
{
int x1 , x2 ;
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " i:ntohs " , & x1 ) ) {
1996-06-12 01:04:55 -03:00
return NULL ;
}
2007-01-14 13:03:32 -04:00
if ( x1 < 0 ) {
PyErr_SetString ( PyExc_OverflowError ,
" can't convert negative number to unsigned long " ) ;
return NULL ;
}
x2 = ( unsigned int ) ntohs ( ( unsigned short ) x1 ) ;
1996-06-12 01:04:55 -03:00
return PyInt_FromLong ( x2 ) ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( ntohs_doc ,
1998-07-07 17:45:43 -03:00
" ntohs(integer) -> integer \n \
\ n \
2002-06-13 17:33:02 -03:00
Convert a 16 - bit integer from network to host byte order . " );
1998-07-07 17:45:43 -03:00
1996-06-12 01:04:55 -03:00
static PyObject *
2002-07-25 13:01:12 -03:00
socket_ntohl ( PyObject * self , PyObject * arg )
1996-06-12 01:04:55 -03:00
{
2002-07-25 13:01:12 -03:00
unsigned long x ;
1996-06-12 01:04:55 -03:00
2002-07-25 13:01:12 -03:00
if ( PyInt_Check ( arg ) ) {
x = PyInt_AS_LONG ( arg ) ;
2002-07-25 13:37:51 -03:00
if ( x = = ( unsigned long ) - 1 & & PyErr_Occurred ( ) )
return NULL ;
2007-01-14 13:03:32 -04:00
if ( ( long ) x < 0 ) {
PyErr_SetString ( PyExc_OverflowError ,
" can't convert negative number to unsigned long " ) ;
return NULL ;
}
1996-06-12 01:04:55 -03:00
}
2002-07-25 13:01:12 -03:00
else if ( PyLong_Check ( arg ) ) {
x = PyLong_AsUnsignedLong ( arg ) ;
2002-07-25 13:37:51 -03:00
if ( x = = ( unsigned long ) - 1 & & PyErr_Occurred ( ) )
return NULL ;
2002-07-25 13:01:12 -03:00
# if SIZEOF_LONG > 4
{
unsigned long y ;
/* only want the trailing 32 bits */
y = x & 0xFFFFFFFFUL ;
if ( y ^ x )
return PyErr_Format ( PyExc_OverflowError ,
" long int larger than 32 bits " ) ;
x = y ;
2002-08-06 19:25:02 -03:00
}
2002-07-25 13:01:12 -03:00
# endif
}
else
2002-08-06 19:25:02 -03:00
return PyErr_Format ( PyExc_TypeError ,
2002-07-25 13:01:12 -03:00
" expected int/long, %s found " ,
2007-12-18 22:37:44 -04:00
Py_TYPE ( arg ) - > tp_name ) ;
2002-07-25 13:01:12 -03:00
if ( x = = ( unsigned long ) - 1 & & PyErr_Occurred ( ) )
return NULL ;
2007-01-14 13:03:32 -04:00
return PyLong_FromUnsignedLong ( ntohl ( x ) ) ;
1996-06-12 01:04:55 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( ntohl_doc ,
1998-07-07 17:45:43 -03:00
" ntohl(integer) -> integer \n \
\ n \
2002-06-13 17:33:02 -03:00
Convert a 32 - bit integer from network to host byte order . " );
1998-07-07 17:45:43 -03:00
1996-06-12 01:04:55 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_htons ( PyObject * self , PyObject * args )
1996-06-12 01:04:55 -03:00
{
2003-12-17 05:40:23 -04:00
int x1 , x2 ;
1996-06-12 01:04:55 -03:00
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " i:htons " , & x1 ) ) {
1996-06-12 01:04:55 -03:00
return NULL ;
}
2007-01-14 13:03:32 -04:00
if ( x1 < 0 ) {
PyErr_SetString ( PyExc_OverflowError ,
" can't convert negative number to unsigned long " ) ;
return NULL ;
}
x2 = ( unsigned int ) htons ( ( unsigned short ) x1 ) ;
1996-06-12 01:04:55 -03:00
return PyInt_FromLong ( x2 ) ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( htons_doc ,
1998-07-07 17:45:43 -03:00
" htons(integer) -> integer \n \
\ n \
2002-06-13 17:33:02 -03:00
Convert a 16 - bit integer from host to network byte order . " );
1998-07-07 17:45:43 -03:00
1996-06-12 01:04:55 -03:00
static PyObject *
2002-07-25 13:01:12 -03:00
socket_htonl ( PyObject * self , PyObject * arg )
1996-06-12 01:04:55 -03:00
{
2002-07-25 13:01:12 -03:00
unsigned long x ;
1996-06-12 01:04:55 -03:00
2002-07-25 13:01:12 -03:00
if ( PyInt_Check ( arg ) ) {
x = PyInt_AS_LONG ( arg ) ;
2002-07-25 13:37:51 -03:00
if ( x = = ( unsigned long ) - 1 & & PyErr_Occurred ( ) )
return NULL ;
2007-01-14 13:03:32 -04:00
if ( ( long ) x < 0 ) {
PyErr_SetString ( PyExc_OverflowError ,
" can't convert negative number to unsigned long " ) ;
return NULL ;
}
1996-06-12 01:04:55 -03:00
}
2002-07-25 13:01:12 -03:00
else if ( PyLong_Check ( arg ) ) {
x = PyLong_AsUnsignedLong ( arg ) ;
2002-07-25 13:37:51 -03:00
if ( x = = ( unsigned long ) - 1 & & PyErr_Occurred ( ) )
return NULL ;
2002-07-25 13:01:12 -03:00
# if SIZEOF_LONG > 4
{
unsigned long y ;
/* only want the trailing 32 bits */
y = x & 0xFFFFFFFFUL ;
if ( y ^ x )
return PyErr_Format ( PyExc_OverflowError ,
" long int larger than 32 bits " ) ;
x = y ;
2002-08-06 19:25:02 -03:00
}
2002-07-25 13:01:12 -03:00
# endif
}
else
2002-08-06 19:25:02 -03:00
return PyErr_Format ( PyExc_TypeError ,
2002-07-25 13:01:12 -03:00
" expected int/long, %s found " ,
2007-12-18 22:37:44 -04:00
Py_TYPE ( arg ) - > tp_name ) ;
2007-01-14 13:03:32 -04:00
return PyLong_FromUnsignedLong ( htonl ( ( unsigned long ) x ) ) ;
1996-06-12 01:04:55 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( htonl_doc ,
1998-07-07 17:45:43 -03:00
" htonl(integer) -> integer \n \
\ n \
2002-06-13 17:33:02 -03:00
Convert a 32 - bit integer from host to network byte order . " );
1998-07-07 17:45:43 -03:00
2002-06-06 23:08:35 -03:00
/* socket.inet_aton() and socket.inet_ntoa() functions. */
1999-08-20 15:21:51 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( inet_aton_doc ,
1999-08-20 15:21:51 -03:00
" inet_aton(string) -> packed 32-bit IP representation \n \
\ n \
1999-08-20 16:11:27 -03:00
Convert an IP address in string format ( 123.45 .67 .89 ) to the 32 - bit packed \ n \
2002-06-13 17:33:02 -03:00
binary format used in low - level network functions . " );
1999-08-20 15:21:51 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_inet_aton ( PyObject * self , PyObject * args )
1999-08-20 15:21:51 -03:00
{
1999-09-09 12:42:59 -03:00
# ifndef INADDR_NONE
# define INADDR_NONE (-1)
# endif
2003-02-12 22:15:42 -04:00
# ifdef HAVE_INET_ATON
2003-02-12 19:08:22 -04:00
struct in_addr buf ;
2006-04-23 08:59:25 -03:00
# endif
# if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
2003-02-12 23:13:40 -04:00
/* Have to use inet_addr() instead */
unsigned long packed_addr ;
# endif
char * ip_addr ;
1999-08-20 16:11:27 -03:00
2003-02-12 23:13:40 -04:00
if ( ! PyArg_ParseTuple ( args , " s:inet_aton " , & ip_addr ) )
1999-08-20 16:11:27 -03:00
return NULL ;
2003-02-12 19:08:22 -04:00
2003-02-12 23:13:40 -04:00
# ifdef HAVE_INET_ATON
2006-04-23 08:59:25 -03:00
# ifdef USE_INET_ATON_WEAKLINK
if ( inet_aton ! = NULL ) {
# endif
2003-02-12 19:08:22 -04:00
if ( inet_aton ( ip_addr , & buf ) )
return PyString_FromStringAndSize ( ( char * ) ( & buf ) ,
sizeof ( buf ) ) ;
PyErr_SetString ( socket_error ,
" illegal IP address string passed to inet_aton " ) ;
return NULL ;
2006-04-23 08:59:25 -03:00
# ifdef USE_INET_ATON_WEAKLINK
} else {
# endif
# endif
# if !defined(HAVE_INET_ATON) || defined(USE_INET_ATON_WEAKLINK)
2005-08-26 05:34:00 -03:00
/* special-case this address as inet_addr might return INADDR_NONE
* for this */
if ( strcmp ( ip_addr , " 255.255.255.255 " ) = = 0 ) {
packed_addr = 0xFFFFFFFF ;
} else {
2006-05-26 09:03:27 -03:00
2005-08-26 05:34:00 -03:00
packed_addr = inet_addr ( ip_addr ) ;
1999-08-20 16:11:27 -03:00
2005-08-26 05:34:00 -03:00
if ( packed_addr = = INADDR_NONE ) { /* invalid address */
PyErr_SetString ( socket_error ,
" illegal IP address string passed to inet_aton " ) ;
return NULL ;
}
1999-08-20 16:11:27 -03:00
}
return PyString_FromStringAndSize ( ( char * ) & packed_addr ,
sizeof ( packed_addr ) ) ;
2006-04-23 08:59:25 -03:00
# ifdef USE_INET_ATON_WEAKLINK
}
# endif
2003-02-12 19:08:22 -04:00
# endif
1999-08-20 15:21:51 -03:00
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( inet_ntoa_doc ,
2000-03-07 10:05:16 -04:00
" inet_ntoa(packed_ip) -> ip_address_string \n \
1999-08-20 15:21:51 -03:00
\ n \
2002-06-13 17:33:02 -03:00
Convert an IP address from 32 - bit packed binary format to string format " );
1999-08-20 15:21:51 -03:00
static PyObject *
2002-06-07 00:19:37 -03:00
socket_inet_ntoa ( PyObject * self , PyObject * args )
1999-08-20 15:21:51 -03:00
{
char * packed_str ;
1999-08-20 16:11:27 -03:00
int addr_len ;
1999-08-20 15:21:51 -03:00
struct in_addr packed_addr ;
2000-03-24 16:56:56 -04:00
if ( ! PyArg_ParseTuple ( args , " s#:inet_ntoa " , & packed_str , & addr_len ) ) {
1999-08-20 15:21:51 -03:00
return NULL ;
}
2001-03-02 02:34:14 -04:00
1999-08-20 15:21:51 -03:00
if ( addr_len ! = sizeof ( packed_addr ) ) {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
1999-08-20 15:21:51 -03:00
" packed IP wrong length for inet_ntoa " ) ;
return NULL ;
}
memcpy ( & packed_addr , packed_str , addr_len ) ;
return PyString_FromString ( inet_ntoa ( packed_addr ) ) ;
}
1998-07-07 17:45:43 -03:00
2003-04-25 02:48:32 -03:00
# ifdef HAVE_INET_PTON
PyDoc_STRVAR ( inet_pton_doc ,
" inet_pton(af, ip) -> packed IP address string \n \
\ n \
Convert an IP address from string format to a packed string suitable \ n \
for use with low - level network functions . " );
static PyObject *
socket_inet_pton ( PyObject * self , PyObject * args )
{
int af ;
char * ip ;
int retval ;
2003-05-10 04:36:56 -03:00
# ifdef ENABLE_IPV6
2003-04-25 02:48:32 -03:00
char packed [ MAX ( sizeof ( struct in_addr ) , sizeof ( struct in6_addr ) ) ] ;
2003-05-10 04:36:56 -03:00
# else
char packed [ sizeof ( struct in_addr ) ] ;
# endif
2003-04-25 02:48:32 -03:00
if ( ! PyArg_ParseTuple ( args , " is:inet_pton " , & af , & ip ) ) {
return NULL ;
}
2004-06-02 09:35:29 -03:00
# if !defined(ENABLE_IPV6) && defined(AF_INET6)
2003-08-05 03:25:06 -03:00
if ( af = = AF_INET6 ) {
PyErr_SetString ( socket_error ,
" can't use AF_INET6, IPv6 is disabled " ) ;
return NULL ;
}
2006-05-26 09:03:27 -03:00
# endif
2003-08-05 03:25:06 -03:00
2003-04-25 02:48:32 -03:00
retval = inet_pton ( af , ip , packed ) ;
if ( retval < 0 ) {
PyErr_SetFromErrno ( socket_error ) ;
return NULL ;
} else if ( retval = = 0 ) {
PyErr_SetString ( socket_error ,
" illegal IP address string passed to inet_pton " ) ;
return NULL ;
} else if ( af = = AF_INET ) {
return PyString_FromStringAndSize ( packed ,
sizeof ( struct in_addr ) ) ;
2003-05-10 04:36:56 -03:00
# ifdef ENABLE_IPV6
2003-04-25 02:48:32 -03:00
} else if ( af = = AF_INET6 ) {
return PyString_FromStringAndSize ( packed ,
sizeof ( struct in6_addr ) ) ;
2003-05-10 04:36:56 -03:00
# endif
2003-04-25 02:48:32 -03:00
} else {
PyErr_SetString ( socket_error , " unknown address family " ) ;
return NULL ;
}
}
2006-05-26 09:03:27 -03:00
2003-04-25 02:48:32 -03:00
PyDoc_STRVAR ( inet_ntop_doc ,
" inet_ntop(af, packed_ip) -> string formatted IP address \n \
\ n \
Convert a packed IP address of the given family to string format . " );
static PyObject *
socket_inet_ntop ( PyObject * self , PyObject * args )
{
int af ;
char * packed ;
int len ;
const char * retval ;
2003-05-10 04:36:56 -03:00
# ifdef ENABLE_IPV6
2003-04-25 02:48:32 -03:00
char ip [ MAX ( INET_ADDRSTRLEN , INET6_ADDRSTRLEN ) + 1 ] ;
2003-05-10 04:36:56 -03:00
# else
char ip [ INET_ADDRSTRLEN + 1 ] ;
# endif
2006-05-26 09:03:27 -03:00
2003-04-25 02:48:32 -03:00
/* Guarantee NUL-termination for PyString_FromString() below */
2004-11-07 10:24:25 -04:00
memset ( ( void * ) & ip [ 0 ] , ' \0 ' , sizeof ( ip ) ) ;
2003-04-25 02:48:32 -03:00
if ( ! PyArg_ParseTuple ( args , " is#:inet_ntop " , & af , & packed , & len ) ) {
return NULL ;
}
if ( af = = AF_INET ) {
if ( len ! = sizeof ( struct in_addr ) ) {
PyErr_SetString ( PyExc_ValueError ,
" invalid length of packed IP address string " ) ;
return NULL ;
}
2003-05-10 04:36:56 -03:00
# ifdef ENABLE_IPV6
2003-04-25 02:48:32 -03:00
} else if ( af = = AF_INET6 ) {
if ( len ! = sizeof ( struct in6_addr ) ) {
PyErr_SetString ( PyExc_ValueError ,
" invalid length of packed IP address string " ) ;
return NULL ;
}
2003-05-10 04:36:56 -03:00
# endif
2003-04-25 02:48:32 -03:00
} else {
PyErr_Format ( PyExc_ValueError ,
" unknown address family %d " , af ) ;
return NULL ;
}
retval = inet_ntop ( af , packed , ip , sizeof ( ip ) ) ;
if ( ! retval ) {
PyErr_SetFromErrno ( socket_error ) ;
return NULL ;
} else {
return PyString_FromString ( retval ) ;
}
/* NOTREACHED */
PyErr_SetString ( PyExc_RuntimeError , " invalid handling of inet_ntop " ) ;
return NULL ;
}
# endif /* HAVE_INET_PTON */
2001-07-21 15:05:31 -03:00
/* Python interface to getaddrinfo(host, port). */
/*ARGSUSED*/
static PyObject *
2002-06-07 00:19:37 -03:00
socket_getaddrinfo ( PyObject * self , PyObject * args )
2001-07-21 15:05:31 -03:00
{
2001-11-07 04:31:03 -04:00
struct addrinfo hints , * res ;
struct addrinfo * res0 = NULL ;
2003-04-18 07:39:54 -03:00
PyObject * hobj = NULL ;
2001-07-21 15:05:31 -03:00
PyObject * pobj = ( PyObject * ) NULL ;
2001-08-12 06:28:40 -03:00
char pbuf [ 30 ] ;
2001-07-21 15:05:31 -03:00
char * hptr , * pptr ;
int family , socktype , protocol , flags ;
int error ;
PyObject * all = ( PyObject * ) NULL ;
PyObject * single = ( PyObject * ) NULL ;
2003-04-18 07:39:54 -03:00
PyObject * idna = NULL ;
2001-07-21 15:05:31 -03:00
family = socktype = protocol = flags = 0 ;
2002-12-11 09:10:57 -04:00
family = AF_UNSPEC ;
2003-04-18 07:39:54 -03:00
if ( ! PyArg_ParseTuple ( args , " OO|iiii:getaddrinfo " ,
& hobj , & pobj , & family , & socktype ,
& protocol , & flags ) ) {
return NULL ;
}
if ( hobj = = Py_None ) {
hptr = NULL ;
} else if ( PyUnicode_Check ( hobj ) ) {
idna = PyObject_CallMethod ( hobj , " encode " , " s " , " idna " ) ;
if ( ! idna )
return NULL ;
hptr = PyString_AsString ( idna ) ;
} else if ( PyString_Check ( hobj ) ) {
hptr = PyString_AsString ( hobj ) ;
} else {
2006-05-26 09:03:27 -03:00
PyErr_SetString ( PyExc_TypeError ,
2003-04-18 07:39:54 -03:00
" getaddrinfo() argument 1 must be string or None " ) ;
2001-07-21 15:05:31 -03:00
return NULL ;
}
if ( PyInt_Check ( pobj ) ) {
2001-07-31 15:05:33 -03:00
PyOS_snprintf ( pbuf , sizeof ( pbuf ) , " %ld " , PyInt_AsLong ( pobj ) ) ;
2001-07-21 15:05:31 -03:00
pptr = pbuf ;
} else if ( PyString_Check ( pobj ) ) {
pptr = PyString_AsString ( pobj ) ;
} else if ( pobj = = Py_None ) {
pptr = ( char * ) NULL ;
} else {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error , " Int or String expected " ) ;
2003-08-07 08:55:15 -03:00
goto err ;
2001-07-21 15:05:31 -03:00
}
memset ( & hints , 0 , sizeof ( hints ) ) ;
hints . ai_family = family ;
hints . ai_socktype = socktype ;
hints . ai_protocol = protocol ;
hints . ai_flags = flags ;
2003-05-09 04:53:18 -03:00
Py_BEGIN_ALLOW_THREADS
ACQUIRE_GETADDRINFO_LOCK
2001-07-21 15:05:31 -03:00
error = getaddrinfo ( hptr , pptr , & hints , & res0 ) ;
2003-05-09 04:53:18 -03:00
Py_END_ALLOW_THREADS
RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
2001-07-21 15:05:31 -03:00
if ( error ) {
2002-06-07 00:19:37 -03:00
set_gaierror ( error ) ;
2003-08-07 08:55:15 -03:00
goto err ;
2001-07-21 15:05:31 -03:00
}
if ( ( all = PyList_New ( 0 ) ) = = NULL )
goto err ;
for ( res = res0 ; res ; res = res - > ai_next ) {
2001-10-12 15:59:27 -03:00
PyObject * addr =
2004-06-03 06:24:42 -03:00
makesockaddr ( - 1 , res - > ai_addr , res - > ai_addrlen , protocol ) ;
2001-10-12 15:59:27 -03:00
if ( addr = = NULL )
goto err ;
2001-07-21 15:05:31 -03:00
single = Py_BuildValue ( " iiisO " , res - > ai_family ,
res - > ai_socktype , res - > ai_protocol ,
res - > ai_canonname ? res - > ai_canonname : " " ,
2001-10-12 15:59:27 -03:00
addr ) ;
Py_DECREF ( addr ) ;
2001-07-21 15:05:31 -03:00
if ( single = = NULL )
goto err ;
if ( PyList_Append ( all , single ) )
goto err ;
Py_XDECREF ( single ) ;
}
2003-04-18 07:39:54 -03:00
Py_XDECREF ( idna ) ;
2002-08-09 00:37:42 -03:00
if ( res0 )
freeaddrinfo ( res0 ) ;
2001-07-21 15:05:31 -03:00
return all ;
err :
Py_XDECREF ( single ) ;
Py_XDECREF ( all ) ;
2003-04-18 07:39:54 -03:00
Py_XDECREF ( idna ) ;
2001-11-07 04:31:03 -04:00
if ( res0 )
freeaddrinfo ( res0 ) ;
2001-07-21 15:05:31 -03:00
return ( PyObject * ) NULL ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getaddrinfo_doc ,
2002-08-08 17:37:08 -03:00
" getaddrinfo(host, port [, family, socktype, proto, flags]) \n \
- > list of ( family , socktype , proto , canonname , sockaddr ) \ n \
2001-07-21 15:05:31 -03:00
\ n \
2002-06-13 17:33:02 -03:00
Resolve host and port into addrinfo struct . " );
2001-07-21 15:05:31 -03:00
/* Python interface to getnameinfo(sa, flags). */
/*ARGSUSED*/
static PyObject *
2002-06-07 00:19:37 -03:00
socket_getnameinfo ( PyObject * self , PyObject * args )
2001-07-21 15:05:31 -03:00
{
PyObject * sa = ( PyObject * ) NULL ;
int flags ;
char * hostp ;
2001-11-02 19:34:52 -04:00
int port , flowinfo , scope_id ;
2001-07-21 15:05:31 -03:00
char hbuf [ NI_MAXHOST ] , pbuf [ NI_MAXSERV ] ;
struct addrinfo hints , * res = NULL ;
int error ;
PyObject * ret = ( PyObject * ) NULL ;
flags = flowinfo = scope_id = 0 ;
2001-11-02 19:34:52 -04:00
if ( ! PyArg_ParseTuple ( args , " Oi:getnameinfo " , & sa , & flags ) )
return NULL ;
2002-06-06 23:08:35 -03:00
if ( ! PyArg_ParseTuple ( sa , " si|ii " ,
& hostp , & port , & flowinfo , & scope_id ) )
2001-07-21 15:05:31 -03:00
return NULL ;
2001-07-31 15:05:33 -03:00
PyOS_snprintf ( pbuf , sizeof ( pbuf ) , " %d " , port ) ;
2001-07-21 15:05:31 -03:00
memset ( & hints , 0 , sizeof ( hints ) ) ;
2002-12-11 09:10:57 -04:00
hints . ai_family = AF_UNSPEC ;
2001-08-04 19:37:23 -03:00
hints . ai_socktype = SOCK_DGRAM ; /* make numeric port happy */
2003-05-09 04:53:18 -03:00
Py_BEGIN_ALLOW_THREADS
ACQUIRE_GETADDRINFO_LOCK
2001-07-21 15:05:31 -03:00
error = getaddrinfo ( hostp , pbuf , & hints , & res ) ;
2003-05-09 04:53:18 -03:00
Py_END_ALLOW_THREADS
RELEASE_GETADDRINFO_LOCK /* see comment in setipaddr() */
2001-07-21 15:05:31 -03:00
if ( error ) {
2002-06-07 00:19:37 -03:00
set_gaierror ( error ) ;
2001-07-21 15:05:31 -03:00
goto fail ;
}
if ( res - > ai_next ) {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2001-07-21 15:05:31 -03:00
" sockaddr resolved to multiple addresses " ) ;
goto fail ;
}
switch ( res - > ai_family ) {
case AF_INET :
{
char * t1 ;
int t2 ;
if ( PyArg_ParseTuple ( sa , " si " , & t1 , & t2 ) = = 0 ) {
2002-06-07 00:19:37 -03:00
PyErr_SetString ( socket_error ,
2001-07-21 15:05:31 -03:00
" IPv4 sockaddr must be 2 tuple " ) ;
goto fail ;
}
break ;
}
2001-12-02 06:15:37 -04:00
# ifdef ENABLE_IPV6
2001-07-21 15:05:31 -03:00
case AF_INET6 :
{
struct sockaddr_in6 * sin6 ;
sin6 = ( struct sockaddr_in6 * ) res - > ai_addr ;
sin6 - > sin6_flowinfo = flowinfo ;
sin6 - > sin6_scope_id = scope_id ;
break ;
}
# endif
}
error = getnameinfo ( res - > ai_addr , res - > ai_addrlen ,
hbuf , sizeof ( hbuf ) , pbuf , sizeof ( pbuf ) , flags ) ;
if ( error ) {
2002-06-07 00:19:37 -03:00
set_gaierror ( error ) ;
2001-07-21 15:05:31 -03:00
goto fail ;
}
ret = Py_BuildValue ( " ss " , hbuf , pbuf ) ;
fail :
if ( res )
freeaddrinfo ( res ) ;
return ret ;
}
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( getnameinfo_doc ,
2002-08-08 17:37:08 -03:00
" getnameinfo(sockaddr, flags) --> (host, port) \n \
2001-07-21 15:05:31 -03:00
\ n \
2002-06-13 17:33:02 -03:00
Get host and port for a sockaddr . " );
2001-07-21 15:05:31 -03:00
2002-07-18 14:08:35 -03:00
/* Python API to getting and setting the default timeout value. */
static PyObject *
socket_getdefaulttimeout ( PyObject * self )
{
if ( defaulttimeout < 0.0 ) {
Py_INCREF ( Py_None ) ;
return Py_None ;
}
else
return PyFloat_FromDouble ( defaulttimeout ) ;
}
PyDoc_STRVAR ( getdefaulttimeout_doc ,
2002-08-08 17:37:08 -03:00
" getdefaulttimeout() -> timeout \n \
2002-07-18 14:08:35 -03:00
\ n \
Returns the default timeout in floating seconds for new socket objects . \ n \
A value of None indicates that new socket objects have no timeout . \ n \
When the socket module is first imported , the default is None . " );
static PyObject *
socket_setdefaulttimeout ( PyObject * self , PyObject * arg )
{
double timeout ;
if ( arg = = Py_None )
timeout = - 1.0 ;
else {
timeout = PyFloat_AsDouble ( arg ) ;
if ( timeout < 0.0 ) {
if ( ! PyErr_Occurred ( ) )
PyErr_SetString ( PyExc_ValueError ,
" Timeout value out of range " ) ;
return NULL ;
}
}
defaulttimeout = timeout ;
Py_INCREF ( Py_None ) ;
return Py_None ;
}
PyDoc_STRVAR ( setdefaulttimeout_doc ,
2002-08-08 17:37:08 -03:00
" setdefaulttimeout(timeout) \n \
2002-07-18 14:08:35 -03:00
\ n \
Set the default timeout in floating seconds for new socket objects . \ n \
A value of None indicates that new socket objects have no timeout . \ n \
When the socket module is first imported , the default is None . " );
1991-06-27 12:51:29 -03:00
/* List of functions exported by this module. */
2002-06-07 00:19:37 -03:00
static PyMethodDef socket_methods [ ] = {
{ " gethostbyname " , socket_gethostbyname ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , gethostbyname_doc } ,
2002-06-07 00:19:37 -03:00
{ " gethostbyname_ex " , socket_gethostbyname_ex ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , ghbn_ex_doc } ,
2002-06-07 00:19:37 -03:00
{ " gethostbyaddr " , socket_gethostbyaddr ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , gethostbyaddr_doc } ,
2002-06-07 00:19:37 -03:00
{ " gethostname " , socket_gethostname ,
2006-05-29 18:04:52 -03:00
METH_NOARGS , gethostname_doc } ,
2002-06-07 00:19:37 -03:00
{ " getservbyname " , socket_getservbyname ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , getservbyname_doc } ,
2004-06-27 21:50:43 -03:00
{ " getservbyport " , socket_getservbyport ,
METH_VARARGS , getservbyport_doc } ,
2002-06-07 00:19:37 -03:00
{ " getprotobyname " , socket_getprotobyname ,
2006-05-29 18:04:52 -03:00
METH_VARARGS , getprotobyname_doc } ,
1994-08-18 12:42:46 -03:00
# ifndef NO_DUP
2002-06-07 00:19:37 -03:00
{ " fromfd " , socket_fromfd ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , fromfd_doc } ,
2004-08-09 01:51:41 -03:00
# endif
# ifdef HAVE_SOCKETPAIR
{ " socketpair " , socket_socketpair ,
METH_VARARGS , socketpair_doc } ,
1994-08-18 12:42:46 -03:00
# endif
2002-06-07 00:19:37 -03:00
{ " ntohs " , socket_ntohs ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , ntohs_doc } ,
2002-06-07 00:19:37 -03:00
{ " ntohl " , socket_ntohl ,
2002-07-25 13:01:12 -03:00
METH_O , ntohl_doc } ,
2002-06-07 00:19:37 -03:00
{ " htons " , socket_htons ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , htons_doc } ,
2002-06-07 00:19:37 -03:00
{ " htonl " , socket_htonl ,
2002-07-25 13:01:12 -03:00
METH_O , htonl_doc } ,
2002-06-07 00:19:37 -03:00
{ " inet_aton " , socket_inet_aton ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , inet_aton_doc } ,
2002-06-07 00:19:37 -03:00
{ " inet_ntoa " , socket_inet_ntoa ,
2000-08-02 23:06:16 -03:00
METH_VARARGS , inet_ntoa_doc } ,
2003-04-25 02:48:32 -03:00
# ifdef HAVE_INET_PTON
{ " inet_pton " , socket_inet_pton ,
METH_VARARGS , inet_pton_doc } ,
{ " inet_ntop " , socket_inet_ntop ,
METH_VARARGS , inet_ntop_doc } ,
# endif
2002-06-07 00:19:37 -03:00
{ " getaddrinfo " , socket_getaddrinfo ,
2001-07-21 15:05:31 -03:00
METH_VARARGS , getaddrinfo_doc } ,
2002-06-07 00:19:37 -03:00
{ " getnameinfo " , socket_getnameinfo ,
2001-07-21 15:05:31 -03:00
METH_VARARGS , getnameinfo_doc } ,
2002-07-18 18:11:26 -03:00
{ " getdefaulttimeout " , ( PyCFunction ) socket_getdefaulttimeout ,
2002-07-18 14:08:35 -03:00
METH_NOARGS , getdefaulttimeout_doc } ,
{ " setdefaulttimeout " , socket_setdefaulttimeout ,
METH_O , setdefaulttimeout_doc } ,
1991-06-27 12:51:29 -03:00
{ NULL , NULL } /* Sentinel */
1991-06-25 18:36:08 -03:00
} ;
1991-06-27 12:51:29 -03:00
2002-06-07 00:19:37 -03:00
# ifdef RISCOS
# define OS_INIT_DEFINED
static int
os_init ( void )
{
_kernel_swi_regs r ;
r . r [ 0 ] = 0 ;
_kernel_swi ( 0x43380 , & r , & r ) ;
taskwindow = r . r [ 0 ] ;
2003-05-10 04:36:56 -03:00
return 1 ;
2002-06-07 00:19:37 -03:00
}
# endif /* RISCOS */
1996-06-26 15:22:49 -03:00
# ifdef MS_WINDOWS
2002-06-07 00:19:37 -03:00
# define OS_INIT_DEFINED
1996-06-20 13:25:29 -03:00
2002-06-07 00:19:37 -03:00
/* Additional initialization and cleanup for Windows */
1996-06-20 13:25:29 -03:00
static void
2002-06-07 00:19:37 -03:00
os_cleanup ( void )
1996-06-20 13:25:29 -03:00
{
WSACleanup ( ) ;
}
static int
2002-06-07 00:19:37 -03:00
os_init ( void )
1996-06-20 13:25:29 -03:00
{
WSADATA WSAData ;
int ret ;
char buf [ 100 ] ;
ret = WSAStartup ( 0x0101 , & WSAData ) ;
switch ( ret ) {
2002-06-07 00:19:37 -03:00
case 0 : /* No error */
2003-07-09 01:57:46 -03:00
Py_AtExit ( os_cleanup ) ;
2002-06-07 00:19:37 -03:00
return 1 ; /* Success */
1996-06-20 13:25:29 -03:00
case WSASYSNOTREADY :
PyErr_SetString ( PyExc_ImportError ,
" WSAStartup failed: network not ready " ) ;
break ;
case WSAVERNOTSUPPORTED :
case WSAEINVAL :
2002-06-06 23:08:35 -03:00
PyErr_SetString (
PyExc_ImportError ,
" WSAStartup failed: requested version not supported " ) ;
1996-06-20 13:25:29 -03:00
break ;
default :
2001-11-28 16:27:42 -04:00
PyOS_snprintf ( buf , sizeof ( buf ) ,
" WSAStartup failed: error code %d " , ret ) ;
1996-06-20 13:25:29 -03:00
PyErr_SetString ( PyExc_ImportError , buf ) ;
break ;
}
2002-06-07 00:19:37 -03:00
return 0 ; /* Failure */
1996-06-20 13:25:29 -03:00
}
1996-06-26 15:22:49 -03:00
# endif /* MS_WINDOWS */
1996-06-20 13:25:29 -03:00
1997-11-22 17:53:48 -04:00
2002-06-07 00:19:37 -03:00
# ifdef PYOS_OS2
# define OS_INIT_DEFINED
1997-11-22 17:53:48 -04:00
2002-06-07 00:19:37 -03:00
/* Additional initialization for OS/2 */
1997-11-22 17:53:48 -04:00
static int
2002-06-07 00:19:37 -03:00
os_init ( void )
1997-11-22 17:53:48 -04:00
{
2002-06-07 00:19:37 -03:00
# ifndef PYCC_GCC
2002-06-06 23:08:35 -03:00
char reason [ 64 ] ;
int rc = sock_init ( ) ;
1997-11-22 17:53:48 -04:00
2002-06-06 23:08:35 -03:00
if ( rc = = 0 ) {
2002-06-07 00:19:37 -03:00
return 1 ; /* Success */
2002-06-06 23:08:35 -03:00
}
1997-11-22 17:53:48 -04:00
2002-06-06 23:08:35 -03:00
PyOS_snprintf ( reason , sizeof ( reason ) ,
" OS/2 TCP/IP Error# %d " , sock_errno ( ) ) ;
PyErr_SetString ( PyExc_ImportError , reason ) ;
1997-11-22 17:53:48 -04:00
2002-06-07 00:19:37 -03:00
return 0 ; /* Failure */
2002-03-02 23:03:52 -04:00
# else
2002-06-07 00:19:37 -03:00
/* No need to initialise sockets with GCC/EMX */
return 1 ; /* Success */
2002-03-02 23:03:52 -04:00
# endif
1997-11-22 17:53:48 -04:00
}
# endif /* PYOS_OS2 */
2002-06-07 00:19:37 -03:00
# ifndef OS_INIT_DEFINED
static int
os_init ( void )
{
return 1 ; /* Success */
}
# endif
2002-02-16 14:23:30 -04:00
/* C API table - always add new things to the end for binary
compatibility . */
static
PySocketModule_APIObject PySocketModuleAPI =
{
2002-06-07 00:19:37 -03:00
& sock_type ,
2004-03-23 19:16:54 -04:00
NULL
2002-02-16 14:23:30 -04:00
} ;
2002-06-06 23:08:35 -03:00
2002-06-07 00:19:37 -03:00
/* Initialize the _socket module.
2002-06-06 23:08:35 -03:00
2002-06-07 00:19:37 -03:00
This module is actually called " _socket " , and there ' s a wrapper
" socket.py " which implements some additional functionality . On some
platforms ( e . g . Windows and OS / 2 ) , socket . py also implements a
wrapper for the socket type that provides missing functionality such
as makefile ( ) , dup ( ) and fromfd ( ) . The import of " _socket " may fail
with an ImportError exception if os - specific initialization fails .
On Windows , this does WINSOCK initialization . When WINSOCK is
initialized succesfully , a call to WSACleanup ( ) is scheduled to be
made at exit time .
*/
1991-06-27 12:51:29 -03:00
2002-06-13 17:33:02 -03:00
PyDoc_STRVAR ( socket_doc ,
2002-08-08 17:37:08 -03:00
" Implementation module for socket operations. \n \
\ n \
See the socket module for documentation . " );
1998-07-07 17:45:43 -03:00
2002-08-01 23:27:13 -03:00
PyMODINIT_FUNC
2000-07-24 13:06:23 -03:00
init_socket ( void )
1991-06-25 18:36:08 -03:00
{
2008-01-04 11:23:30 -04:00
PyObject * m , * has_ipv6 , * tmp ;
2002-06-07 00:19:37 -03:00
if ( ! os_init ( ) )
1997-11-22 17:53:48 -04:00
return ;
2002-06-07 00:19:37 -03:00
2007-12-18 22:37:44 -04:00
Py_TYPE ( & sock_type ) = & PyType_Type ;
2002-06-06 23:08:35 -03:00
m = Py_InitModule3 ( PySocket_MODULE_NAME ,
2002-06-07 00:19:37 -03:00
socket_methods ,
socket_doc ) ;
2006-01-19 02:09:39 -04:00
if ( m = = NULL )
return ;
2002-04-01 10:53:37 -04:00
2007-09-09 20:36:46 -03:00
socket_error = PyErr_NewException ( " socket.error " ,
PyExc_IOError , NULL ) ;
2002-06-07 00:19:37 -03:00
if ( socket_error = = NULL )
1997-10-01 01:29:29 -03:00
return ;
2004-03-23 19:16:54 -04:00
PySocketModuleAPI . error = socket_error ;
2002-06-07 00:19:37 -03:00
Py_INCREF ( socket_error ) ;
PyModule_AddObject ( m , " error " , socket_error ) ;
socket_herror = PyErr_NewException ( " socket.herror " ,
socket_error , NULL ) ;
if ( socket_herror = = NULL )
2001-07-21 15:05:31 -03:00
return ;
2002-06-07 00:19:37 -03:00
Py_INCREF ( socket_herror ) ;
PyModule_AddObject ( m , " herror " , socket_herror ) ;
socket_gaierror = PyErr_NewException ( " socket.gaierror " , socket_error ,
2001-07-21 15:05:31 -03:00
NULL ) ;
2002-06-07 00:19:37 -03:00
if ( socket_gaierror = = NULL )
2001-07-21 15:05:31 -03:00
return ;
2002-06-07 00:19:37 -03:00
Py_INCREF ( socket_gaierror ) ;
PyModule_AddObject ( m , " gaierror " , socket_gaierror ) ;
2003-06-29 00:08:05 -03:00
socket_timeout = PyErr_NewException ( " socket.timeout " ,
socket_error , NULL ) ;
if ( socket_timeout = = NULL )
return ;
Py_INCREF ( socket_timeout ) ;
PyModule_AddObject ( m , " timeout " , socket_timeout ) ;
2002-06-07 00:19:37 -03:00
Py_INCREF ( ( PyObject * ) & sock_type ) ;
2002-04-01 10:53:37 -04:00
if ( PyModule_AddObject ( m , " SocketType " ,
2002-06-07 00:19:37 -03:00
( PyObject * ) & sock_type ) ! = 0 )
1997-10-01 01:29:29 -03:00
return ;
2002-06-07 00:19:37 -03:00
Py_INCREF ( ( PyObject * ) & sock_type ) ;
2002-04-01 10:53:37 -04:00
if ( PyModule_AddObject ( m , " socket " ,
2002-06-07 00:19:37 -03:00
( PyObject * ) & sock_type ) ! = 0 )
2001-10-27 19:20:47 -03:00
return ;
1999-08-09 11:40:40 -03:00
2003-04-25 02:48:32 -03:00
# ifdef ENABLE_IPV6
has_ipv6 = Py_True ;
# else
has_ipv6 = Py_False ;
# endif
Py_INCREF ( has_ipv6 ) ;
PyModule_AddObject ( m , " has_ipv6 " , has_ipv6 ) ;
2002-02-16 14:23:30 -04:00
/* Export C API */
2002-04-01 10:53:37 -04:00
if ( PyModule_AddObject ( m , PySocket_CAPI_NAME ,
2002-02-16 14:23:30 -04:00
PyCObject_FromVoidPtr ( ( void * ) & PySocketModuleAPI , NULL )
) ! = 0 )
return ;
1999-08-09 11:40:40 -03:00
/* Address families (we only support AF_INET and AF_UNIX) */
# ifdef AF_UNSPEC
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_UNSPEC " , AF_UNSPEC ) ;
1999-08-09 11:40:40 -03:00
# endif
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_INET " , AF_INET ) ;
2001-07-21 15:05:31 -03:00
# ifdef AF_INET6
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_INET6 " , AF_INET6 ) ;
2001-07-21 15:05:31 -03:00
# endif /* AF_INET6 */
2004-04-04 04:13:49 -03:00
# if defined(AF_UNIX)
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_UNIX " , AF_UNIX ) ;
1994-08-01 08:34:53 -03:00
# endif /* AF_UNIX */
1999-08-09 11:40:40 -03:00
# ifdef AF_AX25
2002-04-01 10:53:37 -04:00
/* Amateur Radio AX.25 */
PyModule_AddIntConstant ( m , " AF_AX25 " , AF_AX25 ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_IPX
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_IPX " , AF_IPX ) ; /* Novell IPX */
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_APPLETALK
2002-04-01 10:53:37 -04:00
/* Appletalk DDP */
PyModule_AddIntConstant ( m , " AF_APPLETALK " , AF_APPLETALK ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_NETROM
2002-04-01 10:53:37 -04:00
/* Amateur radio NetROM */
PyModule_AddIntConstant ( m , " AF_NETROM " , AF_NETROM ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_BRIDGE
2002-04-01 10:53:37 -04:00
/* Multiprotocol bridge */
PyModule_AddIntConstant ( m , " AF_BRIDGE " , AF_BRIDGE ) ;
1999-08-09 11:40:40 -03:00
# endif
2004-07-19 14:01:20 -03:00
# ifdef AF_ATMPVC
/* ATM PVCs */
PyModule_AddIntConstant ( m , " AF_ATMPVC " , AF_ATMPVC ) ;
# endif
1999-08-09 11:40:40 -03:00
# ifdef AF_AAL5
2002-04-01 10:53:37 -04:00
/* Reserved for Werner's ATM */
PyModule_AddIntConstant ( m , " AF_AAL5 " , AF_AAL5 ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_X25
2002-04-01 10:53:37 -04:00
/* Reserved for X.25 project */
PyModule_AddIntConstant ( m , " AF_X25 " , AF_X25 ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_INET6
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_INET6 " , AF_INET6 ) ; /* IP version 6 */
1999-08-09 11:40:40 -03:00
# endif
# ifdef AF_ROSE
2002-04-01 10:53:37 -04:00
/* Amateur Radio X.25 PLP */
PyModule_AddIntConstant ( m , " AF_ROSE " , AF_ROSE ) ;
1999-08-09 11:40:40 -03:00
# endif
2004-07-19 14:01:20 -03:00
# ifdef AF_DECnet
/* Reserved for DECnet project */
PyModule_AddIntConstant ( m , " AF_DECnet " , AF_DECnet ) ;
# endif
# ifdef AF_NETBEUI
/* Reserved for 802.2LLC project */
PyModule_AddIntConstant ( m , " AF_NETBEUI " , AF_NETBEUI ) ;
# endif
# ifdef AF_SECURITY
/* Security callback pseudo AF */
PyModule_AddIntConstant ( m , " AF_SECURITY " , AF_SECURITY ) ;
# endif
# ifdef AF_KEY
/* PF_KEY key management API */
PyModule_AddIntConstant ( m , " AF_KEY " , AF_KEY ) ;
# endif
# ifdef AF_NETLINK
/* */
PyModule_AddIntConstant ( m , " AF_NETLINK " , AF_NETLINK ) ;
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_ROUTE " , NETLINK_ROUTE ) ;
2006-04-06 19:29:33 -03:00
# ifdef NETLINK_SKIP
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_SKIP " , NETLINK_SKIP ) ;
2006-04-06 19:29:33 -03:00
# endif
# ifdef NETLINK_W1
PyModule_AddIntConstant ( m , " NETLINK_W1 " , NETLINK_W1 ) ;
# endif
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_USERSOCK " , NETLINK_USERSOCK ) ;
PyModule_AddIntConstant ( m , " NETLINK_FIREWALL " , NETLINK_FIREWALL ) ;
2006-02-20 21:07:27 -04:00
# ifdef NETLINK_TCPDIAG
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_TCPDIAG " , NETLINK_TCPDIAG ) ;
2006-02-20 21:07:27 -04:00
# endif
# ifdef NETLINK_NFLOG
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_NFLOG " , NETLINK_NFLOG ) ;
2006-02-20 21:07:27 -04:00
# endif
2006-01-16 00:31:40 -04:00
# ifdef NETLINK_XFRM
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_XFRM " , NETLINK_XFRM ) ;
2006-01-16 00:31:40 -04:00
# endif
2006-04-06 19:29:33 -03:00
# ifdef NETLINK_ARPD
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_ARPD " , NETLINK_ARPD ) ;
2006-04-06 19:29:33 -03:00
# endif
# ifdef NETLINK_ROUTE6
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_ROUTE6 " , NETLINK_ROUTE6 ) ;
2006-04-06 19:29:33 -03:00
# endif
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_IP6_FW " , NETLINK_IP6_FW ) ;
2007-02-13 08:14:19 -04:00
# ifdef NETLINK_DNRTMSG
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_DNRTMSG " , NETLINK_DNRTMSG ) ;
2007-02-13 08:14:19 -04:00
# endif
2006-04-06 19:29:33 -03:00
# ifdef NETLINK_TAPBASE
2006-01-14 14:12:57 -04:00
PyModule_AddIntConstant ( m , " NETLINK_TAPBASE " , NETLINK_TAPBASE ) ;
2006-04-06 19:29:33 -03:00
# endif
2006-04-01 03:33:08 -04:00
# endif /* AF_NETLINK */
2004-07-19 14:01:20 -03:00
# ifdef AF_ROUTE
/* Alias to emulate 4.4BSD */
PyModule_AddIntConstant ( m , " AF_ROUTE " , AF_ROUTE ) ;
# endif
# ifdef AF_ASH
/* Ash */
PyModule_AddIntConstant ( m , " AF_ASH " , AF_ASH ) ;
# endif
# ifdef AF_ECONET
/* Acorn Econet */
PyModule_AddIntConstant ( m , " AF_ECONET " , AF_ECONET ) ;
# endif
# ifdef AF_ATMSVC
/* ATM SVCs */
PyModule_AddIntConstant ( m , " AF_ATMSVC " , AF_ATMSVC ) ;
# endif
# ifdef AF_SNA
/* Linux SNA Project (nutters!) */
PyModule_AddIntConstant ( m , " AF_SNA " , AF_SNA ) ;
# endif
# ifdef AF_IRDA
/* IRDA sockets */
PyModule_AddIntConstant ( m , " AF_IRDA " , AF_IRDA ) ;
# endif
# ifdef AF_PPPOX
/* PPPoX sockets */
PyModule_AddIntConstant ( m , " AF_PPPOX " , AF_PPPOX ) ;
# endif
# ifdef AF_WANPIPE
/* Wanpipe API Sockets */
PyModule_AddIntConstant ( m , " AF_WANPIPE " , AF_WANPIPE ) ;
# endif
# ifdef AF_LLC
/* Linux LLC */
PyModule_AddIntConstant ( m , " AF_LLC " , AF_LLC ) ;
# endif
2004-01-31 08:34:17 -04:00
2004-02-02 02:05:24 -04:00
# ifdef USE_BLUETOOTH
2004-01-31 08:34:17 -04:00
PyModule_AddIntConstant ( m , " AF_BLUETOOTH " , AF_BLUETOOTH ) ;
PyModule_AddIntConstant ( m , " BTPROTO_L2CAP " , BTPROTO_L2CAP ) ;
2007-02-14 06:07:37 -04:00
PyModule_AddIntConstant ( m , " BTPROTO_HCI " , BTPROTO_HCI ) ;
PyModule_AddIntConstant ( m , " SOL_HCI " , SOL_HCI ) ;
PyModule_AddIntConstant ( m , " HCI_FILTER " , HCI_FILTER ) ;
2004-02-02 02:05:24 -04:00
# if !defined(__FreeBSD__)
2007-06-05 15:16:52 -03:00
PyModule_AddIntConstant ( m , " HCI_TIME_STAMP " , HCI_TIME_STAMP ) ;
PyModule_AddIntConstant ( m , " HCI_DATA_DIR " , HCI_DATA_DIR ) ;
2004-01-31 08:34:17 -04:00
PyModule_AddIntConstant ( m , " BTPROTO_SCO " , BTPROTO_SCO ) ;
2004-02-02 02:05:24 -04:00
# endif
2004-01-31 08:34:17 -04:00
PyModule_AddIntConstant ( m , " BTPROTO_RFCOMM " , BTPROTO_RFCOMM ) ;
2006-05-30 00:18:50 -03:00
PyModule_AddStringConstant ( m , " BDADDR_ANY " , " 00:00:00:00:00:00 " ) ;
PyModule_AddStringConstant ( m , " BDADDR_LOCAL " , " 00:00:00:FF:FF:FF " ) ;
2004-01-31 08:34:17 -04:00
# endif
2001-08-10 17:29:40 -03:00
# ifdef HAVE_NETPACKET_PACKET_H
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AF_PACKET " , AF_PACKET ) ;
PyModule_AddIntConstant ( m , " PF_PACKET " , PF_PACKET ) ;
PyModule_AddIntConstant ( m , " PACKET_HOST " , PACKET_HOST ) ;
PyModule_AddIntConstant ( m , " PACKET_BROADCAST " , PACKET_BROADCAST ) ;
PyModule_AddIntConstant ( m , " PACKET_MULTICAST " , PACKET_MULTICAST ) ;
PyModule_AddIntConstant ( m , " PACKET_OTHERHOST " , PACKET_OTHERHOST ) ;
PyModule_AddIntConstant ( m , " PACKET_OUTGOING " , PACKET_OUTGOING ) ;
PyModule_AddIntConstant ( m , " PACKET_LOOPBACK " , PACKET_LOOPBACK ) ;
PyModule_AddIntConstant ( m , " PACKET_FASTROUTE " , PACKET_FASTROUTE ) ;
2001-03-02 02:34:14 -04:00
# endif
1999-08-09 11:40:40 -03:00
2008-01-07 12:12:44 -04:00
# ifdef HAVE_LINUX_TIPC_H
PyModule_AddIntConstant ( m , " AF_TIPC " , AF_TIPC ) ;
/* for addresses */
PyModule_AddIntConstant ( m , " TIPC_ADDR_NAMESEQ " , TIPC_ADDR_NAMESEQ ) ;
PyModule_AddIntConstant ( m , " TIPC_ADDR_NAME " , TIPC_ADDR_NAME ) ;
PyModule_AddIntConstant ( m , " TIPC_ADDR_ID " , TIPC_ADDR_ID ) ;
PyModule_AddIntConstant ( m , " TIPC_ZONE_SCOPE " , TIPC_ZONE_SCOPE ) ;
PyModule_AddIntConstant ( m , " TIPC_CLUSTER_SCOPE " , TIPC_CLUSTER_SCOPE ) ;
PyModule_AddIntConstant ( m , " TIPC_NODE_SCOPE " , TIPC_NODE_SCOPE ) ;
/* for setsockopt() */
PyModule_AddIntConstant ( m , " SOL_TIPC " , SOL_TIPC ) ;
PyModule_AddIntConstant ( m , " TIPC_IMPORTANCE " , TIPC_IMPORTANCE ) ;
PyModule_AddIntConstant ( m , " TIPC_SRC_DROPPABLE " , TIPC_SRC_DROPPABLE ) ;
PyModule_AddIntConstant ( m , " TIPC_DEST_DROPPABLE " ,
TIPC_DEST_DROPPABLE ) ;
PyModule_AddIntConstant ( m , " TIPC_CONN_TIMEOUT " , TIPC_CONN_TIMEOUT ) ;
PyModule_AddIntConstant ( m , " TIPC_LOW_IMPORTANCE " ,
TIPC_LOW_IMPORTANCE ) ;
PyModule_AddIntConstant ( m , " TIPC_MEDIUM_IMPORTANCE " ,
TIPC_MEDIUM_IMPORTANCE ) ;
PyModule_AddIntConstant ( m , " TIPC_HIGH_IMPORTANCE " ,
TIPC_HIGH_IMPORTANCE ) ;
PyModule_AddIntConstant ( m , " TIPC_CRITICAL_IMPORTANCE " ,
TIPC_CRITICAL_IMPORTANCE ) ;
/* for subscriptions */
PyModule_AddIntConstant ( m , " TIPC_SUB_PORTS " , TIPC_SUB_PORTS ) ;
PyModule_AddIntConstant ( m , " TIPC_SUB_SERVICE " , TIPC_SUB_SERVICE ) ;
2008-01-10 22:12:33 -04:00
/* PyModule_AddIntConstant(m, "TIPC_SUB_CANCEL", TIPC_SUB_CANCEL); XXX This var is missing on gcc (GCC) 4.1.1 (Gentoo 4.1.1) and it breaks the build */
2008-01-07 12:12:44 -04:00
PyModule_AddIntConstant ( m , " TIPC_WAIT_FOREVER " , TIPC_WAIT_FOREVER ) ;
PyModule_AddIntConstant ( m , " TIPC_PUBLISHED " , TIPC_PUBLISHED ) ;
PyModule_AddIntConstant ( m , " TIPC_WITHDRAWN " , TIPC_WITHDRAWN ) ;
PyModule_AddIntConstant ( m , " TIPC_SUBSCR_TIMEOUT " , TIPC_SUBSCR_TIMEOUT ) ;
PyModule_AddIntConstant ( m , " TIPC_CFG_SRV " , TIPC_CFG_SRV ) ;
PyModule_AddIntConstant ( m , " TIPC_TOP_SRV " , TIPC_TOP_SRV ) ;
# endif
1999-08-09 11:40:40 -03:00
/* Socket types */
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOCK_STREAM " , SOCK_STREAM ) ;
PyModule_AddIntConstant ( m , " SOCK_DGRAM " , SOCK_DGRAM ) ;
1998-08-04 19:53:56 -03:00
# ifndef __BEOS__
/* We have incomplete socket support. */
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOCK_RAW " , SOCK_RAW ) ;
PyModule_AddIntConstant ( m , " SOCK_SEQPACKET " , SOCK_SEQPACKET ) ;
2002-12-11 09:10:57 -04:00
# if defined(SOCK_RDM)
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOCK_RDM " , SOCK_RDM ) ;
1998-08-04 19:53:56 -03:00
# endif
2002-12-11 09:10:57 -04:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef SO_DEBUG
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_DEBUG " , SO_DEBUG ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_ACCEPTCONN
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_ACCEPTCONN " , SO_ACCEPTCONN ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_REUSEADDR
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_REUSEADDR " , SO_REUSEADDR ) ;
1995-02-07 11:39:52 -04:00
# endif
2004-07-10 11:19:21 -03:00
# ifdef SO_EXCLUSIVEADDRUSE
PyModule_AddIntConstant ( m , " SO_EXCLUSIVEADDRUSE " , SO_EXCLUSIVEADDRUSE ) ;
# endif
1995-02-07 11:39:52 -04:00
# ifdef SO_KEEPALIVE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_KEEPALIVE " , SO_KEEPALIVE ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_DONTROUTE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_DONTROUTE " , SO_DONTROUTE ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_BROADCAST
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_BROADCAST " , SO_BROADCAST ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_USELOOPBACK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_USELOOPBACK " , SO_USELOOPBACK ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_LINGER
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_LINGER " , SO_LINGER ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_OOBINLINE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_OOBINLINE " , SO_OOBINLINE ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_REUSEPORT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_REUSEPORT " , SO_REUSEPORT ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_SNDBUF
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_SNDBUF " , SO_SNDBUF ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_RCVBUF
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_RCVBUF " , SO_RCVBUF ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_SNDLOWAT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_SNDLOWAT " , SO_SNDLOWAT ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_RCVLOWAT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_RCVLOWAT " , SO_RCVLOWAT ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_SNDTIMEO
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_SNDTIMEO " , SO_SNDTIMEO ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_RCVTIMEO
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_RCVTIMEO " , SO_RCVTIMEO ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_ERROR
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_ERROR " , SO_ERROR ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef SO_TYPE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SO_TYPE " , SO_TYPE ) ;
1995-02-07 11:39:52 -04:00
# endif
/* Maximum number of connections for "listen" */
# ifdef SOMAXCONN
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOMAXCONN " , SOMAXCONN ) ;
1995-02-07 11:39:52 -04:00
# else
2002-06-06 23:08:35 -03:00
PyModule_AddIntConstant ( m , " SOMAXCONN " , 5 ) ; /* Common value */
1995-02-07 11:39:52 -04:00
# endif
/* Flags for send, recv */
# ifdef MSG_OOB
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_OOB " , MSG_OOB ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_PEEK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_PEEK " , MSG_PEEK ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_DONTROUTE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_DONTROUTE " , MSG_DONTROUTE ) ;
1995-02-07 11:39:52 -04:00
# endif
2000-04-25 18:34:53 -03:00
# ifdef MSG_DONTWAIT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_DONTWAIT " , MSG_DONTWAIT ) ;
2000-04-25 18:34:53 -03:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef MSG_EOR
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_EOR " , MSG_EOR ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_TRUNC
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_TRUNC " , MSG_TRUNC ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_CTRUNC
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_CTRUNC " , MSG_CTRUNC ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_WAITALL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_WAITALL " , MSG_WAITALL ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_BTAG
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_BTAG " , MSG_BTAG ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef MSG_ETAG
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " MSG_ETAG " , MSG_ETAG ) ;
1995-02-07 11:39:52 -04:00
# endif
/* Protocol level and numbers, usable for [gs]etsockopt */
# ifdef SOL_SOCKET
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_SOCKET " , SOL_SOCKET ) ;
1995-02-07 11:39:52 -04:00
# endif
1999-08-09 11:40:40 -03:00
# ifdef SOL_IP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_IP " , SOL_IP ) ;
1999-08-09 11:40:40 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_IP " , 0 ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_IPX
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_IPX " , SOL_IPX ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_AX25
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_AX25 " , SOL_AX25 ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_ATALK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_ATALK " , SOL_ATALK ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_NETROM
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_NETROM " , SOL_NETROM ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_ROSE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_ROSE " , SOL_ROSE ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_TCP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_TCP " , SOL_TCP ) ;
1999-08-09 11:40:40 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_TCP " , 6 ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef SOL_UDP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_UDP " , SOL_UDP ) ;
1999-08-09 11:40:40 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " SOL_UDP " , 17 ) ;
1999-08-09 11:40:40 -03:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef IPPROTO_IP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IP " , IPPROTO_IP ) ;
1998-05-28 17:18:18 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IP " , 0 ) ;
1995-02-07 11:39:52 -04:00
# endif
2001-08-04 19:37:23 -03:00
# ifdef IPPROTO_HOPOPTS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_HOPOPTS " , IPPROTO_HOPOPTS ) ;
2001-08-04 19:37:23 -03:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef IPPROTO_ICMP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_ICMP " , IPPROTO_ICMP ) ;
1998-05-28 17:18:18 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_ICMP " , 1 ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_IGMP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IGMP " , IPPROTO_IGMP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_GGP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_GGP " , IPPROTO_GGP ) ;
1995-02-07 11:39:52 -04:00
# endif
2001-08-04 19:37:23 -03:00
# ifdef IPPROTO_IPV4
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IPV4 " , IPPROTO_IPV4 ) ;
2001-08-04 19:37:23 -03:00
# endif
2003-10-03 10:56:20 -03:00
# ifdef IPPROTO_IPV6
PyModule_AddIntConstant ( m , " IPPROTO_IPV6 " , IPPROTO_IPV6 ) ;
# endif
2001-08-04 19:37:23 -03:00
# ifdef IPPROTO_IPIP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IPIP " , IPPROTO_IPIP ) ;
2001-08-04 19:37:23 -03:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef IPPROTO_TCP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_TCP " , IPPROTO_TCP ) ;
1998-05-28 17:18:18 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_TCP " , 6 ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_EGP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_EGP " , IPPROTO_EGP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_PUP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_PUP " , IPPROTO_PUP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_UDP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_UDP " , IPPROTO_UDP ) ;
1998-05-28 17:18:18 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_UDP " , 17 ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_IDP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IDP " , IPPROTO_IDP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_HELLO
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_HELLO " , IPPROTO_HELLO ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_ND
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_ND " , IPPROTO_ND ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_TP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_TP " , IPPROTO_TP ) ;
1995-02-07 11:39:52 -04:00
# endif
2001-08-04 19:37:23 -03:00
# ifdef IPPROTO_IPV6
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IPV6 " , IPPROTO_IPV6 ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_ROUTING
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_ROUTING " , IPPROTO_ROUTING ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_FRAGMENT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_FRAGMENT " , IPPROTO_FRAGMENT ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_RSVP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_RSVP " , IPPROTO_RSVP ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_GRE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_GRE " , IPPROTO_GRE ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_ESP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_ESP " , IPPROTO_ESP ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_AH
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_AH " , IPPROTO_AH ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_MOBILE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_MOBILE " , IPPROTO_MOBILE ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_ICMPV6
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_ICMPV6 " , IPPROTO_ICMPV6 ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_NONE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_NONE " , IPPROTO_NONE ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_DSTOPTS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_DSTOPTS " , IPPROTO_DSTOPTS ) ;
2001-08-04 19:37:23 -03:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef IPPROTO_XTP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_XTP " , IPPROTO_XTP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_EON
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_EON " , IPPROTO_EON ) ;
1995-02-07 11:39:52 -04:00
# endif
2001-08-04 19:37:23 -03:00
# ifdef IPPROTO_PIM
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_PIM " , IPPROTO_PIM ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_IPCOMP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_IPCOMP " , IPPROTO_IPCOMP ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPPROTO_VRRP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_VRRP " , IPPROTO_VRRP ) ;
2001-08-04 19:37:23 -03:00
# endif
1995-02-07 11:39:52 -04:00
# ifdef IPPROTO_BIP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_BIP " , IPPROTO_BIP ) ;
1995-02-07 11:39:52 -04:00
# endif
/**/
# ifdef IPPROTO_RAW
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_RAW " , IPPROTO_RAW ) ;
1998-05-28 17:18:18 -03:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_RAW " , 255 ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPROTO_MAX
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPROTO_MAX " , IPPROTO_MAX ) ;
1995-02-07 11:39:52 -04:00
# endif
/* Some port configuration */
# ifdef IPPORT_RESERVED
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPORT_RESERVED " , IPPORT_RESERVED ) ;
1995-02-07 11:39:52 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPORT_RESERVED " , 1024 ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IPPORT_USERRESERVED
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPORT_USERRESERVED " , IPPORT_USERRESERVED ) ;
1995-02-07 11:39:52 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPPORT_USERRESERVED " , 5000 ) ;
1995-02-07 11:39:52 -04:00
# endif
1995-02-17 11:11:07 -04:00
/* Some reserved IP v.4 addresses */
# ifdef INADDR_ANY
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_ANY " , INADDR_ANY ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_ANY " , 0x00000000 ) ;
1995-02-17 11:11:07 -04:00
# endif
# ifdef INADDR_BROADCAST
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_BROADCAST " , INADDR_BROADCAST ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_BROADCAST " , 0xffffffff ) ;
1995-02-17 11:11:07 -04:00
# endif
# ifdef INADDR_LOOPBACK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_LOOPBACK " , INADDR_LOOPBACK ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_LOOPBACK " , 0x7F000001 ) ;
1995-02-17 11:11:07 -04:00
# endif
# ifdef INADDR_UNSPEC_GROUP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_UNSPEC_GROUP " , INADDR_UNSPEC_GROUP ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_UNSPEC_GROUP " , 0xe0000000 ) ;
1995-02-17 11:11:07 -04:00
# endif
# ifdef INADDR_ALLHOSTS_GROUP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_ALLHOSTS_GROUP " ,
INADDR_ALLHOSTS_GROUP ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_ALLHOSTS_GROUP " , 0xe0000001 ) ;
1995-02-17 11:11:07 -04:00
# endif
# ifdef INADDR_MAX_LOCAL_GROUP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_MAX_LOCAL_GROUP " ,
INADDR_MAX_LOCAL_GROUP ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_MAX_LOCAL_GROUP " , 0xe00000ff ) ;
1995-02-17 11:11:07 -04:00
# endif
# ifdef INADDR_NONE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_NONE " , INADDR_NONE ) ;
1995-02-17 11:11:07 -04:00
# else
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " INADDR_NONE " , 0xffffffff ) ;
1995-02-17 11:11:07 -04:00
# endif
2001-08-04 19:37:23 -03:00
/* IPv4 [gs]etsockopt options */
1995-02-07 11:39:52 -04:00
# ifdef IP_OPTIONS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_OPTIONS " , IP_OPTIONS ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_HDRINCL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_HDRINCL " , IP_HDRINCL ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_TOS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_TOS " , IP_TOS ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_TTL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_TTL " , IP_TTL ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_RECVOPTS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_RECVOPTS " , IP_RECVOPTS ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_RECVRETOPTS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_RECVRETOPTS " , IP_RECVRETOPTS ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_RECVDSTADDR
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_RECVDSTADDR " , IP_RECVDSTADDR ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_RETOPTS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_RETOPTS " , IP_RETOPTS ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_MULTICAST_IF
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_MULTICAST_IF " , IP_MULTICAST_IF ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_MULTICAST_TTL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_MULTICAST_TTL " , IP_MULTICAST_TTL ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_MULTICAST_LOOP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_MULTICAST_LOOP " , IP_MULTICAST_LOOP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_ADD_MEMBERSHIP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_ADD_MEMBERSHIP " , IP_ADD_MEMBERSHIP ) ;
1995-02-07 11:39:52 -04:00
# endif
# ifdef IP_DROP_MEMBERSHIP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_DROP_MEMBERSHIP " , IP_DROP_MEMBERSHIP ) ;
1995-02-07 11:39:52 -04:00
# endif
1999-08-09 11:40:40 -03:00
# ifdef IP_DEFAULT_MULTICAST_TTL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_DEFAULT_MULTICAST_TTL " ,
IP_DEFAULT_MULTICAST_TTL ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef IP_DEFAULT_MULTICAST_LOOP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_DEFAULT_MULTICAST_LOOP " ,
IP_DEFAULT_MULTICAST_LOOP ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef IP_MAX_MEMBERSHIPS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IP_MAX_MEMBERSHIPS " , IP_MAX_MEMBERSHIPS ) ;
1999-08-09 11:40:40 -03:00
# endif
2001-08-04 19:37:23 -03:00
/* IPv6 [gs]etsockopt options, defined in RFC2553 */
# ifdef IPV6_JOIN_GROUP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPV6_JOIN_GROUP " , IPV6_JOIN_GROUP ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPV6_LEAVE_GROUP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPV6_LEAVE_GROUP " , IPV6_LEAVE_GROUP ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPV6_MULTICAST_HOPS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPV6_MULTICAST_HOPS " , IPV6_MULTICAST_HOPS ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPV6_MULTICAST_IF
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPV6_MULTICAST_IF " , IPV6_MULTICAST_IF ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPV6_MULTICAST_LOOP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPV6_MULTICAST_LOOP " , IPV6_MULTICAST_LOOP ) ;
2001-08-04 19:37:23 -03:00
# endif
# ifdef IPV6_UNICAST_HOPS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPV6_UNICAST_HOPS " , IPV6_UNICAST_HOPS ) ;
2001-08-04 19:37:23 -03:00
# endif
2003-12-30 07:14:01 -04:00
/* Additional IPV6 socket options, defined in RFC 3493 */
# ifdef IPV6_V6ONLY
PyModule_AddIntConstant ( m , " IPV6_V6ONLY " , IPV6_V6ONLY ) ;
# endif
/* Advanced IPV6 socket options, from RFC 3542 */
# ifdef IPV6_CHECKSUM
PyModule_AddIntConstant ( m , " IPV6_CHECKSUM " , IPV6_CHECKSUM ) ;
# endif
# ifdef IPV6_DONTFRAG
PyModule_AddIntConstant ( m , " IPV6_DONTFRAG " , IPV6_DONTFRAG ) ;
# endif
# ifdef IPV6_DSTOPTS
PyModule_AddIntConstant ( m , " IPV6_DSTOPTS " , IPV6_DSTOPTS ) ;
# endif
# ifdef IPV6_HOPLIMIT
PyModule_AddIntConstant ( m , " IPV6_HOPLIMIT " , IPV6_HOPLIMIT ) ;
# endif
# ifdef IPV6_HOPOPTS
PyModule_AddIntConstant ( m , " IPV6_HOPOPTS " , IPV6_HOPOPTS ) ;
# endif
# ifdef IPV6_NEXTHOP
PyModule_AddIntConstant ( m , " IPV6_NEXTHOP " , IPV6_NEXTHOP ) ;
# endif
# ifdef IPV6_PATHMTU
PyModule_AddIntConstant ( m , " IPV6_PATHMTU " , IPV6_PATHMTU ) ;
# endif
# ifdef IPV6_PKTINFO
PyModule_AddIntConstant ( m , " IPV6_PKTINFO " , IPV6_PKTINFO ) ;
# endif
# ifdef IPV6_RECVDSTOPTS
PyModule_AddIntConstant ( m , " IPV6_RECVDSTOPTS " , IPV6_RECVDSTOPTS ) ;
# endif
# ifdef IPV6_RECVHOPLIMIT
PyModule_AddIntConstant ( m , " IPV6_RECVHOPLIMIT " , IPV6_RECVHOPLIMIT ) ;
# endif
# ifdef IPV6_RECVHOPOPTS
PyModule_AddIntConstant ( m , " IPV6_RECVHOPOPTS " , IPV6_RECVHOPOPTS ) ;
# endif
# ifdef IPV6_RECVPKTINFO
PyModule_AddIntConstant ( m , " IPV6_RECVPKTINFO " , IPV6_RECVPKTINFO ) ;
# endif
# ifdef IPV6_RECVRTHDR
PyModule_AddIntConstant ( m , " IPV6_RECVRTHDR " , IPV6_RECVRTHDR ) ;
# endif
# ifdef IPV6_RECVTCLASS
PyModule_AddIntConstant ( m , " IPV6_RECVTCLASS " , IPV6_RECVTCLASS ) ;
# endif
# ifdef IPV6_RTHDR
PyModule_AddIntConstant ( m , " IPV6_RTHDR " , IPV6_RTHDR ) ;
# endif
# ifdef IPV6_RTHDRDSTOPTS
PyModule_AddIntConstant ( m , " IPV6_RTHDRDSTOPTS " , IPV6_RTHDRDSTOPTS ) ;
# endif
# ifdef IPV6_RTHDR_TYPE_0
PyModule_AddIntConstant ( m , " IPV6_RTHDR_TYPE_0 " , IPV6_RTHDR_TYPE_0 ) ;
# endif
# ifdef IPV6_RECVPATHMTU
PyModule_AddIntConstant ( m , " IPV6_RECVPATHMTU " , IPV6_RECVPATHMTU ) ;
# endif
# ifdef IPV6_TCLASS
PyModule_AddIntConstant ( m , " IPV6_TCLASS " , IPV6_TCLASS ) ;
# endif
# ifdef IPV6_USE_MIN_MTU
PyModule_AddIntConstant ( m , " IPV6_USE_MIN_MTU " , IPV6_USE_MIN_MTU ) ;
# endif
2001-08-04 19:37:23 -03:00
1999-08-09 11:40:40 -03:00
/* TCP options */
# ifdef TCP_NODELAY
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_NODELAY " , TCP_NODELAY ) ;
1999-08-09 11:40:40 -03:00
# endif
# ifdef TCP_MAXSEG
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_MAXSEG " , TCP_MAXSEG ) ;
1999-08-09 11:40:40 -03:00
# endif
2001-12-22 11:05:32 -04:00
# ifdef TCP_CORK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_CORK " , TCP_CORK ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_KEEPIDLE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_KEEPIDLE " , TCP_KEEPIDLE ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_KEEPINTVL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_KEEPINTVL " , TCP_KEEPINTVL ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_KEEPCNT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_KEEPCNT " , TCP_KEEPCNT ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_SYNCNT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_SYNCNT " , TCP_SYNCNT ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_LINGER2
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_LINGER2 " , TCP_LINGER2 ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_DEFER_ACCEPT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_DEFER_ACCEPT " , TCP_DEFER_ACCEPT ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_WINDOW_CLAMP
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_WINDOW_CLAMP " , TCP_WINDOW_CLAMP ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_INFO
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_INFO " , TCP_INFO ) ;
2001-12-22 11:05:32 -04:00
# endif
# ifdef TCP_QUICKACK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " TCP_QUICKACK " , TCP_QUICKACK ) ;
2001-12-22 11:05:32 -04:00
# endif
1999-08-09 11:40:40 -03:00
/* IPX options */
# ifdef IPX_TYPE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " IPX_TYPE " , IPX_TYPE ) ;
1999-08-09 11:40:40 -03:00
# endif
1998-04-09 17:56:35 -03:00
2001-07-21 15:05:31 -03:00
/* get{addr,name}info parameters */
# ifdef EAI_ADDRFAMILY
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_ADDRFAMILY " , EAI_ADDRFAMILY ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_AGAIN
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_AGAIN " , EAI_AGAIN ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_BADFLAGS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_BADFLAGS " , EAI_BADFLAGS ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_FAIL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_FAIL " , EAI_FAIL ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_FAMILY
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_FAMILY " , EAI_FAMILY ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_MEMORY
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_MEMORY " , EAI_MEMORY ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_NODATA
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_NODATA " , EAI_NODATA ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_NONAME
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_NONAME " , EAI_NONAME ) ;
2001-07-21 15:05:31 -03:00
# endif
2003-12-30 07:14:01 -04:00
# ifdef EAI_OVERFLOW
PyModule_AddIntConstant ( m , " EAI_OVERFLOW " , EAI_OVERFLOW ) ;
# endif
2001-07-21 15:05:31 -03:00
# ifdef EAI_SERVICE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_SERVICE " , EAI_SERVICE ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_SOCKTYPE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_SOCKTYPE " , EAI_SOCKTYPE ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_SYSTEM
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_SYSTEM " , EAI_SYSTEM ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_BADHINTS
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_BADHINTS " , EAI_BADHINTS ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_PROTOCOL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_PROTOCOL " , EAI_PROTOCOL ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef EAI_MAX
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " EAI_MAX " , EAI_MAX ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_PASSIVE
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_PASSIVE " , AI_PASSIVE ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_CANONNAME
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_CANONNAME " , AI_CANONNAME ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_NUMERICHOST
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_NUMERICHOST " , AI_NUMERICHOST ) ;
2001-07-21 15:05:31 -03:00
# endif
2003-12-30 07:14:01 -04:00
# ifdef AI_NUMERICSERV
PyModule_AddIntConstant ( m , " AI_NUMERICSERV " , AI_NUMERICSERV ) ;
# endif
2001-07-21 15:05:31 -03:00
# ifdef AI_MASK
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_MASK " , AI_MASK ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_ALL
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_ALL " , AI_ALL ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_V4MAPPED_CFG
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_V4MAPPED_CFG " , AI_V4MAPPED_CFG ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_ADDRCONFIG
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_ADDRCONFIG " , AI_ADDRCONFIG ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_V4MAPPED
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_V4MAPPED " , AI_V4MAPPED ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef AI_DEFAULT
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " AI_DEFAULT " , AI_DEFAULT ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_MAXHOST
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_MAXHOST " , NI_MAXHOST ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_MAXSERV
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_MAXSERV " , NI_MAXSERV ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_NOFQDN
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_NOFQDN " , NI_NOFQDN ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_NUMERICHOST
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_NUMERICHOST " , NI_NUMERICHOST ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_NAMEREQD
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_NAMEREQD " , NI_NAMEREQD ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_NUMERICSERV
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_NUMERICSERV " , NI_NUMERICSERV ) ;
2001-07-21 15:05:31 -03:00
# endif
# ifdef NI_DGRAM
2002-04-01 10:53:37 -04:00
PyModule_AddIntConstant ( m , " NI_DGRAM " , NI_DGRAM ) ;
2001-07-21 15:05:31 -03:00
# endif
2003-11-27 15:40:22 -04:00
/* shutdown() parameters */
# ifdef SHUT_RD
PyModule_AddIntConstant ( m , " SHUT_RD " , SHUT_RD ) ;
# elif defined(SD_RECEIVE)
PyModule_AddIntConstant ( m , " SHUT_RD " , SD_RECEIVE ) ;
# else
PyModule_AddIntConstant ( m , " SHUT_RD " , 0 ) ;
# endif
# ifdef SHUT_WR
PyModule_AddIntConstant ( m , " SHUT_WR " , SHUT_WR ) ;
# elif defined(SD_SEND)
PyModule_AddIntConstant ( m , " SHUT_WR " , SD_SEND ) ;
# else
PyModule_AddIntConstant ( m , " SHUT_WR " , 1 ) ;
# endif
# ifdef SHUT_RDWR
PyModule_AddIntConstant ( m , " SHUT_RDWR " , SHUT_RDWR ) ;
# elif defined(SD_BOTH)
PyModule_AddIntConstant ( m , " SHUT_RDWR " , SD_BOTH ) ;
# else
PyModule_AddIntConstant ( m , " SHUT_RDWR " , 2 ) ;
# endif
2008-01-04 11:23:30 -04:00
# ifdef SIO_RCVALL
tmp = PyLong_FromUnsignedLong ( SIO_RCVALL ) ;
if ( tmp = = NULL )
return ;
PyModule_AddObject ( m , " SIO_RCVALL " , tmp ) ;
PyModule_AddIntConstant ( m , " RCVALL_OFF " , RCVALL_OFF ) ;
PyModule_AddIntConstant ( m , " RCVALL_ON " , RCVALL_ON ) ;
PyModule_AddIntConstant ( m , " RCVALL_SOCKETLEVELONLY " , RCVALL_SOCKETLEVELONLY ) ;
PyModule_AddIntConstant ( m , " RCVALL_IPLEVEL " , RCVALL_IPLEVEL ) ;
PyModule_AddIntConstant ( m , " RCVALL_MAX " , RCVALL_MAX ) ;
# endif /* _MSTCPIP_ */
1998-04-09 17:56:35 -03:00
/* Initialize gethostbyname lock */
2003-05-09 04:53:18 -03:00
# if defined(USE_GETHOSTBYNAME_LOCK) || defined(USE_GETADDRINFO_LOCK)
netdb_lock = PyThread_allocate_lock ( ) ;
1998-04-09 17:56:35 -03:00
# endif
1991-06-25 18:36:08 -03:00
}
2001-06-24 18:18:26 -03:00
2002-06-07 00:19:37 -03:00
2001-06-24 18:18:26 -03:00
# ifndef HAVE_INET_PTON
2007-11-22 07:21:16 -04:00
# if !defined(NTDDI_VERSION) || (NTDDI_VERSION < NTDDI_LONGHORN)
2002-06-07 00:19:37 -03:00
/* Simplistic emulation code for inet_pton that only works for IPv4 */
2003-04-25 02:48:32 -03:00
/* These are not exposed because they do not set errno properly */
2002-06-07 00:19:37 -03:00
2002-06-06 23:08:35 -03:00
int
2002-06-07 00:19:37 -03:00
inet_pton ( int af , const char * src , void * dst )
2001-06-24 18:18:26 -03:00
{
2002-06-07 00:19:37 -03:00
if ( af = = AF_INET ) {
2001-06-24 18:18:26 -03:00
long packed_addr ;
packed_addr = inet_addr ( src ) ;
if ( packed_addr = = INADDR_NONE )
return 0 ;
memcpy ( dst , & packed_addr , 4 ) ;
return 1 ;
}
/* Should set errno to EAFNOSUPPORT */
return - 1 ;
}
2001-07-21 06:42:15 -03:00
const char *
inet_ntop ( int af , const void * src , char * dst , socklen_t size )
2001-06-24 18:18:26 -03:00
{
if ( af = = AF_INET ) {
struct in_addr packed_addr ;
if ( size < 16 )
/* Should set errno to ENOSPC. */
return NULL ;
memcpy ( & packed_addr , src , sizeof ( packed_addr ) ) ;
return strncpy ( dst , inet_ntoa ( packed_addr ) , size ) ;
}
/* Should set errno to EAFNOSUPPORT */
return NULL ;
}
2002-06-07 00:19:37 -03:00
2001-06-24 18:18:26 -03:00
# endif
2007-11-22 07:21:16 -04:00
# endif