give error messages when local message could not be sent, see #2586

src/common/xmpp/dispatcher_nb.py

@@ -398,7 +398,7 @@ class Dispatcher(PlugIn):
 			Additional callback arguments can be specified in args. '''
 		self.SendAndWaitForResponse(stanza, 0, func, args)
 	
-	def send(self, stanza):
+	def send(self, stanza, is_message = False):
 		''' Serialise stanza and put it on the wire. Assign an unique ID to it before send.
 			Returns assigned ID.'''
 		if type(stanza) in [type(''), type(u'')]: 
@@ -425,7 +425,7 @@ class Dispatcher(PlugIn):
 			stanza=route
 		stanza.setNamespace(self._owner.Namespace)
 		stanza.setParent(self._metastream)
-		self._owner.Connection.send(stanza)
+		self._owner.Connection.send(stanza, is_message)
 		return _ID
 	
 	def disconnect(self):

src/common/zeroconf/client_zeroconf.py

@@ -33,10 +33,10 @@ DATA_SENT='DATA SENT'
 TYPE_SERVER, TYPE_CLIENT = range(2)
 
 # wait XX sec to establish a connection
-CONNECT_TIMEOUT_SECONDS = 30
+CONNECT_TIMEOUT_SECONDS = 10
 
 # after XX sec with no activity, close the stream
-ACTIVITY_TIMEOUT_SECONDS = 180
+ACTIVITY_TIMEOUT_SECONDS = 30
 
 class ZeroconfListener(IdleObject):
 	def __init__(self, port, conn_holder):
@@ -68,6 +68,7 @@ class ZeroconfListener(IdleObject):
 		self.started = True
 	
 	def pollend(self):
+		#print 'pollend'
 		''' called when we stop listening on (host, port) '''
 		self.disconnect()
 	
@@ -89,13 +90,13 @@ class ZeroconfListener(IdleObject):
 		self.conn_holder.kill_all_connections()
 	
 	def accept_conn(self):
-		''' accepts a new incomming connection '''
+		''' accepts a new incoming connection '''
 		_sock  = self._serv.accept()
 		_sock[0].setblocking(False)
 		return _sock
 
 class P2PClient(IdleObject):
-	def __init__(self, _sock, host, port, conn_holder, messagequeue = [], to = None):
+	def __init__(self, _sock, host, port, conn_holder, stanzaqueue = [], to = None):
 		self._owner = self
 		self.Namespace = 'jabber:client'
 		self.defaultNamespace = self.Namespace
@@ -103,7 +104,7 @@ class P2PClient(IdleObject):
 		self._registered_name = None
 		self._caller = conn_holder.caller
 		self.conn_holder = conn_holder
-		self.messagequeue = messagequeue
+		self.stanzaqueue = stanzaqueue
 		self.to = to
 		self.Server = host
 		self.DBG = 'client'
@@ -121,28 +122,45 @@ class P2PClient(IdleObject):
 			self.sock_type = TYPE_SERVER
 		else:
 			self.sock_type = TYPE_CLIENT
-		conn = P2PConnection('', _sock, host, port, self._caller, self.on_connect)
+		conn = P2PConnection('', _sock, host, port, self._caller, self.on_connect, self)
 		self.sock_hash = conn._sock.__hash__
-		self.conn_holder.add_connection(self, self.Server, self.to)
+		self.fd = conn.fd
+		self.conn_holder.add_connection(self, self.Server, port, self.to)
+		self.conn_holder.number_of_awaiting_messages[self.fd] = len(self.stanzaqueue)
 	
-	def add_message(self, message):
+	def add_stanza(self, stanza, is_message = False):
 		if self.Connection:
 			if self.Connection.state == -1:
 				return False
-			self.send(message)
+			self.send(stanza, is_message)
 		else:
-			self.messagequeue.append(message)
+			self.stanzaqueue.append((stanza, is_message))
+
+		if is_message:
+			#print 'fd: %s' % self.fd
+			if self.conn_holder.number_of_awaiting_messages.has_key(self.fd):
+				self.conn_holder.number_of_awaiting_messages[self.fd]+=1
+			else:
+				self.conn_holder.number_of_awaiting_messages[self.fd] = 1
+		
+			#print "number_of_awaiting_messages %s" % self.conn_holder.number_of_awaiting_messages
 		return True
 	
+	def on_message_sent(self, connection_id):
+		#print 'message successfully sent'
+		#print connection_id
+		self.conn_holder.number_of_awaiting_messages[connection_id]-=1
+		#print self.conn_holder.number_of_awaiting_messages
+
 	def on_connect(self, conn):
 		self.Connection = conn
 		self.Connection.PlugIn(self)
 		dispatcher_nb.Dispatcher().PlugIn(self)
 		self._register_handlers()
 		if self.sock_type == TYPE_CLIENT:
-			while self.messagequeue:
+			while self.stanzaqueue:
-				message = self.messagequeue.pop(0)
+				stanza, is_message = self.stanzaqueue.pop(0)
-				self.send(message)
+				self.send(stanza, is_message)
 
 	def StreamInit(self):
 		''' Send an initial stream header. '''
@@ -171,13 +189,19 @@ class P2PClient(IdleObject):
 			return
 		if self.sock_type == TYPE_SERVER:
 			self.send_stream_header()
-			while self.messagequeue:
+			while self.stanzaqueue:
-				message = self.messagequeue.pop(0)
+				stanza, is_message = self.stanzaqueue.pop(0)
-				self.send(message)
+				self.send(stanza, is_message)
 
 	
 	def on_disconnect(self):
+		#print 'on_disconnect, to:%s' % self.to
 		if self.conn_holder:
+			if self.conn_holder.number_of_awaiting_messages.has_key(self.fd):
+				if self.conn_holder.number_of_awaiting_messages[self.fd] > 0:
+					self._caller.dispatch('MSGERROR',[unicode(self.to), -1, \
+					_('Connection to host could not be established'), None, None])
+				del self.conn_holder.number_of_awaiting_messages[self.fd]
 			self.conn_holder.remove_connection(self.sock_hash) 
 		if self.__dict__.has_key('Dispatcher'):
 			self.Dispatcher.PlugOut()
@@ -227,16 +251,19 @@ class P2PClient(IdleObject):
 	
 class P2PConnection(IdleObject, PlugIn):
 	''' class for sending file to socket over socks5 '''
-	def __init__(self, sock_hash, _sock, host = None, port = None, caller = None, on_connect = None):
+	def __init__(self, sock_hash, _sock, host = None, port = None, caller = None, on_connect = None, client = None):
 		IdleObject.__init__(self)
-		self._owner = None
+		self._owner = client
 		PlugIn.__init__(self)
 		self.DBG_LINE='socket'
 		self.sendqueue = []
 		self.sendbuff = None
+		self.buff_is_message = False
 		self._sock = _sock
+		self.sock_hash = None
 		self.host, self.port = host, port
 		self.on_connect = on_connect
+		self.client = client
 		self.writable = False
 		self.readable = False
 		self._exported_methods=[self.send, self.disconnect, self.onreceive]
@@ -284,26 +311,33 @@ class P2PConnection(IdleObject, PlugIn):
 		if not recv_handler(None) and _tmp == self.on_receive:
 			self.on_receive = recv_handler
 		
-	
+	def send(self, packet, is_message = False):
-	
-	def send(self, stanza):
 		'''Append stanza to the queue of messages to be send. 
 		If supplied data is unicode string, encode it to utf-8.
 		'''
 		if self.state <= 0:
 			return
-		r = stanza
+
+		r = packet
+
 		if isinstance(r, unicode): 
 			r = r.encode('utf-8')
 		elif not isinstance(r, str): 
 			r = ustr(r).encode('utf-8')
-		self.sendqueue.append(r)
+
+		self.sendqueue.append((r, is_message))
 		self._plug_idle()
 		
 	def read_timeout(self):
+		#print 'read_timeout: %s' % self.fd
+		#print self.client.conn_holder.number_of_awaiting_messages
+		if self.client.conn_holder.number_of_awaiting_messages[self.fd] > 0:
+			self.client._caller.dispatch('MSGERROR',[unicode(self.client.to), -1, \
+					_('Connection to host could not be established'), None, None])
+			#print 'error, set to zero'
+			self.client.conn_holder.number_of_awaiting_messages[self.fd] = 0 
 		self.pollend()
 
-	
 	def do_connect(self):
 		errnum = 0
 		try:
@@ -328,6 +362,7 @@ class P2PConnection(IdleObject, PlugIn):
 		if self.state == 0:
 			self.do_connect()
 			return
+		#print 'pollout:'
 		gajim.idlequeue.remove_timeout(self.fd)
 		self._do_send()
 	
@@ -391,6 +426,7 @@ class P2PConnection(IdleObject, PlugIn):
 	
 	def disconnect(self):
 		''' Closes the socket. '''
+		#print 'disconnect'
 		gajim.idlequeue.remove_timeout(self.fd)
 		gajim.idlequeue.unplug_idle(self.fd)
 		try:
@@ -408,7 +444,7 @@ class P2PConnection(IdleObject, PlugIn):
 		if not self.sendbuff:
 			if not self.sendqueue:
 				return None # nothing to send
-			self.sendbuff = self.sendqueue.pop(0)
+			self.sendbuff, self.buff_is_message = self.sendqueue.pop(0)
 			self.sent_data = self.sendbuff
 		try:
 			send_count = self._sock.send(self.sendbuff)
@@ -423,6 +459,7 @@ class P2PConnection(IdleObject, PlugIn):
 					# we are not waiting for write 
 					self._plug_idle()
 				self._on_send()
+
 		except socket.error, e:
 			sys.exc_clear()
 			if e[0] == socket.SSL_ERROR_WANT_WRITE:
@@ -451,7 +488,10 @@ class P2PConnection(IdleObject, PlugIn):
 			self.DEBUG(self.sent_data,'sent')
 			if hasattr(self._owner, 'Dispatcher'):
 				self._owner.Dispatcher.Event('', DATA_SENT, self.sent_data)
-		self.sent_data  = None
+		self.sent_data = None
+		if self.buff_is_message:
+			self._owner.on_message_sent(self.fd)
+			self.buff_is_message = False
 
 	def _on_send_failure(self):
 		self.DEBUG("Socket error while sending data",'error')
@@ -468,7 +508,9 @@ class ClientZeroconf:
 		self.connections = {}
 		self.recipient_to_hash = {}
 		self.ip_to_hash = {}
+		self.hash_to_port = {}
 		self.listener = None
+		self.number_of_awaiting_messages = {}
 
 	def test_avahi(self):
 		try:
@@ -545,11 +587,12 @@ class ClientZeroconf:
 		for connection in self.connections.values():
 			connection.force_disconnect()
 	
-	def add_connection(self, connection, ip, recipient):
+	def add_connection(self, connection, ip, port, recipient):
 		sock_hash = connection.sock_hash
 		if sock_hash not in self.connections:
 			self.connections[sock_hash] = connection
 		self.ip_to_hash[ip] = sock_hash
+		self.hash_to_port[sock_hash] = port
 		if recipient:
 			self.recipient_to_hash[recipient] = sock_hash
 		
@@ -564,6 +607,8 @@ class ClientZeroconf:
 			if self.ip_to_hash[i] == sock_hash:
 				del self.ip_to_hash[i]
 				break
+		if self.hash_to_port.has_key(sock_hash):
+			del self.hash_to_port[sock_hash]
 
 	def start_listener(self, port):
 		for p in range(port, port + 5):
@@ -579,21 +624,34 @@ class ClientZeroconf:
 			return self.roster.getRoster()
 		return {}
 
-	def send(self, msg_iq):
+	def send(self, stanza, is_message = False):
-		msg_iq.setFrom(self.roster.zeroconf.name)
+		#print 'send called, is_message = %s' % is_message
-		to = msg_iq.getTo()
+		#print stanza
-		if to in self.recipient_to_hash:
+		stanza.setFrom(self.roster.zeroconf.name)
-			conn = self.connections[self.recipient_to_hash[to]]
+		to = stanza.getTo()
-			if conn.add_message(msg_iq):
+		
-				return
 		try:
 			item = self.roster[to]
 		except KeyError:
-			#XXX invalid recipient, show some error maybe ?
+			self.caller.dispatch('MSGERROR', [unicode(to), '-1', _('Contact is offline. Your message could not be sent.'), None, None])
-			return
+			return False
-		if item['address'] in self.ip_to_hash:
-			conn = self.connections[self.ip_to_hash[item['address']]]
-			if conn.add_message(msg_iq):
-				return
-		P2PClient(None, item['address'], item['port'], self, [msg_iq], to)
 	
+		# look for hashed connections
+		if to in self.recipient_to_hash:
+			conn = self.connections[self.recipient_to_hash[to]]
+			#print 'hashed recipient: %s' % conn.sock_hash
+			if conn.add_stanza(stanza, is_message):
+				return
+
+		#print 'hash_to_port: %s' % self.hash_to_port
+		#print 'ip_to_hash: %s' % self.ip_to_hash
+		if item['address'] in self.ip_to_hash:
+			hash = self.ip_to_hash[item['address']]
+			if self.hash_to_port[hash] == item['port']:
+				#print 'hashed recipient by address: %s' % conn.sock_hash
+				conn = self.connections[hash]
+				if conn.add_stanza(stanza, is_message):
+					return
+
+		# otherwise open new connection
+		P2PClient(None, item['address'], item['port'], self, [(stanza, is_message)], to)

src/common/zeroconf/connection_zeroconf.py

@@ -302,7 +302,6 @@ class ConnectionZeroconf(ConnectionHandlersZeroconf):
 		# 'disconnect'
 		elif show == 'offline' and self.connected:
 			self.disconnect()
-			self.dispatch('STATUS', 'offline')
 			
 		# update status
 		elif show != 'offline' and self.connected:
@@ -311,6 +310,8 @@ class ConnectionZeroconf(ConnectionHandlersZeroconf):
 			if show == 'invisible':
 				check = check and self.connection.remove_announce()
 			elif was_invisible:
+				if not self.connected:
+					check = check and self.connect(show, msg)
 				check = check and self.connection.announce()
 			if self.connection and not show == 'invisible':
 				check = check and self.connection.set_show_msg(show, msg)
@@ -319,7 +320,7 @@ class ConnectionZeroconf(ConnectionHandlersZeroconf):
 		if check:
 			self.dispatch('STATUS', show)
 		else:
-			# show notification that avahi, or system bus is down	
+			# show notification that avahi or system bus is down	
 			self.dispatch('STATUS', 'offline')
 			self.status = 'offline'
 			self.dispatch('CONNECTION_LOST',
@@ -339,6 +340,10 @@ class ConnectionZeroconf(ConnectionHandlersZeroconf):
 		if not msg and chatstate is None:
 			return
 		
+		if self.status in ('invisible', 'offline'):
+			self.dispatch('MSGERROR', [unicode(jid), '-1', _('You are not connected or not visible to others. Your message could not be sent.'), None, None])
+			return
+
 		msgtxt = msg
 		msgenc = ''
 		if keyID and USE_GPG:
@@ -384,7 +389,9 @@ class ConnectionZeroconf(ConnectionHandlersZeroconf):
 				if chatstate is 'composing' or msgtxt: 
 					chatstate_node.addChild(name = 'composing') 
 		
-		self.connection.send(msg_iq)
+		if not self.connection.send(msg_iq, msg != None):
+			return
+
 		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:
@@ -402,11 +409,9 @@ class ConnectionZeroconf(ConnectionHandlersZeroconf):
 		
 	def send_stanza(self, stanza):
 		# send a stanza untouched
-		print 'connection_zeroconf.py: send_stanza'
 		if not self.connection:
 			return
-		#self.connection.send(stanza)
+		self.connection.send(stanza)
-		pass
 	
 	def ack_subscribed(self, jid):
 		gajim.log.debug('This should not happen (ack_subscribed)')