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.
====== Windrop portable sous Cygwin ======
===== Vue d’ensemble =====
Ce guide décrit une méthode reproductible pour construire un environnement Windrop portable sous Cygwin autour des composants suivants : **OpenSSL 3.6.1**, **Tcl 9.0.3**, **TclTLS 2.0**, **tcllib 2.0** et **Eggdrop 1.10.1**, avec les modules additionnels optionnels : //botnetop//, //gseen// et //stats//

L’objectif est de produire un arbre propre, isolé et relançable, sans dépendre d’un état implicite de la session ni d’un ancien build.

Le principe est simple :
  * travailler avec des variables d’environnement stables
  * séparer clairement les sources, le build et l’installation
  * nettoyer avant chaque grosse étape
  * valider chaque étape avant de passer à la suivante

<WRAP center round box 80%>
Un grand merci à [[https://github.com/michaelortmann/windrop?tab=readme-ov-file|Michael Ortmann]] pour le guide original. Il a fourni une excellente base de départ, très utile pour reproduire un build Windrop portable moderne. Ce HOWTO s’appuie sur ce travail et documente les étapes supplémentaires, les correctifs et les détails de packaging nécessaires pour rendre l’ensemble réellement reproductible en pratique.
</WRAP>

===== Pré-requis Cygwin =====

Installer au minimum les paquets suivants :
<code bash>text
autoconf2.7
automake1.17
binutils
gcc-core
gcc-g++
make
mingw64-x86_64-gcc-core
pkg-config
git
wget
curl
zip
unzip
tar
xz
patch
perl
python3
python3-devel
rebase
dash
zlib
zlib-devel</code>


Vérification rapide :

```bash
for cmd in gcc g++ make autoconf pkg-config tar wget; do
  printf '%-12s ' "$cmd"
  if command -v "$cmd" >/dev/null 2>&1; then
    "$cmd" --version 2>/dev/null | head -1
  else
    echo "KO"
  fi
done
printf '%-12s ' "nproc"
if command -v nproc >/dev/null 2>&1; then
  nproc
else
  echo "KO"
fi
```

### Vérification Python

Comme Eggdrop peut construire `python.mod`, vérifier aussi :

```bash
echo "python3:        $(command -v python3 2>/dev/null || echo KO)"
echo "python version: $(python3 --version 2>/dev/null || echo KO)"
echo "python3-config: $(readlink -f /usr/bin/python3-config 2>/dev/null || echo KO)"
echo "includes:       $(/usr/bin/python3-config --includes 2>/dev/null || echo KO)"
echo "ldflags:        $(/usr/bin/python3-config --ldflags 2>/dev/null || echo KO)"
```

Point important sous Cygwin :

- ne pas utiliser `$(command -v python3-config)` dans ce guide
- forcer `/usr/bin/python3-config`
- cela évite les chemins cassés du type `-I//include/...` et `-L//lib`

### Modules additionnels optionnels

Le flux ci-dessous permet aussi d’intégrer, de façon optionnelle, trois modules externes souvent associés aux builds Windrop récents :

- `botnetop.mod`
- `gseen.mod`
- `stats.mod`

Ils sont récupérés via `git clone`, d’où la présence de `git` dans les prérequis.

### Compilation parallèle

Sous Cygwin, les compilations peuvent être accélérées avec :

```bash
nproc
make -j"$(nproc)"
```

Dans ce guide :

- `make -j"$(nproc)"` est utilisé pour la compilation
- `make install` reste en simple
- `tcllib` reste volontairement plus conservateur

---

## Variables d’environnement

Définir ces variables au début de la session :

```bash
export BUILD_ROOT=/home/eggbox/windrop-build
export WINDROP_ROOT=/home/eggbox/windrop-root

export OPENSSL_PREFIX=$WINDROP_ROOT/openssl
export TCL_PREFIX=$WINDROP_ROOT/tcl

export PATH="$TCL_PREFIX/bin:$OPENSSL_PREFIX/bin:/bin:/usr/bin:$PATH"
export LD_LIBRARY_PATH="$OPENSSL_PREFIX/lib:$OPENSSL_PREFIX/lib64:$TCL_PREFIX/lib"
export TCLLIBPATH="$TCL_PREFIX/lib"
export PKG_CONFIG_PATH="$OPENSSL_PREFIX/lib/pkgconfig:$OPENSSL_PREFIX/lib64/pkgconfig"
```

Vérification :

```bash
echo "BUILD_ROOT=$BUILD_ROOT"
echo "WINDROP_ROOT=$WINDROP_ROOT"
echo "OPENSSL_PREFIX=$OPENSSL_PREFIX"
echo "TCL_PREFIX=$TCL_PREFIX"
```

Si vous ouvrez plus tard une nouvelle session Cygwin, il suffit de relancer ce bloc.

---

## Préparation des répertoires

Créer l’arborescence de travail :

```bash
mkdir -p "$BUILD_ROOT"/{src,build} "$WINDROP_ROOT"
```

Vérification :

```bash
find "$BUILD_ROOT" -maxdepth 2 -type d | sort
find "$WINDROP_ROOT" -maxdepth 2 -type d | sort
```

---

## Téléchargement des sources

Se placer dans le répertoire des sources :

```bash
mkdir -p "$BUILD_ROOT/src"
cd "$BUILD_ROOT/src"
```

Télécharger les archives :

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

### Sources des modules optionnels

Ces modules ne sont pas fournis sous forme d’archives `.tar.gz` dans ce guide. Ils seront récupérés plus tard directement dans l’arbre Eggdrop via Git.

Dépôts utilisés :

- `https://github.com/michaelortmann/botnetop.mod`
- `https://github.com/michaelortmann/gseen.mod`
- `https://github.com/michaelortmann/stats.mod`

Vérification :

```bash
ls -lh "$BUILD_ROOT/src"
```

---

## Règle générale pour les archives `.tar.gz`

Pour éviter les `cd` fragiles, utiliser systématiquement cette méthode :

```bash
cd "$BUILD_ROOT/build"
export ARCHIVE="$BUILD_ROOT/src/monarchive.tar.gz"
export SRC_DIR="$(tar tzf "$ARCHIVE" | head -1 | cut -d/ -f1)"
echo "$SRC_DIR"
tar xzf "$ARCHIVE"
cd "$SRC_DIR"
```

---

## 1. Construire OpenSSL 3.6.1

### Nettoyage préventif

```bash
rm -rf "$OPENSSL_PREFIX"
mkdir -p "$OPENSSL_PREFIX"
```

### Décompression

```bash
cd "$BUILD_ROOT/build"
export ARCHIVE="$BUILD_ROOT/src/openssl-3.6.1.tar.gz"
export SRC_DIR="$(tar tzf "$ARCHIVE" | head -1 | cut -d/ -f1)"
tar xzf "$ARCHIVE"
cd "$SRC_DIR"
```

### Configuration

```bash
./Configure \
  --prefix="$OPENSSL_PREFIX" \
  shared \
  Cygwin-x86_64
```

Point important : la cible doit être `Cygwin-x86_64` avec un `C` majuscule.

### Compilation et installation

```bash
make -j"$(nproc)"
make install_sw
```

### Permissions des DLL

```bash
chmod 755 "$OPENSSL_PREFIX/bin/cygcrypto-3.dll" 2>/dev/null || true
chmod 755 "$OPENSSL_PREFIX/bin/cygssl-3.dll" 2>/dev/null || true
```

### Vérification de la version OpenSSL

```bash
"$OPENSSL_PREFIX/bin/openssl" version -a
ls -l "$OPENSSL_PREFIX/bin"/cyg*.dll
```

---

## 2. Construire Tcl 9.0.3

### Nettoyage préventif

```bash
rm -rf "$TCL_PREFIX"
mkdir -p "$TCL_PREFIX"
mkdir -p "$TCL_PREFIX/man/mann"
```

### Décompression

```bash
cd "$BUILD_ROOT/build"
export ARCHIVE="$BUILD_ROOT/src/tcl9.0.3-src.tar.gz"
export SRC_DIR="$(tar tzf "$ARCHIVE" | head -1 | cut -d/ -f1)"
tar xzf "$ARCHIVE"
cd "$SRC_DIR/unix"
```

### Configuration, compilation et installation

```bash
./configure --prefix="$TCL_PREFIX"
make -j"$(nproc)"
make install
ln -sf "$TCL_PREFIX/bin/tclsh9.0" "$TCL_PREFIX/bin/tclsh"
```

### Vérification de la version Tcl

```bash
"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "auto_path=$auto_path"
EOF
```

Résultat attendu : `Tcl=9.0.3`

---

## 3. Construire TclTLS 2.0

### Nettoyage préventif

```bash
rm -rf "$TCL_PREFIX/lib/tcltls2.0"
```

### Décompression

```bash
cd "$BUILD_ROOT/build"
export ARCHIVE="$BUILD_ROOT/src/tcltls-2.0-src.tar.gz"
export SRC_DIR="$(tar tzf "$ARCHIVE" | head -1 | cut -d/ -f1)"
tar xzf "$ARCHIVE"
cd "$SRC_DIR"
```

### Nettoyage de build

```bash
make distclean 2>/dev/null || true
make clean 2>/dev/null || true
```

### Configuration

```bash
./configure \
  --prefix="$TCL_PREFIX" \
  --with-tcl="$TCL_PREFIX/lib" \
  --with-tclinclude="$TCL_PREFIX/include" \
  CPPFLAGS="-I$OPENSSL_PREFIX/include -I$TCL_PREFIX/include" \
  LDFLAGS="-L$OPENSSL_PREFIX/lib -L$OPENSSL_PREFIX/lib64 -L$TCL_PREFIX/lib"
```

### Compilation et installation

```bash
make -j"$(nproc)"
make install
```

### Permissions des DLL

```bash
chmod 755 "$TCL_PREFIX/lib/tcltls2.0/cygtcl9tls2.0.dll" 2>/dev/null || true
chmod 755 "$OPENSSL_PREFIX/bin/cygcrypto-3.dll" 2>/dev/null || true
chmod 755 "$OPENSSL_PREFIX/bin/cygssl-3.dll" 2>/dev/null || true
find "$TCL_PREFIX/lib/tcltls2.0" -type d -exec chmod 755 {} \; 2>/dev/null || true
```

### Vérification de la version TclTLS

```bash
"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "tls=[package require tls]"
EOF
```

Résultat attendu :

- `Tcl=9.0.3`
- `tls=2.0`

---

## 4. Installer tcllib 2.0

### Décompression

```bash
cd "$BUILD_ROOT/build"
export ARCHIVE="$BUILD_ROOT/src/tcllib-2.0.tar.gz"
export SRC_DIR="$(tar tzf "$ARCHIVE" | head -1 | cut -d/ -f1)"
tar xzf "$ARCHIVE"
cd "$SRC_DIR"
```

### Nettoyage préventif

```bash
make clean 2>/dev/null || true
rm -rf "$TCL_PREFIX/lib/tcllib2.0"
rm -rf "$TCL_PREFIX/man"
mkdir -p "$TCL_PREFIX/man/mann"
```

### Patch local de `installer.tcl`

Dans cet environnement, `tcllib 2.0` peut échouer avec :

```text
error deleting ".../tcllib2.0/page/plugins": directory not empty
```

Sauvegarde :

```bash
cp -a installer.tcl installer.tcl.orig
```

Patch Perl :

```bash
perl -0pi -e 's/run file delete \$sub/set __visible [glob -nocomplain [file join \$sub *]]\n                        set __hidden  [glob -nocomplain -types hidden [file join \$sub *]]\n                        if {![llength [concat \$__visible \$__hidden]]} {\n                            catch {run file delete -force -- \$sub}\n                        }/s' installer.tcl
```

Vérification visuelle :

```bash
nl -ba installer.tcl | sed -n '129,140p'
```

### Configuration

```bash
./configure --prefix="$TCL_PREFIX"
```

### Installation Tcl pure

Ici, ne pas utiliser `make` simple : il essaie aussi de lancer une étape `critcl`.

Utiliser directement :

```bash
make install-tcl
```

### Vérification rapide de tcllib

```bash
"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
package require fileutil
puts "tcllib OK"
EOF
```

---

## 5. Construire Eggdrop 1.10.1

### Nettoyage préventif

```bash
rm -rf "$WINDROP_ROOT/eggdrop-1.10.1"
```

### Décompression

```bash
cd "$BUILD_ROOT/build"
export ARCHIVE="$BUILD_ROOT/src/eggdrop-1.10.1.tar.gz"
export SRC_DIR="$(tar tzf "$ARCHIVE" | head -1 | cut -d/ -f1)"
tar xzf "$ARCHIVE"
cd "$SRC_DIR"
```

### Modules additionnels optionnels

Si l’objectif est de reproduire un build enrichi avec `botnetop`, `gseen` et `stats`, cloner les dépôts dans `src/mod` avant la configuration :

```bash
cd "$BUILD_ROOT/build/$SRC_DIR/src/mod"
env -i HOME="$HOME" USER="$USER" TERM="$TERM" PATH="/bin:/usr/bin" \
  git clone --depth=1 https://github.com/michaelortmann/botnetop.mod.git
env -i HOME="$HOME" USER="$USER" TERM="$TERM" PATH="/bin:/usr/bin" \
  git clone --depth=1 https://github.com/michaelortmann/gseen.mod.git
env -i HOME="$HOME" USER="$USER" TERM="$TERM" PATH="/bin:/usr/bin" \
  git clone --depth=1 https://github.com/michaelortmann/stats.mod.git
cd "$BUILD_ROOT/build/$SRC_DIR"
```

Cette étape est optionnelle. Si ces modules ne sont pas nécessaires, passer directement à la configuration.

### Configuration

Eggdrop autodétecte correctement Tcl dans ce contexte.  
En revanche, il faut fournir explicitement :

- le chemin des headers OpenSSL
- le chemin des bibliothèques OpenSSL
- le chemin stable de `python3-config`

```bash
export PYTHON_CONFIG=/usr/bin/python3-config

./configure \
  --prefix="$WINDROP_ROOT/eggdrop-1.10.1" \
  --with-sslinc="$OPENSSL_PREFIX/include" \
  --with-ssllib="$OPENSSL_PREFIX/lib" \
  --with-python-config="$PYTHON_CONFIG"
```

### Compilation

```bash
make config
```

### Vérification de `python.mod`

Contrôler les flags générés :

```bash
grep -n '^PYTHON_CFLAGS\|^PYTHON_LDFLAGS' src/mod/python.mod/Makefile
```

Résultat attendu :

- chemins Python cohérents
- pas de `-I//include/...`
- pas de `-L//lib`

Si `//include` ou `//lib` apparaissent encore, interrompre ici et corriger la détection Python avant compilation.

```bash
make -j"$(nproc)"
```

### Installation

```bash
make install DEST="$WINDROP_ROOT/eggdrop-1.10.1"
```

## Vérification globale de l’environnement Tcl

```bash
cd "$BUILD_ROOT"
export PATH="$TCL_PREFIX/bin:$OPENSSL_PREFIX/bin:/bin:/usr/bin:$PATH"
export LD_LIBRARY_PATH="$OPENSSL_PREFIX/lib:$OPENSSL_PREFIX/lib64:$TCL_PREFIX/lib"
export TCLLIBPATH="$TCL_PREFIX/lib"

"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "tls=[package require tls]"
catch {package require fileutil} r1
puts "fileutil=$r1"
EOF
```

Ne poursuivre que si tout répond correctement.

---

### Copie des DLL nécessaires dans la racine du bot

Pour qu’un bundle Windrop portable puisse être lancé directement depuis Windows, il ne suffit pas d’installer Eggdrop : il faut aussi copier dans la racine du bot les DLL runtime nécessaires.

Copier les fichiers suivants dans :

```text
$WINDROP_ROOT/eggdrop-1.10.1/
```

Commande :

```bash
cd "$WINDROP_ROOT/eggdrop-1.10.1/"
cp -f /bin/cygwin1.dll "$WINDROP_ROOT/eggdrop-1.10.1/"
cp -f /bin/cygz.dll "$WINDROP_ROOT/eggdrop-1.10.1/"
cp -f /bin/cyggcc_s-seh-1.dll "$WINDROP_ROOT/eggdrop-1.10.1/"

cp -f "$OPENSSL_PREFIX/bin/cygcrypto-3.dll" "$WINDROP_ROOT/eggdrop-1.10.1/"
cp -f "$OPENSSL_PREFIX/bin/cygssl-3.dll" "$WINDROP_ROOT/eggdrop-1.10.1/"

cp -f "$TCL_PREFIX/bin/cygtcl9.0.dll" "$WINDROP_ROOT/eggdrop-1.10.1/"
```

À ce stade, la racine du bot doit contenir au minimum :

- `eggdrop.exe-1.10.1`
- `cygwin1.dll`
- `cygz.dll`
- `cyggcc_s-seh-1.dll`
- `cygcrypto-3.dll`
- `cygssl-3.dll`
- `cygtcl9.0.dll`

Sans cette étape, un lancement direct depuis `cmd.exe` peut échouer avec un message indiquant qu’une DLL est manquante.

### Chargeur portable de packages Tcl

Le bundle portable repose sur [`scripts/autoload_pkgs.tcl`](https://teuk.org/downloads/windrop/tcl/autoload_pkgs-1.0.zip) pour charger les packages Tcl depuis l’arborescence locale `./lib`, sans dépendre d’un environnement Tcl installé ailleurs sur la machine.

Ce script doit donc être présent dans :

```text
scripts/autoload_pkgs.tcl
```

La configuration minimale fournie charge explicitement ce fichier avant le wrapper HTTPS et avant les autres scripts Tcl.

Extrait :

```tcl
# Chargeur portable depuis ./lib uniquement
source scripts/autoload_pkgs.tcl
```

Le bundle doit donc embarquer au minimum les éléments suivants :

```text
scripts/autoload_pkgs.tcl
lib/tcl9
lib/tcllib2.0
```

et, si le support TLS Tcl est utilisé dans les scripts, le répertoire TclTLS portable correspondant au build.


### Ajout du bundle CA portable pour HTTPS

Si le fichier fourni [Windrop-portable-1.10.1-minimal.conf](https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.zip) est utilisé avec le wrapper HTTPS Tcl 9, il faut embarquer un bundle de certificats CA dans le répertoire du bot.

L’emplacement attendu est :

```text
ssl/certs/cacert.pem
```

Créer l’arborescence puis télécharger `cacert.pem` :

```bash
mkdir -p "$WINDROP_ROOT/eggdrop-1.10.1/ssl/certs"

wget -O "$WINDROP_ROOT/eggdrop-1.10.1/ssl/certs/cacert.pem" \
  "https://curl.se/ca/cacert.pem"
```

Vérification de la présence du bundle CA :

```bash
ls -lh "$WINDROP_ROOT/eggdrop-1.10.1/ssl/certs/cacert.pem"
```

Si le fichier de configuration [Windrop-portable-1.10.1-minimal.conf](https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.zip) est inclus dans le bundle, il est alors possible d’y utiliser :

```tcl
set ::httpscompat::cafile "ssl/certs/cacert.pem"
```

puis de décommenter le chargement du wrapper HTTPS si nécessaire :

```tcl
source scripts/https_compat_tcl9.tcl
```

Cette étape n’est utile que si des scripts Tcl utilisent réellement `package http`, en particulier avec des URLs `https://`.

### Remplacement des liens symboliques pour un vrai bundle Windows

Une installation Eggdrop sous Cygwin peut laisser des liens symboliques dans l’arbre installé, notamment :

- `eggdrop.exe -> eggdrop.exe-1.10.1`
- `modules -> modules-1.10.1`

Pour obtenir un répertoire réellement portable et facile à copier depuis le filesystem Windows, il est préférable de remplacer ces liens par de vrais fichiers et de vrais répertoires.

Commande :

```bash
cd "$WINDROP_ROOT/eggdrop-1.10.1"

rm -f eggdrop.exe
cp -f eggdrop.exe-1.10.1 eggdrop.exe

rm -rf modules
cp -a modules-1.10.1 modules
```

### Copie des fichiers des modules optionnels

Si `botnetop.mod`, `gseen.mod` et `stats.mod` ont été clonés et compilés, copier ensuite leurs fichiers de configuration et de langue dans l’arbre installé :

```bash
cd "$BUILD_ROOT/build/$SRC_DIR"
cp src/mod/botnetop.mod/botnetop.conf "$WINDROP_ROOT/eggdrop-1.10.1" 2>/dev/null || true
cp src/mod/gseen.mod/gseen.conf "$WINDROP_ROOT/eggdrop-1.10.1" 2>/dev/null || true
cp src/mod/gseen.mod/*.lang "$WINDROP_ROOT/eggdrop-1.10.1/language/" 2>/dev/null || true
cp src/mod/stats.mod/stats.conf "$WINDROP_ROOT/eggdrop-1.10.1" 2>/dev/null || true
cp src/mod/stats.mod/language/* "$WINDROP_ROOT/eggdrop-1.10.1/language/" 2>/dev/null || true
cp -r src/mod/stats.mod/templates "$WINDROP_ROOT/eggdrop-1.10.1" 2>/dev/null || true
```

Ces copies sont elles aussi optionnelles et n’ont de sens que si les modules ont été ajoutés plus tôt dans l’arbre Eggdrop.

### Vérification de l’arbre installé

```bash
find "$WINDROP_ROOT/eggdrop-1.10.1" -maxdepth 3 -ls
```

---

## Configuration initiale

Le fichier fourni [Windrop-portable-1.10.1-minimal.conf](https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.conf) sert de base de départ.  
Avant le premier lancement, vérifier au minimum :

- l’identité du bot (`username`, `admin`, `network`, `nick`, `altnick`, `realname`)
- le port d’écoute (`listen`)
- l’owner
- les serveurs IRC
- les canaux à rejoindre
- les modules réellement souhaités

Le wrapper HTTPS Tcl 9 est prévu mais reste **désactivé par défaut** :

```tcl
#source scripts/https_compat_tcl9.tcl
```

## Annexe – Wrapper HTTPS Tcl 9 / TclTLS 2.0

Le wrapper HTTPS Tcl 9 / TclTLS 2.0 rétablit une compatibilité propre pour les scripts Tcl utilisant `package http`, en particulier avec des URLs `https://`, dans un bundle Windrop portable basé sur Tcl 9, TclTLS 2.0 et tcllib 2.0.

Ce wrapper doit être chargé avant les scripts Tcl qui utilisent HTTP/HTTPS.

Archive fournie :

- [`https_compat_tcl9-1.4.zip`](https://teuk.org/downloads/windrop/tcl/https_compat_tcl9-1.4.zip)

Exemple de chargement dans la configuration :

```tcl
# Optional overrides before loading:
#   set ::httpscompat::debug 1
#   set ::httpscompat::cafile "ssl/certs/cacert.pem"
#   set ::httpscompat::selftest_host "google.com"

source scripts/https_compat_tcl9.tcl
```

Si ce wrapper est activé, il est aussi recommandé d’embarquer un bundle CA portable dans :

```text
ssl/certs/cacert.pem
```

et de définir dans la configuration :

```tcl
set ::httpscompat::cafile "ssl/certs/cacert.pem"
```

Cette annexe complète la section du HOWTO consacrée au bundle CA portable et à la configuration initiale.

## Lancement d’Eggdrop avec un wrapper CMD portable

Dans l’arbre installé, `eggdrop.exe` peut être un lien symbolique ou un stub non directement exploitable selon le contexte Windows.  
Le vrai binaire à lancer est généralement `eggdrop.exe-1.10.1`.

Le plus simple consiste donc à fournir un lanceur `eggdrop.cmd` placé dans le répertoire d’installation Eggdrop.  
Ce wrapper :

- se base sur son propre emplacement ;
- ajoute les chemins `openssl\bin` et `tcl\bin` sans écraser le `PATH` système ;
- définit `TCL_LIBRARY`, `TCLLIBPATH` et les variables liées aux certificats ;
- lance le vrai binaire `eggdrop.exe-1.10.1`.

### Fichier `eggdrop.cmd`

```cmd
@echo off
setlocal EnableExtensions

set "BASE_DIR=%~dp0"
if "%BASE_DIR:~-1%"=="\" set "BASE_DIR=%BASE_DIR:~0,-1%"

set "EGGDIR=%BASE_DIR%"
set "OPENSSL_DIR=%EGGDIR%\..\openssl"
set "TCL_DIR=%EGGDIR%\..\tcl"

set "BINARY=%EGGDIR%\eggdrop.exe-1.10.1"
if not exist "%BINARY%" (
  echo [ERROR] Could not find binary : "%BINARY%"
  exit /b 1
)

set "PATH=%OPENSSL_DIR%\bin;%TCL_DIR%\bin;%PATH%"
set "TCL_LIBRARY=%TCL_DIR%\lib\tcl9"
set "TCLLIBPATH=%TCL_DIR%\lib"
set "SSL_CERT_DIR=%EGGDIR%\ssl\certs"
set "SSL_CERT_FILE=%EGGDIR%\ssl\certs\cacert.pem"

pushd "%EGGDIR%" >nul 2>&1
if errorlevel 1 (
  echo [ERROR] Could not change directory to "%EGGDIR%"
  exit /b 1
)

"%BINARY%" %*
set "RC=%ERRORLEVEL%"

popd >nul 2>&1
exit /b %RC%
```

### Usage

À ce stade de l’installation, il ne faut plus utiliser le shell Cygwin mais une `cmd.exe` classique. Le répertoire `/home/eggbox/windrop-root/eggdrop-1.10.1` peut être copié n’importe où sur le filesystem Windows.

Initialisation d’un nouveau bot :

```cmd
eggdrop.cmd -m bot.conf
```

Lancement en foreground :

```cmd
eggdrop.cmd -n bot.conf
```

Lancement normal :

```cmd
eggdrop.cmd bot.conf
```

`bot.conf` est donné ici à titre indicatif.  
En pratique, il faut partir du fichier [Windrop-portable-1.10.1-minimal.conf](https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.conf), l’adapter, puis l’utiliser avec ce lanceur.

---

### Rappels pratiques

### Toujours nettoyer avant les grosses briques

Le nettoyage préventif fait partie du flux normal.

### Toujours se repositionner avant un `make clean`

Un `make clean` ou `make distclean` ne doit jamais dépendre du répertoire courant laissé par l’étape précédente.

### Pour les `.tar.gz` archives

Toujours :

- définir `ARCHIVE`
- déterminer `SRC_DIR` avec `tar tzf ... | head -1 | cut -d/ -f1`
- utiliser `tar xzf`
- faire `cd "$SRC_DIR"`

### Si une variable a disparu

Recharger le bloc des variables d’environnement.

### Si l’environnement devient douteux

Nettoyer les préfixes et reprendre les étapes depuis le début du composant concerné.

---

## Résumé

La séquence recommandée est :

1. préparer les variables d’environnement
2. télécharger les sources
3. construire OpenSSL
4. construire Tcl
5. construire TclTLS
6. installer tcllib
7. construire Eggdrop
8. ajouter éventuellement les modules complémentaires et leurs fichiers associés
9. valider l’ensemble

Cette méthode reste volontairement conservatrice. Elle privilégie la reproductibilité, la lisibilité et la reprise propre d’un build en cas d’échec.