connection_zeroconf.py 18.9 KB
Newer Older
1
##	common/zeroconf/connection_zeroconf.py
sb's avatar
sb committed
2 3 4 5 6 7
##
## Contributors for this file:
##	- Yann Le Boulanger <asterix@lagaule.org>
##	- Nikos Kouremenos <nkour@jabber.org>
##	- Dimitur Kirov <dkirov@gmail.com>
##	- Travis Shirk <travis@pobox.com>
8
##  - Stefan Bethge <stefan@lanpartei.de>
sb's avatar
sb committed
9 10 11
##
## Copyright (C) 2003-2004 Yann Le Boulanger <asterix@lagaule.org>
##                         Vincent Hanquez <tab@snarc.org>
12
## Copyright (C) 2006 Yann Le Boulanger <asterix@lagaule.org>
sb's avatar
sb committed
13 14 15 16 17
##                    Vincent Hanquez <tab@snarc.org>
##                    Nikos Kouremenos <nkour@jabber.org>
##                    Dimitur Kirov <dkirov@gmail.com>
##                    Travis Shirk <travis@pobox.com>
##                    Norman Rasmussen <norman@rasmussen.co.za>
18
##                    Stefan Bethge <stefan@lanpartei.de>
sb's avatar
sb committed
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published
## by the Free Software Foundation; version 2 only.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##


import os
import random
random.seed()

import signal
if os.name != 'nt':
	signal.signal(signal.SIGPIPE, signal.SIG_DFL)
38
import getpass
sb's avatar
sb committed
39
import gobject
40
import notify
sb's avatar
sb committed
41

sb's avatar
sb committed
42 43 44
from common import helpers
from common import gajim
from common import GnuPG
sb's avatar
sb committed
45 46 47
from common.zeroconf import zeroconf
from common.zeroconf import connection_handlers_zeroconf
from common.zeroconf import client_zeroconf
sb's avatar
sb committed
48
from connection_handlers_zeroconf import *
49

sb's avatar
sb committed
50 51 52 53 54 55
USE_GPG = GnuPG.USE_GPG

class ConnectionZeroconf(ConnectionHandlersZeroconf):
	'''Connection class'''
	def __init__(self, name):
		ConnectionHandlersZeroconf.__init__(self)
56 57
		# system username
		self.username = None
sb's avatar
sb committed
58 59
		self.name = name
		self.connected = 0 # offline
sb's avatar
sb committed
60
		self.connection = None
sb's avatar
sb committed
61
		self.gpg = None
62
		self.is_zeroconf = True
63
		self.privacy_rules_supported = False
sb's avatar
sb committed
64 65
		self.status = ''
		self.old_show = ''
sb's avatar
sb committed
66 67 68 69 70
	
		self.call_resolve_timeout = False
		
		#self.time_to_reconnect = None
		#self.new_account_info = None
71
		self.bookmarks = []
sb's avatar
sb committed
72

73
		#we don't need a password, but must be non-empty
74
		self.password = 'zeroconf'
75

76 77 78 79 80
		#XXX use that somewhere
		self.autoconnect = False
		self.sync_with_global_status = True
		self.no_log_for = False

sb's avatar
sb committed
81 82 83 84 85 86 87 88 89 90 91 92
		# Do we continue connection when we get roster (send presence,get vcard...)
		self.continue_connect_info = None
		if USE_GPG:
			self.gpg = GnuPG.GnuPG()
			gajim.config.set('usegpg', True)
		else:
			gajim.config.set('usegpg', False)
		
		self.on_connect_success = None
		self.on_connect_failure = None
		self.retrycount = 0
		self.jids_for_auto_auth = [] # list of jid to auto-authorize
93
		self.get_config_values_or_default()
94
		self.zeroconf = zeroconf.Zeroconf(self._on_new_service,
95 96
			self._on_remove_service, self._on_name_conflictCB, 
			self._on_disconnected, self.username, self.host, self.port)
97 98
		self.muc_jid = {} # jid of muc server for each transport type
		self.vcard_supported = False
99

100 101 102 103 104
	def _on_name_conflictCB(self, alt_name):
		self.disconnect()
		self.dispatch('STATUS', 'offline')
		self.dispatch('ZC_NAME_CONFLICT', alt_name)

105 106 107
	def get_config_values_or_default(self):
		''' get name, host, port from config, or 
		create zeroconf account with default values'''
108

109 110
		if not self.username:
			self.username = unicode(getpass.getuser())
111
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'name', self.username)
112
		else:
113 114 115
			self.username = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'name')

		if not gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'name'):
116
			print 'Creating zeroconf account'
117 118 119 120 121 122
			gajim.config.add_per('accounts', gajim.ZEROCONF_ACC_NAME)
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'autoconnect', True)
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'no_log_for', '')
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'password', 'zeroconf')
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'sync_with_global_status', True)

123
			#XXX make sure host is US-ASCII
124
			self.host = unicode(socket.gethostname())
125
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'hostname', self.host)
126
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'custom_port', 5298)
127
			gajim.config.set_per('accounts', gajim.ZEROCONF_ACC_NAME, 'is_zeroconf', True)
128 129 130 131 132 133 134 135 136
		self.host = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'hostname')
		self.port = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'custom_port')
		self.autoconnect = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'autoconnect')
		self.sync_with_global_status = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'sync_with_global_status')
		self.no_log_for = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'no_log_for')
		self.first = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_first_name')
		self.last = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_last_name')
		self.jabber_id = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_jabber_id')
		self.email = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_email')
sb's avatar
sb committed
137
	# END __init__
138

sb's avatar
sb committed
139 140 141 142 143 144 145 146 147 148
	def put_event(self, ev):
		if gajim.handlers.has_key(ev[0]):
			gajim.handlers[ev[0]](self.name, ev[1])

	def dispatch(self, event, data):
		'''always passes account name as first param'''
		self.put_event((event, data))

	def _reconnect(self):
		gajim.log.debug('reconnect')
149

150
		signed = self.get_signed_msg(self.status)
sb's avatar
sb committed
151 152
			
	def quit(self, kill_core):
153
	
sb's avatar
sb committed
154
		if kill_core and self.connected > 1:
sb's avatar
sb committed
155
			self.disconnect()
sb's avatar
sb committed
156
	
sb's avatar
sb committed
157 158 159
	def disable_account(self):
		self.disconnect()

sb's avatar
sb committed
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
	def test_gpg_passphrase(self, password):
		self.gpg.passphrase = password
		keyID = gajim.config.get_per('accounts', self.name, 'keyid')
		signed = self.gpg.sign('test', keyID)
		self.gpg.password = None
		return signed != 'BAD_PASSPHRASE'

	def get_signed_msg(self, msg):
		signed = ''
		keyID = gajim.config.get_per('accounts', self.name, 'keyid')
		if keyID and USE_GPG:
			use_gpg_agent = gajim.config.get('use_gpg_agent')
			if self.connected < 2 and self.gpg.passphrase is None and \
				not use_gpg_agent:
				# We didn't set a passphrase
				self.dispatch('ERROR', (_('OpenPGP passphrase was not given'),
					#%s is the account name here
					_('You will be connected to %s without OpenPGP.') % self.name))
			elif self.gpg.passphrase is not None or use_gpg_agent:
				signed = self.gpg.sign(msg, keyID)
				if signed == 'BAD_PASSPHRASE':
					signed = ''
					if self.connected < 2:
						self.dispatch('BAD_PASSPHRASE', ())
		return signed
185

sb's avatar
sb committed
186 187 188
	def _on_resolve_timeout(self):
		if self.connected:
			self.zeroconf.resolve_all()
189 190
			diffs = self.roster.getDiffs()
			for key in diffs:
191
				self.roster.setItem(key)
sb's avatar
sb committed
192
				self.dispatch('ROSTER_INFO', (key, self.roster.getName(key), 'both', 'no', self.roster.getGroups(key)))
193
				self.dispatch('NOTIFY', (key, self.roster.getStatus(key), self.roster.getMessage(key), 'local', 0, None, 0))
sb's avatar
sb committed
194
				#XXX open chat windows don't get refreshed (full name), add that
sb's avatar
sb committed
195 196 197
		return self.call_resolve_timeout

	# callbacks called from zeroconf	
198
	def _on_new_service(self,jid):
199
		self.roster.setItem(jid)
200 201
		self.dispatch('ROSTER_INFO', (jid, self.roster.getName(jid), 'both', 'no', self.roster.getGroups(jid)))
		self.dispatch('NOTIFY', (jid, self.roster.getStatus(jid), self.roster.getMessage(jid), 'local', 0, None, 0))
202
	
203
	def _on_remove_service(self, jid):
204
		self.roster.delItem(jid)
sb's avatar
sb committed
205 206
		# 'NOTIFY' (account, (jid, status, status message, resource, priority,
		# keyID, timestamp))
207
		self.dispatch('NOTIFY', (jid, 'offline', '', 'local', 0, None, 0))
sb's avatar
sb committed
208

209 210 211 212 213 214 215 216
	def _on_disconnected(self):
		self.disconnect()
		self.dispatch('STATUS', 'offline')
		self.dispatch('CONNECTION_LOST',
			(_('Connection with account "%s" has been lost') % self.name,
			_('To continue sending and receiving messages, you will need to reconnect.')))
		self.status = 'offline'

217 218 219 220 221 222 223 224 225 226 227 228
	def connect(self, data = None, show = 'online', msg = ''):
		self.get_config_values_or_default()

		self.zeroconf.txt['status'] = show
		self.zeroconf.txt['msg'] = msg
		self.zeroconf.txt['1st'] = self.first
		self.zeroconf.txt['last'] = self.last
		self.zeroconf.txt['jid'] = self.jabber_id
		self.zeroconf.txt['email'] = self.email
		self.zeroconf.username = self.username
		self.zeroconf.host = self.host
		self.zeroconf.port = self.port
229

230
		if self.zeroconf.connect():
231 232 233 234
			if not self.connection:
				self.connection = client_zeroconf.ClientZeroconf(self.zeroconf, self)
			else:
				self.zeroconf.announce()
235 236 237 238 239
			self.roster = self.connection.getRoster()
			self.dispatch('ROSTER', self.roster)

			#display contacts already detected and resolved
			for jid in self.roster.keys():
240 241
				self.dispatch('ROSTER_INFO', (jid, self.roster.getName(jid), 'both', 'no', self.roster.getGroups(jid)))
				self.dispatch('NOTIFY', (jid, self.roster.getStatus(jid), self.roster.getMessage(jid), 'local', 0, None, 0))
242 243 244

			self.connected = STATUS_LIST.index(show)

sb's avatar
sb committed
245
			# refresh all contacts data every five seconds
246
			self.call_resolve_timeout = True
sb's avatar
sb committed
247
			gobject.timeout_add(5000, self._on_resolve_timeout)
248
		else:
249 250
			self.dispatch('STATUS', 'offline')
			self.status = 'offline'
251 252 253 254 255

	def disconnect(self, on_purpose = False):
		self.connected = 0
		self.time_to_reconnect = None
		if self.connection:
dkirov's avatar
dkirov committed
256 257
			if self.connection.listener:
				self.connection.listener.disconnect()
258 259 260 261 262
			self.connection = None
			# stop calling the timeout
			self.call_resolve_timeout = False
			self.zeroconf.disconnect()

263
	def reconnect(self, new_port):
264 265 266 267 268 269 270 271 272 273 274 275 276 277
		txt = {}
		txt['1st'] = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_first_name')
		txt['last'] = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_last_name')
		txt['jid'] = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_jabber_id')
		txt['email'] = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'zeroconf_email')

		port = gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'custom_port')

		if new_port or use_tls:
			self.connection.kill_all_connections()
			self.connection.listener.disconnect()
			self.connection.start_listener(port)

		self.zeroconf.remove_announce()
278
		self.zeroconf.txt = txt
279
		self.zeroconf.port = port
280
		self.zeroconf.username = self.username
281
		self.zeroconf.announce()
282

sb's avatar
sb committed
283 284 285
	def change_status(self, show, msg, sync = False, auto = False):
		if not show in STATUS_LIST:
			return -1
286
		self.status = show
287

288 289
		check = True		#to check for errors from zeroconf

290
		# 'connect'
sb's avatar
sb committed
291
		if show != 'offline' and not self.connected:
292
			self.connect(None, show, msg)
293
			if show != 'invisible':
294
					check = self.zeroconf.announce()
295 296
			else:
					self.connected = STATUS_LIST.index(show)
sb's avatar
sb committed
297

298
		# 'disconnect'
sb's avatar
sb committed
299
		elif show == 'offline' and self.connected:
300
			self.disconnect()
301
			self.dispatch('STATUS', 'offline')
302
			
303
		# update status
sb's avatar
sb committed
304 305 306 307
		elif show != 'offline' and self.connected:
			was_invisible = self.connected == STATUS_LIST.index('invisible')
			self.connected = STATUS_LIST.index(show)
			if show == 'invisible':
308 309 310 311
				check = check and self.zeroconf.remove_announce()
			elif was_invisible:
				check = check and self.zeroconf.announce()
			if self.connection and not show == 'invisible':
312 313
				txt = {}
				txt['status'] = show
314
				txt['msg'] = msg
315 316
				check = check and self.zeroconf.update_txt(txt)

317
		#stay offline when zeroconf does something wrong
318 319 320
		if check:
			self.dispatch('STATUS', show)
		else:
321
			# show notification that avahi, or system bus is down	
322
			self.dispatch('STATUS', 'offline')
323
			self.status = 'offline'
324 325 326 327
			self.dispatch('CONNECTION_LOST',
				(_('Could not change status of account "%s"') % self.name,
				_('Please check if avahi-daemon is running.')))
			
sb's avatar
sb committed
328 329 330 331
	def get_status(self):
		return STATUS_LIST[self.connected]

	def send_message(self, jid, msg, keyID, type = 'chat', subject='',
332 333
	chatstate = None, msg_id = None, composing_jep = None, resource = None, 
	user_nick = None):
334 335
		fjid = jid

sb's avatar
sb committed
336 337 338 339
		if not self.connection:
			return
		if not msg and chatstate is None:
			return
340
		
sb's avatar
sb committed
341 342 343 344 345 346 347 348 349 350 351
		msgtxt = msg
		msgenc = ''
		if keyID and USE_GPG:
			#encrypt
			msgenc = self.gpg.encrypt(msg, [keyID])
			if msgenc:
				msgtxt = '[This message is encrypted]'
				lang = os.getenv('LANG')
				if lang is not None or lang != 'en': # we're not english
					msgtxt = _('[This message is encrypted]') +\
						' ([This message is encrypted])' # one  in locale and one en
352 353

		
sb's avatar
sb committed
354 355
		if type == 'chat':
			msg_iq = common.xmpp.Message(to = fjid, body = msgtxt, typ = type)
356
			
sb's avatar
sb committed
357 358 359 360 361 362 363
		else:
			if subject:
				msg_iq = common.xmpp.Message(to = fjid, body = msgtxt,
					typ = 'normal', subject = subject)
			else:
				msg_iq = common.xmpp.Message(to = fjid, body = msgtxt,
					typ = 'normal')
364

sb's avatar
sb committed
365 366
		if msgenc:
			msg_iq.setTag(common.xmpp.NS_ENCRYPTED + ' x').setData(msgenc)
367
		
sb's avatar
sb committed
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
		# chatstates - if peer supports jep85 or jep22, send chatstates
		# please note that the only valid tag inside a message containing a <body>
		# tag is the active event
		if chatstate is not None:
			if composing_jep == 'JEP-0085' or not composing_jep:
				# JEP-0085
				msg_iq.setTag(chatstate, namespace = common.xmpp.NS_CHATSTATES)
			if composing_jep == 'JEP-0022' or not composing_jep:
				# JEP-0022
				chatstate_node = msg_iq.setTag('x', namespace = common.xmpp.NS_EVENT)
				if not msgtxt: # when no <body>, add <id>
					if not msg_id: # avoid putting 'None' in <id> tag
						msg_id = ''
					chatstate_node.setTagData('id', msg_id)
				# when msgtxt, requests JEP-0022 composing notification
				if chatstate is 'composing' or msgtxt: 
					chatstate_node.addChild(name = 'composing') 
385 386
		
		self.connection.send(msg_iq)
sb's avatar
sb committed
387 388 389 390 391 392 393 394 395 396 397 398
		no_log_for = gajim.config.get_per('accounts', self.name, 'no_log_for')
		ji = gajim.get_jid_without_resource(jid)
		if self.name not in no_log_for and ji not in no_log_for:
			log_msg = msg
			if subject:
				log_msg = _('Subject: %s\n%s') % (subject, msg)
			if log_msg:
				if type == 'chat':
					kind = 'chat_msg_sent'
				else:
					kind = 'single_msg_sent'
				gajim.logger.write(kind, jid, log_msg)
399
		
sb's avatar
sb committed
400
		self.dispatch('MSGSENT', (jid, msg, keyID))
401
		
sb's avatar
sb committed
402
	def send_stanza(self, stanza):
403
		# send a stanza untouched
404
		print 'connection_zeroconf.py: send_stanza'
sb's avatar
sb committed
405 406
		if not self.connection:
			return
407
		#self.connection.send(stanza)
408
		pass
sb's avatar
sb committed
409 410
	
	def ack_subscribed(self, jid):
411
		gajim.log.debug('This should not happen (ack_subscribed)')
sb's avatar
sb committed
412 413

	def ack_unsubscribed(self, jid):
414
		gajim.log.debug('This should not happen (ack_unsubscribed)')
sb's avatar
sb committed
415 416 417

	def request_subscription(self, jid, msg = '', name = '', groups = [],
	auto_auth = False):
418
		gajim.log.debug('This should not happen (request_subscription)')
sb's avatar
sb committed
419 420

	def send_authorization(self, jid):
421
		gajim.log.debug('This should not happen (send_authorization)')
sb's avatar
sb committed
422 423

	def refuse_authorization(self, jid):
424
		gajim.log.debug('This should not happen (refuse_authorization)')
sb's avatar
sb committed
425 426

	def unsubscribe(self, jid, remove_auth = True):
427
		gajim.log.debug('This should not happen (unsubscribe)')
sb's avatar
sb committed
428 429

	def unsubscribe_agent(self, agent):
430
		gajim.log.debug('This should not happen (unsubscribe_agent)')
sb's avatar
sb committed
431

432
	def update_contact(self, jid, name, groups):	
sb's avatar
sb committed
433 434 435 436 437
		if self.connection:
			self.connection.getRoster().setItem(jid = jid, name = name,
				groups = groups)
	
	def new_account(self, name, config, sync = False):
438
		gajim.log.debug('This should not happen (new_account)')
sb's avatar
sb committed
439 440

	def _on_new_account(self, con = None, con_type = None):
441
		gajim.log.debug('This should not happen (_on_new_account)')
sb's avatar
sb committed
442 443 444 445 446

	def account_changed(self, new_name):
		self.name = new_name

	def request_last_status_time(self, jid, resource):
447 448
		gajim.log.debug('This should not happen (request_last_status_time)')
		
sb's avatar
sb committed
449
	def request_os_info(self, jid, resource):
450
		'''
sb's avatar
sb committed
451 452 453 454 455 456 457 458
		if not self.connection:
			return
		to_whom_jid = jid
		if resource:
			to_whom_jid += '/' + resource
		iq = common.xmpp.Iq(to = to_whom_jid, typ = 'get', queryNS =\
			common.xmpp.NS_VERSION)
		self.connection.send(iq)
459 460
		'''
		pass
sb's avatar
sb committed
461 462

	def get_settings(self):
463
		gajim.log.debug('This should not happen (get_settings)')
sb's avatar
sb committed
464 465

	def get_bookmarks(self):
466
		gajim.log.debug('This should not happen (get_bookmarks)')
467
		
sb's avatar
sb committed
468
	def store_bookmarks(self):
469
		gajim.log.debug('This should not happen (store_bookmarks)')
470
		
sb's avatar
sb committed
471
	def get_metacontacts(self):
472
		gajim.log.debug('This should not happen (get_metacontacts)')
473
		
sb's avatar
sb committed
474
	def send_agent_status(self, agent, ptype):
475
		gajim.log.debug('This should not happen (send_agent_status)')
sb's avatar
sb committed
476 477

	def join_gc(self, nick, room, server, password):
478
		gajim.log.debug('This should not happen (join_gc)')
479
		
sb's avatar
sb committed
480
	def send_gc_message(self, jid, msg):
481
		gajim.log.debug('This should not happen (send_gc_message)')
482
		
sb's avatar
sb committed
483
	def send_gc_subject(self, jid, subject):
484
		gajim.log.debug('This should not happen (send_gc_subject)')
485
		
sb's avatar
sb committed
486
	def request_gc_config(self, room_jid):
487
		gajim.log.debug('This should not happen (request_gc_config)')
488
		
sb's avatar
sb committed
489
	def change_gc_nick(self, room_jid, nick):
490
		gajim.log.debug('This should not happen (change_gc_nick)')
491
		
sb's avatar
sb committed
492
	def send_gc_status(self, nick, jid, show, status):
493
		gajim.log.debug('This should not happen (send_gc_status)')
494
		
sb's avatar
sb committed
495
	def gc_set_role(self, room_jid, nick, role, reason = ''):
496
		gajim.log.debug('This should not happen (gc_set_role)')
497
		
sb's avatar
sb committed
498
	def gc_set_affiliation(self, room_jid, jid, affiliation, reason = ''):
499
		gajim.log.debug('This should not happen (gc_set_affiliation)')
500
		
sb's avatar
sb committed
501
	def send_gc_affiliation_list(self, room_jid, list):
502
		gajim.log.debug('This should not happen (send_gc_affiliation_list)')
503
		
sb's avatar
sb committed
504
	def get_affiliation_list(self, room_jid, affiliation):
505
		gajim.log.debug('This should not happen (get_affiliation_list)')
506
		
sb's avatar
sb committed
507
	def send_gc_config(self, room_jid, config):
508
		gajim.log.debug('This should not happen (send_gc_config)')
509
		
sb's avatar
sb committed
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
	def gpg_passphrase(self, passphrase):
		if USE_GPG:
			use_gpg_agent = gajim.config.get('use_gpg_agent')
			if use_gpg_agent:
				self.gpg.passphrase = None
			else:
				self.gpg.passphrase = passphrase

	def ask_gpg_keys(self):
		if USE_GPG:
			keys = self.gpg.get_keys()
			return keys
		return None

	def ask_gpg_secrete_keys(self):
		if USE_GPG:
			keys = self.gpg.get_secret_keys()
			return keys
		return None

	def change_password(self, password):
		if not self.connection:
			return
533
		'''
sb's avatar
sb committed
534 535 536 537 538 539 540
		hostname = gajim.config.get_per('accounts', self.name, 'hostname')
		username = gajim.config.get_per('accounts', self.name, 'name')
		iq = common.xmpp.Iq(typ = 'set', to = hostname)
		q = iq.setTag(common.xmpp.NS_REGISTER + ' query')
		q.setTagData('username',username)
		q.setTagData('password',password)
		self.connection.send(iq)
541 542 543
		'''
		pass
		
sb's avatar
sb committed
544
	def unregister_account(self, on_remove_success):
545
		gajim.log.debug('This should not happen (unregister_account)')
546
		
sb's avatar
sb committed
547
	def send_invite(self, room, to, reason=''):
548
		gajim.log.debug('This should not happen (send_invite)')
549
		
sb's avatar
sb committed
550 551
	def send_keepalive(self):
		# nothing received for the last foo seconds (60 secs by default)
552
		pass
553
		
554 555 556 557 558 559 560
	def _event_dispatcher(self, realm, event, data):
		if realm == '':
			if event == common.xmpp.transports.DATA_RECEIVED:
				self.dispatch('STANZA_ARRIVED', unicode(data, errors = 'ignore'))
			elif event == common.xmpp.transports.DATA_SENT:
				self.dispatch('STANZA_SENT', unicode(data))

561
# END ConnectionZeroconf