W języku C, jak używać biblioteki libcurl do odczytywania odpowiedzi HTTP na ciąg znaków?

Question

Mam pracę domową, w której muszę jakoś porównać dwie odpowiedzi HTTP. Piszę to na C i używam libcurl, aby było łatwiej. Wywołuję funkcję, która używa libcurl do wykonania żądania HTTP i odpowiedzi z innej funkcji, i chcę zwrócić odpowiedź HTTP jako char *. Tu jest mój kodu tak daleko (zawiesi):

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

Rozwiązanie C libcurl get output into a string działa, ale nie w moim przypadku, bo po prostu chcą, aby powrócić ciąg do funkcji wywołującej.

Wszelkie pomysły?

Answer 1

Naprawiono to za Ciebie. Musisz zająć się przypadkiem, w którym funkcja write_data() jest wywoływana wiele razy, i przekazać mu odpowiedni rodzaj parametru. Musisz także śledzić, jak dużą masz strukturę, dzięki czemu możesz przydzielić wystarczającą ilość pamięci.

Zostawiłem w debugowania printf w funkcji write_data które pomogą Ci zrozumieć, jak to działa.

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

Uwaga: skompilować z gcc -o test test.c -lcurl (zakładając, że wklejony test.c). Użyj numeru gcc -o test test.c -lcurl -DDEBUG, aby wyświetlić wywołania testowe printf().

Nota prawna: to brzydki, szybki i brudny kod. Mogą występować błędy. Proszę zobaczyć more robust, better commented example here.