[C++] LibSimpleWeb, des requetes HTTP simples

[Dobry]

Dans ce semi tutoriel, qui me permettra par la même occasion de vous présenter une librairie très simple que j'ai codé pour faire des requetes web en C++, nous verrons comment créer une bibliothèque partagée (shared library).
Je suis sur Gnu/Linux et je ne developperais que cette aspect car c'est le seul que je connaisse.
Déjà, qu'est ce qu'une "Shared Library" ?
- Ce sont des bibliothèque qui sont chargés par le programme lors de son lancement, en d'autres termes, un programme nécéssitant une bibliothèque de ce type ne pourra fonctionner que si elle est installée sur le système.
- Ainsi ces bibliothèques sont idépendantes du programme, ce qui rend l'éxécutable plus léger (contrairement à une compilation statique par exemple).

Comment on crée une "Shared Library" ?
Nous verrons d'abord comment faire en utilisant g++ pour compiler une bibliothèque codée en C++, puis nous verrons comment faire pour en compiler une en C avec gcc (en réalité les commandes sont EXACTEMENT les mêmes).

La particularité lorsque l'on commence à coder une bibliothèque pour le système c'est qu'il n'y a pas de fonction main() mais uniquement des fonctions qui seront ensuite appellées, il va donc nous falloir deux fichiers, que nous
appellerons "simpleweb.h" et "simpleweb.cpp", un qui est le header et l'autre la source.

Attaquons nous d'abord au header (.h)
Les lignes suivante nous permettrons

Code CPP :

#ifndef SIMPLEWEB_H
#define SIMPLEWEB_H
 /* fonctions de la bibliothèque ici */
#endif
 

Nous allons maintenant nous attaquer au prototypes des fonctions de notre bibliothèque, voici celles que je vais vous présenter :

Code CPP :

 
  size_t download(char *ptr, size_t size, size_t nmemb, std:tring *stream); // Fonction de callback pour libCurl
  int urlRetrieve(std:tring url, std:tring path); // Télécharge un fichier distant
  std:tring read(std:tring url); // Retourne le code source d'une page web
  std:tring sendPost(std::map<std:tring,std:tring>& data, std:tring url); // Envoi des données en POST à une page et retourne la source de la page

Mais pour pouvoir utiliser les différents types de données et prototypes suivants, nous devons également déclarer les lib que l'on doit inclure :

Code CPP :


  #define CURL_STATICLIB
  #include <iostream>
  #include <fstream>
  #include <string>
  #include <curl/curl.h>
  #include <curl/types.h>
  #include <curl/easy.h>
  #include <map>

Ce qui nous donne au final pour simpleweb.h

#ifndef SIMPLEWEB_H
#define SIMPLEWEB_H
  #define CURL_STATICLIB
  #include <iostream>
  #include <fstream>
  #include <string>
  #include <curl/curl.h>
  #include <curl/types.h>
  #include <curl/easy.h>
  #include <map>
  size_t download(char *ptr, size_t size, size_t nmemb, std:tring *stream);
  int urlRetrieve(std:tring url, std:tring path);
  std:tring read(std:tring url);
  std:tring sendPost(std::map<std:tring,std:tring>& data, std:tring url);
#endif
 

Attaquons nous maintenant au contenu de ces fonctions dans simpleweb.c, dans lequel nous avons besoin d'uniquement un include qui est :
#include "simpleweb.h", car les autres sont définis dans simpleweb.h

Voici ensuite le contenu des fonctions (utilisant libCurl), j'ai essayé de commenter au maximum mais si des éléments vous échappent n'hésitez pas à me demander des explications :

Code CPP :


size_t download(char *ptr, size_t size, size_t nmemb, std:tring *stream) { // Fonction Callback appellée par CURLOPT_WRITEFUNCTION
  if(stream != NULL){ // Si le pointeur est  correct,
   stream->append(ptr, size*nmemb); // On ajoute les données recu au string
   return size*nmemb; // On retourne la taille des données
  }
  return 0;
}

int urlRetrieve(std:tring url, std:tring path){ // Télécharge un fichier distant
  std::ofstream file(path.c_str(), std::ios::in | std::ios::trunc); // Fichier crée
  CURL *curl;
  std:tring reponse="";
  curl = curl_easy_init();
 
  if(curl){
   
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str()); // On défini la destination de la requete
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, download); // On appelle la fonction de callback
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &reponse); // On écrit le résultat (le contenu du download) dans le std:tring reponse.
    curl_easy_perform(curl); // On lance la requete
    curl_easy_cleanup(curl);
    file << reponse; // On ecrit dans le fichier
   
    return 1;
  }else
    return 0;
}

std:tring read(std:tring url){ // Retourne la source de l'url
  std:tring source("");
  CURL *curl;
  curl = curl_easy_init();
 
  if(curl){
   
    curl_easy_setopt(curl, CURLOPT_URL, url.c_str()); // Même commentaire qu'avant, on défini la source
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, download); // Fonction de callback
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &source); // On stocke le résultat
    curl_easy_perform(curl); // on lance la requete
    curl_easy_cleanup(curl);
  }
  return source; // On retourne la source
}

std:tring sendPost(std::map<std:tring,std:tring>& data, std:tring url){ // Envoi des champs $_POST à une page et retourne la réponse de la page
    std:tring post = "", source="";
    CURL *curl;
    while(!data.empty()){ // On parcour la map (tableau associatif de la STL)
      post+=data.begin()->first; // On récupère le nom de la clé
      post+="=";
      post+=data.begin()->second; // et sa valeur
      post+="&";
      data.erase(data.begin()); // On supprime au fur et à mesure les valeurs de la map
    }
   
    curl = curl_easy_init();
    if(curl) {
      curl_easy_setopt(curl, CURLOPT_URL, url.c_str()); // On défini l'url destination
      curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post.c_str()); // Les paramètres à envoyer en POST
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, download); // Fonction de callback
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, &source); // Stockage du résultat (réponse de la page)
      curl_easy_perform(curl);
      curl_easy_cleanup(curl);
    }  
 
  return source; // On retourne le contenu
}
 

Voici pour les fonctions qui se trouvent dans notre simpleweb.c, il va falloir maintenant nous attaquer à la compilation de la bibliothèque à l'aide de g++
g++ -fpic -c simpleweb.c
On obtient maintenant un simpleweb.o
g++ -shared -o libsimpleweb.so simpleweb.o
Le nom du fichier de la shared library doit être sous la forme lib*.so
Maintenant, nous allons proceder de façon un peu brutal mais efficace pour installer notre bilbiothèque sur le système,
cp libsimpleweb.so /usr/local/lib
cp libsimpleweb.so /usr/lib
Et puis pour le header
cp simpleweb.h /usr/local/include
cp simpleweb.h /usr/include

Voilà normalement cela devrait fonctionner, nous allons maintenant essayer un programme test pour voir si la bibliothèque fonctionne réellement :

Code CPP :


#include <simpleweb.h>

int main(){
  urlRetrieve("http://hwc-crew.com/images/logo.png","/home/user/Desktop/hwclogo.png"); // Changez le lien de sauvegarde du fichier
}
 

Pour compiler, on utilise :
g++ testweb.cpp -o test -lsimpleweb -lcurl

Ma bibliothèque nécéssite libCurl je dois donc également fournir ce flag pour la compilation, et sinon, le flag est le nom de votre bibliothèque sans le "lib" devant et le ".so".


Si quelque chose est peu clair ou faux, n'hésitez pas à me contacter pour que je le corrige.