debian/: Use `dh_python2' for packaging.

[mLib-python] / ident.pyx

diff --git a/ident.pyx b/ident.pyx
index 1cc9e9e55f7bbf04253e96a776bb028f81519762..9a522bdfae29855ecf31135ff5ecbcec79dc8b35 100644 (file)
--- a/ident.pyx
+++ b/ident.pyx
@@ -41,6 +41,12 @@ cdef _inaddr_topy(sockaddr_in *sin):
   return inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)
 
 cdef class SelIdentify:
   return inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)
 
 cdef class SelIdentify:

+  """
+  SelIdentify(SK, [userproc = None], [bogusproc = None],
+                  [badproc = None], [errorproc = None],)
+
+  Asynchronously enquire about remote user of socket SK.
+  """

   cdef ident_request irq
   cdef int _activep
   cdef readonly localaddr
   cdef ident_request irq
   cdef int _activep
   cdef readonly localaddr


@@ -48,16 +54,13 @@ cdef class SelIdentify:
   cdef _user
   cdef _bad
   cdef _error
   cdef _user
   cdef _bad
   cdef _error

-  cdef _failed

   cdef _bogus
   cdef _bogus

-  def __cinit__(me, sk,
-              userproc = None, bogusproc = None,
-              badproc = None, errorproc = None, failedproc = None,
-              *hunoz, **hukairz):
+  def __cinit__(me, sk, userproc = None, bogusproc = None,
+                badproc = None, errorproc = None, *hunoz, **hukairz):

     cdef sockaddr_in s_in, s_out
     cdef sockaddr_in s_in, s_out

-    cdef size_t sz_in, sz_out
+    cdef socklen_t sz_in, sz_out

     cdef int fd
     cdef int fd

-    if PyObject_TypeCheck(sk, socket.SocketType):
+    if typecheck(sk, socket.SocketType):

       fd = sk.fileno()
       sz_in = PSIZEOF(&s_in)
       sz_out = PSIZEOF(&s_out)
       fd = sk.fileno()
       sz_in = PSIZEOF(&s_in)
       sz_out = PSIZEOF(&s_out)


@@ -78,29 +81,24 @@ cdef class SelIdentify:
     me._user = _checkcallable(userproc, 'user proc')
     me._bad = _checkcallable(badproc, 'bad proc')
     me._error = _checkcallable(errorproc, 'error proc')
     me._user = _checkcallable(userproc, 'user proc')
     me._bad = _checkcallable(badproc, 'bad proc')
     me._error = _checkcallable(errorproc, 'error proc')

-    me._failed = _checkcallable(failedproc, 'failed proc')

     me._bogus = _checkcallable(bogusproc, 'bogus proc')
   def __dealloc__(me):
     if me._activep:
       ident_abort(&me.irq)
   property activep:
     me._bogus = _checkcallable(bogusproc, 'bogus proc')
   def __dealloc__(me):
     if me._activep:
       ident_abort(&me.irq)
   property activep:

+    """I.activep -> BOOL: query still in progress?"""

     def __get__(me):
       return _tobool(me._activep)
   property userproc:
     def __get__(me):
       return _tobool(me._activep)
   property userproc:

+    """I.userproc -> FUNC: call FUNC(OS, USER) if server replied"""

     def __get__(me):
       return me._user
     def __set__(me, proc):
       me._user = _checkcallable(proc, 'user proc')
     def __del__(me):
       me._user = None
     def __get__(me):
       return me._user
     def __set__(me, proc):
       me._user = _checkcallable(proc, 'user proc')
     def __del__(me):
       me._user = None

-  property eofproc:
-    def __get__(me):
-      return me._eof
-    def __set__(me, proc):
-      me._eof = _checkcallable(proc, 'eof proc')
-    def __del__(me):
-      me._eof = None

   property badproc:
   property badproc:

+    """I.badproc -> FUNC: call FUNC() if server's reply was broken"""

     def __get__(me):
       return me._bad
     def __set__(me, proc):
     def __get__(me):
       return me._bad
     def __set__(me, proc):


@@ -108,20 +106,15 @@ cdef class SelIdentify:
     def __del__(me):
       me._bad = None
   property errorproc:
     def __del__(me):
       me._bad = None
   property errorproc:

+    """I.errorproc -> FUNC: call FUNC(ERR) if server reported error"""

     def __get__(me):
       return me._error
     def __set__(me, proc):
       me._error = _checkcallable(proc, 'error proc')
     def __del__(me):
       me._error = None
     def __get__(me):
       return me._error
     def __set__(me, proc):
       me._error = _checkcallable(proc, 'error proc')
     def __del__(me):
       me._error = None

-  property failedproc:
-    def __get__(me):
-      return me._failed
-    def __set__(me, proc):
-      me._failed = _checkcallable(proc, 'failed proc')
-    def __del__(me):
-      me._failed = None

   property bogusproc:
   property bogusproc:

+    """I.bogusproc -> FUNC: call FUNC() on failure if no specific handler"""

     def __get__(me):
       return me._bogus
     def __set__(me, proc):
     def __get__(me):
       return me._bogus
     def __set__(me, proc):


@@ -129,6 +122,7 @@ cdef class SelIdentify:
     def __del__(me):
       me._bogus = None
   def kill(me):
     def __del__(me):
       me._bogus = None
   def kill(me):

+    """I.kill(): cancel ident query"""

     if not me._activep:
       raise ValueError, 'already disabled'
     ident_abort(&me.irq)
     if not me._activep:
       raise ValueError, 'already disabled'
     ident_abort(&me.irq)


@@ -137,22 +131,23 @@ cdef class SelIdentify:
     me._activep = 0
     me.dead()
   def dead(me):
     me._activep = 0
     me.dead()
   def dead(me):

+    """I.dead(): called when operation completes or fails"""

     pass
   def user(me, os, user):
     pass
   def user(me, os, user):

+    """I.user(OS, USER): called if server returns user name"""

     return _maybecall(me._user, (os, user))
   def bad(me):
     return _maybecall(me._user, (os, user))
   def bad(me):

+    """I.bad(): called if server's reply is invalid"""

     if me._bad is not None:
       return me._bad()
     return me.bogus()
   def error(me, error):
     if me._bad is not None:
       return me._bad()
     return me.bogus()
   def error(me, error):

+    """I.error(ERR): called if server returns an error"""

     if me._error is not None:
       return me._error(error)
     return me.bogus()
     if me._error is not None:
       return me._error(error)
     return me.bogus()

-  def failed(me, errno, strerror):
-    if me._failed is not None:
-      return me._failed(errno, strerror)
-    return me.bogus()

   def bogus(me):
   def bogus(me):

+    """I.bogus(): called on failure if there's no more specific handler"""

     return _maybecall(me._bogus, ())
 
 cdef void _identfunc(ident_reply *i, void *arg):
     return _maybecall(me._bogus, ())
 
 cdef void _identfunc(ident_reply *i, void *arg):