netflow.h

/*
 *  Copyright (c) 2002-2003    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */
 
#ifndef __INCLUDED_SCOPIRA_TOOL_NETFLOW_H__
#define __INCLUDED_SCOPIRA_TOOL_NETFLOW_H__

#include <list>

#include <scopira/tool/export.h>
#include <scopira/tool/array.h>
#include <scopira/tool/flow.h>
#include <scopira/tool/platform.h>

namespace scopira
{
  namespace tool
  {
#ifdef PLATFORM_win32
    typedef SOCKET socket_handle_t;
#else
    typedef int socket_handle_t;
#endif

    class netaddr;
    class nethostrec;

    class netflow;  // TCP
    class udpflow;

    class unixflow;

    class net_loop;
    
    SCOPIRA_EXPORT std::string get_hostname(void);
    SCOPIRA_EXPORT bool hostname_to_hostrec(const std::string& hname, nethostrec& rec);
  }
}

// win32 implementation notice:
// users dont link to the winsock lib, so DONT
// inline any winsock calls
 
class scopira::tool::netaddr : public scopira::tool::fixed_array<unsigned char,4>
{
  public:
    SCOPIRA_EXPORT netaddr(void);
    SCOPIRA_EXPORT netaddr(int _ip0, int _ip1, int _ip2, int _ip3);

    static netaddr zero(void) { return netaddr(0, 0, 0, 0); }
    static netaddr any(void) { return zero(); }
    static netaddr broadcast(void) { return netaddr(255, 255, 255, 255); }
    static netaddr localhost(void) { return netaddr(); }

    SCOPIRA_EXPORT std::string as_string(void) const;
    SCOPIRA_EXPORT bool parse_string(const std::string &s);
};

SCOPIRA_EXPORT scopira::tool::oflow_i& operator <<(scopira::tool::oflow_i& o, const scopira::tool::netaddr &addr);

class scopira::tool::nethostrec : public virtual scopira::tool::object
{
  public: // all public, like a struct

    typedef std::list < std::string > strlist_t;
    typedef std::list < netaddr > addrlist_t;

    std::string name;
    strlist_t aliases;    // list of <stringobj>
    int addrlen;        // length of an address
    addrlist_t addrlist;   // list of <netaddr>

  public:
    SCOPIRA_EXPORT nethostrec(void);
    SCOPIRA_EXPORT virtual ~nethostrec(void);

    SCOPIRA_EXPORT void clear(void);

    SCOPIRA_EXPORT const netaddr & get_addr(void) const;
};

SCOPIRA_EXPORT scopira::tool::oflow_i& operator <<(scopira::tool::oflow_i& o, const scopira::tool::nethostrec &recs);

class scopira::tool::netflow : public scopira::tool::iflow_i, public scopira::tool::oflow_i
{
  public:
    enum {
      tcp_nodelay_c = 1,
    };
  private:    // typedef socket handles to a common name
    socket_handle_t dm_sock;

    bool dm_open;
    bool dm_fail;
    bool dm_sfail;
    bool dm_server;
    int dm_port;
    netaddr dm_addr;

  public:
    SCOPIRA_EXPORT netflow(void);
    SCOPIRA_EXPORT netflow(const netaddr * _addr, int _port, int socket_options = 0);
    SCOPIRA_EXPORT virtual ~netflow();

    SCOPIRA_EXPORT virtual bool failed(void) const;

    SCOPIRA_EXPORT virtual size_t read(byte_t* _buf, size_t _maxsize);
    SCOPIRA_EXPORT virtual size_t write(const byte_t* _buf, size_t _size);

    SCOPIRA_EXPORT size_t read_short(byte_t* _buf, size_t _maxsize);

    SCOPIRA_EXPORT void open(const netaddr * _addr, int _port, int socket_options = 0);
    SCOPIRA_EXPORT void close(void);

    SCOPIRA_EXPORT bool accept(netflow& nconn);

    SCOPIRA_EXPORT bool read_ready(int msec);

    const netaddr& get_addr(void) const { return dm_addr; }
    int get_port(void) const { return dm_port; }

  protected:
    SCOPIRA_EXPORT void open_relay(socket_handle_t _fd, const flow_i::byte_t* _addr, int _addrlen, int _port);

};

class scopira::tool::net_loop
{
  public:
#ifdef PLATFORM_win32
    SCOPIRA_EXPORT net_loop(void);
    SCOPIRA_EXPORT ~net_loop();
#else
    SCOPIRA_EXPORT net_loop(void) { }
    SCOPIRA_EXPORT ~net_loop() { }
#endif
};

class scopira::tool::udpflow : public virtual scopira::tool::object
{
  public:
    SCOPIRA_EXPORT udpflow(void);
    SCOPIRA_EXPORT udpflow(int _port);
    SCOPIRA_EXPORT virtual ~udpflow();

    bool failed(void) const { return dm_fail; }

    SCOPIRA_EXPORT size_t read(netaddr &actualsrc, int &actualport, byte_t* _buf, size_t _maxsize);
    SCOPIRA_EXPORT size_t write(netaddr dest, int destport, const byte_t* _buf, size_t _size);

    SCOPIRA_EXPORT void open(int _port);
    SCOPIRA_EXPORT void close(void);

    SCOPIRA_EXPORT bool read_ready(int msec);

    int get_port(void) const { return dm_port; }

  private:
    int dm_port;    
    socket_handle_t dm_sock; 
    bool dm_fail;
    bool dm_open;   
};

#ifndef PLATFORM_win32 

class scopira::tool::unixflow : public scopira::tool::iflow_i, public scopira::tool::oflow_i
{
  protected:
    std::string dm_filename;
    bool dm_server, dm_open, dm_fail, dm_sfail;
    int dm_sock;

  public:
    unixflow(void);
    unixflow(const std::string &filename, bool server_mode);
    virtual ~unixflow();

    virtual bool failed(void) const;

    virtual size_t read(byte_t* _buf, size_t _maxsize);
    virtual size_t write(const byte_t* _buf, size_t _size);

    void open(const std::string &filename, bool server_mode);
    void close(void);

    bool accept(unixflow& nconn);

    bool read_ready(int msec);

    const std::string &get_filename(void) const { return dm_filename; }
    bool is_server(void) const { return dm_server; }

  protected:
    void open_relay(int _fd, const std::string &filename);
};
#endif    //PLATFORM_win32

#endif