Parsen von HTTP-Headern in C++

Ich bin mit curl zur Kommunikation mit einem server.

Wenn ich eine Anfrage für Daten erhalte ich den HTTP-Header, gefolgt von jpeg-Daten durch eine Grenze getrennt und zwar so:

Parsen von HTTP-Headern in C++

Muss ich analysieren

  1. Der boundary string
  2. Die Content-Length.

Habe ich kopiert die eingehenden Daten in einem char-array in etwa so:

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 );
}

Wie kann ich am besten tun Sie dies in C++?? Wie kann ich eigentlich überprüfen und analysieren die _data array für die Informationen, die ich will?? Sind die alle boost-Bibliotheken, die ich benutzen kann zum Beispiel???

Eine Antwort, die nicht mit boost oder irgendetwas würde sehr geschätzt werden.

InformationsquelleAutor Harry Boy | 2014-09-17

  1. 4

    Könnte man Parsen der Header-on-the-fly, oder stellen Sie Sie in einer Karte und post-Prozess später.
    Verwenden find, substr Methoden aus der std::string.
    Blick auf Boost String Algorithmen Library, es enthält viele algorithmen, z.B. trim

    z.B. Platz-Header in die std::map und drucken Sie (Rohschnitt):

    #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;
}

    Erhalten Sie die Ausgabe:

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

    Dass die überschriften, die Sie extrahieren konnte der Bedarf für das post-processing.

    Wie er verwendet libcurl, wissen Sie, dass er in einer einzigen vollständigen header in jedem callback, das macht es viel einfacher zu Parsen...

    InformationsquelleAutor Grigorii Chudnov

  2. 1

    Den cpp-Netzwerkbibliothek Projekt (basierend auf boost) enthält einen vollständigen MIME-parser (geschrieben mit boost.Geist).

    Ich bin nicht wirklich glücklich mit der Schnittstelle des parsers, aber es funktioniert gut.

    InformationsquelleAutor Marshall Clow

  3. 1

    Ich würde alle Header in eine Karte, nach denen Sie leicht Durchlaufen wird. Keine Verstärkung benötigt. Hier ein grundlegendes Beispiel arbeiten mit 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;
    }
}

    InformationsquelleAutor jvandenbroek

Schreibe einen Kommentar