home *** CD-ROM | disk | FTP | other *** search
/ The Net: Ultimate Internet Guide / WWLCD1.ISO / pc / java / in4wjcxu / other / irc / ircd / note.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-14  |  103.7 KB  |  2,927 lines
  1. /************************************************************************
  2.  *   IRC - Internet Relay Chat, ircd/note.c
  3.  *   Copyright (C) 1990 Jarle Lyngaas
  4.  *
  5.  *   This program is free software; you can redistribute it and/or modify
  6.  *   it under the terms of the GNU General Public License as published by
  7.  *   the Free Software Foundation; either version 1, or (at your option)
  8.  *   any later version.
  9.  *
  10.  *   This program is distributed in the hope that it will be useful,
  11.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *   GNU General Public License for more details.
  14.  *
  15.  *   You should have received a copy of the GNU General Public License
  16.  *   along with this program; if not, write to the Free Software
  17.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. /*
  21.  *        Author: Jarle Lyngaas
  22.  *        E-mail: nmijl@alf.uib.no
  23.  *        On IRC: Wizible
  24.  */
  25.  
  26. #include "struct.h"
  27. #ifdef NPATH
  28. #include "numeric.h"
  29. #include <ctype.h>
  30. #include <stdio.h>
  31. #include <time.h>
  32. #include "common.h"
  33. #include "sys.h"
  34. #include "h.h"
  35.  
  36. #define VERSION "v2.1"
  37.  
  38. #define NOTE_SAVE_FREQUENCY 30 /* Frequency of save time in minutes */
  39. #define NOTE_MAXSERVER_TIME 120 /* Max days for a request in the server */
  40. #define NOTE_MAXSERVER_MESSAGES 2000 /* Max number of requests in the server */
  41. #define NOTE_MAXUSER_MESSAGES 200 /* Max number of requests for each user */
  42. #define NOTE_MAXSERVER_WILDCARDS 200 /* Max number of server toname w.cards */
  43. #define NOTE_MAXUSER_WILDCARDS 5 /* Max number of user toname wildcards */
  44.  
  45. #define MAX_DAYS_NO_USE_SPY 31 /* No match or no user on */
  46. #define SECONDS_WAITFOR_MODE 10
  47. #define LAST_CLIENTS 200 /* More than this on within prev. time gets secret */
  48. /* Jan Kautz 
  49. was:
  50.  
  51. #define BUF_LEN 256
  52. #define MSG_LEN 512
  53.  
  54. */
  55. #define BUF_LEN IRC_SUCKS_LINE_LENGTH
  56. #define MSG_LEN IRC_SUCKS_LINE_LENGTH+2
  57. #define REALLOC_SIZE 1024
  58.  
  59. #define FLAGS_WASOPER (1<<0)
  60. #define FLAGS_SIGNOFF_REMOVE (1<<1)
  61. #define FLAGS_NAME (1<<2)
  62. #define FLAGS_FROM_REG (1<<3)
  63. #define FLAGS_NEWS (1<<4)
  64. #define FLAGS_ON_THIS_SERVER (1<<5)
  65. #define FLAGS_REPEAT_UNTIL_TIMEOUT (1<<6)
  66. #define FLAGS_ALL_NICK_VALID (1<<7)
  67. #define FLAGS_SERVER_GENERATED_NOTICE (1<<8)
  68. #define FLAGS_NICK_AND_WILDCARD_VALID (1<<9)
  69. #define FLAGS_SERVER_GENERATED_DESTINATION (1<<10)
  70. #define FLAGS_DISPLAY_IF_RECEIVED (1<<11)
  71. #define FLAGS_DISPLAY_IF_CORRECT_FOUND (1<<12)
  72. #define FLAGS_DISPLAY_IF_DEST_REGISTER (1<<13)
  73. #define FLAGS_SEND_ONLY_IF_SENDER_ON_IRC (1<<14)
  74. #define FLAGS_NO_NICKCHANGE_SPY (1<<16)
  75. #define FLAGS_SEND_ONLY_IF_THIS_SERVER (1<<17)
  76. #define FLAGS_SEND_ONLY_IF_DESTINATION_OPER (1<<18)
  77. #define FLAGS_SEND_ONLY_IF_NICK_NOT_NAME (1<<19)
  78. #define FLAGS_SEND_ONLY_IF_NOT_EXCEPTION (1<<20)
  79. #define FLAGS_KEY_TO_OPEN_OPER_LOCKS (1<<21)
  80. #define FLAGS_FIND_CORRECT_DEST_SEND_ONCE (1<<22)
  81. #define FLAGS_DISPLAY_CHANNEL_DEST_REGISTER (1<<23)
  82. #define FLAGS_DISPLAY_SERVER_DEST_REGISTER (1<<24)
  83. #define FLAGS_PRIVATE_DISPLAYED (1<<25)
  84. #define FLAGS_REGISTER_NEWNICK (1<<26)
  85. #define FLAGS_NOTICE_RECEIVED_MESSAGE (1<<27)
  86. #define FLAGS_RETURN_CORRECT_DESTINATION (1<<28)
  87. #define FLAGS_NOT_QUEUE_REQUESTS (1<<29)
  88. #define FLAGS_NEWNICK_DISPLAYED (1<<30)
  89.  
  90. #define DupNewString(x,y) if (!StrEq(x,y)) { MyFree(x); DupString(x,y); }  
  91. #define MyEq(x,y) (!myncmp(x,y,strlen(x)))
  92. #define Usermycmp(x,y) mycmp(x,y)
  93. #define Key(sptr) KeyFlags(sptr,-1)
  94. #define Message(msgclient) get_msg(msgclient, 'm')
  95. #define IsOperHere(sptr) (IsOper(sptr) && MyConnect(sptr))
  96. #define NULLCHAR ((char *)0)
  97. #define SPY_CTRLCHAR 13
  98. #define DummyChar '~'
  99.  
  100. /* Using Message(msgclient) to get message part of *any* message
  101.    cause the spy function is an ugly hack saving log in this field - Jarle */
  102.  
  103. typedef struct MsgClient {
  104.             char *fromnick, *fromname, *fromhost, *tonick,
  105.                  *toname, *tohost, *message, *passwd;
  106.             long timeout, time, flags, id;
  107.           } aMsgClient;
  108.   
  109. static int note_mst = NOTE_MAXSERVER_TIME,
  110.            note_mum = NOTE_MAXUSER_MESSAGES,
  111.            note_msm = NOTE_MAXSERVER_MESSAGES,
  112.            note_msw = NOTE_MAXSERVER_WILDCARDS,
  113.            note_muw = NOTE_MAXUSER_WILDCARDS,
  114.            note_msf = NOTE_SAVE_FREQUENCY*60,
  115.            wildcard_index = 0,
  116.            toname_index = 0,
  117.            fromname_index = 0,
  118.            max_toname,
  119.            max_wildcards,
  120.            max_fromname,
  121.            m_id = 0,
  122.            changes_to_save = 0,
  123.            buffer_overload = 0;
  124.  
  125. static long old_clock = 0, old_clock_request = 0;
  126. static aMsgClient **ToNameList, **FromNameList, **WildCardList;
  127. extern aClient *client, *find_person(), *local[];
  128. extern int highest_fd;
  129. extern aChannel *channel;
  130. extern char *MyMalloc(), *MyRealloc(), *myctime();
  131. extern char *myctime();
  132. static char *ptr = "IRCnote", *note_save_filename_tmp, file_inited = 0;
  133.  
  134. static char *UserName(sptr)
  135. aClient *sptr;
  136. {
  137.  if (*(sptr->user->username) != DummyChar) return sptr->user->username;
  138.   else return sptr->user->username+1; 
  139. }
  140.  
  141. static int numeric(string)
  142. char *string;
  143. {
  144.  register char *c = string;
  145.  
  146.  while (*c) if (!isdigit(*c)) return 0; else c++;
  147.  return 1;
  148. }
  149.  
  150. static char *clean_spychar(string)
  151. char *string;
  152. {
  153.  static char buf[MSG_LEN]; 
  154.  char *c, *bp = buf;
  155.  
  156.  for (c = string; *c; c++) if (*c != SPY_CTRLCHAR) *bp++ = *c;
  157.  *bp = 0;
  158.  return buf;
  159. }
  160.  
  161. static char *myitoa(value)
  162. long value;
  163. {
  164.  static char buf[BUF_LEN]; 
  165.   
  166.  sprintf(buf, "%d", value);
  167.  return buf;
  168. }
  169.  
  170. static char *relative_time(seconds)
  171. long seconds;
  172. {
  173.  static char buf[20];
  174.  char *c;
  175.  long d, h, m;
  176.  
  177.  if (seconds < 0) seconds = 0; 
  178.  d = seconds / (3600*24);
  179.  seconds -= d*3600*24;
  180.  h = seconds / 3600;
  181.  seconds -= h*3600;
  182.  m = seconds / 60;
  183.  seconds -= m*60;
  184.  sprintf(buf, "%3dd:%2dh:%2dm", d, h, m);
  185.  c = buf; 
  186.  while (*c) {
  187.               if (*c == ' ') *c = '0';
  188.               c++;
  189.         } 
  190.  return buf;
  191. }
  192.  
  193. static char *mytime(value)
  194. long value;
  195. {
  196.  long clock;
  197.  time(&clock);
  198.  return (relative_time(clock-value));
  199. }
  200.  
  201. static char *get_msg(msgclient, field)
  202. aMsgClient *msgclient;
  203. char field;
  204. {
  205.  char *c = msgclient->message;
  206.  static char buf[MSG_LEN], *empty_char = "";
  207.  int t, p;
  208.  buf[0] = 0;
  209.  
  210.  switch(field) {
  211.      case 'n' : t = 1; break;
  212.      case 'u' : t = 2; break;
  213.      case 'h' : t = 3; break;
  214.      case 'r' : t = 4; break;
  215.      case '1' : t = 5; break;
  216.      case '2' : t = 6; break;
  217.      default: t = 0;
  218.    }
  219.  if (!t) {
  220.            while (*c) c++;
  221.            while (c != msgclient->message && *c != SPY_CTRLCHAR) c--;
  222.            if (*c == SPY_CTRLCHAR) c++;
  223.            return c;
  224.        }
  225.  while(t--) {
  226.       p = 0;
  227.       while (*c && *c != SPY_CTRLCHAR) buf[p++] = *c++;
  228.       if (!*c) return empty_char;
  229.       buf[p] = 0; c++;
  230.   };
  231.  return buf;
  232. }       
  233.  
  234. static void update_spymsg(msgclient)
  235. aMsgClient *msgclient;
  236. {
  237.  long clock, t;
  238.  char *buf, *empty = "-", ctrlbuf[2], mbuf[MSG_LEN]; 
  239.  
  240.  time (&clock);
  241.  mbuf[0] = 0; ctrlbuf[0] = SPY_CTRLCHAR; ctrlbuf[1] = 0;
  242.  
  243.  buf = get_msg(msgclient, 'n'); if (!*buf) buf = empty; 
  244.  strcat(mbuf, buf); strcat(mbuf, ctrlbuf); 
  245.  buf = get_msg(msgclient, 'u'); if (!*buf) buf = empty; 
  246.  strcat(mbuf, buf); strcat(mbuf, ctrlbuf); 
  247.  buf = get_msg(msgclient, 'h'); if (!*buf) buf = empty; 
  248.  strcat(mbuf, buf); strcat(mbuf, ctrlbuf); 
  249.  buf = get_msg(msgclient, 'r'); if (!*buf) buf = empty; 
  250.  strcat(mbuf, buf); strcat(mbuf, ctrlbuf); 
  251.  buf = get_msg(msgclient, '1'); if (!*buf) buf = empty; 
  252.  strcat(mbuf, buf); strcat(mbuf, ctrlbuf); 
  253.  strcat(mbuf, myitoa(clock-msgclient->time)); 
  254.  strcat(mbuf, ctrlbuf); t = MSG_LEN - strlen(mbuf) - 10;
  255.  strncat(mbuf, clean_spychar(Message(msgclient)), t);
  256.  strcat(mbuf, "\0");
  257.  DupNewString(msgclient->message, mbuf);
  258.  changes_to_save = 1;
  259. }
  260.  
  261. static char *wildcards(string)
  262. char *string;
  263. {
  264.  register char *c;
  265.  
  266.  for (c = string; *c; c++) if (*c == '*' || *c == '?') return(c);
  267.  return 0;
  268. }
  269.  
  270. static int only_wildcards(string)
  271. char *string;
  272. {
  273.  register char *c;
  274.  
  275.  for (c = string;*c;c++) 
  276.       if (*c != '*' && *c != '?') return 0;
  277.  return 1;
  278. }
  279.  
  280. static char *split_string(string, field, n)
  281. char *string;
  282. int field, n;
  283. {
  284.  static char buf[MSG_LEN], *empty_char = "";
  285.  char *c = string;
  286.  int p, t;
  287.  buf[0] = 0;
  288.  
  289.  while(field--) {
  290.       p = 0; t = n;
  291.       while (*c) {
  292.             if (*c == ' ' && (field || !--t)) break;
  293.             buf[p++] = *c++;
  294.     }
  295.       if (!*c) if (!field) {
  296.                   buf[p] = 0; return buf;
  297.                 } else return empty_char;
  298.       buf[p] = 0; c++;
  299.   };
  300.  return buf;
  301. }
  302.  
  303. static char *wild_fromnick(nick, msgclient)
  304. char *nick;
  305. aMsgClient *msgclient;
  306. {
  307.  static char buf[BUF_LEN];
  308.  char *msg, *c;
  309.  
  310.  if (msgclient->flags & FLAGS_ALL_NICK_VALID) {
  311.      strcpy(buf, "*"); return buf;
  312.    }
  313.  if (msgclient->flags & FLAGS_NICK_AND_WILDCARD_VALID
  314.      && MyEq(msgclient->fromnick, nick)) {
  315.      strcpy(buf, nick);
  316.      strcat(buf, "*"); return buf;
  317.   }
  318.  if (msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER) {
  319.     msg = Message(msgclient);
  320.     while (*msg == '%') { 
  321.            msg++; c = split_string(msg, 1, 1);
  322.            if (!mycmp(c, nick)) { 
  323.                strcpy(buf, "*");
  324.                return buf;
  325.         }
  326.            while (*msg && *msg != ' ') msg++; if (*msg) msg++;
  327.       }     
  328.   }
  329.  return NULLCHAR;
  330. }
  331.  
  332. static int number_fromname()
  333. {
  334.  register int t, nr = 0;
  335.  long clock;
  336.  
  337.  time (&clock);
  338.  for (t = 1;t <= fromname_index; t++) 
  339.       if (FromNameList[t]->timeout > clock
  340.           && !(FromNameList[t]->flags & FLAGS_SERVER_GENERATED_NOTICE)
  341.           && !(FromNameList[t]->flags & FLAGS_SERVER_GENERATED_DESTINATION)) 
  342.        nr++;
  343.  return nr;         
  344. }
  345.  
  346.  
  347. static int first_tnl_indexnode(name)
  348. char *name;
  349. {
  350.  register int s, t = toname_index+1, b = 0, tname;
  351.  aMsgClient *msgclient;
  352.  
  353.  if (!t) return 0;
  354.  while ((s = (b+t) >> 1) != b) {
  355.        msgclient = ToNameList[s];
  356.        tname = (msgclient->flags & FLAGS_NAME) ? 1 : 0;
  357.        if (mycmp(tname ? msgclient->toname : msgclient->tonick, name) < 0)
  358.         b = s; else t = s;
  359.   }
  360.  return t;
  361. }
  362.  
  363. static int last_tnl_indexnode(name)
  364. char *name;
  365. {
  366.  register int s, t = toname_index+1, b = 0, tname;
  367.  aMsgClient *msgclient;
  368.  
  369.  if (!t) return 0;
  370.  while ((s = (b+t) >> 1) != b) {
  371.        msgclient = ToNameList[s];
  372.        tname = (msgclient->flags & FLAGS_NAME) ? 1 : 0;
  373.        if (mycmp(tname ? msgclient->toname : msgclient->tonick, name) > 0)
  374.         t = s; else b = s;
  375.    }
  376.  return b;
  377. }
  378.  
  379. static int first_fnl_indexnode(fromname)
  380. char *fromname;
  381. {
  382.  register int s, t = fromname_index+1, b = 0;
  383.  
  384.  if (!t) return 0;
  385.  while ((s = (b+t) >> 1) != b)
  386.        if (mycmp(FromNameList[s]->fromname,fromname)<0) b = s; else t = s;
  387.  return t;
  388. }
  389.  
  390. static int last_fnl_indexnode(fromname)
  391. char *fromname;
  392. {
  393.  register int s, t = fromname_index+1, b = 0;
  394.  
  395.  if (!t) return 0;
  396.  while ((s = (b+t) >> 1) != b)
  397.        if (mycmp(FromNameList[s]->fromname,fromname)>0) t = s; else b = s;
  398.  return b;
  399. }
  400.  
  401. static int fnl_msgclient(msgclient)
  402. aMsgClient *msgclient;
  403. {
  404.  register int t, f, l;
  405.  aMsgClient **index_p;
  406.  
  407.  f = first_fnl_indexnode(msgclient->fromname);
  408.  l = last_fnl_indexnode(msgclient->fromname);
  409.  index_p = FromNameList + f;
  410.  
  411.  for (t = f; t <= l; t++) 
  412.       if (*(index_p++) == msgclient) return(t);
  413.  return 0;
  414. } 
  415.  
  416. static int tnl_msgclient(msgclient)
  417. aMsgClient *msgclient;
  418. {
  419.  register int t, f, l, tname;
  420.  aMsgClient **index_p;
  421.  
  422.  if (msgclient->flags & FLAGS_NAME 
  423.      || !wildcards(msgclient->tonick)) {
  424.      tname = (msgclient->flags & FLAGS_NAME) ? 1 : 0;
  425.      f = first_tnl_indexnode(tname ? msgclient->toname : msgclient->tonick);
  426.      l = last_tnl_indexnode(tname ? msgclient->toname : msgclient->tonick);
  427.      index_p = ToNameList + f;
  428.   } else {
  429.           index_p = WildCardList + 1;
  430.           f = 1; l = wildcard_index;
  431.       }
  432.  for (t = f; t <= l; t++) 
  433.       if (*(index_p++) == msgclient) return(t);
  434.  return 0;
  435. } 
  436.  
  437. static aMsgClient *new(passwd,fromnick,fromname,fromhost,tonick,
  438.                        toname,tohost,flags,timeout,time,message)
  439. char *passwd,*fromnick,*fromname,*fromhost,
  440.      *tonick,*toname,*tohost,*message;
  441. long timeout,time,flags;
  442. {
  443.  register aMsgClient **index_p;
  444.  register int t;
  445.  int allocate,first,last,n;
  446.  aMsgClient *msgclient;
  447.             
  448.  if (number_fromname() > note_msm) return NULL; 
  449.  if (fromname_index == max_fromname-1) {
  450.     max_fromname += REALLOC_SIZE;
  451.     allocate = max_fromname*sizeof(FromNameList)+1;
  452.     FromNameList = (aMsgClient **) MyRealloc((char *)FromNameList,allocate);
  453.   }
  454.  if (wildcard_index == max_wildcards-1) {
  455.     max_wildcards += REALLOC_SIZE;
  456.     allocate = max_wildcards*sizeof(WildCardList)+1;
  457.     WildCardList = (aMsgClient **) MyRealloc((char *)WildCardList,allocate);
  458.   }
  459.  if (toname_index == max_toname-1) {
  460.     max_toname += REALLOC_SIZE;
  461.     allocate = max_toname*sizeof(ToNameList)+1;
  462.     ToNameList = (aMsgClient **) MyRealloc((char *)ToNameList,allocate);
  463.   }
  464.  
  465.  /* Correction if corrupt format */
  466.  if (!(flags & FLAGS_SERVER_GENERATED_NOTICE)
  467.      && !(flags & FLAGS_SERVER_GENERATED_DESTINATION)) flags &= ~FLAGS_NAME; 
  468.  if (!wildcards(toname) && wildcards(tonick)) flags |= FLAGS_NAME; 
  469.  
  470.  msgclient = (aMsgClient *)MyMalloc(sizeof(struct MsgClient));
  471.  DupString(msgclient->passwd,passwd);
  472.  DupString(msgclient->fromnick,fromnick);
  473.  DupString(msgclient->fromname,fromname);
  474.  DupString(msgclient->fromhost,fromhost);
  475.  DupString(msgclient->tonick,tonick);
  476.  DupString(msgclient->toname,toname);
  477.  DupString(msgclient->tohost,tohost);
  478.  DupString(msgclient->message,message);
  479.  msgclient->flags = flags;
  480.  msgclient->timeout = timeout;
  481.  msgclient->time = time;
  482.  if (flags & FLAGS_NAME || !wildcards(tonick)) {
  483.     n = last_tnl_indexnode(flags & FLAGS_NAME ? toname : tonick) + 1;
  484.     index_p = ToNameList+toname_index;
  485.     toname_index++;t = toname_index-n;
  486.     while (t--) {
  487.                   index_p[1] = *index_p; index_p--;
  488.       }
  489.     ToNameList[n] = msgclient;
  490.   } else { 
  491.           wildcard_index++;
  492.           WildCardList[wildcard_index] = msgclient;
  493.      }
  494.  first = first_fnl_indexnode(fromname);
  495.  last = last_fnl_indexnode(fromname);
  496.  if (!(n = first)) n = 1;
  497.  index_p = FromNameList+n;
  498.  while (n <= last && mycmp(msgclient->fromhost,(*index_p)->fromhost)>0) {
  499.         index_p++;n++;
  500.    }
  501.  while (n <= last && mycmp(msgclient->fromnick,(*index_p)->fromnick)>=0){ 
  502.         index_p++;n++;
  503.    }
  504.  index_p = FromNameList+fromname_index;
  505.  fromname_index++;t = fromname_index-n; 
  506.  while (t--) {
  507.                index_p[1] = *index_p; index_p--;
  508.     }
  509.  FromNameList[n] = msgclient;
  510.  changes_to_save = 1;
  511.  msgclient->id = ++m_id;
  512.  return msgclient;
  513. }
  514.  
  515. static void r_code(string,fp)
  516. register char *string;
  517. register FILE *fp;
  518. {
  519.  register int v;
  520.  register char c, *cp = ptr;
  521.  
  522.  do {
  523.       if ((v = getc(fp)) == EOF) {
  524.          exit(-1);       
  525.        }
  526.       c = v;
  527.       *string = c-*cp;
  528.       if (!*++cp) cp = ptr;
  529.   } while (*string++);
  530. }
  531.  
  532. static void w_code(string,fp)
  533. register char *string;
  534. register FILE *fp;
  535. {
  536.  register char *cp = ptr;
  537.  
  538.  do {
  539.       putc((char)(*string+*cp),fp);
  540.       if (!*++cp) cp = ptr;
  541.   } while (*string++);
  542. }
  543.  
  544. static char *ltoa(i)
  545. register long i;
  546. {
  547.  static unsigned char c[20];
  548.  register unsigned char *p = c;
  549.  
  550.   do {
  551.       *p++ = (i&127) + 1;
  552.        i >>= 7;
  553.     } while(i > 0);
  554.     *p = 0;
  555.     return (char *) c;
  556. }
  557.  
  558. static long atol(c)
  559. register unsigned char *c;
  560. {
  561.  register long a = 0;
  562.  register unsigned char *s = c;
  563.  
  564.  while (*s != 0) ++s;
  565.  while (--s >= c) {
  566.         a <<= 7;
  567.         a += *s - 1;
  568.    }
  569.   return a;
  570. }
  571.  
  572. static void init_messages()
  573. {
  574.  FILE *fp,*fopen();
  575.  long timeout,atime,clock,flags;
  576.  int allocate;
  577.  char passwd[20], fromnick[BUF_LEN], fromname[BUF_LEN],
  578.       fromhost[BUF_LEN], tonick[BUF_LEN], toname[BUF_LEN],
  579.       tohost[BUF_LEN], message[MSG_LEN], buf[20];
  580.  
  581.  file_inited = 1;
  582.  max_fromname = max_toname = max_wildcards = REALLOC_SIZE;
  583.  allocate = REALLOC_SIZE*sizeof(FromNameList)+1;
  584.  ToNameList = (aMsgClient **) MyMalloc(allocate);
  585.  FromNameList = (aMsgClient **) MyMalloc(allocate);
  586.  WildCardList = (aMsgClient **) MyMalloc(allocate); 
  587.  note_save_filename_tmp = MyMalloc(strlen(NPATH)+6);
  588.  sprintf(note_save_filename_tmp,"%s.tmp",NPATH);
  589.  time(&clock);old_clock = clock;
  590.  fp = fopen(NPATH,"r");
  591.  if (!fp) return;
  592.  r_code(buf,fp);note_msm = atol(buf);
  593.  r_code(buf,fp);note_mum = atol(buf);
  594.  r_code(buf,fp);note_msw = atol(buf);
  595.  r_code(buf,fp);note_muw = atol(buf);
  596.  r_code(buf,fp);note_mst = atol(buf);
  597.  r_code(buf,fp);note_msf = atol(buf);
  598.  for (;;) {
  599.         r_code(passwd,fp);if (!*passwd) break;
  600.         r_code(fromnick,fp);r_code(fromname,fp);
  601.         r_code(fromhost,fp);r_code(tonick,fp);r_code(toname,fp);
  602.         r_code(tohost,fp);r_code(buf,fp),flags = atol(buf);
  603.         r_code(buf,fp);timeout = atol(buf);r_code(buf,fp);
  604.         atime = atol(buf);r_code(message,fp);
  605.         flags &= ~FLAGS_FROM_REG;
  606.         if (clock > 0 && *toname != DummyChar && *fromname != DummyChar)  
  607.             new(passwd,fromnick,fromname,fromhost,tonick,toname,
  608.                 tohost,flags,timeout,atime,message);
  609.   }
  610.  fclose(fp);
  611. }
  612.  
  613. static int numeric_host(host)
  614. char *host;
  615. {
  616.   while (*host) {
  617.         if (!isdigit(*host) && *host != '.') return 0;
  618.         host++;
  619.    } 
  620.  return 1;
  621. }
  622.  
  623. static int elements_inhost(host)
  624. char *host;
  625. {
  626.  int t = 0;
  627.  
  628.  while (*host) {
  629.        if (*host == '.') t++;
  630.        host++;
  631.     }
  632.  return t;
  633. }
  634.  
  635. static int valid_elements(host)
  636. char *host;
  637. {
  638.  register char *c = host;
  639.  register int t = 0, numeric = 0;
  640.  
  641.  while (*c) {
  642.         if (!isdigit(*c) && *c != '.' && *c != '*' && *c != '?' ) break;
  643.         c++;
  644.    } 
  645.  if (!*c) numeric = 1;
  646.  c = host;
  647.  if (numeric)
  648.      while (*c && *c != '*' && *c != '?') {
  649.             if (*c == '.') t++;
  650.             c++;
  651.       }
  652.   else {
  653.         while (*c++);
  654.         while (c != host && *c != '*' && *c != '?') { 
  655.                if (*c == '.') t++;
  656.                c--;
  657.           }
  658.     } 
  659.  if (!t && *c != '*' && *c != '?') t = 1;
  660.  return t;
  661. }
  662.  
  663. static char *local_host(host)
  664. char *host;
  665. {
  666.  static char buf[BUF_LEN];
  667.  char *buf_p = buf, *host_p;
  668.  int t, e;
  669.  
  670.  e = elements_inhost(host);
  671.  if (e < 2) return host;
  672.  if (!numeric_host(host)) {
  673.      if (!e) return host;
  674.      host_p = host;
  675.      if (e > 2) t = 2; else t = 1;
  676.     while (t--) { 
  677.            while (*host_p && *host_p != '.') {
  678.                   host_p++;buf_p++;
  679.              }
  680.            if (t && *host_p) { 
  681.               host_p++; buf_p++;
  682.         }
  683.       }
  684.      buf[0] = '*';
  685.      strcpy(buf+1, host_p);
  686.   } else {
  687.           host_p = buf;
  688.           strcpy(buf,host);
  689.           while (*host_p) host_p++;    
  690.           t = 2;
  691.           while(t--) {
  692.                while (host_p != buf && *host_p-- != '.'); 
  693.          }
  694.            host_p+=2;
  695.            *host_p++ = '*';
  696.            *host_p = 0;
  697.        }
  698.   return buf;
  699. }
  700.  
  701. static int host_check(host1,host2)
  702. char *host1,*host2;
  703. {
  704.  char buf[BUF_LEN];
  705.  
  706.  if (numeric_host(host1) != numeric_host(host2)) return 0;
  707.  strcpy(buf,local_host(host1));
  708.  if (!mycmp(buf,local_host(host2))) return 1;
  709.  return 0;
  710. }
  711.  
  712. static long timegm(tm)
  713. struct tm *tm;
  714. {
  715.  static int days[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
  716.  register long mday = tm->tm_mday-1, mon = tm->tm_mon, year = tm->tm_year-70;
  717.  
  718.  mday+=((year+2) >> 2)+days[mon];
  719.  if (mon < 2 && !((year+2) & 3)) mday--;
  720.  return tm->tm_sec+tm->tm_min*60+tm->tm_hour*3600+mday*86400+year*31536000;
  721. }
  722.  
  723. static long set_date(sptr,time_s)
  724. aClient *sptr;
  725. char *time_s;
  726. {
  727.  struct tm *tm;
  728.  long clock,tm_gmtoff;
  729.  int t,t1,month,date,year;
  730.  char *c = time_s,arg[3][BUF_LEN];
  731.  static char *months[] = {
  732.     "January",    "February",    "March",    "April",
  733.     "May",            "June",            "July",            "August",
  734.     "September",    "October",    "November",    "December"
  735.     }; 
  736.  
  737.  time (&clock);
  738.  tm = localtime(&clock);
  739.  tm_gmtoff = timegm(tm)-clock;
  740.  tm->tm_sec = 0;
  741.  tm->tm_min = 0;
  742.  tm->tm_hour = 0;
  743.  if (*time_s == '-') {
  744.     if (!time_s[1]) return 0;
  745.     return timegm(tm)-tm_gmtoff-3600*24*atoi(time_s+1);
  746.   }
  747.  for (t = 0;t<3;t++) {
  748.       t1 = 0;
  749.       while (*c && *c != '/' && *c != '.' && *c != '-')
  750.              arg[t][t1++] = *c++;
  751.       arg[t][t1] = 0;
  752.       if (*c) c++;
  753.   } 
  754.  
  755.  date = atoi(arg[0]);
  756.  if (*arg[0] && (date<1 || date>31)) {
  757.      sendto_one(sptr,"NOTICE %s :#?# Unknown date",sptr->name);
  758.      return -1;
  759.   }
  760.  month = atoi(arg[1]);
  761.  if (month) month--;
  762.   else for (t = 0;t<12;t++) {
  763.             if (MyEq(arg[1],months[t])) { 
  764.                 month = t;break;
  765.              } 
  766.             month = -1;
  767.         }
  768.  if (*arg[1] && (month<0 || month>11)) {
  769.       sendto_one(sptr,"NOTICE %s :#?# Unknown month",sptr->name);
  770.       return -1; 
  771.   }       
  772.  year = atoi(arg[2]);
  773.  if (*arg[2] && (year<71 || year>99)) {
  774.      sendto_one(sptr,"NOTICE %s :#?# Unknown year",sptr->name);
  775.      return -1;
  776.    }
  777.  tm->tm_mday = date;
  778.  if (*arg[1]) tm->tm_mon = month;
  779.  if (*arg[2]) tm->tm_year = year;
  780.  return timegm(tm)-tm_gmtoff;
  781. }
  782.  
  783. static int local_check(sptr, msgclient, passwd, flags, tonick,
  784.                    toname, tohost, time_l, id)
  785. aClient *sptr;
  786. aMsgClient *msgclient;
  787. char *passwd, *tonick, *toname, *tohost;
  788. long flags,time_l;
  789. int id;
  790. {
  791.  if (msgclient->flags == flags 
  792.      && (!id || id == msgclient->id)
  793.      && !Usermycmp(UserName(sptr),msgclient->fromname)
  794.      && (!mycmp(sptr->name, msgclient->fromnick)
  795.          || wild_fromnick(sptr->name, msgclient))
  796.      && (!time_l || msgclient->time >= time_l 
  797.                     && msgclient->time < time_l+24*3600)
  798.      && !matches(tonick,msgclient->tonick)
  799.      && !matches(toname,msgclient->toname)
  800.      && !matches(tohost,msgclient->tohost)
  801.      && (*msgclient->passwd == '*' && !msgclient->passwd[1]
  802.          || StrEq(passwd,msgclient->passwd))
  803.      &&  host_check(sptr->user->host,msgclient->fromhost)) return 1;
  804.  return 0;
  805. }
  806.  
  807. static int send_flag(flags)
  808. long flags;
  809. {
  810.   if (flags & FLAGS_RETURN_CORRECT_DESTINATION
  811.       || flags & FLAGS_DISPLAY_IF_CORRECT_FOUND
  812.       || flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS
  813.       || flags & FLAGS_DISPLAY_IF_DEST_REGISTER
  814.       || flags & FLAGS_SERVER_GENERATED_DESTINATION
  815.       || flags & FLAGS_NOT_QUEUE_REQUESTS
  816.       || flags & FLAGS_NEWS
  817.       || flags & FLAGS_REPEAT_UNTIL_TIMEOUT
  818.          && !(flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE)) return 0;
  819.   return 1;
  820. }
  821.  
  822. static void display_flags(flags, c, mode)
  823. long flags;
  824. char *c, mode;
  825. {
  826.  char t = 0;
  827.  int send = 0;
  828.  
  829.  if (send_flag(flags)) send = 1;
  830.  if (mode != 'q') {
  831.      if (send) c[t++] = '['; else c[t++] = '<';
  832.   } else c[t++] = '+';
  833.  if (mode != 'q' && (flags & FLAGS_WASOPER)) c[t++] = 'O';
  834.  if (flags & FLAGS_SERVER_GENERATED_DESTINATION) c[t++] = 'H';
  835.  if (flags & FLAGS_ALL_NICK_VALID) c[t++] = 'C';
  836.  if (flags & FLAGS_SERVER_GENERATED_NOTICE) c[t++] = 'G';
  837.  if (flags & FLAGS_DISPLAY_IF_RECEIVED) c[t++] = 'D';
  838.  if (flags & FLAGS_DISPLAY_IF_CORRECT_FOUND) c[t++] = 'L';
  839.  if (flags & FLAGS_NEWS) c[t++] = 'S';
  840.  if (flags & FLAGS_DISPLAY_IF_DEST_REGISTER) c[t++] = 'X';
  841.  if (flags & FLAGS_DISPLAY_CHANNEL_DEST_REGISTER) c[t++] = 'J';
  842.  if (flags & FLAGS_DISPLAY_SERVER_DEST_REGISTER) c[t++] = 'A';
  843.  if (flags & FLAGS_REPEAT_UNTIL_TIMEOUT) c[t++] = 'R';
  844.  if (flags & FLAGS_SIGNOFF_REMOVE) c[t++] = 'M';
  845.  if (flags & FLAGS_NO_NICKCHANGE_SPY) c[t++] = 'U';
  846.  if (flags & FLAGS_NICK_AND_WILDCARD_VALID) c[t++] = 'V';
  847.  if (flags & FLAGS_SEND_ONLY_IF_THIS_SERVER) c[t++] = 'I';
  848.  if (flags & FLAGS_SEND_ONLY_IF_NICK_NOT_NAME) c[t++] = 'Q';
  849.  if (flags & FLAGS_SEND_ONLY_IF_NOT_EXCEPTION) c[t++] = 'E';
  850.  if (flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS) c[t++] = 'K';
  851.  if (flags & FLAGS_SEND_ONLY_IF_SENDER_ON_IRC) c[t++] = 'Y';
  852.  if (flags & FLAGS_NOTICE_RECEIVED_MESSAGE) c[t++] = 'N';
  853.  if (flags & FLAGS_RETURN_CORRECT_DESTINATION) c[t++] = 'F';
  854.  if (flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE) c[t++] = 'B';
  855.  if (flags & FLAGS_REGISTER_NEWNICK) c[t++] = 'T';
  856.  if (flags & FLAGS_SEND_ONLY_IF_DESTINATION_OPER) c[t++] = 'W';
  857.  if (flags & FLAGS_NOT_QUEUE_REQUESTS) c[t++] = 'Z';
  858.  if (t == 1) c[t++] = '-';
  859.  if (mode != 'q') {
  860.      if (send) c[t++] = ']'; else c[t++] = '>';
  861.   }
  862.  c[t] = 0;
  863. }
  864.  
  865. static void remove_msg(msgclient)
  866. aMsgClient *msgclient;
  867. {
  868.  register aMsgClient **index_p;
  869.  register int t;
  870.  int n,allocate;
  871.  
  872.  n = tnl_msgclient(msgclient);
  873.  if (msgclient->flags & FLAGS_NAME 
  874.      || !wildcards(msgclient->tonick)) {
  875.      index_p = ToNameList+n; 
  876.      t = toname_index-n;   
  877.      while (t--) {
  878.                    *index_p = index_p[1]; index_p++;
  879.        }
  880.      ToNameList[toname_index] = 0;
  881.      toname_index--;
  882.   } else { 
  883.           index_p = WildCardList+n; 
  884.           t = wildcard_index-n;
  885.           while (t--) {
  886.                         *index_p = index_p[1]; index_p++;
  887.             }
  888.           WildCardList[wildcard_index] = 0;
  889.           wildcard_index--;
  890.      }
  891.  n = fnl_msgclient(msgclient);
  892.  index_p = FromNameList+n;t = fromname_index-n;
  893.  while (t--) {
  894.                 *index_p = index_p[1]; index_p++;
  895.    }
  896.  FromNameList[fromname_index] = 0;
  897.  fromname_index--;
  898.  MyFree(msgclient->passwd);
  899.  MyFree(msgclient->fromnick);
  900.  MyFree(msgclient->fromname);
  901.  MyFree(msgclient->fromhost);
  902.  MyFree(msgclient->tonick);
  903.  MyFree(msgclient->toname);
  904.  MyFree(msgclient->tohost);
  905.  MyFree(msgclient->message);
  906.  MyFree((char *)msgclient);
  907.  changes_to_save = 1;
  908.  if (max_fromname - fromname_index > REALLOC_SIZE *2) {
  909.     max_fromname -= REALLOC_SIZE; 
  910.     allocate = max_fromname*sizeof(FromNameList)+1;
  911.     FromNameList = (aMsgClient **) MyRealloc((char *)FromNameList,allocate);
  912.   }
  913.  if (max_wildcards - wildcard_index > REALLOC_SIZE * 2) {
  914.     max_wildcards -= REALLOC_SIZE;
  915.     allocate = max_wildcards*sizeof(WildCardList)+1;
  916.     WildCardList = (aMsgClient **) MyRealloc((char *)WildCardList,allocate);
  917.   }
  918.  if (max_toname - toname_index > REALLOC_SIZE * 2) {
  919.     max_toname -= REALLOC_SIZE;
  920.     allocate = max_toname*sizeof(ToNameList)+1;
  921.     ToNameList = (aMsgClient **) MyRealloc((char *)ToNameList,allocate);
  922.   }
  923. }
  924.  
  925. static int KeyFlags(sptr, flags) 
  926. aClient *sptr;
  927. long flags;
  928. {
  929.  int t,last, first_tnl, last_tnl, nick_list = 1;
  930.  long clock;
  931.  aMsgClient **index_p,*msgclient; 
  932.  
  933.  t = first_tnl_indexnode(sptr->name);
  934.  last = last_tnl_indexnode(sptr->name);
  935.  first_tnl = first_tnl_indexnode(UserName(sptr));
  936.  last_tnl = last_tnl_indexnode(UserName(sptr));
  937.  index_p = ToNameList;
  938.  time (&clock);
  939.  while (1) {
  940.      while (last && t <= last) {
  941.         msgclient = index_p[t];
  942.         if (msgclient->flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS
  943.         && msgclient->flags & flags
  944.         && !matches(msgclient->tonick,sptr->name)
  945.         && !matches(msgclient->toname,UserName(sptr))
  946.         && !matches(msgclient->tohost,sptr->user->host)) return 1;
  947.             t++;
  948.     }
  949.      if (index_p == ToNameList) {
  950.          if (nick_list) {
  951.              nick_list = 0; t = first_tnl; last = last_tnl;
  952.       } else {
  953.                    index_p = WildCardList;
  954.                    t = 1; last = wildcard_index;
  955.           }
  956.       } else return 0;
  957.  }
  958. }
  959.  
  960. static int set_flags(sptr, string, flags, mode, type)
  961. aClient *sptr;
  962. char *string, mode, *type;
  963. long *flags;
  964. {
  965.  char *c,on,buf[40],cu;
  966.  int op,uf = 0;
  967.  
  968.  op = IsOperHere(sptr) ? 1:0; 
  969.  for (c = string; *c; c++) {
  970.       if (*c == '+') { 
  971.           on = 1;continue;
  972.        } 
  973.       if (*c == '-') { 
  974.           on = 0;continue;
  975.        } 
  976.       cu = islower(*c)?toupper(*c):*c;
  977.       switch (cu) {
  978.               case 'S': if (on) *flags |= FLAGS_NEWS;
  979.                          else *flags &= ~FLAGS_NEWS;
  980.                         break;             
  981.               case 'R': if (on) *flags |= FLAGS_REPEAT_UNTIL_TIMEOUT;
  982.                          else *flags &= ~FLAGS_REPEAT_UNTIL_TIMEOUT;
  983.                         break;        
  984.               case 'U': if (on) *flags |= FLAGS_NO_NICKCHANGE_SPY;
  985.                          else *flags &= ~FLAGS_NO_NICKCHANGE_SPY;
  986.                         break;             
  987.               case 'V': if (on) *flags |= FLAGS_NICK_AND_WILDCARD_VALID;
  988.                          else *flags &= ~FLAGS_NICK_AND_WILDCARD_VALID;
  989.                         break;             
  990.               case 'I': if (on) *flags |= FLAGS_SEND_ONLY_IF_THIS_SERVER; 
  991.                          else *flags &= ~FLAGS_SEND_ONLY_IF_THIS_SERVER;
  992.                         break;             
  993.               case 'W': if (on) *flags |= FLAGS_SEND_ONLY_IF_DESTINATION_OPER;
  994.                          else *flags &= ~FLAGS_SEND_ONLY_IF_DESTINATION_OPER;
  995.                         break;             
  996.               case 'Q': if (on) *flags |= FLAGS_SEND_ONLY_IF_NICK_NOT_NAME;
  997.                          else *flags &= ~FLAGS_SEND_ONLY_IF_NICK_NOT_NAME;
  998.                         break;             
  999.               case 'E': if (on) *flags |= FLAGS_SEND_ONLY_IF_NOT_EXCEPTION; 
  1000.                          else *flags &= ~FLAGS_SEND_ONLY_IF_NOT_EXCEPTION;
  1001.                         break;             
  1002.               case 'Y': if (on) *flags |= FLAGS_SEND_ONLY_IF_SENDER_ON_IRC;
  1003.                          else *flags &= FLAGS_SEND_ONLY_IF_SENDER_ON_IRC;
  1004.                         break;             
  1005.               case 'N': if (on) *flags |= FLAGS_NOTICE_RECEIVED_MESSAGE;
  1006.                          else *flags &= ~FLAGS_NOTICE_RECEIVED_MESSAGE;
  1007.                         break;             
  1008.               case 'D': if (on) *flags |= FLAGS_DISPLAY_IF_RECEIVED;
  1009.                          else *flags &= ~FLAGS_DISPLAY_IF_RECEIVED;
  1010.                         break;             
  1011.               case 'F': if (on) *flags |= FLAGS_RETURN_CORRECT_DESTINATION;
  1012.                          else *flags &= ~FLAGS_RETURN_CORRECT_DESTINATION;
  1013.                         break;
  1014.               case 'L': if (on) *flags |= FLAGS_DISPLAY_IF_CORRECT_FOUND;
  1015.                          else *flags &= ~FLAGS_DISPLAY_IF_CORRECT_FOUND;
  1016.                         break;
  1017.               case 'X':  if (on) *flags |= FLAGS_DISPLAY_IF_DEST_REGISTER;
  1018.                           else *flags &= ~FLAGS_DISPLAY_IF_DEST_REGISTER;
  1019.                         break;
  1020.               case 'J':  if (on) *flags |= FLAGS_DISPLAY_CHANNEL_DEST_REGISTER;
  1021.                           else *flags &= ~FLAGS_DISPLAY_CHANNEL_DEST_REGISTER;
  1022.                         break;
  1023.               case 'A':  if (on) *flags |= FLAGS_DISPLAY_SERVER_DEST_REGISTER;
  1024.                           else *flags &= ~FLAGS_DISPLAY_SERVER_DEST_REGISTER;
  1025.                         break;
  1026.               case 'C': if (on) *flags |= FLAGS_ALL_NICK_VALID;
  1027.                          else *flags &= ~FLAGS_ALL_NICK_VALID;
  1028.                         break;
  1029.               case 'M': if (on) *flags |= FLAGS_SIGNOFF_REMOVE;
  1030.                          else *flags &= ~FLAGS_SIGNOFF_REMOVE;
  1031.                         break;
  1032.               case 'T': if (KeyFlags(sptr,FLAGS_REGISTER_NEWNICK) 
  1033.                             || op || mode == 'd' || !on) {
  1034.                             if (on) *flags |= FLAGS_REGISTER_NEWNICK;
  1035.                              else *flags &= ~FLAGS_REGISTER_NEWNICK;
  1036.                          } else buf[uf++] = cu;
  1037.                         break;
  1038.               case 'B': if (KeyFlags(sptr,FLAGS_FIND_CORRECT_DEST_SEND_ONCE)
  1039.                             || op || mode == 'd' || !on) {
  1040.                             if (on) 
  1041.                                *flags |= FLAGS_FIND_CORRECT_DEST_SEND_ONCE;
  1042.                              else *flags &= ~FLAGS_FIND_CORRECT_DEST_SEND_ONCE;
  1043.                          } else buf[uf++] = cu;
  1044.                         break;
  1045.               case 'K': if (op || mode == 'd' || !on) {
  1046.                             if (on) *flags |= FLAGS_KEY_TO_OPEN_OPER_LOCKS;
  1047.                              else *flags &= ~FLAGS_KEY_TO_OPEN_OPER_LOCKS;
  1048.                          } else buf[uf++] = cu;
  1049.                         break;
  1050.               case 'O': if (mode == 'd') {
  1051.                            if (on) *flags |= FLAGS_WASOPER;
  1052.                             else *flags &= ~FLAGS_WASOPER;
  1053.                         } else buf[uf++] = cu;
  1054.                          break;
  1055.               case 'G': if (mode == 'd') {
  1056.                            if (on) *flags |= FLAGS_SERVER_GENERATED_NOTICE;
  1057.                              else *flags &= ~FLAGS_SERVER_GENERATED_NOTICE;
  1058.                  } else buf[uf++] = cu;
  1059.                         break;
  1060.               case 'H': if (mode == 'd') {
  1061.                            if (on) 
  1062.                                *flags |= FLAGS_SERVER_GENERATED_DESTINATION;
  1063.                             else *flags &= ~FLAGS_SERVER_GENERATED_DESTINATION;
  1064.                           } else buf[uf++] = cu;
  1065.                         break;
  1066.               case 'Z': if (KeyFlags(sptr,FLAGS_NOT_QUEUE_REQUESTS)
  1067.                             || op || mode == 'd' || !on) {
  1068.                              if (on) *flags |= FLAGS_NOT_QUEUE_REQUESTS;
  1069.                   else *flags &= ~FLAGS_NOT_QUEUE_REQUESTS;
  1070.                          } else buf[uf++] = cu;
  1071.                          break;  
  1072.               default:  buf[uf++] = cu;
  1073.         } 
  1074.   }
  1075.  buf[uf] = 0;
  1076.  if (uf) {
  1077.      sendto_one(sptr,"NOTICE %s :#?# Unknown flag%s: %s %s",sptr->name,
  1078.                 uf> 1  ? "s" : "",buf,type);
  1079.      return 0;
  1080.   }
  1081.  if (mode == 's') {
  1082.     if (*flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS)
  1083.         sendto_one(sptr,"NOTICE %s :### %s", sptr->name,
  1084.                    "WARNING: Recipient got keys to unlock the secret portal;");
  1085.      else if (*flags & FLAGS_NOT_QUEUE_REQUESTS)
  1086.               sendto_one(sptr,"NOTICE %s :### %s",sptr->name,
  1087.                          "WARNING: Recipient can't queue requests;");
  1088.       else if (*flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE
  1089.                && *flags & FLAGS_REPEAT_UNTIL_TIMEOUT
  1090.                && send_flag(*flags)) 
  1091.                sendto_one(sptr,"NOTICE %s :### %s",sptr->name,
  1092.                          "WARNING: Broadcast message in action;");
  1093.  }
  1094.  return 1;
  1095. }
  1096.  
  1097. static void split(string, nick, name, host)
  1098. char *string, *nick, *name, *host;
  1099. {
  1100.  char *np = string, *fill;
  1101.  
  1102.  *nick = 0; *name = 0; *host = 0;
  1103.  fill = nick;
  1104.  while (*np) { 
  1105.         *fill = *np;
  1106.         if (*np == '!') { 
  1107.            *fill = 0; fill = name;
  1108.      } else if (*np == '@') { 
  1109.                     *fill = 0; fill = host;
  1110.               } else fill++;
  1111.         np++;
  1112.    } 
  1113.  *fill = 0;       
  1114.  if (!*nick) { *nick = '*'; nick[1] = 0; } 
  1115.  if (!*name) { *name = '*'; name[1] = 0; } 
  1116.  if (!*host) { *host = '*'; host[1] = 0; } 
  1117. }
  1118.  
  1119. void save_messages()
  1120. {
  1121.  aMsgClient *msgclient;
  1122.  long clock, gflags = 0;
  1123.  static long t2 = MAX_DAYS_NO_USE_SPY*3600*24;
  1124.  FILE *fp,*fopen();
  1125.  int t = 1;
  1126.  char *c, mbuf[MSG_LEN], dibuf[40];
  1127.  
  1128.  if (!file_inited || !changes_to_save) return;
  1129.  time(&clock);
  1130.  gflags |= FLAGS_WASOPER; gflags |= FLAGS_NAME;
  1131.  gflags |= FLAGS_SERVER_GENERATED_NOTICE;
  1132.  
  1133.  while (fromname_index && t <= fromname_index) {
  1134.         msgclient = FromNameList[t];
  1135.         if (msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER) {
  1136.             *mbuf = '\0';
  1137.             while (!*mbuf) {
  1138.                    strcpy(mbuf, get_msg(msgclient, '2'));
  1139.                    if (!*mbuf) update_spymsg(msgclient);
  1140.           }
  1141.             if (*get_msg(msgclient, 'n') == '-') {
  1142.               if (clock > msgclient->time + t2)
  1143.                   msgclient->timeout = 0; 
  1144.         } else {
  1145.                      if (clock > msgclient->time + t2 + atoi(mbuf))
  1146.                          msgclient->timeout = 0;
  1147.                 } 
  1148.         }       
  1149.        if (clock > msgclient->timeout) {
  1150.            display_flags(msgclient->flags, dibuf, 'q');
  1151.            sprintf(mbuf,"Expired: /Note User -%d %s %s!%s@%s %s", 
  1152.                    (int)((msgclient->timeout - msgclient->time)/3600),
  1153.                    dibuf, msgclient->tonick, msgclient->toname, 
  1154.                    msgclient->tohost, Message(msgclient));
  1155.            c = wild_fromnick(msgclient->fromnick, msgclient);
  1156.            if (msgclient->timeout
  1157.                && !(msgclient->flags & FLAGS_SERVER_GENERATED_NOTICE)
  1158.                && !(msgclient->flags & FLAGS_SERVER_GENERATED_DESTINATION))
  1159.              new(msgclient->passwd,"SERVER","-","-",
  1160.                  c ? c : msgclient->fromnick, msgclient->fromname,
  1161.                  local_host(msgclient->fromhost), gflags,
  1162.                  24*7*3600+clock, clock, mbuf);
  1163.            remove_msg(msgclient); continue;
  1164.         }  
  1165.        t++;
  1166.    }
  1167.  changes_to_save = 0;
  1168.  fp = fopen(note_save_filename_tmp,"w");
  1169.  if (!fp) {
  1170.     sendto_ops("Can't open for write: %s", NPATH);
  1171.     return;
  1172.  }
  1173.  w_code(ltoa((long)note_msm),fp);
  1174.  w_code(ltoa((long)note_mum),fp);
  1175.  w_code(ltoa((long)note_msw),fp);
  1176.  w_code(ltoa((long)note_muw),fp);
  1177.  w_code(ltoa((long)note_mst),fp);
  1178.  w_code(ltoa((long)note_msf),fp);
  1179.  t = 1;
  1180.  while (fromname_index && t <= fromname_index) {
  1181.      msgclient = FromNameList[t];
  1182.      w_code(msgclient->passwd,fp),w_code(msgclient->fromnick,fp);
  1183.      w_code(msgclient->fromname,fp);w_code(msgclient->fromhost,fp);
  1184.      w_code(msgclient->tonick,fp),w_code(msgclient->toname,fp);
  1185.      w_code(msgclient->tohost,fp),
  1186.      w_code(ltoa(msgclient->flags),fp);
  1187.      w_code(ltoa(msgclient->timeout),fp);
  1188.      w_code(ltoa(msgclient->time),fp);
  1189.      w_code(msgclient->message,fp);
  1190.      t++;
  1191.   }
  1192.  w_code("",fp);
  1193.  fclose(fp);
  1194.  fp = fopen(note_save_filename_tmp,"r");
  1195.  if (!fp || getc(fp) == EOF) {
  1196.     sendto_ops("Error writing: %s", note_save_filename_tmp);
  1197.     if (fp) fclose(fp); return; 
  1198.   }
  1199.  fclose (fp);
  1200.  unlink(NPATH);link(note_save_filename_tmp,NPATH);
  1201.  unlink(note_save_filename_tmp);
  1202.  chmod(NPATH, 432);
  1203. }
  1204.  
  1205. static char *flag_send(aptr, sptr, qptr, nick, msgclient, mode, chn)
  1206. aClient *aptr, *sptr, *qptr;
  1207. char *nick, mode, *chn;
  1208. aMsgClient *msgclient;
  1209. {
  1210.  int t, t1, exception;
  1211.  static char ebuf[BUF_LEN];
  1212.  char *c, *message;
  1213.  
  1214.  message = Message(msgclient);
  1215.  
  1216.  if (MyConnect(sptr)) msgclient->flags |= FLAGS_ON_THIS_SERVER;
  1217.      else if (mode != 'e' && mode != 'q') 
  1218.               msgclient->flags &= ~FLAGS_ON_THIS_SERVER;
  1219.  if (!(msgclient->flags & FLAGS_ON_THIS_SERVER) 
  1220.        && msgclient->flags & FLAGS_SEND_ONLY_IF_THIS_SERVER
  1221.      || (msgclient->flags & FLAGS_SEND_ONLY_IF_NICK_NOT_NAME 
  1222.          && mode == 'v' && StrEq(nick,UserName(sptr)))
  1223.      || (!IsOper(sptr) &&
  1224.          msgclient->flags & FLAGS_SEND_ONLY_IF_DESTINATION_OPER)
  1225.      || (mode == 'v' || mode == 'j' || mode == 'l') && qptr == aptr) 
  1226.         return NULLCHAR;
  1227.  
  1228.  if (msgclient->flags & FLAGS_SEND_ONLY_IF_NOT_EXCEPTION) {
  1229.      c = message;
  1230.      for(;;) {
  1231.          exception = 0;t = t1 = 0 ;ebuf[0] = 0;
  1232.          while (*c != '!') {
  1233.                 if (!*c || *c == ' ' || t > BUF_LEN) return message;
  1234.                 ebuf[t++] = *c++;
  1235.            }
  1236.          if (!*c++) return message;
  1237.          t1 += t;ebuf[t] = 0;
  1238.          if (!matches(ebuf,nick)) exception = 1;
  1239.          t=0;ebuf[0] = 0;            
  1240.          while (*c != '@') {
  1241.                 if (!*c || *c == ' ' || t > BUF_LEN) return message;
  1242.                 ebuf[t++] = *c++;
  1243.            }
  1244.          if (!*c++) return message;
  1245.          t1 += t;ebuf[t] = 0;
  1246.          if (matches(ebuf,UserName(sptr))) exception = 0;
  1247.          t=0;ebuf[0] = 0;
  1248.          if (*c == ' ') return message;
  1249.          while (*c && *c != ' ') {
  1250.               if (t > BUF_LEN) return message;
  1251.               ebuf[t++] = *c++;
  1252.            } 
  1253.          if (*c) c++; t1 += t;ebuf[t] = 0; message += t1+2;
  1254.          if (*c) message++;
  1255.          if (exception && !matches(ebuf,sptr->user->host)) return NULLCHAR;
  1256.      }
  1257.    }
  1258.  return message;
  1259. }
  1260.  
  1261. static char *check_flags(aptr, sptr, qptr, nick, newnick, qptr_nick,
  1262.                          msgclient, repeat, gnew, mode, sptr_chn)
  1263. aClient *aptr, *sptr, *qptr;
  1264. aMsgClient *msgclient;
  1265. char *nick, *newnick, *qptr_nick, mode;
  1266. int *repeat, *gnew;
  1267. aChannel *sptr_chn;
  1268. {
  1269.  char *c, mbuf[MSG_LEN], buf[BUF_LEN], ebuf[BUF_LEN], *message, 
  1270.       wmode[2], *spy_channel = NULLCHAR, *spy_server = NULLCHAR;
  1271.  long clock, gflags;
  1272.  int t, t1, t2, last, secret = 1, send = 1, right_tonick = 0, 
  1273.      show_channel = 0, sptr_chn_exits = 0;
  1274.  aMsgClient *fmsgclient;
  1275.  aChannel *chptr;
  1276.  Link *link;
  1277.  
  1278.  if (mode != 'g') {
  1279.     if (!(msgclient->flags & FLAGS_FROM_REG)) qptr = 0;
  1280.      else for (qptr = client; qptr; qptr = qptr->next)
  1281.             if (qptr->user && 
  1282.                 (!mycmp(qptr->name,msgclient->fromnick)
  1283.                 || wild_fromnick(qptr->name, msgclient))
  1284.                 && !Usermycmp(UserName(qptr),msgclient->fromname)
  1285.                 && host_check(qptr->user->host,msgclient->fromhost)) 
  1286.                 break; 
  1287.     if (!qptr) msgclient->flags &= ~FLAGS_FROM_REG;
  1288.   }
  1289.  if (!mycmp(nick, msgclient->tonick)
  1290.      || !mycmp(nick, get_msg(msgclient, 'n'))) right_tonick = 1;
  1291.  if (!sptr->user->channel && !IsInvisible(sptr)) secret = 0;
  1292.  if (secret && !IsInvisible(sptr)) 
  1293.   for (link = sptr->user->channel; link; link = link->next)
  1294.        if (!SecretChannel(link->value.chptr)) secret = 0;
  1295.  if (mode == 'a' || buffer_overload) secret = 1;
  1296.  wmode[1] = 0; *repeat = 0; *gnew = 0; 
  1297.  
  1298.  if (!send_flag(msgclient->flags)) send = 0; 
  1299.  if (mode == 'a' || mode == 'v'
  1300.      || mode == 'c' && !wildcards(msgclient->tonick)
  1301.      || mode == 'g' && (!wild_fromnick(qptr->name, msgclient)
  1302.                         || StrEq(qptr_nick, qptr->name))) {
  1303.      msgclient->flags &= ~FLAGS_NEWNICK_DISPLAYED; 
  1304.      msgclient->flags &= ~FLAGS_PRIVATE_DISPLAYED;
  1305.   }
  1306.  message = flag_send(aptr, sptr, qptr, nick, msgclient, mode, sptr_chn);
  1307.  if (!message
  1308.      || (msgclient->flags & FLAGS_SERVER_GENERATED_NOTICE) && 
  1309.         (mode != 'a' && mode != 'v')
  1310.      || msgclient->flags & FLAGS_SEND_ONLY_IF_SENDER_ON_IRC && !qptr) { 
  1311.     *repeat = 1; return NULLCHAR; 
  1312.   }
  1313.  if ((!secret || right_tonick) 
  1314.      && msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER) {
  1315.      time(&clock);
  1316.      mbuf[0] = 0; buf[0] = SPY_CTRLCHAR; buf[1] = 0;
  1317.      strcat(mbuf, clean_spychar(nick)); strcat(mbuf, buf);
  1318.      strcat(mbuf, clean_spychar(UserName(sptr))); strcat(mbuf, buf);
  1319.      strcat(mbuf, clean_spychar(sptr->user->host)); strcat(mbuf, buf);
  1320.      strcat(mbuf, clean_spychar(sptr->info)); strcat(mbuf, buf);
  1321.      strcat(mbuf, myitoa(clock-msgclient->time)); strcat(mbuf, buf);
  1322.      if (*get_msg(msgclient, '2'))
  1323.         strcat(mbuf, get_msg(msgclient, '2')); 
  1324.       else strcat(mbuf, myitoa(clock-msgclient->time));
  1325.      strcat(mbuf, buf);
  1326.      t = MSG_LEN - strlen(mbuf) - 10;
  1327.      strncat(mbuf, clean_spychar(Message(msgclient)), t);
  1328.      strcat(mbuf, "\0");
  1329.      DupNewString(msgclient->message, mbuf);
  1330.      message = flag_send(aptr, sptr, qptr, nick, msgclient, mode, sptr_chn);
  1331.      changes_to_save = 1;
  1332.    }
  1333.  if (msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER
  1334.      && qptr && qptr != sptr) {
  1335.      time(&clock);
  1336.      t = first_fnl_indexnode(UserName(qptr));
  1337.      last = last_fnl_indexnode(UserName(qptr));
  1338.      while (last && t <= last) {
  1339.             fmsgclient = FromNameList[t];
  1340.             if (fmsgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER
  1341.                 && clock < fmsgclient->timeout
  1342.                 && fmsgclient != msgclient
  1343.                 && (!mycmp(mode == 'g' ? qptr_nick : qptr->name, 
  1344.                     fmsgclient->fromnick)
  1345.                    || wild_fromnick(mode == 'g' ? qptr_nick :qptr->name,
  1346.                                     fmsgclient))
  1347.                 && !Usermycmp(UserName(qptr), fmsgclient->fromname)
  1348.                 && host_check(qptr->user->host, fmsgclient->fromhost)
  1349.                 && !matches(fmsgclient->tonick, nick)
  1350.                 && !matches(fmsgclient->toname, UserName(sptr))
  1351.                 && !matches(fmsgclient->tohost, sptr->user->host)
  1352.                 && flag_send(aptr, sptr, qptr, nick, fmsgclient, 
  1353.                              mode, sptr_chn)) {
  1354.                 t1 = wildcards(fmsgclient->tonick) ? 1 : 0;
  1355.                 t2 = wildcards(msgclient->tonick) ? 1 : 0;
  1356.                 if (!t1 && t2) goto end_this_flag;
  1357.                 if (t1 && !t2) { t++; continue; }
  1358.                 t1 = (fmsgclient->flags & FLAGS_NAME) ? 1 : 0;
  1359.                 t2 = (msgclient->flags & FLAGS_NAME) ? 1 : 0;
  1360.                 if (t1 && !t2) goto end_this_flag;
  1361.                 if (!t1 && t2) { t++; continue; }
  1362.                 if (fnl_msgclient(fmsgclient) < fnl_msgclient(msgclient))
  1363.                     goto end_this_flag;
  1364.           }
  1365.             t++;
  1366.        }
  1367.          mbuf[0] = 0;
  1368.          for (link = sptr->user->channel; link; link = link->next) {
  1369.               chptr = link->value.chptr;
  1370.               if (sptr_chn == chptr) sptr_chn_exits = 1;
  1371.               if (IsMember(qptr, chptr)) {
  1372.                   msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1373.                   if (mode != 'j' && mode != 'l') goto end_this_flag;
  1374.            } else if (ShowChannel(qptr, chptr)) show_channel = 1;
  1375.               if (ShowChannel(qptr, chptr)) {
  1376.                   if (strlen(mbuf)+strlen(chptr->chname) >= MSG_LEN) continue;
  1377.                   if (mbuf[0]) strcat(mbuf, " ");
  1378.               strcat(mbuf, chptr->chname);
  1379.            }       
  1380.         }
  1381.        for (link = qptr->user->channel; link; link = link->next)
  1382.             if (link->value.chptr == sptr_chn) break;
  1383.        if (link || mbuf[0] && sptr_chn_exits && !PubChannel(sptr_chn)) 
  1384.            mbuf[0] = 0;
  1385.         else if (!show_channel) {
  1386.                if (msgclient->flags & FLAGS_PRIVATE_DISPLAYED) mbuf[0] = 0;
  1387.                 else {
  1388.                        strcpy(mbuf, "*Private*");
  1389.                        msgclient->flags |= FLAGS_PRIVATE_DISPLAYED;
  1390.               }
  1391.              } else if (mbuf[0]) msgclient->flags &= ~FLAGS_PRIVATE_DISPLAYED; 
  1392.  
  1393.       if (msgclient->flags & FLAGS_DISPLAY_CHANNEL_DEST_REGISTER
  1394.           && mode != 'v' && mbuf[0]) spy_channel = mbuf;
  1395.       if (msgclient->flags & FLAGS_DISPLAY_SERVER_DEST_REGISTER)
  1396.           spy_server = sptr->user->server;
  1397.       if (spy_channel || spy_server)
  1398.           sprintf(ebuf,"%s%s%s%s%s", spy_channel ? " " : "",
  1399.                   spy_channel ? spy_channel : "",
  1400.                   spy_server ? " (" : "",
  1401.                   spy_server ? spy_server : "",
  1402.                   spy_server ? ")" : "");
  1403.         else ebuf[0] = 0;
  1404.       while (*message == '%') {
  1405.             while (*message && *message != ' ') message++;
  1406.             if (*message) message++;
  1407.     }
  1408.       sprintf(buf,"%s@%s",UserName(sptr),sptr->user->host);
  1409.       switch (mode) {
  1410.         case 'm' :
  1411.         case 'l' :
  1412.      case 'j' : if (!(msgclient->flags & FLAGS_NEWNICK_DISPLAYED)
  1413.                        && !(only_wildcards(msgclient->tonick)
  1414.                        && only_wildcards(msgclient->toname))
  1415.                        && !secret && !right_tonick && !spy_channel) {
  1416.                        sendto_one(qptr, "NOTICE %s :### %s (%s) %s%s %s",
  1417.                                   qptr->name, nick, buf, "signs on",
  1418.                                   ebuf, message);
  1419.                       msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1420.             } else if (spy_channel && 
  1421.                                (!secret || right_tonick)) {
  1422.                                sendto_one(qptr,
  1423.                                           "NOTICE %s :### %s (%s) is on %s",
  1424.                                           qptr->name, nick, buf, spy_channel);
  1425.                                msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1426.             }
  1427.                     break;
  1428.         case 'v' :
  1429.       case 'a' : if (!secret || right_tonick) {
  1430.                        sendto_one(qptr,
  1431.                                   "NOTICE %s :### %s (%s) %s%s %s",
  1432.                                   qptr->name, nick, buf, 
  1433.                                   "signs on", ebuf, message);
  1434.                        msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1435.             }
  1436.                    break;
  1437.     case 'c' : if (!(msgclient->flags & FLAGS_NEWNICK_DISPLAYED)
  1438.                        && !(only_wildcards(msgclient->tonick)
  1439.                             && only_wildcards(msgclient->toname))
  1440.                        && (!secret || right_tonick)) {
  1441.                        sendto_one(qptr,
  1442.                                   "NOTICE %s :### %s (%s) is %s%s %s",
  1443.                         qptr->name, nick, buf,
  1444.                           spy_channel ? "on" : "here",
  1445.                                    ebuf,message);
  1446.                         msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1447.                     }
  1448.                    break;
  1449.         case 's' :
  1450.     case 'g' : if ((!secret || right_tonick) &&
  1451.                       (!(msgclient->flags & FLAGS_NEWNICK_DISPLAYED)
  1452.                         && !(only_wildcards(msgclient->tonick)
  1453.                              && only_wildcards(msgclient->toname)))) {
  1454.                        sendto_one(qptr,
  1455.                                   "NOTICE %s :### %s (%s) is %s%s %s",
  1456.                                qptr->name, nick, buf,
  1457.                                   spy_channel ? "on" : "on IRC now",
  1458.                                   ebuf,message);
  1459.                        msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1460.                     }
  1461.                    break;
  1462.         case 'q' :
  1463.         case 'e' : if (!secret || right_tonick)
  1464.                        sendto_one(qptr,
  1465.                         "NOTICE %s :### %s (%s) %s %s",
  1466.                   qptr->name, nick,
  1467.                       buf,"signs off", message);
  1468.                        break;
  1469.     case 'n' : msgclient->flags &= ~FLAGS_NEWNICK_DISPLAYED;
  1470.                    if (secret) { 
  1471.                        if (right_tonick) 
  1472.                            sendto_one(qptr,
  1473.                                       "NOTICE %s :### %s (%s) %s %s",
  1474.                                       qptr->name, nick, buf,
  1475.                                       "signs off", message);
  1476.                 } else {
  1477.                          if (mycmp(nick, newnick)
  1478.                              && !(msgclient->flags & FLAGS_NO_NICKCHANGE_SPY))
  1479.                             sendto_one(qptr,
  1480.                                        "NOTICE %s :### %s (%s) %s <%s> %s",
  1481.                                        qptr->name, nick, buf, 
  1482.                                        "changed name to", newnick, message);
  1483.                             if (!matches(msgclient->tonick,newnick))
  1484.                                 msgclient->flags |= FLAGS_NEWNICK_DISPLAYED;
  1485.                      }
  1486.  
  1487.       }
  1488.         end_this_flag:;
  1489.  }
  1490.  
  1491.  if (send && !right_tonick && secret
  1492.      && !(msgclient->flags & FLAGS_SERVER_GENERATED_NOTICE)
  1493.      && !(msgclient->flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE)) {
  1494.      if (mode == 'v') nick = msgclient->tonick;
  1495.       else { 
  1496.              *repeat = 1; return NULLCHAR;
  1497.        }
  1498.  }
  1499.  if (mode == 'q' || mode == 'e' || mode == 'n') { 
  1500.      *repeat = 1; return NULLCHAR;
  1501.   }
  1502.  while (mode != 'g' && (msgclient->flags & FLAGS_RETURN_CORRECT_DESTINATION
  1503.         || msgclient->flags & FLAGS_DISPLAY_IF_CORRECT_FOUND)) {
  1504.         if (*message && matches(message, sptr->info) || 
  1505.             secret && !right_tonick) {
  1506.            *repeat = 1; break;
  1507.      }
  1508.         time(&clock); 
  1509.         sprintf(mbuf,"Search for %s!%s@%s (%s): %s!%s@%s (%s)",
  1510.                 msgclient->tonick,msgclient->toname,msgclient->tohost,
  1511.                 *message ? message : "*", nick,
  1512.                 UserName(sptr),sptr->user->host,sptr->info);
  1513.         if (msgclient->flags & FLAGS_DISPLAY_IF_CORRECT_FOUND && qptr) {
  1514.             sendto_one(qptr,"NOTICE %s :### %s",qptr->name,mbuf);
  1515.             break;
  1516.      }
  1517.         t1 = 0; 
  1518.         t = first_tnl_indexnode(msgclient->fromname);
  1519.         last = last_tnl_indexnode(msgclient->fromname);
  1520.         while (last && t <= last) {
  1521.               if (ToNameList[t]->timeout > clock &&
  1522.                   ToNameList[t]->flags & FLAGS_SERVER_GENERATED_NOTICE &&
  1523.                   !Usermycmp(ToNameList[t]->toname, msgclient->fromname) &&
  1524.                   !mycmp(ToNameList[t]->tohost,
  1525.                          local_host(msgclient->fromhost))) {
  1526.                   t1++;
  1527.                   if (!mycmp(Message(ToNameList[t]),mbuf)) {
  1528.                      t1 = -1; break;
  1529.            }
  1530.            }      
  1531.               t++;
  1532.           }  
  1533.         if (t1 < 0) break;
  1534.         if (t1 > 10) {
  1535.             msgclient->timeout = clock-1; 
  1536.             break;
  1537.      }
  1538.         gflags = 0;
  1539.         gflags |= FLAGS_WASOPER;
  1540.         gflags |= FLAGS_NAME;
  1541.         gflags |= FLAGS_SERVER_GENERATED_NOTICE;
  1542.         *gnew = 1;
  1543.         c = wild_fromnick(msgclient->fromnick, msgclient);
  1544.         new(msgclient->passwd,"SERVER_F","-","-",
  1545.             c ? c : msgclient->fromnick, msgclient->fromname,
  1546.             local_host(msgclient->fromhost), gflags, 
  1547.             24*7*3600+clock, clock, mbuf);
  1548.         break;
  1549.   }
  1550. if (msgclient->flags & FLAGS_REPEAT_UNTIL_TIMEOUT) *repeat = 1;
  1551.  
  1552. while (send && qptr != sptr &&
  1553.         (msgclient->flags & FLAGS_NOTICE_RECEIVED_MESSAGE
  1554.          || msgclient->flags & FLAGS_DISPLAY_IF_RECEIVED)) {
  1555.         time(&clock);
  1556.         if (!right_tonick && secret && clock-msgclient->time < 3600*24*7)
  1557.        { *repeat = 1; send = 0; break; }
  1558.         sprintf(buf,"%s (%s@%s) has received note queued %s before delivery.",
  1559.                 nick, UserName(sptr), sptr->user->host,
  1560.                 mytime(msgclient->time));
  1561.         if (msgclient->flags & FLAGS_DISPLAY_IF_RECEIVED && 
  1562.             qptr && (right_tonick || !secret)) {
  1563.            sendto_one(qptr,"NOTICE %s :### %s", qptr->name, buf);
  1564.            break;
  1565.          }
  1566.        gflags = 0;
  1567.        gflags |= FLAGS_WASOPER;
  1568.        gflags |= FLAGS_SERVER_GENERATED_NOTICE;
  1569.        time(&clock);*gnew = 1;
  1570.        c = wild_fromnick(msgclient->fromnick, msgclient);
  1571.        new(msgclient->passwd,"SERVER","-","-",
  1572.            c ? c : msgclient->fromnick, msgclient->fromname,
  1573.            local_host(msgclient->fromhost), gflags,note_mst*24*3600+clock,
  1574.            clock,buf);
  1575.        break;
  1576.     }
  1577.  while (send && msgclient->flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE) {
  1578.         if (mode == 'g') {
  1579.             *repeat = 1; send = 0; break;
  1580.       }
  1581.         t = first_tnl_indexnode(UserName(sptr));
  1582.         last = last_tnl_indexnode(UserName(sptr));
  1583.         while (last && t <= last) {
  1584.              if (ToNameList[t]->flags & FLAGS_SERVER_GENERATED_DESTINATION
  1585.                  && (!mycmp(ToNameList[t]->fromnick,msgclient->fromnick)
  1586.                      || wild_fromnick(ToNameList[t]->fromnick, msgclient))
  1587.                  && !Usermycmp(ToNameList[t]->fromname,msgclient->fromname)
  1588.                  && host_check(ToNameList[t]->fromhost,msgclient->fromhost)
  1589.                  && (!(msgclient->flags & FLAGS_REGISTER_NEWNICK) 
  1590.                      || !mycmp(ToNameList[t]->tonick,nick))
  1591.                  && !Usermycmp(ToNameList[t]->toname,UserName(sptr))
  1592.                  && host_check(ToNameList[t]->tohost,sptr->user->host)) {
  1593.                  send = 0; break;
  1594.              }
  1595.              t++;
  1596.       }
  1597.         if (!send) break;
  1598.         gflags = 0;
  1599.         gflags |= FLAGS_NAME;
  1600.         gflags |= FLAGS_REPEAT_UNTIL_TIMEOUT;
  1601.         gflags |= FLAGS_SERVER_GENERATED_DESTINATION;
  1602.         if (msgclient->flags & FLAGS_ALL_NICK_VALID) 
  1603.          gflags |= FLAGS_ALL_NICK_VALID;
  1604.         if (msgclient->flags & FLAGS_NICK_AND_WILDCARD_VALID) 
  1605.          gflags |= FLAGS_NICK_AND_WILDCARD_VALID;
  1606.         if (msgclient->flags & FLAGS_WASOPER) gflags |= FLAGS_WASOPER;
  1607.         time(&clock); *gnew = 1;
  1608.         new(msgclient->passwd,msgclient->fromnick, msgclient->fromname,
  1609.             msgclient->fromhost,nick,UserName(sptr),
  1610.             sptr->user->host,gflags,msgclient->timeout,clock,"");
  1611.         break;
  1612.    }
  1613.   if (send) return message; 
  1614.    else return NULLCHAR;
  1615. }
  1616.  
  1617. static void check_messages(aptr, sptr, info, mode)
  1618. aClient *sptr, *aptr; /* aptr = who activated */
  1619. void *info;
  1620. char mode;
  1621. {
  1622.  aMsgClient *msgclient, **index_p;
  1623.  char *qptr_nick, dibuf[40], *newnick, *message, *tonick;
  1624.  int last, first_tnl = 0, last_tnl = 0, first_tnil, last_tnil, nick_list = 1,
  1625.      number_matched = 0, t, repeat, gnew;
  1626.  long clock,flags;
  1627.  aClient *qptr = sptr; /* qptr points to active person queued a request */
  1628.  aChannel *sptr_chn = 0;
  1629.  
  1630.  if (!file_inited) init_messages();
  1631.  if (mode == 'm' || mode == 'j' || mode == 'l') {
  1632.      sptr_chn = (aChannel *)info; qptr_nick = sptr->name;
  1633.   } else qptr_nick = (char *)info;
  1634.  tonick = qptr_nick;
  1635.  if (!sptr->user || !*tonick) return;
  1636.  if (mode == 'a' && StrEq(sptr->info,"IRCnote") /* Removed in next release */
  1637.      && StrEq(sptr->name, sptr->info)) {
  1638.          sendto_one(sptr,":%s NOTICE %s : <%s> %s (%d) %s",
  1639.                     me.name, tonick, me.name, VERSION, number_fromname(),
  1640.                     StrEq(ptr,"IRCnote") ? "" : (!*ptr ? "-" : ptr));
  1641.       }
  1642.  time(&clock);
  1643.  if (!fromname_index) return;
  1644.  if (mode != 'j' && mode != 'l') {
  1645.      t = first_fnl_indexnode(UserName(sptr));
  1646.      last = last_fnl_indexnode(UserName(sptr));
  1647.      while (last && t <= last) {
  1648.            msgclient = FromNameList[t];
  1649.            if (!host_check(msgclient->fromhost, sptr->user->host)) {
  1650.                t++; continue;
  1651.             }
  1652.            if (!mycmp(qptr_nick, msgclient->fromnick)
  1653.                || wild_fromnick(qptr_nick, msgclient)) {
  1654.                if (msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER)
  1655.                    update_spymsg(msgclient);
  1656.                if ((mode == 'e' || mode == 'q')
  1657.                    && msgclient->flags & FLAGS_SIGNOFF_REMOVE)
  1658.                    msgclient->timeout = 0;
  1659.         }
  1660.            msgclient->flags |= FLAGS_FROM_REG;
  1661.            t++; 
  1662.         }
  1663.    }
  1664.  if (clock > old_clock+note_msf) {
  1665.     save_messages(); old_clock = clock;
  1666.   }
  1667.  if (mode == 'v') {
  1668.      nick_list = 0; /* Rest done with A flag */
  1669.   }
  1670.  if (mode == 'n') {
  1671.      newnick = tonick;tonick = sptr->name;
  1672.    }
  1673.  if (mode != 'g') {
  1674.      first_tnl = first_tnl_indexnode(UserName(sptr));
  1675.      last_tnl = last_tnl_indexnode(UserName(sptr));
  1676.      first_tnil = first_tnl_indexnode(tonick);
  1677.      last_tnil = last_tnl_indexnode(tonick);
  1678.   }
  1679.  if (mode == 's' || mode == 'g') {
  1680.      t = first_fnl_indexnode(UserName(sptr));
  1681.      last = last_fnl_indexnode(UserName(sptr));
  1682.      index_p = FromNameList;
  1683.      sptr = client; /* Notice new sptr */
  1684.      while (sptr && (!sptr->user || !*sptr->name)) sptr = sptr->next;
  1685.      if (!sptr) return;
  1686.      tonick = sptr->name;
  1687.   } else {
  1688.            if (nick_list) {
  1689.              t = first_tnil; last = last_tnil;
  1690.         } else {
  1691.                      t = first_tnl; last = last_tnl;
  1692.         }
  1693.            index_p = ToNameList;
  1694.       }
  1695.  while(1) {
  1696.     while (last && t <= last) {
  1697.            msgclient = index_p[t];
  1698.            if (msgclient->timeout < clock
  1699.                || index_p == WildCardList  
  1700.                   && (send_flag(msgclient->flags) 
  1701.                       || msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER)
  1702.                   && ((msgclient->flags & FLAGS_WASOPER 
  1703.                        && !valid_elements(msgclient->tohost))
  1704.                        || !(msgclient->flags & FLAGS_WASOPER)
  1705.                           && matches(local_host(sptr->user->host), 
  1706.                                      msgclient->tohost))) {
  1707.               t++; continue;
  1708.         }
  1709.            gnew = 0; repeat=1;
  1710.            if (!(msgclient->flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS)
  1711.                && !(msgclient->flags & FLAGS_SERVER_GENERATED_DESTINATION)
  1712.                && (index_p != ToNameList 
  1713.                    || (!nick_list && msgclient->flags & FLAGS_NAME)
  1714.                    || (nick_list && !(msgclient->flags & FLAGS_NAME)))
  1715.                && !matches(msgclient->tonick, tonick)
  1716.                && !matches(msgclient->toname, UserName(sptr))
  1717.                && !matches(msgclient->tohost, sptr->user->host)
  1718.                && (mode != 's' && mode != 'g'
  1719.                    || (wild_fromnick(qptr_nick, msgclient)
  1720.                        || !mycmp(qptr_nick, msgclient->fromnick))
  1721.                        && host_check(msgclient->fromhost, 
  1722.                                      qptr->user->host))) {
  1723.                message = check_flags(aptr, sptr, qptr, tonick, newnick,
  1724.                                      qptr_nick, msgclient, &repeat, 
  1725.                                      &gnew, mode, sptr_chn);
  1726.                if (message) {
  1727.                    flags = msgclient->flags;
  1728.                    display_flags(flags, dibuf, '-');
  1729.                    if (flags & FLAGS_SERVER_GENERATED_NOTICE)
  1730.                        sendto_one(sptr,"NOTICE %s :/%s/ %s",
  1731.                                   tonick, mytime(msgclient->time), message);
  1732.                    else sendto_one(sptr,
  1733.                                    "NOTICE %s :Note from %s!%s@%s /%s/ %s %s",
  1734.                                     tonick, msgclient->fromnick, 
  1735.                                     msgclient->fromname, msgclient->fromhost, 
  1736.                                     mytime(msgclient->time), dibuf, message);
  1737.                    }
  1738.                if (!(msgclient->flags & FLAGS_NAME)) number_matched++;
  1739.          }
  1740.            if (!repeat) msgclient->timeout = 0;
  1741.            if (gnew) {
  1742.                if (mode != 'g') {
  1743.                   first_tnl = first_tnl_indexnode(UserName(sptr));
  1744.                   last_tnl = last_tnl_indexnode(UserName(sptr));
  1745.                   first_tnil = first_tnl_indexnode(tonick);
  1746.                   last_tnil = last_tnl_indexnode(tonick);
  1747.         }
  1748.                if (mode == 's' || mode == 'g') {
  1749.                   t = fnl_msgclient(msgclient);
  1750.                   last = last_fnl_indexnode(UserName(qptr));
  1751.         } else {
  1752.                          if (index_p == ToNameList) {
  1753.                              t = tnl_msgclient(msgclient);
  1754.                              if (nick_list) last = last_tnil; 
  1755.                               else last = last_tnl;
  1756.                         }
  1757.             }
  1758.             } 
  1759.            if (repeat && (mode == 's' || mode =='g')) {
  1760.                sptr = sptr->next;
  1761.                while (sptr && (!sptr->user || !*sptr->name)) sptr = sptr->next;
  1762.                 if (!sptr || number_matched) {
  1763.                     number_matched = 0; sptr = client; 
  1764.                     while (sptr && (!sptr->user || !*sptr->name))
  1765.                            sptr = sptr->next;
  1766.                     if (!sptr) return;
  1767.                     tonick = sptr->name; t++; continue;
  1768.          }
  1769.                tonick = sptr->name;
  1770.             } else t++;
  1771.      }
  1772.      if (mode == 's' || mode == 'g') return;
  1773.      if (index_p == ToNameList) {
  1774.          if (nick_list) {
  1775.              if (mode == 'a' || mode == 'q') break;
  1776.              nick_list = 0; t = first_tnl; last = last_tnl;
  1777.       } else {
  1778.                   index_p = WildCardList;
  1779.                   t = 1; last = wildcard_index;
  1780.          }
  1781.       } else {
  1782.                if (mode == 'n') {
  1783.                    mode = 'c'; tonick = newnick;
  1784.                    first_tnil = first_tnl_indexnode(tonick);
  1785.                    last_tnil = last_tnl_indexnode(tonick);
  1786.                    t = first_tnil; last = last_tnil;
  1787.                    nick_list = 1; index_p = ToNameList;
  1788.             } else break;
  1789.      }
  1790.   }
  1791.   if (mode == 'c' || mode == 'a') 
  1792.      check_messages(sptr, sptr, tonick, 'g');
  1793. }
  1794.  
  1795. static int check_lastclient(sptr, mode, clock, sptr_chn)
  1796. aClient *sptr;
  1797. char mode;
  1798. long clock;
  1799. aChannel *sptr_chn;
  1800. {
  1801.   static aClient *client_list[LAST_CLIENTS + 1];
  1802.   static long max_last_client = -1, time_list[LAST_CLIENTS + 1], reset = 0;
  1803.   static long last_check_time = 0;
  1804.   static char mode_list[LAST_CLIENTS + 1];
  1805.   static aChannel *chn_list[LAST_CLIENTS + 1];
  1806.   register aClient *sptr_exist, *last_client;
  1807.   register int t = 0, new = -1, multi_buffered = 0, ret = 1;
  1808.   register long longest_time = 0;
  1809.   register char b_mode;
  1810.  
  1811.  if (!reset) { 
  1812.     for (t = 0; t < LAST_CLIENTS; t++) client_list[t] = 0;
  1813.     reset = 1;
  1814.   }
  1815.  if (mode == 'j' || mode == 'e' || mode == 'l')
  1816.      for (t = 0; t <= max_last_client; t++) {
  1817.          if (client_list[t] != sptr) continue;
  1818.          b_mode = mode_list[t];
  1819.          if (mode == 'e') {
  1820.             if (b_mode == 'v' && ret) {
  1821.                 ret = 0; check_messages(sptr, sptr, sptr->name, 'q');
  1822.          }
  1823.             client_list[t] = 0;
  1824.       } else if (b_mode == 'j' || b_mode == 'l') {
  1825.                      multi_buffered = 1;
  1826.                      time_list[t] = clock;
  1827.                      mode_list[t] = mode;
  1828.              chn_list[t] = 0;
  1829.                      break;
  1830.               }
  1831.        }
  1832.   if (!multi_buffered && 
  1833.       (mode == 'a' || mode == 'j' || mode == 'l' || mode == 'o'))
  1834.       for (t = 0; t < LAST_CLIENTS; t++) {
  1835.            if (!client_list[t]) { new = t; break; }
  1836.            if (time_list[t] > longest_time) {
  1837.                longest_time = time_list[t];
  1838.                new = t;
  1839.         }
  1840.        }
  1841.  if (mode != 'a' && mode != 'j' && mode != 'l' || last_check_time != clock) {
  1842.      last_check_time = clock;
  1843.      for (t = 0; t <= max_last_client; t++)
  1844.          if (client_list[t] && 
  1845.              (clock - time_list[t] > SECONDS_WAITFOR_MODE 
  1846.              || (client_list[t] == sptr && mode != 'j' 
  1847.                  && mode != 'l' && mode != 'o') 
  1848.              || t == new)) {
  1849.              last_client = client_list[t];
  1850.              for (sptr_exist=client;sptr_exist;sptr_exist = sptr_exist->next)
  1851.              if (sptr_exist == last_client) break;
  1852.              if (sptr_exist) {
  1853.                 if (t == new) buffer_overload = 1;
  1854.                 if (mode_list[t] == 'j' || mode_list[t] == 'l')
  1855.                  check_messages(sptr ? sptr : client_list[t], client_list[t], 
  1856.                                 chn_list[t], mode_list[t]);
  1857.                  else check_messages(sptr ? sptr : client_list[t], 
  1858.                                      client_list[t], client_list[t]->name, 
  1859.                                      mode_list[t]);
  1860.                  buffer_overload = 0;
  1861.               }
  1862.              client_list[t] = 0;
  1863.              if (max_last_client == t)
  1864.               while (max_last_client > -1 && !client_list[max_last_client]) 
  1865.                 max_last_client--;
  1866.          }
  1867.    }
  1868.  if (new != -1) {
  1869.     client_list[new] = sptr; 
  1870.     time_list[new] = clock;
  1871.     chn_list[new] = sptr_chn;
  1872.     if (mode == 'a') mode_list[new] = 'v';
  1873.      else mode_list[new] = mode; 
  1874.     if (new > max_last_client) max_last_client = new;
  1875.   }
  1876.  return ret;
  1877. }
  1878.  
  1879. void check_command(info, command, par1, par2, par3)
  1880. void *info;
  1881. char *command, *par1, *par2, *par3;
  1882. {
  1883.  char *arg, *c, mode, nick[BUF_LEN]; 
  1884.  static char last = 0, last_command[BUF_LEN], last_nick[BUF_LEN], 
  1885.         last_chn[BUF_LEN], last_mode = 0, last_modes[BUF_LEN];
  1886.  int from_secret = 0, on = -1;
  1887.  long *delay, clock, last_call = 0, source;
  1888.  Link *link;
  1889.  aChannel *chptr = 0;
  1890.  aClient *sptr;
  1891.  
  1892.  time (&clock);
  1893.  if (!last) {
  1894.      last_command[0] = 0; last_nick[0] = 0; 
  1895.      last_modes[0] = 0, last_chn[0] = 0; last = 1;
  1896.   }
  1897.  if (!command) {
  1898.         delay = (long *) info;
  1899.         if (*delay > SECONDS_WAITFOR_MODE) *delay = SECONDS_WAITFOR_MODE;
  1900.         if (clock - last_call < SECONDS_WAITFOR_MODE) return;
  1901.         last_call = clock;
  1902.         check_lastclient((aClient *)0, (char)'-', clock, (aChannel *)0);
  1903.         return;
  1904.   } 
  1905.  source = (long) info;
  1906.  arg = split_string(command, 2, 1);
  1907.  if (StrEq(arg, "USER")) mode = 'a'; else
  1908.  if (StrEq(arg, "NICK")) mode = 'n'; else
  1909.  if (StrEq(arg, "JOIN")) mode = 'j'; else
  1910.  if (StrEq(arg, "MODE")) mode = 'm'; else
  1911.  if (StrEq(arg, "QUIT")) mode = 'e'; else
  1912.  if (StrEq(arg, "PART") || StrEq(arg, "KICK")) mode = 'l'; else 
  1913.  if (StrEq(arg, "KILL")) {
  1914.      par1 = par2; /* Who kills before who's killed here... */
  1915.      mode = 'e';
  1916.  } else return;
  1917.  strcpy(nick, par1);
  1918.  if ((c = (char *)index(nick, '!')) != NULL) *c = '\0';
  1919.  if ((c = (char *)index(nick, '[')) != NULL) *c = '\0';
  1920.  if (mode == 'm' && (c = (char *)index(command, '+')) != NULL) par3 = c;
  1921.  if (mode == 'm' && (c = (char *)index(command, '-')) != NULL) par3 = c;
  1922.  if (mode == 'm' && (c = (char *)index(command, 'c')) != NULL) return;
  1923.  if (mode == 'j' && (c = (char *)index(command, '0')) != NULL) par2 = c+1;
  1924.  
  1925.  if (last_mode == mode && StrEq(last_nick, nick)) {
  1926.      if (mode == 'm') {
  1927.          if (StrEq(last_modes, par3)) return;
  1928.       }  else if (mode == 'j' || mode == 'l') {
  1929.                   if (StrEq(last_chn, par2)) return;
  1930.                } else return;
  1931.   }
  1932.  if (mode == 'm') strncpyzt(last_modes, par3, BUF_LEN-1);
  1933.  if (mode == 'j' || mode == 'l') strncpyzt(last_chn, par2, BUF_LEN-1);
  1934.  strncpyzt(last_command, command, BUF_LEN-1); 
  1935.  strncpyzt(last_nick, nick, BUF_LEN-1); 
  1936.  last_mode = mode;
  1937.  
  1938.  if (mode == 'm' && *par3 == '+' && par3[1] == 'o') mode = 'o';
  1939.  sptr = find_person(nick, (aClient *)NULL);
  1940.  if (!sptr) for (sptr = client; sptr; sptr = sptr->next)
  1941.                  if (StrEq(sptr->name, nick)) break;
  1942.  if (!sptr || !sptr->user || !IsRegisteredUser(sptr)) return;
  1943.  if (mode != 'j' && mode != 'l' && mode != 'm') {
  1944.      if (check_lastclient(sptr, mode, clock, chptr) && mode != 'o')
  1945.          check_messages(sptr, sptr, mode == 'n' ? par2 : sptr->name, mode);
  1946.      return;
  1947.   }
  1948.  for (link = sptr->user->channel; link; link = link->next)
  1949.       if (link->value.chptr && 
  1950.           StrEq(par2, link->value.chptr->chname)) break;
  1951.  if (link) chptr = link->value.chptr;
  1952.  for (link = sptr->user->channel; link; link = link->next)
  1953.       if (link->value.chptr != chptr && PubChannel(link->value.chptr)) break;
  1954.  if (chptr && link && !PubChannel(chptr)) return;  
  1955.  if (mode != 'm') {
  1956.      check_lastclient(sptr, mode, clock, chptr);
  1957.      return;
  1958.   }
  1959.  for (c = par3; *c; c++) {
  1960.       if (*c == '+') { 
  1961.           on = 1;continue;
  1962.        } 
  1963.       if (*c == '-') { 
  1964.           on = 0;continue;
  1965.        } 
  1966.       if (!on && (!chptr && *c == 'i' || *c == 'p' || *c == 's')
  1967.           && (!chptr || PubChannel(chptr))) from_secret = 1;
  1968.    }
  1969.  if (!from_secret) return;
  1970.  if (chptr)
  1971.      for (link = chptr->members; link; link = link->next) {
  1972.           check_lastclient(link->value.cptr, mode, clock, chptr);
  1973.           check_messages(link->value.cptr, link->value.cptr, chptr, mode);
  1974.       }
  1975.   else {
  1976.          check_lastclient(sptr, mode, clock, chptr);
  1977.          check_messages(sptr, sptr, chptr, mode);
  1978.     }
  1979. }
  1980.  
  1981. static void msg_remove(sptr, passwd, flag_s, id_s, name, time_s)
  1982. aClient *sptr;
  1983. char *passwd, *flag_s, *id_s, *name, *time_s;
  1984. {
  1985.  aMsgClient *msgclient;
  1986.  int removed = 0, t, last, id;
  1987.  long clock, flags = 0, time_l;
  1988.  char dibuf[40], tonick[BUF_LEN], toname[BUF_LEN], tohost[BUF_LEN];
  1989.  
  1990.  if (!set_flags(sptr,flag_s, &flags,'d',"")) return;
  1991.  if (!*time_s) time_l = 0; 
  1992.   else { 
  1993.         time_l = set_date(sptr,time_s);
  1994.         if (time_l < 0) return;
  1995.     }
  1996.  split(name, tonick, toname, tohost);
  1997.  if (id_s) id = atoi(id_s); else id = 0;
  1998.  t = first_fnl_indexnode(UserName(sptr));
  1999.  last = last_fnl_indexnode(UserName(sptr));
  2000.  time (&clock);
  2001.  while (last && t <= last) {
  2002.        msgclient = FromNameList[t]; flags = msgclient->flags;
  2003.         if (clock > msgclient->timeout) { t++; continue; }
  2004.         set_flags(sptr, flag_s, &flags, 'd',"");
  2005.         if (local_check(sptr,msgclient,passwd,flags,
  2006.                         tonick,toname,tohost,time_l,id)) {
  2007.             display_flags(msgclient->flags, dibuf, '-'),
  2008.             sendto_one(sptr,"NOTICE %s :### Removed -> %s %s (%s@%s)",
  2009.                        sptr->name,dibuf,msgclient->tonick,
  2010.                        msgclient->toname,msgclient->tohost);
  2011.             remove_msg(msgclient); last--; removed++;
  2012.  
  2013.         } else t++;
  2014.    }
  2015.  if (!removed) 
  2016.   sendto_one(sptr,"NOTICE %s :#?# No such request(s) found", sptr->name);
  2017. }
  2018.  
  2019. static void msg_save(sptr)
  2020. aClient *sptr;
  2021. {
  2022.  if (!changes_to_save) {
  2023.      sendto_one(sptr,"NOTICE %s :### No changes to save",sptr->name);
  2024.      return;
  2025.  }
  2026.  if (IsOperHere(sptr)) {
  2027.     save_messages();
  2028.     sendto_one(sptr,"NOTICE %s :### Requests are now saved",sptr->name);
  2029.   } else
  2030.       sendto_one(sptr,"NOTICE %s :### Oops! All requests lost...",sptr->name);
  2031. }
  2032.  
  2033. static void setvar(sptr,msg,l,value)
  2034. aClient *sptr;
  2035. int *msg,l;
  2036. char *value;
  2037. {
  2038.  int max;
  2039.  static char *message[] = {
  2040.              "Max server messages:",
  2041.              "I don't think that this is a good idea...",
  2042.              "Max server messages are set to:",
  2043.              "Max server messages with wildcards:",
  2044.              "Too many wildcards makes life too hard...",
  2045.              "Max server messages with wildcards are set to:",
  2046.              "Max user messages:",
  2047.              "Too cheeky fingers on keyboard error...",
  2048.              "Max user messages are set to:",
  2049.              "Max user messages with wildcards:",
  2050.              "Give me $$$, and I may fix your problem...",
  2051.              "Max user messages with wildcards are set to:",
  2052.              "Max server days:",
  2053.              "Can't remember that long time...",
  2054.              "Max server days are set to:",
  2055.              "Note save frequency:",
  2056.              "Save frequency may not be like that...",
  2057.              "Note save frequency is set to:" 
  2058.           };
  2059.  
  2060.  if (*value) {
  2061.     max = atoi(value);
  2062.     if (!IsOperHere(sptr))
  2063.         sendto_one(sptr,"NOTICE %s :### %s",sptr->name,message[l+1]);
  2064.      else { 
  2065.            if (!max && (msg == ¬e_mst || msg == ¬e_msf)) max = 1;
  2066.            *msg = max;if (msg == ¬e_msf) *msg *= 60;
  2067.            sendto_one(sptr,"NOTICE %s :### %s %d",sptr->name,message[l+2],max);
  2068.            changes_to_save = 1;
  2069.        }
  2070.  } else {
  2071.          max = *msg; if (msg == ¬e_msf) max /= 60;
  2072.          sendto_one(sptr,"NOTICE %s :### %s %d",sptr->name,message[l],max);
  2073.      }
  2074. }
  2075.  
  2076. static void msg_stats(sptr, arg, value)
  2077. aClient *sptr;
  2078. char *arg, *value;
  2079. {
  2080.  long clock;
  2081.  char buf[BUF_LEN], *fromhost = NULLCHAR, *fromnick, *fromname;
  2082.  int tonick_wildcards = 0,toname_wildcards = 0,tohost_wildcards = 0,any = 0,
  2083.      nicks = 0,names = 0,hosts = 0,t = 1,last = fromname_index,flag_notice = 0,
  2084.      flag_destination = 0, all_wildcards = 0;
  2085.  aMsgClient *msgclient;
  2086.  
  2087.  if (*arg) {
  2088.      if (!mycmp(arg,"MSM")) setvar(sptr,¬e_msm,0,value); else 
  2089.      if (!mycmp(arg,"MSW")) setvar(sptr,¬e_msw,3,value); else
  2090.      if (!mycmp(arg,"MUM")) setvar(sptr,¬e_mum,6,value); else
  2091.      if (!mycmp(arg,"MUW")) setvar(sptr,¬e_muw,9,value); else
  2092.      if (!mycmp(arg,"MST")) setvar(sptr,¬e_mst,12,value); else
  2093.      if (!mycmp(arg,"MSF")) setvar(sptr,¬e_msf,15,value); else
  2094.      if (MyEq(arg,"USED")) {
  2095.          time(&clock);
  2096.          while (last && t <= last) {
  2097.                 msgclient = FromNameList[t];
  2098.                 if (clock > msgclient->timeout) { t++; continue; }
  2099.                 any++;
  2100.                 if (msgclient->flags & FLAGS_SERVER_GENERATED_DESTINATION)
  2101.                     flag_destination++; else
  2102.                 if (msgclient->flags & FLAGS_SERVER_GENERATED_NOTICE)
  2103.                     flag_notice++; else
  2104.                 if (IsOperHere(sptr) || Key(sptr))
  2105.                     if (!fromhost || 
  2106.                         !host_check(msgclient->fromhost,fromhost)) {
  2107.                         nicks++;names++;hosts++;
  2108.                         fromhost = msgclient->fromhost;
  2109.                         fromname = msgclient->fromname;
  2110.                         fromnick = msgclient->fromnick;
  2111.                      } else if (Usermycmp(msgclient->fromname,fromname)) {
  2112.                                 nicks++;names++;
  2113.                                 fromname = msgclient->fromname;
  2114.                                 fromnick = msgclient->fromnick;
  2115.                              } else if (mycmp(msgclient->fromnick,fromnick)) {
  2116.                                         nicks++;
  2117.                                         fromnick = msgclient->fromnick;
  2118.                                } 
  2119.                 if (wildcards(msgclient->tonick) && 
  2120.                     wildcards(msgclient->toname)) all_wildcards++;
  2121.                 if (wildcards(msgclient->tonick))
  2122.                     tonick_wildcards++;
  2123.                 if (wildcards(msgclient->toname))
  2124.                     toname_wildcards++;
  2125.                 if (wildcards(msgclient->tohost))
  2126.                     tohost_wildcards++;
  2127.                 t++;
  2128.         }
  2129.         if (!any) 
  2130.              sendto_one(sptr,"NOTICE %s :#?# No request(s) found",sptr->name);
  2131.                 else {
  2132.                      if (IsOperHere(sptr) || Key(sptr)) {
  2133.                          sprintf(buf,"%s%d %s%d %s%d %s (%s%d %s%d %s%d %s%d)",
  2134.                                  "Nicks:",nicks,"Names:",names,
  2135.                                  "Hosts:",hosts,"W.cards",
  2136.                                  "Nicks:",tonick_wildcards,
  2137.                                  "Names:",toname_wildcards,
  2138.                                  "Hosts:",tohost_wildcards,
  2139.                                  "All:",all_wildcards);
  2140.                          sendto_one(sptr,"NOTICE %s :### %s",sptr->name,buf);
  2141.               }
  2142.                       sprintf(buf,"%s %s%d / %s%d",
  2143.                               "Server generated",
  2144.                               "G-notice: ",flag_notice,
  2145.                               "H-header: ",flag_destination);
  2146.                       sendto_one(sptr,"NOTICE %s :### %s",sptr->name,buf);
  2147.          }
  2148.      } else if (!mycmp(arg,"RESET")) {
  2149.                 if (!IsOperHere(sptr)) 
  2150.                     sendto_one(sptr,"NOTICE %s :### %s",sptr->name,
  2151.                                "Wrong button - try another next time...");
  2152.                  else {
  2153.                        note_mst = NOTE_MAXSERVER_TIME,
  2154.                        note_mum = NOTE_MAXUSER_MESSAGES,
  2155.                        note_msm = NOTE_MAXSERVER_MESSAGES,
  2156.                        note_msw = NOTE_MAXSERVER_WILDCARDS,
  2157.                        note_muw = NOTE_MAXUSER_WILDCARDS;
  2158.                        note_msf = NOTE_SAVE_FREQUENCY*60;
  2159.                        sendto_one(sptr,"NOTICE %s :### %s",
  2160.                                   sptr->name,"Stats have been reset");
  2161.                        changes_to_save = 1;
  2162.            }
  2163.         }
  2164.   } else {
  2165.       t = number_fromname();
  2166.       sprintf(buf,"%s%d /%s%d /%s%d /%s%d /%s%d /%s%d /%s%d",
  2167.               "QUEUE:",t,
  2168.               "MSM:",note_msm,
  2169.               "MSW:",note_msw,
  2170.               "MUM:",note_mum,
  2171.               "MUW:",note_muw,
  2172.               "MST:",note_mst,
  2173.               "MSF:",note_msf/60);
  2174.         sendto_one(sptr,"NOTICE %s :### %s",sptr->name,buf);
  2175.     }
  2176. }
  2177.  
  2178. static int msg_send(sptr, silent, passwd, flag_s, timeout_s, name, message)
  2179. aClient *sptr;
  2180. int silent;
  2181. char *passwd, *flag_s, *timeout_s, *name, *message;
  2182. {
  2183.  aMsgClient **index_p, *msgclient;
  2184.  int sent_wild = 0, sent = 0, nick_list = 1,
  2185.      first_tnl, last_tnl, t, first, last, join = 0;
  2186.  long clock, timeout, flags = 0;
  2187.  char buf[BUF_LEN], dibuf[40], *empty_char = "", tonick[BUF_LEN], 
  2188.       toname[BUF_LEN], tohost[BUF_LEN], *msg;
  2189.  
  2190.  time (&clock);
  2191.  t = first_tnl_indexnode(sptr->name);
  2192.  last = last_tnl_indexnode(sptr->name);
  2193.  first_tnl = first_tnl_indexnode(UserName(sptr));
  2194.  last_tnl = last_tnl_indexnode(UserName(sptr));
  2195.  index_p = ToNameList;
  2196.  time (&clock);
  2197.  while (1) {
  2198.      while (last && t <= last) {
  2199.           msgclient = index_p[t];
  2200.         if (clock > msgclient->timeout) { t++; continue; }
  2201.             msg = flag_send((aClient *)0, sptr, (aClient *)0 , sptr->name, 
  2202.                   msgclient, '-', NULLCHAR);
  2203.             if (msg && msgclient->flags & FLAGS_NOT_QUEUE_REQUESTS
  2204.             && !(msgclient->flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS)
  2205.              && !matches(msgclient->tonick,sptr->name) 
  2206.              && !matches(msgclient->toname,UserName(sptr))
  2207.             && !matches(msgclient->tohost,sptr->user->host)) {
  2208.         sendto_one(sptr,"NOTICE %s :### %s (%s@%s) %s %s",sptr->name,
  2209.                msgclient->fromnick,msgclient->fromname,
  2210.                msgclient->fromhost,
  2211.                            "doesn't allow you to queue requests:", msg);
  2212.         return -1;
  2213.         }
  2214.             t++;
  2215.     }
  2216.      if (index_p == ToNameList) {
  2217.          if (nick_list) {
  2218.              nick_list = 0; t = first_tnl; last = last_tnl;
  2219.           } else {
  2220.                    index_p = WildCardList;
  2221.                    t = 1; last = wildcard_index;
  2222.               }
  2223.  
  2224.       } else break;
  2225.  }
  2226.  if (number_fromname() >= note_msm 
  2227.      && !IsOperHere(sptr) && !Key(sptr)) {
  2228.      if (!note_msm || !note_mum)
  2229.          sendto_one(sptr,
  2230.                     "NOTICE %s :#?# The notesystem is closed for no-operators",
  2231.                     sptr->name);
  2232.       else sendto_one(sptr,"NOTICE %s :#?# No more than %d request%s %s",
  2233.                       sptr->name, note_msm, note_msm < 2 ? "" : "s",
  2234.                       "allowed in the server");
  2235.      return -1;
  2236.   }
  2237.  if (clock > old_clock+note_msf) {
  2238.     save_messages();old_clock = clock;
  2239.   }
  2240.  if (!set_flags(sptr,flag_s,&flags,'s',"")) return -1;
  2241.  split(name, tonick, toname, tohost);
  2242.  if (IsOper(sptr)) flags |= FLAGS_WASOPER;
  2243.  if (*timeout_s == '+') timeout = atoi(timeout_s + 1) * 24;
  2244.   else if (*timeout_s == '-') timeout = atoi(timeout_s + 1);
  2245.  if (timeout > note_mst*24 && !(flags & FLAGS_WASOPER) && !Key(sptr)) {
  2246.     sendto_one(sptr,"NOTICE %s :#?# Max time allowed is %d day%s",
  2247.                sptr->name,note_mst,note_mst > 1 ? "s" : "");
  2248.     return -1;
  2249.   }
  2250.  if (!message) {
  2251.     if (!send_flag(flags)) message = empty_char; 
  2252.      else {
  2253.            sendto_one(sptr,"NOTICE %s :#?# No message specified",sptr->name);
  2254.            return -1;
  2255.        }
  2256.   }
  2257.  if (*toname == DummyChar) {
  2258.      sendto_one(sptr,
  2259.                 "NOTICE %s :#?# Please skip that first character in username",
  2260.                 sptr->name);
  2261.      return -1;
  2262.   }
  2263.  first = first_fnl_indexnode(UserName(sptr));
  2264.  last = last_fnl_indexnode(UserName(sptr));
  2265.  t = first;
  2266.  while (last && t <= last) {
  2267.         msgclient = FromNameList[t];
  2268.         if (clock > msgclient->timeout) { t++; continue; }
  2269.         if (!mycmp(sptr->name, msgclient->fromnick)
  2270.             && !Usermycmp(UserName(sptr), msgclient->fromname)
  2271.             && host_check(sptr->user->host, msgclient->fromhost)
  2272.             && StrEq(msgclient->tonick, tonick)
  2273.             && StrEq(msgclient->toname, toname)
  2274.             && StrEq(msgclient->tohost, tohost)
  2275.             && StrEq(msgclient->passwd, passwd)
  2276.             && StrEq(Message(msgclient), clean_spychar(message))
  2277.             && msgclient->flags == (msgclient->flags | flags)) {
  2278.             msgclient->timeout = timeout*3600+clock;
  2279.             join = 1;
  2280.       }
  2281.         t++;
  2282.     }
  2283.   if (!join && !(flags & FLAGS_WASOPER) && !Key(sptr)) {
  2284.      time(&clock); t = first;
  2285.      while (last && t <= last) {
  2286.          if (!Usermycmp(UserName(sptr),FromNameList[t]->fromname)) {
  2287.              if (host_check(sptr->user->host,FromNameList[t]->fromhost)) {
  2288.                  sent++;
  2289.                  if (wildcards(FromNameList[t]->tonick)
  2290.                      && wildcards(FromNameList[t]->toname))
  2291.                     sent_wild++;  
  2292.               }
  2293.                  
  2294.           }
  2295.          t++;
  2296.        }
  2297.      if (sent >= note_mum) {
  2298.         sendto_one(sptr,"NOTICE %s :#?# No more than %d request%s %s",
  2299.                    sptr->name,note_mum,note_mum < 2?"":"s",
  2300.                    "for each user allowed in the server");
  2301.         return -1;
  2302.       }
  2303.      while (wildcards(tonick) && wildcards(toname)) {
  2304.             if (!note_msw || !note_muw)
  2305.                 sendto_one(sptr,
  2306.                           "NOTICE %s :#?# No-operators are not allowed %s",
  2307.                           sptr->name,
  2308.                           "to specify nick and username with wildcards");
  2309.             else if (wildcard_index >= note_msw) 
  2310.                      sendto_one(sptr,"NOTICE %s :#?# No more than %d req. %s",
  2311.                                 sptr->name, note_msw,
  2312.                                 "with nick and username w.cards allowed.");
  2313.             else if (sent_wild >= note_muw) 
  2314.                      sendto_one(sptr,"NOTICE %s :#?# No more than %d %s %s",
  2315.                                 sptr->name, note_muw, 
  2316.                                 note_muw < 2 ? "request ":" requests",
  2317.                                 "with nick and username w.cards allowed.");
  2318.           else break;
  2319.           return -1;
  2320.      }
  2321.    }
  2322.  while ((send_flag(flags) || flags & FLAGS_DISPLAY_IF_DEST_REGISTER) &&
  2323.        wildcards(tonick) && wildcards(toname)) { 
  2324.        if ((flags & FLAGS_WASOPER || Key(sptr)) && !valid_elements(tohost))
  2325.           sendto_one(sptr, 
  2326.                      "NOTICE %s :#?# This matches more than one country.",
  2327.                      sptr->name);
  2328.         else if (!(flags & FLAGS_WASOPER) && !Key(sptr) &&
  2329.                  matches(local_host(sptr->user->host), tohost))
  2330.                  sendto_one(sptr, "NOTICE %s :#?# %s must be a local host.",
  2331.                             sptr->name, local_host(sptr->user->host));
  2332.           else break; 
  2333.        return -1;
  2334.   }
  2335.  if (!join) {
  2336.      time(&clock);
  2337.      flags |= FLAGS_FROM_REG;
  2338.      msgclient = new(passwd,sptr->name, UserName(sptr),  
  2339.                      sptr->user->host, tonick, toname, tohost, flags, 
  2340.                      timeout*3600+clock, clock, clean_spychar(message));
  2341.      if (flags & FLAGS_DISPLAY_IF_DEST_REGISTER) update_spymsg(msgclient);
  2342.   }
  2343.  display_flags(flags, dibuf, '-');
  2344.  sprintf(buf, "%s %s %s!%s@%s for %s",
  2345.          join ? "Joined..." : "Queued...",dibuf, 
  2346.          tonick, toname, tohost, relative_time(timeout*3600));
  2347.  if (!silent) {
  2348.     sendto_one(sptr,"NOTICE %s :### %s",sptr->name, buf);
  2349.     if (send_flag(flags)) check_messages(sptr, sptr, sptr->name, 's');
  2350.   }
  2351.  if (join) return 0; else return 1;
  2352. }
  2353.  
  2354. static void msg_news(sptr, silent, passwd, flag_s, timeout_s, name, message)
  2355. aClient *sptr;
  2356. int silent;
  2357. char *passwd, *flag_s, *timeout_s, *name, *message;
  2358. {
  2359.  aMsgClient *msgclient;
  2360.  long clock;
  2361.  int joined = 0, queued = 0, ret, t = 1, msg_len;
  2362.  char *c, tonick[BUF_LEN], toname[BUF_LEN], tohost[BUF_LEN], 
  2363.       anyname[BUF_LEN], buf[MSG_LEN];
  2364.  
  2365.  split(name, tonick, toname, tohost);
  2366.  if (MyEq("ADMIN.", tonick) && !IsOper(sptr) && !KeyFlags(sptr, FLAGS_NEWS)) {
  2367.      sendto_one(sptr,
  2368.                 "NOTICE %s :#?# No privileges for admin group.", 
  2369.                 sptr->name);
  2370.      return;
  2371.   }
  2372.  time (&clock);
  2373.  sprintf(buf, "[News:%s] ", tonick); msg_len = MSG_LEN-strlen(buf)-1;
  2374.  strncat(buf, message, msg_len); strcat(flag_s, "-RS");
  2375.  while (fromname_index && t <= fromname_index) {
  2376.         msgclient = FromNameList[t];
  2377.         if (!Usermycmp(UserName(sptr), msgclient->fromname)
  2378.             && (!mycmp(sptr->name, msgclient->fromnick)
  2379.                 || wild_fromnick(sptr->name, msgclient)
  2380.             &&  host_check(sptr->user->host,msgclient->fromhost))) {
  2381.         t++; continue;
  2382.      }
  2383.         if (clock < msgclient->timeout
  2384.             && !(msgclient->flags & FLAGS_SERVER_GENERATED_NOTICE)
  2385.             && !(msgclient->flags & FLAGS_SERVER_GENERATED_DESTINATION)  
  2386.             && (msgclient->flags & FLAGS_NEWS
  2387.                 && !matches(msgclient->tonick, tonick)
  2388.                 && !matches(msgclient->toname, UserName(sptr))
  2389.                 && !matches(msgclient->tohost, sptr->user->host)
  2390.                 && (!matches(toname, msgclient->tonick)
  2391.                     || matches(toname, tonick)
  2392.                        && !mycmp(msgclient->tonick, tonick))      
  2393.                 && (!*Message(msgclient)
  2394.                     || !matches(Message(msgclient), message))
  2395.                 || !mycmp(tonick, "admin.users"))
  2396.             && !matches(tohost, msgclient->fromhost)
  2397.             && !(msgclient->flags & FLAGS_KEY_TO_OPEN_OPER_LOCKS)) {
  2398.             c = wild_fromnick(msgclient->fromnick, msgclient);            
  2399.             sprintf(anyname, "%s!%s@%s", 
  2400.                     c ? c : msgclient->fromnick, msgclient->fromname, 
  2401.                     local_host(msgclient->fromhost));
  2402.             ret = msg_send(sptr, 1, passwd, flag_s, 
  2403.                            timeout_s, anyname, buf);
  2404.             if (!ret) joined++;
  2405.              else if (ret < 0) return;
  2406.                else { 
  2407.                      queued++;
  2408.                      t = fnl_msgclient(msgclient);
  2409.          }
  2410.      }
  2411.        t++;
  2412.    }
  2413.  strcpy(buf, "user");
  2414.  if (queued > 1) strcat(buf, "s"); 
  2415.  if (joined) { 
  2416.     strcat(buf, ", ");
  2417.     strcat(buf, myitoa(joined)); strcat(buf, " joined");
  2418.   } 
  2419.  sendto_one(sptr,"NOTICE %s :### News to %d %s", sptr->name, queued, buf);
  2420. }
  2421.  
  2422. static void msg_list(sptr, arg, passwd, flag_s, id_s, name, time_s)
  2423. aClient *sptr;
  2424. char *arg, *passwd, *flag_s, *id_s, *name, *time_s;
  2425. {
  2426.  aMsgClient *msgclient;
  2427.  int number = 0, t, last, ls = 0, count = 0, 
  2428.      found = 0, log = 0, id, id_count = 0;
  2429.  long clock, flags = 0, time_l, time_queued;
  2430.  char tonick[BUF_LEN], toname[BUF_LEN], tohost[BUF_LEN],
  2431.       *message, buf[BUF_LEN], dibuf[40], mbuf[MSG_LEN], 
  2432.       *dots = "...", *wildcard = "*";
  2433.  
  2434.  if (MyEq(arg,"ls")) ls = 1; else
  2435.  if (MyEq(arg,"count")) count = 1; else
  2436.  if (MyEq(arg,"log")) log = 1; else
  2437.  if (MyEq(arg,"llog")) log = 3;
  2438.   else {
  2439.          sendto_one(sptr,"NOTICE %s :#?# No such option: %s",sptr->name,arg); 
  2440.          return;
  2441.     }
  2442.  if (!*name && !id_s && !*flag_s) {
  2443.               if (log) log++;
  2444.               if (ls) ls++;
  2445.               name = wildcard;
  2446.   }
  2447.  if (!set_flags(sptr,flag_s, &flags,'d',"")) return;
  2448.  if (!*time_s) time_l = 0; 
  2449.   else { 
  2450.         time_l = set_date(sptr,time_s);
  2451.         if (time_l < 0) return;
  2452.     }
  2453.  split(name, tonick, toname, tohost);
  2454.  if (id_s) id = atoi(id_s); else id = 0;
  2455.  t = first_fnl_indexnode(UserName(sptr));
  2456.  last = last_fnl_indexnode(UserName(sptr));
  2457.  time(&clock); 
  2458.  while (last && t <= last) {
  2459.         msgclient = FromNameList[t];
  2460.     msgclient->id = ++id_count;
  2461.         flags = msgclient->flags;
  2462.         if (clock > msgclient->timeout) { t++; continue; }
  2463.         set_flags(sptr,flag_s,&flags,'d',"");
  2464.         if (local_check(sptr,msgclient,passwd,flags,
  2465.                            tonick,toname,tohost,time_l,id)) {
  2466.             message = Message(msgclient); number++;
  2467.             if (ls == 2 && *message) message = dots;
  2468.             display_flags(msgclient->flags, dibuf, '-');
  2469.             if (log) { 
  2470.                 if (!(msgclient->flags & FLAGS_DISPLAY_IF_DEST_REGISTER))
  2471.                     { t++ ; continue; }
  2472.                 strcpy(mbuf, get_msg(msgclient, 'n'));
  2473.                 if (*mbuf == '-') *mbuf = '\0';
  2474.                 if (*mbuf) { 
  2475.                    strcat(mbuf, "!");
  2476.                    strcat(mbuf, get_msg(msgclient, 'u')); strcat(mbuf, "@");
  2477.                    strcat(mbuf, get_msg(msgclient, 'h')); 
  2478.                    time_queued = atoi(get_msg(msgclient, '1'))+msgclient->time;
  2479.                  }
  2480.                 if (log == 1 || log == 3) {            
  2481.                    found++;
  2482.                    if (*mbuf) {
  2483.                       strcat(mbuf, " (");
  2484.                       strcat(mbuf, get_msg(msgclient, 'r')); strcat(mbuf, ")");
  2485.                     } else {
  2486.                              time_queued = clock;
  2487.                              strcpy(mbuf, "<No matches yet>");
  2488.                 }
  2489.                    sendto_one(sptr,"NOTICE %s :### %s: %s!%s@%s => %s", 
  2490.                               sptr->name, log == 1 ? mytime(time_queued) :
  2491.                               myctime(time_queued),
  2492.                               msgclient->tonick, msgclient->toname, 
  2493.                               msgclient->tohost, mbuf); 
  2494.              } else if (*mbuf) {
  2495.                             found++;
  2496.                             sendto_one(sptr,"NOTICE %s :### %s: %s", 
  2497.                                        sptr->name, 
  2498.                                        log == 2 ? mytime(time_queued) :
  2499.                                        myctime(time_queued), mbuf); 
  2500.                 }
  2501.           } else 
  2502.                  if (!count) {
  2503.                     found++;
  2504.                     sprintf(buf,"for %s", 
  2505.                            relative_time(msgclient->timeout-clock));
  2506.                     sendto_one(sptr,"NOTICE %s :#%d %s %s (%s@%s) %s: %s",
  2507.                               sptr->name, msgclient->id, dibuf,
  2508.                               msgclient->tonick, msgclient->toname,
  2509.                               msgclient->tohost, buf, message);
  2510.          }
  2511.      }
  2512.        t++;
  2513.      }
  2514.  if (count) sendto_one(sptr,"NOTICE %s :### %s %s (%s@%s): %d",
  2515.                        sptr->name,"Number of requests to",
  2516.                        tonick ? tonick : "*", toname ? toname:"*",
  2517.                        tohost ? tohost : "*", number);
  2518.   else if (!found) sendto_one(sptr,"NOTICE %s :#?# No such %s", sptr->name,
  2519.                               log ? "log(s)" : "request(s) found");
  2520. }
  2521.  
  2522. static void msg_flag(sptr, passwd, flag_s, id_s, name, newflag_s)
  2523. aClient *sptr;
  2524. char *passwd, *flag_s, *id_s, *name, *newflag_s;
  2525. {
  2526.  aMsgClient *msgclient;
  2527.  int flagged = 0, t, last, id;
  2528.  long clock, flags = 0;
  2529.  char tonick[BUF_LEN], toname[BUF_LEN], tohost[BUF_LEN],
  2530.       dibuf1[40], dibuf2[40];
  2531.  
  2532.  if (!*newflag_s) {
  2533.      sendto_one(sptr,"NOTICE %s :#?# No flag changes specified",sptr->name);
  2534.      return;
  2535.   }
  2536.  if (!set_flags(sptr, flag_s, &flags,'d',"in matches flag")) return;
  2537.  if (!set_flags(sptr, newflag_s, &flags,'c',"in flag changes")) return;
  2538.  split(name, tonick, toname, tohost);
  2539.  if (id_s) id = atoi(id_s); else id = 0;
  2540.  t = first_fnl_indexnode(UserName(sptr));
  2541.  last = last_fnl_indexnode(UserName(sptr));
  2542.  time(&clock);
  2543.  while (last && t <= last) {
  2544.        msgclient = FromNameList[t];flags = msgclient->flags;
  2545.         if (clock > msgclient->timeout) { t++; continue; }
  2546.         set_flags(sptr,flag_s,&flags,'d',"");
  2547.         if (local_check(sptr,msgclient,passwd,flags,
  2548.                         tonick,toname,tohost,0,id)) {
  2549.             flags = msgclient->flags; display_flags(flags, dibuf1, '-');
  2550.             set_flags(sptr,newflag_s,&msgclient->flags,'s',"");
  2551.             display_flags(msgclient->flags, dibuf2, '-');
  2552.             if (flags == msgclient->flags) 
  2553.                 sendto_one(sptr,"NOTICE %s :### %s -> %s %s (%s@%s)",
  2554.                            sptr->name, "No flag change for",
  2555.                            dibuf1, msgclient->tonick,
  2556.                            msgclient->toname,msgclient->tohost);
  2557.              else                                        
  2558.                 sendto_one(sptr,"NOTICE %s :### %s -> %s %s (%s@%s) to %s",
  2559.                           sptr->name,"Flag change",dibuf1,msgclient->tonick,
  2560.                           msgclient->toname, msgclient->tohost, dibuf2);
  2561.            flagged++;
  2562.         } 
  2563.        t++;
  2564.    }
  2565.  if (!flagged) 
  2566.   sendto_one(sptr,"NOTICE %s :#?# No such request(s) found",sptr->name);
  2567. }
  2568.  
  2569. static void msg_sent(sptr, arg, name, time_s, delete)
  2570. aClient *sptr;
  2571. char *arg, *name, *time_s, *delete;
  2572. {
  2573.  aMsgClient *msgclient,*next_msgclient;
  2574.  char fromnick[BUF_LEN], fromname[BUF_LEN], fromhost[BUF_LEN]; 
  2575.  int number = 0, t, t1, last, nick = 0, count = 0, users = 0;
  2576.  long clock,time_l;
  2577.  
  2578.  if (!*arg) nick = 1; else
  2579.   if (MyEq(arg,"COUNT")) count = 1; else
  2580.    if (MyEq(arg,"USERS")) users = 1; else
  2581.    if (!MyEq(arg,"NAME")) {
  2582.        sendto_one(sptr,"NOTICE %s :#?# No such option: %s",sptr->name, arg); 
  2583.        return;
  2584.   }
  2585.  if (users) {
  2586.     if (!IsOperHere(sptr)) {
  2587.         sendto_one(sptr,"NOTICE %s :### %s",sptr->name,
  2588.                    "A dragon is guarding the names...");
  2589.         return;
  2590.      }
  2591.     if (!*time_s) time_l = 0; 
  2592.      else { 
  2593.             time_l = set_date(sptr,time_s);
  2594.             if (time_l < 0) return;
  2595.        }
  2596.     split(name, fromnick, fromname, fromhost); 
  2597.     time(&clock);
  2598.     for (t = 1; t <= fromname_index; t++) {
  2599.          msgclient = FromNameList[t]; t1 = t;
  2600.          do next_msgclient = t1 < fromname_index ? FromNameList[++t1] : 0;
  2601.           while (next_msgclient && next_msgclient->timeout <= clock);
  2602.          if (msgclient->timeout > clock
  2603.              && (!time_l || msgclient->time >= time_l 
  2604.                  && msgclient->time < time_l+24*3600)
  2605.              && (!matches(fromnick,msgclient->fromnick))
  2606.              && (!matches(fromname,msgclient->fromname))
  2607.              && (!matches(fromhost,msgclient->fromhost))
  2608.              && (!*delete || !mycmp(delete,"RM")
  2609.                  || !mycmp(delete,"RMBF") &&
  2610.                     (msgclient->flags & FLAGS_RETURN_CORRECT_DESTINATION ||
  2611.                      msgclient->flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE))) {
  2612.              if (*delete || !next_msgclient
  2613.                  || mycmp(next_msgclient->fromnick,msgclient->fromnick)
  2614.                  || mycmp(next_msgclient->fromname,msgclient->fromname)     
  2615.                  || !(host_check(next_msgclient->fromhost,
  2616.                                  msgclient->fromhost))) {
  2617.                   sendto_one(sptr,"NOTICE %s :### %s[%d] %s (%s@%s) @%s",
  2618.                              sptr->name,
  2619.                              *delete ? "Removing -> " : "", 
  2620.                              *delete ? 1 : count+1,
  2621.                              msgclient->fromnick,msgclient->fromname,
  2622.                              local_host(msgclient->fromhost),
  2623.                              msgclient->fromhost);
  2624.                     if (*delete) msgclient->timeout = clock-1;
  2625.                  count = 0; number = 1;
  2626.          } else count++;
  2627.      }
  2628.      }
  2629.     if (!number) 
  2630.      sendto_one(sptr, "NOTICE %s :#?# No request(s) from such user(s) found",
  2631.                 sptr->name);
  2632.   return;
  2633.  }
  2634.  t = first_fnl_indexnode(UserName(sptr));
  2635.  last = last_fnl_indexnode(UserName(sptr));
  2636.  time (&clock);
  2637.  while (last && t <= last) {
  2638.         msgclient = FromNameList[t];
  2639.         if (clock > msgclient->timeout) { t++; continue; }
  2640.         if (!Usermycmp(UserName(sptr),msgclient->fromname)
  2641.             && (!nick || !mycmp(sptr->name,msgclient->fromnick))) {
  2642.             if (host_check(sptr->user->host,msgclient->fromhost)) { 
  2643.                 if (!count) 
  2644.                     sendto_one(sptr,"NOTICE %s :### Queued %s from host %s",
  2645.                                sptr->name, mytime(msgclient->time),
  2646.                                msgclient->fromhost);
  2647.                 number++;
  2648.              }
  2649.          }
  2650.        t++;
  2651.     }
  2652.  if (!number) 
  2653.   sendto_one(sptr,"NOTICE %s :#?# No such request(s) found",sptr->name);
  2654.   else if (count) sendto_one(sptr,"NOTICE %s :### %s %d",sptr->name,
  2655.                              "Number of requests queued:",number);
  2656. }
  2657.  
  2658. static int name_len_error(sptr, name)
  2659. aClient *sptr;
  2660. char *name;
  2661. {
  2662.  if (strlen(name) >= BUF_LEN) {
  2663.     sendto_one(sptr,
  2664.                "NOTICE %s :#?# Nick!name@host can't be longer than %d chars",
  2665.                sptr->name, BUF_LEN-1);
  2666.     return 1;
  2667.   }
  2668.  return 0;
  2669. }
  2670.  
  2671. static int flag_len_error(sptr, flag_s)
  2672. aClient *sptr;
  2673. char *flag_s;
  2674. {
  2675.  if (strlen(flag_s) >= BUF_LEN) {
  2676.     sendto_one(sptr,"NOTICE %s :#?# Flag string can't be longer than %d chars",
  2677.                sptr->name,BUF_LEN-1);
  2678.     return 1;
  2679.   }
  2680.  return 0;
  2681. }
  2682.  
  2683. static int alias_send(sptr, option, flags, msg, timeout)
  2684. aClient *sptr;
  2685. char *option, **flags, **msg, **timeout;
  2686. {
  2687.  static char flag_s[BUF_LEN+10], *deft = "+31",
  2688.         *waitfor_message = "[Waiting]";
  2689.  
  2690.  if (MyEq(option,"SEND")) {
  2691.      sprintf(flag_s,"+D%s", *flags);
  2692.      if (!*timeout) *timeout = deft; 
  2693.   } else
  2694.  if (MyEq(option,"NEWS")) {
  2695.      sprintf(flag_s,"+RS%s", *flags);
  2696.      if (!*timeout) *timeout = deft; 
  2697.   } else
  2698.  if (MyEq(option,"WAITFOR")) { 
  2699.      sprintf(flag_s,"+YD%s", *flags); 
  2700.      if (!*msg) *msg = waitfor_message; 
  2701.   } else 
  2702.  if (MyEq(option,"SPY")) sprintf(flag_s,"+RX%s", *flags); else
  2703.  if (MyEq(option,"FIND")) sprintf(flag_s,"+FR%s", *flags); else
  2704.  if (MyEq(option,"KEY")) sprintf(flag_s,"+KR%s", *flags); else
  2705.  if (MyEq(option,"WALL")) sprintf(flag_s,"+BR%s", *flags); else
  2706.  if (MyEq(option,"WALLOPS")) sprintf(flag_s,"+BRW%s", *flags); else
  2707.  if (MyEq(option,"DENY")) sprintf(flag_s,"+RZ%s", *flags); else
  2708.   return 0;
  2709.  *flags = flag_s;
  2710.  return 1;
  2711. }
  2712.  
  2713. static void antiwall(sptr)
  2714. aClient *sptr;
  2715. {
  2716.  int t = 1, wall = 0;
  2717.  aMsgClient *msgclient;
  2718.  long gflags = 0, clock;
  2719.  char buf[MSG_LEN], *c;
  2720.  
  2721.  time (&clock);
  2722.  if (!IsOper(sptr)) { 
  2723.      sendto_one(sptr,"NOTICE %s :#?# Only ghosts may travel through walls...", 
  2724.                sptr->name);
  2725.      return;
  2726.   }
  2727.  while (fromname_index && t <= fromname_index) {
  2728.         msgclient = FromNameList[t];
  2729.         if (msgclient->flags & FLAGS_FIND_CORRECT_DEST_SEND_ONCE 
  2730.             && !matches(msgclient->tonick, sptr->name)
  2731.             && !matches(msgclient->toname, UserName(sptr))
  2732.             && !matches(msgclient->tohost, sptr->user->host)
  2733.             && flag_send((aClient *)0, sptr, (aClient *)0, sptr->name, 
  2734.                          msgclient, '-', NULLCHAR)) {
  2735.             msgclient->flags &= ~FLAGS_FIND_CORRECT_DEST_SEND_ONCE;
  2736.             sendto_one(sptr,
  2737.                        "NOTICE %s :### Note wall to %s!%s@%s deactivated.", 
  2738.                        sptr->name, msgclient->tonick, msgclient->toname, 
  2739.                        msgclient->tohost);
  2740.             sprintf(buf,"%s (%s@%s) has deactivated your Note Wall...",
  2741.                     sptr->name,UserName(sptr),sptr->user->host);
  2742.             c = wild_fromnick(msgclient->fromnick, msgclient);
  2743.             gflags |= FLAGS_WASOPER;
  2744.             gflags |= FLAGS_SERVER_GENERATED_NOTICE;
  2745.             new(msgclient->passwd,"SERVER","-","-",
  2746.                 c ? c : msgclient->fromnick, msgclient->fromname,
  2747.                 local_host(msgclient->fromhost), gflags, 
  2748.                            note_mst*24*3600+clock, clock, buf);
  2749.             wall = 1;
  2750.      }
  2751.         t++;
  2752.     }
  2753.  if (!wall) { 
  2754.      sendto_one(sptr,"NOTICE %s :#?# Hunting for ghost walls?", 
  2755.                 sptr->name);
  2756.      return;
  2757.   }
  2758. }
  2759.  
  2760. int m_note(cptr, sptr, parc, parv)
  2761. aClient *cptr, *sptr;
  2762. int parc;
  2763. char *parv[];
  2764. {
  2765.  char *option, *arg, *timeout = NULLCHAR, *passwd = NULLCHAR, *param,  
  2766.       *id = NULLCHAR, *flags = NULLCHAR, *name = NULLCHAR, *msg = NULLCHAR,
  2767.       *wildcard = "*", *c, *c2, *default_timeout = "+1", *deft = "+31";
  2768.  static char buf1[BUF_LEN], buf2[BUF_LEN], buf3[BUF_LEN],
  2769.         buf4[BUF_LEN], msg_buf[MSG_LEN], passwd_buf[BUF_LEN], 
  2770.         timeout_buf[BUF_LEN], option_buf[BUF_LEN], 
  2771.         id_buf[BUF_LEN], flags_buf[BUF_LEN + 3];
  2772.  int t, silent = 0, remote = 0;
  2773.  aClient *acptr;
  2774.  
  2775.  if (!file_inited) init_messages();
  2776.  if (parc < 2) {
  2777.     sendto_one(sptr,"NOTICE %s :#?# No option specified.", sptr->name); 
  2778.     return -1;
  2779.   }
  2780.  param = parv[1];
  2781.  if (parc > 1 && !myncmp(param,"service ",8)) {
  2782.      if (!IsOperHere(sptr)) {
  2783.          sendto_one(sptr,"NOTICE %s :### %s",sptr->name,
  2784.                    "Beyond your power poor soul...");
  2785.          return 0;
  2786.       }
  2787.      sptr = find_person(split_string(param, 2, 1), (aClient *)0);
  2788.      if (!sptr) return 0;
  2789.      t = 0; 
  2790.      while (*param && t < 2) {
  2791.             if (*param == ' ') t++;
  2792.             param++;
  2793.        }                 
  2794.      if (!*param) parc = 0;
  2795.   }  else {
  2796.            c = split_string(param, 1, 1); c2 = c;
  2797.            while (*c2 && *c2 != '.') c2++;
  2798.            if (*c2) {
  2799.                if (wildcards(c))
  2800.                    for (t = 0; t <= highest_fd; t++) {
  2801.                        if (!(acptr = local[t])) continue;
  2802.                        if (IsServer(acptr) && acptr != cptr) 
  2803.                           sendto_one(acptr, ":%s NOTE %s", sptr->name, param);
  2804.             }
  2805.                  else for (acptr = client; acptr; acptr = acptr->next)
  2806.                           if (IsServer(acptr) && acptr != cptr
  2807.                               && !mycmp(c, acptr->name)) {
  2808.                       sendto_one(acptr, 
  2809.                                         ":%s NOTE %s", sptr->name, param);
  2810.                               break;
  2811.                }
  2812.                if (!matches(c, me.name)) {
  2813.                    if (wildcards(c)) remote = -1; else remote = 1;
  2814.                    while (*param && *param != ' ') param++; 
  2815.                          if (*param) param++;
  2816.                          if (!*param) {
  2817.                             sendto_one(sptr,
  2818.                                        "NOTICE %s :#?# No option specified.", 
  2819.                                        sptr->name);
  2820.                             return -1;
  2821.                           }
  2822.            } else return 0;
  2823.      
  2824.         }
  2825.        }
  2826.  if (!IsRegistered(sptr)) { 
  2827.     sendto_one(sptr, ":%s %d * :You have not registered as an user", 
  2828.            me.name, ERR_NOTREGISTERED); 
  2829.     return -1;
  2830.    }
  2831.  if (strlen(param) >= MSG_LEN) {
  2832.     sendto_one(sptr,"NOTICE %s :#?# Line can't be longer than %d chars",
  2833.                sptr->name, MSG_LEN-1);
  2834.     return -1;
  2835.  }
  2836.  for (t = 2; t < 10; t++) {
  2837.       arg = split_string(param, t, 1);
  2838.       switch (*arg) {
  2839.               case '&' :
  2840.               case '$' : passwd = passwd_buf;strncpyzt(passwd,arg+1,10);
  2841.                          break; 
  2842.               case '%' : passwd = passwd_buf;strncpyzt(passwd,arg+1,10);
  2843.                          silent = 1; break;
  2844.               case '#' : id = id_buf; strncpyzt(id,arg+1,BUF_LEN); break; 
  2845.               case '+' :
  2846.               case '-' : if (numeric(arg+1)) {
  2847.                              timeout = timeout_buf; 
  2848.                              strncpyzt(timeout,arg,BUF_LEN); 
  2849.               } else { 
  2850.                                    flags = flags_buf;
  2851.                                    strncpyzt(flags,arg,BUF_LEN);  
  2852.                  }
  2853.                           break;
  2854.               default : goto end_loop_case;
  2855.         }
  2856.     } 
  2857.  end_loop_case:;
  2858.  strncpyzt(option_buf, split_string(param, 1, 1), BUF_LEN-1); 
  2859.  strncpyzt(buf1, split_string(param, t, 1), BUF_LEN-1);
  2860.  strncpyzt(buf2, split_string(param, t+1, 1), BUF_LEN-1);
  2861.  strncpyzt(buf3, split_string(param, t+2, 1), BUF_LEN-1);
  2862.  strncpyzt(buf4, split_string(param, t+3, 1), BUF_LEN-1);
  2863.  strcpy(msg_buf, split_string(param, t+1, 0)); msg = msg_buf;
  2864.  option = option_buf;
  2865.  c = msg; while (*c) c++;
  2866.  while (c != msg && *--c == ' '); 
  2867.  if (c != msg) c++; *c = 0;
  2868.  if (!*msg) msg = NULLCHAR;
  2869.  if (!passwd || !*passwd) passwd = wildcard;
  2870.  if (!flags) flags = (char *) "";
  2871.  if (flags && flag_len_error(sptr, flags)) return 0;
  2872.  time (&old_clock_request);
  2873.  
  2874.  if (MyEq(option,"STATS")) msg_stats(sptr, buf1, buf2); else
  2875.  if (MyEq(option,"VERSION")) sendto_one(sptr,"NOTICE %s :Running version %s", 
  2876.                                         sptr->name, VERSION); 
  2877.  else if (remote < 0 && (mycmp(option, "NEWS") || !msg)) return 0; else
  2878.  if (alias_send(sptr,option, &flags, &msg, &timeout) || MyEq(option,"USER")) {
  2879.      if (!*buf1) {
  2880.         if (MyEq(option,"SPY")) check_messages(sptr, sptr, sptr->name, 'g');
  2881.          else sendto_one(sptr,
  2882.                        "NOTICE %s :#?# Please specify at least one argument", 
  2883.                         sptr->name);
  2884.         return 0;
  2885.       }
  2886.      name = buf1;if (!*name) name = wildcard;
  2887.      if (name_len_error(sptr, name)) return 0;
  2888.      if (!timeout || !*timeout) timeout = default_timeout; 
  2889.      if (mycmp(option, "NEWS") || !msg) {
  2890.          msg_send(sptr, silent, passwd, flags, timeout, name, msg);
  2891.       } else msg_news(sptr, silent, passwd, flags, 
  2892.                       timeout == default_timeout ? deft : timeout, 
  2893.                       name, msg);
  2894.   } else
  2895.  if (MyEq(option,"LS") || MyEq(option,"COUNT") 
  2896.      || MyEq(option,"LOG") || MyEq(option,"LLOG")) {
  2897.      name = buf1;if (name_len_error(sptr, name)) return 0;
  2898.      msg_list(sptr, option, passwd, flags, id, name, buf2);
  2899.    } else
  2900.  if (MyEq(option,"SAVE")) msg_save(sptr); else
  2901.  if (MyEq(option,"ANTIWALL")) antiwall(sptr); else
  2902.  if (MyEq(option,"FLAG")) {
  2903.      name = buf1;if (!*name) name = wildcard;
  2904.      if (name_len_error(sptr, name)) return 0;
  2905.      msg_flag(sptr, passwd, flags, id, name, buf2); 
  2906.   } else
  2907.  if (MyEq(option,"SENT")) {
  2908.     name = buf2;if (!*name) name = wildcard;
  2909.     if (name_len_error(sptr, name)) return 0;
  2910.     msg_sent(sptr, buf1, name, buf3, buf4);
  2911.   } else
  2912.  if (!mycmp(option,"RM")) {
  2913.      if (!*buf1 && !id && !*flags) {
  2914.         sendto_one(sptr,
  2915.                    "NOTICE %s :#?# Please specify at least one argument", 
  2916.                    sptr->name);
  2917.         return 0;
  2918.       }
  2919.      name = buf1;if (!*name) name = wildcard;
  2920.      if (name_len_error(sptr, name)) return 0;
  2921.      msg_remove(sptr, passwd, flags, id, name, buf2); 
  2922.   } else sendto_one(sptr,"NOTICE %s :#?# No such option: %s", 
  2923.                     sptr->name, option);
  2924.  return 0;
  2925. }
  2926. #endif
  2927.