C:/Anonymizer/Codifier.cpp

Go to the documentation of this file.

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

#include "Codifier.h"

using namespace std;

//Ritorna la classe di un Indirizzo IP
int Codifier::getClass(const struct in_addr address){

  u_int8_t a= GetByte(address.s_addr,3);//primo byte
 
  if (a<=127)             return 1; //classe A     
  if((a>=128)&&(a<=191))  return 2; //classe B
  if((a>=192)&&(a<=223))  return 3; //classe C
  if((a>=224)&&(a<=239))  return 4; //classe D
  if((a>=240)&&(a<=254))  return 5; //classe E
  if((a>=255))            return 6; //IP Error
  else                    return 6;
}

//Funzione che crea una super lista di indirizzi IP generati su funzioni diverse
//
struct in_addr Codifier::Codifica( struct in_addr address, int prefix){
  struct in_addr encodedAddress;
//  address.s_addr=ntohl(address.s_addr);

  if((address.s_addr!=0x00000000)&&(address.s_addr!=0xffffffff)){//Ricopio per intero gli indirizzi 0.0.0.0 e 255.255.255.255
    
    //Se prefix è true è richiesta la codifica prefix-preserving.
    if (prefix!=0) encodedAddress=P.Codifica(address);
    else
    {
    int clas=getClass(address);
 
    if(clas==1) encodedAddress=A.Codifica(address);
    if(clas==2) encodedAddress=B.Codifica(address);
    if(clas==3) encodedAddress=C.Codifica(address);
    if(clas==4) encodedAddress=D.Codifica(address);
    if(clas==5 || clas==6) encodedAddress=address;
    }    
  }
  //encodedAddress.s_addr=htonl(encodedAddress.s_addr);
  return encodedAddress;
}

//------------------------------------------Prefix-Preserving-----------------------------------

struct Nodo{
    bool bit;
    PNodo sin;
    PNodo des;
};

inline bool GetBit(unsigned long a, int bitno)
{
    return (a >> (bitno))& 1;
};

inline bool randomBit()
{
    // genera un numero casuale in un intervallo con un numero pari di
    // elementi (ad esempio 100)...
    int iValore = (int)(((float)rand() / (float)RAND_MAX) * 1000.0f);

    // ... e determina la sua parità.
    return ((iValore % 2) != 0) ? true : false;
};

PrefixPreservingTree::PrefixPreservingTree(){
    root= new Nodo;
    root->des=0;
    root->sin=0;
}    
    
PrefixPreservingTree::~PrefixPreservingTree(){
    Svuota();
}
 
void PrefixPreservingTree::_Codifica(PNodo& n, unsigned long address,int pos,unsigned long& temp, bool b)
{
     
  //I primi 4 bit dell'indirizzo non saranno modificati per mantenere la corrispondenza delle classi        
  if (pos>27 && pos<32){
      if (!n){
          n=new Nodo;
          n->des=0;
          n->sin=0;
          n->bit=b;
      }   
      //in ogni caso aggiorniamo la variabile temp:
      //temp = (temp << 1L) | ((b == true) ? 1 : 0);
      temp=temp | ( b <<(pos));
        
      //Calcoliamo il valore del prossimo bit:
      bool b_succ= GetBit(address,pos-1);
      if (b_succ==0)
            _Codifica(n->sin, address, pos-1, temp, b_succ);
      if (b_succ==1)
            _Codifica(n->des, address, pos-1, temp, b_succ);
  }
  
//Se invece siamo tra il 5° e il 32° bit:
//se il bit è già presente nell'albero si recupererà la codifica già effettuata,
// altrimenti si inizializzerà un nuovo nodo e si sceglierà al 50% tra 0 e 1. 
  //if(pos>=0 && pos<28){
      else{
      if(!n){
          n=new Nodo;
          n->des=0;
          n->sin=0;
          n->bit = randomBit();
      }
      //in ogni caso aggiorniamo la variabile temp:
      //temp = (temp << 1L) | ((n->bit == true) ? 1 : 0);
      temp=temp | ( n->bit <<(pos));
      
      //Se non siamo giunti alla fine dell'indirizzo:
      if(pos>0){
            bool b_succ=GetBit(address,pos-1);
            if(b_succ==0)
                  _Codifica(n->sin,address,pos-1,temp, b_succ);
            if(b_succ==1)
                  _Codifica(n->des,address,pos-1,temp,b_succ);
     }
  }
}        
  
void PrefixPreservingTree::_Svuota(const PNodo& n){
    if(n){
        _Svuota(n->sin);
        _Svuota(n->des);
        delete n;
    }
}        

void PrefixPreservingTree::Svuota(){
    _Svuota(root);
    root=0;
}    

struct in_addr PrefixPreservingTree::Codifica(struct in_addr address){
    int pos=31;
    unsigned long temp=0;
    struct in_addr encodedAddress;
    encodedAddress.s_addr=0;
    //salviamo nella variabile l'indirizzo in formato long, che sarà data in ingresso alla funz ricorsiva
    unsigned long add= address.s_addr;
    
    bool b= GetBit(add,pos);
      if (b==0)
          _Codifica(root->sin, add, pos, temp,b);
      else          
          _Codifica(root->des, add, pos, temp,b);
                                                            
    encodedAddress.s_addr=temp;
    return encodedAddress;
}


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

//Funzioni della Classe PublicCodifierA:

u_int8_t PublicCodifierA::New_Net()
{
    curr_net += 1;

    // 10.x.x.x riservati per indirizzi privati.
    if (curr_net == 10) 
      curr_net += 1;

    // se arriva alla fine delle reti non deve "sforare"
    // l'array,banalmente facciamo "ripartire" il conteggio
    // delle reti.
    if (curr_net == 128)
        curr_net = 1;
    //
    return curr_net;
}

struct in_addr PublicCodifierA::Codifica (const struct in_addr address)
{
    //cout<<"PublicA"<<endl;
    u_int8_t net = GetByte(address.s_addr, 3);

    // Newnet non è ancora stato inizializzato (è il primo accesso alla map)
    if (V[net].newnet == 0)
        V[net].newnet = New_Net();
    
  // a questo punto, sempre e comunque è sicuramente presente la voce
    // newnet, mi interesso solo della parte host.
    struct in_addr encodedAddress;
    mappa::iterator i;             

    i = V[net].mapA.find(address);  

    if (i == V[net].mapA.end()) {
        // aggiorna il numero dello host, prima di usarlo per la codifica che
        // segue...
        V[net].newhost += 1;

        // crea una nuova codifica...
        encodedAddress.s_addr = (V[net].newnet << 24) | V[net].newhost;

        // ... memorizzalo nella mappa.
      V[net].mapA[address] = encodedAddress;
    } else {
        // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.
        encodedAddress = (*i).second;
    }

    //
    return encodedAddress;
}

//Funzioni della Classe PrivateCodifierA:

struct in_addr PrivateCodifierA::Codifica (const struct in_addr address)
{
    //cout<<"PrivateA"<<endl;
    struct in_addr encodedAddress;
    mappa::iterator i;             

    i = elem.mapA.find(address);  

    if (i == elem.mapA.end()) {
        // aggiorna il numero dello host, prima di usarlo per la codifica che
        // segue...
        elem.newhost += 1;

        // crea una nuova codifica...
        encodedAddress.s_addr = (10 << 24) | elem.newhost;

        // ... memorizzalo nella mappa.
      elem.mapA[address] = encodedAddress;
    } else {
        // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.
        encodedAddress = (*i).second;
    }

    //
    return encodedAddress;
}

//Funzioni della Classe PublicCodifierB

u_int16_t PublicCodifierB::New_Net()
{
    curr_net += 1;

    //da 172.16.0.0 a 172.31.255.255 indirizzi provati Classe B.
    if((curr_net>=44048)&(curr_net<=44063)) 
      curr_net=44064; //172.32

    // se arriva alla fine delle reti non deve "sforare"
    // l'array,banalmente facciamo "ripartire" il conteggio
    // delle reti.
    if (curr_net > 49151)//191.255
        curr_net = 32768;
    //
    return curr_net;
}

struct in_addr PublicCodifierB::Codifica (const struct in_addr address)
{
    //cout<<"PublicB"<<endl;
    u_int8_t net1=(GetByte(address.s_addr, 3) - 128);
    u_int8_t net2=GetByte(address.s_addr, 2);

    // Newnet non è ancora stato inizializzato (è il primo accesso alla map)
    if (V[net1][net2].newnet == 0)
        V[net1][net2].newnet = New_Net();
    
  // a questo punto, sempre e comunque è sicuramente presente la voce
    // newnet, mi interesso solo della parte host.
    struct in_addr encodedAddress;
    mappa::iterator i;             

    i = V[net1][net2].mapB.find(address);  

    if (i == V[net1][net2].mapB.end()) {
        // aggiorna il numero dell'host, prima di usarlo per la codifica che
        // segue...
        V[net1][net2].newhost += 1;

        // crea una nuova codifica...
        encodedAddress.s_addr = (V[net1][net2].newnet << 16) | V[net1][net2].newhost;

        // ... memorizzalo nella mappa.
      V[net1][net2].mapB[address] = encodedAddress;
    } else {
        // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.
        encodedAddress = (*i).second;
    }

    //
    return encodedAddress;
}

//Funzioni della Classe PrivateCodifierB
struct in_addr PrivateCodifierB::Codifica (const struct in_addr address)
{
    //cout<<"PrivateB"<<endl;
    u_int8_t net1=GetByte(address.s_addr, 3);
    u_int8_t net2=GetByte(address.s_addr, 2);

    struct in_addr encodedAddress;
    mappa::iterator i;             

    i = V[net2].mapB.find(address);  

    if (i == V[net2].mapB.end()) {
        // aggiorna il numero dell'host, prima di usarlo per la codifica che
        // segue...
        V[net2].newhost += 1;

        // crea una nuova codifica...
        encodedAddress.s_addr = (net1 << 24) |  V[net2].newhost;

        // ... memorizzalo nella mappa.
      V[net2].mapB[address] = encodedAddress;
    } else {
        // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.
        encodedAddress = (*i).second;
    }

    //
    return encodedAddress;
}

   
u_int32_t PublicCodifierC::New_Net()
{
    curr_net += 1;

    if((curr_net>=12625920)&(curr_net<=12626175)) 
      //da 192.168.0 a 192.168.255 indirizzi provati Classe C.
        curr_net=12626176; //192.169.0

    // se arriva alla fine delle reti non deve "sforare"
    // l'array,banalmente facciamo "ripartire" il conteggio
    // delle reti.
    if (curr_net > 14680063)//223.255.255
        curr_net = 12582912;
    //
    return curr_net;
}

//Funzioni della Classe PublicCodifierC:
struct in_addr PublicCodifierC::Codifica (const struct in_addr address)
{
   //cout<<"PublicC"<<endl;
   u_int8_t net1=(GetByte(address.s_addr, 3)-192);
   u_int8_t net2=GetByte(address.s_addr, 2);
   u_int8_t net3=GetByte(address.s_addr, 1);
      
   struct in_addr encodedAddress;   
   mappa1::iterator i;                    
   i=V[net1][net2].mapC1.find(net3);  
     
   if(i==V[net1][net2].mapC1.end()){
       ElemM Newelem;
         Newelem.newnet=New_Net(); 
         Newelem.newhost+=1;
         
         encodedAddress.s_addr=((Newelem.newnet<<8) | (Newelem.newhost));
         Newelem.mapC2[address]=encodedAddress;
         V[net1][net2].mapC1[net3]=Newelem;
      } 
   else{
        mappa::iterator j;
      j=V[net1][net2].mapC1[net3].mapC2.find(address);
      
      if(j==V[net1][net2].mapC1[net3].mapC2.end()){
          //definiamo un intero corrispondente ai 3 ottetti della nuova net (già presente in memoria):
       u_int32_t newnet3 = V[net1][net2].mapC1[net3].newnet;
       V[net1][net2].mapC1[net3].newhost +=1;
       
       encodedAddress.s_addr=((newnet3 <<8) | (V[net1][net2].mapC1[net3].newhost));
       V[net1][net2].mapC1[net3].mapC2[address]=encodedAddress;
      }
      else
         // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.  
           encodedAddress=(*j).second; 
           
  }
  return encodedAddress;
}

//Funzioni della Classe PrivateCodifierC:
struct in_addr PrivateCodifierC::Codifica (const struct in_addr address)
{
    //cout<<"PrivateC"<<endl;
    u_int8_t net1=GetByte(address.s_addr, 3);
    u_int8_t net2=GetByte(address.s_addr, 2);
    u_int8_t net3=GetByte(address.s_addr, 1);

    struct in_addr encodedAddress;
    mappa::iterator i;             

    i = V[net3].mapC.find(address);  

    if (i == V[net3].mapC.end()) {
        // aggiorna il numero dell'host, prima di usarlo per la codifica che
        // segue...
        V[net3].newhost += 1;

        // crea una nuova codifica...
        encodedAddress.s_addr = ((net1 << 24) | (net2 << 16)| V[net3].newhost);

        // ... memorizzalo nella mappa.
      V[net3].mapC[address] = encodedAddress;
    } else {
        // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.
        encodedAddress = (*i).second;
    }

    //
    return encodedAddress;
}

//Funzioni della Classe CodifierD:
u_int8_t CodifierD::New_Net()
{
    curr_net += 1;
    
    if (curr_net > 247)
        curr_net = 1;
    //
    return curr_net;
}

struct in_addr CodifierD::Codifica (const struct in_addr address)
{
  //cout<<"PublicD"<<endl;
    u_int8_t net = (GetByte(address.s_addr, 3)-224);

    // Newnet non è ancora stato inizializzato (è il primo accesso alla map)
    if (V[net].newnet == 0)
        V[net].newnet = New_Net();
    
  // a questo punto, sempre e comunque è sicuramente presente la voce
    // newnet, mi interesso solo della parte host.
    struct in_addr encodedAddress;
    mappa::iterator i;             

    i = V[net].mapD.find(address);  

    if (i == V[net].mapD.end()) {
        // aggiorna il numero dello host, prima di usarlo per la codifica che
        // segue...
        V[net].newhost += 1;

        // crea una nuova codifica...
        encodedAddress.s_addr = ((V[net].newnet << 24) | V[net].newhost);

        // ... memorizzalo nella mappa.
      V[net].mapD[address] = encodedAddress;
    } else {
        // nel caso in cui l'indirizzo sia già stato codificato in passato,
        // recupera il valore per mezzo dell'iteratore usato poc'anzi.
        encodedAddress = (*i).second;
    }

    //
    return encodedAddress;
}

---