tocprotocol.cpp

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

    GNU Messenger - The secure instant messenger

    Original TOC implementation: 
    Copyright (C) 1999-2001  Henrik Abelsson <henrik@abelsson.com>

    Re-written implementation in C++:
    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 <iomanip>
#include <string>
#include <sstream>

#include "gm/tocprotocol.h"
#include "gm/basenetwork.h"
#include "gm/protocol.h"
#include "gm/tree.h"
#include "gm/buffer.h"

#include "cryptopp/misc.h"

#define TOC_VER         1
#define TOC_TLV         1
#define UID_AIM_CHAT    "748F2420-6287-11D1-8222-444553540000"

namespace GNUMessenger {

using namespace std;
using namespace CryptoPP;

string TocProtocol::getErrorText(int i, const string& name)
{
     switch (i)
     {
         case(901): return name + string(" not currently available"); break;
         case(902): return string("Warning of ") + name + (" not currently available"); break;
         case(903): return "A message has been dropped, you are exceeding the server speed limit"; break;

         case(911): return "Error validating input"; break;
         case(912): return "Invalid account"; break;
         case(913): return "Error encountered while processing request"; break;
         case(914): return "Service unavailable"; break;
         case(950): return string("Chat in ") + name + string("is unavailable"); break;
         case(960): return string("You are sending message too fast to ") + name; break;
         case(961): return string("You missed an im from ") + name + (" because it was too big."); break;
         case(962): return string("You missed an im from ") + name + (" because it sent to fast."); break;
         case(970): return "Failure"; break;
         case(971): return "Too many matches"; break;
         case(972): return "Need more qualifiers"; break;
         case(973): return "Dir service temporarily unavailable"; break;
         case(974): return "Email lookup restricted"; break;
         case(975): return "Keyword Ignored"; break;
         case(976): return "No Keywords"; break;
         case(977): return "Language not supported"; break;
         case(978): return "Country not supported"; break;
         case(979): return string("Failure unknown ") + name; break;
         case(980): return "Incorrect nickname or password."; break;
         case(981): return "The service is temporarily unavailable."; break;
         case(982): return "Your warning level is currently too high to sign on."; break;
         case(983): return string("You have been connecting and disconnecting too frequently.  "
         "Wait 10 minutes and try again.  "
         "If you continue to try, you will need to wait even longer."); break;
         case(989): return string("An unknown signon error has occurred ") + name; break;
         default: return "An unknown error has occured."; break;
    }
}


  /*
 * General Errors *
   901   - $1 not currently available
   902   - Warning of $1 not currently available
   903   - A message has been dropped, you are exceeding
       the server speed limit

   * Admin Errors  *
   911   - Error validating input
   912   - Invalid account
   913   - Error encountered while processing request
   914   - Service unavailable

   * Chat Errors  *
   950   - Chat in $1 is unavailable.

   * IM & Info Errors *
   960   - You are sending message too fast to $1
   961   - You missed an im from $1 because it was too big.
   962   - You missed an im from $1 because it was sent too fast.

   * Dir Errors *
   970   - Failure
   971   - Too many matches
   972   - Need more qualifiers
   973   - Dir service temporarily unavailable
   974   - Email lookup restricted
   975   - Keyword Ignored
   976   - No Keywords
   977   - Language not supported
   978   - Country not supported
   979   - Failure unknown $1


   * Auth errors *
   980   - Incorrect nickname or password.
   981   - The service is temporarily unavailable.
   982   - Your warning level is currently too high to sign on.
   983   - You have been connecting and
       disconnecting too frequently.  Wait 10 minutes and try again.
       If you continue to try, you will need to wait even longer.
   989   - An unknown signon error has occurred $1
*/


class TocProtocol::FlapHeader {
public:
  
    FlapHeader() 
    { 
        m_ast = (byte)'*';
        m_type = (byte)2;
        m_seq = Network::NBO(real_seq++);
        m_len = (byte)0;
    }

    static word16 real_seq;

private:
    byte m_ast;
    word16 m_seq;

public:
    byte m_type;
    word16 m_len;

    VBuffer getHdr()
    {
        VBuffer header;

        header += m_ast;
        header += m_type;
        header += (byte) (m_seq & 0xff);
        header += (byte) ((m_seq >> 8)& 0xff);
        header += (byte) (m_len & 0xff);
        header += (byte) ((m_len >> 8)& 0xff);

        return header;
    }

};

word16 TocProtocol::FlapHeader::real_seq = 1;


string 
TocProtocol::aim_encode(const string& s)
{
    string buf;
    buf.reserve(s.length());
    for (unsigned int i = 0; i < s.length(); i++) {
        switch (s[i]) {
        case '$': case '{': case '}':
        case '[': case ']': case '(':
        case ')': case '\"': case '\\':
            buf += '\\';  buf += s[i];
            break;
        case '\n': buf += "<BR>"; break;
        default:  buf += s[i]; break;
        }
    }
    return buf;
}

string TocProtocol::aim_normalize(const string& s)
{
    string buf;
    buf.reserve(s.length());

    for (unsigned int i=0; i<s.length(); i++) {
        char c = s[i];
        if (c != ' ' && c!='\t' && c!='\n')
            buf += tolower(c);
    }
    return buf;
}

string TocProtocol::roastPassword(const VBuffer& pass)
{
    /* Trivial "encryption" */
    stringstream pword;
    pword << "0x";
    string roast("Tic/Toc");

    for (unsigned int i = 0; i < pass.size(); i++) {
        pword << hex << setfill('0') << setw(2) << (word16)(pass[i] ^ roast[i % roast.length()]);
    }

    return pword.str();
}

void TocProtocol::reset()
{
    logout();
    login();

}

void TocProtocol::send_flap(int type, const VBuffer& data)
{
    m_net->sendData(return_flap(type, data));
}

VBuffer TocProtocol::return_flap(int type, const VBuffer& data)
{
    // output buffer object
    VBuffer buffer;

    /*
    * FLAP Header (6 bytes)
    * -----------


    * Offset   Size  Type
    * 0        1     ASTERISK (literal ASCII '*')
    * 1        1     Frame Type
    * 2        2     Sequence Number
    * 4        2     Data Length
    */

    // flap header object
    FlapHeader fh;

    // set length to payload length
    word16 len = (word16)data.size();

    // set flap type
    fh.m_type = (byte)type;
    // put length in network byte order
    fh.m_len = Network::NBO(len);

    // get the header and return it to the output buffer
    buffer = fh.getHdr();

    if (len > 0)
        buffer += data;

    return buffer;
}

TocProtocol::TocProtocol(const XMLNode &n, ProtocolManager *manager):
  Protocol(n, manager, "toc"), m_realLength(0)
{
    m_away = false;
    m_net = addNet();

    LOG_DEBUG("New TocProtocol instance, initializing hashmap...");
    
    m_funcMap["UPDATE_BUDDY"] = &TocProtocol::processUpdateBuddy;
    m_funcMap["FLAP SIGNON"] = &TocProtocol::processSignon;
    m_funcMap["IM_IN"] = &TocProtocol::processIM;
    m_funcMap["SIGN_ON"] = &TocProtocol::processSignon;
    m_funcMap["CONFIG"] = &TocProtocol::processGotConfig;
    m_funcMap["NICK"] = &TocProtocol::processNick;
    m_funcMap["ERROR"] = &TocProtocol::processError;
    
}

TocProtocol::~TocProtocol()
{
    //LOG_DEBUG("Deleting TocProtocol instance");
    if (m_net)
        removeNet(m_net);
}


void TocProtocol::login() //string server, int port, string name, string pass)
{
    LOG_DEBUG("TOC: login()");
    // initiate socket connection to host
    if (!m_net)
        m_net = addNet();
    
    m_net->connectTo(m_conf.child("server").property("host"),
        m_conf.child("server").intProperty("port"));

    // fire connecting event
    eventStateChange(S_connecting);

}

void TocProtocol::shutdown() {
    m_net->disconnect();
    removeNet(m_net);
    m_net = 0;
}

void TocProtocol::logout()
{
    LOG_DEBUG("TOC: logout()");
    //shutdown();

    eventStateChange(S_offline);
    eventLoggedOut();
}

bool TocProtocol::sendMessage(const Contact &c, const string &message)
{
    LOG_DEBUG("sendMessage [" << c.getServerId(getProtocol()) << "] " << message);

    VBuffer msg;
    msg += string("toc_send_im ");
    msg += aim_normalize(c.getServerId(getProtocol()));
    msg += string(" \"");
    msg += aim_encode(message);
    msg += string("\"");
    msg += (byte)0;

    send_flap(TYPE_DATA,msg);
    return true;
}


void TocProtocol::sendMessageAuto(const Contact &c, const string &message)
{
    LOG_DEBUG("sendMessageAuto");
    VBuffer msg;
    msg += string("toc_send_im ");
    msg += aim_normalize(c.getServerId(getProtocol()));
    msg += (byte)' ';
    msg += (byte)'\"';
    msg += aim_encode(message);
    msg += string("\" \"auto\"");
    msg += (byte)0;

    send_flap(TYPE_DATA,msg);
}

void TocProtocol::addContact(const Contact &c)
{
    m_buddies[aim_normalize(c.getServerId(getProtocol()))] = c;
    
    if (getState() == S_online) {
        forceContactUpdate(c);
    } else {
        m_buddies[aim_normalize(c.getServerId(getProtocol()))].
            setStatus(getProtocol(), Contact::Offline);
    }
    
    LOG_DEBUG("TocProtocol::addContact: I am not adding to TOC");
    /*if (m_state==S_online)
        send_flap(TYPE_DATA, "toc_add_buddy " + aim_normalize(c.getServerId(getProtocol())));

    m_buddies[aim_normalize(c.getServerId(getProtocol()))] = c;
    m_buddies[aim_normalize(c.getServerId(getProtocol()))].setStatus(getProtocol(), Contact::Offline);
    eventStatusChange(c);*/
}

void TocProtocol::addBuddies()
{
    LOG_DEBUG("TocProtocol::addBuddies");
    VBuffer msg;
    msg += string("toc_add_buddy");
    
    map<string, Contact>::const_iterator it = m_buddies.begin();
    for (; it != m_buddies.end(); it++) {
        msg += string(" ");
        msg += it->first;
    }

    msg += (byte)0;
    send_flap(TYPE_DATA, msg);
}

void TocProtocol::forceContactUpdate(const Contact& c)
{
    LOG_DEBUG("TocProtocol::forceContactUpdate");
    
    VBuffer msg;
    msg += string("toc_get_status "); 
    msg += c.getServerId(getProtocol());
    msg += (byte)0;
    send_flap(TYPE_DATA, msg);
    
}

void TocProtocol::tocSendKeepalive()
{
    send_flap(TYPE_KEEPALIVE, VBuffer());
}

void TocProtocol::delContact(const Contact &c)
{
    map<string, Contact>::iterator it = m_buddies.find(
        aim_normalize(c.getServerId(getProtocol())));
        
    if (it != m_buddies.end())
        m_buddies.erase(it);
    
    LOG_DEBUG("TocProtocol::delContact: I am not removing from TOC");
}


// some kind of error occured.
void TocProtocol::connectionError(Network *net, int e)
{
    eventError(e, "A Network error occured.");

    LOG_DEBUG("TocProtocol::connectionError: Connection closed!");

    m_net->disconnect();

    eventStateChange(S_offline);
    eventLoggedOut();
}

void TocProtocol::connectedToServer(Network *net)
{
    // when socket tells that we are connected, start TOC process
    VBuffer flap("FLAPON\r\n\r\n", 10);
    m_net->sendData(flap);

    LOG_DEBUG("FLAPON");

    // update state to connecting
    eventStateChange(S_connecting);
}

void TocProtocol::signup()
{
    LOG_DEBUG("Doing FLAP SIGNON");

    string normalizedUsername(aim_normalize(m_conf.child("user").property("username")));
    word16 usernameLength = (word16)normalizedUsername.length();

    // create pre-flapon packet (same packet really)
    FlapHeader pre;
    pre.m_type = (byte)TYPE_SIGNON;
    pre.m_len = Network::NBO(word16(usernameLength + 8));

    usernameLength = Network::NBO(usernameLength);
    
    word32 ver = Network::NBO(word32(TOC_VER));
    word16 tlv = Network::NBO(word16(TOC_TLV));

    // create flapon packet
    VBuffer flapOn;
    flapOn += (byte) (ver & 0xff);
    flapOn += (byte) ((ver >> 8) & 0xff);
    flapOn += (byte) ((ver >> 16) & 0xff);
    flapOn += (byte) ((ver >> 24) & 0xff);
    flapOn += (byte) (tlv & 0xff);
    flapOn += (byte) ((tlv >> 8) & 0xff);

    flapOn += (byte) (usernameLength & 0xff);
    flapOn += (byte) ((usernameLength >> 8) & 0xff);
    
    flapOn += normalizedUsername;
    
    send_flap(TYPE_SIGNON, flapOn);

    /*
    * toc_signon <authorizer host> <authorizer port> <User Name> <Password>
    *            <language> <version>
    */

    VBuffer tocSignon;
    tocSignon += string("toc_signon ");
    tocSignon += m_conf.child("loginserver").property("host");
    tocSignon += (byte)' ';
    tocSignon += m_conf.child("loginserver").property("port");
    tocSignon += (byte)' ';
    tocSignon += normalizedUsername;
    tocSignon += (byte)' ';
    tocSignon += roastPassword(m_conf.child("user").property("password"));
    tocSignon += string(" english \"NNIM\"");
    tocSignon += (byte)0;

    send_flap(TYPE_DATA, tocSignon);
    
    eventStateChange(S_online);
}

void TocProtocol::sendCap() 
{
    VBuffer caps;
    caps += string("toc_set_caps ");
    caps += string(UID_AIM_CHAT);
    send_flap(TYPE_DATA, caps);
}

vector<string> TocProtocol::splitStr(const string& str)
{
    unsigned int i=0;
    vector<string> words;

    string tmp;
    while (i < str.length())
    {
        while(str[i]!=':' && i<str.length())
        tmp+=str[i++];
        i++;
        words.push_back(tmp);

        tmp="";
    }

    return words;

}

vector<string> TocProtocol::splitStrLF(const string& str)
{
    unsigned int i=0;
    vector<string> words;
    string tmp;

    while (i < str.length())
    {
        while(str[i]!=0xA && i<str.length())
            tmp+=str[i++];
        i++;
        words.push_back(tmp);
        tmp="";
    }
    return words;

}

void TocProtocol::handleData(Network *net)
{
    VBuffer data;
    net->socketData(data);

    if (data.size() == 0)
        return;

    handleData(net,data);

}

void TocProtocol::handleData(Network *net, const VBuffer &data)
{
    
    byte frameType = data[1];
    
    switch (frameType) {
        case (1): LOG_DEBUG("TOC: Signon Frame"); break;
        case (2): LOG_DEBUG("TOC: Data Frame"); break;
        case (5): LOG_DEBUG("TOC: Keep Alive"); return;
        default:
            LOG_ERROR("TOC: Unknown Frame Type: " << (unsigned char)data[1]);
    }

    if (m_buffer.size() != 0) { // means we have some partitial data
        VBuffer newData;
        // do concat buffer with present data

        newData += m_buffer;
        m_buffer.clear();

        newData += data;
        handleData(net, newData);
        return;
    }
    
    // extract payload length from data
    word16 payLoadLength;
    payLoadLength = (word16)data[4];
    payLoadLength |= (word16)(data[5] << 8);
    
    // convert from network byte order
    payLoadLength = Network::NBO(payLoadLength);

    // see if payload length is greater then actual payload, 
    // if so, more on the way

    LOG_DEBUG("Payload length: " << payLoadLength << " Data length: " << (unsigned int)data.size());

    if (payLoadLength > (data.size() - 6)) {
        m_buffer +=  data;
    } else {
        handleRealData(net, string((const char *)(data.data()+6), payLoadLength));
        
        // recurse if there is more than one command in data stream
        if (data.size() > (unsigned int)(payLoadLength+6)) {
            LOG_DEBUG("More than one command in data stream.");
            handleData(net, data.sub(payLoadLength + 6));
        }
    }
}

void TocProtocol::handleRealData(Network *net, const string& data)
{
    if (data.length() < 80)
        LOG_DEBUG("Got Data: " << data);
    
    string command;
    
    // if we are connecting, we should just go to signup
    // but the actual data should be the flap signon msg
    if (getState() == S_connecting) {
        signup();
        return;
    }
    
    unsigned int position((unsigned int)data.find(':', 0));
    
    command = data.substr(0, position);
    
    LOG_DEBUG(command);
    
    FuncMap::iterator it = m_funcMap.find(command);
    
    if (it == m_funcMap.end()) {
        LOG_DEBUG("TOC: Function not found in hashtable: " << command);
    } else {
        (this->*(it->second))(data);
    }
    
}

void TocProtocol::processUpdateBuddy(const string& data)
{
    LOG_DEBUG("TOC: UPDATE_BUDDY");
    vector <string> words=splitStr(data);

    string user = aim_normalize(words[1]);
    
    /* are we online? */
    bool online = (words[2] == "T") ? true : false;

    if (m_buddies.find(user) != m_buddies.end())
    {
        if (online) {
            if (words[6][2] == 'U') {
                LOG_DEBUG("Buddy is away");
                m_buddies[user].setStatus(getProtocol(), Contact::Away);
            } else {
                m_buddies[user].setStatus(getProtocol(), Contact::Online);
            }
        } else {
            m_buddies[user].setStatus(getProtocol(), Contact::Offline);
        }
        
        switch (words[6][1]) {
            case ('A'): LOG_DEBUG("Buddy is Oscar Admin"); break; // Oscar Admin
            case ('U'): LOG_DEBUG("Buddy is Oscar Unconfirmed"); break; // Oscar Unconfirmed
            case ('O'): LOG_DEBUG("Buddy is Oscar Normal"); break; // Oscar Normal
        }

        eventStatusChange(m_buddies[user]);
    }
}

void TocProtocol::processFlapSignon(const string& data)
{
    LOG_DEBUG("TocProtocol::processFlapSignon");   
    signup();
}
void TocProtocol::processSignon(const string& data)
{
    LOG_DEBUG("TocProtocol::processSignon");   
}
void TocProtocol::processGotConfig(const string& data)
{
    LOG_DEBUG("TocProtocol::processGotConfig");
    
    VBuffer setInfo("toc_set_info \"");
    setInfo += aim_encode("<html><body><b>Yes, I'm using NNIM!<br>"
        "Visit NNIM at <a href=\"http://nnim.sf.net\">http://nnim.sf.net</a>.</b>"
        "</body></html>");
        
    setInfo += '\"';
    setInfo += (byte)0;
    send_flap(TYPE_DATA, setInfo);
    
    addBuddies();

    VBuffer initDone("toc_init_done");
    initDone += (byte)0;

    send_flap(TYPE_DATA, initDone);
    
    // send capabilities
    //sendCap();

    eventStateChange(S_online);
    eventLoggedIn();

    tocParseConfig(data.substr(7,data.length()));   
}

void TocProtocol::processIM(const string& data)
{
    LOG_DEBUG("TocProtocol::processIM");
    
    vector <string> words = splitStr(data);

    string msg = words[3];
    string name = aim_normalize(words[1]);

    if (m_buddies.find(name)==m_buddies.end() || 
        (!m_buddies[words[1]].isOK())) // also see if contact is destroyed, it would be better if i was notified
    {   
        LOG_DEBUG("Anonymous user msg.");
        // if we can't find the user, we prompt for acceptance
        Contact c;
        c.addProtocol(getProtocol());
        c.setServerId(getProtocol(), words[1]);
        c.setStatus(getProtocol(), Contact::Online);
        //c.activateProtocol(getProtocol());
        c.setName(words[1]);

        eventRecvdMessageNotBuddy(c, msg);
        return;
    }

    // if we are away, respond with away message
    if (m_away)
    {
        if (m_awayMessage == "")
            sendMessageAuto(m_buddies[name], "I am away");
        else
            sendMessageAuto(m_buddies[name], m_awayMessage);
    }
    // if is auto responce maybe say so
    if (words[2] == "T")
        msg = "Auto responce: " + msg;
    
    eventRecvdMessage(m_buddies[name],msg);
    
}
void TocProtocol::processError(const string& data)
{
    LOG_DEBUG("TocProtocol::processError");
    int num;
    stringstream err;
    err << data.substr(6,data.length());
    err >> num;
    
    LOG_DEBUG("Err Num: " << num);

    eventError(E_protocol, getErrorText(num, data.substr(6, data.length())));
    LOG_ERROR(getErrorText(num, data.substr(6, data.length())));
    
    eventStateChange(S_offline);    
}

void TocProtocol::processNick(const string& data)
{
    LOG_DEBUG("TocProtocol::processNick");
    
    m_screenName = data.substr(5, data.length());    
}

void TocProtocol::update()
{

}
void TocProtocol::newUser(const string& userName, const VBuffer& password)
{

}

void TocProtocol::getPubkey()
{

}

void TocProtocol::getInfo(const string& contact)
{
    LOG_DEBUG("TocProtocol::getInfo " << aim_normalize(contact));
    
    VBuffer msg;
    msg += string("toc_get_info ");
    msg += aim_normalize(contact);
    msg += (byte)0;
    
    send_flap(TYPE_DATA, msg);
}

void TocProtocol::setAway(const string& msg)
{
    LOG_DEBUG("TocProtocol::setAway");
    if (msg.length() == 0)
    {
        m_away = false;
        m_awayMessage = "";
    } else {
        m_away = true;
        m_awayMessage = aim_encode(msg);
    }

    VBuffer setAway;
    setAway += string("toc_set_away \"");
    setAway += aim_encode(msg);
    setAway += (byte)'\"';
    setAway += (byte)0;

    send_flap(TYPE_DATA, setAway);

}

void TocProtocol::setInfo(const string& info)
{
    LOG_DEBUG("TocProtocol::setInfo");
    VBuffer tSetInfo;
    tSetInfo += string("toc_set_info \"");
    tSetInfo += aim_encode(info);
    tSetInfo += (byte)'\"';
    tSetInfo += (byte)0;
    
    send_flap(TYPE_DATA, tSetInfo);

}

void TocProtocol::tocParseConfig(const string& config)
{
    
    vector<string> myContacts = splitStrLF(config);
    LOG_DEBUG("TocProtocol::tocParseConfig: " << myContacts.size() << " contacts from server");
    
    vector<buddy> buddies;

    
    string currentGroup = "Buddies";
    
    buddy temp;
    temp.proto = getProtocol();
  
    for (unsigned int it = 0; it < myContacts.size(); it++)
    {
        if (myContacts[it][0] == 'g') { // this is a group definition
            currentGroup = myContacts[it].substr(2);
        }
        else
            if (myContacts[it][0] == 'b') {
                
                temp.name = myContacts[it].substr(2);
                temp.group = currentGroup;
                buddies.push_back(temp);
            }
    }
    
    if (buddies.size() > 0)
        eventGotContacts(buddies);

}

} 

/*
    -----
    $Log: tocprotocol.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.

    Revision 1.4  2003/04/13 18:43:58  mentat
    Heavy commits.

    Revision 1.3  2003/04/09 21:19:56  mentat
    Updating to compile.

    Revision 1.2  2003/03/25 23:33:10  mentat
    Hopefully getting things working again.

    Revision 1.1  2003/03/02 16:19:05  mentat
    Importing new sources.

    Revision 1.23  2003/01/22 19:51:35  mentat
    Large laptop checkin, most stuff won't work probably.

    Revision 1.20  2002/11/09 03:13:27  mentat
    Temp. Checkin.

    Revision 1.19  2002/11/04 21:18:35  mentat
    Fixed all those pesky leaks with scoped_arrays in Xerces code.

    Revision 1.18  2002/07/04 22:45:44  mentat
    Major changes to NNIM's contact interface and wizards.

    Revision 1.17  2002/06/30 16:53:12  mentat
    Fixed glitch in treectrl that caused assert and shaved 5 megs off of CryptoPP

    Revision 1.16  2002/06/29 16:45:06  mentat
    Added multi-protocol support to Contact and fixed AuthLoad code.

    Revision 1.15  2002/06/28 18:34:50  mentat
    SF CVS merge.

    Revision 1.11  2002/06/27 22:33:27  thementat
    Fixed TOC error and applied patch for gcc 2.95 in AuthLoad

    Revision 1.10  2002/06/27 11:52:51  thementat
    More event handling fixes.

    Revision 1.9  2002/06/26 17:40:12  thementat
    Added the Open-Source ssh2 lib from Bitvise.

    Revision 1.8  2002/06/26 04:27:08  thementat
    Event fixes.

    Revision 1.7  2002/06/25 16:48:14  thementat
    Got TOC done! (mostly)

    Revision 1.6  2002/06/25 04:46:21  thementat
    More toc work.

    Revision 1.5  2002/06/24 18:00:50  thementat
    Fixed TOC sequence bug.

    Revision 1.4  2002/06/24 12:07:40  thementat
    Toc fixes.

    Revision 1.3  2002/06/23 18:35:51  thementat
    Added vbuf class and changing all protocol to use.

    Revision 1.2  2002/06/23 14:50:01  thementat
    Work on TOC protocol and new buffer class.

    Revision 1.1.1.1  2002/06/06 17:21:50  thementat
    Checkin of new sources BETA 2

    Revision 1.13  2001/12/17 18:33:42  mentat
    Importing changes for NNIM Beta 1 client.

    Revision 1.11  2001/12/16 19:46:50  mentat
    Updates to TOC protocol and authload class.

    Revision 1.10  2001/12/13 19:01:54  mentat
    Took out some logging i added from toc, fixed a bug in toc that was
    confusing my client (and me), it was:  m_state was defined as private
    in tocprotocol.h (int) but it was also defined in the parent protocol.h, so
    when I called getState, the protocol would return the wrong one. Fixed now.

    Revision 1.9  2001/12/12 02:10:46  mentat
    Added #include <sys/time.h> to tocprotocol.cpp to resolve FreeBSD compile error, fixed small error in authload.cpp

    Revision 1.8  2001/12/08 21:45:27  mentat
    Added setAway and setAllAway to Protocol Manager along with modifying some protocol code.

    Revision 1.7  2001/12/06 04:46:40  mentat
    Added setAway() and setAllAway(...) to manager class and to toc protocol, also added changes to toc so that will log in with wx client.

    Revision 1.6  2001/11/24 00:32:44  henrik
    Addcontact dialog restructuring, chat improvements, login/logout improvements.

    Revision 1.5  2001/10/05 14:11:00  abelsson
    Added debug() macro for debug output.

    Revision 1.4  2001/10/04 16:26:37  abelsson
    Added missing protocol status callbacks.



    Revision 1.3  2001/10/02 22:51:57  estyrke
    Added some more boilerplates...

*/

---