====== Compilation d'eggdrop avec Tcl 9 ======
<WRAP center round info 60%>
Nota: Ce tutoriel a été écrit par [[https://forum.eggdrop.fr/member.php?action=profile&uid=4232|Te[u]K]], qui le tiendra à jour. Il explique comment compiler et exécuter Eggdrop 1.10.1 avec Tcl 9.0.3, TclTLS 2.0, Tcllib 2.0 et OpenSSL 3.6.1 sur Debian
</WRAP>

===== Introduction =====
Si vous maintenez encore des scripts Tcl historiques autour d'Eggdrop, vous avez sans doute déjà rencontré le même mur: les environnements modernes évoluent, les bibliothèques TLS changent, les versions système de Tcl ne collent plus forcément à ce que vos scripts attendent, et les vieux montages //qui marchaient avant// deviennent fragiles.

L'objectif de ce guide est de proposer une base propre, reproductible et moderne pour faire tourner **Eggdrop 1.10.1** avec **OpenSSL 3.6.1**, **Tcl 9.0.3**, **TclTLS 2.0** et **Tcllib 2.0** sur Debian, en évitant autant que possible les dépendances implicites au système.

L'idée n'est pas seulement de faire démarrer le bot, mais de construire une pile cohérente, explicite, et plus facile à déboguer quand on commence à réinjecter de vieux scripts Tcl, parfois écrits il y a très longtemps, parfois testés dans des environnements très différents.

Ce guide repose sur une procédure réellement validée en labo, avec des pièges concrets rencontrés en route.

==== Pourquoi ne pas utiliser simplement les versions système ? ====
Sur une Debian récente, vous avez déjà :
  * un OpenSSL système,
  * parfois un Tcl système,
  * et de quoi compiler Eggdrop.

Mais dans la pratique, ce n'est pas assez propre si vous voulez :
  * figer exactement les versions,
  * éviter les surprises de linkage,
  * comparer plusieurs environnements,
  * ou reproduire un comportement au plus près d'une pile cible donnée.

Dans ce guide, on choisit donc de tout isoler sous `/opt/eggdrop-lab` avec une séparation claire entre :
  * les **sources**
  * les **bibliothèques privées**
  * le **runtime Eggdrop**
  * l'**instance réelle du bot**
==== Pourquoi c'est important pour les scripts Tcl historiques sous Eggdrop ====
C'est probablement la partie la plus importante du sujet.

Beaucoup de scripts Tcl historiques pour Eggdrop reposent sur des hypothèses implicites :
  * présence de certains packages Tcl dans `auto_path`
  * comportement d'une vieille pile TLS
  * wrappers HTTP artisanaux
  * dépendances à `tcllib`
  * différences de comportement entre Tcl 8.x et Tcl 9
  * environnement Windows/Cygwin/Windrop différent d'un Linux moderne

Quand on remet ces scripts dans un contexte moderne, le vrai problème n'est pas seulement //est-ce qu'Eggdrop démarre ?// mais souvent:
  * est-ce que les bons packages Tcl sont réellement chargés ?
  * est-ce que `tls` utilise bien le bon OpenSSL ?
  * est-ce qu'on dépend involontairement des libs système ?
  * est-ce qu'un vieux script échoue à cause de son code, ou à cause de la pile runtime ?

Avec une pile maîtrisée comme celle-ci, vous réduisez énormément le bruit de fond :
  * moins d'ambiguïtés
  * moins de faux diagnostics
  * plus de chances d'isoler les vrais problèmes de compatibilité dans les scripts

<WRAP center round box 80%>
Autrement dit :  
ce guide n'est pas seulement utile pour //installer Eggdrop//, il est surtout utile pour **travailler proprement sur des scripts Tcl historiques dans un environnement moderne**.
</WRAP>

===== Préparation du système =====
==== Pile logicielle cible ====
Ce guide vise explicitement cette pile :
  * OpenSSL 3.6.1
  * Tcl 9.0.3
  * TclTLS 2.0
  * Tcllib 2.0
  * Eggdrop 1.10.1

==== Arborescence de travail recommandée ====
On utilisera cette base :
<code bash>/opt/eggdrop-lab/
/opt/eggdrop-lab/src
/opt/eggdrop-lab/openssl361
/opt/eggdrop-lab/tcl903
/opt/eggdrop-lab/eggdrop1101
# Instance d'eggdrop
/home/eggbot/EggdropBot
</code>
==== Variables système ====
Dans ce guide, on utilise des variables shell pour éviter les chemins codés en dur.
<code bash>
BOT_USER="eggbot"
BOT_HOME="/home/$BOT_USER"
BOT_INSTANCE="EggdropBot"

OPENSSL_HOME="/opt/eggdrop-lab/openssl361"
TCL_HOME="/opt/eggdrop-lab/tcl903"
SRC_HOME="/opt/eggdrop-lab/src"
</code>

<WRAP center round important 80%>
**Remarque importante sur `BOT_USER`**

Choisissez ce nom avec soin. Ce n'est pas juste un détail cosmétique. Selon votre environnement, il peut avoir un impact sur la lisibilité des chemins, les ownerships, les logs, les noms de services, et parfois, indirectement, ce qui apparaît côté **identd / ident**

Évitez donc un nom improvisé ou trop personnel si vous comptez publier votre procédure ou réutiliser la structure ailleurs.
</WRAP>
==== Dépendances de build ====
<code bash>sudo apt update
sudo apt install -y build-essential pkg-config autoconf automake libtool make \
  gcc g++ libc6-dev zlib1g-dev libbz2-dev wget curl \
  ca-certificates git unzip xz-utils
</code>

On n'installe volontairement **aucun Tcl système** via Debian.
==== Création de l'arborescence ====
<code bash>mkdir -p /opt/eggdrop-lab/src
mkdir -p /opt/eggdrop-lab/openssl361
mkdir -p /opt/eggdrop-lab/tcl903
mkdir -p /opt/eggdrop-lab/eggdrop1101</code>

==== Téléchargement des sources ====
<code bash>cd /opt/eggdrop-lab/src
wget -O openssl-3.6.1.tar.gz "https://github.com/openssl/openssl/releases/download/openssl-3.6.1/openssl-3.6.1.tar.gz"
wget -O tcl9.0.3-src.tar.gz "https://prdownloads.sourceforge.net/tcl/tcl9.0.3-src.tar.gz"
wget -O tcltls-2.0-src.tar.gz "https://core.tcl-lang.org/tcltls/uv/tcltls-2.0-src.tar.gz"
wget -O eggdrop-1.10.1.tar.gz "https://ftp.eggheads.org/pub/eggdrop/source/1.10/eggdrop-1.10.1.tar.gz"
wget -O tcllib-2.0.tar.gz "https://core.tcl-lang.org/tcllib/tarball/tcllib-2.0.tar.gz?r=tcllib-2-0"</code>
==== Création de l'utilisateur runtime ====
<code bash>sudo useradd -m -d "$BOT_HOME" -s /bin/bash "$BOT_USER"
sudo passwd "$BOT_USER"
sudo chown -R "$BOT_USER:$BOT_USER" /opt/eggdrop-lab</code>

===== Compilation du système =====
==== OpenSSL 3.6.1 ====
<code bash>cd "$SRC_HOME"
tar xzf openssl-3.6.1.tar.gz
cd openssl-3.6.1
./Configure --prefix="$OPENSSL_HOME" --openssldir="$OPENSSL_HOME/ssl" shared zlib \
  linux-x86_64 "-Wl,-rpath,$OPENSSL_HOME/lib64" "-Wl,-rpath,$OPENSSL_HOME/lib"
make -j"$(nproc)"
make install_sw</code>
=== Vérification ===
<code bash>LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib" "$OPENSSL_HOME/bin/openssl" version -a</code>


==== Tcl 9.0.3 ====
<code bash>cd "$SRC_HOME"
tar xzf tcl9.0.3-src.tar.gz
cd tcl9.0.3/unix
./configure --prefix="$TCL_HOME"
make -j"$(nproc)"
make install
ln -sf "$TCL_HOME/bin/tclsh9.0" "$TCL_HOME/bin/tclsh"</code>
=== Vérification ===
<code bash>"$TCL_HOME/bin/tclsh9.0" <<< 'puts [info patchlevel]'</code>

==== TclTLS 2.0 ====
Pour éviter toute ambiguïté sur le nom du répertoire extrait, on utilise une méthode déterministe :
<code bash>cd "$SRC_HOME"
TLS_TARBALL="tcltls-2.0-src.tar.gz"
TLS_SRCDIR="$(tar tzf "$TLS_TARBALL" | head -1 | cut -d/ -f1)"
tar xzf "$TLS_TARBALL"
cd "$TLS_SRCDIR"
make distclean 2>/dev/null || true
export PKG_CONFIG_PATH="$OPENSSL_HOME/lib64/pkgconfig:$OPENSSL_HOME/lib/pkgconfig"
export LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib:$TCL_HOME/lib"
./configure --prefix="$TCL_HOME" --with-tcl="$TCL_HOME/lib" --with-tclinclude="$TCL_HOME/include" \
  CPPFLAGS="-I$OPENSSL_HOME/include -I$TCL_HOME/include" \
  LDFLAGS="-L$OPENSSL_HOME/lib64 -L$OPENSSL_HOME/lib -L$TCL_HOME/lib -Wl,-rpath,$OPENSSL_HOME/lib64 -Wl,-rpath,$OPENSSL_HOME/lib -Wl,-rpath,$TCL_HOME/lib"
make -j"$(nproc)"
make install</code>
=== Vérification ===
<code bash>export TCLLIBPATH="$TCL_HOME/lib"
export LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib:$TCL_HOME/lib"
"$TCL_HOME/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "tls=[package require tls]"
EOF</code>
==== Tcllib 2.0 ====
<WRAP center round important 80%>
Pour éviter une erreur liée à **Critcl** et à la partie optionnelle **TcllibC**, on utilise `make install-tcl` et non `make install`.
</WRAP>
<code bash>cd "$SRC_HOME"
TCLLIB_TARBALL="tcllib-2.0.tar.gz"
TCLLIB_SRCDIR="$(tar tzf "$TCLLIB_TARBALL" | head -1 | cut -d/ -f1)"
tar xzf "$TCLLIB_TARBALL"
cd "$TCLLIB_SRCDIR"
./configure --prefix="$TCL_HOME"
make -j"$(nproc)"
make install-tcl</code>
=== Vérification ===
<code bash>
export TCLLIBPATH="$TCL_HOME/lib $TCL_HOME/lib/tcllib2.0"
export LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib:$TCL_HOME/lib"
"$TCL_HOME/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "tls=[package require tls]"
puts "TCLLIBPATH=$::env(TCLLIBPATH)"
puts "auto_path=$auto_path"
foreach p {md5 sha1 struct::list uri base64 json} {
    if {[catch {package require $p} v]} {
        puts "$p => ERR: $v"
    } else {
        puts "$p => OK: $v"
    }
}
EOF</code>

===== Compiler Eggdrop 1.10.1 =====
Passer sous l'utilisateur runtime: `su - "$BOT_USER"`

Puis redéfinir les variables :
<code bash>
BOT_USER="eggbot"
BOT_HOME="/home/$BOT_USER"
BOT_INSTANCE="EggdropBot"
OPENSSL_HOME="/opt/eggdrop-lab/openssl361"
TCL_HOME="/opt/eggdrop-lab/tcl903"
SRC_HOME="/opt/eggdrop-lab/src"</code>
<WRAP center round tip 80%>
Si vous aviez déjà tenté un installation, pensez à nettoyer tout ce qui pourrait rester comme traces avec `rm -rf "$BOT_HOME/$BOT_INSTANCE/*"`
</WRAP>
==== Extraction d'Eggdrop ====
<code bash>cd "$SRC_HOME"
EGGDROP_TARBALL="eggdrop-1.10.1.tar.gz"
EGGDROP_SRCDIR="$(tar tzf "$EGGDROP_TARBALL" | head -1 | cut -d/ -f1)"
rm -rf "$EGGDROP_SRCDIR"
tar xzf "$EGGDROP_TARBALL"
cd "$EGGDROP_SRCDIR"
make distclean 2>/dev/null || true</code>
==== Exportation de l'environnement de build ====
<code bash>export CPPFLAGS="-I$TCL_HOME/include -I$OPENSSL_HOME/include"
export LDFLAGS="-L$TCL_HOME/lib -L$OPENSSL_HOME/lib64 -L$OPENSSL_HOME/lib -Wl,-rpath,$TCL_HOME/lib -Wl,-rpath,$OPENSSL_HOME/lib64 -Wl,-rpath,$OPENSSL_HOME/lib"
export LIBS="-lssl -lcrypto -lz -lpthread -lm -lresolv"
export LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib:$TCL_HOME/lib"
export PKG_CONFIG_PATH="$OPENSSL_HOME/lib64/pkgconfig:$OPENSSL_HOME/lib/pkgconfig"</code>
==== Installation d'Eggdrop ====
<code bash>./configure \
  --prefix=/opt/eggdrop-lab/eggdrop1101 \
  --with-tcllib="$TCL_HOME/lib" \
  --with-tclinc="$TCL_HOME/include"
make config
make -j"$(nproc)"
make install DEST="$BOT_HOME/$BOT_INSTANCE"</code>
=== Vérification ===
<code bash>find "$BOT_HOME/$BOT_INSTANCE" -maxdepth 2 -type f -name 'eggdrop*' -ls
file "$BOT_HOME/$BOT_INSTANCE/eggdrop-1.10.1"
ldd "$BOT_HOME/$BOT_INSTANCE/eggdrop-1.10.1"</code>
Le fichier `eggdrop-1.10.1` doit être un vrai **binaire ELF**, pas un script.
Les dépendances doivent pointer vers :
  * `"$TCL_HOME/lib/libtcl9.0.so"`
  * `"$OPENSSL_HOME/lib64/libssl.so.3"`
  * `"$OPENSSL_HOME/lib64/libcrypto.so.3"`
=== Vérification des modules ===
<code bash>ldd "$BOT_HOME/$BOT_INSTANCE/modules-1.10.1/assoc.so"
ldd "$BOT_HOME/$BOT_INSTANCE/modules-1.10.1/blowfish.so"
ldd "$BOT_HOME/$BOT_INSTANCE/modules-1.10.1/server.so"</code>
<WRAP center round tip 80%>
L'installation staging peut créée un lien symbolique `eggdrop -> eggdrop-1.10.1`, il est à supprimer avec `rm -f "$BOT_HOME/$BOT_INSTANCE/eggdrop"`, car nous allons créer un lanceur //runtime// nommé **eggdrop**.
</WRAP>
==== Création du lanceur ====
Dans cet exemple, on garde volontairement un style shell simple avec `"$EGGROOT/eggdrop-1.10.1" $*`, pour rester proche d'un usage classique.
<code bash>cat > "$BOT_HOME/$BOT_INSTANCE/eggdrop" <<EOF
#!/bin/bash
set -e
export EGGROOT="$BOT_HOME/$BOT_INSTANCE"
export OPENSSL_HOME="$OPENSSL_HOME"
export TCL_HOME="$TCL_HOME"
export PATH="\$OPENSSL_HOME/bin:\$TCL_HOME/bin:/usr/bin:/bin"
export TCLLIBPATH="\$TCL_HOME/lib \$TCL_HOME/lib/tcllib2.0"
export LD_LIBRARY_PATH="\$OPENSSL_HOME/lib64:\$OPENSSL_HOME/lib:\$TCL_HOME/lib:\${LD_LIBRARY_PATH:-}"
cd "\$EGGROOT"
"\$EGGROOT/eggdrop-1.10.1" \$*
EOF
chmod +x "$BOT_HOME/$BOT_INSTANCE/eggdrop"</code>
=== Vérification ===
<code bash>cat "$BOT_HOME/$BOT_INSTANCE/eggdrop"
ls -l "$BOT_HOME/$BOT_INSTANCE/eggdrop"</code>
===== Tests et lancement =====
==== Test des composants ====
Tout d'abord, on teste Tcl et ses package directement:
<code bash>export PATH="$OPENSSL_HOME/bin:$TCL_HOME/bin:/usr/bin:/bin"
export TCLLIBPATH="$TCL_HOME/lib $TCL_HOME/lib/tcllib2.0"
export LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib:$TCL_HOME/lib:${LD_LIBRARY_PATH:-}"
"$TCL_HOME/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "tls=[package require tls]"
puts "TCLLIBPATH=$::env(TCLLIBPATH)"
puts "auto_path=$auto_path"
foreach p {md5 sha1 struct::list uri base64 json} {
    if {[catch {package require $p} v]} {
        puts "$p => ERR: $v"
    } else {
        puts "$p => OK: $v"
    }
}
EOF</code>
==== Test d'Eggdrop ====
Nous testons le lanceur
<code bash>"$BOT_HOME/$BOT_INSTANCE/eggdrop" -v</code>
===== Finalisation d'eggdrop =====
N'utilisez pas `eggdrop.conf`, mais faites en une copie de travail, idéalement nommée comme votre eggdrop: 
<code bash>cp "$BOT_HOME/$BOT_INSTANCE/eggdrop.conf" "$BOT_HOME/$BOT_INSTANCE/${BOT_INSTANCE}.conf"</code>
Vous pouvez ensuite [[:eggdrop:configuration|configurer votre eggdrop]] (`$BOT_HOME/$BOT_INSTANCE/${BOT_INSTANCE}.conf`).
<WRAP center round tip 80%>
N'oubliez pas que le démarrage s'effectue avec le [[#creation_du_lanceur|lanceur]]:
  * `"$BOT_HOME/$BOT_INSTANCE/eggdrop" -m "${BOT_INSTANCE}.conf"` pour le premier démarrage,
  * `"$BOT_HOME/$BOT_INSTANCE/eggdrop" -n "${BOT_INSTANCE}.conf"` pour le fonctionnement //en premier plan//
</WRAP>
===== Astuces à retenir =====
  * Utiliser `tar xzf` pour les archives `.tar.gz`
  * Ne pas utiliser de wildcard ambigu comme `cd tcltls-*`
  * Pour Tcllib, utiliser `make install-tcl` afin d'éviter une erreur optionnelle liée à Critcl/TcllibC
  * Supprimer toute ancienne instance staging avant réinstallation
  * Supprimer le lien symbolique `eggdrop -> eggdrop-1.10.1` avant de créer votre propre lanceur `eggdrop`
  * Tester Tcl/TclTLS/Tcllib directement avec `tclsh`, pas via le lanceur Eggdrop
  * Choisir soigneusement `BOT_USER`, surtout si identd peut entrer en jeu
===== Conclusion =====
Avec cette approche, vous obtenez une pile Eggdrop moderne, propre et maîtrisée : OpenSSL, Tcl, TclTLS et Tcllib maitrisés, Eggdrop compilé proprement avec les bonnes liaisons, runtime isolé, moins d'ambiguïtés pour le diagnostic de vieux scripts Tcl

Et c'est précisément ce qui rend cette méthode intéressante si vous voulez remettre en route ou moderniser des scripts Tcl historiques sous Eggdrop, sans vous battre en permanence contre les bibliothèques système ou un environnement runtime flou.
==== Notes finales ====
Cette procédure a été élaborée à partir d'un vrai travail de validation sur Debian, avec des ajustements concrets à partir des problèmes rencontrés en route.

Elle constitue une bonne base pour :
  * un labo propre
  * une migration progressive
  * la préparation d'un article plus large autour de Tcl 9, Eggdrop 1.10.1 et de la compatibilité des scripts historiques
===== Voir aussi =====
[[:eggdrop:installation]]