Le Guide du ROOTard pour Linux: Communiquer
Description: Ce document regroupe l'adaptation d'articles parus dans la Linux-Gazette. Merci à Nat Makarévitch pour ses relectures et Joël Bernier pour la mise en page HTML.
Keywords: Linux, francais, français, france, GNU, FSF, Debian, Redhat, Slackware, Mandrake, kheops, document, documentation, logiciel, libre, informatique, free, software, open, source, sourceware, freeware, soleil, support, assistance, hot line

> - Page suivante Page précédente Table des matières ## 13. Communiquer ## 13.1 UUCP et modem UUCP (Unix to Unix CoPy) vous permet de transférer des fichiers et d'exécuter certaines commandes sur une machine distante sous forme de batches. Ce système permet ainsi de transférer du courrier électronique, des news et des fichiers. En fait, ce protocole permet d'effectuer un transfert de fichiers et d'exécuter certaines commandes en fonction du type de fichier (par exemple `rmail` et `rnews`). Cela permet à une machine non connectée en permanence à l'Internet d'avoir accès à la messagerie et aux groupes de discussions. Bien que ce protocole ait près de vingt ans, il est toujours particulièrement adapté. Un exemple : bien que je sois aux Etats-Unis à l'heure actuelle, je reçois toutes mes news ainsi que la plupart de mon courier via UUCP depuis la France (sur une liaison TCP/IP). Avant de continuer, nous supposons que vous avez installé le paquetage Taylor UUCP, un lecteur de courrier électronique (`elm`, `mutt`, etc.), `sendmail`, un serveur de news (`inn`) et un lecteur de news. UUCP a besoin de plusieurs fichiers de configuration qui se trouvent dans `/etc/uucp` (les chemins d'accès peuvent varier d'une installation à l'autre). Si vous aviez une configuration fondée sur HDB, le paquetage Taylor contient un outil qui permet d'effectuer une conversion automatique de vos fichiers. Cela fonctionne très bien. `sys` : il s'agit du fichier principal. On y définit les interlocuteurs, les protocoles utilisés, etc... Une configuration simple (serveur perceval) :
>       # Ce qui suit les '#' est du commentaire.

>        protocol itejgv # Je ne suis pas difficile, j'accepte [presque] tout.

>        system latulipe # L'identifiant du systeme distant.
>        call-login * # Le compte UUCP sur la machine distante ('*' renvoie sur le fichier call).
>        call-password * # Son mot de passe (ici, '*' renvoie sur le fichier call).
>        local-send / # Ces repertoires sont ceux accessibles (en fonction du transfert).
>        local-receive /var/spool/uucppublic
>        remote-send /
>        remote-receive /var/spool/uucppublic.
>        time any # On peut établir une connexion à tout moment.
>        phone 0102030405 # Le numéro à appeler.
>        port ACU # L'identifiant du port, voir fichier port.
>        chat "" \r\c ogin:-BREAK-ogin:-BREAK- \L word: \P # Le dialogue pour la
>        # connexion. Il faut voir aussi le fichier dial qui se charge de la partie
>        # initialisation modem et appel.
>   Dans le cas d'une configuration un peu plus complexe (machine latulipe) :
>        remote-send ~ # Là, on se limite au repertoire utilisateur d'uucp
>        remote-receive ~
>        local-send ~
>        local-receive ~
>        command-path /usr/sbin /usr/bin # Le chemins des commandes
>        commands rmail rnews # Les commandes autorisées
>        time any # Appel à toute heure - ne pas mettre le téléphone sur la même ligne! :-)

>        system excalibur
>        port type TCP # Connection via TCP/IP sur service uucp
>        address glou.machine.fr # La machine distante
>        call-login uutulipe # Mon nom utilisateur
>        call-password ***censuré*** # Mon mot de passe

>        system perceval # Identifiant
>        port ACU
>        protocol i # Protocole i, il permet de faire du full-duplex et de la récupération sur erreurs, interessant pour une ligne série.
>        call-login uutulipe
>        call-password ***censuré***
>        phone 0102030406
>        alternate # Une autre forme de connexion, au cas où la première échoue
>        port type TCP
>        address perceval.uic.asso.fr
>        protocol t # Protocole t, pas de gestion d'erreur (déjà gérée par TCP/IP)
> - On peut voir que, dans ce dernier cas, si une connexion modem sur perceval échoue (par exemple le modem est déjà utilisé pour une connexion ppp ;-), UUCP essaie de s'y connecter avec la seconde solution (au dessus de TCP/IP). Dans la partie alternate, on ne précise que les différences avec la solution principale (notament, il n'est pas utile de repréciser le login, password, etc...) D'autre part, les scripts de connexion n'ont pas été défini (il y a habituellement un script de connexion par défaut qui est suffisant dans les cas standards). `port` : la configuration des ports d'appel UUCP
>        #
>        # Connexion Série
>        #
>        port ACU
>        type modem # type du port, principaux choix : modem, direct, tcp.
>        device /dev/ttyS0 # périphériques.
>        dialer hayes # Identifiant pour le script d'appel, voir fichier dial.
>        speed 115200 # Débit.
>        #
>        # Connexion par TCP
>        #
>        port TCP
>        type tcp
>        seven-bit false
>        reliable true
>        half-duplex false
>        service uucp
> - > `dial` : le script d'appel `
>   >      dialer hayes # Correspond à la définition du port dans le fichier port.
>   >      chat "" ATZ\r\c\d\d OK\r ATQ0M0E0\r\c OK\r AT&K1\r\c OK\r ATDT\T\r\c CONNECT \d\d
>   >      chat-fail RING\r
>   >      chat-fail NO\sCARRIER
>   >      chat-fail ERROR
>   >      chat-fail NO\sDIALTONE
>   >      chat-fail BUSY
>   >      chat-fail NO\sANSWER
>   >      chat-fail VOICE
>   >      complete \d\d+++\d\dATH\r\c
>   >      abort \d\d+++\d\dATH\r\c
> - ` Ici aussi, rien de très compliqué. Il faut essentiellement réadapter la seconde ligne (chat) pour les chaines d'initialisation de son modem. `call` : les logins/passwords pour se connecter aux systèmes distants Configuration de perceval :
>       latulipe        uupercev        ***censuré***
> - Traduction : si on se connecte sur le serveur latulipe, on utilise uupercev comme nom d'utilisateur uucp et ***censuré*** comme mot de passe. On peut utiliser le fichier `call` pour laisser en accès libre le fichier `sys` (car il ne contient plus les logins/passwords) mais il faut alors limiter les accès à ce fichier. `password` : les logins/passwords des comptes UUCP hébergés Configuration de perceval :
>        uutulipe        ***censuré***
> - Traduction : il existe un compte uutulipe qui a le droit de se connecter (avec ***censuré*** comme mot de passe). Si ce fichier n'existe pas, la connexion peut être authentifiée avec le fichier `/etc/passwd` (il faut alors compiler UUCP avec les bonnes options... Dans mon cas, je ne voulais pas voir les comptes UUCP apparaître comme utilisateurs). Les plus sérieux compileront UUCP en activant l'option HAVE_ENCRYPTED_PASSWORDS pour utiliser des mots de passes cryptés dans ce fichier. `config` Configuration de perceval :
>        nodename        perceval
> - Normalement, le nom UUCP est celui de la machine. Néanmoins, vous pouvez définir le nom que vous voulez. Il existe d'autres options, mais qui dépassent le cadre d'un site UUCP artisanal... Maintenant, le système est configuré. Il n'y a plus qu'à le tester... Pour visualiser la configuration, vous pouvez utiliser la commande `uuchk`. Il n'y a plus qu'à configurer son serveur pour qu'il accepte les connexions UUCP (démon uucico) : Fichier `/etc/passwd` Une des manipulations les plus basiques pour mettre en place un feed uucp est de rajouter une ligne dans le fichier `/etc/passwd` (machine latulipe) :
>        uupercev:JuNKieSPW:1000:1000:Compte UUCP Perceval:/var/spool/uucppublic:/usr/sbin/uucico
>   Cela sous entend que son script de connexion ressemble à quelque chose comme :
>        telnet\slatulipe.freenix.fr ogin: \L word: \P
> - Cette configuration est utilisable également avec une connexion modem lorsque ce dernier est géré comme un terminal (cf `agetty` et autres). Connection TCP/IP Service UUCP Très simple, il suffit de vérifier que le fichier `/etc/services` contient bien la ligne :
>       uucp            540/tcp         uucpd           # BSD uucpd(8) UUCP service
>   et que le fichier `/etc/inetd.conf` contienne :
>       uucp   stream  tcp     nowait  uucp    /usr/sbin/tcpd  /usr/lib/uucp/uucico -l
> - La commande `/usr/sbin/tcpd` correspond aux tcp-wrappers, elle est court-circuitable mais je vous recommande plutôt de la garder et de jeter un coup d'oeil à la configuration des dits tcp-wrappers. Mgetty Dans le cas de `mgetty`, on peut utiliser le fichier `/etc/mgetty/login.config` pour y inserer (ou decommenter) la ligne :
>       # username  userid  utmp_entry  login_program        [arguments]
>         U*        uucp    @           /usr/lib/uucp/uucico -l -u @
> Ainsi, au lieu de se connecter via `login`, on passe directement à `uucico` (sur perceval ou latulipe, le `U*` est un `uu*` correspondant aux uutulipe et autres uuperceval). Bien sûr, rien n'empêche un mélange de tous les genres... Dans tous les cas, si vous cherchez de plus amples renseignements, pensez à consulter la documentation fournie avec le paquetage Taylor. Il existe de plus un excellent livre chez O'Reilly sur UUCP. C'est un peu la bible du genre, n'hésitez donc pas à vous plonger dedans. ## 13.2 Appels entrants Bon. Au point où l'on en est, vous pouvez appeler. Maintenant, on va configurer la machine pour que le monde extérieur puisse appeler. Tout se joue dans le fichier `/etc/inittab`. Décommenter une ligne comme par exemple :
>     s1:45:respawn:/sbin/agetty -h -t 60 9600 modem
>     |   |    |                  |    |    |     |--- Port a utiliser
>     |   |    |                  |    |    |--------- Vitesse du modem
>     |   |    |                  |    |--- Temps au bout duquel on racroche
>     |   |    |                  |-------- Active le controle de flux rts/cts
>     |   |    |------------- A relancer lorsqu'il se termine
>     |   |------------------ Runlevels.
>     |---------------------- Identificateur
> Donc, au prochain boot, un système de login est prêt sur le port `/dev/modem` (port série sur lequel est connecté le modem). Le dernier problème est de le configurer. En effet, le modem doit être positionné pour la vitesse. En fait, cela dépend du modem. Si jamais vous pouvez positionner des switch, rendez le modem muet (`ATQ2`) et surtout, mettez-le en auto-reponse (`ATS0=1`). Si vous n'avez pas de switches, faîtes un `AT&W` pour sauvegarder les paramètres. Pour vérifier la config, utilisez `/usr/lib/uucp/uuchk`. Si vous voulez d'autres renseignements, je vous conseille de lire le HOWTO UUCP. ## 13.3 PPP L'objet de ce paragraphe est l'installation d'une connexion PPP. ### Introduction PPP (Point to Point Protocol) permet d'établir une connexion IP sur une voie série de manière plus efficace que SLIP (Serial Line Internet Protocol). Une fois la connexion établie, tous les protocoles supérieurs à IP (TCP, UDP, ICMP et tous les services associés : FTP, telnet, NFS, http, X...) sont disponibles. Il est également possible de faire passer de l'IPX. Pour établir une connexion PPP, il faut: un serveur supportant le protocole PPP ; un modem *au moins* V32 (9600 bauds) ; un soft de connexion à PPP ; un peu de patience... PPP est supporté par un grand nombre de systèmes (dont MS-Windows) et on peut normalement se connecter d'un système à l'autre. Cependant, cette documentation ne traite que le cas de Linux ! ### Accès à un serveur PPP Pour accéder à un serveur PPP installé, votre noyau doit être compilé avec le support TCP/IP. Pour cela, lors du make config il faut répondre comme suit :
>     Networking support (CONFIG_NET) [y] y
>     TCP/IP networking (CONFIG_INET) [y] y
>     IP forwarding/gatewaying (CONFIG_IP_FORWARD) [y] n
>     Network device support? (CONFIG_NETDEVICES) [y] y
>     PPP (point-to-point) support (CONFIG_PPP) [y] y
> Vous devez en plus récupérer les sources des programmes d'accès à PPP (dans l'archive `ppp-2.1.2a.tar.gz`, voire b, c, ou d) de manière à installer les programmes suivants : `pppd` le programme d'établissement du protocole `chat` qui permet de dérouler le chat-script d'appel au site PPP Vous pouvez par exemple installer `pppd` et `chat` dans le répertoire `/usr/sbin`. Ensuite, vous devez configurer vos shell-scripts de boot de manière à configurer la couche TCP/IP (par exemple dans un fichier `/etc/rc.d/rc.net` qui sera lancé par `/etc/rc.d/rc.local`). En voici un exemple :
>     echo -n "/etc/rc.net: "
>     INETD=/sbin/inetd
>     PORTMAP=/sbin/portmap

>     # loopback
>     /sbin/ifconfig lo 127.0.0.1 up netmask 255.255.255.0
>     /sbin/route add 127.0.0.1 lo

>     # demarrage des demons

>     if [ -x $PORTMAP ]; then
>             echo -n ", `basename $PORTMAP`"
>             $PORTMAP
>     fi

>     if [ -x $INETD ]; then
>             echo -n ", `basename $INETD`"
>             $INETD
>     fi

>     echo ""
> Il faut ensuite ajouter l'adresse IP de la machine dans le fichier `/etc/hosts` :
>          127.0.0.1          loopback localhost      # useful aliases
>          199.103.124.170    pcpf.lectra.fr pcpf     # Mon beau PC en PPP
> L'adresse IP de la machine correspond à celle affectée par l'administrateur du serveur PPP pour la connexion associée à un numéro de téléphone donné. Cela signifie que la personne qui se connecte 10 minutes après utilisera la même adresse IP que vous. Enfin, vous devez configurer votre domaine dans le fichier `/etc/resolv.conf` :
>      domain lectra.fr
>      nameserver 192.1.2.1
> La deuxième ligne est utilisée si vous souhaitez utiliser un serveur de noms, c'est-à-dire une machine renvoie l'adresse IP correspondant au nom de machine fourni. Si vous n'avez pas de serveur de noms, vous ne pourrez utiliser que des adresses numériques (199.103.124.x) ou bien vous devrez mettre dans le fichier `/etc/hosts` toutes les machines auxquelles vous voulez accéder avec leurs adresses IP... Vous pouvez également mettre votre nom de domaine dans le fichier `/etc/ppp/options` qui doit exister même vide (si vous ne voulez pas que `pppd` demande `/etc/ppp/options`, il faut le compiler avec l'option `-DREQ_SYSOPTIONS=0`). Vous pouvez maintenant fébrilement tester la connexion en utilisant un shell-script du style (attention : tout cela constitue une seule ligne) :
>     /usr/sbin/pppd connect '/usr/sbin/chat -v ABORT ERROR ABORT "NO CARRIER" \
>     ABORT BUSY "" ATB0 OK ATDTxxxxxxxx CONNECT "" ogin: ppp \
>     word: ppp0' /dev/modem 9600 -detach debug crtscts modem \
>     defaultroute 199.103.124.170:
> La commande `chat` permet d'effectuer la connexion en appelant le numéro de téléphone de votre serveur. Attention de ne pas oublier les options de la deuxième ligne en particulier `modem` et `defaultroute`. La spécification de la vitesse (9600) ainsi que le chat-script à utiliser (ABORT ERROR ABORT "NO CARRIER" ABORT BUSY "" ATB0 OK ATDTxxxxxxxx CONNECT) dépendent bien entendu du modem et de la configuration du serveur (voir également le login et le password). L'adresse IP doit être celle déclarée en tant qu'adresse de la machine en PPP dans `/etc/hosts` (on peut également y mettre le nom de la machine en PPP). Les informations de debug doivent sortir sur la console (si vous avez configuré le fichier `/etc/syslog.conf` pour cela). À partir de là, vous êtes connecté sur le réseau distant et vous pouvez faire par exemple:
>       $ ping 199.103.124.50
>       PING 199.103.124.50 (199.103.124.50): 56 data bytes
>       64 bytes from 199.103.124.50: icmp_seq=0 ttl=255 time=268 ms
>       64 bytes from 199.103.124.50: icmp_seq=1 ttl=255 time=247 ms
>       64 bytes from 199.103.124.50: icmp_seq=2 ttl=255 time=266 ms
> pour tester la connexion. Si le ping marche et que le réseau est connecté à l'Internet, alors vous avez Internet à la maison ! Si ça ne marche pas, vous pouvez tester en tapant `/sbin/ifconfig` et le résultat doit ressembler à ça :
>     lo        Link encap Local Loopback
>               inet addr 127.0.0.1  Bcast 127.255.255.255  Mask 255.0.0.0
>               UP LOOPBACK RUNNING  MTU 2000  Metric 1
>               RX packets 0 errors 0 dropped 0 overrun 0
>               TX packets 0 errors 0 dropped 0 overrun 0

>     ppp0      Link encap Serial Line IP
>               inet addr 199.103.124.170  P-t-P 199.103.124.50  Mask 255.255.255.0
>               UP POINTOPOINT RUNNING  MTU 1500  Metric 1
>               RX packets 33 errors 0 dropped 0 overrun 0
>               TX packets 42 errors 0 dropped 0 overrun 0
> Surtout, vous devez avoir une ligne commençant par ppp0 sinon, c'est qu'il y a un problème. Vous pouvez également tester le routage par `netstat -nr` qui doit donner quelque chose de semblable à :
>     Kernel routing table
>     Destination     Gateway         Genmask         Flags Metric Ref Use    Iface
>     199.103.124.50  0.0.0.0         255.255.255.255 UH    0      0        6 ppp0
>     127.0.0.0       0.0.0.0         255.0.0.0       U     0      0        0 lo
>     0.0.0.0         199.103.124.50  0.0.0.0         UG    0      0     6298 ppp0
> Avec une ligne 0.0.0.0 contenant l'adresse IP du serveur PPP. Si vous n'avez pas cette ligne, il se peut que vous ayez oublié l'option `defaultroute`. ### Configuration d'un serveur PPP Pour cela, vous devez installer les mêmes logiciels que dans le chapitre précédent (configurer le noyau, installer `pppd`). En plus de ça, il faut créer un login spécial pour les connexions PPP dans `/etc/passwd`, par exemple :
>     ppp::61:60:Connexion PPP:/:/usr/bin/ppp_login
> Le script `/usr/bin/ppp_login` étant :
>     #!/bin/sh
>     # Connexion PPP --> adresse IP = 199.103.124.170
>     exec /usr/sbin/pppd -d -detach -ip modem proxyarp :199.103.124.170
> L'option `proxyarp` permet à la machine connectée d'accèder à tout le réseau :
>      199.103.124.170                   199.103.124.50
>     +-----------+      PPP link       +----------+
>     | pcpf      | ------------------- |  ondee   |
>     +-----------+                     +----------+
>                                             |           Ethernet
>                         ----------------------------------- 199.103.124.x
> ### Bibliographie Pour plus d'informations, voir le fichier README.Linux de la distribution `ppp-2.1.2a.tar.gz`. Remarque : ce fichier peut généralement se trouver dans le répertoire `/usr/doc`. ## 13.4 Un réseau derrière une seule adresse Une question commune est : "j'ai un accès Internet mais une seule adresse IP et je voudrais pourtant pouvoir connecter plusieurs machines". Le `NET3-HOWTO` répond à cette question mais il oublie une possibilité. Cette note a pour but d'expliquer les quatre façons de résoudre le problème ci-dessus. Obtenir plusieurs adresses. L'idéal serait sans doute d'avoir un vrai sous-réseau sur le site distant, qui pourrait être routé "normalement". C'est la méthode la plus normale et la seule qui donnera à toutes les machines du réseau distant une vraie connectivité Internet. Mais si votre fournisseur d'accès est un opérateur commercial, il vous faudra probablement payer *beaucoup* plus cher pour un tel accès (qui lui coûte effectivement plus). Si c'est une université ou association, elle n'aura peut-être pas envie de configurer un cas spécial pour vous. Il va donc falloir se contenter d'un des trois bricolages suivants, qui commencent tous par allouer aux ordinateurs supplémentaires une adresse privée, prise dans le RFC 1918 (qui a remplacé le fameux 1597). "IP masquerading". C'est une traduction d'adresses dynamique fournie par le noyau de la machine Linux passerelle. Une idée simple et géniale. C'est peut-être la méthode la plus générale, car elle marche pour un grand nombre de services réseaux. Notez quand même tout de suite que tous ne fonctionneront pas, notamment `ping` et beaucoup de services UDP. "IP masquerading" nécessite un noyau récent (2.* ou certains 1.3.* ou un patch du 1.2.*) et il est documenté sur http://www.indyramp.com/masq ou http://hwy401.com/achau/ipmasq/. Un HOWTO décrivant clairement l'installation de IP masquerading se trouve à http://www.freenix.org/linux/HOWTO-vo/mini/IP-Masquerade. "Socks" est un relais générique, fonctionnant au niveau application (donc pas de modifications dans le noyau contrairement au "IP masquerading". Il nécessite des programmes spéciaux (trouvés couramment sur les machines Unix) du côté client. Les documentations se trouvent en général dans les livres ou serveurs parlant de sécurité car on l'utilise beaucoup dans ce contexte. C'est ainsi que le document "Firewall-HOWTO" décrit cette solution (il est traduit en français, voir http://www.freenix.org/linux/HOWTO/.) Relais applicatif : c'est ainsi qu'on nomme les programmes tournant au niveau application qui relaient les requêtes des clients, installés sur le réseau sans adresses IP légales. Outre le relayage qui permet à ces machines de sortir, ils fournissent typiquement une valeur ajoutée, par exemple en gardant en mémoire locale des informations fréquemment accédées. C'est à mon avis la solution la plus simple à mettre en oeuvre, elle marche sur tous les noyaux et même sur d'autres Unix que Linux. Certaines applications n'ont aucun problème à être ainsi relayées car elles ont toujours fonctionné comme ça : le courrier, les News, la synchronisation d'horloges, le service de noms, etc. D'autres se sont converties au relayage à posteriori et y ont gagné beaucoup (pour le Web, c'est le relayage qui permet de mettre en oeuvre les indispensables caches comme celui de Renater http://cache.cnrs.fr/). Ainsi, le gros avantage du relayage est de pouvoir apporter une valeur ajoutée : réécriture d'adresses et gestion de files d'attente centralisées pour le courrier, caches pour le Web. Le meilleur relais + cache Web à l'heure actuelle est Squid http://www.nlanr.net/Squid/. Le relayage a deux défauts : toutes les applications ne disposent pas d'un relais (on peut utiliser Socks pour combler les trous) et il faut installer un nouveau relais à chaque application. Le relayage est donc recommandé si on se contente des services de base : courrier, Web, News, etc. ## 13.5 Sendmail La configuration de sendmail est toujours quelque chose de particulièrement pénible et difficile. Toutefois, certains outils facilitent grandement les choses. Les distributions sont fournies avec certains fichiers, qui peuvent être une solution. Toutefois, il est plus sain de réinstaller le fichier de configuration en se basant sur les documents qui suivent : Programmes : sendmail : ftp://ftp.lip6.fr/pub/unix/mail/sendmail/ucb ; procmail : ftp://ftp.lip6.fr/pub/unix/mail/procmail ; fetchmail : ftp://ftp.lip6.fr/pub/linux/sunsite/system/mail/pop ; kit Jussieu : ftp://ftp.jussieu.fr/jussieu/sendmail/kit/ ; UUCP : n'importe quel site miroir GNU, par exemple ftp://ftp.pasteur.fr/pub/Gnu ou ftp://ftp.lip6.fr/pub/gnu/ ; exmh : http://www.smli.com/~bwelch/exmh/. Documents : excellente documentation dans le kit Jussieu, en français : http://www.prism.uvsq.fr/~pda/kit-jussieu/ ; FAQ FreeBSD notamment "How do I use sendmail for mail delivery with UUCP?" ; http://www.freebsd.org/FAQ/ ' pourquoi utiliser UUCP : http://web.pasteur.fr/other/computer/Linux/my-BBS/uucp.txt ; la doc de Taylor-UUCP ; Linux Network Administrator's Guide (voir plus bas). ## 13.6 Configuration du mail lors d'une connexion avec un provider Les providers reçoivent les messages et les rendent accessibles via un serveur POP (mail.fournisseur.fr en général). Il faut donc récupérer les messages reçus par ce serveur vers la machine linux dans le fichier `/var/spool/mail/utilisateur`. Pour cela, vous pouvez utiliser le programme `fetchmail` qui permet entre autres choses de récupérer du courrier pour plusieurs utilisateurs sur différents serveurs. Voici un exemple de fichier `.fetchmailrc` :
>     # Recuperation  de mon courrieur chez mon fournisseur 1
>     poll mail.fournisseur.fr protocol POP3:
>             user UserServeurPop has password MotDePasseServeurPop is NomLocal here
>             fetchall

>     # Recuperation  de mon courrieur chez mon fournisseur 2
>     poll mail.fournisseur2.fr protocol POP3:
>             user UserServeurPop2 has password MotDePasseServeurPop2 is NomLocal here
>             fetchall
> Vous pouvez également utiliser le programme `gwpop` de Stéphane Bortzmeyer. On peut le trouver sur le site ftp://ftp.pasteur.fr/pub/Network/gwpop. Dans ce script, définir :
>     $mailhost = "mail.fournisseur.fr";
>     $deliver= "deliver NomUserLocal ";
> Puis, une fois connecté, lancer via un script (histoire de ne pas avoir à tout retaper à chaque fois) :
>     gwpop -p MotDePasseServeurPop UserServeurPop
> Une fois que le courier est reçu, la question est de savoir comment en envoyer. Deux méthodes sont couramment utilisées dans le monde unix pour créer le fichier `sendmail.cf` nécessaire. ## 13.7 Utilisation du Kit de Jussieu Recompilez et installez la dernière version de `sendmail`. Voici le fichier de règles qu'il faut indiquer via le kit sendmail Jussieu :
>     #!/bin/sh
>     #
>     # Regles pour le domaine lolonet
>     #
>     Domaine="MonNomdeDomaineAvecUnPoint"
>     AdressesInternes=RIEN
>     V8="o"
>     Aliases="/etc/aliases"
>     SendmailSt="/etc/sendmail.st"
>     SendmailHf="/usr/lib/sendmail.hf"
>     Mqueue="/var/spool/mqueue"
> et le fichier de config :
>     #!/bin/sh
>     Host='NomDeMaMachine'
>     AdressesLocales=TOUT_DOMAINE
>     RelaisExterieur='smtp.[mail.fournisseur.fr]'
>     ReecritureAdressesLocales=$Domaine
>     RevAliases='hash -N /etc/revaliases'
>     MailerLocal='/usr/bin/procmail lsSDFMhPfn procmail -Y -a $h -d $u'
> On utilise le programme `procmail` comme mailer local. Ce programme permet à chaque utilisateur de filtrer automatiquement les messages reçus via des règles spécifiées dans le fichier `.procmailrc` de leur `$HOME`. Il suffit ensuite de modifier le configurateur en décommentant la ligne suivante:
>     CPP="$CPP -traditional"
> puis de générer le fichier de config :
>     ./configurateur regles.lolonet Machine.config > sendmail.cf.Machine
> et de copier le fichier généré dans `/etc/sendmail.cf`. ## 13.8 Utilisation de m4 Vous pouvez conserver le `sendmail` fourni par votre distribution mais je vous recommande fortement de compiler vous même la dernière version disponible. Vous trouverez dans le repertoire `sendmail-ver/cf/cf` une liste de fichiers .mc prédéfinis... Vous pouvez vous baser sur ceux ci, sur le fichier `sendmail-ver/cf/README` et sur le fichier `sendmail-ver/doc/op/op.me` pour vous faire un fichier `linux.mc` à votre convenance. Voici un exemple commenté basé sur la configuration suivante : Domaine local non routable : `mondomaine.a.moi` Serveur SMTP du fournisseur d'accès : `mail.fournisseur.fr` Ce document présente l'une des possibilités de sendmail qui permet de définir un mailer particulier comme coûteux. Une autre option disant à `sendmail` de garder en attente les messages utilisant de tels médias, il nous suffit de définir le mailer smtp comme étant coûteux pour voir tous les messages à destination de l'extérieur rester dans la queue jusqu'à ce qu'on les en chasse explicitement par un `sendmail -q`, placé par exemple dans le script `/etc/ppp/ip-up` lors d'une connexion PPP.
>     divert(-1)
>     #   linux.rtc.mc, version dialup
>     #   Copyright (C) 1998 Jean Charles Delépine
>     #
>     #   This program is free software; you can redistribute it and/or modify
>     #   it under the terms of the GNU General Public License as published by
>     #   the Free Software Foundation; either version 2 of the License, or
>     #   (at your option) any later version.
>     #
>     #   This program is distributed in the hope that it will be useful,
>     #   but WITHOUT ANY WARRANTY; without even the implied warranty of
>     #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>     #   GNU General Public License for more details.
>     #
>     divert(0)
>     include(`../m4/cf.m4')dnl On récupère les macros générales...
>     dnl
>     VERSIONID(`@(#)linux.rtc.mc, 0.6 (Delépine) 14/08/1998')dnl
>     dnl
>     dnl ********************************************************************
>     OSTYPE(linux)dnl
>     dnl
>     dnl A priori on tournera sous linux cette ligne ne fait que définir
>     dnl un mailer local que l'on va s'empresser de redéfinir mais il vaut
>     dnl mieux la laisser au cas où les futures versions de sendmail y
>     dnl ajouttent de nouvelles fonctionalités.
>     dnl
>     dnl ********************************************************************
>     DOMAIN(generic)dnl
>     dnl
>     dnl le domaine 'generic' défini le nom des .forward, la feature 'redirect'
>     dnl et l'utilisation de sendmail.cw
>     dnl
>     GENERICS_DOMAIN(mondomaine.a.moi mondomain)
>     dnl
>     dnl défini la classe des domaines influencés par les genericstables
>     dnl utilisées plus bas. Y mettre tous les noms que votre serveur peut
>     dnl prendre suivant les outils utilisés (pine, netscape, mail...)
>     dnl
>     dnl ********************************************************************
>     dnl
>     FEATURE(always_add_domain)dnl
>     dnl
>     dnl j'aime bien recevoir mes courriers locaux avec l'adresse réécrite
>     dnl
>     FEATURE(masquerade_envelope)dnl
>     dnl
>     dnl pour que le from de l'enveloppe soit correct... c'est cette adresse
>     dnl qui sera utilisée par les serveurs smtp menant à vos correspondants
>     dnl pour vous prevenir en cas de problèmes (user unknown, ...)
>     dnl
>     dnl ********************************************************************
>     FEATURE(local_procmail)dnl
>     dnl
>     dnl Par défaut le mailer local pour linux est mail.local, je lui préfère
>     dnl procmail d'autant plus que mail.local n'est généralement pas
>     dnl fourni avec les distributions actuelles de linux (il peut être
>     dnl trouvé dans le package sources de sendmail).
>     dnl
>     dnl ATTENTION, procmail est sensé être dans /usr/local/bin mais si vous ne
>     dnl l'avez pas compilé vous même il est certainement dans /usr/bin... si
>     dnl vous êtes dans ce cas, décommentez la ligne suivante.
>     dnl
>     dnl FEATURE(local_procmail,``/usr/bin/procmail'')dnl
>     dnl
>     dnl ********************************************************************
>     FEATURE(genericstable,``hash -N /etc/revaliases'')dnl
>     dnl
>     dnl un FEATURE(genericstable) suffirait mais je veux rester cohérent
>     dnl avec la solution "Kit de Jussieu" fournie précédemment,
>     dnl je renomme donc /etc/genericstable en /etc/revaliases
>     dnl C'est dans ce fichier que nous définierons les règles de
>     dnl transcription d'adresse entre adresse locale -> adresse provider.
>     dnl ex: machin@mondomaine.a.moi -> nom.prenom@fournisseur.fr
>     dnl
>     dnl ********************************************************************
>     FEATURE(nocanonify)dnl
>     dnl
>     dnl On ne cherchera pas a canoniser les domaines des messages à
>     dnl envoyer.
>     dnl
>     dnl ********************************************************************
>     dnl define(`confDOMAIN_NAME',`ppp.fournisseur.fr')dnl
>     dnl
>     dnl Défini le nom qu'annoncera sendmail par EHLO aux autres
>     dnl serveur SMTP...
>     dnl Vous pouvez mettre ce que vous voulez ici mais je considère plus
>     dnl propre d'annoncer son véritable nom (que les serveurs sérieux
>     dnl indiqueront de toute façon dans les entêtes).
>     dnl Si vous disposez d'une adresse IP fixe, vous mettez ici le
>     dnl le nom DNS associé à cette adresse lors de vos connexion PPP.
>     dnl
>     dnl Si votre fournisseur d'accés utilise des adresses dynamiques,
>     dnl reportez vous à la section
>     dnl "Que faire en cas d'attribution dynamique de l'adresse IP"
>     dnl
>     dnl ********************************************************************
>     define(`confDEF_CHAR_SET', `ISO-8859-1')dnl
>     dnl
>     dnl pour que le destinataire sache comment lire notre 8bit
>     dnl
>     dnl ********************************************************************
>     define(`confCON_EXPENSIVE',`True')dnl
>     dnl
>     dnl Ce qui coûte cher doit attendre un 'sendmail -q'
>     dnl
>     dnl ********************************************************************
>     define(`confCOPY_ERRORS_TO', `Postmaster')dnl
>     dnl
>     dnl Les messages d'erreur doivent être envoyés en copie au Postmaster
>     dnl
>     dnl ********************************************************************
>     define(`confME_TOO', `True')dnl
>     dnl
>     dnl Pour que les messages envoyés à une liste locale soit aussi envoyés
>     dnl à l'auteur
>     dnl
>     dnl ********************************************************************
>     define(`SMART_HOST', `smtp8:[mail.fournisseur.fr]')dnl
>     dnl
>     dnl Ce n'est pas à moi de négocier avec le bout du monde. Je délègue
>     dnl donc cette tâche au serveur de mon FAI.
>     dnl On utilise smtp8 pour envoyer les accents en 8 bits sans passage
>     dnl par le quoted unreadable. Attention, on considère ici que
>     dnl mail.fournisseur.fr dispose d'un MTA correct acceptant les messages en
>     dnl 8 bits (soit la plupart si ce n'est tout les fournisseurs d'accès)
>     dnl
>     dnl ********************************************************************
>     define(`SMTP_MAILER_FLAGS', `e')dnl
>     dnl
>     dnl Le flag 'e' est là pour expensive : smtp coûte cher !
>     dnl
>     dnl ********************************************************************
>     dnl
>     MAILER(local)dnl
>     MAILER(smtp)dnl
>     dnl
>     dnl Définition des mailers qui seront utilisés.
>     dnl
>     dnl ********************************************************************
> Placez votre `linux.rtc.mc` modifié dans le répertoire `sendmail-ver/cf/cf` et lancez la commande :
>     m4 < linux.rtc.mc > sendmail.cf
> ## 13.9 Une fois le sendmail.cf généré... Le copier dans `/etc`. Il est nécessaire de définir l'adresse IP du serveur SMTP dans le fichier `/etc/hosts`. À partir des versions 8.7 de `sendmail` (si votre version est antérieure : changez-en !) `sendmail` utilise les service switch sur les systèmes les supportant (Ultrix, Solaris, OSF/1, linux-libc6...) et implante lui même ces services via le fichier `/etc/service.switch` sur les autres systèmes (SunOS, HP-UX, BSD, Linux-libc5, ...) Si votre système utilise la Glibc2 (RedHat 5.x, Debian 2.0,...) vous devrez utiliser un fichier `/etc/nsswitch.conf` dont voici un exemple :
>          # /etc/nsswitch.conf
>          #
>          # Name Service Switch configuration file.
>          # Attention: si vous utilisez les services NIS ou NIS+,
>          # vous devrez adapter le contenu de ce fichier.

>          passwd:     files
>          shadow:     files
>          group:      files

>          # On veut que le fichier /etc/hosts soit visité en
>          # premier.
>          # Attention de bien laisser une référence au service de noms (DNS)
>          # ou vous ne pourrez plus utiliser d'outils réseaux compilés en libc6 !

>          hosts:      files dns

>          networks:   files

>          ethers:     files
>          protocols:  files
>          rpc:        db files
>          services:   files
> Si vous utilisez encore la libc5, le fichier `/etc/host.conf` n'est pas pris en compte par sendmail et vous devrez utiliser un fichier `/etc/service.switch` contenant l'unique ligne :
>     hosts files
> Ainsi, lorsque `sendmail` cherchera notre relais smtp, il ira directement voir dans le fichier `/etc/hosts` sans se soucier du `DNS`. Enfin, il faut réécrire l'adresse locale pour que les messages envoyés aient un champ `From` correspondant à l'adresse fournie par le fournisseur. Il suffit d'ajouter dans `/etc/revaliases` une ligne du style :
>     NomLocal:       NomFournisseur@fournisseur.fr
> Je vous recommande d'y ajouter aussi les diverses adresses que votre serveur peut utiliser pour communiquer avec le reste du monde :
>     root:           NomFournisseur@fournisseur.fr
>     news:           NomFournisseur@fournisseur.fr
>     postmaster:     NomFournisseur@fournisseur.fr
>     Le-chat:        NomFournisseur@fournisseur.fr
>     ...
> et ensuite régénérer la base avec :
>     /usr/sbin/sendmail -bi -oA/etc/revaliases
> Si un démon sendmail tourne actuellemnt, tuez le :
>         # kill `head -1 /var/run/sendmail.pid`
> Puis relancez le :
>         # /usr/sbin/sendmail -bd -os
> Éditez vos fichiers de démarrage (souvent dans `/etc/rc.?d` ou `/etc/init.d`) afin de modifier si nécessaire la ligne lançant `sendmail` au moment du boot en la remplaçant par `/usr/sbin/sendmail -bd -os'.` Voila ! Les mails sont stockés dans `/var/spool/mqueue`. Lorsque vous êtes connectés par PPP et que vous souhaitez envoyer tous les mails, il suffit de faire
>     /usr/sbin/sendmail -q
> ## 13.10 Que faire en cas d'attribution dynamique de l'adresse IP Quel est le problème ? Lorsque sendmail communique avec un autre MTA, il se présente (commande HELO ou EHLO) en utilisant le contenu de la macro `$j` qui est généralement le résultat de la commande `hostname` sur le système hôte. Dans le cas d'une machine reliée de façon intermitente à l'Internet ce résultat n'est généralement pas une adresse officielle, déclarée, donc connue du service de noms (DNS). Nous avons vu que la solution quand on dispose d'une adresse IP fixe et valide consistait en forcer la définition de la macro `$j` par la commande du kit m4 :
>         define(`confDOMAIN_NAME',`ppp.fournisseur.fr')dnl
> Mais il faut, pour utiliser cette solution, connaître à l'avance le nom qui sera attribué à notre machine lors de la future connexion... ce n'est donc pas envisageable dans le cas qui nous préoccupe. Dans le fichier `/etc/sendmail.cf` que nous venons de générer, nous pouvons voir :
>     # my official domain name
>     # ... define this only if sendmail cannot automatically determine your domain
>     #Dj$w.Foo.COM
> - C'est à cet endroit qu'a eventuellement lieu la définition de la macro `$j` qui nous intéresse. Lors d'une connexion PPP, le script `/etc/ip-up/`, lancé au début de la connexion, reçoit en argument l'adresse IP qui nous a été attribuée. Il est donc possible, dans ce script, de demander au serveur de noms (le nôtre ou celui du provider) de transcrire cette adresse IP en un nom de domaine pleinement qualifié, de modifier `/etc/sendmail.cf` puis de relancer sendmail avec cette nouvelle définition. Différentes méthodes et programmes le permettent mais la plupart sont verbeux et nécessiteraient un filtre `awk` ou `grep` pour extraire le nom qui nous intéresse... j'ai donc écrit un petit utilitaire très simple `gethost` dans cet unique but. Pour pouvoir utiliser le script ip-up que je fournis plus loin : copiez `/etc/sendmail.cf` en `/etc/sendmail.cf.base` afin de disposer d'une base à partir de laquelle `ip-up` pourra travailler. Compilez `gethost` :
>         gcc -o gethost gethost.c
> et placez-le dans le repertoire `/usr/local/bin`. Il vous reste à modifier votre fichier `/etc/ppp/ip-up` en y intégrant le mien. Un exemple de script ip-up :
>     #!/bin/sh
>     #   /etc/ppp/ip-up   script permettant de configurer correctement
>     #                    sendmail dans le cas des attributions
>     #                    dynamique d'adresse IP
>     #
>     #   Copyright © 04/1998 Jean Charles Delépine
>     #
>     #   This program is free software; you can redistribute it and/or modify
>     #   it under the terms of the GNU General Public License as published by
>     #   the Free Software Foundation; either version 2 of the License, or
>     #   (at your option) any later version.
>     #
>     #   This program is distributed in the hope that it will be useful,
>     #   but WITHOUT ANY WARRANTY; without even the implied warranty of
>     #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>     #   GNU General Public License for more details.

>     # Les paramètres passés à ip-up par pppd (man pppd) :
>     # $1 = nom de l'interface (ppp0)
>     # $2 = périférique utilisé (/dev/modem)
>     # $3 = vitesse de transmission
>     # $4 = adresse IP locale (celle qui nous intéresse)
>     # $5 = adresse IP distante (le serveur de modem du provider, sera
>     #      notre passerelle vers le reste du monde)
>     # $6 = ipparam (option donnée par l'utilisateur via l'option ipparam
>     #      de pppd)

>     HOST=`/usr/local/bin/gethost $4`

>     sed s/'#Dj.*'/"Dj$HOST"/ /etc/sendmail.cf.base >/etc/sendmail.cf

>     kill -1 `head -1 /var/run/sendmail.pid`

>     /usr/sbin/sendmail -q&

>     exit 0
> Le programme `gethost.c` :
>     /*
>         gethost.c, récupère le nom canonique d'une machine
>                    à partir de son adresse IP.

>         Copyright © 04/1998 Jean Charles Delépine

>         This program is free software; you can redistribute it and/or modify
>         it under the terms of the GNU General Public License as published by
>         the Free Software Foundation; either version 2 of the License, or
>         (at your option) any later version.

>         This program is distributed in the hope that it will be useful,
>         but WITHOUT ANY WARRANTY; without even the implied warranty of
>         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
>         GNU General Public License for more details.
>     */

>     #include <stdio.h>
>     #include <netdb.h>
>     #include <arpa/inet.h>
>     #include <string.h>

>     int main(argc,argv)
>     char argc;
>     char *argv[];
>     {
>       struct hostent *host;
>       struct in_addr ia;

>       if (argc < 2) {
>         fprintf(stderr,"Usage : %s addr\n",argv[0]);
>         exit(1);
>       }
>       if (!inet_aton (argv[1],& ia)) {
>           fprintf(stderr,"Erreur: adresse invalide\n");
>           exit(1);
>       }

>       host=gethostbyaddr((char *) & ia, sizeof(ia), AF_INET);

>       if (!host) {
>         fprintf(stderr,"Erreur: adresse non trouvée ou pas de DNS\n");
>         exit(1);
>       }
>      printf("%s\n",host->h_name);
>       exit(0);
>     }
> ## 13.11 netstat -s Une option de `netstat` existant sur certaines plates-formes est inexistante avec Linux (option `-s`). Qu'importe : le script Perl 5 qui suit résoud ce problème ! Il suffit de le sauvegarder sous le nom de `netstat`, et de le mettre avec le vrai dans le PATH. Perl fait le reste.
>     #!/usr/local/bin/perl
>     # Il faut perl 5
>     require 5.003;

>     $stats = "/proc/net/snmp";

>     if ($ARGV[0] eq '-s') {
>         open (STATS, "< $stats") || die "Cannot open $stats: $!";
>         while (<STATS>) {
>             chop;
>             undef $i;
>             ($category, @fields) = split;
>             chop $category;
>             print "\n$category statistics:\n";
>             $_ = <STATS>;
>             ($category, @values) = split;
>             $~ = "STAT";
>             foreach $field (@fields) {
>                 write;
>             }
>         }
>         close (STATS);
>     }
>     else {
>         system ($0, join (' ', @ARGV));
>     }

>     format STAT =
>     @<<<<<<<<<<<<<<<<<:@>>>>>>>
>     $field,       ,$values[$i++]
>     .
> Page suivante Page précédente Table des matières