Jump to content

chain

Administrators
  • Posts

    5,983
  • Joined

  • Last visited

  • Days Won

    17

Posts posted by chain

  1. It's become fun learning stuff on IRCWX  server its become more and more fun as I go along. it's brought me back to scripting and marketing and etc.

    We have tried to target IRC chatters that use Mibbit and other webchat sources, but when it comes down to IRC scripters they don't like change much. 

    So hopefully as IRCWX is progressing more in more and we hopefully can connect a portal towards IRC scripters it's a great learning experince and doing this with good friends.

    I still believe we can get more chatters on IRCWX Networks and bring back a lot of old chatters!! it takes time but day by day we try. even if we have a few to that come back on means we are moving forward.

    The goal is to aim that chatters use this type of network that is safe and more reliable then discord or any other chat source. 

    A few of the other Networks were afraid that we were out there to take there chatter's, this was not the case this was for IRC-Community to help IRCWX and maintain a good base that would bring in more people. Also it creates a place were err0r can create and add more to the IRCWX system. It enables us to move forward and help Duke create a chat environment that will grab users to engage with this network.

    So lets continue to build IRCWX and great chat place.

  2. # No services privmsg by JohnnyCage 
    
    set ChanServ_nick "CS"
    set NickServ_nick "NS"
    set MemoServ_nick "MS"
    
    bind dcc -|- msg check_msg
    
    proc check_msg { arg1 arg2 arg3 } {
        global ChanServ_nick NickServ_nick MemoServ_nick
        set saob [lrange $arg3 1 end]
        set kamkogo [lindex $arg3 0]
        set kamkogo [string toupper $kamkogo 0 end]
        if {![matchattr $arg1 +n]} {
    	if {$kamkogo == $ChanServ_nick || $kamkogo == $NickServ_nick || $kamkogo == $MemoServ_nick} {
    	    putlog "$arg1, only +n flag users can write private with $kamkogo!"
    	    return 0
    	}
        }
        putserv "PRIVMSG $kamkogo :$saob"
    }
    
    putlog "No services privmsg loaded"

     

  3. ### autowhom.tcl v1.0.0, 
    ### by Graeme Donaldson
    ### Automatically does a .whom when a user logs on to partyline.
    
    set awver "1.0.0"
    set awnver "100000"
    
    putlog "Loading autowhom.tcl $awver by Souperman..."
    
    bind chon - * awdowhom
    
    proc awdowhom {hand idx} {
    	*dcc:whom $hand $idx *
    }
    putlog "Successfully loaded autowhom.tcl $awver by Souperman!"

     

  4. # partyline notify 1.2.1 - by wreck
    # thanks to: blood_x, ppslim, quasimodo
    #
    
    # Set this to the channel to notify.
    set party-chan "#Channel #Channel2 #Channel3"
    
    proc login:party {hand idx} {
      global party-chan
      foreach who [dcclist] {
        if {[lindex $who 1] == $hand} {
          if {[string length [set email [getuser $hand XTRA EMAIL]]] > 0} {
            puthelp "PRIVMSG ${party-chan} :$hand \[\002$email\002\] \([lindex $who 2]\) Connected."
          } else {
            puthelp "PRIVMSG ${party-chan} :$hand \([lindex $who 2]\) Connected."
          }
          break
        }
      }
    }
    
    proc logout:party {hand idx} {
      global party-chan party-just-quit
      if {[info exists party-just-quit] && ${party-just-quit} == $hand} {unset party-just-quit ; return 0}
      puthelp "PRIVMSG ${party-chan} :$hand Disconnected \(lost connection\)."
    }
    
    proc logout:filt {idx text} {
      global party-chan party-just-quit
      set hand [idx2hand $idx]
      set party-just-quit $hand
      if {[llength $text] > 1} {
        puthelp "PRIVMSG ${party-chan} :$hand Disconnected \([lrange [split $text] 1 end]\)."
      } else {
        puthelp "PRIVMSG ${party-chan} :$hand Disconnected \(lost connection\)."
      }
      return $text
    }
    
    bind chon - * login:party
    bind chof - * logout:party
    bind filt - .quit* logout:filt
    
    putlog "partyline-notify :${party-chan} :Loaded"

     

  5. # Anti Trout Slap v1.1 By Dude
    
    # Kick method
    # 0 = Kick the user who slaps bot
    # 1 = Kick the user who slaps anybody
    # 2 = Kickban the user who slaps bot
    # 3 = Kickban the user who slaps anybody
    set troutkickmethod 0
    
    set troutkickreason "Reason here!"
    
    # BAN Time
    set troutbantime 120
    
    bind ctcp - ACTION antitrout:ctcp:action
    
    proc antitrout:ctcp:action {nick uhost hand dest keyword arg} {
     global botnick troutkickmethod troutkickreason troutbantime
     if { [validchan $dest] == 1 && ([string tolower [lindex $arg 0]] == "slaps" || [string tolower [lindex $arg 0]] == "slap") && [lsearch [string tolower $arg] trout] >= 2 && [string tolower $nick] != [string tolower $botnick] && [botisop $dest] == 1 } {
      if { $troutkickmethod == 0 && [string tolower [lindex $arg 1]] == [string tolower $botnick] } {
       putserv "kick $dest $nick :$troutkickreason"
      }
      if { $troutkickmethod == 1 } {
       putserv "kick $dest $nick :$troutkickreason"
      }
      if { $troutkickmethod == 2 && [string tolower [lindex $arg 1]] == [string tolower $botnick] } {
       scan [string tolower [getchanhost $nick $dest]] "%\[^@]@%s" host host
       newchanban $dest *!*@$host $botnick "$troutkickreason" $troutbantime
      }
      if { $troutkickmethod == 3 } {
       scan [string tolower [getchanhost $nick $dest]] "%\[^@]@%s" host host
       newchanban $dest *!*@$host $botnick "$troutkickreason" $troutbantime
      }
     }
     return 0
    }
    putlog "Anti-Slap loaded!"

     

  6. # MSG Filter v1.1
    
    set nomsg(ignflags) "n"
    
    set nomsg(filter) {
       "NickName"
       "NickName1"
       "#Channel"
       "#Channel1"
    }
    bind dcc -|- msg nomsg:filter
    proc nomsg:filter {hand idx arg} {
    global nomsg
    set victime [string tolower [lindex $arg 0]]
    foreach filter $nomsg(filter) {
       if {($victime == $filter) && ![matchattr $hand $nomsg(ignflags)|]} {
          putdcc $idx "You Don`t Have AutoriZatioN to Use .msg Those NickNames!!"
          return 0
       }
    }
    putserv "PRIVMSG $victime :[lrange $arg 1 end]"
    putdcc $idx "Msg to [lindex $arg 0]: [lrange $arg 1 end]"
    return 1
    }
    
    putlog "MSG Filter v1.1 by Neon loaded!"

     

  7. Google has pulled several “stalkerware” ads that violated its policies by promoting apps that encouraged prospective users to spy on their spouses’ phone.

    These consumer-grade spyware apps are often marketed to parents wishing to monitor their child’s calls, messages, apps, photos and location, often under the guise of protecting against predators. But these apps, which are often designed to be installed surreptitiously and without the device owner’s consent, have been repurposed by abusers to spy on the phones of their spouses.

    The rise in the use of so-called “stalkerware” (or spouseware) prompted an industrywide response in recent years to combat the spread of phone monitoring apps. Antivirus makers have worked to better detect stalkerware, and federal authorities are taking action against spyware makers that further expose their victims to security threats. Last August, Google banned ads in users’ search results that promoted apps that are designed “with the express purpose of tracking or monitoring another person or their activities without their authorization.”

     

    Read More Here

  8. It took quite some time, but here it is: an official stable 5.0.0.

    Since the beta1 release several bugs were fixed and the codebase has been
    polished a quite lot. The last stable release was more than six years ago,
    so the changes are really too many to be listed. You're encouraged to upgrade
    and just try it out.

    Most prominent contributors to this release are @IceN9ne, @wodim, @Stanzilla,
    @DarthGandalf, @Dessa, @staticfox, @AndrioCelos and @craftwar: Honor and Glory! 🙂
    As usual, developers hang around #kvirc@Freenode. Come in and say hi!

    Have fun!
    Szymon Stefanek and The KVIrc Development Team

    KVIrc-5.0.0-x86-Debug.exe

  9. alias opens {
      set %nick chain
      set %chan #coders-irc-lounge
      set %root D:/Abs/www
      sockopen LOG1 cs1.coders-irc.net  10001
    }
    on *:SOCKOPEN:LOG*:{
      sockwrite -n $sockname NICK %nick
      sockwrite -n $sockname USER project . . Socket
      sockwrite -n $sockname USERHOST $sockname
      .timer 1 3 /sockwrite -n $sockname JOIN %chan
    }
    on *:SOCKCLOSE:LOG*:{ .timer 1 5 /opens }
    on *:SOCKREAD:LOG*:{
      sockread %temp
      tokenize 32 $gettok(%temp,1-,32)
    
      var %file = %root $+ $gettok($3,1,58) $+ .txt
      var %file2 = %root $+ $gettok($3,1,58) $+ .txt
    
      if ($1 == PING) { sockwrite -n $sockname PONG $2 | return }
      if ($gettok($4,1,58) == VERSION) { sockwrite -n $sockname NOTICE $gettok($gettok($1,1,58),1,33) : $+ $chr(1) $+ VERSION mIRC Socket by codelibary.com $+ $chr(1) | return }
      if ($2 == PRIVMSG) {
        if ($left($3,1) == $chr(35)) {
          if ($gettok($gettok($gettok($1-,4,32),1,58),1,1) == ACTION) { write %file $timestamp * $gettok($gettok($1,1-,58),1,33) $gettok($5-,1,1) }
          else { write %file $timestamp < $+ $gettok($gettok($1,1,58),1,33) $+ > $gettok($4-,1-,58) }
        }
        else {
          if ($gettok($gettok($gettok($1-,4,32),1,58),1,1) == ACTION) { write %file2 $timestamp * $gettok($gettok($1,1-,58),1,33) $gettok($5-,1,1) }
          else { write %file2 $timestamp < $+ $gettok($gettok($1,1,58),1,33) $+ > $gettok($4-,1-,58) }
        }
      }
      if ($2 == 332) { write %file $timestamp * Topic is ' $+ $gettok($4-,2,58) $+ ' }
      if ($2 == 333) { write %file $timestamp * Set by $5 on $date(1113566259) @ $time(1113566259) }
      if ($2 == JOIN) {
        if ($gettok($gettok($1,1,58),1,33) == %nick) { write %file $timestamp * Now talking in $gettok($3,1,58) }
        else { write %file $timestamp * $gettok($gettok($1,1,58),1,33) ( $+ $gettok($gettok($1,1,58),2,33) $+ ) has joined $gettok($3,1,58) }
      }
      if ($2 == PART) { write %file $timestamp * $gettok($gettok($1,1,58),1,33) ( $+ $gettok($gettok($1,1,58),2,33) $+ ) has left $gettok($3,1,58) }
      if ($2 == NOTICE && $left($3,1) == $chr(35)) { write %file $timestamp - $+ $gettok($gettok($1,1,58),1,33) $+ : $+ $gettok($3,1,58) $gettok($4-,1,58) }
      if ($2 == NOTICE && $left($3,1) != $chr(35)) { write %file $timestamp - $+ $gettok($gettok($1,1,58),1,33) $+ - $gettok($4-,1,58) }
      if ($2 == TOPIC) { write %file $timestamp * $gettok($gettok($1,1,58),1,33) changes topic to ' $+ $gettok($4,1,58) $+ ' }
      if ($2 == KICK) {
        if ($4 == %nick) {
          write %file $timestamp * You were kicked by $gettok($gettok($1,1,58),1,33) ( $+ $gettok($5-,1,58) $+ )
          write %file $timestamp * Attempting to rejoin channel $3
          sockwrite -n $sockname join $3
        }
        else { write %file $timestamp * $4 was kicked by $gettok($gettok($1,1,58),1,33) ( $+ $gettok($5-,1,58) $+ ) }
      }
      if ($2 == MODE) { write %file $timestamp * $gettok($gettok($1,1,58),1,33) sets mode $4 $5 }
    }

     

  10. alias trivia {
      if ($1 == on) { set %trivia on | set %botnick $?="Bot's nick?" | echo -a Trivia ON | return }
      if ($1 == off) { set %trivia off | unset %botnick | echo -a Trivia OFF | return }
    }
    on *:TEXT:*:#:{
      if $nick == %botnick && %trivia == on {
        if ($strip($1-) isin $read(trivia.questions, w, * $+ $strip($1-))) {
          set %text $strip($1-)
          set %number $readn
          set %ftext $remove($read(trivia.questions, g, %number),| $+ %text)
        }
        if ($strip($1) == Hint:) { set %len $len($2-) | answer | return }
      }
    }
    alias answer {
      if (| isin %ftext) { goto end | halt | return }
      if (%len != $len($remove(%ftext,| $+ %text))) { goto end | halt | return }
      else {
        if ($len(%text) >= 70) { .timer 1 7 /msg # $lower(%ftext) | goto end | return }
        if ($len(%text) <= 70) { .timer 1 5 /msg # $lower(%ftext) | goto end | return }
      }
      :end
      unset %number %text %ftext %len
    }

     

  11. on !@*:TEXT:!*:#:{
      if ($1 == !op) {
        if ($2 == $null) { mode # +o $nick | return }
        if ($2 isnum) {
          if ($gettok($2-,*,32) > 1) {
            var %inc = 0
            while %inc != $gettok($2-,*,32) {
              inc %inc
              var %opz = $nick(#,$gettok($2-,%inc,32)) %opz
              var %sopz = o $+ %sopz
            }
            mode # + $+ %sopz %opz
          }
          else { if $nick(#,$2) != $me mode # +o $nick(#,$2) | return }
        }
      }
      if ($1 == !deop) && ($2 != $me) {
        if ($2 == $null) { mode # -o $nick | return }
        if ($2 isnum) {
          if ($gettok($2-,*,32) > 1) {
            var %inc = 0
            while %inc != $gettok($2-,*,32) {
              inc %inc
              if ($nick(#,$gettok($2-,%inc,32)) != $me) {
                var %opz = $nick(#,$gettok($2-,%inc,32)) %opz
                var %sopz = o $+ %sopz
              }
            }
            mode # - $+ %sopz %opz
          }
          else { if $nick(#,$2) != $me mode # -o $nick(#,$2) | return }
        }
      }
    }

     

  12. set web_chans(#online) online.html
    set web_dir D:/Abs/www
    set web_update 1
    foreach i [timers] {
        if {[lindex $i 1] == "web_write"} {
            killtimer [lindex $i 2]
        }
    }
    
    if ![info exists web_topic] {set web_topic(*) "*"}
    foreach i [channels] {set web_topic($i) ""}
    proc web_write {} {
        global web_dir web_update botnick nick web_topic web_chans
        foreach i [array names web_chans] {
            set wpage $web_dir$web_chans($i)
            set web_page $web_chans($i)
            set web_chan $i
            set a [open $wpage w]
            if {$web_topic($i) == ""} {
                set web_topic($i) "topic unknown"
            }
            puts $a "<META HTTP-EQUIV=\"refresh\" content=\"[expr $web_update * 60]\; url=$web_page\">"
            puts $a "<TITLE>$web_chan IRC channel stats (Written at [time] [date])</TITLE>"
            puts $a "<CENTER><FONT face=Verdana SIZE=\"5\"><B>$nick's $web_chan stats</B></FONT><BR><FONT face=Verdana size=2>Topic:$web_topic($i)</FONT></CENTER><P>"
            if {![onchan $botnick $web_chan]} {
                puts $a "<FONT face=Verdana SIZE=2><center><B>I ($nick) am currently not on $web_chan, try again later</center></B></FONT>"
                puts $a "<CENTER><FONT face=Verdana SIZE=4><B>$web_chan, [getchanmode $web_chan] ([llength [chanlist $web_chan]] users)</FONT></B></CENTER>"
            }
            puts $a "<CENTER>"
            puts $a "<TABLE BORDER=0 bgcolor=black cellSpacing=1 cellPadding=0 width=100%>"
            puts $a "<TR bgcolor=silver><TD bgcolor=silver><FONT face=Verdana size=2 COLOR=black><center><B>Nickname</B></center></td><td bgcolor=silver><FONT face=Verdana size=2 COLOR=black><center><B>Status/info line</B></center></td><td bgcolor=silver><FONT face=Verdana size=2 COLOR=black><center><b>Address</B></center></td></tr>"
            set chanlist [chanlist $web_chan]
            set chanlist "$botnick [lsort [lrange $chanlist 1 end]]"
            set oplist ""
            set vlist ""
            set noplist ""
            set noplist2 ""
            foreach i $chanlist {if [isop $i $web_chan] {lappend oplist $i} {lappend noplist $i}}
            foreach i $noplist {
                if [isvoice $i $web_chan] {
                    lappend vlist $i
                } {
                    lappend noplist2 $i
                }
            }
            set noplist $noplist2
            foreach i "\{$oplist\} \{$noplist\} \{$vlist\}" {
                foreach b $i {
                    set c ""
                    if {[isop $b $web_chan]} {set q "<FONT face=Verdana COLOR=red size=2>@</FONT>"} {set q ""}
                    if {[isvoice $b $web_chan]} {set q "<FONT face=Verdana COLOR=red size=2>+</FONT>"}
                    if {[matchattr [nick2hand $b $web_chan] b]} {append c ", (BOT)"}
                    if {$botnick == $b} {
                        puts $a "<TR bgcolor=white><TD bgcolor=white><FONT face=Verdana size=2>$q$b</TD><TD bgcolor=white><FONT face=Verdana size=2>Eggdrop Service</TD><TD bgcolor=white></TD></TR>"
                    }
                    if {$botnick != $b} {
                        set hand [nick2hand $b $web_chan]
                        puts $a "<TR bgcolor=white><TD bgcolor=white><FONT face=Verdana size=2>$q$b</TD><TD bgcolor=white><FONT face=Verdana size=2>Idle [getchanidle $b $web_chan] min$c</TD><TD bgcolor=white><FONT face=Verdana size=2>[getchanhost $b $web_chan]</TD></TR>"
                        if {[getchaninfo $hand $web_chan] != "" && ![matchattr $b b] && $hand != "*"} {
                            puts $a "<TR bgcolor=white><TD bgcolor=white></TD><TD COLSPAN=2 bgcolor=white><FONT face=Verdana size=2><I>Info: [getchaninfo [nick2hand $b $web_chan] $web_chan]</I></TD></TR>"
                        }
                    }
                }
            }
            puts $a "</TABLE>"
            if {[chanbans $web_chan] != ""} {
                puts $a "<P><TABLE BORDER=0 bgcolor=black cellSpacing=1 cellPadding=0 width=100%>"
                puts $a "<TR bgcolor=silver><TD bgcolor=silver><CENTER><FONT face=Verdana SIZE=2><B>Bans:</B></FONT></CENTER></TD></TR>"
                foreach c [chanbans $web_chan] {
                    puts $a "<TR bgcolor=white><TD bgcolor=white><FONT face=Verdana size=2>$c</TD></TR>"
                }
                puts $a "</TABLE>"
            }
            puts $a "</CENTER>"
            puts $a "<P><BR><FONT face=Verdana SIZE=2><CENTER>This page is updated every $web_update minute(s).</CENTER>"
            puts $a "<FONT face=Verdana SIZE=2><CENTER>HTML2.Tcl Eggdrop 1.3 script</CENTER>"
            close $a
        }
        timer $web_update web_write
    }
    bind topc - * web_topic
    proc web_topic {nick uhost handle channel vars} {
        global web_topic web_chans
        if {[lsearch [array names web_chans] $channel] != "-1"} {
            set web_topic($channel) $vars
        }
    }
    web_write
    putlog "\002HTML2\002 - Writing: [array names web_chans] :stats files"

     

  13. unbind dcc - +host *dcc:+host
    bind dcc p|p +host *dcc:+host
    
    proc *dcc:+host {hand idx arg} {
    	if {[llength $arg] < 1} {
    		putdcc $idx "Usage: +host \[handle\] <newhostmask>"
    		return
    	}
    	if {[llength $arg] > 1} {
    		set user [lindex $arg 0]
    		set host [lindex $arg 1]
    		if {[validuser $user] == 0} {
    			putdcc $idx "No such user."
    			return
    		}
    		if {[llength [getuser $user HOSTS]] > 2 && $user != "abuse" && $user != "rhodie" && $user != "ThEShADoW"} {
    			putdcc $idx "Sorry brato, pove4e ot 3 hosta nea ima." 
    			return
    		}
    		putlog "#$hand# +host $user $host"
    		setuser $user hosts $host
    		putdcc $idx "Added '$host' to $user"
    		return
    	}
    	set host [lindex $arg 0]
    # Àêî èñêàòå íÿêîè ïîòðåáèòåëè äà ìîãàò äà àäâàò ïîâå÷å îò 3 õîñò-à çàìåíåòå èìåíàòà èì ñ Nick, Nick1 ...
    	if {[llength [getuser $hand HOSTS]] > 2 && $hand != "Nick" && $hand != "Nick1"} {
    		putdcc $idx "Sorry brato, pove4e ot 3 hosta nea imash."
    		return
    	}
    	putlog "#$hand# +host $hand $host"
    	setuser $hand hosts $host
    	putdcc $idx "Added '$host' to $hand"
    	return
    }
    
    putlog "HostLimit.tcl by IRCHelp.UniBG.Net+LHG Crew Loaded!!!"

     

  14. # Set the next lines as the triggers and random responses you want
    set ai_data {
     {
      {"What time is it?" "*time*" "What is the time?" "What's the time?" "Anyone have the time?"} {
       "$nick, it's [clock format [clock seconds]]"
      }
     }
    }
    
    # Set the next line as the channels you want to run in
    set ai_chans "#test1, #test2"
    bind pubm - * pub_ai
    
    putlog "Time Show by Beliata"
    
    proc pub_ai {nick uhost hand chan arg} {
     global ai_data ai_chans botnick
     if {(([lsearch -exact [string tolower $ai_chans] [string tolower $chan]] != -1) || ($ai_chans == "*")) && (![matchattr $hand b]) && ($nick != $botnick)} {
      foreach block $ai_data {
       set triggers [lindex $block 0]
       set responses [lindex $block 1]
       foreach trigger $triggers {
        if {[string match [string tolower $trigger] [string tolower $arg]]} {
         putserv "PRIVMSG $chan :[subst [lindex $responses [rand [llength $responses]]]]"
        }
       }
      }
     }
    }

     

  15. # This TCL will remove users for the userlist who are not seen in 60 days
    # You may try the dcc command .cleanup too... does the same, but does it
    # right away.
    
    bind time - "00 04 * * *" time_scan_userfile
    bind dcc +m cleanup dcc_scan_userfile
    
    proc dcc_scan_userfile {hand idx args} {
        putlog "$hand started userfile scan... Time: [time]"
        scan_userfile
    }
    
    proc time_scan_userfile {min hour day month year} {
        putlog "Stated auto-scan of userfile. Time: [time]"
        scan_userfile
    }
    
    proc scan_userfile { } {
        set rmusers 0
        set errors 0
        foreach hand [userlist] {
    	set leave 0
    	if {[lindex [getuser $hand LASTON] 0] < [expr [unixtime] - 5184000]} {
    	    if {[matchattr $hand +n] == 1} {
    		set leave 1
    	    }
    	    if {[matchattr $hand +m] == 1} {
    		set leave 1
    	    }
    	    if {[matchattr $hand +f] == 1} {
    		set leave 1
    	    }
    	    if {[matchattr $hand +o] == 1} {
    		set leave 1
    	    }
    	    if {$leave == 0} {
    		set okdel [deluser $hand]
    		if {$okdel == 1} {
    		    putlog "Deleted: $hand"
    		    incr rmusers
    		}
    		if {$okdel != 1} {
    		    putlog "Error in deleting: $hand"
    		    incr errors
    		}
    	    }
    	}
        }
        putlog "CleanUp stats:"
        putlog "Current time: [time]"
        putlog "Users deleted: $rmusers"
        putlog "Errors: $errors"
    }
    
    putlog "cleanup.tcl loaded..."
    putlog "Made by Christian Felde"
    putlog "email: cfelde@powertech.no or cfelde@geocities.com"

     

  16. ## File, where the list of the !ison-ed users are stored.
    set filename "nlist.txt"
    
    # Channel to whom the stuff goes.
    set nchan "#Channel"
    
    # File exits ? if no then created!
    if {![file exists $filename]} {
        set fh [open $filename w]
        puts -nonewline $fh ""
        close $fh
    }
    
    ## Don't change anything below, unless you know what you are doing!
    # glob vars
    set tell "notell"
    set online ""
    
    ### raw 303 (ISON)
    bind raw - 303 online:raw
    
    ### raw 325 (NS Id)
    bind raw - 325 whois:idented
    
    proc whois:idented {* 325 arg} {
    global nchan
      putserv "INVITE [lindex $arg 1] $nchan"
    }
    
    ## ison is triggered
    proc online:raw {* 303 arg} {
      global online nchan tell
      set nlist [getinfo]
      string tolower $nlist
      set arg [string trimleft [lrange $arg 1 end] ":"]
      set arg [charfilter $arg]
      if {$arg == ""} {
    	set online1 $online
        if {$tell == "tell"} {
          puthelp "PRIVMSG $nchan :Noone's online."
          set tell "notell"
        }
    	unset online
    	set online [qonreport 1 $arg $online1]
    	set quitted [qonreport 0 $online1 $online]
    	set quitted [charfilter $quitted]
    	set quitted [removespaces $quitted]
    	if {$quitted == ""} {
    	  return
    	}
        putserv "PRIVMSG $nchan: $quitted offline."
        set online ""
      } else {
      	if {$tell == "tell"} {
    	  set arg [removespaces $arg]
    	  set onchan [onlineon $arg]
    	  set tell "notell"
    	  set online $arg
          puthelp "PRIVMSG $nchan :Online: $arg"
          puthelp "PRIVMSG $nchan :Online total [llength $arg] of [llength $nlist]."
          puthelp "PRIVMSG $nchan :On $nchan: [llength $onchan] of [llength $arg] online."
    	  return
    	}
    
    	if {$online == ""} {
    	  set arg [removespaces $arg]
    	  set onchan [onlineon $arg]
          set online $arg
          puthelp "PRIVMSG $nchan :Online: $arg"
          puthelp "PRIVMSG $nchan :Online total [llength $arg] of [llength $nlist]."
          puthelp "PRIVMSG $nchan :On $nchan: [llength $onchan] of [llength $arg] online."
          return
    	}
    
    	set foo [qonreport 0 $arg $online]
    
    	if {$foo != ""} {
    	  set foo [charfilter $foo]
    	  set foo [removespaces $foo]
    	  set onchan [onlineon $arg]
          append online " $foo"
          puthelp "PRIVMSG $nchan :Online: $foo"
          puthelp "PRIVMSG $nchan :Online total [llength $arg] of [llength $nlist]."
          puthelp "PRIVMSG $nchan :On $nchan: [llength $onchan] of [llength $arg] online."
    	}
    	set online1 $online
    	unset online
    	set online [qonreport 1 $arg $online1]
    	set quitted [qonreport 0 $online1 $online]
    	set quitted [charfilter $quitted]
    	set quitted [removespaces $quitted]
    	if {$quitted == ""} {
    	  return
    	}
        putserv "PRIVMSG $nchan :$quitted offline."
      }
    }
    
    ### !ison
    bind pub n !ison ison:pub
    
    proc ison:pub {nick host hand chan arg} {
      global nchan tell
      if {[string tolower $chan] != [string tolower $nchan]} {
    	return
      }
      set tell "tell"
      set nlist "[getinfo]"
      putserv "ISON :$nlist"
    }
    
    ### !addison <nickname(s)>
    bind pub n !addison ison:addison
    
    proc ison:addison {nick host hand chan arg} {
      global nchan
      if {[string tolower $chan] != [string tolower $nchan]} {
    	return
      }
      if {[lindex $arg 0] == ""} {
    	putserv "PRIVMSG $chan :$nick: Usage !addison <nickname(s)>"
    	return
      }
      set nlist [getinfo]
      set dontsay [dupZZ $nlist $arg 0]
      if {$dontsay == ""} {
    	set count [expr [llength $arg] + [llength $nlist]]
    	set arg [charfilter $arg]
    	set arg [removespaces $arg]
    	putserv "PRIVMSG $chan :$nick: Done. Successfully added $arg. Total ($count)."
    	writetof "$nlist $arg"
    	set tell "tell"
        putserv "ISON :$nlist"
      } else {
    	set dontsay [removespaces $dontsay]
    	set dontsay [charfilter $dontsay]
    	putserv "PRIVMSG $chan :There is a duplicate :$dontsay"
    	set nlist [getinfo]
            set list ""
            foreach bla $arg {
            if {[lsearch $list $bla] == -1} {
              lappend list $bla
                }
            }
            set final [$nlist $list 1]
    	if {$final != ""} {
    	  set count [expr [llength $final] + [llength $nlist]]
    	  set final [removespaces $final]
    	  set final [charfilter $final]
    	  putserv "PRIVMSG $chan :$nick: Done. Successfully added $final. Total ($count)."
    	}
    	writetof "$nlist $final"
        putserv "ISON :$nlist $final"
    	set tell "tell"
      }
    }
    
    ## !delison <nickname>
    bind pub n !delison del_in_fd
    proc del_in_fd {nick uhost hand chan arg} {
      global nchan
      if {[string tolower $chan] != [string tolower $nchan]} {
    	return
      }
      if {[llength $arg] != 1} {
        puthelp "NOTICE $nick :Usage: !delison <nickname|phone number>"
        return 0
      }
      set nicknames [getinfo]
      
      set who [lindex $arg 0]
      set who [charfilter $who]
      
      if {[lsearch -exact $nicknames [lindex $arg 0]] == -1} {
    	puthelp "NOTICE $nick :Nickname $who not found in the database!"
    	return 0
      }
      regsub -all "\\\m$who\\\M" $nicknames "" nicknames
      regsub -all {\s+} $nicknames { } nicknames
      writetof $nicknames
      puthelp "NOTICE $nick :Nickname $who erased from the database!"
    }
    
    ## !list [nickname]
    bind pub n !list list_out_of_fd
    proc list_out_of_fd {nick uhost hand chan arg} {
      global nchan
      if {[string tolower $chan] != [string tolower $nchan]} {
    	return
      }
      if {[llength $arg] == 0} {
    	set nicknames [getinfo]
    	set nicknames [charfilter $nicknames]
    	set nicknames [removespaces $nicknames]
    	if {$nicknames == ""} {
    	  puthelp "NOTICE $nick :No one is added in the database!"
    	} else {
    	  puthelp "NOTICE $nick :Added in the database: $nicknames"
    	}
      } elseif {[llength $arg] == 1} {
    	set nicknames [getinfo]
    	set nicknames [string tolower $nicknames]
    	if {[lsearch -exact $nicknames [lindex $arg 0]] == -1} {
    	  puthelp "NOTICE $nick :[charfilter [lindex $arg 0]] not found in the database!"
    	} else {
    	  puthelp "NOTICE $nick :[charfilter [lindex $arg 0]] is in the database!"
    	}
      } else {
    	puthelp "NOTICE $nick :Usage: !list \[nickname\]"
      }
    }
    
    ## The proc
    proc notify {} {
      set nlist [getinfo]
      putserv "ISON :$nlist"
      if {![string match *notify* [utimers]]} { utimer 30 notify }
    }
    
    proc charfilter {x {y ""} } {
      for {set i 0} {$i < [string length $x]} {incr i} {
        switch -- [string index $x $i] {
          "\"" {append y "\\\""}
          "\\" {append y "\\\\"}
          "\[" {append y "\\\["}
          "\]" {append y "\\\]"}
          "\}" {append y "\\\}"}
          "\{" {append y "\\\{"}
          default {append y [string index $x $i]}
        }
      }
      return $y
    }
    
    proc getinfo {} {
      global filename
      set file [open $filename r]
      set nlist ""
      while {![eof $file]} {
    	set chast [gets $file]
        if {$chast != ""} {
    	  append nlist $chast
    	}
      }
      close $file
      return $nlist
    }
    
    proc removespaces {arg} {
      regsub {^\s+} $arg "" arg
      return $arg
    }
    
    proc onlineon {arg} {
      global nchan
      set onchan ""
      foreach tempchar $arg {
        if {![onchan $tempchar $nchan]} {
    #      putserv "INVITE $tempchar $nchan"
          putserv "WHOIS $tempchar"
        } else {
          append onchan " $tempchar"
        }
      }
      return $onchan
    }
    
    proc qonreport {how arg online} {
      set aq 0
      set foo ""
      foreach el $arg {
        foreach el1 $online {
    	  if {$el == $el1} {
    	    set aq 1
    	  }
        }
        if {$aq == $how} {
    	  append foo " $el"
    	}
        set aq 0
      }
      return $foo
    }
    
    proc writetof {what} {
      global filename
      set fh [open $filename w]
      puts $fh $what
      close $fh
    }
    
    proc dupZZ {where what how} {
      set dontsay ""
      foreach el1 $what {
    	if {[lsearch -exact $where $el1] != -1} {
    	  if {$how == 0} {
      		append dontsay " $el1"
    	  }
        } else {
    	  if {$how == 1} {
    		append dontsay " $el1"
    	  }
    	}
      }
      return $dontsay
    }
    
    if {![string match *notify* [utimers]]} { utimer 30 notify }
    
    putlog "ISON TCL by IRCHelp.UniBG.Net+LHG Crew ++/++ Counter by V1p3r#TCL Loaded !!!"

     

  17. # Cmd Resolve by Jeff Fisher (guppy@eggheads.org)
    
    bind dcc -|- resolve resolve_cmd
    bind dcc -|- dns resolve_cmd
    
    proc resolve_cmd {hand idx arg} {
      if {[scan $arg "%s" hostip] != 1} {
        global lastbind
        putidx $idx "Usage: $lastbind <host or ip>"
      } else {
        putidx $idx "Looking up $hostip ..."
        set hostip [split $hostip]
        dnslookup $hostip resolve_callback $idx $hostip
      }
      return 0
    }
    proc resolve_callback {ip host status idx hostip} {
      if {![valididx $idx]} {
        return 0
      } elseif {!$status} {
        putidx $idx "Unable to resolve $hostip"
      } elseif {[regexp -nocase -- $ip $hostip]} {
        putidx $idx "Resolved $ip to $host"
      } else {
        putidx $idx "Resolved $host to $ip"
      }
      putcmdlog "#[idx2hand $idx]# resolve $hostip"
      return 0
    }
    loadhelp cmd_resolve.help

     

  18. # Script: unloadtcl.tcl
    # Version: 1.1
    # Author: Wingman <Wingman@WINGDesign.de>
    
    # Description: This scripts allows you to load/unload tcl scripts via
    # partyline.
    
    # DCC Commands:
    # .loadtcl <scriptname>
    # .unloadtcl <scriptname>
    # .viewtcls <loaded/all>
    
    # Updates:
    # 1.1 (16. Nov 99) added .viewtcls all, settings for dir, pattern, automaticlly
    #     rehash/restart, now .loadtcl notifies loaded tcls and don't let you load 
    #     the same tcl twice. Also fixed some unbind bugs.
    
    # Known bugs:
    # it can't unbind bindings, which are set via foreach e.g. userinfo.tcl
    
    # Settings:
    
    # 0 = no rehash/restart, 1 = rehash, 2 = restart
    set ul(refresh) 1
    set ul(dir) "scripts"
    set ul(pattern) "*.tcl"
    
    # Bindings:
    bind dcc n unloadtcl dcc:unloadtcl
    bind dcc n loadtcl dcc:loadtcl
    bind dcc n viewtcls dcc:viewtcls 
    
    # Procedures - You don't have to edit anything below.
    
    proc ul:get_scripts {} {
      global config
      set loaded_scripts ""
      set file [open $config r]
      while {![eof $file]} {
        set line [gets $file]
        if {[string match "source*" $line]} {
          set script "[string range $line 15 end]"
          if {[string match "/" $script]} {
            set script [lindex [split $script /] [incr [llength [split $script /]] -1]]
            set path [string range $line 0 [string length $script]]
          }
          append loaded_scripts "$script "
        }
      }
      close $file
      return $loaded_scripts
    }
    
    proc dcc:loadtcl { hand idx arg } {
      global config ul
      if {[llength $arg] < 1} {
        putdcc $idx "Usage: .loadtcl <scriptname>"
        return
      } 
      if {![file exists scripts/$arg]} {
        putdcc $idx "Can't find tcl $arg."
        return
      }
      if {[lsearch "[ul:get_scripts]" $arg] != -1} {
        putdcc $idx "Tcl script already loaded: $arg"
        return
      }
      set file [open $config a+]
      puts $file "source scripts/$arg"
      close $file
      putdcc $idx "Done. $arg successfully loaded."
      if {$ul(refresh) == 1} { 
        rehash
      } elseif {$ul(refresh) == 2} {
        restart
      } {
        putdcc $idx "Now do a .rehash or .restart."
      }
      return 1
    }
    
    proc dcc:unloadtcl { hand idx arg } {
      global config ul 
      if {[llength $arg] < 1} {
        putdcc $idx "Usage: .unloadtcl <scriptname>"
        putdcc $idx "       try '.viewtcls loaded' for a list of loaded scripts"
        return 
      }
      if {![file exists scripts/$arg]} {
        putdcc $idx "Can't find tcl: $arg."
        return
      }
      set file [open $config r]
      while {![eof $file]} {
        set line [gets $file]
        if {![string match "source scripts/$arg *" $line] && ![string match "source scripts/$arg" $line]} {
          lappend content $line
        } {
          set foo 1
        }
      }
      close $file
      if {![info exists foo]} {
        putdcc $idx "Can't find loaded tcl: $arg."
        return
      }
      set file [open $config w]
      foreach line $content { puts $file $line }
      close $file
      set ubc_success 0
      set ubc_failed 0
      set proc_success 0
      set proc_failed 0
      set file [open scripts/$arg r]
      while {![eof $file]} {
        set line [gets $file]
        if {([string match "* bind *" $line] || [string match "bind *" $line]) && ![string match "*#*" $line]} {
          set foo1  [lindex $line 1]
          if {[string match "*\$*" $foo1]} {
            set varname [lindex [split $foo1 \$] 1]
    	if {[string match "*(*" $varname]} {
    	  global [lindex [split $varname (] 0]
    	} {
    	  global $varname
    	}
    	set foo1 [set $varname]
          }
          set foo2 [lindex $line 2]
          if {[string match "*\$*" $foo2]} {
    	if {[llength [split $foo2 |]] == 2} {
    	  set gflag [lindex [split $foo2 |] 0]
    	  set cflag [lindex [split $foo2 |] 1]
    	  if {[string index $gflag 0] == "\$"} {
     	    global [string trimleft $gflag $]
    	    set foo2 "[set [string trimleft $gflag $]]"
    	  } {
    	    set foo2 "$gflag"
    	  }
    	  if {[string index $cflag 1] == "\$"} {
    	    global [string trimleft $cflag $]
    	    append foo2 "|[set [string trimleft $cflag $]]"
    	  } {
    	    append foo2 "|$cflag"
    	  }
    	} elseif {[llength [split $foo2 &]] == 2} {
              set gflag [lindex [split $foo2 &] 0]
              set cflag [lindex [split $foo2 &] 1]
              if {[string index $gflag 0] == "\$"} {
                global [string trimleft $gflag $]
                set foo2 "[set [string trimleft $gflag $]]"
              } {
                set foo2 "$gflag"
              }
              if {[string index $cflag 1] == "\$"} {
                global [string trimleft $cflag $]
                append foo2 "&[set [string trimleft $cflag $]]"
              } {
                append foo2 "&$cflag"
              }
    	} else {
              set varname [lindex [split $foo2 "\$"] 1]
              if {[string match "*(*" $varname]} {
                global [lindex [split $varname (] 0]
              } {
                global $varname
    	  }
    	  set foo2 [set $varname]
    	}
          }
          set foo3 [lindex $line 3]
          if {[string match "*\$*" $foo3]} {
            set varname [lindex [split $foo3 \$] 1]
            if {[string match "*(*" $varname]} {
    	  global [lindex [split $varname (] 0]
    	} {
              global $varname
    	}
    	set foo3 [set $varname]
          }
          set foo4 [lindex $line 4]
          catch { unbind $foo1 $foo2 $foo3 $foo4 } error
          if {[string match "TCL error:*" $error]} {
            putdcc $idx " *** error, while executing: unbind $foo1 $foo2 $foo3 $foo4"
    	putdcc $idx "     msg: $error"
    	incr ubc_failed
          } {
            incr ubc_success
          }
        }
        if {[string match "*proc *\{*\}*\{*" $line]} {
          set procname [lindex [lindex [split $line \{] 0] 1]
          catch { rename $procname "" } error
          if {[string match "TCL error:*" $error]} {
            putdcc $idx " *** error while executing: rename $procname \"\""
    	putdcc $idx "     msg: $error"
    	incr proc_failed
          } {
            incr proc_success
          }
        }
      }
      close $file
      putdcc $idx "All Done. Showing report:"
      putdcc $idx "  Unbinded $ubc_success commands."
      if {$ubc_failed > 0} {
        putdcc $idx "   * failed: $ubc_failed commands."
      }
      putdcc $idx "  Deleted $proc_success procedures."
      if {$proc_failed > 0} {
        putdcc $idx "   * failed: $proc_failed procedures."
      }
      if {$ul(refresh) == 1} {
        rehash
      } elseif {$ul(refresh) == 2} {
        restart
      } {
        putdcc $idx "I recommend to do an rehash or better a .restart!"
      }
      return 1
    }
    
    proc dcc:viewtcls { hand idx arg } {
      global ul
      set loaded_scripts [ul:get_scripts]
      if {[string tolower $arg] == "loaded"} {  
        putlog "#$hand# viewtcls $arg"
        if {![info exists loaded_scripts]} {
          putdcc $idx "No tcls loaded."
        } {
          putdcc $idx "List of loaded tcls:"
          foreach script $loaded_scripts {
            putdcc $idx " $script"
          }
        }
        return
      } elseif {[string tolower $arg] == "all"} {
        catch { glob $ul(dir)/$ul(pattern) } tclfiles
        if {[lrange "$tclfiles" 0 4] == "no files matched glob pattern"} {
          putdcc $idx "Can't find any tcl ($ul(pattern)) script in $ul(dir)."
          return 1
        }
        foreach script $tclfiles {
          if {[lsearch -exact "$loaded_scripts" [string range $script [expr [string length $ul(dir)]+1] end]] == -1} {
            putdcc $idx "  [string range $script [expr [string length $ul(dir)]+1] end]"
          } {
            putdcc $idx "  [string range $script [expr [string length $ul(dir)]+1] end] (loaded)"
          }
        }
        return 1
      }
    putdcc $idx "Usage: .viewtcls <loaded/all>"
    return
    }
    
    #putlog "UnloadTCL v1.1 by Wingman loaded."

     

  19. # TCL SCRIPT FOR !nslookup !traceroute
    
    putlog "Channel script version 0.5.3 by |SmUrF| loaded"
    
    proc commandchar {} {
    	return "!"
    }
    
    bind pub - [commandchar]nslookup nslookup
    bind pub - [commandchar]traceroute traceroute
    
    proc nslookup {nick host hand chan text} {
    		if {[onchan $text $chan] == 1} {
    			set host [lindex [split [getchanhost $text $chan] @] 1]
    		} else {
    			set host $text
    		}
    		set input [open "|nslookup $host" r]
    		set trash [gets $input]
    		set trash [gets $input]
    		while {![eof $input]} {
    			catch {set contents [gets $input]}
    			putserv "PRIVMSG $nick :$contents"
    		}
    		catch {close $input}
    }
    
    proc traceroute {nick host hand chan text} {
    		if {[onchan $text $chan] == 1} {
    			set host [lindex [split [getchanhost $text $chan] @] 1]
    		} else {
    			set host $text
    		}
    		set input [open "|traceroute $host" r]
    		while {![eof $input]} {
    		        catch {set contents [gets $input]}
    		        putserv "PRIVMSG $nick :$contents"
    	        }
    		catch {close $input}
    }

     

  20. //To run this script you need version.dll
    
    
    on *:CONNECT:{
      set %version Stupid!
      echo 0 $dll($scriptdirversion.dll,motfv,Load)
      echo 0 $dll($scriptdirversion.dll,motfv,Sync)
    }
    on *:DISCONNECT:echo 0 $dll($scriptdirversion.dll,motfv,Unload)
    ctcp *:MOTFV:{
      .ctcpreply $nick VERSION %version
      echo -a $timestamp * CTCP Version 4 $+ $nick $+  ( $+ $wildsite $+ )
      haltdef
    }

     

×
×
  • Create New...