cURL - mettre la sortie dans la variable?

Je suis actuellement en utilisant ce code C:

CURL *curl;
CURLcode res;

curl = curl_easy_init();
if (curl) {
    curl_easy_setopt(curl, CURLOPT_URL, "http://my-domain.org/");
    res = curl_easy_perform(curl);

    curl_easy_cleanup(curl);
}

Il imprime le résultat sur la console. Comment puis-je obtenir le même résultat, mais de le lire dans, disons, une chaîne de caractères? (C'est probablement une question de base, mais je ne comprend pas encore le libcurl API...)

Merci pour toute aide!

Mike

source d'informationauteur Mike

  1. 16

    Vous avez besoin de passer une fonction de tampon et d'écrire dans la zone tampon.

    /* setting a callback function to return the data */
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_callback_func);

/* passing the pointer to the response as the callback parameter */
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &response);


/* the function to invoke as the data recieved */
size_t static write_callback_func(void *buffer,
                        size_t size,
                        size_t nmemb,
                        void *userp)
{
    char **response_ptr =  (char**)userp;

    /* assuming the response is a string */
    *response_ptr = strndup(buffer, (size_t)(size *nmemb));

}

    Veuillez jeter un oeil plus d'infos ici.

  2. 4

    vous avez besoin d'une écriture fonction de rappel. J'utilise ce genre de fonction pour lire la réponse, d'erreur et d'être en mesure de fournir mes propres en-têtes:

    size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream)
{
std::string buf = std::string(static_cast<char *>(ptr), size * nmemb);
std::stringstream *response = static_cast<std::stringstream *>(stream);
response->write(buf.c_str(), (std::streamsize)buf.size());
return size * nmemb;
}
bool CurlGet(
const std::string &url, 
const std::vector<std::string> &headers, 
std::stringstream &response, 
std::string &error)
{
curl_global_init(CURL_GLOBAL_ALL);
curl_slist *headerlist = NULL;
std::vector<std::string>::const_iterator it;
for (it = headers.begin(); it < headers.end(); it++) {
headerlist = curl_slist_append(headerlist, it->c_str());
}   
CURL *curl = curl_easy_init();
char ebuf[CURL_ERROR_SIZE];
curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, ebuf);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
CURLcode res = curl_easy_perform(curl); 
curl_easy_cleanup(curl);
curl_slist_free_all(headerlist);
if (res != CURLE_OK)
error = ebuf;
else
error.clear();
return res == CURLE_OK; 
}
  3. 2

    Cela peut être fait en utilisant

    curl_easy_setopt(easyhandle, CURLOPT_WRITEFUNCTION, write_data);

    qui définit une fonction de rappel write_data qui est une fonction avec la signature

    size_t write_data(void *buffer, size_t size, size_t nmemb, void *userp);

    Si vous voulez userp être certains internes struct que vous utilisez dans votre programme, appel 

    curl_easy_setopt(easyhandle, CURLOPT_WRITEDATA, &internal_struct);

    pour obtenir le pointeur de internal_struct transmise à chaque appel de write_data.

  4. 1

    Salut, je résoudre les problème de retour de code 23 de retour d'appel de la fonction de retour de la taille de fonction de rappel.

    voir code ci-dessous:

    /* setting a callback function to return the data */
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_callback_func);
/* passing the pointer to the response as the callback parameter */
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &response);
/* the function to invoke as the data recieved */
size_t static write_callback_func(void *buffer,
size_t size,
size_t nmemb,
void *userp)
{
char **response_ptr =  (char**)userp;
/* assuming the response is a string */
*response_ptr = strndup(buffer, (size_t)(size *nmemb));
return ((size_t)(size *nmemb));
//if you not send return value of size it will show you ERROR CODE 23return  curl_easy_perform();
}
  5. 0

    Aucun des autres exemples travaillé pour moi.

    Voici ce que j'ai fini par le faire:

    size_t static curl_write(void *buffer, size_t size, size_t nmemb, void *userp)
{
userp += strlen(userp);  //Skipping to first unpopulated char
memcpy(userp, buffer, nmemb);  //Populating it.
return nmemb;
}
int GetCurl()
{
CURL *curl;
CURLcode res;
char *s = (char *) malloc(512);
curl = curl_easy_init();
if (curl)
{
curl_easy_setopt(curl, CURLOPT_URL, "http://www.google.com");
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, s);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
}
printf("GREAT SUCCESS!! Your string is %s\n", s);
}