Réseau en Java - Les adresses IP

Chaque machine à une adresse IP unique dans le réseau. Elle sert à identifier la machine pour qu'elle puisse recevoir les paquets acheminés à l'aide des routeurs envoyés par d'autres machines. 
Une adresse IP de type IPV4 sur 32 bits( 4 octets ) est sous cette forme : xxx.xxx.xxx.xxx, par exemple: 192.168.0.3. Elle est composée de deux parties : 
Une partie droite indique le réseau appelée ID de réseau  : 192.168.0 et elle est statique.
La deuxième partie à gauche indique la machine dans ce réseau appelée ID d'hôte  : 192.168.0.3.
L'adresse IP par défaut est 0.0.0.0/8. Elle sert à se connecter à se connecter seulement au serveur DHCP, Ce dernier fournis l'adresse IP.

On distingue trois classes d'adressage: 
  1. la classe AID de réseau : xxx (126 réseaux) et l'ID d'hôte : xxx.xxx.xxx (16777214 ordinateurs).
  2. la classe BID de réseau : xxx.xxx (16384 réseaux ) et l'ID d'hôte : xxx.xxx (65534 ordinateurs).
  3. la classe CID de réseau : xxx.xxx.xxx (2097152 réseaux ) et l'ID d'hôte : xxx (254 ordinateur).

Le masque:

L’intérêt du masque est de permettre d’identifier le réseau associé à l'adresse IP. Il est composé de 4 octets comme une adresse IP, par exemple le masque de l'adresse IP 192.168.0.1 est 255.255.255.0 et on écrit 192.168.0.1/24. Pour les débutants je vous conseille de lire ce résumé sur Wikipédia: Adresse IP.

Vérifier si une adresse IP est correcte

public class VerifierAdresse {

  static boolean estCorrecte(String adr){
  String[] parties = adr.split("\\.");
  //La plage d'un nombre est entre 0 et 255
  for(int i = 0 ; i < 4; i++){
      //Convertir en entier et tester 
      if(new Integer(parties[i])<0 || new Integer(parties[i])>255)
      //retroune false
      return false;
  }
  //retourne true par défaut 
  return true;
 }
 
 public static void main(String[] args) {
     String adr= "192.168.1.3";
     System.out.println("adr+" est "+estCorrecte(adr));
 }
}
Le package qui nous permet de manipuler les adresses IP est java.net et fournit la classe InetAdress qui contient les méthodes qu'on va travailler avec:

getLocalHost: retourne l'adresse IP local de la machine.
getByName(String nom_de_la_machine): retourne l'IP qui correspond au nom passé en paramètre.
getAllByName(String nom_de_la_machine): retourne toutes les adresses IP qui correspondent au nom passé comme paramètre.

Les méthodes applicables sur cet l'objet retourné par l'une des méthodes décrites sont:
getHostName: retourne le nom de la machine.
getAddress: retourne l'adresse IP sous forme d'un tableau.
toString: retourne la chaîne de caractère contenant le nom et l'adresse.

Le programme suivant calcule le préfixe, l'adresse, le masque réseau, le masque inverse (Cisco wildcard), l'adresse réseau et l'adresse de diffusion (Broadcast).

import java.math.BigInteger;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

/*************************************
 * @author www.codeurjava.com
 * Tous droits réservés
 */

public class Adressage {
      
       public static void main(String[] zero) throws SocketException {
            
           String adresse = "192.168.1.199/10";
           String[] parties = adresse.split("/");
           String ip = parties[0];
           int prefixe;
           if (parties.length < 2) {
               prefixe = 0;
           } else {
               prefixe = Integer.parseInt(parties[1]);
           }
           System.out.println("Addresse =\t" + ip+"\nPrefixe =\t" + prefixe);
          
           //convertir le masque entier en un tableau de 32bits
           int masque = 0xffffffff << (32 - prefixe);
           int valeur = masque;
           byte[] bytes_masque = new byte[]{
                   (byte)(valeur >>> 24), (byte)(valeur >> 16 & 0xff), (byte)(valeur >> 8 & 0xff), (byte)(valeur & 0xff) };

           try {
                 //masque
                 InetAddress netAddr = InetAddress.getByAddress(bytes_masque);
                 System.out.println("Masque =\t" + netAddr.getHostAddress());
                        
            /*************************
             * Adresse réseau
             */
            //Convertir l'adresse IP en long
            long ipl = ipToLong(ip);
                
            //Convertir l'IP en un tableau de 32bits
            byte[] bytes_ip = new byte[]{
             (byte) ((ipl >> 24) & 0xFF),
            (byte) ((ipl >> 16) & 0xFF),
             (byte) ((ipl >> 8 ) & 0xFF),
             (byte) (ipl & 0xFF)};
           
            //Le ET logique entre l'adresse IP et le masque
            byte[] bytes_reseau = new byte[]{
                    (byte) (bytes_ip[0] & bytes_masque[0]),
                    (byte) (bytes_ip[1] & bytes_masque[1]),
                    (byte) (bytes_ip[2] & bytes_masque[2]),
                    (byte) (bytes_ip[3] & bytes_masque[3]),
            };
            //adresse réseau obtenue
            InetAddress adr_reseau = InetAddress.getByAddress(bytes_reseau);
            System.out.println("Adresse réseau =\t"+adr_reseau.getHostAddress());
           
            /********************************
             *Adresse de diffusion broadcast            
            */
            //adresse réseau - masque inversé ~val & 0xff
            //inverser le masque
            bytes_masque = new byte[]{
                    (byte) (~bytes_masque[0] & 0xff),
                    (byte) (~bytes_masque[1] & 0xff),
                    (byte) (~bytes_masque[2] & 0xff),
                    (byte) (~bytes_masque[3] & 0xff),
            };
            System.out.println("Masque inverse (Wildcard) =\t"+InetAddress.getByAddress(bytes_masque).getHostAddress());
           
            byte[] bytes_broadcast = new byte[]{
                    (byte) (bytes_reseau[0] | bytes_masque[0]),
                    (byte) (bytes_reseau[1] | bytes_masque[1]),
                    (byte) (bytes_reseau[2] | bytes_masque[2]),
                    (byte) (bytes_reseau[3] | bytes_masque[3]),
            };
            //adresse Broadcast obtenue
            InetAddress adrbroadcast = InetAddress.getByAddress(bytes_broadcast);
            System.out.println("Adresse de diffusion (Broadcast) =\t"+adrbroadcast.getHostAddress());
           
             } catch (UnknownHostException e) {
                    e.printStackTrace();
             }
       }

        public static long ipToLong(String ipAddress) { 
                long result = 0;   
                String[] ipAddressInArray = ipAddress.split("\\.");

                for (int i = 3; i >= 0; i--) {
                     long ip = Long.parseLong(ipAddressInArray[3 - i]);
                     result |= ip << (i * 8);
                }
                return result;
       }
}
Exécution:
Addresse = 35.204.121.13
Prefixe = 10
Masque = 255.192.0.0
Masque inverse (Wildcard) = 0.63.255.255
Adresse réseau = 35.192.0.0
Adresse de diffusion (Broadcast) = 35.255.255.255

Conaitre l'adresse IP du serveur sur le web

Il est aussi possible de connaitre l'adresse local de l'ordinateur et du serveur à partir d'une adresse web.

import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class AdresseServeur {
      
   public static void main(String[] zero) throws SocketException {
          
      String LocaleAdresse ;
      InetAddress ServeurAdresse;

      try{
          //Adresse locale
          LocaleAdresse = (String) InetAddress.getLocalHost().getHostAddress();
          System.out.println("L'adresse locale = "+LocaleAdresse );
                   
          //Adresse du serveur google
          ServeurAdresse= InetAddress.getByName("www.google.net");
          System.out.println("L'adresse du serveur Google = "+ServeurAdresse);
      } catch (UnknownHostException e) {
          e.printStackTrace();
      }
   }
}
Exécution:
L'adresse locale = 192.168.1.2
L'adresse du serveur Google = www.google.net/41.201.128.40


Partager cet article

Voir aussi: