Modules/socketmodule.c

/***********************************************************
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);
}