2017 lines
75 KiB
Plaintext
2017 lines
75 KiB
Plaintext
= Protocole Relay de WeeChat
|
||
:author: Sébastien Helleu
|
||
:email: flashcode@flashtux.org
|
||
:lang: fr
|
||
:toc: left
|
||
:toclevels: 3
|
||
:toc-title: Table des matières
|
||
:sectnums:
|
||
:docinfo1:
|
||
|
||
|
||
Ce document est une spécification du protocole Relay de WeeChat : le protocole
|
||
utilisé pour relayer les données de WeeChat aux clients, qui sont surtout des
|
||
interfaces distantes.
|
||
|
||
|
||
[[introduction]]
|
||
== Introduction
|
||
|
||
[[terminology]]
|
||
=== Terminologie
|
||
|
||
Les termes suivants sont utilisés dans ce document :
|
||
|
||
* _relay_ : il s'agit de l'extension "relay" de WeeChat, qui agit comme un
|
||
"serveur" et autorise les _clients_ à se connecter
|
||
* _client_ : il s'agit d'un autre logiciel, connecté au _relay_ via une
|
||
connexion réseau; dans la plupart des cas, ce _client_ est une interface
|
||
distante.
|
||
|
||
[[network_diagram]]
|
||
=== Diagramme réseau
|
||
|
||
Les _clients_ sont connectés au _relay_ comme dans le diagramme ci-dessous :
|
||
|
||
....
|
||
┌──────────┐ Station de travail
|
||
┌────────┐ ┌───┤ client 1 │ (Linux, Windows,
|
||
│ irc │◄──┐ ╔═══════════╤═══════╗ │ └──────────┘ BSD, macOS ...)
|
||
└────────┘ └──╢ │ ║◄───┘ ┌──────────┐
|
||
...... ║ WeeChat │ Relay ║◄───────┤ client 2 │ Appareil mobile
|
||
┌────────┐ ┌──╢ │ ║◄───┐ └──────────┘ (Android, iPhone ...)
|
||
│ jabber │◄──┘ ╚═══════════╧═══════╝ │ ......
|
||
└────────┘ │ ┌──────────┐
|
||
...... └───┤ client N │ Autres appareils
|
||
└──────────┘
|
||
|
||
|
||
└────────────┘ └───────────────────┘╘══════╛└────────────────────────────────┘
|
||
serveurs interface ncurses protocole interfaces distantes
|
||
relay
|
||
....
|
||
|
||
[NOTE]
|
||
Tous les clients ici utilisent le protocole _weechat_ dans l'extension _relay_.
|
||
L'extension _relay_ autorise aussi des clients IRC, et _relay_ agit alors comme
|
||
un _proxy IRC_ (non décrit dans ce document).
|
||
|
||
[[protocol_generalities]]
|
||
== Généralités sur le protocole
|
||
|
||
* Les connexions du _client_ vers _relay_ sont faites avec des sockets TCP sur
|
||
l'IP/port utilisé par _relay_ pour écouter les nouvelles connexions.
|
||
* Le nombre de clients est limité par l'option _relay.network.max_clients_.
|
||
* Chaque _client_ est indépendant des autres clients.
|
||
* Les messages du _client_ vers _relay_ sont appelés _commandes_, elles sont
|
||
envoyées sous forme de texte (une chaîne de caractères).
|
||
* Les messages de _relay_ vers le _client_ sont appelés des _messages_, ils sont
|
||
envoyés sous forme de données binaires.
|
||
|
||
[[commands]]
|
||
== Commandes (client → relay)
|
||
|
||
Les commandes ont le format :
|
||
|
||
----
|
||
(id) commande paramètres\n
|
||
----
|
||
|
||
Les champs sont :
|
||
|
||
* _id_ : identifiant du message (facultatif) qui sera envoyée dans la réponse de
|
||
_relay_; elle doit être entre parenthèses, et ne doit pas commencer par un
|
||
underscore (les identifiants commençant par un underscore sont réservés
|
||
pour les messages _évènements_ de WeeChat)
|
||
* _commande_ : une commande (voir le tableau ci-dessous)
|
||
* _paramètres_ : paramètres facultatifs pour la commande (plusieurs paramètres
|
||
sont séparés par des espaces).
|
||
|
||
Liste des commandes disponibles (détail dans les chapitres suivants) :
|
||
|
||
[width="80%",cols="^3m,14",options="header"]
|
||
|===
|
||
| Commande | Description
|
||
| handshake | Poignée de main : préparer l'authentification du client et définir des options, avant la commande _init_.
|
||
| init | S'authentifier avec _relay_.
|
||
| hdata | Demander un _hdata_.
|
||
| info | Demander une _info_.
|
||
| infolist | Demander une _infolist_.
|
||
| nicklist | Demander une _nicklist_ (liste de pseudos).
|
||
| input | Envoyer des données à un tampon (texte ou commande).
|
||
| sync | Synchroniser un/des tampon(s) : recevoir les mises à jour pour le(s) tampon(s).
|
||
| desync | Désynchroniser un/des tampon(s) : stopper les mises à jour pour le(s) tampon(s).
|
||
| quit | Se déconnecter de _relay_.
|
||
|===
|
||
|
||
[[command_handshake]]
|
||
=== handshake
|
||
|
||
_WeeChat ≥ 2.9._
|
||
|
||
Effectuer une poignée de main entre le client et WeeChat : cela est obligatoire
|
||
dans la plupart des cas pour connaître les paramètres de la session et préparer
|
||
l'authentification avec la commande _init_.
|
||
|
||
La poignée de main peut être effectuée plusieurs fois avant la commande _init_,
|
||
même si cela est rarement nécessaire.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
handshake [<option>=<valeur>,[<option>=<valeur>,...]]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _option_ : une des options suivantes :
|
||
** _password_ : liste d'algorithmes de hachage supportés par le client (séparés par
|
||
des deux-points), les valeurs autorisées sont :
|
||
*** _plain_ : mot de passe en clair (pas de hachage)
|
||
*** _sha256_ : mot de passe salé et haché avec l'algorithme SHA256
|
||
*** _sha512_ : mot de passe salé et haché avec l'algorithme SHA512
|
||
*** _pbkdf2+sha256_ : mot de passe salé et haché avec l'algorithme PBKDF2
|
||
(avec un hachage SHA256)
|
||
*** _pbkdf2+sha512_ : mot de passe salé et haché avec l'algorithme PBKDF2
|
||
(avec un hachage SHA512)
|
||
** _compression_ : type de compression :
|
||
*** _zlib_ : activer la compression _zlib_ pour les messages envoyés par _relay_
|
||
(activée par défaut si _relay_ supporte la compression _zlib_)
|
||
*** _off_ : désactiver la compression
|
||
|
||
Notes à propos de l'option _password_ :
|
||
|
||
* Si l'option _password_ n'est pas donnée (ou si la commande _handshake_ n'est
|
||
pas envoyée par le client), _relay_ utilise automatiquement l'authentification
|
||
_plain_ (si elle est autorisée côté _relay_).
|
||
* _Relay_ choisit l'algorithme le plus sûr disponible à la fois côté client et
|
||
_relay_, par ordre de priorité du premier (plus sûr) au dernier utilisé :
|
||
. _pbkdf2+sha512_
|
||
. _pbkdf2+sha256_
|
||
. _sha512_
|
||
. _sha256_
|
||
. _plain_
|
||
|
||
[NOTE]
|
||
Si l'option _password_ n'est pas donnée, WeeChat utilise automatiquement
|
||
l'authentification _plain_ (si autorisée par _relay_).
|
||
|
||
WeeChat répond avec une table de hachage qui contient les clés et valeurs
|
||
suivantes :
|
||
|
||
* _auth_password_ : l'authentification mot de passe négociée : supportée par le
|
||
client et _relay_ :
|
||
** (valeur vide) : la négociation a échoué, l'authentification par mot de passe
|
||
n'est *PAS* possible
|
||
** _plain_
|
||
** _sha256_
|
||
** _sha512_
|
||
** _pbkdf2+sha256_
|
||
** _pbkdf2+sha512_
|
||
* _hash_iterations_ : nombre d'itérations pour le hachage (pour l'algorithme
|
||
PBKDF2 seulement)
|
||
* _totp_:
|
||
** _on_ : le mot de passe à usage unique basé sur le temps (TOTP : Time-based
|
||
One-Time Password) est configuré et est attendu dans la commande _init_
|
||
** _off_ : le mot de passe à usage unique basé sur le temps (TOTP : Time-based
|
||
One-Time Password) n'est pas activé et pas nécessaire dans la commande _init_
|
||
* _nonce_ : un tampon d'octets non prédictibles, envoyé en hexadécimal, pour
|
||
empêcher les attaques par rejeu ; si _auth_password_ est un algorithme de
|
||
hachage, le client doit calculer le mot de passe haché avec ce nonce,
|
||
concaténé avec un nonce client et le mot de passe utilisateur (le nonce
|
||
_relay_ + le nonce client constituent le sel utilisé dans l'algorithme de
|
||
hachage du mot de passe)
|
||
|
||
Exemples :
|
||
|
||
----
|
||
# rien d'offert par le client (ou seulement "plain"), l'authentification par mot de passe "plain" sera utilisée si autorisée côté relay
|
||
handshake
|
||
handshake password=plain
|
||
|
||
# seulement plain, sha256 et pbkdf2+sha256 sont supportés par le client
|
||
handshake password=plain:sha256:pbkdf2+sha256
|
||
----
|
||
|
||
Exemple de réponse :
|
||
|
||
[source,python]
|
||
----
|
||
id: 'handshake'
|
||
htb: {'auth_password': 'pbkdf2+sha256', 'hash_iterations': '100000', 'totp': 'on', 'nonce': '85B1EE00695A5B254E14F4885538DF0D'}
|
||
----
|
||
|
||
Le client peut s'authentifier avec cette commande (voir la <<command_init,commande init>>),
|
||
le sel est le nonce _relay_ + "ABCD" ("41424344" en hexadécimal) :
|
||
|
||
----
|
||
init password_hash=pbkdf2+sha256:85b1ee00695a5b254e14f4885538df0d41424344:100000:01757d53157ca14a1419e3a8cc1563536520a60b76d2d48e7f9ac09afc945a1c
|
||
----
|
||
|
||
[TIP]
|
||
Avec WeeChat ≤ 2.8, la commande _handshake_ n'est pas implémentée, WeeChat ignore
|
||
silencieusement cette commande, même si elle est envoyée avant la commande _init_. +
|
||
Il est donc sûr d'envoyer cette commande à n'importe quelle version de WeeChat.
|
||
|
||
[[command_init]]
|
||
=== init
|
||
|
||
_Mis à jour dans les versions 2.4, 2.8, 2.9._
|
||
|
||
S'authentifier avec _relay_.
|
||
|
||
Il doit s'agir de la première commande envoyée à _relay_ (seule la commande
|
||
_handshake_ peut être envoyée avant _init_). +
|
||
Si elle n'est pas envoyée, _relay_ coupera la connexion à la première commande
|
||
reçue, sans avertissement.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
init [<option>=<valeur>,[<option>=<valeur>,...]]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _option_ : une des options suivantes :
|
||
** _password_ : mot de passe utilisé pour s'authentifier avec _relay_
|
||
(option _relay.network.password_ dans WeeChat)
|
||
** _password_hash_ : mot de passe haché utilisé pour s'authentifier avec _relay_
|
||
(option _relay.network.password_ dans WeeChat), voir ci-dessous pour le format
|
||
_(WeeChat ≥ 2.8)_
|
||
** _totp_ : mot de passe à usage unique basé sur le temps (TOTP : Time-based
|
||
One-Time Password) utilisé comme second facteur d'authentification, en plus
|
||
du mot de passe (option _relay.network.totp_secret_ dans WeeChat)
|
||
_(WeeChat ≥ 2.4)_
|
||
** _compression_ : type de compression (*obsolète* depuis la version 2.9, gardé
|
||
pour des raisons de compatibilité mais devrait être envoyé dans la
|
||
<<command_handshake,commande handshake>>) :
|
||
*** _zlib_ : activer la compression _zlib_ pour les messages envoyés par _relay_
|
||
(activée par défaut si _relay_ supporte la compression _zlib_)
|
||
*** _off_ : désactiver la compression
|
||
|
||
[NOTE]
|
||
Avec WeeChat ≥ 1.6, les virgules peuvent être échappées dans la valeur,
|
||
par exemple `init password=foo\,bar` pour envoyer le mot de passe "foo,bar".
|
||
|
||
Le format du mot de passe haché est l'un des suivants, où _hash_ est le mot
|
||
de passe haché en hexadécimal :
|
||
|
||
* `+sha256:sel:hash+` avec :
|
||
** _sel_ : sel (hexadécimal), qui doit démarrer avec le nonce de _relay_,
|
||
concaténé au nonce client
|
||
** _hash_ : le sel et mot de passe haché (hexadécimal)
|
||
* `+sha512:sel:hash+` avec :
|
||
** _sel_ : sel (hexadécimal), qui doit démarrer avec le nonce de _relay_,
|
||
concaténé au nonce client
|
||
** _hash_ : le set et mot de passe haché (hexadécimal)
|
||
* `+pbkdf2+sha256:sel:itérations:hash+` avec :
|
||
** _sel_ : sel (hexadécimal), qui doit démarrer avec le nonce de _relay_,
|
||
concaténé au nonce client
|
||
** _iterations_ : nombre d'itérations
|
||
** _hash_ : le sel et mot de passe haché avec l'algorithme SHA256 (hexadécimal)
|
||
* `+pbkdf2+sha256:sel:itérations:hash+` avec :
|
||
** _sel_ : sel (hexadécimal), qui doit démarrer avec le nonce de _relay_,
|
||
concaténé au nonce client
|
||
** _iterations_ : nombre d'itérations
|
||
** _hash_ : le sel et mot de passe haché avec l'algorithme SHA512 (hexadécimal)
|
||
|
||
[NOTE]
|
||
Les chaînes en hexadécimal peuvent être en minuscules ou majuscules, _relay_
|
||
peut décoder les deux.
|
||
|
||
Exemples :
|
||
|
||
----
|
||
# initialiser et utiliser la compression zlib par défaut (si WeeChat la supporte)
|
||
init password=mypass
|
||
|
||
# initialiser avec des virgules dans le mot de passe (WeeChat ≥ 1.6)
|
||
init password=mypass\,avec\,virgules
|
||
|
||
# initialiser avec le mot de passe et TOTP (WeeChat ≥ 2.4)
|
||
init password=mypass,totp=123456
|
||
|
||
# initialiser et désactiver la compression
|
||
init password=mypass,compression=off
|
||
|
||
# initialiser avec un mot de passe haché (SHA256 : sel="nonce:cnonce") (WeeChat ≥ 2.9)
|
||
init password_hash=sha256:6e6f6e63653a636e6f6e6365:b9a4c3393dfac4330736684510378851e581c68add8eca84110c31a33e694676
|
||
|
||
# initialiser avec un mot de passe haché (SHA512 : sel="nonce:cnonce") (WeeChat ≥ 2.9)
|
||
init password_hash=sha512:6e6f6e63653a636e6f6e6365:4469190d4e0d1fdc0afb6f408d9873c89b8ce89cc4db79fe058255c55ad6821fa5e9bb068f9e578c8ae7cc825d85ff99c439d59e439bc589d95620a1e6b8ae6e
|
||
|
||
# initialiser avec un mot de passe haché (PBKDF2 : SHA256, sel="nonce:cnonce", 100000 itérations) (WeeChat ≥ 2.9)
|
||
init password_hash=pbkdf2:sha256:6e6f6e63653a636e6f6e6365:100000:01757d53157ca14a1419e3a8cc1563536520a60b76d2d48e7f9ac09afc945a1c
|
||
----
|
||
|
||
[[command_hdata]]
|
||
=== hdata
|
||
|
||
Demander un _hdata_.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
(id) hdata <chemin> [<clés>]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _chemin_ : chemin vers le hdata, avec le format :
|
||
"hdata:pointeur/var/var/.../var", la dernière variable est le hdata retourné :
|
||
** _hdata_ : nom du hdata
|
||
** _pointeur_ : pointeur ("0x12345") ou nom de liste (par exemple :
|
||
"gui_buffers") (nombre autorisé, voir ci-dessous)
|
||
** _var_ : un nom de variable dans le hdata parent (nom précédent dans le
|
||
chemin) (nombre autorisé, voir ci-dessous)
|
||
* _clés_ : liste de clés (séparées par des virgules) à retourner dans le hdata
|
||
(si non spécifié, toutes les clés sont retournées, ce qui n'est pas recommandé
|
||
avec les grosses structures hdata)
|
||
|
||
Un nombre est autorisé après le pointeur et les variables, avec le format "(N)".
|
||
Les valeurs possibles sont :
|
||
|
||
* nombre positif : itérer en utilisant l'élément suivant, N fois
|
||
* nombre négatif : itérer en utilisant l'élément précédent, N fois
|
||
* _*_ : itérer en utilisant l'élément suivant, jusqu'à la fin de la liste
|
||
|
||
[NOTE]
|
||
Avec WeeChat ≥ 1.6, si le chemin vers le hdata est invalide ou si un pointeur
|
||
NULL est trouvé, un hdata vide est retourné (voir l'exemple dans
|
||
<<object_hdata,l'objet hdata>>). +
|
||
Avec des versions plus anciennes, rien n'était retourné.
|
||
|
||
Exemples :
|
||
|
||
----
|
||
# demander tous les tampons, un hdata de type "buffer" est retourné
|
||
# les clés "number" et "name" sont retournées pour chaque tampon
|
||
hdata buffer:gui_buffers(*) number,name
|
||
|
||
# demander toutes les lignes de tous les tampons, un hdata de type "line_data"
|
||
# est retourné
|
||
# toutes les clés sont retournées
|
||
hdata buffer:gui_buffers(*)/lines/first_line(*)/data
|
||
|
||
# demander le nom complet du premier tampon
|
||
hdata buffer:gui_buffers full_name
|
||
|
||
# demander le contenu de la hotlist
|
||
hdata hotlist:gui_hotlist(*)
|
||
----
|
||
|
||
[[command_info]]
|
||
=== info
|
||
|
||
Demander une _info_.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
(id) info <nom> [<paramètres>]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _nom_ : nom de l'info à obtenir
|
||
* _paramètres_ : paramètres pour l'info (facultatif)
|
||
|
||
Exemple :
|
||
|
||
----
|
||
info version
|
||
----
|
||
|
||
[[command_infolist]]
|
||
=== infolist
|
||
|
||
Demander une _infolist_.
|
||
|
||
[IMPORTANT]
|
||
Le contenu de l'infolist est une duplication des données. Dans la mesure du
|
||
possible, utilisez plutôt la commande <<command_hdata,hdata>>, qui est un accès
|
||
direct aux données (cela est plus rapide, utilise moins de mémoire et retourne
|
||
des objets plus petits dans le message).
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
(id) infolist <nom> [<pointeur> [<paramètres>]]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _nom_ : nom de l'infolist à obtenir
|
||
* _pointeur_ : pointeur (facultatif)
|
||
* _paramètres_ : paramètres (facultatif)
|
||
|
||
Exemple :
|
||
|
||
----
|
||
infolist buffer
|
||
----
|
||
|
||
[[command_nicklist]]
|
||
=== nicklist
|
||
|
||
Demander une _nicklist_ (liste de pseudos), pour un ou tous les tampons.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
(id) nicklist [<tampon>]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _tampon_ : pointeur (_0x12345_) ou nom complet du tampon (par exemple :
|
||
_core.weechat_ ou _irc.freenode.#weechat_)
|
||
|
||
Exemples :
|
||
|
||
----
|
||
# demander la liste de pseudos pour tous les tampons
|
||
nicklist
|
||
|
||
# demander la liste de pseudos pour irc.freenode.#weechat
|
||
nicklist irc.freenode.#weechat
|
||
----
|
||
|
||
[[command_input]]
|
||
=== input
|
||
|
||
Envoyer des données à un tampon.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
input <tampon> <données>
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _tampon_ : pointeur (_0x12345_) ou nom complet du tampon (par exemple :
|
||
_core.weechat_ ou _irc.freenode.#weechat_)
|
||
* _données_ : données à envoyer au tampon : si elles commencent par `/`,
|
||
cela sera exécuté comme une commande sur le tampon, sinon le texte est envoyé
|
||
comme entrée sur le tampon
|
||
|
||
Exemples :
|
||
|
||
----
|
||
input core.weechat /help filter
|
||
input irc.freenode.#weechat bonjour !
|
||
----
|
||
|
||
[[command_sync]]
|
||
=== sync
|
||
|
||
_Mis à jour dans la version 0.4.1._
|
||
|
||
Synchroniser un ou plusieurs tampons, pour obtenir les mises à jour.
|
||
|
||
[IMPORTANT]
|
||
Il est recommandé d'utiliser cette commande immédiatement après avoir demandé
|
||
les données des tampons (lignes, ...). Elle peut être envoyée dans le même
|
||
message (après un caractère de nouvelle ligne : "\n").
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
sync [<tampon>[,<tampon>...] <option>[,<option>...]]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _tampon_ : pointeur (_0x12345_) ou nom complet du tampon (par exemple :
|
||
_core.weechat_ ou _irc.freenode.#weechat_); le nom "*" peut être utilisé pour
|
||
spécifier tous les tampons
|
||
* _options_ : un ou plusieurs mots-clés, séparés par des virgules (par défaut
|
||
_buffers,upgrade,buffer,nicklist_ pour "*" et _buffer,nicklist_ pour un
|
||
tampon) :
|
||
** _buffers_ : recevoir les signaux à propos des tampons (ouverts/fermés,
|
||
déplacés, renommés, mélangés, masqués/démasqués); peut être utilisé seulement
|
||
avec "*" _(WeeChat ≥ 0.4.1)_
|
||
** _upgrade_ : recevoir les signaux à propos de la mise à jour de WeeChat
|
||
(mise à jour, fin de mise à jour); peut être utilisé seulement avec "*"
|
||
_(WeeChat ≥ 0.4.1)_
|
||
** _buffer_ : recevoir les signaux à propos du tampon (nouvelles lignes, type
|
||
changé, titre changé, variable locale ajoutée/supprimée, et les même signaux
|
||
que _buffers_ pour le tampon) _(mis à jour dans la version 0.4.1)_
|
||
** _nicklist_ : recevoir la liste de pseudos après des changements
|
||
|
||
Exemples :
|
||
|
||
----
|
||
# synchroniser tous les tampons avec la liste de pseudos
|
||
# (les 3 commandes sont équivalentes, mais la première est recommandée pour une
|
||
# compatibilité avec les futures versions)
|
||
sync
|
||
sync *
|
||
sync * buffers,upgrade,buffer,nicklist
|
||
|
||
# synchroniser le tampon "core"
|
||
sync core.buffer
|
||
|
||
# synchroniser le canal #weechat, sans la liste de pseudos
|
||
sync irc.freenode.#weechat buffer
|
||
|
||
# obtenir les signaux généraux + tous les signaux pour le canal #weechat
|
||
sync * buffers,upgrade
|
||
sync irc.freenode.#weechat
|
||
----
|
||
|
||
[[command_desync]]
|
||
=== desync
|
||
|
||
_Mis à jour dans la version 0.4.1._
|
||
|
||
Désynchroniser un ou plusieurs tampons, pour stopper les mises à jour.
|
||
|
||
[NOTE]
|
||
Ceci retirera les _options_ pour les tampons. Si des options sont toujours
|
||
actives pour les tampons, le client recevra toujours les mises à jour pour ces
|
||
tampons.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
desync [<tampon>[,<tampon>...] <option>[,<option>...]]
|
||
----
|
||
|
||
Paramètres :
|
||
|
||
* _tampon_ : pointeur (_0x12345_) ou nom complet du tampon (par exemple :
|
||
_core.weechat_ ou _irc.freenode.#weechat_); le nom "*" peut être utilisé pour
|
||
spécifier tous les tampons
|
||
* _options_ : un ou plusieurs mots-clés, séparés par des virgules (le défaut est
|
||
_buffers,upgrade,buffer,nicklist_ pour "*" et _buffer,nicklist_ pour un
|
||
tampon); voir <<command_sync,la commande sync>> pour les valeurs
|
||
|
||
[NOTE]
|
||
En utilisant le tampon "*", les autres tampons synchronisés (en utilisant un
|
||
nom) sont gardés. +
|
||
Donc si vous envoyez : "sync *", puis "sync irc.freenode.#weechat", puis
|
||
"desync *", les mises à jour sur le canal #weechat seront toujours envoyées par
|
||
WeeChat (vous devez le retirer explicitement pour stopper les mises à jour).
|
||
|
||
Exemples :
|
||
|
||
----
|
||
# désynchroniser tous les tampons
|
||
# (les 3 commandes sont équivalentes, mais la première est recommandée pour une
|
||
# compatibilité avec les futures versions)
|
||
desync
|
||
desync *
|
||
desync * buffers,upgrade,buffer,nicklist
|
||
|
||
# désynchroniser la liste de pseudos pour le canal #weechat
|
||
# (garder les mises à jour du tampon)
|
||
desync irc.freenode.#weechat nicklist
|
||
|
||
# désynchroniser le canal #weechat
|
||
desync irc.freenode.#weechat
|
||
----
|
||
|
||
[[command_test]]
|
||
=== test
|
||
|
||
Commande de test : WeeChat répondra avec différents objets.
|
||
|
||
Cette commande est utile pour tester le décodage d'objets binaires retournés par
|
||
WeeChat.
|
||
|
||
[IMPORTANT]
|
||
Vous ne devez pas utiliser les pointeurs retournés par cette commande, ils ne
|
||
sont pas valides. Cette commande doit être utilisée seulement pour tester le
|
||
décodage d'un message envoyé par WeeChat.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
test
|
||
----
|
||
|
||
Exemple :
|
||
|
||
----
|
||
test
|
||
----
|
||
|
||
Objets retournés (dans cet ordre) :
|
||
|
||
[width="80%",cols="^3,3m,5m",options="header"]
|
||
|===
|
||
| Type | Type (dans le message) | Valeur
|
||
| caractère | chr | 65 ("A")
|
||
| entier | int | 123456
|
||
| entier | int | -123456
|
||
| long | lon | 1234567890
|
||
| long | lon | -1234567890
|
||
| chaîne | str | "a string"
|
||
| chaîne | str | ""
|
||
| chaîne | str | NULL
|
||
| tampon de données | buf | "buffer"
|
||
| tampon de données | buf | NULL
|
||
| pointeur | ptr | 0x1234abcd
|
||
| pointeur | ptr | NULL
|
||
| date/heure | tim | 1321993456
|
||
| tableau de chaînes | arr str | [ "abc", "de" ]
|
||
| tableau d'entiers | arr int | [ 123, 456, 789 ]
|
||
|===
|
||
|
||
[[command_ping]]
|
||
=== ping
|
||
|
||
_WeeChat ≥ 0.4.2._
|
||
|
||
Envoyer un ping à WeeChat qui répondra avec un message "_pong" et les mêmes
|
||
paramètres.
|
||
|
||
Cette commande est pratique pour tester que la connexion avec WeeChat est
|
||
toujours active et mesurer le temps de réponse.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
ping [<paramètres>]
|
||
----
|
||
|
||
Exemple :
|
||
|
||
----
|
||
ping 1370802127000
|
||
----
|
||
|
||
[[command_quit]]
|
||
=== quit
|
||
|
||
Se déconnecter de _relay_.
|
||
|
||
Syntaxe :
|
||
|
||
----
|
||
quit
|
||
----
|
||
|
||
Exemple :
|
||
|
||
----
|
||
quit
|
||
----
|
||
|
||
[[messages]]
|
||
== Messages (relay → client)
|
||
|
||
Les messages sont envoyés sous forme de données binaires, en utilisant le format
|
||
suivant (avec la taille en octets) :
|
||
|
||
....
|
||
┌────────╥─────────────╥─────────╥────────┬─────────╥───────╥────────┬─────────┐
|
||
│ taille ║ compression ║ id ║ type 1 │ objet 1 ║ ... ║ type N │ objet N │
|
||
└────────╨─────────────╨─────────╨────────┴─────────╨───────╨────────┴─────────┘
|
||
└──────┘ └───────────┘ └───────┘ └──────┘ └───────┘ └──────┘ └───────┘
|
||
4 1 4 + str 3 ?? 3 ??
|
||
└────────────────────┘ └─────────────────────────────────────────────────────┘
|
||
en-tête (5) données compressées (??)
|
||
└────────────────────────────────────────────────────────────────────────────┘
|
||
'taille' octets
|
||
....
|
||
|
||
* _taille_ (entier non signé, 4 octets) : nombre d'octets du message entier
|
||
(en incluant ce champ)
|
||
* _compression_ (octet) : drapeau :
|
||
** _0x00_ : les données qui suivent ne sont pas compressées
|
||
** _0x01_ : les données qui suivent sont compressées avec _zlib_
|
||
* _id_ (chaîne, 4 octets + contenu) : l'identifiant envoyé par le client
|
||
(avant le nom de la commande); il peut être vide (chaîne avec une longueur
|
||
de zéro sans contenu) si l'identifiant n'était pas donné dans la commande
|
||
* _type_ (3 caractères) : un type : 3 lettres (voir le tableau ci-dessous)
|
||
* _objet_ : un objet (voir tableau ci-dessous)
|
||
|
||
[[message_compression]]
|
||
=== Compression
|
||
|
||
Si le drapeau de _compression_ est égal à 0x01, alors *toutes* les données après
|
||
sont compressées avec _zlib_, et par conséquent doivent être décompressées avant
|
||
d'être utilisées.
|
||
|
||
[[message_identifier]]
|
||
=== Identifiant
|
||
|
||
Il y a deux types d'identifiants (_id_) :
|
||
|
||
* _id_ envoyé par le _client_ : _relay_ répondra avec le même _id_ dans sa
|
||
réponse
|
||
* _id_ d'un évènement : pour certains évènements, _relay_ enverra un message au
|
||
_client_ en utilisant un _id_ spécifique, commençant par underscore (voir le
|
||
tableau ci-dessous)
|
||
|
||
Les identifiants réservés par WeeChat :
|
||
|
||
[width="100%",cols="5m,5,3,4,7",options="header"]
|
||
|===
|
||
| Identifiant | Reçu avec _sync_ | Données envoyées |
|
||
Description | Action recommandée dans le client
|
||
|
||
| _buffer_opened | buffers / buffer | hdata : buffer |
|
||
Tampon ouvert. | Ouvrir le tampon.
|
||
|
||
| _buffer_type_changed | buffers / buffer | hdata : buffer |
|
||
Type de tampon changé. | Changer le type de tampon.
|
||
|
||
| _buffer_moved | buffers / buffer | hdata : buffer |
|
||
Tampon déplacé. | Déplacer le tampon.
|
||
|
||
| _buffer_merged | buffers / buffer | hdata : buffer |
|
||
Tampon mélangé. | Mélanger le tampon.
|
||
|
||
| _buffer_unmerged | buffers / buffer | hdata : buffer |
|
||
Tampon sorti du mélange. | Sortir le tampon du mélange.
|
||
|
||
| _buffer_hidden | buffers / buffer | hdata : buffer |
|
||
Tampon masqué. | Masquer le le tampon.
|
||
|
||
| _buffer_unmerged | buffers / buffer | hdata : buffer |
|
||
Tampon démasqué. | Démasquer le tampon.
|
||
|
||
| _buffer_renamed | buffers / buffer | hdata : buffer |
|
||
Tampon renommé. | Renommer le tampon.
|
||
|
||
| _buffer_title_changed | buffers / buffer | hdata : buffer |
|
||
Titre du tampon changé. | Changer le titre du tampon.
|
||
|
||
| _buffer_localvar_added | buffers / buffer | hdata : buffer |
|
||
Variable locale ajoutée. | Ajouter la variable locale dans le tampon.
|
||
|
||
| _buffer_localvar_changed | buffers / buffer | hdata : buffer |
|
||
Variable locale changée. | Changer la variable locale dans le tampon.
|
||
|
||
| _buffer_localvar_removed | buffers / buffer | hdata : buffer |
|
||
Variable locale supprimée. | Supprimer la variable locale du tampon.
|
||
|
||
| _buffer_closing | buffers / buffer | hdata : buffer |
|
||
Tampon qui se ferme. | Fermer le tampon.
|
||
|
||
| _buffer_cleared | buffer | hdata : buffer |
|
||
Tampon qui est vidé. | Vider le tampon.
|
||
|
||
| _buffer_line_added | buffer | hdata : line |
|
||
Ligne ajoutée dans le tampon. | Afficher la ligne dans le tampon.
|
||
|
||
| _nicklist | nicklist | hdata : nicklist_item |
|
||
Liste de pseudos pour un tampon. | Remplacer la liste de pseudos.
|
||
|
||
| _nicklist_diff | nicklist | hdata : nicklist_item |
|
||
Différence de liste de pseudos pour un tampon . | Mettre à jour la liste de pseudos.
|
||
|
||
| _pong | (always) | chaîne : paramètres du ping |
|
||
Réponse à un "ping". | Mesurer le temps de réponse.
|
||
|
||
| _upgrade | upgrade | (vide) |
|
||
WeeChat se met à jour. | Se désynchroniser de WeeChat (ou quitter).
|
||
|
||
| _upgrade_ended | upgrade | (vide) |
|
||
WeeChat a été mis à jour. | (Re)synchroniser avec WeeChat.
|
||
|===
|
||
|
||
[[message_buffer_opened]]
|
||
==== _buffer_opened
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_opened" est envoyé par
|
||
WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| short_name | chaîne | Nom court (exemple : _#weechat_).
|
||
| nicklist | entier | 1 si le tampon a une liste de pseudos, sinon 0.
|
||
| title | chaîne | Titre du tampon.
|
||
| local_variables | table de hachage | Variables locales.
|
||
| prev_buffer | pointeur | Pointeur vers le tampon précédent.
|
||
| next_buffer | pointeur | Pointeur vers le tampon suivant.
|
||
|===
|
||
|
||
Exemple : canal _#weechat_ rejoint sur freenode, nouveau tampon
|
||
_irc.freenode.#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_opened'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'short_name': 'str', 'nicklist': 'int',
|
||
'title': 'str', 'local_variables': 'htb', 'prev_buffer': 'ptr', 'next_buffer': 'ptr'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x35a8a60']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
short_name: None
|
||
nicklist: 0
|
||
title: None
|
||
local_variables: {'plugin': 'irc', 'name': 'freenode.#weechat'}
|
||
prev_buffer: '0x34e7400'
|
||
next_buffer: '0x0'
|
||
----
|
||
|
||
[[message_buffer_moved]]
|
||
==== _buffer_moved
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_moved" est envoyé par
|
||
WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| prev_buffer | pointeur | Pointeur vers le tampon précédent.
|
||
| next_buffer | pointeur | Pointeur vers le tampon suivant.
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ déplacé vers le numéro 2 :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_moved'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'prev_buffer': 'ptr', 'next_buffer': 'ptr'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x34588c0']
|
||
number: 2
|
||
full_name: 'irc.freenode.#weechat'
|
||
prev_buffer: '0x347b9f0'
|
||
next_buffer: '0x3471bc0'
|
||
----
|
||
|
||
[[message_buffer_merged]]
|
||
==== _buffer_merged
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_merged" est envoyé par
|
||
WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| prev_buffer | pointeur | Pointeur vers le tampon précédent.
|
||
| next_buffer | pointeur | Pointeur vers le tampon suivant.
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ mélangé avec le tampon n°2 :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_merged'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'prev_buffer': 'ptr', 'next_buffer': 'ptr'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4db4c00']
|
||
number: 2
|
||
full_name: 'irc.freenode.#weechat'
|
||
prev_buffer: '0x4cef9b0'
|
||
next_buffer: '0x0'
|
||
----
|
||
|
||
[[message_buffer_unmerged]]
|
||
==== _buffer_unmerged
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_unmerged" est envoyé
|
||
par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| prev_buffer | pointeur | Pointeur vers le tampon précédent.
|
||
| next_buffer | pointeur | Pointeur vers le tampon suivant.
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ sorti du mélange :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_unmerged'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'prev_buffer': 'ptr', 'next_buffer': 'ptr'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4db4c00']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
prev_buffer: '0x4cef9b0'
|
||
next_buffer: '0x0'
|
||
----
|
||
|
||
[[message_buffer_hidden]]
|
||
==== _buffer_hidden
|
||
|
||
_WeeChat ≥ 1.0._
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_hidden" est envoyé par
|
||
WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| prev_buffer | pointeur | Pointeur vers le tampon précédent.
|
||
| next_buffer | pointeur | Pointeur vers le tampon suivant.
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ masqué :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_hidden'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'prev_buffer': 'ptr', 'next_buffer': 'ptr'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4db4c00']
|
||
number: 2
|
||
full_name: 'irc.freenode.#weechat'
|
||
prev_buffer: '0x4cef9b0'
|
||
next_buffer: '0x0'
|
||
----
|
||
|
||
[[message_buffer_unhidden]]
|
||
==== _buffer_unhidden
|
||
|
||
_WeeChat ≥ 1.0._
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_unhidden" est envoyé
|
||
par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| prev_buffer | pointeur | Pointeur vers le tampon précédent.
|
||
| next_buffer | pointeur | Pointeur vers le tampon suivant.
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ démasqué :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_unhidden'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'prev_buffer': 'ptr', 'next_buffer': 'ptr'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4db4c00']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
prev_buffer: '0x4cef9b0'
|
||
next_buffer: '0x0'
|
||
----
|
||
|
||
[[message_buffer_renamed]]
|
||
==== _buffer_renamed
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_renamed" est envoyé
|
||
par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| short_name | chaîne | Nom court (exemple : _#weechat_).
|
||
| local_variables | table de hachage | Variables locales.
|
||
|===
|
||
|
||
Exemple : tampon privé renommé de _FlashCode_ en _Flash2_ :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_renamed'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'short_name': 'str', 'local_variables': 'htb'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4df7b80']
|
||
number: 5
|
||
full_name: 'irc.freenode.Flash2'
|
||
short_name: 'Flash2'
|
||
local_variables: {'server': 'freenode', 'plugin': 'irc', 'type': 'private',
|
||
'channel': 'FlashCode', 'nick': 'test', 'name': 'local.Flash2'}
|
||
----
|
||
|
||
[[message_buffer_title_changed]]
|
||
==== _buffer_title_changed
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_title_changed" est
|
||
envoyé par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| title | chaîne | Titre du tampon.
|
||
|===
|
||
|
||
Exemple : titre changé sur le canal _#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_title_changed'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'title': 'str'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4a715d0']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
title: 'Welcome on #weechat! https://weechat.org/'
|
||
----
|
||
|
||
[[message_buffer_cleared]]
|
||
==== _buffer_cleared
|
||
|
||
_WeeChat ≥ 1.0._
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_cleared" est envoyé
|
||
par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ vidé :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_cleared'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4a715d0']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
----
|
||
|
||
[[message_buffer_type_changed]]
|
||
==== _buffer_type_changed
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_type_changed" est
|
||
envoyé par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| type | entier | Type de tampon : 0 = formaté (par défaut), 1 = contenu libre.
|
||
|===
|
||
|
||
Exemple : type de tampon _script.scripts_ changé de formaté (0) à contenu
|
||
libre (1) :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_type_changed'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'type': 'int'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x27c9a70']
|
||
number: 4
|
||
full_name: 'script.scripts'
|
||
type: 1
|
||
----
|
||
|
||
[[message_buffer_localvar_added]]
|
||
==== _buffer_localvar_added
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_localvar_added" est
|
||
envoyé par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| local_variables | table de hachage | Variables locales.
|
||
|===
|
||
|
||
Exemple : variable locale _test_ ajoutée dans le tampon
|
||
_irc.freenode.#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id='_buffer_localvar_added', objects:
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'local_variables': 'htb'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4a73de0']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
local_variables: {'server': 'freenode', 'test': 'value', 'plugin': 'irc',
|
||
'type': 'channel', 'channel': '#weechat', 'nick': 'test',
|
||
'name': 'freenode.#weechat'}
|
||
----
|
||
|
||
[[message_buffer_localvar_changed]]
|
||
==== _buffer_localvar_changed
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_localvar_changed" est
|
||
envoyé par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| local_variables | table de hachage | Variables locales.
|
||
|===
|
||
|
||
Exemple : variable locale _test_ mise à jour dans le tampon
|
||
_irc.freenode.#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id='_buffer_localvar_changed', objects:
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'local_variables': 'htb'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4a73de0']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
local_variables: {'server': 'local', 'test': 'value2', 'plugin': 'irc',
|
||
'type': 'channel', 'channel': '#weechat', 'nick': 'test',
|
||
'name': 'freenode.#weechat'}
|
||
----
|
||
|
||
[[message_buffer_localvar_removed]]
|
||
==== _buffer_localvar_removed
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_localvar_removed" est
|
||
envoyé par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
| local_variables | table de hachage | Variables locales.
|
||
|===
|
||
|
||
Exemple : variable locale _test_ supprimée du tampon _irc.freenode.#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_localvar_removed'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str', 'local_variables': 'htb'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4a73de0']
|
||
number: 3
|
||
full_name: 'irc.freenode.#prout'
|
||
local_variables: {'server': 'local', 'plugin': 'irc', 'type': 'channel',
|
||
'channel': '#weechat', 'nick': 'test', 'name': 'freenode.#weechat'}
|
||
----
|
||
|
||
[[message_buffer_line_added]]
|
||
==== _buffer_line_added
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_line_added" est envoyé
|
||
par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| buffer | pointeur | Pointeur vers le tampon.
|
||
| date | date/heure | Date du message.
|
||
| date_printed | date/heure | Date d'affichage du message.
|
||
| displayed | caractère | 1 si le message est affiché, 0 si le message est filtré (caché).
|
||
| highlight | caractère | 1 si la ligne a un highlight, sinon 0.
|
||
| tags_array | tableau de chaînes | Liste des étiquettes de la ligne.
|
||
| prefix | chaîne | Préfixe.
|
||
| message | chaîne | Message.
|
||
|===
|
||
|
||
Exemple : nouveau message _hello!_ du pseudo _FlashCode_ sur le tampon
|
||
_irc.freenode.#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_line_added'
|
||
hda:
|
||
keys: {'buffer': 'ptr', 'date': 'tim', 'date_printed': 'tim', 'displayed': 'chr',
|
||
'highlight': 'chr', 'tags_array': 'arr', 'prefix': 'str', 'message': 'str'}
|
||
path: ['line_data']
|
||
item 1:
|
||
__path: ['0x4a49600']
|
||
buffer: '0x4a715d0'
|
||
date: 1362728993
|
||
date_printed: 1362728993
|
||
displayed: 1
|
||
highlight: 0
|
||
tags_array: ['irc_privmsg', 'notify_message', 'prefix_nick_142', 'nick_FlashCode', 'log1']
|
||
prefix: 'F06@F@00142FlashCode'
|
||
message: 'hello!'
|
||
----
|
||
|
||
[[message_buffer_closing]]
|
||
==== _buffer_closing
|
||
|
||
Ce message est envoyé au client lorsque le signal "buffer_closing" est envoyé
|
||
par WeeChat.
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| number | entier | Numéro de tampon (≥ 1).
|
||
| full_name | chaîne | Nom complet (exemple : _irc.freenode.#weechat_).
|
||
|===
|
||
|
||
Exemple : tampon _irc.freenode.#weechat_ en cours de fermeture par WeeChat :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_buffer_closing'
|
||
hda:
|
||
keys: {'number': 'int', 'full_name': 'str'}
|
||
path: ['buffer']
|
||
item 1:
|
||
__path: ['0x4a715d0']
|
||
number: 3
|
||
full_name: 'irc.freenode.#weechat'
|
||
----
|
||
|
||
[[message_nicklist]]
|
||
==== _nicklist
|
||
|
||
Ce message est envoyé au client lorsque de grosses mises à jour sont effectuées
|
||
sur la liste de pseudos (groupes/pseudos ajoutés/supprimés/changés). Le message
|
||
contient la liste complète des pseudos.
|
||
|
||
Lorsque de petites mises à jour sont faites sur la liste de pseudos (par exemple
|
||
l'ajout d'un seul pseudo), un autre message avec l'identifiant __nicklist_diff_
|
||
est envoyé (voir ci-dessous).
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| group | caractère | 1 pour un groupe, 0 pour un pseudo.
|
||
| visible | caractère | 1 si le groupe/pseudo est affiché, sinon 0.
|
||
| level | entier | Niveau du groupe (0 pour un pseudo).
|
||
| name | chaîne | Nom du groupe/pseudo.
|
||
| color | chaîne | Couleur du nom.
|
||
| prefix | chaîne | Préfixe (seulement pour un pseudo).
|
||
| prefix_color | chaîne | Couleur du préfixe (seulement pour un pseudo).
|
||
|===
|
||
|
||
Exemple : liste de pseudos pour le tampon _irc.freenode.#weechat_ :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_nicklist'
|
||
hda:
|
||
keys: {'group': 'chr', 'visible': 'chr', 'level': 'int', 'name': 'str', 'color': 'str',
|
||
'prefix': 'str', 'prefix_color': 'str'}
|
||
path: ['buffer', 'nicklist_item']
|
||
item 1:
|
||
__path: ['0x4a75cd0', '0x31e95d0']
|
||
group: 1
|
||
visible: 0
|
||
level: 0
|
||
name: 'root'
|
||
color: None
|
||
prefix: None
|
||
prefix_color: None
|
||
item 2:
|
||
__path: ['0x4a75cd0', '0x41247b0']
|
||
group: 1
|
||
visible: 1
|
||
level: 1
|
||
name: '000|o'
|
||
color: 'weechat.color.nicklist_group'
|
||
prefix: None
|
||
prefix_color: None
|
||
item 3:
|
||
__path: ['0x4a75cd0', '0x4a60d20']
|
||
group: 0
|
||
visible: 1
|
||
level: 0
|
||
name: 'FlashCode'
|
||
color: '142'
|
||
prefix: '@'
|
||
prefix_color: 'lightgreen'
|
||
item 4:
|
||
__path: ['0x4a75cd0', '0x4aafaf0']
|
||
group: 1
|
||
visible: 1
|
||
level: 1
|
||
name: '001|v'
|
||
color: 'weechat.color.nicklist_group'
|
||
prefix: None
|
||
prefix_color: None
|
||
item 5:
|
||
__path: ['0x4a75cd0', '0x4a48d80']
|
||
group: 1
|
||
visible: 1
|
||
level: 1
|
||
name: '999|...'
|
||
color: 'weechat.color.nicklist_group'
|
||
prefix: None
|
||
prefix_color: None
|
||
item 6:
|
||
__path: ['0x4a75cd0', '0x4a5f560']
|
||
group: 0
|
||
visible: 1
|
||
level: 0
|
||
name: 'test'
|
||
color: 'weechat.color.chat_nick_self'
|
||
prefix: ' '
|
||
prefix_color: ''
|
||
----
|
||
|
||
[[message_nicklist_diff]]
|
||
==== _nicklist_diff
|
||
|
||
_WeeChat ≥ 0.4.1._
|
||
|
||
Ce message est envoyé au client lorsque de petites mises à jour sont effectuées
|
||
sur la liste de pseudos (groupes/pseudos ajoutés/supprimés/changés). Le message
|
||
contient les différences de la liste de pseudos (entre l'ancienne liste de
|
||
pseudos et la nouvelle).
|
||
|
||
Données envoyées dans le hdata :
|
||
|
||
[width="100%",cols="3m,2,10",options="header"]
|
||
|===
|
||
| Nom | Type | Description
|
||
| _diff | caractère | Type de différence (voir ci-dessous).
|
||
| group | caractère | 1 pour un groupe, 0 pour un pseudo.
|
||
| visible | caractère | 1 si le groupe/pseudo est affiché, sinon 0.
|
||
| level | entier | Niveau du groupe (0 pour un pseudo).
|
||
| name | chaîne | Nom du groupe/pseudo.
|
||
| color | chaîne | Couleur du nom.
|
||
| prefix | chaîne | Préfixe (seulement pour un pseudo).
|
||
| prefix_color | chaîne | Couleur du préfixe (seulement pour un pseudo).
|
||
|===
|
||
|
||
La valeur de __diff_ peut être :
|
||
|
||
* `+^+` : le groupe parent : le(s) groupe(s)/pseudo(s) après celui-ci sont liés à
|
||
ce groupe
|
||
* `+++` : groupe/pseudo ajouté dans le groupe parent
|
||
* `+-+` : groupe/pseudo supprimé du groupe parent
|
||
* `+*+` : groupe/pseudo mis à jour dans le groupe parent
|
||
|
||
Exemple : pseudo _master_ ajouté dans le groupe _000|o_ (opérateurs de canel sur
|
||
un canal IRC), pseudos _nick1_ et _nick2_ ajoutés dans le groupe _999|..._
|
||
(utilisateurs standard sur un canal IRC) :
|
||
|
||
[source,python]
|
||
----
|
||
id: '_nicklist_diff'
|
||
hda:
|
||
keys: {'_diff': 'chr', 'group': 'chr', 'visible': 'chr', 'level': 'int', 'name': 'str',
|
||
'color': 'str', 'prefix': 'str', 'prefix_color': 'str'}
|
||
path: ['buffer', 'nicklist_item']
|
||
item 1:
|
||
__path: ['0x46f2ee0', '0x343c9b0']
|
||
_diff: 94 ('^')
|
||
group: 1
|
||
visible: 1
|
||
level: 1
|
||
name: '000|o'
|
||
color: 'weechat.color.nicklist_group'
|
||
prefix: None
|
||
prefix_color: None
|
||
item 2:
|
||
__path: ['0x46f2ee0', '0x47e7f60']
|
||
_diff: 43 ('+')
|
||
group: 0
|
||
visible: 1
|
||
level: 0
|
||
name: 'master'
|
||
color: 'magenta'
|
||
prefix: '@'
|
||
prefix_color: 'lightgreen'
|
||
item 3:
|
||
__path: ['0x46f2ee0', '0x46b8e70']
|
||
_diff: 94 ('^')
|
||
group: 1
|
||
visible: 1
|
||
level: 1
|
||
name: '999|...'
|
||
color: 'weechat.color.nicklist_group'
|
||
prefix: None
|
||
prefix_color: None
|
||
item 4:
|
||
__path: ['0x46f2ee0', '0x3dba240']
|
||
_diff: 43 ('+')
|
||
group: 0
|
||
visible: 1
|
||
level: 0
|
||
name: 'nick1'
|
||
color: 'green'
|
||
prefix: ' '
|
||
prefix_color: ''
|
||
item 5:
|
||
__path: ['0x46f2ee0', '0x3c379d0']
|
||
_diff: 43 ('+')
|
||
group: 0
|
||
visible: 1
|
||
level: 0
|
||
name: 'nick2'
|
||
color: 'lightblue'
|
||
prefix: ' '
|
||
prefix_color: ''
|
||
----
|
||
|
||
[[message_pong]]
|
||
==== _pong
|
||
|
||
_WeeChat ≥ 0.4.2._
|
||
|
||
Ce message est envoyé au client lorsque _relay_ reçoit un message "ping".
|
||
|
||
Données envoyées dans la chaîne : paramètres reçus dans le message "ping".
|
||
|
||
L'action recommandée dans le client est de mesurer le temps dé réponse et se
|
||
déconnecter si le temps est très long.
|
||
|
||
[[message_upgrade]]
|
||
==== _upgrade
|
||
|
||
_WeeChat ≥ 0.3.8._
|
||
|
||
Ce message est envoyé au client lorsque WeeChat commence sa mise à jour.
|
||
|
||
Il n'y a pas de données dans le message.
|
||
|
||
L'action recommandée dans le client est de se désynchroniser de WeeChat (envoi
|
||
de la commande _desync_), ou de se déconnecter de WeeChat (car après la mise à
|
||
jour, tous les pointeurs changeront).
|
||
|
||
[NOTE]
|
||
Pendant la mise à jour de WeeChat, le socket reste ouvert (sauf si la connexion
|
||
utilise SSL).
|
||
|
||
[[message_upgrade_ended]]
|
||
==== _upgrade_ended
|
||
|
||
_WeeChat ≥ 0.3.8._
|
||
|
||
Ce message est envoyé au client lorsque WeeChat a terminé sa mise à jour.
|
||
|
||
Il n'y a pas de données dans le message.
|
||
|
||
L'action recommandée dans le client est de se resynchroniser avec WeeChat :
|
||
envoyer à nouveau les commandes envoyées au démarrage après _init_.
|
||
|
||
[[objects]]
|
||
=== Objets
|
||
|
||
Les objets sont identifiés par 3 lettres, appelées _type_. Les types suivants
|
||
sont utilisés :
|
||
|
||
[width="100%",cols="^2m,5,10",options="header"]
|
||
|===
|
||
| Type | Valeur | Longueur
|
||
| chr | Caractère signé | 1 octet
|
||
| int | Entier signé | 4 octets
|
||
| lon | Entier long signé | 1 octet + longueur de l'entier sous forme de chaîne
|
||
| str | Chaîne | 4 octets + longueur de la chaîne (sans le `\0` final)
|
||
| buf | Tampon d'octets | 4 octets + longueur des données
|
||
| ptr | Pointeur | 1 octet + longueur du pointeur sous forme de chaîne
|
||
| tim | Date/heure | 1 octet + longueur de la date/heure sous forme de chaîne
|
||
| htb | Table de hachage | Variable
|
||
| hda | Contenu du hdata | Variable
|
||
| inf | Info : nom + contenu | Variable
|
||
| inl | Contenu de l'infolist | Variable
|
||
| arr | Tableau d'objets | 3 octets (type) + nombre d'objets + données
|
||
|===
|
||
|
||
[[object_char]]
|
||
==== Caractère
|
||
|
||
Un caractère signé est un octet.
|
||
|
||
Exemple :
|
||
|
||
....
|
||
┌────┐
|
||
│ 41 │ ────► 65 (0x41: "A")
|
||
└────┘
|
||
....
|
||
|
||
[[object_integer]]
|
||
==== Entier
|
||
|
||
Un entier signé est stocké sur 4 octets, encodé au format "big-endian" (octet le
|
||
plus significatif en premier).
|
||
|
||
Intervalle : -2147483648 à 2147483647.
|
||
|
||
Exemples :
|
||
|
||
....
|
||
┌────┬────┬────┬────┐
|
||
│ 00 │ 01 │ E2 │ 40 │ ────► 123456
|
||
└────┴────┴────┴────┘
|
||
|
||
┌────┬────┬────┬────┐
|
||
│ FF │ FE │ 1D │ C0 │ ────► -123456
|
||
└────┴────┴────┴────┘
|
||
....
|
||
|
||
[[object_long_integer]]
|
||
==== Entier long
|
||
|
||
Un entier long signé est encodé sous forme de chaîne de caractères, avec la
|
||
longueur sur un octet.
|
||
|
||
Intervalle : -9223372036854775808 à 9223372036854775807.
|
||
|
||
Exemples :
|
||
|
||
....
|
||
┌────╥────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
|
||
│ 0A ║ 31 │ 32 │ 33 │ 34 │ 35 │ 36 │ 37 │ 38 │ 39 │ 30 │ ────► 1234567890
|
||
└────╨────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
|
||
└──┘ └───────────────────────────────────────────────┘
|
||
long. '1' '2' '3' '4' '5' '6' '7' '8' '9' '0'
|
||
|
||
┌────╥────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
|
||
│ 0B ║ 2D │ 31 │ 32 │ 33 │ 34 │ 35 │ 36 │ 37 │ 38 │ 39 │ 30 │ ────► -1234567890
|
||
└────╨────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
|
||
└──┘ └────────────────────────────────────────────────────┘
|
||
long. '-' '1' '2' '3' '4' '5' '6' '7' '8' '9' '0'
|
||
....
|
||
|
||
[[object_string]]
|
||
==== Chaîne de caractères
|
||
|
||
Une chaîne de caractère est une longueur (un entier sur 4 octets) + le contenu
|
||
de la chaîne (sans le `\0` final).
|
||
|
||
Exemple :
|
||
|
||
....
|
||
┌────┬────┬────┬────╥────┬────┬────┬────┬────┐
|
||
│ 00 │ 00 │ 00 │ 05 ║ 68 │ 65 │ 6C │ 6C │ 6F │ ────► "hello"
|
||
└────┴────┴────┴────╨────┴────┴────┴────┴────┘
|
||
└─────────────────┘ └──────────────────────┘
|
||
longueur 'h' 'e' 'l' 'l' 'o'
|
||
....
|
||
|
||
Une chaîne vide a une longueur de zéro :
|
||
|
||
....
|
||
┌────┬────┬────┬────┐
|
||
│ 00 │ 00 │ 00 │ 00 │ ────► ""
|
||
└────┴────┴────┴────┘
|
||
└─────────────────┘
|
||
longueur
|
||
....
|
||
|
||
Une chaîne _NULL_ (pointeur NULL en C) a une longueur de -1 :
|
||
|
||
....
|
||
┌────┬────┬────┬────┐
|
||
│ FF │ FF │ FF │ FF │ ────► NULL
|
||
└────┴────┴────┴────┘
|
||
└─────────────────┘
|
||
longueur
|
||
....
|
||
|
||
[[object_buffer]]
|
||
==== Tampon de données
|
||
|
||
Même format que l'objet <<object_string,chaîne>>; le contenu est simplement un
|
||
tableau d'octets.
|
||
|
||
[[object_pointer]]
|
||
==== Pointeur
|
||
|
||
Un pointeur est encodé sous forme de chaîne de caractère (hexadécimal), avec la
|
||
longueur sur un octet.
|
||
|
||
Exemple :
|
||
|
||
....
|
||
┌────╥────┬────┬────┬────┬────┬────┬────┬────┬────┐
|
||
│ 09 ║ 31 │ 61 │ 32 │ 62 │ 33 │ 63 │ 34 │ 64 │ 35 │ ────► 0x1a2b3c4d5
|
||
└────╨────┴────┴────┴────┴────┴────┴────┴────┴────┘
|
||
└──┘ └──────────────────────────────────────────┘
|
||
long. '1' 'a' '2' 'b' '3' 'c' '4' 'd' '5'
|
||
....
|
||
|
||
Un pointeur _NULL_ a une longueur de 1 avec la valeur 0 :
|
||
|
||
....
|
||
┌────╥────┐
|
||
│ 01 ║ 00 │ ────► NULL (0x0)
|
||
└────╨────┘
|
||
└──┘ └──┘
|
||
long. 0
|
||
....
|
||
|
||
[[object_time]]
|
||
==== Date/heure
|
||
|
||
La date/heure (nombre de secondes) est encodé sous forme de chaîne de
|
||
caractères, avec la longueur sur un octet.
|
||
|
||
Exemple :
|
||
|
||
....
|
||
┌────╥────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
|
||
│ 0A ║ 31 │ 33 │ 32 │ 31 │ 39 │ 39 │ 33 │ 34 │ 35 │ 36 │ ────► 1321993456
|
||
└────╨────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
|
||
└──┘ └───────────────────────────────────────────────┘
|
||
long. '1' '3' '2' '1' '9' '9' '3' '4' '5' '6'
|
||
....
|
||
|
||
[[object_hashtable]]
|
||
==== Table de hachage
|
||
|
||
Une table de hachage contient le type pour les clés, le type pour les valeurs,
|
||
le nombre d'éléments dans la table de hachage (entier sur 4 octets), et les clés
|
||
et valeurs de chaque élément.
|
||
|
||
....
|
||
┌───────────┬─────────────┬───────╥───────┬─────────╥─────╥───────┬─────────┐
|
||
│ type_keys │ type_values │ count ║ key 1 │ value 1 ║ ... ║ key N │ value N │
|
||
└───────────┴─────────────┴───────╨───────┴─────────╨─────╨───────┴─────────┘
|
||
....
|
||
|
||
Exemple :
|
||
|
||
....
|
||
┌─────┬─────┬───╥──────┬─────╥──────┬─────┐
|
||
│ str │ str │ 2 ║ key1 │ abc ║ key2 │ def │ ────► { 'key1' => 'abc',
|
||
└─────┴─────┴───╨──────┴─────╨──────┴─────┘ 'key2' => 'def' }
|
||
└───┘ └───┘ └─┘ └──────────┘ └──────────┘
|
||
type type nombre élément 1 élément 2
|
||
clés valeurs
|
||
....
|
||
|
||
[[object_hdata]]
|
||
==== Hdata
|
||
|
||
Un _hdata_ contient un chemin avec les noms de hdata, une liste de clés, le
|
||
nombre d'objets, et l'ensemble des objets (chemin avec les pointeurs, puis les
|
||
objets).
|
||
|
||
....
|
||
┌────────┬──────┬───────╥────────┬─────────────────────╥──
|
||
│ h-path │ keys │ count ║ p-path │ value 1 ... value N ║ ...
|
||
└────────┴──────┴───────╨────────┴─────────────────────╨──
|
||
|
||
──╥────────┬─────────────────────╥─────┐
|
||
... ║ p-path │ value 1 ... value N ║ ... │
|
||
──╨────────┴─────────────────────╨─────┘
|
||
....
|
||
|
||
* _h-path_ (chaîne) : chemin utilise pour atteindre le hdata (exemple :
|
||
_buffer/lines/line/line_data_); le dernier élément du chemin est le hdata
|
||
retourné
|
||
* _keys_ (chaînes) : chaîne avec une liste de _clé:type_ (séparés par des
|
||
virgules), exemple : _number:int,name:str_
|
||
* _count_ (entier) : nombre d'objets
|
||
* _p-path_ : chemin avec les pointeurs vers les objets (le nombre de pointeurs
|
||
ici est le nombre d'éléments dans le chemin)
|
||
* _values_ : liste de valeurs (le nombre de valeurs est le nombre de clés
|
||
retournées pour le hdata)
|
||
|
||
Exemple de hdata avec deux tampons (tampon "core" weechat et le serveur
|
||
freenode) et deux clés (_number_ et _full_name_) :
|
||
|
||
....
|
||
# commande
|
||
hdata buffer:gui_buffers(*) number,full_name
|
||
|
||
# réponse
|
||
┌────────┬──────────────────────────┬───╥──
|
||
│ buffer │ number:int,full_name:str │ 2 ║ ...
|
||
└────────┴──────────────────────────┴───╨──
|
||
└──────┘ └────────────────────────┘ └─┘
|
||
h-path clés nombre
|
||
|
||
──╥─────────┬───┬──────────────╥─────────┬───┬────────────────────┐
|
||
... ║ 0x12345 │ 1 │ core.weechat ║ 0x6789a │ 2 │irc.server.freenode │
|
||
──╨─────────┴───┴──────────────╨─────────┴───┴────────────────────┘
|
||
└──────────────────────────┘ └────────────────────────────────┘
|
||
tampon 1 tampon 2
|
||
....
|
||
|
||
Exemple de hdata avec les lignes du tampon "core" :
|
||
|
||
....
|
||
# commande
|
||
hdata buffer:gui_buffers(*)/lines/first_line(*)/data
|
||
|
||
# réponse
|
||
┌─────────────────────────────┬─────┬────╥──
|
||
│ buffer/lines/line/line_data │ ... │ 50 ║ ...
|
||
└─────────────────────────────┴─────┴────╨──
|
||
└───────────────────────────┘ └───┘ └──┘
|
||
h-path (noms de hdata) clés nombre
|
||
|
||
──╥───────────┬───────────┬───────────┬───────────┬───────╥──
|
||
... ║ 0x23cf970 │ 0x23cfb60 │ 0x23d5f40 │ 0x23d8a10 │ ..... ║ ...
|
||
──╨───────────┴───────────┴───────────┴───────────┴───────╨──
|
||
└─────────────────────────────────────────────┘ └─────┘
|
||
p-path (pointeurs) objets
|
||
└─────────────────────────────────────────────────────┘
|
||
ligne 1
|
||
|
||
──╥───────────┬───────────┬───────────┬───────╥──────────────┐
|
||
... ║ 0x23cf970 │ 0x23cfb60 │ 0x23d6110 │ ..... ║ ............ │
|
||
──╨───────────┴───────────┴───────────┴───────╨──────────────┘
|
||
└─────────────────────────────────┘ └─────┘
|
||
p-path (pointeurs) objets
|
||
└─────────────────────────────────────────┘ └────────────┘
|
||
ligne 2 lignes 3-50
|
||
....
|
||
|
||
Exemple de hdata avec la liste des pseudos :
|
||
|
||
....
|
||
# commande
|
||
nicklist
|
||
|
||
# réponse
|
||
┌───────────────────┬──
|
||
│ buffer/nick_group │ ...
|
||
└───────────────────┴──
|
||
└─────────────────┘
|
||
h-path
|
||
|
||
──╥───────────────────────────────────────────────────────────┬────╥──
|
||
... ║ group:chr,visible:chr,name:str,color:str,prefix:str,(...) │ 12 ║ ...
|
||
──╨───────────────────────────────────────────────────────────┴────╨──
|
||
└─────────────────────────────────────────────────────────┘ └──┘
|
||
clés nombre
|
||
|
||
──╥─────────┬─────────┬───┬───┬──────┬─┬─┬─┬───╥──
|
||
... ║ 0x12345 │ 0x6789a │ 1 │ 0 │ root │ │ │ │ 0 ║ ...
|
||
──╨─────────┴─────────┴───┴───┴──────┴─┴─┴─┴───╨──
|
||
└─────────────────┘ └──────────────────────┘
|
||
p-path objets
|
||
└──────────────────────────────────────────┘
|
||
groupe (racine de la liste des pseudos)
|
||
|
||
──╥─────────┬─────────┬───┬───┬───────┬─┬─┬─┬───╥──
|
||
... ║ 0x123cf │ 0x678d4 │ 1 │ 0 │ 000|o │ │ │ │ 1 ║ ...
|
||
──╨─────────┴─────────┴───┴───┴───────┴─┴─┴─┴───╨──
|
||
└─────────────────┘ └───────────────────────┘
|
||
p-path objets
|
||
└───────────────────────────────────────────┘
|
||
groupe (ops du canal)
|
||
|
||
──╥─────────┬─────────┬───┬───┬──────────┬──────┬───┬────────────┬───╥──
|
||
... ║ 0x128a7 │ 0x67ab2 │ 0 │ 1 │ ChanServ │ blue │ @ │ lightgreen │ 0 ║ ...
|
||
──╨─────────┴─────────┴───┴───┴──────────┴──────┴───┴────────────┴───╨──
|
||
└─────────────────┘ └────────────────────────────────────────────┘
|
||
p-path objets
|
||
└────────────────────────────────────────────────────────────────┘
|
||
pseudo (@ChanServ)
|
||
....
|
||
|
||
Exemple de hdata vide (la hotlist est vide dans WeeChat) :
|
||
|
||
....
|
||
# commande
|
||
hdata hotlist:gui_hotlist(*)
|
||
|
||
# réponse
|
||
┌────────┬────────┬───┐
|
||
│ (NULL) │ (NULL) │ 0 │
|
||
└────────┴────────┴───┘
|
||
└──────┘ └──────┘ └─┘
|
||
h-path clés nombre
|
||
....
|
||
|
||
[[object_info]]
|
||
==== Info
|
||
|
||
Une _info_ contient un nom et une valeur (les deux sont des chaînes de
|
||
caractères).
|
||
|
||
....
|
||
┌──────┬───────┐
|
||
│ name │ value │
|
||
└──────┴───────┘
|
||
....
|
||
|
||
* _nom_ (chaîne) : nom de l'info
|
||
* _value_ (chaîne) : valeur
|
||
|
||
Exemple de l'info _version_ :
|
||
|
||
....
|
||
┌─────────┬───────────────────┐
|
||
│ version │ WeeChat 0.3.7-dev │
|
||
└─────────┴───────────────────┘
|
||
....
|
||
|
||
[[object_infolist]]
|
||
==== Infolist
|
||
|
||
Une _infolist_ contient un nom, nombre d'éléments, et les éléments (ensemble de
|
||
variables).
|
||
|
||
....
|
||
┌──────┬───────╥────────╥─────╥────────┐
|
||
│ name │ count ║ item 1 ║ ... ║ item N │
|
||
└──────┴───────╨────────╨─────╨────────┘
|
||
....
|
||
|
||
Un élément est :
|
||
|
||
....
|
||
┌───────╥────────┬────────┬─────────╥─────╥────────┬────────┬─────────┐
|
||
│ count ║ name 1 │ type 1 │ value 1 ║ ... ║ name N │ type N │ value N │
|
||
└───────╨────────┴────────┴─────────╨─────╨────────┴────────┴─────────┘
|
||
....
|
||
|
||
* _name_ (chaîne) : nom de l'infolist (_buffer_, _window_, _bar_, ...)
|
||
* _count_ (entier) : nombre d'éléments
|
||
* _item_ :
|
||
** _count_ : nombre de variables dans l'élément
|
||
** _name_ : nom de variable
|
||
** _type_ : type de variable (_int_, _str_, ...)
|
||
** _value_ : valeur de la variable
|
||
|
||
Exemple d'infolist avec deux tampons (tampon "core" weechat et le serveur
|
||
freenode) :
|
||
|
||
....
|
||
# commande
|
||
infolist buffer
|
||
|
||
# réponse
|
||
┌────────┬───╥────┬─────────┬─────┬─────────┬─────╥──
|
||
│ buffer │ 2 ║ 42 │ pointer │ ptr │ 0x12345 │ ... ║ ...
|
||
└────────┴───╨────┴─────────┴─────┴─────────┴─────╨──
|
||
└──────┘ └─┘ └──────────────────────────────────┘
|
||
nom nombre élément 1
|
||
|
||
──╥────┬─────────┬─────┬─────────┬─────┐
|
||
... ║ 42 │ pointer │ ptr │ 0x6789a │ ... │
|
||
──╨────┴─────────┴─────┴─────────┴─────┘
|
||
└──────────────────────────────────┘
|
||
élément 2
|
||
....
|
||
|
||
[[object_array]]
|
||
==== Tableau
|
||
|
||
Un tableau est un type (3 octets) + nombre d'objets (entier sur 4 octets) + les
|
||
données.
|
||
|
||
Exemple de tableau avec deux chaînes de caractères :
|
||
|
||
....
|
||
┌─────╥────┬────┬────┬────╥────┬────┬────┬────╥──
|
||
│ str ║ 00 │ 00 │ 00 │ 02 ║ 00 │ 00 │ 00 │ 03 ║ ...
|
||
└─────╨────┴────┴────┴────╨────┴────┴────┴────╨──
|
||
└───┘ └─────────────────┘ └─────────────────┘
|
||
type nombre de chaînes longueur
|
||
|
||
──╥────┬────┬────╥────┬────┬────┬────╥────┬────┐
|
||
... ║ 61 │ 62 │ 63 ║ 00 │ 00 │ 00 │ 02 ║ 64 │ 65 │ ────► [ "abc", "de" ]
|
||
──╨────┴────┴────╨────┴────┴────┴────╨────┴────┘
|
||
└────────────┘ └─────────────────┘ └───────┘
|
||
'a' 'b' 'c' longueur 'd' 'e'
|
||
....
|
||
|
||
Exemple de tableau avec trois entiers :
|
||
|
||
....
|
||
┌─────╥────┬────┬────┬────╥────┬────┬────┬────╥──
|
||
│ int ║ 00 │ 00 │ 00 │ 03 ║ 00 │ 00 │ 00 │ 7B ║ ...
|
||
└─────╨────┴────┴────┴────╨────┴────┴────┴────╨──
|
||
└───┘ └─────────────────┘ └─────────────────┘
|
||
type nombre d'entiers 123 (0x7B)
|
||
|
||
──╥────┬────┬────┬────╥────┬────┬────┬────┐
|
||
... ║ 00 │ 00 │ 01 │ C8 ║ 00 │ 00 │ 03 │ 15 │ ────► [ 123, 456, 789 ]
|
||
──╨────┴────┴────┴────╨────┴────┴────┴────┘
|
||
└─────────────────┘ └─────────────────┘
|
||
456 (0x1C8) 789 (0x315)
|
||
....
|
||
|
||
Un tableau _NULL_ :
|
||
|
||
....
|
||
┌─────╥────┬────┬────┬────┐
|
||
│ str ║ 00 │ 00 │ 00 │ 00 │ ────► NULL
|
||
└─────╨────┴────┴────┴────┘
|
||
└───┘ └─────────────────┘
|
||
type nombre de chaînes
|
||
....
|
||
|
||
[[typical_session]]
|
||
== Session typique
|
||
|
||
....
|
||
┌────────┐ ┌───────┐ ┌─────────┐
|
||
│ Client ├ ─ ─ ─ ─ (réseau)─ ─ ─ ─ ┤ Relay ├────────────────┤ WeeChat │
|
||
└────────┘ └───────┘ └─────────┘
|
||
║ ║ ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ ouverture socket ║ ajout du client ║
|
||
║ ║ ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ cmd: handshake password=xxx,... ║ négociation algos ║
|
||
║ ║ et options ║
|
||
║ ◄───────────────────────────────╢ ║
|
||
║ msg: id: "handshake" ... ║ ║
|
||
║ ║ ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ cmd: init password=xxx,... ║ authentification ║
|
||
║ ║ client ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ cmd: hdata buffer ... ╟───────────────────────► ║
|
||
║ sync ... ║ demande de hdata ║ lecture
|
||
║ ║ ║ valeurs
|
||
║ ║ ◄───────────────────────╢ hdata
|
||
║ ◄───────────────────────────────╢ hdata ║
|
||
créat° ║ msg: hda buffer ║ ║
|
||
tampons ║ ║ ║
|
||
║ ........ ║ ........ ║
|
||
║ ║ ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ cmd: input ... ╟───────────────────────► ║
|
||
║ ║ envoi données au tampon ║ envoi données
|
||
║ ║ ║ au tampon
|
||
║ ........ ║ ........ ║
|
||
║ ║ ║ signal
|
||
║ ║ ◄───────────────────────╢ reçu
|
||
║ ◄───────────────────────────────╢ signal XXX ║ (accroché
|
||
MAJ ║ msg: id: "_buffer_..." ║ ║ par relay)
|
||
tampons ║ ║ ║
|
||
║ ........ ║ ........ ║
|
||
║ ║ ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ cmd: ping ... ║ ║
|
||
║ ║ ║
|
||
║ ◄───────────────────────────────╢ ║
|
||
mesure ║ msg: id: "_pong" ... ║ ║
|
||
temps ║ ║ ║
|
||
réponse ║ ........ ║ ........ ║
|
||
║ ║ ║
|
||
╟───────────────────────────────► ║ ║
|
||
║ cmd: quit ║ déconnexion du client ║
|
||
║ ║ ║
|
||
....
|