xmpp

#xmpp

Table des matières

À propos 1

Chapitre 1: Démarrer avec xmpp 2

Remarques 2

Versions 2

Examples 2

Connexion et envoi d'un message 2

SleekXMPP (Python) 2

Smack (Java / Android) 3

Créer une session de discussion et envoyer un message 3

Créer une connexion client Xmpp à l'aide de la bibliothèque agsxmpp 4

Envoyer un message avec la bibliothèque agsxmpp 4

Chapitre 2: Architecture 6

Remarques 6

Adressabilité 6

Streams Stateful 6

Le routage 6

Les serveurs 6

Examples 7

Visualisation du réseau XMPP en tant que graphique 7

Chapitre 3: Négociation de flux 10

Remarques 10

Examples 10

Fermer un flux 10

Lancer un flux 10

Fermer la connexion XMPP en utilisant la bibliothèque agsxmpp 11

Chapitre 4: XMPP Adresse alias. JID (identifiants Jabber) 12

Syntaxe 12

Paramètres 12

Remarques 12

Examples 12

Fractionnement d'un JID (générique) 12

Types JID 13

Valider un JID (générique) 13

Fractionnement d'un JID (Go) 14

Fractionnement d'un JID (Rust) 15

Crédits 16

À propos

You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: xmpp

It is an unofficial and free xmpp ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official xmpp.

The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.

Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to info@zzzprojects.com

https://riptutorial.com/fr/home 1

Chapitre 1: Démarrer avec xmpp

Remarques

Le protocole XMPP (Extensible Messaging and Presence Protocol) est un protocole réseau utilisant XML pour échanger des données structurées entre deux ou plusieurs entités connectées au réseau en temps quasi réel. XMPP a été créé pour satisfaire aux directives de l'IETF pour les protocoles de présence et de messagerie instantanée ( RFC 2779 ), mais son objectif va bien au-delà de la messagerie instantanée. Il est également utilisé comme un middleware orienté message, pour la communication machine à machine (M2M) et pour l'Internet des objets (IoT).

Le protocole de base léger XMPP fournit aux utilisateurs

authentification forte•adresses globales•format structuré et extensible pour l'échange de données•

L'approche extensible permet de créer des protocoles personnalisés sur le noyau XMPP.

Le protocole XMPP de base est défini dans la RFC 6120 et est géré par Internet Engineering Task Force (XMPP). Les extensions de messagerie instantanée sont définies dans la RFC 6121 et un troisième document ( RFC 7622 ) définit le format des adresses XMPP, également appelées "Jabber Identifiers" (JID). Des fonctionnalités supplémentaires sont spécifiées sous la forme de protocoles d'extension XMPP ( XMPP Extension Protocols ), créés par la communauté et gérés par XMPP Standards Foundation (XSF).

Versions

Version Remarques Date de sortie

1.0 Core: RFC 6120 , IM: RFC 6121 , adresse: RFC 7622 2011-03-01

0,9 Core: RFC 3920 , IM: RFC 3921 , adresse: RFC 6122 2004-10-01

Examples

Connexion et envoi d'un message

SleekXMPP (Python)

import sleekxmpp client = sleekxmpp.Client("address@example.net", "password") client.connect()

https://riptutorial.com/fr/home 2

client.process(blocking=False) client.send_message(mto="remote@example.net", mbody=self.msg)

Smack (Java / Android)

XMPPTCPConnection connection = new XMPPTCPConnection("user", "password", "example.org") connection.connect().login(); Message message = new Message("otheruser@example.net", "Hi, how are you?"); connection.sendStanza(message); connection.disconnect();

Créer une session de discussion et envoyer un message

Smack (Java)

Utiliser Smack 4.1•Il est recommandé d'inclure la dépendance Smack as Maven dans votre projet (par exemple en utilisant gradle ou Maven).

•

En outre, les artefacts / jarres Smack suivants doivent être ajoutés manuellement au classpath: smack-core, smack-extensions, smack-experimental, smack-im, smnack-tcp, smack-java7

•

import org.jivesoftware.smack.ConnectionConfiguration.SecurityMode; import org.jivesoftware.smack.SmackException; import org.jivesoftware.smack.XMPPException; import org.jivesoftware.smack.chat.Chat; import org.jivesoftware.smack.chat.ChatManager; import org.jivesoftware.smack.chat.ChatMessageListener; import org.jivesoftware.smack.packet.Message; import org.jivesoftware.smack.packet.Presence; import org.jivesoftware.smack.tcp.XMPPTCPConnection; import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration; public void sendMessage() { XMPPTCPConnectionConfiguration config = XMPPTCPConnectionConfiguration.builder() .setServiceName("mydomain.local") .setHost("127.0.0.1") .setPort(5222) .build(); XMPPTCPConnection connection = new XMPPTCPConnection(config); connection.connect(); connection.login("test1", "test1pwd"); ChatManager chatManager = ChatManager.getInstanceFor(connection); String test2JID = "test2@domain.example"; Chat chat = chatManager.createChat(test2JID); chat.sendMessage("Hello, how are you?"); connection.disconnect(); }

https://riptutorial.com/fr/home 3

Créer une connexion client Xmpp à l'aide de la bibliothèque agsxmpp

public void OpenXmppConnection(int port, bool useSsl, string serverJid, string userName, string password) { try { _xmppClientConnection.AutoResolveConnectServer = true; _xmppClientConnection.Port = port; _xmppClientConnection.UseSSL = useSsl; _xmppClientConnection.Server = serverJid; _xmppClientConnection.Username = userName; _xmppClientConnection.Password = password; _xmppClientConnection.Resource = "web"; //authenticate and open connection with server _xmppClientConnection.Open(); } catch (Exception ex) { } }

Envoyer un message avec la bibliothèque agsxmpp

public class ConversationManager { #region ClassMemeber private XmppClientConnection _xmppClientConnection = null; public ConversationManager(XmppClientConnection con) { _xmppClientConnection = con; } public void SendMessage(string message, string to, string guid, string type) { try { if (_xmppClientConnection != null) { Jid jidTo = new Jid(to); agsXMPP.protocol.client.Message mesg = new agsXMPP.protocol.client.Message(jidTo, _ConnectionWrapper.MyJid, agsXMPP.protocol.client.MessageType.chat, message); mesg.Id = guid; mesg.AddChild(new agsXMPP.protocol.extensions.msgreceipts.Request());//request delievery _xmppClientConnection.Send(mesg); } } catch (Exception ex)

https://riptutorial.com/fr/home 4

{ } } }

Lire Démarrer avec xmpp en ligne: https://riptutorial.com/fr/xmpp/topic/2451/demarrer-avec-xmpp

https://riptutorial.com/fr/home 5

Chapitre 2: Architecture

Remarques

XMPP permet l'échange en duplex intégral de données structurées et le traitement simultané des demandes entre des clients et des serveurs adressables globalement sur le réseau. À la différence de HTTP et de l’architecture REST (Representational State Transfer) largement déployée sur le Web, les connexions XMPP sont à l’état et concurrentes, et un nombre illimité de transactions peut se produire dans le contexte d’une seule session. Cette architecture est parfois appelée aussi "Disponibilité pour les transactions simultanées" (ACT).

Adressabilité

Pour faciliter le routage sur le réseau, toutes les adresses XMPP sont globalement adressables. Comme pour le courrier électronique, il est réalisé avec DNS et une architecture client / serveur fédérée. Les adresses sont de la forme localpart@domainpart/resourcepart où la partie locale est facultative et correspond à un utilisateur du réseau, domainpar est requis et correspond à un serveur et resourcepart est facultatif et fait référence à un client connecté spécifique pour cet utilisateur (dans Les utilisateurs de XMPP peuvent être connectés depuis de nombreux endroits différents, par exemple un téléphone et un ordinateur portable dans le cas de la messagerie instantanée ou de nombreux capteurs utilisant un seul compte dans le cas des appareils compatibles avec Internet des objets. XMPP fournit également des fonctionnalités permettant de détecter la présence (disponibilité) d'autres adresses sur le réseau.

Streams Stateful

Les connexions XMPP sont des connexions TCP de longue durée qui transportent des flux XML d'un client vers un serveur (c2s) ou d'un serveur vers un serveur (s2s). La longue durée de vie de ces sessions et leur gestion dynamique permettent aux nœuds du réseau de transmettre des données à tout moment et de les acheminer ou de les livrer immédiatement.

Le routage

Les flux forment un lien direct sur le réseau entre un client et un serveur ou un serveur et un serveur. Si un client souhaite communiquer avec un client distant sur le réseau, il envoie d'abord les informations à son serveur, qui forme une connexion de serveur à serveur avec le serveur distant, qui transmet ensuite les informations à son client.

Les serveurs

Serveurs dans le réseau XMPP acheminent les données, mais ont également un certain nombre d'autres responsabilités, notamment le maintien de l'état de la session, le stockage des données client (historique des discussions, fichiers, messages envoyés lorsque aucun client n'est en ligne,

https://riptutorial.com/fr/home 6

listes de contacts, etc. Ils sont la plupart de la logique métier de la gestion d'une connexion XMPP. Cela permet aux clients de rester aussi "stupides" que possible (contenant très peu de logique).

Examples

Visualisation du réseau XMPP en tant que graphique

Le réseau XMPP peut être considéré comme un graphe bidirectionnel avec des serveurs (S) fonctionnant dans un maillage, des clients (C) regroupés sur leur serveur local et des flux représentés par des bords extravertis:

https://riptutorial.com/fr/home 7

Lorsqu'un client souhaite envoyer des données (par exemple, un message ou des informations de présence) à un autre client sur le réseau, le message est toujours acheminé le long du chemin le

https://riptutorial.com/fr/home 8

plus court possible (d'un client vers son serveur sur le même serveur ou sur le serveur des clients distants, puis sur le client si le client distant est sur un serveur différent).

Lire Architecture en ligne: https://riptutorial.com/fr/xmpp/topic/3038/architecture

https://riptutorial.com/fr/home 9

Chapitre 3: Négociation de flux

Remarques

Les connexions XMPP comprennent deux flux XML: un pour les entrées et un pour les sorties. Ces flux sont généralement envoyés via la même connexion TCP (bien que parfois plusieurs connexions puissent être utilisées, en particulier pour les connexions de serveur à serveur) et partagent certaines fonctionnalités pour lesquelles une négociation est requise (par exemple, authentification avec SASL).

Examples

Fermer un flux

Un flux est fermé en envoyant une </stream> fermeture </stream> . Une fois la balise de flux de fermeture envoyée, aucune donnée supplémentaire ne doit être envoyée sur le flux (même en réponse aux données reçues de l'autre partie). Avant de fermer la connexion, l'entité émettrice doit attendre qu'une </stream> réponse </stream> donne à l'autre partie le temps d'envoyer des données en attente et expire (et met fin à la connexion TCP sous-jacente) pas reçu dans un délai choisi.

</stream:stream>

Si le flux est chiffré avec TLS, les parties doivent terminer le TLS proprement en envoyant une alerte TLS close_notify et en recevant une en réponse. Votre bibliothèque TLS le fait probablement pour vous.

Lancer un flux

Une fois qu'une connexion TCP est établie, l'en-tête de flux initial est envoyé par l'entité initiatrice. De même, chaque fois qu'un redémarrage de flux est requis (par exemple, après avoir négocié une couche de sécurité telle que TLS), un en-tête de flux doit également être envoyé:

<?xml version='1.0'?> <stream:stream from='juliet@im.example.com' to='im.example.com' version='1.0' xml:lang='en' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>

L'en-tête XML est facultatif, mais s'il existe, il ne doit rien spécifier d'autre que XML version 1.0 avec codage UTF-8.

En réponse, l'entité réceptrice enverra sa propre balise d'ouverture contenant un identifiant de

https://riptutorial.com/fr/home 10

session unique:

<?xml version='1.0'?> <stream:stream from='im.example.com' id='++TR84Sm6A3hnt3Q065SnAbbk3Y=' to='juliet@im.example.com' version='1.0' xml:lang='en' xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>

Fermer la connexion XMPP en utilisant la bibliothèque agsxmpp

public class ConnectionManager { private XmppClientConnection _xmppClientConnection = null; public ConnectionManager() { if (_xmppClientConnection == null) { _xmppClientConnection = new XmppClientConnection(); } } public void CloseXmppConnection() { try { if (_xmppClientConnection != null) { //Close xmpp Client Connection _xmppClientConnection.Close(); } } catch (Exception ex) { } } }

Lire Négociation de flux en ligne: https://riptutorial.com/fr/xmpp/topic/4248/negociation-de-flux

https://riptutorial.com/fr/home 11

Chapitre 4: XMPP Adresse alias. JID (identifiants Jabber)

Syntaxe

[localpart "@"] domainpart ["/" resourcepart]•

Paramètres

Partie Usage courant

Partie locale Identifie une entité XMPP (facultative)

Domainpart Identifie le service XMPP

Resourcepart Identifie une session d'une entité XMPP (facultatif)

Remarques

Les adresses XMPP, plus connues sous le nom de JID (Jabber Identifiers), sont définies dans la RFC 7622 et servent d’adresses sur le réseau XMPP. Ils ressemblent à une adresse e-mail, mais ont parfois un "composant de ressource" facultatif à la fin qui identifie un client particulier connecté en tant que compte représenté par le reste de l'adresse (XMPP pouvant avoir plusieurs clients connectés par compte). Un exemple d'adresse XMPP avec le resourcepart (un client) xyz est:

romeo@example.net/xyz

Examples

Fractionnement d'un JID (générique)

Pour diviser un JID en ses composants (la partie locale, domainpart et resourcepart), l'algorithme suivant doit être utilisé (où la partie locale est représentée par lp , la partie ressource par rp et la partie domaine par dp et ∈ est utilisée pour vérifier si le caractère donné est inclus dans la chaîne):

https://riptutorial.com/fr/home 12

Notez que localpart et resourcepart sont facultatifs et peuvent entraîner des chaînes vides (vous

Types JID

Un JID se compose de trois parties: localpart @ domainpart / resourcepart.

JID complets (toujours une partie ressource)

romeo@example.org/orchard

JIDs nus (toujours sans partie ressource)

romeo@example.org

Valider un JID (générique)

Contrairement aux e-mails, les JID ont été définis en tenant compte de l'internationalisation (i18n) L'algorithme de validation d'un JID qui a déjà été divisé en ses parties locales, domainpart et res

L'étape de Validations doit effectuer les opérations suivantes:

Vérifiez que la partie locale est inférieure à 1024 octets (octets, pas de glyphes)•

https://riptutorial.com/fr/home 13

Vérifiez que la partie locale ne contient aucun "&'/:<>@•Vérifiez que la pièce de ressource est inférieure à 1024 octets•Vérifiez que la part de domaine est supérieure à zéro octet et inférieure à 1024 octets (et validez éventuellement que les différentes parties du domaine correspondent aux exigences DNS)

•

Si le domaine est une adresse IPv6 valide, assurez-vous qu'il utilise la notation entre crochets (par exemple, [::1] au lieu de ::1 )

•

Fractionnement d'un JID (Go)

Le package mellium.im/xmpp/jid implémente des opérations sur les JID. Pour diviser une chaîne JID en ses composants, la fonction SplitString peut être utilisée:

lp, dp, rp, err := SplitString("romeo@example.net")

Aucune validation n'est effectuée par la fonction et les pièces ne sont pas garanties pour être valides.

Pour diviser manuellement une chaîne sans dépendre du package jid , le code sous-jacent ressemble à ceci:

// SplitString splits out the localpart, domainpart, and resourcepart from a // string representation of a JID. The parts are not guaranteed to be valid, and // each part must be 1023 bytes or less. func SplitString(s string) (localpart, domainpart, resourcepart string, err error) { // RFC 7622 §3.1. Fundamentals: // // Implementation Note: When dividing a JID into its component parts, // an implementation needs to match the separator characters '@' and // '/' before applying any transformation algorithms, which might // decompose certain Unicode code points to the separator characters. // // so let's do that now. First we'll parse the domainpart using the rules // defined in §3.2: // // The domainpart of a JID is the portion that remains once the // following parsing steps are taken: // // 1. Remove any portion from the first '/' character to the end of the // string (if there is a '/' character present). sep := strings.Index(s, "/") if sep == -1 { sep = len(s) resourcepart = "" } else { // If the resource part exists, make sure it isn't empty. if sep == len(s)-1 { err = errors.New("The resourcepart must be larger than 0 bytes") return } resourcepart = s[sep+1:] s = s[:sep] }

https://riptutorial.com/fr/home 14

// 2. Remove any portion from the beginning of the string to the first // '@' character (if there is an '@' character present). sep = strings.Index(s, "@") switch sep { case -1: // There is no @ sign, and therefore no localpart. localpart = "" domainpart = s case 0: // The JID starts with an @ sign (invalid empty localpart) err = errors.New("The localpart must be larger than 0 bytes") return default: domainpart = s[sep+1:] localpart = s[:sep] } // We'll throw out any trailing dots on domainparts, since they're ignored: // // If the domainpart includes a final character considered to be a label // separator (dot) by [RFC1034], this character MUST be stripped from // the domainpart before the JID of which it is a part is used for the // purpose of routing an XML stanza, comparing against another JID, or // constructing an XMPP URI or IRI [RFC5122]. In particular, such a // character MUST be stripped before any other canonicalization steps // are taken. domainpart = strings.TrimSuffix(domainpart, ".") return }

Fractionnement d'un JID (Rust)

Dans Rust, le xmpp-addr ( docs ) peut être utilisé pour manipuler les JID. Pour diviser un JID en ses composants (sans valider que ces parties sont valides), la fonction Jid::split peut être utilisée:

let (lp, dp, rp) = Jid::split("feste@example.net")?; assert_eq!(lp, Some("feste")); assert_eq!(dp, "example.net"); assert_eq!(rp, None);

Lire XMPP Adresse alias. JID (identifiants Jabber) en ligne: https://riptutorial.com/fr/xmpp/topic/3036/xmpp-adresse-alias--jid--identifiants-jabber-

https://riptutorial.com/fr/home 15

Crédits

S. No

Chapitres Contributeurs

1 Démarrer avec xmpp Afsheen126, bilal, Community, Flow, ge0rg, khan, Sam Whited

2 Architecture Sam Whited

3 Négociation de flux khan, Sam Whited

4XMPP Adresse alias. JID (identifiants Jabber)

Flow, ge0rg, Sam Whited

https://riptutorial.com/fr/home 16