Da Hug Page

Dans la large gamme des produits Cisco, on retrouve le Cisco CallManager.
C’est un IPBX, on parle donc de voix sur IP (VoIP), et ici de la version 4.2(3).

Je ne discuterais pas de l’interface un rien complexe de l’interface d’administration (/ccmadmin/) ou de l’interface utilisateur (/ccmuser/).

Parmis tous les services qui tournent sur le serveur, deux m’ont particulièrement attiré.

1. Cisco Web Dialer API Reference Guide for Cisco Unified CallManager 4.2(3)
2. Cisco AXL Programming Guide for Cisco Unified CallManager 4.2(3)

Le premier présente l’application WebDialer qui permet de piloter son poste téléphonique en initiant des appels à partir de son navigateur préféré. Mais détaille aussi le moyen de passer des ordres SOAP pour faire comme l’application Webdialer mais sans ouvrir une popup du navigateur…

Le deuxième permet de passer des ordres SOAP au Cisco CallManager, et donc aux plus courageux de développer une interface d’administration du serveur.

Je me suis donc amusé à coder un WebService en PHP pour initier des appels sur un CallManager.
Ce Webservice étant par la suite utilisé par un Yahoo! Widget dévelloper par mes soins pour un client.

Paramètres
Pour les exemples ci-dessous nous considèrerons que :

• Hostname du CallManager : mon.callmanager.com
• Utilisateur SOAP : soapuser
• Mot de passe SOAP : secret
• $userid : userid de l’utilisateur connecté sur le poste téléphonique IP.
• $codepin : le code PIN de l’utilisateur
• $destination : le numéro a appeler
• $deviceName : le profile associé au poste téléphonique IP.

Webdialer SOAP API

Pour initier un appel

<?php
/*
plus rapide qu’il soit en local que sur le CallManager
Distant : http://mon.callmanager.com/webdialer/wsdl/WebdialerSoap.wsdl
*/
$wsdl = ‘/path/to/cisco/WebdialerSoap.wsdl’;
$location = ‘http://mon.callmanager.com/wdsoap/servlet/rpcrouter’;

$options = array(
‘uri’ => ‘urn:WebdialerSoap’,
‘location’ => $location,
‘connection_timeout’ => 10,
‘soap_version’ => SOAP_1_1,
);

$client = new SoapClient( $wsdl, $options);

$params = array(
‘Credential’ => array(
‘userID’ => $userid,
‘password’ => $codepin,
),
‘dest’ => $destination,
‘UserProfile’ => array(
‘user’ => $userid,
‘deviceName’ => $deviceName,
‘lineNumber’ => $codepin,
‘supportEM’ => true,
‘locale’ => ‘FR’
),
);

$response = $client->__soapCall(‘makeCallSoap’, $params);
/* ou */
/*
$response = $client->makeCallSoap($params);
*/
?>

Et pour raccrocher :


<?php
$wsdl = '/path/to/cisco/WebdialerSoap.wsdl';
$location = 'http://mon.callmanager.com/wdsoap/servlet/rpcrouter';

$options = array(
‘uri’ => ‘urn:WebdialerSoap’,
‘location’ => $location,
‘connection_timeout’ => 10,
‘soap_version’ => SOAP_1_1,
);

$client = new SoapClient( $wsdl, $options);

$params = array(
‘Credential’ => array(
‘userID’ => $userid,
‘password’ => $codepin,
),
‘UserProfile’ => array(
‘user’ => $userid,
‘deviceName’ => $deviceName,
‘lineNumber’ => $codepin,
‘supportEM’ => true,
‘locale’ => ‘FR’
),
);

$response = $client->__soapCall(‘endCallSoap’, $params);
/* ou */
/*
$response = $client->endCallSoap($params);
*/
?>

Les informations relatives au $deviceName sont récupérés par un appel similaire à la méthode SOAP « getProfileSoap ».

Exemple :

<?php
$wsdl = '/path/to/cisco/WebdialerSoap.wsdl';
$location = 'http://mon.callmanager.com/wdsoap/servlet/rpcrouter';

$options = array(
‘uri’ => ‘urn:WebdialerSoap’,
‘location’ => $location,
‘connection_timeout’ => 10,
‘soap_version’ => SOAP_1_1,
);

$client = new SoapClient( $wsdl, $options);

$params = array(
‘Credential’ => array(
‘userID’ => $userid,
‘password’ => $codepin,
),
‘userid’ => $userid,
);

$response = $client->__soapCall(‘getProfileSoap’, $params);
/* ou */
/**/
$response = $client->getProfileSoap($params);

if (is_soap_fault($response)) {
trigger_error(« SOAP Fault: (faultcode: {$result->faultcode}, faultstring: {$result->faultstring}) », E_USER_ERROR);
}

var_dump( $response );
?>

Le problème c’est que la méthode « getProfileSoap » n’est pas utilisable dans un environement « Extension mobility ».

Et donc il faut faire appel à AXLAPI.

AXL API
La on va taper dans la base de données du CallManager grace à une méthode SOAP : executeSQLQuery.


<?php
$wsdl = '/path/to/cisco/AXLAPI.wsdl';
$location = 'http://mon.callmanager.com/CCMApi/AXL/V1/AXLAPI.wsdl';

$options = array(
‘login’ => ‘soapuser’,
‘password’ => ‘secret’,
‘location’ => $location,
‘connection_timeout’ => 10,
‘soap_version’ => SOAP_1_1,
);

$client = new SoapClient( $wsdl, $options);

$params = array(
‘sql’ => sprintf(« SELECT TOP 1 Name FROM Device WHERE LoginUserid = ‘%s’ AND Name LIKE ‘SEP%%’; », $userid)
);

$response = $client->executeSQLQuery($params);

if (is_soap_fault($response)) {
trigger_error(« SOAP Fault: (faultcode: {$result->faultcode}, faultstring: {$result->faultstring}) », E_USER_ERROR);
}

var_dump( $response );
?>

Noter comme l’authentification entre la WebdialerAPI et la AXLAPI sont différents.
Les paramètres Credential sont implémentés de manières différentes.

have fun
hug

Objectif:
Installer un serveur Cobalt Raq 3/3i/4/550 sans avoir besoin de démonter le disque dur, et donc via le réseau.

Moyens:
Les RaqX sont équipés de carte réseau PXE.
C’est à dire que le serveur peut booter à travers le réseau, et charger un mini système en mémoire.
A partir de là il est possible de préparer le disque du Raq en y installant un système de base.
Pour cet exercice nous allons utiliser une Debian.

NB:
Ce document reprend une partie des informations citées par Zone38 ici.
Pour les raq3/3i/4 il sera nécessaire de flasher la ROM du Raq, PAS LES 550.

Etapes:
Dans un premier temps nous allons configurer notre serveur debootstrap : bootp, dhcp, tftp.
Puis nous configurons un environement minimal sur ce serveur.
Enfin nous ferons booter le Raq à travers le réseau sur ce système minimal, ce qui nous permettra de le préparer pour un boot autonome.

1. Préparation du serveur debootstrap

Installation des packages nécessaires :


# aptitude install dhcp3-server syslinux tftpd-hpa


dhcp3-server :
Ce service nous permettra d’attribuer une IP à notre Raq, et d’indiquer le serveur bootp.

syslinux :
Ceci est un boot loader permettant l’installation de Linux sur des systèmes distants ayant des partitions MS-DOS/Windows FAT.
Il est concu pour simplifier l’instalalation de Linux, et la création de disquette de rescue, ou d’autre disque de boot.
Il peut notament être utilisé comme bootloader PXE pour des boot à travers le réseau.

tftpd-hpa :
Service TFTP dérivé de OpenBSD. Très utile dans le cas d’installation via PXE.
Ce service sera pris en charge par inetd.

1.1. Configuration du tftp et du PXE.

Copier /usr/lib/syslinux/pxelinux.0 dans /var/lib/tftpboot :


# cp /usr/lib/syslinux/pxelinux.0 /var/lib/tftpboot/


Ensuite créer le dossier pxelinux.cfg dans /var/lib/tftpboot :


cd /var/lib/tftpboot
mkdir pxelinux.cfg


Puis créer le fichier /var/lib/tftpboot/pxelinux.cfg/default qui va contenir :


vim pxelinux.cfg/default


avec les lignes suivantes :

PROMPT 0
DEFAULT pxe
LABEL pxe
KERNEL vmlinuz
APPEND initrd=initrd.img root=/dev/nfs nfsroot=192.168.107.77:/nfsroot-x86
IPAPPEND 1

Explications :
On défini en fait le kernel, et les parametres à passer au noyau :

- KERNEL vmlinuz : donc il va chager le kernel nommé vmlinuz dans /var/lib/tftpboot.
- APPEND : listes des paramètres à passer au kernel :
. initrd=initrd.img : chargera initrd.img à partir de /var/lib/tftpboot
. root=/dev/nfs : le root sera sur un disque NFS
. nfsroot=192.168.107.77:/nfsroot-x86 : chemin d’accès au partage.

A noter qu’ici l’IP 192.168.107.77 correspond à celle de votre serveur debootstrap.

1.2. Installation et configuration du NFS.

Une fois que notre Raq aura booté, il cherchera à monter une partition NFS à travers le réseau.
Il faut donc installer un serveur NFS, et le configurer de manière à ce que le Raq y trouve un système complet.

1.2.1 Installation du serveur NFS.

Pour plus de simplicité on choisirat la version userland du NFS de la debian.


# aptitude install nfs-user-server


1.2.2. Configuration du NFS.


# mkdir /nfsroot-x86


Edition du fichier /etc/exports :


# vim /etc/exports


Ajouter la ligne suivante :

/nfsroot-x86 192.168.107.78 (rw,no_root_squash)

- /nfsroot-x86 : correspond au partage.
- 192.168.107.78 : l’ip du Raq après requète DHCP.
- rw : Read Write (c’est mieux de pouvoir ecrire)
- no_root_squash : parce que sinon toute action en root est transformé en nobody…

Relancer le service NFS :


# /etc/init.d/nfs-user-server restart


1.2.3. Installation du système minimal dans ls NFS.

Pour cela on utilise debootstrap, ce qui permet de faire une install de base Debian.


# aptitude install debootstrap
# debootstrap sarge /nfsroot-x86 http://ftp2.fr.debian.org/debian/


debootstrap va alors télécharger, puis vérifier un ensemble de package, et enfin les installer.

I: Retrieving debootstrap.invalid_dists_sarge_Release
I: Validating debootstrap.invalid_dists_sarge_Release
I: Retrieving debootstrap.invalid_dists_sarge_main_binary-i386_Packages
I: Validating debootstrap.invalid_dists_sarge_main_binary-i386_Packages
I: Checking adduser...
I: Checking apt...
I: Checking apt-utils...
I: Checking aptitude...
I: Checking at...
I: Checking base-config...
I: Checking base-files...
I: Checking base-passwd...
I: Checking bash...
I: Checking bsdmainutils...
I: Checking bsdutils...
....
Setting up base-config (2.53.10) ...

I: Base system installed successfully.
umount: /nfsroot-x86/dev/pts: not mounted
umount: /nfsroot-x86/dev/shm: not mounted
umount: /nfsroot-x86/proc/bus/usb: not mounted

Puis nous modifions le /etc/fstab afin de luis rajouter une ligne pour


# vim /etc/fstab


proc            /nfsroot-x86/proc proc  defaults        0       0

Enfin nous monter /nfsroot-x86/proc :


# mount proc /nfsroot-x86/proc -t proc


Notre « boot-système » est presque prêt.
Nous allons apporter quelques mofication spécifique au Raq.

1.2.4 Quelques fichiers utiles

S’assurer que le fichier /nfsroot-x86/etc/resolv.conf existe et qu’il est semblable au votre, sinon le copier à partir de /etc/resolv.conf


# cp /etc/resolv.conf /nfsroot-x86/etc/resolv.conf


Copier votre fichier sources.list pour apt :


# cp /etc/apt/sources.list /nfsroot-x86/etc/apt/


Modifier le fichier /etc/inittab :


# vim /etc/inittab


...
# Example how to put a getty on a serial line (for a terminal)
#
T0:23:respawn:/sbin/getty -L ttyS0 115200 vt102
T1:23:respawn:/sbin/getty -L ttyS1 115200 vt102
...

Cela permettra d’accèder au Raq via un cable console, pour la suite de l’installation.

1.2.5. Installation de quelqueq paquets utiles :


{chroot}# aptitude install vim sudo
{chroot}# visudo


Si RAID soft :

{chroot}# aptitude install mdadm


Il y a la possibilité d’installer ssh, dans ce cas je vous conseille alors de modififer le fichier /etc/ssh/sshd_config pour qu’il écoute sur l’IP de votre


{chroo}# aptitude install ssh
{chroo}# vi /etc/ssh/sshd_config


- #ListenAddress 0.0.0.0
+ ListenAddress 192.168.107.78

Entrer dans /nfsroot-x86 avec chroot :


# chroot /nfsroot-x86 /bin/bash


Là vous pouvez lancer base-config pour finaliser l’installation du deboostrap.


{chroot}# base-config


1.3. Configuration du serveur DHCP

Nous allons récupérer l’adresse MAC du Raq.
Pour cela raccorder un cable série en 15200 n 8.

Puis lancer minicom avec les bons paramètres, et allumer le Raq.
Dans la séquence de boot du Raq vous devez voir ceci (exemple tiré d’un Raq550):

...
Initializing ethernet: 2 controller(s) found
  National Semiconductor DP83815 Found at port 0xfe00, MAC: 00:10:e0:05:ef:03
  National Semiconductor DP83815 Found at port 0xfd00, MAC: 00:10:e0:05:ef:c6
...

C’est la première ligne qui nous intéresse.

Editer le fichier de configuration de votre serveur DHCP :


# vim /etc/dhcp3/dhcpd.conf


Et ajouter les lignes suivantes :

host cobalt_pxe {
        hardware ethernet 00:10:e0:05:ef:03;
        filename "/pxelinux.0";
        server-name "backup";
        next-server 192.168.107.77;
        fixed-address 192.168.107.78;
}

Retirer les « \ » c’est WordPress qui les rajoute

Et relancer votre service dhcpd


# /etc/init.d/dhcp3-server restart


2. Configuration du Cobalt

Le processus de boot du Cobalt est le suivant :

1. booter sur la ROM et charger en RAM un mini noyau Linux
2. Selon l’option de boot (Net,Disk,etc ..) le Raq va alos chercher un faire un deuxième boot sur un kernel vmlinuz

Il est possible de configurer le Raq pour booter sur le réseau.
Pour cela, via minicom, dans la séquence de boot du Raq vous devez voir ceci :

IDE: stabilizing spinup: 100%
Checking Memory: done

Press spacebar to enter ROM mode

Taper sur la barre d’espace, et voilà vous êtes dans la ROM.

Maintenant nous allons dire au Raq qu’au prochain reboot il devra booter sur le réseau et sur l’IP de notre serveur :

Cobalt:Main Menu> boot

Cobalt:Boot Menu> read_boot_type
From disk

Cobalt:Boot Menu> read_boot_dev
md1

Cobalt:Main Menu> lowlevel

{si pas de dhcp}
Cobalt:Lowlevel Hardware Menu> cmos

Cobalt:CMOS Menu> btoip 192 168 107 77
{/fi}

Cobalt:CMOS Menu> main

Cobalt:Main Menu> bfn

Vérifier dans les logs de votre serveur bootstrap que le NFS est bien pris en compte :


# tail -f /var/log/syslog


May 11 13:59:21 localhost mountd[10989]: NFS mount of /nfsroot-x86 attempted from 192.168.107.78
May 11 13:59:21 localhost mountd[10989]: /nfsroot-x86 has been mounted by 192.168.107.78

Voilà, dans le minicom vous devez voir apparaitre un prompt Debian.

3. Installation du Cobalt

Nous allons préparer le disque du Raq pour accueillir une Debian.

3.1 Partitionner et formater le disque


{serial}# fdisk /dev/hda


Exemple :

   Device Boot         Start         End      Blocks   Id  System
   /dev/hda1               1       19842    10000336+  83  Linux                 /
   /dev/hda2           19843       21827     1000440   82  Linux swap / Solaris  swap
   /dev/hda3           21828       41669    10000368   82  Linux                 /var
   /dev/hda4           41670       77545    18081504   82  Linux                 /opt

Dans le cas d’une configuration de raid logiciel :

# fdisk /dev/hda

Command (m for help): p

Disk /dev/hda: 40.0 GB, 40020664320 bytes
16 heads, 63 sectors/track, 77545 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/hda1               1        7938     4000720+  fd  Linux raid autodetect
/dev/hda2            7939        9923     1000440   fd  Linux raid autodetect
/dev/hda3            9924       17841     3990672   fd  Linux raid autodetect
/dev/hda4           17842       77545    30090816   fd  Linux raid autodetect

# fdisk /dev/hdc

Command (m for help): p

Disk /dev/hdc: 40.0 GB, 40020664320 bytes
16 heads, 63 sectors/track, 77545 cylinders
Units = cylinders of 1008 * 512 = 516096 bytes

   Device Boot      Start         End      Blocks   Id  System
/dev/hdc1               1        7938     4000720+  fd  Linux raid autodetect
/dev/hdc2            7939        9923     1000440   fd  Linux raid autodetect
/dev/hdc3            9924       17841     3990672   fd  Linux raid autodetect
/dev/hdc4           17842       77545    30090816   fd  Linux raid autodetect

Puis formater les partitions :


{serial}# mke2fs -r 0 -O none /dev/hda1
{serial}# mke2fs /dev/hda3
{serial}# mke2fs /dev/hda4
{serial}# mkswap /dev/hda2
{serial}# swapon /dev/hda2


Ensuite on les monte dans /mnt :


{serial}# mount /dev/hda1 /mnt
{serial}# mkdir /mnt/var
{serial}# mount /dev/hda3 /mnt/var
{serial}# mkdir /mnt/opt
{serial}# mount /dev/hda4 /mnt/opt


Dans le cas d’un RAID 1 soft :

a. Création du raid

{serial}# mdadm --create /dev/md1 --level 1 --raid-devices=2 /dev/hda1 /dev/hdc1
{serial}# mdadm --create /dev/md2 --level 1 --raid-devices=2 /dev/hda2 /dev/hdc2
{serial}# mdadm --create /dev/md3 --level 1 --raid-devices=2 /dev/hda3 /dev/hdc3
{serial}# mdadm --create /dev/md4 --level 1 --raid-devices=2 /dev/hda4 /dev/hdc4

b. Vérification de la synchronisation

{serial}# cat /proc/mdstat

c. Configuration du RAID

{serial}# mdadm --detail --scan
{serial}# mdadm --detail --scan > /etc/mdadm.conf

d. Formatage des partitions et montage

{serial}# mke2fs -r 0 -O none /dev/md1
{serial}# mke2fs /dev/md3
{serial}# mke2fs /dev/md4
{serial}# mkswap /dev/md2
{serial}# swapon /dev/md2
{serial}# mount /dev/md1 /mnt/
{serial}# mkdir /mnt/var
{serial}# mount /dev/md3 /mnt/var
{serial}# mkdir /mnt/opt
{serial}# mount /dev/md4 /mnt/opt

3.2. Installation d’un système de base.

Maintenant nous allons lancer un debootstrap pour construire un system dans /mnt


{serial}# debootstrap sarge /mnt http://ftp2.fr.debian.org/debian/


Nous allons copier quelques fichiers , i.e. les même qu’à l’étape 1.2.4.

Dans le cas d’un RAID soft, copier le fichier mdadm.conf


{serial}# cp /etc/mdadm.conf /mnt/etc/mdadm.conf


Il faut aussi penser à monter /mnt/proc :


{serial}# mount proc /mnt/proc -t proc


Puis nous entrons dans le nouveau système avec chroot :


{seria}# chroot /mnt /bin/bash


3.3. Configuration du système

Une fois dans le chroot je lance quelques commandes :


{serial-chroot}# base-config
{serial-chroot}# aptitude update
{serial-chroot}# aptitude dist-upgrade



{serial-chroot}# aptitude install vim sudo
{serial-chroot}# visudo


Si RAID soft :

{serial-chroot}# aptitude install mdadm


3.4. Compilation d’un kernel (selon la doc)

3.4.1. Récupération du kernel

{serial-chroot}# aptitude install vim libncurses5-dev kernel-package gcc make ncftp
{serial-chroot}# cd /usr/src
{serial-chroot}# ncftp ftp.free.fr

{serial-chroot}> cd pub/linux/kernel


Si RAID soft :

{serial-chroot}# aptitude install mdadm


3.4. Compilation d’un kernel (selon la doc)

3.4.1. Récupération du kernel

{serial-chroot}# aptitude install vim libncurses5-dev kernel-package gcc make ncftp
{serial-chroot}# cd /usr/src
{serial-chroot}# ncftp ftp.free.fr

{serial-chroot}> cd pub/linux/kernel
{serial-chroot}> cd v2.4
{serial-chroot}> get linux-2.4.32.tar.gz
{serial-chroot}> quit


3.4.2. Décompression du kernel

{serial-chroot}# tar xfz linux-2.4.32.tar.gz


3.4.3. Récupération du patch et du fichier de configuration du kernel

{serial-chroot}# sync
{serial-chroot}# wget http://hugues.lepesant.com/stuff/cobalt/cobalt-2.4.32.patch
{serial-chroot}# wget http://hugues.lepesant.com/stuff/cobalt/conf_cobalt-RaqXXX_2432


XXX = 34 pour les Raq3, Raq3i, et Raq4
XXX = 550 pour le Raq550

3.4.4. Configuration et compilation du kernel

{serial-chroot}# ln -s linux-2.4.32 linux
{serial-chroot}# patch -p 0 < cobalt-2.4.32.patch
{serial-chroot}# cp conf_cobalt-RaqXXX_2432 linux/.config
{serial-chroot}# cd linux
{serial-chroot}# make menuconfig
{serial-chroot}# vim /etc/kernel-pkg.conf
{serial-chroot}# make-kpkg clean
{serial-chroot}# make-kpkg --revision=cobalt.1.0 kernel_image
{serial-chroot}# make-kpkg modules_image


3.4.5. Préparation du Cobalt

{serial-chroot}# vi /etc/kernel-img.conf
{serial-chroot}# mkdir /etc/cobalt
{serial-chroot}# vi /etc/cobalt/kernel_cobalt_install.sh
{serial-chroot}# vi /etc/cobalt/kernel_cobalt_remove.sh
{serial-chroot}# chmod u+x /etc/cobalt/kernel_cobalt*.sh


3.4.6. Installation du kernel

{serial-chroot}# cd /usr/src
{serial-chroot}# dpkg -i kernel-image-2.4.32_cobalt.1.0_i386.deb
{serial-chroot}# cd /boot
{serial-chroot}# ln -sf System.map-2.4.32 System.map


3.4.7. Configuration du Cobalt

{serial-chroot}# vim /etc/network/interface
{serial-chroot}# vim /etc/hosts
{serial-chroot}# vim /etc/inittab
{serial-chroot}# vim /etc/default/rcS
{serial-chroot}# exit


3.4.8. Reboot

{serial}# reboot


Et voilà, vous pouvez suivre le boot de votre Cobalt via le cable console et minicom.