The Linux Craftsman - Contributions [fr]

Atmega328 registers

2018-11-01T18:46:54Z

Magsss : /* Performances */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on n'a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 positions vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifié avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le fait de savoir si le jeu en vaut la chandelle. Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registres est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:46:35Z

Magsss : /* Performances */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on n'a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 positions vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifié avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le fait de savoir si le jeu en vaut la chandelle. Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:45:35Z

Magsss : /* Lecture d'état */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on n'a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 positions vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifié avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:44:13Z

Magsss : /* Modification de sens */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on n'a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 positions vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:41:53Z

Magsss : /* Passage à 1 */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on n'a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 positions vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:40:12Z

Magsss : /* Comment manipuler un registre ? */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on n'a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:38:24Z

Magsss : /* Comment manipuler un registre ? */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voilà, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:38:00Z

Magsss : /* Comment manipuler un registre ? */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier son état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voila, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:37:21Z

Magsss : /* Comment manipuler un registre ? */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on a identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier sont état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voila, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:36:48Z

Magsss : /* Le cas de l'ATmega328 */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5ème bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on à identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier sont état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voila, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:36:14Z

Magsss : /* Le cas de l'ATmega328 */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogiques font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5émé bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on à identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier sont état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voila, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:35:13Z

Magsss : /* Introduction */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voilà, la manipulation de registres ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registres implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in fine, elles vont elles-mêmes manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogique font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5émé bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on à identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier sont état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voila, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

Atmega328 registers

2018-11-01T18:33:22Z

Magsss : /* Introduction */

= Introduction =
Lorsque l'on commence à écrire des programmes qui sortent de l'ordinaire ou que l'on veut pousser un microcontrôleur à la limite de ses capacités, il est obligatoire de descendre au niveau des registres.
Seulement voila, la manipulation de registre ne s'improvise pas, nécessite de connaître le hardware que l'on utilise et, de par sa nature, est '''spécifique''' à un type de microcontrôleur !

Manipuler les registre implique donc de sacrifier la portabilité du code, offerte par l'utilisation des fonctions ''haut niveau'' comme ''digitalWrite()'', au profit de la vitesse d'exécution et de la compacité du code.

Les fonctions comme ''digitalWrite()'', ''digitalRead()'', ''pinMode()'' permettent au développeur d'accomplir une action sans avoir à se soucier du type de microcontrôleur utilisé mais, in finé, elle vont elle même manipuler les registres pour accomplir ces tâches !

= Le cas de l'ATmega328 =
{|
|-
|valign="top"|
L'AtMega328 est le microcontrôleur utilisé sur les Arduino Uno, pro, nano et bon nombre de circuits électroniques d'autres marques ! Ci à droite, l'association entre le nom des broches et leurs positions dans le registre.

On peut remarquer que :
* les broches D0, D1, D2, D3, D4, D5 et D6 font partie du groupe '''D''' (P'''D''');
* les broches D8, D9, D10, D11, D12 et D13 font partie du groupe '''B''' (P'''B''');
* les broches analogique font partie du groupe '''C''' (P'''C''').
A chacun de ces groupes on peut associer trois registres :
* PORT → pour positionner l'état du port (HIGH ou LOW);
* PIN → pour lire l'état d'un port;
* DDR ('''D'''ata '''D'''irection '''R'''egister) → pour positionner le sens d'un port (INPUT, OUTPUT);
On se retrouve donc avec 9 registres manipulables:
* PORTD, PIND et DDRD pour les broches D0, D1, D2, D3, D4, D5 et D6;
* PORTB, PINB et DDRB pour les broches D8, D9, D10, D11, D12 et D13;
* PORTC, PINC et DDRC pour les broches analogiques.
La position du bit dans le registre est déterminé par le numéro attenant à la lettre du groupe. Par exemple, si on prend le cas de la broche D13, c'est le 5émé bit du groupe B (PB'''5''')
[[Fichier:Mapping D13 atmega328.png]]
.
||
[[Fichier:Atmega328 pin mapping.png|centré]]
|}

= Comment manipuler un registre ? =
Maintenant que l'on à identifié le groupe et la position du bit des broches dans les registres, nous pouvons passer à la manipulation !

Reprenons l'exemple de la broche D13. Pour modifier sont état, il suffit de modifier la valeur de PORTB:
<source lang="c">
PORTB = B00100000; // pour mettre D13 à HIGH
PORTB = B00000000; // pour mettre D13 à LOW
</source>
Seulement voila, on sait que sa position dans les registres correspond au bit numéro 6 mais on a absolument aucune idée de la valeur de PORTB au moment de la modification !
La manipulation précédente va certainement modifier l'état de D13 mais va aussi modifier l'état des autre broches du groupe '''B'''. On ne peut donc pas agir de la sorte, il faut utiliser un opérateur logique pour modifier les registres et on va distinguer deux cas de figures: le passage à ''1'' et celui à ''0''.

== Passage à ''1'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''OU''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB |= B00100000; // pour mettre seulement D13 à HIGH
</source>
Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB |= B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ou||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de OU
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A OU B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
1
|-
|align="center"|
1
|align="center"|
0
|align="center"|
1
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''(1<<5)'' ou même la constante prévue à cet effet ''(1<<PB5)''.
Le chiffre ''1'' est un entier qui s'écrit en binaire comme cela:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||0||0||0||0||0||1
|}
Il nous suffit donc de le décaler de 5 position vers la gauche pour obtenir B00100000:
{|align="center"
|-
||position||7||6||5||4||3||2||1||0
|-
||valeur||0||0||1||0||0||0||0||0
|}
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB |= B00100000;
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>
|}

== Passage à ''0'' ==
{|
|-
|valign="top" width="40%"|
Pour modifier l'état d'un registre à ''1'' sans modifier l'état des autres registres nous allons utiliser l'opérateur ''ET''.

Si on reprend l'exemple précédent, nous allons plutôt faire cela:
<source lang="c">
PORTB &= ~B00100000; // pour mettre seulement D13 à LOW
</source>
L'opérateur ''~'' permet d'obtenir le [https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_un complément A1] d'un nombre binaire: B00100000 devient alors B11011111.

Imaginons que PORTB est la valeur suivante ''B00010101'', PORTB &= ~B00100000 revient à faire:
{|align="center"
|-
||||0||0||0||1||0||1||0||1
|-
||ET||1||1||0||1||1||1||1||1
|-
|colspan="9"|<hr>
|-
||||0||0||0||1||0||1||0||1
|}
On a donc réussi à modifier la valeur de D13 sans modifier l'état des autres broches !
|width="1%"|
|width="12%" valign="top"|
Table de vérité de ET
{|border="1"
|-
|width="60px" align="center"|
A
|width="60px" align="center"|
B
|width="60px" align="center"|
A ET B
|-
|align="center"|
0
|align="center"|
0
|align="center"|
0
|-
|align="center"|
0
|align="center"|
1
|align="center"|
0
|-
|align="center"|
1
|align="center"|
0
|align="center"|
0
|-
|align="center"|
1
|align="center"|
1
|align="center"|
1
|}
|width="1%"|
|valign="top" width="40%"|
On peut également effectuer cette manipulation par décalage de bit. Dans l'exemple précédent nous avons utilisé ''~B00100000'' pour faire le OU mais on aurait pu utiliser l'écriture ''~(1<<5)'' ou même la constante prévue à cet effet ''~(1<<PB5)''..
Les trois écritures suivantes sont donc équivalentes:
<source lang="c">
PORTB &= ~B00100000;
PORTB &= ~(1<<5);
PORTB &= ~(1<<PB5);
</source>
|}

= Modification de l'état d'une broche =
Dans l'exemple suivant nous allons modifier l'état de la broche D13 pour la faire clignoter.
==Modification de sens ==
Dans un premier temps il faut la placer en sortie et pour cela nous allons manipuler le registre ''DDRB'':
* la valeur ''1'' positionne la broche en sortie (''OUTPUT'');
* la valeur ''0'' positionne la broche en entrée (''INPUT''), si la l'état est positionné à ''1'' cela active la résistance de ''pullup'' (''INPUT_PULLUP'').
Nous allons donc modifier le registre DDRB comme suit, les trois notations sont équivalentes:
<source lang="c">
DDRB |= B00100000; // Positionnement de D13 en OUTPUT
DDRB |= (1<<5);
DDRB |= (1<<PB5);
</source>

==Modification d'état ==
On peut maintenant modifier son état grâce au registre PORTB:
<source lang="c">
PORTB |= B00100000; // Positionnement de D13 à HIGH
PORTB |= (1<<5);
PORTB |= (1<<PB5);
</source>

==Lecture d'état==
{|
|-
|valign="top" width="50%"|
Il est possible de lire l'état de la broche D13 grâce au registre ''PINB''. Nous allons utiliser la même technique du masquage que précédemment avec l'opérateur ''ET''.
Imaginons que PINB est la valeur suivante ''B00110101'', PINB &= B00100000 revient à faire:
{|align="center"
|-
||||0||0||1||1||0||1||0||1
|-
||ET||0||0||1||0||0||0||0||0
|-
|colspan="9"|<hr>
|-
||||0||0||1||0||0||0||0||0
|}
|width="1%"|
|valign="top" width="50%"|
On va donc retirer l'état des autres broches sans modifier pour autant celui de la broche D13 !
Il ne nous reste plus qu'à décaler ce bit de 5 positions vers la droite pour pouvoir le lire.

Les deux écritures suivantes sont équivalentes:
<source lang="c">
uint8_t state;
state = (PINB & B00100000) >> 5;
state = (PINB & B00100000) >> PB5;
</source>
|}
<hr>
{|
|-
|valign="top" width="50%"|
Rien n’empêche d'utiliser cela pour faire des tests:
<source lang="c">
// Modification de D13 en sortie
DDRB |= B00100000;
// Passage de D13 à HIGH
PORTB |= (1 << PB5);
if ((PINB & B00100000) >> PB5) {
Serial.println("D13 is ON");
}
// Passage de D13 à LOW
PORTB &= ~(1 << PB5);
if ((PINB & B00100000) >> PB5 == 0) {
Serial.println("D13 is OFF");
}
</source>
|width="1%"|
|valign="top" width="50%"|
Lorsque l'on exécute le code suivant on s'aperçoit que rien ne s'affiche. La raison est simple, la modification de registre est tellement rapide que l'état électrique n'a pas le temps d'être modifier avant la lecture !

Il suffit d'ajouter:
<source lang="c">
delay(1);
</source>
Avant les lignes modifiant les états:
<source lang="c">
...
PORTB |= (1 << PB5);
...
PORTB &= ~(1 << PB5);
...
</source>
|}

= Performances =
La '''véritable''' interrogation réside dans le faite de savoir si le jeu en vaut la chandelle ? Est-il intéressant de sacrifier la simplicité d'écriture et la compréhension du code pour la performance ?

Pour faire un test probant, allumons la led présente sur D13 100.000 fois avec:
* dans un premier temps ''pinMode()'' et ''digitalWrite()'';
* dans un second temps ''DDRB'' et ''PORTB'';

{|width="100%"
|-
|valign="top" width="50%"|
Voila le premier test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
pinMode(13, OUTPUT);
for (uint32_t i = 0; i < LIMIT; i++) {
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''2138''' octets et le résultat est:
<pre>
Temps d’exécution: 709
</pre>
|width="1%"|
|valign="top" width="50%"|
Voila le deuxième test:
<source lang="c">
#define LIMIT 100000
void setup() {
Serial.begin(9600);
int32_t timer = millis();
DDRB |= (1<<PB5);
for(uint32_t i = 0; i < LIMIT; i++){
PORTB |= (1<<PB5);
PORTB &= ~(1<<PB5);
}
int32_t elapsed = millis() - timer;
Serial.print("Temps d'exécution: ");
Serial.println(elapsed);
}
void loop() {
}
</source>
Le croquis utilise '''1844''' octets et le résultat est:
<pre>
Temps d’exécution: 62
</pre>
|}
On peut constater que le code utilisant les registre est non seulement plus léger ('''13,67%''') mais également plus rapide ('''11.42''' fois) !

C socket

2018-11-01T18:31:58Z

Magsss : /* Performances */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaie de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par là que les clients envoient un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>

= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situations de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmi:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le fait de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenue par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.

=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurait pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le fait de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme a complètement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:30:51Z

Magsss : /* Gestion des utilisateurs */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaie de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par là que les clients envoient un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>

= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situations de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmi:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le fait de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenue par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.

=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:29:27Z

Magsss : /* Utilisation */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaie de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par là que les clients envoient un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>

= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situations de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmi:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:29:06Z

Magsss : /* Utilisation */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaie de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par là que les clients envoient un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>

= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situations de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:28:22Z

Magsss : /* Serveur UDP */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaie de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par là que les clients envoient un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>

= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:27:13Z

Magsss : /* Lecture */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:26:05Z

Magsss : /* Mode connecté (TCP) */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieure à ''0'' elle correspond au nombre d'octets reçus.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:22:17Z

Magsss : /* Écriture */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:20:43Z

Magsss : /* Lecture */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:20:07Z

Magsss : /* Fonctions spécifiques */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemblent aux précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volée''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:19:35Z

Magsss : /* Modification */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondant à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemble au précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volé''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:19:07Z

Magsss : /* Écriture */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyés ou ''-1'' si une erreur survient (errno est positionné);

===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondants à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemble au précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volé''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:18:41Z

Magsss : /* Lecture */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères où mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçus ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);
===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondants à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemble au précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volé''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:09:07Z

Magsss : /* Côté serveur */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'en-tête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)

== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);
===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondants à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemble au précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volé''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C socket

2018-11-01T18:08:28Z

Magsss : /* Introduction */

= Introduction =
{|
|-
||
Les sockets permettent de connecter deux programmes qui s'exécutent sur deux machines différentes. Cette connexion se fait à travers le réseau grâce à l'utilisation d'un port (TCP ou UDP) et d'une adresse IP.

Il y a deux types de sockets, une qui est démarrée par la partie serveur en ''écoute'' et l'autre démarrée par la partie cliente qui se connecte à la première.

Ci-contre une image résumant les différentes étapes pour arriver à l'envoi de données.
||
[[Fichier:Socket workflow.png|centré|200px]]
|}

= Création =
== Côté serveur ==
Tout d'abord il faut créer l'objet socket:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int socket(int domain, int type, int protocol)
</source>
*domain → integer, communication domain e.g., AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
*type → type de communication
**SOCK_STREAM: TCP
**SOCK_DGRAM: UDP
**SOCK_RAW: socket à l'état brut (bas niveau)
*protocol → valeur du champ ''protocol'' de l'entête de niveau 3 (généralement ''0'')
*la valeur de retour est le fichier descripteur de la socket ou ''-1'' en cas d'erreur (''errno'' est positionnée)

Une fois le descripteur de socket créé, il est possible de le configurer:
<source lang="c">
#include <sys/socket.h>
#include <netinet/in.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen)
</source>
* sockfd → le fichier descripteur de la socket;
* level → niveau d'application de l'option (SOL_SOCKET, TCP, UDP, ...);
* optname → le nom de l'option (''SO_REUSEADDR'', ''SO_REUSEPORT'', ''SO_KEEPALIVE'', ...)
* optval, optlen → utilisé pour accéder aux options de la socket;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)
Il existe plusieurs options de socket, les plus utilisées étant :
* ''SO_REUSEADDR'' → permet de réutiliser l'adresse de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_REUSEPORT'' → permet de réutiliser le port de la socket tout de suite même si cette dernière est dans l'état ''wait'';
* ''SO_KEEPALIVE'' → envoie des informations périodiquement pour tester si l'extrémité du tunnel est toujours présente;

Il faut maintenant attacher la socket à un port Internet et une adresse IP:
<source lang="c">
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse
<source lang="c">
struct sockaddr_in {
short sin_family; // e.g: AF_INET
unsigned short sin_port; // e.g: htons(3490)
struct in_addr sin_addr; // détaillé ci-dessous
char sin_zero[8]; // '0' habituellement
};
struct in_addr {
unsigned long s_addr; // initialiser avec inet_aton()
};
</source>
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant passer la socket en état d'écoute, elle est prête à recevoir des connexions:
<source lang="c">
int listen(int sockfd, int backlog)
</source>
* sockfd → le fichier descripteur de la socket;
* backlog → taille maximum de la file d'attente de la socket après laquelle le système répond avec ''ECONNREFUSED'';
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

On peut maintenant attendre une connexion:
<source lang="c">
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → l'adresse du client;
* addrlen → la taille de la structure addr;
* le code retour varie entre un entier positif qui correspond au descripteur de la socket cliente et ''-1'' en cas d'erreur (''errno'' est positionnée)
== Côté client ==
Après avoir créé la socket avec ''socket'' on peut se connecter à la partie serveur:
<source lang="c">
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* addr → une structure symbolisant l'adresse (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour varie entre ''0'' et ''-1'' en cas d'erreur (''errno'' est positionnée)

= Lecture / écriture =
== Fonctions génériques ==
Tout d'abord, on peut dire que la socket est un fichier et se manipule donc comme un fichier !
===Lecture===
Pour lire dans une socket on peut utiliser ''read'':
<source lang="c">
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''write'':
<source lang="c">
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);
===Modification===
Pour modifier un descripteur fichier de socket on utilise ''fcntl'':
<source lang="c">
#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* int args */ );
</source>
* sockfd → le fichier descripteur de la socket;
* cmd → la commande de modification (descripteur, drapeaux, ...);
* args → les arguments correspondants à la commande

Cette commande va nous permettre de modifier le drapeau du descripteur de la socket (''F_SETFL'') pour le rendre non bloquant (''O_NONBLOCK'') !

== Fonctions spécifiques ==
Il existe des fonctions spécifiques pour manipuler les sockets. Ces fonctions ressemble au précédentes mais acceptent des drapeaux en plus pour pouvoir modifier le descripteur ''à la volé''.
===Lecture===
Pour lire dans une socket on peut utiliser ''recv'':
<source lang="c">
#include <unistd.h>

ssize_t recv(int fd, void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);
===Écriture===
Pour écrire dans une socket ou peut utiliser ''send'':
<source lang="c">
#include <unistd.h>

ssize_t send(int fd, const void *buf, size_t count, int flags);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_CONFIRM'', ''MSG_DONTWAIT '', ...);
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Cas d'utilisation =
== Création ==
Pour commencer, il faut créer le descripteur de fichier:
<source lang="c">
int fdsocket;
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Paramétrage des options ==
Il faut maintenant configurer la réutilisation de l'adresse et du port
<source lang="c">
int opt = 1;
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Attachement ==
On peut maintenant attacher la socket à un port et une adresse:
<source lang="c">
struct sockaddr_in adresse;

adresse.sin_family = AF_INET;
// Ecoute sur toutes les adresses (INADDR_ANY <=> 0.0.0.0)
adresse.sin_addr.s_addr = INADDR_ANY;
// Conversion du port en valeur réseaux (Host TO Network Short)
adresse.sin_port = htons(8080);

if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>

== Mise en écoute ==
La socket est prête à passer à l'écoute des connexions des clients:
<source lang="c">
// Taille de la file d'attente
#define BACKLOG 3

if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
</source>
== Acceptation des connexions ==
Il est possible d'accepter les nouvelles connexions:
<source lang="c">
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse, (socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
}
</source>
Il est possible d'utiliser ''fcntl'' pour passer le descripteur de la socket en non bloquant, avant l'appel à la fonction ''accept''. Si le descripteur reste bloquant, la fonction ''accept'' ne rendra pas la main tant qu'un client ne se sera connecté, ayant pour résultat le blocage complet du programme !
<source lang="c">
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
</source>
On peut remarquer, au passage, l'utilisation de ''inet_ntop'' pour convertir l'adresse du client du format binaire au format text.

== Lecture / Écriture ==
=== Mode connecté (TCP) ===
On peut maintenant utiliser le descripteur de la socket du client pour lire et écrire.
* avec les fonctions génériques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];
// Passage en mode non bloquant, sinon read attend
fcntl(clientSocket, F_SETFL, O_NONBLOCK);
int len = read(clientSocket, buffer, BUFFER_LEN);

send(clientSocket, "Coucou\n", strlen("Coucou\n"));
</source>
* avec les fonctions spécifiques:
<source lang="c">
#define BUFFER_LEN 200
// Descripteur de la socket du client
int clientSocket;
char buffer[BUFFER_LEN];

int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

send(clientSocket, "Coucou\n", strlen("Coucou\n"), MSG_DONTWAIT);
</source>

Analysons le retour de la fonction ''read'' ou ''recv'' lorsque l'on utilise un descripteur non bloquant d'après la [http://man7.org/linux/man-pages/man2/recvmsg.2.html documentation] :
<pre>
NAME
recv, recvfrom, recvmsg - receive a message from a socket
[...]
MSG_DONTWAIT (since Linux 2.2)
Enables nonblocking operation; if the operation would block, the call fails with the error EAGAIN or EWOULDBLOCK (this can also be enabled using the O_NONBLOCK flag with the F_SETFL fcntl(2)).
[...]
RETURN VALUE
[...]
These calls return the number of bytes received, or -1 if an error
occurred. In the event of an error, errno is set to indicate the
error.
When a stream socket peer has performed an orderly shutdown, the
return value will be 0 (the traditional "end-of-file" return).
[...]
</pre>
Le retour est :
* lorsque le descripteur est vide (aucune donnée de la part du client) ''-1'' et ''errno'' sera positionné à la valeur ''EAGAIN'', il ne faut donc pas fermer la socket si le retour est ''-1'' ! Il faut d'abord vérifier que ''errno'' '''n'a pas''' la valeur ''EAGAIN'';
* lorsque le retour est ''0'', cela signifie que l'extrémité est fermée, il faut donc fermer le descripteur local;
* lorsque la valeur est supérieur à ''0'' elle correspond au nombre d'octets reçu.

On peut donc en déduire le morceau de code suivant pour gérer le retour de ''read'' ou ''recv'':
<source lang="c">
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);

if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
} else if (len > 0) {
// Le client à envoyé des données
}
</source>

=== Mode datagramme (UDP) ===
===Lecture===
Pour lire dans une socket on peut utiliser ''recvfrom'':
<source lang="c">
#include <unistd.h>

ssize_t recvfrom(int fd, void *buf, size_t count, int flags, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères ou mettre le message reçu;
* count → le nombre de caractères à recevoir;
* flags → liste de drapeaux (eg. ''O_NONBLOCK'');
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères reçu ou ''-1'' si une erreur survient (errno est positionné);

===Écriture===
Pour écrire dans une socket ou peut utiliser ''sendto'':
<source lang="c">
#include <unistd.h>

ssize_t sendto(int fd, const void *buf, size_t count, const struct sockaddr *addr, socklen_t addrlen);
</source>
* sockfd → le fichier descripteur de la socket;
* buf → le tableau de caractères contenant le message à envoyer;
* count → le nombre de caractères à envoyer;
* flags → liste de drapeaux (eg. ''MSG_DONTWAIT '', ...);
* addr → une structure symbolisant l'adresse du client (cf. ci-dessus)
* addrlen → la taille de l'objet addr;
* le code retour correspond au nombre de caractères envoyer ou ''-1'' si une erreur survient (errno est positionné);

= Exemples =
== Serveur TCP ==
Voici un exemple de serveur ''echo'' qui renvoie le message au client. Les connexions utilisent TCP et un simple client comme telnet suffit pour l'utiliser.
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_CLIENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int clientSocket, int clients[]);
void manageClient(int clients[]);

int main(void) {
// Création et initialisation du tableau contenant les descripteurs des sockets clients
int clients[NB_CLIENTS];
for (int i = 0; i < NB_CLIENTS; i++) {
clients[i] = -1;
}
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
int clientSocket;
while (1) {
// Descripteur de la socket du client, on attend une connexion
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(clientSocket, clients);
}
manageClient(clients);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int clientSocket, int clients[]) {
// On vérifie si on à de la place de libre
int found = -1;
for (int i = 0; i < NB_CLIENTS; i++) {
// On cherche de la place
if (clients[i] == -1) {
// On ajoute le client
printf("Ajout du client à l'index %i\n", i);
clients[i] = clientSocket;
// Nouvelle connexion, envoie du message de bienvenu
send(clientSocket, "Entrez 'exit' pour quitter\n", strlen("Entrez 'exit' pour quitter\n"),
MSG_DONTWAIT);
found = 0;
break;
}
}
if (found == -1) {
// On a plus de place de libre
puts("Plus de place, désolé");
close(clientSocket);
}
}
// On traite l'input des clients
void manageClient(int clients[]) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
for (int i = 0; i < NB_CLIENTS; i++) {
// On vérifie les messages
int clientSocket = clients[i];
if (clientSocket == -1) {
continue;
}
int len = recv(clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(clientSocket);
// On fait de la place dans le tableau
clients[i] = -1;
}
}
}
</source>

On peut interroger notre serveur avec ''telnet'' (''yum -y install telnet''):
<pre>
# telnet 127.0.0.1 8080
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
Entrez 'exit' pour quitter
coucou
Vous avez dit : coucou
</pre>
== Serveur UDP ==
Si on essaye de reproduire le même type de serveur mais cette fois-ci avec une socket en UDP, cela devient beaucoup plus simple. En effet, en UDP, plus besoin de tenir un tableau avec les descripteurs des sockets des clients car... on est en mode déconnecté (datagramme) ! Entendez par la que les clients envoie un message sans attendre de réponse et sans se soucier de savoir si le message est arrivé au serveur.

<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
void manageClient(int serverSocket);

int main(void) {
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
while (1) {
// Descripteur de la socket du client, on attend une connexion
manageClient(serverSocket);
}
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en UDP
if ((fdsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
return fdsocket;
}
// On traite l'input des clients
void manageClient(int serverSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
unsigned int addrLen = sizeof(clientAdresse);
// On vérifie si on a reçu un message
int len = recvfrom(serverSocket, buffer, BUFFER_LEN, MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, &addrLen);
if (len == -1 && errno != EAGAIN) {
printf("Problème de socket %s\n", strerror(errno));
exit(EXIT_FAILURE);
} else if (len > 0) {
printf("Message reçu de %s:%i\n", inet_ntoa(clientAdresse.sin_addr),
ntohs(clientAdresse.sin_port));
// Ajout du terminateur de chaîne
buffer[len] = '\0';
// On renvoie le texte au client dans un buffer assez grand
len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
sendto(serverSocket, response, strlen(response), MSG_DONTWAIT,
(struct sockaddr*) &clientAdresse, addrLen);
}
}
</source>
On peut interroger notre serveur avec ''netcat'' (''yum -y install nc''):
<pre>
# nc -u 127.0.0.1 8080
coucou
Vous avez dit : coucou
</pre>
= Notification évènementielle avec epoll =
Depuis la version 2.5 du noyau Linux il est possible d'utiliser une série de fonctions, appartenant à l'espace utilisateur (user-space), permettant de suivre l'état d'un descripteur de fichier.
La différence avec read, recv ou encore recvfrom c'est que l'on va pouvoir surveiller plusieurs descripteurs de fichiers en même temps, laissant le CPU libre pour effectuer autre chose !

== Utilisation ==
Tout d'abord il faut créer un descripteur de fichier de type ''epoll'':
<source lang="c">
#include <sys/epoll.h>

int epoll_create1(int flags);
</source>
* flags → EPOLL_CLOEXEC pour éviter les situation de compétition en environnement parallélisé;
* le code retour correspond au descripteur ''epoll'' ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Une fois le descripteur ''epoll'' créé, il faut lui associer un événement:
<source lang="c">
#include <sys/epoll.h>

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* op → une opération parmis:
** EPOLL_CTL_ADD → pour ajouter un événement sur un descripteur de fichier;
** EPOLL_CTL_MOD → pour modifier un événement sur un descripteur de fichier;
** EPOLL_CTL_DEL → pour supprimer un événement sur un descripteur de fichier;
* fd → un descripteur de fichier à surveiller;
* event → la structure contenant l'événement à surveiller (''EPOLLIN'', ''EPOLLOUT'', EPOLLRDHUP'', ...);
* le code retour varie entre ''0'' en cas de succès ou ''-1'' en cas d'erreur (''errno'' est positionnée).

Voici la structure ''epoll_event'':
<source lang="c">
#include <sys/epoll.h>

struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};

typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
</source>

Enfin, il ne reste plus qu'à ''attendre'' des événements:
<source lang="c">
#include <sys/epoll.h>

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
</source>
* epfd → le descripteur ''epoll'' à modifier;
* events → un tableau de ''epoll_event contenant les événements;
* maxevents → le nombre maximum d'événements à traiter (selon la taille du tableau);
* timeout → le temps, en millisecondes que la fonction attend:
** ''-1'' → la fonction devient bloquante;
** ''0'' → retourne immédiatement;
** ''> 0'' → attend le nombre de millisecondes spécifiées;
* le code retour correspond au nombre d'événements ou ''-1'' en cas d'erreur (''errno'' est positionnée).

== Améliorations architecturales ==
=== Gestion des utilisateurs===
Tout d'abord, le faite de laisser ''epoll'' gérer les descripteurs de socket nous permet de supprimer le tableau ''clients'' ainsi que la variable ''NB_CLIENTS''. En effet, la référence vers le descripteur est maintenu par ''epoll'' et nous pouvons gérer maintenant un nombre ''illimité'' de clients.
=== Performances ===
La boucle ''while'' de notre serveur consomme énormément de CPU, environ 100% de CPU par client ! On aurais pu utiliser un temporisateur avec ''nanosleep'' pour baisser la consommation CPU entre 5% et 10%...
Le faîte de basculer sur une fonction bloquante comme ''epoll_wait'' qui utilise des signaux (interruptions) permet de réduire considérablement la consommation CPU. Gardez à l'esprit qu'il n'y a rien de mieux que les interruptions, la preuve, lorsque l'on fait un ''top'', notre programme à complétement disparu de la liste !

== Modification du serveur ==
Modifions le code du serveur TCP pour y intégrer ''epoll'':
<source lang="c">
#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/epoll.h>

// Port d'écoute de la socket
#define PORT 8080
// Adresse d'écoute (toutes les adresses)
#define IP INADDR_ANY
// Taille de la file d'attente
#define BACKLOG 3
// Nombre de connexions clients
#define NB_EVENTS 2
// Taille du tampon de lecture des messages
#define BUFFER_LEN 200
// Commande pour arrêter le serveur
#define EXIT_WORD "exit"

void initAdresse(struct sockaddr_in * adresse);
int initSocket(struct sockaddr_in * adresse);
int waitForClient(int * serverSocket);
void addClientToTab(int * epfd, int * clientSocket);
void manageClient(int * epfd, int * clientSocket);
void addEpollEvent(int * epfd, int * socket);
void delEpollEvent(int * epfd, int * socket);

int main(void) {
// Création du descripteur EPOLL
int epfd = epoll_create1(0);
// Structure contenant les événements EPOLL
struct epoll_event events[NB_EVENTS];
// Structure contenant l'adresse
struct sockaddr_in adresse;
initAdresse(&adresse);
// Descripteur de la socket du serveur
int serverSocket = initSocket(&adresse);
addEpollEvent(&epfd, &serverSocket);
int clientSocket;
while (1) {
int nfds = epoll_wait(epfd, events, NB_EVENTS, -1);
for (int i = 0; i < nfds; i++) {
if (events[i].data.fd == serverSocket) {
if ((clientSocket = waitForClient(&serverSocket)) != -1) {
// On ajoute le nouveau client au tableau des descripteurs
addClientToTab(&epfd, &clientSocket);
}
} else if (events[i].events & EPOLLIN) {
// On a reçu quelque chose
manageClient(&epfd, &events[i].data.fd);
}
}
}
close(serverSocket);
return EXIT_SUCCESS;
}
// Initialisation de la structure sockaddr_in
void initAdresse(struct sockaddr_in * adresse) {
(*adresse).sin_family = AF_INET;
(*adresse).sin_addr.s_addr = IP;
(*adresse).sin_port = htons( PORT);
}
// Démarrage de la socket serveur
int initSocket(struct sockaddr_in * adresse) {
// Descripteur de socket
int fdsocket;
// Nombre d'options
int opt = 1;
// Création de la socket en TCP
if ((fdsocket = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Echéc de la création: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Création de la socket\n");
// Paramètrage de la socket
if (setsockopt(fdsocket, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
sizeof(opt)) != 0) {
printf("Echéc de paramètrage: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Paramètrage de la socket\n");
// Attachement de la socket sur le port et l'adresse IP
if (bind(fdsocket, (struct sockaddr *) adresse, sizeof(*adresse)) != 0) {
printf("Echéc d'attachement: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Attachement de la socket sur le port %i\n", PORT);
// Passage en écoute de la socket
if (listen(fdsocket, BACKLOG) != 0) {
printf("Echéc de la mise en écoute: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
// Passage en mode non bloquant
fcntl(fdsocket, F_SETFL, O_NONBLOCK);
printf("Mise en écoute de la socket\n");
return fdsocket;
}
// Attente de connexion d'un client
int waitForClient(int * serverSocket) {
int clientSocket;
// Structure contenant l'adresse du client
struct sockaddr_in clientAdresse;
int addrLen = sizeof(clientAdresse);
if ((clientSocket = accept(*serverSocket, (struct sockaddr*) &clientAdresse,
(socklen_t*) &addrLen)) != -1) {
// Convertion de l'IP en texte
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(clientAdresse.sin_addr), ip, INET_ADDRSTRLEN);
printf("Connexion de %s:%i\n", ip, clientAdresse.sin_port);
// Passage en mode non bloquant
int opt = 1;
setsockopt(clientSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(1));
}
return clientSocket;
}
// Ajoute les clients au tableau
void addClientToTab(int * epfd, int * clientSocket) {
addEpollEvent(epfd, clientSocket);
// Nouvelle connexion, envoie du message de bienvenu
send(*clientSocket, "Entrez 'exit' pour quitter\n",
strlen("Entrez 'exit' pour quitter\n"), MSG_DONTWAIT);
}
// On traite l'input des clients
void manageClient(int * epfd, int * clientSocket) {
// Création d'un tampon pour stocker les messages des clients dans la heap
static char buffer[BUFFER_LEN + 1];
int len = recv(*clientSocket, buffer, BUFFER_LEN, MSG_DONTWAIT);
// Booléen pour suivre l'état de la socket
int isClosed = 0;
if (len == -1 && errno != EAGAIN) {
// Une erreur est survenue
printf("Errno [%i] : %s\n", errno, strerror(errno));
isClosed = 1;
} else if (len == 0) {
// Le client s'est déconnecté (extrémité de la socket fermée)
isClosed = 1;
} else if (len > 0) {
// Ajout du terminateur de chaîne
buffer[len] = '\0';
if (strncmp(buffer, EXIT_WORD, 4) == 0) {
// Le client veut se déconnecter
send(*clientSocket, "Bye\n", strlen("Bye\n"), 0);
isClosed = 1;
} else {
// On renvoie le texte au client dans un buffer assez grand
int len = strlen("Vous avez dit : ") + strlen(buffer) + 1;
char response[len];
strcpy(response, "Vous avez dit : ");
strcat(response, buffer);
// Un seul envoie permet de ne pas surcharger le réseau
send(*clientSocket, response, strlen(response), 0);
}
}
if (isClosed == 1) {
// On enlève la socket des événements EPOLL
delEpollEvent(epfd, clientSocket);
// La socket est fermé ou le client veut quitter le serveur !
printf("Fermeture de la connexion avec le client\n");
// Fermeture de la socket
close(*clientSocket);
}
}
// Ajoute un descripteur de socket aux événements EPOLL
void addEpollEvent(int * epfd, int * socket) {
printf("Ajout de la socket %i dans les événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_ADD, *socket, &event);
}
// Efface un descripteur de socket des événements EPOLL
void delEpollEvent(int * epfd, int * socket) {
printf("Suppression de la socket %i des événements EPOLL\n", *socket);
// Structure contenant les événements EPOLL
struct epoll_event event;
// On enregistre la socket du serveur comme descripteur EPOLL
event.data.fd = *socket;
// On surveille les message entrant, la fermeture de la socket
event.events = EPOLLIN | EPOLLRDHUP;
epoll_ctl(*epfd, EPOLL_CTL_DEL, *socket, &event);
}
</source>
Voici ce que l'on peut observer dans la console:
<pre>
Création de la socket
Paramètrage de la socket
Attachement de la socket sur le port 8080
Mise en écoute de la socket
Ajout de la socket 4 dans les événements EPOLL
Connexion de 127.0.0.1:17607
Ajout de la socket 5 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
Connexion de 127.0.0.1:18119
Ajout de la socket 5 dans les événements EPOLL
Connexion de 127.0.0.1:18631
Ajout de la socket 6 dans les événements EPOLL
Suppression de la socket 5 des événements EPOLL
Fermeture de la connexion avec le client
</pre>

C signals

2018-11-01T18:07:09Z

Magsss : /* Utilisation */

= Introduction =
Il est intéressant de récupérer les signaux afin de pouvoir les interpréter dans un programme. Cela permet de simplifier l’interaction avec l'utilisateur qui veut, par exemple, interrompre, redémarrer ou encore arrêter le programme.

= Utilisation =
Pour enregistrer une fonction gestionnaire de signaux, il faut utiliser la fonction suivante:
<source lang="c">
#include <signal.h>

int signal (int signo, void * func);
</source>
* signo → le signal à attraper ;
* func → un pointeur vers la fonction à exécuter.
* le code retour varie entre :
**la valeur précédente du gestionnaire de signaux ;
**SIG_ERR en cas d'erreur et ''errno'' est positionné.

Le prototype de la fonction gestionnaire est le suivant:
<source lang="c">
void * sig_handler(int signo);
</source>

= Exemple =
Ci-dessous un exemple qui attrape le signal SIGINT (ctrl+c):
<source lang="c">
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

// Indicateur de fin de programme
int end = 0;

// Gestionnaire de signaux
void sig_handler(int sig) {
printf("\nSIGINT attrapé, on stop le programme %i\n", getpid());
end = 1;
}

int main(void) {
puts("Utilisez SIGINT pour interrompre l'exécution !");
// Enregistrement du gestionnaire de signaux
if(signal(SIGINT, sig_handler) == SIG_ERR){
puts("Erreur à l'enregistrement du gestionnaire de signaux !");
}
// Boucle infinie
while(end == 0);
return EXIT_SUCCESS;
}
</source>
Voici un exemple d'output:
<pre>
$ ./signal.bin
Utilisez SIGINT pour interrompre l'exécution !
^C
SIGINT attrapé, on stop le programme 3630
</pre>

C semaphore

2018-11-01T18:05:04Z

Magsss : /* Initialisation */

= Introduction =
Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions soient exécutées en évitant les interblocages un peu comme avec un [[C_pthread#Exclusion_mutuelle | mutex]].

On peut se demander quelle est la différence avec un [[C_pthread#Exclusion_mutuelle | mutex]] ?

Un [[C_pthread#Exclusion_mutuelle | mutex]] est un mécanisme de verrouillage utilisé pour synchroniser l'accès à une ressource alors qu'un sémaphore est un mécanisme de signalisation utilisé pour sérialiser l'exécution dans une portion de code. Un peu comme si les processus se passaient le mot: "J'ai fini, tu peux y aller".

= Utilisation=
== Création ==
Tout d'abord, il faut créer un objet de type sémaphore:
<source lang="c">
#include <semaphore.h>

sem_t semaphore;
</source>
== Initialisation ==
Une fois l'objet créé, on peut l'initialiser:
<source lang="c">
#include <semaphore.h>

int sem_init(sem_t *semaphore, int pshared, unsigned int valeur);
</source>
*semaphore → pointeur vers le sémaphore à initialiser ;
*pshared → drapeau qui précise si le sémaphore est utilisé par des threads (valeur ''0'') ;
*valeur → valeur de départ du sémaphore.
* le code retour varie entre:
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Blocage ==
Une fois le sémaphore initialisé, on peut demander son blocage avec
<source lang="c">
#include <semaphore.h>

int sem_wait(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:350px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est bloquante !
|}
<source lang="c">
#include <semaphore.h>

int sem_trywait(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:380px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est non bloquante !
|}
<source lang="c">
#include <semaphore.h>
#include <time.h>

int sem_timedwait(sem_t *semaphore, const struct timespec *abs_timeout);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:380px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est bloquante le temps spécifié !
|}
Voici le détail de la structure ''timespec'':
<source lang="c">
struct timespec {
time_t tv_sec; /* Seconds */
long tv_nsec; /* Nanoseconds [0 .. 999999999] */
};
</source>

== Relâchement d'un sémaphore ==
Une fois la section critique passée, on peut relâcher le sémaphore:
<source lang="c">
#include <semaphore.h>

int sem_post(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
=Exemple=
Ci-dessous un exemple d'utilisation d'un sémaphore:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>

#define NB_THREAD 4
#define LIMIT 2

// Création du sémaphore;
sem_t semaphore;

void * job(void * args) {
// Récupération de l'identifiant du thread
int tid = pthread_self();
int i = 0;
while (i < LIMIT) {
// On attend la disponibilité du sémaphore
sem_wait(&semaphore);
// Section critique
printf("Je suis le thread [%i] et je vais dormir 1 seconde\n", tid);
sleep(1);
printf("Je suis le thread [%i] et j'ai fini ma sieste\n", tid);
// On relache le sémaphore
sem_post(&semaphore);
i++;
}
pthread_exit(EXIT_SUCCESS);
}

int main() {
// Création d'un tableau de thread
pthread_t threads[NB_THREAD];
// Initialisation du sémaphore
sem_init(&semaphore, PTHREAD_PROCESS_SHARED, 1);
for (int i = 0; i < NB_THREAD; i++) {
int err;
if ((err = pthread_create(&threads[i], NULL, job, NULL)) != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
return EXIT_FAILURE;;
}
printf("Création du thread numéro %i\n", i);
}
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
sem_destroy(&semaphore);
return EXIT_SUCCESS;
}
</source>
Ce programme donne, par exemple, la sortie suivante:
<pre>
Création du thread numéro 0
Création du thread numéro 1
Création du thread numéro 2
Création du thread numéro 3
Je suis le thread [-1171347712] et je vais dormir 1 seconde
Je suis le thread [-1171347712] et j'ai fini ma sieste
Je suis le thread [-1171347712] et je vais dormir 1 seconde
Je suis le thread [-1171347712] et j'ai fini ma sieste
Je suis le thread [-1192327424] et je vais dormir 1 seconde
Je suis le thread [-1192327424] et j'ai fini ma sieste
Je suis le thread [-1192327424] et je vais dormir 1 seconde
Je suis le thread [-1192327424] et j'ai fini ma sieste
Je suis le thread [-1181837568] et je vais dormir 1 seconde
Je suis le thread [-1181837568] et j'ai fini ma sieste
Je suis le thread [-1181837568] et je vais dormir 1 seconde
Je suis le thread [-1181837568] et j'ai fini ma sieste
Je suis le thread [-1160857856] et je vais dormir 1 seconde
Je suis le thread [-1160857856] et j'ai fini ma sieste
Je suis le thread [-1160857856] et je vais dormir 1 seconde
Je suis le thread [-1160857856] et j'ai fini ma sieste
</pre>
On voit bien les threads exécuter la section critique les uns après les autres !

C semaphore

2018-11-01T18:04:21Z

Magsss : /* Introduction */

= Introduction =
Les sémaphores permettent de gérer ce que l'on appelle les sections critiques. Il y a des parties de code où l'on souhaite que toutes les instructions soient exécutées en évitant les interblocages un peu comme avec un [[C_pthread#Exclusion_mutuelle | mutex]].

On peut se demander quelle est la différence avec un [[C_pthread#Exclusion_mutuelle | mutex]] ?

Un [[C_pthread#Exclusion_mutuelle | mutex]] est un mécanisme de verrouillage utilisé pour synchroniser l'accès à une ressource alors qu'un sémaphore est un mécanisme de signalisation utilisé pour sérialiser l'exécution dans une portion de code. Un peu comme si les processus se passaient le mot: "J'ai fini, tu peux y aller".

= Utilisation=
== Création ==
Tout d'abord, il faut créer un objet de type sémaphore:
<source lang="c">
#include <semaphore.h>

sem_t semaphore;
</source>
== Initialisation ==
Une fois l'objet créé, on peut l'initialiser:
<source lang="c">
#include <semaphore.h>

int sem_init(sem_t *semaphore, int pshared, unsigned int valeur);
</source>
*semaphore → pointeur vers le sémaphore à initialiser ;
*pshared → drapeaux qui précise si le sémaphore est utilisé par des threads (valeur ''0'') ;
*valeur → valeur de départ du sémaphore.
* le code retour varie entre:
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné
== Blocage ==
Une fois le sémaphore initialisé, on peut demander son blocage avec
<source lang="c">
#include <semaphore.h>

int sem_wait(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:350px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est bloquante !
|}
<source lang="c">
#include <semaphore.h>

int sem_trywait(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:380px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est non bloquante !
|}
<source lang="c">
#include <semaphore.h>
#include <time.h>

int sem_timedwait(sem_t *semaphore, const struct timespec *abs_timeout);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
{|style="width:380px" align="center"
|
[[Fichier:Warning-icon.png|40px]]
|valign="top"|
Cette fonction est bloquante le temps spécifié !
|}
Voici le détail de la structure ''timespec'':
<source lang="c">
struct timespec {
time_t tv_sec; /* Seconds */
long tv_nsec; /* Nanoseconds [0 .. 999999999] */
};
</source>

== Relâchement d'un sémaphore ==
Une fois la section critique passée, on peut relâcher le sémaphore:
<source lang="c">
#include <semaphore.h>

int sem_post(sem_t *semaphore);
</source>
*semaphore → pointeur vers le sémaphore à bloquer ;
* le code retour varie entre:
** '0' si tout s'est bien passé
** '-1' si une erreur survient et errno est positionné
=Exemple=
Ci-dessous un exemple d'utilisation d'un sémaphore:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>

#define NB_THREAD 4
#define LIMIT 2

// Création du sémaphore;
sem_t semaphore;

void * job(void * args) {
// Récupération de l'identifiant du thread
int tid = pthread_self();
int i = 0;
while (i < LIMIT) {
// On attend la disponibilité du sémaphore
sem_wait(&semaphore);
// Section critique
printf("Je suis le thread [%i] et je vais dormir 1 seconde\n", tid);
sleep(1);
printf("Je suis le thread [%i] et j'ai fini ma sieste\n", tid);
// On relache le sémaphore
sem_post(&semaphore);
i++;
}
pthread_exit(EXIT_SUCCESS);
}

int main() {
// Création d'un tableau de thread
pthread_t threads[NB_THREAD];
// Initialisation du sémaphore
sem_init(&semaphore, PTHREAD_PROCESS_SHARED, 1);
for (int i = 0; i < NB_THREAD; i++) {
int err;
if ((err = pthread_create(&threads[i], NULL, job, NULL)) != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
return EXIT_FAILURE;;
}
printf("Création du thread numéro %i\n", i);
}
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
sem_destroy(&semaphore);
return EXIT_SUCCESS;
}
</source>
Ce programme donne, par exemple, la sortie suivante:
<pre>
Création du thread numéro 0
Création du thread numéro 1
Création du thread numéro 2
Création du thread numéro 3
Je suis le thread [-1171347712] et je vais dormir 1 seconde
Je suis le thread [-1171347712] et j'ai fini ma sieste
Je suis le thread [-1171347712] et je vais dormir 1 seconde
Je suis le thread [-1171347712] et j'ai fini ma sieste
Je suis le thread [-1192327424] et je vais dormir 1 seconde
Je suis le thread [-1192327424] et j'ai fini ma sieste
Je suis le thread [-1192327424] et je vais dormir 1 seconde
Je suis le thread [-1192327424] et j'ai fini ma sieste
Je suis le thread [-1181837568] et je vais dormir 1 seconde
Je suis le thread [-1181837568] et j'ai fini ma sieste
Je suis le thread [-1181837568] et je vais dormir 1 seconde
Je suis le thread [-1181837568] et j'ai fini ma sieste
Je suis le thread [-1160857856] et je vais dormir 1 seconde
Je suis le thread [-1160857856] et j'ai fini ma sieste
Je suis le thread [-1160857856] et je vais dormir 1 seconde
Je suis le thread [-1160857856] et j'ai fini ma sieste
</pre>
On voit bien les threads exécuter la section critique les uns après les autres !

C pipe

2018-11-01T18:02:47Z

Magsss : /* Fonctions utilisées */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminée on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnelle ==
Ci-dessous un exemple qui permet au père de communiquer avec ses fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnelle ==
Dans cet exemple, on crée une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>

= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permissions du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T18:01:44Z

Magsss : /* Utilisation bidirectionnel */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminée on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnelle ==
Ci-dessous un exemple qui permet au père de communiquer avec ses fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnelle ==
Dans cet exemple, on crée une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>

= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T18:01:21Z

Magsss : /* Utilisation uni-directionnelle */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminée on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnelle ==
Ci-dessous un exemple qui permet au père de communiquer avec ses fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnel ==
Dans cette exemple, on créer une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>

= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T18:01:09Z

Magsss : /* Utilisation uni-directionnel */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminée on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnelle ==
Ci-dessous un exemple qui permet au père de communiquer avec ces fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnel ==
Dans cette exemple, on créer une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>

= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T18:01:00Z

Magsss : /* Utilisation dans un contexte d'exécution parallélisé */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminée on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnel ==
Ci-dessous un exemple qui permet au père de communiquer avec ces fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnel ==
Dans cette exemple, on créer une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>

= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T18:00:43Z

Magsss : /* fermeture */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminée on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnel ==
Ci-dessous un exemple qui permet au père de communiquer avec ces fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnel ==
Dans cette exemple, on créer une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>
= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T18:00:32Z

Magsss : /* Lecture */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractères qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminé on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnel ==
Ci-dessous un exemple qui permet au père de communiquer avec ces fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnel ==
Dans cette exemple, on créer une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>
= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C pipe

2018-11-01T17:59:28Z

Magsss : /* Introduction */

= Introduction =
Un tube est un canal par lequel les informations circulent de manière uni-directionnelle. Un processus écrit dans l'entrée du tube et un autre processus lit les informations en sortie.

= Manipulation des tubes =
== Création ==
La première étape est la création d'un tube:
<source lang="c">
#include <unistd.h>

int tube[2];

int pipe(int tube[2]);
</source>

*tube[0] → contiendra le fichier descripteur de l'extrémité de lecture
*tube[1] → contiendra le fichier descripteur de l'extrémité d'écriture
*Le retour sera :
** '0' si tout s'est bien passé
** '1' si une erreur survient et errno est positionné

== Écriture ==
Pour écrire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t write(int tube[1], const void *message, size_t longueur);
</source>
*tube[0] → le fichier descripteur de l'extrémité d'écriture
*message → le message à écrire
*longueur → la longueur du message
*ssize_t → le nombre d'octets écrits

== Lecture ==
Pour lire dans un tube :
<source lang="c">
#include <unistd.h>

ssize_t read(int tube[0], void *message, size_t longueur);
</source>
*tube[1] → le fichier descripteur de l'extrémité de lecture
*message → un tableau de caractère qui contiendra le message à lire
*longueur → la longueur du message à lire
*ssize_t → le nombre d'octets lus

==fermeture==
Un fois la lecture terminé on ferme le tube:
<source lang="c">
int close(int descripteur);
</source>
*descripteur : une extrémité du tube

= Utilisation dans un contexte d'exécution parallélisé =
== Utilisation uni-directionnel ==
Ci-dessous un exemple qui permet au père de communiquer avec ces fils:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Nombre total de thread
#define NB_FORK 2
// Taille du message
#define LENGTH_MSG 30
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(int * tube) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read(*tube, message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s", tid, message);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
int tube[2];
pipe(tube);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(tube[1]);
job(&tube[0]);
close(tube[0]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(tube[1], message, LENGTH_MSG);
close(tube[0]);
close(tube[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>

== Utilisation bidirectionnel ==
Dans cette exemple, on créer une structure qui va contenir les deux tubes pour plus de facilité:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>

// Structure avec des tubes full-duplex
typedef struct fdpipe {
int father[2];
int son[2];
} fdpipe;

// Nombre total de thread
#define NB_FORK 10
// Taille du message
#define LENGTH_MSG 50
// Tableau contenant le message
char message[LENGTH_MSG] = "";

// Fonction exécutée dans le fork
void job(fdpipe * pipes) {
int tid = getpid();
// timer pour attendre maximum 5 secondes
int i = 5;
while (i > 0) {
// lecture dans le tube
if (read((*pipes).father[0], message, LENGTH_MSG) > 0) {
printf("Message du processus [%i] : %s\n", tid, message);
// Ecriture du message dans le tableau
sprintf(message, "je suis [%i] et j'ai bien reçu ton message !\n", tid);
write((*pipes).son[1], message, LENGTH_MSG);
break;
}
sleep(1);
}
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
fdpipe pipes;
pipe(pipes.father);
pipe(pipes.son);
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
close(pipes.father[1]);
job(&pipes);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
exit(EXIT_SUCCESS);
} else {
// On est dans le père
// Ecriture du message dans le tableau
sprintf(message, "Fork [%i], je suis ton père !\n", pid);
// Ecriture du message dans le tube
write(pipes.father[1], message, LENGTH_MSG);
while (i > 0) {
// lecture dans le tube
if (read(pipes.son[0], message, LENGTH_MSG) > 0) {
printf("Réponse du fils : %s\n", message);
break;
}
sleep(1);
}
close(pipes.father[1]);
close(pipes.father[0]);
close(pipes.son[0]);
close(pipes.son[1]);
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce qui nous donne le résultat suivant :
<pre>
Message du processus [18523] : Fork [18523], je suis ton père !
Réponse du fils : je suis [18523] et j'ai bien reçu ton message !
Message du processus [18522] : Fork [18522], je suis ton père !
Message du processus [18524] : Fork [18524], je suis ton père !
Réponse du fils : je suis [18524] et j'ai bien reçu ton message !
Message du processus [18525] : Fork [18525], je suis ton père !
Réponse du fils : je suis [18525] et j'ai bien reçu ton message !
</pre>
= Tube nommé =
== Fonctions utilisées ==
Il est possible de nommer un tube pour pouvoir y accéder depuis un autre processus. Pour ce faire nous allons utiliser les fonctions suivantes :
<source lang="c">
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo (const char* name, mode_t mode);
</source>
* name est le nom du tube ;
* mode correspond aux permission du tube (idem ''chmod'') ;
* le code retour de la fonction varie entre :
** EACCES : droits insuffisants pour créer le tube ;
** EEXIST : un tube de même nom existe déjà ;
** ENAMETOOLONG : nom trop long ;
** ENOENT : le chemin n'existe pas ;
** ENOSPC : espace insuffisant sur le système de fichiers.

<source lang="c">
#include <fcntl.h>

int open (const char* name, int options);
</source>
* name est le nom du tube ;
* options permet de désigner l'extrémité du tube:
** O_WRONLY: pour l'entrée ;
** O_RDONLY: pour la sortie.
* le retour est le descripteur pour la lecture ou l'écriture ou -1 en cas d'échec.

== Exemple d'utilisation ==
Ci-dessous un exemple d'utilisation avec un thread qui lit dans un tube nommé:
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

// Nom du tube
#define FIFO_NAME "/tmp/test.fifo"
// Longeur du buffer de lecture
#define BUFFER_LENGTH 30;
// Mode de lecture du tube
const mode_t FIFO_MODE = 0760;

// Fonction exécutée par le thread
void * job(void * args) {
// Récupération du descripteur en lecture
int fdread;
if ((fdread = open(FIFO_NAME, O_RDONLY)) == -1) {
fprintf(stderr, "Impossible d'ouvrir le tube en lecture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Création d'un tampon pour stocker le contenu du tube
char buffer[30];
// Lecture du contenu du tube
read(fdread, buffer, 30);
// Affichage du contenu
printf("Le tube contient : %s", buffer);
// Fin de l'exécution du thread
pthread_exit(EXIT_SUCCESS);
}

int main() {
// On supprime le tube s'il existe déjà
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Suppression du tube existant: %s\n", FIFO_NAME);
unlink(FIFO_NAME);
}
// Création de la variable qui va contenir le thread
pthread_t thread;
// Création du tube FIFO
if (mkfifo(FIFO_NAME, FIFO_MODE) == -1) {
printf("Erreur de création du tube: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}else{
printf("Création du tube: %s\n", FIFO_NAME);
}
// Création du thread
pthread_create(&thread, NULL, job, NULL);
// Récupération du descripteur en écriture
int fdwrite;
if ((fdwrite = open(FIFO_NAME, O_WRONLY)) == -1) {
printf("Impossible d'ouvrir le tube en écriture: %s\n",
strerror(errno));
exit(EXIT_FAILURE);
}
// Ecriture dans le tube
char message[] = "Bonjour thread";
write(fdwrite, message, sizeof(message));
// En attente de l'éxécution du thread
pthread_join(thread, NULL);
// Fin de l'exécution
return EXIT_SUCCESS;
}
</source>
{|style="width:800px" align="center"
|
[[Fichier:Warning manual.jpg|centré|300px]]
|valign="top"|
Dans l'exemple précédent, vous remarquerez que le thread est créé avant l'ouverture du tube. C'est absolument important de démarrer le thread avant, car la fonction ''open'' va bloquer le fil d'exécution principal tant que le thread n'ouvre pas le tube en lecture ! Pour eviter cela il faut utiliser l'option '''O_NONBLOCK'''
|}

C fork

2018-11-01T17:58:10Z

Magsss : /* Démonisation */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier en-tête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peu importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cet exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du fait que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifiés indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
la ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C fork

2018-11-01T17:57:01Z

Magsss : /* Création de plusieurs forks */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier en-tête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peu importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cet exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du fait que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifiés indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
La ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C fork

2018-11-01T17:56:21Z

Magsss : /* Création d'un fork */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier en-tête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peu importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cet exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du fait que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifié indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
La ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C fork

2018-11-01T17:55:56Z

Magsss : /* Création d'un fork */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier en-tête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peu importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cet exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du faite que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifié indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
La ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C fork

2018-11-01T17:55:29Z

Magsss : /* Fonctions annexes */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier en-tête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peu importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cette exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du faite que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifié indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
La ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C fork

2018-11-01T17:54:11Z

Magsss : /* Fonctionnement */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier en-tête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peut importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cette exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du faite que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifié indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
La ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C fork

2018-11-01T17:52:58Z

Magsss : /* Introduction */

= Introduction =
Un fork est un processus lourd, comprenez par là que l'intégralité du contexte d'exécution du processus père est recopié dans le ''nouveau'' processus fils. Ne cherchez pas, comme avec les [[C_pthread | threads]], a échanger des variables entre les processus car cela ne marchera pas. Il faut utiliser des techniques de communication inter-processus comme les tubes, sockets ou encore sémaphores...

= Fonctionnement =
Pour créer un fork, il suffit d'appeler la fonction du même nom. Cette fonction aura différentes valeurs de retour en fonction du processus dans lequel on se trouve:
*-1 → il y a une erreur ;
*0 → on est dans le processus fils ;
*Le PID du fils → on est dans le processus père.

La valeur retournée par la fonction fork est de type ''pid_t'', c'est pourquoi il faut obligatoirement inclure le fichier ''<sys/types.h>''.

Dans le cas d'une erreur, celle-ci sera accessible grâce à la variable globale ''errno'', il faudra donc inclure le fichier entête ''<errno.h>''.

= Fonctions annexes =
Voici quelques fonctions annexes bien pratiques:
* getpid → retourne le PID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PID est %i\n", getpid()); // affichera par exemple "Mon PID est 14804"
</source>
* getppid → retourne le PPID du processus appelant, de type ''pid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon PPID est %i\n", getppid()); // affichera par exemple "Mon PPID est 14403"
</source>
* getuid → retourne l'UID du processus appelant, de type ''uid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon UID est %i\n", getuid()); // affichera par exemple "Mon UID est 0"
</source>
* getgid → retourne le GID du processus appelant, de type ''gid_t'' :
<source lang="c">
#include <unistd.h>
#include <sys/types.h>

printf("Mon GID est %i\n", getgid()); // affichera par exemple "Mon GID est 0"
</source>
* exit → permet de quitter le programme peut importe où dans le code :
<source lang="c">
#include <stdlib.h>

exit(EXIT_SUCCESS); // quitte le programme en retournant la valeur de succès
</source>
* wait → permet au processus fils d'être libéré pour éviter les zombies:
<source lang="c">
#include <stdlib.h>
#include <sys/wait.h>

int status;

wait(&status); // la valeur de retour du processus fils sera dans la variable status
</source>

= Création d'un fork =
Ci-dessous un exemple de création d'un processus lourd :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
printf("Mon PID est %i et celui de mon père est %i\n", getpid(), getppid());
} else {
// On est dans le père
printf("Mon PID est %i et celui de mon fils est %i\n", getpid(), pid);
}
return EXIT_SUCCESS;
}
</source>
Cette exemple peut retourner la sortie suivante :
<pre>
Mon PID est 15150 et celui de mon fils est 15151
Mon PID est 15151 et celui de mon père est 15150
</pre>
Cependant, on peut très bien avoir cela:
<pre>
Mon PID est 15197 et celui de mon fils est 15198
Mon PID est 15198 et celui de mon père est 1
</pre>
On voit que le numéro de processus du père est devenu ''1''. Cela vient du faite que, lorsque le père se termine, le fils est automatiquement rattaché au processus de PID ''1'' pour ne pas devenir un processus [https://en.wikipedia.org/wiki/Orphan_process ''orphelin''].

= Création de plusieurs forks =
Lorsque l'on a plusieurs forks à gérer, il faut garder la trace de chacun des numéros de processus et également attendre la fin de chacun des fils.

Ci-dessous un code qui démarre plusieurs forks qui vont incrémenter un compteur.
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// Nombre total de thread
#define NB_FORK 2
// Limite de l'incrément
#define INCREMENT_LIMIT 2
// Initialisation de la donnée
int data = 0;

// Fonction exécutée dans le fork
void job() {
int tid = getpid();
while (data < INCREMENT_LIMIT) {
data++;
printf("fork [ %i ] data [ %i ]\n", tid, data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du fork %i\n", tid);
exit(EXIT_SUCCESS);
}
// Fonction qui attend chacun des processus fils
void waitForAll() {
int status;
pid_t pid;
int n = 0;
while (n < NB_FORK) {
pid = wait(&status);
printf("Fork [%i] terminé avec le code %i\n", pid, status);
n++;
}
}

int main() {
for (int i = 0; i < NB_FORK; i++) {
pid_t pid = fork();
if (pid == -1) {
// Il y a une erreur
perror("fork");
return EXIT_FAILURE;
} else if (pid == 0) {
// On est dans le fils
job();
} else {
// On est dans le père
}
}
waitForAll();
return EXIT_SUCCESS;
}
</source>
Ce code donne, par exemple, le résultat suivant:
<pre>
fork [ 15964 ] data [ 1 ]
fork [ 15963 ] data [ 1 ]
fork [ 15964 ] data [ 2 ]
fork [ 15963 ] data [ 2 ]
Fin du fork 15964
Fork [15964] terminé avec le code 0
Fin du fork 15963
Fork [15963] terminé avec le code 0
</pre>
On voit bien que le contexte est recopié car les compteurs sont modifié indépendamment.

=Démonisation=
Il peut être intéressant pour un programme, lorsque l'on cherche à écrire un serveur, que celui-ci se détache du processus qui l'a démarré : ce procédé s'appelle la démonisation.

Pour accomplir cela, rien de plus simple, il suffit d'appeler la fonction suivante:
<source lang="c">
#include <unistd.h>

int daemon(int nochdir, int noclose);
</source>
* ''nochdir'' → si à ''0'', le démon utilise comme répertoire de travail la racine (''/''), sinon il conserve le répertoire de travail courant.
* ''noclose'' → si à ''0'', le démon redirige la sortie standard dans ''/dev/null'', sinon aucun changement n'est fait.
Pour comprendre le phénomène, utilisons le programme suivant :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
sleep(10);
return EXIT_SUCCESS;
}
</source>
Il ne reste plus qu'à compiler ce programme:
<pre>
gcc -o daemon.bin daemon.c
</pre>
Lorsque l'on exécute le programme, il ne rend pas la main et on doit attendre 10 secondes .

Si on ajoute, avant la ligne :
<source lang="c">
sleep(10);
</source>
La ligne suivante:
<source lang="c">
daemon(0,0);
</source>
le programme se détache du processus courant et on peut le voir grâce à la commande ''ps'':
<pre>
# ./daemon.bin
PID du processus principal [ 16559 ]
# ps -ef | grep ./daemon.bin
root 16560 1 0 07:52 ? 00:00:00 ./daemon.bin
</pre>
On peut le voir plus simplement sur cet exemple :
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {
printf("PID du processus principal [ %i ]\n", getpid());
// Passage du programme en arrière plan sans modifier la sortie standard
daemon(0, 1);
printf("PID du démon [ %i ]\n", getpid());
return EXIT_SUCCESS;
}
</source>
L'exécution donne, par exemple :
<pre>
PID du processus principal [ 16613 ]
PID du démon [ 16614 ]
</pre>

C pthread

2018-11-01T17:51:56Z

Magsss : /* Exclusion mutuelle */

= Introduction =
Les threads ou ''processus légers'' sont utilisés pour paralléliser l'exécution dans un programme. Ils sont dits ''légers'' car ils s'exécutent dans le même contexte que le processus d'exécution principal qui les crée et consomment donc moins de mémoire / CPU.

= Pré-requis =
Pour pouvoir créer des threads il faut utiliser la librairie ''pthread'' (POSIX thread):
<source lang='c'>
#include <pthread.h>
</source>
Ce qui donne en ligne de commande:
<source lang='bash'>
gcc -lpthread thread_exemple.c
</source>
Pour inclure la librairie dans [[Eclipse_install|Eclispe]] regardez [[C_devel#Ajouter_une_librairie_.C3.A0_un_projet|ici]].
= Premier thread =
Dans ce premier exemple, nous allons créer un thread qui affiche une message:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
printf("Nous sommes dans le thread.\n");
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
pthread_t thread1;
printf("Avant la création du thread.\n");
// Création du thread
pthread_create(&thread1, NULL, thread_1, NULL);
printf("Après la création du thread.\n");
return EXIT_SUCCESS;
}
</source>
Dans cet exemple, nous utilisons la fonction suivante:
<source lang='c'>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''*attr'' correspond aux arguments de création du thread, passer à la fonction ''pthread_create'';
* ''*(*start_routine)'' est un pointeur vers la fonction exécutée par le thread;
* ''*arg'' est un pointeur vers les arguments passés en paramètres à la fonction ''start_routine'';
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EAGAIN → lorsque les ressources sont insuffisantes ou le nombre de threads maximum est atteint;
** EINVAL → lorsqu'un argument invalide est passé en paramètre;
** EPERM → lorsqu'il y a un problème de droit sur l'ordonnanceur (passé en paramètre);
Lorsque l'on exécute cet exemple, on a le résultat suivant :
<pre>
Avant la création du thread.
Après la création du thread.
</pre>
On ne voit pas le message du thread car le programme se termine sans attendre la fin de son exécution. Pour attendre la fin de l'exécution du thread, il faut utiliser la fonction suivante :
<source lang='c'>
int pthread_join(pthread_t thread, void **retval);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''**retval'' est un pointeur vers un entier qui contiendra la valeur de retour du thread;
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EDEADLK → lorsqu'il y a un ''deadlock'';
** EINVAL → lorsque le thread n'est pas joignable;
** ESRCH → si le thread n'existe pas;
Ajoutez la ligne suivante :
<source lang='c'>
pthread_join(thread1, NULL);
</source>
après l'appel de la fonction ''pthread_create'' pour avoir le résultat suivant:
<pre>
Avant la création du thread.
Nous sommes dans le thread.
Après la création du thread.
</pre>

= Modification d'une variable =
Dans cet exemple nous allons incrémenter dans le thread un entier qui est déclaré dans le processus principal:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
int *i = (int *) arg;
(*i)++;
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
int i = 1;
pthread_t thread1;
printf("Avant la création du thread, i = %i.\n", i);
// Création du thread
pthread_create(&thread1, NULL, thread_1, &i);
pthread_join(thread1, NULL);
printf("Après la création du thread, i = %i.\n", i);
return EXIT_SUCCESS;
}
</source>
Cela donne le résultat suivant :
<pre>
Avant la création du thread, i = 1.
Après la création du thread, i = 2.
</pre>
On peut remarquer que:
* dans le processus principal, on passe une référence vers la variable ''i'' (''&i'') dans la fonction ''pthread_create'';
* dans le thread on récupère le pointeur vers cette variable et on la déclare comme étant un entier :
<source lang='c'>
int *i = (int *) arg;
</source>
* on incrémente la valeur et non l'adresse pointée :
<source lang='c'>
(*i)++;
</source>

= Exclusion mutuelle =
Lorsque l'on cherche à modifier dans plusieurs threads une variable globale, il peut y avoir un problème d'accès concurrent (modification / lecture simultanée). Ce problème peut être réglé en utilisant ce que l'on appelle un ''mutex'' (''mutual exclusion'') et pour des questions pratiques, on utilise généralement une structure pour associer la variable à son ''mutex'':

<source lang="c">
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;
</source>

Dans l'exemple ci-dessus on crée une structure de données avec un entier et un ''mutex''.
Il existe plusieurs fonctions pour manipuler les ''mutex'' et voici les principales:
*pour initialiser un ''mutex'':
<source lang="c">
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr )
</source>
*pour verrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_lock(pthread_mutex_t *mutex)
</source>
*pour déverrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_unlock(pthread_mutex_t *mutex)
</source>
*pour détruire un ''mutex'':
<source lang="c">
int pthread_mutex_destroy(pthread_mutex_t *mutex)
</source>

Le programme suivant permet d'incrémenter la valeur d'un entier dans plusieurs threads différents:
<source lang="c">
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// Nombre total de thread
#define NB_THREAD 2
// Limite de l'incrément
#define INCREMENT_LIMIT 10

// Tableau contenant les threads
pthread_t threads[NB_THREAD];

// Structure de données contenant le mutex
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;

// Fonction exécutée dans le thread
void * job(void *arg) {
mutex_data *md = (mutex_data*) arg;
pthread_t tid = pthread_self();
while ((*md).data < INCREMENT_LIMIT) {
// Vérouillage du mutex
pthread_mutex_lock(&(*md).mutex);
(*md).data++;
// Dévérouillage du mutex
pthread_mutex_unlock(&(*md).mutex);
printf("thread [ %ld ] data [ %i ]\n", tid, (*md).data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du thread %ld\n", tid);
pthread_exit(NULL);
}

// Fonction principale
int main() {
// Création du mutex
mutex_data md;
// Initialisation de la donnée
md.data = 0;
// Initialisation du mutex
if (pthread_mutex_init(&md.mutex, NULL) != 0) {
printf("\n mutex init failed\n");
return EXIT_FAILURE;
}
// Boucle de création des threads
for (int i = 0; i < NB_THREAD; i++) {
// Création du thread et passage de la structure par référence
int err = pthread_create(&threads[i], NULL, job, &md);
if (err != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
break;
}
printf("Création du thread numéro %ld\n", threads[i]);
}
// En attente des threads
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
// Destruction du mutex
pthread_mutex_destroy(&md.mutex);
return EXIT_SUCCESS;
}
</source>
Un exemple de l'exécution de ce programme donne la sortie suivante :
<pre>
Création du thread numéro 140530420492032
Création du thread numéro 140530410002176
thread [ 140530410002176 ] data [ 1 ]
thread [ 140530420492032 ] data [ 2 ]
thread [ 140530410002176 ] data [ 3 ]
thread [ 140530420492032 ] data [ 4 ]
thread [ 140530410002176 ] data [ 5 ]
thread [ 140530420492032 ] data [ 6 ]
thread [ 140530420492032 ] data [ 7 ]
thread [ 140530410002176 ] data [ 8 ]
thread [ 140530420492032 ] data [ 9 ]
thread [ 140530410002176 ] data [ 10 ]
Fin du thread 140530420492032
Fin du thread 140530410002176
</pre>

C pthread

2018-11-01T17:51:11Z

Magsss : /* Exclusion mutuelle */

= Introduction =
Les threads ou ''processus légers'' sont utilisés pour paralléliser l'exécution dans un programme. Ils sont dits ''légers'' car ils s'exécutent dans le même contexte que le processus d'exécution principal qui les crée et consomment donc moins de mémoire / CPU.

= Pré-requis =
Pour pouvoir créer des threads il faut utiliser la librairie ''pthread'' (POSIX thread):
<source lang='c'>
#include <pthread.h>
</source>
Ce qui donne en ligne de commande:
<source lang='bash'>
gcc -lpthread thread_exemple.c
</source>
Pour inclure la librairie dans [[Eclipse_install|Eclispe]] regardez [[C_devel#Ajouter_une_librairie_.C3.A0_un_projet|ici]].
= Premier thread =
Dans ce premier exemple, nous allons créer un thread qui affiche une message:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
printf("Nous sommes dans le thread.\n");
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
pthread_t thread1;
printf("Avant la création du thread.\n");
// Création du thread
pthread_create(&thread1, NULL, thread_1, NULL);
printf("Après la création du thread.\n");
return EXIT_SUCCESS;
}
</source>
Dans cet exemple, nous utilisons la fonction suivante:
<source lang='c'>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''*attr'' correspond aux arguments de création du thread, passer à la fonction ''pthread_create'';
* ''*(*start_routine)'' est un pointeur vers la fonction exécutée par le thread;
* ''*arg'' est un pointeur vers les arguments passés en paramètres à la fonction ''start_routine'';
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EAGAIN → lorsque les ressources sont insuffisantes ou le nombre de threads maximum est atteint;
** EINVAL → lorsqu'un argument invalide est passé en paramètre;
** EPERM → lorsqu'il y a un problème de droit sur l'ordonnanceur (passé en paramètre);
Lorsque l'on exécute cet exemple, on a le résultat suivant :
<pre>
Avant la création du thread.
Après la création du thread.
</pre>
On ne voit pas le message du thread car le programme se termine sans attendre la fin de son exécution. Pour attendre la fin de l'exécution du thread, il faut utiliser la fonction suivante :
<source lang='c'>
int pthread_join(pthread_t thread, void **retval);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''**retval'' est un pointeur vers un entier qui contiendra la valeur de retour du thread;
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EDEADLK → lorsqu'il y a un ''deadlock'';
** EINVAL → lorsque le thread n'est pas joignable;
** ESRCH → si le thread n'existe pas;
Ajoutez la ligne suivante :
<source lang='c'>
pthread_join(thread1, NULL);
</source>
après l'appel de la fonction ''pthread_create'' pour avoir le résultat suivant:
<pre>
Avant la création du thread.
Nous sommes dans le thread.
Après la création du thread.
</pre>

= Modification d'une variable =
Dans cet exemple nous allons incrémenter dans le thread un entier qui est déclaré dans le processus principal:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
int *i = (int *) arg;
(*i)++;
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
int i = 1;
pthread_t thread1;
printf("Avant la création du thread, i = %i.\n", i);
// Création du thread
pthread_create(&thread1, NULL, thread_1, &i);
pthread_join(thread1, NULL);
printf("Après la création du thread, i = %i.\n", i);
return EXIT_SUCCESS;
}
</source>
Cela donne le résultat suivant :
<pre>
Avant la création du thread, i = 1.
Après la création du thread, i = 2.
</pre>
On peut remarquer que:
* dans le processus principal, on passe une référence vers la variable ''i'' (''&i'') dans la fonction ''pthread_create'';
* dans le thread on récupère le pointeur vers cette variable et on la déclare comme étant un entier :
<source lang='c'>
int *i = (int *) arg;
</source>
* on incrémente la valeur et non l'adresse pointée :
<source lang='c'>
(*i)++;
</source>

= Exclusion mutuelle =
Lorsque l'on cherche à modifier dans plusieurs threads une variable globale, il peut y avoir un problème d'accès concurrent (modification / lecture simultanée). Ce problème peut être réglé en utilisant ce que l'on appelle un ''mutex'' (''mutual exclusion'') et pour des questions pratiques, on utilise généralement une structure pour associer la variable à son ''mutex'':

<source lang="c">
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;
</source>

Dans l'exemple ci-dessus on créer une structure de données avec un entier et un ''mutex''.
Il existe plusieurs fonctions pour manipuler les ''mutex'' et voici les principales:
*pour initialiser un ''mutex'':
<source lang="c">
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr )
</source>
*pour verrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_lock(pthread_mutex_t *mutex)
</source>
*pour déverrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_unlock(pthread_mutex_t *mutex)
</source>
*pour détruire un ''mutex'':
<source lang="c">
int pthread_mutex_destroy(pthread_mutex_t *mutex)
</source>

Le programme suivant permet d'incrémenter la valeur d'un entier dans plusieurs thread différents:
<source lang="c">
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// Nombre total de thread
#define NB_THREAD 2
// Limite de l'incrément
#define INCREMENT_LIMIT 10

// Tableau contenant les threads
pthread_t threads[NB_THREAD];

// Structure de données contenant le mutex
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;

// Fonction exécutée dans le thread
void * job(void *arg) {
mutex_data *md = (mutex_data*) arg;
pthread_t tid = pthread_self();
while ((*md).data < INCREMENT_LIMIT) {
// Vérouillage du mutex
pthread_mutex_lock(&(*md).mutex);
(*md).data++;
// Dévérouillage du mutex
pthread_mutex_unlock(&(*md).mutex);
printf("thread [ %ld ] data [ %i ]\n", tid, (*md).data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du thread %ld\n", tid);
pthread_exit(NULL);
}

// Fonction principale
int main() {
// Création du mutex
mutex_data md;
// Initialisation de la donnée
md.data = 0;
// Initialisation du mutex
if (pthread_mutex_init(&md.mutex, NULL) != 0) {
printf("\n mutex init failed\n");
return EXIT_FAILURE;
}
// Boucle de création des threads
for (int i = 0; i < NB_THREAD; i++) {
// Création du thread et passage de la structure par référence
int err = pthread_create(&threads[i], NULL, job, &md);
if (err != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
break;
}
printf("Création du thread numéro %ld\n", threads[i]);
}
// En attente des threads
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
// Destruction du mutex
pthread_mutex_destroy(&md.mutex);
return EXIT_SUCCESS;
}
</source>
Un exemple de l'exécution de ce programme donne la sortie suivante :
<pre>
Création du thread numéro 140530420492032
Création du thread numéro 140530410002176
thread [ 140530410002176 ] data [ 1 ]
thread [ 140530420492032 ] data [ 2 ]
thread [ 140530410002176 ] data [ 3 ]
thread [ 140530420492032 ] data [ 4 ]
thread [ 140530410002176 ] data [ 5 ]
thread [ 140530420492032 ] data [ 6 ]
thread [ 140530420492032 ] data [ 7 ]
thread [ 140530410002176 ] data [ 8 ]
thread [ 140530420492032 ] data [ 9 ]
thread [ 140530410002176 ] data [ 10 ]
Fin du thread 140530420492032
Fin du thread 140530410002176
</pre>

C pthread

2018-11-01T17:50:22Z

Magsss : /* Modification d'une variable */

= Introduction =
Les threads ou ''processus légers'' sont utilisés pour paralléliser l'exécution dans un programme. Ils sont dits ''légers'' car ils s'exécutent dans le même contexte que le processus d'exécution principal qui les crée et consomment donc moins de mémoire / CPU.

= Pré-requis =
Pour pouvoir créer des threads il faut utiliser la librairie ''pthread'' (POSIX thread):
<source lang='c'>
#include <pthread.h>
</source>
Ce qui donne en ligne de commande:
<source lang='bash'>
gcc -lpthread thread_exemple.c
</source>
Pour inclure la librairie dans [[Eclipse_install|Eclispe]] regardez [[C_devel#Ajouter_une_librairie_.C3.A0_un_projet|ici]].
= Premier thread =
Dans ce premier exemple, nous allons créer un thread qui affiche une message:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
printf("Nous sommes dans le thread.\n");
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
pthread_t thread1;
printf("Avant la création du thread.\n");
// Création du thread
pthread_create(&thread1, NULL, thread_1, NULL);
printf("Après la création du thread.\n");
return EXIT_SUCCESS;
}
</source>
Dans cet exemple, nous utilisons la fonction suivante:
<source lang='c'>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''*attr'' correspond aux arguments de création du thread, passer à la fonction ''pthread_create'';
* ''*(*start_routine)'' est un pointeur vers la fonction exécutée par le thread;
* ''*arg'' est un pointeur vers les arguments passés en paramètres à la fonction ''start_routine'';
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EAGAIN → lorsque les ressources sont insuffisantes ou le nombre de threads maximum est atteint;
** EINVAL → lorsqu'un argument invalide est passé en paramètre;
** EPERM → lorsqu'il y a un problème de droit sur l'ordonnanceur (passé en paramètre);
Lorsque l'on exécute cet exemple, on a le résultat suivant :
<pre>
Avant la création du thread.
Après la création du thread.
</pre>
On ne voit pas le message du thread car le programme se termine sans attendre la fin de son exécution. Pour attendre la fin de l'exécution du thread, il faut utiliser la fonction suivante :
<source lang='c'>
int pthread_join(pthread_t thread, void **retval);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''**retval'' est un pointeur vers un entier qui contiendra la valeur de retour du thread;
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EDEADLK → lorsqu'il y a un ''deadlock'';
** EINVAL → lorsque le thread n'est pas joignable;
** ESRCH → si le thread n'existe pas;
Ajoutez la ligne suivante :
<source lang='c'>
pthread_join(thread1, NULL);
</source>
après l'appel de la fonction ''pthread_create'' pour avoir le résultat suivant:
<pre>
Avant la création du thread.
Nous sommes dans le thread.
Après la création du thread.
</pre>

= Modification d'une variable =
Dans cet exemple nous allons incrémenter dans le thread un entier qui est déclaré dans le processus principal:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
int *i = (int *) arg;
(*i)++;
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
int i = 1;
pthread_t thread1;
printf("Avant la création du thread, i = %i.\n", i);
// Création du thread
pthread_create(&thread1, NULL, thread_1, &i);
pthread_join(thread1, NULL);
printf("Après la création du thread, i = %i.\n", i);
return EXIT_SUCCESS;
}
</source>
Cela donne le résultat suivant :
<pre>
Avant la création du thread, i = 1.
Après la création du thread, i = 2.
</pre>
On peut remarquer que:
* dans le processus principal, on passe une référence vers la variable ''i'' (''&i'') dans la fonction ''pthread_create'';
* dans le thread on récupère le pointeur vers cette variable et on la déclare comme étant un entier :
<source lang='c'>
int *i = (int *) arg;
</source>
* on incrémente la valeur et non l'adresse pointée :
<source lang='c'>
(*i)++;
</source>

= Exclusion mutuelle =
Lorsque l'on cherche à modifier dans plusieurs threads, une variable globale, il peut y avoir un problème d'accès concurrent (modification / lecture simultanée). Ce problème peut être réglé en utilisant ce que l'on appel un ''mutex'' (''mutual exclusion'') et pour des questions pratiques, on utilise généralement une structure pour associer la variable à son ''mutex'':

<source lang="c">
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;
</source>

Dans l'exemple ci-dessus on créer une structure de données avec un entier et un ''mutex''.
Il existe plusieurs fonctions pour manipuler les ''mutex'' et voici les principales:
*pour initialiser un ''mutex'':
<source lang="c">
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr )
</source>
*pour verrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_lock(pthread_mutex_t *mutex)
</source>
*pour déverrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_unlock(pthread_mutex_t *mutex)
</source>
*pour détruire un ''mutex'':
<source lang="c">
int pthread_mutex_destroy(pthread_mutex_t *mutex)
</source>

Le programme suivant permet d'incrémenter la valeur d'un entier dans plusieurs thread différents:
<source lang="c">
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// Nombre total de thread
#define NB_THREAD 2
// Limite de l'incrément
#define INCREMENT_LIMIT 10

// Tableau contenant les threads
pthread_t threads[NB_THREAD];

// Structure de données contenant le mutex
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;

// Fonction exécutée dans le thread
void * job(void *arg) {
mutex_data *md = (mutex_data*) arg;
pthread_t tid = pthread_self();
while ((*md).data < INCREMENT_LIMIT) {
// Vérouillage du mutex
pthread_mutex_lock(&(*md).mutex);
(*md).data++;
// Dévérouillage du mutex
pthread_mutex_unlock(&(*md).mutex);
printf("thread [ %ld ] data [ %i ]\n", tid, (*md).data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du thread %ld\n", tid);
pthread_exit(NULL);
}

// Fonction principale
int main() {
// Création du mutex
mutex_data md;
// Initialisation de la donnée
md.data = 0;
// Initialisation du mutex
if (pthread_mutex_init(&md.mutex, NULL) != 0) {
printf("\n mutex init failed\n");
return EXIT_FAILURE;
}
// Boucle de création des threads
for (int i = 0; i < NB_THREAD; i++) {
// Création du thread et passage de la structure par référence
int err = pthread_create(&threads[i], NULL, job, &md);
if (err != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
break;
}
printf("Création du thread numéro %ld\n", threads[i]);
}
// En attente des threads
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
// Destruction du mutex
pthread_mutex_destroy(&md.mutex);
return EXIT_SUCCESS;
}
</source>
Un exemple de l'exécution de ce programme donne la sortie suivante :
<pre>
Création du thread numéro 140530420492032
Création du thread numéro 140530410002176
thread [ 140530410002176 ] data [ 1 ]
thread [ 140530420492032 ] data [ 2 ]
thread [ 140530410002176 ] data [ 3 ]
thread [ 140530420492032 ] data [ 4 ]
thread [ 140530410002176 ] data [ 5 ]
thread [ 140530420492032 ] data [ 6 ]
thread [ 140530420492032 ] data [ 7 ]
thread [ 140530410002176 ] data [ 8 ]
thread [ 140530420492032 ] data [ 9 ]
thread [ 140530410002176 ] data [ 10 ]
Fin du thread 140530420492032
Fin du thread 140530410002176
</pre>

C pthread

2018-11-01T17:49:53Z

Magsss : /* Premier thread */

= Introduction =
Les threads ou ''processus légers'' sont utilisés pour paralléliser l'exécution dans un programme. Ils sont dits ''légers'' car ils s'exécutent dans le même contexte que le processus d'exécution principal qui les crée et consomment donc moins de mémoire / CPU.

= Pré-requis =
Pour pouvoir créer des threads il faut utiliser la librairie ''pthread'' (POSIX thread):
<source lang='c'>
#include <pthread.h>
</source>
Ce qui donne en ligne de commande:
<source lang='bash'>
gcc -lpthread thread_exemple.c
</source>
Pour inclure la librairie dans [[Eclipse_install|Eclispe]] regardez [[C_devel#Ajouter_une_librairie_.C3.A0_un_projet|ici]].
= Premier thread =
Dans ce premier exemple, nous allons créer un thread qui affiche une message:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
printf("Nous sommes dans le thread.\n");
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
pthread_t thread1;
printf("Avant la création du thread.\n");
// Création du thread
pthread_create(&thread1, NULL, thread_1, NULL);
printf("Après la création du thread.\n");
return EXIT_SUCCESS;
}
</source>
Dans cet exemple, nous utilisons la fonction suivante:
<source lang='c'>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''*attr'' correspond aux arguments de création du thread, passer à la fonction ''pthread_create'';
* ''*(*start_routine)'' est un pointeur vers la fonction exécutée par le thread;
* ''*arg'' est un pointeur vers les arguments passés en paramètres à la fonction ''start_routine'';
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EAGAIN → lorsque les ressources sont insuffisantes ou le nombre de threads maximum est atteint;
** EINVAL → lorsqu'un argument invalide est passé en paramètre;
** EPERM → lorsqu'il y a un problème de droit sur l'ordonnanceur (passé en paramètre);
Lorsque l'on exécute cet exemple, on a le résultat suivant :
<pre>
Avant la création du thread.
Après la création du thread.
</pre>
On ne voit pas le message du thread car le programme se termine sans attendre la fin de son exécution. Pour attendre la fin de l'exécution du thread, il faut utiliser la fonction suivante :
<source lang='c'>
int pthread_join(pthread_t thread, void **retval);
</source>
* ''*thread'' est une référence vers la variable qui va contenir le thread;
* ''**retval'' est un pointeur vers un entier qui contiendra la valeur de retour du thread;
* le code retour de la fonction varie entre :
** ''0'' → lorsque tout s'est bien passé;
** EDEADLK → lorsqu'il y a un ''deadlock'';
** EINVAL → lorsque le thread n'est pas joignable;
** ESRCH → si le thread n'existe pas;
Ajoutez la ligne suivante :
<source lang='c'>
pthread_join(thread1, NULL);
</source>
après l'appel de la fonction ''pthread_create'' pour avoir le résultat suivant:
<pre>
Avant la création du thread.
Nous sommes dans le thread.
Après la création du thread.
</pre>

= Modification d'une variable =
Dans cet exemple nous allons incrémenter dans le thread un entier qui est déclarer dans le processus principal:
<source lang='c'>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void *thread_1(void *arg) {
int *i = (int *) arg;
(*i)++;
// Arrêt propre du thread
pthread_exit(NULL);
}

int main(void) {
// Création de la variable qui va contenir le thread
int i = 1;
pthread_t thread1;
printf("Avant la création du thread, i = %i.\n", i);
// Création du thread
pthread_create(&thread1, NULL, thread_1, &i);
pthread_join(thread1, NULL);
printf("Après la création du thread, i = %i.\n", i);
return EXIT_SUCCESS;
}
</source>
Cela donne le résultat suivant :
<pre>
Avant la création du thread, i = 1.
Après la création du thread, i = 2.
</pre>
On peut remarquer que:
* dans le processus principal, on passe une référence vers la variable ''i'' (''&i'') dans la fonction ''pthread_create'';
* dans le thread on récupère le pointeur vers cette variable et on la déclare comme étant un entier :
<source lang='c'>
int *i = (int *) arg;
</source>
* on incrémente la valeur et non l'adresse pointée :
<source lang='c'>
(*i)++;
</source>

= Exclusion mutuelle =
Lorsque l'on cherche à modifier dans plusieurs threads, une variable globale, il peut y avoir un problème d'accès concurrent (modification / lecture simultanée). Ce problème peut être réglé en utilisant ce que l'on appel un ''mutex'' (''mutual exclusion'') et pour des questions pratiques, on utilise généralement une structure pour associer la variable à son ''mutex'':

<source lang="c">
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;
</source>

Dans l'exemple ci-dessus on créer une structure de données avec un entier et un ''mutex''.
Il existe plusieurs fonctions pour manipuler les ''mutex'' et voici les principales:
*pour initialiser un ''mutex'':
<source lang="c">
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr )
</source>
*pour verrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_lock(pthread_mutex_t *mutex)
</source>
*pour déverrouiller un ''mutex'':
<source lang="c">
int pthread_mutex_unlock(pthread_mutex_t *mutex)
</source>
*pour détruire un ''mutex'':
<source lang="c">
int pthread_mutex_destroy(pthread_mutex_t *mutex)
</source>

Le programme suivant permet d'incrémenter la valeur d'un entier dans plusieurs thread différents:
<source lang="c">
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

// Nombre total de thread
#define NB_THREAD 2
// Limite de l'incrément
#define INCREMENT_LIMIT 10

// Tableau contenant les threads
pthread_t threads[NB_THREAD];

// Structure de données contenant le mutex
typedef struct mutex_data {
int data;
pthread_mutex_t mutex;
} mutex_data;

// Fonction exécutée dans le thread
void * job(void *arg) {
mutex_data *md = (mutex_data*) arg;
pthread_t tid = pthread_self();
while ((*md).data < INCREMENT_LIMIT) {
// Vérouillage du mutex
pthread_mutex_lock(&(*md).mutex);
(*md).data++;
// Dévérouillage du mutex
pthread_mutex_unlock(&(*md).mutex);
printf("thread [ %ld ] data [ %i ]\n", tid, (*md).data);
// Pause l'exécution du thread pendant 1 seconde
sleep(1);
}
printf("Fin du thread %ld\n", tid);
pthread_exit(NULL);
}

// Fonction principale
int main() {
// Création du mutex
mutex_data md;
// Initialisation de la donnée
md.data = 0;
// Initialisation du mutex
if (pthread_mutex_init(&md.mutex, NULL) != 0) {
printf("\n mutex init failed\n");
return EXIT_FAILURE;
}
// Boucle de création des threads
for (int i = 0; i < NB_THREAD; i++) {
// Création du thread et passage de la structure par référence
int err = pthread_create(&threads[i], NULL, job, &md);
if (err != 0) {
printf("Echec de la création du thread: [%s]", strerror(err));
break;
}
printf("Création du thread numéro %ld\n", threads[i]);
}
// En attente des threads
for (int i = 0; i < NB_THREAD; i++) {
pthread_join(threads[i], NULL);
}
// Destruction du mutex
pthread_mutex_destroy(&md.mutex);
return EXIT_SUCCESS;
}
</source>
Un exemple de l'exécution de ce programme donne la sortie suivante :
<pre>
Création du thread numéro 140530420492032
Création du thread numéro 140530410002176
thread [ 140530410002176 ] data [ 1 ]
thread [ 140530420492032 ] data [ 2 ]
thread [ 140530410002176 ] data [ 3 ]
thread [ 140530420492032 ] data [ 4 ]
thread [ 140530410002176 ] data [ 5 ]
thread [ 140530420492032 ] data [ 6 ]
thread [ 140530420492032 ] data [ 7 ]
thread [ 140530410002176 ] data [ 8 ]
thread [ 140530420492032 ] data [ 9 ]
thread [ 140530410002176 ] data [ 10 ]
Fin du thread 140530420492032
Fin du thread 140530410002176
</pre>