#!/bin/bash

### Variables globales ###
 #Couleurs et style du texte :
 rouge=`tput setaf 1`
 vert=`tput setaf 2`
 jaune=`tput setaf 3`
 bleuf=`tput setaf 4`
 violet=`tput setaf 5`
 bleu=`tput setaf 6`
 #blanc=`tput setaf 7`
 #frouge=`tput setab 1` #couleur de fond
 #und=`tput sgr 0 1` #souligné
 #unund=`tput rmul` #pas souligné
 #itl=`tput sitm` #italic
 #unitl=`tput ritm` #plus d'italic
 bld=`tput bold`
 reset=`tput sgr0` #style normal

 #Saut à la ligne sur une chaine :
 st=`echo -e $'\n.'`
 st=${st%.}


### Fonction pour afficher un message de confirmation ###
function confirm () {
 #Affiche une confimation avec textes par défaut :
 msgOn="Confirmation"
 msgOK="OK"
 msgOff="Annulé"
 read -n 1 -rep "${1:-${msgOn}} [y] ? " response
 case $response in [yY])
   echo "${2:-${msgOK}}"; true;;
   *)
   echo "${bld}${rouge}${3:-${msgOff}}${reset}"; false;;
 esac
}
#debug :
#confirm && echo "OK"; return;


### Fonction pour la vérification du format de l'IP ###
function isIP() {
 local vip=$1
 local validIP=1
 if [[ $vip =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
   OIFS=$IFS
   IFS='.'
   vip=($vip)
   IFS=$OIFS
   [[ ${vip[0]} -le 255 && ${vip[1]} -le 255 \
   && ${vip[2]} -le 255 && ${vip[3]} -le 255 ]]
   validIP=$?
 fi
 return $validIP
}


### Fonction pour remplacer un mot dans un fichier ###
function replace {
 if [ ! "$1" ] && [ ! "$2" ] && [ ! "$3" ]; then
  echo "Erreur : [replace fichier_source chaine_a_remplacer nouvelle_chaine]"
  return 1
 fi
 #Si le fichier existe :
 if [ -f "$1" ]; then
  #On verifie si le mot à remplacer existe :
  grep "$2" -q "$1" && vin=true || vin=false
  #On remplace le mot dans le fichier si il est présent (sed) :
  sudo sh -c "sed -i -e 's/$2/$3/g' $1"
  #On verifie si le mot remplacé existe :
  grep "$3" -q "$1" && vout=true || vout=false
  #On assigne la variable de vérification :
  if [ $vin == true ] && [ $vout == true ]; then return 0; else return 1; fi
 else
  echo "Erreur : $1 n'existe pas !"; return 1
 fi
}
#debug :
#if replace ".defoIP" "1" "0"; then echo "succes"; else echo "failed"; fi;


### Fonction de verification des arguments ###
function errorarg {
 #Si la varible ip contient un mot ($1) ET que ce mot ne contient pas "--" alors erreur :
 if [[ $ip == *"$1"* ]] && [ $ip != "--$1" ]; then
  echo "Voulez-vous dire : [${bld}${bleu}--$1${reset}] ?"
 return 1; fi
}


### Fonction principale pour modifier l'IP fixe ###
function newip {

### PAR DEFAUT : Installation du nom de la carte Ethernet par défaut (eth0) ###
carte0="$(/sbin/ifconfig | awk 'NR==1{print $1}')"
if [ $carte0 == "enp0s3" ]; then
 echo "${bld}${rouge}=== ATTENTION ===${reset}"
 echo "Ce script a besoin de modifier la nom de la carte Ethernet installée par défaut [${bld}${jaune}enp0s3${reset}]"
 echo "Le nouveau nom sera : [${bld}${jaune}eth0${reset}]"
 echo "Voulez-vous continer ? [y]"
 read ok
 if [ $ok == "y" ]; then
  #Mise à jour du fichier inferfaces :
  if ! replace "/etc/network/interfaces" "enp0s3" "eth0"; then
   echo "${bld}${rouge}Erreur :${reset} mise à jour impossible."
  return; fi
  cname="eth0"
  MAC_ADDR=$(ifconfig enp0s3 | awk '$1 == "enp0s3" { gsub("HWaddr ", "", $0); print $4 }')
  out="SUBSYSTEM=='\"net\"', ACTION=='\"add\"', DRIVERS=='\"?*\"', ATTR{address}=='\"'$MAC_ADDR'\"', ATTR{dev_id}=='\"0x0\"', ATTR{type}=='\"1\"', NAME='\"'$cname'\"'"
  sudo sh -c "echo $out > /etc/udev/rules.d/70-persistent-net.rules"
  confirm "Mise à jour effectuée.${st}Voulez-vous relancer le système" && sudo reboot
 else
  echo "${bld}${rouge}Annulé${reset}"
 fi
return; fi

# Si on ne trouve pas le premier argument, alors affiche un pseudo "man" :
if [ ! "$1" ]; then
 echo "${bld}${rouge}[newip]${reset} : Syntaxe -> [${bld}${bleu}newip ${bleuf}IP${reset}]"
 echo "Options :${st}-> Affiche l'IP courante : [${bld}${bleu}newip ${violet}--myip${reset}]"
 echo "-> Ajoute l'IP enregistrée par défaut : [${bld}${bleu}newip ${violet}--auto${reset}]"
 echo "-> Enregistre l'IP par défaut : [${bld}${bleu}newip ${bleuf}IP ${violet}--setup${reset}]"
 echo "-> Enregistre l'IP courante par défaut : [${bld}${bleu}newip ${violet}--myip ${violet}--setup${reset}]"
 echo "-> Ouvre le fichier 'interfaces' à configurer : [${bld}${bleu}newip ${violet}--configure${reset}]"
 echo "-> Sauvegarde le fichier 'interfaces' courant : [${bld}${bleu}newip ${violet}--backup${reset}]"
 echo "-> Restaure le fichier 'interfaces' sauvegardé : [${bld}${bleu}newip ${violet}--rollback${reset}]"
 echo "-> Restaure le fichier 'interfaces' d'origine : [${bld}${bleu}newip ${violet}--reset${reset}]"
 echo "-> IP FIXE : install un fichier 'interfaces' à configurer : [${bld}${bleu}newip ${violet}--ipfixe${reset}]"
else

 ### Variables pour la fonction ###

 #Argument retourné, soit l'IP :
 ip="$1"
 #Emplacement du fichier 'interfaces' pour configurer les IP :
 FileInterfaces="/etc/network/interfaces"
 #L'IP fixe enregistrée dans le fichier interfaces :
 confip=$(cat $FileInterfaces | awk '$1 == "address" {print $2}')
 #L'IP courante sur la carte eth0 :
 curip=$(/sbin/ifconfig eth0 | awk '$1 == "inet" { gsub("adr:", "", $0); print $2 }')
 #Ou autre script optimisé (à utiliser avec prudence) :
 #curip=$(hostname -I | awk '{print $1}')
 #Fichier de sauvegarde de la configuration originale :
 rfile=".interfacesOriginal"

 ### Vérification des arguments et du format des IP ###

 #Si l'arument n°1 n'est pas conforme :
 if ! isIP $ip; then
  #Par la fonction "errorarg" (on a oublié les "--") :
  errorarg "myip"; errorarg "auto"; errorarg "setup"
  errorarg "configure"; errorarg "backup"
  errorarg "rollback"; errorarg "reset"; errorarg "ipfixe"
 fi

 #Si l'argument n°2 n'est pas vide et qu'il n'est pas égale à --setup :
 if [ -n "$2" ] && [ "$2" != "--setup" ]; then
  #Ici on va retourner l'ensemble des arguments inconnus
  #var de retour :
  aerr=""
  #liste des arguments :
  args=("$@")
  #nombre des arguments
  elements=${#args[@]}
   #boucle sur chacun des args à partir du 2éme :
   for (( i=1;i<$elements;i++)); do
    #la var aerr s'ajoute sur chacum des args incorrecte :
    aerr=${args[${i}]}" "$aerr
   #fin de la boucle :
   done
  #on retourne la var en retirant le dernier carractère soit ${var::-1} :
  echo "[${bld}${rouge}${aerr::-1}${reset}] : commande inconnue !"
 return; fi

 #Option pour remplacer le fichier 'interfaces' avec les parrametres d'IP fixe :
 if [ $ip == "--ipfixe" ]; then
 #On décode une chaine en base64 (chaine=une config ip fixe encodée) et on remplace le fichier interfaces :
 sudo sh -c "echo -n IyMjIGludGVyZmFjZXMoNSkgZmlsZSB1c2VkIGJ5IGlmdXAoOCkgYW5kIGlmZG93big4KQphdXRvIGxvCmlmYWNlIGxvIGluZXQgbG9vcGJhY2sKCiMjIyBUaGUgcHJpbWFyeSBuZXR3b3JrIGludGVyZmFjZQphdXRvIGV0aDAKaWZhY2UgZXRoMCBpbmV0IHN0YXRpYwoKIyMjIERlcHVpcyBVQlVOVFUgc3VyIGxlIHRlcm1pbmFsIHRhcGVyID09PiBpZmNvbmZpZwojIEFqb3V0ZXIgaWNpIGwnSVAgOiAiIGluZXQgYWRyICIgOgogIGFkZHJlc3MgMTkyLjE2OC4wLjE2CgojIyMgRGVwdWlzIFdJTkRPV1MgdGFwZXIgY21kID09PiBpcGNvbmZpZyAvYWxsCiMgQWpvdXRlciBpY2kgbCdJUCA6ICIgbWFzcXVlIGRlIHNvdXMtcsOpc2VhdSAiIDoKICBuZXRtYXNrIDI1NS4yNTUuMjU1LjAKIyBBam91dGVyIGljaSBsJ0lQIDogIiBzZXJ2ZXVyIERIQ1AgIiA6CiAgbmV0d29yayAxOTIuMTY4LjAuMjU0CiMgQWpvdXRlciBpY2kgbCdJUCA6ICIgcGFzc2VyZWxsZSBwYXIgZMOpZmF1dCAiIDoKICBnYXRld2F5IDE5Mi4xNjguMC4yNTQKIyBBam91dGVyIGljaSBsJ0lQIDogIiBzZXJ2ZXVycyBETlMgIi4gQXR0ZW50aW9uIGF1eCBlc3BhY2VzIGVudHJlIGNoYXF1ZSBJUCA6CiAgZG5zLW5hbWVzZXJ2ZXJzIDIxMi4yNy40MC4yNDAgIDIxMi4yNy40MC4yNDEJCg== | base64 -d > $FileInterfaces"
 echo "Le fichier : ${bld}${jaune}$FileInterfaces${reset} à été installé pour une IP fixe."
 echo "Vous devez configurer ce fichier depuis la commande : [${bld}${bleu}newip ${violet}--configure${reset}]"
 echo "Pour info, adresse IP courante : ${bld}${vert}$curip${reset}"
 return; fi

 #Si le fichier insterface d'origine existe :
 if [ -f $rfile ]; then
  #On restaure le fichier si on choisi l'option :
  if [ $ip == "--reset" ]; then
   sudo cp $rfile $FileInterfaces
   echo "Le fichier : ${bld}${jaune}$FileInterfaces${reset} à été restauré."
  return; fi
 else
 #On sauvegarde par défaut le fichier interface au 1er lancement :
  sudo cp $FileInterfaces $rfile
 fi

 #Si on oublie le premier argument avant --setup :
 if [ $ip == "--setup" ]; then
 echo "[${bld}${rouge}--setup${reset}] : syntaxe -> [${bld}${bleu}newip ${violet}--myip ${violet}--setup${reset}]"
 return; fi

 #Pour l'argument : "--setup".
 #Si le fichier ".defoIP" existe :
 if [ -f .defoIP ]; then
  #alors on lit son contenu assigné à la variable "defoIP" :
  defoIP=$(cat .defoIP)
 else
  #sinon si le deuxième argument "$2" existe :
   if [ "$2" == "--setup" ]; then
    #on crée le fichier, on lui donne les permissions d'ecriture et de lecture :
    touch .defoIP; sudo sh -c "chmod 777 .defoIP"
    #On ajoute dans ce fichier l'IP assignée :
    echo -n $ip>.defoIP
    #la variable "defoIP" est assignée par l'IP :
    defoIP=$ip
   fi
 fi
 #debug:
 #cat .defoIP; return;

 #Argument "--myip" pour afficher l'IP courante
 #Si nous n'avons aucun deuxième argument :
 if [ ! "$2" ]; then
  #Si le permier argument ($ip) est égale à "--myip"
  if [ $ip == "--myip" ]; then
   #Si la variable $curip n'est pas vide :
   if [ $curip ]; then
    #On affiche l'adresse IP courante :
    echo "Adresse IP : ${bld}${vert}$curip${reset}"
    #Sinon erreur, pas d'IP :
   else
    echo "IP inconnue!"
   fi
  return; fi
 fi

 #Si l'argement "$1" est égale à "--auto", alors l'IP devient celle definit par la variable "defoIP" :
 if [ $ip == "--auto" ]; then ip=$defoIP; fi

 #Si l'argement "$1" est égale à "--configure", alors on ouvre le fichier de configuration et on quitte :
 if [ $ip == "--configure" ]; then sudo nano $FileInterfaces; return; fi

 #Si le premier argument est égale à "--backup" :
 if [ $ip == "--backup" ]; then
  #Alors on copie la config courante :
  sudo cp $FileInterfaces ".IPinterfaces"
  echo "Le fichier de configuration : [${bld}${bleu}interfaces${reset}] a été sauvegardé."
 return; fi;

 #Si le permier argument est égale à "--rollback" :
 if [ $ip == "--rollback" ]; then
  #si le fichier ".IPinterfaces" existe :
  if [ -f ".IPinterfaces" ]; then
   #Garde en mémoire le message de confirmation valide sur la fonction "confirm" :
   msgOK="Le fichier de configuration : [${bld}${bleu}interfaces${reset}] a été restauré."
   #Et on copie la config d'origine avec confirmation :
   confirm "Restaurer le fichier [${bld}${bleu}interfaces${reset}] d'origine" "$msgOK" && sudo cp ".IPinterfaces" $FileInterfaces
   #Sinon message d'erreur :
  else
   echo "Utilisez d'abord [${bld}${bleu}newip ${violet}--backup${reset}] pour sauvegarder la configuration."
  fi
 return; fi

 #Si le deuxième argument est égale à "--setup" :
 if [ "$2" == "--setup" ]; then
  #si le premier argument ($ip) est égale à "--myip" :
  if [ $ip == "--myip" ]; then
   #si l'IP courante est valide :
   if isIP $curip; then
    #alors la variable "ip" devient l'IP courante :
    ip=$curip
   fi
  fi
  #Vérification de l'IP :
  if ! isIP $ip; then
   echo "${bld}${rouge}Erreur de configuration${reset}"
   echo "Taper : [${bld}${vert}newip${reset}] pour plus d'information. "
  return; fi;
  #On écrit le fichier ".defoIP" avec la variabe $ip :
  echo -n $ip>.defoIP
  echo "L'IP par défaut : ${bld}${jaune}$ip${reset} a été mise à jour !"
  #on quitte :
 return; fi

 #Si l'ip fixe enregistrée est valide (ou présente), alors la variable curip devient confip :
 if isIP $confip; then curip=$confip; fi
 #debug :
 #echo $curip; return;

 #Si l'IP tapé est la même enregitrée, alors on stop le srcipt :
 if [ $curip == $ip ]; then echo "L'IP : ${bld}${jaune}$ip${reset} existe déjà ! "; return; fi

 #Si l'argument "--auto" n'est pas présent :
 if [ ! $ip  == "--auto" ]; then
  #Si l'IP tapé n'est pas une ip, alors on efface la variable "ip" et on sort du script :
  if ! isIP $ip; then echo "${bld}${rouge}$ip${reset} : IP invalide !"; ip=""; return; fi
 else
  #Si le fichier ".defoIP" n'existe pas :
  if [ ! -f .defoIP ]; then
   echo "L'IP par défaut n'a pas été trouvée !"
   echo "Utilisez l'option : [${bld}${bleu}newip ${bleuf}IP ${rouge}--setup${reset}]"
  fi
 return; fi

 #Si l'IP locale est non existante, alors on ouvre le fichier "interfaces" et on sort du script :
 if ! isIP $curip; then
  confirm "Erreur de configuration sur l'IP locale !${st}Editer maintenant les IP" && sudo nano $FileInterfaces
 return; fi

 #####################################

 #Affiche la confirmation :
 read -p "Changer l'ip fixe : ${bld}${jaune}$curip${reset} pour : ${bld}${bleu}$ip${reset} [y] ? " -n 1 -r
 #si on a tapé y ou Y
 if [[ $REPLY =~ ^[Yy]$ ]]
 then
     #saut à la ligne :
     echo
     #Backup automatique du fichier interfaces :
     if [ ! -f .IPinterfaces ]; then sudo cp $FileInterfaces ".IPinterfaces"; fi
     #Appel la fonction "replace" pour remplacer une chaine dans un fichier.
     #ici $curip est remplacée par $ip et retourne une erreur si l'IP n'a pas été remplacée :
     if ! replace $FileInterfaces "$curip" "$ip"; then echo "${bld}${rouge}Attention :${reset} l'IP n'a pas été mise à jour."; return; fi
     #on affiche le message de confirmation :
     echo "Nouvelle IP fixe : ${bld}${vert}$ip${reset}"
     #on lance une nouvelle confimation pour redémarrer :
     confirm "Redémarrer maintenant" && sudo reboot
 else
     #si on appuie pas sur ENTER, alors on saute une ligne :
     if [[ ! -z $REPLY ]]; then echo; fi
     #on vide la variable "ip" :
     ip=""
     #message si l'on a tapé sur une autre touche (annule le script) :
     echo "${bld}${jaune}$curip${reset} n'a pas été modifiée."
 fi

fi
}
### Fin de la fonction principale newip ###


### Méthode pour exporter la fonction "newip" ###
### On peut alors executer la fonction "newip" depuis le terminal ###
export -f newip