path: root/main/eggdrop/gseen.mod.patch

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}
+};