diff options
Diffstat (limited to 'main/eggdrop/gseen.mod.patch')
| -rw-r--r-- | main/eggdrop/gseen.mod.patch | 5123 |
1 files changed, 5123 insertions, 0 deletions
diff --git a/main/eggdrop/gseen.mod.patch b/main/eggdrop/gseen.mod.patch new file mode 100644 index 000000000..e70aef887 --- /dev/null +++ b/main/eggdrop/gseen.mod.patch @@ -0,0 +1,5123 @@ +diff -Nur src/mod/gseen.mod/Makefile src/mod/gseen.mod/Makefile +--- src/mod/gseen.mod/Makefile 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/Makefile 2002-10-26 13:17:44.000000000 +0200 +@@ -0,0 +1,28 @@ ++# Makefile for src/mod/gseen.mod/ ++ ++doofus: ++ @echo "" ++ @echo "Let's try this from the right directory..." ++ @echo "" ++ @cd ../../../; make ++ ++clean: ++ @rm -f *.o *.$(MOD_EXT) *~ ++ ++static: ../gseen.o ++ ++modules: ../../../gseen.$(MOD_EXT) ++ ++../gseen.o: ../module.h ../modvals.h ../../eggdrop.h datahandling.c \ ++ gseen.c sensors.c gseencmds.c gseencmds.c do_seen.c ai.c tclcmds.c \ ++ misc.c seentree.c generic_binary_tree.c slang_gseen_commands.c \ ++ slang.c slang_text.c slang_ids.c slang_chanlang.c seenlang.h \ ++ slang_multitext.c gseen.h ++ $(CC) $(CFLAGS) $(CPPFLAGS) -DMAKING_MODS -c gseen.c ++ rm -f ../gseen.o ++ mv gseen.o ../ ++ ++../../../gseen.$(MOD_EXT): ../gseen.o ++ $(LD) -o ../../../gseen.$(MOD_EXT) ../gseen.o $(XLIBS) ++ ++#safety hash +diff -Nur src/mod/gseen.mod/README src/mod/gseen.mod/README +--- src/mod/gseen.mod/README 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/README 2002-10-26 13:17:45.000000000 +0200 +@@ -0,0 +1,140 @@ ++Description: ++------------ ++ ++gseen.mod is a seen module for eggdrop that tracks not only the users in the ++bot's userfile, but everyone who enters one of the bots channels. ++It does pretty much the same as the popular script bseen and has a few ++additional features like AI-seen and seen-notification. ++It's also way faster than any corresponding script because scripts are always ++much slower than modules. Especially scripts that deal with large amount of ++data often become incredible slow. ++ ++Installation: ++------------- ++ ++gseen.mod is written for eggdrop1.6, but it should also work with eggdrop 1.4. ++ ++You need the eggdrop source to compile the module. ++ ++The following instructions assume, ~/eggdrop1.6.2/ is the directory ++where you installed your eggdrop from. (of course, other source dirs ++will work as well) ++ ++Put gseen.mod.1.1.0.tar.gz in ~/eggdrop1.6.2/src/mod/, ++and unpack it (tar xfz gseen.mod.1.1.0.tar.gz). Change directory ++back to ~/eggdrop1.6.2/. ++ ++Now just do what you've done when you compiled your bot: ++"./configure" ++"make config" (you can skip this command on eggdrop 1.4) ++"make" ++"make install" ++ ++Don't forget to copy the langfiles from eggdrop1.6.2/src/mod/gseen.mod/ to ++eggdrop/language. ++ ++All settings can be found in ~/eggdrop1.6.2/src/mod/gseen.mod/gseen.conf ++Copy it to your eggdrop directory, edit it to fit your needs and put ++"source gseen.conf" at the end of your eggdrop config file. The last thing ++to do is to .rehash your bot. ++ ++ ++Public commands: ++---------------- ++ ++!seen <nick> ++ I think this command doesn't need an explanation. ^_^ ++!seen <mask> ++ Searches the database for entries that match <mask> ++ for example "!seen *!user@dialin-*.isp.com" ++!seennick <nick> ++ !seen also checks if a user was online later with a ++ different nick. !seennick only seens for <nick> ++!seenstats ++ just a little report on how many nicks are tracked ++ ++All commands are also accessible via /msg. ++("/msg <bot> seen <nick>", for example) ++ ++ ++AI seen: ++-------- ++ ++This module has a simple built in AI routine. ++A short example: ++ ++<G`Quann> Argo: have you seen Fabian recently? ++<|Argo|> G`Quann, fabian (~fabian@dns.gifs.de) was last seen quitting ++from #eggdev 1 week 4 days 9 hours 40 minutes 56 seconds ago ++(20.02. 01:39) stating ".....zzzzZZZzzZZZzZZZZZZZZZZzzz..". ++ ++Well, it's not a very intelligent AI, it's rather brute-force. So don't ++forget to use the ai-seen-ignore setting. ++I know that's not coded very elegant, but if you configure it correctly, ++the failure-rate is way lower than with other AI scripts... ++ ++DCC commands: ++------------- ++ ++.seen ++.seennick ++.seenstats ++ just the same as the public versions ++.purgeseens ++ deletes expired data (this also happens automatically once a day) ++ (m) ++ ++Channel Settings: ++----------------- ++ ++ +noseendata ++ don't log any seen data in this channel ++ +quietseens ++ send answers directly via notice to the person who asked and ++ don't bother the rest of the channel with the reply ++ +quietaiseens ++ same as +quietseens, but for AI seens ++ +nopubseens ++ ignore every seen-command in this channel ++ ++TCL commands: ++------------- ++ ++There are no special tcl commands, only the usual bind procs. ++ ++The only one that should be mentioned is: ++ ++*pubm:seen <nick> <uhost> <hand> <chan> <text> ++ triggers the AI seen ++ returns: 1 if a reply was sent, 0 otherwise ++ ++So if you're using another AI script on your bot, you can modify it to ++use this proc and avoid doubled replies this way. ++ ++Other: ++------ ++ ++There is absolutely NO WARRANTY on this module. I do my best to make it ++work properly, but if anything gets screwed up, I'm not responsible. Use ++this module at your own risk. ++ ++Feedback: ++--------- ++ ++Feel free to send feedback and bugreports (I hope there won't be any<g>) to ++gseen.mod@visions-of-fantasy.de ++ ++The newest gseen version can always be found at: ++http://www.visions-of-fantasy.de/gseen.mod/ ++ ++Thanks to: ++---------- ++ ++- Fabian for teaching me plenty of things ++- everyone who tested the many buggy development versions :) ++- the eggdev team for developing eggdrop ++ ++Most of all, I would like to thank Bass for writing bseen.tcl because alot ++of the ideas for this module came from using that tcl script. It's still the ++most powerful seen script, so if you want something that's easier to use than ++a module, get a copy of bseen.tcl. +diff -Nur src/mod/gseen.mod/UPDATES src/mod/gseen.mod/UPDATES +--- src/mod/gseen.mod/UPDATES 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/UPDATES 2002-10-26 13:17:46.000000000 +0200 +@@ -0,0 +1,55 @@ ++Changes in gseen.mod: (since v1.0.0) ++-------------------- ++ ++1.1.1 ++- fixed "no newline" compilation warnings that appeared on some systems. ++- fixed uninitialized "li" variable in do_seen() ++- fixed lacking compatibility to eggdrop1.4 (confirmation anyone?) ++- new option: hide-secret-chans ++ ++1.1.0 (15.6.2001) ++- added multilang support ++- removed static buffers ++- organized data in a binary search tree (much faster) ++- optimized a few other things ++- added settings: ++ - fuzzy-search ++ - max-matches ++ - wildcard-search ++ ++1.0.8 ++- quiet-seens wasn't working for !seennick ++- added quiet-ai-seens ++- renamed nopub to nopubseens and nolog to noseendata and ++ quietseen to quietseens ++ ++1.0.7 ++- added compatibility to !channels ++- fixed a bug relating strict-host 0 had some strange effects on ++ !seen requests for users with ~ in their ident ++ ++1.0.6 ++- fixed a very evil bug that allowed anyone to crash the bot, sorry ++ ++1.0.5 ++- quietseens wasn't working correctly ++- added support for egg1.5's udef chansets ++ ++1.0.4 ++- added GPL stuff ++- changed error msg that appears if no gseen file exists ++ ++1.0.3 ++- readme updates ++- fixed a grammatical error in do_seen ++ ++1.0.2 ++- bot wanted to free a NULL pointer sometimes ++ ++1.0.1 ++- !seen without parameter returned stupid results :) ++- fixed little typo in .purgeseens ++- "I found 1 matches..." -> "I found 1 match..." ++ ++1.0.0 ++- release :) +diff -Nur src/mod/gseen.mod/addons/gseen.selectlang.1.0.0.tcl src/mod/gseen.mod/addons/gseen.selectlang.1.0.0.tcl +--- src/mod/gseen.mod/addons/gseen.selectlang.1.0.0.tcl 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/addons/gseen.selectlang.1.0.0.tcl 2002-10-26 13:18:14.000000000 +0200 +@@ -0,0 +1,80 @@ ++#####################################################################
++#
++# gseen.selectlang v1.0.0
++#
++# This is a simple script which selects a language based on the
++# user's host.
++#
++# It only works for /msg commands.
++#
++# If the user is in a channel which has a language defined, gseen's
++# internal functions will override this selection and use the language
++# of the channel instead.
++#
++#####################################################################
++
++
++# Here you can define which language to use for which host.
++# The first part is the mask for the host, and the second part
++# is the language which should be used for this host.
++
++set tld-langs {
++ {"*.de" "de"}
++ {"*.at" "de"}
++ {"*.ch" "de"}
++ {"*.t-dialin.net" "de"}
++ {"*.t-ipconnect.net" "de"}
++ {"*.pl" "pl"}
++ {"*.jp" "ja"}
++}
++
++#################################################
++
++
++proc selectlang:getlang {uhost} {
++ global tld-langs
++
++ foreach tld ${tld-langs} {
++ if {[string match [lindex $tld 0] $uhost]} {
++ return [lindex $tld 1]
++ }
++ }
++ return ""
++}
++
++proc sl:rebind {oldtarget newtarget} {
++ foreach binding [binds msg] {
++ if {[lindex $binding 4] == $oldtarget} {
++ unbind [lindex $binding 0] [lindex $binding 1] [lindex $binding 2] [lindex $binding 4]
++ bind [lindex $binding 0] [lindex $binding 1] [lindex $binding 2] $newtarget
++ }
++ }
++}
++
++proc sl:msg:trigger {nick uhost hand rest target} {
++ global default-slang
++
++ set lang [selectlang:getlang $uhost]
++ set old-slang ${default-slang}
++ if {$lang != ""} {
++ set default-slang $lang
++ putlog "using '$lang'..."
++ }
++ $target $nick $uhost $hand $rest
++ set default-slang ${old-slang}
++}
++
++sl:rebind *msg:seen sl:msg:seen
++proc sl:msg:seen {nick uhost hand rest} {
++ sl:msg:trigger $nick $uhost $hand $rest *msg:seen
++}
++
++sl:rebind *msg:seenstats sl:msg:seenstats
++proc sl:msg:seenstats {nick uhost hand rest} {
++ sl:msg:trigger $nick $uhost $hand $rest *msg:seenstats
++}
++
++sl:rebind *msg:seennick sl:msg:seennick
++proc sl:msg:seennick {nick uhost hand rest} {
++ sl:msg:trigger $nick $uhost $hand $rest *msg:seennick
++} +\ No newline at end of file +diff -Nur src/mod/gseen.mod/ai.c src/mod/gseen.mod/ai.c +--- src/mod/gseen.mod/ai.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/ai.c 2002-10-26 13:17:47.000000000 +0200 +@@ -0,0 +1,151 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++static int quietaiseens(char *chan) ++{ ++ char buf[121], *b; ++ ++ Context; ++ strncpy(buf, quiet_ai_seen, 120); ++ buf[120] = 0; ++ b = buf; ++ while (b[0]) ++ if (!strcasecmp(chan, newsplit(&b))) ++ return 1; ++#if EGG_IS_MIN_VER(10503) ++ if (ngetudef("quietaiseens", chan)) ++ return 1; ++#endif ++ return 0; ++} ++ ++static int tcl_pubmseen STDVAR ++{ ++ char *nick, *uhost, *hand, *chan, *text; ++ char buf[1024]; ++ char *words, *word; ++ seendat *l; ++ int i; ++ ++ Context; ++ BADARGS(6, 6, " nick uhost hand chan text"); ++ nick = argv[1]; ++ uhost = argv[2]; ++ hand = argv[3]; ++ chan = argv[4]; ++ text = argv[5]; ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, chan)); ++ glob_nick = nick; ++ for (i = 0; i < strlen(text); i++) ++ if (strchr("!?.,\"", text[i])) ++ text[i] = ' '; ++ strncpy(buf, ignore_words, 1023); ++ buf[1023] = 0; ++ words = buf; ++ while (words[0]) ++ add_ignoredword(newsplit(&words)); ++ strncpy(buf, text, 1023); ++ buf[1023] = 0; ++ words = buf; ++ while (words[0]) { ++ word = newsplit(&words); ++ if (word_is_ignored(word)) ++ continue; ++ l = findseen(word); ++ if (l) { ++ if (quietaiseens(chan)) { ++ set_prefix(SLNOTPREFIX); ++ dprintf(DP_HELP, "NOTICE %s :%s%s\n", nick, reply_prefix, ++ do_seen(word, nick, uhost, chan, 0)); ++ } else { ++ set_prefix(SLPUBPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", chan, reply_prefix, ++ do_seen(word, nick, uhost, chan, 0)); ++ } ++ add_seenreq(word, nick, uhost, chan, now); ++ free_ignoredwords(); ++ Tcl_AppendResult(irp, "1", NULL); ++ return TCL_OK; ++ } ++ } ++ free_ignoredwords(); ++ Tcl_AppendResult(irp, "0", NULL); ++ return TCL_OK; ++} ++ ++static tcl_cmds mytcls[] = ++{ ++ {"*pubm:seen", tcl_pubmseen}, ++ {"*chjn:gseen", gseen_chjn}, ++ {"*chpt:gseen", gseen_chpt}, ++ {0, 0} ++}; ++ ++static void add_ignoredword(char *word) ++{ ++ ignoredword *l, *nl; ++ ++ l = ignoredwords; ++ while (l && l->next) ++ l = l->next; ++ nl = nmalloc(sizeof(ignoredword)); ++ nl->word = nmalloc(strlen(word) + 1); ++ strcpy(nl->word, word); ++ nl->next = NULL; ++ if (ignoredwords) ++ l->next = nl; ++ else ++ ignoredwords = nl; ++} ++ ++static void free_ignoredwords() ++{ ++ ignoredword *l, *ll; ++ ++ l = ignoredwords; ++ while (l) { ++ ll = l->next; ++ nfree(l->word); ++ nfree(l); ++ l = ll; ++ } ++ ignoredwords = NULL; ++} ++ ++static int expmem_ignoredwords() ++{ ++ ignoredword *l; ++ int size = 0; ++ ++ for (l = ignoredwords; l; l = l->next) { ++ size += sizeof(ignoredword); ++ size += strlen(l->word) + 1; ++ } ++ return size; ++} ++ ++static int word_is_ignored(char *word) ++{ ++ ignoredword *l; ++ ++ for (l = ignoredwords; l; l = l->next) ++ if (!strcasecmp(l->word, word)) ++ return 1; ++ return 0; ++} +diff -Nur src/mod/gseen.mod/datahandling.c src/mod/gseen.mod/datahandling.c +--- src/mod/gseen.mod/datahandling.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/datahandling.c 2002-10-26 13:17:48.000000000 +0200 +@@ -0,0 +1,151 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++ ++static void write_seens() ++{ ++ seenreq *r; ++ seenreq_by *b; ++ FILE *f; ++ char s[125]; ++ ++ Context; ++ /* putlog(LOG_MISC, "*", "Saving seen data..."); */ ++ if (!gseenfile[0]) ++ return; ++ sprintf(s, "%s~new", gseenfile); ++ f = fopen(s, "w"); ++ chmod(s, 0600); ++ if (f == NULL) { ++ putlog(LOG_MISC, "*", "ERROR writing gseen file."); ++ return; ++ } ++ fprintf(f, "# gseen data file v1.\n"); ++ write_seen_tree_target = f; ++ btree_getall(&seentree, write_seen_tree); ++ for (r = requests; r; r = r->next) ++ for (b = r->by; b; b = b->next) ++ /* @ nick by host chan when */ ++ fprintf(f, "@ %s %s %s %s %lu\n", r->nick, b->who, b->host, b->chan, ++ b->when); ++ fclose(f); ++ unlink(gseenfile); ++ movefile(s, gseenfile); ++ /* putlog(LOG_MISC, "*", "Done."); */ ++ return; ++} ++ ++static void read_seens() ++{ ++ FILE *f; ++ char buf[512], *s, *type, *nick, *host, *chan, *msg, *by; ++ time_t when; ++ int spent, iType, i; ++ ++ Context; ++ f = fopen(gseenfile, "r"); ++ if (f == NULL) { ++ putlog(LOG_MISC, "*", "Can't open gseen file, creating new database..."); ++ return; ++ } ++ while (!feof(f)) { ++ buf[0] = 0; ++ s = buf; ++ fgets(s, 511, f); ++ i = strlen(buf); ++ if (buf[i - 1] == '\n') ++ buf[i - 1] = 0; ++ if ((buf[0] == 0) || (buf[0] == '#')) ++ continue; ++ type = newsplit(&s); ++ if (!strcmp(type, "!")) { ++ nick = newsplit(&s); ++ host = newsplit(&s); ++ chan = newsplit(&s); ++ iType = atoi(newsplit(&s)); ++ when = (time_t) atoi(newsplit(&s)); ++ spent = atoi(newsplit(&s)); ++ msg = s; ++ add_seen(iType, nick, host, chan, msg, when, spent); ++ } else if (!strcmp(type, "@")) { ++ nick = newsplit(&s); ++ by = newsplit(&s); ++ host = newsplit(&s); ++ chan = newsplit(&s); ++ when = (time_t) atoi(newsplit(&s)); ++ add_seenreq(nick, by, host, chan, when); ++ } ++ } ++ fclose(f); ++ Context; ++ return; ++} ++ ++static void purge_seens() ++{ ++ seenreq *r, *rr; ++ seenreq_by *b, *bb; ++ ++ Context; ++ if (!expire_seens) ++ return; ++ btree_getall_expanded(&seentree, purge_seen_tree); ++ debug0("purge done"); ++ r = requests; ++ rr = NULL; ++ while (r) { ++ b = r->by; ++ bb = NULL; ++ while (b) { ++ if ((now - b->when) > (expire_seens * 86400)) { ++ debug2("request for %s from %s has expired.", r->nick, b->who); ++ nfree(b->who); ++ nfree(b->host); ++ nfree(b->chan); ++ if (bb) { ++ bb->next = b->next; ++ nfree(b); ++ b = bb->next; ++ } else { ++ r->by = b->next; ++ nfree(b); ++ b = r->by; ++ } ++ } else { ++ bb = b; ++ b = b->next; ++ } ++ } ++ if (!r->by) { ++ debug1("no further seen requests for %s, deleting", r->nick); ++ nfree(r->nick); ++ if (rr) { ++ rr->next = r->next; ++ nfree(r); ++ r = rr->next; ++ } else { ++ requests = r->next; ++ nfree(r); ++ r = requests; ++ } ++ } else { ++ rr = r; ++ r = r->next; ++ } ++ } ++} +diff -Nur src/mod/gseen.mod/do_seen.c src/mod/gseen.mod/do_seen.c +--- src/mod/gseen.mod/do_seen.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/do_seen.c 2002-10-26 13:17:50.000000000 +0200 +@@ -0,0 +1,840 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++/* do_seen(): Checks if someone matches the mask, and returns the reply ++ * mask : first paramater (e.g. "G`Quann", "G`Quann", "*!*@*.isp.de", ...) ++ * nick : nick of the one, who triggered the command ++ * uhost: user@host of nick ++ * chan : chan, where the command was triggered ++ * bns : ++ * 1 : do a botnet-seen if no matches are found ++ * 0 : don't do a botnet-seen ++ * -1 : return NULL instead of text, if no matches were found ++ * (necessary for botnet seen) ++ */ ++static char *do_seen(char *mask, char *nick, char *uhost, char *chan, int bns) ++{ ++ char hostbuf[UHOSTLEN + 1], *host, *newhost, *tmp, *dur; ++ seendat *l; ++ gseenres *r; ++ int wild, nr; ++ char bnquery[256]; ++ struct userrec *u; ++ struct laston_info *li; ++ struct chanset_t *ch; ++ ++ Context; ++ start_seentime_calc(); ++ if (seen_reply) { ++ nfree(seen_reply); ++ seen_reply = NULL; ++ } ++ l = NULL; ++ li = NULL; ++ host = hostbuf; ++ newhost = NULL; ++ mask = newsplit(&mask); ++ glob_query = mask; ++ while (mask[0] == ' ') ++ mask++; ++ if (!mask[0]) { ++ return SLNOPARAM; ++ } ++ if (strchr(mask, '?') || strchr(mask, '*')) { ++ // if wildcard-searches ares not allowed, then either return ++ // NULL (for botnet-seen), or a appropriate warning ++ if (!wildcard_search) { ++ if (bns == -1) ++ return NULL; ++ else ++ return SLNOWILDCARDS; ++ } else ++ wild = 1; ++ } else { ++ if (strlen(mask) > seen_nick_len) // don't process if requested nick is too long ++ return SLTOOLONGNICK; // (e.g. stop stupid jokes) ++ if (!strcasecmp(mask, nick)) { ++ return SLMIRROR; ++ } ++ // check if the nick is on the current channel ++ if (onchan(mask, chan)) ++ return SLONCHAN; ++ if ((glob_othernick = handonchan(mask, chan))) ++ return SLHANDONCHAN; ++ // check if it is on any other channel ++ if ((ch = onanychan(mask))) { ++#if EGG_IS_MIN_VER(10500) ++ if (!secretchan(ch->dname)) { ++ glob_otherchan = ch->dname; ++ return SLONOTHERCHAN; ++ } ++#else ++ if (!secretchan(ch->name)) { ++ glob_otherchan = ch->name; ++ return SLONOTHERCHAN; ++ } ++#endif ++ } ++ // check if the user who uses this handle is on the channel under ++ // a different nick ++ if ((ch = handonanychan(mask))) { ++#if EGG_IS_MIN_VER(10500) ++ if (!secretchan(ch->dname)) { ++ glob_otherchan = ch->dname; ++ return SLONOTHERCHAN; ++ } ++#else ++ if (!secretchan(ch->name)) { ++ glob_otherchan = ch->name; ++ return SLONOTHERCHAN; ++ } ++#endif ++ } ++ add_seenreq(mask, nick, uhost, chan, now); ++ wild = 0; ++ l = findseen(mask); ++ // if there's a result, and if we don't want to search for the same user ++ // under a different nick, just make a do_seennick on the result ++ if (l && !fuzzy_search) { ++ tmp = do_seennick(l); ++ end_seentime_calc(); ++ return tmp; ++ } ++ if (!l) { ++ u = get_user_by_handle(userlist, mask); ++ if (u) { ++ li = get_user(&USERENTRY_LASTON, u); ++ } ++ if (!u || !li) { ++ if (bns == -1) { // if bns is 0, then do_seen() was triggered by ++ end_seentime_calc(); // a botnet seen function, which needs a clear ++ return NULL; // NULL to detect if there was a result or not ++ } ++ tmp = SLNOTSEEN; ++ if (bns && ((strlen(mask) + strlen(nick) + strlen(uhost) ++ + strlen(chan) + 20) < 255)) { ++ debug0("trying botnet seen"); ++ if (bnsnick) ++ nfree(bnsnick); ++ if (bnschan) ++ nfree(bnschan); ++ bnsnick = nmalloc(strlen(nick) + 1); ++ strcpy(bnsnick, nick); ++ bnschan = nmalloc(strlen(chan) + 1); ++ strcpy(bnschan, chan); ++ sprintf(bnquery, "gseen_req %s %s %s %s", mask, nick, uhost, chan); ++ botnet_send_zapf_broad(-1, botnetnick, NULL, bnquery); ++ } ++ } else { ++ // we have a matching handle, no seen-entry, but a laston entry ++ // in the userbase, so let's just return that one. ++ dur = gseen_duration(now - li->laston); ++ glob_laston = dur; ++ tmp = SLPOORSEEN; ++ seen_reply = nmalloc(strlen(tmp) + 1); ++ strcpy(seen_reply, tmp); ++ end_seentime_calc(); ++ return seen_reply; ++ } ++ end_seentime_calc(); ++ return tmp; ++ } ++ // now prepare the host for fuzzy-search ++ if (strlen(l->host) < UHOSTLEN) { ++ maskstricthost(l->host, host); ++ host = strchr(host, '!') + 1; // strip nick from host for faster search ++ } else { ++ end_seentime_calc(); ++ return "error, too long host"; ++ } ++ } ++ if (l && (l->type == SEEN_CHPT)) { ++ tmp = do_seennick(l); ++ end_seentime_calc(); ++ return tmp; ++ } ++ numresults = 0; ++ // wildmatch_seens uses a global var to store hosts in it ++ // (to prevent massive nmalloc/nfree-usage), so don't forget ++ // to initialize and free it ++ temp_wildmatch_host = my_malloc(1); ++ wildmatch_seens(host, mask, wild); ++ my_free(temp_wildmatch_host); ++ temp_wildmatch_host = NULL; ++ if (!results) { ++ end_seentime_calc(); ++ if (bns == -1) ++ return NULL; // let the botnet seen function know, that seen failed ++ return SLNOMATCH; ++ } ++ if (numresults >= max_matches) { ++ end_seentime_calc(); ++ free_seenresults(); ++ return SLTOOMANYMATCHES; ++ } ++ sortresults(); ++ if (strcasecmp(results->seen->nick, mask)) { ++ // if the user's latest nick is not the nick for which we were searching, ++ // say that there were multiple matches and display the latest one ++ if (numresults == 1) ++ tmp = SLONEMATCH; ++ else if (numresults <= 5) ++ tmp = SLLITTLEMATCHES; ++ else ++ tmp = SLMANYMATCHES; ++ seen_reply = nmalloc(strlen(tmp) + 1); ++ strcpy(seen_reply, tmp); ++ nr = 0; ++ for (r = results; (r && (nr < 5)); r = r->next) { ++ nr++; ++ if (nr > 1) { ++ seen_reply = nrealloc(seen_reply, 1 + strlen(seen_reply) + 1 + strlen(r->seen->nick) + 1); ++ strcat(seen_reply, ", "); ++ } else { ++ seen_reply = nrealloc(seen_reply, 1 + strlen(seen_reply) + strlen(r->seen->nick) + 1); ++ strcat(seen_reply, " "); ++ } ++ strcat(seen_reply, r->seen->nick); ++ } ++ tmp = do_seennick(results->seen); ++ seen_reply = nrealloc(seen_reply, 2 + strlen(seen_reply) + strlen(tmp) + 1); ++ sprintf(seen_reply, "%s. %s", seen_reply, tmp); ++ } else { // first result is the nick which we were searching for ++ // just return the info for this nick and don't care about other results ++ tmp = do_seennick(results->seen); ++ seen_reply = nmalloc(strlen(tmp) + 1); ++ strcpy(seen_reply, tmp); ++ } ++ free_seenresults(); ++ end_seentime_calc(); ++ return seen_reply; ++} ++ ++/* do_seennick(): ++ * takes a seen-dataset and produces the corresponding reply basically ++ * by referencing to the lang entry with the same number as the seen-type. ++ */ ++static char *do_seennick(seendat *l) ++{ ++// char buf[256], *msg; ++ int stype; ++ ++ Context; ++ if (!l) { ++ debug0("ERROR! Tryed to do a seennick on a NULL pointer!"); ++ return "ERROR! seendat == NULL!!!"; ++ } ++ glob_seendat = l; ++ // l->type is the basic language-entry-number ++ stype = l->type + 100; ++ // in some cases, we might need a special reply, so modify the ++ // number if neccessary ++ switch (l->type) { ++ case SEEN_JOIN: ++ if (!onchan(l->nick, l->chan)) ++ stype += 20; ++ break; ++ case SEEN_PART: ++ /* nothing to do here */ ++ break; ++ case SEEN_SIGN: ++ /* nothing again */ ++ break; ++ case SEEN_NICK: ++ if (!onchan(l->msg, l->chan)) ++ stype += 20; ++ break; ++ case SEEN_NCKF: ++ if (!onchan(l->nick, l->chan)) ++ stype += 20; ++ break; ++ case SEEN_KICK: ++/* msg = buf; ++ strncpy(buf, l->msg, 255); ++ msg[255] = 0; ++ sglobpunisher = newsplit(&msg); ++ sglobreason = msg; */ ++ break; ++ case SEEN_SPLT: ++ /* nothing to do here */ ++ break; ++ case SEEN_REJN: ++ if (!onchan(l->nick, l->chan)) ++ stype += 20; ++ break; ++ case SEEN_CHJN: ++ case SEEN_CHPT: ++ if (!strcmp(l->chan, "0")) ++ stype += 20; ++ break; ++ default: ++ stype = 140; ++ } ++ return getslang(stype); ++} ++ ++/* findseens(): ++ * interface for webseen.mod ++ * find all results for a query and return a pointer to this list ++ * (basically the core of do_seen()) ++ */ ++static gseenres *findseens(char *mask, int *ret, int fuzzy) ++{ ++ char hostbuf[UHOSTLEN + 1], *host, *newhost; ++ seendat *l; ++ int wild; ++ ++ Context; ++ start_seentime_calc(); ++ *ret = WS_OK; ++ l = NULL; ++ host = hostbuf; ++ newhost = NULL; ++ mask = newsplit(&mask); ++ while (mask[0] == ' ') ++ mask++; ++ if (!mask[0]) { ++ *ret = WS_NOPARAM; ++ return NULL; ++ } ++ if (strchr(mask, '?') || strchr(mask, '*')) { ++ // if wildcard-searches ares not allowed, then either return ++ // NULL (for botnet-seen), or a appropriate warning ++ if (!wildcard_search) { ++ *ret = WS_NOWILDCARDS; ++ return NULL; ++ } ++ wild = 1; ++ } else { ++ if (strlen(mask) > seen_nick_len) { // don't process if requested nick is too long ++ *ret = WS_TOOLONGNICK; // (e.g. stop stupid jokes) ++ return NULL; ++ } ++ add_seenreq(mask, "www-user", "unknown_host", "webinterface", now); ++ wild = 0; ++ l = findseen(mask); ++ // if there's a result, and if we don't want to search for the same user ++ // under a different nick, just return this result ++ if (l && (!fuzzy_search || !fuzzy)) { ++ numresults = 1; ++ add_seenresult(l); ++ end_seentime_calc(); ++ return results; ++ } ++ if (!l) { ++ // no matching user was found :( ++ *ret = WS_NORESULT; ++ end_seentime_calc(); ++ return NULL; ++ } ++ // now prepare the host for fuzzy-search ++ if (strlen(l->host) < UHOSTLEN) { ++ maskstricthost(l->host, host); ++ host = strchr(host, '!') + 1; // strip nick from host for faster search ++ } else { ++ *ret = WS_TOOLONGHOST; ++ end_seentime_calc(); ++ return NULL; ++ } ++ } ++ if (l && (l->type == SEEN_CHPT)) { ++ numresults = 1; ++ add_seenresult(l); ++ end_seentime_calc(); ++ return results; ++ } ++ numresults = 0; ++ // wildmatch_seens uses a global var to store hosts in it ++ // (to prevent massive nmalloc/nfree-usage), so don't forget ++ // to initialize and free it ++ temp_wildmatch_host = my_malloc(1); ++ wildmatch_seens(host, mask, wild); ++ my_free(temp_wildmatch_host); ++ temp_wildmatch_host = NULL; ++ if (!results) { ++ // no match :( ++ *ret = WS_NORESULT; ++ end_seentime_calc(); ++ return NULL; ++ } ++ if (numresults >= max_matches) { ++ free_seenresults(); ++ *ret = WS_TOOMANYMATCHES; ++ end_seentime_calc(); ++ return NULL; ++ } ++ sortresults(); ++ *ret = 0; ++ end_seentime_calc(); ++ return results; ++} ++ ++ ++char seenstats_reply[512]; ++static char *do_seenstats() ++{ ++ glob_totalnicks = count_seens(); ++ glob_totalbytes = gseen_expmem(); ++ sprintf(seenstats_reply, "%s", SLSEENSTATS); ++ return seenstats_reply; ++} ++ ++// add an seen result (to the top of the list) ++static void add_seenresult(seendat *seen) ++{ ++ gseenres *nl; ++ ++ numresults++; ++ if (numresults > max_matches) ++ return; ++ nl = nmalloc(sizeof(gseenres)); ++ nl->seen = seen; ++ nl->next = results; ++ results = nl; ++} ++ ++static int expmem_seenresults() ++{ ++ int bytes = 0; ++ gseenres *l; ++ ++ for (l = results; l; l = l->next) ++ bytes += sizeof(gseenres); ++ return bytes; ++} ++ ++static void free_seenresults() ++{ ++ gseenres *l, *ll; ++ ++ l = results; ++ while (l) { ++ ll = l->next; ++ nfree(l); ++ l = ll; ++ } ++ results = NULL; ++} ++ ++static void sortresults() ++{ ++ int again = 1; ++ gseenres *last, *p, *c, *n; ++ int a, b; ++ ++ Context; ++ again = 1; ++ last = NULL; ++ while ((results != last) && (again)) { ++ p = NULL; ++ c = results; ++ n = c->next; ++ again = 0; ++ while (n != last) { ++ if (!c || !n) ++ a = b = 0; ++ else ++ a = c->seen->when; ++ b = n->seen->when; ++ if (a < b) { ++ again = 1; ++ c->next = n->next; ++ n->next = c; ++ if (p == NULL) ++ results = n; ++ else ++ p->next = n; ++ } ++ p = c; ++ c = n; ++ n = n->next; ++ } ++ last = c; ++ } ++ Context; ++ return; ++} ++ ++static void sortrequests(seenreq *l) ++{ ++ int again = 1; ++ seenreq_by *last, *p, *c, *n; ++ int a, b; ++ ++ Context; ++ again = 1; ++ last = NULL; ++ while ((l->by != last) && (again)) { ++ p = NULL; ++ c = l->by; ++ n = c->next; ++ again = 0; ++ while (n != last) { ++ if (!c || !n) ++ a = b = 0; ++ else ++ a = c->when; ++ b = n->when; ++ if (a < b) { ++ again = 1; ++ c->next = n->next; ++ n->next = c; ++ if (p == NULL) ++ l->by = n; ++ else ++ p->next = n; ++ } ++ p = c; ++ c = n; ++ n = n->next; ++ } ++ last = c; ++ } ++ Context; ++ return; ++} ++ ++/* stolen from tcl_duration in tclmisc.c */ ++char gs_duration_temp[256]; ++static char *gseen_duration(int seconds) ++{ ++ char s[256]; ++ time_t sec; ++ ++ sec = seconds; ++ s[0] = 0; ++ if (sec < 1) { ++ snprintf(gs_duration_temp, sizeof(gs_duration_temp), "%s", SLSOMETIME); ++ return gs_duration_temp; ++ } ++ if (sec < 60) { ++ sprintf(gs_duration_temp, "%d %s", (int) (sec / 1), ++ ((int) (sec / 1) > 1) ? SLSECONDS : SLSECOND); ++ return gs_duration_temp; ++ } ++ if (sec >= 31536000) { ++ sprintf(s, "%d %s ", (int) (sec / 31536000), ++ ((int) (sec / 31536000) > 1) ? SLYEARS : SLYEAR); ++ sec -= (((int) (sec / 31536000)) * 31536000); ++ } ++ if (sec >= 604800) { ++ sprintf(&s[strlen(s)], "%d %s ", (int) (sec / 604800), ++ ((int) (sec / 604800) > 1) ? SLWEEKS : SLWEEK); ++ sec -= (((int) (sec / 604800)) * 604800); ++ } ++ if (sec >= 86400) { ++ sprintf(&s[strlen(s)], "%d %s ", (int) (sec / 86400), ++ ((int) (sec / 86400) > 1) ? SLDAYS : SLDAY); ++ sec -= (((int) (sec / 86400)) * 86400); ++ } ++ if (sec >= 3600) { ++ sprintf(&s[strlen(s)], "%d %s ", (int) (sec / 3600), ++ ((int) (sec / 3600) > 1) ? SLHOURS : SLHOUR); ++ sec -= (((int) (sec / 3600)) * 3600); ++ } ++ if (sec >= 60) { ++ sprintf(&s[strlen(s)], "%d %s ", (int) (sec / 60), ++ ((int) (sec / 60) > 1) ? SLMINUTES : SLMINUTE); ++ sec -= (((int) (sec / 60)) * 60); ++ } ++ strcpy(gs_duration_temp, s); ++ if (gs_duration_temp[strlen(gs_duration_temp) - 1] == ' ') ++ gs_duration_temp[strlen(gs_duration_temp) - 1] = 0; ++ return gs_duration_temp; ++} ++ ++static int onchan(char *nick, char *chan) ++{ ++ struct chanset_t *ch; ++ memberlist *m; ++ ++ ch = findchan_by_dname(chan); ++ if (!ch) ++ return 0; ++ m = ismember(ch, nick); ++ if (!m) ++ return 0; ++ else if (chan_issplit(m)) ++ return 0; ++ else ++ return 1; ++} ++ ++/* handonchan(): ++ * checks if the given user is on the channel and returns its nick ++ */ ++static char *handonchan(char *hand, char *chan) ++{ ++ struct chanset_t *ch; ++ memberlist *m; ++ ++ ch = findchan_by_dname(chan); ++ if (!ch) ++ return 0; ++ if (ch->channel.members > 0) { ++ for (m = ch->channel.member; m; m = m->next) { ++ if (m->user) { ++ if (m->user->handle && !rfc_casecmp(m->user->handle, hand)) ++ return m->nick; ++ } ++ } ++ } ++ return NULL; ++} ++ ++/* onanychan(): ++ * checks if the given nickname is on any of the bot's chans. ++ */ ++static struct chanset_t *onanychan(char *nick) ++{ ++ struct chanset_t *ch; ++ memberlist *m; ++ ++ for (ch = chanset; ch; ch = ch->next) { ++ m = ismember(ch, nick); ++ if (m && !chan_issplit(m)) ++ return ch; ++ } ++ return NULL; ++} ++ ++/* handonanychan(): ++ * checks if the given user is on any channel (no matter under which nick) ++ */ ++static struct chanset_t *handonanychan(char *hand) ++{ ++ struct chanset_t *ch; ++ memberlist *m; ++ ++ for (ch = chanset; ch; ch = ch->next) { ++ if (ch->channel.members > 0) { ++ for (m = ch->channel.member; m; m = m->next) { ++ if (m->user) { ++ if (m->user->handle && !rfc_casecmp(m->user->handle, hand)) ++ return ch; ++ } ++ } ++ } ++ } ++ return NULL; ++} ++ ++static void add_seenreq(char *nick, char *from, char *host, char *chan, ++ time_t when) ++{ ++ seenreq *l, *nl; ++ seenreq_by *b, *nb; ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (!tell_seens) ++ return; ++ if (strcmp(chan, "[partyline]") && secretchan(chan)) ++ chan = buf; ++ for (l = requests; l; l = l->next) { ++ if (!strcasecmp(nick, l->nick)) { ++ for (b = l->by; b; b = b->next) { ++ if (!strcasecmp(from, b->who)) { ++ nfree(b->chan); ++ b->chan = nmalloc(strlen(chan) + 1); ++ strcpy(b->chan, chan); ++ b->when = when; ++ return; ++ } ++ } ++ b = l->by; ++ while (b && b->next) ++ b = b->next; ++ nb = nmalloc(sizeof(seenreq_by)); ++ nb->who = nmalloc(strlen(from) + 1); ++ strcpy(nb->who, from); ++ nb->host = nmalloc(strlen(host) + 1); ++ strcpy(nb->host, host); ++ nb->chan = nmalloc(strlen(chan) + 1); ++ strcpy(nb->chan, chan); ++ nb->when = when; ++ nb->next = NULL; ++ if (l->by) ++ b->next = nb; ++ else ++ l->by = nb; ++ return; ++ } ++ } ++ nb = nmalloc(sizeof(seenreq_by)); ++ nb->who = nmalloc(strlen(from) + 1); ++ strcpy(nb->who, from); ++ nb->host = nmalloc(strlen(host) + 1); ++ strcpy(nb->host, host); ++ nb->chan = nmalloc(strlen(chan) + 1); ++ strcpy(nb->chan, chan); ++ nb->when = when; ++ nb->next = NULL; ++ l = requests; ++ while (l && l->next) ++ l = l->next; ++ nl = nmalloc(sizeof(seenreq)); ++ nl->nick = nmalloc(strlen(nick) + 1); ++ strcpy(nl->nick, nick); ++ nl->by = nb; ++ nl->next = NULL; ++ if (requests) ++ l->next = nl; ++ else ++ requests = nl; ++} ++ ++static int expmem_seenreq() ++{ ++ seenreq *l; ++ seenreq_by *b; ++ int size; ++ ++ size = 0; ++ for (l = requests; l; l = l->next) { ++ size += sizeof(seenreq); ++ size += strlen(l->nick) + 1; ++ for (b = l->by; b; b = b->next) { ++ size += sizeof(seenreq_by); ++ size += strlen(b->who) + 1; ++ size += strlen(b->host) + 1; ++ size += strlen(b->chan) + 1; ++ } ++ } ++ return size; ++} ++ ++static int count_seenreq(seenreq_by *b) ++{ ++ seenreq_by *l; ++ int nr; ++ ++ nr = 0; ++ for (l = b; l; l = l->next) ++ nr++; ++ return nr; ++} ++ ++static void free_seenreq() ++{ ++ seenreq *l, *ll; ++ seenreq_by *b, *bb; ++ ++ Context; ++ l = requests; ++ while (l) { ++ b = l->by; ++ while (b) { ++ bb = b->next; ++ nfree(b->who); ++ nfree(b->host); ++ nfree(b->chan); ++ nfree(b); ++ b = bb; ++ } ++ ll = l->next; ++ nfree(l->nick); ++ nfree(l); ++ l = ll; ++ } ++ requests = NULL; ++} ++ ++static void report_seenreq(char *channel, char *nick) ++{ ++ seenreq *l, *ll; ++ seenreq_by *b, *bb; ++ char *reply, *tmp; ++ int nr; ++ ++ if (!tell_seens) ++ return; ++ ll = NULL; ++ l = requests; ++ reply = NULL; ++ while (l) { ++ if (!strcasecmp(l->nick, nick)) { ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, channel)); ++ glob_nick = nick; ++ nr = count_seenreq(l->by); ++ if (nr == 1) { ++ glob_seenrequest = l; ++ dprintf(DP_HELP, "NOTICE %s :%s\n", l->nick, SLONELOOK); ++ } else { ++ sortrequests(l); ++ glob_seenrequest = l; ++ glob_seenrequests = nr; ++ tmp = SLMORELOOKS; ++ reply = nmalloc(strlen(tmp) + 1); ++ strcpy(reply, tmp); ++ nr = 0; ++ for (b = l->by; b; b = b->next) { ++ nr++; ++ reply = nrealloc(reply, strlen(reply) + ((nr == 1) ? 1 : 2) + strlen(b->who) + 1); ++ sprintf(reply, "%s%s%s", reply, (nr == 1) ? " " : ", ", b->who); ++ } ++ tmp = SLLASTLOOK; ++ reply = nrealloc(reply, strlen(reply) + 2 + strlen(tmp) + 1); ++ sprintf(reply, "%s. %s", reply, tmp); ++ dprintf(DP_HELP, "NOTICE %s :%s\n", l->nick, reply); ++ nfree(reply); ++ } ++ b = l->by; ++ while (b) { ++ bb = b->next; ++ nfree(b->who); ++ nfree(b->host); ++ nfree(b->chan); ++ nfree(b); ++ b = bb; ++ } ++ nfree(l->nick); ++ if (ll) ++ ll->next = l->next; ++ else ++ requests = l->next; ++ nfree(l); ++ if (ll) ++ l = ll->next; ++ else ++ l = requests; ++ } else { ++ ll = l; ++ l = l->next; ++ } ++ } ++} ++ ++static void start_seentime_calc() ++{ ++ struct timeval t; ++ ++ gettimeofday(&t, NULL); ++ glob_presearch = (float) t.tv_sec + (((float) t.tv_usec) / 1000000); ++} ++ ++static void end_seentime_calc() ++{ ++ struct timeval t; ++ ++ gettimeofday(&t, NULL); ++ glob_aftersearch = (float) t.tv_sec + (((float) t.tv_usec) / 1000000); ++ glob_total_searchtime += glob_aftersearch - glob_presearch; ++ glob_total_queries++; ++} +diff -Nur src/mod/gseen.mod/generic_binary_tree.c src/mod/gseen.mod/generic_binary_tree.c +--- src/mod/gseen.mod/generic_binary_tree.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/generic_binary_tree.c 2002-10-26 13:17:51.000000000 +0200 +@@ -0,0 +1,311 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++#define GENERIC_BINARY_TREE 1 ++ ++struct generic_binary_tree { ++ void *root; ++ int (*comparedata) (void *data1, void *data2); ++ int (*expmemdata) (void *data); ++ void (*freedata) (void *data); ++}; ++ ++struct generic_binary_tree_node { ++ void *data; ++ void *left; ++ void *right; ++}; ++ ++static void btree_add(struct generic_binary_tree *, void *); ++static int btree_expmem(struct generic_binary_tree *); ++static int btree_recursive_expmem(struct generic_binary_tree *, struct generic_binary_tree_node *); ++static void *btree_get(struct generic_binary_tree *, void *t); ++static void btree_freetree(struct generic_binary_tree *); ++static void btree_recursive_free(struct generic_binary_tree *, ++ struct generic_binary_tree_node *); ++static void btree_getall(struct generic_binary_tree *, void (*) (void *)); ++static void btree_recursive_getall(struct generic_binary_tree_node *, ++ void (*) (void *)); ++static void btree_getall_expanded(struct generic_binary_tree *tree, void (*) (void *)); ++static void btree_recursive_getall_expanded(struct generic_binary_tree_node *, ++ void (*) (void *)); ++static void btree_remove(struct generic_binary_tree *, void *); ++ ++static void btree_add(struct generic_binary_tree *tree, void *data) ++{ ++ struct generic_binary_tree_node *node, *lastnode; ++ int cmp, lastcmp; ++ ++ Assert(tree); ++ Assert(data); ++ cmp = lastcmp = 0; ++ node = tree->root; ++ lastnode = NULL; ++ while (node) { ++ cmp = tree->comparedata(node->data, data); ++ if (!cmp) { ++ // item is identical -> free old data and insert new ++ tree->freedata(node->data); ++ node->data = data; ++ return; ++ } ++ lastnode = node; ++ lastcmp = cmp; ++ if (cmp < 0) ++ node = node->left; ++ else ++ node = node->right; ++ } ++ node = nmalloc(sizeof(struct generic_binary_tree_node)); ++ node->left = NULL; ++ node->right = NULL; ++ node->data = data; ++ if (!lastnode) ++ tree->root = node; ++ else { ++ Assert(lastcmp); ++ if (lastcmp < 0) { ++ Assert(!lastnode->left); ++ lastnode->left = node; ++ } else { ++ Assert(!lastnode->right); ++ lastnode->right = node; ++ } ++ } ++} ++ ++static int btree_expmem(struct generic_binary_tree *tree) ++{ ++ int size = 0; ++ ++ Assert(tree); ++ size += btree_recursive_expmem(tree, tree->root); ++ return size; ++} ++ ++static int btree_recursive_expmem(struct generic_binary_tree *tree, struct generic_binary_tree_node *node) ++{ ++ int size = 0; ++ ++ if (!node) ++ return 0; ++ size += sizeof(struct generic_binary_tree_node); ++ size += tree->expmemdata(node->data); ++ size += btree_recursive_expmem(tree, node->left); ++ size += btree_recursive_expmem(tree, node->right); ++ return size; ++} ++ ++static void *btree_get(struct generic_binary_tree *tree, void *what) ++{ ++ struct generic_binary_tree_node *node; ++ int cmp; ++ ++ node = tree->root; ++ while (node) { ++ cmp = tree->comparedata(node->data, what); ++ if (!cmp) ++ return node->data; ++ if (cmp < 0) ++ node = node->left; ++ else ++ node = node->right; ++ } ++ return NULL; ++} ++ ++static void btree_freetree(struct generic_binary_tree *tree) ++{ ++ btree_recursive_free(tree, tree->root); ++} ++ ++static void btree_recursive_free(struct generic_binary_tree *tree, ++ struct generic_binary_tree_node *node) ++{ ++ if (!node) ++ return; ++ btree_recursive_free(tree, node->left); ++ btree_recursive_free(tree, node->right); ++ tree->freedata(node->data); ++ nfree(node); ++} ++ ++/* btree_getall(): ++ * calls the specified function for each item in the tree. ++ * NOTE: getall() calls the proc _before_ it proceeds into recursion. This way, ++ * one can savely store the tree into a file without mixing up its form. ++ * But if you delete an item from the called prcedure, this function ++ * WILL crash. Use btree_getall() expanded instead. ++ */ ++static void btree_getall(struct generic_binary_tree *tree, void (*func) (void *)) ++{ ++ Assert(tree); ++ btree_recursive_getall(tree->root, func); ++} ++ ++static void btree_recursive_getall(struct generic_binary_tree_node *node, ++ void (*func) (void *)) ++{ ++ if (!node) ++ return; ++ // first call the function, then proceed into recursion ++ // this way, the tree keeps in form if its saved to a file, for example ++ Assert(func); ++ func(node->data); ++ ++ btree_recursive_getall(node->left, func); ++ btree_recursive_getall(node->right, func); ++} ++ ++/* btree_getall_expanded(): ++ * the same as btree_getall(), but calls the function after the greatest level of recursion ++ * has been reached. The node-pointers won't be accessed anymore when the first function ++ * gets called. You can savely use this to free items. ++ */ ++static void btree_getall_expanded(struct generic_binary_tree *tree, void (*func) (void *)) ++{ ++ Assert(tree); ++ btree_recursive_getall_expanded(tree->root, func); ++} ++ ++static void btree_recursive_getall_expanded(struct generic_binary_tree_node *node, ++ void (*func) (void *)) ++{ ++ if (!node) ++ return; ++ btree_recursive_getall_expanded(node->left, func); ++ btree_recursive_getall_expanded(node->right, func); ++ ++ Assert(func); ++ func(node->data); ++} ++ ++static void btree_remove(struct generic_binary_tree *tree, void *data) ++{ ++ struct generic_binary_tree_node *node, *last, *largenode, *lastlarge; ++ int ret, lastret; ++ ++ Assert(tree); ++ Assert(data); ++ last = NULL; ++ lastret = 0; ++ node = tree->root; ++ while (node) { ++ ret = tree->comparedata(node->data, data); ++ if (ret == 0) ++ break; ++ last = node; ++ lastret = ret; ++ if (ret < 0) ++ node = node->left; ++ else ++ node = node->right; ++ } ++ if (!node) // oops, item not found ++ return; ++ if (!node->left && !node->right) { ++ // *freu* no sub-branches! We can easily delete this item. ++ if (last) { ++ if (lastret < 0) ++ last->left = NULL; ++ else ++ last->right = NULL; ++ } else ++ tree->root = NULL; ++ } else if (!node->left) { ++ // also pretty easy. Just connect the child to the parent. ++ if (last) { ++ if (lastret < 0) ++ last->left = node->right; ++ else ++ last->right = node->right; ++ } else ++ tree->root = node->right; ++ } else if (!node->right) { ++ // same as above, but mirrored ++ if (last) { ++ if (lastret < 0) ++ last->left = node->left; ++ else ++ last->right = node->left; ++ } else ++ tree->root = node->left; ++ } else { ++ // aaargh... two sub-trees! The world is not fair... *sigh* ++ debug0("argl... worst case, two subtrees. :( Let's pray..."); ++ // now we take the largest item from the left subtree and replace the ++ // doomed node with it. ++ // since it is the largest val, the tree remains valid and doesn't ++ // get deformed too much. ++ ++ // at first, we have to find this node and cut it from the tree ++ largenode = node->left; ++ lastlarge = NULL; ++ while (largenode && largenode->right) { ++ lastlarge = largenode; ++ largenode = largenode->right; ++ } ++ ++ // only set largenode->left to node->left if largenode exists. ++ // otherwise node->left points to largenode, which would result ++ // in a nice short-circuit ++ // If it does not exist, just leave largenode->left as it is because we just ++ // move largenode one level up, so it can keep its left subtree. ++ if (lastlarge) { ++ lastlarge->right = largenode->left; ++ largenode->left = node->left; ++ } ++ ++ // now connect node's subtrees to it ++ largenode->right = node->right; ++ ++ // and finally replace node with largenode ++ if (last) { ++ if (lastret < 0) ++ last->left = largenode; ++ else ++ last->right = largenode; ++ } else ++ tree->root = largenode; ++ } ++ // finally kill the node... we shouldn't need it anymore ++ tree->freedata(node->data); ++ nfree(node); ++ node = NULL; ++} ++ ++#ifdef BTREE_WITHOPTIMIZE ++static void btree_optimize(struct generic_binary_tree *tree, ++ struct generic_binary_tree_node *node, ++ struct generic_binary_tree_node *last, ++ int limit) ++{ ++/* int leftdepth, rightdepth; ++ ++ if (!node) ++ return; ++ btree_optimize(tree, node->left, node, last, limit); ++ btree_optimize(tree, node->right, node, last, limit); ++ leftdepth = btree_depth(node->left); ++ rightdepth = btree_depth(node->right); ++ if ((leftdepth - rightdepth) > limit) { ++ ++ } ++*/ ++} ++#endif +diff -Nur src/mod/gseen.mod/global_vars.c src/mod/gseen.mod/global_vars.c +--- src/mod/gseen.mod/global_vars.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/global_vars.c 2002-10-26 13:18:09.000000000 +0200 +@@ -0,0 +1,34 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++static char *glob_query, *glob_laston, *glob_otherchan, *glob_othernick; ++static char *glob_remotebot, *glob_nick; ++static struct slang_header *glob_slang; ++static seendat *glob_seendat; ++static seenreq *glob_seenrequest; ++static int glob_seenrequests, glob_totalnicks, glob_totalbytes; ++ ++static void reset_global_vars() ++{ ++ glob_query = glob_laston = glob_otherchan = glob_othernick = NULL; ++ glob_remotebot = glob_nick = NULL; ++ glob_seendat = NULL; ++ glob_slang = NULL; ++ glob_seenrequest = NULL; ++ glob_seenrequests = glob_totalnicks = glob_totalbytes = 0; ++} +diff -Nur src/mod/gseen.mod/gseen.c src/mod/gseen.mod/gseen.c +--- src/mod/gseen.mod/gseen.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/gseen.c 2002-10-26 14:24:48.000000000 +0200 +@@ -0,0 +1,328 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++#define MAKING_GSEEN ++#define MODULE_NAME "gseen" ++#define MODULE_VERSION "1.1.1 dev3" ++#define MODULE_NUMVERSION 10100 ++#include "../module.h" ++#include "../irc.mod/irc.h" ++#include "../server.mod/server.h" ++#include "../channels.mod/channels.h" ++#include <stdlib.h> ++#include <sys/stat.h> ++#include <time.h> /* for time_t */ ++ ++#undef global ++static Function *global = NULL, *irc_funcs = NULL, *server_funcs = NULL, *channels_funcs = NULL; ++ ++#ifndef EGG_IS_MIN_VER ++#define EGG_IS_MIN_VER(ver) ((ver) <= 10400) ++#endif ++ ++#ifndef EGG_IS_MAX_VER ++#define EGG_IS_MAX_VER(ver) ((ver) >= 10400) ++#endif ++ ++#ifndef Context ++#define Context context ++#endif ++ ++#ifndef findchan_by_dname ++#define findchan_by_dname findchan ++#endif ++ ++#include "gseen.h" ++#include "seenlang.h" ++ ++static struct slang_header *coreslangs = NULL; ++static gseenres *results = NULL; ++static seenreq *requests = NULL; ++static ignoredword *ignoredwords = NULL; ++static char *bnsnick = NULL; ++static char *bnschan = NULL; ++static char *seen_reply = NULL; ++static char *temp_wildmatch_host; ++static int numresults = 0; ++static double glob_presearch, glob_aftersearch; ++int numseens, glob_total_queries; ++double glob_total_searchtime; ++ ++static char gseenfile[121] = "gseen.dat"; ++static char no_pub[121]; ++static char quiet_seen[121]; ++static char quiet_ai_seen[121]; ++static char no_log[121]; ++static char ignore_words[1024]; ++static char default_slang[21] = "eng"; ++static int gseen_numversion = MODULE_NUMVERSION; ++static int save_seens = 60; ++static int save_seens_temp = 1; ++static int expire_seens = 60; ++static int maxseen_thr = 0; ++static int maxseen_time = 0; ++static int seenflood_thr = 0; ++static time_t seenflood_time = 0; ++static int use_handles = 0; ++static int tell_seens = 1; ++static int botnet_seen = 1; ++int fuzzy_search = 1; // search for the same user under a differnt nick ++static int wildcard_search = 1;// allow wildcard seaching? ("*!*@*.isp.de") ++static int max_matches = 500; // break if there are more than X matches ++static int hide_secret_chans = 1; // #chan (+secret) => [secret] ++static int seen_nick_len = 32; ++ ++#include "global_vars.c" ++#define SLANG_NOTYPES 1 ++#define SLANG_NOFACTS 1 ++#define SLANG_NOGETALL 1 ++#define SLANG_NOVALIDATE 1 ++#include "slang.c" ++#include "slang_gseen_commands.c" ++#include "generic_binary_tree.c" ++#include "seentree.c" ++#include "datahandling.c" ++#include "sensors.c" ++#include "do_seen.c" ++#include "gseencmds.c" ++#include "ai.c" ++#include "misc.c" ++#include "tclcmds.c" ++ ++static int gseen_expmem() ++{ ++ int size = 0; ++ ++ size += seentree_expmem(); ++ size += expmem_seenresults(); ++ size += expmem_seenreq(); ++ size += expmem_ignoredwords(); ++ size += slang_expmem(coreslangs); ++ size += slang_glob_expmem(); ++ size += slang_chanlang_expmem(chanlangs); ++ if (bnsnick) ++ size += strlen(bnsnick) + 1; ++ if (bnschan) ++ size += strlen(bnschan) + 1; ++ if (seen_reply) { ++ size += strlen(seen_reply) + 1; ++ } ++ return size; ++} ++ ++static void free_gseen() ++{ ++ seentree_free(); ++ slang_free(coreslangs); ++ slang_chanlang_free(chanlangs); ++ if (seen_reply) ++ nfree(seen_reply); ++ return; ++} ++ ++/* a report on the module status */ ++static void gseen_report(int idx, int details) ++{ ++ int size = 0; ++ ++ Context; ++ if (details) { ++ size = gseen_expmem(); ++ dprintf(idx, " using %d bytes\n", size); ++ } ++} ++ ++static void gseen_minutely () ++{ ++ if (save_seens_temp >= save_seens) { ++ write_seens(); ++ save_seens_temp = 1; ++ } else ++ save_seens_temp++; ++} ++ ++static void gseen_daily () ++{ ++ Context; ++ purge_seens(); ++} ++ ++static tcl_strings my_tcl_strings[] = ++{ ++ {"gseenfile", gseenfile, 121, 0}, ++ {"ai-seen-ignore", ignore_words, 1024, 0}, ++ {"no-pub-seens", no_pub, 121, 0}, ++ {"quiet-seens", quiet_seen, 121, 0}, ++ {"quiet-ai-seens", quiet_ai_seen, 121, 0}, ++ {"no-log", no_log, 121, 0}, ++ {"no-seendata", no_log, 121, 0}, ++ {"default-slang", default_slang, 20, 0}, ++ {0, 0, 0, 0} ++}; ++ ++static tcl_ints my_tcl_ints[] = ++{ ++ {"save-seens", &save_seens, 0}, ++ {"expire-seens", &expire_seens, 0}, ++ {"use-handles", &use_handles, 0}, ++ {"tell-seens", &tell_seens, 0}, ++ {"botnet-seens", &botnet_seen, 0}, ++ {"max-matches", &max_matches, 0}, ++ {"fuzzy-search", &fuzzy_search, 0}, ++ {"wildcard-search", &wildcard_search, 0}, ++ {"hide-secret-chans", &hide_secret_chans, 0}, ++ {"seen-nick-len", &seen_nick_len, 0}, ++ {0, 0, 0} ++}; ++ ++static tcl_coups my_tcl_coups[] = ++{ ++ {"max-seens", &maxseen_thr, &maxseen_time}, ++ {0, 0, 0}, ++}; ++ ++static char *gseen_close() ++{ ++ Context; ++ write_seens(); ++ slang_glob_free(); ++ free_gseen(); ++ free_seenreq(); ++ free_seenresults(); ++ free_ignoredwords(); ++ if (bnsnick) ++ nfree(bnsnick); ++ if (bnschan) ++ nfree(bnschan); ++ rem_tcl_strings(my_tcl_strings); ++ rem_tcl_ints(my_tcl_ints); ++ rem_tcl_coups(my_tcl_coups); ++ rem_tcl_commands(mytcls); ++ rem_tcl_commands(gseentcls); ++ rem_tcl_commands(seendebugtcls); ++ rem_tcl_commands(gseentcls); ++ rem_builtins(H_dcc, mydcc); ++ rem_builtins(H_join, seen_join); ++ rem_builtins(H_kick, seen_kick); ++ rem_builtins(H_nick, seen_nick); ++ rem_builtins(H_part, seen_part); ++ rem_builtins(H_sign, seen_sign); ++ rem_builtins(H_splt, seen_splt); ++ rem_builtins(H_rejn, seen_rejn); ++ rem_builtins(H_pub, seen_pub); ++ rem_builtins(H_msg, seen_msg); ++ rem_builtins(H_bot, seen_bot); ++ del_hook(HOOK_MINUTELY, (Function) gseen_minutely); ++ del_hook(HOOK_DAILY, (Function) gseen_daily); ++ module_undepend(MODULE_NAME); ++ return NULL; ++} ++ ++char *gseen_start(); ++ ++static Function gseen_table[] = ++{ ++ (Function) gseen_start, ++ (Function) gseen_close, ++ (Function) gseen_expmem, ++ (Function) gseen_report, ++ /* 4 - 7 */ ++ (Function) findseens, ++ (Function) free_seenresults, ++ (Function) gseen_duration, ++ (Function) & glob_seendat, ++ (Function) & numresults, ++ (Function) & fuzzy_search, ++ (Function) & numseens, ++ (Function) & glob_total_queries, ++ (Function) & glob_total_searchtime, ++ (Function) & gseen_numversion, ++}; ++ ++char *gseen_start(Function * global_funcs) ++{ ++ global = global_funcs; ++ Context; ++ module_register(MODULE_NAME, gseen_table, 1, 1); ++ if (!(irc_funcs = module_depend(MODULE_NAME, "irc", 1, 0))) ++ return "You need the irc module to use the gseen module."; ++ if (!(server_funcs = module_depend(MODULE_NAME, "server", 1, 0))) ++ return "You need the server module to use the gseen module."; ++ if (!(channels_funcs = module_depend(MODULE_NAME, "channels", 1, 0))) ++ return "You need the channels module to use the gseen module."; ++ if (!module_depend(MODULE_NAME, "eggdrop", 107, 0)) { ++ if (!module_depend(MODULE_NAME, "eggdrop", 106, 0)) { ++ if (!module_depend(MODULE_NAME, "eggdrop", 105, 0)) { ++ if (!module_depend(MODULE_NAME, "eggdrop", 104, 0)) { ++ module_undepend(MODULE_NAME); ++ return "This module requires eggdrop1.4.0 or later"; ++ } ++ } ++ } ++ } ++ chanlangs = NULL; ++ coreslangs = NULL; ++ slang_glob_init(); ++ ++ results = NULL; ++ requests = NULL; ++ ignoredwords = NULL; ++ bnsnick = NULL; ++ bnschan = NULL; ++ seen_reply = NULL; ++ ++ numresults = 0; ++ numseens = 0; ++ glob_total_queries = 0; ++ glob_total_searchtime = 0.0; ++ ignore_words[0] = 0; ++ no_pub[0] = 0; ++ quiet_seen[0] = 0; ++ no_log[0] = 0; ++ seentree_init(); ++ add_tcl_strings(my_tcl_strings); ++ add_tcl_ints(my_tcl_ints); ++ add_tcl_coups(my_tcl_coups); ++ add_tcl_commands(mytcls); ++ add_tcl_commands(seendebugtcls); ++ add_tcl_commands(gseentcls); ++ add_builtins(H_dcc, mydcc); ++ add_builtins(H_join, seen_join); ++ add_builtins(H_kick, seen_kick); ++ add_builtins(H_nick, seen_nick); ++ add_builtins(H_part, seen_part); ++ add_builtins(H_sign, seen_sign); ++ add_builtins(H_sign, seen_sign); ++ add_builtins(H_splt, seen_splt); ++ add_builtins(H_rejn, seen_rejn); ++ add_builtins(H_pub, seen_pub); ++ add_builtins(H_msg, seen_msg); ++ add_builtins(H_bot, seen_bot); ++ read_seens(); ++ add_hook(HOOK_MINUTELY, (Function) gseen_minutely); ++ add_hook(HOOK_DAILY, (Function) gseen_daily); ++#if EGG_IS_MIN_VER(10503) ++ initudef(1, "noseendata", 1); ++ initudef(1, "quietseens", 1); ++ initudef(1, "quietaiseens", 1); ++ initudef(1, "nopubseens", 1); ++#endif ++ glob_slang_cmd_list = slang_commands_list_add(glob_slang_cmd_list, slang_text_gseen_command_table); ++ putlog(LOG_MISC, "*", "gseen.mod v%s loaded.", MODULE_VERSION); ++ return NULL; ++} +diff -Nur src/mod/gseen.mod/gseen.conf src/mod/gseen.mod/gseen.conf +--- src/mod/gseen.mod/gseen.conf 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/gseen.conf 2002-10-26 13:17:54.000000000 +0200 +@@ -0,0 +1,147 @@ ++ ++###### ++##### ++### General Settings ++##### ++###### ++ ++# the file where the seen data will be backuped. ++# WARNING: set this _before_ the module is loaded. ++set gseenfile "gseen.dat" ++ ++# now load the module ++loadmodule gseen ++ ++# load the English language file ++loadseenslang "en" "English" language/gseen.en.lang ++ ++# load the German language file ++loadseenslang "de" "Deutsch" language/gseen.de.lang ++ ++# set the default language to english... ++set default-slang "en" ++ ++# ... but let #xwp use the german langfile ++setchanseenlang #xwp "de" ++ ++# the char that marks public commands (!seen, etc...) ++# "" is a valid option ++set cmdchar "!" ++ ++# delete data sets that are older than x days ++set expire-seens 60 ++ ++# only answer x seen requests in y seconds to prevent flooding ++set max-seens 7:60 ++ ++# tell users if someone was !seen'ing for them ++set tell-seens 1 ++ ++# check if the user was online under a different nick ++set fuzzy-search 1 ++ ++# allow user to include wildcards in the search? ++set wildcard-search 1 ++ ++# break search if there are more than x matches ++set max-matches 250 ++ ++# forward a request to other bots, if a !seen returned no result? ++set botnet-seens 1 ++ ++# store channels, which are +secret on the bot as [secret]? ++set hide-secret-chans 1 ++ ++# backup the seen data every x minutes ++set save-seens 60 ++ ++###### ++##### ++### AI Settings ++##### ++###### ++ ++# this setting configures on which sentences your bot should ++# attempt to do an ai-seen. Each of them is a simple wildcard ++# mask. Set this to "" if you want to deactivate ai-seens or ++# create more precise masks if the bots reacts too often. ++set ai-seen-binds { ++ "${nick}*seen*" ++ "${botnet-nick}*seen*" ++ "${nick}*gesehen*" ++ "${botnet-nick}*gesehen*" ++} ++ ++# this is just the same as above, but if triggered it will ++# not do an ai-seen, but display its seen-stats. ++set ai-seenstats-binds { ++ "${nick}*seenstats*" ++ "${botnet-nick}*seenstats*" ++} ++ ++# when doing an AI seen, ignore the following words (otherwise ++# the bot might give weird answers like "<bot> nick, bot was last seen..." :) ++set ai-seen-ignore "$nick ${botnet-nick} seen" ++ ++###### ++##### ++### special stuff (can be ignored in most cases) ++##### ++###### ++ ++# if the user is known by the bot, log their handle instead of the nick ++# (not recommended, might cause confusion by the users) ++set use-handles 0 ++ ++###### ++##### ++### outdated settings (only important for eggdropv1.4 users) ++##### ++###### ++ ++# channels where you do not want your bot to reply to public queries ++set no-pub-seens "" ++ ++# channels where you want your bot to send replies via notice to the user and ++# not to the channel ++set quiet-seens "" ++ ++# same as quiet-seens but for AI seen ++set quiet-ai-seens "" ++ ++# channels where you do not want your bot to log seen data ++set no-seendata "" ++ ++ ++############################################################################### ++# end of configuration ++# just ignore everything below ^_^ ++############################################################################### ++ ++bind chjn - * *chjn:gseen ++bind chpt - * *chpt:gseen ++ ++catch "unbind pub - !seen *pub:!seen" ++catch "unbind pub - !seennick *pub:!seennick" ++catch "unbind pub - !seenstats *pub:!seenstats" ++bind pub - ${cmdchar}seen *pub:!seen ++bind pub - ${cmdchar}seennick *pub:!seennick ++bind pub - ${cmdchar}seenstats *pub:!seenstats ++ ++foreach bnd [binds pubm] { ++ if {([lindex $bnd 2] == "*pubm:seen") || ([lindex $bnd 2] == "*pub:!seenstats")} { ++ unbind [lindex $bnd 0] [lindex $bnd 1] [lindex $bnd 2] [lindex $bnd 4] ++ } ++} ++ ++if {${ai-seen-binds} != ""} { ++ foreach mask ${ai-seen-binds} { ++ bind pubm -|- "% [subst $mask]" *pubm:seen ++ } ++} ++ ++if {${ai-seenstats-binds} != ""} { ++ foreach mask ${ai-seenstats-binds} { ++ bind pubm -|- "% [subst $mask]" *pub:!seenstats ++ } ++} +diff -Nur src/mod/gseen.mod/language/gseen.de.lang src/mod/gseen.mod/language/gseen.de.lang +--- src/mod/gseen.mod/language/gseen.de.lang 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/language/gseen.de.lang 2002-10-26 13:18:12.000000000 +0200 +@@ -0,0 +1,131 @@ ++##################################################################### ++# ++# Deutsche Sprachdatei für GSeen.Mod v1.1.0 ++# ++# Der Text in dieser Datei kann nach belieben verändert werden. Du ++# kannst Tags hinzufügen oder entfernen, wie es Dir gefällt. Die Tags ++# müssen nicht in einer bestimmten Reihenfolge oder Anzahl vorkommen. ++# ++# Wenn Du mehr als eine Zeile pro ID angibst, dann wird bei der ++# Antwort per Zufall eine daraus ausgewählt. (das funktioniert nicht ++# bei den Zeiteinheiten) ++# ++# Falls Du denkst, daß hier noch ein paar wichtige Tags fehlen, dann ++# schick mir einfach eine email. Vielleicht füge ich sie dann in der ++# nächsten Version hinzu. ++# ++# Eine komplette Liste der Verfügbaren Tags befindet sich am Ende von ++# slang_gseen_commands.c (leider ohne Erklährungen) ++# ++##################################################################### ++ ++# ++## Zeiteinheiten ++# ++# jeweils in Singular und Plural ++# ++D 0 Jahr ++D 1 Jahre ++D 2 Woche ++D 3 Wochen ++D 4 Tag ++D 5 Tage ++D 6 Stunde ++D 7 Stunden ++D 8 Minute ++D 9 Minuten ++D 10 Sekunde ++D 11 Sekunden ++# falls ein üngültiger Zeitwert angegeben war, dann wird dieser Text ausgegeben: ++D 12 einiger Zeit ++ ++ ++# ++## Präfixe ++# ++# Dieses Fragment wird jeweils vor eine Antwort gesetzt. Dadurch ++# ist beispielsweise bei öffentlichen Anfragen ersichtlich, für ++# wen die Antwort ist. ++# Achtung: Die Nummer muss auf jeden Fall definiert werden. Sie muss ++# zwar keinen Text beinhalten, aber wenn sie nicht vorhanden ++# ist, dann gibt es eine Fehlermeldung ++ ++# für Antworten, die in den Channel geschrieben werden: ++10 <?nick/?>, ++# für Antworten, die per NOTICE an den User geschickt werden: ++11 ++# für Antworten auf Anfragen, die per "/msg <bot> seen" erfolgt sind: ++12 ++# und für Antworten auf der Partyline: ++13 ++ ++# ++## Fehlermeldungen ++# ++54 weißt Du was ein Parameter ist? ^_^ ++54 ich würde Dir ja gerne helfen, aber solange Du nicht sagst, nach wem Du suchst, kann ich nicht viel tun. ++54 meinst Du nicht, es wäre geschickter zu sagen, nach wem Du überhaupt suchst? ++54 42. ++55 sehe ich etwa wie ein Spiegel aus? ^_^ ++55 Spieglein, Spieglein an der Wand... ++55 leidest Du etwa unter multiplen Persönlichkeiten? *eg* ++56 also wenn Du <?query/?> jetzt hier nicht sehen kannst, dann brauchst Du sicherlich eine neue Brille ^_^ ++56 ich muss mir unbedingt mal die Tarnkappe von <?query/?> ausleihen. Scheint ja prima zu funktioneren. ++56 schau Dir bitte nochmal ganz genau an, wer grade alles im Channel ist. ++57 Tut mir leid, aber Wildcards ('?', oder '*') sind bei der Suche nicht erlaubt. ++58 Öhm... naja... etwas arg lang, dieser Nick... :) ++ ++# ++## Kein Ergebnis ++# ++65 Ich kann mich nicht daran erinnern, <?query/?> gesehen zu haben... ++65 <?query/?>? Hmm... ich bin mir nicht sicher... vielleicht... eventuell... nein, kenne ich nicht. ++65 der Name sagt mir nichts. Hast Du Dich vielleicht vertippt? ++66 Ich hab' <?query/?> seit <?laston/?> nicht mehr gesehen. ++67 Sorry, aber zu deiner Anfrage passt nichts in meiner Datenbank :( ++68 Autschi, das gab viel zu viele Ergebnisse. Bitte formuliere deine Suche etwas genauer. ++ ++73 <?query/?> ist grade unter dem Nick "<?othernick/?>" in diesem Channel zu finden. ++74 <?query/?> ist gerade in <?otherchan/?>. ++75 Deine Anfrage führte zu genau einem Ergebnis: ++76 Immerhin <?numresults/?> Treffer ergab deine Anfrage: ++77 Wow, auf deine Anfrage passen sogar <?numresults/?> Einträge in meiner Datenbank! Dies sind die 5 aktuellsten: ++ ++# ++## falls ein anderer Bot etwas gefunden hat: ++# ++85 <?remotebot/?> sagt: ++ ++# ++## die eigentliche Information ++# ++101 Ich habe <?snick/?> (<?shost/?>) zuletzt <?schan/?> vor <?swhen/?> betreten sehen (<?stime/?>). <?snick/?> ist noch immer da. ++121 Ich habe <?snick/?> (<?shost/?>) zuletzt <?schan/?> vor <?swhen/?> betreten sehen (<?stime/?>), aber <?snick/?> verschwand mysteriöserweise. ++102 Ich habe <?snick/?> (<?shost/?>) zuletzt <?schan/?> vor <?swhen/?> nach <?spent/?> verchatteter Zeit verlassen sehen (<?stime/?>) ++103 Ich habe <?snick/?> (<?shost/?>) zuletzt in <?schan/?> gesehen, als er/sie vor <?swhen/?> (<?stime/?>) nach <?spent/?> das IRC verließ ("<?smsg/?>"). ++104 Zuletzt habe ich <?snick/?> (<?shost/?>) vor <?swhen/?> in <?schan/?> gesehen, den Nick zu <?snick2/?> wechselnd. <?snick2/?> ist noch immer dort. ++124 <?snick/?> (<?shost/?>) was last seen changing his/her nick to <?snick2/?> on <?schan/?> <?swhen/?> ago (<?stime/?>), but <?snick2/?> mysteriously dematerialized. ++105 Zuletzt habe ich <?snick/?> (<?shost/?>) vor <?swhen/?> in <?schan/?> gesehen, den Nick von <?snick2/?> wechselnd. <?snick/?> ist noch immer dort. ++125 <?snick/?> (<?shost/?>) was last seen changing his/her nick from <?snick2/?> on <?schan/?> <?swhen/?> ago (<?stime/?>), but <?snick/?> mysteriously dematerialized. ++106 Zuletzt habe ich <?snick/?> (<?shost/?>) gesehen, als er vor <?swhen/?> (<?stime/?>) von <?punisher/?> aus <?schan/?> gejagt wurde. (<?kickreason/?>) ++107 <?snick/?> (<?shost/?>) habe ich zuletzt vor <?swhen/?> gesehen, als er/sie von <?schan/?> aus in einem Netsplit verschwand. ++108 <?snick/?> (<?shost/?>) habe ich zuletzt vor <?swhen/?> gesehen, als er/sie nach einem Netsplit in <?schan/?> zurück kam. <?snick/?> ist noch immer dort. ++128 <?snick/?> (<?shost/?>) habe ich zuletzt vor <?swhen/?> gesehen, als er/sie nach einem Netsplit in <?schan/?> zurück kam. Allerdings konnte <?snick/?> dem Gott der Netsplits nicht endgültig entkommen und ist wieder verschollen... ++109 <?snick/?> was last seen joining the botnet channel <?schan/?> on <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++129 <?snick/?> was last seen joining the partyline on <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++110 <?snick/?> was last seen leaving the botnet channel <?schan/?> from <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++130 <?snick/?> was last seen leaving the partyline from <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++140 <?snick/?> (<?shost/?>) was last seen on <?schan/?> <?swhen/?> ago (<?stime/?>). ++ ++# ++## Seen-Mitteilungen ++# ++170 <?rnick/?> (<?rhost/?>) scheint vor <?rwhen/?> (<?rtime/?>) in <?rchan/?> auf der Suche nach Dir gewesen zu sein. ++171 <?requests/?> Leute haben sich nach Dir erkundigt: ++172 Der/die letzte war <?rnick/?> (<?rhost/?>) in <?rchan/?> vor <?rwhen/?> (<?rtime/?>). ++ ++# ++## Statistiken ++# ++180 Momentan sind <?totalnicks/?> Nicks in meiner Datenbank. Gesamter Speicherverbrauch: <?totalbytes/?> Bytes ++180 In meiner Datenbank befinden sich <?totalnicks/?> Nicks und verbrauchen <?totalbytes/?> Bytes Speicher. +diff -Nur src/mod/gseen.mod/language/gseen.en.lang src/mod/gseen.mod/language/gseen.en.lang +--- src/mod/gseen.mod/language/gseen.en.lang 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/language/gseen.en.lang 2002-10-26 13:18:13.000000000 +0200 +@@ -0,0 +1,131 @@ ++##################################################################### ++# ++# Default English langfile for GSeen.Mod v1.1.0 ++# ++# Just edit the text below to fit your needs. You can add or remove ++# any tag just like you want, they do not need to appear in a special ++# order (or number). ++# ++# If you enter more than one line per ID, then a random one will be ++# chosen for each reply. (this does not work for the time strings) ++# ++# If you think you need more tags, just email me and maybe I'll add ++# them in the next release. ++# ++# A complete list of available Tags can be found at the end of the ++# file slang_gseen_commands.c (unfortunately, it does not contain any ++# descriptions for the tags) ++# ++##################################################################### ++ ++# ++## time string ++# ++# each time string in singular and plural ++# ++D 0 year ++D 1 years ++D 2 week ++D 3 weeks ++D 4 day ++D 5 days ++D 6 hour ++D 7 hours ++D 8 minute ++D 9 minutes ++D 10 second ++D 11 seconds ++# if an invalid time value was supplied, output the following string ++D 12 some time ++ ++# ++## Prefixes ++# ++# These are the prefixes of the replies. By default, there's only ++# a prefix for public requests (so you know for whom the answer is), ++# but you can also define prefixes for other requests. ++ ++# for replies in the channel: ++10 <?nick/?>, ++# for replies via notice: ++11 ++# for replies via PRIVMSG ++12 ++# for replies on the partyline ++13 ++ ++# ++## error messages ++# ++54 do you know what a parameter is? ++54 don't you think it would be more reasonable to say for whom you are searching? ++54 42. ++55 do I look like a mirror? ^_^ ++55 mirror mirror on the wall... ++55 do you have a split personality? *eg* ++56 if you can't see <?query/?> here right now, you probably need new glasses. ^_^ ++56 please look a bit closer at the memberlist of this channel. ++57 I'm sorry, but wildcards ('?' or '*') are not allowed in a search. ++58 Hum... don't you think this nick is a bit long? ^_^ ++58 you know that the length of nicks is limited, don't you? ++ ++# ++## no result ++# ++65 I don't remember seeing <?query/?>. ++65 <?query/?>? hmm... I'm trying to remember... maybe... I'm not sure... no. I don't remember <?query/?>. ++66 I haven't seen <?query/?> for <?laston/?>. ++67 I found no matches to your query. ++67 I'm sorry, but your search didn't return any results. ++68 Ouch, your search returned way too many matches. Please refine it. ++ ++# ++## victim is online ++# ++73 <?query/?> is <?othernick/?>, who is on this channel right now. ++74 <?query/?> is on <?otherchan/?> right now. ++ ++# ++## results found ++# ++75 I found one match to your query: ++76 I found <?numresults/?> matches to your query: ++77 I found <?numresults/?> matches to your query. These are the 5 most recent ones: ++ ++# ++## results found by another bot in the botnet ++# ++85 <?remotebot/?> says: ++ ++# ++## the core info ++# ++101 <?snick/?> (<?shost/?>) was last seen joining <?schan/?> <?swhen/?> ago (<?stime/?>). <?snick/?> is still there. ++121 <?snick/?> (<?shost/?>) was last seen joining <?schan/?> <?swhen/?> ago (<?stime/?>), but <?snick/?> mysteriously dematerialized. ++102 <?snick/?> (<?shost/?>) was last seen parting <?schan/?> <?swhen/?> ago (<?stime/?>), after spending <?spent/?> there. ++103 <?snick/?> (<?shost/?>) was last seen quitting <?schan/?> <?swhen/?> ago (<?stime/?>) stating "<?smsg/?>" after spending <?spent/?> there. ++104 <?snick/?> (<?shost/?>) was last seen changing his/her nick to <?snick2/?> on <?schan/?> <?swhen/?> ago (<?stime/?>). <?snick2/?> is still there. ++124 <?snick/?> (<?shost/?>) was last seen changing his/her nick to <?snick2/?> on <?schan/?> <?swhen/?> ago (<?stime/?>), but <?snick2/?> mysteriously dematerialized. ++105 <?snick/?> (<?shost/?>) was last seen changing his/her nick from <?snick2/?> on <?schan/?> <?swhen/?> ago (<?stime/?>). <?snick/?> is still there. ++125 <?snick/?> (<?shost/?>) was last seen changing his/her nick from <?snick2/?> on <?schan/?> <?swhen/?> ago (<?stime/?>), but <?snick/?> mysteriously dematerialized. ++106 <?snick/?> (<?shost/?>) was last seen being kicked from <?schan/?> by <?punisher/?> (<?kickreason/?>) <?swhen/?> ago (<?stime/?>), after spending <?spent/?> there. ++107 <?snick/?> (<?shost/?>) was last seen splitting from <?schan/?> <?swhen/?> ago (<?stime/?>), after spending <?spent/?> there. ++108 <?snick/?> (<?shost/?>) was last seen rejoining <?schan/?> from a netsplit <?swhen/?> ago (<?stime/?>) <?snick/?> is still there. ++128 <?snick/?> (<?shost/?>) was last seen rejoining <?schan/?> from a netsplit <?swhen/?> ago (<?stime/?>), but the god of netsplits didn't let him escape, so he's not here now. ++109 <?snick/?> was last seen joining the botnet channel <?schan/?> on <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++129 <?snick/?> was last seen joining the partyline on <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++110 <?snick/?> was last seen leaving the botnet channel <?schan/?> from <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++130 <?snick/?> was last seen leaving the partyline from <?bnbot/?> <?swhen/?> ago (<?stime/?>). ++140 <?snick/?> (<?shost/?>) was last seen on <?schan/?> <?swhen/?> ago (<?stime/?>). ++ ++# ++## seen notification ++# ++170 <?rnick/?> (<?rhost/?>) was looking for you on <?rchan/?> <?rwhen/?> ago (<?rtime/?>). ++171 There have been <?requests/?> users looking for you: ++172 The last one was <?rnick/?> (<?rhost/?>) on <?rchan/?> <?rwhen/?> ago (<?rtime/?>). ++ ++# ++## seen stats ++# ++180 I'm currently tracking <?totalnicks/?> nicks using <?totalbytes/?> bytes. +diff -Nur src/mod/gseen.mod/gseen.h src/mod/gseen.mod/gseen.h +--- src/mod/gseen.mod/gseen.h 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/gseen.h 2002-10-26 13:17:55.000000000 +0200 +@@ -0,0 +1,157 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++/* #define USE_MEMDEBUG 1 */ ++ ++#define SEEN_JOIN 1 ++#define SEEN_PART 2 ++#define SEEN_SIGN 3 ++#define SEEN_NICK 4 ++#define SEEN_NCKF 5 ++#define SEEN_KICK 6 ++#define SEEN_SPLT 7 ++#define SEEN_REJN 8 ++#define SEEN_CHPT 9 ++#define SEEN_CHJN 10 ++ ++typedef struct gseen_data { ++ int type; ++ char *nick; ++ char *host; ++ char *chan; ++ char *msg; ++ time_t when; ++ int spent; ++} seendat; ++ ++typedef struct gseen_result { ++ struct gseen_result *next; ++ seendat *seen; ++} gseenres; ++ ++typedef struct gseen_requests { ++ struct gseen_requests *next; ++ char *who; ++ char *host; ++ char *chan; ++ time_t when; ++} seenreq_by; ++ ++typedef struct gseen_request { ++ struct gseen_request *next; ++ char *nick; ++ struct gseen_requests *by; ++} seenreq; ++ ++typedef struct gseen_ignorewords { ++ struct gseen_ignorewords *next; ++ char *word; ++} ignoredword; ++ ++#ifdef MAKING_GSEEN ++static int gseen_expmem(); ++static void free_gseen(); ++static int get_spent(char *, char *); ++static void write_seens(); ++static void read_seens(); ++static char *do_seen(char *, char *, char *, char *, int); ++static void add_seenresult(seendat *); ++static int expmem_seenresults(); ++static void free_seenresults(); ++static void sortresults(); ++static char *do_seennick(seendat *); ++static int onchan(char *, char *); ++static char *handonchan(char *, char *); ++static struct chanset_t *onanychan(char *); ++static struct chanset_t *handonanychan(char *); ++static char *do_seenstats(); ++static void add_seenreq(char *, char *, char *, char *, time_t); ++static int expmem_seenreq(); ++static void free_seenreq(); ++static void sortrequests(seenreq *); ++static void report_seenreq(char *, char *); ++static int count_seenreq(seenreq_by *b); ++static int expmem_ignoredwords(); ++static void free_ignoredwords(); ++static void add_ignoredword(char *word); ++static int word_is_ignored(char *word); ++static void purge_seens(); ++static int seenflood(); ++static int secretchan(char *); ++static int nopub(char *); ++static int quietseen(char *); ++static int quietaiseens(char *); ++static int nolog(char *); ++static void start_seentime_calc(); ++static void end_seentime_calc(); ++#endif ++ ++ ++#ifdef MAKING_GSEEN ++ ++// tree stuff ++static void maskstricthost(const char *, char *); ++#endif ++ ++// interface for webseen ++#define WS_OK 0 ++#define WS_NORESULT 1 ++#define WS_NOPARAM 2 ++#define WS_NOWILDCARDS 3 ++#define WS_TOOLONGNICK 4 ++#define WS_TOOMANYMATCHES 5 ++#define WS_TOOLONGHOST 6 ++ ++#ifndef MAKING_GSEEN ++#define findseens ((gseenres *(*)(char *, int *, int))gseen_funcs[4]) ++#define free_seenresults ((void (*)())gseen_funcs[5]) ++#define gseen_duration ((char *(*)(int))gseen_funcs[6]) ++#define numresults (*(int *)(gseen_funcs[12])) ++#define fuzzy_search (*(int *)(gseen_funcs[13])) ++#define numseens (*(int *)(gseen_funcs[15])) ++#define glob_total_queries (*(int *)(gseen_funcs[16])) ++#define glob_total_searchtime (*(double *)(gseen_funcs[17])) ++#define gseen_numversion (*(int *)(gseen_funcs[19])) ++#else ++static gseenres *findseens(char *, int *, int); ++static char *gseen_duration(int); ++#endif ++ ++#ifdef MAKING_GSEEN ++ ++#ifdef malloc ++#undef malloc ++#endif ++#ifdef free ++#undef free ++#endif ++#ifdef realloc ++#undef realloc ++#endif ++ ++#ifdef USE_MEMDEBUG ++#define my_malloc nmalloc ++#define my_free nfree ++#define my_realloc nrealloc ++#else ++#define my_malloc malloc ++#define my_free free ++#define my_realloc realloc ++#endif ++ ++#endif +diff -Nur src/mod/gseen.mod/gseencmds.c src/mod/gseen.mod/gseencmds.c +--- src/mod/gseen.mod/gseencmds.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/gseencmds.c 2002-10-26 13:17:56.000000000 +0200 +@@ -0,0 +1,420 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++#define PREFIX_LENGTH 20 ++ ++static char reply_prefix[PREFIX_LENGTH + 1]; ++#define set_prefix(x) strncpy(reply_prefix, x, PREFIX_LENGTH); \ ++ reply_prefix[PREFIX_LENGTH] = 0; ++ ++static int seenflood() ++{ ++ if (!maxseen_thr || !maxseen_time) ++ return 0; ++ if ((now - seenflood_time) > maxseen_time) { ++ seenflood_time = now; ++ seenflood_thr = 0; ++ } ++ seenflood_thr++; ++ if (seenflood_thr > maxseen_thr) ++ return 1; ++ else ++ return 0; ++} ++ ++static int nopub(char *chan) ++{ ++ char buf[121], *b; ++ ++ Context; ++ strncpy(buf, no_pub, 120); ++ buf[120] = 0; ++ b = buf; ++ while (b[0]) ++ if (!strcasecmp(chan, newsplit(&b))) ++ return 1; ++#if EGG_IS_MIN_VER(10503) ++ if (ngetudef("nopubseens", chan)) ++ return 1; ++#endif ++ return 0; ++} ++ ++static int quietseen(char *chan) ++{ ++ char buf[121], *b; ++ ++ Context; ++ strncpy(buf, quiet_seen, 120); ++ buf[120] = 0; ++ b = buf; ++ while (b[0]) ++ if (!strcasecmp(chan, newsplit(&b))) ++ return 1; ++#if EGG_IS_MIN_VER(10503) ++ if (ngetudef("quietseens", chan)) ++ return 1; ++#endif ++ return 0; ++} ++ ++static int cmd_seen(struct userrec *u, int idx, char *par) ++{ ++ char *query; ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, default_slang); ++ glob_nick = dcc[idx].nick; ++ query = newsplit(&par); ++ glob_query = query; ++ set_prefix(SLDCCPREFIX); ++ putlog(LOG_CMDS, "*", "#%s# seen %s", dcc[idx].nick, par); ++ dprintf(idx, "%s%s\n", reply_prefix, do_seen(query, dcc[idx].nick, ++ dcc[idx].host, "[partyline]", botnet_seen)); ++ return 0; ++} ++ ++static int cmd_seenstats(struct userrec *u, int idx, char *par) ++{ ++ Context; ++ if (seenflood()) ++ return 0; ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, default_slang); ++ glob_nick = dcc[idx].nick; ++ set_prefix(SLDCCPREFIX); ++ putlog(LOG_CMDS, "*", "#%s# seenstats", dcc[idx].nick); ++ dprintf(idx, "%s%s\n", reply_prefix, do_seenstats()); ++ return 0; ++} ++ ++static int cmd_purgeseens(struct userrec *u, int idx, char *par) ++{ ++ Context; ++ purge_seens(); ++ putlog(LOG_CMDS, "*", "#%s# purgeseens", dcc[idx].nick); ++ return 0; ++} ++ ++static int pub_seen(char *nick, char *host, char *hand, ++ char *channel, char *text) ++{ ++ char *dest; ++#if EGG_IS_MIN_VER(10500) ++ struct chanset_t *chan; ++#endif ++ ++ Context; ++ if (seenflood() || nopub(channel)) ++ return 0; ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, channel)); ++ glob_nick = nick; ++ putlog(LOG_CMDS, "*", "<<%s>> !%s! seen %s", nick, hand, text); ++ if (quietseen(channel)) { ++ set_prefix(SLNOTPREFIX); ++ dprintf(DP_HELP, "NOTICE %s :%s%s\n", nick, reply_prefix, ++ do_seen(newsplit(&text), nick, host, channel, botnet_seen)); ++ return 0; ++ } ++#if EGG_IS_MIN_VER(10500) ++ chan = findchan_by_dname(channel); ++ if (chan) ++ dest = chan->name; ++ else ++ dest = channel; ++#else ++ dest = channel; ++#endif ++ set_prefix(SLPUBPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", dest, reply_prefix, ++ do_seen(newsplit(&text), nick, host, channel, botnet_seen)); ++ return 0; ++} ++ ++static int pub_seenstats(char *nick, char *host, char *hand, ++ char *channel, char *text) ++{ ++ char *dest; ++#if EGG_IS_MIN_VER(10500) ++ struct chanset_t *chan; ++#endif ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ if (nopub(channel)) ++ return 0; ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, channel)); ++ glob_nick = nick; ++ putlog(LOG_CMDS, "*", "<<%s>> !%s! seenstats", nick, hand); ++ if (quietseen(channel)) { ++ set_prefix(SLNOTPREFIX); ++ dprintf(DP_HELP, "NOTICE %s :%s%s\n", nick, reply_prefix, do_seenstats()); ++ return 0; ++ } ++#if EGG_IS_MIN_VER(10500) ++ chan = findchan_by_dname(channel); ++ if (chan) ++ dest = chan->name; ++ else ++ dest = channel; ++#else ++ dest = channel; ++#endif ++ set_prefix(SLPUBPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", dest, reply_prefix, do_seenstats()); ++ return 1; ++} ++ ++static int msg_seen(char *nick, char *uhost, struct userrec *u, char *text) ++{ ++ Context; ++ if (seenflood()) ++ return 0; ++ reset_global_vars(); ++ glob_slang = slang_getbynick(coreslangs, nick); ++ glob_nick = nick; ++ putlog(LOG_CMDS, "*", "(%s!%s) !%s! seen %s", nick, uhost, u ? u->handle : "*", text); ++ set_prefix(SLMSGPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", nick, reply_prefix, ++ do_seen(newsplit(&text), nick, uhost, "[/msg]", botnet_seen)); ++ return 1; ++} ++ ++static int pub_seennick(char *nick, char *host, char *hand, ++ char *channel, char *text) ++{ ++ seendat *l; ++ char *dest; ++#if EGG_IS_MIN_VER(10500) ++ struct chanset_t *chan; ++#endif ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ if (nopub(channel)) ++ return 0; ++ putlog(LOG_CMDS, "*", "<<%s>> !%s! seennick %s", nick, hand, text); ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, channel)); ++ glob_nick = nick; ++#if EGG_IS_MIN_VER(10500) ++ chan = findchan_by_dname(channel); ++ if (chan) ++ dest = chan->name; ++ else ++ dest = channel; ++#else ++ dest = channel; ++#endif ++ text = newsplit(&text); ++ l = findseen(text); ++ if (!l) { ++ glob_query = text; ++ if (quietseen(channel)) { ++ set_prefix(SLNOTPREFIX); ++ dprintf(DP_HELP, "NOTICE %s :%s%s\n", nick, reply_prefix, SLNOTSEEN); ++ } else { ++ set_prefix(SLPUBPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", dest, reply_prefix, SLNOTSEEN); ++ } ++ return 0; ++ } ++ if (quietseen(channel)) { ++ set_prefix(SLNOTPREFIX); ++ dprintf(DP_HELP, "NOTICE %s :%s%s\n", nick, reply_prefix, do_seennick(l)); ++ } else { ++ set_prefix(SLPUBPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", dest, reply_prefix, do_seennick(l)); ++ } ++ return 0; ++} ++ ++static int msg_seennick(char *nick, char *uhost, struct userrec *u, char *text) ++{ ++ seendat *l; ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ putlog(LOG_CMDS, "*", "(%s!%s) !%s! seennick %s", nick, uhost, u ? u->handle : "*", text); ++ reset_global_vars(); ++ glob_slang = slang_getbynick(coreslangs, nick); ++ glob_nick = nick; ++ set_prefix(SLMSGPREFIX); ++ text = newsplit(&text); ++ l = findseen(text); ++ if (!l) { ++ glob_query = text; ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", nick, reply_prefix, SLNOTSEEN); ++ return 0; ++ } ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s\n", nick, reply_prefix, do_seennick(l)); ++ return 0; ++} ++ ++static int cmd_seennick(struct userrec *u, int idx, char *text) ++{ ++ seendat *l; ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ putlog(LOG_CMDS, "*", "#%s# seennick %s", dcc[idx].nick, text); ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, default_slang); ++ glob_nick = dcc[idx].nick; ++ set_prefix(SLMSGPREFIX); ++ text = newsplit(&text); ++ l = findseen(text); ++ if (!l) { ++ glob_query = text; ++ dprintf(idx, "%s%s\n", reply_prefix, SLNOTSEEN); ++ return 0; ++ } ++ dprintf(idx, "%s%s\n", reply_prefix, do_seennick(l)); ++ return 0; ++} ++ ++static int bot_gseen_req(char *bot, char *code, char *par) ++{ ++ char *mask, *nick, *uhost, *chan, *reply; ++ char tosend[256]; ++ int i; ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ i = nextbot(bot); ++ if (i < 0) { ++ debug1("Couldn't answer botnet-seen-request from %s: no such bot", bot); ++ return 0; ++ } ++ mask = newsplit(&par); ++ nick = newsplit(&par); ++ uhost = newsplit(&par); ++ chan = newsplit(&par); ++ reset_global_vars(); ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, chan)); ++ glob_nick = nick; ++ reply = do_seen(mask, nick, uhost, chan, -1); ++ if (!reply) ++ return 0; ++ if ((strlen(nick) + strlen(chan) + strlen(reply)) < 255) { ++ sprintf(tosend, "gseen_rep %s %s %s", nick, chan, reply); ++ botnet_send_zapf(i, botnetnick, bot, tosend); ++ } ++ return 0; ++} ++ ++static int bot_gseen_rep(char *bot, char *code, char *par) ++{ ++ char *nick, *chan, *reply; ++ int i; ++ ++ Context; ++ if (seenflood()) ++ return 0; ++ if (!bnsnick || !bnschan) { ++ if (bnsnick) ++ nfree(bnsnick); ++ if (bnschan) ++ nfree(bnschan); ++ bnsnick = bnschan = NULL; ++ return 0; ++ } ++ nick = newsplit(&par); ++ chan = newsplit(&par); ++ reset_global_vars(); ++ glob_remotebot = bot; ++ glob_slang = slang_find(coreslangs, slang_chanlang_get(chanlangs, chan)); ++ glob_nick = nick; ++ reply = par; ++ if (strcmp(nick, bnsnick) || strcmp(chan, bnschan)) ++ return 0; /* unwanted reply */ ++ if (findchan(chan)) { ++ if (nopub(chan)) { ++ nfree(bnsnick); ++ nfree(bnschan); ++ bnsnick = bnschan = NULL; ++ debug1("%s is nopub, bns-reply dropped", chan); ++ return 0; ++ } ++ if (quietseen(chan)) { ++ set_prefix(SLNOTPREFIX); ++ dprintf(DP_HELP, "NOTICE %s :%s%s%s\n", nick, reply_prefix, SLRBOTSAYS, reply); ++ } else { ++ set_prefix(SLPUBPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s%s\n", chan, reply_prefix, SLRBOTSAYS, reply); ++ } ++ } else if (!strcmp(chan, "[/msg]")) { ++ set_prefix(SLMSGPREFIX); ++ dprintf(DP_HELP, "PRIVMSG %s :%s%s%s\n", nick, reply_prefix, SLRBOTSAYS, reply); ++ } else if (!strcmp(chan, "[partyline]")) { ++ for (i = 0; i < dcc_total; i++) { ++ if ((!strcasecmp(nick, dcc[i].nick)) && ++ (dcc[i].type->flags & DCT_SIMUL)) { ++ set_prefix(SLDCCPREFIX); ++ dprintf(i, "%s%s%s\n", reply_prefix, SLRBOTSAYS, reply); ++ break; ++ } ++ } ++ } else ++ debug1("Couldn't send received bns answer, no such chan %s", chan); ++ nfree(bnsnick); ++ nfree(bnschan); ++ bnsnick = bnschan = NULL; ++ return 0; ++} ++ ++static cmd_t mydcc[] = ++{ ++ {"seen", "-|-", cmd_seen, NULL}, ++ {"seenstats", "-|-", cmd_seenstats, NULL}, ++ {"purgeseens", "m", cmd_purgeseens, NULL}, ++ {"seennick", "-|-", cmd_seennick, NULL}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_pub[] = ++{ ++ {"!seen", "", pub_seen, 0}, ++ {"!seenstats", "", pub_seenstats, 0}, ++ {"!seennick", "", pub_seennick, 0}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_msg[] = ++{ ++ {"seen", "", msg_seen, 0}, ++ {"seennick", "", msg_seennick, 0}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_bot[] = ++{ ++ {"gseen_req", "", bot_gseen_req, 0}, ++ {"gseen_rep", "", bot_gseen_rep, 0}, ++ {0, 0, 0, 0} ++}; +diff -Nur src/mod/gseen.mod/misc.c src/mod/gseen.mod/misc.c +--- src/mod/gseen.mod/misc.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/misc.c 2002-10-26 13:17:57.000000000 +0200 +@@ -0,0 +1,116 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++/* maskstricthost(): ++ * basically the same as maskhost() from src/misc.c, but _never_ stripts ++ * "~+-^=" off the host ++ * maskhost() version: * $Id: misc.c,v 1.30 2000/10/27 19:27:32 fabian Exp $ ++ */ ++static void maskstricthost(const char *s, char *nw) ++{ ++ register const char *p, *q, *e, *f; ++ int i; ++ ++ *nw++ = '*'; ++ *nw++ = '!'; ++ p = (q = strchr(s, '!')) ? q + 1 : s; ++ /* Strip of any nick, if a username is found, use last 8 chars */ ++ if ((q = strchr(p, '@'))) { ++ int fl = 0; ++ ++ if ((q - p) > 9) { ++ nw[0] = '*'; ++ p = q - 7; ++ i = 1; ++ } else ++ i = 0; ++ while (*p != '@') { ++ if (!fl && strchr("~+-^=", *p)) { ++// if (strict_host) ++ nw[i] = '?'; ++// else ++// i--; ++ } else ++ nw[i] = *p; ++ fl++; ++ p++; ++ i++; ++ } ++ nw[i++] = '@'; ++ q++; ++ } else { ++ nw[0] = '*'; ++ nw[1] = '@'; ++ i = 2; ++ q = s; ++ } ++ nw += i; ++ e = NULL; ++ /* Now q points to the hostname, i point to where to put the mask */ ++ if ((!(p = strchr(q, '.')) || !(e = strchr(p + 1, '.'))) && !strchr(q, ':')) ++ /* TLD or 2 part host */ ++ strcpy(nw, q); ++ else { ++ if (e == NULL) { /* IPv6 address? */ ++ const char *mask_str; ++ ++ f = strrchr(q, ':'); ++ if (strchr(f, '.')) { /* IPv4 wrapped in an IPv6? */ ++ f = strrchr(f, '.'); ++ mask_str = ".*"; ++ } else /* ... no, true IPv6. */ ++ mask_str = ":*"; ++ strncpy(nw, q, f - q); ++ /* No need to nw[f-q] = 0 here, as the strcpy below will ++ * terminate the string for us. ++ */ ++ nw += (f - q); ++ strcpy(nw, mask_str); ++ } else { ++ for (f = e; *f; f++); ++ f--; ++ if (*f >= '0' && *f <= '9') { /* Numeric IP address */ ++ while (*f != '.') ++ f--; ++ strncpy(nw, q, f - q); ++ /* No need to nw[f-q] = 0 here, as the strcpy below will ++ * terminate the string for us. ++ */ ++ nw += (f - q); ++ strcpy(nw, ".*"); ++ } else { /* Normal host >= 3 parts */ ++ /* a.b.c -> *.b.c ++ * a.b.c.d -> *.b.c.d if tld is a country (2 chars) ++ * OR *.c.d if tld is com/edu/etc (3 chars) ++ * a.b.c.d.e -> *.c.d.e etc ++ */ ++ const char *x = strchr(e + 1, '.'); ++ ++ if (!x) ++ x = p; ++ else if (strchr(x + 1, '.')) ++ x = e; ++ else if (strlen(x) == 3) ++ x = p; ++ else ++ x = e; ++ sprintf(nw, "*%s", x); ++ } ++ } ++ } ++} +diff -Nur src/mod/gseen.mod/seenlang.h src/mod/gseen.mod/seenlang.h +--- src/mod/gseen.mod/seenlang.h 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/seenlang.h 2002-10-26 13:17:58.000000000 +0200 +@@ -0,0 +1,61 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++#define SLPUBPREFIX getslang(10) ++#define SLNOTPREFIX getslang(11) ++#define SLMSGPREFIX getslang(12) ++#define SLDCCPREFIX getslang(13) ++ ++#define SLNOPARAM getslang(54) ++#define SLMIRROR getslang(55) ++#define SLONCHAN getslang(56) ++#define SLNOWILDCARDS getslang(57) ++#define SLTOOLONGNICK getslang(58) ++ ++#define SLNOTSEEN getslang(65) ++#define SLPOORSEEN getslang(66) ++#define SLNOMATCH getslang(67) ++#define SLTOOMANYMATCHES getslang(68) ++ ++#define SLHANDONCHAN getslang(73) ++#define SLONOTHERCHAN getslang(74) ++#define SLONEMATCH getslang(75) ++#define SLLITTLEMATCHES getslang(76) ++#define SLMANYMATCHES getslang(77) ++ ++#define SLRBOTSAYS getslang(85) ++ ++#define SLYEAR getdur(0) ++#define SLYEARS getdur(1) ++#define SLWEEK getdur(2) ++#define SLWEEKS getdur(3) ++#define SLDAY getdur(4) ++#define SLDAYS getdur(5) ++#define SLHOUR getdur(6) ++#define SLHOURS getdur(7) ++#define SLMINUTE getdur(8) ++#define SLMINUTES getdur(9) ++#define SLSECOND getdur(10) ++#define SLSECONDS getdur(11) ++#define SLSOMETIME getdur(12) ++ ++#define SLONELOOK getslang(170) ++#define SLMORELOOKS getslang(171) ++#define SLLASTLOOK getslang(172) ++ ++#define SLSEENSTATS getslang(180) +diff -Nur src/mod/gseen.mod/seentree.c src/mod/gseen.mod/seentree.c +--- src/mod/gseen.mod/seentree.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/seentree.c 2002-10-26 13:18:10.000000000 +0200 +@@ -0,0 +1,213 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++static struct generic_binary_tree seentree; ++ ++static void seentree_init(); ++static int seentree_expmem(); ++static void seentree_free(); ++static int compareseens(void *, void *); ++static int expmemseen(void *); ++static void add_seen(int, char *, char *, char *, char *, ++ time_t, int); ++static void freeseen(void *); ++static seendat *findseen(char *); ++static void wildmatch_seens(char *, char *, int); ++static void process_wildmatch_seens(void *); ++static void write_seen_tree(void *); ++static void purge_seen_tree(void *); ++static int count_seens(); ++static void _count_seens(void *); ++ ++ ++static void seentree_init() ++{ ++ seentree.root = NULL; ++ seentree.comparedata = compareseens; ++ seentree.expmemdata = expmemseen; ++ seentree.freedata = freeseen; ++} ++ ++static int seentree_expmem() ++{ ++ return btree_expmem(&seentree); ++} ++ ++static void seentree_free() ++{ ++ btree_freetree(&seentree); ++ seentree.root = NULL; ++} ++ ++static int compareseens(void *first, void *second) ++{ ++ return rfc_casecmp(((seendat *) first)->nick, ((seendat *) second)->nick); ++} ++ ++// add another entry to the tree ++static void add_seen(int type, char *nick, char *host, char *chan, char *msg, ++ time_t when, int spent) ++{ ++ seendat *newseen; ++ ++ newseen = nmalloc(sizeof(seendat)); ++ newseen->type = type; ++ newseen->nick = nmalloc(strlen(nick) + 1); ++ strcpy(newseen->nick, nick); ++ newseen->host = nmalloc(strlen(host) + 1); ++ strcpy(newseen->host, host); ++ newseen->chan = nmalloc(strlen(chan) + 1); ++ strcpy(newseen->chan, chan); ++ newseen->msg = nmalloc(strlen(msg) + 1); ++ strcpy(newseen->msg, msg); ++ newseen->when = when; ++ newseen->spent = spent; ++ btree_add(&seentree, newseen); ++} ++ ++static void freeseen(void *what) ++{ ++ seendat *s = (seendat *) what; ++ ++ Assert(s); ++ Assert(s->nick); ++ Assert(s->host); ++ Assert(s->chan); ++ Assert(s->msg); ++ ++ nfree(s->nick); ++ nfree(s->host); ++ nfree(s->chan); ++ nfree(s->msg); ++ nfree(s); ++} ++ ++static int expmemseen(void *what) ++{ ++ int size = 0; ++ seendat *d = (seendat *) what; ++ ++ size += sizeof(seendat); ++ size += strlen(d->nick) + 1; ++ size += strlen(d->host) + 1; ++ size += strlen(d->chan) + 1; ++ size += strlen(d->msg) + 1; ++ return size; ++} ++ ++// finds a seen entry in the tree ++seendat findseen_temp; ++static seendat *findseen(char *nick) ++{ ++ findseen_temp.nick = nick; ++ return btree_get(&seentree, &findseen_temp); ++} ++ ++// function to find all nicks that match a host ++// (calls btree_getall() which calls a target function for each item) ++// host: user's hostmask (used if search query doesn't contain any wildcards) ++// mask: search mask ++// wild: defines if we want to use the mask, or host for the search ++static char *wildmatch_host, *wildmatch_mask; ++int wildmatch_wild; ++static void wildmatch_seens(char *host, char *mask, int wild) ++{ ++ wildmatch_host = host; ++ wildmatch_mask = mask; ++ wildmatch_wild = wild; ++ btree_getall(&seentree, process_wildmatch_seens); ++} ++ ++/* process_wildmatch_seens(): ++ * gets called from the binary tree for each existing item. ++ */ ++static void process_wildmatch_seens(void *data) ++{ ++ seendat *s = (seendat *) data; ++ ++ if ((numresults > max_matches) && (max_matches > 0)) // Don't return too many ++ return; // matches... ++ if (!wildmatch_wild) { ++ if (wild_match(wildmatch_host, s->host)) ++ add_seenresult(s); ++ } else { ++ temp_wildmatch_host = my_realloc(temp_wildmatch_host, strlen(s->nick) + 1 + strlen(s->host) + 1); ++ strcpy(temp_wildmatch_host, s->nick); ++ strcat(temp_wildmatch_host, "!"); ++ strcat(temp_wildmatch_host, s->host); ++ if (wild_match(wildmatch_mask, s->nick) || wild_match(wildmatch_mask, temp_wildmatch_host)) ++ add_seenresult(s); ++ } ++} ++ ++// write seendata in the datafile ++FILE *write_seen_tree_target; ++static void write_seen_tree(void *data) ++{ ++ seendat *node = (seendat *) data; ++ ++ /* format: "! nick host chan type when spent msg" */ ++ fprintf(write_seen_tree_target, "! %s %s %s %d %lu %d %s\n", node->nick, ++ node->host, node->chan, node->type, node->when, node->spent, ++ node->msg); ++} ++ ++// recursive function to remove old data ++// QUESTION: What happens if one of the nodes get moved by killseen()? ++// Possible bug/crash? ++// I think it should not be a problem. When killseen() is called the ++// first time, recursion already reached its end and no pointers ++// are accessed anymore. But I'm not sure... maybe I'm wrong. ++static void purge_seen_tree(void *data) ++{ ++ seendat *node = (seendat *) data; ++ ++ if ((now - node->when) > (expire_seens * 86400)) { ++ debug1("seen data for %s has expired.", node->nick); ++ btree_remove(&seentree, node); ++ } ++} ++ ++// counts the number of nicks in the database ++static int count_seens_temp; ++static int count_seens() ++{ ++ count_seens_temp = 0; ++ btree_getall(&seentree, _count_seens); ++ return count_seens_temp; ++} ++ ++static void _count_seens(void *node) ++{ ++ count_seens_temp++; ++} ++ ++static int tcl_killseen STDVAR ++{ ++ Context; ++ BADARGS(2, 2, " nick"); ++ findseen_temp.nick = argv[1]; ++ btree_remove(&seentree, &findseen_temp); ++ return TCL_OK; ++} ++ ++static tcl_cmds seendebugtcls[] = ++{ ++ {"killseen", tcl_killseen}, ++ {0, 0} ++}; +diff -Nur src/mod/gseen.mod/sensors.c src/mod/gseen.mod/sensors.c +--- src/mod/gseen.mod/sensors.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/sensors.c 2002-10-26 13:18:00.000000000 +0200 +@@ -0,0 +1,273 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++static int get_spent(char *nick, char *chan) ++{ ++ struct chanset_t *ch = NULL; ++ memberlist *m = NULL; ++ ++ int spent; ++ ch = findchan_by_dname(chan); ++ if (ch) ++ m = ismember(ch, nick); ++ if (m && m->joined) ++ spent = now - m->joined; ++ else ++ spent = -1; ++ return spent; ++} ++ ++static int secretchan(char *chan) ++{ ++ struct chanset_t *ch; ++ ++ ch = findchan_by_dname(chan); ++ if (!ch) ++ return 0; ++ if (ch->status & CHAN_SECRET) ++ return 1; ++ return 0; ++} ++ ++static int nolog(char *chan) ++{ ++ char buf[121], *b; ++ ++ Context; ++ strncpy(buf, no_log, 120); ++ buf[120] = 0; ++ b = buf; ++ while (b[0]) ++ if (!strcasecmp(chan, newsplit(&b))) ++ return 1; ++#if EGG_IS_MIN_VER(10503) ++ if (ngetudef("noseendata", chan)) ++ return 1; ++#endif ++ return 0; ++} ++ ++static int gseen_join(char *nick, char *uhost, char *hand, char *chan) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_JOIN, nick, uhost, chan, "", now, get_spent(nick, chan)); ++ report_seenreq(chan, nick); ++ if ((hand[0] == '*') && strcasecmp(nick, hand)) ++ report_seenreq(chan, hand); ++ return 0; ++} ++ ++static int gseen_kick(char *nick, char *uhost, char *hand, char *chan, ++ char *victim, char *reason) ++{ ++ struct chanset_t *ch = NULL; ++ memberlist *m = NULL; ++ char msg[1024], *s; ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ ch = findchan_by_dname(chan); ++ if (!ch) { ++ debug2("Unable to seen %s getting kicked from %s", victim, chan); ++ return 0; ++ } ++ if (secretchan(chan)) ++ chan = buf; ++ s = msg; ++ s[0] = 0; ++ m = ismember(ch, victim); ++ if (!m) { ++ debug2("Unable to seen %s getting kicked from %s", victim, chan); ++ return 0; ++ } ++ if ((strlen(nick) + strlen(reason) + 2) < 1024) ++ sprintf(s, "%s %s", nick, reason); ++ add_seen(SEEN_KICK, victim, m->userhost, chan, s, now, ++ get_spent(victim, chan)); ++ return 0; ++} ++ ++static int gseen_nick(char *nick, char *uhost, char *hand, char *chan, ++ char *newnick) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_NICK, nick, uhost, chan, newnick, now, get_spent(nick, chan)); ++ if (!(use_handles && (hand[0] != '*'))) ++ add_seen(SEEN_NCKF, newnick, uhost, chan, nick, now, get_spent(nick, chan)); ++ report_seenreq(chan, newnick); ++ if ((hand[0] != '*') && strcasecmp(newnick, hand)) ++ report_seenreq(chan, hand); ++ return 0; ++} ++ ++#if EGG_IS_MIN_VER(10502) ++static int gseen_part(char *nick, char *uhost, char *hand, char *chan, ++ char *reason) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_PART, nick, uhost, chan, reason, now, get_spent(nick, chan)); ++ return 0; ++} ++#else ++static int gseen_part(char *nick, char *uhost, char *hand, char *chan) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_PART, nick, uhost, chan, "", now, get_spent(nick, chan)); ++ return 0; ++} ++#endif ++ ++static int gseen_sign(char *nick, char *uhost, char *hand, char *chan, ++ char *reason) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_SIGN, nick, uhost, chan, reason, now, get_spent(nick, chan)); ++ return 0; ++} ++ ++static int gseen_splt(char *nick, char *uhost, char *hand, char *chan) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_SPLT, nick, uhost, chan, "", now, get_spent(nick, chan)); ++ return 0; ++} ++ ++static int gseen_rejn(char *nick, char *uhost, char *hand, char *chan) ++{ ++ char buf[10] = "[secret]"; ++ ++ Context; ++ if (nolog(chan)) ++ return 0; ++ if (use_handles && (hand[0] != '*')) ++ nick = hand; ++ if (secretchan(chan)) ++ chan = buf; ++ add_seen(SEEN_REJN, nick, uhost, chan, "", now, get_spent(nick, chan)); ++ return 0; ++} ++ ++static int gseen_chjn STDVAR ++{ ++ Context; ++ BADARGS(7, 7, " bot hand chan flag idx host"); ++ add_seen(SEEN_CHJN, argv[2], argv[6], argv[3], argv[1], now, -1); ++ return 0; ++} ++ ++static int gseen_chpt STDVAR ++{ ++ Context; ++ BADARGS(5, 5, " bot hand idx chan"); ++ add_seen(SEEN_CHPT, argv[2], "unknown", argv[4], argv[1], now, -1); ++ return 0; ++} ++ ++static cmd_t seen_kick[] = ++{ ++ {"*", "", (Function) gseen_kick, "gseen"}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_nick[] = ++{ ++ {"*", "", (Function) gseen_nick, "gseen"}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_join[] = ++{ ++ {"*", "", (Function) gseen_join, "gseen"}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_part[] = ++{ ++ {"*", "", (Function) gseen_part, "gseen"}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_sign[] = ++{ ++ {"*", "", (Function) gseen_sign, "gseen"}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_splt[] = ++{ ++ {"*", "", (Function) gseen_splt, "gseen"}, ++ {0, 0, 0, 0} ++}; ++ ++static cmd_t seen_rejn[] = ++{ ++ {"*", "", (Function) gseen_rejn, "gseen"}, ++ {0, 0, 0, 0} ++}; +diff -Nur src/mod/gseen.mod/slang.c src/mod/gseen.mod/slang.c +--- src/mod/gseen.mod/slang.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang.c 2002-10-26 13:18:03.000000000 +0200 +@@ -0,0 +1,309 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++static struct slang_header *slang_find(struct slang_header *, char *); ++ ++#include "slang_text.c" ++#include "slang_multitext.c" ++#include "slang_ids.c" ++#ifndef SLANG_NOTYPES ++#include "slang_types.c" ++#endif ++#include "slang_duration.c" ++#ifndef SLANG_NOFACTS ++#include "slang_facts_places.c" ++#include "slang_facts.c" ++#endif ++#include "slang_chanlang.c" ++ ++ ++struct slang_header { ++ struct slang_header *next; ++ char *lang; ++ char *desc; ++ struct slang_id *ids; ++#ifndef SLANG_NOTYPES ++ struct slang_type *types; ++#endif ++ struct slang_duration *durations; ++}; ++ ++static void slang_glob_init() ++{ ++ glob_slang_cmd_list = NULL; ++} ++ ++static int slang_glob_expmem() ++{ ++ return slang_commands_list_expmem(glob_slang_cmd_list); ++} ++ ++static void slang_glob_free() ++{ ++ slang_commands_list_free(glob_slang_cmd_list); ++ glob_slang_cmd_list = NULL; ++} ++ ++static struct slang_header *slang_create(struct slang_header *list, char *lang, char *desc) ++{ ++ struct slang_header *nslang, *l; ++ ++ Assert(lang); ++ debug2("Creating language '%s' starting by %d", lang, (int) list); ++ for (nslang = list; nslang; nslang = nslang->next) ++ if (!strcasecmp(nslang->lang, lang)) ++ return list; ++ nslang = nmalloc(sizeof(struct slang_header)); ++ nslang->next = NULL; ++ nslang->desc = NULL; ++ nslang->lang = nmalloc(strlen(lang) + 1); ++ strcpy(nslang->lang, lang); ++ nslang->desc = nmalloc(strlen(desc) + 1); ++ strcpy(nslang->desc, desc); ++ nslang->ids = NULL; ++#ifndef SLANG_NOTYPES ++ nslang->types = NULL; ++#endif ++ nslang->durations = NULL; ++ for (l = list; l && l->next; l = l->next); ++ if (l) ++ l->next = nslang; ++ else { ++ Assert(!list); ++ list = nslang; ++ } ++ return list; ++} ++ ++static int slang_expmem(struct slang_header *what) ++{ ++ int size = 0; ++ ++ while (what) { ++ size += sizeof(struct slang_header); ++ size += strlen(what->lang) + 1; ++ size += strlen(what->desc) + 1; ++ size += slang_id_expmem(what->ids); ++#ifndef SLANG_NOTYPES ++ size += slang_type_expmem(what->types); ++#endif ++ size += slang_duration_expmem(what->durations); ++ what = what->next; ++ } ++ return size; ++} ++ ++static void slang_free(struct slang_header *what) ++{ ++ struct slang_header *next; ++ ++ while (what) { ++ next = what->next; ++ slang_id_free(what->ids); ++#ifndef SLANG_NOTYPES ++ slang_type_free(what->types); ++#endif ++ slang_duration_free(what->durations); ++ nfree(what->lang); ++ nfree(what->desc); ++ nfree(what); ++ what = next; ++ } ++} ++ ++static int slang_load(struct slang_header *slang, char *filename) ++{ ++ FILE *f; ++ char *buffer, *s; ++ char *cmd, *sid, *strtol_ret; ++#ifndef SLANG_NOTYPES ++ char *type; ++#endif ++ int line, id; ++ ++ Assert(slang); ++ putlog(LOG_MISC, "*", "Loading language \"%s\" from %s...", slang->lang, filename); ++ f = fopen(filename, "r"); ++ if (!f) { ++ putlog(LOG_MISC, "*", "Couldn't open slangfile \"%s\"!", filename); ++ return 0; ++ } ++ buffer = nmalloc(2000); ++ line = 0; ++ while (!feof(f)) { ++ s = buffer; ++ if (fgets(s, 2000, f)) { ++ line++; ++ // at first, kill those stupid line feeds and carriage returns... ++ if (s[strlen(s) - 1] == '\n') ++ s[strlen(s) - 1] = 0; ++ if (s[strlen(s) - 1] == '\r') ++ s[strlen(s) - 1] = 0; ++ if (!s[0]) ++ continue; ++ cmd = newsplit(&s); ++ ++ if (!strcasecmp(cmd, "T")) { ++#ifndef SLANG_NOTYPES ++ type = newsplit(&s); ++ slang->types = slang_type_add(slang->types, type, s); ++#endif ++ } else if (!strcasecmp(cmd, "D")) { ++ sid = newsplit(&s); ++ id = strtol(sid, &strtol_ret, 10); ++ if (strtol_ret == sid) { ++ putlog(LOG_MISC, "*", "ERROR in slangfile \"%s\", line %d: %s is not a valid " ++ "duration index!", filename, line, sid); ++ continue; ++ } ++ slang->durations = slang_duration_add(slang->durations, id, s); ++ } else { ++ id = strtol(cmd, &strtol_ret, 10); ++ if (strtol_ret == cmd) ++ continue; ++ slang->ids = slang_id_add(slang->ids, id, s); ++ } ++ } ++ } ++ fclose(f); ++ nfree(buffer); ++ return 1; ++} ++ ++static struct slang_header *slang_find(struct slang_header *where, char *language) ++{ ++ struct slang_header *slang = NULL; ++ ++ // at first, search for the specified language ++ for (slang = where; slang; slang = slang->next) ++ if (!strcasecmp(slang->lang, language)) ++ return slang; ++ // oops... language seems to be invalid. Let's find the default. ++ Assert(default_slang); ++ for (slang = where; slang; slang = slang->next) ++ if (!strcasecmp(slang->lang, default_slang)) ++ return slang; ++ // default_slang wasn't found either? *sigh* ++ // Let's return the first known language then. ++ return where; ++} ++ ++#ifndef SLANG_NOVALIDATE ++/* slang_valid(): ++ * check if the given language is a valid one ++ */ ++static int slang_valid(struct slang_header *where, char *language) ++{ ++ struct slang_header *slang = NULL; ++ ++ for (slang = where; slang; slang = slang->next) ++ if (!strcasecmp(slang->lang, language)) ++ return 1; ++ return 0; ++} ++#endif ++ ++static char getslang_error[12]; ++static char *getslang(int id) ++{ ++ char *text; ++ ++ if (!glob_slang) { ++ putlog(LOG_MISC, "*", "WARNING! No language selected! (getslang())"); ++ return "NOLANG"; ++ } ++ text = slang_id_get(glob_slang->ids, id); ++ if (!text) { ++ snprintf(getslang_error, sizeof(getslang_error), "SLANG%d", id); ++ return getslang_error; ++ } ++ return text; ++} ++ ++static char *getdur(int idx) ++{ ++ char *text; ++ ++ Assert((idx >= 0) && (idx < DURATIONS)); ++ if (!glob_slang) { ++ putlog(LOG_MISC, "*", "WARNING! No language selected! (getdur())"); ++ return "NOLANG"; ++ } ++ text = slang_duration_get(glob_slang->durations, idx); ++ if (!text) { ++ snprintf(getslang_error, sizeof(getslang_error), "DUR%d", idx); ++ return getslang_error; ++ } ++ return text; ++} ++ ++#ifndef SLANG_NOTYPES ++static char *getslangtype(char *type) ++{ ++ char *stype; ++ ++ if (!glob_slang) { ++ putlog(LOG_MISC, "*", "WARNING! No language selected! (getslangtype())"); ++ return "NOLANG"; ++ } ++ stype = slang_type_get(glob_slang->types, type); ++ if (stype) ++ return stype; ++ else ++ return type; ++} ++ ++static int slangtypetoi(char *slangtype) ++{ ++ char *type; ++ ++ if (!glob_slang) { ++ putlog(LOG_MISC, "*", "WARNING! No language selected! (slangtypetoi())"); ++ return T_ERROR; ++ } ++ type = slang_type_slang2type(glob_slang->types, slangtype); ++ if (type) { ++ debug1("type: %s", type); ++ return typetoi(type); ++ } else ++ return typetoi(slangtype); ++} ++#endif ++ ++#ifndef SLANG_NOGETALL ++static char *getslang_first(int id) ++{ ++ char *text; ++ ++ if (!glob_slang) { ++ putlog(LOG_MISC, "*", "WARNING! No language selected! (getslang())"); ++ return "NOLANG"; ++ } ++ text = slang_id_get_first(glob_slang->ids, id); ++ if (!text) { ++ snprintf(getslang_error, sizeof(getslang_error), "SLANG%d", id); ++ return getslang_error; ++ } ++ return text; ++} ++ ++static char *getslang_next() ++{ ++ return slang_id_get_next(); ++} ++#endif +diff -Nur src/mod/gseen.mod/slang_chanlang.c src/mod/gseen.mod/slang_chanlang.c +--- src/mod/gseen.mod/slang_chanlang.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang_chanlang.c 2002-10-26 13:18:02.000000000 +0200 +@@ -0,0 +1,113 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++struct slang_chanlang { ++ struct slang_chanlang *next; ++ char *chan; ++ char *lang; ++}; ++ ++static struct slang_chanlang *chanlangs = NULL; ++ ++static struct slang_chanlang *slang_chanlang_add(struct slang_chanlang *, char *, char *); ++static int slang_chanlang_expmem(struct slang_chanlang *); ++static void slang_chanlang_free(struct slang_chanlang *); ++static char *slang_chanlang_get(struct slang_chanlang *, char *); ++ ++static struct slang_chanlang *slang_chanlang_add(struct slang_chanlang *where, char *chan, char *lang) ++{ ++ struct slang_chanlang *item; ++ ++ for (item = where; item; item = item->next) ++ if (!rfc_casecmp(item->chan, chan)) ++ break; ++ if (!item) { ++ item = nmalloc(sizeof(struct slang_chanlang)); ++ item->chan = nmalloc(strlen(chan) + 1); ++ strcpy(item->chan, chan); ++ item->lang = nmalloc(strlen(lang) + 1); ++ strcpy(item->lang, lang); ++ item->next = where; ++ where = item; ++ } else { ++ Assert(item->lang); ++ item->lang = nrealloc(item->lang, strlen(lang) + 1); ++ strcpy(item->lang, lang); ++ } ++ return where; ++} ++ ++static int slang_chanlang_expmem(struct slang_chanlang *what) ++{ ++ int size = 0; ++ ++ while (what) { ++ Assert(what); ++ Assert(what->chan); ++ Assert(what->lang); ++ size += sizeof(struct slang_chanlang); ++ size += strlen(what->chan) + 1; ++ size += strlen(what->lang) + 1; ++ what = what->next; ++ } ++ return size; ++} ++ ++static void slang_chanlang_free(struct slang_chanlang *what) ++{ ++ struct slang_chanlang *next; ++ ++ while (what) { ++ Assert(what); ++ Assert(what->chan); ++ Assert(what->lang); ++ next = what->next; ++ nfree(what->chan); ++ nfree(what->lang); ++ nfree(what); ++ what = next; ++ } ++} ++ ++static char *slang_chanlang_get(struct slang_chanlang *where, char *chan) ++{ ++ while (where) { ++ if (!rfc_casecmp(where->chan, chan)) ++ return where->lang; ++ where = where->next; ++ } ++ return default_slang; ++} ++ ++/* slang_getbynick(): ++ * tries to find an appropriate language for nick by searching ++ * him on a channel and using the language of this channel. ++ */ ++static struct slang_header *slang_getbynick(struct slang_header *where, char *nick) ++{ ++ struct chanset_t *chan; ++ ++ for (chan = chanset; chan; chan = chan->next) ++ if (ismember(chan, nick)) ++#if EGG_IS_MIN_VER(10500) ++ return slang_find(where, slang_chanlang_get(chanlangs, chan->dname)); ++#else ++ return slang_find(where, slang_chanlang_get(chanlangs, chan->name)); ++#endif ++ return slang_find(where, default_slang); ++} +diff -Nur src/mod/gseen.mod/slang_duration.c src/mod/gseen.mod/slang_duration.c +--- src/mod/gseen.mod/slang_duration.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang_duration.c 2002-10-26 13:18:01.000000000 +0200 +@@ -0,0 +1,82 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++#define DURATIONS 13 ++ ++struct slang_duration { ++ char *durs[DURATIONS]; ++}; ++ ++static struct slang_duration *slang_duration_add(struct slang_duration *where, int idx, char *text) ++{ ++ int i; ++ ++ if ((idx < 0) || (idx >= DURATIONS)) { ++ putlog(LOG_MISC, "*", "Warning: Invalid duration index \"%d\".", idx); ++ return where; ++ } ++ debug2("Adding duration[%d]: %s", idx, text); ++ if (!where) { ++ where = nmalloc(sizeof(struct slang_duration)); ++ for (i = 0; i < DURATIONS; i++) ++ where->durs[i] = NULL; ++ } ++ if (where->durs[idx]) ++ nfree(where->durs[idx]); ++ where->durs[idx] = nmalloc(strlen(text) + 1); ++ strcpy(where->durs[idx], text); ++ return where; ++} ++ ++static int slang_duration_expmem(struct slang_duration *what) ++{ ++ int i, size = 0; ++ ++ if (!what) ++ return 0; ++ size += sizeof(struct slang_duration); ++ for (i = 0; i < DURATIONS; i++) ++ if (what->durs[i]) ++ size += strlen(what->durs[i]) + 1; ++ return size; ++} ++ ++static void slang_duration_free(struct slang_duration *what) ++{ ++ int i; ++ ++ if (what) { ++ for (i = 0; i < DURATIONS; i++) ++ if (what->durs[i]) ++ nfree(what->durs[i]); ++ nfree(what); ++ } ++} ++ ++static char *slang_duration_get(struct slang_duration *where, int idx) ++{ ++ if (!where) { ++ debug0("no where"); ++ return NULL; ++ } ++ if ((idx < 0) || (idx >= DURATIONS)) { ++ debug1("invalid duration index: %d", idx); ++ return NULL; ++ } ++ return where->durs[idx]; ++} +diff -Nur src/mod/gseen.mod/slang_gseen_commands.c src/mod/gseen.mod/slang_gseen_commands.c +--- src/mod/gseen.mod/slang_gseen_commands.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang_gseen_commands.c 2002-10-26 13:18:06.000000000 +0200 +@@ -0,0 +1,235 @@ ++static void slang_send_botnick() ++{ ++ strncat(slang_text_buf, botname, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_query() ++{ ++ if (glob_query) ++ strncat(slang_text_buf, glob_query, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_laston() ++{ ++ if (glob_laston) ++ strncat(slang_text_buf, glob_laston, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_otherchan() ++{ ++ if (glob_otherchan) ++ strncat(slang_text_buf, glob_otherchan, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_othernick() ++{ ++ if (glob_othernick) ++ strncat(slang_text_buf, glob_othernick, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_remotebot() ++{ ++ if (glob_remotebot) ++ strncat(slang_text_buf, glob_remotebot, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_snick() ++{ ++ if (glob_seendat) ++ strncat(slang_text_buf, glob_seendat->nick, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_shost() ++{ ++ if (glob_seendat) ++ strncat(slang_text_buf, glob_seendat->host, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_schan() ++{ ++ if (glob_seendat) ++ strncat(slang_text_buf, glob_seendat->chan, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_swhen() ++{ ++ char *dur; ++ ++ if (glob_seendat) { ++ dur = gseen_duration(now - glob_seendat->when); ++ strncat(slang_text_buf, dur, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_stime() ++{ ++ time_t tt; ++ char t[20]; ++ ++ if (glob_seendat) { ++ tt = glob_seendat->when; ++ strftime(t, 19, "%d.%m. %H:%M", localtime(&tt)); ++ strncat(slang_text_buf, t, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_spent() ++{ ++ char *dur; ++ ++ if (glob_seendat) { ++ dur = gseen_duration(glob_seendat->spent); ++ strncat(slang_text_buf, dur, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_smsg() ++{ ++ if (glob_seendat) ++ strncat(slang_text_buf, glob_seendat->msg, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_numresults() ++{ ++ char buf[7]; ++ ++ snprintf(buf, sizeof(buf), "%d", numresults); ++ strncat(slang_text_buf, buf, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_punisher() ++{ ++ char *reason; ++ int len; ++ ++ if (glob_seendat) { ++ reason = strchr(glob_seendat->msg, ' '); ++ if (!reason) ++ strncat(slang_text_buf, glob_seendat->msg, sizeof(slang_text_buf)); ++ else { ++ len = (int) reason - (int) glob_seendat->msg; ++ strncat(slang_text_buf, glob_seendat->msg, (sizeof(slang_text_buf) < len) ? sizeof(slang_text_buf) : len); ++ } ++ } ++} ++ ++static void slang_send_kickreason() ++{ ++ char *reason; ++ ++ if (glob_seendat) { ++ reason = strchr(glob_seendat->msg, ' '); ++ if (reason) ++ strncat(slang_text_buf, reason, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_rnick() ++{ ++ if (glob_seenrequest) { ++ Assert(glob_seenrequest->by); ++ Assert(glob_seenrequest->by->who); ++ strncat(slang_text_buf, glob_seenrequest->by->who, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_rchan() ++{ ++ if (glob_seenrequest) { ++ Assert(glob_seenrequest->by); ++ Assert(glob_seenrequest->by->chan); ++ strncat(slang_text_buf, glob_seenrequest->by->chan, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_rhost() ++{ ++ if (glob_seenrequest) { ++ Assert(glob_seenrequest->by); ++ Assert(glob_seenrequest->by->host); ++ strncat(slang_text_buf, glob_seenrequest->by->host, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_rtime() ++{ ++ time_t tt; ++ char t[20]; ++ ++ if (glob_seenrequest) { ++ Assert(glob_seenrequest->by); ++ tt = glob_seenrequest->by->when; ++ strftime(t, sizeof(t), "%d.%m. %H:%M", localtime(&tt)); ++ strncat(slang_text_buf, t, sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_rwhen() ++{ ++ if (glob_seenrequest) { ++ Assert(glob_seenrequest->by); ++ strncat(slang_text_buf, gseen_duration(now - glob_seenrequest->by->when), sizeof(slang_text_buf)); ++ } ++} ++ ++static void slang_send_requests() ++{ ++ char buf[7]; ++ ++ snprintf(buf, sizeof(buf), "%d", glob_seenrequests); ++ strncat(slang_text_buf, buf, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_totalnicks() ++{ ++ char buf[7]; ++ ++ snprintf(buf, sizeof(buf), "%d", glob_totalnicks); ++ strncat(slang_text_buf, buf, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_totalbytes() ++{ ++ char buf[20]; ++ ++ snprintf(buf, sizeof(buf), "%d", glob_totalbytes); ++ strncat(slang_text_buf, buf, sizeof(slang_text_buf)); ++} ++ ++static void slang_send_nick() ++{ ++ if (glob_nick) ++ strncat(slang_text_buf, glob_nick, sizeof(slang_text_buf)); ++} ++ ++struct slang_text_commands slang_text_gseen_command_table[] = ++{ ++ {"botnick", slang_send_botnick}, ++ {"query", slang_send_query}, ++ {"laston", slang_send_laston}, ++ {"otherchan", slang_send_otherchan}, ++ {"othernick", slang_send_othernick}, ++ {"remotebot", slang_send_remotebot}, ++ {"snick", slang_send_snick}, ++ {"swhen", slang_send_swhen}, ++ {"stime", slang_send_stime}, ++ {"shost", slang_send_shost}, ++ {"schan", slang_send_schan}, ++ {"spent", slang_send_spent}, ++ {"smsg", slang_send_smsg}, ++ {"numresults", slang_send_numresults}, ++ {"snick2", slang_send_smsg}, ++ {"bnbot", slang_send_smsg}, ++ {"punisher", slang_send_punisher}, ++ {"kickreason", slang_send_kickreason}, ++ {"rnick", slang_send_rnick}, ++ {"rchan", slang_send_rchan}, ++ {"rhost", slang_send_rhost}, ++ {"rtime", slang_send_rtime}, ++ {"rwhen", slang_send_rwhen}, ++ {"requests", slang_send_requests}, ++ {"totalnicks", slang_send_totalnicks}, ++ {"totalbytes", slang_send_totalbytes}, ++ {"nick", slang_send_nick}, ++ {0, 0} ++}; +diff -Nur src/mod/gseen.mod/slang_ids.c src/mod/gseen.mod/slang_ids.c +--- src/mod/gseen.mod/slang_ids.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang_ids.c 2002-10-26 13:18:04.000000000 +0200 +@@ -0,0 +1,104 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++struct slang_id { ++ struct slang_id *next; ++ int id; ++ struct slang_multitext *mtext; ++}; ++ ++static struct slang_id* slang_id_add(struct slang_id *, int, char *); ++static int slang_id_expmem(struct slang_id *); ++static void slang_id_free(struct slang_id *); ++static char *slang_id_get(struct slang_id *, int); ++ ++static struct slang_id* slang_id_add(struct slang_id *where, int id, char *text) ++{ ++ struct slang_id *newitem; ++ ++ newitem = NULL; ++ if (where) { ++ for (newitem = where; newitem; newitem = newitem->next) ++ if (newitem->id == id) ++ break; ++ } ++ if (!newitem) { ++ newitem = nmalloc(sizeof(struct slang_id)); ++ newitem->next = NULL; ++ newitem->id = id; ++ newitem->mtext = NULL; ++ if (where) ++ newitem->next = where; ++ else ++ newitem->next = NULL; ++ where = newitem; ++ } ++ newitem->mtext = slang_mtext_add(newitem->mtext, text); ++ return where; ++} ++ ++static int slang_id_expmem(struct slang_id *what) ++{ ++ int size = 0; ++ ++ for (; what; what = what->next) { ++ size += sizeof(struct slang_id); ++ size += slang_multitext_expmem(what->mtext); ++ } ++ return size; ++} ++ ++static void slang_id_free(struct slang_id *what) ++{ ++ struct slang_id *next; ++ ++ while (what) { ++ next = what->next; ++ slang_multitext_free(what->mtext); ++ nfree(what); ++ what = next; ++ } ++} ++ ++static char *slang_id_get(struct slang_id *where, int i) ++{ ++ while (where) { ++ if (where->id == i) ++ return slang_multitext_getrandomtext(where->mtext); ++ where = where->next; ++ } ++ return NULL; ++} ++ ++#ifndef SLANG_NOGETALL ++static char *slang_id_get_first(struct slang_id *where, int id) ++{ ++ while (where) { ++ if (where->id == id) { ++ return slang_multitext_get_first(where->mtext); ++ } ++ where = where->next; ++ } ++ return NULL; ++} ++ ++static char *slang_id_get_next() ++{ ++ return slang_multitext_get_next(); ++} ++#endif +diff -Nur src/mod/gseen.mod/slang_multitext.c src/mod/gseen.mod/slang_multitext.c +--- src/mod/gseen.mod/slang_multitext.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang_multitext.c 2002-10-26 13:18:05.000000000 +0200 +@@ -0,0 +1,151 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++struct slang_mt_content { ++ struct slang_mt_content *next; ++ struct slang_text *text; ++}; ++ ++struct slang_multitext { ++ int nr; ++ struct slang_mt_content *contents; ++}; ++ ++static struct slang_multitext *slang_mtext_add(struct slang_multitext *, char *); ++static int slang_multitext_expmem(struct slang_multitext *); ++static void slang_multitext_free(struct slang_multitext *); ++static char *slang_multitext_getrandomtext(struct slang_multitext *); ++#ifndef SLANG_NOTYPES ++static struct slang_text *slang_multitext_find(struct slang_multitext *, char *); ++#endif ++#ifndef SLANG_NOGETALL ++static char *slang_multitext_get_first(struct slang_multitext *); ++static char *slang_multitext_get_next(); ++#endif ++ ++static struct slang_multitext *slang_mtext_add(struct slang_multitext *where, char *text) ++{ ++ struct slang_mt_content *oc, *nc; ++ ++ if (!where) { ++ where = nmalloc(sizeof(struct slang_multitext)); ++ where->nr = 0; ++ where->contents = NULL; ++ } ++ nc = nmalloc(sizeof(struct slang_mt_content)); ++ nc->next = NULL; ++ nc->text = slang_text_parse(text); ++ for (oc = where->contents; oc && oc->next; oc = oc->next); ++ if (oc) { ++ Assert(!oc->next); ++ oc->next = nc; ++ } else ++ where->contents = nc; ++ where->nr++; ++ return where; ++} ++ ++static int slang_multitext_expmem(struct slang_multitext *what) ++{ ++ struct slang_mt_content *content; ++ int size = 0; ++ ++ if (!what) { ++ debug0("WARNING! slang_multitext_expmem() called with NULL pointer!"); ++ return 0; ++ } ++ size += sizeof(struct slang_multitext); ++ for (content = what->contents; content; content = content->next) { ++ size += sizeof(struct slang_mt_content); ++ size += slang_text_expmem(content->text); ++ } ++ return size; ++} ++ ++static void slang_multitext_free(struct slang_multitext *what) ++{ ++ struct slang_mt_content *content, *next; ++ ++ if (!what) { ++ debug0("WARNING! slang_multitext_free() called with NULL pointer!"); ++ return; ++ } ++ content = what->contents; ++ while (content) { ++ next = content->next; ++ slang_text_free(content->text); ++ nfree(content); ++ content = next; ++ } ++ nfree(what); ++} ++ ++static char *slang_multitext_getrandomtext(struct slang_multitext *where) ++{ ++ struct slang_mt_content *content; ++ unsigned long x; ++ ++ if (!where) ++ return NULL; ++ x = random() % where->nr; ++ for (content = where->contents; content; content = content->next) ++ if (!x) ++ return slang_text_get(content->text); ++ else ++ x--; ++ // we should never reach this part ++ debug0("warning: getrandomtext didn't find anything!"); ++ return NULL; ++} ++ ++#ifndef SLANG_NOTYPES ++static struct slang_text *slang_multitext_find(struct slang_multitext *where, char *what) ++{ ++ struct slang_mt_content *content; ++ ++ Assert(where); ++ for (content = where->contents; content; content = content->next) { ++ Assert(content->text); ++ if (!slang_text_strcasecmp(content->text, what)) ++ return content->text; ++ } ++ return NULL; ++} ++#endif ++ ++#ifndef SLANG_NOGETALL ++static struct slang_mt_content *glob_mtext_content; ++static char *slang_multitext_get_first(struct slang_multitext *where) ++{ ++ Assert(where); ++ glob_mtext_content = where->contents; ++ if (glob_mtext_content) ++ return slang_text_get(glob_mtext_content->text); ++ else ++ return NULL; ++} ++ ++static char *slang_multitext_get_next() ++{ ++ glob_mtext_content = glob_mtext_content->next; ++ if (glob_mtext_content) ++ return slang_text_get(glob_mtext_content->text); ++ else ++ return NULL; ++} ++#endif +diff -Nur src/mod/gseen.mod/slang_text.c src/mod/gseen.mod/slang_text.c +--- src/mod/gseen.mod/slang_text.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/slang_text.c 2002-10-26 13:18:07.000000000 +0200 +@@ -0,0 +1,200 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++struct slang_text { ++ struct slang_text *next; ++ char *string; ++ void (*command) (); ++}; ++ ++struct slang_text_commands { ++ char *command; ++ void (*targetfunc) (); ++}; ++ ++struct slang_command_list { ++ struct slang_command_list *next; ++ struct slang_text_commands *commands; ++}; ++ ++static struct slang_text *slang_text_parse(char *); ++static struct slang_text *slang_text_create(struct slang_text *); ++static void slang_text_add_string(struct slang_text *, char *); ++static void slang_text_add_command(struct slang_text *, char *); ++static void slang_text_free(struct slang_text *); ++static int slang_text_expmem(struct slang_text *); ++static char *slang_text_get(struct slang_text *); ++#ifndef SLANG_NOTYPES ++static int slang_text_strcasecmp(struct slang_text *, char *); ++#endif ++ ++static struct slang_text *slang_text_parse(char *text) ++{ ++ char *cmdstart, *cmdend; ++ struct slang_text *firstitem, *item; ++ ++ firstitem = slang_text_create(NULL); ++ item = firstitem; ++ while ((cmdstart = strstr(text, "<?"))) { ++ cmdstart[0] = 0; ++ slang_text_add_string(item, text); ++ item = slang_text_create(item); ++ text += 2; ++ cmdstart += 2; ++ cmdend = strstr(cmdstart, "/?>"); ++ if (!cmdend) { ++ putlog(LOG_MISC, "*", "ERROR parsing slang text: unterminated command \"%s\"!", cmdstart); ++ break; ++ } ++ cmdend[0] = 0; ++ slang_text_add_command(item, cmdstart); ++ item = slang_text_create(item); ++ text = cmdend + 3; ++ } ++ slang_text_add_string(item, text); ++ return firstitem; ++} ++ ++static struct slang_text *slang_text_create(struct slang_text *where) ++{ ++ struct slang_text *newpart; ++ ++ newpart = nmalloc(sizeof(struct slang_text)); ++ newpart->next = NULL; ++ newpart->string = NULL; ++ newpart->command = NULL; ++ while (where && where->next) ++ where = where->next; ++ if (where) ++ where->next = newpart; ++ return newpart; ++} ++ ++static void slang_text_add_string(struct slang_text *item, char *s) ++{ ++ Assert(item); ++ Assert(!item->string); ++ item->string = nmalloc(strlen(s) + 1); ++ strcpy(item->string, s); ++} ++ ++static void slang_text_free(struct slang_text *item) ++{ ++ if (!item) ++ return; ++ slang_text_free(item->next); ++ if (item->string) ++ nfree(item->string); ++ nfree(item); ++} ++ ++static int slang_text_expmem(struct slang_text *item) ++{ ++ int size = 0; ++ ++ while (item) { ++ size += sizeof(struct slang_text); ++ if (item->string) ++ size += strlen(item->string) + 1; ++ item = item->next; ++ } ++ return size; ++} ++ ++#ifndef SLANG_NOTYPES ++static int slang_text_strcasecmp(struct slang_text *item, char *text) ++{ ++ Assert(item); ++ debug2("s_t_sc: '%s', '%s'", text, item->string); ++ if (item->command || item->next) ++ return 1; ++ return strcasecmp(item->string, text); ++} ++#endif ++ ++static char slang_text_buf[500]; ++static char *slang_text_get(struct slang_text *item) ++{ ++ slang_text_buf[0] = 0; ++ while (item) { ++ if (item->string) ++ strncat(slang_text_buf, item->string, sizeof(slang_text_buf)); ++ else if (item->command) ++ item->command(); ++ item = item->next; ++ } ++ return slang_text_buf; ++} ++ ++/*****************************************************/ ++ ++ ++static struct slang_command_list *glob_slang_cmd_list; ++ ++static struct slang_command_list *slang_commands_list_add(struct slang_command_list *where, struct slang_text_commands *what) ++{ ++ struct slang_command_list *newcommandlist; ++ ++ newcommandlist = nmalloc(sizeof(struct slang_command_list)); ++ newcommandlist->commands = what; ++ newcommandlist->next = where; ++ return newcommandlist; ++} ++ ++static int slang_commands_list_expmem(struct slang_command_list *what) ++{ ++ int size = 0; ++ ++ while (what) { ++ size += sizeof(struct slang_command_list); ++ what = what->next; ++ } ++ return size; ++} ++ ++static void slang_commands_list_free(struct slang_command_list *what) ++{ ++ struct slang_command_list *next; ++ ++ while (what) { ++ next = what->next; ++ nfree(what); ++ what = next; ++ } ++} ++ ++static void slang_text_add_command(struct slang_text *item, char *s) ++{ ++ struct slang_command_list *cmdlist; ++ char *cmd; ++ int i; ++ ++ cmd = newsplit(&s); ++ i = 0; ++ for (cmdlist = glob_slang_cmd_list; cmdlist; cmdlist = cmdlist->next) { ++ for (i = 0; 1; i++) { ++ if (!cmdlist->commands[i].command) ++ break; ++ if (!strcasecmp(cmdlist->commands[i].command, cmd)) { ++ item->command = cmdlist->commands[i].targetfunc; ++ return; ++ } ++ } ++ } ++ putlog(LOG_MISC, "*", "ERROR! Unknown slang-command: '%s'", cmd); ++} +diff -Nur src/mod/gseen.mod/tclcmds.c src/mod/gseen.mod/tclcmds.c +--- src/mod/gseen.mod/tclcmds.c 1970-01-01 01:00:00.000000000 +0100 ++++ src/mod/gseen.mod/tclcmds.c 2002-10-26 13:18:08.000000000 +0200 +@@ -0,0 +1,53 @@ ++/* ++ * Copyright (C) 2000,2001 Florian Sander ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ */ ++ ++static int tcl_setchanseenlang STDVAR ++{ ++ Context; ++ BADARGS(3, 3, " channel language"); ++ chanlangs = slang_chanlang_add(chanlangs, argv[1], argv[2]); ++ return TCL_OK; ++} ++ ++static int tcl_loadseenslang STDVAR ++{ ++// int ret = 0; ++ char *shortname, *longname, *filename; ++ struct slang_header *slang; ++ ++ Context; ++ BADARGS(4, 4, " language description langfile"); ++ shortname = argv[1]; ++ longname = argv[2]; ++ filename = argv[3]; ++ coreslangs = slang_create(coreslangs, shortname, longname); ++ slang = slang_find(coreslangs, shortname); ++ Assert(slang); ++ if (!slang_load(slang, filename)) { ++ Tcl_AppendResult(irp, "Couldn't open seenslang file!!!", NULL); ++ return TCL_ERROR; ++ } ++ return TCL_OK; ++} ++ ++static tcl_cmds gseentcls[] = ++{ ++ {"loadseenslang", tcl_loadseenslang}, ++ {"setchanseenlang", tcl_setchanseenlang}, ++ {0, 0} ++}; |