##@cooked comments # -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 ## Outils pour les distributions debian ##@cooked nocomments ##@require base ##@require sysinfos ##@require service uprovide debian urequire base sysinfos service ipcalc ################################################################################ # Gestion des packages function pkg_check() { # Vérifier que les packages sont installés sur le système local pkg status for pkg in "$@"; do status="$(LANG=C dpkg -s "$pkg" 2>/dev/null | grep '^Status:')" || return 1 [[ "$status" == *not-installed* ]] && return 1 [[ "$status" == *deinstall* ]] && return 1 done return 0 } function pkg_update() { # Mettre à jour la liste des packages silencieusement sans confirmation LANG=C apt-get update -qy } function pkg_upgrade() { # Mettre à jour la liste des packages silencieusement sans confirmation LANG=C apt-get upgrade -qy } function pkg_install() { # Installer les packages silencieusement et sans confirmation LANG=C apt-get install -qy "$@" } function pkg_installm() { # Installer les packages silencieusement et sans confirmation # Retourner 0 si au moins un des packages a été installé. Sinon, les # packages n'ont pas été installés, soit parce qu'ils sont déjà installé, # soit parce qu'il y a eu une erreur. if ! pkg_check "$@"; then # essayer d'installer les packages pkg_install "$@" else # aucun package n'a été installé return 1 fi } ################################################################################ # Gestion des services function service_disable() { # Désactiver le service $1 pour qu'il ne se lance pas automatiquement au # démarrage update-rc.d -f "$1" remove } function service_enable() { # Activer le service $1 pour qu'il se lance automatiquement au démarrage update-rc.d "$1" defaults } ################################################################################ # Gestion des interfaces réseau __DEBIAN_NETWORK_DEVEL_SHOW_MODIFS= __DEBIAN_NETWORK_INTERFACES=/etc/network/interfaces function __network_parse_confbr() { local br; local -a ifaces splitpair "$1" br ifaces array_split ifaces "$ifaces" , __npc_destbr="$br" array_copy __npc_destifaces ifaces } function network_parse_confbr() { # network_parse_confbr "$confbr" br ifaces local __npc_destbr; local -a __npc_destifaces __network_parse_confbr "$1" set_var "${2:-br}" "$__npc_destbr" array_copy "${3:-ifaces}" __npc_destifaces } function network_format_confbr() { # network_format_confbr "$br" ifaces --> "br:ifaces" echo "$1:$(array_join "${2:-ifaces}" ,)" } function __network_parse_confip() { local tmpig iface gateway; local -a ipsuffixes splitfsep2 "$1" : tmpig ipsuffixes splitfsep "$tmpig" // iface gateway array_split ipsuffixes "$ipsuffixes" , __npc_destiface="$iface" __npc_destgateway="$gateway" array_copy __npc_destipsuffixes ipsuffixes } function network_parse_confip() { # network_parse_confip "$confip" iface gateway ipsuffixes local __npc_destiface __npc_destgateway; local -a __npc_destipsuffixes __network_parse_confip "$1" set_var "${2:-iface}" "$__npc_destiface" set_var "${3:-gateway}" "$__npc_destgateway" array_copy "${4:-ipsuffixes}" __npc_destipsuffixes } function network_parse_ipsuffix() { # network_parse_ipsuffix "$ipsuffix" ip suffix splitfsep "$1" / "${2:-ip}" "${3:-suffix}" } function network_format_confip() { # network_format_confip "$iface" "$gateway" ipsuffixes --> "iface//gateway:ipsuffixes" local tmpig="$1${2:+//$2}" echo "${tmpig:+$tmpig:}$(array_join "${3:-ipsuffixes}" ,)" } function network_format_ipsuffix() { # network_format_ipsuffix "$ip" "$suffix" --> "ip:suffix" if [ "${1,,}" == "dhcp" ]; then echo "${1,,}" else echo "$1${2:+/$2}" fi } function __network_fix_confbrs() { local -a confbrs ifaces brs ips local confbr br iface # recenser les bridges et créer les tableaux __BR_ifaces for confbr in "${__nfc_confbrs[@]}"; do network_parse_confbr "$confbr" br ifaces array_addu brs "$br" eval "local -a ${br}_ifaces" done # puis constuire la liste des interfaces associées à chaque bridge for confbr in "${__nfc_confbrs[@]}"; do network_parse_confbr "$confbr" br ifaces array_extendu "${br}_ifaces" ifaces done # puis construire le tableau final array_new confbrs for br in "${brs[@]}"; do array_add confbrs "$(network_format_confbr "$br" "${br}_ifaces")" done array_copy __nfc_destconfbrs confbrs } function network_fix_confbrs() { # normaliser le tableau $1(=confbrs): fusionner les doublons local -a __nfc_confbrs __nfc_destconfbrs array_copy __nfc_confbrs "${1:-confbrs}" __network_fix_confbrs array_copy "${1:-confbrs}" __nfc_destconfbrs } function __network_fix_confips() { local -a confips ipsuffixes ifaces ips local confip iface gateway ip suffix mainip local mainiface="$1" # recenser les interfaces et créer les tableaux __IFACE_ipspecs for confip in "${__nfc_confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes [ -n "$iface" ] || iface="$mainiface" array_addu ifaces "$iface" eval "local ${iface}_gateway; local -a ${iface}_ipsuffixes" done # puis construire la liste des adresses IP associées à chaque interface for confip in "${__nfc_confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes [ -n "$iface" ] || iface="$mainiface" # si la passerelle a déjà été spécifiée, la récupérer local tmpgw="${iface}_gateway" [ -n "${!tmpgw}" ] && gateway="${!tmpgw}" # calculer l'adresse ip principale, pour pouvoir traiter le cas où # l'adresse ip principale est l'adresse de la passerelle. mainip= for ipsuffix in "${ipsuffixes[@]}"; do network_parse_ipsuffix "$ipsuffix" ip suffix if ! array_contains ips "$ip"; then [ -n "$suffix" ] || suffix=24 if [ -z "$mainip" ]; then [ -n "$gateway" ] || gateway="$(ipcalc_gateway "$ip" "$suffix")" mainip="$ip" fi array_add "${iface}_ipsuffixes" "$(network_format_ipsuffix "$ip" "$suffix")" array_add ips "$ip" fi done [ "$gateway" == "$mainip" ] && gateway= # si l'adresse ip principale est obtenue par dhcp, il ne faut pas # spécifier la passerelle: elle sera fournie par le serveur DHCP. # Utiliser le marqueur "none" pour que la valeur ne soit pas modifiée. [ "${ipsuffixes[0]}" == "dhcp" ] && gateway=none set_var "${iface}_gateway" "$gateway" done # puis construire le tableau final array_new confips for iface in "${ifaces[@]}"; do gateway="${iface}_gateway"; gateway="${!gateway}" [ "$gateway" == "none" ] && gateway= array_add confips "$(network_format_confip "$iface" "$gateway" "${iface}_ipsuffixes")" done array_copy __nfc_destconfips confips } function network_fix_confips() { # normaliser le tableau $1(=confips): fusionner les doublons, spécifier le # suffixe /24 par défaut, etc. $2 est le cas échéant l'interface associée # aux adresses ip non qualifiées local -a __nfc_confips __nfc_destconfips array_copy __nfc_confips "${1:-confips}" __network_fix_confips "$2" array_copy "${1:-confips}" __nfc_destconfips } function __network_fix_mainiface() { local -a confips ifaces ipsuffixes local br iface gateway confip mainconfip local mainiface="$1" # déterminer mainiface if [ -z "$mainiface" -a -n "${__nfm_confbrs[0]}" ]; then network_parse_confbr "${__nfm_confbrs[0]}" br ifaces mainiface="$br" fi if [ -z "$mainiface" -a -n "${__nfm_confips[0]}" ]; then network_parse_confip "${__nfm_confips[0]}" iface gateway ipsuffixes mainiface="$iface" fi [ -n "$mainiface" ] || mainiface=eth0 # ensuite, il faut reécrire confips avec la valeur de mainiface array_new confips for confip in "${__nfm_confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes [ -n "$iface" ] || iface="$mainiface" confip="$(network_format_confip "$iface" "$gateway" ipsuffixes)" if [ "$iface" == "$mainiface" ]; then mainconfip="$confip" else array_add confips "$confip" fi done [ -n "$mainconfip" ] && array_ins confips "$mainconfip" array_copy __nfm_destconfips confips } function network_fix_mainiface() { # A partir des valeurs des tableaux $1(=confbrs) et $2(=confips), et de # l'interface principale $3, déterminer l'interface principale. Si $3 est # spécifié, c'est la valeur sélectionnée. Sinon, si un bridge existe, c'est # le premier bridge qui est sélectionné. Sinon, la première interface est # sélectionnée. Sinon, on prend eth0. # Ensuite, réorganiser les tableaux de façon que confips[0] devienne la # configuration ip de l'interface principale. local -a __nfm_confbrs __nfm_confips __nfm_destconfips array_copy __nfm_confbrs "${1:-confbrs}" array_copy __nfm_confips "${2:-confips}" __network_fix_mainiface "$3" array_copy "${2:-confips}" __nfm_destconfips } function network_fix_confs() { network_fix_confbrs "${1:-confbrs}" network_fix_confips "${2:-confips}" network_fix_mainiface "${1:-confbrs}" "${2:-confips}" "$3" } function __network_valid_ifaces() { ip link | awk '/<.*>/ { flags = $0; sub(/^.*.*$/, ",", flags) if (flags ~ /,LOOPBACK,/) next if (flags !~ /,UP,/) next sub(/:$/, "", $2); print $2 }' } function __network_set_confbrs() { local -a ifaces tmpconfbrs confbrs local confbr br iface array_from_lines ifaces "$(__network_valid_ifaces)" array_from_lines tmpconfbrs "$(brctl show 2>/dev/null | awk ' BEGIN { confbrs = "" } NR == 1 { next } { if ($1 != "" && $2 != "") { if (confbr != "") print confbr confbr = $1 ":" $4 } else { confbr = confbr "," $1 } } END { if (confbr != "") print confbr } ')" for confbr in "${tmpconfbrs[@]}"; do splitpair "$confbr" br iface array_contains ifaces "$br" || continue array_add confbrs "$confbr" done array_copy __nsc_destconfbrs confbrs } function network_set_confbrs() { # initialiser $1(=confbrs) avec l'état des bridges sur le système courant local -a __nsc_destconfbrs __network_set_confbrs array_copy "${1:-confbrs}" __nsc_destconfbrs } function __network_set_gateway() { # initialiser la variable gateway avec la passerelle associée à l'interface # $1 gateway="$(route -n | awk -v iface="$1" '$1 == "0.0.0.0" && $8 == iface { print $2 }')" } function __network_set_confip() { # initialiser la variable confip avec l'état de l'interface $1, en assumant # que la passerelle vaut $2. # retourner 1 si l'interface n'a pas d'adresse ip associée local -a ipsuffixes array_from_lines ipsuffixes "$(ip addr show dev "$1" | awk '$1 == "inet" { print $2 }')" confip="$(network_format_confip "$1" "$2" ipsuffixes)" [ "${#ipsuffixes[*]}" -gt 0 ] } function __network_set_confips() { local -a confips ifaces local iface gateway array_from_lines ifaces "$(__network_valid_ifaces)" for iface in "${ifaces[@]}"; do __network_set_gateway "$iface" __network_set_confip "$iface" "$gateway" || continue array_add confips "$confip" done array_copy __nsc_destconfips confips } function network_set_confips() { # initialiser le tableau $1(=confips) avec l'état des interfaces sur le # système courant local -a __nsc_destconfips __network_set_confips array_copy "${1:-confips}" __nsc_destconfips } function network_interfaces_check_confbr() { # Vérifier que la configuration du bridge $1, dont les membres sont les # interfaces du tableau $2(=ifaces) est faite dans le fichier # $3(=/etc/network/interfaces) local -a __nicc_ifaces; array_copy __nicc_ifaces "${2:-ifaces}" local br="$1" local -a ifaces; array_copy ifaces __nicc_ifaces local nifile="${3:-$__DEBIAN_NETWORK_INTERFACES}" awkrun <"$nifile" -f br="$br" ifaces[@]=__nicc_ifaces ' BEGIN { array_new(iface_have_autos) array_new(iface_have_hotplugs) array_new(iface_have_manuals) for (i = 1; i <= ifaces_count; i++) { iface_have_autos[i] = 0 iface_have_hotplugs[i] = 0 iface_have_manuals[i] = 0 } br_have_auto = 0 br_have_hotplug = 0 have_br = 0 } function get_iface_index(iface, i) { for (i = 1; i <= ifaces_count; i++) { if (ifaces[i] == iface) return i } return 0 } $1 ~ /^(allow-)?auto$/ { for (j = 2; j <= NF; j++) { i = get_iface_index($j) if (i != 0) iface_have_autos[i] = 1 if ($i == br) br_have_auto = 1 } } $1 == "allow-hotplug" { for (j = 2; j <= NF; j++) { i = get_iface_index($j) if (i != 0) iface_have_hotplugs[i] = 1 if ($i == br) br_have_hotplug = 1 } } $1 == "iface" && $3 == "inet" && $4 == "manual" { i = get_iface_index($2) if (i != 0) iface_have_manuals[i] = 1 } $1 == "iface" && $2 == br && $3 == "inet" { have_br = 1 } END { check_auto_or_hotplug = br_have_auto || br_have_hotplug check_manuals = 1 if (check_auto_or_hotplug) { for (i = 1; i <= ifaces_count; i++) { if (!iface_have_autos[i] && !iface_have_hotplugs[i]) { check_auto_or_hotplug = 0 break } if (!iface_have_manuals[i]) { check_manuals = 0 break } } } if (!check_auto_or_hotplug || !check_manuals || !have_br) { exit 1 } exit 0 }' } function network_interfaces_check_confip() { # Vérifier que la configuration de l'interface $1, avec la passerelle $2, # avec les adresses IP du tabbleau $3(=ipsuffixes) est faite dans le fichier # $4(=/etc/network/interfaces) local -a __nicc_ipsuffixes; array_copy __nicc_ipsuffixes "${3:-ipsuffixes}" local iface="$1" gateway="$2" local -a ipsuffixes; array_copy ipsuffixes __nicc_ipsuffixes local nifile="${4:-$__DEBIAN_NETWORK_INTERFACES}" awkrun <"$nifile" -f iface="$iface" gateway="$gateway" ipsuffixes[@]=ipsuffixes ' BEGIN { have_auto = 0 have_hotplug = 0 have_iface = 0 have_method = 0 # static ou dhcp have_gateway = ipsuffixes[1] == "dhcp" || gateway == "" array_new(have_ips) array_new(have_ip_ups) array_new(have_ip_downs) for (i = 1; i <= ipsuffixes_count; i++) { have_ips[i] = 1 have_ip_ups[i] = 0 have_ip_downs[i] = 0 } have_ips[1] = 0 have_ip_ups[1] = 1 have_ip_downs[1] = 1 in_iface = 0 } function get_ipsuffix_index(ipsuffix, i) { ip0 = ipsuffix; sub(/\/[0-9]+$/, "", ip0) for (i = 1; i <= ipsuffixes_count; i++) { # XXX ne pas comparer les suffixes pour le moment ipi = ipsuffixes[i]; sub(/\/[0-9]+$/, "", ipi) if (ipi == ip0) return i } return 0 } $1 == "iface" && $2 == iface && $3 == "inet" { have_iface = 1 if (ipsuffixes[1] == "dhcp") { have_method = $4 == "dhcp" } else { have_method = $4 == "static" } in_iface = 1 next } in_iface && $1 == "gateway" && $2 == gateway { have_gateway = 1 next } in_iface && $1 == "address" && get_ipsuffix_index($2) == 1 { have_ips[1] = 1 next } in_iface && $0 ~ "^[ \\t]*(post-)?up (/sbin/)?ip addr add " { if (match($0, "ip addr add (.*/.*) dev " iface " ", vs) != 0) { i = get_ipsuffix_index(vs[1]) if (i > 1) { have_ip_ups[i] = 1 } } next } in_iface && $0 ~ "^[ \\t]*(pre-)?down (/sbin/)?ip addr del " { if (match($0, "ip addr del (.*/.*) dev " iface " ", vs) != 0) { i = get_ipsuffix_index(vs[1]) if (i > 1) { have_ip_downs[i] = 1 } } next } $1 == "iface" { in_iface = 0 next } $1 ~ /^(allow-)?auto$/ { for (i = 2; i <= NF; i++) { if ($i == iface) { have_auto = 1 } } in_iface = 0 next } $1 == "allow-hotplug" { for (i = 2; i <= NF; i++) { if ($i == iface) { have_hotplug = 1 } } in_iface = 0 next } END { check_auto_or_hotplug = have_auto || have_hotplug check_iface = have_iface && have_method && have_gateway check_ips = 1 for (i = 1; i <= ipsuffixes_count; i++) { if (!have_ips[i] || !have_ip_ups[i] || !have_ip_downs[i]) { check_ips = 0 break } } if (!check_auto_or_hotplug || !check_iface || !check_ips) { exit 1 } exit 0 }' } function __network_interfaces_remove_iface() { awkrun -f iface="$1" ' function match_iface(iface, line) { if (line == "") line = $0 " " return line ~ (" " iface " ") } function remove_auto_iface(iface, line) { if (line == "") line = $0 " " gsub(" " iface " ", " ", line) return line } function print_auto_iface(line) { if (line ~ /^(allow-)?auto *$/) { # une seule interface sur la ligne: ne pas l"afficher } else { # supprimer l"interface de la ligne sub(/ *$/, "", line) print line } } function remove_hotplug_iface(iface, line) { if (line == "") line = $0 if (line !~ / $/) line = line " " gsub(" " iface " ", " ", line) return line } function print_hotplug_iface(line) { if (line ~ /^allow-hotplug *$/) { # une seule interface sur la ligne: ne pas l"afficher } else { # supprimer l"interface de la ligne sub(/ *$/, "", line) print line } } BEGIN { in_iface = 0 found_iface = 0 modified = 0 } !found_iface && $1 == "iface" && $2 == iface && $3 == "inet" { in_iface = 1 found_iface = 1 modified = 1 next } $1 == "iface" { in_iface = 0 } $1 ~ /^(allow-)?auto$/ { in_iface = 0 if (match_iface(iface)) { print_auto_iface(remove_auto_iface(iface)) modified = 1 next } } $1 == "allow-hotplug" { in_iface = 0 if (match_iface(iface)) { print_hotplug_iface(remove_hotplug_iface(iface)) modified = 1 next } } !in_iface { print } END { if (modified) exit 0 else exit 1 }' } function network_interfaces_remove_iface() { # Supprimer dans le fichier $2(=/etc/network/interfaces) toute la # configuration qui concerne l'interface $1 local iface="$1" nifile="${2:-$__DEBIAN_NETWORK_INTERFACES}" local tmpfile; ac_set_tmpfile tmpfile local modified if __network_interfaces_remove_iface "$iface" <"$nifile" >"$tmpfile"; then cat "$tmpfile" >"$nifile" modified=1 fi ac_clean "$tmpfile" [ -n "$modified" ] } function network_interfaces_remove_ifaces() { # Supprimer dans le fichier $2(=/etc/network/interfaces) toute la # configuration qui concerne les interfaces du tableau $1=(ifaces) local -a __niri_ifaces; array_copy __niri_ifaces "${1:-ifaces}" local -a ifaces; array_copy ifaces __niri_ifaces local nifile="${2:-$__DEBIAN_NETWORK_INTERFACES}" local workfile; ac_set_tmpfile workfile local tmpfile; ac_set_tmpfile tmpfile local iface modified cat "$nifile" >"$workfile" for iface in "${__niri_ifaces[@]}"; do if __network_interfaces_remove_iface "$iface" <"$workfile" >"$tmpfile"; then cat "$tmpfile" >"$workfile" modified=1 fi done [ -n "$modified" ] && cat "$workfile" >"$nifile" ac_clean "$workfile" "$tmpfile" [ -n "$modified" ] } function network_interfaces_remove_confbr() { # Supprimer dans le fichier $3(=/etc/network/interfaces) toute la # configuration qui concerne le bridge $1, et dont les interfaces sont # listées dans le tableau $2(=ifaces) local -a __nirc_ifaces; array_copy __nirc_ifaces "${2:-ifaces}" local -a ifaces; array_copy ifaces __nirc_ifaces array_ins ifaces "$1" network_interfaces_remove_ifaces ifaces "$3" } function network_interfaces_add_confip() { # ajouter dans le fichier $4(=/etc/network/interfaces) la configuration pour # l'interface $1, avec éventuellement la passerelle $2, et les adresses ips # telles qu'elles sont définies dans le table $3(=ipsuffixes) local -a __niac_ipsuffixes; array_copy __niac_ipsuffixes "${3:-ipsuffixes}" local iface="$1" gateway="$2" local -a ipsuffixes; array_copy ipsuffixes __niac_ipsuffixes local nifile="${4:-$__DEBIAN_NETWORK_INTERFACES}" local mainip netmask method network_parse_ipsuffix "${ipsuffixes[0]}" mainip netmask if [ "$mainip" == "dhcp" ]; then mainip= netmask= method=dhcp else netmask="$(ipcalc_netmask "$netmask")" [ -n "$netmask" ] || netmask=255.255.255.0 method=static fi echo >>"$nifile" " auto $iface iface $iface inet $method${mainip:+ address $mainip netmask $netmask${gateway:+ gateway $gateway}}" local i=0 ipsuffix for ipsuffix in "${ipsuffixes[@]:1}"; do echo >>"$nifile" "\ up ip addr add $ipsuffix dev $iface label $iface:$i down ip addr del $ipsuffix dev $iface label $iface:$i" i=$(($i + 1)) done } function network_interfaces_add_confbr() { # ajouter dans le fichier $4(=/etc/network/interfaces) la configuration pour # le bridge $1, avec la liste des interfaces dans le tableau $2(=ifaces) et # la liste des configurations des adresses des interfaces dans le tableau # $3(=confips) local -a __niac_ifaces; array_copy __niac_ifaces "${2:-ifaces}" local -a __niac_confips; array_copy __niac_confips "${3:-confips}" local br="$1" local -a ifaces; array_copy ifaces __niac_ifaces local -a confips; array_copy confips __niac_confips local nifile="${4:-$__DEBIAN_NETWORK_INTERFACES}" local iface confip for iface in "${ifaces[@]}"; do echo >>"$nifile" " auto $iface iface $iface inet manual" done local found= for confip in "${confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes if [ "$iface" == "$br" ]; then found=1 break fi done [ -n "$found" ] || return 1 network_interfaces_add_confip "$br" "$gateway" ipsuffixes "$nifile" ifaces="${ifaces[*]}" [ -n "$ifaces" ] || ifaces="none" echo >>"$nifile" "\ bridge_ports $ifaces bridge_stp off bridge_fd 2 bridge_maxwait 0" } function __network_backup() { local file="$1" local backup="$file.orig$(date +%Y%m%d)" [ -f "$backup" ] || cat "$file" >"$backup" 2>/dev/null } function network_fix_hostname() { local hostname="${1%%.*}" local modified [ -f /etc/hostname ] || touch /etc/hostname if [ -n "$__DEBIAN_NETWORK_DEVEL_SHOW_MODIFS" ]; then uecho "Setting /etc/hostname to $hostname" elif [ "$(/etc/hostname modified=1 fi [ -n "$modified" ] } function network_fix_mailname() { local host="$1" local modified [ -f /etc/mailname ] || touch /etc/mailname if [ -n "$__DEBIAN_NETWORK_DEVEL_SHOW_MODIFS" ]; then uecho "Setting /etc/mailname to $host" elif [ "$(/etc/mailname modified=1 fi [ -n "$modified" ] } function network_fix_exim4() { local host="$1" oldhost="$2" local tmpfile; ac_set_tmpfile tmpfile local modified sed "$tmpfile" " /^dc_other_hostnames=/c\\ dc_other_hostnames='$host'" if [ -n "$__DEBIAN_NETWORK_DEVEL_SHOW_MODIFS" ]; then if testdiff "$tmpfile" /etc/exim4/update-exim4.conf.conf; then uecho "Setting /etc/exim4/update-exim4.conf.conf to:" cat "$tmpfile" | sed 's/^/ /g' 1>&2 else uecho "/etc/exim4/update-exim4.conf.conf: pas de modifications" fi elif testdiff "$tmpfile" /etc/exim4/update-exim4.conf.conf; then __network_backup /etc/exim4/update-exim4.conf.conf if show_debug; then edebug "Setting /etc/exim4/update-exim4.conf.conf to:" cat "$tmpfile" | sed 's/^/ /g' 1>&2 else estep /etc/exim4/update-exim4.conf.conf fi cat "$tmpfile" >/etc/exim4/update-exim4.conf.conf update-exim4.conf modified=1 fi ac_clean "$tmpfile" [ -n "$modified" ] } function network_fix_postfix() { local host="$1" oldhost="$2" local tmpfile; ac_set_tmpfile tmpfile local modified awkrun "$tmpfile" host="$host" oldhost="$oldhost" ' /^myhostname *=/ { $0 = "myhostname = " host } /^mydestination *=/ { gsub(" *" oldhost " *,? *", "") if ($0 !~ (" *" host " *,? *")) { sub(/^mydestination *= */, "mydestination = " host ", ") } } { print }' if [ -n "$__DEBIAN_NETWORK_DEVEL_SHOW_MODIFS" ]; then if testdiff "$tmpfile" /etc/postfix/main.cf; then uecho "Setting /etc/postfix/main.cf to:" cat "$tmpfile" | sed 's/^/ /g' 1>&2 else uecho "/etc/postfix/main.cf: pas de modifications" fi elif testdiff "$tmpfile" /etc/postfix/main.cf; then __network_backup /etc/postfix/main.cf if show_debug; then edebug "Setting /etc/postfix/main.cf to:" cat "$tmpfile" | sed 's/^/ /g' 1>&2 else estep /etc/postfix/main.cf fi cat "$tmpfile" >/etc/postfix/main.cf modified=1 fi ac_clean "$tmpfile" [ -n "$modified" ] } function network_fix_hosts() { local host="$1" hostname="${1%%.*}"; local shost="${host//./\\.}" local ip="$2"; local sip="${ip//./\\.}" local oldhost="$3" oldhostname="${3%%.*}"; soldhost="${host//./\\.}" local tmpfile; ac_set_tmpfile tmpfile local modified awkrun "$tmpfile" \ host="$host" hostname="$hostname" \ ip="$ip" \ oldhost="$oldhost" oldhostname="$oldhostname" \ ' /^[^# \t]/ { gsub("[ \\t]+" host "[ \\t]*", " ") gsub("[ \\t]+" hostname "[ \\t]*", " ") gsub("[ \\t]+" oldhost "[ \\t]*", " ") gsub("[ \\t]+" oldhostname "[ \\t]*", " ") if ($0 ~ /^[^ \t]+[ \t]*$/) next gsub(/[ \t]*$/, "") } { print }' if quietgrep "^$sip[ $TAB]\\+$shost[ $TAB]\\+$hostname" "$tmpfile"; then sed -i "\ s/\$/ / /^[ $TAB]$oldhost[ $TAB]/d /^[ $TAB]$oldhostname[ $TAB]/d s/ \$// " "$tmpfile" fi if ! quietgrep "^$sip[ $TAB]\\+$shost[ $TAB]\\+$hostname" "$tmpfile"; then sed -i "/^$sip[ $TAB]/d" "$tmpfile" sed -i "1i\\ $ip$TAB$host $hostname" "$tmpfile" fi if [ -n "$__DEBIAN_NETWORK_DEVEL_SHOW_MODIFS" ]; then if testdiff "$tmpfile" /etc/hosts; then uecho "Setting /etc/hosts to:" cat "$tmpfile" | sed 's/^/ /g' 1>&2 else uecho "/etc/hosts: pas de modifications" fi elif testdiff "$tmpfile" /etc/hosts; then __network_backup /etc/hosts if show_debug; then edebug "Setting /etc/hosts to:" cat "$tmpfile" | sed 's/^/ /g' 1>&2 else estep /etc/hosts fi cat "$tmpfile" >/etc/hosts modified=1 fi ac_clean "$tmpfile" [ -n "$modified" ] } function network_config() { # (Re)configurer le réseau sur l'hôte courant. # $1 (host) est le nom d'hôte. # $2 (confips) est le nom d'un tableau contenant la configuration des # adresses ips pour les interfaces. # $3 (confbrs) est le nom d'un tableau contenant la configuration des # bridges à créer/mettre à jour. # $4 (mainiface) est le nom de l'interface principale, c'est à dire # l'interface qui est sélectionnée si une adresse ip n'est pas préfixée de # son interface. En principe, l'interface principale est le premier bridge # défini ou la première interface définie. # $5 (reset_interfaces) spécifie de ne pas chercher à mettre à jour le # fichier /etc/network/interfaces, mais de le recréer depuis zéro. # $6 (oldhost) est le nom d'hôte actuel, avant la modification # Si un des arguments n'est pas spécifié, il est ignoré. # Le tableau confips doit contenir des définitions d'une des formes # suivantes: # [[iface][//gateway]:]address[/suffix],... # [iface:]dhcp # La deuxième forme est pour spécifier qu'une interface est configurée par # DHCP. iface vaut par défaut eth0, sauf si une définition de bridge # existe, auquel cas il s'agit du premier bridge défini. Pour chaque # interface, seule la première spécification d'adresse IP tient compte de # l'argument gateway. Les autres spécifications définissent des adresses IP # supplémentaires pour l'interface. # Le tableau brs doit contenir des définitions de la forme suivante: # br:ifaces,... # br est le nom du bridge, e.g. br0. ifaces est une liste d'interfaces # séparées par une virgule. e.g. br0:eth0,eth1 # Bien que ce soit techniquement possible, ce script interdit que l'on # définisse une adresse IP pour une interface faisant partie d'un bridge. local -a __nc_confips __nc_confbrs [ -n "$2" ] && array_copy __nc_confips "$2" [ -n "$3" ] && array_copy __nc_confbrs "$3" local host="$1" local -a confips; array_copy confips __nc_confips local -a confbrs; array_copy confbrs __nc_confbrs local mainiface="$4" reset_interfaces="$5" oldhost="$6" local modified network_fix_confs confbrs confips "$mainiface" local confbr br; local -a ifaces local confip iface gateway mainip suffix; local -a ipsuffixes network_parse_confip "${confips[0]}" iface gateway ipsuffixes network_parse_ipsuffix "${ipsuffixes[0]}" mainip suffix if [ -n "${confips[*]}" -o -n "${confbrs[*]}" ]; then # Vérifier qu'une interface avec une adresse IP ne figure pas dans les # bridges à configurer. en profiter pour classer les interfaces par # type: standard et bridges etitle "Configuration des interfaces réseau" local -a ifaces_with_ips ifaces local -a brifaces ifaces_with_ips=() for confip in "${confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes array_addu ifaces_with_ips "$iface" done for confbr in "${confbrs[@]}"; do network_parse_confbr "$confbr" br ifaces array_add brifaces "$br" for iface in "${ifaces[@]}"; do if array_contains ifaces_with_ips "$iface"; then eerror "$iface: Impossible de configurer une interface dans un bridge ET avec une adresse IP" return 1 fi done done # vérifier si une modification est nécessaire local modify for confbr in "${confbrs[@]}"; do network_parse_confbr "$confbr" br ifaces if ! network_interfaces_check_confbr "$br" iface; then modify=1 break fi done if [ -z "$modify" ]; then for confip in "${confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes if ! network_interfaces_check_confip "$iface" "$gateway" ipsuffixes; then modify=1 break fi done fi # yes! il faut refaire la configuration if [ -n "$modify" ]; then # faire une copie de travail local interfaces; ac_set_tmpfile interfaces cat "$__DEBIAN_NETWORK_INTERFACES" >"$interfaces" if [ -n "$reset_interfaces" ]; then echo >"$interfaces" "\ # This file describes the network interfaces available on your system # and how to activate them. For more information, see interfaces(5). # The loopback network interface auto lo iface lo inet loopback " fi # d'abord supprimer l'ancienne configuration for confbr in "${confbrs[@]}"; do network_parse_confbr "$confbr" br ifaces network_interfaces_remove_confbr "$br" ifaces "$interfaces" done for confip in "${confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes network_interfaces_remove_iface "$iface" "$interfaces" done # puis recréer la configuration for confbr in "${confbrs[@]}"; do network_parse_confbr "$confbr" br ifaces network_interfaces_add_confbr "$br" ifaces confips "$interfaces" done for confip in "${confips[@]}"; do network_parse_confip "$confip" iface gateway ipsuffixes if ! array_contains brifaces "$iface"; then network_interfaces_add_confip "$iface" "$gateway" ipsuffixes "$interfaces" fi done # Fin de traitement if [ -n "$__DEBIAN_NETWORK_DEVEL_SHOW_MODIFS" ]; then if testdiff "$interfaces" "$__DEBIAN_NETWORK_INTERFACES"; then uecho "Setting $__DEBIAN_NETWORK_INTERFACES to:" cat "$interfaces" | sed 's/^/ /g' 1>&2 else uecho "$__DEBIAN_NETWORK_INTERFACES: pas de modifications" fi elif testdiff "$interfaces" "$__DEBIAN_NETWORK_INTERFACES"; then __network_backup "$__DEBIAN_NETWORK_INTERFACES" if show_debug; then edebug "Setting $__DEBIAN_NETWORK_INTERFACES to:" cat "$interfaces" | sed 's/^/ /g' 1>&2 else estep "$__DEBIAN_NETWORK_INTERFACES" fi cat "$interfaces" >"$__DEBIAN_NETWORK_INTERFACES" modified=1 fi ac_clean "$interfaces" fi eend fi # configurer le nom d'hôte if [ -n "$host" ]; then host="$(ipcalc_fqdn_maybe "$host")" etitle "Configuration du nom d'hôte: $host" # si on ne spécifie pas l'adresse ip principale, la résoudre ici. ceci # est nécessaire pour mettre à jour /etc/hosts if [ "$mainip" == dhcp ]; then # si l'adresse obtenue est en DHCP, ne pas mettre à jour /etc/hosts mainip= elif [ -z "$mainip" ]; then local -a mainips resolv_ips mainips "$host" [ -n "${mainips[*]}" ] || { eerror "$host: Impossible de résoudre ce nom d'hôte" return 1 } mainip="${mainips[0]}" fi network_fix_hostname "$host" network_fix_mailname "$host" network_fix_hosts "$host" "$mainip" "$oldhost" eend fi [ -z "$modified" ] && return 10 return 0 }