def reg_user(self, user):
""" Registers a L{User} instance in this batch to the SIP server.
At the beginning of the simulation, users stay unregistered for some amount of time
and this function is called when the register event is triggered.
Along with registration, a C{PJSUA.Account} instance is attached to the user and a
L{UserAccountCallback} instance is set to the C{Account}.
@type user: User
@param user: the user instance to be registered
"""
try:
uname = user.id + self.BASE_ID
trans = self.lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(uname))
conf = pj.AccountConfig(self.SIP_SERVER_IP, str(uname),
self.PASSWORD)
conf.reg_timeout = user.registration_period
conf.ka_interval = 0
conf.transport_id = trans._id
acc = self.lib.create_account(conf)
user.account = acc
acc_cb = UserAccountCallback(user)
acc.set_callback(acc_cb)
except Exception, e:
print "Exception while registering user:", str(e)
def _bind(self):
# bind self.transport to self.lib
SIP_LOCAL_PORT = 5060
try:
self.transport = self.lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(SIP_LOCAL_PORT))
except pj.Error:
debug("Error binding transport")
debug(pj.Error)
def create_TransportConfig():
logger.debug("create_TransportConfig")
# Doc: http://www.pjsip.org/python/pjsua.htm#TransportConfig
TransportConfig = pj.TransportConfig(
port=conf.get_int(SIPPHONE_SECTION, 'transport.port', 0),
bound_addr=conf.get(SIPPHONE_SECTION, 'transport.bound_addr', ''),
public_addr=conf.get(SIPPHONE_SECTION, 'transport.public_addr', ''))
return TransportConfig
def run(self, domain, user, password):
try:
mediaconfig = pj.MediaConfig()
mediaconfig.quality = 10
self.lib.init(log_cfg=pj.LogConfig(level=4, callback=self.log_cb),
media_cfg=mediaconfig)
transport = self.lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig())
self.lib.start()
# Put your sIP client credentials here
acc = self.lib.create_account(
pj.AccountConfig(domain=domain,
username=user,
password=password))
acc_cb = MyAccountCallback(app=self, account=acc)
acc.set_callback(acc_cb)
acc_cb.wait()
print "\n"
print "Registration complete, status=", acc.info().reg_status, \
"(" + acc.info().reg_reason + ")"
if len(sys.argv) > 1:
lck = self.lib.auto_lock()
my_sip_uri = "sip:" + transport.info().host + \
":" + str(transport.info().port)
# Menu loop
while True:
print "My SIP URI is", my_sip_uri
print "Menu: h=hangup call, q=quit"
input = sys.stdin.readline().rstrip("\r\n")
if input == "h":
if not self.current_call:
print "There is no call"
continue
self.current_call.hangup()
self.reset_all()
elif input == "q":
break
# shutdown the library
transport = None
self.lib.destroy()
self.lib = None
except pj.Error, e:
print "Exception: " + str(e)
self.lib.destroy()
lib = None
def _init_lib(self) -> None:
self.lib = pjsua.Lib()
self.lib.init(log_cfg=pjsua.LogConfig(level=logging.DEBUG))
pjsua_port = random.randint(5080, 6080)
self.transports = dict(
t1=self.lib.create_transport(pjsua.TransportType.UDP, pjsua.TransportConfig(pjsua_port))
)
self.lib.start()
self.lib.handle_events()
def register(self,
server,
port,
username,
password,
default_account=False,
proxy=None,
protocol='UDP',
bind_address='127.0.0.1',
bind_port=0):
""" Register an account at i.e. Asterisk PBX, and set network transport options.
Returns: Account registered, account callback handler.
"""
if protocol == 'UDP': protocol = pj.TransportType.UDP
elif protocol == 'TCP': protocol = pj.TransportType.TCP
elif protocol == 'TLS': protocol = pj.TransportType.TLS
else: logger.info(f"Error: Invalid protocol type.")
logger.info("Creating transport and generating SIP URI.")
transport = self.lib.create_transport(
protocol,
pj.TransportConfig(
0
) # TransportConfig(host=bind_address, port=bind_port) # TODO: Add bind_address and bind_port here.
)
public_sip_uri = f"sip:{username}@{str(transport.info().host)}:{str(transport.info().port)}"
logger.info(
f"Listening on {transport.info().host}:{transport.info().port} for {public_sip_uri}."
)
logger.info(
f"Attempting registration for {public_sip_uri} at {server}:{port}."
)
account_cfg = pj.AccountConfig(domain=server + ":" + port,
username=username,
password=password)
account_cfg.id = public_sip_uri
account = self.lib.create_account(acc_config=account_cfg,
set_default=default_account)
account.set_transport(transport)
account_handler = AccountHandler(lib=self.lib, account=account)
account.set_callback(account_handler)
logger.info(f"Waiting for registration...")
account_handler.wait()
logger.info(
f"Successfully registered {public_sip_uri}, status: {account.info().reg_status} ({account.info().reg_reason})."
)
return account
def sip_registration(lib, conf_params):
global acc, common_objects
lib.init(log_cfg=pj.LogConfig(level=1, callback=log_cb))
transport = lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(0))
lib.start()
acc = lib.create_account(
pj.AccountConfig(conf_params['elx_host'], conf_params['sip_user'],
conf_params['sip_pass']))
acc_cb = MyAccountCallback(acc)
acc.set_callback(acc_cb)
acc_cb.wait()
def register_all(self):
trans = {}
accs = []
for user in self.users:
uname = user.id + self.BASE_ID
trans[user.id] = self.lib.create_transport(
pj.TransportType.UDP, pj.TransportConfig(uname))
uname = user.id + self.BASE_ID
conf = pj.AccountConfig(self.SIP_SERVER_IP, str(uname),
self.PASSWORD)
conf.reg_timeout = 1000000
conf.ka_interval = 0
conf.transport_id = trans[user.id]._id
accs.append(self.lib.create_account(conf))
return trans, accs
def start(self):
ua = pj.UAConfig()
ua.nameserver = ['8.8.8.8', '8.8.4.4']
ua.user_agent = "PJSIP Python EasyPhone"
media = pj.MediaConfig()
media.enable_ice = True
logger = pj.LogConfig(level=self.verbose, callback=logger_callback)
self.pjsip.init(ua_cfg=ua, media_cfg=media, log_cfg=logger)
self.pjsip.create_transport(pj.TransportType.TCP, pj.TransportConfig())
self.pjsip.set_null_snd_dev()
self.pjsip.start()
self.pjsip.handle_events()
def __init__(self):
#self.__account_cb=self.MyAccountCallback()
#self.__call_cb=self.MyCallCallback
self.__lib = pj.Lib()
self.__lib.init(log_cfg=pj.LogConfig(3, callback=self.__log_cb))
self.__transport = self.__lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(0))
print "\nListening on", self.__transport.info().host,
print "port", self.__transport.info().port, "\n"
self.__lib.start(True)
self.__acc = self.__lib.create_account_for_transport(
self.__transport, cb=self.MyAccountCallback(self))
self.__self_uri = "sip:" + self.__transport.info().host + ":" + str(
self.__transport.info().port)
def __create_transport(self, cfg):
"""Create a PJSUA transport from a transport configuration."""
def __to_pjprotocol(prot_str, is_v6):
"""
Translate a string protocol to an enumerated type for PJSUA.
PJSUA's enumerations require both the transport protocol to be used
and whether IPv6 is being used.
"""
if prot_str == 'udp':
if is_v6:
return pj.TransportType.UDP_IPV6
else:
return pj.TransportType.UDP
elif prot_str == 'tcp':
if is_v6:
return pj.TransportType.TCP_IPV6
else:
return pj.TransportType.TCP
elif prot_str == 'tls':
if is_v6:
LOGGER.error("PJSUA python bindings do not support IPv6"
"with TLS")
self.test_object.stop_reactor()
else:
return pj.TransportType.TLS
else:
return pj.TransportType.UNSPECIFIED
protocol = (cfg.get('protocol', 'udp')).lower()
bind = cfg.get('bind', '127.0.0.1')
bindport = cfg.get('bindport', '5060')
public_addr = cfg.get('public_addr', '')
is_v6 = False
try:
socket.inet_pton(socket.AF_INET6, bind)
is_v6 = True
except socket.error:
# Catching an exception just means the address is not IPv6
pass
pj_protocol = __to_pjprotocol(protocol, is_v6)
LOGGER.info("Creating transport config %s:%s" % (bind, bindport))
transport_cfg = pj.TransportConfig(int(bindport), bind, public_addr)
return self.lib.create_transport(pj_protocol, transport_cfg)
def __init__(self,lib=None):
if lib:
self.lib=lib
elif pj.Lib.instance():
self.lib=pj.Lib.instance()
else:
self.lib = pj.Lib()
ua=pj.UAConfig()
ua.max_calls=40
self.lib.init(log_cfg = pj.LogConfig(level=2,callback=log_cb),ua_cfg=ua)
self._transport=self.lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(0))
self.lib.start()
devs=self.lib.enum_snd_dev()
if not len(devs):
self.lib.set_null_snd_dev()
self.player=Player()
self.created={}
def init(self):
self.status = States.init
self.lib = pj.Lib()
self.cfg_ua = pj.UAConfig()
self.cfg_md = pj.MediaConfig()
self.cfg_ua.max_calls, self.cfg_ua.user_agent = 32, "TrashTalker/1.0"
self.cfg_md.no_vad, self.cfg_md.enable_ice = True, False
self.cfg_lg = pj.LogConfig(level=self.LOG_LEVEL, callback=PJLog)
self.lib.init(ua_cfg=cfg_ua, media_cfg=cfg_md, log_cfg=cfg_lg)
self.lib.set_null_snd_dev()
self.lib.start(with_thread=True)
self.transport = self.lib.create_transport(
pj.TransportType.UDP, pj.TransportConfig(self.port))
self.account = self.lib.create_account_for_transport(self.transport,
cb=AccountCb())
self.uri = "sip:%s:%s" % (self.transport.info().host,
self.transport.info().port)
self.status &= States.done
def reg_attack(self):
trans = {}
for user in self.users:
uname = user.id + self.BASE_ID
trans[user.id] = self.lib.create_transport(
pj.TransportType.UDP, pj.TransportConfig(uname))
while True:
for user in self.users:
try:
uname = user.id + self.BASE_ID
conf = pj.AccountConfig(self.SIP_SERVER_IP, str(uname),
self.PASSWORD)
conf.transport_id = trans[user.id]._id
acc = self.lib.create_account(conf)
acc.delete()
except Exception, e:
print "Exception while registering user:", str(e)
time.sleep(3)
def setUp(self):
self.assertTrue(self.AH_Agent.isConnected(),
"AH_Agent connection failure")
if self.lib == None:
self.lib = pjsua.Lib()
self.lib.init(log_cfg=pjsua.LogConfig(
level=0, filename='PJSUA.log', callback=None, console_level=0))
self.lib.set_null_snd_dev()
self.lib.create_transport(pjsua.TransportType.UDP,
pjsua.TransportConfig(5060))
self.lib.start()
self.acc = self.lib.create_account(
pjsua.AccountConfig(config.PBX_Host, "test1", "12345"))
self.assertTrue(self.acc.is_valid(), "invalid account")
acc_cb = MyAccountCallback(self.acc)
self.acc.set_callback(acc_cb)
acc_cb.wait()
self.assertTrue(acc_cb.account.info().reg_status >= 200,
"Could not register")
def connect(self):
self.logger.info('Connecting SIP device.')
lib = pj.Lib.instance()
self.metrics['connect'] = {}
self.metrics['handled_sms'] = []
self.metrics['handled_call'] = []
self.metrics['send_sms'] = []
self.metrics['dial_call'] = []
if not self._login():
self.logger.error('Login error')
return False
if not self._authenticate():
self.logger.error('Authentication error')
return False
## Transport / Listener
try:
self.logger.debug('Creating transport...')
tr = lib.create_transport(
pj.TransportType.TLS,
pj.TransportConfig(random.randint(1024, 64 * 1024), '0.0.0.0'))
self.logger.debug(
'Transport created. Type:%s, description:%s, is_reliable:%s, is_secure:%s, is_datagram:%s, host:%s, port:%s, ref_cnt:%s',
tr.info().type,
tr.info().description,
tr.info().is_reliable,
tr.info().is_secure,
tr.info().is_datagram,
tr.info().host,
tr.info().port,
tr.info().ref_cnt)
except pj.Error, e:
self.logger.error('Error creating transport:', e)
def wait(self):
self.sem = threading.Semaphore(0)
self.sem.acquire()
def on_reg_state(self):
if self.sem:
if self.account.info().reg_status >= 200:
self.sem.release()
lib = pj.Lib()
try:
lib.init(log_cfg=pj.LogConfig(level=4, callback=log_cb))
lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(5080))
lib.start()
acc = lib.create_account(pj.AccountConfig("pjsip.org", "bennylp", "***"))
acc_cb = MyAccountCallback(acc)
acc.set_callback(acc_cb)
acc_cb.wait()
print("\n")
print("Registration complete, status=", acc.info().reg_status, \
"(" + acc.info().reg_reason + ")")
print("\nPress ENTER to quit")
sys.stdin.readline()
lib.destroy()
if echo_cancel_type != -1:
media_cfg.ec_options = echo_cancel_type
if echo_cancel_tail != -1:
media_cfg.ec_tail_len = echo_cancel_tail
if quality != -1:
media_cfg.quality = quality
if channel_count != -1:
media_cfg.channel_count = channel_count
media_cfg.no_vad = no_vad
lib.init(ua_cfg, loging_cfg, media_cfg)
lib.set_snd_dev(audio_dev_in, audio_dev_out)
my_transport_cfg = pj.TransportConfig()
my_transport_cfg.port = rtp_port
transport = lib.create_transport(pj.TransportType.UDP, my_transport_cfg)
lib.start()
my_account_cfg = pj.AccountConfig(sip_registrar, user, password)
acc = lib.create_account(my_account_cfg)
acc_cb = MyAccountCallback(acc)
acc.set_callback(acc_cb)
acc_cb.wait()
log("Registration complete, status=" + str(acc.info().reg_status) + "(" +
str(acc.info().reg_reason) + ")")
def __init__(self):
super( Example,self ).__init__()
self.initUI()
lib = pj.Lib()
current_call = None
my_ua_cfg = pj.UAConfig()
my_ua_cfg.nameserver = ['8.8.8.8', '8.8.4.4']
my_ua_cfg.user_agent = "hanxiaotian_bupt"
# http://www.pjsip.org/python/pjsua.htm#MediaConfig
my_media_cfg = pj.MediaConfig()
my_media_cfg.enable_ice = True
#
# Procedure: Initialize > Create Transpot > Start > Handle calls > Shutdown
#
# https://trac.pjsip.org/repos/wiki/Python_SIP/Settings#StartupandShutdown
# Initialize the Library
lib.init(ua_cfg=my_ua_cfg, media_cfg=my_media_cfg, log_cfg = pj.LogConfig(level=3, callback=log_cb))
# Create One or More Transports
transport = lib.create_transport(pj.TransportType.TCP, pj.TransportConfig())
#transport = lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(0))
#transport = lib.create_transport(pj.TransportType.TLS, pj.TransportConfig(port=5060)) # SSL
lib.set_null_snd_dev()
# Starting the Library
lib.start()
lib.handle_events()
#
# Registration
#
acc_cfg = pj.AccountConfig()
succeed = 0
while (succeed == 0):
print "---------------------------------------------------------------------"
acc_cfg.id = "sip:[email protected]"
#
acc_cfg.reg_uri = "sip:10.103.241.142;transport=tcp"
#
acc_cfg.proxy = []
server = "10.103.241.142"
acc_cfg.proxy = [ "sip:10.103.241.142;transport=tcp;lr" ]
#
realm = "han"
#
username = "******"
#
passwd = "101"
print "---------------------------------------------------------------------"
acc_cfg.auth_cred = [pj.AuthCred(realm, username ,passwd)]
self.acc_cb = MyAccountCallback()
self.acc = lib.create_account(acc_cfg, cb=self.acc_cb)
self.acc_cb.wait()
# Conditions are not correct, because when "IP address change detected for account", all other accounts is Forbidden
if ((str(self.acc.info().reg_status) == "200") or (str(self.acc.info().reg_status) == "403")):
succeed = 1
else:
print ""
print "Registration failed, status=", self.acc.info().reg_status, \
"(" + self.acc.info().reg_reason + ")"
print ""
print "Please try again !"
global call_slot
current_call = None
recorderid = None
playerid = None
call_slot = None
lib = pj.Lib()
try:
mediaconfig = pj.MediaConfig()
mediaconfig.quality = 10
lib.init(log_cfg=pj.LogConfig(
level=4, callback=log_cb), media_cfg=mediaconfig)
transport = lib.create_transport(
pj.TransportType.UDP, pj.TransportConfig())
lib.start()
# Put your sIP client credentials here
acc = lib.create_account(pj.AccountConfig(
"10.208.209.59", "1000", "1000"))
acc_cb = MyAccountCallback(acc)
acc.set_callback(acc_cb)
acc_cb.wait()
print "\n"
print "Registration complete, status=", acc.info().reg_status, \
"(" + acc.info().reg_reason + ")"
if len(sys.argv) > 1:
def Active_state(self):
print("Call is :", self.call.info().state_text),
print("last code :", self.call.info().last_code),
print("(" + self.call.info().last_reason + ")")
#Disconnection
if (self.call.info().state_text == 'DISCONNCTD'):
print 'Press anykey to Unregister.....'
return
try:
#Instance creation
sip_lib = sip.Lib()
sip_lib.init(log_cfg = sip.LogConfig(level=3, callback=log_cb))
#creating Transport Object Instance...
client_IP_address = raw_input('Enter Client IP address :')
transport_socket = sip.TransportConfig()
transport_socket.port = 5060
transport_socket.bound_addr = client_IP_address
print('Binding IP ' + client_IP_address + 'to default port no 5060.....'),
transport_bind =sip_lib.create_transport(sip.TransportType.UDP,transport_socket)
print('OK')
#Starting SIP libraries
sip_lib.start()
sip_lib.set_null_snd_dev()
#Starting Registering Process
r_IP=raw_input("Enter IP address of the Server: ")
r_name=raw_input("Enter Username: "******"Enter Password: "******"sip:%s" % (r_name)
conf_of_account.reg_uri ='sip:%s:%s' % (r_IP,transport_socket.port)
account_callback = Calling_back_account(conf_of_account)
acc = sip_lib.create_account(conf_of_account,cb=account_callback)
#Setting value to Calling_back_account class
acc.set_callback(account_callback)
print('Status= ',acc.info().reg_status,'(' + acc.info().reg_reason + ')')
time.sleep(5)
print 'Registration is Complete....'
Reg_unreg=raw_input("you want to unregister?...")
if (Reg_unreg=="y"):
acc.set_registration(False)
else:
#Cll
c_ID = raw_input('Enter UID to make call : ')
print 'Calling %s.....' % (c_ID)
s_URI = 'sip:%s@%s:%s' % (c_ID,r_IP,transport_socket.port)
call = acc.make_call(s_URI, SRCallCallback(acc))
#Unreg
input = sys.stdin.readline().rstrip('\r\n')
print 'Unregistering.....'
time.sleep(2)
sip_lib.destroy()
time.sleep(2)
sip_lib= None
sys.exit(1)
#Excpt
except sip.Error, err:
print 'Initializations Error', err
sip_lib.destroy()
try:
print "call is connecting to", uri
return account_C.connect_call(uri, cb=CallBackforCurrCall())
except pj.Error, e:
print "Details of encountered exception in making call: " + str(e)
return None
#Main : Program starts here
#Library instance is created for lib class
lib = pj.Lib()
try:
lib.init(log_cfg=pj.LogConfig(level=Log_Value, callback=log_callback))
transport = lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(0))
lib.start()
account_C = lib.create_account(
pj.AccountConfig("192.168.137.1", "2020", "password"))
acc_cb = CallbckforAccount(account_C)
account_C.set_callback(acc_cb)
print "\n"
print "Status of the completed Registration =", account_C.info(
).reg_status, "(" + account_C.info().reg_reason + ")"
if len(sys.argv) > 1:
lck = lib.auto_lock()
on_call = connect_call(sys.argv[1])
print 'Current call is', on_call
del lck
call_slot = self.call.info().conf_slot
libObj.instance().conf_connect(call_slot, 0)
libObj.instance().conf_connect(0, call_slot)
# Main Program
try:
# Starting of the Main Class
# Step 1: First we need to Create library instance - which is the base class for the rest of the classes
libObj = pj.Lib()
# Step 2: Instantiating the library with the default configuration
libObj.init(log_cfg=pj.LogConfig(level=3, callback=log_cb))
# Step 3: Configuring the Transport Object
transObj = pj.TransportConfig()
print "************************REGISTRATION PROCESS BEGINS************************"
# Step 4: Define the SIP Port
transObj.port = 5060
# Step 5: Let the PJSIP know the client machine address
clientIP = raw_input("python SIPClient IP : ")
print "Using default SIP Port: 5060\n\n"
transObj.bound_addr = clientIP
transport = libObj.create_transport(pj.TransportType.UDP, transObj)
# Starting the Library class
libObj.start()
libObj.set_null_snd_dev()
#Information to create header of REGISTER SIP message
serverIP = raw_input("Proxy Server IP address:")
def main(argv):
global broker
global pj
global lib
global args
app_name = "SIP2MQTT"
parser = argparse.ArgumentParser(
description=
'A SIP monitoring tool that publishes incoming calls with CallerID to an MQTT channel'
)
requiredNamed = parser.add_argument_group('required named arguments')
requiredNamed.add_argument("-a",
"--mqtt_domain",
type=str,
required=True,
help="the MQTT broker domain string",
default=os.environ.get('MQTT_DOMAIN', None))
requiredNamed.add_argument("-t",
"--mqtt_port",
type=int,
required=True,
help="the MQTT broker port number",
default=os.environ.get('MQTT_PORT', None))
parser.add_argument("--mqtt_keepalive",
type=int,
required=False,
help="the MQTT broker keep alive in seconds",
default=60)
parser.add_argument("--mqtt_protocol",
type=str,
required=False,
help="the MQTT broker protocol",
default="MQTTv311",
choices=['MQTTv31', 'MQTTv311'])
requiredNamed.add_argument("-u",
"--mqtt_username",
type=str,
required=True,
help="the MQTT broker username",
default=os.environ.get('MQTT_USERNAME', None))
requiredNamed.add_argument("-p",
"--mqtt_password",
type=str,
required=False,
help="the MQTT broker password",
default=os.environ.get('MQTT_PASSWORD', None))
parser.add_argument("--mqtt_topic",
type=str,
required=False,
help="the MQTT broker topic",
default=os.environ.get('MQTT_TOPIC', "home/sip"))
requiredNamed.add_argument("-d",
"--sip_domain",
type=str,
required=True,
help="the SIP domain",
default=os.environ.get('SIP_DOMAIN', None))
parser.add_argument("--sip_port",
type=int,
required=False,
help="the SIP transport port number",
default=os.environ.get('SIP_PORT', 5060))
requiredNamed.add_argument("-n",
"--sip_username",
type=str,
required=True,
help="the SIP username",
default=os.environ.get('SIP_USERNAME', None))
requiredNamed.add_argument("-s",
"--sip_password",
type=str,
required=False,
help="the SIP password",
default=os.environ.get('SIP_PASSWORD', None))
parser.add_argument("--sip_display",
type=str,
required=False,
help="the SIP user display name",
default=app_name)
parser.add_argument("--log_level",
type=int,
required=False,
help="the application log level",
default=3,
choices=[0, 1, 2, 3])
parser.add_argument("-v",
"--verbosity",
action="count",
help="increase output verbosity",
default=3)
args = parser.parse_args()
log_level = logging.INFO #Deault logging level
if args.verbosity == 1:
log_level = logging.ERROR
elif args.verbosity == 2:
log_level = logging.WARN
elif args.verbosity == 3:
log_level = logging.INFO
elif args.verbosity >= 4:
log_level = logging.DEBUG
# Configure logging
# logging.basicConfig(filename="sip2mqtt.log", format="%(asctime)s - %(levelname)s - %(message)s",
# datefmt="%m/%d/%Y %I:%M:%S %p", level=log_level)
root = logging.getLogger()
root.setLevel(log_level)
# ch = logging.StreamHandler(sys.stdout)
# ch.setLevel(log_level)
# formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# ch.setFormatter(formatter)
# root.addHandler(ch)
# A more docker-friendly approach is to output to stdout
logging.basicConfig(stream=sys.stdout,
format="%(asctime)s - %(levelname)s - %(message)s",
datefmt="%m/%d/%Y %I:%M:%S %p",
level=log_level)
# Log startup messages and our configuration parameters
logging.info("------------------------")
logging.info("Starting up...")
logging.info("--- MQTT Broker Configuration ---")
logging.info("Domain: " + args.mqtt_domain)
logging.info("Port: " + str(args.mqtt_port))
logging.info("Protocol: " + args.mqtt_protocol)
logging.info("Username: "******"Keepalive Interval: " + str(args.mqtt_keepalive))
logging.info("Status Topic: " + args.mqtt_topic)
logging.info("--- SIP Configuration ---")
logging.info("Domain: " + args.sip_domain)
logging.info("Username: "******"DisplayName: " + args.sip_display)
try:
# Handle mqtt connection and callbacks
broker = mqtt.Client(client_id="",
clean_session=True,
userdata=None,
protocol=eval("mqtt." + args.mqtt_protocol))
broker.username_pw_set(args.mqtt_username, password=args.mqtt_password)
broker.on_connect = mqtt_connect
#broker.on_message = mqtt_message #don't need this callback for now
broker.connect(args.mqtt_domain, args.mqtt_port, args.mqtt_keepalive)
# Create library instance of Lib class
lib = pj.Lib()
ua = pj.UAConfig()
ua.user_agent = app_name
mc = pj.MediaConfig()
mc.clock_rate = 8000
lib.init(ua_cfg=ua,
log_cfg=pj.LogConfig(level=args.verbosity, callback=None),
media_cfg=mc)
lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(args.sip_port))
lib.set_null_snd_dev()
lib.start()
acc_cfg = pj.AccountConfig()
acc_cfg.id = "sip:" + args.sip_username + "@" + args.sip_domain
acc_cfg.reg_uri = "sip:" + args.sip_domain
acc_cfg.auth_cred = [
pj.AuthCred(args.sip_domain, args.sip_username, args.sip_password)
]
acc_cfg.allow_contact_rewrite = False
acc = lib.create_account(acc_cfg)
acc_cb = SMAccountCallback(acc)
acc.set_callback(acc_cb)
logging.info("-- Registration Complete --")
logging.info('SIP: Status = ' + str(acc.info().reg_status) + ' (' +
acc.info().reg_reason + ')')
except pj.Error, e:
logging.critical(("Exception: " + str(e)))
lib.destroy()
sys.exit(1)
#Connecting the call to a different sound device
call_slot = self.call.info().conf_slot
lib.conf_connect(call_slot, 0)
lib.conf_connect(0, call_slot)
print ("Hi. Have a nice day!")
print (lib)
# Main loop Part
try:
# Starting
# Creating the library instance of Lib Class
lib = pj.Lib()
# Instantiate library with default configuration
lib.init(log_cfg = pj.LogConfig(level=3, callback=log_cb))
# UDP configuration by binding up with 5060
trans_conf = pj.TransportConfig()
print "--------REGISTRATION STARTS BELOW--------"
print "\n\n"
trans_conf.port = 5060
client_IP=raw_input ("Enter the IP Adderess of your client : ")
print "Port number for SIP calls: 5060"
trans_conf.bound_addr = client_IP
transport = lib.create_transport(pj.Transporttype.UDP,trans_conf)
# Initiate the instance for Library Class
lib.start()
lib.set_null_snd_dev()
#Registration server configuration
#creating header sip register
my_media_cfg = pj.MediaConfig()
my_media_cfg.enable_ice = True
#
# Procedure: Initialize > Create Transpot > Start > Handle calls > Shutdown
#
# https://trac.pjsip.org/repos/wiki/Python_SIP/Settings#StartupandShutdown
# Initialize the Library
lib.init(ua_cfg=my_ua_cfg,
media_cfg=my_media_cfg,
log_cfg=pj.LogConfig(level=3, callback=log_cb))
# Create One or More Transports
transport = lib.create_transport(pj.TransportType.TCP,
pj.TransportConfig())
#transport = lib.create_transport(pj.TransportType.UDP, pj.TransportConfig(0))
#transport = lib.create_transport(pj.TransportType.TLS, pj.TransportConfig(port=5060)) # SSL
lib.set_null_snd_dev()
# Starting the Library
lib.start()
lib.handle_events()
#
# Registration
#
acc_cfg = pj.AccountConfig()
os.system('clear')
print "sipclient.py -- Simple SIP Client use PJSUA Python Module (PJSIP API)"
print ""
print "Making call to", uri
return acc.make_call(uri, cb=MyCallCallback())
except pj.Error, e:
print "Exception: " + str(e)
return None
# Create library instance
lib = pj.Lib()
try:
# Initialize library
lib.init(log_cfg=pj.LogConfig(level=LOG_LEVEL, callback=log_callback))
# Configuring one Transport Object
tran_conf = pj.TransportConfig()
tran_conf.bound_addr = "192.168.100.50" # IP address of PJSIP client
transport = lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(0))
print "\nListening on", transport.info().host, "\n"
# Start library
lib.start()
# Configuring Account class to register with Registrar server
acc_conf = pj.AccountConfig(domain='192.168.100.50',
username='******',
password='******',
display='2050',
registrar='sip:192.168.100.1',
proxy='sip:192.168.100.1')
'text':
'```Nova ligação de %s em %s```' %
(info.remote_contact, time.strftime("%Y-%m-%d %H:%M"))
}
urllib2.urlopen("https://api.telegram.org/bot%s/sendMessage?%s" %
(telegramBotId, urllib.urlencode(data))).read()
try:
# Create library instance
lib = pj.Lib()
# Init library with default config
lib.init(log_cfg=pj.LogConfig(level=3, callback=log_cb))
transportConfig = pj.TransportConfig()
transportConfig.port = 5080
# Create UDP transport which listens to any available port
transport = lib.create_transport(pj.TransportType.UDP, transportConfig)
# Start the library
lib.start()
acc_cfg = pj.AccountConfig()
acc_cfg.id = "%s" % sipId
acc_cfg.reg_uri = "%s" % sipRegUrl
acc_cfg.proxy = ["%s" % sipProxy]
acc_cfg.auth_cred = [pj.AuthCred("*", "%s" % sipUser, "%s" % sipPassword)]
acc_ck = CallbackAccount()
med_conf.jb_max = 0
med_conf.jb_min = 0
med_conf.max_media_ports = 1020
ua_config = pj.UAConfig()
ua_config.max_calls = 1000
lib.init(ua_cfg=ua_config,
log_cfg=pj.LogConfig(level=7, callback=log_cb),
media_cfg=med_conf)
# Remedy the non availibility of sound device
lib.set_null_snd_dev()
# Create UDP transport which listens to any available port
transport = lib.create_transport(pj.TransportType.UDP,
pj.TransportConfig(VOIP_SERVER_PORT))
RECORDING = True
lib.start()
# configure client account
acc_cfg = pj.AccountConfig()
acc_cfg.id = "sip:" + SIP_CALLER_ID + "@" + VOIP_SERVER
acc_cfg.reg_uri = "sip:" + VOIP_SERVER
acc_cfg.proxy = ["sip:" + VOIP_SERVER]
acc_cfg.auth_cred = [
pj.AuthCred(VOIP_SERVER, SIP_CALLER_ID, SIP_CALLER_PASSWORD)
]
acc = lib.create_account(acc_cfg)
acc_cb = MyAccountCallback(acc)
# Set of admins. If empty then everyone is admin! admins = set([]) # acc_cfg holds the account config (set it to None to disable account) acc_cfg = None acc_cfg = pj.AccountConfig() if acc_cfg: acc_cfg.id = "sip:[email protected]" acc_cfg.reg_uri = "sip:pjsip.org" acc_cfg.proxy = [ "sip:pjsip.org;lr;transport=tcp" ] acc_cfg.auth_cred = [ pj.AuthCred("*", "bot", "secretpass") ] acc_cfg.publish_enabled = True #acc_cfg.require_timer = True # Transport configs (set them to None to disable the transport) udp_cfg = pj.TransportConfig(5080) tcp_cfg = pj.TransportConfig(0) #tcp_cfg = None # Logging Config (you can also set it to None to use default values) def log_cb(level, str, len): print str, log_cfg = pj.LogConfig() #log_cfg.callback = log_cb # UA Config (you can also set it to None to use default values) ua_cfg = pj.UAConfig() ua_cfg.user_agent = "PJSIP ConfBot" ua_cfg.stun_host = "stun.pjsip.org"
