Analyser les en-têtes HTTP en C++

J'utilise curl pour communiquer avec un serveur.

Quand je fais une demande de données-je recevoir les en-têtes HTTP suivie par jpeg de données, séparés par une frontière comme suit:

Analyser les en-têtes HTTP en C++

J'ai besoin d'analyser

  1. La frontière de la chaîne
  2. La Longueur Du Contenu.

J'ai copié les données entrantes à un char array comme ceci:

static size_t OnReceiveData ( void * pvData, size_t tSize, size_t tCount, void * pvUser )
{
    printf("%*.*s", tSize * tCount, tSize * tCount, pvData);

    char* _data;
    if(pvData != nullptr && 0 != tCount)
    {
        _data = new char[tCount];
       memcpy(_data, pvData, tCount);
    }

    return ( tCount );
}

Comment puis-je mieux le faire en C++?? Comment inspecter et analyser les _data tableau pour l'information que je veux?? Sont toutes les bibliothèques boost que je peux utiliser par exemple??

Une réponse pas d'utilisation de boost ou quoi que ce soit serait très appréciée.

OriginalL'auteur Harry Boy | 2014-09-17

  1. 4

    Vous pourriez analyser les en-têtes à la volée, ou de les mettre dans une carte et post-traiter plus tard.
    Utilisation find, substr méthodes de la std::string.
    Regardez Stimuler La Chaîne Des Algorithmes De La Bibliothèque, il contient beaucoup d'algorithmes, par exemple trim

    par exemple, pour placer les en-têtes dans le std::map et de les imprimer (rough cuts):

    #include <stdlib.h>
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <boost/algorithm/string.hpp>

int main(int argc, char* argv[]) {
  const char* s = "HTTP/1.1 200 OK\r\n"
    "Content-Type: image/jpeg; charset=utf-8\r\n"
    "Content-Length: 19912\r\n\r\n";

  std::map<std::string, std::string> m;

  std::istringstream resp(s);
  std::string header;
  std::string::size_type index;
  while (std::getline(resp, header) && header != "\r") {
    index = header.find(':', 0);
    if(index != std::string::npos) {
      m.insert(std::make_pair(
        boost::algorithm::trim_copy(header.substr(0, index)), 
        boost::algorithm::trim_copy(header.substr(index + 1))
      ));
    }
  }

  for(auto& kv: m) {
    std::cout << "KEY: `" << kv.first << "`, VALUE: `" << kv.second << '`' << std::endl;
  }

  return EXIT_SUCCESS;
}

    Vous obtiendrez la sortie:

    KEY: `Content-Length`, VALUE: `19912`
KEY: `Content-Type`, VALUE: `image/jpeg; charset=utf-8`

    Avoir les en-têtes, vous pouvez extraire le nécessaire pour le post-traitement.

    Comme il utilise libcurl, vous savez qui il est un seul plein d'en-tête dans chaque rappel, ce qui le rend beaucoup plus simple à analyser...

    OriginalL'auteur Grigorii Chudnov

  2. 1

    La rpc-netlib projet (basé sur boost) contient un analyseur MIME (écrit avec boost.de l'esprit).

    Je ne suis pas vraiment heureux avec l'interface de l'analyseur, mais il fonctionne bien.

    OriginalL'auteur Marshall Clow

  3. 1

    Je mettrais tous les en-têtes dans une carte, après quoi vous pouvez facilement parcourir. Pas de boost nécessaire. Voici une base de travail exemple avec libcurl:

    #include <iostream>
#include <string>
#include <map>
#include <curl/curl.h>
static size_t OnReceiveData (void * pData, size_t tSize, size_t tCount, void * pmUser)
{
size_t length = tSize * tCount, index = 0;
while (index < length)
{
unsigned char *temp = (unsigned char *)pData + index;
if ((temp[0] == '\r') || (temp[0] == '\n'))
break;
index++;
}
std::string str((unsigned char*)pData, (unsigned char*)pData + index);
std::map<std::string, std::string>* pmHeader = (std::map<std::string, std::string>*)pmUser;
size_t pos = str.find(": ");
if (pos != std::string::npos)
pmHeader->insert(std::pair<std::string, std::string> (str.substr(0, pos), str.substr(pos + 2)));
return (tCount);
}
int main(int argc, char* argv[])
{
CURL *curl = curl_easy_init();
if (!curl)
return 1;
std::map<std::string, std::string> mHeader;
curl_easy_setopt(curl, CURLOPT_URL, "http://www.example.com");
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, OnReceiveData);
curl_easy_setopt(curl, CURLOPT_HEADERDATA, &mHeader);
curl_easy_setopt(curl, CURLOPT_NOBODY, true);
curl_easy_perform(curl);
curl_easy_cleanup(curl);
std::map<std::string, std::string>::const_iterator itt;
for (itt = mHeader.begin(); itt != mHeader.end(); itt++)
{
if (itt->first == "Content-Type" || itt->first == "Content-Length")
std::cout << itt->first << ": " << itt->second << std::endl;
}
}

    OriginalL'auteur jvandenbroek