def _sendMessage(self, msgid, text, content_type="text/plain"):
utf8_encode = content_type not in ('application/im-iscomposing+xml',
'message/cpim')
message_request = Message(
FromHeader(self.account.uri, self.account.display_name),
ToHeader(self.target_uri),
RouteHeader(self.routes[0].get_uri()),
content_type,
text.encode('utf-8') if utf8_encode else text,
credentials=self.account.credentials)
self.notification_center.add_observer(self, sender=message_request)
message_request.send(
15 if content_type != "application/im-iscomposing+xml" else 5)
id = str(message_request)
if content_type != "application/im-iscomposing+xml":
BlinkLogger().log_info(u"Sent %s SMS message to %s" %
(content_type, self.target_uri))
self.enableIsComposing = True
message = self.messages.pop(msgid)
message.status = 'sent'
else:
message = MessageInfo(id, content_type=content_type)
self.messages[id] = message
return message
def send(self):
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(
host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = self.to_uri
try:
routes = lookup.lookup_sip_proxy(
uri, settings.sip.transport_list).wait()
except DNSLookupError:
msg = 'DNS lookup error while looking for %s proxy' % uri
log.warning(msg)
raise SIPMessageError(0, msg)
else:
route = routes.pop(0)
from_header = FromHeader(self.from_uri)
to_header = ToHeader(self.to_uri)
route_header = RouteHeader(route.uri)
notification_center = NotificationCenter()
for chunk in chunks(self.body, 1000):
if self.use_cpim:
additional_headers = []
payload = CPIMPayload(
self.body.encode('utf-8'),
self.content_type,
charset='utf-8',
sender=ChatIdentity(self.from_uri, None),
recipients=[ChatIdentity(self.to_uri, None)],
additional_headers=additional_headers)
payload, content_type = payload.encode()
else:
content_type = self.content_type
payload = self.body.encode('utf-8')
request = SIPMessageRequest(from_header, to_header,
route_header, content_type,
payload)
notification_center.add_observer(self, sender=request)
self._requests.add(request)
request.send()
error = None
count = len(self._requests)
while count > 0:
notification = self._channel.wait()
if notification.name == 'SIPMessageDidFail':
error = (notification.data.code, notification.data.reason)
count -= 1
self._requests.clear()
if error is not None:
raise SIPMessageError(*error)
def _send_message(self, message):
if (not self.last_route):
self.log_info('No route found')
return
message.timestamp = ISOTimestamp.now()
if not isinstance(message, OTRInternalMessage):
try:
content = self.encryption.otr_session.handle_output(
message.content, message.content_type)
except OTRError as e:
if 'has ended the private conversation' in str(e):
self.log_info(
'Encryption has been disabled by remote party, please resend the message again'
)
self.encryption.stop()
else:
self.log_info('Failed to encrypt outgoing message: %s' %
str(e))
return
timeout = 5
if message.content_type != "application/im-iscomposing+xml":
self.enableIsComposing = True
timeout = 15
message_request = Message(FromHeader(self.account.uri,
self.account.display_name),
ToHeader(self.target_uri),
RouteHeader(self.last_route.uri),
message.content_type,
message.content,
credentials=self.account.credentials)
self.notification_center.add_observer(self, sender=message_request)
message_request.send(timeout)
message.status = 'sent'
message.call_id = message_request._request.call_id.decode()
if not isinstance(message, OTRInternalMessage):
if self.encryption.active:
self.log_info(
'Sending encrypted %s message %s to %s' %
(message.content_type, message.id, self.last_route.uri))
else:
self.log_info(
'Sending %s message %s to %s' %
(message.content_type, message.id, self.last_route.uri))
id = str(message_request)
self.messages[id] = message
def send_chuck_norris_fact(self, source_uri, destination_uri, fact):
lookup = DNSLookup()
settings = SIPSimpleSettings()
try:
routes = lookup.lookup_sip_proxy(
destination_uri, settings.sip.transport_list).wait()
except DNSLookupError:
print "DNS lookup error while looking for %s proxy\n" % destination_uri
else:
route = routes.pop(0)
message_request = Message(FromHeader(source_uri),
ToHeader(destination_uri),
RouteHeader(route.get_uri()),
'text/plain', fact)
message_request.send()
def send_chuck_norris_fact(self, source_uri, destination_uri, fact):
lookup = DNSLookup()
settings = SIPSimpleSettings()
try:
routes = lookup.lookup_sip_proxy(destination_uri, settings.sip.transport_list).wait()
except DNSLookupError:
print "DNS lookup error while looking for %s proxy\n" % destination_uri
else:
route = routes.pop(0)
message_request = Message(FromHeader(source_uri),
ToHeader(destination_uri),
RouteHeader(route.get_uri()),
'text/plain',
fact)
message_request.send()
def sendReplicationMessage(self,
response_code,
content,
content_type="message/cpim",
timestamp=None):
timestamp = timestamp or ISOTimestamp.now()
# Lookup routes
if self.account.sip.outbound_proxy is not None:
uri = SIPURI(host=self.account.sip.outbound_proxy.host,
port=self.account.sip.outbound_proxy.port,
parameters={
'transport':
self.account.sip.outbound_proxy.transport
})
else:
uri = SIPURI(host=self.account.id.domain)
route = None
if self.last_route is None:
lookup = DNSLookup()
settings = SIPSimpleSettings()
try:
routes = lookup.lookup_sip_proxy(
uri, settings.sip.transport_list).wait()
except DNSLookupError:
pass
else:
route = routes[0]
else:
route = self.last_route
if route:
extra_headers = [
Header("X-Offline-Storage", "no"),
Header("X-Replication-Code", str(response_code)),
Header("X-Replication-Timestamp", str(ISOTimestamp.now()))
]
message_request = Message(FromHeader(self.account.uri,
self.account.display_name),
ToHeader(self.account.uri),
RouteHeader(route.uri),
content_type,
content,
credentials=self.account.credentials,
extra_headers=extra_headers)
message_request.send(
15 if content_type != "application/im-iscomposing+xml" else 5)
def _sendMessage(self, msgid, text, content_type="text/plain"):
utf8_encode = content_type not in ('application/im-iscomposing+xml', 'message/cpim')
message_request = Message(FromHeader(self.account.uri, self.account.display_name), ToHeader(self.target_uri),
RouteHeader(self.routes[0].get_uri()), content_type, text.encode('utf-8') if utf8_encode else text, credentials=self.account.credentials)
self.notification_center.add_observer(self, sender=message_request)
message_request.send(15 if content_type!="application/im-iscomposing+xml" else 5)
id=str(message_request)
if content_type != "application/im-iscomposing+xml":
BlinkLogger().log_info(u"Sent %s SMS message to %s" % (content_type, self.target_uri))
self.enableIsComposing = True
message = self.messages.pop(msgid)
message.status='sent'
else:
message = MessageInfo(id, content_type=content_type)
self.messages[id] = message
return message
def sendReplicationMessage(self,
response_code,
text,
content_type="message/cpim",
timestamp=None):
timestamp = timestamp or datetime.datetime.now(tzlocal())
# Lookup routes
if self.account.sip.outbound_proxy is not None:
uri = SIPURI(host=self.account.sip.outbound_proxy.host,
port=self.account.sip.outbound_proxy.port,
parameters={
'transport':
self.account.sip.outbound_proxy.transport
})
else:
uri = SIPURI(host=self.account.id.domain)
lookup = DNSLookup()
settings = SIPSimpleSettings()
try:
routes = lookup.lookup_sip_proxy(
uri, settings.sip.transport_list).wait()
except DNSLookupError:
pass
else:
utf8_encode = content_type not in (
'application/im-iscomposing+xml', 'message/cpim')
extra_headers = [
Header("X-Offline-Storage", "no"),
Header("X-Replication-Code", str(response_code)),
Header("X-Replication-Timestamp",
str(Timestamp(datetime.datetime.now())))
]
message_request = Message(
FromHeader(self.account.uri, self.account.display_name),
ToHeader(self.account.uri),
RouteHeader(routes[0].get_uri()),
content_type,
text.encode('utf-8') if utf8_encode else text,
credentials=self.account.credentials,
extra_headers=extra_headers)
message_request.send(
15 if content_type != "application/im-iscomposing+xml" else 5)
def sendReplicationMessage(self, response_code, text, content_type="message/cpim", timestamp=None):
timestamp = timestamp or datetime.datetime.now(tzlocal())
# Lookup routes
if self.account.sip.outbound_proxy is not None:
uri = SIPURI(host=self.account.sip.outbound_proxy.host,
port=self.account.sip.outbound_proxy.port,
parameters={'transport': self.account.sip.outbound_proxy.transport})
else:
uri = SIPURI(host=self.account.id.domain)
lookup = DNSLookup()
settings = SIPSimpleSettings()
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
pass
else:
utf8_encode = content_type not in ('application/im-iscomposing+xml', 'message/cpim')
extra_headers = [Header("X-Offline-Storage", "no"), Header("X-Replication-Code", str(response_code)), Header("X-Replication-Timestamp", str(Timestamp(datetime.datetime.now())))]
message_request = Message(FromHeader(self.account.uri, self.account.display_name), ToHeader(self.account.uri),
RouteHeader(routes[0].get_uri()), content_type, text.encode('utf-8') if utf8_encode else text, credentials=self.account.credentials, extra_headers=extra_headers)
message_request.send(15 if content_type != "application/im-iscomposing+xml" else 5)
def _send(self):
if self.session.routes:
from_uri = self.account.uri
content = self.content if isinstance(
self.content, bytes) else self.content.encode()
additional_sip_headers = []
if self.account.sms.use_cpim:
ns = CPIMNamespace('urn:ietf:params:imdn', 'imdn')
additional_headers = [CPIMHeader('Message-ID', ns, self.id)]
if self.account.sms.enable_imdn and self.content_type not in self.__disabled_imdn_content_types__:
additional_headers.append(
CPIMHeader('Disposition-Notification', ns,
'positive-delivery, display'))
payload = CPIMPayload(
content,
self.content_type,
charset='utf-8',
sender=ChatIdentity(from_uri, self.account.display_name),
recipients=[ChatIdentity(self.sip_uri, None)],
timestamp=str(self.timestamp),
additional_headers=additional_headers)
payload, content_type = payload.encode()
else:
payload = content
content_type = self.content_type
route = self.session.routes[0]
message_request = Message(FromHeader(from_uri,
self.account.display_name),
ToHeader(self.sip_uri),
RouteHeader(route.uri),
content_type,
payload,
credentials=self.account.credentials,
extra_headers=additional_sip_headers)
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=message_request)
message_request.send()
else:
pass
def send(self):
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = self.to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
msg = 'DNS lookup error while looking for %s proxy' % uri
log.warning(msg)
raise SIPMessageError(0, msg)
else:
route = routes.pop(0)
from_header = FromHeader(self.from_uri)
to_header = ToHeader(self.to_uri)
route_header = RouteHeader(route.uri)
notification_center = NotificationCenter()
for chunk in chunks(self.body, 1000):
request = SIPMessageRequest(from_header, to_header, route_header, self.content_type, self.body)
notification_center.add_observer(self, sender=request)
self._requests.add(request)
request.send()
error = None
count = len(self._requests)
while count > 0:
notification = self._channel.wait()
if notification.name == 'SIPMessageDidFail':
error = (notification.data.code, notification.data.reason)
count -= 1
self._requests.clear()
if error is not None:
raise SIPMessageError(*error)
def _send_message(self, targeturi, messagebody, route):
## sends a message to the target URI
notification_center = NotificationCenter()
if route:
uri = targeturi
if uri is None:
uri = ToHeader(
SIPURI(user=self.account.id.username,
host=self.account.id.domain))
identity = str(self.account.uri)
if self.account.display_name:
identity = '"%s" <%s>' % (self.account.display_name, identity)
self.output.put(
"Sending MESSAGE from '%s' to '%s' using proxy %s" %
(identity, targeturi, route))
message_request = Message(
FromHeader(self.account.uri, self.account.display_name),
ToHeader(uri), RouteHeader(route.uri), 'text/plain',
messagebody, self.account.credentials, [])
notification_center.add_observer(self, sender=message_request)
message_request.send()
else:
self.output.put('No route to try. Aborting.\n')
return
async def send_request(self, arc_name: str, scaip_request: ScaipRequest):
logger.info(f"send_request to {arc_name}: {scaip_request}")
config = self.config
arc_config = config.get_arc_config(arc_name)
if not arc_config:
raise ValueError(f"no configuration found for ARC {arc_name}")
xml_model = scaip_request.to_xml_model()
xml_str = self.serializer.render(xml_model)
result = self.new_result_future(scaip_request.reference)
if scaip_request.caller_id.startswith(
"sip") and scaip_request.caller_id != "sip:":
caller_id = URI(scaip_request.caller_id)
sender = SIPURI(user=caller_id.user,
host=caller_id.host,
port=caller_id.port)
else:
sender = self.get_user_agent_uri()
receiver = SIPURI(user=arc_config.username,
host=arc_config.hostname,
port=arc_config.port)
message = Message(FromHeader(sender), ToHeader(receiver),
RouteHeader(receiver), 'application/scaip+xml',
xml_str)
message.send()
logger.info(f"sent message: {xml_str}")
scaip_response = await result
logger.info(f"received response: {scaip_response}")
return scaip_response
