En C, comment utilisez-vous libcurl pour lire une réponse HTTP dans une chaîne?

J'ai des devoirs où j'ai besoin d'une certaine manière à comparer les deux réponses HTTP. Je suis en train d'écrire sur le C et j'ai utiliser libcurl pour rendre les choses plus facile. Je suis l'appel de la fonction qui utilise libcurl pour faire une demande et la réponse HTTP à partir d'une autre fonction, et je veux le retour de la réponse HTTP en tant que char *. Voici mon code pour l'instant (ça plante):

#include <stdio.h>
#include <curl/curl.h>
#include <string.h>

size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream) {
    size_t written;
    written = fwrite(ptr, size, nmemb, stream);
    return written;
}

char *handle_url(void) {
    CURL *curl;
    char *fp;
    CURLcode res;
    char *url = "http://www.yahoo.com";
    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
                fprintf(stderr, "curl_easy_perform() failed: %s\n",   curl_easy_strerror(res));

        curl_easy_cleanup(curl);

        //printf("\n%s", fp);
    }
    return fp;
}

Cette solution C libcurl obtenir une sortie dans une chaîne fonctionne, mais pas dans mon cas car j'ai juste envie de retourner la chaîne à la fonction appelante.

Des idées?

source d'informationauteur empty set

  1. 19

    Fixe pour vous. Vous avez besoin de gérer le cas où l' write_data() fonction est appelée plusieurs fois, et passer le bon type de paramètre. Vous avez également besoin de garder une trace de la façon dont grand une structure que vous avez, de sorte que vous pouvez allouer suffisamment de mémoire.

    Je l'ai laissé dans un debug printf dans le write_data fonction pour vous aider à comprendre comment il fonctionne.

    #include <stdio.h>
#include <curl/curl.h>
#include <string.h>
#include <stdlib.h>
struct url_data {
size_t size;
char* data;
};
size_t write_data(void *ptr, size_t size, size_t nmemb, struct url_data *data) {
size_t index = data->size;
size_t n = (size * nmemb);
char* tmp;
data->size += (size * nmemb);
#ifdef DEBUG
fprintf(stderr, "data at %p size=%ld nmemb=%ld\n", ptr, size, nmemb);
#endif
tmp = realloc(data->data, data->size + 1); /* +1 for '\0' */
if(tmp) {
data->data = tmp;
} else {
if(data->data) {
free(data->data);
}
fprintf(stderr, "Failed to allocate memory.\n");
return 0;
}
memcpy((data->data + index), ptr, n);
data->data[data->size] = '\0';
return size * nmemb;
}
char *handle_url(char* url) {
CURL *curl;
struct url_data data;
data.size = 0;
data.data = malloc(4096); /* reasonable size initial buffer */
if(NULL == data.data) {
fprintf(stderr, "Failed to allocate memory.\n");
return NULL;
}
data.data[0] = '\0';
CURLcode res;
curl = curl_easy_init();
if (curl) {
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",  
curl_easy_strerror(res));
}
curl_easy_cleanup(curl);
}
return data.data;
}
int main(int argc, char* argv[]) {
char* data;
if(argc < 2) {
fprintf(stderr, "Must provide URL to fetch.\n");
return 1;
}
data = handle_url(argv[1]);
if(data) {
printf("%s\n", data);
free(data);
}
return 0;
}

    Remarque: compiler avec gcc -o test test.c -lcurl (en supposant que vous avez collé dans test.c). Utilisation gcc -o test test.c -lcurl -DDEBUG de voir le test de printf() appels.

    Avertissement: c'est moche, rapide et sale de code. Il peut y avoir des bugs. Veuillez voir le plus robuste, mieux un exemple commenté ici.