chiark - git - mdw - mLib-python/blob - selpk.pyx

   1 ### -*-pyrex-*-
   2 ###
   3 ### Selecting packet-buffer
   4 ###
   5 ### (c) 2005 Straylight/Edgeware
   6 ###
   7
   8 ###----- Licensing notice ---------------------------------------------------
   9 ###
  10 ### This file is part of the Python interface to mLib.
  11 ###
  12 ### mLib/Python is free software; you can redistribute it and/or modify
  13 ### it under the terms of the GNU General Public License as published by
  14 ### the Free Software Foundation; either version 2 of the License, or
  15 ### (at your option) any later version.
  16 ###
  17 ### mLib/Python is distributed in the hope that it will be useful,
  18 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ### GNU General Public License for more details.
  21 ###
  22 ### You should have received a copy of the GNU General Public License
  23 ### along with mLib/Python; if not, write to the Free Software Foundation,
  24 ### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25
  26 cdef class SelPacketBuffer:
  27   """
  28   SelPacketBuffer(FILE, [packetproc = None], [eofproc = None])
  29
  30   Split an incoming stream into packets.
  31   """
  32   cdef selpk p
  33   cdef _packet
  34   cdef _eof
  35   def __cinit__(me, fd, packetproc = None, eofproc = None, *hunoz, **hukairz):
  36     selpk_init(&me.p, &_sel, _getfd(fd), _selpkfunc, <void *>me)
  37     selpk_disable(&me.p)
  38     me._packet = _checkcallable(packetproc, 'packet proc')
  39     me._eof = _checkcallable(eofproc, 'eof proc')
  40   def __dealloc__(me):
  41     selpk_destroy(&me.p)
  42   property activep:
  43     """SPK.activep -> BOOL: is the buffer still active?"""
  44     def __get__(me):
  45       return _to_bool(me.p.pk.f & PKBUF_ENABLE)
  46   property fd:
  47     """SPK.fd -> INT: the file descriptor"""
  48     def __get__(me):
  49       return me.p.reader.fd
  50   property want:
  51     """SPK.want -> INT: size of next packet to return"""
  52     def __get__(me):
  53       return me.p.pk.want
  54     def __set__(me, n):
  55       if n <= 0:
  56         raise TypeError, 'size must be positive'
  57       selpk_want(&me.p, n)
  58   property packetproc:
  59     """SPK.packetproc -> FUNC: call FUNC(PACKET) on each packet"""
  60     def __get__(me):
  61       return me._packet
  62     def __set__(me, proc):
  63       me._packet = _checkcallable(proc, 'packet proc')
  64     def __del__(me):
  65       me._packet = None
  66   property eofproc:
  67     """SPK.eofproc -> FUNC: call FUNC() at end-of-file"""
  68     def __get__(me):
  69       return me._eof
  70     def __set__(me, proc):
  71       me._eof = _checkcallable(proc, 'eof proc')
  72     def __del__(me):
  73       me._eof = None
  74   def enable(me):
  75     """SPK.enable(): enable the buffer, allowing packets to be emitted"""
  76     if me.p.pk.f & PKBUF_ENABLE:
  77       raise ValueError, 'already enabled'
  78     selpk_enable(&me.p)
  79     me.enabled()
  80     return me
  81   def disable(me):
  82     """SPK.disable(): disable the buffer, suspending packet emission"""
  83     if not (me.p.pk.f & PKBUF_ENABLE):
  84       raise ValueError, 'already disabled'
  85     selpk_disable(&me.p)
  86     me.disabled()
  87     return me
  88   def enabled(me):
  89     """SPK.enabled(): called when buffer is enabled"""
  90     pass
  91   def disabled(me):
  92     """SPK.disabled(): called when buffer is disabled"""
  93     pass
  94   def packet(me, pk):
  95     """SPK.packet(PACKET): called for each completed packet"""
  96     return _maybecall(me._packet, (pk,))
  97   def eof(me):
  98     """SPK.eof(): called at end-of-file"""
  99     return _maybecall(me._eof, ())
 100
 101 cdef void _selpkfunc(unsigned char *p, size_t n, pkbuf *pk,
 102                      size_t *keep, void *arg):
 103   cdef SelPacketBuffer pb
 104   cdef void *rp
 105   cdef Py_ssize_t rn
 106   pb = <SelPacketBuffer>arg
 107   if p is NULL:
 108     pb.eof()
 109   else:
 110     r = pb.packet(PyString_FromStringAndSize(<char *>p, n))
 111     if r is not None:
 112       PyObject_AsReadBuffer(r, <cvp *>&rp, &rn)
 113       if rn > n:
 114         raise ValueError, 'remaining buffer too large'
 115       if rn:
 116         memcpy(p + n - rn, rp, rn)
 117         keep[0] = rn
 118
 119 ###----- That's all, folks --------------------------------------------------