lookjapan.COM - IRC ve mIRC dünyasının forumu!   buy vps


  lookjapan.COM - IRC ve mIRC dünyasının forumu! IF - Unreal, Services ve Botlar Eggdrop, BNC ve Socket Botlar TCL Scriptler


Yeni Konu   Cevap Yaz

 
LinkBack Seçenekler Stil
Alt 01 Şubat 2015, 23:43   #1
 
Ahmet - ait Kullanıcı Resmi (Avatar)
 
Üyelik tarihi: 01 Şubat 2015
Bulunduğu yer: istanbul
Mesajlar: 50
WEB Sitesi: www.hobichat.net
IRC Sunucusu:
İlgi Alanı: Unreal
Alınan Beğeni: 21
Standart Sentinel.tcl Eggdrop Koruma Botu

PHP- Kodu: 
# sentinel.tcl v2.70 (15 April 2002)
# Copyright 1998-2002 by slennox
# slennox's eggdrop page - http://www.egghelp.org/

# Flood protection system for eggdrop, with integrated BitchX CTCP
# simulation. This script is designed to provide strong protection for your
# bot and channels against large floodnets and proxy floods.
#
# Note that this script was developed on the eggdrop 1.3, 1.4, and 1.6
# series and may not work properly on other versions.
#
# v2.00 - New standalone release. Contains refinements and features from
#         the netbots.tcl version of sentinel.tcl.
# v2.50 - Locktimes of less than 30 were erroneously allowed.
#         putquick -next is now supported (eggdrop 1.5+) for faster channel
#         lock.
#       - Ban mechanism now checks if flooders are coming from the same
#         domain or ident and performs wildcard bans instead of banning
#         each IP/host individually.
#       - Added tsunami detection to the avalanche flood detection system.
#       - Variables are now cleared after removing a channel.
#       - Removed unnecessary botonchan checks throughout components where
#         botisop already checks for that.
#       - Removed all unnecessary use of parentheses.
# v2.60 - Modified putquick compatibility proc.
#       - Added sl_wideban option to make domain/ident bans optional.
#       - Fixed typos in various ban-related functions.
#       - Unused procs are now unloaded.
#       - Wildcard bans covering domains/idents were not doing proper
#         checks on join-part flooders.
# v2.70 - Fixed "allbans" error which could occur when sl_wideban is
#         disabled.
#       - Added sl_masktype option, currently offering three different
#         ban/ignore mask types.
#       - Merged unsets in sl_unsetarray.
#       - Changed use of "split" in timers to the less ugly "list".
#
# sentinel.tcl is centered around its channel lock mechanism. It sets the
# channel +mi (moderated and invite-only) whenever a substantial flood on
# the channel is detected. This ensures channel stability when flooded,
# allowing the bots to deal with the flood as smoothly as possible.
# sentinel.tcl detects the following types of floods:
#
# * Channel CTCP floods. This is the most common type of flood, and will
#   often make users quit from the channel with 'Excess Flood'. A quick
#   channel lock can prevent this.
# * Channel join-part floods. A common type of channel flood in which many
#   floodbots cycle the channel.
# * Channel nick floods. Nick floods are unique in that they can occur even
#   after a channel is locked. sentinel has special mechanisms to deal with
#   this as effectively as possible.
# * Channel avalanche/tsunami floods. While the avalanche flood is quite
#   uncommon these days, tsunami floods are often used to seriously lag
#   mIRC and other clients using control codes (colour, bold, underline,
#   etc.)
# * Channel text floods. Not small text floods - but when hundreds of
#   messages are sent to the channel within a short period. Detected to
#   stop really aggressive text floods and reduce the possibility of the
#   bot crashing or consuming excessive CPU.
#
# sentinel also has additional protection features for the bot and channel:
#
# * Bogus username detection. Users with annoying bogus characters in their
#   ident are banned. A channel lock is applied if multiple join in a short
#   period.
# * Full ban list detection. During a serious flood, the ban list may
#   become full. If this happens, the bots may start kick flooding since
#   they cannot ban. If the ban list is full, the channel will be set +i.
# * Bot CTCP flood protection. Protects the bot if it is CTCP flooded.
# * Bot MSG flood protection. Protects the bot if it's flooded with MSGs or
#   MSG commands.
# * Automatic bans and ignores. During a flood, sentinel will compile a
#   list of the flooders, then kick-ban them after the channel has been
#   locked.
# * BitchX simulation. This has been built-in mainly because you cannot use
#   a third-party BitchX simulator with sentinel (only one script at a time
#   can have control of CTCPs). sentinel provides accurate simulation of
#   BitchX 75p1+ and 75p3+ CTCP replies and AWAY mode.
# * Public commands (lc and uc) and DCC commands (.lock and .unlock) for
#   locking/unlocking channels.
# * DCC command .sentinel displays current settings.
#
# Important Notes:
# - Make sure no bots are enforcing channel mode -i and/or -m.
# - Bans are added to the bot's internal ban list, and expire after 24
#   hours by default. If you have +dynamicbans set, the bans may be removed
#   from the channel much sooner than this, but the ban will remain in the
#   bot's internal ban list until it expires.
# - For greater protection against large channel floods, I recommend you
#   also use a channel limiter script, such as chanlimit.tcl.
# - There is a trade-off between convenience and security. The more
#   automation you enable, the more stress the bot will be under during a
#   flood and the more stuff it will be sending to the server.
# - Where security is paramount, have one or two bots that aren't running
#   sentinel.tcl. Since sentinel.tcl is a complex script with many
#   automated and convenience features, there is a potential for
#   vulnerabilities.

# The following flood settings are in number:seconds format, 0:0 to
# disable.

# Bot CTCP flood.
set sl_bcflood 5:30

# Bot MSG flood.
set sl_bmflood 6:20

# Channel CTCP flood.
set sl_ccflood 5:20

# Channel avalanche/tsunami flood.
set sl_avflood 6:20

# Channel text flood.
set sl_txflood 80:30

# Channel bogus username join flood.
set sl_boflood 4:20

# Channel join-part flood.
set sl_jflood 6:20

# Channel nick flood.
set sl_nkflood 6:20

# Flood setting notes:
# - Don't fiddle too much with the seconds field in the flood settings, as
#   it can reduce the effectiveness of the script. The seconds field should
#   set in the 20-60 seconds range.
# - Avalanche/tsunmami flood detection may be CPU intensive on a busy
#   channel, although I don't think it's a big deal on most systems. If
#   you're concerned about CPU usage you may wish to disable it, perhaps
#   leaving it enabled on one bot. Disabling text flood protection can
#   further reduce CPU usage.
# - On bots with avalanche/tsunami flood detection enabled, it's
#   recommended that you also enable text flood detection to cap CPU usage
#   during a flood.
# - If you enable nick flood detection, it's strongly recommended that it
#   be enabled on all bots that have sentinel.tcl loaded. This is required
#   for effective nick flood handling.

# Specify the number of control characters that must be in a line before
# it's counted by the tsunami flood detector. For efficiency reasons,
# tsunami detection is implemented with avalanche detection, so sl_avflood
# must be enabled for tsunami detection to be active. Setting this to 0
# will disable tsunami detection.
set sl_tsunami 10
# Valid settings: 0 to disable, otherwise 1 or higher.

# Length of time in minutes to ban channel flooders. This makes the bot
# perform kicks and bans on flooders after the channel lock. Because of the
# reactive nature of automatic bans, you should disable this on at least
# one bot for the most effective protection.
set sl_ban 1440
# Valid settings: 0 to disable, otherwise 1 or higher.

# Length of time in minutes of on-join bans for bogus usernames. For the
# most effective protection, you should disable this on at least one bot.
set sl_boban 1440
# Valid settings: 0 to disable, otherwise 1 or higher.

# Set global bans on channel flooders and bogus usernames?
set sl_globalban 0
# Valid settings: 1 for global bans, 0 for channel-specific bans.

# When processing a list of flooders, sentinel.tcl compares the hosts to
# see if multiple flooders are coming from a particular domain/IP or using
# the same ident (e.g. different vhosts on a single user account). If
# multiple flooders come from the same domain/IP, or if multiple flooders
# have the same ident, then the whole domain/IP (i.e. *!*@*.domain.com or
# *!*@555.555.555.*) or ident (i.e. *!*username@*) is banned. If you
# disable this option, all bans will be in *!*@machine.domain.com and
# *!*@555.555.555.555 format.
set sl_wideban 1
# Valid settings: 1 to enable, 0 to disable.

# Maximum number of bans allowed in the bot's ban list before sentinel will
# stop adding new bans. This prevents the bot from adding hundreds of bans
# on really large floods. Note that this has nothing to do with the channel
# ban list.
set sl_banmax 100
# Valid settings: 1 or higher.

# Length of time in minutes to ignore bot flooders. On bots with sl_ban
# active, channel flooders are also added to the ignore list.
set sl_igtime 240
# Valid settings: 1 or higher.

# Select the type of hostmask to use when banning and/or ignoring flooders.
# There are three to choose from:
#   0 - *!*@machine.domain.com / *!*@555.555.555.555
#   1 - *!*ident@machine.domain.com / *!*ident@555.555.555.555
#   2 - *!*ident@*.domain.com / *!*ident@555.555.555.*
# The default option, 0, is strongly recommended for most situations, and
# provides the best level of protection. The other two options are provided
# mainly for special cases.
set sl_masktype 0
# Valid settings: 0, 1, or 2, depending on the hostmask type you wish to use.

# Length of time in seconds to set channel +i if flooded. If set to 0, +i
# will not be removed automatically.
set sl_ilocktime 120
# Valid settings: 0 to prevent +i being removed automatically, otherwise 30
# or higher.

# Length of time in seconds to set channel +m if flooded. If set to 0, +m
# will not be removed automatically.
set sl_mlocktime 60
# Valid settings: 0 to prevent +m being removed automatically, otherwise 30
# or higher.

# On small floods (two flooders or less), remove the +mi shortly after bans
# have been set, instead of waiting for the locktimes to expire? This
# prevents unnecessary extended locks on small floods. This setting is only
# used by bots with sl_ban enabled.
set sl_shortlock 0
# Valid settings: 0 to disable, 1 to enable.

# Number of bans to allow in the channel ban list before setting the
# channel +i. If enabled, this should preferably be set to just below the
# maximum number of bans allowed.
set sl_bfmaxbans 19
# Valid settings: 0 to disable +i on full ban list, otherwise 1 or higher.

# List of users to send a note to when channel is flooded, bot is flooded,
# or ban list becomes full.
set sl_note "YourNick"
# Valid settings: one user like "Tom", a list of users like
# "Tom Dick Harry", or "" to specify that no notes are sent.

# Notice to send to channel when locked due to flood.
set sl_cfnotice "Channel locked temporarily due to flood, sorry for any inconvenience this may cause :-)"
# Valid settings: a text string, or set it to "" to disable.

# Notice to send to channel when locked due to full ban list.
set sl_bfnotice "Channel locked temporarily due to full ban list, sorry for any inconvenience this may cause :-)"
# Valid settings: a text string, or set it to "" to disable.

# Enable 'lc' and 'uc' public commands for locking/unlocking channel?
set sl_lockcmds 2
# Valid settings: 0 to disable, 1 to enable, 2 to require user to be opped
# on the channel to use the command.

# Users with these flags are allowed to use lc/uc public commands, and
# .lock/.unlock DCC commands.
set sl_lockflags "o"
# Valid settings: one flag like "n", or a list of flags like "fo" (means
# 'f OR o').

# Enable BitchX CTCP and AWAY simulation?
set sl_bxsimul 0
# Valid settings: 1 to enable, 0 to disable.


# Don't edit below unless you know what you're doing.

if {$numversion 1032400} {
  
proc botonchan {chan} {
    global 
botnick
    
if {![validchan $chan]} {
      
error "illegal channel: $chan"
    
} elseif {![onchan $botnick $chan]} {
      return 
0
    
}
    return 
1
  
}
  
proc putquick {text args} {
    
putserv $text
  
}
}

proc sl_ctcp {nick uhost hand dest key arg} {
  global 
botnet-nick botnick realname sl_ban sl_bflooded sl_bcflood sl_bcqueue sl_bxjointime sl_bxmachine sl_bxonestack sl_bxsimul sl_bxsystem sl_bxversion sl_bxwhoami sl_ccbanhost sl_ccbannick sl_ccflood sl_ccqueue sl_flooded sl_locked sl_note
  set chan 
[string tolower $dest]
  if {[
lsearch -exact $sl_ccflood 0] == -&& [validchan $chan] && ![isop $nick $chan]} {
    if {
$nick == $botnick} {return 0}
    if {
$sl_ban && !$sl_locked($chan) && ![matchattr $hand f|f $chan]} {
      
lappend sl_ccbannick($chan$nick lappend sl_ccbanhost($chan) [string tolower $uhost]
      
utimer [lindex $sl_ccflood 1] [list sl_ccbanqueue $chan]
    }
    if {
$sl_flooded($chan)} {return 1}
    
incr sl_ccqueue($chan)
    
utimer [lindex $sl_ccflood 1] [list sl_ccqueuereset $chan]
    if {
$sl_ccqueue($chan) >= [lindex $sl_ccflood 0]} {
      
sl_lock $chan "CTCP flood" ${botnet-nick} ; return 1
    
}
    if {
$sl_bflooded} {return 1}
  } elseif {[
lindex $sl_bcflood 0] && $dest == $botnick} {
    if {
$sl_bflooded} {
      
sl_ignore [string tolower $uhost$hand "CTCP flooder" ; return 1
    
}
    
incr sl_bcqueue
    utimer 
[lindex $sl_bcflood 1] {incr sl_bcqueue -1}
    if {
$sl_bcqueue >= [lindex $sl_bcflood 0]} {
      
putlog "sentinel: CTCP flood detected on me! Stopped answering CTCPs temporarily."
      
set sl_bflooded 1
      utimer 
[lindex $sl_bcflood 1] {set sl_bflooded 0}
      if {[
info commands sendnote] != ""} {
        foreach 
recipient $sl_note {
          if {[
validuser $recipient]} {
            
sendnote SENTINEL $recipient "Bot was CTCP flooded."
          
}
        }
      }
      return 
1
    
}
  }

  if {!
$sl_bxsimul} {return 0}
  if {
$sl_bxonestack} {return 1}
  
set sl_bxonestack 1 utimer 2 {set sl_bxonestack 0}
  switch -
exact -- $key {
    
"CLIENTINFO" {
      
set bxcmd [string toupper $arg]
      switch -
exact -- $bxcmd {
        
"" {putserv "NOTICE $nick :\001CLIENTINFO SED UTC ACTION DCC CDCC BDCC XDCC VERSION CLIENTINFO USERINFO ERRMSG FINGER TIME PING ECHO INVITE WHOAMI OP OPS UNBAN IDENT XLINK UPTIME  :Use CLIENTINFO <COMMAND> to get more specific information\001"}
        
"SED" {putserv "NOTICE $nick :\001CLIENTINFO SED contains simple_encrypted_data\001"}
        
"UTC" {putserv "NOTICE $nick :\001CLIENTINFO UTC substitutes the local timezone\001"}
        
"ACTION" {putserv "NOTICE $nick :\001CLIENTINFO ACTION contains action descriptions for atmosphere\001"}
        
"DCC" {putserv "NOTICE $nick :\001CLIENTINFO DCC requests a direct_client_connection\001"}
        
"CDCC" {putserv "NOTICE $nick :\001CLIENTINFO CDCC checks cdcc info for you\001"}
        
"BDCC" {putserv "NOTICE $nick :\001CLIENTINFO BDCC checks cdcc info for you\001"}
        
"XDCC" {putserv "NOTICE $nick :\001CLIENTINFO XDCC checks cdcc info for you\001"}
        
"VERSION" {putserv "NOTICE $nick :\001CLIENTINFO VERSION shows client type, version and environment\001"}
        
"CLIENTINFO" {putserv "NOTICE $nick :\001CLIENTINFO CLIENTINFO gives information about available CTCP commands\001"}
        
"USERINFO" {putserv "NOTICE $nick :\001CLIENTINFO USERINFO returns user settable information\001"}
        
"ERRMSG" {putserv "NOTICE $nick :\001CLIENTINFO ERRMSG returns error messages\001"}
        
"FINGER" {putserv "NOTICE $nick :\001CLIENTINFO FINGER shows real name, login name and idle time of user\001"}
        
"TIME" {putserv "NOTICE $nick :\001CLIENTINFO TIME tells you the time on the user's host\001"}
        
"PING" {putserv "NOTICE $nick :\001CLIENTINFO PING returns the arguments it receives\001"}
        
"ECHO" {putserv "NOTICE $nick :\001CLIENTINFO ECHO returns the arguments it receives\001"}
        
"INVITE" {putserv "NOTICE $nick :\001CLIENTINFO INVITE invite to channel specified\001"}
        
"WHOAMI" {putserv "NOTICE $nick :\001CLIENTINFO WHOAMI user list information\001"}
        
"OP" {putserv "NOTICE $nick :\001CLIENTINFO OP ops the person if on userlist\001"}
        
"OPS" {putserv "NOTICE $nick :\001CLIENTINFO OPS ops the person if on userlist\001"}
        
"UNBAN" {putserv "NOTICE $nick :\001CLIENTINFO UNBAN unbans the person from channel\001"}
        
"IDENT" {putserv "NOTICE $nick :\001CLIENTINFO IDENT change userhost of userlist\001"}
        
"XLINK" {putserv "NOTICE $nick :\001CLIENTINFO XLINK x-filez rule\001"}
        
"UPTIME" {putserv "NOTICE $nick :\001CLIENTINFO UPTIME my uptime\001"}
        
"default" {putserv "NOTICE $nick :\001ERRMSG CLIENTINFO: $arg is not a valid function\001"}
      }
      return 
1
    
}
    
"VERSION" {
      
putserv "NOTICE $nick :\001VERSION \002BitchX-$sl_bxversion\002 by panasync \002-\002 $sl_bxsystem :\002 Keep it to yourself!\002\001"
      
return 1
    
}
    
"USERINFO" {
      
putserv "NOTICE $nick :\001USERINFO \001"
      
return 1
    
}
    
"FINGER" {
      
putserv "NOTICE $nick :\001FINGER $realname ($sl_bxwhoami@$sl_bxmachine) Idle [expr [unixtime] - $sl_bxjointime] seconds\001"
      
return 1
    
}
    
"PING" {
      
putserv "NOTICE $nick :\001PING $arg\001"
      
return 1
    
}
    
"ECHO" {
      if {[
validchan $chan]} {return 1}
      
putserv "NOTICE $nick :\001ECHO [string range $arg 0 59]\001"
      
return 1
    
}
    
"ERRMSG" {
      if {[
validchan $chan]} {return 1}
      
putserv "NOTICE $nick :\001ERRMSG [string range $arg 0 59]\001"
      
return 1
    
}
    
"INVITE" {
      if {
$arg == "" || [validchan $chan]} {return 1}
      
set chanarg [lindex [split $arg0]
      if {(((
$sl_bxversion == "75p1+") && ([string trim [string index $chanarg 0"#+&"] == "")) || (($sl_bxversion == "75p3+") && ([string trim [string index $chanarg 0"#+&!"] == "")))} {
        if {[
validchan $chanarg]} {
          
putserv "NOTICE $nick :\002BitchX\002: Access Denied"
        
} else {
          
putserv "NOTICE $nick :\002BitchX\002: I'm not on that channel"
        
}
      }
      return 
1
    
}
    
"WHOAMI" {
      if {[
validchan $chan]} {return 1}
      
putserv "NOTICE $nick :\002BitchX\002: Access Denied"
      
return 1
    
}
    
"OP" -
    
"OPS" {
      if {
$arg == "" || [validchan $chan]} {return 1}
      
putserv "NOTICE $nick :\002BitchX\002: I'm not on [lindex [split $arg] 0], or I'm not opped"
      
return 1
    
}
    
"UNBAN" {
      if {
$arg == "" || [validchan $chan]} {return 1}
      if {[
validchan [lindex [split $arg0]]} {
        
putserv "NOTICE $nick :\002BitchX\002: Access Denied"
      
} else {
        
putserv "NOTICE $nick :\002BitchX\002: I'm not on that channel"
      
}
      return 
1
    
}
  }
  return 
0
}

proc sl_bmflood {nick uhost hand text} {
  global 
sl_bmflood sl_bflooded sl_bmqueue sl_note
  
if {[matchattr $hand b] && [string tolower [lindex [split $text0]] == "go"} {return 0}
  if {
$sl_bflooded} {
    
sl_ignore [string tolower $uhost$hand "MSG flooder" ; return 0
  
}
  
incr sl_bmqueue
  utimer 
[lindex $sl_bmflood 1] {incr sl_bmqueue -1}
  if {
$sl_bmqueue >= [lindex $sl_bmflood 0]} {
    
putlog "sentinel: MSG flood detected on me! Stopped answering MSGs temporarily."
    
set sl_bflooded 1
    utimer 
[lindex $sl_bmflood 1] {set sl_bflooded 0}
    if {[
info commands sendnote] != ""} {
      foreach 
recipient $sl_note {
        if {[
validuser $recipient]} {
          
sendnote SENTINEL $recipient "Bot was MSG flooded."
        
}
      }
    }
  }
  return 
0
}

proc sl_avflood {from keyword arg} {
  global 
botnet-nick botnick sl_ban sl_avbanhost sl_avbannick sl_avflood sl_avqueue sl_flooded sl_locked sl_txflood sl_txqueue
  set arg 
[split $arg]
  
set chan [string tolower [lindex $arg 0]]
  if {![
validchan $chan]} {return 0}
  
set nick [lindex [split $from !] 0]
  if {
$nick == $botnick || $nick == "" || [string match *.* $nick]} {return 0}
  if {![
onchan $nick $chan] || [isop $nick $chan]} {return 0}
  if {!
$sl_flooded($chan) && [lsearch -exact $sl_txflood 0] == -1} {
    
incr sl_txqueue($chan)
    if {
$sl_txqueue($chan) >= [lindex $sl_txflood 0]} {
      
sl_lock $chan "TEXT flood" ${botnet-nick}
    }
  }
  
set text [join [lrange $arg 1 end]]
  if {[
sl_checkaval $text] && [lsearch -exact $sl_avflood 0] == -1} {
    
set uhost [string trimleft [getchanhost $nick $chan"~+-^="]
    
set hand [nick2hand $nick $chan]
    if {
$sl_ban && !$sl_locked($chan) && $nick != $botnick && ![matchattr $hand f|f $chan]} {
      
lappend sl_avbannick($chan$nick lappend sl_avbanhost($chan) [string tolower $uhost]
      
utimer [lindex $sl_avflood 1] [list sl_avbanqueue $chan]
    }
    if {
$sl_flooded($chan)} {return 0}
    
incr sl_avqueue($chan)
    
utimer [lindex $sl_avflood 1] [list sl_avqueuereset $chan]
    if {
$sl_avqueue($chan) >= [lindex $sl_avflood 0]} {
      
sl_lock $chan "AVALANCHE/TSUNAMI flood" ${botnet-nick}
    }
  }
  return 
0
}

proc sl_checkaval {text} {
  global 
sl_tsunami
  
if {[regsub -all -- "\001|\007" $text "" temp] >= 3} {return 1}
  if {
$sl_tsunami && [regsub -all -- "\002|\003|\017|\026|\037" $text "" temp] >= $sl_tsunami} {return 1}
  return 
0
}

proc sl_nkflood {nick uhost hand chan newnick} {
  global 
botnet-nick botnick sl_ban sl_banmax sl_flooded sl_globalban sl_locked sl_nickkick sl_nkbanhost sl_nkflood sl_nkflooding sl_nkqueue
  set chan 
[string tolower $chan]
  if {[
isop $newnick $chan]} {return 0}
  if {
$sl_ban && !$sl_locked($chan) && $nick != $botnick && ![matchattr $hand f|f $chan]} {
    
lappend sl_nkbanhost($chan) [string tolower $uhost]
    
utimer [lindex $sl_nkflood 1] [list sl_nkbanqueue $chan]
  }
  if {!
$sl_nickkick && $sl_flooded($chan) && $sl_locked($chan)} {
    
putserv "KICK $chan $newnick :NICK flooder"
    
set sl_nickkick 1 set sl_nkflooding($chan) [unixtime]
    if {
$sl_ban} {
      
set bhost [string tolower [sl_masktype $uhost]]
      if {
$sl_globalban} {
        if {[
llength [banlist]] < $sl_banmax && ![isban $bhost] && ![matchban $bhost]} {
          
newban $bhost sentinel "NICK flooder" $sl_ban
        
}
      } else {
        if {[
llength [banlist $chan]] < $sl_banmax && ![isban $bhost $chan] && ![matchban $bhost $chan]} {
          
newchanban $chan $bhost sentinel "NICK flooder" $sl_ban
        
}
      }
    }
    
utimer [expr [rand 2] + 3] {set sl_nickkick 0}
    return 
0
  
}
  if {
$sl_flooded($chan)} {return 0}
  
incr sl_nkqueue($chan)
  
utimer [lindex $sl_nkflood 1] [list sl_nkqueuereset $chan]
  if {
$sl_nkqueue($chan) >= [lindex $sl_nkflood 0]} {
    
sl_lock $chan "NICK flood" ${botnet-nick}
  }
  return 
0
}

proc sl_jflood {nick uhost hand chan} {
  global 
botnet-nick botnick sl_ban sl_banmax sl_boban sl_bobanhost sl_bobannick sl_boflood sl_boqueue sl_flooded sl_globalban sl_jbanhost sl_jbannick sl_jflood sl_jqueue sl_locked sl_pqueue
  
if {$nick == $botnick} {
    
sl_setarray $chan
  
} else {
    
set ihost [string tolower [sl_masktype $uhost]]
    if {[
isignore $ihost]} {
      
killignore $ihost
    
}
    
set chan [string tolower $chan]
    if {[
lsearch -exact $sl_boflood 0] == -&& [sl_checkbogus [lindex [split $uhost @] 0]]} {
      if {!
$sl_locked($chan) && ![matchattr $hand f|f $chan]} {
        
set bhost [string tolower [sl_masktype $uhost]]
        if {
$sl_boban && [botisop $chan] && !$sl_flooded($chan)} {
          
putserv "KICK $chan $nick :BOGUS username"
          
if {$sl_globalban} {
            if {[
llength [banlist]] < $sl_banmax && ![isban $bhost] && ![matchban $bhost]} {
              
newban $bhost sentinel "BOGUS username" $sl_boban
            
}
          } else {
            if {[
llength [banlist $chan]] < $sl_banmax && ![isban $bhost $chan] && ![matchban $bhost $chan]} {
              
newchanban $chan $bhost sentinel "BOGUS username" $sl_boban
            
}
          }
        }
        if {
$sl_ban} {
          
lappend sl_bobannick($chan$nick lappend sl_bobanhost($chan) [string tolower $uhost]
          
utimer [lindex $sl_boflood 1] [list sl_bobanqueue $chan]
        }
      }
      if {!
$sl_flooded($chan)} {
        
incr sl_boqueue($chan)
        
utimer [lindex $sl_boflood 1] [list sl_boqueuereset $chan]
        if {
$sl_boqueue($chan) >= [lindex $sl_boflood 0]} {
          
sl_lock $chan "BOGUS joins" ${botnet-nick}
        }
      }
    }
    if {[
lsearch -exact $sl_jflood 0] == -1} {
      if {
$sl_ban && !$sl_locked($chan) && ![matchattr $hand f|f $chan]} {
        
lappend sl_jbannick($chan$nick lappend sl_jbanhost($chan) [string tolower $uhost]
        
utimer [lindex $sl_jflood 1] [list sl_jbanqueue $chan]
      }
      if {
$sl_flooded($chan)} {return 0}
      
incr sl_jqueue($chan)
      
utimer [lindex $sl_jflood 1] [list sl_jqueuereset $chan]
      if {
$sl_jqueue($chan) >= [lindex $sl_jflood 0] && $sl_pqueue($chan) >= [lindex $sl_jflood 0]} {
        
sl_lock $chan "JOIN-PART flood" ${botnet-nick}
      }
    }
  }
  return 
0
}

proc sl_checkbogus {ident} {
  if {[
regsub -all -- "\[^\041-\176\]" $ident "" temp] >= 1} {return 1}
  return 
0
}

proc sl_pflood {nick uhost hand chan {msg ""}} {
  global 
botnick sl_ban sl_flooded sl_jflood sl_locked sl_pbanhost sl_pbannick sl_pqueue
  
if {[lsearch -exact $sl_jflood 0] != -1} {return 0}
  if {
$nick == $botnick} {
    if {![
validchan $chan]} {
      
timer 5 [list sl_unsetarray $chan]
    }
    return 
0
  
}
  
set chan [string tolower $chan]
  if {
$sl_ban && !$sl_locked($chan) && ![matchattr $hand f|f $chan]} {
    
lappend sl_pbannick($chan$nick lappend sl_pbanhost($chan) [string tolower $uhost]
    
utimer [lindex $sl_jflood 1] [list sl_pbanqueue $chan]
  }
  if {
$sl_flooded($chan)} {return 0}
  
incr sl_pqueue($chan)
  
utimer [lindex $sl_jflood 1] [list sl_pqueuereset $chan]
  return 
0
}

proc sl_pfloodk {nick uhost hand chan kicked reason} {
  global 
botnick sl_flooded sl_jflood sl_pqueue
  
if {[lsearch -exact $sl_jflood 0] != -1} {return 0}
  if {
$kicked == $botnick} {return 0}
  
set chan [string tolower $chan]
  if {
$sl_flooded($chan)} {return 0}
  
incr sl_pqueue($chan)
  
utimer [lindex $sl_jflood 1] [list sl_pqueuereset $chan]
  return 
0
}

proc sl_lock {chan flood detected} {
  global 
botnet-nick sl_bflooded sl_cfnotice sl_flooded sl_ilocktime sl_mlocktime sl_note
  
if {[string tolower $detected] == [string tolower ${botnet-nick}]} {
    
set sl_flooded($chanset sl_bflooded 1
    
if {[botisop $chan]} {
      
sl_quicklock $chan
      sl_killutimer 
"sl_unlock $chan *"
      
sl_killutimer "set sl_bflooded 0"
      
if {$sl_mlocktime} {
        
utimer $sl_mlocktime [list sl_unlock $chan m]
      }
      if {
$sl_ilocktime} {
        
utimer $sl_ilocktime [list sl_unlock $chan i]
      }
      
utimer 120 {set sl_bflooded 0}
      
putlog "sentinel: $flood detected on $chan! Channel locked temporarily."
      
if {$sl_cfnotice != ""} {
        
puthelp "NOTICE $chan :$sl_cfnotice"
      
}
    } else {
      
putlog "sentinel: $flood detected on $chan! Cannot lock channel because I'm not opped."
      
utimer 120 {set sl_bflooded 0}
    }
  } else {
    
putlog "sentinel: $flood detected by $detected on $chan!"
  
}
  if {[
info commands sendnote] != ""} {
    foreach 
recipient $sl_note {
      if {[
validuser $recipient]} {
        if {[
string tolower $detected] == [string tolower ${botnet-nick}]} {
          
sendnote SENTINEL $recipient "$flood detected on $chan."
        
} else {
          
sendnote SENTINEL $recipient "$flood detected by $detected on $chan."
        
}
      }
    }
  }
  return 
0
}

proc sl_unlock {chan umode} {
  global 
sl_bflooded sl_bfmaxbans sl_flooded sl_ilocktime sl_mlocktime sl_nkflooding
  
if {[expr [unixtime] - $sl_nkflooding($chan)] < 12} {
    
putlog "sentinel: nick flooding still in progress on $chan - not removing +mi yet.."
    
set sl_flooded($chanset sl_bflooded 1
    sl_killutimer 
"sl_unlock $chan *"
    
sl_killutimer "set sl_bflooded 0"
    
utimer $sl_mlocktime [list sl_unlock $chan m] ; utimer $sl_ilocktime [list sl_unlock $chan i]
    
utimer 120 {set sl_bflooded 0}
  } else {
    
set sl_flooded($chan0
    
if {![botisop $chan]} {return 0}
    if {
$umode == "mi"} {
      
putlog "sentinel: flood was small, performing early unlock.."
    
}
    if {[
string match *i$umode] && [string match *i* [lindex [split [getchanmode $chan]] 0]]} {
      if {
$sl_bfmaxbans && [llength [chanbans $chan]] >= $sl_bfmaxbans} {
        
putlog "sentinel: not removing +i on $chan due to full ban list."
      
} else {
        
pushmode $chan -i
        putlog 
"sentinel: removed +i on $chan"
      
}
    }
    if {[
string match *m$umode] && [string match *m* [lindex [split [getchanmode $chan]] 0]]} {
      
pushmode $chan -m
      putlog 
"sentinel: removed +m on $chan"
    
}
  }
  return 
0
}

proc sl_mode {nick uhost hand chan mode victim} {
  global 
botnick sl_ban sl_bfmaxbans sl_bfnotice sl_bfull sl_flooded sl_locked sl_note sl_unlocked
  set chan 
[string tolower $chan]
  if {
$mode == "+b" && $sl_bfmaxbans && !$sl_bfull($chan) && ![string match *i* [lindex [split [getchanmode $chan]] 0]] && [botisop $chan] && [llength [chanbans $chan]] >= $sl_bfmaxbans} {
    
putserv "MODE $chan +i"
    
set sl_bfull($chan1
    utimer 5 
[list set sl_bfull($chan0]
    
putlog "sentinel: locked $chan due to full ban list!"
    
if {$sl_bfnotice != ""} {
      
puthelp "NOTICE $chan :$sl_bfnotice"
    
}
    if {[
info commands sendnote] != ""} {
      foreach 
recipient $sl_note {
        if {[
validuser $recipient]} {
          
sendnote SENTINEL $recipient "Locked $chan due to full ban list."
        
}
      }
    }
  } elseif {
$mode == "+i" && $sl_flooded($chan)} {
    
set sl_locked($chan1
    
if {$sl_ban} {
      
sl_killutimer "sl_*banqueue $chan"
      
utimer 7 [list sl_dokicks $chan] ; utimer 16 [list sl_setbans $chan]
    }
  } elseif {
$mode == "-i" || $mode == "-m"} {
    
set sl_locked($chan0
    set sl_unlocked
($chan) [unixtime]
    if {
$sl_flooded($chan)} {
      
set sl_flooded($chan0
      
if {$mode == "-i"} {
        
sl_killutimer "sl_unlock $chan i"
      
} else {
        
sl_killutimer "sl_unlock $chan m"
      
}
      
sl_killutimer "sl_unlock $chan mi"
      
if {$nick != $botnick} {
        
putlog "sentinel: $chan unlocked by $nick"
      
}
    }
  }
  return 
0
}

proc sl_dokicks {chan} {
  global 
sl_avbannick sl_bobannick sl_ccbannick sl_kflooders sl_jbannick sl_pbannick
  
if {![botisop $chan]} {return 0}
  
set sl_kflooders 0
  sl_kick $chan $sl_ccbannick
($chan"CTCP flooder" set sl_ccbannick($chan""
  
sl_kick $chan $sl_avbannick($chan"AVALANCHE/TSUNAMI flooder" set sl_avbannick($chan""
  
sl_kick $chan $sl_bobannick($chan"BOGUS username" set sl_bobannick($chan""
  
set jklist $sl_jbannick($chan) ; set pklist $sl_pbannick($chan)
  if {
$jklist != "" && $pklist != ""} {
    
set klist ""
    
foreach nick $jklist {
      if {[
lsearch -exact $pklist $nick] != -1} {
        
lappend klist $nick
      
}
    }
    
sl_kick $chan $klist "JOIN-PART flooder"
  
}
  
set sl_jbannick($chan"" set sl_pbannick($chan""
  
return 0
}

proc sl_kick {chan klist reason} {
  global 
sl_kflooders sl_kicks
  
if {$klist != ""} {
    
set kicklist ""
    
foreach nick $klist {
      if {[
lsearch -exact $kicklist $nick] == -1} {
        
lappend kicklist $nick
      
}
    }
    unset 
nick
    incr sl_kflooders 
[llength $kicklist]
    foreach 
nick $kicklist {
      if {[
onchan $nick $chan] && ![onchansplit $nick $chan]} {
        
lappend ksend $nick
        
if {[llength $ksend] >= $sl_kicks} {
          
putserv "KICK $chan [join $ksend ,] :$reason"
          
unset ksend
        
}
      }
    }
    if {[
info exists ksend]} {
      
putserv "KICK $chan [join $ksend ,] :$reason"
    
}
  }
  return 
0
}

proc sl_setbans {chan} {
  global 
sl_avbanhost sl_bobanhost sl_ccbanhost sl_kflooders sl_jbanhost sl_nkbanhost sl_pbanhost sl_shortlock sl_unlocked sl_wideban
  
if {![botonchan $chan]} {return 0}
  
set sl_ccbanhost($chan) [sl_dfilter $sl_ccbanhost($chan)]
  
set sl_avbanhost($chan) [sl_dfilter $sl_avbanhost($chan)]
  
set sl_nkbanhost($chan) [sl_dfilter $sl_nkbanhost($chan)]
  
set sl_bobanhost($chan) [sl_dfilter $sl_bobanhost($chan)]
  
set sl_jbanhost($chan) [sl_dfilter $sl_jbanhost($chan)]
  
set sl_pbanhost($chan) [sl_dfilter $sl_pbanhost($chan)]
  
set blist ""
  
if {$sl_jbanhost($chan) != "" && $sl_pbanhost($chan) != ""} {
    foreach 
bhost $sl_jbanhost($chan) {
      if {[
lsearch -exact $sl_pbanhost($chan$bhost] != -1} {
        
lappend blist $bhost
      
}
    }
  }
  
set allbans [sl_dfilter [concat $sl_ccbanhost($chan$sl_avbanhost($chan$sl_nkbanhost($chan$sl_bobanhost($chan$blist]]
  if {
$sl_wideban} {
    
sl_ban $chan [sl_dcheck $allbans"MULTIPLE IDENT/HOST flooders"
  
}
  
sl_ban $chan $sl_ccbanhost($chan"CTCP flooder" set sl_ccbanhost($chan""
  
sl_ban $chan $sl_avbanhost($chan"AVALANCHE/TSUNAMI flooder" set sl_avbanhost($chan""
  
sl_ban $chan $sl_nkbanhost($chan"NICK flooder" set sl_nkbanhost($chan""
  
sl_ban $chan $sl_bobanhost($chan"BOGUS username" set sl_bobanhost($chan""
  
sl_ban $chan $blist "JOIN-PART flooder"
  
set sl_jbanhost($chan"" set sl_pbanhost($chan""
  
if {$sl_shortlock && $sl_kflooders <= && [llength $allbans] <= && [expr [unixtime] - $sl_unlocked($chan)] > 120} {
    
sl_killutimer "sl_unlock $chan *"
    
utimer 10 [list sl_unlock $chan mi]
  }
  return 
0
}

proc sl_dfilter {list} {
  
set newlist ""
  
foreach item $list {
    if {[
lsearch -exact $newlist $item] == -1} {
      
lappend newlist $item
    
}
  }
  return 
$newlist
}

proc sl_dcheck {bhosts} {
  
set blist ""
  
foreach bhost $bhosts {
    
set baddr [lindex [split [maskhost $bhost"@"1]
    
set bident [string trimleft [lindex [split $bhost "@"0"~"]
    if {![
info exists baddrs($baddr)]} {
      
set baddrs($baddr1
    
} else {
      
incr baddrs($baddr)
    }
    if {![
info exists bidents($bident)]} {
      
set bidents($bident1
    
} else {
      
incr bidents($bident)
    }
  }
  foreach 
baddr [array names baddrs] {
    if {
$baddrs($baddr) >= 2} {
      
lappend blist *!*@$baddr
    
}
  }
  foreach 
bident [array names bidents] {
    if {
$bidents($bident) >= 2} {
      
lappend blist *!*$bident@*
    }
  }
  return 
$blist
}

proc sl_ban {chan blist reason} {
  global 
sl_ban sl_banmax sl_globalban
  
if {$blist != ""} {
    if {
$sl_globalban} {
      foreach 
bhost $blist {
        if {![
string match *!* $bhost]} {
          if {[
matchban *!$bhost]} {continue}
          
set bhost [sl_masktype $bhost]
          if {[
isban $bhost]} {continue}
        } else {
          if {[
isban $bhost]} {continue}
          foreach 
ban [banlist] {
            if {[
lindex $ban 5] == "sentinel" && [string match $bhost [string tolower [lindex $ban 0]]]} {
              
killban $ban
            
}
          }
        }
        if {[
llength [banlist]] >= $sl_banmax} {continue}
        
newban $bhost sentinel $reason $sl_ban
        putlog 
"sentinel: banned $bhost ($reason)"
        
sl_ignore $bhost $reason
      
}
    } else {
      foreach 
bhost $blist {
        if {![
string match *!* $bhost]} {
          if {[
matchban *!$bhost $chan]} {continue}
          
set bhost [sl_masktype $bhost]
          if {[
isban $bhost $chan]} {continue}
        } else {
          if {[
isban $bhost $chan]} {continue}
          foreach 
ban [banlist $chan] {
            if {[
lindex $ban 5] == "sentinel" && [string match $bhost [string tolower [lindex $ban 0]]]} {
              
killchanban $chan $ban
            
}
          }
        }
        if {[
llength [banlist $chan]] >= $sl_banmax} {continue}
        
newchanban $chan $bhost sentinel $reason $sl_ban
        putlog 
"sentinel: banned $bhost on $chan ($reason)"
        
sl_ignore $bhost $reason
      
}
    }
  }
  return 
0
}

proc sl_ignore {ihost hand flood} {
  global 
sl_igtime
  
if {$hand != "*"} {
    foreach 
chan [channels] {
      if {[
matchattr $hand f|f $chan]} {return 0}
    }
  }
  if {![
string match *!* $ihost]} {
    foreach 
ignore [ignorelist] {
      if {[
string match [string tolower [lindex $ignore 0]] $ihost]} {
        return 
0
      
}
    }
    
set ihost [sl_masktype $ihost]
    if {[
isignore $ihost]} {return 0}
  } else {
    if {[
isignore $ihost]} {return 0}
    foreach 
ignore [ignorelist] {
      if {[
lindex $ignore 4] == "sentinel" && [string match $ihost [string tolower [lindex $ignore 0]]]} {
        
killignore $ignore
      
}
    }
  }
  
newignore $ihost sentinel $flood $sl_igtime
  putlog 
"sentinel: added $ihost to ignore list ($flood)"
  
return 1
}

# queuereset procs allow all queue timers to be killed easily
proc sl_ccqueuereset {chan} {
  global 
sl_ccqueue
  incr sl_ccqueue
($chan) -1
  
return 0
}

proc sl_bcqueuereset {} {
  global 
sl_bcqueue
  incr sl_bcqueue 
-1
  
return 0
}

proc sl_bmqueuereset {} {
  global 
sl_bmqueue
  incr sl_bmqueue 
-1
  
return 0
}

proc sl_avqueuereset {chan} {
  global 
sl_avqueue
  incr sl_avqueue
($chan) -1
  
return 0
}

proc sl_txqueuereset {} {
  global 
sl_txqueue sl_txflood
  
foreach chan [string tolower [channels]] {
    if {[
info exists sl_txqueue($chan)]} {
      
set sl_txqueue($chan0
    
}
  }
  
utimer [lindex $sl_txflood 1sl_txqueuereset
  
return 0
}

proc sl_nkqueuereset {chan} {
  global 
sl_nkqueue
  incr sl_nkqueue
($chan) -1
  
return 0
}

proc sl_boqueuereset {chan} {
  global 
sl_boqueue
  incr sl_boqueue
($chan) -1
  
return 0
}

proc sl_jqueuereset {chan} {
  global 
sl_jqueue
  incr sl_jqueue
($chan) -1
  
return 0
}

proc sl_pqueuereset {chan} {
  global 
sl_pqueue
  incr sl_pqueue
($chan) -1
  
return 0
}

proc sl_ccbanqueue {chan} {
  global 
sl_ccbanhost sl_ccbannick
  set sl_ccbannick
($chan) [lrange sl_ccbannick($chan1 end] ; set sl_ccbanhost($chan) [lrange sl_ccbanhost($chan1 end]
  return 
0
}

proc sl_avbanqueue {chan} {
  global 
sl_avbanhost sl_avbannick
  set sl_avbannick
($chan) [lrange sl_avbannick($chan1 end] ; set sl_avbanhost($chan) [lrange sl_avbanhost($chan1 end]
  return 
0
}

proc sl_nkbanqueue {chan} {
  global 
sl_nkbanhost
  set sl_nkbanhost
($chan) [lrange sl_nkbanhost($chan1 end]
  return 
0
}

proc sl_bobanqueue {chan} {
  global 
sl_bobanhost sl_bobannick
  set sl_bobannick
($chan) [lrange sl_bobannick($chan1 end] ; set sl_bobanhost($chan) [lrange sl_bobanhost($chan1 end]
  return 
0
}

proc sl_jbanqueue {chan} {
  global 
sl_jbanhost sl_jbannick
  set sl_jbannick
($chan) [lrange sl_jbannick($chan1 end] ; set sl_jbanhost($chan) [lrange sl_jbanhost($chan1 end]
  return 
0
}

proc sl_pbanqueue {chan} {
  global 
sl_pbanhost sl_pbannick
  set sl_pbannick
($chan) [lrange sl_pbannick($chan1 end] ; set sl_pbanhost($chan) [lrange sl_pbanhost($chan1 end]
  return 
0
}

proc sl_flud {nick uhost hand type chan} {
  global 
sl_flooded
  set chan 
[string tolower $chan]
  if {[
validchan $chan] && $sl_flooded($chan)} {return 1}
  return 
0
}

proc sl_lc {nick uhost hand chan arg} {
  global 
sl_lockcmds
  set chan 
[string tolower $chan]
  if {![
botisop $chan]} {return 0}
  if {
$sl_lockcmds == && ![isop $nick $chan]} {return 0}
  
sl_quicklock $chan
  putlog 
"sentinel: channel lock requested by $hand on $chan"
  
return 0
}

proc sl_uc {nick uhost hand chan arg} {
  global 
sl_lockcmds
  set chan 
[string tolower $chan]
  if {![
botisop $chan]} {return 0}
  if {
$sl_lockcmds == && ![isop $nick $chan]} {return 0}
  
putserv "MODE $chan -mi"
  
putlog "sentinel: channel unlock requested by $hand on $chan"
  
return 0
}

proc sl_dcclc {hand idx arg} {
  global 
sl_lockflags
  putcmdlog 
"#$hand# lock $arg"
  
set chan [lindex [split $arg0]
  if {
$chan == "-all"} {
    if {![
matchattr $hand $sl_lockflags]} {
      
putidx $idx "You're not global +$sl_lockflags." ; return 0
    
}
    
set locklist ""
    
foreach chan [channels] {
      if {[
botisop $chan]} {
        
sl_quicklock $chan
        lappend locklist $chan
      
}
    }
    
putidx $idx "Locked [join $locklist ""]"
  
} else {
    if {
$chan == ""} {
      
set chan [lindex [console $idx0]
    }
    if {![
validchan $chan]} {
      
putidx $idx "No such channel." ; return 0
    
} elseif {![matchattr $hand $sl_lockflags|$sl_lockflags $chan]} {
      
putidx $idx "You're not +$sl_lockflags on $chan." ; return 0
    
} elseif {![botonchan $chan]} {
      
putidx $idx "I'm not on $chan; return 0
    
} elseif {![botisop $chan]} {
      
putidx $idx "I'm not opped on $chan; return 0
    
}
    
sl_quicklock $chan
    putidx $idx 
"Locked $chan"
  
}
  return 
0
}

proc sl_dccuc {hand idx arg} {
  global 
sl_lockflags
  putcmdlog 
"#$hand# unlock $arg"
  
set chan [lindex [split $arg0]
  if {
$chan == "-all"} {
    if {![
matchattr $hand $sl_lockflags]} {
      
putidx $idx "You're not global +$sl_lockflags." ; return 0
    
}
    
set locklist ""
    
foreach chan [channels] {
      if {[
botisop $chan]} {
        
putserv "MODE $chan -mi"
        
lappend locklist $chan
      
}
    }
    
putidx $idx "Unlocked [join $locklist ""]"
  
} else {
    if {
$chan == ""} {
      
set chan [lindex [console $idx0]
    }
    if {![
validchan $chan]} {
      
putidx $idx "No such channel." ; return 0
    
} elseif {![matchattr $hand $sl_lockflags|$sl_lockflags $chan]} {
      
putidx $idx "You're not +$sl_lockflags on $chan." ; return 0
    
} elseif {![botonchan $chan]} {
      
putidx $idx "I'm not on $chan; return 0
    
} elseif {![botisop $chan]} {
      
putidx $idx "I'm not opped on $chan; return 0
    
}
    
putserv "MODE $chan -mi"
    
putidx $idx "Unlocked $chan"
  
}
  return 
0
}

proc sl_quicklock {chan} {
  global 
numversion
  
if {$numversion 1050000} {
    
putquick "MODE $chan +mi"
  
} else {
    
putquick "MODE $chan +mi" -next
  
}
}

proc sl_dcc {hand idx arg} {
  global 
sl_avflood sl_ban sl_banmax sl_bcflood sl_boban sl_boflood sl_bmflood sl_bxsimul sl_bfmaxbans sl_ccflood sl_detectquits sl_globalban sl_igtime sl_jflood sl_kicks sl_lockcmds sl_lockflags sl_ilocktime sl_mlocktime sl_nkflood sl_note sl_shortlock sl_tsunami sl_txflood
  putcmdlog 
"#$hand# sentinel $arg"
  
putidx $idx "This bot is protected by sentinel.tcl by slennox"
  
putidx $idx "Current settings"
  
if {[lsearch -exact $sl_bcflood 0] != -1} {
    
putidx $idx "- Bot CTCP flood:           Off"
  
} else {
    
putidx $idx "- Bot CTCP flood:           [lindex $sl_bcflood 0] in [lindex $sl_bcflood 1] secs"
  
}
  if {[
lsearch -exact $sl_bmflood 0] != -1} {
    
putidx $idx "- Bot MSG flood:            Off"
  
} else {
    
putidx $idx "- Bot MSG flood:            [lindex $sl_bmflood 0] in [lindex $sl_bmflood 1] secs"
  
}
  if {[
lsearch -exact $sl_ccflood 0] != -1} {
    
putidx $idx "- Channel CTCP flood:       Off"
  
} else {
    
putidx $idx "- Channel CTCP flood:       [lindex $sl_ccflood 0] in [lindex $sl_ccflood 1] secs"
  
}
  if {[
lsearch -exact $sl_avflood 0] != -1} {
    
putidx $idx "- Channel AVALANCHE flood:  Off"
  
} else {
    
putidx $idx "- Channel AVALANCHE flood:  [lindex $sl_avflood 0] in [lindex $sl_avflood 1] secs"
  
}
  if {[
lsearch -exact $sl_avflood 0] != -|| !$sl_tsunami} {
    
putidx $idx "- Channel TSUNAMI flood:    Off"
  
} else {
    
putidx $idx "- Channel TSUNAMI flood:    [lindex $sl_avflood 0] in [lindex $sl_avflood 1] secs ($sl_tsunami ctrl codes / line)"
  
}
  if {[
lsearch -exact $sl_txflood 0] != -1} {
    
putidx $idx "- Channel TEXT flood:       Off"
  
} else {
    
putidx $idx "- Channel TEXT flood:       [lindex $sl_txflood 0] in [lindex $sl_txflood 1] secs"
  
}
  if {[
lsearch -exact $sl_boflood 0] != -1} {
    
putidx $idx "- Channel BOGUS flood:      Off"
  
} else {
    
putidx $idx "- Channel BOGUS flood:      [lindex $sl_boflood 0] in [lindex $sl_boflood 1] secs"
  
}
  if {
$sl_detectquits} {
    
set detectquits "quit detection ON"
  
} else {
    
set detectquits "quit detection OFF"
  
}
  if {[
lsearch -exact $sl_jflood 0] != -1} {
    
putidx $idx "- Channel JOIN-PART flood:  Off"
  
} else {
    
putidx $idx "- Channel JOIN-PART flood:  [lindex $sl_jflood 0] in [lindex $sl_jflood 1] secs ($detectquits)"
  
}
  if {[
lsearch -exact $sl_nkflood 0] != -1} {
    
putidx $idx "- Channel NICK flood:       Off"
  
} else {
    
putidx $idx "- Channel NICK flood:       [lindex $sl_nkflood 0] in [lindex $sl_nkflood 1] secs"
  
}
  if {!
$sl_ilocktime} {
    
putidx $idx "- Channel +i locktime:      Indefinite"
  
} else {
    
putidx $idx "- Channel +i locktime:      $sl_ilocktime secs"
  
}
  if {!
$sl_mlocktime} {
    
putidx $idx "- Channel +m locktime:      Indefinite"
  
} else {
    
putidx $idx "- Channel +m locktime:      $sl_mlocktime secs"
  
}
  if {
$sl_shortlock && $sl_ban} {
    
putidx $idx "- Small flood short lock:   Active"
  
} else {
    
putidx $idx "- Small flood short lock:   Inactive"
  
}
  if {
$sl_ban && $sl_ban 120} {
    
putidx $idx "- Channel flood bans:       $sl_ban mins"
  
} elseif {$sl_ban >= 120} {
    
putidx $idx "- Channel flood bans:       [expr $sl_ban / 60] hrs"
  
} else {
    
putidx $idx "- Channel flood bans:       Disabled"
  
}
  if {!
$sl_boban || [lsearch -exact $sl_boflood 0] != -1} {
    
putidx $idx "- Bogus username bans:      Disabled"
  
} elseif {$sl_boban && $sl_boban 120} {
    
putidx $idx "- Bogus username bans:      $sl_boban mins"
  
} elseif {$sl_boban >= 120} {
    
putidx $idx "- Bogus username bans:      [expr $sl_boban / 60] hrs"
  
}
  if {
$sl_ban || [lsearch -exact $sl_boflood 0] == -1} {
    if {
$sl_globalban} {
      
putidx $idx "- Ban type:                 Global [sl_masktype nick@host.domain]"
    
} else {
      
putidx $idx "- Ban type:                 Channel-specific [sl_masktype nick@host.domain]"
    
}
  }
  if {
$sl_ban || [lsearch -exact $sl_boflood 0] == -1} {
    
putidx $idx "- Maximum bans:             $sl_banmax"
  
}
  if {
$sl_igtime && $sl_igtime 120} {
    
putidx $idx "- Flooder ignores:          $sl_igtime mins"
  
} elseif {$sl_igtime >= 120} {
    
putidx $idx "- Flooder ignores:          [expr $sl_igtime / 60] hrs"
  
} else {
    
putidx $idx "- Flooder ignores:          Permanent"
  
}
  if {
$sl_ban} {
    
putidx $idx "- Kicks per line:           $sl_kicks"
  
}
  if {!
$sl_bfmaxbans} {
    
putidx $idx "- Maximum channel bans:     Disabled"
  
} else {
    
putidx $idx "- Maximum channel bans:     $sl_bfmaxbans"
  
}
  if {
$sl_note != ""} {
    
putidx $idx "- Flood notification:       Notifying [join $sl_note ""]"
  
} else {
    
putidx $idx "- Flood notification:       Off"
  
}
  if {!
$sl_lockcmds} {
    
putidx $idx "- Public lc/uc commands:    Disabled"
  
} elseif {$sl_lockcmds == 1} {
    
putidx $idx "- Public lc/uc commands:    Enabled (+$sl_lockflags users, ops not required)"
  
} elseif {$sl_lockcmds == 2} {
    
putidx $idx "- Public lc/uc commands:    Enabled (+$sl_lockflags users, ops required)"
  
}
  if {
$sl_bxsimul} {
    
putidx $idx "- BitchX simulation:        On"
  
} elseif {!$sl_bxsimul} {
    
putidx $idx "- BitchX simulation:        Off"
  
}
  return 
0
}

if {
$sl_bxsimul} {
  
bind raw 001 sl_bxserverjoin
  
if {![info exists sl_bxonestack]} {
    
set sl_bxonestack 0
  
}
  if {![
info exists sl_bxversion]} {
    
set sl_bxversion [lindex {75p175p3+} [rand 2]]
  }
  
set sl_bxsystem "*IX" set sl_bxwhoami $username set sl_bxmachine ""
  
catch {set sl_bxsystem [exec uname --r]}
  catch {
set sl_bxwhoami [exec id -un]}
  catch {
set sl_bxmachine [exec uname -n]}
  
set sl_bxjointime [unixtime]
  
proc sl_bxserverjoin {from keyword arg} {
    global 
sl_bxjointime sl_bxisaway
    set sl_bxjointime 
[unixtime] ; set sl_bxisaway 0
    
return 0
  
}
  
proc sl_bxaway {} {
    global 
sl_bxjointime sl_bxisaway
    
if {!$sl_bxisaway} {
      
puthelp "AWAY :is away: (Auto-Away after 10 mins) \[\002BX\002-MsgLog [lindex {On Off} [rand 2]]\]"
      
set sl_bxisaway 1
    
} else {
      
puthelp "AWAY"
      
set sl_bxisaway 0 set sl_bxjointime [unixtime]
    }
    if {![
string match *sl_bxaway* [timers]]} {
      
timer [expr [rand 300] + 10sl_bxaway
    
}
    return 
0
  
}
  if {![
info exists sl_bxisaway]} {
    
set sl_bxisaway 0
  
}
  if {![
string match *sl_bxaway* [timers]]} {
    
timer [expr [rand 300] + 10sl_bxaway
  
}
}

proc sl_setarray {chan} {
  global 
sl_avbanhost sl_avbannick sl_avqueue sl_bfull sl_bobanhost sl_bobannick sl_boqueue sl_ccbanhost sl_ccbannick sl_ccqueue sl_flooded sl_jbanhost sl_jbannick sl_jqueue sl_locked sl_nkbanhost sl_nkflooding sl_nkqueue sl_pbanhost sl_pbannick sl_pqueue sl_txqueue sl_unlocked
  set chan 
[string tolower $chan]
  
sl_killutimer "incr sl_*queue($chan) -1"
  
sl_killutimer "sl_*banqueue $chan"
  
sl_killutimer "sl_*queuereset $chan"
  
set sl_flooded($chanset sl_locked($chanset sl_unlocked($chan) [unixtime]
  
set sl_nkflooding($chan) [unixtime]
  
set sl_ccqueue($chanset sl_ccbanhost($chan"" set sl_ccbannick($chan""
  
set sl_avqueue($chanset sl_avbanhost($chan"" set sl_avbannick($chan""
  
set sl_txqueue($chan0
  set sl_nkqueue
($chanset sl_nkbanhost($chan""
  
set sl_boqueue($chanset sl_bobanhost($chan"" set sl_bobannick($chan""
  
set sl_jqueue($chanset sl_jbanhost($chan"" set sl_jbannick($chan""
  
set sl_pqueue($chanset sl_pbanhost($chan"" set sl_pbannick($chan""
  
set sl_bfull($chan0
  
return 0
}

proc sl_unsetarray {chan} {
  global 
sl_avbanhost sl_avbannick sl_avqueue sl_bfull sl_bobanhost sl_bobannick sl_boqueue sl_ccbanhost sl_ccbannick sl_ccqueue sl_flooded sl_jbanhost sl_jbannick sl_jqueue sl_locked sl_nkbanhost sl_nkflooding sl_nkqueue sl_pbanhost sl_pbannick sl_pqueue sl_txqueue sl_unlocked
  set chan 
[string tolower $chan]
  if {![
validchan $chan] && [info exists sl_flooded($chan)]} {
    unset 
sl_flooded($chansl_locked($chansl_unlocked($chansl_nkflooding($chansl_ccqueue($chansl_ccbanhost($chansl_ccbannick($chansl_avqueue($chansl_avbanhost($chansl_avbannick($chansl_txqueue($chansl_nkqueue($chansl_nkbanhost($chansl_boqueue($chansl_bobanhost($chansl_bobannick($chansl_jqueue($chansl_jbanhost($chansl_jbannick($chansl_pqueue($chansl_pbanhost($chansl_pbannick($chansl_bfull($chan)
  }
  return 
0
}

proc sl_settimer {} {
  foreach 
chan [channels] {
    
sl_setarray $chan
  
}
  return 
0
}

proc sl_killutimer {cmd} {
  
set n 0
  regsub 
-all -- {\[} $cmd {\[} cmd regsub -all -- {\]} $cmd {\]} cmd
  
foreach tmr [utimers] {
    if {[
string match $cmd [join [lindex $tmr 1]]]} {
      
killutimer [lindex $tmr 2]
      
incr n
    
}
  }
  return 
$n
}

proc sl_masktype {uhost} {
  global 
sl_masktype
  
switch -exact -- $sl_masktype {
    
{return *!*[string range $uhost [string first $uhostend]}
    
{return *!*$uhost}
    
{return *!*[lindex [split [maskhost $uhost"!"1]}
  }
  return
}

if {![
info exists sl_unlocked] && ![string match *sl_settimer* [utimers]]} {
  
utimer 3 sl_settimer
}

if {![
info exists sl_bflooded]} {
  
set sl_bflooded 0
}
if {![
info exists sl_bcqueue]} {
  
set sl_bcqueue 0
}
if {![
info exists sl_bmqueue]} {
  
set sl_bmqueue 0
}
if {![
info exists sl_nickkick]} {
  
set sl_nickkick 0
}

set sl_bcflood [split $sl_bcflood :] ; set sl_bmflood [split $sl_bmflood :]
set sl_ccflood [split $sl_ccflood :] ; set sl_avflood [split $sl_avflood :]
set sl_txflood [split $sl_txflood :] ; set sl_boflood [split $sl_boflood :]
set sl_jflood [split $sl_jflood :] ; set sl_nkflood [split $sl_nkflood :]
set sl_note [split $sl_note]

if {
$sl_ilocktime && $sl_ilocktime 30} {
  
set sl_ilocktime 30
}
if {
$sl_mlocktime && $sl_mlocktime 30} {
  
set sl_mlocktime 30
}

set trigger-on-ignore 0
if {!${kick-method}} {
  
set sl_kicks 8
} else {
  
set sl_kicks ${kick-method}
}

if {
$numversion <= 1040400} {
  if {
$numversion >= 1032100} {
    
set kick-bogus 0
  
}
  if {
$numversion >= 1032400} {
    
set ban-bogus 0
  
}
}
if {
$numversion >= 1032400} {
  
set kick-fun 0 set ban-fun 0
}
if {
$numversion >= 1032500} {
  
set ctcp-mode 0
}

if {![
string match *sl_txqueuereset* [utimers]] && [lsearch -exact $sl_txflood 0] == -1} {
  
utimer [lindex $sl_txflood 1sl_txqueuereset
}

bind pub $sl_lockflags|$sl_lockflags lc sl_lc
bind pub $sl_lockflags
|$sl_lockflags uc sl_uc
bind dcc $sl_lockflags
|$sl_lockflags lock sl_dcclc
bind dcc $sl_lockflags
|$sl_lockflags unlock sl_dccuc
if {!$sl_lockcmds} {
  
unbind pub $sl_lockflags|$sl_lockflags lc sl_lc
  unbind pub $sl_lockflags
|$sl_lockflags uc sl_uc
  rename sl_lc 
""
  
rename sl_uc ""
}
bind dcc m|m sentinel sl_dcc
bind raw 
NOTICE sl_avflood
bind raw 
PRIVMSG sl_avflood
if {[lsearch -exact $sl_avflood 0] != -&& [lsearch -exact $sl_txflood 0] != -1} {
  
unbind raw NOTICE sl_avflood
  unbind raw 
PRIVMSG sl_avflood
  rename sl_avflood 
""
}
bind ctcp CLIENTINFO sl_ctcp
bind ctcp 
USERINFO sl_ctcp
bind ctcp 
VERSION sl_ctcp
bind ctcp 
FINGER sl_ctcp
bind ctcp 
ERRMSG sl_ctcp
bind ctcp 
- ECHO sl_ctcp
bind ctcp 
INVITE sl_ctcp
bind ctcp 
WHOAMI sl_ctcp
bind ctcp 
OP sl_ctcp
bind ctcp 
OPS sl_ctcp
bind ctcp 
UNBAN sl_ctcp
bind ctcp 
PING sl_ctcp
bind ctcp 
TIME sl_ctcp
bind msgm 
- * sl_bmflood
if {[lsearch -exact $sl_bmflood 0] != -1} {
  
unbind msgm - * sl_bmflood
  rename sl_bmflood 
""
}
bind nick - * sl_nkflood
if {[lsearch -exact $sl_nkflood 0] != -1} {
  
unbind nick - * sl_nkflood
  rename sl_nkflood 
""
}
bind join - * sl_jflood
bind part 
- * sl_pflood
bind sign 
- * sl_pflood
if {![info exists sl_detectquits]} {
  
set sl_detectquits 0
}
if {!
$sl_detectquits} {
  
unbind sign - * sl_pflood
}
bind kick - * sl_pfloodk
bind flud 
- * sl_flud
bind mode 
- * sl_mode

putlog 
"Loaded sentinel.tcl v2.70 by slennox"

return 

 Ahmet isimli Üye şimdilik offline konumundadır   Alıntı

Yeni Konu   Cevap Yaz

Etiketler
botu, eggdrop, koruma, sentineltcl


Konuyu Toplam 1 Üye okuyor. (0 Kayıtlı üye ve 1 Misafir)
 
Seçenekler
Stil

Yetkileriniz
Konu Acma Yetkiniz Yok
Cevap Yazma Yetkiniz Yok
Eklenti Yükleme Yetkiniz Yok
Mesajınızı Değiştirme Yetkiniz Yok

BB code is Açık
Smileler Açık
[IMG] Kodları Açık
HTML-Kodu Kapalı
Trackbacks are Açık
Pingbacks are Açık
Refbacks are Açık


Benzer Konular
Konu Konuyu Başlatan Forum Cevaplar Son Mesaj
N-Bot (Nevarline Socket Koruma Botu) pCkOpAt mIRC/Socket Botlar 3 31 Ocak 2019 15:10
Koruma Botu İstekleriniz Vesaire mIRC/Socket Botlar 6 05 Aralık 2018 01:53
daHi Koruma Botu Güncel Link No_FeaR mIRC/Socket Botlar 1 12 Şubat 2017 23:29
IGS v0.3 Koruma Botu No_FeaR mIRC/Socket Botlar 0 19 Nisan 2015 12:01
Koruma Botu Arşivi! Entrance mIRC/Socket Botlar 0 01 Şubat 2015 12:55

web hosting web hosting
 buy vds
 vps buy

Powered by vBulletin®
Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.