Discussion :

[fanfouer]

Bonjour,

Je suis entrain d'écrire plusieurs classes permettant de faire des requêtes HTTP/HTTPS et gérant les différent scenarii d'authentification définis dans ces protocoles.

En HTTP 1.1, l'usage de réponses "chunkées" me déroute à plusieurs égards et notamment dans la lecture du contenu du socket.
De ce que j'ai compris, un serveur HTTP 1.1 va diviser la réponse à faire en plusieurs morceaux et les envoie au fil de l'eau précédés de leur taille en octets.

J'utilise massivement Boost.asio et me suis inspiré de cet exemple : http://www.boost.org/doc/libs/1_53_0...ync_client.cpp
Je l'ai complétement repris pour fusionner les deux approches synchrones/asynchrones et ajouter HTTPS/SSL.

En mode synchrone, je cherche à mettre l'intégralité du contenu du socket dans un std::stringstream avant de passer à la phase de traitement (c'est pareil en asynchrone en fait mais avec une spécificité supplémentaire qui complexifierait l'explication ici).

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
 
	std::stringstream *http_body = new std::stringstream(); // Flux du corp de la reponse à la requete
	boost::asio::streambuf *response = new boost::asio::streambuf(HTTP_SOCKET_MAXSIZE); // Flux de reponse brut
	boost::system::error_code step_err; // Erreur éventuelle à cet étape du traitement
	int size_read = -1; // Taille en octets lue depuis le socket
	// Premiere lecture avant le \r\n\r\n séparant les headers du body
	try {
		boost::asio::read_until(*socket, *response, "\r\n\r\n");
		*http_body << response;
	}catch (boost::system::system_error &e){
		step_err = e.code();
	}
 
	// Lecture du body ligne par ligne jusqu'à la fin
	while (size_read != 5){
		try {
			boost::asio::read_until(*socket, *response, "\r\n");
			size_read = response->size();
			std::cout << size_read << std::endl;
			*http_body << response;
		}catch (boost::system::system_error &e){
			step_err = e.code();
		}
	}
 
	this->send_handle_readContent (socket, response, http_body, step_err); // Passage a l'étape suivante

Néanmoins, dans le cas de réponses longues (une page HTML, par exemple http://www.infos-reseaux.com sur lequel je fais mes tests) je n'ai pas la totalité de la réponse. La lecture s'arrête à un endroit complétement arbitraire qui ne laisse rien entrevoir sur le pourquoi de la chose.

Sur des réponses bien plus courtes, par exemple :http://www.infos-reseaux.com/service...poData.Owner/2
J'ai le tout sans problème.

Le fait que la réponse soit chunkée ne permet pas de connaitre à l'avance la taille totale de la réponse du coup je vois mal comment déterminer une condition de fin de lecture.
Je crois que c'est ce qui pose problème ici.

Est-ce que quelqu'un a une expérience en la matière?

Merci par avance & bon week end

[koala01]

Salut,

Le code qui s'occupe normalement de récupérer le corps de la page est

Code :

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

1
2
3
while (boost::asio::read(socket, response,
          boost::asio::transfer_at_least(1), error))
      std::cout << &response;

qui a pour résultat:
de lire sur le socket (socket) le transfert minimum de 1 byte, de placer le résultat de cette lecture dans la variable response et de définir l'erreur (s'il y en a une) error.

Comme c'est dans une boucle, cela s'effectue "jusqu'à ce qu'une erreur survienne"

Le std::cout<<&responsecorrespond au traitement de la réponse
juste après, tu as une vérification d'erreur, car, la fin du flux est considérée comme une erreur.

Si l'erreur est "autre chose" que EOF (End Of File), alors, on lance une exception (qui devra être rattrapée par un catch )

Code :

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

1
2
    if (error != boost::asio::error::eof)
      throw boost::system::system_error(error);

NOTA: response est un streambuffer, c'est à dire, "simplement" un tableau de caractères qui sera agrandi automatiquement lors de l'ajout, et qui pourra être utilisé (pas son adresse) par "n'importe quel flux" que tu pourrais envisager, ce qui explique le fait que l'on utilise "l'adresse de" response à chaque fois

[fanfouer]

Bonjour koala01, merci pour cette réponse.

En fait le code donné dans l'exemple boost est adapté pour du HTTP 1.0 dans lequel le chunking n'est pas de mise.

En utilisant cela le while(read...), j'ai remarqué trois possibilités d'échec:
- Soit le \r\n\r\n entre les en-têtes et le body stoppe la lecture de telle sorte que je n'ai que les en-têtes et pas de corps.
- Soit la lecture de quelque chunk désoriente le mécanisme qui remplis le socket et je n'ai pas tout le corps.
- Enfin, si j'ai toute la réponse, end of file n'est pas prononcé et read attends jusque le socket soit remplis à nouveau. Donc je n'ai pas de boucle infinie mais mon programme est bloqué.

Je suis entrain de regarder en parallèle si l'utilisation de cpp-netlib n'est pas plus pertinente.
Des avantages sont non négligeables:
- L'interface uniforme qu'il s'agisse de requêtes synchrones ou asynchrones et le support intégré du SSL.
Je n'ai plus qu'à écrire qu'un wrapper de leur client et le tour est joué.

D'un autre côté je suis curieux de savoir pourquoi le chunking perturbe autant Boost

Bonne après midi.

[koala01]

Je ne sais pas si tu l'as remarqué, mais, a priori, cela se passe en deux temps:
1- on récupère l'en-tête depuis le socket avec un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
    // Process the response headers.
    std::string header;
    while (std::getline(response_stream, header) && header != "\r")
      std::cout << header << "\n";
    std::cout << "\n";
    // Process the response headers.
    std::string header;
    while (std::getline(response_stream, header) && header != "\r")
      std::cout << header << "\n";
    std::cout << "\n";

2- on récupère le corps de la page (en gros, ce qui se trouve entre les balises <html> et </html>) avec le code

Code :

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

1
2
3
4
5
6
7
  // Read until EOF, writing data to output as we go.
    boost::system::error_code error;
    while (boost::asio::read(socket, response,
          boost::asio::transfer_at_least(1), error))
      std::cout << &response;
    if (error != boost::asio::error::eof)
      throw boost::system::system_error(error);

Il est donc de ton ressort de veiller à récupérer l'en-tête "si besoin"

[fanfouer]

Oui je suis bien d'accord... Cela est valable pour le 1er cas d'échec mais pour les deux autres?

Lorsque la réponse est vraiment longue, avec ou sans récupération des en-tetes je n'ai quand même pas tous les chunks.