FICS 1.6.2

1 files changed, 1247 insertions, 0 deletions

diff --git a/FICS/talkproc.c b/FICS/talkproc.c
new file mode 100644
index 0000000..cfd35b6
--- /dev/null
+++ b/FICS/talkproc.c
@@ -0,0 +1,1247 @@
+/* talkproc.c
+ *
+ */
+
+/*
+    fics - An internet chess server.
+    Copyright (C) 1993  Richard V. Nash
+
+    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.
+*/
+
+/* Revision history:
+   name				yy/mm/dd	Change
+   hersco and Marsalis         	95/07/24	Created
+   Sparky                       95/10/05        
+                                Modifed tell function for the following 
+                                changes:  no longer informs you that someone
+                                is censoring in tells to channels, whisper or
+                                kibitz.  Titles now shown instead of ratings
+                                in kibitz and whisper, admins on duty now are
+                                shown as (*), and computers marked as (C) as
+                                well as with rating.
+                                               
+*/
+
+#include "stdinclude.h"
+
+#include "common.h"
+#include "talkproc.h"
+#include "comproc.h"
+#include "command.h"
+#include "utils.h"
+#include "ficsmain.h"
+#include "config.h"
+#include "playerdb.h"
+#include "network.h"
+#include "rmalloc.h"
+#include "variable.h"
+#include "gamedb.h"
+#include "gameproc.h"
+#include "obsproc.h"
+/* #include "hostinfo.h" */
+#include "multicol.h"
+#include "lists.h"
+#include "formula.h"
+#include <string.h>
+
+#include <sys/resource.h>
+
+/* grimm */
+#if defined(SGI)
+#else
+/* int system(char *arg); */
+#endif
+
+int quota_time;
+
+#if 0
+PUBLIC int com_query(int p, param_list param)
+{
+  int p1;
+  int count = 0;
+
+  if (!parray[p].registered) {
+    pprintf(p, "Only registered players can use the query command.\n");
+    return COM_OK;
+  }
+  if (in_list(p, L_MUZZLE, parray[p].login)) {
+    pprintf(p, "You are muzzled.\n");
+    return COM_OK;
+  }
+  if (!printablestring(param[0].val.string)) {
+    pprintf(p, "Your message contains some unprintable character(s).\n");
+    return COM_OK;
+  }
+  if (!parray[p].query_log) {
+    parray[p].query_log = tl_new(5);
+  } else {
+    if (tl_numinlast(parray[p].query_log, 60 * 60) >= 2) {
+      pprintf(p, "Your can only query twice per hour.\n");
+      return COM_OK;
+    }
+  }
+  in_push(IN_SHOUT);
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (p1 == p)
+      continue;
+    if (parray[p1].status != PLAYER_PROMPT)
+      continue;
+    if (player_censored(p1, p))
+      continue;
+    count++;
+    if (parray[p1].highlight) {
+      pprintf_prompt(p1, "\n\033[7m%s queries:\033[0m %s\n", parray[p].name,
+		     param[0].val.string);
+    } else {
+      pprintf_prompt(p1, "\n%s queries: %s\n", parray[p].name,
+		     param[0].val.string);
+    }
+  }
+  pprintf(p, "Query heard by %d player(s).\n", count);
+  tl_logevent(parray[p].query_log, 1);
+  in_pop();
+  return COM_OK;
+}
+#endif
+
+/* hawk: hacked it to fit ALL persons - quota list is not needed anymore */
+int CheckShoutQuota(int p)
+{
+  int timenow = time(0);
+  int timeleft = 0;
+
+  if (((timeleft = timenow - parray[p].lastshout_a) < quota_time) &&
+      (parray[p].adminLevel == 0))  {
+    return (quota_time - timeleft);
+  } else {
+    return 0;
+  }
+}
+
+PUBLIC int com_shout(int p, param_list param)
+{
+  int p1;
+  int count = 0;
+  int timeleft;			/* time left for quota if applicable */
+
+  if (!parray[p].registered) {
+    pprintf(p, "Only registered players can use the shout command.\n");
+    return COM_OK;
+  }
+  if (in_list(p, L_MUZZLE, parray[p].login)) {
+    pprintf(p, "You are muzzled.\n");
+    return COM_OK;
+  }
+  if (param[0].type == TYPE_NULL) {
+    if ((timeleft = CheckShoutQuota(p))) {
+      pprintf(p, "Next shout available in %d seconds.\n", timeleft);
+    } else {
+      pprintf(p, "Your next shout is ready for use.\n");
+    }
+    return COM_OK;
+  }
+  if ((timeleft = CheckShoutQuota(p))) {
+    pprintf(p, "Shout not sent. Next shout in %d seconds.\n", timeleft);
+    return COM_OK;
+  }
+  parray[p].lastshout_a = parray[p].lastshout_b;
+  parray[p].lastshout_b = time(0);
+  if (!printablestring(param[0].val.string)) {
+    pprintf(p, "Your message contains some unprintable character(s).\n");
+    return COM_OK;
+  }
+/*  in_push(IN_SHOUT); */
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (p1 == p)
+      continue;
+    if (parray[p1].status != PLAYER_PROMPT)
+      continue;
+    if (!parray[p1].i_shout)
+      continue;
+    if (player_censored(p1, p))
+      continue;
+    count++;
+    pprintf_prompt(p1, "\n%s shouts: %s\n", parray[p].name,
+		   param[0].val.string);
+  }
+  pprintf(p, "(%d) %s shouts: %s\n", count, parray[p].name,
+	  param[0].val.string);
+/*  in_pop(); */
+  if ((timeleft = CheckShoutQuota(p))) {
+    pprintf(p, "Next shout in %d seconds.\n", timeleft);
+    return COM_OK;
+  }
+  return COM_OK;
+}
+
+PUBLIC int com_cshout(int p, param_list param)
+{
+  int p1;
+  int count = 0;
+
+  if (!parray[p].registered) {
+    pprintf(p, "Only registered players can use the cshout command.\n");
+    return COM_OK;
+  }
+  if (in_list(p, L_CMUZZLE, parray[p].login)) {
+    pprintf(p, "You are c-muzzled.\n");
+    return COM_OK;
+  }
+  if (!printablestring(param[0].val.string)) {
+    pprintf(p, "Your message contains some unprintable character(s).\n");
+    return COM_OK;
+  }
+/*  in_push(IN_SHOUT); */
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (p1 == p)
+      continue;
+    if (parray[p1].status != PLAYER_PROMPT)
+      continue;
+    if (!parray[p1].i_cshout)
+      continue;
+    if (player_censored(p1, p))
+      continue;
+    count++;
+    pprintf_prompt(p1, "\n%s c-shouts: %s\n", parray[p].name,
+		   param[0].val.string);
+  }
+  pprintf(p, "(%d) %s c-shouts: %s\n", count, parray[p].name,
+	  param[0].val.string);
+/*  in_pop(); */
+  return COM_OK;
+}
+
+PUBLIC int com_it(int p, param_list param)
+{
+  int p1;
+  int count = 0;
+  int timeleft;
+
+  if (!parray[p].registered) {
+    pprintf(p, "Only registered players can use the it command.\n");
+    return COM_OK;
+  }
+  if (in_list(p, L_MUZZLE, parray[p].login)) {
+    pprintf(p, "You are muzzled.\n");
+    return COM_OK;
+  }
+  if (param[0].type == TYPE_NULL) {
+    if ((timeleft = CheckShoutQuota(p))) {
+      pprintf(p, "Next shout available in %d seconds.\n", timeleft);
+    } else {
+      pprintf(p, "Your next shout is ready for use.\n");
+    }
+    return COM_OK;
+  }
+  if ((timeleft = CheckShoutQuota(p))) {
+    pprintf(p, "Shout not sent. Next shout in %d seconds.\n", timeleft);
+    return COM_OK;
+  }
+  parray[p].lastshout_a = parray[p].lastshout_b;
+  parray[p].lastshout_b = time(0);
+
+  if (!printablestring(param[0].val.string)) {
+    pprintf(p, "Your message contains some unprintable character(s).\n");
+    return COM_OK;
+  }
+/*  in_push(IN_SHOUT); */
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (p1 == p)
+      continue;
+    if (parray[p1].status != PLAYER_PROMPT)
+      continue;
+    if (!parray[p1].i_shout)
+      continue;
+    if (player_censored(p1, p))
+      continue;
+    count++;
+    if ((!strncmp(param[0].val.string, "\'", 1)) ||
+	(!strncmp(param[0].val.string, ",", 1)) ||
+	(!strncmp(param[0].val.string, ".", 1))) {
+      pprintf_prompt(p1, "\n--> %s%s\n", parray[p].name,
+		     param[0].val.string);
+    } else {
+      pprintf_prompt(p1, "\n--> %s %s\n", parray[p].name,
+		     param[0].val.string);
+    }
+  }
+  if ((!strncmp(param[0].val.string, "\'", 1)) ||
+      (!strncmp(param[0].val.string, ",", 1)) ||
+      (!strncmp(param[0].val.string, ".", 1))) {
+    pprintf(p, "(%d) --> %s%s\n", count, parray[p].name, param[0].val.string);
+  } else {
+    pprintf(p, "(%d) --> %s %s\n", count, parray[p].name, param[0].val.string);
+  }
+/*  in_pop(); */
+  if ((timeleft = CheckShoutQuota(p))) {
+    pprintf(p, "Next shout in %d seconds.\n", timeleft);
+    return COM_OK;
+  }
+  return COM_OK;
+}
+
+#define TELL_TELL 0
+#define TELL_SAY 1
+#define TELL_WHISPER 2
+#define TELL_KIBITZ 3
+#define TELL_CHANNEL 4
+PRIVATE int tell(int p, int p1, char *msg, int why, int ch)
+{
+  char tmp[MAX_LINE_SIZE];
+  int rating;
+  int rating1;
+
+  if (!printablestring(msg)) {
+    pprintf(p, "Your message contains some unprintable character(s).\n");
+    return COM_OK;
+  }
+/*  if (p1 == p) {
+ *   pprintf(p, "Quit talking to yourself! It's embarrassing.\n");
+ *   return COM_OK;
+ * }
+ */
+  if ((!parray[p1].i_tell) && (!parray[p].registered)) {
+    pprintf(p, "Player \"%s\" isn't listening to unregistered tells.\n",
+	    parray[p1].name);
+    return COM_OK;
+  }
+  if ((player_censored(p1, p)) && (parray[p].adminLevel == 0)) {
+    if ((why != TELL_KIBITZ) || (why != TELL_WHISPER) || (why != TELL_CHANNEL))
+    {
+       pprintf(p, "Player \"%s\" is censoring you.\n", parray[p1].name);
+    }
+    return COM_OK;
+  }
+/*  in_push(IN_TELL); */
+  switch (why) {
+  case TELL_SAY:
+    pprintf_highlight(p1, "\n%s", parray[p].name);
+    pprintf_prompt(p1, " says: %s\n", msg);
+    break;
+  case TELL_WHISPER:
+  case TELL_KIBITZ:
+    rating = GetRating(&parray[p], TYPE_BLITZ);
+    if (rating < ( rating1 = ( GetRating(&parray[p], TYPE_STAND ) ) ) )
+      rating = rating1;
+    if (in_list(p, L_FM, parray[p].name))
+      pprintf(p1, "\n%s(FM)", parray[p].name);
+    else if (in_list(p, L_IM, parray[p].name))
+      pprintf(p1, "\n%s(IM)", parray[p].name);
+    else if (in_list(p, L_GM, parray[p].name))
+      pprintf(p1, "\n%s(GM)", parray[p].name);
+    else if ((parray[p].adminLevel >= 10) && (parray[p].i_admin))
+      pprintf(p1, "\n%s(*)", parray[p].name);
+    else if ((rating >= parray[p1].kiblevel) || 
+             ((parray[p].adminLevel >= 10) && (parray[p].i_admin)))
+        if (!parray[p].registered)
+            pprintf(p1, "\n%s(++++)", parray[p].name);
+
+        else if (rating != 0)
+           if (in_list(p, L_COMPUTER, parray[p].name))
+               pprintf(p1, "\n%s(%d)(C)", parray[p].name, rating);
+           else
+               pprintf(p1, "\n%s(%d)", parray[p].name, rating);
+        else 
+            pprintf(p1, "\n%s(----)", parray[p].name, rating);
+    else break;
+
+    if (why == TELL_WHISPER) 
+       pprintf_prompt(p1, " whispers: %s\n", msg);
+    else 
+       pprintf_prompt(p1, " kibitzes: %s\n", msg);
+
+    break;
+  case TELL_CHANNEL:
+    pprintf(p1, "\n%s", parray[p].name);
+    pprintf_prompt(p1, "(%d): %s\n", ch, msg);
+    break;
+  case TELL_TELL:
+  default:
+    if (parray[p1].highlight) {
+      pprintf_highlight(p1, "\n%s", parray[p].name);
+    } else {
+      pprintf(p1, "\n%s", parray[p].name);
+    }
+    pprintf_prompt(p1, " tells you: %s\n", msg);
+    break;
+  }
+  tmp[0] = '\0';
+  if (!(parray[p1].busy[0] == '\0')) {
+    sprintf(tmp, ", who %s (idle: %s)", parray[p1].busy,
+	    hms_desc(player_idle(p1)));
+  } else {
+    if (((player_idle(p1) % 3600) / 60) > 2) {
+      sprintf(tmp, ", who has been idle %s", hms_desc(player_idle(p1)));
+    }
+    /* else sprintf(tmp," "); */
+  }
+  if ((why == TELL_SAY) || (why == TELL_TELL)) {
+    pprintf(p, "(told %s%s)\n", parray[p1].name,
+            (((parray[p1].game>=0) && (garray[parray[p1].game].status == GAME_EXAMINE)) 
+            ? ", who is examining a game" : 
+	    (parray[p1].game >= 0 && (parray[p1].game != parray[p].game))
+	    ? ", who is playing" : tmp));
+    parray[p].last_tell = p1;
+  }
+/*  in_pop(); */
+  return COM_OK;
+}
+
+PUBLIC int com_ptell(int p, param_list param) /*tells partner - doesn't change last tell */
+
+{
+  char tmp[MAX_LINE_SIZE];
+  int p1;
+
+   if (parray[p].partner < 0) {
+     pprintf (p, "You do not have a partner at present.\n");
+     return COM_OK;
+   }
+
+   p1 = parray[p].partner;
+   if ((p1 < 0) || (parray[p1].status == PLAYER_PASSWORD)
+       || (parray[p1].status == PLAYER_LOGIN)) {
+     pprintf(p, "Your partner is not logged in.\n");
+     return COM_OK;
+   }
+   if (parray[p1].highlight) {
+      pprintf_highlight(p1, "\n%s", parray[p].name);
+    } else {
+      pprintf(p1, "\n%s", parray[p].name);
+    }
+    pprintf_prompt(p1, " (your partner) tells you: %s\n", param[0].val.string);
+    tmp[0] = '\0';
+    if (!(parray[p1].busy[0] == '\0')) {
+      sprintf(tmp, ", who %s (idle: %s)", parray[p1].busy,
+              hms_desc(player_idle(p1)));
+    } else {
+      if (((player_idle(p1) % 3600) / 60) > 2) {
+        sprintf(tmp, ", who has been idle %s", hms_desc(player_idle(p1)));
+      }
+    }
+    /* else sprintf(tmp," "); */
+    pprintf(p, "(told %s%s)\n", parray[p1].name,
+            (((parray[p1].game>=0) && (garray[parray[p1].game].status == GAME_EXAMINE))
+            ? ", who is examining a game" :
+            (parray[p1].game >= 0 && (parray[p1].game != parray[p].game))
+            ? ", who is playing" : tmp));
+ return COM_OK;
+}
+
+PRIVATE int chtell(int p, int ch, char *msg)
+{
+  int p1, count = 0;
+
+  if ((ch == 0) && (parray[p].adminLevel == 0)) {
+    pprintf(p, "Only admins may send tells to channel 0.\n");
+    return COM_OK;
+  }
+
+  if (ch < 0) {
+    pprintf(p, "The lowest channel number is 0.\n");
+    return COM_OK;
+  }
+
+  if (ch >= MAX_CHANNELS) {
+    pprintf(p, "The maximum channel number is %d.\n", MAX_CHANNELS - 1);
+    return COM_OK;
+  }
+
+  for (p1 = 0; p1 < p_num; p1++) {
+    if ((p1 == p) || (parray[p1].status != PLAYER_PROMPT)) 
+      continue;
+    if ((on_channel(ch, p1)) && (!player_censored(p1, p))) {
+      tell(p, p1, msg, TELL_CHANNEL, ch);
+      count++;
+    }
+  }
+
+  if (count) 
+    parray[p].last_channel = ch;
+  
+  pprintf(p, "(%d->(%d))\n", ch, count);
+  if (!on_channel(ch, p))
+    pprintf(p, " (You're not listening to channel %d.)\n", ch);
+  
+  return COM_OK;
+}
+
+PUBLIC int com_whisper(int p, param_list param)
+{
+  int g;
+  int p1;
+  int count = 0;
+
+  if (!parray[p].num_observe && parray[p].game < 0) {
+    pprintf(p, "You are not playing or observing a game.\n");
+    return COM_OK;
+  }
+  if (!parray[p].registered && (parray[p].game == -1)) {
+    pprintf(p, "You must be registered to whisper other people's games.\n");
+    return COM_OK;
+  }
+  if (parray[p].game >= 0)
+    g = parray[p].game;
+  else
+    g = parray[p].observe_list[0];
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (p1 == p)
+      continue;
+    if (parray[p1].status != PLAYER_PROMPT)
+      continue;
+    if (player_is_observe(p1, g) ||
+        (garray[g].link >= 0 && player_is_observe(p1, garray[g].link))) {
+      tell(p, p1, param[0].val.string, TELL_WHISPER, 0);
+      if ((parray[p].adminLevel >= ADMIN_ADMIN) || !garray[g].private)
+	count++;
+    }
+  }
+  pprintf(p, "whispered to %d.\n", count);
+  return COM_OK;
+}
+
+PUBLIC int com_kibitz(int p, param_list param)
+{
+  int g;
+  int p1;
+  int count = 0;
+
+  if (!parray[p].num_observe && parray[p].game < 0) {
+    pprintf(p, "You are not playing or observing a game.\n");
+    return COM_OK;
+  }
+  if (!parray[p].registered && (parray[p].game == -1)) {
+    pprintf(p, "You must be registered to kibitz other people's games.\n");
+    return COM_OK;
+  }
+  if (parray[p].game >= 0)
+    g = parray[p].game;
+  else
+    g = parray[p].observe_list[0];
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (p1 == p)
+      continue;
+    if (parray[p1].status != PLAYER_PROMPT)
+      continue;
+    if ((player_is_observe(p1, g) || parray[p1].game == g ||
+         (garray[g].link >= 0 &&
+          (player_is_observe(p1, garray[g].link) || parray[p1].game == garray[g].link)
+         )
+        ) && parray[p1].i_kibitz) {
+      tell(p, p1, param[0].val.string, TELL_KIBITZ, 0);
+      if ((parray[p].adminLevel >= ADMIN_ADMIN) || !garray[g].private || (parray[p1].game == g))
+	count++;
+    }
+  }
+  pprintf(p, "kibitzed to %d.\n", count);
+  return COM_OK;
+}
+
+PUBLIC int com_tell(int p, param_list param)
+{
+  int p1;
+
+  if (param[0].type == TYPE_NULL)
+    return COM_BADPARAMETERS;
+  if (param[0].type == TYPE_WORD) {
+    stolower(param[0].val.word);
+    if (!strcmp(param[0].val.word, ".")) {
+      if (parray[p].last_tell < 0) {
+	pprintf(p, "No one to tell anything to.\n");
+	return COM_OK;
+      } else {
+	return tell(p, parray[p].last_tell, param[1].val.string, TELL_TELL, 0);
+      }
+    }
+    if (!strcmp(param[0].val.word, ",")) {
+      if (parray[p].last_channel < 0) {
+	pprintf(p, "No previous channel.\n");
+	return COM_OK;
+      } else {
+	return chtell(p, parray[p].last_channel, param[1].val.string);
+      }
+    }
+    p1 = player_find_part_login(param[0].val.word);
+    if ((p1 < 0) || (parray[p1].status == PLAYER_PASSWORD)
+	|| (parray[p1].status == PLAYER_LOGIN)) {
+      pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
+      return COM_OK;
+    }
+    return tell(p, p1, param[1].val.string, TELL_TELL, 0);
+  } else {			/* Channel */
+    return chtell(p, param[0].val.integer, param[1].val.string);
+  }
+}
+
+PUBLIC int com_xtell(int p, param_list param)
+{
+  int p1;
+  char *msg;
+  char tmp[2048];
+
+  msg = param[1].val.string;
+  p1 = player_find_part_login(param[0].val.word);
+  if ((p1 < 0) || (parray[p1].status == PLAYER_PASSWORD)
+      || (parray[p1].status == PLAYER_LOGIN)) {
+    pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
+    return COM_OK;
+  }
+  if (!printablestring(msg)) {
+    pprintf(p, "Your message contains some unprintable character(s).\n");
+    return COM_OK;
+  }
+  if ((!parray[p1].i_tell) && (!parray[p].registered)) {
+    pprintf(p, "Player \"%s\" isn't listening to unregistered tells.\n",
+	    parray[p1].name);
+    return COM_OK;
+  }
+  if ((player_censored(p1, p)) && (parray[p].adminLevel == 0)) {
+    pprintf(p, "Player \"%s\" is censoring you.\n", parray[p1].name);
+    return COM_OK;
+  }
+  if (parray[p1].highlight) {
+    pprintf_highlight(p1, "\n%s", parray[p].name);
+  } else {
+    pprintf(p1, "\n%s", parray[p].name);
+  }
+  pprintf_prompt(p1, " tells you: %s\n", msg);
+
+  tmp[0] = '\0';
+  if (!(parray[p1].busy[0] == '\0')) {
+    sprintf(tmp, ", who %s (idle: %s)", parray[p1].busy,
+	    hms_desc(player_idle(p1)));
+  } else {
+    if (((player_idle(p1) % 3600) / 60) > 2) {
+      sprintf(tmp, ", who has been idle %s", hms_desc(player_idle(p1)));
+    }
+  }
+  pprintf(p, "(told %s%s)\n", parray[p1].name,
+          (((parray[p1].game>=0) && (garray[parray[p1].game].status == GAME_EXAMINE)) 
+          ? ", who is examining a game" : 
+	  (parray[p1].game >= 0 && (parray[p1].game != parray[p].game))
+          ? ", who is playing" : tmp));
+  return COM_OK;
+}
+
+PUBLIC int com_say(int p, param_list param)
+{
+  if (parray[p].opponent < 0) {
+    if (parray[p].last_opponent < 0) {
+      pprintf(p, "No one to say anything to, try tell.\n");
+      return COM_OK;
+    } else {
+      return tell(p, parray[p].last_opponent, param[0].val.string, TELL_SAY, 0);
+    }
+  }
+  return tell(p, parray[p].opponent, param[0].val.string, TELL_SAY, 0);
+}
+
+#if 0
+PRIVATE int notorcen(int p, param_list param, int *num, int max,
+		      char **list, char *listname)
+{
+  int i, p1, connected;
+
+  if (param[0].type != TYPE_WORD) {
+    if (!*num) {
+      pprintf(p, "Your %s list is empty.\n", listname);
+      return COM_OK;
+    } else
+      pprintf(p, "-- Your %s list contains %d names: --", listname, *num);
+    /* New code to print names in columns */
+    {
+      multicol *m = multicol_start(MAX_NOTIFY + 1);
+      for (i = 0; i < *num; i++)
+	multicol_store_sorted(m, list[i]);
+      multicol_pprint(m, p, 78, 2);
+      multicol_end(m);
+    }
+    return COM_OK;
+  }
+  if (*num >= max) {
+    pprintf(p, "Sorry, your %s list is already full.\n", listname);
+    return COM_OK;
+  }
+  if (!FindPlayer(p, param[0].val.word, &p1, &connected))
+    return COM_OK;
+
+  for (i = 0; i < *num; i++) {
+    if (!strcasecmp(list[i], param[0].val.word)) {
+      pprintf(p, "Your %s list already includes %s.\n",
+	      listname, parray[p1].name);
+      if (!connected)
+	player_remove(p1);
+      return COM_OK;
+    }
+  }
+  if (p1 == p) {
+    pprintf(p, "You can't %s yourself.\n", listname);
+    return COM_OK;
+  }
+  list[*num] = strdup(parray[p1].name);
+  ++(*num);
+  pprintf(p, "%s is now on your %s list.\n", parray[p1].name, listname);
+  if (!connected)
+    player_remove(p1);
+  return COM_OK;
+}
+
+PRIVATE int unnotorcen(int p, param_list param, int *num, int max,
+		        char **list, char *listname)
+{
+  char *pname = NULL;
+  int i, j;
+  int unc = 0;
+
+  if (param[0].type == TYPE_WORD) {
+    pname = param[0].val.word;
+  }
+  for (i = 0; i < *num; i++) {
+    if (!pname || !strcasecmp(pname, list[i])) {
+      pprintf(p, "%s is removed from your %s list.\n",
+	      list[i], listname);
+      rfree(list[i]);
+      list[i] = NULL;
+      unc++;
+    }
+  }
+  if (unc) {
+    i = 0;
+    j = 0;
+    while (j < *num) {
+      if (list[j] != NULL) {
+	list[i++] = list[j];
+      }
+      j++;
+    }
+    while (i < j) {
+      list[i++] = NULL;
+    }
+    (*num) -= unc;
+  } else {
+    pprintf(p, "No one was removed from your %s list.\n", listname);
+  }
+  return COM_OK;
+}
+
+
+PUBLIC int com_notify(int p, param_list param)
+{
+  return notorcen(p, param, &parray[p].num_notify, MAX_NOTIFY,
+		  parray[p].notifyList, "notify");
+}
+
+PUBLIC int com_censor(int p, param_list param)
+{
+  return notorcen(p, param, &parray[p].num_censor, MAX_CENSOR,
+		  parray[p].censorList, "censor");
+}
+
+PUBLIC int com_unnotify(int p, param_list param)
+{
+  return unnotorcen(p, param, &parray[p].num_notify, MAX_NOTIFY,
+		    parray[p].notifyList, "notify");
+}
+
+PUBLIC int com_uncensor(int p, param_list param)
+{
+  return unnotorcen(p, param, &parray[p].num_censor, MAX_CENSOR,
+		    parray[p].censorList, "censor");
+}
+
+#endif
+
+#if 0 /* now in lists.c */
+PUBLIC int com_channel(int p, param_list param)
+{
+  int i, err;
+
+  if (param[0].type == TYPE_NULL) {	/* Turn off all channels */
+    for (i = 0; i < MAX_CHANNELS; i++) {
+      if (!channel_remove(i, p))
+	pprintf(p, "Channel %d turned off.\n", i);
+    }
+  } else {
+    i = param[0].val.integer;
+    if ((i == 0) && (!on_channel(i, p)) && (parray[p].adminLevel == 0)) {
+      pprintf(p, "Only admins may join channel 0.\n");
+      return COM_OK;
+    }
+    if (i < 0) {
+      pprintf(p, "The lowest channel number is 0.\n");
+      return COM_OK;
+    }
+    if (i >= MAX_CHANNELS) {
+      pprintf(p, "The maximum channel number is %d.\n", MAX_CHANNELS - 1);
+      return COM_OK;
+    }
+    if (on_channel(i, p)) {
+      if (!channel_remove(i, p))
+	pprintf(p, "Channel %d turned off.\n", i);
+    } else {
+      if (!(err = channel_add(i, p)))
+	pprintf(p, "Channel %d turned on.\n", i);
+      else {
+	if (err == 1)
+	  pprintf(p, "Channel %d is already full.\n", i);
+	if (err == 3)
+	  pprintf(p, "Maximum channel number exceeded.\n");
+      }
+    }
+  }
+  return COM_OK;
+}
+#endif
+
+PUBLIC int com_inchannel(int p, param_list param)
+{
+  int p1,count = 0;
+  char tmp[18];
+
+
+  if (param[0].type == NULL) {
+    pprintf (p,"inchannel [no params] has been removed\n");
+    pprintf (p,"Please use inchannel [name] or inchannel [number]\n");
+    return COM_OK;
+  }
+
+  if (param[0].type == TYPE_WORD) {
+    p1 = player_find_part_login(param[0].val.word);
+    if ((p1 < 0) || (parray[p1].status != PLAYER_PROMPT)) {
+      pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
+      return COM_OK;
+    }
+    pprintf (p,"%s is in the following channels:",parray[p1].name); /* no \n */
+    if (list_channels (p,p1))
+      pprintf (p," No channels found.\n",parray[p1].name);
+    return COM_OK;
+  } else {
+    sprintf (tmp,"%d",param[0].val.integer);
+    for (p1 = 0; p1 < p_num; p1++) {
+      if (parray[p1].status != PLAYER_PROMPT)
+	continue;
+      if (in_list(p1,L_CHANNEL,tmp)) {
+        if (!count)
+          pprintf(p,"Channel %d:",param[0].val.integer);
+        pprintf (p," %s%s",parray[p1].name,(((parray[p1].adminLevel >= 10) && (parray[p1].i_admin) && (param[0].val.integer < 2)) ? "(*)" : ""));
+        count++;
+        } 
+    }
+    if (!count)
+      pprintf(p,"Channel %d is empty.\n",param[0].val.integer);
+    else
+      pprintf (p,"\n%d %s in channel %d.\n",count,(count == 1 ? "person is" : "people are"),param[0].val.integer);
+    return COM_OK;
+  }
+}
+
+#if 0 /* if anyone can do inchannel NULL without n^3 computation
+		please do so*/
+PUBLIC int com_inchannel(int p, param_list param)
+{
+  int c1, c2;
+  int i, j, count = 0;
+
+  if (param[0].type == TYPE_NULL) {	/* List everyone on every channel */
+    c1 = -1;
+    c2 = -1;
+  } else if (param[1].type == TYPE_NULL) {	/* One parameter */
+    c1 = param[0].val.integer;
+    if (c1 < 0) {
+      pprintf(p, "The lowest channel number is 0.\n");
+      return COM_OK;
+    }
+    c2 = -1;
+  } else {			/* Two parameters */
+    c1 = param[0].val.integer;
+    c2 = param[1].val.integer;
+    if ((c1 < 0) || (c2 < 0)) {
+      pprintf(p, "The lowest channel number is 0.\n");
+      return COM_OK;
+    }
+    pprintf(p, "Two parameter inchannel is not implemented.\n");
+    return COM_OK;
+  }
+  if ((c1 >= MAX_CHANNELS) || (c2 >= MAX_CHANNELS)) {
+    pprintf(p, "The maximum channel number is %d.\n", MAX_CHANNELS - 1);
+    return COM_OK;
+  }
+  for (i = 0; i < MAX_CHANNELS; i++) {
+    if (numOn[i] && ((c1 < 0) || (i == c1))) {
+      /* First get rid of ghosts. */
+      for (j=0; j < numOn[i]; j++) {
+        if (parray[channels[i][j]].status == PLAYER_PROMPT)
+          continue;
+        channels[i][j] = channels[i][--numOn[i]];
+        j--;
+      }
+      pprintf(p, "Channel %d:", i);
+      for (j = 0; j < numOn[i]; j++) {
+	pprintf(p, " %s", parray[channels[i][j]].name);
+        if ((i==0 || i==1) && parray[channels[i][j]].adminLevel >= 10
+                           && parray[channels[i][j]].i_admin)
+          pprintf(p, "(*)");
+      }
+      count++;
+      pprintf(p, "\n");
+    }
+  }
+  if (!count) {
+    if (c1 < 0)
+      pprintf(p, "No channels in use.\n");
+    else
+      pprintf(p, "Channel not in use.\n");
+  }
+  return COM_OK;
+}
+#endif
+
+PUBLIC int com_sendmessage(int p, param_list param)
+{
+  int p1, connected = 1;
+
+  if (!parray[p].registered) {
+    pprintf(p, "You are not registered and cannot send messages.\n");
+    return COM_OK;
+  }
+  if ((param[0].type == TYPE_NULL) || (param[1].type == TYPE_NULL)) {
+    pprintf(p, "No message sent.\n");
+    return COM_OK;
+  }
+  if (!FindPlayer(p, param[0].val.word, &p1, &connected))
+    return COM_OK;
+
+  if (!parray[p1].registered) {
+    pprintf(p, "Player \"%s\" is unregistered and cannot receive messages.\n",
+            parray[p1].name);
+    return COM_OK; /* no need to removed */
+  }
+
+  if ((player_censored(p1, p)) && (parray[p].adminLevel == 0)) {
+    pprintf(p, "Player \"%s\" is censoring you.\n", parray[p1].name);
+    if (!connected)
+      player_remove(p1);
+    return COM_OK;
+  }
+  if (player_add_message(p1, p, param[1].val.string)) {
+    pprintf(p, "Couldn't send message to %s. Message buffer full.\n",
+	    parray[p1].name);
+  } else {
+    if (connected) {
+      pprintf(p1, "\n%s just sent you a message:\n", parray[p].name);
+      pprintf_prompt(p1, "    %s\n", param[1].val.string);
+    } 
+  }
+  if (!connected)
+    player_remove(p1);
+  return COM_OK;
+}
+
+PUBLIC int com_messages(int p, param_list param)
+{
+  int start;
+  /* int end = -1; */
+
+  if (!parray[p].registered) {
+    pprintf (p, "Unregistered players may not send or receive messages.\n");
+    return COM_OK;
+  }
+  if (param[0].type == TYPE_NULL) {
+    player_show_messages (p);
+  } else if (param[0].type == TYPE_WORD) {
+    if (param[1].type != TYPE_NULL)
+      return com_sendmessage(p, param);
+    else ShowMsgsBySender(p, param);
+  } else {
+    start = param[0].val.integer;
+    ShowMsgRange (p, start, start);
+  }
+  return COM_OK;
+}
+
+PUBLIC int com_clearmessages(int p, param_list param)
+{
+  int start;
+
+  if (player_num_messages(p) <= 0) {
+    pprintf(p, "You have no messages.\n");
+    return COM_OK;
+  }
+  if (param[0].type == TYPE_NULL) {
+    pprintf(p, "Messages cleared.\n");
+    player_clear_messages(p);
+  } else if (param[0].type == TYPE_WORD) {
+    ClearMsgsBySender(p, param);
+  } else if (param[0].type == TYPE_INT) {
+    start = param[0].val.integer;
+    ClrMsgRange (p, start, start);
+  }
+  return COM_OK;
+}
+
+PUBLIC int com_mailmess(int p, param_list param)
+{
+  char *buffer[1000];
+  char mdir[MAX_FILENAME_SIZE];
+  char filename[MAX_FILENAME_SIZE];
+  char subj[81], fname[MAX_FILENAME_SIZE];
+
+
+  if (!parray[p].registered) {
+    pprintf(p, "Only registered people can use the mailmess command.\n");
+    return COM_OK;
+  }
+  sprintf(filename, "%s.messages", parray[p].login);
+  sprintf(mdir, "%s/player_data/%c/", stats_dir, parray[p].login[0]);
+
+  if (search_directory(mdir, filename, buffer, 1000)) {
+    sprintf(subj, "Your FICS messages from server %s", fics_hostname);
+    sprintf(fname, "%s/%s", mdir, filename);
+    mail_file_to_user (p, subj, fname);
+    pprintf(p, "Messages sent to %s\n", parray[p].emailAddress);
+  } else {
+    pprintf(p, "You have no messages.\n");
+  }
+  return COM_OK;
+
+}
+
+PUBLIC int com_znotify(int p, param_list param)
+{
+  int p1, count = 0;
+
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (player_notified(p, p1)) {
+      if (!count)
+	pprintf(p, "Present company on your notify list:\n  ");
+      pprintf(p, " %s", parray[p1].name);
+      count++;
+    }
+  }
+  if (count)
+    pprintf(p, ".\n");
+  else
+    pprintf(p, "No one from your notify list is logged on.\n");
+
+  count = 0;
+  for (p1 = 0; p1 < p_num; p1++) {
+    if (player_notified(p1, p) && parray[p1].status == PLAYER_PROMPT) {
+      if (!count)
+	pprintf(p,
+		"The following players have you on their notify list:\n  ");
+      pprintf(p, " %s", parray[p1].name);
+      count++;
+    }
+  }
+  if (count)
+    pprintf(p, ".\n");
+  else
+    pprintf(p, "No one logged in has you on their notify list.\n");
+  return COM_OK;
+}
+
+PUBLIC int com_qtell(int p, param_list param)
+{
+  int p1;
+  char tmp[MAX_STRING_LENGTH];
+  char dummy[2];
+  char buffer1[MAX_STRING_LENGTH];	/* no highlight and no bell */
+  char buffer2[MAX_STRING_LENGTH];	/* no highlight and bell */
+  char buffer3[MAX_STRING_LENGTH];	/* highlight and no bell */
+  char buffer4[MAX_STRING_LENGTH];	/* highlight and and bell */
+  int i,count;
+/*  FILE *fp; */
+
+  if (!in_list(p, L_TD, parray[p].name)) {
+    pprintf(p, "Only TD programs are allowed to use this command.\n");
+    return COM_OK;
+  }
+  strcpy(buffer1, ":\0");
+  strcpy(buffer2, ":\0");
+  strcpy(buffer3, ":\0");
+  strcpy(buffer4, ":\0");
+
+  sprintf(tmp, "%s", param[1].val.string);
+  for (i = 0, count = 0; ((tmp[i] != '\0') && (count < 1029));) {
+    if ((tmp[i] == '\\') && (tmp[i + 1] == 'n')) {
+      strcat(buffer1, "\n:");
+      strcat(buffer2, "\n:");
+      strcat(buffer3, "\n:");
+      strcat(buffer4, "\n:");
+      count += 2;
+      i += 2;
+    } else if ((tmp[i] == '\\') && (tmp[i + 1] == 'b')) {
+      strcat(buffer2, "\007");
+      strcat(buffer4, "\007");
+      count++;
+      i += 2;
+    } else if ((tmp[i] == '\\') && (tmp[i + 1] == 'H')) {
+      strcat(buffer3, "\033[7m");
+      strcat(buffer4, "\033[7m");
+      count += 4;
+      i += 2;
+    } else if ((tmp[i] == '\\') && (tmp[i + 1] == 'h')) {
+      strcat(buffer3, "\033[0m");
+      strcat(buffer4, "\033[0m");
+      count += 4;
+      i += 2;
+    } else {
+      dummy[0] = tmp[i];
+      dummy[1] = '\0';
+      strcat(buffer1, dummy);
+      strcat(buffer2, dummy);
+      strcat(buffer3, dummy);
+      strcat(buffer4, dummy);
+      count++;
+      i++;
+    }
+  }
+
+  if (param[0].type == TYPE_WORD) {
+/*
+    fp = fopen("/tmp/fics-log", "a");
+    fprintf(fp, "PLAYER \"%s\" - MESSAGE \"%s\"\n", param[0].val.word, param[1].val.string);
+    fclose(fp);
+*/
+    if ((p1 = player_find_bylogin(param[0].val.word)) < 0) {
+      pprintf(p, "*qtell %s 1*\n", param[0].val.word);
+      return COM_OK;
+    }
+    pprintf_prompt(p1, "\n%s\n", (parray[p1].highlight && parray[p1].bell) ? buffer4 :
+		   (parray[p1].highlight && !parray[p1].bell) ? buffer3 :
+		   (!parray[p1].highlight && parray[p1].bell) ? buffer2 :
+		   buffer1);
+    pprintf(p, "*qtell %s 0*\n", parray[p1].name);
+
+  } else {
+    int p1;
+    int ch = param[0].val.integer;
+
+    if (ch == 0) {
+      pprintf(p, "*qtell %d 1*\n", param[0].val.integer);
+      return COM_OK;
+    }
+    if (ch < 0) {
+      pprintf(p, "*qtell %d 1*\n", param[0].val.integer);
+      return COM_OK;
+    }
+    if (ch >= MAX_CHANNELS) {
+      pprintf(p, "*qtell %d 1*\n", param[0].val.integer);
+      return COM_OK;
+    }
+    sprintf (tmp,"%d",param[0].val.integer);
+    for (p1 = 0; p1 < p_num ; p1++) {
+      if ((p1 == p) || (player_censored(p1, p)) || (parray[p1].status != PLAYER_PROMPT))
+	continue;
+      if (in_list(p1,L_CHANNEL,tmp))
+        pprintf_prompt(p1, "\n%s\n", (parray[p1].highlight && parray[p1].bell) ? buffer4 :
+		     (parray[p1].highlight && !parray[p1].bell) ? buffer3 :
+		     (!parray[p1].highlight && parray[p1].bell) ? buffer2 :
+		     buffer1);
+    }
+    pprintf(p, "*qtell %d 0*\n", param[0].val.integer);
+  }
+  return COM_OK;
+}
+
+PUBLIC int on_channel(int ch, int p)
+{
+ char tmp[10];  /* 9 digits ought to be enough :) */
+
+ sprintf (tmp,"%d",ch);
+ return in_list(p, L_CHANNEL,tmp );  /* since needs ch converted to a string keep
+                                        hidden from view */
+}
+
+#if 0
+
+void WhichList(int p, char *partial, char **Full)
+{
+  int i, gotit = -1;
+  int slen = strlen(partial);
+  static char *MyList[] = {"notify", "censor", "channel", ""};
+
+  for (i=0; MyList[i][0] != '\0'; i++) {
+    if (strncmp(partial, MyList[i], slen))
+      continue;
+    if (gotit >= 0) {
+      pprintf(p, "Ambiguous list name.\n");
+      *Full = NULL;
+      return;
+    }
+    gotit = i;
+  }
+  if (gotit >= 0)
+    *Full = MyList[gotit];
+  else **Full = '\0';
+  return;
+}
+
+PUBLIC int com_plus(int p, param_list param)
+{
+  char *list;
+  int chan;
+  parameter *Param1 = &param[1];
+
+  WhichList (p, param[0].val.word, &list);
+
+  if (list == NULL) return COM_OK;
+
+  if (!strcmp(list, "notify"))
+    return notorcen (p, Param1, &parray[p].num_notify, MAX_NOTIFY,
+		     parray[p].notifyList, "notify");
+  if (!strcmp(list, "censor"))
+    return notorcen (p, Param1, &parray[p].num_censor, MAX_NOTIFY,
+		     parray[p].censorList, "censor");
+  if (!strcmp(list, "channel")) {
+    chan = atoi(param[1].val.word);
+    if (chan < 0) {
+    }
+
+    switch (channel_add(chan, p)) {
+      case 0:  pprintf(p, "Channel %d turned on.\n", chan);  break;
+      case 1:  pprintf(p, "Channel %d is already full.\n", chan);  break;
+      case 2:  pprintf(p, "You are already on channel %d.\n", chan);  break;
+      case 3:  pprintf(p, "Maximum number of channels exceeded.\n");  break;
+    }
+    return COM_OK;
+  }
+  return com_addlist(p, param);
+}
+
+PUBLIC int com_minus(int p, param_list param)
+{
+  char *list;
+  int chan;
+  parameter *Param1 = &param[1];
+
+  WhichList (p, param[0].val.word, &list);
+
+  if (list == NULL) return COM_OK;
+
+  if (!strcmp(list, "notify"))
+    return unnotorcen (p, Param1, &parray[p].num_notify, MAX_NOTIFY,
+		       parray[p].notifyList, "notify");
+  if (!strcmp(list, "censor"))
+    return unnotorcen (p, Param1, &parray[p].num_censor, MAX_CENSOR,
+		       parray[p].censorList, "censor");
+  if (!strcmp(list, "channel")) {
+    chan = atoi(param[1].val.word);
+    if (on_channel(chan, p))
+      channel_remove(chan, p);
+    else
+      pprintf(p, "You are not on channel %d", chan);
+    return COM_OK;
+  }
+  return com_sublist(p, param);
+}
+#endif