def on_yes(dummy, fjid, file_props, account):
# Delete old file
os.remove(file_props.file_name)
jid, resource = app.get_room_and_nick_from_fjid(fjid)
if resource:
contact = app.contacts.get_contact(account, jid, resource)
else:
contact = app.contacts.get_contact_with_highest_priority(
account, jid)
fjid = contact.get_full_jid()
# Request the file to the sender
sid = helpers.get_random_string()
new_file_props = FilesProp.getNewFileProp(account, sid)
new_file_props.file_name = file_props.file_name
new_file_props.name = file_props.name
new_file_props.desc = file_props.desc
new_file_props.size = file_props.size
new_file_props.date = file_props.date
new_file_props.hash_ = file_props.hash_
new_file_props.type_ = 'r'
tsid = app.connections[account].get_module(
'Jingle').start_file_transfer(fjid, new_file_props, True)
new_file_props.transport_sid = tsid
self.add_transfer(account, contact, new_file_props)
def _get_contact_or_gc_contact_for_jid(self, jid):
contact = app.contacts.get_contact_from_full_jid(self._account, jid)
if contact is None:
room_jid, nick = app.get_room_and_nick_from_fjid(jid)
contact = app.contacts.get_gc_contact(self._account, room_jid,
nick)
return contact
def execute(self, request):
account = self.connection.name
# Forward messages
events = app.events.get_events(account, types=['chat', 'normal'])
j, resource = app.get_room_and_nick_from_fjid(self.jid)
for jid in events:
for event in events[jid]:
ev_typ = event.type_
if ev_typ == 'printed_chat':
ev_typ = 'chat'
app.nec.push_outgoing_event(MessageOutgoingEvent(None,
account=account, jid=j, message=event.message, type_=ev_typ,
subject=event.subject, resource=resource, forward_from=jid,
delayed=event.time_, now=True))
response, cmd = self.buildResponse(request, status = 'completed')
cmd.addChild('note', {}, _('The status has been changed.'))
# if going offline, we need to push response so it won't go into
# queue and disappear
self.connection.connection.send(response, now = True)
# send new status
app.interface.roster.send_status(self.connection.name, 'offline', '')
# finish the session
return False
def _raise_event(self, name, **kwargs):
jid, resource = app.get_room_and_nick_from_fjid(self.peerjid)
app.nec.push_incoming_event(
NetworkEvent(name,
conn=self.connection,
fjid=self.peerjid,
jid=jid,
sid=self.sid,
resource=resource,
jingle_session=self,
**kwargs))
def get_jid_resource(self, check_fake_jid=False):
if check_fake_jid and hasattr(self, 'id_') and \
self.id_ in self.conn.groupchat_jids:
self.fjid = self.conn.groupchat_jids[self.id_]
del self.conn.groupchat_jids[self.id_]
else:
self.fjid = helpers.get_full_jid_from_iq(self.stanza)
if self.fjid is None:
self.jid = None
else:
self.jid, self.resource = app.get_room_and_nick_from_fjid(self.fjid)
def on_event_added(self, event):
account = event.account
jid = event.jid
when = time.time()
contact = ""
key = (account, jid)
events = [
'chat', 'printed_chat', 'printed_normal', 'normal', 'file-request',
'jingle-incoming'
]
if event.type_ in events:
contact = app.contacts.get_contact_from_full_jid(account, jid)
if contact:
contact = contact.get_shown_name()
else:
contact = jid
elif event.type_ == "pm" or event.type_ == "printed_pm":
contact = app.get_nick_from_jid(app.get_room_from_fjid(jid)) + \
"/" + app.get_room_and_nick_from_fjid(jid)[1]
elif event.type_ == "printed_marked_gc_msg":
contact = app.get_nick_from_jid(app.get_room_from_fjid(jid))
else:
return
event.time = when
if key not in self.events:
icon = None
if app.config.get("show_avatars_in_roster"):
pix = app.contacts.get_avatar(account, jid, size=16)
icon = Gtk.Image()
icon.set_from_pixbuf(pix)
item = Gtk.ImageMenuItem(contact + " (1)")
if icon:
item.set_image(icon)
item.set_always_show_image(True)
item.connect("activate", self.event_raise, event)
item.show()
self.menu.insert(item, self.menuEventInsertIndex)
self.event_separator.show()
self.events[key] = {}
self.events[key]['item'] = item
self.events[key]['contact'] = contact
self.events[key]['events'] = [event]
else:
self.events[key]['events'].append(event)
item = self.events[key]['item']
item.set_label(self.events[key]['contact'] + " (" +
str(len(self.events[key]['events'])) + ")")
self.indicator.set_status(appindicator.IndicatorStatus.ATTENTION)
def _check_last_interaction(self) -> GLib.SOURCE_CONTINUE:
now = time.time()
for jid in list(self._last_mouse_activity.keys()):
time_ = self._last_mouse_activity[jid]
current_state = self._chatstates.get(jid)
if current_state is None:
self._last_mouse_activity.pop(jid, None)
self._last_keyboard_activity.pop(jid, None)
continue
if current_state in (State.GONE, State.INACTIVE):
continue
new_chatstate = None
if now - time_ > INACTIVE_AFTER:
new_chatstate = State.INACTIVE
elif current_state == State.COMPOSING:
key_time = self._last_keyboard_activity[jid]
if now - key_time > PAUSED_AFTER:
new_chatstate = State.PAUSED
if new_chatstate is not None:
if self._chatstates.get(jid) != new_chatstate:
contact = app.contacts.get_contact(self._account, jid)
if contact is None:
room, nick = app.get_room_and_nick_from_fjid(jid)
contact = app.contacts.get_gc_contact(
self._account, room, nick)
if contact is not None:
contact = contact.as_contact()
else:
# Contact not found, maybe we left the group chat
# or the contact was removed from the roster
self._log.info(
'Contact %s not found, reset chatstate', jid)
self._chatstates.pop(jid, None)
self._last_mouse_activity.pop(jid, None)
self._last_keyboard_activity.pop(jid, None)
continue
self.set_chatstate(contact, new_chatstate)
return GLib.SOURCE_CONTINUE
def generate(self):
self.jid, self.resource = app.get_room_and_nick_from_fjid(self.fjid)
self.resource = 'local'
self.prio = 0
self.keyID = None
self.idle_time = None
self.timestamp = 0
self.contact_nickname = None
self.avatar_sha = None
self.need_add_in_roster = False
self.need_redraw = False
if self.show == 'offline':
self.ptype = 'unavailable'
else:
self.ptype = None
self.is_gc = False
self.user_nick = ''
self.transport_auto_auth = False
self.errcode = None
self.errmsg = ''
self.popup = False # Do we want to open chat window ?
return True
def execute(self, request):
account = self.connection.name
# Forward messages
events = app.events.get_events(account, types=['chat', 'normal',
'printed_chat'])
j, resource = app.get_room_and_nick_from_fjid(self.jid)
for jid in events:
for event in events[jid]:
ev_typ = event.type_
if ev_typ == 'printed_chat':
ev_typ = 'chat'
app.nec.push_outgoing_event(MessageOutgoingEvent(None,
account=account, jid=j, message=event.message, type_=ev_typ,
subject=event.subject, resource=resource, forward_from=jid,
delayed=event.time_))
# Inform other client of completion
response, cmd = self.buildResponse(request, status = 'completed')
cmd.addChild('note', {}, _('All unread messages have been forwarded.'))
self.connection.connection.send(response)
return False # finish the session
def _messageCB(self, con, stanza, properties):
"""
Called when we receive a message
"""
if properties.type.is_error:
return
log.info('Zeroconf MessageCB')
# Don’t trust from attr set by sender
stanza.setFrom(con._owner.to)
app.nec.push_incoming_event(
NetworkEvent('raw-message-received',
conn=self,
stanza=stanza,
account=self.name))
type_ = stanza.getType()
if type_ is None:
type_ = 'normal'
id_ = stanza.getID()
fjid = str(stanza.getFrom())
jid, resource = app.get_room_and_nick_from_fjid(fjid)
msgtxt = stanza.getBody()
session = self.get_or_create_session(fjid, properties.thread)
if properties.thread and not session.received_thread_id:
session.received_thread_id = True
timestamp = time.time()
session.last_receive = timestamp
additional_data = AdditionalDataDict()
parse_oob(properties, additional_data)
parse_xhtml(properties, additional_data)
if properties.is_encrypted:
additional_data['encrypted'] = properties.encrypted.additional_data
else:
if properties.eme is not None:
msgtxt = get_eme_message(properties.eme)
event_attr = {
'conn': self,
'stanza': stanza,
'account': self.name,
'additional_data': additional_data,
'timestamp': time.time(),
'fjid': fjid,
'jid': jid,
'resource': resource,
'unique_id': id_,
'correct_id': parse_correction(properties),
'msgtxt': msgtxt,
'session': session,
'gc_control': None,
'popup': False,
'msg_log_id': None,
'displaymarking': None,
'stanza_id': id_,
'properties': properties,
}
app.nec.push_incoming_event(
NetworkEvent('decrypted-message-received', **event_attr))
def generate(self):
self.fjid = self.jingle_session.peerjid
self.jid, self.resource = app.get_room_and_nick_from_fjid(self.fjid)
self.sid = self.jingle_session.sid
return True
def _fill_completion_dict(self):
"""
Fill completion_dict for key auto completion. Then load history for
current jid (by calling another function)
Key will be either jid or full_completion_name (contact name or long
description like "pm-contact from groupchat....").
{key : (jid, account, nick_name, full_completion_name}
This is a generator and does pseudo-threading via idle_add().
"""
liststore = get_completion_liststore(
self._ui.query_entry.get_child())
liststore.set_sort_column_id(1, Gtk.SortType.ASCENDING)
self._ui.query_entry.get_child().get_completion().connect(
'match-selected', self.on_jid_entry_match_selected)
self._ui.query_entry.set_model(liststore)
# Add all jids in logs.db:
db_jids = app.logger.get_jids_in_db()
completion_dict = dict.fromkeys(db_jids)
self.accounts_seen_online = list(app.contacts.get_accounts())
# Enhance contacts of online accounts with contact.
# Needed for mapping below
for account in self.accounts_seen_online:
completion_dict.update(
helpers.get_contact_dict_for_account(account))
muc_active_icon = get_icon_name('muc-active')
online_icon = get_icon_name('online')
keys = list(completion_dict.keys())
# Move the actual jid at first so we load history faster
actual_jid = self._ui.query_entry.get_child().get_text()
if actual_jid in keys:
keys.remove(actual_jid)
keys.insert(0, actual_jid)
if '' in keys:
keys.remove('')
if None in keys:
keys.remove(None)
# Map jid to info tuple
# Warning : This for is time critical with big DB
for key in keys:
completed = key
completed2 = None
contact = completion_dict[completed]
if contact:
info_name = contact.get_shown_name()
info_completion = info_name
info_jid = contact.jid
else:
# Corresponding account is offline, we know nothing
info_name = completed.split('@')[0]
info_completion = completed
info_jid = completed
info_acc = self._get_account_for_jid(info_jid)
if (app.logger.jid_is_room_jid(completed) or
app.logger.jid_is_from_pm(completed)):
icon = muc_active_icon
if app.logger.jid_is_from_pm(completed):
# It's PM. Make it easier to find
room, nick = app.get_room_and_nick_from_fjid(completed)
info_completion = '%s from %s' % (nick, room)
completed = info_completion
info_completion2 = '%s/%s' % (room, nick)
completed2 = info_completion2
info_name = nick
else:
icon = online_icon
if len(completed) > 70:
completed = completed[:70] + '[\u2026]'
liststore.append((icon, completed))
self.completion_dict[key] = (
info_jid, info_acc, info_name, info_completion)
self.completion_dict[completed] = (
info_jid, info_acc, info_name, info_completion)
if completed2:
if len(completed2) > 70:
completed2 = completed2[:70] + '[\u2026]'
liststore.append((icon, completed2))
self.completion_dict[completed2] = (
info_jid, info_acc, info_name, info_completion2)
if key == actual_jid:
self._load_history(info_jid, self.account or info_acc)
yield True
keys.sort()
yield False
def _message_received(self, con, stanza):
# https://tools.ietf.org/html/rfc6120#section-8.1.1.1
# If the stanza does not include a 'to' address then the client MUST
# treat it as if the 'to' address were included with a value of the
# client's full JID.
#
# Implementation Note: However, if the client does
# check the 'to' address then it is suggested to check at most the
# bare JID portion (not the full JID)
own_jid = self._con.get_own_jid().getStripped()
to = stanza.getTo()
if to is None:
stanza.setTo(own_jid)
elif not to.bareMatch(own_jid):
log.warning('Message addressed to someone else: %s', stanza)
raise nbxmpp.NodeProcessed
# Check if a child of the message contains any
# namespaces that we handle in other modules.
# nbxmpp executes less common handlers last
if self._message_namespaces & set(stanza.getProperties()):
return
muc_user = stanza.getTag('x', namespace=nbxmpp.NS_MUC_USER)
if muc_user is not None:
if muc_user.getChildren():
# Not a PM, handled by MUC module
return
log.info('Received from %s', stanza.getFrom())
app.nec.push_incoming_event(
NetworkEvent('raw-message-received',
conn=self._con,
stanza=stanza,
account=self._account))
if stanza.getFrom() == self._con.get_own_jid(warn=True):
# Drop messages sent from our own full jid
# It can happen that when we sent message to our own bare jid
# that the server routes that message back to us
log.info('Received message from self: %s, message is dropped',
stanza.getFrom())
return
stanza, sent, forwarded = parse_carbon(self._con, stanza)
from_ = stanza.getFrom()
type_ = stanza.getType()
if type_ is None:
type_ = 'normal'
self_message = is_self_message(stanza, type_ == 'groupchat')
muc_pm = is_muc_pm(stanza, from_, type_ == 'groupchat')
id_ = stanza.getID()
fjid = None
if from_ is not None:
try:
fjid = helpers.parse_jid(str(from_))
except helpers.InvalidFormat:
log.warning('Invalid JID: %s, ignoring it', stanza.getFrom())
return
jid, resource = app.get_room_and_nick_from_fjid(fjid)
# Check for duplicates
stanza_id, origin_id = self._get_unique_id(stanza, forwarded, sent,
self_message, muc_pm)
# Check groupchat messages for duplicates,
# We do this because of MUC History messages
if type_ == 'groupchat' or self_message or muc_pm:
if type_ == 'groupchat':
archive_jid = stanza.getFrom().getStripped()
else:
archive_jid = own_jid
if app.logger.find_stanza_id(self._account, archive_jid, stanza_id,
origin_id, type_ == 'groupchat'):
return
thread_id = stanza.getThread()
msgtxt = stanza.getBody()
# TODO: remove all control UI stuff
gc_control = app.interface.msg_win_mgr.get_gc_control(
jid, self._account)
if not gc_control:
minimized = app.interface.minimized_controls[self._account]
gc_control = minimized.get(jid)
if gc_control and jid == fjid:
if type_ == 'error':
msgtxt = _('error while sending %(message)s ( %(error)s )') % {
'message': msgtxt,
'error': stanza.getErrorMsg()
}
# TODO: why is this here?
if stanza.getTag('html'):
stanza.delChild('html')
session = None
if type_ != 'groupchat':
if muc_pm and type_ == 'error':
session = self._con.find_session(fjid, thread_id)
if not session:
session = self._con.get_latest_session(fjid)
if not session:
session = self._con.make_new_session(fjid,
thread_id,
type_='pm')
else:
session = self._con.get_or_create_session(fjid, thread_id)
if thread_id and not session.received_thread_id:
session.received_thread_id = True
session.last_receive = time.time()
timestamp = parse_delay(stanza)
if timestamp is None:
timestamp = time.time()
event_attr = {
'conn': self._con,
'stanza': stanza,
'account': self._account,
'id_': id_,
'encrypted': False,
'additional_data': {},
'forwarded': forwarded,
'sent': sent,
'timestamp': timestamp,
'fjid': fjid,
'jid': jid,
'resource': resource,
'stanza_id': stanza_id,
'unique_id': stanza_id or origin_id,
'mtype': type_,
'msgtxt': msgtxt,
'thread_id': thread_id,
'session': session,
'self_message': self_message,
'muc_pm': muc_pm,
'gc_control': gc_control
}
event = MessageReceivedEvent(None, **event_attr)
app.nec.push_incoming_event(event)
app.plugin_manager.extension_point('decrypt', self._con, event,
self._on_message_decrypted)
if not event.encrypted:
eme = parse_eme(event.stanza)
if eme is not None:
event.msgtxt = eme
self._on_message_decrypted(event)
def fill_jabber_page(self):
self.xml.get_object('nickname_label').set_markup(
'<b><span size="x-large">' + self.contact.get_shown_name() +
'</span></b>')
self.xml.get_object('jid_label').set_text(self.contact.jid)
subscription_label = self.xml.get_object('subscription_label')
ask_label = self.xml.get_object('ask_label')
if self.gc_contact:
self.xml.get_object('subscription_title_label').set_markup(
Q_("?Role in Group Chat:<b>Role:</b>"))
uf_role = helpers.get_uf_role(self.gc_contact.role)
subscription_label.set_text(uf_role)
self.xml.get_object('ask_title_label').set_markup(
_("<b>Affiliation:</b>"))
uf_affiliation = helpers.get_uf_affiliation(
self.gc_contact.affiliation)
ask_label.set_text(uf_affiliation)
else:
uf_sub = helpers.get_uf_sub(self.contact.sub)
subscription_label.set_text(uf_sub)
if self.contact.sub == 'from':
tt_text = _(
"This contact is interested in your presence information, but you are not interested in their presence"
)
elif self.contact.sub == 'to':
tt_text = _(
"You are interested in the contact's presence information, but it is not mutual"
)
elif self.contact.sub == 'both':
tt_text = _(
"The contact and you want to exchange presence information"
)
else: # None
tt_text = _(
"You and the contact have a mutual disinterest in each-others presence information"
)
subscription_label.set_tooltip_text(tt_text)
uf_ask = helpers.get_uf_ask(self.contact.ask)
ask_label.set_text(uf_ask)
if self.contact.ask == 'subscribe':
tt_text = _(
"You are waiting contact's answer about your subscription request"
)
else:
tt_text = _("There is no pending subscription request.")
ask_label.set_tooltip_text(tt_text)
resources = '%s (%s)' % (self.contact.resource,
str(self.contact.priority))
uf_resources = self.contact.resource + _(' resource with priority ')\
+ str(self.contact.priority)
if not self.contact.status:
self.contact.status = ''
con = app.connections[self.account]
# do not wait for os_info if contact is not connected or has error
# additional check for observer is needed, as show is offline for him
if self.contact.show in ('offline', 'error')\
and not self.contact.is_observer():
self.os_info_arrived = True
else: # Request os info if contact is connected
if self.gc_contact:
con.get_module('SoftwareVersion').request_software_version(
self.real_jid,
callback=self.set_os_info,
user_data=self.real_jid)
else:
jid = self.contact.get_full_jid()
con.get_module('SoftwareVersion').request_software_version(
jid, callback=self.set_os_info, user_data=jid)
# do not wait for entity_time if contact is not connected or has error
# additional check for observer is needed, as show is offline for him
if self.contact.show in ('offline', 'error')\
and not self.contact.is_observer():
self.entity_time_arrived = True
else: # Request entity time if contact is connected
if self.gc_contact:
j, r = app.get_room_and_nick_from_fjid(self.real_jid)
GLib.idle_add(
con.get_module('EntityTime').request_entity_time, j, r)
else:
GLib.idle_add(
con.get_module('EntityTime').request_entity_time,
self.contact.jid, self.contact.resource)
self.os_info = {
0: {
'resource': self.real_resource,
'client': '',
'os': ''
}
}
self.time_info = {0: {'resource': self.real_resource, 'time': ''}}
i = 1
contact_list = app.contacts.get_contacts(self.account,
self.contact.jid)
if contact_list:
for c in contact_list:
if c.resource != self.contact.resource:
resources += '\n%s (%s)' % (c.resource, str(c.priority))
uf_resources += '\n' + c.resource + \
_(' resource with priority ') + str(c.priority)
if c.show not in ('offline', 'error'):
jid = c.get_full_jid()
con.get_module(
'SoftwareVersion').request_software_version(
jid, callback=self.set_os_info, user_data=jid)
GLib.idle_add(
con.get_module('EntityTime').request_entity_time,
c.jid, c.resource)
self.os_info[i] = {
'resource': c.resource,
'client': '',
'os': ''
}
self.time_info[i] = {'resource': c.resource, 'time': ''}
i += 1
self.xml.get_object('resource_prio_label').set_text(resources)
resource_prio_label_eventbox = self.xml.get_object(
'resource_prio_label_eventbox')
resource_prio_label_eventbox.set_tooltip_text(uf_resources)
self.fill_status_label()
if self.gc_contact:
con.get_module('VCardTemp').request_vcard(
self._nec_vcard_received,
self.gc_contact.get_full_jid(),
room=True)
else:
con.get_module('VCardTemp').request_vcard(self._nec_vcard_received,
self.contact.jid)
def _messageCB(self, con, stanza, properties):
"""
Called when we receive a message
"""
log.info('Zeroconf MessageCB')
# Dont trust from attr set by sender
stanza.setFrom(con._owner.to)
app.nec.push_incoming_event(NetworkEvent(
'raw-message-received',
conn=self,
stanza=stanza,
account=self.name))
type_ = stanza.getType()
if type_ is None:
type_ = 'normal'
id_ = stanza.getID()
fjid = str(stanza.getFrom())
jid, resource = app.get_room_and_nick_from_fjid(fjid)
thread_id = stanza.getThread()
msgtxt = stanza.getBody()
session = self.get_or_create_session(fjid, thread_id)
if thread_id and not session.received_thread_id:
session.received_thread_id = True
session.last_receive = time.time()
event_attr = {
'conn': self,
'stanza': stanza,
'account': self.name,
'id_': id_,
'encrypted': False,
'additional_data': AdditionalDataDict(),
'forwarded': False,
'sent': False,
'timestamp': time.time(),
'fjid': fjid,
'jid': jid,
'resource': resource,
'unique_id': id_,
'message_id': properties.id,
'mtype': type_,
'msgtxt': msgtxt,
'thread_id': thread_id,
'session': session,
'self_message': False,
'muc_pm': False,
'gc_control': None}
event = ZeroconfMessageReceivedEvent(None, **event_attr)
app.nec.push_incoming_event(event)
app.plugin_manager.extension_point(
'decrypt', self, event, self._on_message_decrypted)
if not event.encrypted:
if properties.eme is not None:
event.msgtxt = get_eme_message(properties.eme)
self._on_message_decrypted(event)
def handle_negotiation(self, form):
if form.getField('accept') and not form['accept'] in ('1', 'true'):
self.cancelled_negotiation()
return
# encrypted session states. these are described in stanza_session.py
try:
if form.getType() == 'form' and 'security' in form.asDict():
security_options = [x[1] for x in form.getField('security').\
getOptions()]
if security_options == ['none']:
self.respond_archiving(form)
else:
# bob responds
# we don't support 3-message negotiation as the responder
if 'dhkeys' in form.asDict():
self.fail_bad_negotiation(
'3 message negotiation not '
'supported when responding', ('dhkeys', ))
return
negotiated, not_acceptable, ask_user = \
self.verify_options_bob(form)
if ask_user:
def accept_nondefault_options(is_checked):
self.dialog.destroy()
negotiated.update(ask_user)
self.respond_e2e_bob(form, negotiated,
not_acceptable)
def reject_nondefault_options():
self.dialog.destroy()
for key in ask_user.keys():
not_acceptable.append(key)
self.respond_e2e_bob(form, negotiated,
not_acceptable)
self.dialog = dialogs.YesNoDialog(
_('Confirm these '
'session options'),
_('The remote client wants to negotiate a session '
'with these features:\n\n%s\n\nAre these options '
'acceptable?'
'') % (negotiation.describe_features(ask_user)),
on_response_yes=accept_nondefault_options,
on_response_no=reject_nondefault_options,
transient_for=self.control.parent_win.window)
else:
self.respond_e2e_bob(form, negotiated, not_acceptable)
return
elif self.status == 'requested-archiving' and form.getType() == \
'submit':
try:
self.archiving_accepted(form)
except exceptions.NegotiationError as details:
self.fail_bad_negotiation(details)
return
# alice accepts
elif self.status == 'requested-e2e' and form.getType() == 'submit':
negotiated, not_acceptable, ask_user = self.verify_options_alice(
form)
if ask_user:
def accept_nondefault_options(is_checked):
if dialog:
dialog.destroy()
if is_checked:
allow_no_log_for = app.config.get_per(
'accounts', self.conn.name,
'allow_no_log_for').split()
jid = str(self.jid)
if jid not in allow_no_log_for:
allow_no_log_for.append(jid)
app.config.set_per('accounts', self.conn.name,
'allow_no_log_for',
' '.join(allow_no_log_for))
negotiated.update(ask_user)
try:
self.accept_e2e_alice(form, negotiated)
except exceptions.NegotiationError as details:
self.fail_bad_negotiation(details)
def reject_nondefault_options():
self.reject_negotiation()
dialog.destroy()
allow_no_log_for = app.config.get_per(
'accounts', self.conn.name,
'allow_no_log_for').split()
if str(self.jid) in allow_no_log_for:
dialog = None
accept_nondefault_options(False)
else:
dialog = dialogs.YesNoDialog(
_('Confirm these session '
'options'),
_('The remote client selected these options:\n\n%s'
'\n\nContinue with the session?') %
(negotiation.describe_features(ask_user)),
_('Always accept for this contact'),
on_response_yes=accept_nondefault_options,
on_response_no=reject_nondefault_options,
transient_for=self.control.parent_win.window)
else:
try:
self.accept_e2e_alice(form, negotiated)
except exceptions.NegotiationError as details:
self.fail_bad_negotiation(details)
return
elif self.status == 'responded-archiving' and form.getType() == \
'result':
try:
self.we_accept_archiving(form)
except exceptions.NegotiationError as details:
self.fail_bad_negotiation(details)
return
elif self.status == 'responded-e2e' and form.getType() == 'result':
try:
self.accept_e2e_bob(form)
except exceptions.NegotiationError as details:
self.fail_bad_negotiation(details)
return
elif self.status == 'identified-alice' and form.getType(
) == 'result':
try:
self.final_steps_alice(form)
except exceptions.NegotiationError as details:
self.fail_bad_negotiation(details)
return
except exceptions.Cancelled:
# user cancelled the negotiation
self.reject_negotiation()
return
if form.getField('terminate') and\
form.getField('terminate').getValue() in ('1', 'true'):
self.acknowledge_termination()
self.conn.delete_session(str(self.jid), self.thread_id)
return
# non-esession negotiation. this isn't very useful, but i'm keeping it
# around to test my test suite.
if form.getType() == 'form':
if not self.control:
jid, resource = app.get_room_and_nick_from_fjid(str(self.jid))
account = self.conn.name
contact = app.contacts.get_contact(account, str(self.jid),
resource)
if not contact:
contact = app.contacts.create_contact(
jid=jid,
account=account,
resource=resource,
show=self.conn.get_status())
app.interface.new_chat(contact,
account,
resource=resource,
session=self)
negotiation.FeatureNegotiationWindow(account, str(self.jid), self,
form)
def _messageCB(self, ip, con, stanza):
"""
Called when we receive a message
"""
log.debug('Zeroconf MessageCB')
app.nec.push_incoming_event(
NetworkEvent('raw-message-received',
conn=self,
stanza=stanza,
account=self.name))
type_ = stanza.getType()
if type_ is None:
type_ = 'normal'
id_ = stanza.getID()
fjid = str(stanza.getFrom())
if fjid is None:
for key in self.connection.zeroconf.contacts:
if ip == self.connection.zeroconf.contacts[key][
Constant.ADDRESS]:
fjid = key
break
jid, resource = app.get_room_and_nick_from_fjid(fjid)
thread_id = stanza.getThread()
msgtxt = stanza.getBody()
session = self.get_or_create_session(fjid, thread_id)
if thread_id and not session.received_thread_id:
session.received_thread_id = True
session.last_receive = time.time()
event_attr = {
'conn': self,
'stanza': stanza,
'account': self.name,
'id_': id_,
'encrypted': False,
'additional_data': {},
'forwarded': False,
'sent': False,
'timestamp': time.time(),
'fjid': fjid,
'jid': jid,
'resource': resource,
'unique_id': id_,
'mtype': type_,
'msgtxt': msgtxt,
'thread_id': thread_id,
'session': session,
'self_message': False,
'muc_pm': False,
'gc_control': None
}
event = ZeroconfMessageReceivedEvent(None, **event_attr)
app.nec.push_incoming_event(event)
app.plugin_manager.extension_point('decrypt', self, event,
self._on_message_decrypted)
if not event.encrypted:
eme = parse_eme(event.stanza)
if eme is not None:
event.msgtxt = eme
self._on_message_decrypted(event)
