Je suis tombé hier sur le post suivant :

http://www.phoboslab.org/log/2010/05/9-years-of-sleep

J'ai trouvé l'idée surpuissante, malheureusement, d'une part il n'a pas rendu public son code, et d'autre part, de toute façon, il opère sur des logs mIRC, moi même utilisant irssi.

C'est pourquoi je me suis mis en tête de réaliser un programme ayant pour but de générer un graph similaire, à partir de mes sept ans de logs.
Et ça donne ça :

Mon irssi étant lancé en permanence, plutôt que de regarder les ouvertures/fermetures de session, je tente de deviner les moments où je suis actif sur IRC (donc où j'écris), avec un idle time de deux heures.

Ayant plus de 500Mo de logs, j'ai écris le programme en C, avec la possibilité de lancer des jobs simultanément, ce qui au final s'est révélé peut-être overkill, puisque sur ma machine cela s'exécute en moins de dix secondes.

Ne trouvant rien de satisfaisant pour faire des graphes comme celui-ci, je dessine moi-même l'image avec Imlib2 (qui a une documentation et une API bien moisie, au passage).

Ainsi, contrairement à mon con mais néanmoins frère cité au début, je mets à disposition les sources, que vous pourrez trouver sur le dépôt git :

$ git clone git://git.symlink.me/pub/romain/irssleep.git

Lire README pour savoir comment compiler et exécuter.

À titre d'information, pour ma part je lance la commande suivante :

$ ./irssleep -j 5\
             -n romain\
             -e 1/5/2003,1/8/2006,School\
             -e 1/2/2005,Black-hole\
             -e "10/12/2006,Irssi at home"\
             -e 1/10/2006,31/6/2008,Bordeaux\
             -e 10/7/2008/,27/08/2009,INL\
             -e 15/12/2008,Katin\
             -e 1/12/2009,1/1/2011,Proformatique\
             irclogs/**/*

Le web, c'est le mal. Et pourtant, on est contraint de vivre avec lui au quotidien, puisqu'il semble que le Cloud Computing est la voie de l'avenir.

Mes amis, allons nous rester les bras ballants, à devoir supporter l'utilisation de navigateurs tous plus lourds les uns que les autres, ne s'intégrant pas dans notre environnement de bureau ? Mais pire encore, qui nous font perdre notre liberté. La liberté de choisir les applications que l'on souhaite, le traitement de nos données par des logiciels tiers, la liberté de bénéficier de l'ergonomie qui nous arrange ?

Heureusement, ces contraintes sont peut-être bientôt révolues. Je tiens en effet à vous présenter weboob.

Projet complémentaire à Minbif, qui permet d'utiliser son client IRC favori pour accéder aux réseaux de messagerie instantanée, qui sort ce lundi 5 avril en version 1.0.2, et au sujet duquel une conférence se déroulera aux RMLL 2010, weboob (WEB Out Of Browsers) se veut un espoir pour tous les révoltés qui ne supportent plus d'être à la merci des ”webmaster”.

Weboob est un projet qui a pour but de réunir un nombre important de modules maintenus pour divers sites web, offrant une interface logique avec eux. Chaque module implémente des capabilities, décrivant les services offerts.

À partir de là, des applications utilisateurs sont réalisées, reposant sur des modules implémentant telle ou telle capability, et permettant une interaction riche avec les sites web.

La particularité est que la couche d'abstraction offerte par weboob permet aux applications de ne pas se soucier des modules qui sont chargés. L'utilisateur rempli une première fois une configuration en sélectionnant les sites web qu'il souhaite voir utilisé, et avec quelle configuration. Puis après, quelque soit l'application utilisée, il n'aura plus à se soucier des sites qui sont derrière les opérations qu'il effectue.

Afin de mieux montrer le potentiel de weboob, voici quelques cas d'utilisation concrets :

Monboob

Cette application est en fait un démon. Il se repose sur les modules qui implémentent les capabilities ICapMessages et dérivés. Pour le moment seul le module DLFP (linuxfr.org) est implémenté, mais pourront voir le jour non seulement des modules pour Slashdot, Reddit, ou autres sites de news, mais également des moteurs de forum.

L'idée est d'une part d'envoyer par mail non seulement les articles, mais aussi les commentaires associés. Et d'autre part, lorsqu'on répond à ce mail avec son client préféré, de poster cette réponse.

Voici ce que ça donne :

Increase de sa productivity : maximum.

travel

Cette application en console utilise les modules implémentant ICapTravel et dérivés. Les sites supportés pour le moment sont CanalTP (pour les horaires de TGV/Corail/TER), et transilien.fr (pour les horaires de transilien, RER, bus, sur Paris).

On peut faire une recherche sur les gares :

$ travel stations defense
.--------------------------------.---------------------------------------------.
| ID                             | Name                                        |
+--------------------------------+---------------------------------------------+
| LDU                            | LA DEFENSE GARE SNCF                        |
| GAW                            | LA DEFENSE RER A                            |
| OCE87382218                    | gare de La Défense (92800)                  |
+--------------------------------'---------------------------------------------+
|   3 stations listed                                                          |
'------------------------------------------------------------------------------'

Et à partir de là, récupérer les horaires d'une gare donnée :

$ travel departures GAW
.-----.-----------.-------.-----------------------.-------.--------------------.
| ID  | Type      | Time  | Arrival               | Late  | Info               |
+-----+-----------+-------+-----------------------+-------+--------------------+
|   0 | QTIE      | 09:30 | MARNE LA VALLEE CHESSY|       | Voie 1             |
|   1 | UBOS      | 09:32 | CERGY LE HAUT         |       | Voie 2             |
|   2 | OKEY      | 09:33 | TORCY MARNE LA VALLEE |       | Voie 1             |
|   3 | TEDY      | 09:37 | POISSY                |       | Voie 2             |
|   4 | QTIE      | 09:40 | MARNE LA VALLEE CHESSY|       | Voie 1             |
|   5 | UBOS      | 09:41 | CERGY LE HAUT         |       | Voie 2             |
+-----'-----------'-------'-----------------------'-------'--------------------+
|   6 departures listed                                                        |
'------------------------------------------------------------------------------'

On peut constater que l'intégration entre les deux backends est faite de façon plus ou moins transparente. En effet, ainsi que l'on voit dans la liste des gares, les identifiants courts sont issus de transilien.fr, et les identifiants longs de CanalTP. Ainsi, pour récupérer les horaires de TGV, on préfèrera utiliser un ID long. Une amélioration au niveau de la présentation est à faire.

Il est à noter qu'un frontend similaire graphique est en préparation pour Nokia N900.

Un autre aspect de cette application serait de permettre la réservation de billets de TGV en ligne, en se reposant sur le site web dont la notoriété n'est malheureusement plus à faire, voyage-sncf.

boobank

Application toujours en console, changeant les modules implémentant la capability ICapBank, et permet de récupérer des informations de site bancaire. L'avantage de weboob est que si vous possédez des comptes dans plusieurs banques, vous pourrez afficher vos comptes de manière unifiée.

Pour le moment, seul le module bnporc, issus du projet éponyme que j'avais implémenté il y a un an de cela, est implémenté.

On peut ainsi récupérer la liste de ses comptes :

$ boobank list
               ID   Account                    Balance        Coming
+-----------------+---------------------+--------------+-------------+
  1255000XXXXXXXX   Compte de chèques          -314.13      -1110.36
  1255000XXXXXXXX   Livret Jeune                 74.17          0.00

Et également obtenir un détail des opérations à venir :

$ boobank coming 1255000XXXXXXXX
      Date   Label                                                     Amount
+----------+----------------------------------------------------+-------------+
  20100503   FACTURE CARTE DU 310310 SNC HAUDRECHY 92 PUTEA        -28.70
  20100503   FACTURE CARTE DU 310310 LA DIVA 92 PUTEAUX CAR        -30.50
  20100503   FACTURE CARTE DU 310310 TAVERNE OLYMPIA 75 PAR        -26.80
  20100503   FACTURE CARTE DU 260310 SNC HAUDRECHY 92 PUTEA        -27.50

On peut imaginer réaliser des graphes à partir de ces données, les stocker au fur et à mesure pour voir l'évolution des comptes, et même pourquoi pas imaginer un démon qui mettrait à jour régulièrement et enverrait des alertes en cas de mouvements inhabituels.

Conclusion

On se rend compte que la séparation entre les backends (les modules accédant aux sites web) et les frontends (les applications faisant appel à ces modules par l'intermédiaire de weboob), et la couche d'abstraction que représente weboob entre les deux, permet de concentrer les efforts, d'une part sur la simple boobisation des sites web, de par les outils que fournis weboob, et d'autre part sur le traitement de ces données. Ainsi, un même set de backends peut être utilisé par des applications différentes, graphiques ou non.

Il n'y a pour l'instant que quelques modules, et des applications certes fonctionnelles mais assez pauvres en traitement des données. Mais il y a là une formidable opportunité d'améliorer considérablement cela et de permettre de retirer de plus en plus le web pour les besoins quotidiens.

Minbif est déjà une passerelle IRC vers réseaux de messageries instantanées stable et largement utilisable.

Néanmoins, afin de mieux satisfaire les attentes des utilisateurs, une réunion Roadmap 2010 va être organisée, afin de parler des objectifs de cette nouvelle année, les futures fonctionnalités que vous souhaiteriez voir dans Minbif, comment innover, mais aussi comment gagner en popularité, quel type de marketing on pourrait faire autour de Minbif, etc.

Minbif vivant grâce à sa communauté, tout le monde peut se joindre à nous pour cet évènement :

Où:    #minbif-roadmap sur Freenode.
Quand: on Thursday 4th March 2010
De:    21:00 CET
À:     23:00 CET
De:    01:00 CET
À:     03:00 CET

Vous pourrez nous aider à rendre Minbif meilleur !

La communication est une nécessité dans notre société moderne, dont personne ne peut se passer, sous peine de se voir coupé du monde et d'être réduit à l'état d'ermite. La webcam joue un rôle important dans ce besoin d'échanges par Internet, permettant d'atteindre les interactions les plus folles.

Mais qu'en est-il pour le geek qui reste cantonné à son bon vieux terminal, se restreignant à IRC, ou tout au plus profitant d'outils dépassés tels que BitlBee pour accéder aux messageries instantanées, sans avoir même la possibilité d'échanger de fichiers, contraint de se passer de toute autre forme d'échanges que celui du texte ? N'a-t-il pas le droit lui aussi de bénéficier des cam hots après avoir récupéré une proie facile et dépravée sur messagerie instantanée depuis le site de rencontre Adopte un mec ?

Heureusement pour lui, les laboratoires Symlink Me apportent la solution !

MinBif, cette passerelle IRC libre vers plus d'une quinzaine de réseaux de messageries instantanées, déjà évoquée ici, et qui est parue la semaine dernière en version 1.0beta, propose maintenant, outre le support des transferts de fichiers dans les deux sens, la CACAcam.

Cette fonctionnalité permet de réceptionner, sur les réseaux de messageries instantanées supportés*, le flux de la webcam de son correspondant, et de l'afficher en ASCII Art dans son client IRC favori.

Comment cela marche-t-il ? Une fois accepté la proposition de session webcam, vous vous verrez proposé par le serveur un DCC CHAT. Celui-ci établi, vous recevrez les frames dans la fenêtre correspondante. Associé à un plugin irssi, vous verrez, dans la fenêtre de discussion de votre contact, une zone sur le coin supérieur droit contenant l'affichage de la vidéo.

Un exemple parlant davantage, voici, cachée derrière cette capture d'écran, une vidéo montrant le système en œuvre :

Vidéo sous format OGV

MinBif 1.0beta2 devrait paraître très rapidement afin de proposer cette évolution majeure. Retrouvez ici les informations complémentaires sur la CACAcam.

* Dans la limite des réseaux de messageries instantanées dont libpurple supporte le flux vidéo.

Transferts de fichiers

Fonctionnalité tant attendue des grands mais aussi des petits, c'est le transfert de fichiers.

Absente de BitlBee, réclamée de tous, primordiale dans les rapports sociaux sur messagerie instantanée, MinBif l'a faite !

Le fonctionnement est simple. En réception, lorsque vous acceptez de réceptionner le fichier, le téléchargement débute entre IM->MinBif en background. Dans le même temps, MinBif vous propose un DCC, et le transfert MinBif->IRC User se fait en parallèle.

Pour l'envoie, ce serait pareil, sauf que ce serait exactement le contraire. L'utilisateur enverrait le fichier par DCC à MinBif, qui lui lancerait le transfert vers IM.

Pour le moment, seule la partie réception est implémentée, et la partie d'envoi devrait être faite sous peu.

Webcam

Aujourd'hui est parue libpurple 2.6. Dans le ChangeLog apparaît un point vraiment très intéressant :

libpurple support maintenant la voix et la vidéo !

C'est une très bonne nouvelle pour MinBif, car ce sera l'occasion d'implémenter la CACAcam.

Une autre idée plus user friendly et usefull m'est venue ce matin, ce serait d'ouvrir un flux DCC CHAT entre MinBif et l'utilisateur, dans lequel on ferait transiter les frames de la vidéo, et d'avoir un script irssi qui l'affiche dans une fenêtre. Et si irssi est lancé sur un serveur, encore rajouter une couche pour que les données arrivent jusqu'à votre machine :)

Ça, j'aime ! Le commit de Matthew Barnes, un employé Redhat, sur Evolution, m'a bien fait rire :

2009-04-12  Matthew Barnes  <mbarnes@redhat.com>

       ** Remove a bunch of juvenile comments.  Source code should
          look professional, even if some developers are not.

La première chose que je constate, c'est que je ne suis pas le seul à avoir du mal avec la glib, lorsque l'on voit des structures comme _glib_sux_donkeys, et des fonctions comme g_lib_sux_htor, g_lib_sux_htand, ou des commentaires qui veulent tout dire comme /* fucking glib... */. Je dois avouer que la fonction courier_imap_is_a_piece_of_shit est assez sympa aussi, tout comme ce commentaire qui finalement veut tout dire :

/* FIXME: please god, when will the hurting stop? Thus function is so
   fucking broken it's not even funny. */

Je préfère donc avoir recours à un MUA sérieux dont les développeurs ont davantage de respect pour le code que pour leurs utilisateurs :

rom1@nasiguv ~/mutt-1.5.17 $ grep -i fuck *
rom1@nasiguv ~/mutt-1.5.17 $ grep -i shit *
rom1@nasiguv ~/mutt-1.5.17 $ grep -i crap * -A 1
init.c:/* initial string that starts completion. No telling how much crap
init.c- * the user has typed so far. Allocate LONG_STRING just to be sure! */
rom1@nasiguv ~/mutt-1.5.17 $

Ceux qui maintenant savent comment sortir son python pour draguer seront peut-être intéressé d'apprendre que j'ai réitéré l'expérience avec le site de la BNP Paribas.

En effet, las d'avoir à passer par Firefox pour aller sur un site lent et mal codé afin de savoir si je peux encore me permettre de sortir me bourrer la gueule, j'ai repris l'idée que j'avais eu pour AuM, et ai profité de mon arrêt maladie d'aujourd'hui pour écrire un petit programme dont le but est d'avoir une commande à lancer pour récupérer dans son terminal l'état de ses comptes :

$ ./bnporc.py -l 30141xxxxx list
Password:
  Compte                       Solde       À venir
+---------------------+--------------+-------------+
  Compte de chèques         xxx65.12       -160.18
  Livret Jeune              xxx71.86          0.00
  Prêt personnel            xxx46.39          0.00

Les 'x' sont placés à postériori dans l'unique but de maintenir ma vie privée.

Identification graphique

La particularité de ce site, c'est que pour s'identifier, il est nécessaire d'entrer son identifiant dans un champ texte, mais l'insertion de son mot de passe se fait graphiquement :

L'image est générée pour positionner les chiffres à des emplacements aléatoires. Lorsque l'utilisateur clique sur une partie de l'image, le navigateur va rajouter dans un champ caché la position de la case cochée. C'est le serveur qui a stocké l'équivalence et qui va être en mesure de vérifier la validité.

Ainsi que l'on peut le voir, la grille est assez triviale à analyser. BNPorc va donc se contenter de parcourir l'image avec des sauts hardcodés et vérifiera la couleur du pixel en haut à gauche de chaque case pour tout d'abord savoir si la case contient ou pas un chiffre (puisque les chiffres ont un fond gris). Il ajoute alors le contenu de la case dans un buffer, hash le tout et compare avec les valeurs enregistrées pour retrouver le chiffre auquel la case correspond.
Il est alors aisé, à partir du mot de passe numérique entrée au clavier par l'utilisateur de BNPorc, de retrouver les identifiants des cases à transférer au serveur.

Code HTML pourri

Une autre difficulté que j'ai rencontré, c'est la présence de code de merde. On trouve par exemple ceci :

<SCRIPT language=javascript>
if (navigator.appName != "Microsoft Internet Explorer") {
    document.write('<INPUT size="10" '); }
else {
    document.write('<INPUT size="10" ');
}
</SCRIPT>
maxlength="10" value="" name="ch1" type="text"&gt;

Allez savoir l'intérêt d'une telle manipulation, le problème que ça m'a posé c'est que, du coup, mechanize ne trouvait pas cette entrée là. Heureusement, après avoir cherché dans les tréfonds de la lib, ainsi que de ClientForm, il a été possible de rajouter à la main le champ.

BNP's Original Reporter Client

Ce petit outil est donc pour le moment limité au listing des comptes avec leur solde, mais il sera aisé de rajouter diverses informations, comme la liste de toutes les opérations à venir (notamment en ce qui concerne les achats effectués par carte bancaire).

Je pense qu'un tel outil apporte vraiment quelque chose, par exemple, on pourrait faire un indicateur dans la statusbar afin d'avoir le montant du compte, faire des stats sur ses achats (voir avec des regexp où part l'argent), rajouter un système d'alertes, etc.
L'inconvénient, par contre, c'est que je n'ai plus d'excuses pour faire attention à ne pas être à découvert.

Le code source peut être récupéré par git :

$ git clone git://git.symlink.me/pub/romain/bnporc.git

Je vous parlais dans un autre billet du projet précédemment appelé BitlBee2, qui est une passerelle IRC vers des réseaux de messagerie instantanée.

Sur le site du projet se trouvent l'annonce de la release, incluant le ChangeLog et l'archive de la release.

Je dis précédemment appelé bitlbee2, tout simplement parce qu'en raison d'un conflit avec Wilmer, un des auteurs de BitlBee, suite à quelques échanges par email, puis des commentaires de sa part peu cordiaux sur mon autre billet, le projet a été amené à être renommé.

Cette version alpha a pour but de présenter le projet qui se trouve être dans un état utilisable, reprenant les principales fonctionnalités de BitlBee.

MAJ: Ainsi que l'on peut le voir dans les commentaires, j'ai tenté de contacter par email Wilmer, un des auteurs de bitlbee, afin de lui parler du projet et d'avoir son avis concernant l'éventuelle utilisation du nom bitlbee2 pour le projet. L'accueil a été très cassant, me demandant de changer le nom, et cherchant à critiquer le projet plutôt que de voir les bonnes idées que j'essaie de pratiquer dans ce projet.
Je reviendrai sur cette histoire dans un billet prochain. En attendant, le projet s'appelle maintenant Minbif.

Tout le monde connaît bitlbee, cette passerelle IRC vers des protocoles d'IM, qui a été créée il y a sept ans et qui est connu notamment pour son support Jabber désastreux.

Lorsqu'il fut créé, ce projet avait pompé du code de GAIM, un logiciel de messagerie instantanée d'abord orienté AIM puis qui est devenu multi-protocole. Bien évidemment, les récupérations upstreams se sont avérées faibles ou inexistantes, ainsi bitlbee bénéficie d'un support de très peu de protocoles : MSN Messenger, AIM, Yahoo et Jabber. En plus de ça, le code des protocoles de bitlbee est hacké de tous les côtés, et le support Jabber a mis très longtemps avant de devenir stable, même si il reste incomplet.
En outre, bitlbee ne supporte qu'une ancienne version du protocole de MSN Messenger (MSNP8 alors qu'on en est à MSNP15), qui ne supporte pas les transferts de fichiers, et est très peu robuste. Un patch avait été établi sur une ancienne version de bitlbee pour supporter le protocole MSN9 et MSN Plus!, mais il ne fut pas intégré à bitlbee, notamment en raison de fonctionnalités potentiellement coûteuses comme le transfert de fichier, posant d'éventuels problèmes sur leur serveur bitlbee public.

Ayant une installation propre de bitlbee, ne supportant plus les limitations de bitlbee, ne souhaitant pas m'attaquer au code incompréhensible (que j'avais eu l'occasion d'appercevoir lorsque j'avais fais un patch), et ayant du temps à perdre (bon ce n'est pas tout à fait vrai), je me suis donc lancé dans l'écriture d'une version 2 de bitlbee from scratch.

Écrit en C++, le grand apport de Bitlbee 2 est d'utiliser la libpurple, cette bibliothèque en C (avec la Glib) créée par et pour Pidgin, le nouveau nom de GAIM après un litige avec AOL, offre toute l'API nécessaire et suffisante pour créer des comptes permettant de se connecter à n'importe lequel des 13 protocoles supportés de base (sans compter les plugins) de façon transparente, gérer la liste des contacts, le transfert de fichier, etc.

Cherchant à éviter les défauts conceptuels de bitlbee, les changements fonctionnels seront (en partie) les suivants :

• Suppression du robot root. Tout passe maintenant exclusivement par des commandes IRC.
• Un compte est représenté par un serveur IRC. Ceux qui ignorent l'architecture d'un réseau IRC, celui-ci est composé de plusieurs serveurs reliés les uns aux autres, généralement en étoile.
• La commande /map est utilisée pour lister les comptes, mais aussi en rajouter, en supprimer ou en modifier.
• Pour se connecter à un compte, la commande à utiliser est naturellement /sconnect, et /squit pour s'y déconnecter.
• Remplaçant l'identifiant numérique unique de bitlbee1, il y a maintenant deux manières de représenter un compte. L'identifiant court se présente sous forme <proto><num> ou sous forme longue (utilisée pour les serveurs) <username>:<proto><num>. Par exemple, romain@example.com:jabber0.
• Chaque compte a son propre salon de statut. Il est également possible de faire partager le même salon de statut à plusieurs comptes.
• Les salons de statut débutent par '&' alors que les salons sur IM débutent par '#'.
• La commande /invite sera utilisée sur le salon de statut pour ajouter quelqu'un dans ses contacts.
• La commande /kick pourra être utilisée pour retirer quelqu'un de ses contacts, et /ban pour bloquer le contact.

Le but à terme est de réimplémenter toutes les fonctionnalités de bitlbee à travers les commandes IRC, et des extra. Je me suis par exemple intéressé ce matin à réaliser ceci :

rendu ASCII-art de l'avatar avec libcaca

Malheureusement, libpurple ne supporte pas la webcam, ce qui est fort dommage, mais j'ai d'autres idées sympa en tête.

Faisant suite au précédent billet, celui-ci va pointer une grande difficulté du C++, qui est la gestion des pointeurs de fonctions sur les objets.

Pointeurs de fonction

La syntaxe C est très simple, pour faire un pointeur vers une fonction, il suffit d'une ligne :

void f(int arg) {}
 
void (*callback) (int arg) = &f;
callback(5);

En C++, c'est un peu plus complexe. Le pointeur de fonction représentant une adresse mémoire, on ne peut pas dans un seul pointeur associer la méthode pointée, et l'objet appelé avec cette méthode. Ceci est impossible en C++ :

class A
{
public:
	bool f() { return true; }
};
 
A a;
bool (*callback)() = &a.f; //error 

Il est cependant possible de garder le pointeur vers la méthode (statiquement), puis d'appeler cette méthode sur un objet donné. Ce qui donne :

bool (A::*callback)() = &A::f;
 
(a.*func)();

Callbacks

Il est possible, en C++, de masquer ce mécanisme, grâce à une classe dédiée du genre :

class _CallBack
{
public:
        virtual ~_CallBack() {}
        virtual bool run() = 0;
};
 
template<typename T>
class CallBack : public _CallBack
{
public:
 
        typedef bool (T::*TFunc) ();
 
        CallBack(T* _obj, TFunc _func)
		: obj(_obj), func(_func)
	{}
 
        virtual bool run()
        {
                return (obj->*func) ();
        }
 
private:
        T* obj;
        TFunc func;
};

Pour garder un callback, il devient alors juste nécessaire d'avoir un pointeur vers une instance de CallBack :

_CallBack* cb = new CallBack<A>(a, &A::f);
cb->run(); // calls a.f() 

Il est à noter que comme CallBack est une classe template, il est nécessaire de garder un pointeur vers sa classe de base _CallBack, et par polymorphisme les appels seront correctement effectués.

Compatibilité C

Il arrive parfois qu'il est nécessaire d'utiliser une bibliothèque C qui, évidement, requiert un pointeur vers une fonction. Il est relativement fréquent que les méthodes de définition de callback prenne un argument void* data, permettant ainsi de récupérer le contexte dans le callback.

Il est dans ce cas là possible de trouver une parade, grâce à la méthode suivante :

bool g_callback(void* data)
{
        _CallBack* cb = static_cast<_CallBack*>(data);
 
        if(!data)
        {
                b_log[W_ERR] << "g_callback() error";
                return false;
        }
 
        return cb->run();
}

read_cb = new CallBack(a, &A::f);
glib_input_add(fd, PURPLE_INPUT_READ, g_callback_input, read_cb); 

Dans cet exemple, chaque fois qu'un événement en lecture se produit sur le descripteur de fichier fd, l'appel est effectué à a.f(). Évidement, il faut faire très attention à ce que a ne soit pas libéré.

Le cas sans solution

Malheureusement, dans le cas où la bibliothèque ne permet pas de définir un attribut data arbitraire, il est impossible de retrouver le contexte, mis à part en misant aléatoirement sur la valeur des éventuels arguments du callback. Si il n'y en a pas, il n'y a pas de solution.

C'est le cas avec la libpurple, dans le cadre de mon projet bitlbee2, qui prends des instances de structures contenant des pointeurs de fonctions sans pouvoir spécifier aucun argument arbitraire, et bien évidement sans aucun argument de contexte.