Changeset - 61e7cfaa7f98
Parent rev.
Child rev.
[Not reviewed]
0 2 0
Jan Kaluza - 10 years ago 2016-02-28 14:43:59
jkaluza@redhat.com
Libcommuni treat ERR_NICKNAME colision the same way as ERR_NICKNAMEINUSE
2 files changed with 17 insertions and 9 deletions:
backends/libcommuni/session.cpp
13
9
libtransport/Conversation.cpp
4
0 comments (0 inline, 0 general)
backends/libcommuni/session.cpp
➞
Show inline comments
 
@@ -195,48 +195,49 @@ void MyIrcSession::on_socketError(QAbstractSocket::SocketError error) {
 
		case QAbstractSocket::RemoteHostClosedError: reason = "The remote host closed the connection."; break;
 
		case QAbstractSocket::HostNotFoundError: reason = "The host address was not found."; break;
 
		case QAbstractSocket::SocketAccessError: reason = "The socket operation failed because the application lacked the required privileges."; break;
 
		case QAbstractSocket::SocketResourceError: reason = "The local system ran out of resources."; break;
 
		case QAbstractSocket::SocketTimeoutError: reason = "The socket operation timed out."; break;
 
		case QAbstractSocket::DatagramTooLargeError: reason = "The datagram was larger than the operating system's limit."; break;
 
		case QAbstractSocket::NetworkError: reason = "An error occurred with the network."; break;
 
		case QAbstractSocket::SslHandshakeFailedError: reason = "The SSL/TLS handshake failed, so the connection was closed"; break;
 
		case QAbstractSocket::UnknownSocketError: reason = "An unidentified error occurred."; break;
 
		default: reason= "Unknown error."; break;
 
	};
 

			




	
	
	
		
 
	if (!m_suffix.empty()) {

			




	
	
	
		
 
		foreach (IrcBuffer *buffer, m_bufferModel->buffers()) {

			




	
	
	
		
 
			if (!buffer->isChannel()) {

			




	
	
	
		
 
				continue;

			




	
	
	
		
 
			}

			




	
	
	
		
 
			m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), TO_UTF8(buffer->title()) + m_suffix, pbnetwork::PARTICIPANT_FLAG_ROOM_NOT_FOUND, pbnetwork::STATUS_NONE, reason);

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		m_np->handleDisconnected(m_user, 0, reason);

			




	
	
	
		
 
		m_np->tryNextServer();

			




	
	
	
		
 
	}

			




	
	
	
		
 
	LOG4CXX_INFO(logger, m_user << ": Disconnected from IRC network: " << reason);

			




	
	
	
		
 
	m_connected = false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MyIrcSession::on_disconnected() {

			




	
	
	
		
 
	if (m_suffix.empty()) {

			




	
	
	
		
 
		m_np->handleDisconnected(m_user, 0, "");

			




	
	
	
		
 
		m_np->tryNextServer();

			




	
	
	
		
 
	}

			




	
	
	
		
 
	m_connected = false;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MyIrcSession::correctNickname(std::string &nick) {

			




	
	
	
		
 
	if (nick.empty()) {

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	switch(nick.at(0)) {

			




	
	
	
		
 
		case '@':

			




	
	
	
		
 
		case '+':

			




	
	
	
		
 
		case '~':

			




	
	
	
		
 
		case '&':

			




	
	
	
		
 
		case '%':

			




	
	
	
		
 
			nick.erase(0, 1);

			




	
	
	
		
 
			break;

			




	
	
		
 
@@ -439,101 +440,104 @@ void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {

			




	
	
	
		
 
			m_topicData = TO_UTF8(parameters[2]);

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case Irc::RPL_TOPICWHOTIME:

			




	
	
	
		
 
			nick = TO_UTF8(parameters[2]);

			




	
	
	
		
 
			if (nick.find("!") != std::string::npos) {

			




	
	
	
		
 
				nick = nick.substr(0, nick.find("!"));

			




	
	
	
		
 
			}

			




	
	
	
		
 
			if (nick.find("/") != std::string::npos) {

			




	
	
	
		
 
				nick = nick.substr(0, nick.find("/"));

			




	
	
	
		
 
			}

			




	
	
	
		
 
			m_np->handleSubject(m_user, TO_UTF8(parameters[1].toLower()) + m_suffix, m_topicData, nick);

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case Irc::ERR_NOSUCHNICK:

			




	
	
	
		
 
		case Irc::ERR_NOSUCHSERVER:

			




	
	
	
		
 
			nick = TO_UTF8(parameters[1]);

			




	
	
	
		
 
			if (m_whois.find(nick) != m_whois.end()) {

			




	
	
	
		
 
				sendMessageToFrontend(m_whois[nick], "whois", nick + ": No such client");

			




	
	
	
		
 
				m_whois.erase(nick);

			




	
	
	
		
 
			}

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case Irc::ERR_ERRONEUSNICKNAME:

			




	
	
	
		
 
			m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case Irc::ERR_NICKNAMEINUSE:

			




	
	
	
		
 
		case Irc::ERR_NICKCOLLISION:

			




	
	
	
		
 
			foreach (IrcBuffer *buffer, m_bufferModel->buffers()) {

			




	
	
	
		
 
				if (!buffer->isChannel()) {

			




	
	
	
		
 
					continue;

			




	
	
	
		
 
				}

			




	
	
	
		
 
				m_np->handleRoomNicknameChanged(m_user, TO_UTF8(buffer->title()) + m_suffix, TO_UTF8(nickName() + "_"));

			




	
	
	
		
 
				m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), TO_UTF8(buffer->title()) + m_suffix, 0, pbnetwork::STATUS_ONLINE, "", TO_UTF8(nickName() + "_"));

			




	
	
	
		
 
			}

			




	
	
	
		
 
			setNickName(nickName() + "_");

			




	
	
	
		
 
			open();

			




	
	
	
		
 
// 			for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {

			




	
	
	
		
 
// 				m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), it->second->getChannel() + m_suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);

			




	
	
	
		
 
// 			}

			




	
	
	
		
 
// 			if (m_suffix.empty()) {

			




	
	
	
		
 
// 				m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname is already in use");

			




	
	
	
		
 
// 			}

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case Irc::ERR_NICKCOLLISION:

			




	
	
	
		
 
			foreach (IrcBuffer *buffer, m_bufferModel->buffers()) {

			




	
	
	
		
 
				if (!buffer->isChannel()) {

			




	
	
	
		
 
					continue;

			




	
	
	
		
 
				}

			




	
	
	
		
 
				m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), TO_UTF8(buffer->title()) + m_suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);

			




	
	
	
		
 
			}

			




	
	
	
		
 
			m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname collision KILL");

			




	
	
	
		
 
			break;

			




	
	
	
		
 
// 			foreach (IrcBuffer *buffer, m_bufferModel->buffers()) {

			




	
	
	
		
 
// 				if (!buffer->isChannel()) {

			




	
	
	
		
 
// 					continue;

			




	
	
	
		
 
// 				}

			




	
	
	
		
 
// 				m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), TO_UTF8(buffer->title()) + m_suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);

			




	
	
	
		
 
// 			}

			




	
	
	
		
 
// 			m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname collision KILL");

			




	
	
	
		
 
// 			break;

			




	
	
	
		
 
		case Irc::ERR_PASSWDMISMATCH:

			




	
	
	
		
 
			foreach (IrcBuffer *buffer, m_bufferModel->buffers()) {

			




	
	
	
		
 
				if (!buffer->isChannel()) {

			




	
	
	
		
 
					continue;

			




	
	
	
		
 
				}

			




	
	
	
		
 
				m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), TO_UTF8(buffer->title()) + m_suffix, pbnetwork::PARTICIPANT_FLAG_NOT_AUTHORIZED);

			




	
	
	
		
 
			}

			




	
	
	
		
 
			if (m_suffix.empty()) {

			




	
	
	
		
 
				m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Password incorrect");

			




	
	
	
		
 
			}

			




	
	
	
		
 
		case 321:

			




	
	
	
		
 
			m_rooms.clear();

			




	
	
	
		
 
			m_names.clear();

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case 322:

			




	
	
	
		
 
			m_rooms.push_back(TO_UTF8(parameters[1]));

			




	
	
	
		
 
			m_names.push_back(TO_UTF8(parameters[1]));

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		case 323:

			




	
	
	
		
 
			m_np->handleRoomList("", m_rooms, m_names);

			




	
	
	
		
 
			break;

			




	
	
	
		
 
		default:

			




	
	
	
		
 
			break;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (m->code() >= 400 && m->code() < 500) {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, m_user << ": Error message received: " << message->toData().data());

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, m_user << ": Numeric message received: " << message->toData().data());

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MyIrcSession::awayTimeout() {

			




	
	
	
		
 
	foreach (IrcBuffer *buffer, m_bufferModel->buffers()) {

			




	
	
	
		
 
		if (!buffer->isChannel()) {

			




	
	
	
		
 
			continue;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		QVariantMap userData = buffer->userData();

			




	
	
	
		
 
		int awayCycle = userData["awayCycle"].toInt();

			




	
	
	
		
 
		int awayTick = userData["awayTick"].toInt();

			




	
	
	
		
 

			




	
	
	
		
 
		if (awayTick == awayCycle) {

			




	
	
	
		
 
			LOG4CXX_INFO(logger, m_user << ": The time has come. Asking /who " << TO_UTF8(buffer->title()) << " again to get current away states.");

			




	
	
	
		
 
			sendCommand(IrcCommand::createWho(buffer->title()));

			




	
	
	
		
 
			awayTick = 0;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		awayTick++;

			




	
	
	
		
 

			




	
	
	
		
 
		userData["awayCycle"] = awayCycle;

			




	
	
	
		
 
		userData["awayTick"] = awayTick;

			




	
	
	
		
 
		buffer->setUserData(userData);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    libtransport/Conversation.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -302,62 +302,65 @@ Swift::Presence::ref Conversation::generatePresence(const std::string &nick, int

			




	
	
	
		
 
		}

			




	
	
	
		
 
		legacyName = Swift::JID::getEscapedNode(legacyName);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));

			




	
	
	
		
 
	presence->setType(Swift::Presence::Available);

			




	
	
	
		
 

			




	
	
	
		
 
	if (!statusMessage.empty())

			




	
	
	
		
 
		presence->setStatus(statusMessage);

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::StatusShow s((Swift::StatusShow::Type) status);

			




	
	
	
		
 

			




	
	
	
		
 
	if (s.getType() == Swift::StatusShow::None) {

			




	
	
	
		
 
		presence->setType(Swift::Presence::Unavailable);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	presence->setShow(s.getType());

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();

			




	
	
	
		
 
	if (m_nickname == nickname) {

			




	
	
	
		
 
		if (flag & PARTICIPANT_FLAG_CONFLICT) {

			




	
	
	
		
 
			delete p;

			




	
	
	
		
 
			presence->setType(Swift::Presence::Error);

			




	
	
	
		
 
			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));

			




	
	
	
		
 
			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::Conflict)));

			




	
	
	
		
 
			LOG4CXX_INFO(logger, m_jid.toString() << ": Generating error presence: PARTICIPANT_FLAG_CONFLICT");

			




	
	
	
		
 
			return presence;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (flag & PARTICIPANT_FLAG_NOT_AUTHORIZED) {

			




	
	
	
		
 
			delete p;

			




	
	
	
		
 
			presence->setType(Swift::Presence::Error);

			




	
	
	
		
 
			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));

			




	
	
	
		
 
			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::NotAuthorized, Swift::ErrorPayload::Auth, statusMessage)));

			




	
	
	
		
 
			LOG4CXX_INFO(logger, m_jid.toString() << ": Generating error presence: PARTICIPANT_FLAG_NOT_AUTHORIZED");

			




	
	
	
		
 
			return presence;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else if (flag & PARTICIPANT_FLAG_ROOM_NOT_FOUD) {

			




	
	
	
		
 
			delete p;

			




	
	
	
		
 
			presence->setType(Swift::Presence::Error);

			




	
	
	
		
 
			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));

			




	
	
	
		
 
			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::ItemNotFound, Swift::ErrorPayload::Cancel, statusMessage)));

			




	
	
	
		
 
			LOG4CXX_INFO(logger, m_jid.toString() << ": Generating error presence: PARTICIPANT_FLAG_ROOM_NOT_FOUND");

			




	
	
	
		
 
			return presence;

			




	
	
	
		
 
		}

			




	
	
	
		
 
		else {

			




	
	
	
		
 
			Swift::MUCUserPayload::StatusCode c;

			




	
	
	
		
 
			c.code = 110;

			




	
	
	
		
 
			p->addStatusCode(c);

			




	
	
	
		
 
			if (m_nicknameChanged) {

			




	
	
	
		
 
				Swift::MUCUserPayload::StatusCode c;

			




	
	
	
		
 
				c.code = 210;

			




	
	
	
		
 
				p->addStatusCode(c);

			




	
	
	
		
 
				m_nicknameChanged = false;

			




	
	
	
		
 
			}

			




	
	
	
		
 
			m_sentInitialPresence = true;

			




	
	
	
		
 
		}

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
	Swift::MUCItem item;

			




	
	
	
		
 
	

			




	
	
	
		
 
	item.affiliation = Swift::MUCOccupant::Member;

			




	
	
	
		
 
	item.role = Swift::MUCOccupant::Participant;

			




	
	
	
		
 

			




	
	
	
		
 
	if (flag & PARTICIPANT_FLAG_MODERATOR) {

			




	
	
	
		
 
		item.affiliation = Swift::MUCOccupant::Admin;

			




	
	
		
 
@@ -411,29 +414,30 @@ void Conversation::handleParticipantChanged(const std::string &nick, Conversatio

			




	
	
	
		
 
		m_participants.erase(nick);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	else {

			




	
	
	
		
 
		m_participants[nick].presence = presence;

			




	
	
	
		
 
		m_participants[nick].alias = alias;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	BOOST_FOREACH(const Swift::JID &jid, m_jids) {

			




	
	
	
		
 
		presence->setTo(jid);

			




	
	
	
		
 
		m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);

			




	
	
	
		
 
	}

			




	
	
	
		
 
	if (!newname.empty()) {

			




	
	
	
		
 
		handleParticipantChanged(newname, flag, status, statusMessage, "", iconhash);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (m_sentInitialPresence && !m_sentInitialSubject && m_subject) {

			




	
	
	
		
 
		m_sentInitialSubject = true;

			




	
	
	
		
 
		m_conversationManager->getComponent()->getFrontend()->sendMessage(m_subject);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// We send error presences only to inform user that he is disconnected

			




	
	
	
		
 
	// from the room. This code must be extended in case we start sending error

			




	
	
	
		
 
	// presences in other situations.

			




	
	
	
		
 
	if (presence->getType() == Swift::Presence::Error) {

			




	
	
	
		
 
		LOG4CXX_INFO(logger, m_jid.toString() << ": Leaving the conversation " << m_legacyName << " because of error.");

			




	
	
	
		
 
		m_conversationManager->getUser()->leaveRoom(m_legacyName);

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: srv01-1135
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support