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