Les poupées linkeuses

Soyez le premier à donner votre avis sur cette source.

Vue 8 503 fois - Téléchargée 466 fois

Description

vous êtes root sur un serveur IRC, et vous vous lamentez de ne pas avoir de visite, ou que vos visiteurs s'esquivent trop rapidement par manque de monde. Vous pouvez, à l'aide du script, mirroriser des chans complets issus d'autres serveurs (tels que ceux du réseau undernet), ce qui donnera l'impression à vos visiteurs que votre serveur est fortement fréquenté.

Source / Exemple :


 
##################################################################
#      MUPPET SHOW- PAR Averell ET NiCkOoS                       #
#      Version 1.16                                              #
#                                                                #
#      Je dédie ce script à mon vieux pote DJ-Philo, à l'origine #
#      de l'appellation "poupées" qui, peut-être, joue encore    #
#      avec ses pigeons, son fer à souder et ses scripts mirc    #
#      au paradis, s'il a le bonheur d'y avoir une connexion     #
#      internet...                                               #
#                                                                #
#      Configurer le fichier (jusqu'à la ligne de fin)           #
#      Lancer depuis un shell par nohup tclsh muppets.tcl &      #
#                                                                #
#      Amusez-vous bien !                                        #
##################################################################

namespace eval proxy {
    # Serveur espionné: il s'agit du serveur qui devra être répliqué
    
    #Realname de la poupée espion
    variable realname "Kermit la Grenouille"
    
    # Ip ou dns du serveur où connecter le bot
    variable ip "Diemen.NL.EU.Undernet.Org"
    
    # Port de connection
    variable port "7000"
    
    # Pseudo du bot
    variable pseudo "KermitFrog"
    # Ident du bot
    variable ident "Frog"
    
    # Le salon où se produit l'opération
    variable salon "#France"
    
    
    # Who a la connection ?
    # 1 = oui    0 = non
    variable who "1"
    
    # Chat = 1 on parle, Chat = 0 on ne parle pas (aux muppets)
    variable chat "1"
	
	# Les chans de la liste "reels" apparaîtront avec le nom correspondant de la liste "virtuels"
	variable reels {#France}
	variable virtuels {#Accueil}
}

namespace eval poupee {
    
    # Serveur miroir (le vôtre...)
    
    # Description du serveur de poupées
    variable servername "Serveur de muppets"
    
    # Nom du link (mettre le bloc de link correspondant, genre link serveur.de.muppets ( blah ... )
    variable link "serveur.de.muppets"
    
    # Mot de passe de connection (mettre le bon mot de passe)
    variable pass "openaccess"
    
    # Ip ou dns du serveur où connecter le bot (mon serveur)
    variable ip "irc.votre-serveur.fr"
    
    # Port de connection (mettre le port de link correspondant)
    variable port "6667"
    
    # Realname des poupées anonymes sur chan (n'est jamais dévoilé sur le serveur espionné)
    variable realname "Un nouveau muppet..."
    variable ident "Muppet"
    variable host "Anonymous.Muppet"
    
    # Nom du service
    variable nameserv "dollyserv"
    variable identserv "service"
    variable hostserv "localhost.net"
    variable realnameserv "Service de gestion des poupées"
    
	
	# Commandes pour faire agir un bot
    variable saymsg "say"
	variable actmsg "act"
	variable notcmsg "notice"
	variable modemsg "mode"
	variable kickmsg "kick"
	
    # Commande pour quitter tout et stopper le process
    variable diemsg "die"
    
    #Commande pour rafraîchir le chan (en cas de modification coté serveur miroir)
    variable resetmsg "reset"
    
    #Commande pour changer de chan principal
    variable setchanmsg "setchan"
    
    #Commande pour joindre le chan principal
    variable joinmsg "join"
    
    #Commande pour partir d'un chan (par exemple: /msg Fozzy leave #channel)
    variable leavemsg "leave"
    
    #Commande pour forcer une commande irc (genre /msg Fozzy raw mode #chan +o untel)
    variable rawmsg "raw"
    
    # Qui suis-je (qui est l'owner du bot)?
    variable me "Tom"
    
    # Flood (3:5 signifie: 3 joins en moins de 5 secondes)
    variable flood "3:5"
    
	# Permettre ou non le changement de topic
	variable changetopic "1"
	
	# pour censurer les liens serveur et http, mettre "<censuré>" dans la variable, ou tout ce que vous voulez en remplacement	
	variable censure ""	
	variable MotsCensures {putain bite couille}
	
    # Divers messages configurables
    
    variable LIGNE_1 "Attention!! %pseudo s'est déconnecté!"
    variable LIGNE_2 "Le salon %salon n'existe pas!!"
    variable LIGNE_3 "net.com split.com"
    variable LIGNE_4 "L'espion %pseudo a été kické!"
    variable LIGNE_5 "C'est bon, je quitte!"
    variable LIGNE_6 "Reset total envoyé !"
    variable LIGNE_7 "OK, nouveau salon: %salon"
    variable LIGNE_8 "Non c'est pas bon!"
    variable LIGNE_9 "OK, j'ai joint %salon"
    variable LIGNE_10 "Non je ne peux pas partir du salon principal!"
    variable LIGNE_11 "OK, je suis parti de %salon"
    variable LIGNE_12 "Non c'est pas bon!"
    variable LIGNE_13 "Parti du channel!"
    variable LIGNE_14 "Parti!"
    variable LIGNE_15 "Bye everybody!"
    variable LIGNE_16 "Commande %commande exécutée!"
    variable LIGNE_17 "Pardon?"
    variable LIGNE_18 "Le pseudo %pseudo est déja pris. Choisissez-en un autre"
    variable LIGNE_19 "Le channel %salon est plein!"
    variable LIGNE_20 "Le channel %salon est en +i (invite only)!"
    variable LIGNE_21 "Votre robot est banni du channel %salon !"
    variable LIGNE_22 "Le channel %salon est protégé par une clé!"
	
    variable debug "0"
}

######### FIN DE LA PARTIE CONFIGURABLE - A PARTIR D'ICI, DEFENSE DE RIEN TOUCHER :)  ###########

set ::poupee(protocol) "unreal32"

##### CENSURE ##########

proc cs { L R } {
if { $R == "" } { return $L }

set liste ""

foreach e $L {
regsub -all {http:\/\/\S+} $e $R e
regsub -all {([a-zA-Z0-9-]{2,}\.){2,}\S{2,}} $e $R e
 foreach mot $poupee::MotsCensures {
  regsub -all -nocase -- $mot $e $R e
  }
lappend liste $e
}
return $liste
}

##### DEBUG ###########

proc print { arg } {
    if {$poupee::debug == "1"} { puts "[clock format [clock seconds] -format {[%H:%M:%S]}] [join $arg]" }
}

##### FONCTIONS DE GESTION DES FLAGS ###########

proc acces { lname } {
    if { $lname == "" } { return "" }
    return [lindex $lname 0]
}

proc pondere { signe } {
    if { $signe == "" } { return 0 }
    return [expr [string map { + 1 % 2 @ 3 & 4 ~ 5 } $signe]]
}

proc insere { lname signe } {
    upvar 1 $lname liste
    
    set liste2 ""
    
    for {set i 0} { $i < [llength $liste] } { incr i } {
        if { [pondere [lindex $liste $i]] > [pondere $signe] } {  lappend liste2 [lindex $liste $i] } else { break }
    }
    
    if { $liste == "" } { lappend liste2 $signe } elseif { [lindex $liste $i] != $signe } { lappend liste2 $signe }
    
    for { } { $i < [llength $liste] } { incr i } {
        lappend liste2 [lindex $liste $i]
    }
    
    set liste $liste2
}

proc enleve { lname signe } {
    upvar 1 $lname liste
    
    set liste2 ""
    
    for {set i 0} { $i < [llength $liste]} { incr i } {
        if { [lindex $liste $i] != $signe } {  lappend liste2 [lindex $liste $i] }
    }
    
    set liste $liste2
}

##### LDELETE ###########

proc ldelete {lname start {stop ""}} \
        {
            upvar 1 $lname _list
            if {$stop == ""} { set stop $start }
            set rc [catch \
            {
                if {$start < 0} { set start 0 }
                if {$stop < $start} { set stop $start }
                set _list [lreplace $_list $start $stop]
            } result]
            return -code $rc $result
        }

##### SYSTEME ANTIFLOOD ##########

proc poupee::floodinit { } {
    global floodnum floodtime tabflood
    
    set floodnum [lindex [split $poupee::flood :] 0]
    set floodtime [lindex [split $poupee::flood :] 1]
    set i [expr $floodnum - 1]
    while {$i >= 0} {
        set tabflood($i) 0
        incr i -1
    }
}

proc poupee::flood { } {
    global floodnum floodtime tabflood
    
    # global botnick
    if {$floodnum == 0} {
        return 0
    }
    set i [expr $floodnum - 1]
    while {$i >= 1} {
        set tabflood($i) $tabflood([expr $i - 1])
        incr i -1
    }
    set tabflood(0) [clock seconds]
    if {[expr [clock seconds] - $tabflood([expr $floodnum - 1])] <= $floodtime} {
        return "flood"
    } {
        return ""
    }
}

###################### VIRTUALISATION DE CHAN ###############################

proc rvv { reel } {
# de réel vers virtuel
if {[llength $proxy::reels] != [llength $proxy::virtuels]} { print "Les tailles des listes sont différentes!"; return $reel }
for {set i 0} {$i < [llength $proxy::reels]} {incr i} {
 if {[string compare -nocase $reel [lindex $proxy::reels $i]] == 0} { return [lindex $proxy::virtuels $i]}
 }
 return $reel
}

proc vvr { virtuel } {
# de virtuel vers réel
if {[llength $proxy::reels] != [llength $proxy::virtuels]} { print "Les tailles des listes sont différentes!"; return $virtuel }
for {set i 0} {$i < [llength $proxy::reels]} {incr i} {
 if {[string compare -nocase $virtuel [lindex $proxy::virtuels $i]] == 0} { return [lindex $proxy::reels $i]}
 }
 return $virtuel
}

######################################

proc poupee::run { name } {
    if {$name == "proxy"} {
        puts $::socket(proxy) "USER $proxy::ident 0 $proxy::ip :$proxy::realname"
        puts $::socket(proxy) "NICK $proxy::pseudo"
    } elseif {$name == "poupee"} {
        puts $::socket(poupee) "PASS :$poupee::pass"
        puts $::socket(poupee) "SERVER $poupee::link 1 :$poupee::servername"
    }
}

proc event {name s} {
    global quitter
    
    gets $s data
    if { [eof $s] } {
        print "ERROR: End Of File "
        set quitter 1
        regsub %pseudo $poupee::LIGNE_1 $proxy::pseudo LIGNE_1b
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_1b"
        exit
    }
    set arg [split $data]
    
    #Debug
    #	puts "$name : $arg"
    if { $name == "poupee" } {
        poupee::event $arg
    } elseif { $name == "proxy" } {
        proxy::event $arg
    }
}


proc openSocket {ip port name} {
    if { [catch {socket $ip $port} ::socket($name)] } {
        puts "erreur $name : $::socket($name)"
        exit
    } else {
        puts "Info $name : Connecté sur $ip:$port"
    }
    
    fconfigure $::socket($name) -buffering line
    fileevent $::socket($name) readable [list event $name $::socket($name)]
    
    poupee::run $name
}

proc poupee::autoconnect { } {
    if {[info exists ::socket(poupee)]} { after 15000 poupee::autoconnect } else { openSocket $poupee::ip $poupee::port poupee }
    if {[info exists ::socket(proxy)]} { after 15000 poupee::autoconnect } else { openSocket $proxy::ip $proxy::port proxy }
}

poupee::floodinit
if {![info exists ::socket(poupee)]} { poupee::autoconnect }
if {![info exists ::socket(proxy)]} { poupee::autoconnect }

set salons ""

proc poupee::trouve {lui} {
    global salons users signes
    
    set liste ""
    foreach s $salons {
        set i [lsearch -exact $users($s) $lui]
        if { $i > -1 } { lappend liste [list [lindex $signes($s) $i] $s] }
    }
    return $liste
}

proc poupee::replaceall {lui parlui } {
    global salons users miroir comchan
    
    foreach s $salons {
        set i [lsearch -exact $users($s) $lui]
        if { $i < 0 } { continue }
        set users($s) [lreplace $users($s) $i $i $parlui]
        set j [lsearch -exact $miroir($s) $lui]
        if { $j < 0 } { continue }
        set miroir($s) [lreplace $miroir($s) $j $j $parlui]
    }    
    set comchan($parlui) $comchan($lui)
	unset comchan($lui)
}

proc poupee::event { arg } {
    set type [lindex $arg 0]
    set type2 [lindex $arg 1]
    set type3 [lindex $arg 2]
    
    switch -exact $type {
        "PING" { puts $::socket(poupee) "PONG [lindex $arg 1]" }
    }
    switch -exact $type2 {
        "KICK" {
            
            set user [string trim [lindex $arg 0] :]
            set chan [string trim [lindex $arg 2] :]
            set cible [lindex $arg 3]
            set msg [lrange $arg 4 end]
            
            poupee::kicklocal $chan $cible
        }
    }
    if {([string compare -nocase $type3 $poupee::nameserv] == 0 || [string compare -nocase $type3 $proxy::pseudo] == 0) && [string compare -nocase [lindex [split [string trim $type :] "!"] 0] $poupee::me] == 0} {
        switch -exact $type2 {
            "PRIVMSG" { poupee::commande [lindex [split [string trim [lindex $arg 0] :] "!"] 0] [lrange $arg 3 end] }
        }
    }	elseif {[string compare -nocase [string trim $type :] $poupee::me] == 0 && $proxy::chat == "1"} {
        switch -exact $type2 {
            "PRIVMSG" { puts $::socket(proxy) "PRIVMSG [vvr $type3] [join [lrange $arg 3 end]]" }
            "NOTICE" { puts $::socket(proxy) "NOTICE [vvr $type3] [join [lrange $arg 3 end]]" }
        }
    }
}

proc poupee::classer { chan } {
    global users signes channel
    
    set users($chan) ""
    set signes($chan) ""
    
    foreach user $channel($chan) {
        if [regexp {^(@|%|\+|&|~)?(.+)} $user toto signe mec] {
            lappend users($chan) $mec
			if { $signe == "&" || $signe == "~" } { lappend signe "@" }
            lappend signes($chan) $signe
        }
    }
    print "USERS: $users($chan)"
    print "SIGNES: $signes($chan)"
    
    set channel($chan) ""
}

proc poupee::creer { arg salon realname force } {
    global users signes miroir salons comchan
    
    # force = 1: on force le join, force = 0, on ne force pas, et force = -1 : il s'agit d'un ircop (chanserv...)
    
    set nick_idhost [split $arg "!"]
    set user [lindex $nick_idhost 0]
    set idhost [lindex $nick_idhost 1]
    set ident [lindex [split $idhost "@"] 0]
    set host [lindex [split $idhost "@"] 1]
    if {$ident == ""} { return }
    if ![info exists comchan($user)] { poupee::connect $user $ident $host $realname
        set comchan($user) ""
    }
    
    if ![regexp {^#} $salon] { 	 return	}
    
    if [info exists users([string toupper $salon])] {
        set i [lsearch -exact $users([string toupper $salon]) $user]
        if { $i < 0 && $force == 1 } { lappend users([string toupper $salon]) $user; lappend signes([string toupper $salon]) "" }
        set j [lsearch -exact $miroir([string toupper $salon]) $user]
        if { $j < 0 } {
            if { $force == 1 || $force < 1 && $i >= 0 } { lappend miroir([string toupper $salon]) $user
               if { [lsearch -exact $comchan($user) [string toupper $salon]] < 0 } { lappend comchan($user) [string toupper $salon] }
                puts $::socket(poupee) ":$user JOIN $salon"
                set signe [acces [lindex $signes([string toupper $salon]) $i]]
                
                switch -exact $signe {
                    "@" { puts $::socket(poupee) ":$poupee::link MODE $salon +o $user" }
                    "%" { puts $::socket(poupee) ":$poupee::link MODE $salon +h $user" }
                    "+" { puts $::socket(poupee) ":$poupee::link MODE $salon +v $user" }
                    "&" { puts $::socket(poupee) ":$poupee::link MODE $salon +oa $user $user" }
                    "~" { puts $::socket(poupee) ":$poupee::link MODE $salon +oq $user $user" }
                }
                
            }  elseif { $force < 0 } { puts $::socket(poupee) ":$user MODE $user +o"; print "ircop depuis creer" }
        }
        # de $j < 0 (le salon miroir ne contient pas le pseudo)
    } elseif { [string compare -nocase $user $proxy::pseudo] == 0 } {
        # Le salon n'existe pas, il est créé par l'espion
        set users([string toupper $salon]) $user
        set miroir([string toupper $salon]) $user
        if { [lsearch -exact $salons [string toupper $salon]] < 0 } { lappend salons [string toupper $salon] }
        if { [lsearch -exact $comchan($user) [string toupper $salon]] < 0 } { lappend comchan($user) [string toupper $salon] }
        # Le set comchan c'est pour l'espion!
        puts $::socket(poupee) ":$user JOIN $salon"
    }
}

proc poupee::virer { user salon } {
    global users signes miroir salons
    
    if {$salon != ""} { set liste [list [string toupper $salon]] } else { set liste $salons }
    foreach s $liste {
        set i [lsearch -exact $users($s) $user]
        if { $i < 0 } { continue }
        ldelete users($s) $i
        ldelete signes($s) $i
        set j [lsearch -exact $miroir($s) $user]
        if { $j < 0 } { continue }
        ldelete miroir($s) $j
    }
}

proc poupee::megasplit { } {
    global miroir salons
    
    foreach salon $salons {
        foreach user $miroir($salon) {
            poupee::quit $user ":$poupee::LIGNE_3"
        }
    }
}

proc poupee::masspart { salon } {
    global miroir salons
    
    set salonmaj [string toupper $salon]
    if { [lsearch -exact $salons $salonmaj] < 0 } {
        regsub %salon $poupee::LIGNE_2 $salon LIGNE_2b
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_2b"
        return
    }
    foreach user $miroir($salonmaj) {
        if { [string compare -nocase $user $proxy::pseudo] != 0 } { poupee::part $user $salon ":$poupee::LIGNE_13" }
    }
}

proc poupee::changemode {modes liste} {
    set resu ""
    set para 0
    for {set i 0} {$i < [string length $modes]} {incr i} {
        set c [string range $modes $i $i]
        if {$c == "-" || $c == "+"} { set signe $c
        }  else {
            set modecomp "$signe$c"
            
            set x 0
            
            switch -exact -- $modecomp {
                "+o" { set x 2 }
                "-o" { set x 2 }
                "+v" { set x 2 }
                "-v" { set x 2 }
                "+h" { set x 2 }
                "-h" { set x 2 }
                "+q" { set x 2 }
                "-q" { set x 2 }
                "+a" { set x 2 }
                "-a" { set x 2 }
                "+b" { set x 1 }
                "-b" { set x 1 }
                "+e" { set x 1 }
                "-e" { set x 1 }
                "+I" { set x 1 }
                "-I" { set x 1 }
                "+k" { set x 1 }
                "+l" { set x 1 }
                "+f" { set x 1 }
                "+L" { set x 1 }
                "+j" { set x 1 }
            }
            
            if {$x == 2} { lappend resu [list $modecomp [lindex $liste $para] pseudo]
                incr para    } elseif {$x == 1} { lappend resu [list $modecomp [lindex $liste $para]]
                incr para    } else { lappend resu $modecomp }
            
        }
    }
    
    return $resu
}

proc proxy::event { arg } {
    global channel fini signes users topic quitter
    
    set type [lindex $arg 0]
    set type2 [lindex $arg 1]
    
    switch -exact $type {
        "PING" { puts $::socket(proxy) "PONG [lindex $arg 1]" }
        "ERROR" { puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :[join $arg]" }
    }
    switch -exact $type2 {
        "332" { 	set topic([lindex $arg 3]) [lrange $arg 4 end] }
        # Topic
        
        "333" { 	if {$poupee::changetopic == "1"} { puts $::socket(poupee) "TOPIC [rvv [lindex $arg 3]] [lindex $arg 4] [lindex $arg 5] [join $topic([lindex $arg 3])]" } }
        # Qui a fait le topic et quand
        
        "352" {
            set user [lindex $arg 7]
            set ident [lindex $arg 4]
            set host [lindex $arg 5]
            set realname [join [lrange $arg 10 end]]
            
            poupee::creer "$user!$ident@$host" [rvv $proxy::salon] $realname	1
            if [regexp {\*} [lindex $arg 8]] { puts $::socket(poupee) ":$user MODE $user +o"; print "ircop depuis 332" }
            # Who
            
        }
        "353" {
            regexp {^\S+ \d+ \S+ \S (\S+) :(.+)$} [join $arg] toto chan liste
            # print "chan ET $arg"
            set chan [string toupper [rvv $chan]]
            if { $fini($chan) == 0 } { set channel($chan) [concat $channel($chan) [split $liste]]
            } else { set channel($chan) [split $liste]; set fini($chan) 0 }
            # /NAMES
            
        }
        "366" {
            regexp {^\S+ \d+ \S+ (\S+)} [join $arg] toto chan
            set chan [string toupper [rvv $chan]]
            set fini($chan) 1
            poupee::classer $chan
            if {$proxy::who == "1"} { puts $::socket(proxy) "WHO $proxy::salon" }
            # Fin de /NAMES
            
        }
        "376" {		poupee::demarrage	}
        "422" {		poupee::demarrage	}
        # Le dernier raw de MOTD
		
        "433" {		
		    regsub %pseudo $poupee::LIGNE_18 $proxy::pseudo LIGNE_18b
			puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_18b"
            print $LIGNE_18b 
			set quitter 1
		# Nickname already in use	
		
			}
        "471" {		
		    regsub %salon $poupee::LIGNE_19 $proxy::salon LIGNE_19b
			puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_19b"
            print $LIGNE_19b 
			set quitter 1
		# channel plein	
		
			}	
	    "473" {		
		    regsub %salon $poupee::LIGNE_20 $proxy::salon LIGNE_20b
			puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_20b"
            print $LIGNE_20b 
			set quitter 1
		# channel invite only
		
			}	
	    "474" {		
		    regsub %salon $poupee::LIGNE_21 $proxy::salon LIGNE_21b
			puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_21b"
            print $LIGNE_21b 
			set quitter 1
		# vous êtes banni
		
			}	
		"475" {		
		    regsub %salon $poupee::LIGNE_22 $proxy::pseudo LIGNE_22b
            puts $::socket(poupee) ":$poupee::nameserv NOTICE $proxy::salon :$LIGNE_22b"	
            print $LIGNE_22b 
			set quitter 1
		# needs correct key
		
			}
        "JOIN" {
            print $arg
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [string trim [lindex $arg 2] :]]
            set fini([string toupper $chan]) 1
            
            if {[string compare -nocase $chan [rvv $proxy::salon]] == 0 && $proxy::who == "1" && $user != $proxy::pseudo && [poupee::flood] == ""} { puts $::socket(proxy) "WHO $user"
            } else { poupee::creer [string trim [lindex $arg 0] :] $chan $poupee::realname 1 }
            
        }
        "PRIVMSG" {
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [lindex $arg 2]]
            set cmd [lrange $arg 3 end]
            
            if {$chan != $proxy::pseudo} {
                poupee::creer [string trim [lindex $arg 0] :] $chan $poupee::realname 0
                puts $::socket(poupee) ":$user PRIVMSG $chan [join [cs $cmd $poupee::censure]]"
            } 	  else { puts $::socket(poupee) ":$user PRIVMSG $poupee::me [join [cs $cmd $poupee::censure]]" }
        }
        "TOPIC" {
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [lindex $arg 2]]
            print $arg
            poupee::creer [string trim [lindex $arg 0] :] $chan $poupee::realname -1
            # Le topic peut être mis par une personne non ircop extérieure au chan si le mode +t n'est pas mis.
            # Mais c'est souvent chanserv qui le fait, d'où le -1
            
            if {$poupee::changetopic == "1"} { puts $::socket(poupee) ":$user TOPIC $chan [join [cs [lrange $arg 3 end] $poupee::censure]]" }
            
        }
        "NOTICE" {
            
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [lindex $arg 2]]
            set cmd [lrange $arg 3 end]
            if ![regexp {\.} $user] {
                if {$chan != $proxy::pseudo} {
                    poupee::creer [string trim [lindex $arg 0] :] $chan $poupee::realname 0
                    puts $::socket(poupee) ":$user NOTICE $chan [join [cs $cmd $poupee::censure]]"
                } else {
                    poupee::creer [string trim [lindex $arg 0] :] [rvv $proxy::salon] $poupee::realname 0
                    puts $::socket(poupee) ":$user NOTICE $poupee::me [join [cs $cmd $poupee::censure]]" }
            }
        }
        "MODE" {
            
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [string trim [lindex $arg 2] :]]
            print $arg
            if [regexp {^#} $chan] {
                poupee::creer [string trim [lindex $arg 0] :] $chan $poupee::realname -1
                # Seul un ircop peut changer le mode si extérieur au chan
                
                set cibles [poupee::changemode [lindex $arg 3] [lrange $arg 4 end]]
                
                if [regexp {\.} $user] { set user $poupee::link }
                set sedeoppe 0
                foreach cible $cibles {
                    if { [lindex $cible 2] == "pseudo" } { poupee::creer "[lindex $cible 1]!$poupee::ident@$poupee::host" $chan $poupee::realname 1 }
                    if {[string compare -nocase $user [lindex $cible 1]] == 0 && [lindex $cible 0] == "-o"} { set sedeoppe 1
                    } else {
                        if {$user != $poupee::link} {
                            set i [lsearch -exact $users([string toupper $chan]) $user]
                            if { $i > -1 } {
                                set signe [acces [lindex $signes([string toupper $chan]) $i]]
                                if { $signe == "" || $signe == "+" } { puts $::socket(poupee) ":$user MODE $user +o"; print "ircop depuis mode" }
                            }
                        }
                        # Seul un ircop peut changer les modes s'il n'a pas le flag approprié
                        
                        poupee::mode $user [lindex $cible 0] $chan [lindex $cible 1] [lindex $cible 2] }
                }
                if {$sedeoppe == 1} { poupee::mode $user "-o" $chan $user pseudo }
            }
        }
        "PART" {
            print $arg
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [string trim [lindex $arg 2] :]]
            set msg [lrange $arg 3 end]
            
            poupee::part $user $chan [cs $msg $poupee::censure]
            
        }
        "KICK" {
            print $arg
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set chan [rvv [string trim [lindex $arg 2] :]]
            set cible [lindex $arg 3]
            set msg [lrange $arg 4 end]
            
            poupee::creer [string trim [lindex $arg 0] :] $chan $poupee::realname -1
            # Seul un ircop peut kicker si extérieur au chan
            
            set i [lsearch -exact $users([string toupper $chan]) $user]
            if { $i > -1 } {
                set signe [acces [lindex $signes([string toupper $chan]) $i]]
                if { $signe == "" || $signe == "+" } { puts $::socket(poupee) ":$user MODE $user +o"; print "ircop depuis kick" }
            }
            # Seul un ircop peut kicker s'il n'a pas les flags appropriés
            
            poupee::kick $user $chan $cible [cs $msg $poupee::censure]
            
            if { $cible == $proxy::pseudo } {
                regsub %pseudo $poupee::LIGNE_4 $proxy::pseudo LIGNE_4b
                puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_4b"
                poupee::megasplit
                puts $::socket(proxy) "JOIN [vvr $chan]"
            }
        }
        "NICK" {
            print $arg
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set newnick [string trim [lindex $arg 2] :]
            if {[poupee::trouve $user] == ""} { poupee::creer [string trim [lindex $arg 0] :] [rvv $proxy::salon] $poupee::realname 1 }
            # Le changement de nick n'a pas lieu sur un chan particulier. Pb si changement de pseudo au moment du join (latence du /who)
            
            puts $::socket(poupee) ":$user NICK $newnick"
            poupee::replaceall $user $newnick
        }
        "QUIT" {
            print $arg
            set user [lindex [split [string trim [lindex $arg 0] :] "!"] 0]
            set msg [lrange $arg 2 end]
            poupee::quit $user [cs $msg $poupee::censure]
        }
    }
}

proc poupee::connect { user ident host realname } {
    
    puts $::socket(poupee) "NICK $user 1 [clock seconds] $ident $host $poupee::link :$realname"
    puts $::socket(poupee) ":$user MODE $user +i"
}


proc poupee::commande { user cmd } {
    global quitter salons
    
	if { [string compare -nocase [lindex $cmd 0] ":$poupee::saymsg"] == 0 } {
        puts $::socket(poupee) ":[lindex $cmd 1] PRIVMSG [lindex $cmd 2] :[join [lrange $cmd 3 end]]"
		
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::actmsg"] == 0 } {
        puts $::socket(poupee) ":[lindex $cmd 1] PRIVMSG [lindex $cmd 2] :\001ACTION [join [lrange $cmd 3 end]]\001"
		
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::notcmsg"] == 0 } {
        puts $::socket(poupee) ":[lindex $cmd 1] NOTICE [lindex $cmd 2] :[join [lrange $cmd 3 end]]"
		
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::modemsg"] == 0 } {
        puts $::socket(poupee) ":[lindex $cmd 1] MODE [join [lrange $cmd 2 end]]"
		
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::kickmsg"] == 0 } {
        puts $::socket(poupee) ":[lindex $cmd 1] KICK [lindex $cmd 2] [lindex $cmd 3] :[join [lrange $cmd 4 end]]"
		
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::diemsg"] == 0 } {
	
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$poupee::LIGNE_5"
        puts $::socket(proxy) "QUIT :$poupee::LIGNE_15"
        
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::resetmsg"] == 0 } {
        
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$poupee::LIGNE_6"
        poupee::megasplit
        foreach s $salons {
            puts $::socket(proxy) "NAMES [vvr $s]"
        }
        puts $::socket(proxy) "WHO $proxy::salon"
        
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::setchanmsg"] == 0 } {
        if [regexp {^#} [lindex $cmd 1]] { set proxy::salon [vvr [lindex $cmd 1]]
            regsub %salon $poupee::LIGNE_7 $proxy::salon LIGNE_7b
            puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_7b"
        } else { puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$poupee::LIGNE_8" }
        
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::joinmsg"] == 0 } {
        if [regexp {^#} [lindex $cmd 1]] { set proxy::salon [vvr [lindex $cmd 1]]
        puts $::socket(proxy) "JOIN $proxy::salon"
        regsub %salon $poupee::LIGNE_9 $proxy::salon LIGNE_9b
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_9b"
        } else { puts $::socket(poupee) ":[lindex $cmd 1] JOIN [lindex $cmd 2]" }
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::leavemsg"] == 0 } {
        if [regexp {^#} [lindex $cmd 1]] {
            if { [string compare -nocase [vvr [lindex $cmd 1]] $proxy::salon] == 0 } {
                puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$poupee::LIGNE_10"
                return
            }
            puts $::socket(proxy) "PART [vvr [lindex $cmd 1]]"
            regsub %salon $poupee::LIGNE_11 [lindex $cmd 1] LIGNE_11b
            puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_11b"
            poupee::masspart [rvv [lindex $cmd 1]]
			# On force rvv mais normalement on n'a pas à le faire car il faut spécifier un chan virtuel
        } else { puts $::socket(poupee) ":[lindex $cmd 1] PART [lindex $cmd 2] :[join [lrange $cmd 3 end]]" }
    } elseif { [string compare -nocase [lindex $cmd 0] ":$poupee::rawmsg"] == 0 } {
        puts $::socket(proxy) "[join [lrange $cmd 1 end]]"
        regsub %commande $poupee::LIGNE_16 [lindex $cmd 1] LIGNE_16b
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$LIGNE_16b"
    } else {
        puts $::socket(poupee) ":$poupee::nameserv NOTICE $poupee::me :$poupee::LIGNE_17"	 }
}

proc poupee::part { user salon msg } {
global comchan

    poupee::virer $user [string toupper $salon]
    if [info exists comchan($user)] {
        if {$msg == ""} {	puts $::socket(poupee) ":$user PART $salon" } else {	puts $::socket(poupee) ":$user PART $salon [join $msg]" } 			
        if { [lsearch -exact $comchan($user) [string toupper $salon]] > -1 } { 
            enleve comchan($user) [string toupper $salon]
        } 
		if { $comchan($user) == "" } { poupee::quit $user ":$poupee::LIGNE_14" }
        
    }
}

proc poupee::quit { user msg } {
global comchan

    poupee::virer $user ""
    if [info exists comchan($user)] {
        puts $::socket(poupee) ":$user QUIT [join $msg]"
        unset comchan($user)
    }
}

proc poupee::mode { user mode salon cible pseudo } {
    global signes users
    
        if { $mode != "+i" && $mode != "+l" && $mode != "+k" } { puts $::socket(poupee) ":$user MODE $salon $mode $cible" }
	# Problème du chan bloqué (+ilk)
    
    if {$pseudo != ""} {
        set i [lsearch -exact $users([string toupper $salon]) $cible]
        set signe [lindex $signes([string toupper $salon]) $i]
        
        switch -exact -- $mode {
            "+o" { insere signe @ }
            "-o" { enleve signe @ }
            "+h" { insere signe % }
            "-h" { enleve signe % }
            "+v" { insere signe + }
            "-v" { enleve signe + }
            "+a" { insere signe & }
            "-a" { enleve signe & }
            "+q" { insere signe ~ }
            "-q" { enleve signe ~ }
        }
        set signes([string toupper $salon]) [lreplace $signes([string toupper $salon]) $i $i $signe]
    }
}

proc poupee::kick { user salon cible msg } {
global comchan

    poupee::virer $cible [string toupper $salon]
    if [info exists comchan($cible)] {
        puts $::socket(poupee) ":$user KICK $salon $cible [join $msg]"
        
        if { [lsearch -exact $comchan($cible) [string toupper $salon]] > -1 } { 
            enleve comchan($cible) [string toupper $salon]
        } 
		if { $comchan($cible) == "" } { poupee::quit $cible ":Kické!" }
    }
}

proc poupee::kicklocal { salon user } {
    global miroir comchan
	
    if [info exists comchan($user)] {
        
if {[lsearch -exact $comchan($user) [string toupper $salon]] < 0} { return }
        set j [lsearch -exact $miroir([string toupper $salon]) $user]
        if { $j > -1 } { ldelete miroir([string toupper $salon]) $j }
        
    }
}


proc poupee::demarrage {} {
    puts $::socket(proxy) "MODE $proxy::pseudo +iB"
    puts $::socket(proxy) "JOIN $proxy::salon"
    poupee::connect $poupee::nameserv $poupee::identserv $poupee::hostserv $poupee::realnameserv
    puts $::socket(poupee) ":$poupee::nameserv MODE $poupee::nameserv +iB"
}

set quitter 0
vwait quitter


Conclusion :


Comme beaucoup de scripts qui existent, l'utilité de celui-ci est toute relative, mais il peut rendre service pour celui ou celle qui souhaite se faire un nom dans le monde un peu désertifié qu'est celui de l'IRC.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

griffondorsonic
Messages postés
97
Date d'inscription
lundi 5 juillet 2010
Statut
Membre
Dernière intervention
21 mars 2012
2 -
un 10 pour une innovation réfléchis
snip74
Messages postés
248
Date d'inscription
vendredi 3 novembre 2006
Statut
Membre
Dernière intervention
11 février 2013
-
Bonjour,
super se script et fonctionne très bien :p.
Juste 3 petites question.

Sur mon server j'ai un salon accueil si j'espionne un autre salon par défaux (#quebec) comment faire que tout les users se retrouve sur le salon accueil au lieu de quebec ?

2eme question quand je coupe putty sa coupe le bot pourquoi ?

3eme Mes users peuve aussi dial avec les users link ?

Cordialement Stéphane
cs_Averell
Messages postés
48
Date d'inscription
mercredi 27 novembre 2002
Statut
Membre
Dernière intervention
9 juin 2016
-
Hello,

1re question: malheureusement le script ne prévoit pas de mirroriser sur un chan ayant un autre nom que le chan d'origine.... par contre, je l'avais fait sur l'addon "superpoupées".

2) Tu as dû oublier le signe & après la commande tclsh muppets.tcl & .

3) Une seule personne n'est capable de dialoguer avec les users link: par défaut, son pseudo est Tom, mais cela se configure (variable "me" dans le script)
snip74
Messages postés
248
Date d'inscription
vendredi 3 novembre 2006
Statut
Membre
Dernière intervention
11 février 2013
-
Bonsoir Averell,
Merci de cette réponse super rapide

2) Tu as dû oublier le signe & après la commande tclsh muppets.tcl & .

Non je les biens mis mais quand je ferme putty sa me coupe le link :/

1re question: malheureusement le script ne prévoit pas de mirroriser sur un chan ayant un autre nom que le chan d'origine.... par contre, je l'avais fait sur l'addon "superpoupées".

Le script et toujour dispo ?

Codialement Stéphane
snip74
Messages postés
248
Date d'inscription
vendredi 3 novembre 2006
Statut
Membre
Dernière intervention
11 février 2013
-
Re !!
Je reviens juste sur un petit truc cher moi quand je ferme puty sa coupe le bot par contre quand j'attends que la fenêtre puty le bot reste connecter si sa peut aidé d'autre personne ^^

Cordialement Stéphane

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.