Initial revision

Modules/socketmodule.c

@@ -0,0 +1,494 @@
+/***********************************************************
+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);
+}