Documentation Squid 3.1 sur Debian 6.

Sommaire En cas d'urgence Installation de Debian Configuration rseau Installation de Squid Compilation de SquidCLIENT Configuration en mandataire transparent Commandes utiles pour SquidCLIENT Installation & configuration d'un cache DNS (pdnsd) Surveillance de Squid avec Calamaris Le serveur web lighttpd Prcisions propos du fichier /etc/squid.squid.conf A propos du paramtre refresh_pattern Annexes (scripts et fichiers de configuration) Page 8 Page 7 Page 6 Page 3 Page 4 Page 5 Page 2

En cas d'urgence
-se connecter avec Putty l'adresse 192.168.0.254. Le mot de passe est jslpdl ( "je suis le poinonneur des lilas") et l'utilisateur est root, puis : vrifier la mmoire vive : free -m), l'espace disque df -m le fonctionnement de squid pstree ensuite aller voir dans les logs tail (ou cat ) /var/log/squid/cache.log -si on veut changer l'adresse de la passerelle mais continuer la maintenance sur le proxy, il faut penser changer l'adresse de l'interface eth1, dans le fichier /etc/network/interfaces puis lancer la commande /etc/init.d/networking restart pour reconfigurer les interfaces. -Si Squid ne fonctionne plus, il faut changer l'adresse du routeur RV042 192.168.0.254 (ainsi les clients DHCP ne verront pas le changement).

Installation de l'OS
On installe une distribution Debian(64 bits) de base avec support SSH et 3 partitions en ReiserFS. Ce sytsme de fichier, bien que n'ayant plus de support, est trs rput pour sa rapidit traiter de petits fichiers. C'est adquat pour notre cache. La partition du cache est nomme /cache1 et les 2 partitions de secours /cache2 et /cache3. De plus, afin d'acclerer le cache, on prcise lors du partitionnement noatime (pas de mise jour des inodes chaque accs) et notail(tail concerne les petits fichiers, cela permet de gagner de la place mais fait perdre en performance). Pour utiliser ReiserFS, il faut passer en mode expert pour disposer de plus d'options. Il peut tre ncessaire la fin de rergler l'heure(problme avec les variables locales) : dpkg-reconfigure tzdata.

Configuration en passerelle
On configure (comme sur la capture) les interfaces eth0 pour le WAN et eth1 pour le LAN L'adressage se gre dans le fichier /etc/network/initerfaces. Si besoin le DNS dans le fichier /etc/resolv.conf . Pour relancer les services rseau, il faut lancer la commande : /etc/init.d/networking restart.

Pour router le trafic entre les 2 interfaces, il faut activer l'ip_forwarding en decommentant ip_forward dans le fichier /etc/sysctl.conf. Ce fichier permet de manipuler chaud le noyau. On force la relecture de ce fichier : sysctl -p

Installation du mandataire
Afin d'installer juste que ce que l'on a besoin, on va compiler Squid partir des sources : wget http://www.squid-cache.org/Version/v3/3.1 md5sum tar -zxvf *.tar.gz rm *.md5 *.gz cd sq* On rpond aux dpendances de squid en lanant aptitude build-dep squid3 On configure avec les options optimales (c'est l'avantage d'utiliser les sources) : ./configure --prefix=/usr Pour se conformer aux emplacements par dfaut --localstatedir=/var des fichiers selon Debian --libexecdir=/usr/lib/squid --srcdir=. --datadir=/usr/share/squid --sysconfdir=/etc/squid --with-default-user=proxy with-logdir=/var/log/squid with-pidfile=/var/run/squid.pid enable-async-io=128 Activation de l'criture asynchrone avec un nombre suffisant de thread with-large-files Pour travailler sur des gros fichiers --with-maxfd=32768 disable-carp --enable-removal-policies=heap,lru Un nombre suffisant de files descriptors Option inutile (sert au dialogue entre plusieurs proxy) Politiques de maintenance du cache (la lru est pour la mmoire vive (last recent used) et la heap permet une prfrence aux gros fichiers . Elle sera utils pour le cache sur le disque Inutile, le wccp est un redirection On utilise netfiler de Linux protocole Cisco de

--disable-wccp --disable-wccp2 --enable-err-languages=French enable-default-err-language=French --enable-linux-netfilter --disable-ipv6 --disable-translation --disable-auto-locale --enable-arp-acl --disable-ident-lookups

Activation des pages d'erreurs en franais Activation de l'outil netfilter pour faire du proxy transparent On dsactive tout ce qui est inutile Cette option est active au cas o on veuille bloquer des adresses MAC Squid peut faire des requtes DNS pour identifier les adresses IP, cela ralentit le processus . On dsactive

Puis on compile : make (cette tape est plutt longue) make install (si il n'y pas de messages d'erreurs, on peut continuer) . Si on veut recompiler Squid . Il faudra se dplacer dans le rpertoire o se trouve les sources : cd /home/skill/squid-source Relancer ./configure avec toutes les options dsires (les anciennes sont accessibles

grce la commande squid -v. Puis make clean make make install

Configuration du mandataire en proxy transparent

L'utilitaire Winscp permet de copier les scripts et fichiers de configuration aux diffrents endroits . Winscp permet d'utiliser le protocole scp entre diffrentes machines . Le serveur sshd du proxy est uniquement l'coute sur le rseau interne (192.168.0.254) . Donnons les droits d'criture au bon utilisateur : chown proxy:proxy /var/log/squid /cache1 /cache2 /cache3 Pour configurer Squid en proxy transparent, on fait appel l'outil netfilter et sa commande iptables . Cela permet de rediriger le port 80 vers le port o coute Squid (3128) et de natter le rseau interne sur la passerelle externe . Voici les lignes iptables, elles se trouvent dans le script de surveillance de Squid (squid-watcher.sh) : iptables --table nat --append PREROUTING -s 192.168.8.254 -p tcp dport 80 -j ACCEPT iptables --table nat --append PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.8.254:3128 iptables -t nat -A POSTROUTING -j MASQUERADE

Illustration 1: Schma de la redirection de port

La premire ligne sert laisser disponible le port 80 en local, il sera utilis ultrieurement pour s'informer de l'tat de Squid grce l'outil calamaris. On place le fichier de configuration de Squid ici : /etc/squid/squid.conf Si ncessaires, les adresses IP seront modifies. Le scripts de dmarrage ici : /etc/init.d/squid Pour le rendre excutable : chmod 755 /etc/init.d/squid On met jour les runlevels : update-rc.d squid defaults Le script de surveillance l : /etc/squid/squid-watcher.sh Penser vrifier si besoin l'adressage IP dans ce script. Ce script de surveillance change les rgles de routage si Squid chute. C'est dire qu' la place de rediriger le port 80 (HTTP) vers le port 3128 (le port o le proxy coute), tout le trafic interne est simplement natt sur l'interface externe. De mme, on le rend excutable : chmod 755 /etc/squid/squid-watcher.sh On renseigne le fichier /etc/rc.local de l'existence de /etc/squid/squid-watcher.sh en plaant avant exit 0 /etc/squid/squid-watcher poll & (le & pour faire tourner en tache de fond le script). On initialise le cache : squid -z

Un reboot et si il n'y pas de messages d'erreurs. Les clients connects eth1 peuvent surfer. Pour vrifier les logs d'accs : tail -f /var/log/squid/access.log

Commandes utiles pour maintenir Squid :

Le daemon SSH (utiliser Putty sur Windows) est l'coute sur l'interface interne (192.168.0.254) Le mot de passe est jslpdl ( "je suis le poinonneur des lilas") et l'utilisateur est root. Pour vrifier la syntaxe avant de relancer Squid : squid -k parse Pour reconfigurer sans stopper Squid : squid -k reconfigure Si Squid fonctionne, on peut voir que la commande squid -k check ne renvoie aucun message. Squid est quip de nombreux messages de dboggage qui peuvent remplir inutilement les logs. La commande squid -k debug renvoie tous les messages d'informations (importants ou non). Heureusement fonctionnant comme un switch, on peut l'utiliser de cette faon : squid -k debug ; sleep 5 ; squid -k debug On peut ensuite (avec tail -n 50 /var/log/squid/cache.log) consultait le log de Squid. Une panne qui semble frquente est l'utilisation abusive de la mmoire vive. Dans ce cas, il faut baisser la valeur de mise en cache (cache_mem) dans le fichier /etc/squid/squid.conf puis lancer les commandes : squid -k parse (afin de vrifier les erreurs de syntaxe) squid -k reconfigure (afin de reconfigurer le cache) Le cache est rgl de faon a se vider partir de 95 % de sa taille (cache_swap). Le paramtre cache_replacement_policy permet de favoriser les gros fichiers, les plus utilis .

Pour rinitialiser le cache (normalement c'est inutile..), il y a 2 partitions de secours, elles sont prtes accueillir un cache . La procdure est renseigne dans le fichier de configuration ( il faut commenter une ligne et en dcommenter une autre puis invoquer la commande : squid -k reconfigure . Ensuite on peut supprimer l'ancien cache (rm -R) . Les sources de Squid, les modules Perl (ncessaire par la suite), les scripts, l'image de la Debian sont sauvegards sur le serveur SKPROD dans le rpertoire commun . Il sera peut tre utile de tlcharger des sources plus rcentes pour Squid, sur le site http://www.squid-cache.org. Un russite de squid s'appelle un TCP_HIT, en moyenne servir 15% de TCP_HIT semble tre correct, 30% est un trs bon score . Cela reste relatif l'usage qui est fait d'internet. Voici comment est logger dans /var/log/squid/access.log :

Afin de lister les objets du cache, on peut utiliser le rapport store.log, la commande suivante donne les objets avec leur type, leur taille et leur URL et les trie par taille (les plus grands en dernier). cat /var/log/squid/store.log | awk '{print$10" "$11" "$13}'|sort -g Ensuite, on peut utiliser squiclient -m purge pour supprimer les objets dsirs (cf capture ci-dessous).

La commande a supprim tous les objets commenant par

http://www.espacepc.com .

Surveillance de Squid avec Calamaris

Afin de surveiller Squid, notamment le pourcentage de TCP_HIT. Calamaris est install. L'installation est plutt simple ici aussi : aptitude install calamaris cat /var/log/squid/access.log | calamaris -a . Cette commande renvoie un tableau de diffrentes statistiques. Avec quelques modules Perl, on va pouvoir avoir des graphes. D'abord il faut dplacer quelques fichiers afin d'avoir la structure suivante : -/usr/local/calamaris/calamaris -/usr/local/calamaris/calamaris.conf -/usr/local/calamaris/calAxestype3d.pm -/usr/local/calamaris/calAxestype.pm Il faut dcommenter dans le fichier /usr/local/calamaris/calamaris la ligne suivante : use lib '/usr/local' : On a besoin du module perl GD::Graph qui a quelques dpendances . Il faut d'abord installer la librairie libgd2-xpm : apt-get install libgd2-xpm-dev build-essential et les modules perl GD et GD::Text::Align . Pour installer ces modules, on se rend sur le site de CPAN afin de tlcharger les sources Les sources sont sauves ici : /home/skill/module_perl_source . Aprs les avoir dcompresser, on se rend dans le dossier de chaque module . On peut passer la compilation et l'installation, refaire pour chaque modules et dans l'ordre des dpendances (c'est dire GD puis GD::Text//align puis GD::Graph) : perl Makefile.pl make make test make install Dsormais on peut utiliser Calamaris de cette faon: cat /var/log/squid/access.log | calamaris -a --outputfile access_stats.html -F html,graph --output-path ./stats Cela construit diffrentes images reprsentatives de l'tat de Squid. Il nous reste donc installer un serveur Web pour que ces graphes soit consultables distance.

Le serveur Web lighttpd

Comme son nom l'indique, ce serveur Web est trs lger. Pour l'installer : aptitude install lighttpd On supprime l'ancien index :cd /var/www ; rm *.html oldindex.html Ensuite en utilisant calamaris de la sorte : cat /var/log/squid/access.log | calamaris -a output-file index.html -F html,graph output-path /var/www

On cre des graphes dans le dossier du serveur Web . On peut consulter les rapports de Squid l'adresse : http://192.168.0.254 . Afin d'automatiser cela, il faut renseigner le fichier /etc/crontab :

Dans un souci de confidentialit, on peut changer les options de rapport . Il faut consulter le manuel : man calamaris. Puis changer la commande lanc dans le fichier /etc/cron.daily/calamaris Par exemple, pour garantir l'anonymat, on pourrait utiliser : cat /var/log/squid/access.log|calamaris -D 10 -P 60 --response-time-report html,graph --output-path /var/www/ --output-file index.html -F

Prcisions propos du fichier /etc/squid.squid.conf

Le proxy lit sa configuration dans ce fichier. Seul le rseau 192.168.0.0 est autoris l'utiliser. Le cache utilis la mthode aufs . En criture et lecture asynchrone, il permet de meilleures performances. Bien que Squid soit conu pour servir des rponses mises jours, on peut aussi lui indiquer de garder des objets plus longtemps. Lors d'une installation de logiciels par Ninit, une capture avec WireShark, a montr que toutes les requts HTTP contenait la directive cache-control=no-cache. Cela forait le mandataire retlcharger les logiciels. Afin d'outrepasser cette directive, on se sert du paramtre refresh_patterns . On recrit ainsi l'entte HTTP des requtes concernes. Cette mthode utilisant des expressions rgulires, on peut les vrifier par exemple grce au site jsregex.com. http://wiki.squid-cache.org/SquidFaq/CompleteFaq

A propos du paramtre refresh_pattern

La directive refresh_pattern contrle indirectement le cache . Elle permet de dcider si Squid doit considrer une requte comme cachable ou non .Des paramtres libraux augmenteront les objets cachs mais aussi les chances que les utilisateurs reoivent une rponse prime. Les rgles ne s'appliquent qu'aux requtes sans date explicite d'expiration. Les serveurs d'origine spcifier une date d'expiration avec soit l'en-tte Expires, ou avec la directive Cache-Control: max-age . Vous pouvez mettre n'importe quel nombre de lignes refresh_pattern dans le fichier de configuration. Squid recherche jusqu ce qu'une expression rgulire corresponde puis dtermine si l'objet dans le cache est prim ou non . La syntaxe est : refresh_pattern [-i] regexp min percent max [options] Le paramtre regexp est une expression rgulire qui est normalement sensible la casse. L'option -i le rend insensible la casse. Le paramtre min est un nombre de minutes. Une rponse ne peut pas tre prime tant que son temps dans le cache ne dpasse pas la valeur minimale. De mme, une rponse ne peut pas tre frache moins que son temps dans le cache est infrieure la dure maximale (max). Les rponses qui se situent entre le minimum et maximum sont soumis au facteur LM-facteur . Pour ces rponses, Squid calcule l'ge de rponse et le facteur LM et le compare au pourcentage. L'ge de rponse est la quantit de temps coul depuis que le serveur d'origine a gnr (ou valid) la rponse. L'ge des ressources est la diffrence entre les en-ttes Last-Modified et la date. Le facteur LM est le rapport entre l' ge de la rponse et l'ge de la ressource. La directive refresh_pattern dispose galement d'options qui force Squid dsobir au protocole HTTP.

Override-expire : cette option provoque la vrification de la valeur minimale avant de vrifier l'en-tte Expires. Ainsi, un minimum non-nul retourne un cache non-valid mme si la rponse est expire. Override-lastmod : Squid vrifie la valeur min avant le pourcentage LM-facteur .

Reload-into-ims : transforme une directive no-cache en validation IMS (If-Modified-Since) . En d'autres termes, Squid ajoute un entte IMS la demande avant de transmettre. Notez que cela ne fonctionne que pour les objets qui ont un horodatage de dernire modification. La requte sortante conserve la directive no-cache, de sorte qu'elle atteint le serveur d'origine. Ignore-reload : Squid ignore la directive no-cache. Il y a encore d'autres options : ignore-no-cache , ignore-no-store , ignore-must-revalidate , ignore-private , ignore-auth , max-stale=NN ; refresh-ims , store-stale Dans le cas des mises jours Windows et installation Ninit, la capture faite avec Wireshark montrer que seule la directive cache-control : no-cache tait utilise . Donc on se sert de l'option reload-into-ims afin de cacher les objets toute en effectuant une vrification . Plus de renseignement ici : http://www.squid-cache.org/Doc/config/refresh_pattern/

Annexes Fichier de configuration de Squid (/etc/squid/squid.conf)

cache_effective_user proxy visible_hostname Skill_Proxy dns_nameservers 127.0.0.1 cache_mgr [email protected] ###config des logs##### cache_log /var/log/squid/cache.log cache_access_log /var/log/squid/access.log cache_store_log /var/log/squid/store.log logfile_rotate 7 ###config des caches#### #seuil en pourcentage de vidage du cache cache_swap_low 95 cache_swap_high 97 #taille maximale des objets en mmoire vive et #dans le cache maximum_object_size_in_memory 4096 KB maximum_object_size 512 MB #politique de nettoyage du cache #lru = last recent used #LFUDA = least frequently used with dynamic aging #favorise les objets populaires et volumineux sur le dur memory_replacement_policy lru cache_replacement_policy heap LFUDA #le cache 1 est le seul utilis #les 2 suivants sont de secours #pour changer de cache : #commenter la ligne du cache1 #decommenter celle du cache 2 ou 3 #sauver le fichier puis lancer la commande #squid -k reconfigure cache_dir aufs /cache1 50000 32 256 #cache_dir aufs /cache2 50000 32 256 #cache_dir aufs /cache3 50000 32 256 #le choix aufs correspond au mode le plus #rapide d'ecriture asynchrone dans le cache coredump_dir /cache1 #RAM reserv pour cacher cache_mem 960 MB #debug_options ALL,1 33,2

#les instructions suivantes ne servent qu'en cas #d'un miroir local #redirect_program /usr/local/squirm/bin/squirm #redirect_children 20 #acl foo dstdomain .winscp.net #acl foo dstdomain .documentfoundation.org #redirector_access allow foo #redirector_access deny all #redirector_bypass on #les rgles suivantes sont les rgles d'accs #elles dfinissent les ports et les plages d'adresses #autorises par Squid acl manager proto cache_object acl localhost src 127.0.0.1/32 ::1 acl to_localhost dst 127.0.0.0/8 0.0.0.0/32 ::1 acl server src 192.168.0.254 acl localnet src 192.168.0.0/24 acl SSL_ports port 443 acl Safe_ports port 80 acl Safe_ports port 21 acl Safe_ports port 443 acl Safe_ports port 70 acl Safe_ports port 210 acl Safe_ports port 1025-65535 acl Safe_ports port 280 acl Safe_ports port 488 acl Safe_ports port 591 acl Safe_ports port 777 acl CONNECT method CONNECT acl PURGE method PURGE http_access allow PURGE server http_access deny PURGE all http_access allow manager localhost http_access allow manager server http_access deny manager http_access deny !Safe_ports http_access deny CONNECT !SSL_ports #http_access deny to_localhost http_access allow localnet http_access allow localhost http_access deny all #ic on prcise l'interface, le port #et le mode d'coute de Squid http_port 192.168.0.254:3128 intercept # Add any of your own refresh_pattern entries above these. refresh_pattern ^ftp: 1440 20% 10080 refresh_pattern ^gopher: 1440 0% 1440 refresh_pattern -i (/cgi-bin/|\?) 0 0% 0 #refresh_pattern . 0 20% 4320 #Tuning pour Windows Update range_offset_limit -1 quick_abort_min -1 #les paramtres "refresh" permettent #d'outrepasser la directive no-cache #contenue dans l'entete HTTP : #l'option -i pour insensible a la casse ##Pour Windows, la date de premption s'tend jusqu' un mois refresh_pattern -i microsoft.com/.*\.(cab|exe|ms[i|u|f]|asf|wm[v|a]|dat|zip) 4320 80% 43200 reload-into-ims refresh_pattern -i windowsupdate.com/.*\.(cab|exe|ms[i|u|f]|asf|wm[v|a]|dat|zip) 4320 80% 43200 reload-into-ims refresh_pattern -i my.windowsupdate.website.com/.*\.(cab|exe|ms[i|u|f]|asf|wm[v|a]|dat| zip) 4320 80% 43200 reload-into-ims ##pour chrome, on vrife toutes les semaines refresh_pattern -i ^.*/chrome_installer.exe 2880 80% 10080 reload-into-ims ##pour 7-Zip, toutes les 2 semaines refresh_pattern -i ^.*/7-Zip/.*\.(msi|exe) 2880 80% 20160 reload-into-ims

refresh_pattern -i ^.*/TeamViewer_Setup\.exe 2880 80% 20160 reload-into-ims

refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern refresh_pattern

-i -i -i -i -i -i -i -i -i -i -i -i -i

^.*/SetupImgBurn.*\.exe 2880 80% 20160 reload-into-ims ^.*/picasa.*\setup.exe 2880 80% 20160 reload-into-ims ^.*/thunderbird.*\.exe 2880 80% 20160 reload-into-ims ^.*/pdfcreator.*\.exe 2880 80% 20160 reload-into-ims ^.*/audacity-win.*\.exe 2880 80% 20160 reload-into-ims ^.*/vlc.*\.exe 2880 80% 20160 reload-into-ims ^.*/adobe/reader.*\.exe 2880 80% 20160 reload-into-ims ^.*/openoffice/.*\.exe 2880 80% 20160 reload-into-ims ^.*/QuickTimeInstaller.exe 2880 80% 20160 reload-into-ims ^.*/cdbxp.*\.exe 2880 80% 20160 reload-into-ims ^.*/mbam-setup.*\.exe 2880 80% 20160 reload-into-ims ^.*/SUPERAntiSpyware.*\.exe 2880 80% 20160 reload-into-ims ^.*/spybots.*\.exe 2880 80% 20160 reload-into-ims

Script de dmarrage de Squid (/etc/init.d/squid)

#! /bin/sh # # squid Startup script for the SQUID HTTP proxy-cache. # # Version: @(#)squid.rc 2.20 01-Oct-2001 [email protected] # ### BEGIN INIT INFO # Provides: squid # Required-Start: $network $remote_fs $syslog # Required-Stop: $network $remote_fs $syslog # Should-Start: $named # Should-Stop: $named # Default-Start: 2 3 4 5 # Default-Stop: 0 1 6 # Short-Description: Squid HTTP Proxy ### END INIT INFO NAME=squid DAEMON=/usr/sbin/squid LIB=/usr/lib/squid PIDFILE=/var/run/$NAME.pid SQUID_ARGS="-YC" [ ! -f /etc/default/squid ] || . /etc/default/squid . /lib/lsb/init-functions PATH=/bin:/usr/bin:/sbin:/usr/sbin [ -x $DAEMON ] || exit 0 grepconf () { w=" " # space tab sq=/etc/squid/squid.conf # sed is cool. res=`sed -ne ' s/^'$1'['"$w"']\+\([^'"$w"']\+\).*$/\1/p; t end; d; :end q' < $sq` [ -n "$res" ] || res=$2 echo "$res" } grepconf2 () { w=" " # space tab sq=/etc/squid/$NAME.conf # sed is cool. res=`sed -ne ' s/^'$1'['"$w"']\+[^'"$w"']\+['"$w"']\+\([^'"$w"']\+\).*$/\1/p; t end; d; :end q' < $sq` [ -n "$res" ] || res=$2 echo "$res" } # Try to increase the # of filedescriptors we can open. maxfds () {

10

[ -n "$SQUID_MAXFD" ] || return [ -f /proc/sys/fs/file-max ] || return 0 global_file_max=`cat /proc/sys/fs/file-max` minimal_file_max=$(($SQUID_MAXFD + 4096)) if [ "$global_file_max" -lt $minimal_file_max ] then echo $minimal_file_max > /proc/sys/fs/file-max fi ulimit -n $SQUID_MAXFD } start () { cdr=`grepconf2 cache_dir /cache1` ctp=`grepconf cache_dir aufs` case "$cdr" in [0-9]*) log_failure_msg "squid: squid.conf contains 2.2.5 syntax - not starting!" log_end_msg 1 exit 1 ;; esac # # Create spool dirs if they don't exist. # if [ -d "$cdr" -a ! -d "$cdr/00" ] || [ "$ctp" = "aufs" -a ! -w "$cdr" ] then log_warning_msg "Creating squid cache structure" $DAEMON $SQUID_ARGS -z fi if [ "$CHUID" = "" ]; then CHUID=root fi maxfds umask 027 start-stop-daemon --quiet --start \ --pidfile $PIDFILE \ --chuid $CHUID \ --exec $DAEMON -- $SQUID_ARGS < /dev/null return $? } stop () { PID=`cat $PIDFILE 2>/dev/null` start-stop-daemon --stop --quiet --pidfile $PIDFILE --name squid # # Now we have to wait until squid has _really_ stopped. # sleep 2 if test -n "$PID" && kill -0 $PID 2>/dev/null then log_action_begin_msg " Waiting" cnt=0 while kill -0 $PID 2>/dev/null do cnt=`expr $cnt + 1` if [ $cnt -gt 24 ] then log_action_end_msg 1 return 1 fi sleep 5 log_action_cont_msg "" done log_action_end_msg 0 return 0 else return 0 fi } case "$1" in start) log_daemon_msg "Starting Squid HTTP proxy" "squid"

11

if start ; then log_end_msg $? else log_end_msg $? fi ;; stop) log_daemon_msg "Stopping Squid HTTP proxy" "squid" if stop ; then log_end_msg $? else log_end_msg $? fi ;; reload|force-reload) log_action_msg "Reloading Squid configuration files" $DAEMON -k reconfigure log_action_end_msg 0 ;; restart) log_daemon_msg "Restarting Squid HTTP proxy" "squid" stop if start ; then log_end_msg $? else log_end_msg $? fi ;; status) status_of_proc -p "$PIDFILE" "$DAEMON" squid && exit 0 || exit $? ;; *) echo "Usage: /etc/init.d/$NAME {start|stop|reload|force-reload|restart|status}" exit 3 ;; esac exit 0

12

Script de surveillance de Squid (/etc/squid/squid-watcher.sh)

#!/bin/bash # # # # # # # # # # # # # # # # # # # # This script runs and keeps a watchful eye on a running Squid instance. If squid should die unexpectedly, it can run the commands of your choice. If squid comes back, another set of commands can be run. Additionally, you can use a separate invocation of this script to signal the daemonized watcher to start and stop immediately (useful to add to your squid init scripts so you don't take unnecessary action when you _want_ to shutdown squid). We use this script to enable/disable iptables rules on the host that redirect port 80 traffic to our squid box. Should squid stop working, we want the redirection to stop (and traffic to pass normally). Once squid returns, the watcher should notice and re-enable the forwarding rules. You'll see our rules in the "start_hook" and "stop_hook" functions. Change them to whatever you see fit. You can run the program from INIT by adding this to /etc/inittab: sq:2345:respawn:/path/to/squid-watcher poll < /dev/null > /dev/null 2>&1 Author: Jason Healy <[email protected]> $Id: squid-watcher 1131 2008-10-13 17:15:46Z jhealy $

SQUID=/usr/sbin/squid SQUIDCLIENT=/usr/bin/squidclient SYSLOG="daemon.warning" EMAIL="contact@skill-informatique" DELAY=20 TESTURL="" # REDIRECTION quand Squid est OK start_hook() { iptables -F iptables -X iptables -t nat -F iptables -t nat -X iptables -t nat -A PREROUTING -s 192.168.0.254 -p tcp --dport 80 -j ACCEPT iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.168.0.254:3128 iptables -t nat -A POSTROUTING -j MASQUERADE 2>&1 } # NAT quand Squid est eteint stop_hook() { iptables -F iptables -t nat -F iptables -X iptables -t nat -X iptables -t nat -A POSTROUTING --out-interface eth0 -j MASQUERADE iptables -A FORWARD --in-interface eth1 -j ACCEPT 2>&1 } ########################################################################### ### No need to customize below here (unless you know what you're doing) ### ########################################################################### NAME=squid-watcher PIDFILE="/var/run/$NAME.pid" LCKFILE="/var/run/$NAME.lck" # Signal names to send for various actions. Shouldn't need to change, # unless you really want to reassign the signal handlers SIGSTART="USR1" SIGSTOP="USR2" SIGINFO="HUP" # Set program status. We use this to figure out what state the script

13

# is in. Possible values: # STOPPED - Squid has been properly shut down and is supposed to be off # RUNNING - Squid is running and responding to requests properly # BROKEN - Squid was shut down improperly, or is not servicing requests # Initially, we don't know what state squid is in, so we assume it's # running and try to recover. STATUS="BROKEN" # Function: Log any messages log() { if [ -n "$*" ]; then if [ -n "$SYSLOG" ]; then logger -i -t $NAME -p "$SYSLOG" -- "$*" fi if [ -n "$EMAIL" ]; then echo -e "\n$*\n\n`date`" | mail -s "$NAME on `hostname`" "$EMAIL" fi echo -e $* fi } # Sanity check on binary paths if [ ! -x $SQUID ]; then log "Can't find executable squid at: $SQUID" exit 1 fi if [ ! -x $SQUIDCLIENT ]; then log "Can't find executable squidclient at: $SQUIDCLIENT" exit 1 fi # Function: test status of squid, and return one of the following: # OK - Squid is running an processing requests normally # NO - Squid process is not running / can't be found # EE - Squid is running, but not servicing requests squidstatus() { if $SQUID -k check 2>/dev/null; then if [ -n "$TESTURL" ]; then if $SQUIDCLIENT -s "$TESTURL" 2>/dev/null; then echo "OK" else echo "EE" fi else echo "OK" fi else echo "NO" fi } # Function: get a lock to protect critical sections lock() { # Loop until we get a lock: until (set -o noclobber; echo $$ >"$LCKFILE") 2>/dev/null; do set x `ls -l $LCKFILE` log "$1 waiting for lockfile (other working since $7 $8 $9)..." sleep 5 done } # Function: release a critical section lock unlock() { rm -f "$LCKFILE" } # Function: Set to running state and call any activation hooks activate() { lock "activate" if [ $STATUS != "RUNNING" ]; then # before activating, do one final test to make sure case `squidstatus` in OK) # Fire it up log "Squid is OK; calling start hook. " `start_hook` STATUS="RUNNING" ;; NO) log "Squid process is not running; not activating" STATUS="BROKEN" ;;

14

EE) log "Squid process not responding; not activating" STATUS="BROKEN" ;; *) log "Unknown squid status; not activating" STATUS="BROKEN" ;; esac fi unlock } # Function: Set to stopped state and call any deactivation hooks deactivate() { lock "deactivate" if [ $STATUS = "RUNNING" ]; then log "Deactivating at user's request; calling stop hook. " `stop_hook` fi if [ "$1" = "STOPPED" ]; then STATUS="STOPPED" else STATUS="BROKEN" fi unlock } # Function: Clean up and exit (signal handler for TERM, QUIT, INT, etc) cleanup() { log "$0 shutting down; deactivating" # return to "STOPPED" state deactivate # clean up lockfiles rm -f "$PIDFILE" "$LCKFILE" } # Function: Start a polling daemon to keep an eye on squid polling() { # Create PID file (make sure we're the only daemon running) if (set -o noclobber; echo $$ >"$PIDFILE") 2>/dev/null; then log "Starting polling daemon" else log "Unable to get lock $PIDFILE; is $NAME already running?" sleep 15 exit 1 fi # Initialize signal handlers trap 'log "Signal to start received"; activate' $SIGSTART trap 'log "Signal to stop received"; deactivate "STOPPED"' $SIGSTOP trap 'log "Ignoring $SIGINFO; current running status is: $STATUS"' $SIGINFO # sig 0 covers all exits, both normal and interrupted trap cleanup 0 # poll forever... while true; do # don't bother checking if squid isn't supposed to be running... if [ $STATUS != "STOPPED" ]; then case `squidstatus` in OK) if [ $STATUS = "BROKEN" ]; then log "Squid has recovered; activating..." activate fi ;; NO) if [ $STATUS = "RUNNING" ]; then log "Squid process is no longer running; deactivating..." deactivate "BROKEN" fi ;; EE) if [ $STATUS = "RUNNING" ]; then log "Squid process not responding; deactivating..." deactivate "BROKEN" fi ;; *) if [ $STATUS = "RUNNING" ]; then log "Unknown squid status; deactivating..."

15

deactivate "BROKEN" fi ;; esac fi # nap for a bit before next check sleep $DELAY & # "wait"ing on process allows signal traps to execute immediately, # rather that pausing until the sleep finishes execution wait done } # Function: send signal to running daemon signal() { echo -n "Sending signal to daemon... " if [ -r "$PIDFILE" ]; then kill -"$1" `cat "$PIDFILE"` echo "done" else echo "could not find PID of daemon in $PIDFILE; is it running?" exit 1; fi } # Function: send start signal to running daemon starting() { signal $SIGSTART } # Function: send stop signal to running daemon stopping() { signal $SIGSTOP } # Function: send info signal to running daemon info() { signal $SIGINFO } ############ ### MAIN ### ############ case "$1" in poll) polling ;; start) starting ;; stop) stopping ;; info) info ;; *) echo "Usage: $0 {poll|start|stop|info}" >&2 echo "" >&2 echo " poll starts a daemon that watches squid" >&2 echo "" >&2 echo " start and stop signal the daemon to stop/start immediately," >&2 echo " rather than waiting for the watcher to notice" >&2 echo "" >&2 echo " info sends info signal to daemon (check syslog)" >&2 echo "" >&2 exit 1 ;; esac

16