def dispatch(self, result_callback, data, callback_parameters):
try:
result_callback(data, *callback_parameters)
except:
dump_exception(
'Rtp_proxy_client_stream: unhandled exception when processing RTPproxy reply'
)
def run(self):
#print(self.run, 'enter')
while True:
#print(self.run, 'cycle')
pollret = dict(self.pollobj.poll()).get(self.fileno, 0)
if pollret & POLLNVAL != 0:
break
if pollret & POLLIN == 0:
continue
try:
clientsock, addr = self.clicm.serversock.accept()
except Exception as why:
if isinstance(why, socket.error):
if why.errno == ECONNABORTED:
continue
elif why.errno == EBADF:
break
else:
raise
dump_exception(
'CLIConnectionManager: unhandled exception when accepting incoming connection'
)
break
#print(self.run, 'handle_accept')
ED2.callFromThread(self.clicm.handle_accept, clientsock, addr)
self.clicm = None
def dispatchThreadCallback(self, thread_cb, cb_params):
try:
thread_cb(*cb_params)
except Exception as ex:
if isinstance(ex, SystemExit):
raise
dump_exception('EventDispatcher2: unhandled exception when processing from-thread-call')
def signal_handler(self, signum, *frame):
ED2.callFromThread(self.dispatch)
if self.previous_handler not in (SIG_IGN, SIG_DFL):
try:
self.previous_handler(signum, *frame)
except:
dump_exception('Signal: unhandled exception in signal chain')
def process_result(self, result_callback, result, *callback_parameters):
try:
result_callback(result, *callback_parameters)
except Exception as ex:
if isinstance(ex, SystemExit):
raise
dump_exception('External_command: unhandled exception in external command results callback')
def _on_sdp_change(self, rtpps, sdp_body, result_callback, en_excpt):
sects = []
try:
sdp_body.parse()
except Exception as exception:
dump_exception('can\'t parse SDP body', extra = sdp_body.content)
if en_excpt:
raise exception
else:
return
for i in range(0, len(sdp_body.content.sections)):
sect = sdp_body.content.sections[i]
if sect.m_header.transport.lower() not in ('udp', 'udptl', 'rtp/avp', \
'rtp/savp', 'udp/bfcp'):
continue
sects.append(sect)
if len(sects) == 0:
sdp_body.needs_update = False
result_callback(sdp_body)
return
formats = sects[0].m_header.formats
self.codecs = ','.join([ str(x) for x in formats ])
if self.repacketize != None:
options = 'z%d' % self.repacketize
else:
options = ''
for sect in sects:
if sect.c_header.atype == 'IP6':
sect_options = '6' + options
else:
sect_options = options
self.update(rtpps, sect.c_header.addr, sect.m_header.port, self._sdp_change_finish, sect_options, \
sects.index(sect), sect.c_header.atype, sdp_body, sect, sects, result_callback)
return
def run(self):
#print(self.run, 'enter')
while True:
#print(self.run, 'spin')
self.userv.wi_available.acquire()
while len(self.userv.wi) == 0:
self.userv.wi_available.wait()
wi = self.userv.wi.pop(0)
if wi == None:
# Shutdown request, relay it further
self.userv.wi.append(None)
self.userv.wi_available.notify()
self.userv.wi_available.release()
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('Rtp_proxy_client_stream: unhandled exception I/O RTPproxy')
data, rtpc_delay = None, None
if result_callback != None:
ED2.callFromThread(self.dispatch, result_callback, data, callback_parameters)
if rtpc_delay != None:
ED2.callFromThread(self.userv.register_delay, rtpc_delay)
self.userv = None
def run(self):
#print(self.run, 'enter')
while True:
#print(self.run, 'spin')
self.userv.wi_available.acquire()
while len(self.userv.wi) == 0:
self.userv.wi_available.wait()
wi = self.userv.wi.pop(0)
if wi == None:
# Shutdown request, relay it further
self.userv.wi.append(None)
self.userv.wi_available.notify()
self.userv.wi_available.release()
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(
'Rtp_proxy_client_stream: unhandled exception I/O RTPproxy'
)
data, rtpc_delay = None, None
if result_callback != None:
ED2.callFromThread(self.dispatch, result_callback, data,
callback_parameters)
if rtpc_delay != None:
ED2.callFromThread(self.userv.register_delay, rtpc_delay)
self.userv = None
def _on_sdp_change(self, rtpps, sdp_body, result_callback, en_excpt):
sects = []
try:
sdp_body.parse()
except Exception as exception:
dump_exception('can\'t parse SDP body', extra=sdp_body.content)
if en_excpt:
raise exception
else:
return
for i in range(0, len(sdp_body.content.sections)):
sect = sdp_body.content.sections[i]
if sect.m_header.transport.lower() not in ('udp', 'udptl', 'rtp/avp', \
'rtp/savp', 'udp/bfcp'):
continue
sects.append(sect)
if len(sects) == 0:
sdp_body.needs_update = False
result_callback(sdp_body)
return
formats = sects[0].m_header.formats
self.codecs = ','.join([str(x) for x in formats])
if self.repacketize != None:
options = 'z%d' % self.repacketize
else:
options = ''
for sect in sects:
if sect.c_header.atype == 'IP6':
sect_options = '6' + options
else:
sect_options = options
self.update(rtpps, sect.c_header.addr, sect.m_header.port, self._sdp_change_finish, sect_options, \
sects.index(sect), sect.c_header.atype, sdp_body, sect, sects, result_callback)
return
def handle_cmd(self, cmd):
try:
self.command_cb(self, cmd)
except:
dump_exception(
'CLIManager: unhandled exception when processing incoming data'
)
self.close()
def process_result(self, result_callback, result, *callback_parameters):
try:
result_callback(result, *callback_parameters)
except Exception as ex:
if isinstance(ex, SystemExit):
raise
dump_exception(
'External_command: unhandled exception in external command results callback'
)
def handle_accept(self, conn, address):
#print(self.handle_accept)
if self.tcp and self.accept_list != None and address[0] not in self.accept_list:
conn.close()
return
try:
cm = CLIManager(conn, self.command_cb, address)
except Exception as e:
dump_exception('CLIConnectionManager: unhandled exception when setting up incoming connection handler')
conn.close()
return
def shutdown(self):
if self.wthr == None:
return
self.wthr.shutdown()
try:
self.clientsock.shutdown(socket.SHUT_RDWR)
except Exception as e:
if not isinstance(e, socket.error) or e.errno != ENOTCONN:
dump_exception('self.clientsock.shutdown(socket.SHUT_RDWR)')
self.clientsock.close()
self.wthr = None
self.rthr = None
def shutdown(self):
if self.wthr == None:
return
self.wthr.shutdown()
try:
self.clientsock.shutdown(socket.SHUT_RDWR)
except Exception as e:
if not isinstance(e, socket.error) or e.errno != ENOTCONN:
dump_exception('self.clientsock.shutdown(socket.SHUT_RDWR)')
self.clientsock.close()
self.wthr = None
self.rthr = None
def handle_accept(self, conn, address):
#print(self.handle_accept)
if self.tcp and self.accept_list != None and address[
0] not in self.accept_list:
conn.close()
return
try:
cm = CLIManager(conn, self.command_cb, address)
except Exception as e:
dump_exception(
'CLIConnectionManager: unhandled exception when setting up incoming connection handler'
)
conn.close()
return
def dispatchSignals(self):
while len(self.signals_pending) > 0:
signum = self.signals_pending.pop(0)
for sl in [x for x in self.slisteners if x.signum == signum]:
if sl not in self.slisteners:
continue
try:
sl.cb_func(*sl.cb_params, **sl.cb_kw_args)
except Exception as ex:
if isinstance(ex, SystemExit):
raise
dump_exception('EventDispatcher2: unhandled exception when processing signal event')
if self.endloop:
return
def dispatchThreadCallbacks(self):
self.tcbs_lock.acquire()
#print('dispatchThreadCallbacks called', str(self), self.thread_cbs)
if len(self.thread_cbs) == 0:
self.tcbs_lock.release()
return
thread_cbs = self.thread_cbs
self.thread_cbs = []
self.tcbs_lock.release()
for thread_cb, cb_params in thread_cbs:
try:
thread_cb(*cb_params)
except Exception as ex:
if isinstance(ex, SystemExit):
raise
dump_exception('EventDispatcher2: unhandled exception when processing from-thread-call')
#print('dispatchThreadCallbacks dispatched', thread_cb, cb_params)
if self.endloop:
return
def dispatchTimers(self):
while len(self.tlisteners) != 0:
el = self.tlisteners[0]
if el.cb_func != None and el.etime > self.last_ts:
# We've finished
return
el = heappop(self.tlisteners)
if el.cb_func == None:
# Skip any already removed timers
self.twasted -= 1
continue
if el.nticks == -1 or el.nticks > 1:
# Re-schedule periodic timer
if el.nticks > 1:
el.nticks -= 1
if el.randomize_runs != None:
ival = el.randomize_runs(el.ival)
else:
ival = el.ival
el.etime.offset(ival)
heappush(self.tlisteners, el)
cleanup = False
else:
cleanup = True
try:
if not el.cb_with_ts:
el.cb_func(*el.cb_params)
else:
el.cb_func(self.last_ts, *el.cb_params)
except Exception as ex:
if isinstance(ex, SystemExit):
raise
dump_exception(
'EventDispatcher2: unhandled exception when processing timeout event'
)
if self.endloop:
return
if cleanup:
el.cleanup()
def run(self):
#print(self.run, 'enter')
while True:
#print(self.run, 'cycle')
pollret = dict(self.pollobj.poll()).get(self.fileno, 0)
if pollret & POLLNVAL != 0:
break
if pollret & POLLIN == 0:
continue
try:
clientsock, addr = self.clicm.serversock.accept()
except Exception as why:
if isinstance(why, socket.error):
if why.errno == ECONNABORTED:
continue
elif why.errno == EBADF:
break
else:
raise
dump_exception('CLIConnectionManager: unhandled exception when accepting incoming connection')
break
#print(self.run, 'handle_accept')
ED2.callFromThread(self.clicm.handle_accept, clientsock, addr)
self.clicm = None
def handleIncoming(self, data_in, address, server, rtime):
if len(data_in) < 32:
return
data = data_in.decode()
self.global_config['_sip_logger'].write('RECEIVED message from %s:%d:\n' % address, data, ltime = rtime.realt)
checksum = md5(data_in).digest()
retrans = self.l1rcache.get(checksum, None)
if retrans == None:
retrans = self.l2rcache.get(checksum, None)
if retrans != None:
if retrans.data == None:
return
self.transmitData(retrans.userv, retrans.data, retrans.address, \
lossemul = retrans.lossemul)
return
if data.startswith('SIP/2.0 '):
try:
resp = SipResponse(data)
tid = resp.getTId(True, True)
except Exception as exception:
dump_exception('can\'t parse SIP response from %s:%d' % (address[0], address[1]), extra = data)
self.l1rcache[checksum] = SipTMRetransmitO()
return
if resp.getSCode()[0] < 100 or resp.getSCode()[0] > 999:
print(datetime.now(), 'invalid status code in SIP response from %s:%d:' % address)
print(data)
sys.stdout.flush()
self.l1rcache[checksum] = SipTMRetransmitO()
return
resp.rtime = rtime
if not tid in self.tclient:
#print 'no transaction with tid of %s in progress' % str(tid)
self.l1rcache[checksum] = SipTMRetransmitO()
return
t = self.tclient[tid]
if self.nat_traversal and resp.countHFs('contact') > 0 and not check1918(t.address[0]):
cbody = resp.getHFBody('contact')
if not cbody.asterisk:
curl = cbody.getUrl()
if check1918(curl.host):
curl.host, curl.port = address
resp.setSource(address)
self.incomingResponse(resp, t, checksum)
else:
try:
req = SipRequest(data)
tids = req.getTIds()
except Exception as exception:
if isinstance(exception, ESipParseException) and exception.sip_response != None:
self.transmitMsg(server, exception.sip_response, address, checksum)
dump_exception('can\'t parse SIP request from %s:%d' % (address[0], address[1]), extra = data)
self.l1rcache[checksum] = SipTMRetransmitO()
return
req.rtime = rtime
via0 = req.getHFBody('via')
ahost, aport = via0.getAddr()
rhost, rport = address
if self.nat_traversal and rport != aport and check1918(ahost):
req.nated = True
if ahost != rhost:
via0.params['received'] = rhost
if 'rport' in via0.params or req.nated:
via0.params['rport'] = str(rport)
if self.nat_traversal and req.countHFs('contact') > 0 and req.countHFs('via') == 1:
try:
cbody = req.getHFBody('contact')
except Exception as exception:
dump_exception('can\'t parse SIP request from %s:%d: %s:' % (address[0], address[1]), extra = data)
self.l1rcache[checksum] = SipTMRetransmitO()
return
if not cbody.asterisk:
curl = cbody.getUrl()
if check1918(curl.host) or curl.port == 0 or curl.host == '255.255.255.255':
curl.host, curl.port = address
req.nated = True
req.setSource(address)
self.incomingRequest(req, checksum, tids, server)
def dispatch(self):
try:
self.callback(*self.parameters)
except:
dump_exception('Signal: unhandled exception in signal callback')
def handleIncoming(self, data_in, address, server, rtime):
if len(data_in) < 32:
return
data = data_in.decode()
self.global_config['_sip_logger'].write(
'RECEIVED message from %s:%d:\n' % address,
data,
ltime=rtime.realt)
checksum = md5(data_in).digest()
retrans = self.l1rcache.get(checksum, None)
if retrans == None:
retrans = self.l2rcache.get(checksum, None)
if retrans != None:
if retrans.data == None:
return
self.transmitData(retrans.userv, retrans.data, retrans.address, \
lossemul = retrans.lossemul)
return
if data.startswith('SIP/2.0 '):
try:
resp = SipResponse(data)
tid = resp.getTId(True, True)
except Exception as exception:
dump_exception('can\'t parse SIP response from %s:%d' %
(address[0], address[1]),
extra=data)
self.l1rcache[checksum] = SipTMRetransmitO()
return
if resp.getSCode()[0] < 100 or resp.getSCode()[0] > 999:
print(
datetime.now(),
'invalid status code in SIP response from %s:%d:' %
address)
print(data)
sys.stdout.flush()
self.l1rcache[checksum] = SipTMRetransmitO()
return
resp.rtime = rtime
if not tid in self.tclient:
#print 'no transaction with tid of %s in progress' % str(tid)
self.l1rcache[checksum] = SipTMRetransmitO()
return
t = self.tclient[tid]
if self.nat_traversal and resp.countHFs(
'contact') > 0 and not check1918(t.address[0]):
cbody = resp.getHFBody('contact')
if not cbody.asterisk:
curl = cbody.getUrl()
if check1918(curl.host):
curl.host, curl.port = address
resp.setSource(address)
self.incomingResponse(resp, t, checksum)
else:
try:
req = SipRequest(data)
tids = req.getTIds()
except Exception as exception:
if isinstance(
exception,
ESipParseException) and exception.sip_response != None:
self.transmitMsg(server, exception.sip_response, address,
checksum)
dump_exception('can\'t parse SIP request from %s:%d' %
(address[0], address[1]),
extra=data)
self.l1rcache[checksum] = SipTMRetransmitO()
return
req.rtime = rtime
via0 = req.getHFBody('via')
ahost, aport = via0.getAddr()
rhost, rport = address
if self.nat_traversal and rport != aport and check1918(ahost):
req.nated = True
if ahost != rhost:
via0.params['received'] = rhost
if 'rport' in via0.params or req.nated:
via0.params['rport'] = str(rport)
if self.nat_traversal and req.countHFs(
'contact') > 0 and req.countHFs('via') == 1:
try:
cbody = req.getHFBody('contact')
except Exception as exception:
dump_exception('can\'t parse SIP request from %s:%d: %s:' %
(address[0], address[1]),
extra=data)
self.l1rcache[checksum] = SipTMRetransmitO()
return
if not cbody.asterisk:
curl = cbody.getUrl()
if check1918(
curl.host
) or curl.port == 0 or curl.host == '255.255.255.255':
curl.host, curl.port = address
req.nated = True
req.setSource(address)
self.incomingRequest(req, checksum, tids, server)
def handle_cmd(self, cmd):
try:
self.command_cb(self, cmd)
except:
dump_exception('CLIManager: unhandled exception when processing incoming data')
self.close()
def dispatch(self, result_callback, data, callback_parameters):
try:
result_callback(data, *callback_parameters)
except:
dump_exception('Rtp_proxy_client_stream: unhandled exception when processing RTPproxy reply')
