Bus LOGiciel

Système de transport de messages

 

Fiabilité

Efficacité

Rapidité

Faible consommation de ressources

Reprise automatique en cas de coupure de lignes

Transfert de pièces jointes multiples

Fonctionne en local ou en réseau

Fonctionnement temps-réel ou temps-partagé

Mode transactionnel

Nombreux pilotes de périphériques : LDAP, port série et parallèle, …

Ouverture vers d’autres langages : JAVA, PICK, C, …

Librairie multi-threads

Accès par la ligne de commande, une socket ou l’appel d’une fonction de la librairie.

Lancement d’application

 

Fonctionne sous les différents UNIX du marché (SCO, HP, …), les systèmes libres (GNU/LINUX, …), Windows XP, 2000, NT4, 95 et 98 avec NutCracker ou UWin, Windows NT avec Interix.

 

 

Disponible sous forme de code source ou de code objet

Disponible sous forme de librairie partagée sous UNIX et sous forme de DLL sous Windows

 

 

Version logicielle correspondant à la documentation : 2.0.23 (TNT16) du 24 décembre 2001.

 

Version :        2,03

Auteur :          Yves Crespin

Date :             14 février 2002


Table des matières

BUS LOGICIEL............................................................................................................................................................................................... 4

Descriptif général............................................................................................................................................................................. 4

Schéma...................................................................................................................................................................................................... 5

Opérations.............................................................................................................................................................................................. 6

Actions...................................................................................................................................................................................................... 7

Administration..................................................................................................................................................................................... 10

Configuration système................................................................................................................................................................ 10

Le compte « blog »............................................................................................................................................................................. 10

Lancement et arrêt du BLOG..................................................................................................................................................... 11

Administration du BLOG (blog.sh et blog_ctrl.sh)..................................................................................................... 12

Fichier de configuration............................................................................................................................................................. 14

Lancement des programmes auxiliaires.......................................................................................................................... 17

Emplacement des fichiers........................................................................................................................................................... 18

Description technique..................................................................................................................................................................... 20

Format d’un message.................................................................................................................................................................... 20

Nom de boîtes aux lettres.......................................................................................................................................................... 21

Gestion des adresses IP.................................................................................................................................................................. 22

Les pièces jointes............................................................................................................................................................................... 23

Message urgent................................................................................................................................................................................. 25

Message lent....................................................................................................................................................................................... 25

Message avec un délai de rétention : alarme............................................................................................................... 26

Mode transactionnel................................................................................................................................................................... 27

Dépose dégradée................................................................................................................................................................................ 28

Les portables sans carte réseau et avec une carte modem............................................................................... 29

Utilisation d’un langage interprété.................................................................................................................................. 30

Fonctionnement avec UWin....................................................................................................................................................... 31

Fonctionnement avec NutCracker....................................................................................................................................... 32

Programmes auxiliaires................................................................................................................................................................ 33

Recherche dans l’annuaire....................................................................................................................................................... 33

Gestion des messages périmés................................................................................................................................................... 35

Modification de l’annuaire...................................................................................................................................................... 36

Liaison avec un port série........................................................................................................................................................... 37

Liaison avec une imprimante sur un port parallèle................................................................................................ 38

Identification LDAP......................................................................................................................................................................... 40

Lanceur d’application.................................................................................................................................................................. 41

Les outils.................................................................................................................................................................................................. 44

Outil d’administration BLOG_ADM....................................................................................................................................... 44

Outil de visualisation des messages BLOG_REC............................................................................................................. 45

Outil d’émission et de réception de message BLOG_SHELL........................................................................................ 46

Etat courant du système........................................................................................................................................................... 48

Message d’erreur et message de trace.............................................................................................................................. 49

Outil d’exploitation et de suivi des messages de trace BLOG_TRACE.............................................................. 51

Les fonctions de la librairie..................................................................................................................................................... 52

La librairie........................................................................................................................................................................................... 52

Les codes d’erreur............................................................................................................................................................................ 53

Les fonctions threads-safe....................................................................................................................................................... 54

Les fonctions....................................................................................................................................................................................... 55

blogdefault............................................................................................................................................................................................ 55

blogset................................................................................................................................................................................................... 56

blogget................................................................................................................................................................................................... 57

blogget_r............................................................................................................................................................................................... 58

blogcmd................................................................................................................................................................................................. 59

blogerror............................................................................................................................................................................................... 63

blogerror_r........................................................................................................................................................................................... 64

Les paramètres.................................................................................................................................................................................. 65

Une alternative à l’usage de la librairie.......................................................................................................................... 67

La passerelle....................................................................................................................................................................................... 67

Une librairie passerelle pour Windows............................................................................................................................. 68

Le protocole........................................................................................................................................................................................ 69

 

BUS LOGICIEL

Descriptif général

Le bus logiciel (BLOG) constitue l’élément garantissant la flexibilité et l’évolution du système global. Il doit prendre en compte la nécessaire autonomie des postes et donc s’affranchir d’un certain nombres de concepts et de solutions impliquant une trop forte connexion des différents sous-ensemble. Il doit aussi fonctionner de manière autonome en réalisant les reprises nécessaires.

Le bus logiciel fournit une couche de transport garantissant l’acheminement des messages.

 

·       Le BLOG fournit une couche de liaison (middleware).

·       Le BLOG utilise un journal des transactions (sécurité).

·       Les échanges supportés par le BLOG sont de type message sans établissement de session entre deux applications.

·       Pour le BLOG, toutes les applications sont clientes. Elles sollicitent un service : l’émission, la consultation ou la destruction d’un message.

·       Un message peut être émis avec une date de délivrance différée (alarme).

·       Une application peut partager une boîte aux lettres.

·       Une application peut disposer d’une ou de plusieurs boîtes aux lettres.

·       Le BLOG maintient pour chaque boîte aux lettres les messages en attente.

·       La consommation mémoire du BLOG est contrôlée. En cas de dépassement du seuil autorisé, les messages les plus anciens et les plus volumineux sont basculés sur disque.

·       Le BLOG transmet les messages ‑ une fois leur durée de vie du message écoulée ‑ à une application spécifique. Charge à celle-ci de traiter ces messages. L’application de base se contente de les sauver dans un fichier.

·       Le BLOG gère les messages dans une file de type FIFO (First In, First Out).

·       Le BLOG produit des statistiques à la demande.

·       Le BLOG supporte une fonctionnement transactionnel : le client obtient une copie d’un message, le traite puis demande la suppression de ce message.

·       Le BLOG permet à plusieurs clients d’attendre sur la même boite afin de réaliser des traitements concurrents.

·       Le BLOG permet d’obtenir « immédiatement » un message en attente ou un indicateur signalant que la boîte aux lettres est vide.

·       Le BLOG fournit un service d’identification LDAP.

·       Le BLOG associé à AGIL permet le cryptage des mot de passe depuis l’interface graphique jusqu’au pilote LDAP.

·       Le BLOG peut utiliser les files de messages (Message Queue Unix) pour transmettre une copie de chaque message entrant. Il faut que l’application s’abonne sur la ou les boites qui l’intéresse.

·       Le BLOG est ouvert : son API permet la réalisation de pilotes pour accéder à des services (Identification LDAP, recherche et modification LDAP, lecture et écriture sur un port série, écriture sur un port parallèle, …).

·       La réalisation d’une action nécessite entre 1,2 et 10 millisecondes suivant le système et sa charge.

·       Le BLOG fournit des outils d’administration disponibles au niveau de la ligne de commande et au niveau de la librairie.

·       Le BLOG fournit une interface au niveau de la ligne de commande. Il est possible d’émettre ou de recevoir des messages depuis un script shell.

·       Le BLOG permet de lancer des applications en mettant tout l’environnement nécessaire en place.

·       La librairie constituant la couche de liaison avec le BLOG est fournie sous forme de librairie partagée.

·       La fonction de liaison avec le BLOG dispose de paramètres supplémentaires afin de supporter les extensions futures.

 

Le BLOG est à la norme « UNIX 98 » et s’appuie sur les couches de transport standard « TCP / IP ».

Schéma

 

 

Opérations

Activation

Le BLOG est un service intégré au niveau système : il est activé automatiquement au démarrage.

Ressources

Le BLOG fonctionne à la demande en mode temps-réel.

 

Le BLOG utilise un port TCP. Ce port est indiqué dans le fichier « /etc/services ». Le nom du service est « blog ».

Le BLOG utilise les « sockets » des domaines « local » et « inet » pour communiquer.

Le BLOG utilise uniquement la mémoire et le disque pour le stockage des messages.

Le BLOG utilise un tableau de sémaphore pour garantir la synchronisation entre BLOG et les applications et d’assurer l’unicité du numéro de chrono lors de dépose dégradée.

 

Suivant la configuration choisie, le BLOG peut utiliser les files de messages (Message Queue) pour permettre un abonnement et un segment de mémoire partagée pour les traces systèmes et des applications.

 

Le BLOG doit être lancé par un utilisateur particulier : « blog ». Ce compte ne doit pas être utilisé à d’autre fin.

 

Sous Windows, le BLOG utilise une variable d’environnement BLOG. L’environnement des applications doit contenir cette variable ou les applications doivent indiquer le répertoire de base du BLOG afin de permettre une dépose dégradée.

 

Application

Une application est connecté automatiquement au BLOG lors de l’émission de son premier message.

La liaison peut être interrompue à la demande de l’application ou - si l’architecture logicielle utilisée le permet - lorsque l’application se termine. Dans tous les cas le BLOG contrôle l’état des connexions et supprime si nécessaire les liaisons «orphelines».

Même en l’absence du BLOG, l’émission d’un message ayant l’attribut « dépose dégradée » est assurée.

 

Message

Une application émet un message à destination d’une boite aux lettres sur une machine désignée explicitement ou implicitement (dans ce cas, il s’agit de la machine locale).

Une application demande à recevoir le premier message disponible sur une des boites aux lettres qu’elle a indiquée.

Trois types de messages existent : les messages lent, normaux et urgents.

L’ordre des messages est respecté uniquement dans le cas des messages normaux. Le dernier message urgent reçu par le BLOG est placé en tête de la liste des messages disponibles.

Un message lent est transmis lorsque aucun autre message est à transmettre.

Des pièces-jointes peuvent êtres attachées à un message.

 

Actions

Les actions représentent les possibilités de l’application.

SEND

Envoi d’un message au format décrit précédemment. Le destinataire est indiqué par le paramètre «blog_dest». Il est possible de se poster un message à soi‑même.

SEND_URGENT

Même fonctionnement qu’en utilisant la commande «SEND» mais le message est envoyé en mode urgent.

Un indicateur est positionné lors de la réception du message pour indiquer que ce message a été émis en mode urgent.

SEND_SLOW

Même fonctionnement qu’en utilisant la commande «SEND» mais le message est envoyé en mode lent.

Un indicateur est positionné lors de la réception du message pour indiquer que ce message a été émis en mode lent.

RECEIVE

Retourne le prochain message d’une des boites aux lettres indiquées par le demandeur.
L’application peut indiquer un délai d’attente. Ce délai est exprimé en secondes et en microsecondes.
Il est possible d’indiquer une réponse immédiate ou une attente infinie. Si aucun message n’est disponible, dans le premier cas l’application reçoit un code indiquant que la boîte aux lettres est vide, dans le deuxième cas, l’application est «bloquée» en réception.
Si ce message à déjà fait l’objet d’une lecture non destructive, un indicateur est positionné pour le signaler.

PEEK_FIRST

Fonctionnement en mode transactionnel: même fonctionnement que la commande «RECEIVE», mais il s’agit d’une consultation et non d’une lecture destructive. Le message est marqué comme consulté. La commande «PEEK_FIRST» fournit toujours le premier message de la boîte. Le message est supprimé avec la commande «DELETE».

PEEK_NEXT

Fonctionnement en mode transactionnel: même fonctionnement que la commande «PEEK_FIRST», mais fournira le prochain message non encore consulté. Le message est marqué comme consulté. Le prochain appel de la commande «PEEK_NEXT» fournira le prochain message non encore consulté.
Cette commande permet de réaliser des applications concurrentes, de consulter les messages en attente.

PEEK_RESET

Fonctionnement en mode transactionnel: supprime l’indicateur de consultation sur tous les messages de la ou des boites aux lettres indiquées.
Appel synchrone.

CLEAR

Suppression de tous les messages en attente sur une boite aux lettres.
Appel synchrone.

CLOSE

Fermeture de la liaison avec le BLOG. A employer impérativement dans le cas de l’utilisation du BLOG à travers une architecture à 3 niveaux (par exemple Universe). Cette commande libère aussi toute la mémoire allouée par la librairie.

DELETE

Fonctionnement en mode transactionnel: détruit le message indiqué parmi les messages consultés précédemment avec une des commandes transactionnelles «PEEK_FIRST» ou «PEEK_NEXT».
Appel synchrone.

DELETE_FORCE

Fonctionnement en mode transactionnel: détruit les messages indiqués.
Appel synchrone.

COUNT

Retourne le nombre de messages contenu dans la boîte aux lettres indiquée.
Appel synchrone.

SEND_ALARM

Même fonctionnement qu’en utilisant la commande «SEND» mais la délivrance du message est retardée. Le champ «BLOG_alarm» indique la date d’échéance du message. Cette date peut être indiquée soit en absolue avec le champ «blog_alarm_date», soit en relatif avec le champ «blog_alarm_delay». Le destinataire est indiqué par le paramètre «blog_dest». Il est possible de se poster un message à soi‑même.
Le message peut être supprimé ou consulté avant l’expiration du délai d’attente avec, respectivement, les commandes suivantes : «DELETE_ALARM» ou «PEEK_ALARM».
Une fois, le délai d’attente expiré, le message est ajouté à la boite aux lettres du destinataire.

SEND_ALARM_URGENT

Même fonctionnement qu’en utilisant la commande «SEND_ALARM» mais le message est envoyé en mode urgent.

Une fois, le délai d’attente expiré, le message est ajouté à la boite aux lettres du destinataire après les messages urgent.

Un indicateur est positionné lors de la réception du message pour indiquer que ce message a été émis en mode urgent.

DELETE_ALARM

Cette commande permet de supprimer un message envoyé avec un délai de rétention avant ou après l’expiration de ce délai. Il suffit d’indiquer le numéro de swap du message. Le message à supprimer doit avoir été émis avec une des commandes suivantes «SEND_ALARM» ou «SEND_ALARM_URGENT».
Appel synchrone.

PEEK_ALARM

Cette commande permet de consulter un message envoyé avec un délai de rétention avant l’expiration de ce délai. Il suffit d’indiquer le numéro de swap du message. Le message à supprimer doit avoir été émis avec une des commandes suivantes «SEND_ALARM» ou «SEND_ALARM_URGENT».
Le message est marqué comme consulté. La commande «PEEK_NEXT» ne le prendra donc pas en compte. Le message est supprimé avant l’expiration du délai avec la commande «DELETE_ALARM» et après l’expiration avec la commande «DELETE».

CLEAR_ALARM

Suppression de toutes les alarmes en attente sur une boite aux lettres.
Appel synchrone.

LOCK_MAILBOX

Cette commande permet de verrouiller une ou plusieurs boites aux lettres (voir Nom de boîtes aux lettres – page : 21). Si le destinataire est unique et si la boîte aux lettres n’existe pas, elle est créée et verrouillée.
Fonctionnement de type sémaphore binaire.
Appel synchrone.

UNLOCK_MAILBOX

Cette commande permet de verrouiller une ou plusieurs boites aux lettres (voir Nom de boîtes aux lettres – page : 21).
Fonctionnement de type sémaphore binaire.
Appel synchrone.

CLOSE_RCV

Cette commande permet de supprimer des demandes de réception d’une ou de plusieurs boites aux lettres (voir Nom de boîtes aux lettres – page : 21).
Cette commande entraîne la fermeture des lignes associées et la transmission à l’application du code BLOG_EKILL.

Administration

Configuration système

/etc/services

Ce fichier doit contenir le nom et le numéro associé pour le service « blog ». Ce numéro doit être le même sur toutes les machines. Ce numéro doit être supérieur à 1024.

Pour utiliser les pièces jointes, il faut aussi indiquer le numéro du service « blog_ftp ». Ce numéro doit respecté les règles précédemment décrites.

/etc/hosts

Si ce fichier est utilisé (pas de DNS par exemple), la boucle locale (loopback) ne doit pas contenir le nom de la machine.

 

 

Le compte « blog »

 

Le BLOG doit être lancé par un utilisateur particulier : « blog ». Ce compte ne doit pas être utilisé à d’autre fin. Ce compte doit fournir une session de type « UNIX 95 » ou « UNIX 98 ». C’est le cas par défaut sur la plupart des systèmes.

 

Le shell doit être POSIX (1993) [ksh : Version M 1993-12-28 m+].

 

Particularité :

HP-UX 10 ne fournit pas par défaut une session « UNIX 95 ».

Pour configurer une session « UNIX 95 », l’utilisateur doit définir dans l’environnement la variable UNIX95 et la variable d’environnement PATH doit contenir l’entrée /usr/bin/xpg4 avant les entrées /bin et /usr/bin.

Par exemple, ce fichier .profile active l’environnement « UNIX 95 ».

UNIX95=

export UNIX95

PATH=/usr/bin/xpg4:/bin:/usr/bin

export PATH

 

HP-UX 11 ne fournit pas par défaut une session « UNIX 95 ».

Pour configurer une session « UNIX 95 », l’utilisateur doit définir dans l’environnement la variable UNIX95.

Par exemple, ce fichier .profile active l’environnement « UNIX 95 ».

UNIX95=

export UNIX95

 

Pour simplifier l’écriture des applications, il est recommandé de respecter les consignes suivantes :

·         Tous les utilisateurs doivent avoir dans leur environnement la variable « BLOG ». Il faut insérer dans le fichier « /etc/profile ».

BLOG=/home/blog/BLOG

export BLOG

·         Le répertoire « /tmp » doit exister.

 

Un programme d’installation réalise automatiquement toutes les opérations nécessaires.

 

Lancement et arrêt du BLOG

 

Le BLOG peut être lancé directement, avec le script « blog.sh » ou le script « blog_ctrl.sh » (voir administration du BLOG).

 

Le BLOG peut être lancé automatiquement au démarrage de la machine. Le script « blog_setup.sh » permet de réaliser les opérations nécessaires pour les systèmes de démarrage de type System V ou de type BSD. Ce script est dans le répertoire contenant les sources du BLOG.

 

 

BLOG

 

Options de la ligne de commande :

-d <trace level>    niveau de trace (par défaut : 0)

-t <trace type>     type de trace (par défaut : SYSLOG)

-c <base file name> nom de base des fichiers de configuration (par défaut : BLOG)

-S                  active les statistiques (par défaut : inactif)

-r                  recouvrement des erreurs lié à un arrêt brutal du BLOG (par défaut : inactif)

-R                  recouvrement automatique des erreurs lié à un arrêt brutal du BLOG (par défaut : inactif)

-l                  utilisation de « syslog » pour stocker les messages d’erreurs et les messages de trace (par défaut : inactif).

-n                  démarrage en « non-démon » (par défaut : inactif).

-L                  démarrage en mode local (lock) (par défaut : inactif).

-C                  fonctionnement par défaut sur réception de SIGSEVG (par défaut : interception).

 

 

Le BLOG peut être arrêté directement ou avec le script « blog.sh » (voir administration du BLOG).

Attention, si le script « blog_ctrl.sh » est actif, il faut d’abord arrêter ce script.

Pour réaliser un arrêt logiciel, if faut soit envoyer un message d’arrêt via la librairie, soit envoyer le signal SIGTERM (15) au BLOG, soit utiliser la commande « BLOG_ADM –c STOP ».

Le BLOG, à son tour, envoi le signal SIGTERM aux programmes indiqués dans le fichier de configuration.

 

Le BLOG indique via le syslog, les événements marquant (erreur, anomalie, …) :

 

BusLogiciel: Demarrage du blog 2.0.4 (Soleil) [Rel] 31/05/2001 [basename :blog user :blog key :B] pid 602

BusLogiciel: Chargement chrono:5131288 swap:5158200

BusLogiciel: Load event (L) ...

BusLogiciel: Load event (L) ...

BusLogiciel: Load event (D) ...

BusLogiciel: Load event (S) ...

BusLogiciel: Load event (W) ...

BusLogiciel: Load event (T) ...

BusLogiciel: BLog ready ...

...

BusLogiciel[602]: BLOG: Receive SIGTERM

BusLogiciel[602]: BLOG: stopping

BusLogiciel[602]: Depose chrono:5132764 swap:5159676

BusLogiciel[602]: BLOG STOP

Administration du BLOG (blog.sh et blog_ctrl.sh)

 

Le script « blog.sh » permet de réaliser facilement les opérations d’administration de base du BLOG.

 

Le script « blog_ctrl.sh » surveille BLOG de manière active ou passive afin de le relancer si nécessaire.

 

blog.sh

 

Paramètre de la ligne de commande :

start               démarrage du BLOG avec un recouvrement si nécessaire

stop                arrêt du BLOG via l’envoi du signal SIGTERM

restart             arrêt suivi d’un démarrage du BLOG

no_recovery         démarrage du BLOG sans recouvrement

recovery            démarrage du BLOG uniquement après un arrêt anormal

auto_recovery       démarrage du BLOG avec un recouvrement si nécessaire

start_syslog        démarrage du BLOG avec un recouvrement si nécessaire.
Les traces BLOG sont envoyés à
syslog.

hup                 demande de libération de la mémoire inutilisée du BLOG via l’envoi du signal SIGHUP

local               demande au BLOG de ne pas émettre ou recevoir des appels à destination ou provenant d’une autre machine

start_local         démarrage du BLOG avec un recouvrement si nécessaire et fonctionnement en mode local (cf local)

network             permet au BLOG d’émettre ou de recevoir des appels à destination ou provenant d’une autre machine

info                permet d’obtenir des informations systèmes relatives au  BLOG (n° de version, options, date, …)

info_all            identique à info. Fournit en plus des informations sur les ressources systèmes utilisées.

stat                permet d’obtenir des informations systèmes relative au BLOG et la liste des boîtes aux lettres statistiques pour chaque destinataires (nombre et volume des messages en attente).

stat_all            identique à stat. Fournit en plus des informations sur chaque messages en attente.

remove_shm          supprime la mémoire partagée.
Ne pas utiliser avec le BLOG actif.
Permet essentiellement de redimensionner la taille de la mémoire partagée.

remove_ipc          supprime les sémaphores et la mémoire partagée.
Ne pas utiliser avec le BLOG actif.
Permet essentiellement de redimensionner la taille de la mémoire partagée.

 

Avant le démarrage, les programmes auxiliaires encore en activité (suite à un arrêt anormal) sont supprimés.

 

Exemple d’utilisation de « blog_ctrl.sh » dans le fichier rclocal

# Supprime le fichier contrôle par blog_ctrl.sh pour se protéger

# d'un arret hard de BLOG.

[ -f /tmp/blog/BusLogiciel ] && rm -f /tmp/blog/BusLogiciel

su - blog -c "nohup /home/blog/BLOG/BIN/blog_ctrl.sh
                      >/tmp/blog/blog_ctrl.log 2>&1 &"

#

Administration

L’administration est réalisée à travers les API de communication standard du BLOG.

Le message doit être destiné au BLOG (BusLogiciel).

Le champ (blog_admin).doit contenir une des commandes suivantes :

STOP                         arrêt logiciel du BLOG

STAT                         production des statistiques générales. Il faut indiquer le nom de l’émetteur (blog_source).

STAT_ALL                 production des statistiques détaillées. Il faut indiquer le nom de l’émetteur (blog_source).

PURGE                       Suppression de tous les messages à émettre destinés à une boite aux lettres locale ou distante. Permet aussi de supprimer tous les messages pour une destination donnée. Il faut indiquer le nom complet de la boite aux lettres (blog_source).

INFO                         Obtention des informations systèmes relatives au BLOG (n° de version, options, date, …). Il faut indiquer le nom de l’émetteur (blog_source).

INFO_ALL                 Identique à INFO, mais fournit en plus l’usage des ressources systèmes.

TRACE_LEVEL           Changement du niveau de trace du BLOG. Il faut indiquer le nouveau niveau de trace (zéro : pas de trace) (blog_blog_trace).

TRACE_TYPE             Changement du type de trace du BLOG. Il faut indiquer le nouveau type de trace (zéro : pas de trace, -1 toutes les traces) (blog_blog_trace).

LOCK                         Demande au BLOG de ne pas émettre ou recevoir des appels à destination ou provenant d’une autre machine.

UNLOCK                     permet au BLOG d’émettre ou de recevoir des appels à destination ou provenant d’une autre machine.

START_LOG               Demande au BLOG de consigner dans le fichier ($BLOG/BIN/blogstat) le suivi des transactions.

STOP_LOG                 Demande au BLOG d’arrêter de consigner le suivi des transactions.

FLUSH_LOG               Demande au BLOG de renommer le fichier courant et d’en commencer un nouveau. Les fichiers renommés ont comme extension un entier positif.

 

Les dates sont affichées avec le fuseau horaire.

 

Fichier de configuration

 

Par défaut, le fichier utilisé se nomme : $BLOG/CONFIG/BLOG.cfg

Pour indiquer un autre fichier de configuration, utilisez l’option –c de la ligne de commande.

 

Format du fichier :

Une ligne vide ou commençant par un des caractères suivants ‘#’ ou ‘;’ est ignoré (commentaire).

 

Tous les paramètres ont une valeur par défaut.

 

Une fois la configuration chargée, le fichier $BLOG/CONFIG/BLOG.cur contient la configuration courante.

 

 

Exemple :

;

;    BLOG.cfg

;    Yves Crespin - Quartz

;

 

# Parfois gethostbyname() ne répond que sur timeout.

# Celui de gethostbyname() doit être de 4 minutes.

# en secondes

# 1 minute

MX_GETHOSTBYNAME_DELAY      60

 

## --MESSAGE

# SWAP

# 20 mo

SWAP_HMEM          20971520

# en secondes (1 heure)

SWAP_HDELAY             3600

# en secondes (1/2 heure)

SWAP_SDELAY             1800

# 8 ko

SWAP_MLEN          8192

# Messages

SWAP_COUNT              20

 

#

# Ce paramètre correspond au timeout sur le select().

# Si le select() retourne sur timeout, les fifos sont nettoyés.

# Si le select() retourne avec des descripteurs à traiter,

# le ménage sera automatiquement réalisé dans les fifos par le traitement

# de la demande.

# Les messages sont stockés dans l'ordre d'arrivée, ils peuvent 'mourrir'

# dans le fifo. Ils seront supprimés au fur et à mesure.

# en secondes

MX_SLEEP           30

 

#

# Les messages qui n'ont pas pu être transmis immédiatement sont

# retransmis sur le réseau au bout de MX_QUEUE_PROCESSED secondes (5 minutes).

# Cela évite de pénaliser l'émetteur s'il existe des problèmes pour

# atteindre le destinataire.

# Sendmail réalise la retransmission au bout de 30 minutes en général (fork).

# en secondes

# 5 minutes

#    error    "MX_QUEUE_PROCESSED must be more than MX_SLEEP"

MX_QUEUE_PROCESSED      300

 

#

# Le nettoyage est réalisé si aucun événement n'est en attente ou

# si le dernier nettoyage date de plus de MX_CLEAN secondes.

# en secondes

# 5 minutes

#    error    "MX_CLEAN must be more than MX_SLEEP"

MX_CLEAN           300

 

# Nombre de boites consultées lors du nettoyage

# Pour chaque boite, MX_REMOVE_LOAD_DEEP permet de limiter la profondeur

# du nettoyage.

MX_REMOVE_REMOTE_MAILBOX    10

MX_REMOVE_LOCAL_MAILBOX     20

MX_REMOVE_RECEIVE_MAILBOX   20

 

# Profondeur d'exploration sur l'ajout d'un message

# Cette valeur doit être faible pour ne pas pénaliser la fluidité.

# Le plus souvent, le parcours sera infructueux.

MX_REMOVE_LOAD_DEEP         40

 

# Les opérations de nettoyage se font 'à temps perdu', elles

# doivent donc être efficaces mais le système doit rester réactif.

# La valeur est donc fixée assez haute pour ne servir que de garde-fou.

# C'est la durée maximale d'un nettoyage.

# en secondes

MX_CLEAN_TIME           30

 

 

#

# La suppression de la mémoire inutilisée est réalisée si aucun événement

# n'est en attente et si le dernier appel date de plus de MX_HUP_CALL secondes.

# en secondes

# 1 heure

#    error    "MX_HUP_CALL must be more than MX_SLEEP"

MX_HUP_CALL             3600

 

#

# Durée de vie des messages des boites temporaires sans durée de vie

# en secondes

# 2 minutes

MX_DEFAULT_CREDIT_ON_MAILBOX_TMP 120

 

# Nombre maximum de relance d'un driver.

MX_DRIVER_RELANCE       20

 

#

# Temps d'inactivité avant de couper une ligne.

# en secondes

MX_LOCAL_INACTIVITY         60

MX_REMOTE_INACTIVITY        60

MX_REMOTE_CLOSE             5

 

#

# Temps d'inactivité avant de supprimer une boite aux lettres

# Cette valeur doit être supérieur à seuil d'inactivité.

# Seules les boites vides sont supprimées.

# en secondes

# 10 minutes

REMOVE_EMPTY_MAILBOX_DELAY 600

 

# Temps de conservation d'un couple <@IP/Mailbox/Chrono>

# 1 an en secondes

MX_REMOTE_CHRONO_KEEP       31536000

 

#

# Temps d'attente entre une demande d'arret et l'arret.

# Cela permet de recevoir les ACK.

# En secondes

MX_WAIT_BEFORE_STOP_SEC     4

# En millisecondes

MX_WAIT_BEFORE_STOP_USEC    0

 

# Granulométrie des allocations

EVENT_GRANULO      200

PROG_GRANULO       10

SOCK_GRANULO       100

REMOTE_MSG_GRANULO 20

LOCAL_MSG_GRANULO  100

RCV_MSG_GRANULO         100

ALARM_MSG_GRANULO  100

NOADDR_GRANULO          10

REMOTE_CHRONO_GRANULO   20

 

#Taille maximum d'un message

#MSGQ_SZ_MAX       4056

#Désactive l'utilisation des messages queues

MSGQ_SZ_MAX        0

 

#Taille de la mémoire partagée utilisée pour les traces

#La mémoire partagée n'est utilisée que sous les conditions suivantes:

# - lancement de BLOG sans l'option '-l' (ell)

# - définition d'une taille supérieur à 0 (zéro)

#La taille est indiquée en kilo-octets

TRACE_SHM_SIZE          1024

#TRACE_SHM_SIZE         4096

# 16 Mo

#TRACE_SHM_SIZE         16384

# 32 Mo

#TRACE_SHM_SIZE         32768

#Désactive l'utilisation de la mémoire partagée

#TRACE_SHM_SIZE         0

 

#Bascule en mode local s’il n’existe pas de route pour atteindre la machine

#cible (absence de réseau)

LOCAL_MODE_ON_HANGUP        Yes

 

# Utilise un algorithme de séquencement

# Il faut être root.

USE_PRIORITY_SCHEDULING TRUE

# Type de séquencement SCHED_FIFO, SCHED_RR, SCHED_RR2

SCHEDULER_ALGORITHM     SCHED_RR

# Priorité de séquencement entre 0 et 31.

SCHEDULER_PRIORITY      16

 

# Si le fichier à transférer est absent, la ligne est coupée.

# Le fichier à transférer est dans le champ "blog_archive"

# Si l'option est négatif, le message est transféré sans la

# pièce-jointe avec le flag FL_APP_NOFILE (0x08).

TFTP_BLOCK_ON_MISSING_FILE TRUE

 

# Seuil de suppression de l'affichage dans les statistiques.

# Les messages sont toujours affichées via STAT_ALL.

# La valeur 0 permet de désactiver (par défaut).

MX_ALARM_ON_STAT   0

MX_RECEIVE_ON_STAT 0

MX_LOCAL_ON_STAT   0

MX_REMOTE_ON_STAT  0

 

# Les messages périmés sont transférés dans la poubelle.

# Celle-ci doit supprimer les pièces-jointes.

# Cette option permet d'indiquer au noyau de le faire.

REMOVE_PJ_ON_TIMEOUT    TRUE

 

#External network (/etc/networks)

EXTERNAL_NET_NAME wanadoo

 

# Fin du fichier

 

Lancement des programmes auxiliaires

 

Par défaut, le fichier utilisé se nomme : $BLOG/CONFIG/BLOG.load

Pour indiquer un autre fichier de configuration, utilisez l’option –c de la ligne de commande.

 

Le nom du fichier contenant la liste des programmes auxiliaires est indiqué dans le fichier de configuration. Ces programmes de niveau application sont lancés directement par le BLOG durant sa phase de démarrage. Lorsque le BLOG reçoit une demande d’arrêt, il envoi le signal SIGTERM aux programmes auxiliaires.

 

Un programme auxiliaire est automatiquement relancé par le système. Cette relance est notifiée dans le journal des événements.

 

En cas de modification du fichier de configuration, il est nécessaire de relancer le BLOG afin que les modifications soient prises en compte (Voir administration du BLOG).

 

Format du fichier :

Une ligne vide ou commençant par le caractère ‘#’ est ignoré (commentaire).

Chaque ligne est exécutée. Il est possible d’utiliser les guillemets pour grouper des arguments.

Si le programme est indiqué avec un chemin relatif, le répertoire est $BLOG/BIN.

 

Les programmes auxiliaires :

Ces programmes sont de niveau application. Ils utilisent uniquement la librairie du BLOG.

Ces programmes sont fournis en standard. Ils peuvent être remplacés par des modules tiers.

Les programmes auxiliaires fournis en standard ne sont pas conçu pour réaliser des accès concurrents sur une même boite aux lettres.

 

Listes des programmes auxiliaires :

BLOG_LSEARCH        Recherche dans un annuaire LDAP.

BLOG_MODIFY         Modification de l’annuaire LDAP.

BLOG_TRASH          Récupération des messages mal formés ou périmé.

BLOG_LOGIN          Vérifie la validité d’un DN et d’un mot de passe.

BLOG_SERIE          Liaison avec un port série.

BLOG_PARALLEL       Liaison avec une imprimante parallèle (Version Linux uniquement).

 

Exemple :

#####

# Syntaxe pour le lancement des programmes:

#<nom du programme>[ <parametres de la ligne de commande>]

#Le programme doit figurer dans le répertoire $BLOG/BIN

#Le répertoire courant du programme est $BLOG/BIN

#

BLOG_TRASH "-d 3" -~ "-t Poubelle.msg" "-n Poubelle"

#

BLOG_LOGIN "-d 3" -c "-n LOGIN" "-h ADMIN DEV COM"

#

BLOG_LSEARCH "-d3" -c "-n LSEARCH" "-h ADMIN DEV COM"

#

BLOG_MODIFY -c "-d 3" "-n LDAP-MODIFY" -- "ldapmodify" "-hADMIN -D'uid=admin,o=Groupe SKALLI, c=fr'" -wxxx

#

BLOG_SERIE "-d 3" "-n SERIE-COM1" -D/dev/ttyS01 -B38400 -e10 -p1 -r

 

#

BLOG_PARALLEL "-d 3" "-n LP1" -D/dev/lp1 –Cprinter.def

#####

 

Emplacement des fichiers

Binaire

$BLOG/BIN                   exécutable du BLOG et programmes auxiliaires

 

Configuration

$BLOG/CONFIG/BLOG.cfg       fichier de configuration du BLOG

$BLOG/CONFIG/BLOG.load      fichier des programmes auxiliaires du BLOG

 

Messages

$BLOG/EVT/.blog             fichier contenant les prochains numéros de chrono et de swap (format binaire 32 bits)

$BLOG/EVT/.remote           fichier contenant les derniers numéros de chrono reçus pour chaque couple boite aux lettres/machine

$BLOG/EVT/.mailbox          fichier contenant les boites aux lettres verrouillées

$BLOG/EVT/S.*               messages à destination d’une boite locale

$BLOG/EVT/W.*               messages à destination d’une boite distante

$BLOG/EVT/T.*               messages à destination de la boîte locale « Poubelle »

$BLOG/EVT/X.*               messages incorrects (taille ou format)

$BLOG/EVT/L.*               messages à destination d’une boite locale.
Dépose dégradée.

$BLOG/EVT/D.*               messages à destination d’une boite distante.
Dépose dégradée.

$BLOG/BIN/Poubelle.msg      contient les messages périmés (voir « Gestion des messages périmé »)

 

PID

/tmp/blog/.blog.pid         contient le PID du BLOG
Si le répertoire /tmp n’existe pas ou n’est pas valide, la variable d’environnement TMPDIR est utilisée.

 

Socket locale

/tmp/blog/BusLogiciel       pseudo-fichier représentant la socket locale
Si le répertoire /tmp n’existe pas ou n’est pas valide, la variable d’environnement TMPDIR est utilisée.

 

Le nom de la racine varie suivant le système d’exploitation « / » sous UNIX, « E:/NuTCRACKER » sous « NuTCracker », …

 

Librairie

/usr/local/lib/libblog.so.2 librairie partagée version 2
Le répertoire est indicatif

/usr/local/lib/libblog.so   librairie partagée courante
Le répertoire est indicatif

 

L’extension des librairies partagées varie suivant le système d’exploitation « .sl » sous HP-UX, « .so » sous « Linux, Solaris », …

 

 

Attention : si le répertoire /tmp n’existe pas, le BLOG utilise le répertoire indiqué par la variable d’environnement TMPDIR.

 

Attention : le répertoire $BLOG/EVT doit avoir le mode 1777 afin de permettre la dépose dégradée.

 

Attention : le répertoire /tmp/blog doit avoir le mode 777 afin de permettre la connexion des clients.

 

Attention : les fichiers de type ‘X’ ne sont plus gérés par le BLOG.
Ces fichiers sont uniquement causés par ‘une absence d’espace sur le périphérique’, par ‘une taille maximale de fichier’ ou par ‘format incorrect ou incohérent’.
Après analyse, ils doivent être supprimés par l’administrateur système.

 

Description technique

Format d’un message

Un message est composé deux parties : une zone texte formaté et une zone binaire optionnelle.

La zone texte du message est constituée d’une suite de ligne. Le séparateur de ligne est la caractère «Line-Feed». La première ligne vide indique la fin de la zone texte.

La zone texte respecte la syntaxe suivante :

<libellé> : <valeur>

Un libellé contient n’importe quel caractère à l’exception du séparateur de libellé et du séparateur de ligne.

Une valeur contient n’importe quel caractère à l’exception du séparateur de ligne.

 

Il est possible de définir des couples libellé-valeur par défaut.

Les libellés peuvent être en majuscules ou minuscules.

 

La zone binaire du message contient n’importe quelle suite de caractère.

La taille maximale d’un message est de 4294967252 (entier non signé sur 4 octets).

 

Un message à une durée de vie exprimée en secondes. Cette durée de vie peut être illimitée.

Paramètres d’appel obligatoire

blog_dest

Destinataire : nom de la boite aux lettres. Pour indiquer une boite aux lettres sur une machine distante, il faut respecter la syntaxe Internet : « @machine.network ». Le nom de la boite aux lettres ne doit pas contenir le caractère « @ » car celui-ci est systématiquement pris comme séparateur.

Dans le cas d’une demande d’émission, le paramètre « blog_dest » indique le destinataire.

Dans le cas d’une demande de réception, le paramètre « blog_dest » indique la liste des boites aux lettres dont l’application souhaite recevoir les messages. Dans le cas d’une demande de réception, il est possible d’indiquer uniquement le début du nom d’une boite aux lettres en utilisant le caractère jocker « * » et/ou d’indiquer la liste des boîtes aux lettres (voir Nom de boîtes aux lettres – page : 21).

Informations complémentaires

Une zone de 8 bits est mise à la disposition de l’application. Cette zone peut permettre de qualifier les messages ou d’ajouter des informations complémentaires afin de permettre un aiguillage immédiat des messages avant même de traiter le message.

 

 

Nom de boîtes aux lettres

 

Le nom du destinataire correspond au nom de la boîtes aux lettre. Il est indiqué dans le champ « blog_dest ».

 

Pour indiquer une boite aux lettres sur une machine distante, il faut respecter la syntaxe Internet : « name@machine.network ».

 

Dans le cas d’une demande d’émission, le paramètre « blog_dest » indique le destinataire.

Dans le cas d’une demande de réception, le paramètre « blog_dest » indique la liste des boites aux lettres dont l’application souhaite recevoir les messages. Dans le cas d’une demande de réception, il est possible d’indiquer uniquement le début du nom d’une boite aux lettres en utilisant le caractère jocker « * » et/ou d’indiquer la liste des boîtes aux lettres. Le séparateur de boîtes est le caractère « ; ».

 

Une boîte aux lettre temporaire doit impérativement commencer par le caractère « ~ ». Ce type de boîte doit être utilisé pour recevoir une réponse à une demande ponctuelle (par exemple : une recherche dans l’annuaire). Ce type de boîte ne permet ni l’utilisation du caractère jocker, ni l’indication de plusieurs boîtes aux lettres.

Lorsqu’un message destiné à une boîte temporaire est périmé, il est transmis à l’application gérant la poubelle qui – par défaut – le supprime.

 

Gestion des adresses IP

 

Il est possible d’indiquer dans le champ « blog_dest » le nom de la boite aux lettres suivi du nom de la machine cible. S’il n’y a pas de machine cible, c’est une demande locale.

Le séparateur entre le nom de la boite aux lettre et le nom de la machine est le caractère « @ ».

 

Adresse IP

Si le nom de la cible est une adresse IP, un contrôle est réalisé pour vérifier l’existence de cette adresse avant l’émission du message vers le BLOG. Le message est transmis au BLOG avec un indicateur « ADDR_IP » signalant la présence d’une adresse IP.

 

Nom de machine

Si le nom de la cible n’est pas une adresse IP, un contrôle est réalisé pour vérifier l’existence de cette machine avant l’émission du message vers le BLOG.

Si un nom de machine peut être une adresse valide – par exemple « 0 », il est considéré comme une adresse. Dans ce cas, si cette adresse n’est pas connue du DNS ou ne figure pas dans le fichier « /etc/hosts », la demande d’émission est refusée.

Si le nom est inconnue, l’indicateur « NO_ADDR » est positionné pour signaler la non résolution du nom, dans ce cas c’est le BLOG qui régulièrement essaye de résoudre cette adresse afin de pouvoir transmettre le message.

 

Vérifie l’adresse IP d’une machine

Avant d’établir une voie de communication vers une machine, le nom de cette machine est contrôlé. Si l’adresse IP obtenue est différente de celle contenue dans le message, tous les messages ayant la même adresse IP sont mis à jour.

 

Cas d’ouverture d’une voie de communication vers une machine

Il existe deux cas nécessitant l’ouverture d’une voie de communication vers une machine :

-          aucune voie n’existe vers cette machine,

-          demande de transfert de fichier vers cette machine.

 

Cas de fermeture d’une voie de communication vers une machine

Il existe trois cas de fermeture d’une voie de communication vers une machine :

-          coupure « involontaire » de ligne (erreur sur la ligne, coupure par l’autre extrémité, perte de porteuse, …),

-          coupure « volontaire » de ligne au bout de 6 minutes d’inactivité

-          fin du transfert d’un fichier vers une machine.

 

Les pièces jointes

Principe

L’application indique la liste des fichiers qu’elle souhaite transmettre, la fonction de transfert des messages réalise une archive compressée auto-extractible et indique le nom de cette archive comme fichier associé. Le BLOG transmet le fichier associé sur la machine cible et en demande l’exécution. Une fois que le fichier associé est sur la machine cible, le BLOG transmet le message.

Une fois les pièces jointes traitées, les scripts associés seront exécutés.

 

Pour être sûr de l’emplacement des fichiers sur la machine cible, il est préférable d’indiquer les noms des fichiers en absolu.

 

Lors de la dépose d’une pièce-jointe, le driver BLOG_FRCV doit avoir les droits d’écriture dans le ou les répertoires concernés. Pour garantir ce fonctionnement, le driver BLOG_FRCV appartenir à root peut avoir le SETUID positionné ou le compte blog à un UID à 0.

 

Un message contenant une ou plusieurs pièces jointes a l’indicateur « PIECE_JOINTE (0x04) » positionné.

 

Si le fichier à transférer est absent, le message est acheminé vers son destinataire avec un indicateur « NOFILE (0x08) ».

 

Le champ « blog_file_src » contient la listes des fichiers sources. Si un de ceux-ci n’existe pas au moment de l’appel le code erreur « BLOG_EINVAL » est retourné. Ce contrôle est réalisé lors de l’affectation du champ et avant la transmission du message.

 

Si la champ « blog_file_dest » n’est pas renseigné, le nom des fichiers de destination seront inchangés.

Si la champ « blog_file_dest » n’a pas le même nombre d’élément que le champ « blog_file_src » au moment de la transmission du message le code erreur « BLOG_EINVAL » est retourné. La correspondance entre les champs « blog_file_src » et « blog_file_dest » est basée sur la position respective dans chacun des champs.

Si le ou les répertoires indiqués dans le champ « blog_file_dest » n’existent pas, ils sont créés avec la permission O777.

 

Le champ « blog_file_add » contient la liste des scripts additionnels. Ces scripts sont exécutés un à un après la mise en place des pièces jointes. Les scripts associées qui ne sont pas exécutables sont lu par la commande « /bin/sh ».

Attention : le BLOG ne réalise aucune redirection.

Affectation

Les informations doivent être transmissent en utilisant le séparateur d’éléments de liste. Le séparateur d’éléments de liste peut-être modifié à tout moment par l’application. Ce séparateur est par défaut le caractère ‘|’.

Configuration

Le fichier $BLOG/CONFIG/BLOG.load doit contenir la ligne suivante :

BLOG_FRCV <path du répertoire contenant la version GNU de cpio>

 

Il est possible de vérifier le fonctionnement avec la commande :

telnet <machine> blog_ftp

Remarques

Les pièces jointes sont transmises compressées.

Pour les fichiers de type « lien symbolique », c’est le fichier pointé qui est copié.

Dans la version courante de la librairie et uniquement pour les machines distantes, les scripts additionnels ne doivent pas contenir le caractère 0x00.

 

Liste des programmes annexes utilisés lors de la création de l’archive :

$BLOG/BIN/blog_archive.sh, cpio, echo, gzip, uuencode

 

Liste des programmes annexes utilisés lors de la création de l’archive :

cpio, cat, uudecode, gzip, rm

 

Attention : si les pièces jointes doivent être renommées sur la machine cible, la version de cpio doit supporter l’option --rename-batch-file.

La version GNU cpio version 2.4.2 la supporte. Cette version est fournie avec le BLOG.

Si la version du constructeur ne supporte pas cette option, il faut installer la version GNU dans le répertoire $BLOG/BIN et indiquer à la commande BLOG_FRCV le nom de ce répertoire.

blog_ftp … blog /home/BLOG/BIN/BLOG_FRCV BLOG_FRCV /home/BLOG/BIN

 

Message urgent

 

Un message émis en mode urgent a l’indicateur « URGENT (0x01) » positionné.

 

Le dernier message urgent reçu par le BLOG est placé en tête de la liste des messages disponibles. Les messages urgents ne sont pas conservés dans l’ordre d’émission : le plus récent est le plus prioritaire.

Les messages urgents doivent être exclusivement réservés à des messages de services ou des acquittements de niveau application.

 

Un message urgent émis avec un délai de rétention est, une fois le délai expiré, placé après le dernier message urgent.

 

Message lent

 

Un message émis en mode lent a l’indicateur « SLOW (0x20) » positionné.

 

Le message lent - comme le message normal - reçu par le BLOG est placé en fin de la liste des messages. Les messages lents sont conservés dans l’ordre d’émission, mais pour une même boite aux lettres, un message lent peut arriver après un message normal.

Le message lent n’a réellement de sens qu’à destination d’une machine distante. Dans ce cas, il sert de balise garantissant que les messages émis avant lui ont bien été transmis.

Si une message comporte une pièce-jointe, la boite aux lettres correspondante sera bloquée en attendant la fin de transmission de la pièce-jointe. Durant ce temps, BLOG cherche à transmettre un message destiné à une autre boite aux lettres. Un message lent ne bénéficie pas de ce traitement.

 

 

Message avec un délai de rétention : alarme

 

Un message émis avec un délai d’attente a l’indicateur « ALARM (0x10) » positionné.

 

La date de mise à disposition du message est indiqué dans le champ système « BLOG_alarm ». Ce champ est au format de date UNIX. Pour le renseigner, il faut soit indiquer dans combien de temps le message doit être mis dans la boite aux lettres du destinataire avec le champ « blog_alarm_delay », soit indiquer la date de délivrance dans le fuseau horaire local avec le champ « blog_alarm_date ».

 

En mode relatif, voici la liste des commutateurs :

a A              année

M                mois

j J              jour

h H              heure

m                minute

s S              seconde

 

En mode absolu, voici le format de la date avec la date sur 4 positions :

jj/MM/aaaa hh:mm:ssa

 

Par exemple, un délai de 1 mois et 1 jour :

blog_alarm_delay=1M 1j

 

Par exemple, un délai de 1 heure :

blog_alarm_delay=1h

 

Par exemple, une échéance le 2 juillet 2000 à 13 heures précise :

blog_alarm_date=2/7/2000 13:00:00

 

Par exemple, une échéance le 100ème jour de l’année 2000 à 13 heures précise :

blog_alarm_date=100/1/2000 13:00:00

 

 

Un message échu est ajouté dans la boite aux lettres du destinataire comme s’il venait d’arriver. Le message est donc placé en queue de la liste des messages disponibles.

Si le message a, en plus l’indicateur urgent, il est ajouté après les autres messages urgents et avant le premier message non-urgent.

 

Il est possible de supprimer des alarmes avec la commande :

BLOG_SHELL –c clear_alarm –D <nom de la boite aux lettres>

 

 

Mode transactionnel

 

Ce mode permet d’affranchir l’application du stockage du message.

La commande «PEEK_FIRST» permet de consulter le premier message de la boîte aux lettres.

La commande «PEEK_NEXT» permet de consulter le premier message non déjà consulté de la boîte aux lettres.

 

Une fois que l’application a terminé le traitement d’un message, elle peut en demander la destruction par la commande «DELETE» en indiquant dans le champ «blog_dest» le nom de la boite aux lettres et dans le champ «blog_swap» le numéro de swap du message à supprimer.

 

En supprimer l’indicateur de consultation des messages d’une boîte aux lettres, l’application doit émettre la commande «PEEK_RESET». Le prochain appel de la commande «PEEK_NEXT» retournera le premier message de la boîte aux lettres.

 

Si la commande «RECEIVE» est utilisé alors que des messages ont été consulté, le premier message est retourné. Pour signaler que ce message à déjà été consulté, l’indicateur « PEEK (0x02) » est positionné

 

Les commandes «DELETE» et «PEEK_RESET» sont synchrones.

 

Il n’y a pas d’erreur spécifique pour la commande «PEEK_RESET».

 

La commande «DELETE» retourne en plus des codes d’erreur indiqué dans la section programmation, les codes d’erreur suivants :

BLOG_EINVAL      le chrono n'a pas fait l'objet d'une consultation

BLOG_ENOENT      le chrono ne figure pas dans la boite aux lettres du destinataire.
Cette information n’est plus remontée à l’application à cause du WorkFlow de RCL.

 

Dépose dégradée

 

Lorsque le BLOG est absent, les applications peuvent continuer à déposer des messages de manière transparente ; par contre, une demande de réception en l’absence du BLOG recevra le code erreur BLOG_ENONET indiquant l’absence du BLOG.

 

Pour permettre une dépose fichier :

·         l’option blog_depose_degradee soit être positionnée.

·         le répertoire $BLOG/EVT doit avoir le mode 1777 et appartenir au compte blog.

·         l’environnement de l’application doit contenir la variable BLOG
ou l’application doit indiquer l’emplacement du répertoire de base du BLOG avec la fonction suivante : blogset("blog_basedir","/home/blog/BLOG")
ou le nom de l’utilisateur indiqué dans la libraire est utilisé pour obtenir le répertoire de base ce celui-ci et ainsi construire le nom du répertoire de base de BLOG.

 

Les messages sont déposés sous forme de fichier dans le répertoire $BLOG/EVT.

 

Lorsque le BLOG démarre, il copie tous les fichiers déposés afin d’en être propriétaire. Lors de la copie, le BLOG change le nom du fichier. Puis le BLOG charge les messages.

 

Les portables sans carte réseau et avec une carte modem

 

Fonctionnement sans réseau

L’absence de carte réseau entraîne la suppression de la couche réseau au niveau du système d’exploitation. Les communications entre les applications et le BLOG fonctionnent normalement, mais il n’est pas possible d’émettre ou de recevoir un message à destination ou provenant d’une autre machine.

Le BLOG réalise le stockage des messages en attente.

Le BLOG réalise périodiquement un essai pour établir une liaison avec la ou les machines distantes pour lesquelles des messages sont en souffrance.

 

Opérations à réaliser lors de l’établissement d’un connexion physique

Pour BLOG, il n’y a aucune modification à réaliser.

Pour déclencher immédiatement la fonction d’établissement des liaisons avec la ou les machines distantes pour lesquelles des messages sont en souffrance, il faut émettre un message indiquant l’ouverture du BLOG vers l’extérieur :

blog.sh network

BLOG_ADM –c UNLOCK

Ou un programme utilisant la librairie de BLOG

 

 

Opérations à réaliser lors de la coupure d’un connexion physique

Pour BLOG, il n’y a aucune modification à réaliser.

Pour éviter que le BLOG ne déclenche périodiquement la fonction d’établissement des liaisons avec la ou les machines distantes pour lesquelles des messages sont en souffrance, il faut émettre un message indiquant la fermeture de BLOG vers l’extérieur ou indiquer dans la configuration « LOCAL_MODE_ON_HANGUP=TRUE ».

Le message coupe aussi immédiatement les liaisons réseau :

blog.sh local

BLOG_ADM –c LOCK

Ou un programme utilisant la librairie de BLOG

 

Opérations à réaliser pour couper au plus tôt une connexion physique

Principe de fonctionnement : avant l’établissement de la connexion, il faut envoyer un message sur la machine cible. A la réception de la réponse, il suffit de couper la ligne.

Si le programme d’établissement de la liaison est un shell script :

BOITE=PPP_$(DATE +%Y%m%d%H%M)

HOST=<nom de la machine cible>

BLOG_SHELL –c echo –S $BOITE –h $HOST -C 3600 >/dev/null

…Lancement du script de connexion …

…Attente que la liaison soit établie …

BLOG_SHELL –c receive –D $BOITE >/dev/null

…Coupure de la ligne …

 

Utilisation d’un langage interprété

 

Avec un type de langage de type interprété, il faut absolument utiliser la commande «CLOSE» afin de couper la liaison avec le BLOG. Cet appel doit être réalisé lors de l’arrêt normal ou anormal (break) du programme afin d’indiquer au BLOG l’arrêt de ce programme.

 

Fonctionnement avec UWin 3.0

UWin s’appuie sur Win32 et AST pour fournir les appels POSIX.

Le répertoire racine de UWin est identique à la racine « / » sous UNIX.

 

Les drivers parallèle et série ne sont pas disponible sous UWin.

 

La variable d’environnement « BLOG » doit être définie. Elle doit indiquer le répertoire de base du BLOG afin de permettre une dépose dégradée. La variable d’environnement peut être définie sous Windows ou sous Uwin.

 

Les répertoires suivants doivent être créés sous le répertoire indiqué par la variable d’environnement BLOG : « EVT », « BIN »

Les binaires doivent être copiés dans le répertoire « BIN ».

Le premier lancement qui suit l’installation indique l’absence du fichier « $BLOG/EVT/.blog ». C’est normal.

 

La DLL « blog » doit se trouver sous « C:\WinNT\System32 ».

Cette DLL est appelable depuis n’importe quel programme Windows : Microsoft Excel, Microsoft Word, Microsoft Visual Basic, … ou depuis n’importe quel langage de programmation.

 

Les fichiers suivants doivent être mis à jour : hosts, services.

Sous Uwin-NT, les fichiers se trouvent sous :

/sys/drivers/etc ou /etc

Sous Uwin-98, les fichiers se trouvent sous :

/sys/etc

 

Les messages destinés au « syslog » sont écrit dans le fichier suivant : « /usr/lib/syslog/log »

Si ce fichier n’existe pas, il doit être créé manuellement.

 

Pour démarrer automatiquement ajouter les lignes suivantes à la fin de /etc/rc

export BLOG=/C/Projets/Blog

$BLOG/BIN/BLOG.exe -d 1 -t -1 -R &

 

et les lignes suivantes dans /etc/stop_uwin

print Stopping Services

echo  -----------------

#

print Stopping BLog Master Service

export BLOG=/C/Projets/Blog

eval $show $BLOG/BIN/BLOG_ADM.exe -c STOP >/dev/null 2>&1

 

Pour avoir un fonctionnent standard getconf CONFORMANCE - standard

Par défaut le fonctionnement est ast

 

Il faut installer les clients pour UWin pour permettre les opérations spéciales :
/etc/ucs install [user]

 

Fonctionnement avec NutCracker

NutCracker s’appuie sur Win32 pour fournir les appels POSIX.

 

Le répertoire racine de NutCracker est identique à la racine « / » sous UNIX.

 

La variable d’environnement « BLOG » doit être définie. Elle doit indiquer le répertoire de base du BLOG afin de permettre une dépose dégradée.

 

Les répertoires suivants doivent être créés sous le répertoire indiqué par la variable d’environnement BLOG : « EVT », « BIN »

Les binaires doivent être copiés dans le répertoire « BIN ».

Le premier lancement qui suit l’installation indique l’absence du fichier « $BLOG/EVT/.blog ».

 

Les fichiers suivants doivent être mis à jour : hosts, services.

Sous NT, les fichiers se trouvent sous :

C:\WINNT\System32\Drivers\Etc

Sous Windows95, les fichiers se trouvent sous :

C:\System

 

 

Sous NT, les messages destinés au « syslog » sont écrit dans le « observateur des événement » dans le « journal des applications ».

 

Sous Windows 9x, les messages sont écrit dans le fichier suivant : « %NUTCROOT%\logs\NuTCEventLog.txt »

 

 

Construction des programmes

Pour certaines plate-formes les binaires sont disponibles.

Dans les autres cas, un script permet de réaliser la compilation et l’installation.

 

Il est nécessaire de disposer de :

-          un compilateur ANSI C

-          flex/bison ou lex/yacc

 

Programmes auxiliaires

Recherche dans l’annuaire

 

Ce module permet d’envoyer une requête au gestionnaire de la base LDAP et d’obtenir le résultat correspondant.

Si le service LDAP n'est pas accessible, le programme tente de connecter périodiquement.

 

Il est possible d’indiquer plusieurs driver LDAP dans le fichier de configuration pour traiter les demandes en parallèle.

 

Le cache LDAP fonctionne au niveau de chaque session. La coupure de la liaison avec LDAP entre la purge du cache.

 

 

Pour utiliser ce service, il faut envoyer un message contenant :

le nom du destinataire (blog_dest). Le nom de ce service est "LSEARCH" (cf. l'option -n).

le nom du programme (blog_source)

le sous-ensemble utilisé pour la recherche (blog_ldap_basedn).
Si ce champ n’est pas renseigné, la valeur par défaut est
“ ou=Responsable, o=Groupe SKALLI, c=fr ”

le filtre de recherche (blog_ldap_filter).
Ce champ doit respecter la syntaxe définie dans la RFC 1558 concernant les filtres de recherche LDAP.

La liste des attributs à retrouver (blog_ldap_attrs).
Chaque attribut doit être séparé par un espace.
Si aucun attribut est indiqué ou si ce champ est absent, la totalité des attributs est pris en compte. Facultatif

le DN complet (blog_binddn) Facultatif

le mot de passe (blog_bindpd) Facultatif

 

Si la requête réussit, le programme retourne dans le champ "blog_status" la chaîne "success"; dans le cas contraire "failed".

En cas d’échec, le champ "blog_body" contient un message d’erreur. Ce message est la description de l’erreur retournée par LDAP.

En cas de réussite, le champ "blog_body" contient le résultat de la requête.

Dans tous les cas, le champ "blog_ldap_matches" contient le nombre d’enregistrement correspondant au résultat de la requête.

 

La première ligne de chaque enregistrement correspond au DN.

Chaque enregistrement est séparé par une ligne vide.

 

La totalité du message est retourné avec la réponse à l'exception du champ "blog_binpd".

 

Options de la ligne de commande :

-d <trace level>       niveau de trace (par défaut : 0)

-t <trace type>        type de trace (par défaut : USER)

-o <trace file>        nom du fichier de trace (par défaut :l’écran)

-n <logical name>      nom logique du driver (par défaut : LDAP-SEARCH)

-c                     utilisation d’un mot de passe crypté. Le cryptage est réalisé dans le module agil

-h <host name>         ldap host (par défaut : localhost)
Il est conseillé d’indiquer toutes les machines sur lesquelles un serveur LDAP est en place. Chaque nom de machine doit être séparé par un espace. Les machines sont essayées dans l’ordre de la liste, le processus est interrompue avec la première machine pour laquelle une connexion réussie est établie

-p <port number>       ldap port

-l <time limit>        ldap time limit

-z <size limit>        ldap size limit

-i <inactivity limit>  permet de couper la liaison avec LDAP après la durée de l’inactivité indiquée. L’intérêt est de permettre le retour sur le serveur principal.

-O <wait max>          attente maximale lors de l’ouverture d’une liaison avec LDAP exprimée en secondes

-B <wait max>          attente maximale lors de l’identification LDAP (bind) exprimée en secondes

-S <wait max>          attente maximale lors d’une recherche LDAP exprimée en secondes

-R <max request>       nombre maximum de requêtes sur la même liaison

-T <time life>         durée de vie d’une requête en secondes dans le cache (-1 désactive le cache)

-M <memory max>        taille maximale du cache en bytes (0 pas de limite)

 

Ce module utilise les API LDAP (Request for Comments: 1823).

 

Gestion des messages périmés

 

Les messages périmés sont gérés comme des messages locaux. La nom de la boîte aux lettres contenant les messages périmés est « Poubelle ».

 

Options de la ligne de commande :

-d <trace level>    niveau de trace (par défaut : 0)

-x <trace type>     type de trace (par défaut : USER)

-o <trace file>     nom du fichier de trace (par défaut :l’écran)

-n <logical name>   nom de la boîte aux lettres (par défaut : Poubelle)

-t <file>           nom du fichier destiné à recevoir les messages (par défaut : $BLOG/BIN/Poubelle.msg)

-T <max file size>  taille maximale du fichier destiné à recevoir les messages (par défaut : illimité)

-~                  les messages provenant d’une boîte temporaire ne seront pas stockés dans la poubelle mais seront supprimés.

 

Fonctionnement :

Lorsque la taille maximale du fichier est atteinte, la première moitié du fichier est supprimée.

 

Format du fichier :

Chaque message commande par « CHRONO= » suivi du numéro de chrono. La ligne suivante commence par « FLAGS= » suivi de la valeur en héxadécimal des indicateurs.

La zone texte est écrite entre crochet.

La zone binaire est encadrée par une ligne contenant “ ==== ”.

Une ligne vide permet de séparer deux messages.

 

Les caractères de contrôles présents dans la zone binaires sont représentés entre crochet en notation héxadécimale.

Le premier flag indiqué correspond au premier octet du champ localflags, le deuxième flag correspond au deuxième octet. Les flags sont séparés par le caractère ‘:’.

 

CHRONO=1

SWAP=1

FLAGS=0:0x1

[BLOG_cmd=send_urgent

BLOG_dest=BusLogiciel@10.1.80.4

BLOG_admin=STAT

BLOG_timestamp=928148012

BLOG_len=12

 

]

====

message n[0xb0]1

====

 

CHRONO=2

SWAP=3

FLAGS=0:0

[BLOG_cmd=send

BLOG_dest=SERVER@linux.quartz.com

BLOG_timestamp=928148012

BLOG_len=12

 

]

====

message n[0xb0]50

====

 

 

Modification de l’annuaire

 

Options de la ligne de commande :

-d <trace level>    niveau de trace (par défaut : 0)

-t <trace type>     type de trace (par défaut : USER)

-o <trace file>     nom du fichier de trace (par défaut :l’écran)

-n <logical name>   nom logique du driver (par défaut : LDAP-DRV)

-c                  utilisation d’un mot de passe crypté. Le cryptage est réalisé dans le module agil

 

Paramètres d’accès :

Ces paramètres doit être précédés de la chaîne ‘--‘ (voir getopt())

Ces paramètres d’accès sont utilisés pour accéder à programme gérant l’annuaire. Il est nécessaire de fournir toutes les informations nécessaires.

 

Fonctionnement :

Le BLOG envoi un message à destination du driver. La zone binaire du message contient la requête.

Le driver ajoute à la fin des paramètres d’accès la requête et demande au système d’exécuter la commande.

Le driver indique dans le champs blog_status la valeur failed ou success. En cas de succès, la zone binaire du message contient l’extrait de l’annuaire correspondant à la requête.

 

Liaison avec un port série

Driver port série pour Unix/Linux.

 

Options de la ligne de commande :

-d <trace level>    niveau de trace (par défaut : 0)

-t <trace type>     type de trace (par défaut : USER)

-o <trace file>     nom du fichier de trace (par défaut :l’écran)

-n <logical name>   nom logique du driver (par défaut : SERIAL-LDAP)

-D <Device name>    nom du fichier spécial correspondant au périphérique

-B <vitesse>        vitesse sur la ligne (de 50 à 38400 bauds)

-e <char>           valeur décimale du caractère utilisé pour indiquer la fin du message

-x <ON|OFF>         indique si la ligne doit gérer le XON/XOFF

-p <delay>          temps de scrutation sur chaque entrée (par défaut : 1 seconde)

-f <mailbox>        nom du destinataire qui doit être utilisé pour les messages provenant du port série.

-r                  il y a un reset (fermeture/ouverture) du port avant chaque écriture (par défaut : pas de reset)

 

blog_hexa                indique que le contenu de la zone binaire est en expansé en hexadécimal. La réponse doit aussi l’être.

blog_reponse          indique qu’une réponse est attendu. La valeur indique le timeout sur l’attente de la réponse.

blog_admin              si le contenu de ce champ est “ reset ”, le canal de communication vers le port série est coupé puis rouvert avant l’écriture du message.

 

Liaison avec une imprimante sur un port parallèle

Driver d'imprimante sur port parallèle pour Linux.

 

Principe de fonctionnement :

Le driver est pour un fonctionnement autonome : en cas d’erreur, il cherche périodiquement à transmettre le message en cours tout en vérifiant qu’une demande d’annulation et/ou une nouvelle demande d’impression n’est pas en attente.

 

Le driver est en attente sur sa boîte aux lettres.

A la réception d'un message, la partie binaire du message est écrite sur le port parallèle après une éventuelle traduction (voir blog_hexa).

En cas d'échec lors de l'écriture, l’état de l'imprimante est contrôlé. Si une erreur est détectée, le driver vérifie l’état de l’imprimante toutes les n micro-secondes (arguments –W sur la ligne de commande du driver) pendant 1 seconde. Puis le driver consulte sa boîte aux lettres. La réception d'un nouveau message entraîne l'abandon du message en erreur.

Pour réaliser l’annulation du message en cours d’impression lors d’une erreur sur l’imprimante, il faut envoyer un message sans partie binaire. Si le message contient une partie binaire, celle-ci est envoyée à l’imprimante.

En l'absence de message dans sa boîte aux lettres, le driver vérifie l'état de l'imprimante. Si celle-ci n'indique plus d’erreur, le driver termine l'écriture du message en cours.

 

 

Description du fichier de configuration de la liaison parallèle :

Ce fichier contient les caractéristiques spécifiques de chaque imprimante : la séquence permettant de réaliser une réinitialisation logicielle, le délai d’attente après une réinitialisation et la signification des différents bits de statut de l’imprimante.

 

La séquence permettant de réaliser une réinitialisation logicielle est indiqué par le mot clé  « RESET » suivi de la séquence à envoyer. Les caractères qui composent cette séquence doit être indiqués en héxadécimal.

 

Le délai d’attente est indiqué par le mot clé  « DELAI » suivi du nombre de secondes. Il faut laisser à l’imprimante le temps d’atteindre un état stable après l’envoi d’une commande de réinitialisation.

 

La signification des différents bits de statut de l’imprimante est indiquée à la fin du fichier de configuration.

En cas d’erreur, le message correspondant à la valeur relevée sur le bit de statut sera émis.

Le caractère ‘*’ en début de message indique que l’état de cette broche correspond à une erreur.

Suite à un échec lors de la transmission d’un message à l’imprimante, l’état de l’imprimante est analysé par rapport aux indicateurs d’erreur contenu dans le fichier de description. Tant que cette analyse indique une erreur, l’émission de données vers l’imprimante est interrompue.

 

#

# Description valide pour les imprimantes standards (HP LaserJet 5L)

#---------------------------------------------------------------------

#

RESET=015317

#

DELAI=10

#

# Pour indiquer les bits signalant une anomalie, il faut mettre le

# caractère '*' avant le message correspondant.

# Si un de ces indicateurs sont positionnés, l'impression sera interrompue.

#

# position du bits:on message:off message:

3:No error:*Error:

4:Printer on line:*Printer off line:

5:*No paper:Paper:

6:Not acknoledge:Acknoledge:

7:Busy:Not busy:

#---------------------------------------------------------------------

 

Options de la ligne de commande :

-d <trace level>    niveau de trace (par défaut : 0)

-t <trace type>     type de trace (par défaut : USER)

-o <trace file>     nom du fichier de trace (par défaut :l’écran)

-n <logical name>   nom logique du driver (par défaut : SERIAL-LDAP)

-D <Device name>    nom du fichier spécial correspondant au périphérique

-C <Config file>    nom du fichier de description de la liaison (par défaut : printer.def)

-W <delay>          délai d’attente en micro secondes pour vérifier l’état de l’imprimante après une erreur (par défaut : 1000)

 

blog_hexa                indique que le contenu de la zone binaire est en expansé en hexadécimal.

 

Identification LDAP

 

Ce module permet de vérifier un DN et un mot de passe dans la base LDAP.

Si le service LDAP n'est pas accessible, le programme tente de connecter toutes les 10 secondes.

 

Pour utiliser ce service, il faut envoyer un message contenant :

          le nom du destinataire (blog_dest). Le nom de ce service est "LOGIN" (cf. l'option -n).

          le nom du programme (blog_source)

          le DN complet (blog_binddn)

          le mot de passe (blog_bindpd)

 

Le type d'identification est "Authentification Simple".

 

ATTENTION : Il faut donner le DN complet.

Par exemple :

          cn=Yves Crespin, ou=people, o=quartz, c=FR

     cn=Barbara Jensen, ou=Information Technology Division, ou=People, o=quartz, c=FR

 

Pour le mot de passe (userpassword dans la nomenclature LDAP), il faut respecter les majuscules.

 

Si le DN et le mot de passe correspondent, le programme retourne dans le champ "blog_status" la chaîne "success"; dans le cas contraire "failed".

 

La totalité du message est retourné avec la réponse à l'exception du champ "blog_binpd".

 

Options de la ligne de commande :

-d <trace level>       niveau de trace (par défaut : 0)

-t <trace type>        type de trace (par défaut : USER)

-o <trace file>        nom du fichier de trace (par défaut :l’écran)

-n <logical name>      nom logique du driver (par défaut : LDAP-LOGIN)

-c                     utilisation d’un mot de passe crypté. Le cryptage est réalisé dans le module agil

-h <host name>         ldap host (par défaut : localhost)

-p <port number>       ldap port

-l <time limit>        ldap time limit

-z <size limit>        ldap size limit

-i <inactivity limit>  permet de couper la liaison avec LDAP après la durée de l’inactivité indiquée. L’intérêt est de permettre le retour sur le serveur principal.

 

Ce module utilise les API LDAP (Request for Comments: 1823).

Lanceur d’application

 

Ce pilote doit permettre d’exécuter un programme à partir d’informations contenues dans un message au format BLOG.

Ce lanceur permet d’exécuter n’importe quels types de programme : shell script, PICK, binaire, ….

Ce lanceur ne réalise pas des opérations de supervision, de contrôle, de suivi ou d’administration des processus.

 

Un driver de BLOG « BLOG_LOAD » est à l’écoute des messages provenant sur la boîte aux lettres indiquée. A la réception de chaque message :

·         il retransmet le message sur la boîte aux lettres indiquée,

·         puis il met en place l’environnement nécessaire à l’exécution de la commande : « user », « group », « root directory », « current working directory », « user file-creation mask », « stdin », « stdout », « stderr » et les variables d’environnement suivantes : « LOGNAME », « HOME », « SHELL », « PATH » et « TZ » ou les variables exportées dans les fichiers d’initialisation du shell de l’utilisateur indiqué.

·         et enfin il exécute la commande indiquée.

 

Les fichiers de profile ne sont pas exécutés lors du lancement de l’application.

 

Les règles de fonctionnement des drivers BLOG s’appliquent aussi à ce driver.

 

L’application est lancée avec une politique de séquencement de type « temps-partagé ».

 

Contrôle

Le contrôle est réalisé à trois niveaux :

·         interdiction d’exécuter les commandes pour les utilisateurs ayant un numéro d’identification à 0 : en général « root »,

·         contrôle du mot de passe crypté pour l’utilisateur indiqué,

·         respect des règles de protection d’Unix (droits et masque de création).

 

Ce contrôle peut être renforcé :

·         par l’option de lancement « P » qui refuse les messages sans mot de passe crypté,

·         par l’option de lancement « U » qui refuse les demandes devant s’exécuter sous les comptes utilisateurs indiqués.

 

Suivant les droits du compte « blog », il peut être nécessaire de positionner le « setuid bit » à « root ». Toutes les précautions nécessaires ont été mises en œuvre afin de ne pas mettre en cause la sécurité.

 

 

Script

Dans le cas du lancement d’un script, il faut indiquer sur la première ligne le programme à utiliser, par exemple :

          #!/bin/sh

 

Passage des informations

Les champs utilisés sont toujours préfixés par « blog_load_ » :

 

Champ

Signification

Optionnel

Option

blog_load_login

user name

oui

-u

blog_load_passwd

crypt user password

oui

 

blog_load_group

user group

oui

-g

blog_load_root

root directory

oui

-r

blog_load_cwd

current working directory

oui

-c

blog_load_umask

user file-creation mask
exprimé en octal, decimal ou hexadécimal

oui

-m

blog_load_env

user environnement (variables and current directory) [0 :disable, 1 :enable]

oui

-l

blog_load_command

Full command name

 

 

blog_load_arguments

Command arguments

oui

 

blog_load_stdin

Standard input file name

oui

 

blog_load_stdout

Standard output file name

oui

 

blog_load_stderr

Standard error file name

oui

 

blog_load_mailbox

Nom de la boîte aux lettres de l’application

oui

 

 

 

Si des informations optionnelles sont absentes, les indications fournies sur la ligne de commandes seront prises en compte.

 

 

En cas d’absence du champs « blog_load_mailbox », celui-ci est construit en supprimant du nom de la boîte aux lettres du message, le nom de la boîte d’écoute.

Par exemple :

          BLOG_LOAD –b BLOG_LOAD_*

Pour le message envoyé sur la boîte « BLOG_LOAD_XTK_007 » le nom de la boîte aux lettres de l’application sera « XTK_007 » par défaut.

 

 

Dans le champs « blog_load_arguments », il est possible d’indiquer des champs du messages. Par exemple pour transmettre le nom de la boîte aux lettres au programme qui doit être lancé comme troisième argument, il faut utiliser la syntaxe suivante :

     blog_load_arguments=arg1 arg2 $blog_dest arg4

Les variables suivantes sont supportées : blog_dest, blog_source, blog_load_mailbox.

 

 

Par défaut les descripteurs de l’entrée, de la sortie et des erreurs sont associés au fichier « /dev/null ».

Les noms de fichiers peuvent être indiqué en relatif par rapport au répertoire de travail.

Si un fichier d’entrée est indiqué, il doit exister et être accessible en lecture.

Si un fichier de sortie ou d’erreur est indiqué, s’il existe, il doit être accessible en écriture. Si le fichier n’existe pas, il est créé en accordant les permissions de lecture et d’écriture uniquement à l’utilisateur. Dans tout les cas, ce fichier est ouvert en mode ajout.

 

 

Options de la ligne de commande :

-d <trace level>       niveau de trace (par défaut : 0)

-t <trace type>        type de trace (par défaut : USER)

-n <logical name>      nom logique du driver (BLOG_LOAD_*)

-P                     ignore les messages sans password

-l                     charge l’environnement de l’utilisateur indiqué (variable et répertoire de travail)

-U <user name>         interdit les comptes indiqués. Le séparateur est « : »

 

Les outils

Outil d’administration BLOG_ADM

Outil d’administration du BLOG

 

Options de la ligne de commande :

-d <trace level>    niveau de trace (par défaut : 0)

-t <trace type>     type de trace (par défaut : USER)

-o <trace file>     nom du fichier de trace (par défaut :l’écran)

-n <logical name>   nom logique du driver (par défaut : Blog_Admin)

-h <hostname name>  nom de la machine à administrer (par défaut : la machine locale)

-c <commande>       liste des commandes (voir « Administration du BLOG (blog.sh) »)

-L <trace level>    niveau de trace pour le BLOG avec la commande TRACE_LEVEL ou TRACE_TYPE

-C <crédits sec>    temps d’attente de la réponse en seconde

-U <crédits usec>   temps d’attente de la réponse en microseconde

-W <attente sec>    temps d’attente avant la réémission de la commande en seconde.
Fermeture de la ligne et libération de la mémoire entre 2 appels.

-w <attente sec>    temps d’attente avant la réémission de la commande en seconde.
Pas de fermeture de ligne et aucune libération de la mémoire entre 2 appels.

-s                  statistique du temps nécessaire pour émettre une demande en direction du Bus logiciel, recevoir l’acquittement de cette demande, émettre une demande de lecture d’une boîte aux lettres et de recevoir le contenu de la première lettre.

 

Fonctionnement :

Ce programme permet d’envoyer une commande d’administration au BLOG. En indiquant le nom d’une machine, il est possible d’administrer une machine distante.

Pour les commandes INFO, INFO_ALL, STAT et STAT_ALL la réponse est écrite sur la sortie standard.

Pour les commandes INFO, INFO_ALL, STAT et STAT_ALL la durée totale comprise entre l’émission de la requête et la réponse de la réponse est affichée en millisecondes.

 

Exemple :

 

Purge des messages à destination d’une boite aux lettres distante à transmettre :

BLOG_ADM –c PURGE –n <nom complet de la boite>

 

Purge tous les messages à destination d’une machine distante à transmettre :

BLOG_ADM –c PURGE –n *@<nom de la machine>

 

Obtention des statistiques du BLOG d’une machine distante :

BLOG_ADM –c STAT –h <nom de la machine distante>

 

Suivi périodique des statistiques complètes du BLOG (périodicité de 10 secondes) :

BLOG_ADM –c STAT_ALL –C 0 –U 0 –w 10

 

BLOG_ADM -s -w 1 -c STAT

time=3.0818 ms

time=2.0823 ms

time=2.0844 ms

time=2.0772 ms

time=2.0829 ms

time=2.0771 ms

time=2.0785 ms

connection 3.0818ms

7 packets round-trip min/avg/max 2.0771ms / 2.0948ms / 3.0818ms

min at 6 packet / max at 1 packet

 

Outil de visualisation des messages BLOG_REC

Outil de visualisation des messages du BLOG

 

Cet outil permet d’afficher le contenu des fichiers indiqués sur la ligne de commande. Les fichiers doivent être des messages produit par BLOG.

 

Options de la ligne de commande :

-M                  affichage de l’en-tête et de la zone texte (défaut)

-H                  affichage de l’en-tête

-t                  affichage de la zone texte du message

-T                  affichage de la zone texte du message
(affichage des caractères de contrôle en hexadécimal)

-b                  affichage de la zone binaire du message

-B                  affichage de la zone binaire du message
(affichage des caractères de contrôle en hexadécimal)

 

Fonctionnement :

Ce programme permet de lire les fichiers contenant les messages et d’en afficher le contenu sur la sortie standard. (Voir Emplacement des fichiers).

 

Remarque :

Le nom du fichier est affiché avant chaque message entre crochet si l’affichage de l’en-tête est actif.

 

 

Exemple :

Commande pour extraire le contenu de la zone binaire du message :

BLOG_REC –b S.00000001 >mon_fichier

 

Outil d’émission et de réception de message BLOG_SHELL

Outil d’émission et de réception de message du BLOG à partir de la ligne commande.

 

Cet outil permet d’envoyer ou de recevoir un message. Il fournit l’accès à toutes les possibilités de la librairie à partir de la ligne de commande.

 

Les champs « blog_source » et « blog_status » peuvent être renseignés soit à partir de la ligne de commande, soit à partir de l’entrée standard ou d’un fichier. L’information indiquée sur la ligne de commande est prioritaire.

 

Le destinataire doit toujours être indiqué, sauf dans le cas de l’utilisation d’une pseudo-commande.

 

Les pseudo-commandes sont les demandes relatives au BLOG : « INFO », « INFO_ALL », « STAT » et « STAT_ALL ». Si le champ « blog_source » n’est pas renseigné, un nom de boîte aux lettres temporaire est créé.

 

Le message reçu est écrit sur la sortie standard.

 

Options de la ligne de commande :

-d                  niveau de trace

-t                  type de trace

-o                  fichier de sortie des traces

-c                  nom de la commande (send, receive, peek_first, delete, delete_force, …) ou de la pseudo-commande

-C                  durée de vie du message en seconde

-D                  nom de la boîte aux lettres du destinataire.
ce nom ne doit pas contenir le nom de la machine.

-h                  nom de la machine destinataire du message

-S                  nom de l’émetteur « blog_source »

-X                  statut « blog_status »

-O                  dépose dégradée en cas d’absence de BLOG

-f                  nom du fichier contenant les champs à ajouter au message.
Le nom de fichier « 
- » indique l’entrée standard.
Les séparateurs de champs et d’enregistrements sont par défaut les séparateurs standard du BLOG (respectivement « 
» et LineFeed).

-b                  nom du fichier contenant la zone binaire.
Le contenu de ce fichier est copié dans le champs « blog_body ».

-r                  séparateur entre le nom du champ et la valeur.

-R                  séparateur d’enregistrement.

-F                  contenu de l’octet mis à la disposition de l’application.
Si la valeur commence par « 0x » cette valeur est traité en héxadécimale.

 

Fonctionnement :

Ce programme permet d’envoyer, de recevoir ou de supprimer des messages.

 

Remarque :

Des pseudo-champs indiquent le numéro de chrono, le numéro de swap et la valeurs flags.

Chrono=68

Swap=26

Flags=0 (0)

 

Exemple :

Commande pour envoyer une demande d’information sur une machine distante. Ce raccourci utilise la commande « send ». Le nom de la boîte est affichée sur la sortie standard.

BLOG_SHELL –c INFO

Chrono=68

Swap=26

Flags=0 (0)

blog_source=~Blog_Shell:432@quartz.fr

 

BLOG_SHELL –c STAT –S MA_BOITE

Chrono=69

Swap=27

Flags=0 (0)

blog_source=MA_BOITE@quartz.fr

 

Commande pour recevoir la premier message de la boîte indiquée :

BLOG_SHELL –c RECEIVE –D "~Blog_Shell:*"

Chrono=70

Swap=28

Flags=0 (1) blog_flags= URGENT

… contenu du message …

 

BLOG_SHELL –c RECEIVE –D MA_BOITE

Chrono=70

Swap=29

Flags=0 (1) blog_flags= URGENT

… contenu du message …

 

 

Commande pour envoyer un message urgent de la boîte indiquée :

BLOG_SHELL –c SEND_URGENT –D Destinataire –S Source

Chrono=71

Swap=30

Flags=0 (0)

blog_source=Source@quartz.fr

 

 

Commandes pour supprimer les demandes de réceptions sur les boîtes indiquées :

BLOG_SHELL –c CLOSE_RCV –D BOITE1\*\;BOITE2\*

Chrono=72

Swap=31

Flags=0 (0)

blog_source=BOITE1*;BOITE2*

 

ou

 

BLOG_ADM –c CLOSE_RCV –n BOITE1\*\;BOITE2\*

 

 

 

Etat courant du système

L’état courant du système est indiqué sur demande (Voir « Administration du BLOG (blog.sh) »).

 

Version logicielle du « Kernel » :

BLOG_version                   numéro de version suivi entre parenthèse du nom de la version suivi entre crochet de l’état de la version.

BLOG_cflags                     options de production du (compilation)

BLOG_date                         date de production du (compilation)

 

Version logicielle de la librairie partagée :

blog_version                   numéro de version suivi entre parenthèse du nom de la version suivi de la date de production (compilation).

 

Configuration :

BLOG_options                   options de lancement

BLOG_blog_unix               nom du fichier utilisé pour les sockets du domaine local, « none » si non supportée

BLOG_blog_inet               numéro du port TCP blog (3233)

BLOG_blog_ftp                 numéro du port TCP blog_ftp (3234)

 

Etat courant :

blog_status                     adresse IP locale et l’accès au réseau (lock|unlock)

BLOG_mem_msg                   quantité de mémoire vive utilisée pour les messages (données)

BLOG_mem_evt                   quantité de mémoire vive utilisée pour les messages (information)

BLOG_mem_db_local         quantité de mémoire vive utilisée pour le nom des destinataires

BLOG_mem_db_rcv             quantité de mémoire vive utilisée pour le nom des boîtes locales

BLOG_mem_db_remote       quantité de mémoire vive utilisée pour le nom des machines

BLOG_mem_db_alarm         quantité de mémoire vive utilisée pour les alarmes

BLOG_tmpdir                     emplacement du répertoire temporaire

 

 

Listes des pilotes (cf BLOG.load) :

Driver(x)                         <Chemin complet du pilote> PID <PID> start at <date de lancement>

Driver(x)                         <Chemin complet du pilote> PID <PID> start at <date de lancement> - prev start <date du précédent lancement> start at <cause de l’arrêt> count <nombre de lancement>

 

La quantité de mémoire utilisée est toujours exprimée en octet.

 

Messages :

Le format général est le suivant :

<nom>  <séparateur>  [<nom de la boite>(nombre de message)]

 

Le séparateur est “ = ”.

 

Le nom des champs est :

BLOG_A                     liste des alarmes en attente

BLOG_S                     liste des destinataires connus

BLOG_R                     liste des noms de boites locales en attente de réception

BLOG_W                     liste des machines pour lesquelles un message est en attente d’émission

BLOG_lines             nombre de lignes ouvertes par type de connexion

 

Message d’erreur et message de trace

Toutes erreurs sont consignées dans le journal des événements du système (voir syslog) ou en mémoire partagée.

Tous les programmes ont une option qui permet d’indiquer le niveau de trace : « -d » et le type de trace « -t ».

Par défaut, ce niveau est à 0.

 

Niveau de trace :

0                désactive les traces

1                annotation

2                information

3                « debug »

 

Emplacement des traces :

Par défaut les traces sont écrites dans une zone en mémoire partagée. Mode de fonctionnement par défaut de BLOG. La mémoire partagée n’est utilisé que pour les traces.

Une application peut choisir l’utilisation de syslog pour stocker les traces applicatives. Dans ce cas et suivant le volume et la fréquence des traces un ralentissement de l’application peu être remarqué.

L’emplacement des traces est indiqué avec la commande suivante. Il peut être changé à tout moment. Normalement une application n’a pas besoin de cette commande. Deux emplacements sont possibles : « syslog » et « shm » (défaut).

if (blogset("blog_trace_location","syslog",0) < 0 ){

                 erreur …

}

 

Identifiant :

Le nom de la session est indiqué avec la commande suivante. Le nom peut être changé à tout moment :

if (blogset("blog_logname","PriseDeCommande",0) < 0 ){

                 erreur …

}

 

Message de trace :

Ajoute un message de trace de niveau 0 (toujours visible) :

if (blogset("blog_trace","Message de trace toujours visible",0) < 0 ){

                 erreur …

}

 

Ajoute un message de trace de niveau 1 (visible uniquement si le niveau de trace est 1) :

if (blogset("blog_trace","Annotation",1) < 0 ){

                 erreur …

}

 

 

Production de trace au niveau 1

Le niveau d’annotation permet à une application de tracer l’émetteur et le destinataire de chaque message (demande d’émission et de réception).

<date>:<nom de la session>[<pid>]:<commande>:<Emetteur> -> <Récepteur>

 

### Emission d’un message

10.04.2000 14.30.20:Blog_Admin[1016]:send_urgent:Blog_Admin -> BusLogiciel@linux

### Emission d’une demande de réception d’un message

10.04.2000 14.30.20:Blog_Admin[1016]:receive:??? -> Blog_Admin

Production de trace au niveau 2

Le niveau d’information permet d’obtenir en plus le contenu complet du message. Les caractères non imprimables sont entre crochet en base 16.

 

### Emission d’un message

# Indique la commande, l’émetteur et le destinataire

10.04.2000 14.30.33:Blog_Admin[1019]:send_urgent:Blog_Admin -> BusLogiciel@linux

# Indique la commande

10.04.2000 14.30.33:Blog_Admin[1019]:BLOG_cmd=send_urgent[0xa]

# Indique les champs de la zone texte

10.04.2000 14.30.33:Blog_Admin[1019]:blog_dest=BusLogiciel@linux[0xa]blog_source=Blog_Admin[0xa]blog_admin=INFO[0xa]blog_credit=5[0xa]blog_timestamp=10.04.2000 14.30.33[0xa]

# Indique la longueur de la partie binaire

10.04.2000 14.30.33:Blog_Admin[1019]:BLOG_len=0[0xa][0xa]

#

### Emission d’une demande de réception d’un message

# Indique la commande, l’émetteur et le destinataire

10.04.2000 14.30.33:Blog_Admin[1019]:receive:??? -> Blog_Admin

# Indique la commande

10.04.2000 14.30.33:Blog_Admin[1019]:BLOG_cmd=receive[0xa]

# Indique les champs de la zone texte

10.04.2000 14.30.33:Blog_Admin[1019]:blog_dest=Blog_Admin[0xa]blog_credit=5[0xa]blog_timestamp=10.04.2000 14.30.33[0xa]

# Indique la longueur de la partie binaire

10.04.2000 14.30.33:Blog_Admin[1019]:BLOG_len=0[0xa][0xa]

#

### Réception du message

10.04.2000 14.30.33:Blog_Admin[1019]:BLOG_version=1.7.190 (???) (Exp)[0xa]BLOG_options= ‑d 1 ‑t 0xffffffff ‑c BLOG ‑p /home/blog/BLOG [0xa]BLOG_cflags=NDEBUG USE_SHM_TRACE SUPPORT_OLD_CHRONO_SWAP_FILE [0xa]BLOG_blog=3233[0xa]BLOG_blog_ftp=3234[0xa]BLOG_date=07.04.2000[0xa]blog_status=10.1.80.2 (unlock)[0xa]BLOG_mem_msg=561[0xa]BLOG_mem_evt=14400[0xa]BLOG_mem_db_local=2800[0xa]BLOG_mem_db_remote=560[0xa]BLOG_mem_db_rcv=3200[0xa]BLOG_cmd=send[0xa]blog_dest=~Blog_Admin.1019@linux[0xa]blog_source=BusLogiciel@linux[0xa]blog_timestamp=10.04.2000 14.30.33[0xa]BLOG_tmpdir=/tmp[0xa]BLOG_len=0[0xa]

 

Production de trace au niveau 3

Identique au niveau 2, et affichage du contenu de la zone binaire.

 

Outil d’exploitation et de suivi des messages de trace BLOG_TRACE

Cet outil permet de suivre en « temps réel » les échanges de messages entres les applications et BLOG. Il permet aussi de réaliser une copie des traces contenues de la mémoire partagée dans un fichier.

 

Options de la ligne de commande :

-r                  efface uniquement le contenu de la mémoire partagée

-f                  met à jour toutes les secondes l’affichages

 

Sans options, ce programme copie le contenu de la mémoire partagée dans un fichier « /tmp/blog.trace ».

Si un fichier de ce nom existe, il renommé en ajoutant la première extension numérique « /tmp/blog.trace.1 » puis « /tmp/blog.trace.2 », ….

 

Le nom de la racine varie suivant le système d’exploitation « / » sous UNIX, « E:/NuTCRACKER » sous « NuTCracker », …

 

En mode suivi, l’affichage est réalisé sur la standard.

 

Les fonctions de la librairie

La librairie

 

La librairie est disponible pour permettre à toute application de communiquer avec le BLOG

 

Un paramètre ne peut contenir ni le caractère “ ”, ni le caractères “ \0 ” (0x00), ni le caractère “ \n ” (0x0A) (séparateur de ligne).

Un paramètre ne peut pas commencer par la chaîne “ BLOG ”.

 

Une valeur ne peut pas contenir ni le caractère “ \n ” (0x0A) (séparateur de ligne), ni le caractères “ \0 ” (0x00).

 

Les codes d’erreur

En cas d’erreur, le code erreur est retourné par la fonction. Le message d’erreur est accessible par la fonction blogerror().

 

Format des messages :

Numéro: message associé

Dans le message, le numéro de l’erreur est sur 2 positions sans le signe ‘- ‘.

 

 

 

BLOG_SUCCESS     0                 succès

BLOG_ETIME       -1               timeout

BLOG_EINVAL      -2               argument invalide

BLOG_EINTERNAL   -3               erreur interne

BLOG_ESYSTEM     -4               erreur système

BLOG_ENOMEM      -5               pas assez de mémoire

BLOG_ENOENT      -6               pas d’entrée

BLOG_ENONET      -7               pas de réseau

BLOG_ECOMM       -8               erreur de communication

BLOG_EPROTO      -9               protocole invalide

BLOG_ESYNC       -10             erreur de synchronisation

BLOG_ESCHEDULE   -11             demande de séquencement (Posix Thread uniquement)
                   dépend de l’implémentation système des threads.

BLOG_ECLIENT     -12             fermeture de la socket cliente (cf blog_socket_read)

BLOG_EKILL       -15             demande d’arrêt de la réception sur les boîtes aux lettres

 

Le descriptif de l’erreur est effacé à chaque appel de fonction excepté l’appel de blogerror().

 

Les fonctions threads-safe

Il existe deux types de threads : les threads applicatifs (Green-Thread, DCE, …) et les threads systèmes ou natif (Posix).

Les fonctions threads-safe ont le suffixe suivant : « _thread » et un paramètre supplémentaire est ajouté en première position : « l’identificateur du thread ». Cet identificateur est de type entier long. Dans le cas des threads POSIX, ce paramètre est remplacé par l’identificateur réel du thread.

Les fonctions

      blogdefault

 

int blogdefault(char *param, char *val, size_t len);

 

Cette fonction permet d’indiquer les paramètres par défaut des messages.

Ces paramètres sont systématiquement ajoutés à chaque message par la fonction qui réalise l’envoi du message. Si un paramètre existe dans le message, il n’est pas remplacé par le paramètre par défaut.

Pour supprimer un paramètre par défaut, il appeler la fonction avec une valeur vide (“”).

Si le paramètre len vaut 0 (zéro), la longueur de la valeur est calculée en respectant les règles de définition des chaînes de caractères en C et en supprimant tous les caractères “ espace ” en fin de chaîne.

ATTENTION : Il n’y a pas de fonctions qui permettent d’obtenir la valeur d’un paramètre par défaut.

 

Paramètres :

param                       nom du paramètre

val                           valeur du paramètre

len                           longueur de la valeur ou 0 (zéro) si la longueur doit être calculée

 

Exemple :

/* par défaut le paramètre "ref" à pour valeur : "#123" */

 

if (blogdefault( "ref" , "#123" , 0 ) < 0 ){

                 erreur …

}

 

/* redéfinit le paramètre "ref".

** La nouvelle valeur est : "transaction n°1"

*/

 

if (blogdefault( "ref" , "transaction n°1" , 0 ) < 0 ){

                 erreur …

}

 

      blogset

 

int blogset(char *param, char *val, size_t len);

 

Cette fonction permet d’indiquer les paramètres d’un message, les paramètres de la session et des messages de trace.

La valeur d’un paramètre indiqué avec cette fonction est prioritaire sur les paramètres par défaut.

Si le paramètre len vaut 0 (zéro), la longueur de la valeur est calculée en respectant les règles de définition des chaînes de caractères en C et en supprimant tous les caractères “ espace ” en fin de chaîne.

Le contenu d’un message est supprimé au premier appel de la fonction blogset() qui suit l’appel d’une la fonction BLOG.

 

Paramètres :

param                       nom du paramètre

val                           valeur du paramètre

len                           longueur de la valeur ou 0 (zéro) si la longueur doit être calculée
Attention, si le paramètre est « blog_trace », le champ « len » indique le niveau de trace.

Niveau de trace :

0                désactive les traces

1                annotation

2                information

3                « debug »

 

Exemple :

/* Le paramètre "ref" à pour valeur : "#123" */

 

if (blogset( "ref" , "#123" , 0 ) < 0 ){

                 erreur …

}

 

/* Cet appel redéfinit le paramètre "ref".

** La nouvelle valeur est : "transaction n°1"

*/

 

if (blogset( "ref" , "transaction n°1" , 0 ) < 0 ){

                 erreur …

}

 

      blogget

 

const char * blogget(char *param);

 

Cette fonction permet d’obtenir la valeur du paramètre indiqué dans le message courant.

Cette fonction permet aussi d’obtenir les informations associées : blog_trace_level, blog_trace_type, blog_syslog, blog_service, blog_basedir, blog_mvalue_sep, blog_version.

 

Si le paramètre indiqué n’existe pas une chaîne vide est retournée, sinon c’est un pointeur sur la valeur du paramètre.

 

La chaîne retournée respecte les règles de définition des chaînes de caractères en C.

ATTENTION : La zone retournée est en lecture seule.

ATTENTION : Cette fonction ne permet pas d’obtenir la valeur d’un paramètre par défaut.

ATTENTION : Le premier appel de la fonction blogset() supprime le contenu du message courant.

 

Paramètres :

param                       nom du paramètre

 

Code de retour :

NULL                         le paramètre indiqué ne figure pas dans le message

!=NULL                     valeur du paramètre en lecture seule

 

Exemple :

/* Le paramètre "ref" à pour valeur : "#123" */

 

const char *    myref ;

 

myref = blogget( "ref" ) ;

if ( myref == NULL || myref[0] == 0 ){

                 erreur

}else{

                 utilisation de la référence

}

 

      blogget_r

 

const size_t blogget_r(char *param, char *w, const size_t len);

 

Cette fonction est identique à la fonction blogget(), elle permet d’indiquer le tampon destiné à contenir la valeur du paramètre indiqué.

Le paramètre len permet d’indiquer la taille du tampon.

Le code de retour contient le nombre d’octets copié dans w.

Si la taille du tampon n’est pas suffisante, la valeur du paramètre indiqué est tronquée et le caractère 0x00 est ajouté à la fin du tampon.

 

 

      blogcmd

 

int blogcmd(char *cmd, long sec, long usec, char *localflags, int *pSwap,

                 char *param_sep, char *param_in, char *param_out);

 

Cette fonction permet d’envoyer ou de recevoir un message.

 

Les paramètres sec et usec permettent d’indiquer soit la durée de vie du message, soit la durée maximale d’attente de réception d’un message.

Un message qui a atteint sa durée de vie est transféré à l’application gérant les messages périmés. Les demandes de réception périmée sont supprimés par le BLOG.

 

 

Un délai d’attente infini est indiqué par la valeur -1 dans les paramètres sec et usec.

 

Un délai d’attente minimal est indiqué par la valeur 0 dans les paramètres sec et usec.

Dans ce cas, si la boite aux lettres est vide, la fonction retourne le code BLOG_ETIMEOUT.

 

Cette fonction retourne toujours le numéro de swap du message.

 

ATTENTION : Le premier appel de la fonction blogcmd() supprime le contenu du message courant.

 

La commande "send" permet d’envoyer un message (poste un courrier).

La commande "send_urgent" permet d’envoyer un message en urgent (poste un courrier).

La commande "send_w/o_reset" permet de renvoyer le dernier message. Cette commande est utile si le message courant ne peut pas être traité dans le contexte courant. Il est alors renvoyé dans la boîte aux lettres pour un traitement ultérieur.

La commande "receive" permet d’aller chercher un message.

La commande "peek_first" permet de consulter le prochain message.

La commande "peek_next" permet de consulter le prochain message non déjà consulté.

La commande "peek_reset" permet de supprimer l’indicateur de lecture sur la ou les boites indiquées.

La commande "clear" permet de supprimer les messages contenu dans une boîte aux lettres.

La commande "clear_alarm" permet de supprimer les alarmes contenu dans une boîte aux lettres.

La commande "delete" permet de supprimer un message consulté précédemment.

La commande "delete_force" permet de supprimer une liste de message.

La commande "send_alarm" permet d’envoyer un message avec une attente.

La commande "send_alarm_urgent" permet d’envoyer un message avec une attente en mode urgent.

La commande "delete_alarm" permet de supprimer un message en attente de mise dans la boite aux lettres du destinataire.

La commande "peek_alarm" permet de consulter un message en attente de mise dans la boite aux lettres du destinataire.

La commande "close" permet de fermer la liaison avec le BLOG et libére toute la mémoire allouée par la librairie.

La commande "close_rcv" permet de notifier aux applications en attente de réception d’un message sur une boîte aux lettres correspondant à un des noms indiqués dans le champ destinataire. La liaison avec le bus est fermé et l’application reçoit le code BLOG_EKILL.

 

Le paramètre "pSwap" est toujours renseigné. Il permet d’obtenir le numéro de swap du message émis, consulté ou lu. C’est ce numéro qui doit être indiqué dans le champ "blog_swap" avant d’appeler l’une des commandes suivantes "delete", "delete_alarm" ou "peek_alarm".

 

La commande "delete_force" permet d’indiquer dans le champ "blog_swap" plusieurs numéros de swap séparé par un des caractères suivants : « , ; ! | <tabulation> <espace> ».

 

La commande peut être relancée en cas d’échec. Dans ce cas et en l’absence de l’appel de la fonction blogset() les champs conservent leurs valeurs respectives.

Paramètres :

commande                 opération à réaliser

sec                           délai d’attente ou durée de vie en secondes

usec                         délai d’attente ou durée de vie en microsecondes

localflags             paramètre d’entrée et de sortie optionnel
le premier octet est à la disposition de l’application
le second octet permet de remonter des informations de BLOG vers l’application.
0x01  message urgent (URGENT)
0x02  message consulté (PEEK)
0x04  pièce jointe (PIECE_JOINTE)
0x08  absence de fichier associé à la pièce jointe (NOFILE)
0x10  message avec un délai d’attente (ALARM)
les deux octets suivants sont réservés pour un usage futur

pSwap                       paramètre de retour optionnel
Contient le numéro de swap du message. Ce numéro doit être utiliser pour supprimer un message en mode transactionnel.

param_sep               prévu pour une extension future (paramètre en entrée uniquement)

param_in                 prévu pour une extension future (paramètre en entrée uniquement)

param_out               prévu pour une extension future (paramètre en sortie uniquement)
la taille maximale est de 256 caractères

 

Exemple :

Char             localflags[4];

int              swap;

 

/* Envoi du message courant d’une durée de vie de 10 secondes */

if ( blogcmd("send" , 10, 0, localflags, NULL, NULL,NULL,NULL) < 0 ){

                 erreur

}

 

/* Envoi du message courant. Ce message a une durée de vie infinie */

if (blogcmd("send" , -1, -1 , localflags, NULL, NULL,NULL,NULL) < 0 ){

                 erreur …

}

 

/* Envoi du message courant. Sans données complémentaire */

if ( blogcmd("send" , 0, 0, NULL, NULL, NULL,NULL,NULL) < 0 ){

                 erreur

}

 

 

/* Demande de réception avec un délai de 3,5 secondes */

ret = blogcmd("peek_first",3,500000,localflags,&swap,NULL,NULL,NULL)

if (ret == BLOG_ETIMEOUT){

                 boîte vide

}else if (ret < 0){

                 erreur

}

 

/* Demande de réception immédiate*/

ret = blogcmd("peek_first" , 0, 0, localflags, &swap ,NULL,NULL,NULL)

if (ret == BLOG_ETIMEOUT){

                 boîte vide

}else if (ret < 0){

                 erreur

}

 

/* Demande de réception avec un délai de 50 millisecondes */

ret = blogcmd("peek_first",0,50000,localflags,&swap,NULL,NULL,NULL) ;

if (ret == BLOG_ETIMEOUT){

                 boîte vide

}else if (ret < 0){

                 erreur

}

 

      blogerror

 

const char *blogerror(void);

 

Cette fonction permet retourne le message d’erreur courant.

Le message d’erreur est effacé à chaque appel de fonction excepté de la fonction BLOG_ERR.

 

Paramètres :

aucun

 

Code de retour :

          !=NULL                     contenu du message d’erreur courant

 

Exemple :

/* Affichage du message d’erreur */

 

if ( blogcmd("send" , 30, 0, NULL, NULL) < 0 ){

                 printf("ERROR : send failed : %s", blogerror () );

}

 

 

      blogerror_r

 

const size_t blogerror_r(char *w, const size_t len);

 

Cette fonction est identique à la fonction blogerror(), elle permet d’indiquer le tampon destiné à contenir le message d’erreur.

Le paramètre len permet d’indiquer la taille du tampon.

Le code de retour contient le nombre d’octets copié dans w.

Si la taille du tampon n’est pas suffisante, le message d’erreur est tronqué et le caractère 0x00 est ajouté à la fin du tampon.

 

 

Les paramètres

 

Ces paramètres figurent dans l’en-tête des messages.

 

Les différents types de paramètres :

 

Il existe sept types de paramètres :

·         les paramètres obligatoires : “ blog_dest ”

·         les paramètres renseignés directement par la fonction d’envoi de message : “ BLOG_cmd ”, “ BLOG_len ”, “ blog_timestamp ”, “ blog_credit ”, “ blog_status ”, “ blog_chrono ”, “ blog_swap ”, “ blog_lflags ”

·         les méta-paramètres qui permettent de lire une partie du message : “ blog_header ”, “ blog_body ”

·         les méta-paramètres qui permettent d’écrire une partie du message : “ blog_body ”, “ blog_body+ ”

·         les paramètres qui permettent de connaître ou de changer les informations de base : “ blog_depose_degradee ”, “ blog_trace_level ”, “ blog_trace_type ”, “ blog_trace_location ”, “ blog_basedir ”, “ blog_mvalue_sep ”, “ blog_syslog ”, “ blog_service ”, “ blog_msgq ”, “ blog_relance_cmd ”, “ blog_socket_read ”.

·         les paramètres qui permettent de lire les informations de base : “ blog_version ”.

·         les paramètres qui permettent de produire une trace : “ blog_trace ”

·         les paramètres définis par l’utilisateur

 

 

Significations des paramètres :

BLOG_cmd                             opération à réaliser

BLOG_len                             longueur de la partie binaire

BLOG_alarm                         date de mise à disposition du message

blog_dest                           nom du destinataire

blog_source                       nom de l’émetteur

blog_timeout                     date d’émission du message en secondes depuis le 1/1/1970

blog_credit                       durée de vie du message en secondes

blog_version                     numéro, nom et date de la version de la librairie

blog_body                           nom du corps du message avec remise à zéro

blog_body+                         nom du corps du message en mode ajout

blog_header                       nom de l’en-tête du message

blog_chrono                       numéro de chrono du dernier message émis ou reçu

blog_swap                           numéro de chrono du dernier message reçu

blog_lflags                       valeurs des flags du dernier message émis ou reçu

 

blog_status                       code retour [success|failed]

 

blog_depose_degradee     active (1) ou inhibe (0) la dépose dégradée (par défaut : 0).

 

blog_trace                         ajoute le message dans la trace

blog_trace_location       emplacement des traces (les valeurs possibles sont « shm » ou « syslog »

blog_trace_level             niveau de trace (0 pas de trace)

blog_trace_type               type de trace (0 pas de trace)

blog_service                     nom du service à utiliser

blog_basedir                     permet d’indiquer le nom du répertoire de base du BLOG.
Par défaut, la variable d’environnement BLOG est utilisé.
Uniquement utilisé pour permettre la dépose dégradée.

blog_mvalue_sep               permet d’indiquer la valeur du séparateur de champs dans une liste.
Par défaut, le séparateur est le caractère “ | ” (0x7c).
Les caractères 0x00 est “ Line-Feed ” ne sont pas autorisés comme séparateur.

blog_syslog                       nom symbolique utilisé dans les messages de trace

blog_msgq                           indique sur quelle “ message queue ” le blog doit envoyer une copie du header dès la réception d’un nouveau message. Pour activer ce service, il faut indiquer :
– le nom logique du programme [champ source] (format texte)
– la clé de la file de message (format texte)
– le numéro du type de message (format texte)
– en-tête standard (optionnel) (binaire)
Le séparateur des champs est le caractère “ Line-Feed ”
Pour désactiver l'envoi sous la forme message queue, il faut appeler la commande en passant -1 ou un message vide.
Le blog, à la réception de chaque nouveau message, envoie les informations indiquées sur la file indiqué.

blog_relance_cmd             paramètre de relance des commandes en cas d’erreur BLOG_ECOMM et BLOG_ENONET. Syntaxe : <nombre de relance avant attente> <nombre de relance avant abandon> <durée de l’attente entre deux commandes>. Par défaut, il n’y a pas de relance.

blog_read_socket             indique à la librairie de contrôler le descripteur de fichier indiqué et de se terminer si ce descripteur est fermée (cf l’utilisation dans « blog_gate_options »).

 

blog_alarm_delay             date de mise à disposition du message exprimé en relatif.

blog_alarm_date               date de mise à disposition du message exprimé en absolu.

 

blog_file_src                   nom du fichier source

blog_file_dest                 nom du fichier destination

 

blog_admin                         commande destiné au BLOG (BusLogiciel)

blog_reponse                     indique qu’une réponse est attendu. La valeur indique le timeout sur l’attente de la réponse. [cf BLOG_SERIE]

blog_hexa                           indique que le contenu du body est en expansé en hexadécimal. La réponse doit aussi l’être. [cf BLOG_SERIE]

Une alternative à l’usage de la librairie

La passerelle

 

La librairie est disponible pour permettre à toute application de communiquer avec le BLOG

Mais dans certains cas, il n’est pas possible (OS non supporté, impossibilité de réaliser une édition de liens, …) ou voulu de lier la librairie avec l’application. Dans ce cas, les fonctionnalités de la librairie sont déportées comme les RPC (Remote Procedure Call).

 

L’application dialogue avec la librairie  via une « socket » (TCP de type STREAM) en utilisant un protocole simple pour réaliser les échanges.

 

Il y a une passerelle par application cliente. Par exemple, une application multi-threads peut utiliser un ensemble de passerelles.

 

Le serveur de passerelle peut être soit :

·         Un driver BLOG : simplicité d'administration car géré par BLOG
Port fixe : blog_gate

·         Géré par inetd. Ce fonctionnement permet d’utiliser la dépose dégradée.
Port au choix : blog_gate, blog_gate2, …

·         Autonome : c'est à dire sans inetd et sans BLOG.
Exemple de lancement : nohup BLOG_GATE &

 

Plusieurs serveurs de passerelles peuvent être actifs en même temps.

 

Une librairie passerelle pour Windows

 

Les fonctions suivantes permettent de gérer complètement la connexion:

 

BlogInitGate

Les paramètres sont :

·         le nom de la machine cible ou NULL pour indiquer la machine locale.

·         le nom du service cible ou NULL pour indiquer le service « blog_gate ».

En cas de succès le retour est 0, en cas d’échec –1.

Cette fonction est optionnelle. Si la liaison n’a pas déjà été ouverte, elle est automatiquement ouverte par le premier appel de blogcmd() avec les paramètres à NULL.

 

extern int BLOG_API BlogInitGate(const char *hostName,const char *servName);

 

BlogCloseGate

Permet de fermer la socket. Par défaut la socket n’est jamais fermée.

 

extern void BLOG_API BlogCloseGate(void);

 

 

 

Les fonctions standards de la librairie sont disponibles sauf :

·         blogdefault() l’interface ne permet pas de conserver des informations.

·         blogget() et blogget_r() n’accepte que les paramètres suivants : blog_header, blog_body, blog_chrono, blog_swap, blog_lflags, BLOG_len.

 

Dans les fonctions standards, la taille maximale est de 512 ko pour les zones texte et binaire.

 

Les fonctions suivantes implémentent le protocole de communication:

 

extern SOCKET BLOG_API OpenSocket(
const char *hostName,
const char *servName
);

extern void BLOG_API CloseSocket(
const SOCKET s
);

extern int BLOG_API SendBlogMessage(
const SOCKET s,
const char *lpText,
const size_t szText,
const char *lpBinary,
const size_t szBinary
);

extern int BLOG_API RecvBlogMessage(
const SOCKET s,
char *lpText,
size_t *lpszText,
char *lpBinary,
size_t *lpszBinary
);

 

 

Le protocole

 

Cette version permet de réaliser une lecture en 2 appels.

 

Le premier appel est un demande de 50 octets.

Le seconde appel est une demande de <taille zone texte>+<taille zone header>.

 

Le numéro de version du protocole reste 1 car la compatibilité est assuré:

- le nombre de ligne est identique,

- la position et la signification des composants est identique.

 

Attention, il ne faut pas comparer directement le contenu de la seconde ligne avec la chaîne "1".

Il peut y avoir des 'espaces' avant ou après cette valeur.

Le protocole garanti uniquement que sur la seconde ligne, il y a la version du protocole.

 

Dans message contenant une zone binaire,

une ligne de séparation doit figurer entre la zone binaire et la zone texte.

Cette ligne doit être compté dans la zone texte.

 

L’en-tête comporte toujours 4 lignes, mais elle est de taille fixe : 50 caractères.

La longueur des différentes zones est indicative.

 

Numéro de ligne

Longueur

Contenu

Description

1

4

BLOG

Identifiant

2

2

1

Version du protocole

3

20

 

Taille de la zone texte

4

20

 

Taille de la zone binaire

 

 

Dans la zone texte, il est possible d’ajouter des informations pour « piloter » la passerelle. Le champs réservé à cet effet est le champ « blog_gate_options ». Les valeurs possibles sont :

« close »                         la passerelle ferme la socket de communication et s’arrête après avoir transmis la réponse.

« no_check_socket »     la passerelle, durant une demande de réception d’un message, ne vérifie pas la socket cliente. Par défaut, si la socket cliente est fermée ou si des données sont disponibles, la passerelle interrompt l’attente du message provenant de BLOG et s’arrête.

Le séparateur entre les différentes options peut être un des caractères suivants : « , ; ! | <tabulation> <espace> ».

 

Par exemple :

      blog_gate_options=close,no_check_socket