sippy 2.2.1__tar.gz → 2.2.2__tar.gz

sippy-2.2.2/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include requirements.txt
+include sippy/dictionary
+recursive-include sippy/UI/static *

{sippy-2.2.1/sippy.egg-info → sippy-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sippy
-Version: 2.2.1
+Version: 2.2.2
 Summary: RFC3261 SIP Stack and Back-to-Back User Agent (B2BUA)
 Home-page: http://www.b2bua.org/
 Author: Sippy Software, Inc.

{sippy-2.2.1 → sippy-2.2.2}/setup.py

@@ -8,13 +8,11 @@ with open("README.md", "r") as fh:
 
 setup(
     name = "sippy",
-    version = "2.2.1",
+    version = "2.2.2",
     packages = find_packages(),
 
     install_requires = requirements,
-    package_data = {
-        '': ['dictionary', '*.md']
-        },
+    include_package_data=True,
     test_suite = 'tests',
 
     entry_points = {

sippy-2.2.1/sippy/B2BRoute.py → sippy-2.2.2/sippy/B2B/Route.py

@@ -26,7 +26,7 @@
 
 from sippy.SipHeader import SipHeader
 from sippy.SipConf import SipConf
-from sippy.B2BTransforms import getTransProc
+from sippy.B2B.Transforms import getTransProc
 
 try:
     from urllib import unquote

sippy-2.2.2/sippy/B2B/SimpleAPI.py

@@ -0,0 +1,142 @@
+# Copyright (c) 2003-2005 Maxim Sobolev. All rights reserved.
+# Copyright (c) 2006-2025 Sippy Software, Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from ..CLIManager import CLIConnectionManager, CLIManager
+from ..Time.MonoTime import MonoTime
+from .States import CCStateConnected, CCStateARComplete
+
+class B2BSimpleAPI(CLIConnectionManager):
+    global_config = None
+
+    def __init__(self, global_config):
+        cmdfile = global_config['b2bua_socket']
+        self.global_config = global_config
+        if cmdfile.startswith('tcp:'):
+            parts = cmdfile[4:].split(':', 1)
+            if len(parts) == 1:
+                address = (parts[0], 12345)
+            else:
+                address = (parts[0], int(parts[1]))
+            super().__init__(self.recvCommand, address, tcp = True)
+        else:
+            if cmdfile.startswith('unix:'):
+                cmdfile = cmdfile[5:]
+            super().__init__(self.recvCommand, cmdfile)
+
+    def recvCommand(self, clim, cmd):
+        ccm = self.global_config['_cmap']
+        args = cmd.split()
+        cmd = args.pop(0).lower()
+        if cmd == 'q':
+            clim.close()
+            return False
+        if cmd == 'l':
+            res = 'In-memory calls:\n'
+            total = 0
+            for (cid, sname), uaast, uaost in ccm.listActiveCalls():
+                res += f'{cid}: {sname} ('
+                if uaast is not None:
+                    _s, _t, _h, _p, _cld, _cli = uaast
+                    res += f'{_s} {_t}:{_h}:{_p} {_cld} {_cli} -> '
+                else:
+                    res += 'N/A -> '
+                if uaost is not None:
+                    _s, _t, _h, _p, _cld, _cli = uaost
+                    res += f'{_s} {_t}:{_h}:{_p} {_cld} {_cli})\n'
+                else:
+                    res += 'N/A)\n'
+                total += 1
+            res += 'Total: %d\n' % total
+            clim.send(res)
+            return False
+        if cmd == 'lt':
+            res = 'In-memory server transactions:\n'
+            for tid, t in self.global_config['_sip_tm'].tserver.iteritems():
+                res += '%s %s %s\n' % (tid, t.method, t.state)
+            res += 'In-memory client transactions:\n'
+            for tid, t in self.global_config['_sip_tm'].tclient.iteritems():
+                res += '%s %s %s\n' % (tid, t.method, t.state)
+            clim.send(res)
+            return False
+        if cmd in ('lt', 'llt'):
+            if cmd == 'llt':
+                mindur = 60.0
+            else:
+                mindur = 0.0
+            ctime = MonoTime()
+            res = 'In-memory server transactions:\n'
+            for tid, t in self.global_config['_sip_tm'].tserver.iteritems():
+                duration = ctime - t.rtime
+                if duration < mindur:
+                    continue
+                res += '%s %s %s %s\n' % (tid, t.method, t.state, duration)
+            res += 'In-memory client transactions:\n'
+            for tid, t in self.global_config['_sip_tm'].tclient.iteritems():
+                duration = ctime - t.rtime
+                if duration < mindur:
+                    continue
+                res += '%s %s %s %s\n' % (tid, t.method, t.state, duration)
+            clim.send(res)
+            return False
+        if cmd == 'd':
+            if len(args) != 1:
+                clim.send('ERROR: syntax error: d <call-id>\n')
+                return False
+            if args[0] == '*':
+                self.discAll()
+                clim.send('OK\n')
+                return False
+            dlist = [x for x in ccm.ccmap if str(x.cId) == args[0]]
+            if len(dlist) == 0:
+                clim.send('ERROR: no call with id of %s has been found\n' % args[0])
+                return False
+            for cc in dlist:
+                cc.disconnect()
+            clim.send('OK\n')
+            return False
+        if cmd == 'r':
+            if len(args) != 1:
+                clim.send('ERROR: syntax error: r [<id>]\n')
+                return False
+            idx = int(args[0])
+            dlist = [x for x in ccm.ccmap if x.id == idx]
+            if len(dlist) == 0:
+                clim.send('ERROR: no call with id of %d has been found\n' % idx)
+                return False
+            for cc in dlist:
+                if not cc.proxied:
+                    continue
+                if cc.state == CCStateConnected:
+                    cc.disconnect(MonoTime().getOffsetCopy(-60), origin = 'media_timeout')
+                    continue
+                if cc.state == CCStateARComplete:
+                    cc.uaO.disconnect(MonoTime().getOffsetCopy(-60), origin = 'media_timeout')
+                    continue
+            clim.send('OK\n')
+            return False
+        clim.send('ERROR: unknown command\n')
+        return False
+
+    def set_rtp_io_socket(self, rtpp_nsock, rtpp_nsock_spec):
+        CLIManager(rtpp_nsock, self.recvCommand)

sippy-2.2.2/sippy/B2B/States.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2003-2005 Maxim Sobolev. All rights reserved.
+# Copyright (c) 2006-2025 Sippy Software, Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+class CCStateIdle(object):
+    sname = 'Idle'
+class CCStateWaitRoute(object):
+    sname = 'WaitRoute'
+class CCStateARComplete(object):
+    sname = 'ARComplete'
+class CCStateConnected(object):
+    sname = 'Connected'
+class CCStateDead(object):
+    sname = 'Dead'
+class CCStateDisconnecting(object):
+    sname = 'Disconnecting'

{sippy-2.2.1 → sippy-2.2.2}/sippy/CLIManager.py

@@ -125,7 +125,7 @@ class CLIConnectionManager(object):
                 conn.close()
                 return
         try:
-            cm = CLIManager(conn, self.command_cb, address)
+            cm = CLIManager(conn, self.command_cb)
         except Exception as e:
             dump_exception('CLIConnectionManager: unhandled exception when setting up incoming connection handler')
             conn.close()
@@ -174,6 +174,11 @@ class _CLIManager_w(Thread):
                 except BrokenPipeError:
                     self.clim = None
                     return
+                except socket.error as why:
+                    if why.errno != EBADF:
+                        raise
+                    self.clim = None
+                    return
                 if res == len(wbuffer):
                     break
                 if res > 0:
@@ -239,14 +244,12 @@ class CLIManager(object):
     clientsock = None
     command_cb = None
     close_pendind = False
-    raddr = None
     wthr = None
     rthr = None
 
-    def __init__(self, clientsock, command_cb, raddr):
+    def __init__(self, clientsock, command_cb):
         self.clientsock = clientsock
         self.command_cb = command_cb
-        self.raddr = raddr
         self.wthr = _CLIManager_w(clientsock, self)
         self.rthr = _CLIManager_r(clientsock, self)
 

{sippy-2.2.1 → sippy-2.2.2}/sippy/Core/EventDispatcher.py

@@ -29,12 +29,13 @@ from __future__ import print_function
 from functools import partial
 from datetime import datetime
 from heapq import heappush, heappop, heapify
-from threading import Lock
+from threading import Lock, local as t_local
 from random import random
 import sys, traceback, signal
 from _thread import get_ident
 from sippy.Time.MonoTime import MonoTime
 from sippy.Core.Exceptions import dump_exception, StdException
+from queue import Queue
 
 from elperiodic.ElPeriodic import ElPeriodic
 
@@ -123,6 +124,8 @@ class EventDispatcher2(Singleton):
     ed_inum = 0
     elp = None
     bands = None
+    _exception = None
+    tloc_data = None
 
     def __init__(self, freq = 100.0):
         EventDispatcher2.state_lock.acquire()
@@ -140,6 +143,7 @@ class EventDispatcher2(Singleton):
         self.elp = ElPeriodic(freq)
         self.elp.CFT_enable(signal.SIGURG)
         self.bands = [(freq, 0),]
+        self.tloc_data = t_local()
 
     def signal(self, signum, frame):
         self.signals_pending.append(signum)
@@ -233,16 +237,35 @@ class EventDispatcher2(Singleton):
     def dispatchThreadCallback(self, thread_cb, cb_params):
         try:
             thread_cb(*cb_params)
-        except Exception as ex:
-            if isinstance(ex, SystemExit):
-                raise
+        except BaseException as ex:
+            if isinstance(ex, (SystemExit, KeyboardInterrupt)):
+                self._exception = ex
+                return
             dump_exception('EventDispatcher2: unhandled exception when processing from-thread-call')
-        #print('dispatchThreadCallback dispatched', thread_cb, cb_params)
+
+    def dispatchThreadCallbackSync(self, res_cb_q, thread_cb, cb_params):
+        try:
+            res = thread_cb(*cb_params)
+        except BaseException as ex:
+            rval = (None, ex)
+        else:
+            rval = (res, None)
+        res_cb_q.put(rval)
 
     def callFromThread(self, thread_cb, *cb_params):
         self.elp.call_from_thread(self.dispatchThreadCallback, thread_cb, cb_params)
         #print('EventDispatcher2.callFromThread completed', str(self), thread_cb, cb_params)
 
+    def callFromThreadSync(self, thread_cb, *cb_params):
+        if not hasattr(self.tloc_data, 'res_cb_q'):
+            self.tloc_data.res_cb_q = Queue()
+        res_cb_q = self.tloc_data.res_cb_q
+        self.elp.call_from_thread(self.dispatchThreadCallbackSync, res_cb_q, thread_cb, cb_params)
+        res, ex = res_cb_q.get()
+        if ex is not None:
+            raise ex
+        return res
+
     def loop(self, timeout = None, freq = None):
         if freq != None and self.bands[0][0] != freq:
             for fb in self.bands:
@@ -274,6 +297,10 @@ class EventDispatcher2(Singleton):
                 break
             self.elp.procrastinate()
             self.last_ts = MonoTime()
+            if self._exception is not None:
+                ex = self._exception
+                self._exception = None
+                raise ex
         return self.el_rval
 
     def breakLoop(self, rval=0):

{sippy-2.2.1 → sippy-2.2.2}/sippy/MsgBody.py

@@ -47,6 +47,7 @@ class MsgBody(object):
         if content != None:
             self.mtype = mtype
             self.content = content
+            self.parsed = type(content) not in str_types
             return
         if cself is not None:
             if type(cself.content) in str_types:

{sippy-2.2.1 → sippy-2.2.2}/sippy/MultipartMixBody.py

@@ -23,14 +23,22 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+from secrets import token_hex
+
 from sippy.SipHeader import SipHeader
+from sippy.SipContentType import SipContentType
 
 class MultipartMixBody():
     parts = None
     boundary = None
+    mtype = SipContentType('multipart/mixed')
+    mtype.parse()
 
     def __init__(self, body = None, ctype = None):
+        self.parts = []
+        self.part_headers = []
         if body is None:
+            self.setBoundary(token_hex(16))
             return
         sep = f'--{ctype.params["boundary"]}'
         bparts = body.split(sep)
@@ -38,8 +46,6 @@ class MultipartMixBody():
         assert len(bparts[0]) == 0
         assert bparts[-1].strip() == '--'
         parts = [p.lstrip() for p in bparts[1:-1]]
-        self.parts = []
-        self.part_headers = []
         for sect in parts:
             headers = []
             ct = None
@@ -55,18 +61,24 @@ class MultipartMixBody():
             sect = MsgBody(sect, ct)
             self.parts.append(sect)
             self.part_headers.append(headers)
-        self.boundary = ctype.params["boundary"]
+        self.setBoundary(ctype.params["boundary"])
+
+    def setBoundary(self, bnd):
+        self.boundary = bnd
+        mtype = self.mtype.getCopy()
+        mtype.params["boundary"] = bnd
+        self.mtype = mtype
 
     def __str__(self):
         bnd = f'--{self.boundary}\r\n'
-        parts = [f'{bnd}Content-Type: {p.mtype}\r\n{p}' for p in self.parts]
+        parts = [f'{bnd}Content-Type: {p.mtype}\r\n\r\n{p}' for p in self.parts]
         s = ''.join(parts)
         s += f'{bnd[:-2]}--\r\n'
         return s
 
     def localStr(self, local_addr = None):
         bnd = f'--{self.boundary}\r\n'
-        parts = [f'{bnd}Content-Type: {p.mtype}\r\n{p.localStr(local_addr)}'
+        parts = [f'{bnd}Content-Type: {p.mtype}\r\n\r\n{p.localStr(local_addr)}'
                  for p in self.parts]
         s = ''.join(parts)
         s += f'{bnd[:-2]}--\r\n'
@@ -78,5 +90,8 @@ class MultipartMixBody():
         cself.boundary = self.boundary
         return cself
 
+    def getContentType(self):
+        return self.mtype.getCopy()
+
 if 'MsgBody' not in globals():
     from sippy.MsgBody import MsgBody

{sippy-2.2.1 → sippy-2.2.2}/sippy/MyConfigParser.py

@@ -33,7 +33,7 @@ except ImportError:
     from configparser import RawConfigParser
     _boolean_states = RawConfigParser.BOOLEAN_STATES
 from sippy.SipConf import SipConf
-from sippy.B2BTransforms import getTransProc
+from sippy.B2B.Transforms import getTransProc
 
 SUPPORTED_OPTIONS = { \
  'acct_enable':       ('B', 'enable or disable Radius accounting'), \

sippy-2.2.1/sippy/Rtp_proxy/Client/stream.py → sippy-2.2.2/sippy/Rtp_proxy/Client/Worker/external.py

@@ -1,5 +1,5 @@
 # Copyright (c) 2003-2005 Maxim Sobolev. All rights reserved.
-# Copyright (c) 2006-2014 Sippy Software, Inc. All rights reserved.
+# Copyright (c) 2006-2025 Sippy Software, Inc. All rights reserved.
 #
 # All rights reserved.
 #
@@ -24,24 +24,17 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-from queue import Queue
-
-from sippy.Time.Timeout import Timeout
 from threading import Thread
 from errno import EINTR, EPIPE, ENOTCONN, ECONNRESET
-from sippy.Time.MonoTime import MonoTime
-from sippy.Math.recfilter import recfilter
-from sippy.Rtp_proxy.Client.net import Rtp_proxy_client_net
-from sippy.Rtp_proxy.cmd import Rtp_proxy_cmd
-
 import socket
 
+from sippy.Time.MonoTime import MonoTime
 from sippy.Core.Exceptions import dump_exception
 from sippy.Core.EventDispatcher import ED2
 
 _MAX_RECURSE = 10
 
-class _RTPPLWorker(Thread):
+class RTPPLWorker_external(Thread):
     daemon = True
     userv = None
     s = None
@@ -84,7 +77,7 @@ class _RTPPLWorker(Thread):
                 rval = self.s.recv(1024)
                 if len(rval) == 0:
                     self.s = None
-                    return self.send_raw(command, _recurse, stime, why)
+                    return self.send_raw(command, _recurse, stime)
                 rval = rval.decode('ascii').strip()
                 break
             except socket.error as why:
@@ -113,7 +106,7 @@ class _RTPPLWorker(Thread):
                 if len(data) == 0:
                     data, rtpc_delay = None, None
             except Exception as e:
-                dump_exception('Rtp_proxy_client_stream: unhandled exception I/O RTPproxy')
+                dump_exception('RTPPLWorker_external: unhandled exception I/O RTPproxy')
                 data, rtpc_delay = None, None
             if result_callback != None:
                 ED2.callFromThread(self.dispatch, result_callback, data, callback_parameters)
@@ -125,89 +118,4 @@ class _RTPPLWorker(Thread):
         try:
             result_callback(data, *callback_parameters)
         except:
-            dump_exception('Rtp_proxy_client_stream: unhandled exception when processing RTPproxy reply')
-
-class Rtp_proxy_client_stream(Rtp_proxy_client_net):
-    is_local = None
-    wi = None
-    nworkers = None
-    nworkers_act = None
-    workers = None
-    delay_flt = None
-    family = None
-    sock_type = socket.SOCK_STREAM
-
-    def __init__(self, global_config, address = '/var/run/rtpproxy.sock', \
-      bind_address = None, nworkers = 1, family = socket.AF_UNIX):
-        #print('Rtp_proxy_client_stream.__init__', address, bind_address, nworkers, family)
-        if family == socket.AF_UNIX:
-            self.is_local = True
-            self.address = address
-        else:
-            self.is_local = False
-            self.address = self.getdestbyaddr(address, family)
-        self.family = family
-        self.wi = Queue()
-        self.nworkers = nworkers
-        self.workers = []
-        for i in range(0, self.nworkers):
-            try:
-                self.workers.append(_RTPPLWorker(self))
-            except:
-                break
-        self.nworkers_act = i + 1
-        self.delay_flt = recfilter(0.95, 0.25)
-
-    def send_command(self, command, result_callback = None, *callback_parameters):
-        if self.nworkers_act == 0:
-            self.rtpp_class._reconnect(self, self.address)
-        if isinstance(command, Rtp_proxy_cmd):
-            command = str(command)
-        elif not command.endswith('\n'):
-            command += '\n'
-        self.wi.put((command, result_callback, callback_parameters))
-
-    def reconnect(self, address, bind_address = None):
-        if not self.is_local:
-            address = self.getdestbyaddr(address, self.family)
-        self.rtpp_class._reconnect(self, address, bind_address)
-
-    def _reconnect(self, address, bind_address = None):
-        Rtp_proxy_client_stream.shutdown(self)
-        self.address = address
-        self.workers = []
-        for i in range(0, self.nworkers):
-            try:
-                self.workers.append(_RTPPLWorker(self))
-            except:
-                break
-        self.nworkers_act = i + 1
-        self.delay_flt = recfilter(0.95, 0.25)
-
-    def shutdown(self):
-        self.wi.put(None)
-        for rworker in self.workers:
-            rworker.join()
-        self.workers = None
-
-    def register_delay(self, rtpc_delay):
-        self.delay_flt.apply(rtpc_delay)
-
-    def get_rtpc_delay(self):
-        return self.delay_flt.lastval
-
-if __name__ == '__main__':
-    class robj(object):
-        rval = None
-    r = robj()
-    def display(res, ro, arg):
-        print(res, arg)
-        ro.rval = (res, arg)
-        ED2.breakLoop()
-    r = Rtp_proxy_client_stream({'_sip_address':'1.2.3.4'})
-    r.send_command('VF 123456', display, r, 'abcd')
-    ED2.loop()
-    r.shutdown()
-    print(r.rval)
-    assert(r.rval == (u'0', 'abcd'))
-    print('passed')
+            dump_exception('RTPPLWorker_external: unhandled exception when processing RTPproxy reply')

sippy-2.2.2/sippy/Rtp_proxy/Client/Worker/internal.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2003-2005 Maxim Sobolev. All rights reserved.
+# Copyright (c) 2006-2025 Sippy Software, Inc. All rights reserved.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from threading import Thread
+from errno import EINTR
+import socket
+
+from sippy.Time.MonoTime import MonoTime
+from sippy.Core.Exceptions import dump_exception
+from sippy.Core.EventDispatcher import ED2
+
+class RTPPLWorker_internal(Thread):
+    daemon = True
+    userv = None
+    s = None
+
+    def __init__(self, userv):
+        Thread.__init__(self)
+        self.userv = userv
+        self.s = userv.address
+        self.start()
+
+    def send_raw(self, command, stime = None):
+        #print('%s.send_raw(%s)' % (id(self), command))
+        if stime == None:
+            stime = MonoTime()
+        while True:
+            try:
+                self.s.send(command.encode())
+            except socket.error as why:
+                if why.errno == EINTR:
+                    continue
+                raise why
+            else: break
+        while True:
+            try:
+                rval = self.s.recv(1024)
+                if len(rval) == 0:
+                    raise socket.error('Connection closed')
+                rval = rval.decode('ascii').strip()
+            except socket.error as why:
+                if why.errno == EINTR:
+                    continue
+                raise why
+            else: break
+        rtpc_delay = stime.offsetFromNow()
+        return (rval, rtpc_delay)
+
+    def run(self):
+        #print(self.run, 'enter')
+        while True:
+            #print(self.run, 'spin')
+            wi = self.userv.wi.get()
+            if wi == None:
+                # Shutdown request, relay it further
+                self.userv.wi.put(None)
+            if wi == None:
+                break
+            command, result_callback, callback_parameters = wi
+            try:
+                data, rtpc_delay = self.send_raw(command)
+                if len(data) == 0:
+                    data, rtpc_delay = None, None
+            except Exception as e:
+                dump_exception('RTPPLWorker_internal: unhandled exception I/O RTPproxy')
+                data, rtpc_delay = None, None
+            if result_callback != None:
+                ED2.callFromThread(result_callback, data, *callback_parameters)
+            if rtpc_delay != None:
+                ED2.callFromThread(self.userv.register_delay, rtpc_delay)
+        self.userv = None
+        self.s = None