Amigo Application de partage de données - Présentation du protocole Jabber - TuxFamily
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
Amigo
Application de partage de données
Présentation du protocole Jabber
Damien Accorsi – lebouquetin@tuxfamily.org ENST – Année 2005
Amigo – http://amigo.tuxfamily.orgPrésentation du protocole Jabber
Sommaire
1. Introduction......................................................................................................................................3
2. Fonctionnement d'un réseau Jabber..................................................................................................3
3. Les flux XML...................................................................................................................................4
3.a. Les différents types de messages échangés...............................................................................4
3.a.1. Les données ...................................................................................................4
3.a.2. Les données .............................................................................................................5
3.a.3. Les données ...................................................................................................6
3.b. Les espaces de noms ou XML NameSpaces.............................................................................7
3.b.1. L'espace jabber:iq..............................................................................................................8
3.b.2. L'espace jabber:x...............................................................................................................8
3.b.3. Autres espaces, espaces personnalisés..............................................................................8
4. Développer des applications avec la technologie Jabber..................................................................8
4.a.1. Pourquoi utiliser Jabber pour développer des applications ?............................................8
4.a.2. Types d'applications..........................................................................................................9
4.a.3. Etendre les flux XML avec des espaces de nom personnalisés.........................................9
4.a.4. Langages, outils et librairies............................................................................................10
5. Conclusion......................................................................................................................................10
6. Annexes..........................................................................................................................................11
Damien ACCORSI 2 Projet ENST 2005Présentation du protocole Jabber Introduction 1. Introduction L'entrée Jabber de Wikipedia en Anglais commence comme suit : “Jabber is an open, XML-based protocol for instant messaging and presence.[...]”. C'est un excellent point de départ pour présenter le protocole Jabber. Jabber est un protocole ouvert basé sur XML, pour échanger des messages et des notions de présence. Une des application de Jabber est un système de messagerie instantanée, mais Jabber est plus que cela. C'est un protocole, un framework de développement d'applications réseaux communicantes. Il existe de nombreuses implémentations de logiciels client et serveur Jabber, orientées messagerie instantanée pour la majorité, chacun ayant ses propres avantages, inconvénients, extensibilités. Il existe également de multiples librairies de développement implémentant le protocole Jabber, et ce, dans de nombreux langages, et utilisables sous différentes licences. Que ce soit avec des langages interprétés de type script (perl, php, python), de type compilé (C, Java, C++...), orientés objet ou non, il est possible de trouver des outils, disponibles souvent sous licence libre, mais ausi sous licence commerciale. Jabber est un protocole qui a été entériné par l'IETF sous le nom XMPP (eXtensible Messaging and Presence Protocol). C'est donc un standard de l'internet, au même titre que HTTP par exemple. L'utilisation historique de Jabber, et sans doute la plus populaire, est la messagerie instantanée type Aim, Yahoo, etc. Le protocole a néanmoins été imaginé de sorte qu'il est en réalité adapté à une utilisation beaucoup plus vaste que la simple messagerie instantanée. Il est possible de développer des applications spécifiques, étendre le langage pour l'adapter à ses besoins personnels, et même l'utiliser comme framework pour des applications communiquant via le standard XML-RPC. Brièvement, voici les caractéristiques principales du protocole Jabber, qui font notamment son intérêt : – Echange de messages et présence basé sur un dialogue XML. – Sécurisé, ouvert et standard. Il a été validé par l'IETF (cf http://xmpp.org/specs/ pour les RFC). – Décentralisé : son fonctionnement est similaire à celui de l'email. – Extensible, notamment grâce à l'utilisation de XML namespaces personnalisés. – Flexible, on peut l'utiliser pour la messagerie instantanée, pour échanger des fichiers, faire du monitoring... – Riche : du fait de son ouverture, de sa standardisation et de son extensibilité, Jabber est extrêmenent riche et se développe beaucoup. De nombreux outils libres ou propriétaires, de nombreuses entreprises utilisent ou proposent des services gravitant autour de la technologie. Compte-tenu de la richesse du sujet, l'exposé se concentrera sur les points suivants : – Fonctionnement d'une infrastructure Jabber. – Fonctionnement et contenu du protocole XML dans le cadre de la messagerie instantanée. – Développer une application Jabber, étendre le langage de base. 2. Fonctionnement d'un réseau Jabber Une infrastructure Jabber est composée de serveurs, de composants et de clients. Les composants sont des applications serveur particulières qui permettent d'offrir des services supplémentaires via les serveurs. Chaque client possède une adresse, un jid (Jabber Identifiant) se présentant sous la forme monlogin@monServeur/LaRessource. Les serveurs communiquent entre eux pour transmettre les flux XML entre utilisateurs. La ressource est facultative, aussi un utilisateur unique est identifié sous la forme monlogin@monserveur. La ressource sert uniquement à différencier les clients connectés avec le même JID. Damien ACCORSI 3 Projet ENST 2005
Présentation du protocole Jabber Fonctionnement d'un réseau Jabber
Par exemple, si mon jid est dummy@jabber.org et que je veux envoyer un message à mon ami dont le jid est
wizard@jabber.com, le flux xml que je vais générer aura la forme suivante :
Comment fonctionne Jabber ?
Pourrais-tu m'expliquer comment fonctionne le protocole Jabber ?
Lorsque je valide le message, mon client le transfert au serveur jabber.org, qui à son tour le transfert au serveur
jabber.com qui enfin le “pousse” vers le client de mon ami. S'il n'est pas connecté, le serveur jabber.com stocke le
message et le transmettra dès que mon ami se connectera.
Le fonctionnement est donc similaire à celui d'une messagerie de type email, à la différence que dans le cas de
Jabber, le message est poussé vers le destinataire, qui n'a donc pas besoin de récupérer explicitement ses
messages. Dès qu'un nouveau message est présent sur le serveur, si le client est connecté (status connu grâce à la
gestion de la présence), le serveur le transfert instantanément.
Ayant reçu mon message, mon ami pourra alors répondre :
Comment fonctionne Jabber ?
Jabber fonctionne comme une messagerie email instantanée.
Les messages sont “poussés” vers le client sans que celui-ci ne le demande.
Il existe différents types de messages XML échangés entre applications Jabber, voyons donc lesquels ils sont.
3. Les flux XML
Le dialogue entre applications défini par Jabber est basé sur des flux XML. Il existe trois types de messages de
base, qui peuvent être spécialisés gràce à l'utilisation d'espaces de noms (XML namespaces). Par exemple, un
client qui se connecte à un serveur doit commencer par s'identifier. Il va donc demander au serveur “Je voudrais
me connecter, pourrais-tu m'authentifier ?” :
dumy
Le serveur répondra alors en explicitant la méthode qu'il souhaite utiliser pour authentifier l'utilisateur.
Mais voyons quels sont les types de messages échangés et à quoi ils servent.
3.a. Les différents types de messages échangés
Il existe principalement trois types de messages. Il en existe en réalité quelques autres, principalement utilisés
dans le dialogue serveur/serveur ou composant/serveur. Nous n'en parlerons pas.
Ces trois types de messages sont :
–
–
–
Damien ACCORSI 4 Projet ENST 2005Présentation du protocole Jabber Les flux XML
3.a.1. Les données
Le moyen classique d'échanger des données/messages entre utilisateurs est . Ceci était bien visible
dans l'exemple présenté dans l'introduction et reproduit ici :
Comment fonctionne Jabber ?
Pourrais-tu m'expliquer comment fonctionne le protocole Jabber ?
La signification des différents attributs/éléments du message est explicitée ci-dessous :
– from : adresse de l'expéditeur. Elle est renseignée par le serveur afin d'éviter toute tentative de spoofing
d'adresse (action de se faire passer pour un autre utilisateur)
– to : le destinataire du message. Si une ressource est précisée, le message sera relayé vers l'application cliente
recherchée. Dans le cas contraire, elle sera relayée vers le client prioritaire actuellemetn connecté, ou mise en
attente si le destinataire n'est pas connecté.
– id : c'est l'identifiant du fil de discussion. Il permet aux applications de savoir, le cas échéant, à quel message
fait référence le message reçu.
– et : sont respectivement le sujet et le corps du message.
Il est possible d'associer des informations structurées supplémentaires au message gràce à l'utilisation de la balise
. Ces informations seront caractérisées par un espace de nom et pourront donc être des informations
“standards” de Jabber ou des informations complètement personnalisées. L'indication d'une url pourra par
exemple être précisée ainsi :
Incroyable !
Es-tu au courant du terrible accident de train ?
http://en.wikipedia.org/wiki/Jabber
Jabber sur Wikipedia
Dans ce cas, l'espace de nom défini dans l'attribut xmlns de la balise indique au destinataire comment traiter
le contenu. Ce peut être un espace de nom personnalisé pour une application spécifique de Jabber. Dans ce cas, il
faudra bien évidemment que le client soit en mesure d'interpréter les données. Il faudra également s'assurer que
l'espace de nom ne commence pas par jabber: afin de ne pas interférer avec une quelconque extension de Jabber.
3.a.2. Les données
IQ signifie Info/Query. les messages de type permettent d'échanger des données très structurées entre les
applications Jabber, et notamment pour :
– authentifier l'utilisateur,
– récupérer la liste des contacts,
– découvrir les services proposés par un serveur, y accéder et interagir,
– ...
Ces messages permettent d'exprimer une quantité impressionante de requête gràce à l'inclusion d'éléments
définis par les espaces de nom (attribut xmlns).
Damien ACCORSI 5 Projet ENST 2005Présentation du protocole Jabber Les flux XML
L'exemple ci-dessous illustre le concept, un client souhaite s'authentifier auprès de son serveur :
user_2
Le serveur lui indique alors la méthode à utiliser pour s'authentifier :
user_2
Le client doit donc fournir son nom d'utilisateur, le mot de passe crypté à l'aide de la méthode digest et la
ressource choisie. C'est ce qu'effectue le client dans le message suivant :
user_2
gaim
9b960b6e13ec7cc6303b47b5c81d0788744b4fbf
Enfin, le serveur confirme la réussite de l'opération en renvoyant un message vide :
En regardant en détail les messages échangés, on constate qu'un attribut type apparaît et qu'il vaut alternativement
get, set, result. En fait les différents types possibles sont les suivants :
– get : utilisé pour effectuer une requête
– set : utilisé pour une “mise à jour” des données, ou leur création
– result : permet d'indiquer que le message est le résultat d'une requête précédente
– error : indique que la requête précédente à abouti à une erreur.
Dans le cas où une erreur intervient, le contenu de sera composé de :
– un élément précisant le code d'erreur et le message correspondant
– les éléments de la requête originale.
Dans l'exemple précédent, en supposant que le digest calculé soit erroné (le mot de passe étant vraisemblablement
faux), le serveur aurait retourné le message suivant :
user_2
gaim
9b960b6e13ec7cc6303b47b5c81d0788744b4fbf
Unauthorized
Quelques remarques :
– les messages de type set ou get attendent un retour de type result.
– les messages de type set ou get doivent comporter une requête dont l'attribut
xmlns est interprété par l'interlocuteur
– Les requêtes peuvent selon le cas, contenir des éléments de précision ou ne pas en contenir !
Voyons maintenant comment échanger des notions de présence...
Damien ACCORSI 6 Projet ENST 2005Présentation du protocole Jabber Les flux XML
3.a.3. Les données
La présence est l'élément de base permettant au serveur de “pousser” les messages vers le client. Si un client est
absent, il est inutile de pousser le message, et dans ce cas, le serveur stockera l'élément dans une file propre au
destinataire. Mais la présence est égalemetn échangée entre utilisateurs, afin que ceux-ci sachent en temps réel (ou
presque) si leurs contacts sont disponibles, auquel cas il peut être intéressant d'engager la conversation.
Notons au passage que, contrairement à des infrastructures de messagerie type IRC, en l'absence du destinataire,
le message est conservé et distribué à sa future connexion (il est également possible d'intégrer des notions de
durée de vie).
Poru que les utilisateurs soient tenus informés de la présence/absence de leurs contacts, un processus préalable
d'abonnement est nécessaire. “Je suis abonné à la présence de Jean-Louis” signifie que nous avons échangé des
messages pour se mettre d'accord et que désormais l'infrastructure Jabber m'indiquera tout changement dans le
status de Jean-Louis. L'abonnement n'est pas forcément bilatéral, aussi je peux être abonné à la présence de Jean-
Louis sans que lui ne le soit en retour.
Dans l'exemple suivant, leo souhaite s'abonner à la présence de lulu. Il commence par l'ajouter à sa liste de
contacts :
Puis il lui envoie une demande d'abonnement :
Le serveur valide l'ajout du contact :
Puis lulu accepte que leo soit tenu informé de sa présence :
Le simple échange de messages permet d'indiquer son status, mais également de procéder à
l'abonnement gràce à l'attribut type dont les valeurs possibles sont :
– available : l'utilisateur est connecté
– unavailable : l'utilisateur n'est pas connecté
– subscribe : un utilisateur demande à un autre s'il peut s'abonner à sa présence
– unsubscribe : un utilisateur demande à se désabonner de la présence d'un autre
– subscribed : l'utilisateur accepte que son interlocuteur s'abonne à sa présence
– unsubscribed : l'utilisateur a refusé la demande d'abonnement ou l'a annulée
En fonctionnement continu, c'est à dire en dehors de toute négociation d'abonnement, un client peut préciser son
status en enrichissant le contenu de de la manière suivante :
away
je suis à la fête de la musique
5
Il faut bien comprendre que la présence est indiquée au serveur par le client, et uniquement au serveur. Le serveur
se charge ensuite de relayer l'information vers les contacts qui sont abonnés à la présence de l'utilisateur.
Notons également la priorité indiquée dans ce message. Dans le cas où plusieurs logiciels clients sont connectés,
c'est elle qui déterminera vers quel client envoyer les messages dont la ressource du destinataire n'est pas précisée.
Damien ACCORSI 7 Projet ENST 2005Présentation du protocole Jabber Les flux XML
Le client dont la présence sera précisée par la priorité la plus grande sera considéré comme le destinataire par
défaut.
Quelques remarques :
– Si l'attribut type n'est pas renseigné, c'est le contenu de qui fera foi.
– L'abonnement à la présence n'est pas forcément symétrique. A peut être abonné à la présence de B sans que B
ne soit abonné à celle de A.
3.b. Les espaces de noms ou XML NameSpaces
Les trois types de messages que nous venons de voir sont la base du protocole de communication Jabber. Trois
types de messages suffisent pour les multiples possibilités qu'offre Jabber car ils peuvent être enrichis à l'aide de
divers éléments XML. Ces éléments seront alors spécialisés par l'utilisation d'espaces de noms (attribut xmlns), de
sorte que les applications comprennent ce que souhaite l'interlocuteur et à quoi correspond le contenu.
Les deux principaux espaces de noms de Jabber sont jabber:iq et jabber:x. Les espaces de nom jabber:iq sont
utilisés dans le cadre d'une communication formalisée entre applications (exemple : procédure d'authentification,
de création de compte), tandis que les espaces jabber:x ont plutôt vocation à ajouter de l'information structurée,
un contexte aux données (exemple : jabber:x:expire permet de limiter la durée de vie d'un message dont le
contenu n'aurait de sens que s'il est délivré à temps).
Sans entrer dans le détail, voici une liste des espaces de noms qui me semblent avoir un intérêt particulier dans le
cadre du projet Amigo.
3.b.1. L'espace jabber:iq
– jabber:iq:auth permet l'authentification de l'utilisateur.
– jabber:iq:last permet de connaître la dernière connexion d'un utilisateur.
– jabber:iq:oob est utilisé dans le cadre du transfert de fichiers entre clients (transfert direct de pair à pair après
l'échange des informations nécessaires via Jabber). OOB signifie Out Of Band.
– jabber:iq:private permet de stocker des informations privées sur le serveur Jabber (rappel : toutes les
informations de l'utilisateur, carte de visite électronique, liste des contacts, etc, sont stockées sur le serveur)
– jabber:iq:register est le moyen de créer/modifier un compte.
– jabber:iq:time et jabber:iq:version permettent de récupérer l'heure et la version d'un logiciel client ou serveur.
3.b.2. L'espace jabber:x
– jabber:x:encrypted permet de transmettre des données cryptées à l'aide de la clé privée de l'expéditeur. Le
destinataire les décryptera seulement s'il est en possession de la clé publique correspondante.
– jabber:x:delay complète les données en intégrant la date de l'envoi d'un message par exemple.
– jabber:x:expire permet de limiter la durée de vie d'un message Jabber.
– jabber:x:oob permet de compléter les données du message.
– vcard-temp permet de transmettre la carte de visite électronique. La présence de -temp est dûe au fait que
Vcard n'est pas un format de carte de visite électronique standardisé.
– xhtml-im permet d'échanger du texte enrichi en lieu et place du texte brut.
3.b.3. Autres espaces, espaces personnalisés
De nombreux autres espaces de noms sont utilisés dans Jabber. Pour en savoir plus, il est préférable de visiter le
site web de la fondation Jabber, notamment pour savoir comment les utiliser. Ils sont très bien documentés grâces
aux spécifications de la fondation : les JEP.
Il est possible de définir des espaces de noms personnalisés, soit sous la forme d'urls, soit sous une forme textuelle
comme par exemple monapplication:service:element. La seule contrainte, dans ce cas, est qu'ils ne commencent
pas par jabber: afin de ne pas être mal interprétés (et qu'ils n'entrent pas en collision avec des espaces de nom
Jabber qui seraient définis par la suite).
Damien ACCORSI 8 Projet ENST 2005Présentation du protocole Jabber Développer des applications avec la technologie Jabber 4. Développer des applications avec la technologie Jabber 4.a.1. Pourquoi utiliser Jabber pour développer des applications ? Plusieurs raisons peuvent inciter à utiliser ce Framework. Tout d'abord, l'aspect messagerie XML permet d'envisager facilement le déploiement d'une application communicante. Deuxièmement, la notion de présence est un moyen facile à mettre en oevure pour faire du monitoring ou agir en fonction de l'éxécution de processus. Enfin, l'existence d'une infrastructure internationale et publique permet de bénéficier d'une gestion réseau sous- traitée. Un des exemples pris dans l'excellent livre Programming Jabber aux éditions O'reilly est le passage d'ordres bancaires et l'information en temps réel concernant l'évolution du marché. C'est un exemple simpliste mais illustrant parfaitement la puissance de Jabber. Jabber est connu pour échanger des messages de manière instantanée entre individus, le format XML permet très facilement d'étendre Jabber pour échanger des informations structurées. Dès lors, l'utilisation de Jabber pour échanger des messages entre application est évidente. Par ailleurs, La richesse en ressources et l'extensibilité de Jabber en font une base privilégiée. Il suffit de constater que l'on trouve, parmis les membres de la fondation Jabber, des personnes du Département de la Navy et de Hewlett Packard pour savoir qu'il y a un certain intérêt dans le protocole. 4.a.2. Types d'applications La première idée qui vient à l'esprit est de développer des applications de messagerie instantanée. Mais de nombreuses variations sont possibles, étant donné que les messages peuvent être échangés par des personnes et des applications. On peut donc développer des applications de messagerie instantanée : – entre humains – entre humain et machine – entre machines Il est par exemple possible de développer une interface à une application pour la manipuler via jabber. On peut également imaginer des applications de messagerie entre individus différentes. En effet, les messages ne sont pas forcément textuels. Ils peuvent être considérés comme des données. On peut alors imaginer des solutions de base de données réparties, dont l'intérêt est de s'intégrer parfaitement dans une messagerie instantanée classique. Enfin, il est envisageable d'utiliser Jabber pour faire du pair-à-pair. Bien que la structure classique soit de type client/serveur, elle peut être utilisée comme initiateur de connexion entre les pairs, puis les applications basculent en pair-à-pair véritable. C'est ce qui se passe, typiquement, lors du transfert de fichiers entre clients : le processus est initié via Jabber, notamment pour échanger les données de connexion (adresse de l'hôte, port, etc) puis les clients dialoguent entre eux pour le téléchargement. 4.a.3. Etendre les flux XML avec des espaces de nom personnalisés Etendre les flux XML en utilisant des espaces de nom personnalisés ? Rien de plus facile. Les seules contraintes sont de respecter le protocole de base et d'intégrer dans les éléments qui ont été prévus pour (, , etc) les données structurées comme voulu, et de ne pas utiliser d'espace de nom commençant par jabber:. Supposons que vous souhaitiez échanger des scores de football. Il suffira de définir un espace de noms soccer et de développer les applications traitant cet espace de nom. Le client pourra effectuer une requête de la manière suivante : Damien ACCORSI 9 Projet ENST 2005
Présentation du protocole Jabber Développer des applications avec la technologie Jabber
20050504
auxerre
Requête à laquelle le serveur répondra :
20050504
auxerre
sedan
2-1
http://fr.sports.yahoo.com/fo/fc/
Ca ne paraît pas trop compliqué. L'intérêt, dans le cas présent, serait d'informer le client dès la fin du match. Dans
ce cas, au coup de sifflet final, le serveur enverrai à chacun de ses abonnés connecté :
20050504
auxerre
sedan
2-1
http://fr.sports.yahoo.com/fo/fc/
L'application du client intégrant instantanément le nouveau score dans sa grille de championnat.
Finalement, on retrouve dans cet exemple le concept des flux RSS, mais orienté temps-réel et pas forcément web.
4.a.4. Langages, outils et librairies
De nombreuses implémentations de Jabber existent. Les langages utilisés sont variés, les licences disponibles
également. La recherche d'outils sur le site web de la fondation jabber permet rapidement de trouver quatre types
de composants permettant de débuter un développement basé sur la technologie Jabber. On y trouve :
– des clients Jabber
– des serveurs
– des composants pouvant s'interconnecter avec des serveurs (un composant est un serveur dédié à un service
particulier. il nécessite donc de s'interconnecter avec un véritable serveur Jabber).
– des librairies permettant de développer des applications en s'abstrayant de la couche protocolaire, à différents
niveaux d'abstraction.
Les langages les plus représentés sont C/C++, Java et Python. Les licences les plus répendues sont la LGPL et des
licences commerciales.
Les librairies sont orientées client, composant ou serveur. Certaines cumulent les orientations. Pour développer
une application particulière, elles seront très utiles, néanmoins le développement peut également s'appuyer sur un
logiciel déjà existant. C'est là une force des logiciels libres. Reste à choisir judicieusement ses outils compte-tenu
de leurs fonctionnalités et des contraintes d'utilisation (licence) qui votn avec.
De l'aide sera sans aucun doute nécessaire, et là encore, les ressources sont riches. Des listes de diffusion, des
groupes de news, plus de 120 serveurs publics permettront de mettre en oeuvre l'expérimentation. Et la présence
Damien ACCORSI 10 Projet ENST 2005Présentation du protocole Jabber Développer des applications avec la technologie Jabber d'outils libres permettra également d'installer un environnement adéquat chez soi. Les ressources disponibles sont très nombreuses, elles sont partiellement listées en annexe de ce document. 5. Conclusion Jabber est un protocole simple et extrêment puissant. L'utilisation native de XML permet de l'étendre facilement et de manière structurée. C'est un framework de développement d'applications réseau facile à mettre en oeuvre, notamment de part la disponibilités de ressources libres, permettant d'expérimenter avec peu de moyen. Jabber est un protocole vivant. Il évolue gràce à la fondation Jabber. Cette évolution rapide, partiellement dûe à sa jeunesse en fait toutefois une base sérieuse pour le développement d'applications, puisqu'un protocole qui évolue est un protocole pour lequel des gens expriment leur intérêt. Pour s'en convaincre, il suffit de constater la présence de grands groupes informatiques au sein de la fondation et de ses sponsors. Jabber est un protocole encore relativement peu répendu, si l'on compare son utilisation aux possibilités multiples qu'il offre. Damien ACCORSI 11 Projet ENST 2005
Présentation du protocole Jabber Annexes
6. Annexes
6.a. Bibliographie
– Programming Jabber, D.J. Adams, aux Editions O'reilly (Première Edition, Janvier 2002)
6.b. Ressources en ligne
– Fondation Jabber : http://www.jabber.org
– Jabber news : http://www.jabber.org/news/
– Gmane, serveur de news relayant la liste jdev : news://gmane.network.jabber.devel
6.c. Outils utilisés
6.c.1. Expérimentation
– Ethereal, outil d'analyse réseaux : http://www.ethereal.com/
– Psi, client de messagerie Jabber : http://psi.affinix.com/
– Net::Jabber, librairie Jabber en Perl : http://search.cpan.org/dist/Net-Jabber/
– Gedit, éditeur de texte : http://www.gnome.org/projects/gedit/
– Jext, éditeur de texte : http://www.jext.org
– Debian, distribution Linux : http://www.debian.org
6.c.2. Autres
– OpenOffice, suite bureautique libre : http://www.openoffice.org
– OpenClipart, bibliothèque de clipart libre : http://openclipart.org/
6.d. Autres
– Site web du projet : http://amigo.tuxfamily.org
– Damien Accorsi, coordinateur du projet :
– email : lebouquetin@tuxfamily.org
– jabber : lebouquetin@develog.com
– Ce document est librement réutilisable selon les termes de la licence FDL de la Free Software Foundation :
http://www.gnu.org/licenses/licenses.fr.html#TOCFDL
Damien ACCORSI 12 Projet ENST 2005Vous pouvez aussi lire
