C:/Anonymizer/Codifier.h

Go to the documentation of this file.

#ifndef _CODIFIER_H_
#define _CODIFIER_H_

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>
#include <map>
#include <iostream>

using namespace std;


//---------------------------Prefix-preserving--------------------------------

struct Nodo;
typedef Nodo* PNodo;

class PrefixPreservingTree{
    private:
        PNodo root;
        //Metodi ricorsivi
        void _Codifica(PNodo& n, unsigned long address, int pos, unsigned long& temp, bool b);
        void _Svuota(const PNodo& n);
    
    public:
        PrefixPreservingTree();
        ~PrefixPreservingTree();
        
        struct in_addr Codifica(struct in_addr address);
        void Svuota();
};

//-----------------------------------Codifier with Map------------------------


inline u_int8_t GetByte(u_int32_t a, int byteno)
{
    //byteno is the byte order: 0 is the least significant, 3 the most significant
    return  (a >> (8 * byteno)) & 0xff;
};

struct AddrComp:public binary_function<const struct in_addr, const struct in_addr, bool> 
{ 
    bool operator()(const struct in_addr addr1, const struct in_addr addr2) const 
    { 
        return (addr1.s_addr <= addr2.s_addr) ? false : true;
    } 
}; 

typedef map<struct in_addr, struct in_addr, AddrComp> mappa;
  
class PublicCodifierA {
class Elem{
  public:
  mappa mapA;
  u_int8_t newnet;
  u_int32_t newhost;
     
  Elem() :newnet(0),newhost(0){};
   ~Elem(){};
};
 private:
  u_int8_t curr_net;
  Elem V[127];
  u_int8_t New_Net();
      
 public:
   PublicCodifierA ():curr_net(0){};
  ~PublicCodifierA (){};
   struct in_addr Codifica (const struct in_addr address);
};

class PrivateCodifierA {
class Elem{
  public:
  mappa mapA;
  u_int32_t newhost;
     
  Elem() :newhost(0){};
   ~Elem(){};
};
 private:
  Elem elem;
    
 public:
   PrivateCodifierA (){};
  ~PrivateCodifierA (){};
   struct in_addr Codifica (const struct in_addr address);
};

class CodifierA {
  private:
    PublicCodifierA pub_ca;
    PrivateCodifierA pri_ca;
  public:
    CodifierA(){};
   ~CodifierA(){};
    struct in_addr Codifica(struct in_addr address){
          struct in_addr encodedAddress;
          int a=GetByte(address.s_addr , 3);
          if(a==10)
             encodedAddress=pri_ca.Codifica(address);
          else
             encodedAddress=pub_ca.Codifica(address);
          return encodedAddress;
          }
};

class PublicCodifierB {
    class Elem{
      public:
      mappa mapB;
        u_int16_t newnet;
        u_int16_t newhost;
     
    Elem() :newnet(0),newhost(0){};
      ~Elem(){};
     };
 private:
  u_int16_t curr_net;
  Elem V[64][256];     //64*256(da 128.0 a 191.255)
  u_int16_t New_Net();
      
 public:
   PublicCodifierB ():curr_net(32767){};  //127.255
  ~PublicCodifierB (){};
   struct in_addr Codifica (const struct in_addr IN);
};

class PrivateCodifierB {
class Elem{
  public:
  mappa mapB;
  u_int32_t newhost;
     
  Elem() :newhost(1048576){};
   ~Elem(){};
};
 private:
  Elem V[32];     //172.16 a 172.31
        
 public:
   PrivateCodifierB (){};
  ~PrivateCodifierB (){};
   struct in_addr Codifica (const struct in_addr address);
    
};
class CodifierB {
  private:
    PublicCodifierB pub_cb;
    PrivateCodifierB pri_cb;
  public:
    CodifierB(){};
   ~CodifierB(){};
    struct in_addr Codifica(struct in_addr address){
          struct in_addr encodedAddress;
          int a=GetByte(address.s_addr , 3);
          int b=GetByte(address.s_addr , 2);
          if((a==127)&&(b>=16)&&(b<=31))
             encodedAddress=pri_cb.Codifica(address);
          else
             encodedAddress=pub_cb.Codifica(address);
          return encodedAddress;
          }
};

typedef class ElemM;
typedef map<u_int8_t, ElemM> mappa1;

class ElemM{
    public:
      mappa mapC2;
      u_int32_t newnet;
      u_int8_t newhost;
      ElemM():newnet(0),newhost(0){};
     ~ElemM(){};
}; 

class PublicCodifierC {
class Elem{
  public:
    mappa1 mapC1;
    bool flag;
    Elem():flag(0){};
   ~Elem(){};    
}; 
 private:
    u_int32_t curr_net;
    Elem V[32][256];     //32*256(da 192.0 a 223.255)
    u_int32_t New_Net();      
 public:
     PublicCodifierC():curr_net(12582911){};  //191.255.255
    ~PublicCodifierC(){};
     struct in_addr Codifica (const struct in_addr IN); 
};

class PrivateCodifierC {
class Elem{
  public:
  mappa mapC;
  u_int16_t newhost;
     
  Elem() :newhost(0){};
   ~Elem(){};
};
 private:
  Elem V[255];     //192.168.0 a 192.168.255
        
 public:
   PrivateCodifierC (){};
  ~PrivateCodifierC (){};
   struct in_addr Codifica (const struct in_addr IN);
    
};

class CodifierC {
  private:
    PublicCodifierC pub_cc;
    PrivateCodifierC pri_cc;
  public:
    CodifierC(){};
   ~CodifierC(){};
    struct in_addr Codifica(struct in_addr address){
          struct in_addr encodedAddress;
          int a=GetByte(address.s_addr , 3);
          int b=GetByte(address.s_addr , 2);
          
          if((a==192)&&(b==168))
             encodedAddress=pri_cc.Codifica(address);
          else
             encodedAddress=pub_cc.Codifica(address);
          return encodedAddress;
          }
};

class CodifierD{
 class Elem{
  public:
    mappa mapD;
    u_int8_t newnet;
    u_int32_t newhost;
       
    Elem() :newnet(0),newhost(0){};
   ~Elem(){};
};
  
 private:
    u_int8_t curr_net;
    Elem V[16]; //16: da 224.0 a 239.255
    u_int8_t New_Net();
      
 public:
     CodifierD():curr_net(223){};
    ~CodifierD(){};
     struct in_addr Codifica (const struct in_addr IN);
};

class Codifier {
  private:
    CodifierA A;
    CodifierB B;
    CodifierC C; 
    CodifierD D;
    PrefixPreservingTree P;
    int getClass(const struct in_addr);
    
  public:
    struct in_addr Codifica( in_addr address, int prefix);
    Codifier(){};
   ~Codifier(){};
};

#endif

---