TCL de modération - Version imprimable

tcl
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#
# ~ MODERATION.TCL || Cyber-TCL.com by Platine ~ #
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~#

###################################################
#                                                 #
#          DEBUT DE LA CONFIGURATION              #
#                                                 #
###################################################

 
#  MAJUSCULES :

 
#-> Expiration de la detection pour les majuscules (en seconde) ?
set expiration(majuscule) "180"

#-> Nombre de majuscule à détecter ?
set detect(majuscule) "10"

#-> Combien d'avertissement avant le kick ?
set avert(majuscule) "2"

#-> Message d'avertissement
set msg(majuscule) "Attention! Merci de ne pas ecrire en MAJUSCULE"

#-> Raison du kick
set kick(majuscule) "Pas la peine de crier on à compris!"

 
#  REPETITION :

 
#-> Expiration de la detection pour les repetitions (en seconde) ?
set expiration(repetition) "900"

#-> Nombre de repetition à détecter ?
set detect(repetition) "2"

#-> Combien d'avertissement avant le kick ?
set avert(repetition) "1"

#-> Message d'avertissement
set msg(repetition) "Attention! surveillez vos répétitions! La prochaine fois vous serez Expulsé!"

#-> Raison du kick
set kick(repetition) "Pas de repetition !"

 
#  LANGAGE :

 
#-> Expiration de la detection pour le langage (en seconde) ?
set expiration(mot) "300"

#-> Combien d'avertissement avant le kickban ?
set avert(mot) "1"

#-> Message d'avertissement
set msg(mot) "Attention! surveillez votre langage! La prochaine fois vous serez Expulsé !"

#-> Raison du kickban
set kick(mot) "Exclu 20 minutes !"

 
#  SPAM :

 
#-> Expiration de la detection pour le spam (en seconde) ?
set expiration(spam) "1800"

#-> Combien d'avertissement avant le kickban ?
set avert(spam) "1"

#-> Message d'avertissement
set msg(spam) "Attention! Evitez vos Publicités! La prochaine fois vous serez Expulsé!"

#-> Raison du kickban
set kick(spam) "Exclu pour pub !"

 
#  NICK :

 
#-> Raison du kickban
set kick(nick) "Veuillez modifier votre pseudo ou celui que vous venez de prendre !"

 
#  NOTICECHAN :

 
#-> Raison du kickban
set kick(notice) "Veuillez ne pas faire de notice chan !"

 
#  BLACKLIST :

 
#-> Raison du kickban
set kick(blacklist) "Vous n'êtes pas le bienvenue sur ce salon !"

 
#  LIMITE :

#-> Activer la limite ? (0=non 1=oui)
set limite(active) "1"

 
#-> Puissance de la limite
set limite(puissance) "2"

 
#-> Temp de rehash pour la limite
set limite(temp) "120"

 
#  ANTI/MASSFLOOD :

 
#-> Nombre de message lors d'une détection mass/flood
set mass(flood) "6"

#-> Temp de rehash pour la remise à 0 du mass/flood (en seconde)
set mass(rehashflood) "2"

#-> Temp pour le retrait du +m (en minute)
set mass(retraitm) "2"

 
#  ANTI/MASSJOIN :

 
#-> Nombre de join lors d'une détection mass/join
set mass(join) "5"

#-> Temp de rehash pour la remise à 0 du mass/join (en seconde)
set mass(rehashjoin) "3"

#-> Temp pour le retrait du +i (en minute)
set mass(retraiti) "2"

 
###################################################
#                                                 #
#              FIN DE CONFIGURATION               #
#                                                 #
###################################################

############
# VARIABLE #
############
 
set fichier(modchan) "modchan.txt"
set fichier(modmot) "modmot.txt"
set fichier(modspam) "modspam.txt"
set fichier(modnick) "modnick.txt"
set fichier(blacklist) "blacklist.txt"
set fichier(protect) "protect.txt"

###########
# FICHIER #
###########
 
set fichiers [list $::fichier(modchan) $::fichier(modmot) $::fichier(modspam) $::fichier(modnick) $::fichier(blacklist) $::fichier(protect)]
foreach txt $fichiers {
     if ![file exists $txt] {
         close [open $txt w+]
     }
}

#Enregistrement des chan à modérer :
 
bind dcc n +modchan +modchan
bind dcc n -modchan -modchan
bind dcc n modchan modchan
 
 
proc +modchan {hand idx arg} {
set chan [lindex $arg 0]
if {$chan eq ""||[string index $chan 0] ne "#"} {putdcc $idx "\002Erreur :\002 .+modchan <#chan>"; return}
if {[verify:b $::fichier(modchan) $chan]} {putdcc $idx "\002Erreur :\002 $chan est déjà modérer.";return}
putdcc $idx "\002+modchan :\002 $chan a été mis dans la liste."
ajouter:donnee $::fichier(modchan) $chan
}
 
proc -modchan {hand idx arg} {
set chan [lindex $arg 0]
if {$chan eq ""||[string index $chan 0] ne "#"} {putdcc $idx "\002Erreur :\002 .-modchan <#chan>"; return}
if {![verify:b $::fichier(modchan) $chan]} {putdcc $idx "\002Erreur :\002 Le chan $chan n'est pas modérer.";return}
putdcc $idx "\002-modchan :\002 $chan n'est plus modérer."
effacer:donnee $::fichier(modchan) $chan
}
 
proc modchan {hand idx arg} {
putdcc $idx "---\002 LISTE DES CHANS MODÉRER \002---";
liste:donnee $idx $::fichier(modchan)
}

#Enregistrement des mots interdit à modérer :
 
bind dcc n +modmot +modmot
bind dcc n -modmot -modmot
bind dcc n modmot modmot
 
proc +modmot {hand idx arg} {
set mot [lindex $arg 0]
if {$mot eq ""} {putdcc $idx "\002Erreur :\002 .+modmot <mot>"; return}
if {[verify:b $::fichier(modmot) $mot]} {putdcc $idx "\002Erreur :\002 $mot est déjà enregistré.";return}
putdcc $idx "\002+modmot :\002 $mot a été mis dans la liste."
ajouter:donnee $::fichier(modmot) $mot
}
 
proc -modmot {hand idx arg} {
set mot [lindex $arg 0]
if {$mot eq ""} {putdcc $idx "\002Erreur :\002 .-modmot <mot>"; return}
if {![verify:b $::fichier(modmot) $mot]} {putdcc $idx "\002Erreur :\002 Le mot $mot n'est pas enregistré.";return}
putdcc $idx "\002-modmot :\002 $mot n'est plus enregistré."
effacer:donnee $::fichier(modmot) $mot
}
 
proc modmot {hand idx arg} {
putdcc $idx "---\002 LISTE DES MOTS INTERDIT \002---";
liste:donnee $idx $::fichier(modmot)
}

#Enregistrement des spams à modérer :
 
bind dcc n +modspam +modspam
bind dcc n -modspam -modspam
bind dcc n modspam modspam
 
proc +modspam {hand idx arg} {
set spam [lindex $arg 0]
if {$spam eq ""} {putdcc $idx "\002Erreur :\002 .+modspam <spam>";putdcc $idx "\002Exemple :\002 .+modspam *.*.com*"; return}
if {[verify:b $::fichier(modspam) $spam]} {putdcc $idx "\002Erreur :\002 $spam est déjà enregistré.";return}
putdcc $idx "\002+modspam :\002 $spam a été mis dans la liste."
ajouter:donnee $::fichier(modspam) $spam
}
 
proc -modspam {hand idx arg} {
set spam [lindex $arg 0]
if {$spam eq ""} {putdcc $idx "\002Erreur :\002 .-modspam <spam>"; return}
if {![verify:b $::fichier(modspam) $spam]} {putdcc $idx "\002Erreur :\002 Le spam $spam n'est pas enregistré.";return }
putdcc $idx "\002-modspam :\002 $spam n'est plus enregistré."
effacer:donnee $::fichier(modspam) $spam
}
 
proc modspam {hand idx arg} {
putdcc $idx "---\002 LISTE DES SPAMS \002---";
liste:donnee $idx $::fichier(modspam)
}

#Enregistrement des nicks à modérer :
 
bind dcc n +modnick +modnick
bind dcc n -modnick -modnick
bind dcc n modnick dcc:modnick
 
proc +modnick {hand idx arg} {
set nick [lindex $arg 0]
if {$nick eq ""} {putdcc $idx "\002Erreur :\002 .+modnick <nick>";putdcc $idx "\002Exemple :\002 .+modnick *.*.com*"; return}
if {[verify:b $::fichier(modnick) $nick]} {putdcc $idx "\002Erreur :\002 $nick est déjà enregistré.";return}
putdcc $idx "\002+modnick :\002 $nick a été mis dans la liste."
ajouter:donnee $::fichier(modnick) $nick
}
 
proc -modnick {hand idx arg} {
set nick [lindex $arg 0]
if {$nick eq ""} {putdcc $idx "\002Erreur :\002 .-modnick <nick>"; return}
if {![verify:b $::fichier(modnick) $nick]} {putdcc $idx "\002Erreur :\002 Le nick $nick n'est pas enregistré.";return }
putdcc $idx "\002-modnick :\002 $nick n'est plus enregistré."
effacer:donnee $::fichier(modnick) $nick
}
 
proc dcc:modnick {hand idx arg} {
putdcc $idx "---\002 LISTE DES NICKS \002---";
liste:donnee $idx $::fichier(modnick)
}

#Enregistrement des blacklists modérer :
 
bind dcc n +blacklist +blacklist
bind dcc n -blacklist -blacklist
bind dcc n blacklist dcc:blacklist
 
proc +blacklist {hand idx arg} {
set host [lindex $arg 0]
if {$host eq ""} {putdcc $idx "\002Erreur :\002 .+blacklist <host>";putdcc $idx "\002Exemple :\002 .+blacklist toto*!*@*.ru"; return}
if {[verify:b $::fichier(blacklist) $host]} {putdcc $idx "\002Erreur :\002 $host est déjà enregistré.";return}
putdcc $idx "\002+blacklist :\002 $host a été mis dans la liste."
ajouter:donnee $::fichier(blacklist) $host
}
 
proc -blacklist {hand idx arg} {
set host [lindex $arg 0]
if {$host eq ""} {putdcc $idx "\002Erreur :\002 .-blacklist <host>"; return}
if {![verify:b $::fichier(blacklist) $host]} {putdcc $idx "\002Erreur :\002 Le host $host n'est pas enregistré.";return }
putdcc $idx "\002-blacklist :\002 $host n'est plus enregistré."
effacer:donnee $::fichier(blacklist) $host
}
 
proc dcc:blacklist {hand idx arg} {
putdcc $idx "---\002 LISTE DE LA BLACKLIST \002---";
liste:donnee $idx $::fichier(blacklist)
}

#Enregistrement d'host à ne pas modérer :
 
bind dcc n +protect +protect
bind dcc n -protect -protect
bind dcc n protect protect
 
proc +protect {hand idx arg} {
set host [lindex $arg 0]
if {$host eq ""} {putdcc $idx "\002Erreur :\002 .+protect <host>";putdcc $idx "\002Exemple :\002 .+protect platine*!*@*"; return}
if {[verify:b $::fichier(protect) $host]} {putdcc $idx "\002Erreur :\002 $host est déjà enregistré.";return}
putdcc $idx "\002+protect :\002 Le host $host est maintenant protégé."
ajouter:donnee $::fichier(protect) $host
}
 
proc -protect {hand idx arg} {
set host [lindex $arg 0]
if {$host eq ""} {putdcc $idx "\002Erreur :\002 .-protect <host>"; return}
if {![verify:b $::fichier(protect) $host]} {putdcc $idx "\002Erreur :\002 Le host $host n'est pas enregistré.";return }
putdcc $idx "\002-protect :\002 Le host $host n'est plus protégé."
effacer:donnee $::fichier(protect) $host
}
 
proc protect {hand idx arg} {
putdcc $idx "---\002 LISTE DES PROTÉGÉ CONTRE LA MODERATION \002---";
liste:donnee $idx $::fichier(protect)
}

#Modération :
 
bind pubm - * moderation	
proc moderation { nick host handle channel arg } {
global modmajuscule modrepetition modmot modspam avert rpt
set arg [split $arg]
set msg [join [lrange [split $arg] 0 end]]
set hostv $nick!$host
set userhost [getchanhost $nick]
set userhost "*!*[string range $userhost [string first @ $userhost] e]"
regsub -all -- {\003[0-9]{0,2}(,[0-9]{0,2})?|\017|\037|\002|\026|\006|\007} $msg "" msg
regsub -all -- {\{|\}|\\{|[}{|]}} $msg "" msg
if {![verify:b $::fichier(modchan) $channel]} {return}
if {[verify:a $::fichier(protect) $hostv]} {return}
if {![info exists modmajuscule($host)]} {set modmajuscule($host) 0; utimer $::expiration(majuscule) [list unset modmajuscule($host)]}
set nombre 0
foreach x [split $msg {}] {
if [string match \[A-Z\] $x] {incr nombre}
}
if {$nombre > $::detect(majuscule)} {
incr modmajuscule($host) 1
if {$::avert(majuscule) < $modmajuscule($host)} {putserv "KICK $channel $nick :$::kick(majuscule)"; set modmajuscule($host) 0; return}
putserv "NOTICE $nick :$::msg(majuscule)"
}
if {[info exists rpt($nick)]} {
if {[lrange $rpt($nick) 2 end]  eq  "$msg"} {
set cnt [lindex $rpt($nick) 1]; incr cnt
set rpt($nick) "[lindex $rpt($nick) 0] $cnt [lrange $rpt($nick) 2 end]"
if {[lindex $rpt($nick) 1] > $::detect(repetition)} {
if {![info exists modrepetition($host)]} {set modrepetition($host) 0; utimer $::expiration(repetition) [list unset modrepetition($host)]}
incr modrepetition($host) 1
if {$::avert(repetition) < $modrepetition($host)} {putserv "KICK $channel $nick :$::kick(repetition)"; set modrepetition($host) 0; return}
putserv "NOTICE $nick :$::msg(repetition)"
unset rpt($nick)
}
} else {set rpt($nick) "[expr [clock seconds] + 10] 1 $msg"}
} else {set rpt($nick) "[expr [clock seconds] + 10] 1 $msg"}
if {[verify:a $::fichier(modmot) $msg]} {
if {![info exists modmot($host)]} {set modmot($host) 0; utimer $::expiration(mot) [list unset modmot($host)]}
incr modmot($host) 1
if {$::avert(mot) < $modmot($host)} {putserv "MODE $channel +b $userhost";putserv "KICK $channel $nick :$::kick(mot)"; set modmot($host) 0; return}
putserv "NOTICE $nick :$::msg(mot)"
}
if {[verify:a $::fichier(modspam) $msg]} {
if {![info exists modspam($host)]} {set modspam($host) 0; utimer $::expiration(spam) [list unset modspam($host)]}
incr modspam($host) 1
if {$::avert(spam) < $modspam($host)} {putserv "MODE $channel +b $userhost";putserv "KICK $channel $nick :$::kick(spam)"; set modspam($host) 0; return}
putserv "NOTICE $nick :$::msg(spam)"
}
}
 
bind join - "*" modnick
proc modnick { nick uhost handle channel } { 
set hostv $nick!$uhost
if {[verify:a $::fichier(protect) $hostv]} {return}
if {[string equal -nocase $nick $::botnick]} {return}
if {![verify:b $::fichier(modchan) $channel]} {return}
if {![verify:a $::fichier(modnick) $nick]} {return}
putserv "MODE $channel +b $nick*!*"
putserv "KICK $channel $nick :$::kick(nick)"
}
 
bind nick - * modnicksuite
proc modnicksuite { nick uhost handle chan newnick } {
set hostv $nick!$uhost
if {[verify:a $::fichier(protect) $hostv]} {return}
if {[string equal -nocase $nick $::botnick]} {return}
if {![verify:b $::fichier(modchan) $chan]} {return}
if {![verify:a $::fichier(modnick) $nick]} {return}
putserv "MODE $chan +b $newnick*!*"
putserv "KICK $chan $newnick :$::kick(nick)"
}
 
bind join - "*" modblacklist
proc modblacklist { nick host handle channel } { 
set hostv $nick!$host
set userhost [getchanhost $nick]
set userhost "*!*[string range $userhost [string first @ $userhost] e]"
if {[verify:a $::fichier(protect) $hostv]} {return}
if {[string equal -nocase $nick $::botnick]} {return}
if {![verify:b $::fichier(modchan) $channel]} {return}
if {![verify:a $::fichier(blacklist) $hostv]} {return}
putserv "MODE $channel +b $userhost"
putserv "KICK $channel $nick :$::kick(blacklist)"
}
 
bind notc - * noticechan
proc noticechan {nick host handle text chan} {
set hostv $nick!$host
if {[verify:a $::fichier(protect) $hostv]} {return}
if {![verify:b $::fichier(modchan) $chan]} {return}
putserv "MODE $chan +b $userhost"
putserv "kick $chan $nick :$::kick(notice)"
}
 
proc zerotime {} {
	global rpt
	foreach nick [array names rpt] {
		if {[lindex $rpt($nick) 0] < [clock seconds]} {unset rpt($nick)}
	}
	utimer 5 zerotime
}
foreach t [utimers] {
	if {[lindex $t 1]  eq  "zerotime"} {killutimer [lindex $t 2]}
}
zerotime
 
bind join -|- "*" join_chargelimite
proc join_chargelimite { nick host hand chan } {
if {$::limite(active) eq 0} {return}
set stop 0
if {[string equal -nocase $nick $::botnick]} {
foreach ti [utimers] {if {[lindex $ti 1] eq "limite"} {set stop 1}} 
if {$stop eq 0} {timer 2 limite}
unset stop
}
}
 
proc limite {} {
if {$::limite(active) eq 0} {return}
set liste [open $::fichier(modchan) r]
while {![eof $liste]} {
gets $liste a
if {$a ne ""} {
set numlimite 0
foreach nombre [chanlist $a] {
incr numlimite 1
set chiffre [expr $numlimite + $::limite(puissance)]
}
putserv "MODE $a +l $chiffre"
}
}
close $liste
utimer $::limite(temp) limite
}
 
bind pubm - * massflood
proc massflood { nick uhost handle chan arg } {
global massflood
set hostv $nick!$uhost
if {[verify:a $::fichier(protect) $hostv]} {return}
if {![verify:b $::fichier(modchan) $chan]} {return}
if {![info exists massflood($chan)]} {set massflood($chan) 0 ;utimer $::mass(rehashflood) [list unset massflood($chan)]}
incr massflood($chan) 1
if {$massflood($chan) eq "$::mass(flood)"} {putserv "mode $chan +m";timer $::mass(retraitm) [list putserv "mode $chan -m"]}
}
 
bind join - * massjoin
proc massjoin {nick host hand chan} {
global massjoin
set hostv $nick!$host
if {[verify:a $::fichier(protect) $hostv]} {return}
if {![verify:b $::fichier(modchan) $chan]} {return}
if {![info exists massjoin($chan)]} {set massjoin($chan) 0 ;utimer $::mass(rehashjoin) [list unset massjoin($chan)]}
incr massjoin($chan) 1
if {$massjoin($chan) eq "$::mass(join)"} {putserv "mode $chan +i";timer $::mass(retraiti) [list putserv "mode $chan -i"]}
}

 
######################
# TRAITEMENT FICHIER #
######################
 
 
proc verify:a {fichierss arg} {
set liste [open $fichierss r]
while {![eof $liste]} {
gets $liste a
regsub -all -- {\{|\}|\\{|[}{|]}} $a "" a
if {$a ne ""} {if {[string match -nocase *$a* $arg]} {close $liste;return 1}}
}
close $liste
return 0
}
 
proc verify:b {fichierss arg} {
set liste [open $fichierss r]
while {![eof $liste]} {
gets $liste a
regsub -all -- {\{|\}|\\{|[}{|]}} $a "" a
if {$a ne ""} {if {[string equal -nocase $a $arg]} {close $liste;return 1}}
}
close $liste
return 0
}
 
proc ajouter:donnee {fichierss arg} {
set liste [open $fichierss a]
puts $liste "$arg"		
close $liste
}
 
proc effacer:donnee {fichierss arg} {
set fichier(back) "$fichierss.back"
set load [open $fichier(back) w+]
close $load
set liste [open $fichierss r]
set bcloseback [open $fichier(back) a]
while {![eof $liste]} {
gets $liste a
if {$a ne ""} {if {[string equal -nocase [lindex $a 0] $arg]} {} else {puts $bcloseback "[lindex $a]"}}
}
close $liste
close $bcloseback
file delete $fichierss
file rename $fichier(back) $fichierss
}
 
proc liste:donnee {idx fichierss} {
set liste [open $fichierss r]
set num 0
while {![eof $liste]} {
gets $liste a
if {$a ne ""} {incr num 1;putdcc $idx "(\002$num\002) [lindex $a 0]"}
}
if {$num eq "0"} { putdcc $idx "Aucun enregistrement." }
putdcc $idx "---\002 FIN DE LA LISTE \002--- Total (\002$num\002)";
close $liste
unset num
}