Cet article va tenter de vous faire découvrir ces nouveautés, d’expliquer certaines décisions de design et bien entendu de vous donner envie de l’essayer !

Présentation

Il y a 2 ans, le code de freelan commençait à être volumineux. Bon nombre de classes outils étaient écrites qui pouvaient intéresser d’autres projets. Nous avons donc décidé de rendre cet ensemble de classes autonome et c’est ainsi qu’est né libsystools.

libsystools propose une interface C++ moderne pour un certain nombre de bibliothèques C mais aussi des classes nouvelles (notamment SmartBuffer).

Ses principaux domaines d’application sont :

• La gestion du xml (parsing, génération, modification, signature);
• la gestion de la cryptographie (RSA, AES, SHA);
• la gestion des certificats;
• la gestion des ports série;
• la gestion du SSL (TLS, DTLS);
• la gestion du réseau (Socket, SocketAddress, SocketAddressResolver) en IPv4 et IPv6.
• la gestion facilité de la mémoire (SmartBuffer);
• une implémentation basique d’un client UPnP;
• une implémentation basique d’un client HTTP;
• une implémentation simple d’une classe de log;
• la gestion de l’encodage (UTF-8, UTF-16, ISO-8859-1, etc.);
• différentes méthodes pour calculer de checksum, compresser des flux, etc.

libsystools a été conçue dès le départ pour être extrêmement portable, qu’il s’agisse des systèmes d’exploitation ou des architectures. Elle est donc utilisable sur Windows (MinGW, Visual Studio 2010), Linux (gcc), Mac OSX (gcc), UNIX (gcc) aussi bien en 32 bits qu’en 64 bits.

L’ensemble de ses classes est documenté et différents exemples sont fournis qui traitent de chacun de ses domaines d’application.

libsystools se base sur différentes bibliothèques :

• libxml2
• libxmlsec1
• openssl
• libiconv
• boost

Faciliter l’existant

Les bibliothèques sur lesquelles se base libsystools sont bien écrites et fiables. Cependant, elles ne fournissent qu’une interface en C.

Lorsqu’on utilise que peu ces bibliothèques dans un projet, il est acceptable de se servir simplement de ces interfaces C. Cependant, lorsqu’un projet en fait un usage intensif, le code devient très rapidement très dur à maintenir.

Qui n’a jamais eu à écrire un code de ce style ?

#include <iostream>

#include <libfoo>

int main()
{
	FOOCONTEXT ctx = CreateFooContext();

	try
	{
		FOOHANDLER handler = CreateFooHandler(ctx);

		try
		{
			// Code
		}
		catch (...)
		{
			FreeFooHandler(handler);

			throw;
		}

		FreeFooHandler(handler);
	}
	catch (...)
	{
		FreeFooContext(ctx);

		throw;
	}

	FreeFooContext(ctx);

	return EXIT_SUCCESS;
}

Bien sûr, un bon programmeur C++ simplifiera l’écriture de ce genre de code avec l’utilisation de classes conteneurs qui se chargent de libérer la ressource associée lors de leur destruction. Mais devoir refaire ce travail d’encapsulation à chaque utilisation est fastidieux, et ne règle qu’une partie du problème.

C’est dans cet esprit qu’on été développées les classes de libsystools : des wrappers simples, faciles à utiliser et efficaces.

En utilisant libsystools, le code précédent aurait plutôt ressemblé à :

#include <iostream>

#include <libfoo>

int main()
{
	FooContext ctx;
	FooHandler handler(ctx);

	// Code

	return EXIT_SUCCESS;
}

Ce qui est bien plus lisible et maintenable, et présente l’avantage d’être “exception-safe”.

Utilisation & Exemples

Nous pourrions exposer les différents aspects conceptuels qui ont motivé chaque décision pendant des heures et sur plusieurs pages, mais après tout, en programmation, il n’y a pas plus explicite que le code. Voici donc quelques exemples d’utilisation commentés.

SmartBuffer, ou comment gérer la mémoire de façon intelligente

S’il ne fallait garder qu’une seule classe, ce serait celle-ci : SmartBuffer est au coeur de libsystools. Utilisée partout, SmartBuffer représente un tableau d’octets à taille variable et dont les différentes instances peuvent partager leur mémoire.

#include <iostream>

#include <systools/smartbuffer.hpp>

int main()
{
	using systools::SmartBuffer;

	// On crée un buffer à partir d'une chaîne C
	SmartBuffer buffer("Hello you");

	// On copie un buffer
	SmartBuffer copy = buffer; // copy et buffer partagent la même mémoire.

	// On réduit copy
	copy.resize(6); // copy a juste été réduit, copy et buffer partagent toujours la même mémoire.

	copy.append("me"); // copy a été modifié, copy et buffer ne partagent plus la même mémoire.

	// On affiche les résultats
	std::cout << "buffer: " << buffer.toStdString() << std::endl; // buffer: Hello you
	std::cout << "copy: " << copy.toStdString() << std::endl; // copy: Hello me

	return EXIT_SUCCESS;
}

// On peut utiliser un SmartBuffer comme valeur de retour de fonction
systools::SmartBuffer getBuffer()
{
	// La méthode-patron "factory" SmartBuffer::from permet de créer un buffer à partir de n'importe quel type.
	return systools::SmartBuffer::from<int>(4);
}

Dans bon nombre de cas, l’utilisation de SmartBuffer permet de simplifier le code existant en remplaçant les paramètres de type :

void fonction(const char* inbuf, size_t inbuflen, char** outbuf, size_t& outbuflen);

Par un simple :

SmartBuffer fonction(const SmartBuffer& inbuf);

La lecture et la maintenance s’en trouvent tous deux grandement facilités.

XML, les wrappers autour de libxml2

Avec l’engouement de tous les domaines pour le web, il est rare aujourd’hui d’avoir du code à produire qui ne nécessite pas de manipuler du XML. En C++, plusieurs solutions existent.

Nous avons opté pour la libxml2 pour plusieurs raisons :

• C’est une bibliothèque mature, complète et quotidiennement maintenue;
• elle est portable sur plusieurs architectures et plateformes;
• elle s’interface très bien avec OpenSSL au sein de libxmlsec1 pour le support des signatures XML.

Le module XML de libsystools se décompose en trois parties :

• Les éléments DOM, qui représentent de façon statique un arbre XML;
• les “writers” qui permettent de générer du XML;
• les objets XPath, qui permettent d’effectuer des requêtes dans les éléments DOM.

Voyons un exemple d’utilisation :

#include <iostream>
#include <cstdlib>
#include <cstring>

#include <boost/shared_ptr.hpp>
#include <boost/foreach.hpp>

#include <systools/xml.hpp>
#include <systools/xml_document.hpp>
#include <systools/xml_node.hpp>
#include <systools/xml_xpath.hpp>
#include <systools/xml_buffer_writer.hpp>
#include <systools/xml_document_writer.hpp>

int main(int, char**)
{
	using namespace systools;

	// Initialization
	xml::Initializer xml;

	std::cout << "Initializing...: " << "OK" << std::endl;

	try
	{
		// Generation

		xml::XmlDocumentWriter writer;

		writer.startDocument();
		writer.startElement("configuration");
		writer.writeAttribute("xmlns", "namespace");
		writer.writeElement("key", "value");
		writer.startElement("parent");
		writer.writeElement("child", "anna");
		writer.writeElement("child", "bobby");
		writer.endElement();
		writer.endDocument();

		xml::XmlDocument document = writer.getResultAsDocument();
		std::cout << "Generating XML document: " << "OK" << std::endl;
		std::cout << document.toString().toStdString() << std::endl;

		// XPath

		xml::XPath xpath = document.xpath();

		if (!xpath.registerNamespace("fl", "namespace"))
		{
			std::cerr << "Warning ! Failed to register the namespace !" << std::endl;
		}

		std::list<xml::XmlNode> list = document.xpath().evaluate("/fl:configuration/fl:parent");

		if (list.size() > 0)
		{
			list = list.front().xpath().evaluate("fl:child");

			std::cout << "Results:" << std::endl;

			BOOST_FOREACH(const xml::XmlNode& node, list)
			{
				std::cout << node.name().toStdString() << ": " << node.content().toStdString() << std::endl;
			}
		}
	}
	catch (Exception& ex)
	{
		std::cout << "Exception caught: " << ex.toString() << std::endl;
	}

	return EXIT_SUCCESS;
}

Reprenons cet exemple point par point :

• Ligne 20 : nous déclarons un xml::Initializer qui existera pour toute la portée du main. Cet objet permet d’initialiser la libxml2 et de garantir sa libération au moment opportun, de façon automatique.
• Ligne 28 : nous créons un XmlDocumentWriter. Cet objet permet une construction facilité d’un arbre XML en construisant l’un après l’autre ses différents éléments.
• Lignes 30 à 38 : Nous créons chacun des noeuds XML. Les différentes fonctions prennent des systools::String en paramètre et supportent donc parfaitement la gestion des différents encodages.
• Ligne 40 : Nous récupérons un arbre XML complet à partir du writer.
• Ligne 46 : Nous récupérons l’instance XPath associé à l’arbre XML (cette instance est partagée par tous les noeuds d’un même arbre)
• Ligne 48 : Nous associons un nom court au namespace nommé “namespace” dans l’instance XPath.
• Ligne 53 : Nous effectuons une requête XPath sur la racine du document.
• Ligne 57 : Nous effectuons une requête XPath sur un sous-noeud du document.

La manipulation du XML est grandement facilitée. On voit que seules quelques instructions suffisent à construire un arbre, à y naviguer et à en extraire les informations utiles.

Le module réseau

Une autre partie importante de libsystools est son module réseau. La manipulation des différentes fonctions et structures réseau d’un système a toujours été la bête noire des programmeurs novices. Entre les spécificités propres à chaque système d’exploitation, et les fonctions dépréciées suite au prochain passage à IPv6 (ça approche, si si, croyez-moi !), il n’est pas toujours évident de produire un code propre et robuste.

Le module réseau de libsystools a été conçu pour résoudre cette problématique. Il propose :

• Une classe qui permet représenter une adresse de socket (IPv4, IPv6, etc.);
• une classe pour effectuer des résolutions de nom ou d’adresse sur le réseau;
• des classes Socket et SecureSocket qui encapsulent respectivement une socket classique et une socket SSL (en TLS ou DTLS);
• une classe “Select” qui encapsule de façon objet les appels à la méthode “select()”;
• une classe pour représenter les adresses Ethernet;
• des outils de conversion entre adresse IP et représentation numérique.

Démontrons la simplicité de son utilisation en montrant le code d’un example qui va successivement :

1. Chercher l’adresse de socket associée à 127.0.0.1:34000 en TCP.
2. Créer une socket
3. Connecter cette socket sur le serveur TCP situé à l’adresse recherchée en 1.
4. Attendre la réception d’un message.
5. Se déconnecter et libérer la socket et toutes les ressources associées.

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string>

#include <list>

#include <systools/network.hpp>
#include <systools/socket.hpp>
#include <systools/socket_address.hpp>
#include <systools/socket_address_resolver.hpp>

int main(int, char**)
{
	using namespace systools;

	network::Initializer network;

	SocketAddressResolver sar;

	try
	{
		sar.getAddrInfo("127.0.0.1", "34000", IPPROTO_TCP, AF_UNSPEC);

		if (sar.size() <= 0)
		{
			std::cout << "No address information was returned." << std::endl;
		} else
		{
			// Usually, one could choose to iterate trough the results and to keep only the first one to which a connection can be established.
			Socket socket(sar.front());
			SocketAddress address(sar.front());

			std::cout << "Connecting to: " << address.toNumericString() << std::endl;

			socket.connect(address);

			SmartBuffer message;

			size_t recv_bytes = socket.recv(message);

			if (recv_bytes > 0)
			{
				std::cout << "Receiving message: " << std::string(message.constData(), message.size()) << std::endl;
			}
		}
	}
	catch (Exception& ex)
	{
		std::cout << "Exception: " << ex.toString() << std::endl;

		return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
}

Pas si mal pour un code d’une cinquantaine de lignes qui gère correctement toutes les erreurs potentielles et la libération des ressources, non ?

Pour conclure

Vous n’avez eu ici qu’un très bref aperçu des possibilités offertes par la libsystools. Pour découvrir plus avant la bibliothèque, je vous invite à consulter sa documentation en ligne.

En tout cas, j’espère sincèrement que cette présentation aura attisé votre curiosité et vous aura donné envie d’essayer la bibliothèque lors de vos prochains développements. Bien entendu, si vous avez des questions générales sur la bibliothèque et des interrogations concernant son évolution future, n’hésitez pas à commenter cet article ou directement contacter l’équipe sur la mailing-list (en anglais).

Bon code !