Table des matières

Passerelle SMS

Passerelle SMS

Nous utiliserons pour cela :

Une clé USB 3G (type Huawei K4511)
Gnokii, le logiciel permettant entre autre l'envoi de SMS via la clé USB 3G
Un script utilisé en tant que transport Postfix faisant la liaison entre la réception d'un mail et l'envoi d'un SMS avec Gnokii.

Les scripts utilisés pour la mise en oeuvre de cette passerelle sont disponibles dans le repos git gnokii-admin-scripts.

Installation de la clé USB 3G

Nous utiliserons une clé USB 3G Huawei K4511 dans ce test. Ce type de clé ont deux mode d'utilisation :

un mode proposant à l'ordinateur sur lequel il est connecté, un lecteur CD virtuel contenant le logiciel d'installation Windows de la clé
un second mode proposant un modem GSM que nous voulons utiliser

Par défaut, lorsque l'on connecte la clé USB à la machine, celle-ci est en mode “CD virtuel”. Pour basculer dans le mode modem GSM, nous allons utiliser l'outil usb-modeswitch qui s'en occupera.

Installation et configuration d'usb-modeswitch

Installer tout d'abord le paquet Debian usb-modeswitch :
```
apt-get install usb-modeswitch
```
Connecter votre clé USB et regarder les identifiants vendeurs et produits de votre clé. Dans mon cas il s'agit de 12d1:14b7 :
```
Bus 001 Device 006: ID 12d1:14b7 Huawei Technologies Co., Ltd.
```
Vérifier si votre clé est connue et supportée directement par le paquet Debian ou bien qu'il vous faut comme moi configurer le switching de mode :
- crée le fichier /etc/usb_modswitch.d/[ID vendeur]:[ID produit], dans mon cas /etc/usb_modeswitch.d/12d1:14b7. Ce fichier contiendra notamment les ID vendeur et produit avant et après switching. Dans mon cas :
```
DefaultVendor= 0x12d1
DefaultProduct=0x14b7

TargetVendor= 0x12d1
TargetProduct= 0x14cc

CheckSuccess=20

MessageContent="55534243123456780000000000000011062000000100000000000000000000"
```

Le paquet Debian installe automatiquement des règles UDEV lançant le switching à la connexion des clés reconnues. Pour vérifier que le lancement automatique pour votre clé est bien présent, chercher la (avec ses identifiants) dans le fichier /lib/udev/rules.d/40-usb_modeswitch.rules

Pour vérifier que le switching fonctionne, il sera nécessaire de redémarrer la machine (ou recharger les règles UDEV manuellement) et retenter l'insertion de la clé. Le switching avec usb_modeswitch devrai être lancer automatiquement un nouveau périphérique du type GSM modem (ttyUSB0 et ttyUSB1). Surveiller les logs kernel pour vous en assurer.

Pour un switch manuel, utiliser la commande :

usb_modeswitch -c /etc/usb_modeswitch.d/12d1\:14b7

En fonction de votre clé, il sera peut-être nécessaire d'installer un kernel Linux plus récent pour que le module option (driver USB GSM modem) supporte votre clé. Si le switching fonctionne (les ID vendeur et produit changent bien) mais que le périphérique n'est pas reconnu pas le module option, vous pouvez tenter de le faire détecter comme ceci :

echo 12d1 14cc > /sys/bus/usb-serial/drivers/option1/new_id

Observer ensuite le résultat dans les logs du kernel et si cela fonctionne vous pouvez automatiser cela via une règle UDEV de cette manière :

echo 'SUBSYSTEM=="usb", SYSFS{idVendor}=="12d1", SYSFS{idProduct}=="14cc", RUN="/usr/local/sbin/detect_usb_key"' > /etc/udev/rules.d/99-usbkey.rules
echo  -e '#!/bin/bash\nmodprobe option\necho "12d1 14cc" > /sys/bus/usb-serial/drivers/option1/new_id' > /usr/local/sbin/detect_usb_key
chmod 755 /usr/local/sbin/detect_usb_key

Cas particulier : Huawei E3131

Comme pour une clé Huawei K4511, il faut tout d'abord utiliser usbmodswitch pour basculer notre clé en mode modem. Pour cela, il faut une version assez récente du paquet usb_modswitch (prendre la version backports sous Debian Squeeze) qui intègre cette clé. Au cas ou, voilà le contenu du fichier de config :

TargetVendor=  0x12d1
TargetProduct= 0x14db

MessageContent="55534243123456780000000000000011062000000000000100000000000000"
NoDriverLoading=1

Mais Huawei a changé un peu la donne avec ces dernières clés en intégrant la techno Hi-Link (http://www.huawei.com/en/about-huawei/newsroom/press-release/hw-093761-e353-data-card.htm). Cette technos à pour but d'afficher à l'ordinateur un simple adaptateur USB Ethernet sur lequel à coup de DHCP on pourra tout simplement se connecter à Internet. C'est nikel si on veut simplement se connecter à Internet justement mais pour nous qui voulons envoyer des SMS…

Heureusement, on peut rebasculer la clé en mode modem série et même bloquer la clé dans ce mode !

Pour cela :

Faite un petit coup de DHCP sur l'interface USB ethernet (eth1 pour moi). Vous pouvez aussi simplement vous attribuer un IP dans le réseau 192.168.1.0/24.
Appeler l'URL HTTP suivante : http://192.168.1.1/html/switchProjectMode.html
La clé basculera alors en mode modem série. Si comme moi, le module option ne la détecte pas, c'est qu'il faut lui faire détecter manuellement :
```
echo "12d1 1442" > /sys/bus/usb-serial/drivers/option1/new_id
```
Il nous reste encore à la bloquer dans ce mode.
Connecté vous au premier device ttyUSB présent (/dev/ttyUSB0 pour moi) à l'aide d'un terminal, j'utilise minicom pour ma part :
```
minicom -D /dev/ttyUSB0
```
Une fois votre terminal connecté, lancer la commande AT suivante :
```
AT^U2DIAG=0
```
La réponse devrais être OK. Il est possible de revenir en arrière en procédant de la même manière et en appelant la commande AT suivante :
```
AT^U2DIAG=119
```
Débrancher et rebrancher la clé USB. Celle-ci devrais réapparaître sous de nouveaux identifiants : 12d1 1c05. Il est alors à nouveau nécessaire de la faire reconnaître par le module option :
```
echo "12d1 1c05" > /sys/bus/usb-serial/drivers/option1/new_id
```

Installer et configurer Gnokii

Installer le paquet Debian gnokii-cli :
```
apt-get install gnokii-cli
```
Editer le fichier de configuration et modifier la variable de configuration principale comme suit :
```
[global]
port = /dev/ttyUSB0
model = AT
connection = serial
```

Il se peut que votre clé fournisse plusieurs interface ttyUSB. Si la première, ttyUSB0 ne fonctionne pas, tenter avec les autres.

Faire un lien entre la configuration globale du système et celle utilisée par l'utilisateur root :
```
mkdir -p /root/.config/gnokii
ln -s /etc/gnokiirc /root/.config/gnokii/config
```

Vérifier que la clé est bien reconnu avec la commande :
```
:~# gnokii --identify
```

Si la clé est bien reconnu, vous devriez avoir quelques choses comme ça :

gnokii --identify
GNOKII Version 0.6.29
IMEI         : XXXXXXXXXXXXXXXXXXX
Manufacturer : Vodafone (Huawei)
Model        : K4511
Product name : K4511
Revision     : 11.810.09.19.287

Gestion du code PIN

Comme toute carte SIM, celle de la clé 3G doit recevoir un code PIN pour pouvoir être utiliser. Il est possible de le faire manuellement en utilisant la commande :

gnokii --entersecuritycode PIN

Il est possible de savoir si le code PIN a déjà été saisi ou non en utilisant la commande :

gnokii --getsecuritycodestatus

Pour automatiser la saisi du code PIN, vous pouvez utiliser le script gnokii-init-modem.pl. Celui-ci communique directement avec la clé pour vérifier si elle attend le code PIN et lui donner si nécessaire. Il est nécessaire d'éditer ce script pour adapter les variables ce configuration suivante :

$port_name : Le chemin du device ttyUSB a utiliser
$pin : le code PIN

Vous devez installer le paquet Debian libdevice-serialport-perl requis pour l'utilisation de ce script.

Mettre en place la passerelle mail -> SMS

Installer le paquet Debian libemail-simple-perl
Ajouter l'utilisateur gnokii et l'ajouter dans le group dialout :
```
adduser --system gnokii
adduser gnokii dialout
```
Installer le script mail2gnokii dans le dossier /usr/local/sbin
Adapter les variables de configurations du script :
- smsc : le numéro de centre de messagerie de votre opérateur mobile (Liste ici)
  - authorized_number : liste de numéro de téléphone destinataire autorisé
  - gnokii_config : le fichier de configuration pour gnokii à utiliser

Ajouter le transport suivant dans votre fichier master.cf :

sms unix    -       n       n       -       1       pipe
  flags=Rq user=gnokii:dialout argv=/usr/local/sbin/mail2gnokii ${user}

L'utiliser pour le domaine de votre choix, exemple sms.example.tld. Pour cela, ajouter dans votre fichier transport :
```
sms.example.tld    sms
```
Regénérer le fichier transport.db et recharger la configuration de Postfix :
```
postmap /etc/postfix/transport
/etc/init.d/postfix reload
```

Le contenu du SMS envoyé est le sujet du mail (header Subject).

Mode d'emploi de la plate-forme

Une fois cette plate-forme en place, vous pourrez envoyer des SMS simplement en envoyant des mails avec des adresses sous la forme 0600000000@sms.example.tld. Seul le sujet de votre mail sera envoyé par SMS.

Pour que cela fonctionne, il faudra bien entendu faire en sorte que vous vous arrangiez pour que le domaine sms.example.tld soit relayé vers votre serveur faisant office de passerelle SMS. Attention cependant à faire en sorte que votre passerelle ne soit pas trop accessible (depuis le web par exemple) pour éviter que n'importe qui puisse envoyé des SMS en faisant grimper votre facture ;)

Initialisation manuelle de la clé au reboot ou à la reconnexion de la clé

Au reboot de la machine ou à la reconnexion de la clé USB, il peut être nécessaire d'activer soit même manuellement la clé, c'est à dire :

Lancer le switch de mode de la clé manuellement :

usb_modeswitch -c /etc/usb_modeswitch.d/12d1\:14b7

Si votre clé n'est pas automatiquement par le kernel :
```
detect_usb_key
```
Vérifier que votre clé est maintenant bien détectée :
```
gnokii --identify
```
Finalement, initialiser la clé en entrant le code PIN :
```
gnokii-init-modem
```

Il peut arriver que le périphérique ttyUSBX change, il faudra donc modifier manuellement dans les fichiers /etc/gnokiirc et /usr/local/sbin/gnokii-init-modem le périphérique à utiliser.

Utilisation pour les notifications Nagios

Pour utiliser votre passerelle SMS pour les notifications Nagios il vous faudra définir dans Nagios un contact sous cette forme :

define contact{
        contact_name                    joe_sms
        alias                           Joe (by SMS)
        host_notification_period        24x7
        service_notification_period     24x7
        host_notification_options       d,u,r
        service_notification_options    w,u,c,r
        host_notification_commands      host-notify-by-epager
        service_notification_commands   service-notify-by-epager
        pager                           0600000000@sms.example.tld
}

Par défaut, vous recevrez des messages sous la forme :

Pour les services : $NOTIFICATIONTYPE$: $HOSTALIAS$/$SERVICEDESC$ is $SERVICESTATE$
Pour les machines : $NOTIFICATIONTYPE$ alert - Host $HOSTNAME$ is $HOSTSTATE$

Si cela ne vous conviens pas, définissez vos propres commandes en vous inspirant de celle par défaut.

Ajouter/supprimer un numéro de téléphone portable destinataire

Le script mail2gnokii comporte une sécurité pour éviter que la passerelle soit utilisée pour envoyer des SMS à n'importe qui. La liste exhaustive des numéros de téléphone portable destinataires doit être définie dans la variable de configuration authorized_number du script.

Pour ajouter ou supprimer un numéro de téléphone de cette liste, il faut donc éditer le fichier /usr/local/sbin/mail2gnokii et modifier la variable authorized_number :

@authorized_number=("0600000000","0700000000");