Consommer des API en C : un guide pratique pour les développeurs modernes

Aujourd'hui, consommer des API web est une pratique courante pour échanger des données entre applications. Les didacticiels sur l'utilisation des API dans des langages comme JavaScript, Python ou PHP sont nombreux, mais le C, souvent associé à la programmation au niveau système, est rarement envisagé à cette fin. Cependant, le C est parfaitement capable de gérer les requêtes API, ce qui en fait un choix viable pour des scénarios tels que les systèmes de point de vente (PoS), les appareils IoT ou les applications embarquées, où le C est déjà utilisé pour son efficacité et son contrôle de bas niveau.

Cet article explore comment consommer des API en C, en tirant parti de la bibliothèque libcurl. À la fin, vous comprendrez comment récupérer et traiter des données à partir d'API à l'aide de C, et pourquoi cette approche est pertinente même dans le développement moderne.

Pourquoi utiliser C pour consommer des API ?

Bien que les langages de niveau supérieur dominent le développement Web, le C reste un choix pratique pour utiliser des API dans des cas d'utilisation spécifiques :

• Performances : C offre des performances élevées et une surcharge minimale, ce qui le rend adapté aux environnements aux ressources limitées comme les appareils IoT.
• Contrôle : la gestion directe de la mémoire permet une optimisation fine, notamment pour les systèmes embarqués.
• Interopérabilité : l'utilisation généralisée du C signifie qu'il s'intègre bien aux opérations au niveau du système, telles que le contrôle du matériel, des capteurs ou d'autres périphériques.
• Longévité : les applications construites en C ont souvent une longue durée de vie, en particulier dans des secteurs comme la vente au détail ou la fabrication.

Présentation de libcurl : l'outil pour HTTP en C

Pour consommer des API en C, libcurl est la bibliothèque incontournable. Il s'agit d'une bibliothèque open source, portable et riche en fonctionnalités permettant de gérer les requêtes réseau via HTTP, HTTPS, FTP, etc. Il prend en charge :

• Faire des requêtes GET, POST et autres requêtes HTTP.
• Gestion des en-têtes et de l'authentification.
• Traitement efficace des réponses.

Étapes de base pour consommer une API en C

Parcourons le processus de consommation d'une API à l'aide de C, en nous concentrant sur un exemple concret de récupération de données JSON.

Configuration et installation

Pour utiliser libcurl, vous devez l'installer sur votre système. Pour la plupart des distributions Linux, cela peut être fait avec :

sudo apt-get install libcurl4-openssl-dev

Sous Windows, vous pouvez télécharger des binaires précompilés depuis le site Web de libcurl : https://curl.se/download.html

Sur macOS si vous utilisez Homebrew vous pouvez l'installer via

brew install curl

Structurer votre programme C

Un programme C simple pour récupérer des données à partir d'une API implique les composants suivants :

• Initialisation de libcurl.
• Configuration de la requête API (URL, méthode HTTP, en-têtes, etc.).
• Réception et stockage de la réponse.
• Nettoyer les ressources.

Voici un exemple de programme pour récupérer des données JSON à partir d'une API publique :

sudo apt-get install libcurl4-openssl-dev

Étapes à suivre

Enregistrez le code dans un fichier, par exemple get.c.
Compilez-le avec la commande suivante :

brew install curl

Exécutez le programme compilé :

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

// Struct to hold response data
struct Memory {
    char *response;
    size_t size;
};

// Callback function to handle the data received from the API
static size_t ResponseCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t totalSize = size * nmemb;
    struct Memory *mem = (struct Memory *)userp;

    printf(". %zu %zu\n", size, nmemb);
    char *ptr = realloc(mem->response, mem->size + totalSize + 1);
    if (ptr == NULL) {
        printf("Not enough memory to allocate buffer.\n");
        return 0;
    }

    mem->response = ptr;
    memcpy(&(mem->response[mem->size]), contents, totalSize);
    mem->size += totalSize;
    mem->response[mem->size] = '<pre class="brush:php;toolbar:false">gcc get.c -o get -lcurl

'; return totalSize; } int main() { CURL *curl; CURLcode res; struct Memory chunk; chunk.response = malloc(1); // Initialize memory chunk.size = 0; // No data yet curl_global_init(CURL_GLOBAL_DEFAULT); curl = curl_easy_init(); if (curl) { // Set URL of the API endpoint char access_token[] = "your-access-token"; char slug[] = "home"; char version[]= "draft"; char url[256]; snprintf(url, sizeof(url), "https://api.storyblok.com/v2/cdn/stories/%s?version=%s&token=%s", slug, version, access_token); // Print the URL printf("URL: %s\n", url); // initializing libcurl // setting the URL curl_easy_setopt(curl, CURLOPT_URL, url ); // Follow redirect curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // Set callback function to handle response data curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ResponseCallback); // Pass the Memory struct to the callback function curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk); // Perform the HTTP GET request res = curl_easy_perform(curl); // Check for errors if (res != CURLE_OK) { fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res)); } else { printf("Response data size: %zu\n", chunk.size); //printf("Response data: \n%s\n", chunk.response); } // Cleanup curl_easy_cleanup(curl); } // Free allocated memory free(chunk.response); curl_global_cleanup(); return 0; }

Comprendre le mécanisme de rappel dans les réponses HTTP avec libcurl

Lorsque vous travaillez avec libcurl pour gérer les réponses HTTP en C, il est important de comprendre le comportement de la fonction de rappel. La fonction de rappel que vous définissez pour traiter les données de réponse, telle que la fonction ResponseCallback, peut être invoquée plusieurs fois pour une seule réponse HTTP. Voici pourquoi et comment cela fonctionne.

Pourquoi le rappel est-il invoqué plusieurs fois ?

Le mécanisme de rappel de libcurl est conçu pour gérer les données de manière efficace et flexible. Au lieu d'attendre que la réponse entière soit téléchargée avant de la traiter, libcurl traite la réponse en morceaux plus petits, appelant votre fonction de rappel à mesure que chaque morceau est reçu.

Ce comportement permet :

• Utilisation efficace de la mémoire : en traitant les morceaux de manière incrémentielle, vous évitez d'avoir à allouer un gros bloc de mémoire à l'avance pour l'intégralité de la réponse.
• Traitement en streaming : vous pouvez traiter ou agir sur chaque morceau au fur et à mesure qu'il arrive, ce qui est utile pour diffuser des réponses volumineuses ou gérer des données en temps réel.

Comment ça marche ?
Chaque fois qu'un morceau de données est reçu du serveur, libcurl appelle votre fonction de rappel. La taille de chaque morceau dépend des conditions du réseau, de la taille des tampons et de la logique interne de libcurl.
Le rappel doit accumuler les morceaux, pour finalement reconstruire la réponse complète.

Voici un exemple de séquence :

1. Le serveur commence à envoyer la réponse.
2. libcurl reçoit le premier morceau et appelle le rappel.
3. Le rappel traite ou stocke le morceau.
4. libcurl reçoit le morceau suivant et rappelle à nouveau le rappel.
5. Ce processus se poursuit jusqu'à ce que la réponse complète soit reçue.

Explication étape par étape du code source pour la fonction ResponseCallback

Le ResponseCallback est la fonction appelée lorsque les données sont reçues par libcurl.

Déclaration de fonction

sudo apt-get install libcurl4-openssl-dev

• void *contents : il s'agit d'un pointeur vers les données reçues du serveur. libcurl fournit ce tampon et le remplit avec les données qu'il télécharge.
• size_t size et size_t nmemb : Ceux-ci représentent la taille de chaque bloc mémoire (size) et le nombre de blocs (nmemb). Ensemble, size * nmemb donne la taille totale des données reçues dans ce morceau.
• void *userp : il s'agit d'un pointeur défini par l'utilisateur passé à la fonction de rappel via curl_easy_setopt(curl, CURLOPT_WRITEDATA, ...). Dans cet exemple, il s'agit d'un pointeur vers un objet struct Memory, qui stocke la réponse complète.

Calculer la taille totale des données

brew install curl

Ceci calcule la taille totale du bloc de données actuel reçu en multipliant la taille d'un bloc (size) par le nombre de blocs (nmemb).
Par exemple, si le serveur envoie 8 blocs de 256 octets chacun, totalSize sera de 8 * 256 = 2048 octets.

Accéder aux données utilisateur (struct Memory)

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

// Struct to hold response data
struct Memory {
    char *response;
    size_t size;
};

// Callback function to handle the data received from the API
static size_t ResponseCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t totalSize = size * nmemb;
    struct Memory *mem = (struct Memory *)userp;

    printf(". %zu %zu\n", size, nmemb);
    char *ptr = realloc(mem->response, mem->size + totalSize + 1);
    if (ptr == NULL) {
        printf("Not enough memory to allocate buffer.\n");
        return 0;
    }

    mem->response = ptr;
    memcpy(&(mem->response[mem->size]), contents, totalSize);
    mem->size += totalSize;
    mem->response[mem->size] = '<pre class="brush:php;toolbar:false">gcc get.c -o get -lcurl

'; return totalSize; } int main() { CURL *curl; CURLcode res; struct Memory chunk; chunk.response = malloc(1); // Initialize memory chunk.size = 0; // No data yet curl_global_init(CURL_GLOBAL_DEFAULT); curl = curl_easy_init(); if (curl) { // Set URL of the API endpoint char access_token[] = "your-access-token"; char slug[] = "home"; char version[]= "draft"; char url[256]; snprintf(url, sizeof(url), "https://api.storyblok.com/v2/cdn/stories/%s?version=%s&token=%s", slug, version, access_token); // Print the URL printf("URL: %s\n", url); // initializing libcurl // setting the URL curl_easy_setopt(curl, CURLOPT_URL, url ); // Follow redirect curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // Set callback function to handle response data curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ResponseCallback); // Pass the Memory struct to the callback function curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk); // Perform the HTTP GET request res = curl_easy_perform(curl); // Check for errors if (res != CURLE_OK) { fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res)); } else { printf("Response data size: %zu\n", chunk.size); //printf("Response data: \n%s\n", chunk.response); } // Cleanup curl_easy_cleanup(curl); } // Free allocated memory free(chunk.response); curl_global_cleanup(); return 0; }

Le pointeur userp est converti en une struct Memory *. Cette structure a été transmise plus tôt dans le programme principal et est utilisée pour accumuler les données reçues.

La struct Memory est définie comme :

./get

• réponse : une chaîne allouée dynamiquement qui stocke les données téléchargées.
• size : la taille actuelle de la chaîne de réponse.

Réaffecter la mémoire

static size_t ResponseCallback(void *contents, size_t size, size_t nmemb, void *userp)

Redimensionne le tampon de réponse pour s'adapter au nouveau bloc de données :

• mem->size : la taille actuelle du tampon.
• totalSize : La taille du nouveau morceau.
• 1 : Espace pour le terminateur nul ( ) pour en faire une chaîne C valide.
• realloc : réalloue dynamiquement la mémoire pour le tampon de réponse.

Si l'allocation échoue, la réallocation renvoie NULL et l'ancienne mémoire reste valide.

Gérer les erreurs d'allocation de mémoire

size_t totalSize = size * nmemb;

Si l'allocation de mémoire échoue (donc ptr est NULL), imprimez un message d'erreur et renvoyez 0. Le retour de 0 signale à libcurl d'abandonner le transfert.

Mettre à jour le tampon

struct Memory *mem = (struct Memory *)userp;

• mem->response = ptr : réattribue la mémoire nouvellement allouée au pointeur de réponse.
• memcpy : copiez le nouveau morceau de données du contenu dans le tampon :
  • &(mem->response[mem->size]) : L'emplacement dans le tampon où les nouvelles données doivent être ajoutées (fin des données actuelles).
  • contenu : Les données reçues du serveur.
  • totalSize : La taille des données à copier.

Mettre à jour la taille totale

struct Memory {
    char *response;
    size_t size;
};

Incrémentez la taille du tampon de réponse pour refléter la nouvelle taille totale après avoir ajouté le nouveau morceau.

Null-Terminer la chaîne de réponse

sudo apt-get install libcurl4-openssl-dev

Ajoutez un terminateur nul à la fin du tampon de réponse pour en faire une chaîne C valide.
Cela garantit que la réponse peut être traitée en toute sécurité comme une chaîne normale terminée par un caractère nul.

Renvoie la taille totale

brew install curl

Renvoie le nombre d'octets traités (totalSize).
Cela signale à libcurl que le bloc de données a été géré avec succès.

Quand choisir C pour les API

Utilisez C pour consommer des API lorsque :

• Les performances comptent : C est idéal pour les applications critiques en termes de vitesse.
• Intégration du système : vous devez combiner les requêtes réseau avec des opérations matérielles (par exemple, récupérer des données pour un système PoS).
• Systèmes embarqués : les appareils aux ressources limitées bénéficient de l'efficacité du C.
• Curiosité et exploration : Parfois, vous utilisez C simplement parce que vous aimez programmer et que vous souhaitez vous mettre au défi en explorant un langage de niveau inférieur pour des tâches souvent réservées à celles de niveau supérieur. C’est un excellent moyen d’approfondir votre compréhension du fonctionnement des choses sous le capot !

Conclusion

Consommer des API en C peut sembler non conventionnel dans le monde de la programmation de haut niveau d'aujourd'hui, mais il s'agit d'un outil puissant pour les scénarios nécessitant des performances, un contrôle et une intégration avec les opérations au niveau du système. En utilisant des bibliothèques comme libcurl, les développeurs peuvent facilement intégrer des requêtes HTTP dans des applications C, comblant ainsi le fossé entre les API modernes et la programmation traditionnelle au niveau du système.

Grâce à ces connaissances, vous pouvez créer des applications C qui interagissent de manière transparente avec les API, prouvant que le C reste pertinent même dans les workflows de développement modernes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!