libcurl examples

The native API for libcurl is in C so this chapter is focussed on examples
written in C. But since many language bindings for libcurl are thin, they
usually expose more or less the same functions and thus they can still be
interesting and educational for users of other languages, too.

Get a simple HTML page

This example just fetches the HTML and sends it to stdout:

  1. #include <stdio.h>
  2. #include <curl/curl.h>
  4. int main(void)
  5. {
  6.   CURL *curl;
  7.   CURLcode res;
  9.   curl = curl_easy_init();
  10.   if(curl) {
  11.     curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/");
  13.     /* Perform the request, res will get the return code */
  14.     res = curl_easy_perform(curl);
  15.     /* Check for errors */
  16.     if(res != CURLE_OK)
  17.       fprintf(stderr, "curl_easy_perform() failed: %s\n",
  18.               curl_easy_strerror(res));
  20.     /* always cleanup */
  21.     curl_easy_cleanup(curl);
  22.   }
  23.   return 0;
  24. }

Get a HTML page in memory

This example is a variation of the former that instead of sending the data to
stdout (which often is not what you want), this stores the received data in a
memory buffer that is made larger as the incoming data grows.

It accomplishes this by using the write callback to receive the data.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #include <curl/curl.h>
  7. struct MemoryStruct {
  8.   char *memory;
  9.   size_t size;
  10. };
  12. static size_t
  13. WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp)
  14. {
  15.   size_t realsize = size * nmemb;
  16.   struct MemoryStruct *mem = (struct MemoryStruct *)userp;
  18.   mem->memory = realloc(mem->memory, mem->size + realsize + 1);
  19.   if(mem->memory == NULL) {
  20.     /* out of memory! */
  21.     printf("not enough memory (realloc returned NULL)\n");
  22.     return 0;
  23.   }
  25.   memcpy(&(mem->memory[mem->size]), contents, realsize);
  26.   mem->size += realsize;
  27.   mem->memory[mem->size] = 0;
  29.   return realsize;
  30. }
  32. int main(void)
  33. {
  34.   CURL *curl_handle;
  35.   CURLcode res;
  37.   struct MemoryStruct chunk;
  39.   chunk.memory = malloc(1);  /* will be grown as needed by the realloc above */
  40.   chunk.size = 0;    /* no data at this point */
  42.   curl_global_init(CURL_GLOBAL_ALL);
  44.   /* init the curl session */
  45.   curl_handle = curl_easy_init();
  47.   /* specify URL to get */
  48.   curl_easy_setopt(curl_handle, CURLOPT_URL, "http://www.example.com/");
  50.   /* send all data to this function  */
  51.   curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
  53.   /* we pass our 'chunk' struct to the callback function */
  54.   curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
  56.   /* some servers don't like requests that are made without a user-agent
  57.      field, so we provide one */
  58.   curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
  60.   /* get it! */
  61.   res = curl_easy_perform(curl_handle);
  63.   /* check for errors */
  64.   if(res != CURLE_OK) {
  65.     fprintf(stderr, "curl_easy_perform() failed: %s\n",
  66.             curl_easy_strerror(res));
  67.   }
  68.   else {
  69.     /*
  70.      * Now, our chunk.memory points to a memory block that is chunk.size
  71.      * bytes big and contains the remote file.
  72.      *
  73.      * Do something nice with it!
  74.      */
  76.     printf("%lu bytes retrieved\n", (long)chunk.size);
  77.   }
  79.   /* cleanup curl stuff */
  80.   curl_easy_cleanup(curl_handle);
  82.   free(chunk.memory);
  84.   /* we're done with libcurl, so clean it up */
  85.   curl_global_cleanup();
  87.   return 0;
  88. }

Submit a login form over HTTP

TBD

Get an FTP directory listing

TBD

Download an HTTPS page straight into memory

TBD

Upload data to an HTTP site without blocking

TBD