From 6574b3ee252f27441c6708b8cbf480fbf42f5431 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Tue, 25 Jun 1991 21:36:08 +0000 Subject: [PATCH] Initial revision --- Modules/socketmodule.c | 494 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 494 insertions(+) create mode 100644 Modules/socketmodule.c diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c new file mode 100644 index 00000000000..a54a2cb7e99 --- /dev/null +++ b/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 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 +#include +#include +#include +#include + +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, "") == 0) { + addr_ret->sin_addr.s_addr = INADDR_ANY; + return 4; + } + if (strcmp(name, "") == 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); +}