+++ /dev/null
-# -*-pyrex-*-
-#
-# $Id$
-#
-# Selectery
-#
-# (c) 2005 Straylight/Edgeware
-#
-
-#----- Licensing notice -----------------------------------------------------
-#
-# This file is part of the Python interface to mLib.
-#
-# mLib/Python is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# mLib/Python is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with mLib/Python; if not, write to the Free Software Foundation,
-# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-#----- External dependencies ------------------------------------------------
-
-cdef extern from 'stddef.h':
- ctypedef int size_t
-cdef extern from 'string.h':
- void memcpy(void *p, void *q, size_t n)
-cdef extern from 'errno.h':
- int errno
- enum:
- EINTR
- EAGAIN
-cdef extern from 'math.h':
- double modf(double x, double *i)
-cdef extern from 'string.h':
- char *strerror(int err)
-cdef extern from 'sys/time.h':
- struct timeval:
- int tv_sec
- int tv_usec
-cdef extern from 'sys/types.h':
- pass
-cdef extern from 'sys/socket.h':
- struct sockaddr:
- int sa_family
- enum:
- AF_INET
- int getsockname(int fd, sockaddr *pa, size_t *psz)
- int getpeername(int fd, sockaddr *pa, size_t *psz)
-cdef extern from 'arpa/inet.h':
- struct in_addr:
- int s_addr
- int inet_aton(char *rp, in_addr *ia)
- char *inet_ntoa(in_addr ia)
-cdef extern from 'netinet/in.h':
- struct sockaddr_in:
- int sin_family
- in_addr sin_addr
- int sin_port
- int htons(int x)
- int htonl(int x)
- int ntohs(int x)
- int ntohl(int x)
-cdef extern from 'netdb.h':
- struct hostent:
- char *h_name
- char **h_aliases
- int h_addrtype
- int h_length
- char **h_addr_list
- char *h_addr
- int h_errno
-
-cdef extern from 'mLib/sel.h':
- ctypedef struct sel_state:
- pass
- ctypedef struct sel_file:
- int fd
- ctypedef struct sel_timer:
- pass
- enum:
- SEL_READ
- SEL_WRITE
- SEL_EXC
- void sel_init(sel_state *s)
- void sel_initfile(sel_state *s, sel_file *f, int fd, unsigned mode,
- void (*func)(int fd, unsigned mode, void *arg),
- void *arg)
- void sel_force(sel_file *f)
- void sel_addfile(sel_file *f)
- void sel_rmfile(sel_file *f)
- void sel_addtimer(sel_state *s, sel_timer *t, timeval *tv,
- void (*func)(timeval *tv, void *arg),
- void *arg)
- void sel_rmtimer(sel_timer *t)
- int sel_select(sel_state *s) except *
-
-cdef extern from 'mLib/conn.h':
- ctypedef struct conn:
- pass
- int conn_fd(conn *c, sel_state *s, int fd,
- void (*func)(int fd, void *arg), void *arg)
- void conn_kill(conn *c)
-
-cdef extern from 'mLib/bres.h':
- ctypedef struct bres_client:
- pass
- void bres_byname(bres_client *r, char *name,
- void (*func)(hostent *h, void *arg), void *arg)
- void bres_byaddr(bres_client *r, in_addr addr,
- void (*func)(hostent *h, void *arg), void *arg)
- void bres_abort(bres_client *r)
- void bres_exec(char *null)
- void bres_init(sel_state *s)
-
-cdef extern from 'mLib/sig.h':
- ctypedef struct sig:
- pass
- void sig_add(sig *s, int n, void (*func)(int n, void *arg), void *arg)
- void sig_remove(sig *s)
- void sig_init(sel_state *s)
-
-cdef extern from 'mLib/lbuf.h':
- cdef struct lbuf:
- int f
- int delim
- size_t sz
- enum:
- LBUF_ENABLE
- LBUF_CRLF
- LBUF_STRICTCRLF
-
-cdef extern from 'mLib/selbuf.h':
- ctypedef struct selbuf:
- sel_file reader
- lbuf b
- void selbuf_enable(selbuf *b)
- void selbuf_disable(selbuf *b)
- void selbuf_setsize(selbuf *b, size_t sz)
- void selbuf_init(selbuf *b, sel_state *s, int fd,
- void (*func)(char *s, size_t len, void *arg), void *arg)
- void selbuf_destroy(selbuf *b)
-
-cdef extern from 'mLib/pkbuf.h':
- ctypedef struct pkbuf:
- int f
- int want
- enum:
- PKBUF_ENABLE
-
-cdef extern from 'mLib/selpk.h':
- ctypedef struct selpk:
- sel_file reader
- pkbuf pk
- void selpk_enable(selpk *b)
- void selpk_disable(selpk *b)
- void selpk_want(selpk *b, size_t sz)
- void selpk_init(selpk *b, sel_state *s, int fd,
- void (*func)(unsigned char *p, size_t n,
- pkbuf *pk, size_t *keep, void *arg),
- void *arg)
- void selpk_destroy(selpk *b)
-
-cdef extern from 'mLib/ident.h':
- ctypedef struct ident_request:
- pass
- enum:
- IDENT_USERID
- IDENT_ERROR
- IDENT_BAD
- struct ident_userid:
- char *os
- char *user
- union ident_u:
- ident_userid userid
- char *error
- ctypedef struct ident_reply:
- int sport
- int dport
- int type
- ident_u u
- void ident(ident_request *rq, sel_state *s,
- sockaddr_in *local, sockaddr_in *remote,
- void (*func)(ident_reply *r, void *arg),
- void *arg)
- void ident_abort(ident_request *rq)
-
-cdef extern from 'Python.h':
- object PyString_FromStringAndSize(char *p, int len)
- int PyString_AsStringAndSize(obj, char **p, int *len) except -1
- int PyObject_AsReadBuffer(obj, void **buf, int *len) except -1
- int PyObject_TypeCheck(obj, ty)
-
-cdef extern from 'grim.h':
- int PSIZEOF(void *x)
-
-import socket
-import signal
-
-#----- Utility functions ----------------------------------------------------
-
-cdef _oserror():
- raise OSError, (errno, strerror(errno))
-
-cdef object _tobool(int i):
- if i:
- return True
- else:
- return False
-
-cdef int _getfd(object fdobj):
- try:
- return fdobj
- except TypeError:
- return fdobj.fileno()
-
-#----- The global select state ----------------------------------------------
-
-cdef sel_state sel
-
-sel_init(&sel)
-bres_init(&sel)
-bres_exec(NULL)
-sig_init(&sel)
-
-def select():
- if sel_select(&sel) and errno != EINTR and errno != EAGAIN:
- _oserror()
-
-#----- File selectors -------------------------------------------------------
-
-READ = SEL_READ
-WRITE = SEL_WRITE
-EXCEPT = SEL_EXC
-
-cdef class File:
- cdef sel_file f
- cdef int _activep
- cdef readonly unsigned mode
- def __new__(me, fd, int mode = SEL_READ):
- if (mode != SEL_READ and
- mode != SEL_WRITE and
- mode != SEL_EXC):
- raise ValueError, 'bad select mode'
- sel_initfile(&sel, &me.f, _getfd(fd), mode, _filefunc, <void *>me)
- me._activep = 0
- me.mode = mode
- def __dealloc__(me):
- if me._activep:
- sel_rmfile(&me.f)
- property fd:
- def __get__(me):
- return me.f.fd
- property activep:
- def __get__(me):
- return _tobool(me._activep)
- def enable(me):
- if me._activep:
- raise ValueError, 'already enabled'
- sel_addfile(&me.f)
- me._activep = 1
- return me
- def disable(me):
- if not me._activep:
- raise ValueError, 'already disabled'
- sel_rmfile(&me.f)
- me._activep = 0
- return me
- def force(me):
- sel_force(&me.f)
- return me
- def ready(me):
- pass
-
-cdef void _filefunc(int fd, unsigned mode, void *arg):
- cdef File sf
- sf = <File>arg
- sf.ready()
-
-#----- Timer selectors ------------------------------------------------------
-
-cdef double _tvtofloat(timeval *tv):
- return tv.tv_sec + (tv.tv_usec / 1000000)
-cdef void _floattotv(timeval *tv, double t):
- cdef double s, us
- us = modf(t, &s)
- tv.tv_sec = s
- tv.tv_usec = us * 1000000
-
-cdef class Timer:
- cdef sel_timer t
- cdef int _activep
- cdef readonly double time
- def __new__(me, double when):
- cdef timeval tv
- _floattotv(&tv, when)
- sel_addtimer(&sel, &me.t, &tv, _timerfunc, <void *>me)
- me._activep = 1
- me.time = when
- def __dealloc__(me):
- if me._activep:
- sel_rmtimer(&me.t)
- property activep:
- def __get__(me):
- return _tobool(me._activep)
- def kill(me):
- if not me._activep:
- raise ValueError, 'already dead'
- sel_rmtimer(&me.t)
- me._activep = 0
- return me
- def timer(me, now):
- pass
-
-cdef void _timerfunc(timeval *now, void *arg):
- cdef Timer st
- st = <Timer>arg
- st._activep = 0
- st.timer(_tvtofloat(now))
-
-#----- Connections ----------------------------------------------------------
-
-cdef class Connect:
- cdef conn c
- cdef int _activep
- cdef readonly object socket
- def __new__(me, sk):
- conn_fd(&me.c, &sel, sk.fileno(), _connfunc, <void *>me)
- me._activep = 1
- me.socket = sk
- def __dealloc__(me):
- if me._activep:
- conn_kill(&me.c)
- property activep:
- def __get__(me):
- return _tobool(me._activep)
- def kill(me):
- if not me._activep:
- raise ValueError, 'already dead'
- conn_kill(&me.c);
- me._activep = 0
- return me
- def connected(me):
- pass
- def error(me, errno, strerror):
- pass
-
-cdef void _connfunc(int fd, void *arg):
- cdef Connect c
- c = <Connect>arg
- c._activep = 0
- if fd == -1:
- c.socket = None
- c.error(errno, strerror(errno))
- else:
- c.connected()
-
-#----- Background name resolution -------------------------------------------
-
-cdef class Resolve:
- cdef bres_client r
- cdef int _activep
- def __init__(me, *hunoz, **hukairz):
- raise TypeError, 'abstract class'
- property activep:
- def __get__(me):
- return _tobool(me._activep)
- def kill(me):
- if not me._activep:
- raise ValueError, 'already dead'
- bres_abort(&me.r)
- return me
- def resolved(me, h):
- pass
- def failed(me):
- pass
-
-cdef class ResolveByName (Resolve):
- def __new__(me, char *name):
- bres_byname(&me.r, name, _resfunc, <void *>me)
- me._activep = 1
- def __init__(me, name):
- pass
-
-cdef class ResolveByAddr (Resolve):
- def __new__(me, char *addr):
- cdef in_addr ia
- if not inet_aton(addr, &ia):
- raise TypeError, 'bad IP address'
- bres_byaddr(&me.r, ia, _resfunc, <void *>me)
- me._activep = 1
- def __init__(me, addr):
- pass
-
-cdef void _resfunc(hostent *h, void *arg):
- cdef Resolve r
- cdef int i
- r = <Resolve>arg
- r._activep = 0
- if h is NULL:
- r.failed(r)
- else:
- alias = []
- addr = []
- i = 0
- while h.h_aliases[i]:
- alias.append(h.h_aliases[i])
- i = i + 1
- i = 0
- while h.h_addr_list[i]:
- addr.append(inet_ntoa((<in_addr *>h.h_addr_list[i])[0]))
- i = i + 1
- r.resolved(h.h_name, alias, addr)
-
-#----- Signal handling ------------------------------------------------------
-
-cdef class Signal:
- cdef sig s
- cdef int _activep
- cdef readonly int signal
- def __new__(me, int sig):
- if sig < 0 or sig >= signal.NSIG:
- raise ValueError, 'signal number out of range'
- me.signal = sig
- me._activep = 0
- def __dealloc__(me):
- if me._activep:
- sig_remove(&me.s)
- def enable(me):
- if me._activep:
- raise ValueError, 'already enabled'
- sig_add(&me.s, me.signal, _sigfunc, <void *>me)
- me._activep = 1
- return me
- def disable(me):
- if not me._activep:
- raise ValueError, 'already disabled'
- sig_remove(&me.s)
- me._activep = 0
- return me
- def signalled(me):
- pass
-
-cdef void _sigfunc(int sig, void *arg):
- cdef Signal s
- s = <Signal>arg
- s.signalled()
-
-#----- Line buffers ---------------------------------------------------------
-
-CRLF = LBUF_CRLF
-STRICTCRLF = LBUF_STRICTCRLF
-
-cdef class LineBuffer:
- cdef selbuf b
- def __new__(me, fd):
- selbuf_init(&me.b, &sel, _getfd(fd), _lbfunc, <void *>me)
- selbuf_disable(&me.b)
- def __dealloc__(me):
- selbuf_destroy(&me.b)
- property activep:
- def __get__(me):
- return _tobool(me.b.b.f & LFBUF_ENABLE)
- property delim:
- def __get__(me):
- if me.b.b.delim == LBUF_CRLF or me.b.b.delim == LBUF_STRICTCRLF:
- return me.b.b.delim
- else:
- return chr(me.b.b.delim)
- def __set__(me, d):
- if d == LBUF_CRLF or d == LBUF_STRICTCRLF:
- me.b.b.delim = d
- else:
- me.b.b.delim = ord(d)
- property size:
- def __get__(me):
- return me.b.b.sz
- def __set__(me, sz):
- selbuf_setsize(&me.b, sz)
- def enable(me):
- if me.b.b.f & LBUF_ENABLE:
- raise ValueError, 'already enabled'
- selbuf_enable(&me.b)
- return me
- def disable(me):
- if not (me.b.b.f & LBUF_ENABLE):
- raise ValueError, 'already disabled'
- selbuf_disable(&me.b)
- return me
- def line(me, line):
- pass
- def eof(me):
- pass
-
-cdef void _lbfunc(char *s, size_t n, void *arg):
- cdef LineBuffer sb
- sb = <LineBuffer>arg
- if s is NULL:
- sb.eof()
- else:
- sb.line(PyString_FromStringAndSize(s, n))
-
-#----- Packet buffers -------------------------------------------------------
-
-cdef class PacketBuffer:
- cdef selpk p
- def __new__(me, fd):
- selpk_init(&me.p, &sel, _getfd(fd), _pkfunc, <void *>me)
- selpk_disable(&me.p)
- def __dealloc__(me):
- selpk_destroy(&me.p)
- property activep:
- def __get__(me):
- return _to_bool(me.p.pk.f & PKBUF_ENABLE)
- property want:
- def __get__(me):
- return me.p.pk.want
- def __set__(me, n):
- selpk_want(&me.p, n)
- def enable(me):
- if me.p.pk.f & PKBUF_ENABLE:
- raise ValueError, 'already enabled'
- selpk_enable(&me.p)
- return me
- def disable(me):
- if not (me.p.pk.f & PKBUF_ENABLE):
- raise ValueError, 'already disabled'
- selpk_disable(&me.p)
- return me
- def packet(me, pk):
- return None
- def eof(me):
- pass
-
-cdef void _pkfunc(unsigned char *p, size_t n, pkbuf *pk,
- size_t *keep, void *arg):
- cdef PacketBuffer pb
- cdef void *rp
- cdef int rn
- pb = <PacketBuffer>arg
- if p is NULL:
- pb.eof()
- else:
- r = pb.packet(PyString_FromStringAndSize(<char *>p, n))
- if r is not None:
- PyObject_AsReadBuffer(r, &rp, &rn)
- if rn > n:
- raise ValueError, 'remaining buffer too large'
- if rn:
- memcpy(p + n - rn, rp, rn)
- keep[0] = rn
-
-#----- Ident client ---------------------------------------------------------
-
-cdef _inaddr_frompy(sockaddr_in *sin, addr):
- cdef int port
- if len(addr) != 2:
- raise TypeError, 'want address/port pair'
- a = addr[0]
- if not inet_aton(a, &sin.sin_addr):
- raise TypeError, 'bad IP address'
- port = addr[1]
- if not (0 <= port < 65536):
- raise TypeError, 'port number out of range'
- sin.sin_port = htons(port)
-
-cdef _inaddr_topy(sockaddr_in *sin):
- return inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)
-
-cdef class Identify:
- cdef ident_request irq
- cdef int _activep
- cdef readonly localaddr
- cdef readonly remoteaddr
- def __new__(me, sk):
- cdef sockaddr_in s_in, s_out
- cdef size_t sz_in, sz_out
- cdef int fd
- if PyObject_TypeCheck(sk, socket.SocketType):
- fd = sk.fileno()
- sz_in = PSIZEOF(&s_in)
- sz_out = PSIZEOF(&s_out)
- if getsockname(fd, <sockaddr *>&s_in, &sz_in) or \
- getpeername(fd, <sockaddr *>&s_out, &sz_out):
- _oserror()
- if s_in.sin_family != AF_INET or s_out.sin_family != AF_INET:
- raise TypeError, 'must be internet socket'
- elif len(sk) != 2:
- raise TypeError, 'want pair of addresses'
- else:
- _inaddr_frompy(&s_in, sk[0])
- _inaddr_frompy(&s_out, sk[1])
- ident(&me.irq, &sel, &s_in, &s_out, _identfunc, <void *>me)
- me.localaddr = _inaddr_topy(&s_in)
- me.remoteaddr = _inaddr_topy(&s_out)
- me._activep = 1
- def __dealloc__(me):
- if me._activep:
- ident_abort(&me.irq)
- property activep:
- def __get__(me):
- return _tobool(me._activep)
- def kill(me):
- if not me._activep:
- raise ValueError, 'already disabled'
- ident_abort(&me.irq)
- me._activep = 0
- def user(me, os, user):
- pass
- def bad(me):
- pass
- def error(me, error):
- pass
- def failed(me, errno, strerror):
- pass
-
-cdef void _identfunc(ident_reply *i, void *arg):
- cdef Identify id
- id = <Identify>arg
- id._activep = 0
- if i.type == IDENT_BAD:
- ii.bad()
- elif i.type == IDENT_ERROR:
- ii.error(i.u.error)
- elif i.type == IDENT_USER:
- ii.user(i.u.userid.os, i.u.userid.user)
-
-#----- That's all, folks ----------------------------------------------------
~mdw / mLib-python / blobdiff