manager.cpp

/*
    $Id: manager_8cpp-source.html,v 1.1 2004/10/05 21:12:02 mentat Exp $

    GNU Messenger - The secure instant messenger
    Copyright (C) 1999-2003  Henrik Abelsson <henrik@abelsson.com>
    Copyright (C) 2002-2004  Jesse Lovelace <jesse at aslogicsys dot com>

    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; either version 2 of the License, or
    (at your option) any later version.

    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.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <iostream>
#include <map>

#include "gm/manager.h"
#include "gm/tocprotocol.h"
#include "gm/settings_manager.h"
#include "gm/debug.h"
#include "gm/contact_manager.h"

namespace GNUMessenger {

using namespace std;

ProtocolManager::~ProtocolManager()
{
    if (!m_shutdown)
        shutdown();
}

void ProtocolManager::shutdown() 
{
    LOG("Shutting down Protocol Manager...");
    for (map<string, Protocol *>::iterator it = m_provider.begin();
        it != m_provider.end(); it++)
    {
        if (it->second) {
            it->second->shutdown();
            delete it->second;
            it->second = 0;
        }
    }
    m_shutdown = true;
    
}

bool ProtocolManager::removeProtocol(const string &proto)
{
    LOG_DEBUG("ProtocolManager::removeProtocol:" << proto); 
    
    logout(proto);
    Protocol * myProto = protocol(proto);

    if (!myProto) {
        LOG_ERROR("Can't find protocol!");
        return false;
    }
    
    m_provider.erase(proto);

    delete myProto;

    return true;
}

bool ProtocolManager::loadProtocol(const string& name)
{
    LOG_DEBUG("ProtocolManager::loadProtocol:" << name); 
    XMLNode config;

    if (m_auth.settings().getNet("toc", config)) {
        
        new TocProtocol(config, this);

        return true;
    }
    
    LOG_ERROR("Could not find protocol settings.");

    return false;

}

bool ProtocolManager::addProtocol(Protocol *proto)
{
    LOG_DEBUG("ProtocolManager::addProtocol: " << proto->getProtocol());
    
    if (m_provider.find(proto->getProtocol()) == m_provider.end()) {
        
        LOG_DEBUG( "Adding " << proto->getProtocol() << " to protocol manager");
        m_provider[proto->getProtocol()]=proto;
        vector<Contact> contacts;
        
        LOG_DEBUG("Loading in contacts to protocol...");
        m_auth.contacts().getContactsOfProtocol(proto->getProtocol(), contacts);
        
        proto->setContacts(contacts);
        
    } else {
        LOG_ERROR("Cannot add duplicate protocols to the provider list, deleting: " << proto->getProtocol());
        
        delete proto;
        return false;
    }
    return true;

}

bool ProtocolManager::hasProtocol(const string& name)
{
    if (m_provider.find(name) != m_provider.end()) {
        return true;
    }
    return false;
}

bool ProtocolManager::changeSettings(const string& proto, XMLNode& conf)
{
    LOG_DEBUG("ProtocolManager::changeSetting: " << proto);
    
    if (m_provider.find(proto) != m_provider.end()) {
        LOG_DEBUG("Updating setings");
        m_provider[proto]->changeSettings(conf);
        return true;
    } else // add the protocol (this implies there were no settings before)!
        LOG_DEBUG("Adding new protocol (with new settings)");
        if (proto == "toc")  {
            new TocProtocol(conf, this);
            return true;
        }
#if 0
        else
            if (proto == "icq")
                new IcqProtocol(conf, this);
            else 
                if (proto == "yahoo")
                    new YahooProtocol(conf, this);
                else
                    if (proto == "msn")
                        new MsnProtocol(conf, this);
                    else 
                        if (proto == "kit")
                            new KitProtocol(conf, this);
#endif
    return false;
}

int ProtocolManager::getState(const string &proto)
{
    if (m_provider.count(proto))
        return m_provider[proto]->getState(); // needs to return
    
    return Protocol::S_invalid; 
}

vector<string> ProtocolManager::protocols() const
{
    vector<string> tmp;
    for (map<string, Protocol*>::const_iterator i=m_provider.begin();i!=m_provider.end();i++)
        tmp.push_back(i->first);

    return tmp;
}

Protocol *ProtocolManager::protocol(const string &proto)
{
    map<string, Protocol *>::iterator it = m_provider.find(proto);
    if (it != m_provider.end())
        return it->second;
    else 
        return NULL;
}

const Protocol *ProtocolManager::protocol(const string &proto) const
{
    map<string, Protocol *>::const_iterator cit = m_provider.find(proto);
    if (cit != m_provider.end())
        return cit->second;
    else 
        return NULL;
}

string ProtocolManager::screenName(const string &proto)
{
    if (m_provider.count(proto))
        return m_provider[proto]->getLoginName();
    else 
        return "";
}

bool ProtocolManager::update(const string &proto)
{
    if (m_provider.find(proto) != m_provider.end())
    {
        m_provider[proto]->update();
        return true;
    }
    return false;
}

void ProtocolManager::updateAll()
{
    LOG_DEBUG("ProtocolManager::updateAll");
    for (map<string, Protocol*>::iterator i=m_provider.begin();i!=m_provider.end();i++)
        i->second->update();
}

bool ProtocolManager::setAway(const string& proto, const string& msg)
{
    LOG_DEBUG("ProtocolManager::setAway: " << proto);
    if (m_provider.count(proto)) {
        m_provider[proto]->setAway(msg);
        return true;
    }

    return false;
}

void ProtocolManager::setAllAway(const string& msg)
{
    for (map<string, Protocol*>::iterator i=m_provider.begin();i!=m_provider.end();i++)
        i->second->setAway(msg);
}

bool ProtocolManager::setInfo(const string& proto, const string& info)
{
    if (m_provider.count(proto)) {
        m_provider[proto]->setInfo(info);
        return true;
    }
  
    return false;
}

void ProtocolManager::setAllInfo(const string& info)
{
    for (map<string, Protocol*>::iterator i=m_provider.begin();i!=m_provider.end();i++)
        i->second->setInfo(info);
}

bool ProtocolManager::login(const string &proto)
{
    LOG_DEBUG("ProtocolManager::login: " << proto);
    if (m_provider.count(proto)) {
        if (!isOnline(proto))
            m_provider[proto]->login();
        return true;
    }
    return false;
}

bool ProtocolManager::logout(const string &proto)
{
    LOG_DEBUG("ProtocolManager::logout: " << proto);
    if (m_provider.count(proto)) {
        LOG_DEBUG("Proto not found.");
        if (isOnline(proto))
            m_provider[proto]->logout();
        return true;
    }
    return false;

}

bool ProtocolManager::sendMessage(const string &proto,const Contact &recipient, const string &message)
{
    LOG_DEBUG("ProtocolManager::sendMessage");
    if (isOnline(proto)) {
        m_provider[proto]->sendMessage(recipient, message);
        return true;
    }
    LOG_DEBUG("That protocol is not online.");
    return false;
}

bool ProtocolManager::sendMessage(const string &proto,const Contact &recipient, const VBuffer& data)
{
    if (isOnline(proto)) {
        m_provider[proto]->sendMessage(recipient, data);  
        return true;
    }
    return false;
}

bool ProtocolManager::sendMessage(const Contact& c, const string& message)
{   
    LOG_DEBUG("ProtocolManager::sendMessage: " << c.getProtocol());
 
    if (c.getProtocol().length() == 0) {
        LOG_DEBUG("Cannot send, no protocol online");
        return false;
    }

    return sendMessage(c.getProtocol(), c, message);

}

bool ProtocolManager::sendMessage(const Contact& c, const VBuffer& data)
{
    LOG_DEBUG("Send message (data) with protocol " << c.getProtocol());
 
    if (c.getProtocol().length() == 0) {
        LOG_DEBUG("Cannot send, no protocol online");
        return false;
    }

    return sendMessage(c.getProtocol(), c, data);
    
}

void ProtocolManager::addContact(const Contact& c)
{
    for (map<string, Protocol*>::iterator it = m_provider.begin();
        it != m_provider.end();
        it++) {
            LOG_DEBUG("Updating " << c.name() << " in proto " << it->first);
            if (c.hasProtocol(it->first))
                (*it->second).addContact(c);
            else // if the protocol doesn't have the contact, make sure it isnt there
                (*it->second).delContact(c);
    }
}


bool ProtocolManager::delContact(const string& str, const Contact& c)
{
    LOG_ERROR("ProtocolManager::delBuddy: I dont do anything");
    return false;
}

#if 0
bool ProtocolManager::customRequest(const string &proto,const XMLNode &n)
{
    if (m_provider.count(proto)) {
        m_provider[proto]->customRequest(n);
        return true;
    }
    return false;
}
#endif

void ProtocolManager::protoGotContacts(const string& proto, const vector<buddy>& c)
{
    LOG_DEBUG("ProtocolManager::protoGotContacts: " << proto);
    c_gotContacts(proto, c);
}

void ProtocolManager::protoLoggedIn(const string& proto)
{
    LOG_DEBUG("ProtocolManager::protoLoggedIn: " << proto);

    m_online[proto] = true;

    c_loggedIn(proto);
}

void ProtocolManager::protoLoggedOut(const string& proto)
{
    LOG_DEBUG("ProtocolManager::protoLoggedOut: " << proto);

    m_online[proto] = false;

    c_loggedOut(proto);
}

void ProtocolManager::protoRecvdMessage(const string& proto, const Contact& c, const string& message)
{
    LOG_DEBUG("Received message:  from: " << c.name() << " on: " << proto);
    c_recvdMessage(proto, c, message);
}
    
void ProtocolManager::protoRecvdMessageAnony(const string& proto, const Contact& c, const string& message)
{
    LOG_DEBUG("Recieved Anonymous message from " << c.name() << " on: " << proto);
    c_recvdMessageAnony(proto, c, message);
}
    
void ProtocolManager::protoStatusChange(const string& proto, const Contact& c)
{
    LOG_DEBUG("Status change for: " << c.name());
    // need to update active list here
    c_statusChange(proto, c);
}
    
void ProtocolManager::protoError(const string& proto, int err_no, const string& error)
{
    LOG_DEBUG("Error. Protocol: " << proto << " Error: " << error);
    c_error(proto, err_no, error);
}

void ProtocolManager::protoStateChange(const string &proto, Protocol::State st)
{
    LOG_DEBUG("Protocol State Change: " << proto);
    
    switch (st) {
        case (Protocol::S_online): 
            LOG_DEBUG("Protocol Online"); break;
        case (Protocol::S_invalid): 
            LOG_DEBUG("Invalid State"); break;
        case (Protocol::S_connecting): 
            LOG_DEBUG("Protocol Connecting"); break;
        case (Protocol::S_offline): 
            LOG_DEBUG("Protocol Offline"); break;
        case (Protocol::S_disconnecting): 
            LOG_DEBUG("Protocol Disconnecting"); break;
        default: LOG_DEBUG("Unknown state");
    }
    
    c_stateChange(proto, st);
}

void ProtocolManager::protoGotPubkey(const Contact& c, const string& key)
{
    LOG_DEBUG("Got public key from: " << c.name());
    c_gotPubkey(c, key);
}
/*
void ProtocolManager::protoGotBuddy(const string& proto, const Contact& c)
{
    c_gotBuddy(proto, c);
}*/

void ProtocolManager::protoCustom(const string& proto, const XMLNode &n)
{
    LOG_DEBUG("Got custom: " << proto);
    c_custom(proto, n);
}
    
list<Network*> ProtocolManager::getNets(const string& proto)
{
    LOG_DEBUG("ProtocolManager::getNets: " << proto);
    if (m_provider.count(proto))
        return m_provider[proto]->getNetworks();

    // temp fix for "not all paths return a value
    list<Network *> dummy;
    return dummy;
}

list<Network*> ProtocolManager::getNetsAll()
{
    LOG_DEBUG("ProtocolManager::getNetsAll");
    list<Network *> tmp;
    for  (map<string, Protocol*>::iterator i = m_provider.begin();
        i != m_provider.end();
        i++)
    {
        list<Network *> nets = i->second->getNetworks();

        for (list<Network*>::iterator j = nets.begin();
            j != nets.end();
            j++) {
            tmp.push_back(*j);
        }
    }
    return tmp;
}

bool ProtocolManager::isGM(const Contact& c)
{
    return false;
}
        
void ProtocolManager::forceKeyX(const Contact& c)
{
    // this must interface ssh2 code
}
    
void ProtocolManager::changeCipher(const Contact& c, int cipherType, int keysize , int blocksize)
{
    // this must interface ssh2 code
}

void ProtocolManager::getInfo(const Contact& contact)
{
    for (map<string, Protocol*>::iterator it = m_provider.begin();
        it != m_provider.end();
        it++) {
            if (contact.hasProtocol(it->first))
                (it->second)->getInfo(contact.getServerId(it->first));
    }

}

void ProtocolManager::protoGotInfo(const Contact& c, const string& info, const string& proto)
{
    c_gotInfo(c, info, proto);
}

bool ProtocolManager::isOnline(const string& proto) const
{
    map<string, bool>::const_iterator it = m_online.find(proto);
    if (m_online.find(proto) == m_online.end()) {
        return false;
    }
    return it->second;

}

unsigned long ProtocolManager::getSentBytes(const string& proto) const
{
    const Protocol * protop = protocol(proto);
    if (protop)
        return protop->getSentBytes();
    else
        return 0;
}
unsigned long ProtocolManager::getSentPackets(const string& proto) const
{
    const Protocol * protop = protocol(proto);
    if (protop)
        return protop->getSentPackets();
    else
        return 0;
}

unsigned long ProtocolManager::getRecvBytes(const string& proto) const
{
    const Protocol * protop = protocol(proto);
    if (protop)
        return protop->getRecvBytes();
    else
        return 0;
}

unsigned long ProtocolManager::getRecvPackets(const string& proto) const
{
    const Protocol * protop = protocol(proto);
    if (protop)
        return protop->getRecvPackets();
    else
        return 0;
}

vector<string> ProtocolManager::getRemoteIPs(const string& proto) const
{
    vector<string> ips;
    const Protocol * protop = protocol(proto);
    if (protop)
        return protop->getRemoteIPs();
    else
        return ips;
}

} 
/*
    -----
    $Log: manager.cpp,v $
    Revision 1.5  2004/10/04 23:28:44  mentat
    Adding VC 2003 project file and compiles on Win32

    Revision 1.4  2004/10/04 05:14:20  mentat
    Adding info get support and HTTP.

    Revision 1.3  2004/10/03 18:39:40  mentat
    Merging in hash_map changes to TOC and getInfo methods.

    Revision 1.2.2.1  2004/10/03 18:36:03  mentat
    Added hash_map to toc protocol and working in getInfo methods.

    Revision 1.2  2004/10/03 15:22:57  mentat
    Fixed a pure virtual function error and improved TOC.

    Revision 1.1.1.1  2004/10/03 06:17:37  mentat
    Initial re-import.

*/

---