Initial revision
This commit is contained in:
Guido van Rossum
parent
d6a15ada72
commit
6574b3ee25
|
|
@ -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);
|
||||
}
|
||||
Loading…
Reference in New Issue