//--------------------------------------------------------------
// File contenente le funzioni per il controllo sintattico
// dei campi generici contenuti nelle form per la gestione dei 
// nomi a dominio.
//
// IsNumber()
// IsLetter(str)
// IsEmpty()
// nospace(str)
// DomainNameOK(str)
// DomainOK(campo)
// mntOK(campo)
// emailOK()
// NichHandleOK(campo, nichdl, label) 
// IPaddressOK(str)
//
// Created by:  Arianna Del Soldato
// Last Update: 24/08/2000 by (A. Del Soldato)
//--------------------------------------------------------------



//******************************************************************
//                             IsNumber(num)
//
// Controlla che la stringa passata come parametro sia composta
// da soli caratteri numerici.
//
//******************************************************************
function IsNumber(num)
{
   var i = 0;
   var letter;

   while (i < num.length)
   {
      letter = num.charAt(i);

      if ((letter == '0') || (letter == '1') || (letter == '2') ||
          (letter == '3') || (letter == '4') || (letter == '5') ||
          (letter == '6') || (letter == '7') || (letter == '8') ||
          (letter == '9'))
      {
         i++;
      }
      else
      {
         return false;
      }
   }

   return true;
}


//******************************************************************
//                      IsLetter(str)
//
// Controlla che la stringa passata come parametro sia composta
// da soli caratteri alfabetici.
//
//******************************************************************
function IsLetter(str)
{
   var i = 0;
   var letter = "";
   var lowerstr = str.toLowerCase();

   while (i < lowerstr.length)
   {
      letter = lowerstr.charAt(i);

      if ((letter == 'a') || (letter == 'b') || (letter == 'c') ||
          (letter == 'd') || (letter == 'e') || (letter == 'f') ||
          (letter == 'g') || (letter == 'h') || (letter == 'i') ||
          (letter == 'l') || (letter == 'm') || (letter == 'n') ||
          (letter == 'o') || (letter == 'p') || (letter == 'q') ||
          (letter == 'r') || (letter == 's') || (letter == 't') ||
          (letter == 'u') || (letter == 'v') || (letter == 'z') ||
          (letter == 'w') || (letter == 'y') || (letter == 'j') ||
          (letter == 'k') || (letter == 'x'))
      {
         i++;
      }
      else
      {
         return false;
      }
   }

   return true;
}


//******************************************************************
//                      DomainNameOK(str)
//
// Controlla che la sintassi della stringa passata come parametro
// sia del tipo:
//        str1.str2.strN.it
// con 'str' stringa composta da caratteri alfabetici e numerici con
// l'aggiunta del segno '-' (meno) e N >= 1.
//
// IN  - str  : stringa contenuta nel campo 'campo'
//
// OUT - true : se la sintassi della stringa è giusta
//     - false: altrimenti
//
//******************************************************************
function DomainNameOK(str)
{
   // legge il valore del campo
   var valore   = str;
   var strN     = '';
   var domainOK = true;
   var ultimo   = false;
   var npoint   = 0;

   // cerca il carattere '.'
   var index = str.indexOf('.');

   // se non esiste almeno un '.', ritorna false
   if (index == -1)
   {
       domainOK = false;
   }
   else
   {
      // fintantoche ci sono delle sotto-stringhe da esaminare
      // e non è stato rilevato alcun errore
      while (((index != -1) || ultimo ) && domainOK)
      {
         // se la sotto-stringa è l'ultima
         if (index == -1)
         {
            strN = str;

            // controlla che la sotto-stringa sia 'it'
            domainOK = (strN == 'it');
            if (!domainOK)
            {
               alert("Il '."+strN+" 'è un suffisso non valido, inserire .it!");
               return false;
            }

            ultimo = false;
         }
         else
         {
             // conta il numero di punti
             npoint++;

             // prende la sotto-stringa corrente
             strN = str.substring(0, index);
             str  = str.substring(index + 1, str.length);

             // controlla che i caratteri della sotto-stringa siano
             // numerici, alfabetici o uguali a '-'
             i = 0;
             len = strN.length;
             while ((i < len) && domainOK)
             {
                var carattere = strN.charAt(i);

                if (IsLetter(carattere) || IsNumber(carattere) || (carattere == '-'))
                {
                   if (carattere == '-')
                   {
                      // controlla che il carattere - non sia
                      // il primo o l'ultimo carattere
                      if ((i == 0) || (i == (len - 1)))
                      {
                         return false;
                      }

                      // controlla che non ci siano due caratteri '-' consecutivi
                      var j = i + 1;
                      var k = i - 1;
                      if ((strN.charAt(j) == '-') || (strN.charAt(k) == '-'))
                      {
                         alert ("ATTENZIONE, il dominio contiene '--', carattere non valido!");
                         i++;
                      }
                   }
                   i++;
                }
                else
                {
                   domainOK = false;
                }
             }

             if ((strN.length > 63) || (strN.length <= 1))
                domainOK = false;
             
             // prende l'indice del prossimo carattere '.'
             index = str.indexOf('.');

             ultimo = (index == -1);

             // controlla che il nome del dominio
             // non sia del tipo str.it con str formata da due soli caratteri 
             if (ultimo && (strN.length <= 2) && (npoint == 1))
                domainOK = false;  
         }
      }
   }
   
   if (domainOK)
   {
      return true;
   }
   else
   {
      return false;
   }
}
 

//**********************************************************************
//                           emailOK
// Controlla la validità sintattica di un indirizzo di e-mail passato
// come parametro.
//
// IN:  e-mail: indirizzo da controllare
//      str   : label del campo corrispondente all'email da controllare
//***********************************************************************
function emailOK(campo, str)
{
   //legge il valuro della email
   email = campo.value;

   //controlla che la e-mail non sia vuota
   if (email == "")
   {
      return true;
   }

   // controllo della presenza del carattere '\@'
   var index     = email.indexOf('\@', 0);
   var address   = "";
   var ok = true;

   if (index == -1)
   {
      ok = false;
   }
   else
   {
      var size = email.length;
      address = email.substring(size + 1, index + 1);
      userid =  email.substring(1, index);

      // controlla: l'unicità del carattere "\@";
      // - la presenza del "." nella parte DX dell'indirizzo;
      // - l'assenza di spazi e
      // - che la stringa non sia del tipo userid\@.address o userid.\@address
      if ((address.indexOf('\@') != -1) || (userid.indexOf('\@') != -1) ||
          (address.indexOf('.') == -1) || (!nospace(email)) ||
          (email.charAt(index - 1) == '.') || (email.charAt(index + 1) == '.'))
      {
         ok = false;
      }
   }

   if (ok == false)
   {
      alert("Invalid e-mail address \n in the '" +str+ "' field!");
      campo.value = "";
      campo.focus();
      campo.select();

      return false;
   }
   else
   {
      return true;
   }
}


//******************************************************************
//                      DomainOK(campo)
//
// Controlla che la sintassi della stringa inserita nel campo "domain"
// sia del tipo:
//        str1.str2.strN.it
// con 'str' stringa composta da caratteri alfabetici e numerici con
// l'aggiunta del segno '-' (meno) e N >= 1.
//
// IN  - campo: campo contenente la stringa da controllare
//
//******************************************************************
function DomainOK(campo)
{
   // legge il valore del campo
   var str      = campo.value;


   // ritorna true se la stringa è vuota
   if (str == "")
   {
      return true;
   }


   if (DomainNameOK(str))
   {
      campo.value = str;
      return true;
   }
   else
   {
      alert("Dominio non valido!");
      campo.value = "";
      campo.focus();
      campo.select();
      return false;
   }
}


//*******************************************************************
//                           IsEmpty()
//
// Controlla che la stringa passata come parametro contenga almeno un
// carattere numerico o alfabetico.
//
// IN  - str: stringa da controllare
//*******************************************************************
function IsEmpty(str)
{
   var i    = 0;
   var ok   = false;
   var tmpchar = "";

   // se la stringa non è vuota
   if (str != "")
   {
      // controlla che ci sia almeno una lettera o un numero
      while ((i < str.length) && (!ok))
      {
         tmpchar = str.charAt(i);
         if (IsLetter(tmpchar) || IsNumber(tmpchar))
         {
            ok = true;
         }

         i++;
      }
   }

   if (ok)
   {
      return false;
   }
   else
   {
      return true;
   }
}


//********************************************************
//                 nospace(str)
//
// Controlla che non ci siano spazi all'interno
// della stringa passata come parametro.
//
//********************************************************
function nospace(str)
{
   if (str != "")
   {
      var index = str.indexOf(" ", 0);
      if (index != -1)
      {
         return false;
      }
   }

   return true;
}


//******************************************************************
//                      mntOK(campo)
//
// Controlla la sintassi del campo "mntner":
// - deve avere una sintassi del tipo nome-MNT con name diverso da
//   "" e tale che non contenga spazi.
// Se la sintassi è corretta, converte la  stringa in maiuscolo
// e la inserisce come valore nei campi "mntner" e "mnt-by".
//
//******************************************************************
function mntOK(campo)
{
   var mntOK = true;
   var index;
   var namemnt;
   var tobeempty;

   // legge il valore del campo mntner e lo
   // converte in lettere maiuscole
   var maintainer = campo.value.toUpperCase();

   if (maintainer == "")
   {
      return true;
   }

   var indexmnt   = maintainer.indexOf('-MNT');
   var indexent   = maintainer.indexOf('-ENT');
   var indexminus = maintainer.indexOf('-');
   var sizemnt    = maintainer.length;

   // controlla che contenga la stringa "-MNT" o la stringa "-ENT" e
   // che non ci siano due caratteri '-' consecutivi
   if (((indexmnt == -1) && (indexent == -1)) ||
       ((maintainer.charAt(indexminus - 1) == '-') || (maintainer.charAt(indexminus + 1) == '-')))
   {
      mntOK = false;
   }
   else
   // controlla che la parte del nome non sia vuota, che non
   // contenga spazi e che il valore inserito termini con -MNT o -ENT.
   {
      index = (indexmnt == -1)? (indexent):(indexmnt);

      namemnt = maintainer.substring(0, index);
      tobeempty = maintainer.substring(sizemnt, index + 4);

      if ((tobeempty != "") || IsEmpty(namemnt) || !nospace(namemnt))
      {
         mntOK = false;
      }
   }

   if (mntOK == false)
   {
      alert("The name of the maintainer " +maintainer+ " is not valid! \n (Insert a name of type: xxxxx-MNT)");
      campo.value = "";
      campo.focus();
      campo.select();
      return false;
   }
   else
   {
      // setta il valore nella form con caratteri maiuscoli
      campo.value = maintainer;
      return true;
   }
}

//*****************************************************************************
//                      NichHandleOK(campo, string)
//
// Controlla che la stringa 'nichdl' passata come parametro abbia la sintassi
// di un nic-handle:
// - non deve contenere spazi;
// - non deve contenere più di un carattere '-';
// - deve contenere almeno 1 numero e 2 lettere;
// - se contiene il carattere "-", l'ultima parte della stringa deve
//   essere la sottostringa ITNIC (prima del 18/09/01 erano le sottostringhe: 
//   -RIPE, -INIC, -ORG, -ARIN, -JPNIC, -AU, JP.)
// Se la sintassi è corretta trasforma la stringa in maiuscolo.
//
// IN  campo : campo della form in cui è stata inserita la stringa
//             da controllare
//     nichdl: stringa da controllare
//     label : label del campo della form in cui è stata inserita la stringa
//
//****************************************************************************
function NichHandleOK(campo, nichdl, label)
{
   var nichdlOK = true;
   var found    = false;
   var letter   = "";
   var nletter  = 0;
   var nnumber  = 0;
   var i        = 0;
   var j        = 0;

   if (nichdl == "")
   {
      return true;
   }

   // trasforma la stringa in lettere minuscole per
   // facilitarne i controlli
   nichdl = nichdl.toLowerCase();

   // controlla che non ci sia più di un carattere "-"
   var indexminus = nichdl.indexOf('-');
   if (indexminus != -1)
   {
       var substrminus1 = nichdl.substring(0, indexminus);
       var substrminus2 = nichdl.substring(indexminus + 1, nichdl.length);

       if (( substrminus2.indexOf('-') != -1) || (substrminus1.indexOf('-') != -1))
           nichdlOK = false;
   }

   // se non ci sono spazi e non ci sono due caratteri "-"
   if (nospace(nichdl) && nichdlOK)
   {
      // controlla che ci siano almeno un numero e due lettere
      while ((i < nichdl.length) && (!found))
      {
          letter = nichdl.charAt(i);

          // conta le lettere
          if ((letter == 'a') || (letter == 'b') || (letter == 'c') ||
              (letter == 'd') || (letter == 'e') || (letter == 'f') ||
              (letter == 'g') || (letter == 'h') || (letter == 'i') ||
              (letter == 'l') || (letter == 'm') || (letter == 'n') ||
              (letter == 'o') || (letter == 'p') || (letter == 'q') ||
              (letter == 'r') || (letter == 's') || (letter == 't') ||
              (letter == 'u') || (letter == 'v') || (letter == 'z') ||
              (letter == 'w') || (letter == 'y') || (letter == 'j') ||
              (letter == 'k') || (letter == 'x'))
             nletter ++;

          // conta i numeri
          if ((letter == '0') || (letter == '1') || (letter == '2') ||
              (letter == '3') || (letter == '4') || (letter == '5') ||
              (letter == '6') || (letter == '7') || (letter == '8') ||
              (letter == '9'))
             nnumber ++;

          if ((nletter >= 2) && (nnumber >= 1))
          {
             found = true;
          }

          i++;
      }

      if (!found)
      {
         // non ci sono almeno 2 lettere e un numero
         nichdlOK = false;
      }
      else
      {
         // se c'è il carattere "-", controlla che l'ultima sottostringa sia
         // -RIPE, -INIC, -ORG, -ARIN, -JPNIC, -AU, -JP, -ITNIC

         // controlla che contenga la stringa "-"
         if (indexminus != -1)
         {
            // creazione dell'array contenente le sottostringhe da controllare
            var substr = new Array ("itnic");

            // legge la prima sottostringa
            var i = 0;
            str = substr[i];

            indexstr = nichdl.indexOf(str);

             while ((i <= 7) && (indexstr == -1))
             {
                  // legge la sottostringa successiva
                i++;
                str = substr[i];
                indexstr = nichdl.indexOf(str);
             }

             var strlength = (i <= 7)? str.length : 0;
             var str1 = nichdl.charAt(indexstr + strlength);

             if ((i > 7) || ((i < 7) && (str1 != "")))
             {
                nichdlOK = false;
             }
             else
             {
                 nichdlOK = true;
             }
         }  // end if (indexminus)
      }// end else (!found)
   } // end if degli spazi
   else
   {
      // ci sono degli spazi
      nichdlOK = false;
   }

   if (nichdlOK)
   {
      // trasforma il nichdl in lettere maiuscole e
      // lo inserisce nel campo della form
      campo.value = nichdl.toUpperCase();
      return true;
   }
   else
   {
      // visualizza messaggio di errore, cancella il valore inserito e
      // posiziona il fuoco e il cursore sul campo
      alert("No valid value in the field: " +label);
      campo.value = "";
      campo.focus();
      campo.select();
      return false;
   }
}


//******************************************************************
//                            IPaddressOK(str)
//
// Controlla che la stringa passata come parametro abbia la sintassi
// di un indirizzo IP in formato dotted-decimal:
//
//       n1.n2.n3.n4     con:  nN numerici e < 255
//
//  IN  - str : stringa da verificare;
//
//  OUT - true : se la sintassi della stringa 'str' è corretta
//        false: altrimenti.
//
//******************************************************************
function IPaddressOK(str)
{
   var IPaddress = str;
   var IPOK   = true;
   var npoint = 0;
   var ultimo = false;

   // esamina la stringa fintantochè non trova un errore
   var index  = IPaddress.indexOf('.');

   while ((index != -1) && IPOK)
   {
       // conta il numero di '.'
       npoint++;

       // legge la cifra corrente e controlla che sia un numero < 255
       N = IPaddress.substring(0, index);
       IPOK = (IsNumber(N) && (N < 255) && !IsEmpty(N));

       // prende la nuova stringa da esaminare
       IPaddress = IPaddress.substring(index + 1, IPaddress.length);

       index = IPaddress.indexOf('.');
   }

   //  controlla la sintassi dell'ultima cifra
   lastOK = IsNumber(IPaddress) && (IPaddress < 255) && !IsEmpty(IPaddress)

   // controlla che i '.' letti siano 3
   // e che non ci siano stati errori nei controlli precedenti
   if ((npoint == 3) && (IPOK) && lastOK)
   {
      return true;
   }
   else
   {
      return false;
   }
}


//******************************************************************
//                            Validate()
//
// Controlla l'esistenza dei valori nei campi obbligatori.
//
// Se non stati inseriti tutti visualizza un messaggio di errore.
//
//******************************************************************
function Validate()
{
   var length = document.form.elements.length;
   var name, value;      // contengono il nome ed il valore di ogni entry
   var index  = 0;       // indice dei campi dell'intera form
   var errore = false;   // guardia del ciclo

   // per ogni elemento della form
   while ((index < length) && !errore)
   {
       // legge il nome ed il suo valore
       name  = document.form.elements[index].name;
       value = document.form.elements[index].value;

       // controlla che non sia vuoto
       errore = (IsEmpty(value));

       index++;
   }

   if (name == 'domain')
   {
      campo = 'the domain name!';
   }
   else
   {
      campo = (name == 'mntner') ? 'the maintainer name!' : 'the password!';
   }

   if (errore)
   {
      alert ("Prego inserire" +campo);
      return false;
   }
   else
   {
      return true;
   }
}