//Fonction privée permettant de traiter une primitive venant de la couche transport
        private void traiterPrimitiveDeTransport(string strPrimitive)
        {
            //Affichage de la primitive reçue
            Utility.AfficherDansConsole("Reseau reçoit de transport : " + strPrimitive, Constantes.TRANSPORT_RESEAU_COLOR);

            //On sépare la primitive pour retrouver ses paramètres
            string[] split     = strPrimitive.Split(';');
            string   primitive = split [1];

            //Traitement de la primitive
            if (primitive == N_CONNECT.req.ToString())                                                  //APPEL DE CONNEXION-----------------
            {
                int addrSource = Convert.ToInt32(split [2]);

                if (addrSource % 27 != 0)                                                               //Le fournisseur internet accepte la connexion
                //Parametres : Adresse Source, Adresse Destination, NIEC
                {
                    ConnexionReseau conn = connexions.EtablirConnexion(Convert.ToInt32(split [2]), Convert.ToInt32(split [3]), Convert.ToInt32(split [0]));

                    //Parametres : NIEC, Adresse Source, Adresse Destination
                    PaquetAppel paquet  = new PaquetAppel(conn.getNumeroConnexion(), conn.getAdresseSource(), conn.getAdresseDestination());
                    Paquet      reponse = liaison.TraiterPaquetDeReseau(paquet);
                    TraiterPaquetDeLiaison(reponse, paquet, true);
                }
                else                                                                                                    //Le fournisseur internet refuse la connexion
                {
                    ConnexionReseau conn = connexions.findConnexionWithNIEC(Convert.ToInt32(split [0]));
                    //Parametres : NIEC, Primitive, Adresse Source, Adresse Destination
                    ecrire_vers_transport(split [0] + ";" + N_DISCONNECT.ind + ";" + split [3] + ";" + Constantes.RAISON_REFUS_FOURNISSEUR);
                }
            }
            else if (primitive == N_DATA.req.ToString())                                //ENVOI DE DONNÉES------------------
            {
                int             niec    = Convert.ToInt32(split [0]);
                String          donnees = split[2];
                ConnexionReseau conn;

                //Segmentation des données à envoyée
                //On vérifie d'abord s'il reste des données à envoyer, et si la connexion existe toujours (car la connexion peut être perdue
                //en cours de traitement
                while (donnees.Length > 0 && (conn = connexions.findConnexionWithNIEC(niec)) != null)
                {
                    int    count = Math.Min(donnees.Length, 128);
                    String data  = donnees.Substring(0, count);                                                                //On récupère au maximum 128 caractères de données
                    donnees = donnees.Remove(0, count);                                                                        //Et on l'enlève de la chaîne d'origine
                    int           m       = (data.Length == 128 ? 1 : 0);                                                      //Valeur de M : 0 - Il n'y a plus d'autre paquet à transmettre, 1 - Il y en a d'autre
                    PaquetDonnees paquet  = new PaquetDonnees(conn.getNumeroConnexion(), conn.getPR(), conn.getPS(), m, data); //Paquet de données
                    Paquet        reponse = liaison.TraiterPaquetDeReseau(paquet);
                    connexions.ModifierPS(conn.getNumeroConnexion(), 1);                                                       //Augmentation de la valeur de P(S)
                    TraiterPaquetDeLiaison(reponse, paquet, true);                                                             //Appel de la fonction pour traiter le paquet reçu de Liaison
                }
            }
            else if (primitive == N_DISCONNECT.req.ToString())                          //DÉCONNEXION
            {
                int niec = Convert.ToInt32(split [0]);
                //On retrouve la connexion et on la retire
                ConnexionReseau conn = connexions.findConnexionWithNIEC(niec);
                connexions.RetirerConnexion(conn);

                //Construction du paquet pour libérer la connexion du coté liaison
                PaquetDemandeLiberation paquet = new PaquetDemandeLiberation(conn.getNumeroConnexion(), conn.getAdresseSource(), conn.getAdresseDestination());
                liaison.TraiterPaquetDeReseau(paquet);
            }
        }
        //Fonction permettant de traiter un paquet reçu de la couche Liaison
        private void TraiterPaquetDeLiaison(Paquet reponse, Paquet origin, bool renvoi)
        {
            if (reponse == null)                        //Aucune réponse... Tentative de renvoi
            {
                if (renvoi)
                {
                    Utility.AfficherDansConsole("*Réseau : Aucune réponse de la couche liaison, tentative de renvoi...*", Constantes.ERREUR_COLOR);
                    reponse = liaison.TraiterPaquetDeReseau(origin);
                    TraiterPaquetDeLiaison(reponse, origin, false);
                }
                else
                {
                    deconnecterVoieLogique(origin.numero_connexion, "Aucune reponse du distant");
                }
            }
            else                                                        //Traitement de la réponse
            //Affichage du paquet reçu
            {
                Utility.AfficherDansConsole("Réseau recoit de Liaison : " + reponse.ToString(), Constantes.RESEAU_LIAISON_COLOR);

                ConnexionReseau conn;
                if (reponse is PaquetConnexionEtablie)                                          //Paquet de connexion établie----------------
                {
                    PaquetConnexionEtablie p = (PaquetConnexionEtablie)reponse;
                    conn = connexions.findConnexionWithNum(p.numero_connexion);
                    ecrire_vers_transport(conn.getNIEC() + ";" + N_CONNECT.conf + ";" + conn.getAdresseDestination());
                }
                else if (reponse is PaquetIndicationLiberation)                                 //Paquet d'indication de libération----------
                {
                    PaquetIndicationLiberation p = (PaquetIndicationLiberation)reponse;
                    conn = connexions.findConnexionWithNum(p.numero_connexion);
                    ecrire_vers_transport(conn.getNIEC() + ";" + N_DISCONNECT.ind + ";" + conn.getAdresseDestination() + ";" + p.raison);
                }
                else if (reponse is PaquetAcquittement)                                         //Paquet d'acquittement----------------------
                {
                    PaquetAcquittement p    = (PaquetAcquittement)reponse;
                    string             type = p.typePaquet.Substring(1);

                    if (type == Constantes.TYPE_PAQUET_ACQUITTEMENT_POSITIF)                        //Acquittement positif-----------------------
                    {
                        conn = connexions.findConnexionWithNum(reponse.numero_connexion);
                        ecrire_vers_transport(conn.getNIEC() + ";" + N_DATA.ind + ";" + conn.getAdresseSource() + ";" + conn.getAdresseDestination());
                        connexions.ModifierPR(reponse.numero_connexion, 1);                         //Modification du P(R) de la connexion
                    }
                    else                                                                            //Acquittement négatif - On tente de renvoyer le paquet
                    {
                        if (renvoi)
                        {
                            //Tentative de renvoi du paquet
                            Utility.AfficherDansConsole("*Réseau : Acquittement négatif de Liaison - Tentative de renvoi*", Constantes.ERREUR_COLOR);
                            Paquet p_rep = liaison.TraiterPaquetDeReseau(origin);
                            TraiterPaquetDeLiaison(p_rep, origin, false);
                        }
                        else
                        {
                            //Déconnexion de la voie logique
                            deconnecterVoieLogique(origin.numero_connexion, "Acquittement negatif");
                        }
                    }
                }
            }
        }
        //Fonction permettant de traiter un paquet reçu de la couche Réseau
        public Paquet TraiterPaquetDeReseau(Paquet paquet)
        {
            //Affichage du paquet reçu
            Utility.AfficherDansConsole("Liaison recoit de réseau : " + paquet.ToString(), Constantes.RESEAU_LIAISON_COLOR);
            Utility.EcrireDansFichier("L_ecr.txt", paquet.ToString(), true);

            //Traitement du paquet
            Paquet reponse = null;

            if (paquet is PaquetAppel)                      //Paquet d'appel----------------------------------
            {
                PaquetAppel p          = (PaquetAppel)paquet;
                int         addrSource = p.adresseSource;

                if (addrSource % 13 == 0)                                           //REFUS DE LA CONNEXION DU DISTANT
                {
                    reponse = new PaquetIndicationLiberation(p.numero_connexion, p.adresseSource, p.adresseDestination, Constantes.RAISON_REFUS_DISTANT);
                }
                else if (addrSource % 19 == 0)                                      //AUCUNE RÉPONSE DE LA COUCHE LIAISON
                {
                    reponse = null;
                }
                else                                                                        //ACCEPTATION DE LA CONNEXION
                {
                    connexions.AjouterConnexion(p.numero_connexion, p.adresseSource, p.adresseDestination);
                    reponse = new PaquetConnexionEtablie(p.numero_connexion, p.adresseSource, p.adresseDestination);
                }
            }
            else if (paquet is PaquetDonnees)               //Paquet de données----------------------------------
            {
                PaquetDonnees    p    = (PaquetDonnees)paquet;
                ConnexionLiaison conn = connexions.findConnexion(paquet.numero_connexion);
                int rdm = new Random().Next(8);
                if (conn.getAdresseSource() % 15 == 0)                                  //Pas de reponse-------------------------------------
                {
                    reponse = null;
                }
                else if (p.pS == rdm)                                                   //Acquittement négatif
                {
                    reponse = new PaquetAcquittement(p.numero_connexion, p.pR, false);
                }
                else                                                                                    //Acquittement positif
                {
                    Utility.AfficherDansConsole("Donnees bien recues : " + p.donnees, Constantes.OUTPUT_COLOR);
                    reponse = new PaquetAcquittement(p.numero_connexion, p.pR + 1, true);

                    //Écriture dans le fichier
                    donneesEnCours += p.donnees;

                    //Si M est égale à 0, cela veut dire que la couche réseau à bien transmis tout ses paquets de données
                    //On peut donc écrire la chaîne dans le fichier de sortie et la réinitialiser
                    if (p.M == 0)
                    {
                        Utility.EcrireDansFichier("S_ecr.txt", donneesEnCours, true);
                        donneesEnCours = "";
                    }
                }
            }
            else if (paquet is PaquetDemandeLiberation)     //Paquet Demande Liberation--------------------------
            {
                PaquetDemandeLiberation p = (PaquetDemandeLiberation)paquet;
                connexions.RetirerConnexion(p.numero_connexion);
            }

            //Écriture du paquet à envoyer dans le fichier de sortie L_lec.txt
            if (reponse != null)
            {
                Utility.EcrireDansFichier("L_lec.txt", reponse.ToString(), true);
            }

            return(reponse);
        }