====== 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éparation =====
==== 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 ===
<code 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
</code>
==== Vérification Python ====
Comme Eggdrop peut construire `python.mod`, vérifier aussi :
<code 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)"</code>

<WRAP center round important 80%>
**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`)
</WRAP>

=== 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 :
<code bash>
nproc
make -j"$(nproc)"</code>

Dans ce guide :
  * `make -j"$(nproc)"` est utilisé pour la compilation
  * `make install` reste en simple
  * `tcllib` reste volontairement plus conservateur
===== Compilation =====
==== 0. Préparation bis ====
=== Variables d’environnement ===
Définir ces variables au début de la session :
<code 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"</code>
== Vérification ==
<code bash>echo "BUILD_ROOT=$BUILD_ROOT"
echo "WINDROP_ROOT=$WINDROP_ROOT"
echo "OPENSSL_PREFIX=$OPENSSL_PREFIX"
echo "TCL_PREFIX=$TCL_PREFIX"</code>

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 :
<code bash>mkdir -p "$BUILD_ROOT"/{src,build} "$WINDROP_ROOT"</code>
== Vérification ==
<code bash>find "$BUILD_ROOT" -maxdepth 2 -type d | sort
find "$WINDROP_ROOT" -maxdepth 2 -type d | sort</code>

=== Téléchargement des sources ===
Se placer dans le répertoire des sources :
<code bash>mkdir -p "$BUILD_ROOT/src"
cd "$BUILD_ROOT/src"</code>
== Télécharger les archives ==
<code 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"</code>
=== 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
=== Règle générale pour les archives ===
Pour éviter les `cd` fragiles, utiliser systématiquement cette méthode :
<code 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"</code>
==== 1. Construire OpenSSL 3.6.1 ====
=== Nettoyage préventif ===
<code bash>rm -rf "$OPENSSL_PREFIX"
mkdir -p "$OPENSSL_PREFIX"</code>
=== Décompression ===
<code 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"</code>
=== Configuration ===
<code bash>./Configure --prefix="$OPENSSL_PREFIX" shared Cygwin-x86_64</code>
<WRAP center round important 80%>
La cible doit être `Cygwin-x86_64` avec un `C` majuscule.
</WRAP>
=== Compilation et installation ===
<code bash>make -j"$(nproc)"
make install_sw</code>
=== Permissions des DLL ===
<code 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</code>

=== Vérification de la version OpenSSL ===
<code bash>"$OPENSSL_PREFIX/bin/openssl" version -a
ls -l "$OPENSSL_PREFIX/bin"/cyg*.dll</code>

==== 2. Construire Tcl 9.0.3 ====
=== Nettoyage préventif ===
<code bash>rm -rf "$TCL_PREFIX"
mkdir -p "$TCL_PREFIX"
mkdir -p "$TCL_PREFIX/man/mann"</code>
=== Décompression ===
<code 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"</code>

=== Configuration, compilation et installation ===
<code bash>
./configure --prefix="$TCL_PREFIX"
make -j"$(nproc)"
make install
ln -sf "$TCL_PREFIX/bin/tclsh9.0" "$TCL_PREFIX/bin/tclsh"</code>
=== Vérification de la version Tcl ===
<code bash>"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "auto_path=$auto_path"
EOF</code>

Résultat attendu : `Tcl=9.0.3`
==== 3. Construire TclTLS 2.0 ====
=== Nettoyage préventif ===
<code bash>rm -rf "$TCL_PREFIX/lib/tcltls2.0"</code>
=== Décompression ===
<code 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"</code>
=== Nettoyage de build ===
<code bash>make distclean 2>/dev/null || true
make clean 2>/dev/null || true</code>
=== Configuration ===
<code 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"</code>
=== Compilation et installation ===
<code bash>make -j"$(nproc)"
make install</code>
=== Permissions des DLL ====
<code 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</code>
=== Vérification de la version TclTLS ===
<code bash>"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
puts "Tcl=[info patchlevel]"
puts "tls=[package require tls]"
EOF</code>

Résultat attendu :
  * `Tcl=9.0.3`
  * `tls=2.0`
==== 4. Installer tcllib 2.0 ====
=== Décompression ===
<code 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"</code>
=== Nettoyage préventif ===
<code 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"</code>
=== Patch local de installer.tcl ===
Dans cet environnement, `tcllib 2.0` peut échouer avec le message `error deleting ".../tcllib2.0/page/plugins": directory not empty`

**Sauvegarde** `cp -a installer.tcl installer.tcl.orig`

**Patch Perl**
<code 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</code>

**Vérification visuelle** `nl -ba installer.tcl | sed -n '129,140p'`
=== Configuration ===
<code bash>./configure --prefix="$TCL_PREFIX"</code>
=== Installation Tcl pure ===
<WRAP center round important 80%>
Ne pas utiliser `make` simple : il essaie aussi de lancer une étape `critcl`.
</WRAP>
<code bash>make install-tcl</code>
=== Vérification rapide de tcllib ===
<code bash>"$TCL_PREFIX/bin/tclsh9.0" <<'EOF'
package require fileutil
puts "tcllib OK"
EOF</code>
==== 5. Construire Eggdrop 1.10.1 ====
=== Nettoyage préventif ===
<code bash>rm -rf "$WINDROP_ROOT/eggdrop-1.10.1"</code>
=== Décompression ===
<code 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"</code>
=== 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 :
<code 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"</code>
<WRAP center round tip 80%>
Cette étape est optionnelle. Si ces modules ne sont pas nécessaires, passer directement à la configuration.
</WRAP>
=== Configuration ===
Eggdrop autodétecte correctement Tcl dans ce contexte. En revanche, il faut fournir explicitement les chemins vers leaders OpenSSL, les bibliothèques OpenSSL et `python3-config`
<code 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"</code>
=== Compilation ===
<code bash>make config</code>
=== Vérification de python.mod ===
Contrôler les flags générés :
<code bash>grep -n '^PYTHON_CFLAGS\|^PYTHON_LDFLAGS' src/mod/python.mod/Makefile</code>
Résultat attendu :
  * chemins Python cohérents
  * pas de `-I<nowiki>//</nowiki>include/...`
  * pas de `-L<nowiki>//</nowiki>lib`

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

<code bash>make -j"$(nproc)"</code>
=== Installation ===
<code bash>make install DEST="$WINDROP_ROOT/eggdrop-1.10.1"</code>
=== Vérification globale de l’environnement Tcl ===
<code 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</code>

<WRAP center round important 80%>
Ne poursuivre que si tout répond correctement.
</WRAP>
=== Copie des DLL nécessaires ===
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 nécessaires dans `$WINDROP_ROOT/eggdrop-1.10.1/`

<code 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/"</code>

À 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` et `cygtcl9.0.dll`

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

===== Premier démarrage =====
==== Chargeur portable de packages Tcl ====
Le bundle portable repose sur [[https://teuk.org/downloads/windrop/tcl/autoload_pkgs-1.0.zip|scripts/autoload_pkgs.tcl]] 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 `scripts/autoload_pkgs.tcl`

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

<code tcl># Chargeur portable depuis ./lib uniquement
source scripts/autoload_pkgs.tcl</code>
Le bundle doit donc embarquer au minimum les éléments suivants : `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 [[https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.conf|Windrop-portable-1.10.1-minimal.conf]] 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 : ssl/certs/cacert.pem

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

<code 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"
</code>

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

<code bash>
ls -lh "$WINDROP_ROOT/eggdrop-1.10.1/ssl/certs/cacert.pem"
</code>

Si le fichier de configuration est inclus dans le bundle, il est alors possible d’y utiliser :

<code tcl>
set ::httpscompat::cafile "ssl/certs/cacert.pem"
</code>

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

<code tcl>
source scripts/https_compat_tcl9.tcl
</code>

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.

<code 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
</code>

=== 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é :

<code 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
</code>

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é ===

<code bash>
find "$WINDROP_ROOT/eggdrop-1.10.1" -maxdepth 3 -ls
</code>

==== Configuration initiale ====

Le fichier fourni ([[https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.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** :

<code tcl>
#source scripts/https_compat_tcl9.tcl
</code>

==== 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 en 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://teuk.org/downloads/windrop/tcl/https_compat_tcl9-1.4.zip|https_compat_tcl9-1.4.zip]]

=== Exemple de chargement dans la configuration ===

<code 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
</code>

Si ce wrapper est activé, il est aussi recommandé d’embarquer un bundle CA portable dans ssl/certs/cacert.pem et de définir dans la configuration :

<code tcl>
set ::httpscompat::cafile "ssl/certs/cacert.pem"
</code>

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

===== Lancement d’Eggdrop avec un wrapper 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 ====

<code dos>
@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%
</code>

==== 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 : eggdrop.cmd -m bot.conf
  * Lancement en foreground : eggdrop.cmd -n bot.conf
  * Lancement normal : eggdrop.cmd bot.conf

bot.conf est donné ici à titre indicatif. En pratique, il faut partir du fichier [[https://teuk.org/downloads/windrop/conf/Windrop-portable-1.10.1-minimal.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.
  * 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é.
  * Pour les archives .tar.gz, toujours :
    * définir ARCHIVE
    * déterminer SRC_DIR avec tar tzf ... | head -1 | cut -d/ -f1
    * utiliser tar xzf
    * faire cd "$SRC_DIR"

===== Résumé =====

La séquence recommandée est :
  - préparer les variables d’environnement
  - télécharger les sources
  - construire OpenSSL
  - construire Tcl
  - construire TclTLS
  - installer tcllib
  - construire Eggdrop
  - ajouter éventuellement les modules complémentaires et leurs fichiers associés
  - 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.