Eggdrop & Tcl

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Compilation d'eggdrop avec Tcl 9 ======
<WRAP center round info 80%>
Nota: Ce tutoriel a été écrit par 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 :

```bash
/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 ?â€.  
Le vrai problÃ¨me est 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

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**.

---

## 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 :

```bash
/opt/eggdrop-lab/
â”œâ”€â”€ src
â”œâ”€â”€ openssl361
â”œâ”€â”€ tcl903
â””â”€â”€ eggdrop1101
```

Et pour lâ€™instance du bot :

```bash
/home/eggbot/EggdropBot
```

Dans ce guide, on utilise des variables shell pour Ã©viter les chemins codÃ©s en dur.

---

## Variables utilisÃ©es dans ce guide

```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"
```

### 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.

---

## DÃ©pendances de build

En root :

```bash
apt update
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
```

On nâ€™installe volontairement **aucun Tcl systÃ¨me** via Debian.

---

## CrÃ©ation de lâ€™arborescence

```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
```

---

## TÃ©lÃ©chargement des sources

```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"
```

---

## Compiler OpenSSL 3.6.1

```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
```

### VÃ©rification

```bash
LD_LIBRARY_PATH="$OPENSSL_HOME/lib64:$OPENSSL_HOME/lib" \
"$OPENSSL_HOME/bin/openssl" version -a
```

---

## Compiler Tcl 9.0.3

```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"
```

### VÃ©rification

```bash
"$TCL_HOME/bin/tclsh9.0" <<< 'puts [info patchlevel]'
```

---

## Compiler TclTLS 2.0

Pour Ã©viter toute ambiguÃ¯tÃ© sur le nom du rÃ©pertoire extrait, on utilise une mÃ©thode dÃ©terministe :

```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
```

### VÃ©rification

```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
```

---

## Compiler Tcllib 2.0

Ici, il y a un point important.

Pour Ã©viter une erreur liÃ©e Ã  **Critcl** et Ã  la partie optionnelle **TcllibC**, on utilise :

```bash
make install-tcl
```

et non `make install`.

```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
```

### VÃ©rification

```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
```

---

## CrÃ©er lâ€™utilisateur runtime

En root :

```bash
useradd -m -d "$BOT_HOME" -s /bin/bash "$BOT_USER"
passwd "$BOT_USER"
chown -R "$BOT_USER:$BOT_USER" /opt/eggdrop-lab
```

---

## Compiler Eggdrop 1.10.1 sous lâ€™utilisateur non privilÃ©giÃ©

Passer sous lâ€™utilisateur :

```bash
su - "$BOT_USER"
```

Puis reposer les variables :

```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"
```

### Nettoyer toute ancienne instance staging

Câ€™est important, notamment pour Ã©viter les vieux liens symboliques oubliÃ©s.

```bash
rm -rf "$BOT_HOME/$BOT_INSTANCE"
mkdir -p "$BOT_HOME/$BOT_INSTANCE"
```

### RÃ©extraire Eggdrop proprement

```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
```

### Exporter lâ€™environnement de build

```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"
```

### Configurer, compiler et installer

```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"
```

---

## VÃ©rifier le binaire installÃ©

```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"
```

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Ã©rifier aussi les modules

```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"
```

---

## Supprimer le lien symbolique `eggdrop` avant de crÃ©er le lanceur

Câ€™est un piÃ¨ge rÃ©el.

Lâ€™installation staging peut crÃ©er ceci :

```bash
eggdrop -> eggdrop-1.10.1
```

Si vous voulez ensuite crÃ©er un **script lanceur nommÃ© `eggdrop`**, il faut **supprimer ce lien symbolique avant**, sinon vous partez vers un comportement ambigu ou rÃ©cursif.

### VÃ©rification

```bash
ls -l "$BOT_HOME/$BOT_INSTANCE/eggdrop"
```

### Suppression du symlink

```bash
rm -f "$BOT_HOME/$BOT_INSTANCE/eggdrop"
```

---

## CrÃ©er le lanceur runtime `eggdrop`

Dans cet exemple, on garde volontairement un style shell simple avec `"$EGGROOT/eggdrop-1.10.1" $*`, pour rester proche dâ€™un usage classique.

```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"
```

### VÃ©rification

```bash
cat "$BOT_HOME/$BOT_INSTANCE/eggdrop"
ls -l "$BOT_HOME/$BOT_INSTANCE/eggdrop"
```

---

## Tester Tcl, TclTLS et Tcllib

Ici, on teste **Tcl directement**, pas via le lanceur Eggdrop.

```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
```

---

## Tester Eggdrop

Cette fois, on utilise bien le lanceur :

```bash
"$BOT_HOME/$BOT_INSTANCE/eggdrop" -v
```

---

## PrÃ©parer une vraie configuration dâ€™instance

Ne lancez pas `eggdrop.conf` tel quel comme configuration finale.

CrÃ©ez une configuration dÃ©diÃ©e :

```bash
cp "$BOT_HOME/$BOT_INSTANCE/eggdrop.conf" \
   "$BOT_HOME/$BOT_INSTANCE/${BOT_INSTANCE}.conf"
```

Ã‰ditez ensuite :

```bash
$BOT_HOME/$BOT_INSTANCE/${BOT_INSTANCE}.conf
```

---

## Initialiser le bot

```bash
"$BOT_HOME/$BOT_INSTANCE/eggdrop" -m "${BOT_INSTANCE}.conf"
```

Puis crÃ©ez lâ€™owner et dÃ©finissez le mot de passe.

---

## Lancer en foreground

```bash
"$BOT_HOME/$BOT_INSTANCE/eggdrop" -n "${BOT_INSTANCE}.conf"
```

---

## PiÃ¨ges importants Ã  retenir

Voici les erreurs les plus faciles Ã  Ã©viter :

1. **Utiliser `tar xzf` pour les archives `.tar.gz`**
2. **Ne pas utiliser de wildcard ambigu comme `cd tcltls-*`**
3. **Pour Tcllib, utiliser `make install-tcl` afin dâ€™Ã©viter une erreur optionnelle liÃ©e Ã  Critcl/TcllibC**
4. **Supprimer toute ancienne instance staging avant rÃ©installation**
5. **Supprimer le lien symbolique `eggdrop -> eggdrop-1.10.1` avant de crÃ©er votre propre lanceur `eggdrop`**
6. **Tester Tcl/TclTLS/Tcllib directement avec `tclsh`, pas via le lanceur Eggdrop**
7. **Compiler Eggdrop sous un utilisateur non privilÃ©giÃ©**
8. **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 privÃ©
- Tcl privÃ©
- TclTLS privÃ©
- Tcllib privÃ©e
- Eggdrop compilÃ© proprement
- 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
- ou la prÃ©paration dâ€™un article plus large autour de Tcl 9, Eggdrop 1.10.1 et de la compatibilitÃ© des scripts historiques