MàJ Semaine du 17 au 23 novembre 2008

cours/G54/20081120-Seance1

@@ -0,0 +1,61 @@
+Jeudi, 20 nov 2008
+G54
+
+Séance 1 : Modélisation objet avancée, Présentation de la modélisation objet
+
+====== Présentation du programme ======
+
+===== Architecture 3 tiers =====
+
+Tout se centre autour d'une architecture 3 tiers, avec trois types d'objets : 
+
+  * interface (IHM)
+  * métier (logique applicative)
+  * peristance (SGBD)
+
+===== Architecture =====
+
+L'avenir du développement objet est d'avoir une plateforme de développement, comme si nous voulions compiler des modèles.
+
+Deux strates d'applications : 
+
+  * Concepteur métier : quelqu'un qui analyse (pas forcément du métier)
+  * Architecte logiciel : 
+
+Le but est de paramétrer chaque couche, afin d'agir sur le développement au niveau du PIM, de la plateforme.
+
+===== Petit historique =====
+
+En 1990, OMT (Roumbough) sortait, puis BOUCH sorti sa méthode (du même nom que son nom de famille), puis Jacobson s'est joint à eux pour sortir en 1997 UML.
+
+Object Management Group (OMG)
+
+===== Modeling =====
+
+UML est un langage visuel, graphique, mais c'est un langage !
+
+Il permet de :
+  * visualiser
+  * spécifiser
+  * structurer
+
+Mais UML n'est PAS UNE MÉTHODE.
+
+Il ne propose pas de démarche, mais seulement une façon de représenter les choses.
+
+====== Rappels ======
+
+===== 3 types de propriétés =====
+
+  * individuelles
+  * collectives : souligné, et préfixé par *s-* (ex: nombre d'étudiant, dans la classe étudiant)
+  * communes : souligné, et préfixé par *c-* (ex: nombre de pattes des insectes)
+
+===== DCC =====
+
+Généralement on procède dans l'ordre:
+  * DCA
+  * DPO
+  * DCC
+
+

cours/G54/20081120-Seance1~

@@ -0,0 +1,54 @@
+Jeudi, 20 nov 2008
+G54
+
+Séance 1 : Modélisation objet avancée, Présentation de la modélisation objet
+
+====== Présentation du programme ======
+
+===== Architecture 3 tiers =====
+
+Tout se centre autour d'une architecture 3 tiers, avec trois types d'objets : 
+
+  * interface (IHM)
+  * métier (logique applicative)
+  * peristance (SGBD)
+
+===== Architecture =====
+
+L'avenir du développement objet est d'avoir une plateforme de développement, comme si nous voulions compiler des modèles.
+
+Deux strates d'applications : 
+
+  * Concepteur métier : quelqu'un qui analyse (pas forcément du métier)
+  * Architecte logiciel : 
+
+Le but est de paramétrer chaque couche, afin d'agir sur le développement au niveau du PIM, de la plateforme.
+
+===== Petit historique =====
+
+En 1990, OMT (Roumbough) sortait, puis BOUCH sorti sa méthode (du même nom que son nom de famille), puis Jacobson s'est joint à eux pour sortir en 1997 UML.
+
+Object Management Group (OMG)
+
+===== Modeling =====
+
+UML est un langage visuel, graphique, mais c'est un langage !
+
+Il permet de :
+  * visualiser
+  * spécifiser
+  * structurer
+
+Mais UML n'est PAS UNE MÉTHODE.
+
+Il ne propose pas de démarche, mais seulement une façon de représenter les choses.
+
+====== Rappels ======
+
+===== 3 types de propriétés =====
+
+  * individuelles
+  * collectives : souligné, et préfixé par *s-* (ex: nombre d'étudiant, dans la classe étudiant)
+  * communes : souligné, et préfixé par *c-* (ex: nombre de pattes des insectes)
+
+

cours/P51/20081120-Seance1

@@ -0,0 +1,28 @@
+Jeudi, 20 nov 2008
+Séance 1
+
+====== Comparaison ======
+
+||PHP|Java|
+|Avantages|Framework émergents (Zend Framework) \\ Simpliste|Framework(Struts, hibernate, JFS, Spring, ...) \\ Culture industrielle \\ Facile de faire évoluer une application lourde \\ Généraliste |
+|Inconvénients|Culture amateuriste (Pas de gros framework établis) \\ Sources diffusées | Lourd (demande une grosse machine) \\ Plein de frameworks|
+
+====== Recherches sur le net ======
+
+  * Présentation des dépôts de code source
+  * Présentation de TRAC (gestion de suivi de projets)
+  * Présentation des outils de suivi de bugs
+  * Recherche sur mpy svn stats
+
+====== Explications ======
+
+  * Diverses explications sur les branches, les tags et la façon de fonctionner de SVN
+  * Découverte de l'intégration continue sur Wikipédia (lecture d'un site sur CruiseControl) : trouver le plus tôt possible les bugs
+    * http://fr.wikipedia.org/wiki/Int%C3%A9gration_continue
+    * http://www.agile-swiss.org/wiki/index.php?title=Integration_continue
+
+====== Intégration continue ======
+
+  * Hudson (logiciel java pour les compilations, etc) : http://www.agile-swiss.org/wiki/index.php?title=Integration_continue
+  * Sonar (logiciel java pour les tests unitaires) : http://sonar.codehaus.org/
+

cours/P51/20081121-Seance2

@@ -0,0 +1,140 @@
+21 novembre 2008
+Séance 2
+
+Les threads
+
+====== Cours ======
+
+Le but de ce cours est d'utiliser la puissance des nouveaux processeurs pour faire des applications rapides.
+
+threads = sous partie d'un processus, donc se lance plus vite qu'un processus et prend moins d'espace mémoire
+Faire un thread implique une nouvelle pile d'exécution et de nouveaux registres alloués.
+
+===== Les Threads, dans Java =====
+
+Dans la classe Java.lang.Thread, il faut l'interface *Runnable :*, et la méthode *run()* (qui ne prend pas d'arguments).
+
+Faire un thread en Java : 
+  * soit on étend (sous - classer) un thread (à l'aide d'extends)
+  * soit on implémente *Runnable* à notre classe Java.
+
+===== Comment choisir quelle méthode utiliser ? =====
+
+Comme Java n'accepte pas l'héritage multiple, mieux vaut implémenter qu'étendre si on a déjà étendu notre classe Java avec une autre.
+
+Implémenter "marche à tout les coups", contrairement à l'autre méthode.
+
+===== Gestion des priorités =====
+
+Si un thread n'est pas actif, il ne consommera pas de temps CPU, vu qu'il est mis de côté.
+
+MAX_PRIORITY et MIN_PRIORITY sont des variables définies dans la classe Thread.
+
+===== Concurrence d'accès =====
+
+Pour éviter l'interblocage, on utilise le mot clé *synchronized* pour gérer les concurrences d'accès.
+
+==== Concurrence d'accès sur une méthode ====
+
+Le <u>verrou est sur l'instance de la classe</u> et pas sur la classe elle même
+
+Mettre un verrou pour une instance d'un champ statique (static) n'est pas la bonne solution !!!
+
+==== Contrôler l'accès à un objet ====
+
+Utile si la classe a été créée sans être prévue/pensée pour les Threads.
+
+Ceci permet d'utiliser une classe dans des Threads.
+
+===== Groupes de Threads =====
+
+Seulement si on a beaucoup de threads (en faisant des *ThreadGroup*).
+
+Permet de lancer un ensemble de threads sans avoir à les instancier l'un après l'autre.
+
+====== Exercice ======
+
+===== Démonstration du cas de l'executor =====
+
+3 producteurs ont une liste de produits. Ils gèrent une file d'attente.
+
+Les consommateurs 1 et 2 tentent d'accéder à la file d'attente.
+
+Il faut gérer les processus inactifs et la synchronisation.
+
+* * *
+
+<code java>
+Executor ex = | Executors.new SingleThread();
+                        | Executors.new ThreadPool(2);
+
+for (int i=0 ; i < 1 000 ; i++)
+    ex.execute(new Runnable() {
+        public void run() {
+            System.out.println("o")
+        }
+    });
+
+</code>
+
+Dans les exécuteurs il n'y a pas de gestion de dépendances, donc on ne sait pas si le 5ième envoyé sera exécuté après le 4ième : ça faut le faire à la main.
+
+===== Cas d'interblocage =====
+
+Tout objet
+
+<code java>
+class DeadLock {
+    private final Object lock1 = new Object();
+    private final Object lock2 = new Object();
+
+    void a() throws Interrupted Exception {
+        lock1.wait();
+        lock2.notify();
+    }
+
+    void b() throws Interrupted Exception {
+        lock2.wait();
+        lock1.notify();
+    }
+}
+</code>
+
+Un thread appelle la méthode a() : 
+  * Le lock1 passe en attente.
+
+Un second thread appelle la méthode b() :
+  * Il se met en attente d'un notify (comme le lock1)
+
+Donc cela fait un verrou mortel, car on en sort pas. Pourquoi : 
+  * lock1 attend lock1.notify (qui est dans lock2)
+  * lock2 attend lock2.notify (qui est dans lock1, lui même en attente d'un notify)
+
+Nous sommes donc dans un DeadLock.
+
+===== Explications =====
+
+wait() : suspend un thread courant
+notify(): réactive UN thread qui a fait un *wait()* sur l'instance
+notifyAll(): réactiver TOUS les threads qui ont fait un *wait()* sur l'instance
+
+Quand un producteur aura fini de produire, il va activer UN thread pour le consommateur : pour pas mettre sur la paille le second consommateur.
+
+==== Arrêt d'un thread ====
+
+<code java>
+T1
+Object t2 ;
+t2.wait() ;
+</code>
+
+Dans ce cas, T1 s'arrête.
+
+<code java>
+T1
+Thread t2;
+t2.wait() ;
+</code>
+Ici c'est T2 qui s'arrête.
+
+

cours/P51/20081121-Seance2~

@@ -0,0 +1,127 @@
+21 novembre 2008
+Séance 2
+
+Les threads
+
+====== Cours ======
+
+Le but de ce cours est d'utiliser la puissance des nouveaux processeurs pour faire des applications rapides.
+
+threads = sous partie d'un processus, donc se lance plus vite qu'un processus et prend moins d'espace mémoire
+Faire un thread implique une nouvelle pile d'exécution et de nouveaux registres alloués.
+
+===== Les Threads, dans Java =====
+
+Dans la classe Java.lang.Thread, il faut l'interface *Runnable :*, et la méthode *run()* (qui ne prend pas d'arguments).
+
+Faire un thread en Java : 
+  * soit on étend (sous - classer) un thread (à l'aide d'extends)
+  * soit on implémente *Runnable* à notre classe Java.
+
+===== Comment choisir quelle méthode utiliser ? =====
+
+Comme Java n'accepte pas l'héritage multiple, mieux vaut implémenter qu'étendre si on a déjà étendu notre classe Java avec une autre.
+
+Implémenter "marche à tout les coups", contrairement à l'autre méthode.
+
+===== Gestion des priorités =====
+
+Si un thread n'est pas actif, il ne consommera pas de temps CPU, vu qu'il est mis de côté.
+
+MAX_PRIORITY et MIN_PRIORITY sont des variables définies dans la classe Thread.
+
+===== Concurrence d'accès =====
+
+Pour éviter l'interblocage, on utilise le mot clé *synchronized* pour gérer les concurrences d'accès.
+
+==== Concurrence d'accès sur une méthode ====
+
+Le <u>verrou est sur l'instance de la classe</u> et pas sur la classe elle même
+
+Mettre un verrou pour une instance d'un champ statique (static) n'est pas la bonne solution !!!
+
+==== Contrôler l'accès à un objet ====
+
+Utile si la classe a été créée sans être prévue/pensée pour les Threads.
+
+Ceci permet d'utiliser une classe dans des Threads.
+
+===== Groupes de Threads =====
+
+Seulement si on a beaucoup de threads (en faisant des *ThreadGroup*).
+
+Permet de lancer un ensemble de threads sans avoir à les instancier l'un après l'autre.
+
+====== Exercice ======
+
+===== Démonstration du cas de l'executor =====
+
+3 producteurs ont une liste de produits. Ils gèrent une file d'attente.
+
+Les consommateurs 1 et 2 tentent d'accéder à la file d'attente.
+
+Il faut gérer les processus inactifs et la synchronisation.
+
+* * *
+
+<code java>
+Executor ex = | Executors.new SingleThread();
+                        | Executors.new ThreadPool(2);
+
+for (int i=0 ; i < 1 000 ; i++)
+    ex.execute(new Runnable() {
+        public void run() {
+            System.out.println("o")
+        }
+    });
+
+</code>
+
+Dans les exécuteurs il n'y a pas de gestion de dépendances, donc on ne sait pas si le 5ième envoyé sera exécuté après le 4ième : ça faut le faire à la main.
+
+===== Cas d'interblocage =====
+
+Tout objet
+
+<code java>
+class DeadLock {
+    private final Object lock1 = new Object();
+    private final Object lock2 = new Object();
+
+    void a() throws Interrupted Exception {
+        lock1.wait();
+        lock2.notify();
+    }
+
+    void b() throws Interrupted Exception {
+        lock2.wait();
+        lock1.notify();
+    }
+}
+</code>
+
+Un thread appelle la méthode a() : 
+  * Le lock1 passe en attente.
+
+Un second thread appelle la méthode b() :
+  * Il se met en attente d'un notify (comme le lock1)
+
+Donc cela fait un verrou mortel, car on en sort pas. Pourquoi : 
+  * lock1 attend lock1.notify (qui est dans lock2)
+  * lock2 attend lock2.notify (qui est dans lock1, lui même en attente d'un notify)
+
+Nous sommes donc dans un DeadLock.
+
+===== Explications =====
+
+wait() : suspend un thread courant
+notify(): réactive UN thread qui a fait un *wait()* sur l'instance
+notifyAll(): réactiver TOUS les threads qui ont fait un *wait()* sur l'instance
+
+Quand un producteur aura fini de produire, il va activer UN thread pour le consommateur : pour pas mettre sur la paille le second consommateur.
+
+
+
+
+
+

cours/S5A/Seance6-22102008

@@ -0,0 +1,339 @@
+22 octobre 2008
+
+====== Réseaux et protocoles ======
+
+===== Le modèle OSI de l'ISO =====
+
+ISO : International Standard Organization
+
+OSI : Open System Interconnection
+
+En pratique le modèle OSI suit ceci : 
+
+|4 |Application (ftp, ssh, ...)|
+|3 |TCP / UDP|
+|2 |IP|
+|1 |Matériel|
+
+|4 |Application|
+|4 |Présentation|
+|4 |Session|
+|3 |Transport|
+|2 |Réseau|
+|1 |Liaison|
+|1 |Physique|
+
+| TCP | DATE ||
+
+| IP |TCP | DATA |||
+
+Quand on développe une application on travaille au niveau des sockets, donc juste au dessus de la couche transport, entre Session et transport.
+
+==== Physique : Codage ====
+
+Le codage est une suite de bits que nous voulons transformer (passage de l'analogique au numérique).
+
+Théorème de Fournier : Somme infinie de signaux sinusoïdaux.
+
+==== Liaison ====
+
+  * évitement de collision
+  * code correcteur
+  * adressage MAC
+
+==== Réseau ====
+
+  * Adressage IP => routage
+
+<code>
+         (_R2_)
+        /     \
+-->(_R1_)     (__)
+        \     /
+         (_R3_)
+</code>
+
+==== Transport ====
+
+  * Mécanisme datagramme, d'acquittements ...
+
+===== Adressage IPv4 =====
+
+Sur 4 octets (32bits)
+
+Notation "décimal pointé" A.B.C.D => unique
+
+Découpé en 2 : 
+
+  * adresse de réseau
+  * identification locale de la machine
+
+3 principales classes d'adresse :
+
+  * Classe A : 1.x.y.z à 127.x.y.z
+    * premier bit à 0
+    * 127 réseaux, 16 777 216 machines c'est à dire 2 puissance 24 machines
+  * Classe B : 128.0.x.y à 191.255.y.z
+    * premier bits à 10
+    * 16 384 réseaux, 65 536 machines ((191 - 128 + 1) x 256 )
+  * Classe C : 192.0.0.2 à 223.255.255.z
+    * premiers bits à 110
+    * 2 097 152 réseaux, 256 machines
+  * Classe D : réservée au multicast
+    * premiers bits à 1110
+  * Classe E : destiné à la recherche ... pour le futur ...
+
+==== Adresses non routables ====
+
+  * 10.0.0.0 --> 10.255.255.255
+  * 172.16.0.0 --> 172.31.255.255
+  * 192.168.0.0 --> 192.168.255.255
+
+  * 169.254.0.0 --> 169.254.255.255 : équivalent sous windows du serveur dhcp
+
+==== Adresse loopback ====
+
+  * 127.0.0.1 : pour la communication interne de la machine
+  * Tous les bits de la portée machine à 0 --> le réseau
+  * tous les bits de la portée machine à 1 --> broadcast
+  * 0.0.0.0 --> pour DHCP
+
+==== CIDR ====
+
+Classless Inter - Domain routing
+
+  * Notation de classe s'est avérée incompatible avec l'évolution de l'internet
+  * Cet adressage ne tient plus compte des classes globales et autorise l'utilisation de sous - réseaux au sein de chaque classe.
+  * Plus de découpage arbitraire et peu flexible en classe
+
+  * Notation : a.b.c.d/x => adresse/préfixe (nombre de bits pour l'adresse réseau, le rest est pour la machine)
+
+Exemple : 
+
+  * 130.79.90.72/32 => cette machine
+  * 130.79.90.72/16 => 2 puissance 16 machines
+
+On fait 2 puissance (32 - x), par exemple pour 130.79.90.72/8, ça fait 2 puissance 24 machines possibles.
+
+On utilise le principe de plus grande correspondance dans la table de routage.
+
+===== Le datagramme IP =====
+
+| 0 | 4 | 8 | 15 / 16 | 31 |
+|Version | IHL | Type de service | Longueur totale ||
+| Identification ||| Flags | Position Fragment |
+| TTL || Protocole | Checksum sur l'entête ||
+| @ SRC |||||
+| @DST |||||
+| DATA |||||
+
+  * Version du protocole IP
+  * IHL ou longueur de l'entête sur 4 bits : longueur en nombre de ??? de 32 bits de l'entête
+  * Type de service ou TOS : indique la manière dont le datagramme doit être traité
+    * 3 premiers bits sur la priorité
+    * 4 bits suivants (D,T,R,C) permet de signifier ce qu'on souhaite protéger
+  * Les champs identificateur, flags et position sont utilisés pour la fragmentation
+    * identificateur : numérotation de l'émetteur
+    * Flags : 
+      * 001 -> encore des fragments
+      * 000 -> dernier framgent
+      * 01x -> ne pas fragmenter
+    * position : positionnement du fragment dans le datagrame d'origine par multiple de 8 octets commançant par 0
+  * TTL : durée de vie, nombre maximal de routeurs que peut traverser le datagramme
+  * Protocole : permet de connaître le protocole de plus haut niveau :
+    * 1. ICMP
+    * 2. IGMP
+    * 6. TCP
+    * 17. UDP
+  * Checksum de l'entête : assume l'intégrité de l'entête
+  * Le champ option est de longueur variable mais toujours couplé par des bits de bourrage pour obtenir un mutliple de 32 bits
+
+===== ARP =====
+
+Adress Resolution Protocol
+
+RFC 826
+
+Permet d'associer une adresse IP à une adresse MAC.
+
+===== ICMP =====
+
+Internet Message Control Protocol
+
+  * RFC 792
+  * Implémentée dans tous les équipements IP
+  * Message encapsulé dans le DATA d'un datagramme IP
+
+| 0 | | 31 |
+| Type | Code | Checksum | 
+| Identifiant || N° de séquence |
+| Masque d'adresse |||
+
+Type sur 8 bits : 
+
+  * 0 : écho reply
+  * 3 : destination "unreachable"
+  * 4 : source quench (contrôle de flux)
+  * 5 : redirects
+  * 8 : echo request
+  * 11 : TTL exceeded
+  * 12 : parameter problem
+  * 13 : timestamp request
+  * 14 : timestamp reply
+  * 30 : traceroute
+
+  * Identifiant (16 bits) : identifie l'échange (en pratique souvent à 0)
+  * Numéro de séquence : qualifie les réponses / requêtes
+
+
+==== L'exemple de traceroute ====
+
+Principe :
+
+  * L'émetteur envoie un datagramme avec TTL=1
+  * Le premier routeur envoie un message de type 11
+  * L'émetteur affiche l'adresse du premier routeur
+  * Il recommence en incrémentant le TTL jusqu'à la destination.
+
+====== Décomposition des couches OSI ======
+
+===== Physique =====
+
+==== Fournier / harmoniques ====
+
+  * D = R log2 (V)
+  * Débit binaire
+  * Rapidité de modulation
+  * Valence
+
+<code>
+  R
+<--> 
+|---+    +----
+|   |    |
+|---+----+----
+|   |    |
+    +----+
+ <------->
+     T
+</code>
+
+D'après la formule de Nuquist, on peut aller en Rapidité Max (Rmax) jusqu'à 2 fois la largeur de bande, soit : 
+<code>
+Rmax : 2H
+</code>
+
+==== Shannon ====
+
+  * D = 71 log2 ( 1 + S / B)
+  * S : puissance du signal
+  * B : puissance du bruit
+
+==== Codage ====
+
+L'idée du codage est tout le temps bouger. Pour permettre la synchronisation, exemple le codage 3 quarts / 1 quart.
+
+À Manchester par exemple : 
+<code>
+  +--+    +---
+     |    |
+     |    |
+     |    |
+     |    |
+     +----+
+
+Côté 0 | Côté 1
+</code>
+
+===== Couche Liaison =====
+
+On va s'intéresser à deux aspects :
+
+  * Les collisions
+  * Code correcteur
+
+Réseau du plus petit au plus grand : 
+
+  * PAN : Bluetooth (ordi - portable)
+  * LAN : Bâtiment
+  * MAN : Échelle d'une ville
+  * WAN : Échelle national
+
+==== Collisions ====
+
+On va s'intéresser au réseau local (LAN). On partage un support (qui peut être physique). Chaque machine veut dialoguer entres elles. Si nous ne sommes pas en full duplex, cela peut créer des collisions (simultanément sur le même canal) : les harmoniques se mélangent, et le récepteur ne pourra plus rien comprendre.
+
+Protocole le plus utilisé dans les LAN : CSMA / CD (partage d'un support donné avec un délai entre chaque trame).
+
+==== Codes correcteurs ====
+
+Les codes correcteurs + les codes détecteurs.
+
+Il faut un code qui détecte une erreur, un autre pour corriger ladite erreur.
+
+Bit de parité : ( |___d____| |_c_| )
+
+  * on prend un mot (bits de données, d), et un bit de codage (c) = n bits de résultats
+  * le bit de codage doit être plus petit que les les bits de données
+
+Le bit de parité est assez simple.
+
+Codage linéaire = on peut le transformer en matrice.
+
+Code polynomial = codage linéaire. (le principe de Hamming est le plus joli, car il permet de trouver l'endroit de l'erreur)
+
+Distance de Hamming : distance minimale entre deux mots du code
+
+=== Codage polynomiaux ===
+
+10101 => X^4 + X^2 + X^0, on commence par X^0 pour le dernier bit à droite, puis on remonte.
+
+Ceci donne un polynôme générateur.
+
+  * Première étape, on décale en mettant des 0
+  * On prend le mot de base dont on a ajouté les 0, et on le divise par le polynôme. Puis on enlève on soustrait le reste de la division au mot de base ajouté des 0.
+
+==== Spanning Tree protocol ====
+
+Si on ne contrôle pas les données, on fait du broadcast storm (tempête de broadcast).
+
+Donc le spanning tree protocol est un algorithme qui permet de trouver comment supprimer le paquet qui revient.
+
+Il choisit une adresse mac comme racine de l'arbre, puis on choisit les chemins les plus courts. Et si 2 chemins sont de même longueur pour une même adresse MAC, on choisit en fonction du numéro parent le plus courts.
+
+===== Couche Réseau : Le routage =====
+
+Tout ce qui nous intéresse : les adresses.
+
+Il faut prendre en considération les :
+  * intra domaine : à travers IGP
+  * inter domaine : à travers BGP
+
+Dans le cas des BGP c'est parfois l'argent qui rend les choses plus lentes que le matériel lui même.
+
+As : Domaine régie par la même entité administrative (Free est un AS, système autonome).
+
+On va s'intéresser au routage dynamique (intra domaine). Il en existe deux : 
+
+  * vecteur de distance : RIP, IGRP (Cisco) : fait juste le nombre de sauts
+  * états des liens OSPF, ls-is, EIGRP (Cisco) : font attention à la capacité des liens
+
+Le dynamisme provient du fait qu'il recalcule les liens et la route si un lien tombe, sans qu'un administrateur ne soit derrière.
+
+===== Couche Transport =====
+
+Parlons de TCP.
+
+Le premier bit part. Au moment où il arrive, on a le temps de propagation (temps de départ du premier bit jusqu'à arrivée).
+
+Quand tout les bits d'un paquets sont arrivés, on a le temps d'émission.
+
+Temps total = temps de propagation + temps d'émission
+
+On met en place des délais, avec acquittement (ACK) : à chaque émission on enclenche un timer (débranché dès qu'on a l'acquittement).
+
+On a mis en place une autre méthode, nommée le **fenêtrage**. En gros c'est le temps qu'on patiente après avoir envoyé tant et tant de paquets. Ce qui réduit le nombre d'acquittements.
+
+Quand tout va bien on augmente de 1 le fenêtrage, si ça va mal on divise par 2 (on va plus vite dans la descente de débit que dans la montée de débit).
+
+

cours/S5A/TP/killall_blk.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+## Script permettant de tuer l'ensemble des processus portant le nom passé en argument
+
+parametre=$1
+
+if [ $parametre ] 
+then
+	if [ $parametre == "--help" ]
+	then
+		echo "Script permettant de tuer l'ensemble des processus portant le nom passé en argument"
+		echo -e "Pour utiliser ce script, faites : \n$0 [programme]\n"
+	else	
+		echo "Extinction des processus portant le nom '$parametre'"
+		for i in `pgrep -f $1`
+		do
+			kill -2 $i || kill -9 $i
+			echo "Processus $1 tué"
+		done
+	fi
+else
+	echo -e "Aucun paramètre.\nPour en savoir plus faites $0 --help"
+fi
+exit 0;

cours/S5A/TP/killall_blk.sh~

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+## Script permettant de tuer l'ensemble des processus portant le nom passé en argument
+
+parametre=$1
+
+if [ $parametre ] 
+then
+	if [ $parametre == "--help" ]
+	then
+		echo "Script permettant de tuer l'ensemble des processus portant le nom passé en argument"
+		echo -e "Pour utiliser ce script, faites : \n$0 parametre\n"
+	else	
+		echo "Extinction des processus portant le nom '$parametre'"
+		for i in `pgrep -f $1`
+		do
+			kill -2 $i || kill -9 $i
+			echo "Processus $1 tué"
+		done
+	fi
+else
+	echo -e "Aucun paramètre.\nPour en savoir plus faites $0 --help"
+fi
+exit 0;

cours/S5A/TP/largeur.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+## Script permettant un parcours en largeur d'une arborescence à partir du répertoire spécifié en argument numéro 1 et affiche chacun des répertoies rencontrés durant son parcours
+
+parametre=$1
+
+if [ $parametre ] 
+then
+	if [ $parametre == "--help" ]
+	then
+		echo "Script permettant un parcours en largeur d'une arborescence à partir du répertoire spécifié en argument numéro 1 et affiche chacun des répertoies rencontrés durant son parcours"
+		echo -e "Pour utiliser ce script, faites : \n$0 [répertoire]\n"
+	else
+		echo "Traitement en cours ..."
+
+		while [ $1 ]
+		do
+			echo "Passage dans $1"
+			resultat=`find $1 -maxdepth 1 -mindepth 1 -type d`
+			shift 1
+			set -- $* $resultat
+		done
+
+		echo "Traitement terminé."
+	fi
+else
+	echo -e "Aucun paramètre.\nPour en savoir plus faites $0 --help"
+fi
+exit 0;

cours/S5A/TP/largeur.sh~

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+## Script permettant un parcours en largeur d'une arborescence à partir du répertoire spécifié en argument numéro 1 et affiche chacun des répertoies rencontrés durant son parcours
+
+parametre=$1
+
+if [ $parametre ] 
+then
+	if [ $parametre == "--help" ]
+	then
+		echo "Script permettant un parcours en largeur d'une arborescence à partir du répertoire spécifié en argument numéro 1 et affiche chacun des répertoies rencontrés durant son parcours"
+		echo -e "Pour utiliser ce script, faites : \n$0 [répertoire]\n"
+	else
+		echo "Traitement en cours"
+
+		while [ $1 ]
+		do
+			echo $1
+			resultat=`find $1 -maxdepth 1 -mindepth 1 -type d`
+			shift 1
+			set -- $* $resultat
+		done
+	fi
+else
+	echo -e "Aucun paramètre.\nPour en savoir plus faites $0 --help"
+fi
+exit 0;

cours/S5A/TP/renomme_mp3.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+## Script permettant de ranger et renommer des MP3 donnés en argument dans une arborescence
+
+parametre=$1
+
+if [ $parametre ] 
+then
+	if [ $parametre == "--help" ]
+	then
+		echo "Script permettant de ranger et renommer des MP3 donnés en argument dans une arborescence"
+		echo -e "Pour utiliser ce script, faites : \n$0 [fichier1] [fichier2] ...\n"
+	else
+		chemin=`pwd`
+		while [ $1 ]
+		do
+			tag=`tail -c 128 $1`
+			groupe=`tail -c 128 $1 | cut -b 34-63`
+			annee=`tail -c 128 $1 | cut -b 94-97`
+			album=`tail -c 128 $1 | cut -b 63-93`
+			titre=`tail -c 128 $1 | cut -b 4-33`
+			stockage=`echo "$groupe/($annee) $album" | sed 's/ /\_/g'`
+			mkdir -p $stockage
+			nouveau_titre="`echo $titre | sed 's/ /\_/g'`.mp3"
+			adresse="$stockage/$nouveau_titre"
+			cp $1 $adresse
+			shift 1
+		done
+	fi
+else
+	echo -e "Aucun paramètre.\nPour en savoir plus faites $0 --help"
+fi
+
+
+exit 0;

cours/S5A/TP/renomme_mp3.sh~

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+## Script permettant de ranger et renommer des MP3 donnés en argument dans une arborescence
+
+parametre=$1
+
+if [ $parametre ] 
+then
+	if [ $parametre == "--help" ]
+	then
+		echo "Script permettant de ranger et renommer des MP3 donnés en argument dans une arborescence"
+		echo -e "Pour utiliser ce script, faites : \n$0 [fichier1] [fichier2] ...\n"
+	else
+		chemin=`pwd`
+		while [ $1 ]
+		do
+			tag=`tail -c 128 $1`
+			groupe=`tail -c 128 $1 | cut -b 34-63`
+			annee=`tail -c 128 $1 | cut -b 94-97`
+			album=`tail -c 128 $1 | cut -b 63-93`
+			titre=`tail -c 128 $1 | cut -b 4-33`
+#			echo "groupe: $groupe"
+#			echo "annee: $annee"
+#			echo "album: $album"
+#			echo "titre: $titre"
+			stockage=`echo "$groupe/($annee) $album" | sed 's/ /\_/g'`
+			mkdir -p $stockage
+			nouveau_titre="`echo $titre | sed 's/ /\_/g'`.mp3"
+			adresse="$stockage/$nouveau_titre"
+#			echo $nouveau_titre
+			cp $1 $adresse
+			shift 1
+		done
+	fi
+else
+	echo -e "Aucun paramètre.\nPour en savoir plus faites $0 --help"
+fi
+
+
+exit 0;

cours/S5A/TP/top10/liste_machines.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+## Script permettant d'avoir le top 10 des machines de chaque utilisateur
+
+	nombre_ligne=`last | wc -l`
+	nombre_reel=$(expr $nombre_ligne - 1 )
+
+	utilisateurs=`last | cut -d " " -f 1 | head -n $nombre_reel | sort | uniq -c | sort -r | head | tr -s " " | cut -d " " -f 3`
+
+	for i in $utilisateurs
+	do
+		echo $i
+		machines=`last -a $i | tr -s " " | cut -d " " -f 2 | sort | uniq -c | sort -r | head | tr -s " " | cut -d " " -f 3`
+		for j in $machines
+		do
+			if [ $j !=  "begins" ]
+			then
+				if [ $j != "" ]
+				then
+					echo -e "\t$j"
+				fi
+			fi
+		done
+	done

cours/S5A/TP/top10/liste_machines.sh~

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+## Script permettant d'avoir le top 10 des machines de chaque utilisateur
+
+	nombre_ligne=`last | wc -l`
+	nombre_reel=$(expr $nombre_ligne - 1 )
+
+	utilisateurs=`last | cut -d " " -f 1 | head -n $nombre_reel | sort | uniq -c | sort -r | head | tr -s " " | cut -d " " -f 3`
+
+	for i in $utilisateurs
+	do
+		echo $i
+		machines=`last -a $i | tr -s " " | cut -d " " -f 2 | sort | uniq -c | sort -r | head | tr -s " " | cut -d " " -f 3`
+		for j in $machines
+		do
+#			if [ $j !=  "wtmp" ]
+#			then
+#				if [ $j != "" ]
+#				then
+			echo -e "\t$j"
+#				fi
+#			fi
+		done
+	done

cours/S5A/TP/top10/top10.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+## Script permettant d'avoir le top 10 des utilisateurs ayant le plus grand nombre de connexions à cette machine
+
+	echo "Traitement en cours ..."
+	nombre_ligne=`last | wc -l`
+	nombre_reel=$(expr $nombre_ligne - 1 )
+
+	utilisateurs=`last | cut -d " " -f 1 | head -n $nombre_reel | sort | uniq -c | sort -r | head | tr -s " " | cut -d " " -f 3`
+	for i in $utilisateurs
+	do
+		if [ $i != "reboot" ]
+		then
+			echo -e "$i"
+		fi
+	done
+

cours/S5A/TP/top10/top10.sh~

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+## Script permettant d'avoir le top 10 des utilisateurs ayant le plus grand nombre de connexions à cette machine
+
+	echo "Traitement en cours ..."
+	nombre_ligne=`last | wc -l`
+	nombre_reel=$(expr $nombre_ligne - 1 )
+
+	utilisateurs=`last | cut -d " " -f 1 | head -n $nombre_reel | sort | uniq -c | sort -rn | head | tr -s " " | cut -d " " -f 3`
+	for i in $utilisateurs
+	do
+		if [ $i != "reboot" ]
+		then
+			echo -e "$i"
+		fi
+	done
+

cours/S5B/20081120-Seance1

@@ -0,0 +1,6 @@
+Séance 1 du 20 nov. 2008
+
+Présentation du programme de Sécurité des systèmes d'information
+
+Cf. Fichier PDF
+