Forest.h

Go to the documentation of this file.

#ifndef FOREST_H
#define FOREST_H

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/time.h>
#include <stdlib.h>
#include <memory.h>
#include <exception>

#include "stdinc.h"
#include "Util.h"
#include "Np4d.h"

using namespace grafalgo;

namespace forest {

typedef int32_t fAdr_t;                                         
typedef uint32_t comt_t;                        
typedef uint8_t flgs_t;                                         


class Forest {
public:
                enum ntyp_t {
                                UNDEF_NODE=0,
                                // untrusted node types
                                CLIENT=1,       
                                SERVER=2,       
                                // trusted node types
                                TRUSTED=100,    
                                ROUTER=101,     
                                CONTROLLER=102  
                };
                
                enum ptyp_t {
                                UNDEF_PKT=0,
                                // client packet types
                                CLIENT_DATA=1,                  
                                SUB_UNSUB=2,                    
                
                                CLIENT_SIG=10,                  
                
                                CONNECT=11,                     
                                DISCONNECT=12,                  

                                UNKNOWN_DEST=13,                
                
                                // internal control packet types
                                NET_SIG=100,                    
                                RTE_REPLY=101,                  
                
                                // router internal types
                                RTR_CTL=200,
                                VOQSTATUS=201
                };
                
                enum ComtConfigMode {
                                NUL_CFG=0,
                                // client packet types
                                STATIC=1,                       
                                LEAFADJUST=2,                   
                                STEPADJUST=3                    
                                                                                //   adjust up by 30% when "full"
                                                                                //   adjust down by 20% when 60% full
                };
                
                enum AccessMethod {
                                NUL_AXS=0,
                                // client packet types
                                OPEN=1,                                         
                                BYPERMISSION=2,                 
                                BYPASSWORD=3                    
                };

                // constants related to packet formats 
                static const uint8_t FOREST_VERSION = 1;
                static const int HDR_LENG = 20;                 
                static const int MAX_PLENG = 1450;              
                static const int OVERHEAD = 24;                 
                static const flgs_t RTE_REQ = 0x01;             
                static const flgs_t ACK_FLAG = 0x02;            
                static const flgs_t NACK_FLAG = 0x02;           

                // well-known ports
                static const ipp_t NM_PORT = 30120;             
                static const ipp_t CC_PORT = 30121;             
                static const ipp_t CM_PORT = 30122;             
                static const ipp_t ROUTER_PORT = 30123; 

                // router implementation parameters 
                static const short int MAXINTF= 20;             
                static const short int MAXLNK = 1000;           
                static const int MINBITRATE = 1;                
                static const int MAXBITRATE = 900000;           
                static const int MINPKTRATE = 1;                
                static const int MAXPKTRATE = 450000;           
                static const uint32_t BUF_SIZ = 1600;           

                // comtrees used for control
                static const comt_t NABOR_COMT = 1;             
                static const comt_t CLIENT_SIG_COMT = 2; 
                static const comt_t NET_SIG_COMT = 100;  

                // methods for manipulating addresses 
                static bool validUcastAdr(fAdr_t);
                static bool mcastAdr(fAdr_t);
                static int zipCode(fAdr_t);
                static int localAdr(fAdr_t);
                static fAdr_t forestAdr(int,int);
                static fAdr_t forestAdr(const char*);
                static string fAdr2string(fAdr_t);
                static bool readForestAdr(istream&, fAdr_t&);

                // miscellaneous 
                static int truPktLeng(int);
                static string nodeType2string(ntyp_t);
                static ntyp_t getNodeType(string&);
                static bool isSigComt(comt_t);
};

typedef uint32_t buffer_t[Forest::BUF_SIZ/sizeof(uint32_t)];

inline bool Forest::validUcastAdr(fAdr_t adr) {
                return adr > 0 && zipCode(adr) != 0 && localAdr(adr) != 0;
}

inline bool Forest::mcastAdr(fAdr_t adr) { return adr < 0; }

inline int Forest::zipCode(fAdr_t adr) { return (adr >> 16) & 0x7fff; }

inline int Forest::localAdr(fAdr_t adr) { return adr & 0xffff; }

inline fAdr_t Forest::forestAdr(int zip, int local ) {
                return ((zip & 0xffff) << 16) | (local & 0xffff);
}

inline fAdr_t Forest::forestAdr(const char *fas) {
                int zip, local, mcAdr;
                if (sscanf(fas,"%d.%d", &zip, &local) == 2 && zip > 0 && local > 0) {
                                return forestAdr(zip,local);
                }
                else if (sscanf(fas,"%d", &mcAdr) == 1 && mcAdr < 0)
                                return mcAdr;
                else
                                return 0;
}

inline string Forest::fAdr2string(fAdr_t fAdr) {
                stringstream ss;
                if (mcastAdr(fAdr)) ss << fAdr;
                else ss << zipCode(fAdr) << "." << localAdr(fAdr);
                return ss.str();
}

inline int Forest::truPktLeng(int x) { return 70+x; }

inline static bool isSigComt(comt_t comt) { return comt > 0 && comt < 1000; }


} // ends namespace


#endif