Socket requête http

**Heroiik** · 26/12/2014, 21h51

Bonsoir,

je suis un tutoriel sur les sockets BSD en c (http://lacl.univ-paris12.fr/cegielski/sec/ch6.pdf) section 6.3.10 et je comprend pas quelque chôse, dans le code ont crée un socket client et un serveur, ensuite je m'y connect grâce à mon navigateur et le socket client envoi au serveur la page qu'il veut afficher, donc pour une fois c'est le client qui envoi la page et non le serveur, sauf que pour envoyé le code il faut d'abord lire une ligne. Hélas il n'explique pas pourquoi... si quelqu'un peut me dire pourquoi ont ne peut pas seulement envoyé la page sans avoir à lire ce que le serveur nous à envoyé.

Merci d'avance

**Obsidian** · 28/12/2014, 14h29

Bonjour,

Une fois la connexion établie, ce qui transite par le canal mis en place ne concerne plus le système et n'est donc pas relatif aux sockets proprement dits.

En l'occurrence, il s'agit simplement d'une petite simulation d'un serveur web. À cette occasion, le client indique au serveur la page qu'il souhaite consulter et celui-ci la lui renvoie. La lecture de ligne en question sert donc juste à recevoir la requête du client même si elle n'est jamais analysée en elle-même et que c'est toujours la même page qui est renvoyée ensuite.

**Heroiik** · 28/12/2014, 15h04

Salut et merci de ta réponse.

La lecture de ligne en question sert donc juste à recevoir la requête du client

Cela veut dire que la requête du client n'est jamais envoyé au serveur ?

Dans ce cas en quoi la récupérer, permet de continuer l’échange d'information ?

Merci.

**Obsidian** · 28/12/2014, 16h22

Si tu te « connectes avec ton navigateur », alors le client, c'est ce navigateur.

La totalité du code que tu vois entre les pages 140 à 142 du document que tu nous présentes est celui du serveur, exclusivement. L'ambiguïté vient probablement du fait que ce que tu appelles socket client est ici celui qui correspond à la connexion, en gardant bien à l'esprit qu'une application peut gérer plusieurs connexions simultanément. Les sockets sont initialement une interface unifiée pour faire de la communication inter-processus en environnement BSD, mais ce n'est que par extension qu'ils sont devenus le mécanisme privilégié pour gérer le réseau (en partie pour raisons historiques, d'ailleurs). Donc, à la base, les sockets sont un peu des descripteurs à tout faire.

Quand tu mets en place un « serveur », tu crées une application qui fonctionne à l'arrière-plan, se met à l'écoute des connexions entrantes et sert les informations demandées par les homologues qui se sont connectés. Vis-à-vis de la programmation système et des sockets, cela va se traduire par :

La création initiale d'un socket (a priori relié à rien) ;
L'association d'une adresse particulière à ce socket grâce à bind(). Tu peux donc lui attribuer une adresse sur le réseau mais également dans d'autres domaines, comme la famille UNIX (ce qui te permet de te « connecter à un nom de fichier », ce qui est un concept assez subtil) ;
Le passage en mode écoute de ce socket avec listen(). Ce n'est qu'à ce stade que tu vas pouvoir commencer à recevoir des connexions entrantes ;
L'acceptation d'une connexion entrante avec accept().

C'est ce dernier point qui est important : lorsque tu appelles accept(), cette fonction te renvoie un autre socket qui, lui, correspond à la connexion établie entre ton serveur et son homologue. Ça lui permet de la traiter individuellement et de la refermer avec close() en fin de dialogue. Le premier socket, lui, continue de vivre sa vie et est toujours à l'écoute. On peut même accepter une nouvelle connexion entrante alors que la première n'est pas encore terminée. accept() renverra encore une fois un nouveau socket propre à cette connexion. Dès lors qu'on ferme le premier socket, c'est tout le serveur qui cesse d'être à l'écoute et les connexions entrantes sont refusées par le système.

En résumé, donc, coté serveur :

Un socket pour recevoir toutes les connexions entrantes, PLUS…
Un socket par connexion établie.

**Heroiik** · 28/12/2014, 16h32

Ah d'accord, merci d'avoir pris le temps de m'expliquer, je viens de comprendre mais ce document est flou (pour un débutant comme moi

)

Bonne journée !

**Obsidian** · 28/12/2014, 16h43

Envoyé par Heroiik

Ah d'accord, merci d'avoir pris le temps de m'expliquer, je viens de comprendre mais ce document est flou (pour un débutant comme moi

)

À ton service. Pour être honnête, je ne suis pas très fan de ce document non plus. Certes, la personne qui l'a écrit a essayé d'être pédagogue et a une réelle volonté de transmettre son savoir mais certains de ces exemples sont mal choisis. Par exemple, pour illustrer l'OOB, plutôt qu'un client qui passe devant tout le monde à la boulangerie, j'aurais plutôt choisi de parler d'une ambulance qui emprunte la bande d'arrêt d'urgence, ou qui utilise son gyrophare pour demander la priorité quand elle circule en ville. Ces deux derniers cas auraient été en rapport avec les réseaux qui disposent de canaux dédiés (par exemple le canal de service D des connexions ISDN) et les réseaux hors-connexions par paquet, comme Internet, dans lesquels on peut marquer un datagramme pour en signifier la priorité.

Bonne journée !

De même, mais n'oublie pas le bouton « résolu » en bas de page.
Merci.

**Heroiik** · 28/12/2014, 16h47

Juste une dernière question,

j'ai modifié le code qui pour moi est plus claire, sauf que désormais je n'arrive pas à voir la page, la page reste en chargement donc j'ai une page blanche et quand je stop le serveur la page se charge.

Par contre quand j'ouvre les flux (seulement ouverture, fermeture) je n'ai plus aucun problème.
Et l’état du socket est "Time Wait" est devrais être "Etablished".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/* serveur.c */
 
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netinet/in.h>
#include <string.h>
#include <stdlib.h>
 
int main(void)
{
    int s;  /* descripteur de socket serveur */
    int c;  /* descripteur de socket accepte */
    struct sockaddr_in serveur;
    struct sockaddr_in client;
    unsigned int longeur;
    char entree[1024];
 
    /* Creation d’un socket serveur */
    s = socket(AF_INET, SOCK_STREAM, 0);
 
    /* Association d’une adresse sur le port 7777 */
    memset(&serveur, 0, sizeof(serveur));
    serveur.sin_family = AF_INET;
    serveur.sin_port = ntohs(7777);
    serveur.sin_addr.s_addr = ntohl(INADDR_LOOPBACK);
 
    bind(s, (struct sockaddr *) &serveur, sizeof(serveur));
 
    /* Mise du serveur a l’ecoute */
    listen(s, 20);
 
    /* Accepte une ligne de texte 
    * l’ignore
    * puis envoie une page Web */
 
    while(1)
    {
        /* Attend une connexion */
        longeur = sizeof(client);
        c = accept(s, (struct sockaddr *) &client, &longeur);
 
        //  Récupere le contenu de la requête client et l'ignore
        recv(c, entree, sizeof(entree), 0);
 
        // debug pour voir le contenu
        printf("%s", entree);
 
        // Page à envoyer
        char request[] = "<HTML>\n<BODY>\n<H1>Bonjour</H1>\n</BODY>\n</HTML>\n";
 
        // Envoie une page HTML
        send(c, request, sizeof(request), 0);
    }
 
    return 0;
}

**Obsidian** · 28/12/2014, 18h41

Envoyé par Heroiik

j'ai modifié le code qui pour moi est plus claire, sauf que désormais je n'arrive pas à voir la page, la page reste en chargement donc j'ai une page blanche et quand je stop le serveur la page se charge.

C'est dû au fait que tu as oublié de refermer la connexion « c » à la fin de ta boucle while(). C'est d'ailleurs un problème puisque tu réutilises la même variable en faisant un tour de boucle et que, donc, tu écrases l'identifiant de la connexion courante qui est toujours active. Et puisqu'elle reste ouverte, le navigateur attend sagement la suite. Quand tu y mets fin artificiellement en cliquant sur STOP, le navigateur y met fin de sa propre initiative puis met en forme ce qu'il a reçu jusque là.

Par contre quand j'ouvre les flux (seulement ouverture, fermeture) je n'ai plus aucun problème.
Et l’état du socket est "Time Wait" est devrais être "Etablished".

Elle n'est plus « established » puisque c'est le navigateur qui a raccroché. Le système y a donc mis fin également mais comme le programme ne s'en est pas soucié, il ne le sait pas encore.

« time wait », en revanche, est un état appliqué par le système aux sockets qui viennent d'être refermés, et ce même si le programme a pris fin. C'est un délai de grâce appliqué aux adresses qu'ils occupent de façon à ce que le brassage se fasse correctement et pour éviter que deux connexions distinctes soient confondues lorsque l'on utilise des protocoles hors-connexion, comme UDP. C'est similaire à ce que ferait un opérateur téléphonique qui mettrait en attente le numéro d'une ligne fraîchement résiliée pendant quelques temps avant de le réattribuer.

C'est très utile, par contre c'est pénible pour un serveur qui est fait pour se mettre à l'écoute d'une adresse bien déterminée : pour une raison incompréhensible, celui-ci ne peut pas être lancé deux fois de suite. Il faut laisser la machine « reposer » avant de recommencer et, en général, nulle part il n'est écrit pourquoi. :-) Tous les programmeurs réseau ont été confrontés à ça au moins une fois et ont découvert SO_REUSEADDR à cette occasion…

**Heroiik** · 28/12/2014, 18h52

Je te remercie !

Socket requête http

Réseau C

Discussions similaires

Partager

Partager