.--.
.----------------------------------------------------------------/  /--. 
| little brother 1.0                                            /  /   |
|     a k a                                                    /  / 08 | 
| la saga d'une boite de bine                                 /  /     |  
'------------------------------------------------------------/  /------' 
                                                            '--'

    l'article  suivant, a  2  but  principale, 1, de donner a  ceux  qui 
sont  lache, un tcl efficace pour eggdrop afin de creer  un  spybot,  et  
en  2eme  lieu de faire lieu de reference pour l'utilisation  de  socket  
en  TCL,  domaine qui manque  malheureusement de documentation (il sagit 
en fait d'un des premiers  TCL  public pour  eggdrop  a  faire  appel  a 
l'utilisation de Socket  (ce n 'est  pas le premier j'en convient,  mais   
les   expliquations  fournie  avec eviterons  bien  des  mots de tete  a  
qui  voudrais  creer  une  application  du  genre  pour  sont   eggdrop. 
personnellement j'ai  du  me  baser  sur  des reference de tcl "normal", 
plutot vague d'ailleur,  afin  d'arriver a mon but ( pas de  danger  que 
j'aille recu l'aide  esperer  sur  undernet (#scripteur  #scripteurs  et 
tout les chan  de  wanabe  egg warlord (#19 genre)). enfin, si vous etes  
trop lache pour essayer de comprendre, copier/coller le code, et ajouter   
le en tcl/script a un de vos egg, 


    Comment utiliser le script ? 
    
    
c'est pas compliquer, si vous etes capable  de  rentrer  sur  irc,  vous 
allez etre capable de vous en servires.  un  coup  installer  et  laoder 
vous n'avez qua taper sur  le  chan ou vous desierez voir l'info arriver 
!pipe nick #chan.

ie: !pipe Encoder #securiweb, va faire entrer sur securiweb un spybot au  
nick  de  encoder  qui  va  paster  tout la  conversation  de  securiweb  
sur  votre  chan (c'a peu etre pratique quand on est plusieur a voulloir  
spyer un meme  chan, ca evite un mass join peu subtile).
    

si vous avez un wingate (un  vrai qui renvois la string  WinGate> , vous 
pourez faire  passer  le  robot par la avec  la commande  suivante !pipe 
nick #chan wingate port

ie : !pipe Encoder #securiweb wingate.com 23

le resultat va etre le meme en bout de ligne sauf que  votre  spybot  va 
avoir le ip du wingate  (moin  reperable ou plus (genre un .jp c'est pas 
trustable :])

ps : si vous voullez utilise le code noubliez  pas   de  creer  dans  le 
repertoire de votre  egg  un  fichier  text  nomer server.txt et inserer 
dedans vos serveur preferer.

bon passont au code :} si vous etez avares d'espace vous pouvez toujours 
enlever les lignes #

comme il sagit dun code free (sans  license),vous en faites ce  que vous  
voullez,  mais  si  vous  faites  des  modifs  interressante  j'aimerais  
que  vous  m'en  facier  par via  encoder@operamail.com  

----------------------lazy cut here------------------------

# Spybot 1.0 by Wyzeman tcl script for Cybersix 


#c'est ici que sa commence ;]
bind pubm - * pipe
proc pipe {nick host hand chan triggers} {
   set triggers [string tolower $triggers]
#mettre tout en minuscule (ce qui vien du chan irc primaire
#et non pas celui quon spy)
   if {[string match !pipe*  $triggers]} {
#si tu vois !pipe quelquechose, commence a faire dequoi
       set pipehost [open server.txt "r"]
       set cline 0
       while {![eof $pipehost]} {
       set lines($cline) [gets $pipehost]
       incr cline
       }
       close $pipehost       
       set pipehost $lines([rand $cline])      
#ici on determine le server undernet choisi dapres une liste
#creer dans un fichier text (server.txt en attache au ezine)
       set pipeport "6660"
#afin deviter que le monde fasse des query stupide jai 
#limiter le port a 6660 (jaurais pu faire un random comme
#pour le serveur, mais bof, si ca fait pas votre affaire 
#vous n'avez qua le modifier       
       set pipenick [lindex $triggers 1]
#le nick choisir (qui correspong au 2e caractere de la string
#!pipe (le premier caractere etais representer par 0)
       set pipechan [lindex $triggers 2] 
#le chan choisi       
       set wingate [lindex $triggers 3]
#le wingate (optionnelle), ne marquer rien apres le chan
#autre qu'un wingate sinon il va essayer de se connecter dessus
       set pwingate [lindex $triggers 4]
#le port du wingate,       
       if {$pipehost < 1} {
       set pipehost "london.uk.eu.undernet.org"
#ici javais un probleme de ligne vide dans le fichier server.txt
#afin de limiter les degats, jai ajouter ceci pour quil force
#le serveur lodon  si  jamais  il tombais sur la ligne vide
#vous pouvez bien sur remplasser par votre serveur preferer
       } else {
       if {$wingate > 0} {
#si il y a quelque chose dans la variable wingate       
       set sock [socket $wingate $pwingate]
#initiation du socket (on voit ici que le socket se gere
#dans une variable (comme en php) donc en gros, creer la
#variable sock qui ouvre un socket sur le wingate et sont port       
       putchan $chan "connected to wingate"
#question de savoir ou le code est rendu        
       fileevent $sock readable [list display_sock $sock $chan $pipenick $pipechan $pipehost $pipeport] 
#va lire la variable sock (referense a la procedure display_sock 
#(voir plus bas) et donne lui les variables ($sock $chan $pipenick, etc)
# parce qu'on va en avoir besoin dans cette procedure
       fconfigure $sock -buffering line 
       } else {
#si la variable wingate est a 0       
       set sock [socket $pipehost $pipeport]
#ouvre un socket sur la valeur de $pipehost et $pipeport
       putchan $chan "connected to $pipehost"       
#vous etes ici       
       fileevent $sock readable [list display_sock $sock $chan $pipenick $pipechan $pipehost $pipeport]
#passe a la procedure display_sock et mode lecture de la variable $sock
#qui correspond au contenu du socket
       fconfigure $sock -buffering line        
       } 
     }
   }
}
 
proc display_sock {sock chan pipenick pipechan pipehost pipeport} {
#la fameuse procedure display_sock
    set 1 [gets $sock]  
#met le contenu du socket dans la variable $1 
#pour quon puisse la modifier independament du socket (ouvert en lecture)
    if {[string match WinGate* $1]} {
#si tu recois la string Wingate>
       fileevent $sock writable [list wingate_connect $sock $pipehost $pipeport $chan]
#va a la procedur wingate_connect avec la variable
#$sock en mode ecriture
       } elseif {[string match  *NOTICE*AUTH*Looking*hostname* $1]} {
       fileevent $sock writable [list auth_sock $sock $chan $pipenick]
       } elseif {[string match PING* $1]} {
       fileevent $sock writable [list ping_sock $sock $1 $chan]
       } elseif {[string match *End*of*/MOTD* $1]} {
       fileevent $sock writable [list join_sock $sock $chan $pipechan]
#differente reconnaissance de string pour effectuer la connection
#elle renvoie a des procedure utilisant la variable
#$sock en mode ecriture (pour envouer du data)
       } elseif {[string match *PRIVMSG*$pipechan* $1]} {       
       set 1 [string trim $1 :]
       set 1 [string map {! " "} $1]
       set 2 [lindex $1 0]
       set 3 [lrange $1 4 end]
#epuration des string recu (afin de conserver que le 
#nescessaire pratique et estetique       
       putchan $chan "$2 $pipechan $3"
#afichage du chan que lon spy sur le chan dorigine(trier plus haut)       
       } elseif {[string match *$pipenick*$pipechan*:Cannot join channel(+l) $1]}
       fileevent $sock writable [list join_sock $sock $chan $pipechan]
#si le chan est +l (limite user) reessaye toi jusqua ce que tu entre
#en re referant a la procedur join_sock a chaque fois
       } elseif {[string match *Cannot*join*channel*]} {
       putchan $chan "cant reach channels"
       close $sock
#si pour une autre raison le spybot peu pas joindre le chan
#dit la raison et deconnect       
       } elseif {[string match *ERROR* $1]} {
       putchan $chan "disconnected"
       putchan $chan "$1 SUCKER'S"
#si irc envoie un message derreurs, reply le (on veut savoir :])
    }
}


proc wingate_connect {sock pipehost pipeport chan} {
    puts $sock "$pipehost $pipeport \r\n"
    putchan $chan "$pipehost $pipeport"
    fileevent $sock writable {}
#fermeture du $sock en ecriture 
}
#procedure a effectuer lors d'un pipe utilisant un wingate

proc auth_sock {sock chan pipenick} {
    set pipeuser "user Data x x :Mom's_on_the_run" 
    set pipenick "nick $pipenick"
    puts $sock "$pipeuser \r\n"
    puts $sock "$pipenick \r\n"
    putchan $chan "sending: $pipeuser $pipenick"
    fileevent $sock writable {}    
}    
#connection a irc typique (largement expliquer un peu partout
#je mabstiendrais donc de commenter :]

proc ping_sock {sock 1 chan} {
    set pipepong [string trim $1 PING ]
    set pong "PONG $pipepong"
    putchan $chan "$pong"
    puts $sock "$pong \r\n"
    fileevent $sock writable {}
}    
#idem 

proc join_sock {sock chan pipechan} {
    putchan $chan "joigning $pipechan"
    puts $sock "JOIN $pipechan \r\n"    
    fileevent $sock writable {}
}
#procedure pour joigner le chan a spyer
#reutiliser si le chan est en +l     

putlog "pipe1.0 by Wyzeman laoded"
#greet a moi meme


---------------------lazy uncut here-----------------------



en gros, les socket tcl sont plutot simple malgres que peu  utiliser  et 
peu doccumenter, je  crois  que  le  manque d'imagination et la lacheter 
sont les  2 principals facteur qui expliquerais se  phenomene.  J'ai  en  
tete  quelque  alternative  a ce code, que je vous ferez p-e par dans un 
article ulterieur de  Mindkind. J'ai ecris cette article afin de prouver 
que ce  la  limite  n'est  pas  nos  connaissance mais bien notre propre 
imagination.  Meme  avec  un  eggdrop  et  du  TCL on peu faire des truc 
interressant.




                                                                 Wyzeman

.-----------------------------------------------------------------------.