- 2013-05-19 - Licence Fondamentale d'Informatique
mercredi 22 mai 2013

application de cours M.kalti LFI2


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.OleDb;
using System.Windows;
using System.Windows.Forms;

namespace ExempleCoursLFI2
{
    class DBConnection
    {       
        public static OleDbConnection GetConnection()
        {
            string strcnn = @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=OuvragesDB.accdb; Persist Security Info=False";
            return new OleDbConnection(strcnn);
        }
    }
  
    class Ouvrage
    {
        public int Inv;
        public string Titre;
        public string Auteur;
        public int AnneeEdition;
        public DateTime DateAchat;

        public Ouvrage()
        {

        }

        public Ouvrage(int i, string t, string a, int ae, DateTime da)
        {
            Inv = i;
            Titre = t;
            Auteur = a;
            AnneeEdition = ae;
            DateAchat = da;
        }
     }

    class DALOuvrage
    {
        public static void Insert(Ouvrage ouv)
        {
            OleDbConnection cnn = DBConnection.GetConnection();
            cnn.Open();
            string strsql = @"INSERT INTO Ouvrage VALUES(?,?,?,?,?)";
            OleDbCommand cmd = new OleDbCommand(strsql, cnn);           

            OleDbParameter pInv = new OleDbParameter("pInv", ouv.Inv);
            OleDbParameter pTitre = new OleDbParameter("pTitre", OleDbType.VarChar);
            pTitre.Value = ouv.Titre;

            OleDbParameter pAuteur = new OleDbParameter("pAuteur", OleDbType.VarChar);
            pAuteur.Value = ouv.Auteur;

            OleDbParameter pAnneeEdition = new OleDbParameter("pAnneeEdition", OleDbType.Integer);
            pAnneeEdition.Value = ouv.AnneeEdition;

            OleDbParameter pDateAchat = new OleDbParameter("pDateAchat", OleDbType.Date);
            pDateAchat.Value = ouv.DateAchat;

            cmd.Parameters.AddRange(new OleDbParameter[]{ pInv, pTitre, pAuteur, pAnneeEdition, pDateAchat });
        
            cmd.ExecuteNonQuery();
            cnn.Close();
         }

        public static void Delete(int Inv)
        {
            OleDbConnection cnn = DBConnection.GetConnection();
            cnn.Open();
            string strsql = @"DELETE FROM Ouvrage WHERE Inventaire = ?";
            OleDbCommand cmd = new OleDbCommand(strsql, cnn);

            OleDbParameter pInv = new OleDbParameter("pInv", Inv);
           
            cmd.Parameters.Add(pInv);
            cmd.ExecuteNonQuery();
            cnn.Close();
        }

        public static void Update(int OldInv, Ouvrage newOuv)
        {
            OleDbConnection cnn = DBConnection.GetConnection();
            cnn.Open();
            string strsql = @"UPDATE Ouvrage SET Inventaire =?, Titre =?, Auteur =?, AnneeEdition=?, DateAchat = ? WHERE Inventaire = ?";

            OleDbCommand cmd = new OleDbCommand(strsql, cnn);

            cmd.Parameters.Add(new OleDbParameter("pNewInv", newOuv.Inv));
            cmd.Parameters.Add(new OleDbParameter("pTitre", newOuv.Titre));
            cmd.Parameters.Add(new OleDbParameter("pAuteur", newOuv.Auteur));
            cmd.Parameters.Add(new OleDbParameter("pAnneeEdition", newOuv.AnneeEdition));
            cmd.Parameters.Add(new OleDbParameter("pDateAchat", newOuv.DateAchat));
            cmd.Parameters.Add(new OleDbParameter("pOldInv", OldInv));
            cmd.ExecuteNonQuery();
            cnn.Close();
        }

        public static Ouvrage SelectByInv(int Inv)
        {
            Ouvrage ouv = new Ouvrage();
            OleDbConnection cnn = DBConnection.GetConnection();
            cnn.Open();
            string strsql = @"SELECT * FROM Ouvrage WHERE Inventaire = ?";
            OleDbCommand cmd = new OleDbCommand(strsql, cnn);
            cmd.Parameters.Add(new OleDbParameter("pInv", Inv));
            OleDbDataReader rd = cmd.ExecuteReader();

            if (rd!=null)
            {
                if(rd.Read())
                {
                    ouv.Inv = rd.GetInt32(0);
                    ouv.Titre = rd.GetString(1);
                    ouv.Auteur = rd.GetString(2);
                    ouv.AnneeEdition = rd.GetInt32(3);
                    ouv.DateAchat = rd.GetDateTime(4);             
                }
            }
            return ouv;
        }

        public static List<Ouvrage> SelectAll()
        {
            List<Ouvrage> LesOuvrages = new List<Ouvrage>();
            OleDbConnection cnn = DBConnection.GetConnection();
            cnn.Open();
            string strsql = @"SELECT * FROM Ouvrage";
            OleDbCommand cmd = new OleDbCommand(strsql, cnn);
            OleDbDataAdapter DA = new OleDbDataAdapter(strsql, cnn);
            DataTable dt = new DataTable("Ouvrage");
            DA.Fill(dt);
            foreach (DataRow dr in dt.Rows)
            {
                LesOuvrages.Add(new Ouvrage((int)dr[0], dr[1].ToString(), dr[2].ToString(), (int)dr[3], (DateTime)dr[4]));                                                                                       
            }
            return LesOuvrages;
        }

        //public static List<Ouvrage> SelectByCriterium(string FieldName, string FieldValue)
        //{
        //}
    }

    class UserConsoleInterface
    {
        public static Ouvrage GetOuvrageFromInterface()
        {
            Ouvrage ouv = new Ouvrage();
            Console.WriteLine("\n **** Saisie d'un ouvrage **** ");
            Console.Write(" Inventaire  : ");
            ouv.Inv = Int32.Parse(Console.ReadLine());
            Console.Write(" Titre  : ");
            ouv.Titre = Console.ReadLine();
            Console.Write(" Auteur  : ");
            ouv.Auteur = Console.ReadLine();
            Console.Write(" Année d'édition  : ");
            ouv.AnneeEdition = Int32.Parse(Console.ReadLine());
            Console.Write(" Date d'achat  : ");
            ouv.DateAchat = DateTime.Parse(Console.ReadLine());           
            return ouv;
        }

        public static void ShowOuvrage(Ouvrage ouv)
        {
            Console.Write("\n Inventaire : " + ouv.Inv);
            Console.Write("\n Titre : " + ouv.Titre);
            Console.Write("\n Auteur : " + ouv.Auteur);
            Console.Write("\n Année d'édition : " + ouv.AnneeEdition);
            Console.Write("\n Date d'achat : " + ouv.DateAchat.ToShortDateString());           
        }

        static char ChoixAction()
        {
            char Choix=' ';
            do
            {
                Console.Clear();
                Console.WriteLine( "***************************************************** \n");
                Console.WriteLine( "                         MENU                         \n");
                Console.WriteLine( "  A : AJOUT" );
                Console.WriteLine( "  S : SUPPRESSION" );
                Console.WriteLine( "  M : MODIFICATION" );
                Console.WriteLine( "  C : CONSULTATION" );
                Console.WriteLine( "  Q : QUITTER" );

                Console.WriteLine( "\n*****************************************************" );
                Console.Write( "Donner votre choix : ");
                string str = Console.ReadLine();
                if(str.Length!=0)
                    Choix = Char.ToLower(str.Trim()[0]);
            }
            while (Choix != 'a' && Choix != 's' && Choix != 'm' && Choix != 'c' && Choix != 'q');
            return Choix;
        }

        public static void Menu()
        {
            char Choix;
            do
            { 
                Choix = ChoixAction();
                switch (Choix)
                {
                    case 'a':
                        {
                            Console.Clear();
                            Console.WriteLine( "\n************ Ajout ************" );
                            DALOuvrage.Insert(UserConsoleInterface.GetOuvrageFromInterface());                           
                            break;
                        }

                    case 's':
                        {
                            Console.Clear();
                            Console.WriteLine( "\n************ Suppression ************" );
                            Console.Write("\n\nDonner l'inventaire de l'ouvrage à supprimer : ");
                            DALOuvrage.Delete(Int32.Parse(Console.ReadLine()));                           
                            break;
                           
                        }

                    case 'm':
                        {
                            int Inv;
                            Console.Clear();
                            Console.WriteLine( "\n************ Modification ************" );
                            Console.Write("\n\nDonner l'inventaire de l'ouvrage à modifier : ");
                            Inv = Int32.Parse(Console.ReadLine());
                            UserConsoleInterface.ShowOuvrage(DALOuvrage.SelectByInv(Inv));                           
                            Console.WriteLine("\nDonner les nouvelles données de l'ouvrage :");
                            DALOuvrage.Update(Inv, UserConsoleInterface.GetOuvrageFromInterface());                           
                            break;
                        }

                    case 'c':
                        {
                            Console.Clear();
                            Console.WriteLine( "\n************ Consultation ************");
                            List<Ouvrage> LesOuvrages = DALOuvrage.SelectAll();
                            foreach (Ouvrage ouv in LesOuvrages)
                            {
                                Console.WriteLine("\n \n ------------------------- ");
                                UserConsoleInterface.ShowOuvrage(ouv);
                            }
                            Console.Read();
                            break;
                        }
                }
            } while (Choix != 'q');
        }
    }
 
    class Program
    {
   

        static void Main(string[] args)
        {          
            UserConsoleInterface.Menu();           
        }
    }
}

08:55
Read More
Publié par à 08:55 0 commentaires

tp : etudient avec language Dot.net










using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.OleDb;
namespace bdetudient
{
         class DataAccess
        {
          //   les fonctions sql 
         // requete  insert a la base de donnée   
            public static void AjouterEtudiant(OleDbConnection cnn, OleDbParameter parcin, OleDbParameter parnom, OleDbParameter parprenom, OleDbParameter pardate_naissance, OleDbParameter paradresse, OleDbParameter partelephone)
            {
                string S = "INSERT INTO ETUDIANT VALUES (?,?,?,?,?,?)";
                OleDbCommand cmd = new OleDbCommand(S, cnn);
                cmd.Parameters.Add(parcin);
                cmd.Parameters.Add(parnom);
                cmd.Parameters.Add(parprenom);
                cmd.Parameters.Add(pardate_naissance);
                cmd.Parameters.Add(paradresse);
                cmd.Parameters.Add(partelephone);
                cmd.ExecuteNonQuery();
                Console.WriteLine("ce bon");


            }

            // requete  insert a la base de donnée   
            public static void SupprimerEtudiant(OleDbConnection cnn, OleDbParameter parcin)
            {
                string strsql = "delete from etudiant where(cin=?)";
                OleDbCommand cmd = new OleDbCommand(strsql, cnn);
                cmd.Parameters.Add(parcin);
                cmd.ExecuteNonQuery();
                Console.WriteLine("ce bon");

            }
         
             // requete  insert a la base de donnée   
            public static void modifierEtudiant(OleDbConnection cnn, OleDbParameter parcin, OleDbParameter parcin2)
            {
                string strsql = "UPDATE  etudiant set cin= ? where cin = ?";
                OleDbCommand cmd = new OleDbCommand(strsql, cnn);
                cmd.Parameters.Add(parcin2);
                cmd.Parameters.Add(parcin);
                 cmd.ExecuteNonQuery();
                Console.WriteLine("ce bon");

            }

            public static void afficherEtudiant(OleDbConnection cnn)
            {
                string strsql = "SELECT * FROM  ETUDIANT ";
                OleDbCommand cmd = new OleDbCommand(strsql, cnn);
                OleDbDataReader rd = cmd.ExecuteReader();
                string s; string s2; string s3; string s4; string s5;
                Int16 ci;
                int i = 0;
                if (rd != null)
                {
                    while (rd.Read())
                    {

                      
                                               s = (string)rd[1];
                        s2 = (string)rd[2];
                        s3 = (string)rd[3];
                        s4 = (string)rd[4];
                        s5 = (string)rd[5];
                        ci = (Int16)rd["cin"];
                               i += 1;
                             //  Console.WriteLine(ci);
                        Console.WriteLine("                      etudiant " + i+":");
                        Console.WriteLine("                                 CIN  :" + ci );
                        Console.WriteLine("                                 nom :" + s );
                        Console.WriteLine("                                 prenom :" + s2 );
                        Console.WriteLine("                                 annee : " + s3);
                        Console.WriteLine("                                 adr : " + s4 );
                        Console.WriteLine("                                 tel :" + s5);
                               Console.WriteLine("             ");



                    }
              }
                Console.WriteLine("ce bon");
            }
          
             // appels de fonctions SQL
             // sasir ajouter
             public static void sasi_ajouter(OleDbConnection cnn)
            {
                Console.WriteLine(" ****** Ajouter Etudiant ******");

               
                string nom, prenom, date_naissance, adresse, telephone;
                int cin;
                cnn.Open();
                Console.WriteLine("| Donner le CIN :");
                cin = Int32.Parse(Console.ReadLine());
                OleDbParameter parcin = new OleDbParameter("cin", cin);
                Console.WriteLine("| Donner le Nom :");
                nom = Console.ReadLine();
                OleDbParameter parnom = new OleDbParameter("nom", nom);
                Console.WriteLine("| Donner le Prenom :");
                prenom = Console.ReadLine();
                OleDbParameter parprenom = new OleDbParameter("prenom", prenom);
                Console.WriteLine("| Donner l'annee :");
                date_naissance = Console.ReadLine();
                OleDbParameter pardate_naissance = new OleDbParameter("annee", date_naissance);

                Console.WriteLine("| Donner l'adresse :");
                adresse = Console.ReadLine();
                OleDbParameter paradresse = new OleDbParameter("adr", adresse);
                Console.WriteLine("| Donner numero de telphone :");
                telephone = Console.ReadLine();
                OleDbParameter partelephone = new OleDbParameter("tel", telephone);
                AjouterEtudiant(cnn, parcin, parnom, parprenom, pardate_naissance, paradresse, partelephone);
                cnn.Close();

            }
             // sasir ajouter
            public static void suprimer(OleDbConnection cnn)
            {
                Console.WriteLine(" *********** Supprimer  Etudiant ***********");
                string cin;
                cnn.Open();
                Console.WriteLine("donne le cin ade l'etudiant que voulez vous supprimer :");
                cin = Console.ReadLine();
                OleDbParameter parcin = new OleDbParameter("cin", cin);
                SupprimerEtudiant(cnn, parcin);
                cnn.Close();

            }
             // modifier
            public static int testcin(OleDbConnection cnn, Int16 cini, OleDbParameter parcin)
            {
                string strsql = "SELECT cin FROM  ETUDIANT Where cin = ? ";
                OleDbCommand cmd = new OleDbCommand(strsql, cnn);
                OleDbDataReader rd = cmd.ExecuteReader();
               
                cmd.Parameters.Add(parcin);
                Console.WriteLine(cini);
              
                int c = 0;
                if (rd != null)
                {
                     c = cini;
                }

               if ( c == cini)
                    return (1);// n'exister pas
                else
                    return (-1);// exister
            }
            public static void modifier(OleDbConnection cnn)
            {
                Console.WriteLine(" *********** modifier  Etudiant ***********");
                cnn.Open();

                Console.WriteLine("donne le CIN a de l'etudiant que voulez vous modifier :");
                string cin = Console.ReadLine();
                OleDbParameter parcin = new OleDbParameter("cin",cin);
                Int16 cini = Int16.Parse(cin);
              //--------------------------
                //Console.WriteLine( cin);
                //string strsql = "SELECT cin FROM  ETUDIANT Where cin = ? ";
                //OleDbCommand cmd = new OleDbCommand(strsql, cnn);
                //cmd.Parameters.Add(parcin);

                //OleDbDataReader rd = cmd.ExecuteReader();
             
             //----------------------
                if (testcin(cnn, cini, parcin) == 1) // exister
                {
                    Console.WriteLine("donne la Nouvelle CIN a de l'etudiant :");
                    //string cin2 = Console.ReadLine();
                    //OleDbParameter parcin2 = new OleDbParameter("cin", cin2);
                    //if (testcin(cnn, cini, parcin2) == -1)
                    //               {
                    //                   modifierEtudiant(cnn, parcin, parcin2);
                    //                  Console.WriteLine("ce bon");
                    //                }
                    //               else
                    //               {
                    //              Console.WriteLine("cind déja utliser");
                    //                  }
                }
                else
                {
                    Console.WriteLine("cin n'exister pas ,verifier votre choix");
                }
                cnn.Close();

            }

         
            public static void afficher(OleDbConnection cnn)
            {
                Console.WriteLine(" ****** afficher Etudiant ******");
                cnn.Open();
                afficherEtudiant(cnn);
                cnn.Close();
            }

            public static void choix2()
            {
                Console.WriteLine("tapez '1' pour return Menu:");
                Console.WriteLine("tapez '0' pour quitter:");
                Console.WriteLine("tapez votre choix:");
                int Choix = Int32.Parse(Console.ReadLine());
                switch (Choix)
                {
                    case 1:
                        {
                            System.Console.Clear();
                            Menu();

                        }; break;
                  
                    case 0:
                        break;
                }
            }
            public static void Menu ()
            {

                string str = @"provider=Microsoft.ace.OleDb.12.0; Data source=C:\Users\ahmedoumezzine\Documents\Visual Studio 2012\Projects\bdetudient\Base de données1.accdb";
                OleDbConnection cnn = new OleDbConnection(str);
            
                Console.WriteLine("\t\t\t     Menu Principale \n\n\n");
                Console.WriteLine("tapez 1 pour ajouter un etudiant:");
                Console.WriteLine("tapez 2 pour supprimer un etudiant:");
                Console.WriteLine("tapez 3 pour modifier un etudiant:");
                Console.WriteLine("tapez 4 pour afficher un etudiant:");

                Console.WriteLine("tapez 0 pour quitter:");
                Console.WriteLine("tapez votre choix:");
                int Choix = Int32.Parse(Console.ReadLine());
                 switch (Choix)
                {
                    case 1:
                        {
                            System.Console.Clear();
                            sasi_ajouter(cnn);
                            Console.WriteLine("     ");
                            Console.WriteLine("   ");
                            choix2();

                        };break;
                            case 2:
                          {
                              System.Console.Clear();
                              suprimer(cnn);
                              Console.WriteLine("     ");
                              Console.WriteLine("   ");
                              choix2();
                              System.Console.Clear();
                        };break;
                     case 3:
                         {
                             System.Console.Clear();
                              modifier(cnn);
                              Console.WriteLine("     ");
                              Console.WriteLine("   ");
                              choix2();
                              System.Console.Clear();
                        };break;
                     case 4:
                         {
                             System.Console.Clear();
                             afficher(cnn);
                             Console.WriteLine("     ");
                             Console.WriteLine("   ");
                             choix2();
                             System.Console.Clear();
                         }; break;
                     case 0:
                         break;
                }
                            }


            static void Main(string[] args)
            {


                string str = @"provider=Microsoft.ace.OleDb.12.0; Data source=C:\Users\ahmedoumezzine\Documents\Visual Studio 2012\Projects\bdetudient\Base de données1.accdb";
                OleDbConnection cnn = new OleDbConnection(str);

                Console.WriteLine("\n\n\t\t  Bienvenus  \n\n\n\n");
                Console.WriteLine("\n\n\t\t Taper Sur 'Entrer' pour Demarrer \n\n\n\n");
                Console.ReadKey();
                System.Console.Clear();
                Menu();
            }
        }
    }


   


08:52
Read More
Publié par à 08:52 0 commentaires
dimanche 19 mai 2013

Les classes d’adresses IP



Qu’est ce qu’une adresse IP?

Adresse IP (Internet Protocol): Une adresse IP est à l’inverse d’une @ MAC, uneadresse logique qui est configurable via le panneau de configuration puis connexion réseau. Une @ IP permet d’identifier une machine dans un réseau. Une adresse IP est composé de 32 bits et est codé en binaire.
Exemple d’adresse IP (binaire) : 1100 0000.1010 1000.0000 0000.0000 0001 =>192.168.0.1
Binaire : Le binaire est un système de numération qui utilise la base 2. C'est-à-dire qu’il y a deux valeurs possibles, qui sont le 0 et le 1 et que l’on appelle bit et 8 bits forment un octet.
Décimal
Binaire
0
0000
1
0001
2
0010
3
0011
4
0100
5
0101
La norme IPv4 (4 pour 4 octets soit 32 bits) permet d’identifier une machine sur un réseau, que ce soit un réseau public ou privé. Les adresses IP sont ainsi séparées en plusieurs classes : A, B, C, D et E.
Exemple d’adresse IP en binaire puis en décimal:
1100 0101.1010 1000.0000 1111.1010 1100 : 197.168.15.172
A quoi servent ces classes d’adresse et comment les distinguer ?
Tout d’abord, il faut savoir qu’une adresse IP est composée en deux parties :
· Une adresse réseau qui permet d’identifier l’adresse de sous réseau
· Une adresse hôte qui permet d’identifier la machine
Ce qu’il faut savoir avant de continuer : Une adresse IP qui a tous ces bits d’hôtes à 0 (par exemple 192.168.30.0) représente l’adresse du réseau. Elle ne peut pas être attribuée à une machine. En revanche lorsqu’une adresse IP a tous ces bits d’hôtes à 1 (par exemple 192.168.30.255), cela représente l’adresse de diffusion également appelébroadcast.
Ce qui diffère entre les classes, c’est le nombre d’adresse réseau et d’hôtes disponible.

Adresse de classe A :
Binaire :
Un adresse de classe A se code avec :
· 1 octet pour l’adresse réseau
· 3 octets pour l’adresse hôte
Soit XXXX XXXX. XXXX XXXX.XXXX XXXX.XXXX XXXX
Une adresse de classe A aura comme premier bit d’adresse réseau la valeur 0 en binaire.
Exemple :
0 XXX XXXX.XXXX XXXX.XXXX XXXX.XXXX XXXX est une adresse de classe A
1 XXX XXXX.XXXX XXXX.XXXX XXXX.XXXX XXXX n’est pas une adresse de classe A
Décimal :
Il est plus facile de comprendre les adresses IP lorsqu’elles sont écrites en décimal.
Les adresses de classe A ont le premier octet (en décimal) de l’adresse réseau compris entre 1 à 126, car l’adresse réseau des classes A est codée sur un octet.
Une astuce pour reconnaitre les classes d’adresses IP lorsqu’elles sont écrites en décimal est de regarder le premier nombre d’une adresse, s’il est compris entre 1 et 126, c’est alors une adresse de classe A, s’il est compris entre 128 et 191, c’est une classe B et entre 192 et 223, c’est une classe C.
Exemple :
79.20.69.230 est une adresse de classe A
192.168.0.69 n’est pas une adresse de classe A
Calcul du nombre d’adresse :
Pour calculer le nombre d’adresse réseau disponible dans une classe A, il suffit de faire le calcul (2^7)-2=126
Explication : Il y a 2^7 (de 00000000 à 01111111 avec 7 bits pouvant être à 1) possibilités de réseaux, soit 128 possibilités. Or le réseau 0 (premier octet valant 00000000) n'existe pas et l’adresse 127 est réservée pour désigner votre machine (me demandez pas pourquoi !), c’est pour cela que l’on ôte 2 au nombre d’adresses de réseaux et que l’on obtient en tout 126 réseaux.
Pour calculer le nombre d’adresse hôtes disponible dans une classe A, on utilise le même principe de calcul, mais ici sur les 3 octets restants, on arrive donc au calcul suivant :
2^(8+8+8 ) -2 = 2^(24)-2 = 16 777 214 adresses hôtes !
Remarque : Il ne faut pas oublier d’enlever l’adresse avec tous les bits d’hôtes à 0 (adresse du réseau) et celle à tous les bits d’hôtes à 1 (adresse de broadcast), soit 2 adresses.
Il existe dans chaque classe d’adresse, des adresses privées réservées à la création de réseaux locaux, car dans une entreprise, la plupart du temps, il n’y a qu’un seul accès Internet qui est partagé sur les différents PC. Les adresses privées permettent de créer des réseaux plus ou moins gros, et c’est dans cette optique que l’on va choisir d’utiliser un réseau privé de classe A, B ou C.
Adresses privées de classe A : de 10.0.0.1 à 10.255.255.254 soit 16 777 214 machines dans un réseau local (Hey les gars, on se fait un CS?)
On retrouve dans les adresses de classes A, les grosses entreprises qui ont besoin d’adresser beaucoup de machines comme par exemple Google, les FAI (Neuf, Free dont toutes les adresses commencent par 88,etc.) mais bizarrement Microsoft n’a pas une adresse de classe A, mais une de B. (bizarre non?)


Adresse de classe B :
Maintenant que l’on a vu avec les adresses de classe A comment le découpage binaire marchait, cela ne va pas être dur de comprendre les adresses de classe B.
Binaire :
Une adresse de classe B se code avec :
· 2 octets pour l’adresse réseau
· 2 octets pour l’adresse hôte
Soit XXXX XXXX. XXXX XXXX.XXXX XXXX.XXXX XXXX
Une adresse de classe B aura ses deux premiers bits d’adresse réseau de valeur 10 en binaire.
Ex : 10 XX XXXX.1010 1110. XXXX XXXX.XXXX XXXX
Décimal :
Les adresses de classe B ont le premier octet (en décimal) de l’adresse réseau compris entre 128 à 191, plus précisément entre 128.0 et 191.255 car l’adresse réseau des classes B est codée sur deux octets.
Ex : 136.56.0.30 est une adresse de classe B
Calcul du nombre d’adresse :
Le nombre d’adresse réseau est plus important que pour les adresses de classe A, puisqu’elle est codée non plus sur un mais deux octets, soit 2^14 (10 000000 00000000 à 10 111111 11111111 avec 16-2=14 bits pouvant être à 1) soit un total de 16384 adresses réseaux. Les deux bits en moins sont les 2 premiers qui restent inchangés.
Le nombre d’adresse hôtes est aussi codée sur 2 octets, soit (2^16) -2 = 65534 hôtes possible.
Remarque : Il ne faut pas oublier d’enlever l’adresse avec tous les bits d’hôtes à 0 (adresse du réseau) et celle à tous les bits d’hôtes à 1 (adresse de broadcast), soit 2 adresses.
Adresse privée de classe B : de 172.16.0.1 à 172.31.255.254 soit 1 048 574 adresses hôtes.

Adresse de classe C :
Qui n’a jamais fait un réseau local et utilisé l’adresse 192.168.0.X. Pas vous? Bon beh je vais expliquer tout ca !
Binaire :
Une adresse de classe C se code avec :
· 3 octets pour l’adresse réseau
· 1 octet pour l’adresse hôte
Soit XXXX XXXX. XXXX XXXX.XXXX XXXX.XXXX XXXX
Une adresse de classe C aura ses trois premiers bits d’adresse réseau de valeur 110 enbinaire.
Ex : 110 1 1011.1010 1110.0011 0110.XXXX XXXX
Décimal :
Les adresses de classe C ont le premier octet (en décimal) de l’adresse réseau compris entre 192 à 223, plus précisément entre 192.0.0 et 223.255.255 car l’adresse réseau des classes C est codée sur trois octets.
Ex : 192.168.30.8 est une adresse de classe C
Calcul du nombre d’adresse :
Le nombre d’adresse réseau est encore plus important que pour les classes B,puisqu’elle est codé sur 21 bits (24bits – 3 inchangés = 21) soit 2^21 = 2097152 adresses réseaux.
Le nombre d’adresse hôtes est en revanche plus petit que pour une classe B car il est codé sur un octet, soit (2^8 ) -2 =254. Il ne faut pas oublier d’enlever l’adresse avec tous les bits d’hôtes à 0 (adresse du réseau) et celle à tous les bits d’hôtes à 1 (adresse de broadcast), soit 2 adresses.
Adresses privées de classe C : de 192.168.0.1 à 192.168.0.254 soit 254 machines dans un réseau local.
Remarque : Une adresse de classe C n’est pas routable (ne peut pas passer un routeur) !
En résumé :
Classe
Début IP
Fin IP
Nb réseau
Nb hôtes
Début IP privé
Fin IP privé
A
1.0.0.0
126.255.255.255
126
16 777 214
10.0.0.1
10.255.255.254
B
128.0.0.0
191.255.255.255
16384
65534
172.16.0.1
172.31.255.254
C
192.0.0.0
223.255.255.255
2097152
254
192.168.0.1
192.168.0.254
Je ne parlerais que très peu des adresses de classe D et E car elles sont très peu utilisées.
Classe D : Adresses multicast, elles permettent la transmission pour une vidéo conférence par exemple. Les adresses réseaux vont de 224 à 231.
Classe E : Ce sont des adresses de test réservés pour le futur.
Maintenant que les classes d’adresses sont bien comprises (enfin j’espère) il est temps d’expliquer le principe et le fonctionnement des masques de sous-réseau.
(J’ai pris l’explication du site www.commentcamarche.net car elle est très bien faite et j’y ai modifié quelques trucs qui à mon goût mérite d’être approfondis).
En résumé, on fabrique un masque contenant des 1 aux emplacements des bits que l'on désire conserver, et des 0 pour ceux que l'on veut annuler. Une fois ce masque créé, il suffit de faire un ET logique entre la valeur que l'on désire masquer et le masque afin de garder intacte la partie que l'on désire et annuler le reste.
Ainsi, un masque réseau (en anglais netmask) se présente sous la forme de 4 octets séparés par des points (comme une adresse IP), il comprend (dans sa notation binaire) des zéros au niveau des bits de l'adresse IP que l'on veut annuler (et des 1 au niveau de ceux que l'on désire conserver).
Intérêt d'un masque de sous-réseau
Le premier intérêt d'un masque de sous-réseau est de permettre d'identifier simplement le réseau associé à une adresse IP.
En effet, le réseau est déterminé par un certain nombre d'octets de l'adresse IP (1 octet pour les adresses de classe A, 2 pour les adresses de classe B, et 3 octets pour la classe C).
Chaque classe possède un masque par défaut :
  • Pour une adresse de Classe A, seul le premier octet doit être conservé. Le masque possède la forme suivante 11111111.00000000.00000000.00000000, c'est-à-dire255.0.0.0 en notation décimale ;
  • Pour une adresse de Classe B, les deux premiers octets doivent être conservé, ce qui donne le masque suivant 11111111.11111111.00000000.00000000, correspondant à 255.255.0.0 en notation décimale ;
  • Pour une adresse de Classe C, avec le même raisonnement, le masque possédera la forme suivante 11111111.11111111.11111111.00000000, c'est-à-dire255.255.255.0 en notation décimale.

    • Or, un réseau est noté en prenant le nombre d'octets qui le caractérise, puis en complétant avec des 0. Le réseau associé à l'adresse 34.56.123.12 est par exemple34.0.0.0, car il s'agit d'une adresse IP de classe A.
    Pour connaître l'adresse du réseau associé à l'adresse IP 34.56.123.12, il suffit donc d'appliquer un masque dont le premier octet ne comporte que des 1 (soit 255 en notation décimale), puis des 0 sur les octets suivants.
    Le masque est: 11111111.00000000.00000000.00000000
    Le masque associé à l'adresse IP 34.208.123.12 est donc 255.0.0.0.
    La valeur binaire de 34.208.123.12 est: 00100010.11010000.01111011.00001100
    Principe du ET logique :
    ET
    0
    1
    0
    0
    0
    1
    0
    1
    Soit :
    0 ET 0 = 0
    0 ET 1 = 0
    1 ET 0 = 0
    1 ET 1 = 1
    Un ET logique entre l'adresse IP et le masque donne ainsi le résultat suivant :
    00100010.11010000.01111011.00001100
                                   ET
    11111111.00000000.00000000.00000000
                                   =
    00100010.00000000.00000000.00000000
    Soit 34.0.0.0. Il s'agit bien du réseau associé à l'adresse 34.208.123.12

    Création de sous-réseauxReprenons l'exemple du réseau 34.0.0.0, et supposons que l'on désire que les deux premiers bits du deuxième octet permettent de désigner le réseau.
    Le masque à appliquer sera alors     :
    11111111.11000000.00000000.00000000

    C'est-à-dire 255.192.0.0
    Si on applique ce masque, à l'adresse 34.208.123.12 on obtient :
    34.192.0.0
    En réalité il y a 4 cas de figures possibles pour le résultat du masquage d'une adresse IP d'un ordinateur du réseau 34.0.0.0
  • Soit les deux premiers bits du deuxième octet sont 00, auquel cas le résultat du masquage est34.0.0.0
  • Soit les deux premiers bits du deuxième octet sont 01, auquel cas le résultat du masquage est34.64.0.0
  • Soit les deux premiers bits du deuxième octet sont 10, auquel cas le résultat du masquage est34.128.0.0
  • Soit les deux premiers bits du deuxième octet sont 11, auquel cas le résultat du masquage est34.192.0.0
    • Ce masquage divise donc un réseau de classe A (pouvant admettre 16 777 214 ordinateurs) en 4 sous-réseaux - d'où le nom de masque de sous-réseau - pouvant admettre 2^22 ordinateurs, c'est-à-dire 4 194 304 ordinateurs.
    Il peut être intéressant de remarquer que dans les deux cas, le nombre total d'ordinateurs est le même, soit 16 777 214 ordinateurs (4 x 4194304 - 2 = 16777214).
    Le nombre de sous-réseaux dépend du nombre de bits attribués en plus au réseau (ici 2). Le nombre de sous-réseaux est donc :
    Nb bits
    Nb sous-réseaux
    1
    2
    2
    4
    3
    8
    4
    16
    5
    32
    6
    64
    7
    128
    8
    256

    Création du masque selon des contraintes
    Pour les deux exemples suivants, j’utiliserai l’adresse de réseau 192.168.10.0 de masque par défaut 255.255.255.0
    Imaginons que nous voulions créer des sous réseaux pouvant accueillir au maximum 8 machines.
    Il va donc falloir résoudre la petite équation 2^X >= 8 où X représente le nombre de bits dans la partie hôte (en partant de la fin) où va être codé le masque.
    Dans ce cas, X = 3 donc il y aura 3 bits à 0 pour identifier les hôtes, le reste des bits seront à 1, soit un masque à 255.255.255.248. (Car 1111 1000 en binaire donne 248 en décimal)
    Vérification : en vert les bits de masques et en violet les bits d’hôtes
    192.168.10.00000 000 soit 192.168.10.0
    192.168.10.00001 000 soit 192.168.10.8
    192.168.10.00010 000 soit 192.168.10.16
    192.168.10.00011 000 soit 192.168.10.24
    Etc…
    On remarque que dans chaque sous-réseau nous avons 8 adresses hôtes disponible (mais véritablement 6 car il faut enlever l’adresse du réseau et l’adresse du broadcast)
    Décomposition du 2ème sous-réseau :
    Adresse sous-réseau : 192.168.10.8 (192.168.10.00001 000)
    Adresse de broadcast : 192.168.10.15 (192.168.10.00001 111)
    Nb hôtes adressable : 6
    Adressage possible des hôtes : 192.168.10.9 à 192.168.10.14
    Autre cas de figure, on veut créer 17 sous réseaux.
    Toujours la même équation 2^X>= 14 ou X va représenter cette fois le nombre de bits dans la partie hôte (en partant du début) où va être codé le masque.
    Dans ce cas, X = 4 (car 16>14), donc il y aura 4 bit au début de la partie hôte pour identifier le sous-réseau soit un masque de 255.255.255.224 (car 1111 0000 en binaire donne 224 en décimal)

    Vérification : en vert les bits de masques et en violet les bits d’hôtes:
    192.168.10.0000 0000 soit 192.168.10.0
    192.168.10.0001 0000 soit 192.168.10.16
    192.168.10.0010 0000 soit 192.168.10.32
    192.168.10.0011 0000 soit 192.168.10.48
    192.168.10.0100 0000 soit 192.168.10.64
    Etc…
    Si l’on continue jusqu’à arriver à 256, on comptera en tout 16 sous-réseau, donc si on n’utilise pas les deux derniers, nous avons nos 14 sous-réseaux.
    Décomposition du 3ème sous réseau :
    Adresse sous-réseau : 192.168.10.32 (192.168.10.0010 0000)
    Adresse de broadcast : 192.168.10.47 (192.168.10.0010 1111)
    Nb hôtes adressable : 14
    Adressage possible des hôtes : 192.168.10.33 à 192.168.10.46
    Notation CIDR (Classless Inter-Domain Routing) :
    La notation CIDR permet d’écrire autrement le masque d’une adresse. Il se place à la fin de l’adresse réseau de cette façon : 192.168.10.0/24 pour un masque en 255.255.255.0.
    Fonctionnement du CIDR :
    Un masque de sous-réseau est toujours avec des bits à 1 continu. Ce qui veut dire que l’on ne peut pas trouver un masque tel que 255.255.255.(1011 0100), un masque sera toujours de la forme 255.255.255.1110 0000 ou 255.255.255.1111 100 etc…, il n’y aura jamais de 0 entre les 1. Pour calculer un CIDR, il faut juste compter le nombre de bits à 1 dans le masque.
    Ainsi un masque en 255.255.255.0 se notera /24.
    Exemple d’écriture: l’adresse 192.168.10.0 de masque 255.255.255.0 devient 192.168.10.0/24
    Voilà c’est tout pour les classes d’adresses IP et les masques, ce n’est pas facile de comprendre du premier coup, mais j’ai essayé de rendre ça le plus compréhensible que j’ai pu.
    11:18
    Read More
    Publié par à 11:18 0 commentaires
    Inscription à : Articles (Atom)
     
    -