Modules/socketmodule.c - platform/external/python/cpython2 - Gitiles

 /***********************************************************
 Copyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
 Netherlands.

                         All Rights Reserved

 Permission to use, copy, modify, and distribute this software and its
 documentation for any purpose and without fee is hereby granted,
 provided that the above copyright notice appear in all copies and that
 both that copyright notice and this permission notice appear in
 supporting documentation, and that the names of Stichting Mathematisch
 Centrum or CWI not be used in advertising or publicity pertaining to
 distribution of the software without specific, written prior permission.

 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 ******************************************************************/

 /* Socket module */

 /*
 This module provides an interface to Berkeley socket IPC.

 Limitations:

 - only AF_INET and AF_UNIX address families
 - no asynchronous I/O
 - no flags on send/receive operations
 - no socket options
 - no protocol parameter on socket() system call
 - although socket objects have read() and write() methods, they can't be
   used everywhere where file objects can be used (e.g., sys.stdout won't
   work and there is no readline() method)

 Interface:

 - socket.socket(family, type) returns a new socket object
 - family and type constants from <socket.h> are accessed as socket.AF_INET etc.
 - socket methods are:
 	- s.bind(sockaddr) --> None
 	- s.connect(sockaddr) --> None
 	- s.accept() --> newsocket, sockaddr
 	- s.listen(n) --> None
 	- s.read(nbytes) --> string
 	- s.write(string) --> nbytes
 	- s.recvfrom(nbytes) --> string, sockaddr
 	- s.sendto(string, sockaddr) --> nbytes
 	- s.shutdown(how) --> None
 	- s.close() --> None
 - errors are reported as the exception socket.error
 - 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
 - a UNIX domain socket is a string specifying the pathname

 Bugs:

 - On the vax, the port numbers seem to be mixed up (when receiving only???)
 */

 #include "allobjects.h"
 #include "modsupport.h"

 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <sys/un.h>
 #include <netdb.h>

 static object *SocketError; /* Exception socket.error */

 static object *
 socket_error()
 {
 	return err_errno(SocketError);
 }

 typedef struct {
 	OB_HEAD
 	int sock_fd;
 	int sock_family;
 	int sock_type;
 	int sock_proto;
 } sockobject;

 extern typeobject Socktype; /* Forward */

 static sockobject *
 newsockobject(fd, family, type, proto)
 	int fd, family, type, proto;
 {
 	sockobject *s;
 	s = NEWOBJ(sockobject, &Socktype);
 	if (s != NULL) {
 		s->sock_fd = fd;
 		s->sock_family = family;
 		s->sock_type = type;
 		s->sock_proto = proto;
 	}
 	return s;
 }

 static int setinetaddr PROTO((char *, struct sockaddr_in *));
 static int
 setinetaddr(name, addr_ret)
 	char *name;
 	struct sockaddr_in *addr_ret;
 {
 	struct hostent *hp;

 	if (strcmp(name, "<any>") == 0) {
 		addr_ret->sin_addr.s_addr = INADDR_ANY;
 		return 4;
 	}
 	if (strcmp(name, "<broadcast>") == 0) {
 		addr_ret->sin_addr.s_addr = INADDR_BROADCAST;
 		return 4;
 	}
 	hp = gethostbyname(name);
 	if (hp == NULL) {
 		err_setstr(SocketError, "host not found");
 		return -1;
 	}
 	memcpy((char *) &addr_ret->sin_addr, hp->h_addr, hp->h_length);
 	return hp->h_length;
 }

 static object *
 makepair(a, b)
 	object *a, *b;
 {
 	object *pair = NULL;
 	if (a == NULL || b == NULL || (pair = newtupleobject(2)) == NULL) {
 		XDECREF(a);
 		XDECREF(b);
 		return NULL;
 	}
 	settupleitem(pair, 0, a);
 	settupleitem(pair, 1, b);
 	return pair;
 }

 /*ARGSUSED*/
 static object *
 makesockaddr(addr, addrlen)
 	struct sockaddr *addr;
 	int addrlen;
 {
 	if (addr->sa_family == AF_INET) {
 		struct sockaddr_in *a = (struct sockaddr_in *) addr;
 		long x = ntohl(a->sin_addr.s_addr);
 		char buf[100];
 		sprintf(buf, "%d.%d.%d.%d",
 			(int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
 			(int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
 		return makepair(newstringobject(buf),
 				newintobject((long) ntohs(a->sin_port)));
 	}
 	if (addr->sa_family == AF_UNIX) {
 		struct sockaddr_un *a = (struct sockaddr_un *) addr;
 		return newstringobject(a->sun_path);
 	}
 	err_setstr(SocketError, "returning unknown socket address type");
 	return NULL;
 }

 static int getsockaddrarg PROTO((sockobject *, object *,
 				 struct sockaddr **, int *));
 static int
 getsockaddrarg(s, args, addr_ret, len_ret)
 	sockobject *s;
 	object *args;
 	struct sockaddr **addr_ret;
 	int *len_ret;
 {
 	if (s->sock_family == AF_UNIX) {
 		static struct sockaddr_un addr;
 		object *path;
 		int len;
 		if (!getstrarg(args, &path) ||
 		    (len = getstringsize(path)) > sizeof addr.sun_path)
 			return 0;
 		addr.sun_family = AF_UNIX;
 		memcpy(addr.sun_path, getstringvalue(path), len);
 		*addr_ret = (struct sockaddr *) &addr;
 		*len_ret = len + sizeof addr.sun_family;
 		return 1;
 	}

 	if (s->sock_family == AF_INET) {
 		static struct sockaddr_in addr;
 		object *host;
 		int port;
 		if (!getstrintarg(args, &host, &port))
 			return 0;
 		if (setinetaddr(getstringvalue(host), &addr) < 0)
 			return 0;
 		addr.sin_family = AF_INET;
 		addr.sin_port = htons(port);
 		*addr_ret = (struct sockaddr *) &addr;
 		*len_ret = sizeof addr;
 		return 1;
 	}

 	err_setstr(SocketError, "getsockaddrarg: bad family");
 	return 0;
 }

 static object *
 sock_accept(s, args)
 	sockobject *s;
 	object *args;
 {
 	char addrbuf[256];
 	int addrlen, newfd;
 	object *res;
 	if (!getnoarg(args))
 		return NULL;
 	addrlen = sizeof addrbuf;
 	newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
 	if (newfd < 0)
 		return socket_error();
 	res = makepair((object *) newsockobject(newfd, AF_UNSPEC, 0, 0),
 		       makesockaddr((struct sockaddr *) addrbuf, addrlen));
 	if (res == NULL)
 		close(newfd);
 	return res;
 }

 static object *
 sock_bind(s, args)
 	sockobject *s;
 	object *args;
 {
 	struct sockaddr *addr;
 	int addrlen;
 	if (!getsockaddrarg(s, args, &addr, &addrlen))
 		return NULL;
 	if (bind(s->sock_fd, addr, addrlen) < 0)
 		return socket_error();
 	INCREF(None);
 	return None;
 }

 static object *
 sock_close(s, args)
 	sockobject *s;
 	object *args;
 {
 	if (!getnoarg(args))
 		return NULL;
 	(void) close(s->sock_fd);
 	s->sock_fd = -1;
 	INCREF(None);
 	return None;
 }

 static object *
 sock_connect(s, args)
 	sockobject *s;
 	object *args;
 {
 	struct sockaddr *addr;
 	int addrlen;
 	if (!getsockaddrarg(s, args, &addr, &addrlen))
 		return NULL;
 	if (connect(s->sock_fd, addr, addrlen) < 0)
 		return socket_error();
 	INCREF(None);
 	return None;
 }

 static object *
 sock_listen(s, args)
 	sockobject *s;
 	object *args;
 {
 	int backlog;
 	if (!getintarg(args, &backlog))
 		return NULL;
 	if (listen(s->sock_fd, backlog) < 0)
 		return socket_error();
 	INCREF(None);
 	return None;
 }

 static object *
 sock_read(s, args)
 	sockobject *s;
 	object *args;
 {
 	int len, n;
 	object *buf;
 	if (!getintarg(args, &len))
 		return NULL;
 	buf = newsizedstringobject((char *) 0, len);
 	if (buf == NULL)
 		return NULL;
 	n = read(s->sock_fd, getstringvalue(buf), len);
 	if (n < 0)
 		return socket_error();
 	if (resizestring(&buf, n) < 0)
 		return NULL;
 	return buf;
 }

 static object *
 sock_recvfrom(s, args)
 	sockobject *s;
 	object *args;
 {
 	char addrbuf[256];
 	object *buf;
 	int addrlen, len, n;
 	if (!getintarg(args, &len))
 		return NULL;
 	buf = newsizedstringobject((char *) 0, len);
 	addrlen = sizeof addrbuf;
 	n = recvfrom(s->sock_fd, getstringvalue(buf), len, 0,
 		     addrbuf, &addrlen);
 	if (n < 0)
 		return socket_error();
 	if (resizestring(&buf, n) < 0)
 		return NULL;
 	return makepair(buf, makesockaddr(addrbuf, addrlen));
 }

 static object *
 sock_sendto(s, args)
 	sockobject *s;
 	object *args;
 {
 	object *buf;
 	struct sockaddr *addr;
 	int addrlen, len, n;
 	if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 2) {
 		err_badarg();
 		return NULL;
 	}
 	if (!getstrarg(gettupleitem(args, 0), &buf) ||
 	    !getsockaddrarg(s, gettupleitem(args, 1), &addr, &addrlen))
 		return NULL;
 	len = getstringsize(buf);
 	n = sendto(s->sock_fd, getstringvalue(buf), len, 0,
 		   addr, addrlen);
 	if (n < 0)
 		return socket_error();
 	return newintobject((long) n);
 }

 static object *
 sock_shutdown(s, args)
 	sockobject *s;
 	object *args;
 {
 	int how;
 	if (!getintarg(args, &how))
 		return NULL;
 	if (shutdown(s->sock_fd, how) < 0)
 		return socket_error();
 	INCREF(None);
 	return None;
 }

 static object *
 sock_write(s, args)
 	sockobject *s;
 	object *args;
 {
 	object *buf;
 	int len, n;
 	if (!getstrarg(args, &buf))
 		return NULL;
 	len = getstringsize(buf);
 	n = write(s->sock_fd, getstringvalue(buf), len);
 	if (n < 0)
 		return socket_error();
 	return newintobject((long) n);
 }

 static struct methodlist sock_methods[] = {
 	{"accept",	sock_accept},
 	{"bind",	sock_bind},
 	{"close",	sock_close},
 	{"connect",	sock_connect},
 	{"listen",	sock_listen},
 	{"read",	sock_read},
 	{"recvfrom",	sock_recvfrom},
 	{"sendto",	sock_sendto},
 	{"shutdown",	sock_shutdown},
 	{"write",	sock_write},
 	{NULL,		NULL}		/* sentinel */
 };

 static void
 sock_dealloc(s)
 	sockobject *s;
 {
 	(void) close(s->sock_fd);
 	DEL(s);
 }

 static object *
 sock_getattr(s, name)
 	sockobject *s;
 	char *name;
 {
 	return findmethod(sock_methods, (object *) s, name);
 }

 static typeobject Socktype = {
 	OB_HEAD_INIT(&Typetype)
 	0,
 	"socket",
 	sizeof(sockobject),
 	0,
 	sock_dealloc,	/*tp_dealloc*/
 	0,		/*tp_print*/
 	sock_getattr,	/*tp_getattr*/
 	0,		/*tp_setattr*/
 	0,		/*tp_compare*/
 	0,		/*tp_repr*/
 	0,		/*tp_as_number*/
 	0,		/*tp_as_sequence*/
 	0,		/*tp_as_mapping*/
 };

 /*ARGSUSED*/
 static object *
 socket_socket(self, args)
 	object *self;
 	object *args;
 {
 	sockobject *s;
 	int family, type, proto, fd;
 	if (!getintintarg(args, &family, &type))
 		return NULL;
 	proto = 0;
 	fd = socket(family, type, proto);
 	if (fd < 0)
 		return socket_error();
 	s = newsockobject(fd, family, type, proto);
 	if (s == NULL)
 		close(fd);
 	return (object *) s;
 }

 static struct methodlist socket_methods[] = {
 	{"socket",	socket_socket},
 	{NULL,		NULL}		 /* Sentinel */
 };

 static void
 insint(d, name, value)
 	object *d;
 	char *name;
 	int value;
 {
 	object *v = newintobject((long) value);
 	if (v == NULL) {
 		/* Don't bother reporting this error */
 		err_clear();
 	}
 	else {
 		dictinsert(d, name, v);
 		DECREF(v);
 	}
 }

 void
 initsocket()
 {
 	object *m, *d;

 	m = initmodule("socket", socket_methods);
 	d = getmoduledict(m);
 	SocketError = newstringobject("socket.error");
 	if (SocketError == NULL || dictinsert(d, "error", SocketError) != 0)
 		fatal("can't define socket.error");
 	insint(d, "AF_INET", AF_INET);
 	insint(d, "AF_UNIX", AF_UNIX);
 	insint(d, "SOCK_STREAM", SOCK_STREAM);
 	insint(d, "SOCK_DGRAM", SOCK_DGRAM);
 	insint(d, "SOCK_RAW", SOCK_RAW);
 	insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
 	insint(d, "SOCK_RDM", SOCK_RDM);
 }
	/***********************************************************
	Copyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
	Netherlands.

	All Rights Reserved

	Permission to use, copy, modify, and distribute this software and its
	documentation for any purpose and without fee is hereby granted,
	provided that the above copyright notice appear in all copies and that
	both that copyright notice and this permission notice appear in
	supporting documentation, and that the names of Stichting Mathematisch
	Centrum or CWI not be used in advertising or publicity pertaining to
	distribution of the software without specific, written prior permission.

	STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
	THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
	FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
	FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

	******************************************************************/

	/* Socket module */

	/*
	This module provides an interface to Berkeley socket IPC.

	Limitations:

	- only AF_INET and AF_UNIX address families
	- no asynchronous I/O
	- no flags on send/receive operations
	- no socket options
	- no protocol parameter on socket() system call
	- although socket objects have read() and write() methods, they can't be
	used everywhere where file objects can be used (e.g., sys.stdout won't
	work and there is no readline() method)

	Interface:

	- socket.socket(family, type) returns a new socket object
	- family and type constants from <socket.h> are accessed as socket.AF_INET etc.
	- socket methods are:
	- s.bind(sockaddr) --> None
	- s.connect(sockaddr) --> None
	- s.accept() --> newsocket, sockaddr
	- s.listen(n) --> None
	- s.read(nbytes) --> string
	- s.write(string) --> nbytes
	- s.recvfrom(nbytes) --> string, sockaddr
	- s.sendto(string, sockaddr) --> nbytes
	- s.shutdown(how) --> None
	- s.close() --> None
	- errors are reported as the exception socket.error
	- 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
	- a UNIX domain socket is a string specifying the pathname

	Bugs:

	- On the vax, the port numbers seem to be mixed up (when receiving only???)
	*/

	#include "allobjects.h"
	#include "modsupport.h"

	#include <sys/types.h>
	#include <sys/socket.h>
	#include <netinet/in.h>
	#include <sys/un.h>
	#include <netdb.h>

	static object SocketError; / Exception socket.error */

	static object *
	socket_error()
	{
	return err_errno(SocketError);
	}

	typedef struct {
	OB_HEAD
	int sock_fd;
	int sock_family;
	int sock_type;
	int sock_proto;
	} sockobject;

	extern typeobject Socktype; /* Forward */

	static sockobject *
	newsockobject(fd, family, type, proto)
	int fd, family, type, proto;
	{
	sockobject *s;
	s = NEWOBJ(sockobject, &Socktype);
	if (s != NULL) {
	s->sock_fd = fd;
	s->sock_family = family;
	s->sock_type = type;
	s->sock_proto = proto;
	}
	return s;
	}

	static int setinetaddr PROTO((char , struct sockaddr_in ));
	static int
	setinetaddr(name, addr_ret)
	char *name;
	struct sockaddr_in *addr_ret;
	{
	struct hostent *hp;

	if (strcmp(name, "<any>") == 0) {
	addr_ret->sin_addr.s_addr = INADDR_ANY;
	return 4;
	}
	if (strcmp(name, "<broadcast>") == 0) {
	addr_ret->sin_addr.s_addr = INADDR_BROADCAST;
	return 4;
	}
	hp = gethostbyname(name);
	if (hp == NULL) {
	err_setstr(SocketError, "host not found");
	return -1;
	}
	memcpy((char *) &addr_ret->sin_addr, hp->h_addr, hp->h_length);
	return hp->h_length;
	}

	static object *
	makepair(a, b)
	object a, b;
	{
	object *pair = NULL;
	if (a == NULL \|\| b == NULL \|\| (pair = newtupleobject(2)) == NULL) {
	XDECREF(a);
	XDECREF(b);
	return NULL;
	}
	settupleitem(pair, 0, a);
	settupleitem(pair, 1, b);
	return pair;
	}

	/ARGSUSED/
	static object *
	makesockaddr(addr, addrlen)
	struct sockaddr *addr;
	int addrlen;
	{
	if (addr->sa_family == AF_INET) {
	struct sockaddr_in a = (struct sockaddr_in ) addr;
	long x = ntohl(a->sin_addr.s_addr);
	char buf[100];
	sprintf(buf, "%d.%d.%d.%d",
	(int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
	(int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
	return makepair(newstringobject(buf),
	newintobject((long) ntohs(a->sin_port)));
	}
	if (addr->sa_family == AF_UNIX) {
	struct sockaddr_un a = (struct sockaddr_un ) addr;
	return newstringobject(a->sun_path);
	}
	err_setstr(SocketError, "returning unknown socket address type");
	return NULL;
	}

	static int getsockaddrarg PROTO((sockobject , object ,
	struct sockaddr *, int ));
	static int
	getsockaddrarg(s, args, addr_ret, len_ret)
	sockobject *s;
	object *args;
	struct sockaddr **addr_ret;
	int *len_ret;
	{
	if (s->sock_family == AF_UNIX) {
	static struct sockaddr_un addr;
	object *path;
	int len;
	if (!getstrarg(args, &path) \|\|
	(len = getstringsize(path)) > sizeof addr.sun_path)
	return 0;
	addr.sun_family = AF_UNIX;
	memcpy(addr.sun_path, getstringvalue(path), len);
	addr_ret = (struct sockaddr ) &addr;
	*len_ret = len + sizeof addr.sun_family;
	return 1;
	}

	if (s->sock_family == AF_INET) {
	static struct sockaddr_in addr;
	object *host;
	int port;
	if (!getstrintarg(args, &host, &port))
	return 0;
	if (setinetaddr(getstringvalue(host), &addr) < 0)
	return 0;
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr_ret = (struct sockaddr ) &addr;
	*len_ret = sizeof addr;
	return 1;
	}

	err_setstr(SocketError, "getsockaddrarg: bad family");
	return 0;
	}

	static object *
	sock_accept(s, args)
	sockobject *s;
	object *args;
	{
	char addrbuf[256];
	int addrlen, newfd;
	object *res;
	if (!getnoarg(args))
	return NULL;
	addrlen = sizeof addrbuf;
	newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);
	if (newfd < 0)
	return socket_error();
	res = makepair((object *) newsockobject(newfd, AF_UNSPEC, 0, 0),
	makesockaddr((struct sockaddr *) addrbuf, addrlen));
	if (res == NULL)
	close(newfd);
	return res;
	}

	static object *
	sock_bind(s, args)
	sockobject *s;
	object *args;
	{
	struct sockaddr *addr;
	int addrlen;
	if (!getsockaddrarg(s, args, &addr, &addrlen))
	return NULL;
	if (bind(s->sock_fd, addr, addrlen) < 0)
	return socket_error();
	INCREF(None);
	return None;
	}

	static object *
	sock_close(s, args)
	sockobject *s;
	object *args;
	{
	if (!getnoarg(args))
	return NULL;
	(void) close(s->sock_fd);
	s->sock_fd = -1;
	INCREF(None);
	return None;
	}

	static object *
	sock_connect(s, args)
	sockobject *s;
	object *args;
	{
	struct sockaddr *addr;
	int addrlen;
	if (!getsockaddrarg(s, args, &addr, &addrlen))
	return NULL;
	if (connect(s->sock_fd, addr, addrlen) < 0)
	return socket_error();
	INCREF(None);
	return None;
	}

	static object *
	sock_listen(s, args)
	sockobject *s;
	object *args;
	{
	int backlog;
	if (!getintarg(args, &backlog))
	return NULL;
	if (listen(s->sock_fd, backlog) < 0)
	return socket_error();
	INCREF(None);
	return None;
	}

	static object *
	sock_read(s, args)
	sockobject *s;
	object *args;
	{
	int len, n;
	object *buf;
	if (!getintarg(args, &len))
	return NULL;
	buf = newsizedstringobject((char *) 0, len);
	if (buf == NULL)
	return NULL;
	n = read(s->sock_fd, getstringvalue(buf), len);
	if (n < 0)
	return socket_error();
	if (resizestring(&buf, n) < 0)
	return NULL;
	return buf;
	}

	static object *
	sock_recvfrom(s, args)
	sockobject *s;
	object *args;
	{
	char addrbuf[256];
	object *buf;
	int addrlen, len, n;
	if (!getintarg(args, &len))
	return NULL;
	buf = newsizedstringobject((char *) 0, len);
	addrlen = sizeof addrbuf;
	n = recvfrom(s->sock_fd, getstringvalue(buf), len, 0,
	addrbuf, &addrlen);
	if (n < 0)
	return socket_error();
	if (resizestring(&buf, n) < 0)
	return NULL;
	return makepair(buf, makesockaddr(addrbuf, addrlen));
	}

	static object *
	sock_sendto(s, args)
	sockobject *s;
	object *args;
	{
	object *buf;
	struct sockaddr *addr;
	int addrlen, len, n;
	if (args == NULL \|\| !is_tupleobject(args) \|\| gettuplesize(args) != 2) {
	err_badarg();
	return NULL;
	}
	if (!getstrarg(gettupleitem(args, 0), &buf) \|\|
	!getsockaddrarg(s, gettupleitem(args, 1), &addr, &addrlen))
	return NULL;
	len = getstringsize(buf);
	n = sendto(s->sock_fd, getstringvalue(buf), len, 0,
	addr, addrlen);
	if (n < 0)
	return socket_error();
	return newintobject((long) n);
	}

	static object *
	sock_shutdown(s, args)
	sockobject *s;
	object *args;
	{
	int how;
	if (!getintarg(args, &how))
	return NULL;
	if (shutdown(s->sock_fd, how) < 0)
	return socket_error();
	INCREF(None);
	return None;
	}

	static object *
	sock_write(s, args)
	sockobject *s;
	object *args;
	{
	object *buf;
	int len, n;
	if (!getstrarg(args, &buf))
	return NULL;
	len = getstringsize(buf);
	n = write(s->sock_fd, getstringvalue(buf), len);
	if (n < 0)
	return socket_error();
	return newintobject((long) n);
	}

	static struct methodlist sock_methods[] = {
	{"accept", sock_accept},
	{"bind", sock_bind},
	{"close", sock_close},
	{"connect", sock_connect},
	{"listen", sock_listen},
	{"read", sock_read},
	{"recvfrom", sock_recvfrom},
	{"sendto", sock_sendto},
	{"shutdown", sock_shutdown},
	{"write", sock_write},
	{NULL, NULL} /* sentinel */
	};

	static void
	sock_dealloc(s)
	sockobject *s;
	{
	(void) close(s->sock_fd);
	DEL(s);
	}

	static object *
	sock_getattr(s, name)
	sockobject *s;
	char *name;
	{
	return findmethod(sock_methods, (object *) s, name);
	}

	static typeobject Socktype = {
	OB_HEAD_INIT(&Typetype)
	0,
	"socket",
	sizeof(sockobject),
	0,
	sock_dealloc, /tp_dealloc/
	0, /tp_print/
	sock_getattr, /tp_getattr/
	0, /tp_setattr/
	0, /tp_compare/
	0, /tp_repr/
	0, /tp_as_number/
	0, /tp_as_sequence/
	0, /tp_as_mapping/
	};

	/ARGSUSED/
	static object *
	socket_socket(self, args)
	object *self;
	object *args;
	{
	sockobject *s;
	int family, type, proto, fd;
	if (!getintintarg(args, &family, &type))
	return NULL;
	proto = 0;
	fd = socket(family, type, proto);
	if (fd < 0)
	return socket_error();
	s = newsockobject(fd, family, type, proto);
	if (s == NULL)
	close(fd);
	return (object *) s;
	}

	static struct methodlist socket_methods[] = {
	{"socket", socket_socket},
	{NULL, NULL} /* Sentinel */
	};

	static void
	insint(d, name, value)
	object *d;
	char *name;
	int value;
	{
	object *v = newintobject((long) value);
	if (v == NULL) {
	/* Don't bother reporting this error */
	err_clear();
	}
	else {
	dictinsert(d, name, v);
	DECREF(v);
	}
	}

	void
	initsocket()
	{
	object m, d;

	m = initmodule("socket", socket_methods);
	d = getmoduledict(m);
	SocketError = newstringobject("socket.error");
	if (SocketError == NULL \|\| dictinsert(d, "error", SocketError) != 0)
	fatal("can't define socket.error");
	insint(d, "AF_INET", AF_INET);
	insint(d, "AF_UNIX", AF_UNIX);
	insint(d, "SOCK_STREAM", SOCK_STREAM);
	insint(d, "SOCK_DGRAM", SOCK_DGRAM);
	insint(d, "SOCK_RAW", SOCK_RAW);
	insint(d, "SOCK_SEQPACKET", SOCK_SEQPACKET);
	insint(d, "SOCK_RDM", SOCK_RDM);
	}