MASTER INFORMATIQUE
Architecture LOGICIELLE
Exercices
Année 2021-2022
Table des matières
2 Les sockets ............................................................................................................................. 3
2.1 Premières sockets ..................................................................................................................... 3
2.2 Plusieurs échanges .................................................................................................................... 4
2.3 Communication à plusieurs ....................................................................................................... 4
2.4 Taille des données inconnue ..................................................................................................... 4
2.5 Sans bibliothèque ...................................................................................................................... 5
2.6 Bibliothèque de socket connectées .......................................................................................... 5
2.7 Synchronisation et blocages...................................................................................................... 5
2.8 Communication structurée ....................................................................................................... 5
ii
[Link] – Module Architecture Logicielle
2 Les sockets
Nous avons regroupé dans cette partie les exercices des deux chapitres sur les sockets.
2.1 Premières sockets
Dans cet exercice nous allons utiliser les extraits de code vu en cours pour réaliser une
première application avec des sockets.
Positionnez-vous dans le répertoire sockets/premieres, il y a deux fichers :
fonctionsSocket.h et fonctionsSocket.c. Le premier est le fichier d’entête définissant le
prototype des fonctions socket simplifiée et des valeurs associées. Le second contient le code
de ces fonctions.
1. Composer les parties de code données dans le cours pour passer une valeur entière entre
deux sockets non-connectées et une chaîne de caractère entre deux sockets connectées.
2. Faire l’inverse : la chaîne en mode non-connecté et la valeur en mode connecté.
3. Passer un tableau d’entiers entre deux programmes dans chacun des modes.
4. Réaliser le passage des différents types de données : tableaux, structures et types définis
par le programmeur.
Ecrire vos programmes dans le répertoire sockets/premieres.
Pour compiler un programme monPrgm.c qui utilise notre bibliothèque de sockets, vous
devez utiliser la commande :
gcc -o monPrgm monPrgm.c fonctionsSocket.o
... ou faire un Makefile.
Pour exécuter les programmes, créer deux fenêtres shell, positionner-vous dans le
répertoire sockets/premieres et lancer l’exécution de chacun des programmes dans des fenêtres
différentes. En mode non-connecté, le programme récepteur doit être lané en premier. En mode
connecté, c’est le serveur qui doit être lané en premier.
[Link] – Module Architecture Logicielle
2.2 Plusieurs échanges
Dans l’exercice précédent, nous nous sommes contentés de faire un échange entre les deux
programmes. Dans cet exercice nous mettons en place plusieurs échanges pour établir une
vraie communication. Nous utilisons le mode connecté.
1. Compléter les progammes échangeant la chaîne de caractères de manière à ce que le
récepteur de la chaîne retourne la taille de celle-ci à l’émetteur.
2. Ecrire les programmes de manière à ce que l’émetteur de la chaîne saisisse celle-ci au
clavier avant de l’envoyer. Nous supposerons que la taille maximale de la chaîne est de
256 caractères.
3. Modifier les programmes de manière à répéter l’échange tant que la chaîne envoyée n’est
pas “fin”. Dans ce cas, fermer proprement la connexion entre les deux programmes sans
retourner de réponse.
4. Modifier le premier programme de l’exercice de manière à ce qu’il envoie
successivement cinq chaînes de caractères, sans attendre de retour du récepteur. Une fois
les chaînes reçues, le récepteur retourne un tableau contenant les différentes tailles des
chaînes.
2.3 Communication à plusieurs
Écrire trois programmes qui communiquent sous la forme d’un anneau : le premier envoie
ses messages au deuxième, qui les envoie au troisième. C’est le premier programme qui initie
la communication. Par la suite, un programme ne communique avec le suivant que s’il a reçu
un message de son prédécesseur.
1. Quel mode de communication est-il préférable d’utiliser?
2. Comment garantir que les identifications utilisées pour les sockets sont correctes si les
programmes sont lancés par des personnes différentes sur des machines différentes?
3. Comment permettre qu’aucun des programmes ne soit bloqué par les autres?
4. Écrire les programmes.
2.4 Taille des données inconnue
Dans cet exercice, nous souhaitons mettre en place une communication avec des tailles de
données inconnues.
Utiliser les programmes en mode connecté réalisés à l’exercice 2.2 pour réaliser une
communication où la taille de la chaîne n’est pas fixée :
1. Quelle est l’incidence sur les programmes client et serveur?
2. Proposer deux solutions différentes pour réaliser cet échange,
3. La solution est-elle différente si les programmes échangent un tableau d’entiers?
A partir de cet exercice nous vous recommandons de préparer le chapitre “Les sockets des
experts”.
[Link] – Module Architecture Logicielle
2.5 Sans bibliothèque
Reécrire les programmes des exercices 2.1 et 2.3 sans utiliser la bibliothèque fonctionsSocket, seulement
avec les fonctions de l’interface socket standard.
2.6 Bibliothèque de socket connectées
Ecrire le code des fonctions socketClient( machine, port) et socketServeur( port ) qui permettent
de créer de manière simple les sockets en mode connecté.
2.7 Synchronisation et blocages
Écrire un programme serveur et deux programmes clients de manière à ce que le serveur affiche
le message du client qui envoie le premier.
Sans utiliser de fonctions non-bloquante ni la fonction select :
1. Écrire les programmes en mode non-connecté,
2. Écrire les programmes en mode connecté.
Écrire les mêmes programmes avec des fonctions non-bloquantes puis avec la fonction select.
Quels sont les avantages des deux méthodes?
2.8 Communication structurée
Écrire un programme serveur, qui permet de réaliser les quatre opérations arithmétiques de base
(+,-,*,/) pour le compte d’un client.
Le serveur ne traite qu’un client qui envoie des opérations élémentaires :
1. Quel problème se pose pour la constitution d’un message et quelles solutions? Proposer
plusieurs solutions.
2. Ecrire le programme serveur.
3. Ecrire le programme client.
4. Comment permettre à un client d’effectuer l’opération : (4*5) + (34 /2)
5. Comment permettre à un client d’envoyer un nombre quelconque d’opérations à effectuer et de
terminer sans affecter le serveur.
6. Quels sont les cas d’erreur possibles? Apporter des solutions de manière à garantir la sécurité
du serveur.
Le serveur traite plusieurs clients :
1. Adapter le serveur pour qu’il soit accessible après la fin de l’exécution du programme
client et serve un second client?
2. Adapter le serveur pour qu’il puisse servir d’autres clients avant que le premier ne soit
terminé? Proposer des solutions avec les sockets non-bloquantes et avec la fonction select.
[Link] – Module Architecture Logicielle 4
