basenetwork.h

// --*-c++-*--
/*
    $Id: basenetwork_8h-source.html,v 1.1 2004/10/05 21:11:59 mentat Exp $
 
    GNU Messenger - The secure instant messenger
    Copyright (c) 1999-2002 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

*/
#ifndef GM_NETWORK_H
#define GM_NETWORK_H

#include <string>

#include "cryptopp/misc.h"

#include "gm/exception.h"
#include "gm/xmlnode.h"
#include "gm/buffer.h"

namespace GNUMessenger
{
    using namespace std;
    using namespace CryptoPP;

    class Protocol;
    class PeerProtocol;

    class Network
    {
    public:

        class NetworkError: public Exception
        {
        public:
            NetworkError(const string& error): Exception(error) {}
        };

        template <typename T>
        static T NBO(const T& in) {
#ifdef IS_LITTLE_ENDIAN
        return ByteReverse(in);
#else
        else return in;
#endif
        }


        enum Error
        {
            ERROR_NETWORK_NOERROR =  101, 
            ERROR_NETWORK_INVOP,    
            ERROR_NETWORK_IOERR,    
            ERROR_NETWORK_INVADDR,  
            ERROR_NETWORK_INVSOCK,  
            ERROR_NETWORK_NOHOST,   
            ERROR_NETWORK_INVPORT,  
            ERROR_NETWORK_WOULDBLOCK,   
            ERROR_NETWORK_TIMEDOUT, 
            ERROR_NETWORK_MEMERR,   
            ERROR_NETWORK_UNKNOWNERR,   
            ERROR_NETWORK_ALLOCERR  
        };

        enum Status {
            Connected,
            Closed,
            HostLookupFailure,
            ConnectionRefused,
            FailedRead,
            FailedWrite,
            NotConnected
        };
        
        Network(Protocol *owner);
        
        virtual void connectTo(const string& host, unsigned int port)=0;
        
        virtual string getRemoteIP()=0;

        virtual bool isConnected() =0;

        virtual unsigned long availableData() =0;

        virtual Status status() { return m_status; }

        virtual void sendData(const char *data,unsigned long len)=0;
        virtual void sendData(const string &data) { sendData(data.c_str(),(unsigned long)data.length()); }
        virtual void sendData(const XMLNode &data) { string tmp=data; sendData(tmp.c_str(),(unsigned long)tmp.length()); }
        virtual void sendData(const VBuffer& data) = 0;
        
        virtual void disconnect()=0;

        virtual void socketData(byte*& data, unsigned int& len)=0;
        virtual void socketData(string& data) = 0;
        virtual void socketData(VBuffer& data) = 0;
        
        virtual void checkForData()=0;

        virtual int getSock()=0;

        virtual void setOwner(Protocol* protocol) { m_owner=protocol; }
        
        unsigned long getSentBytes() const { return m_sentBytes; }
        unsigned long getSentPackets() const { return m_sentPackets; }
        
        unsigned long getRecvBytes() const { return m_recvBytes; }
        unsigned long getRecvPackets() const { return m_recvPackets; }
        
        virtual string getHTTP(const string& url) = 0;

    protected:
    
        unsigned long m_sentBytes;
        unsigned long m_recvBytes;
        unsigned long m_sentPackets;
        unsigned long m_recvPackets;
        
        Protocol *m_owner;
        Status m_status;
    };

    class NetworkServer
    {
    public:

        class NetworkServerError: public Exception
        {
        public:
            NetworkServerError(const string& error): Exception(error) {}
        };

        enum Status { 
            Listening, 
            NotListening, 
            Error };

        NetworkServer(PeerProtocol *owner, unsigned int port=3000): m_owner(owner), m_port(port) {}

        virtual void StartListen()=0;
        virtual void StopListen()=0;

        virtual bool isIncomming()=0;

        virtual Network * getIncomming()=0;

        virtual int getStatus() { return m_status;}

        virtual unsigned short getPort() { return m_port; }

        virtual void setOwner(PeerProtocol *protocol) { m_owner=protocol; }

    protected:

        PeerProtocol *m_owner;
        int m_status;
        unsigned int m_port;

    };

} // !GNUMessenger

#endif // !GM_NETWORK_H

---