ircd/parse.c

   1 /*
   2  * IRC - Internet Relay Chat, common/parse.c
   3  * Copyright (C) 1990 Jarkko Oikarinen and
   4  *                    University of Oulu, Computing Center
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 1, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  * $Id$
  21  */
  22 #include "config.h"
  23
  24 #include "parse.h"
  25 #include "client.h"
  26 #include "channel.h"
  27 #include "handlers.h"
  28 #include "hash.h"
  29 #include "ircd.h"
  30 #include "ircd_alloc.h"
  31 #include "ircd_chattr.h"
  32 #include "ircd_features.h"
  33 #include "ircd_policy.h"
  34 #include "ircd_reply.h"
  35 #include "ircd_string.h"
  36 #include "msg.h"
  37 #include "numeric.h"
  38 #include "numnicks.h"
  39 #include "opercmds.h"
  40 #include "querycmds.h"
  41 #include "res.h"
  42 #include "s_bsd.h"
  43 #include "s_conf.h"
  44 #include "s_debug.h"
  45 #include "s_misc.h"
  46 #include "s_numeric.h"
  47 #include "s_user.h"
  48 #include "send.h"
  49 #include "struct.h"
  50 #include "sys.h"
  51 #include "whocmds.h"
  52 #include "whowas.h"
  53
  54 #include <assert.h>
  55 #include <string.h>
  56 #include <stdlib.h>
  57
  58
  59
  60 struct MessageTree {
  61   char *final;
  62   struct Message *msg;
  63   struct MessageTree *pointers[26];
  64 };
  65
  66
  67 struct Message msgtab[] = {
  68   {
  69     MSG_PRIVATE,
  70     TOK_PRIVATE,
  71     0, MAXPARA, MFLG_SLOW, 0,
  72     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
  73     { m_unregistered, m_privmsg, ms_privmsg, mo_privmsg, m_ignore }
  74   },
  75   {
  76     MSG_NICK,
  77     TOK_NICK,
  78     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
  79     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
  80     { m_nick, m_nick, ms_nick, m_nick, m_ignore }
  81   },
  82   {
  83     MSG_NOTICE,
  84     TOK_NOTICE,
  85     0, MAXPARA, MFLG_SLOW | MFLG_IGNORE, 0,
  86     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
  87     { m_ignore, m_notice, ms_notice, mo_notice, m_ignore }
  88   },
  89   {
  90     MSG_WALLCHOPS,
  91     TOK_WALLCHOPS,
  92     0, MAXPARA, MFLG_SLOW, 0,
  93     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
  94     { m_unregistered, m_wallchops, ms_wallchops, m_wallchops, m_ignore }
  95   },
  96   {
  97     MSG_CPRIVMSG,
  98     TOK_CPRIVMSG,
  99     0, MAXPARA, MFLG_SLOW, 0,
 100     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 101     { m_unregistered, m_cprivmsg, m_ignore, m_cprivmsg, m_ignore }
 102   },
 103   {
 104     MSG_CNOTICE,
 105     TOK_CNOTICE,
 106     0, MAXPARA, MFLG_SLOW, 0,
 107     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 108     { m_unregistered, m_cnotice, m_ignore, m_cnotice, m_ignore }
 109   },
 110   {
 111     MSG_JOIN,
 112     TOK_JOIN,
 113     0, MAXPARA, MFLG_SLOW, 0,
 114     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 115     { m_unregistered, m_join, ms_join, m_join, m_ignore }
 116   },
 117   {
 118     MSG_MODE,
 119     TOK_MODE,
 120     0, MAXPARA, MFLG_SLOW, 0,
 121     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 122     { m_unregistered, m_mode, ms_mode, m_mode, m_ignore }
 123   },
 124   {
 125     MSG_BURST,
 126     TOK_BURST,
 127     0, MAXPARA, MFLG_SLOW, 0,
 128     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 129     { m_ignore, m_ignore, ms_burst, m_ignore, m_ignore }
 130   },
 131   {
 132     MSG_CREATE,
 133     TOK_CREATE,
 134     0, MAXPARA, MFLG_SLOW, 0,
 135     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 136     { m_ignore, m_ignore, ms_create, m_ignore, m_ignore }
 137   },
 138   {
 139     MSG_DESTRUCT,
 140     TOK_DESTRUCT,
 141     0, MAXPARA, MFLG_SLOW, 0,
 142     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 143     { m_ignore, m_ignore, ms_destruct, m_ignore, m_ignore }
 144   },
 145   {
 146     MSG_QUIT,
 147     TOK_QUIT,
 148     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 149     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 150     { m_quit, m_quit, ms_quit, m_quit, m_ignore }
 151   },
 152   {
 153     MSG_PART,
 154     TOK_PART,
 155     0, MAXPARA, MFLG_SLOW, 0,
 156     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 157     { m_unregistered, m_part, ms_part, m_part, m_ignore }
 158   },
 159   {
 160     MSG_TOPIC,
 161     TOK_TOPIC,
 162     0, MAXPARA, MFLG_SLOW, 0,
 163     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 164     { m_unregistered, m_topic, ms_topic, m_topic, m_ignore }
 165   },
 166   {
 167     MSG_INVITE,
 168     TOK_INVITE,
 169     0, MAXPARA, MFLG_SLOW, 0,
 170     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 171     { m_unregistered, m_invite, ms_invite, m_invite, m_ignore }
 172   },
 173   {
 174     MSG_KICK,
 175     TOK_KICK,
 176     0, MAXPARA, MFLG_SLOW, 0,
 177     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 178     { m_unregistered, m_kick, ms_kick, m_kick, m_ignore }
 179   },
 180   {
 181     MSG_WALLOPS,
 182     TOK_WALLOPS,
 183     0, MAXPARA, MFLG_SLOW, 0,
 184     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 185     { m_unregistered, m_not_oper, ms_wallops, mo_wallops, m_ignore }
 186   },
 187   {
 188     MSG_WALLUSERS,
 189     TOK_WALLUSERS,
 190     0, MAXPARA, MFLG_SLOW, 0,
 191     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 192     { m_unregistered, m_not_oper, ms_wallusers, mo_wallusers, m_ignore }
 193   },
 194   {
 195     MSG_DESYNCH,
 196     TOK_DESYNCH,
 197     0, MAXPARA, MFLG_SLOW, 0,
 198     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 199     { m_ignore, m_ignore, ms_desynch, m_ignore, m_ignore }
 200   },
 201   {
 202     MSG_PING,
 203     TOK_PING,
 204     0, MAXPARA, MFLG_SLOW, 0,
 205     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 206     { m_unregistered, m_ping, ms_ping, mo_ping, m_ignore }
 207   },
 208   {
 209     MSG_PONG,
 210     TOK_PONG,
 211     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 212     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 213     { mr_pong, m_pong, ms_pong, m_pong, m_ignore }
 214   },
 215   {
 216     MSG_ERROR,
 217     TOK_ERROR,
 218     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 219     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 220     { mr_error, m_ignore, ms_error, m_ignore, m_ignore }
 221   },
 222   {
 223     MSG_KILL,
 224     TOK_KILL,
 225     0, MAXPARA, MFLG_SLOW, 0,
 226     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 227     { m_unregistered, m_not_oper, ms_kill, mo_kill, m_ignore }
 228   },
 229   {
 230     MSG_USER,
 231     TOK_USER,
 232     0, MAXPARA, MFLG_SLOW, 0,
 233     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 234     { m_user, m_registered, m_ignore, m_registered, m_ignore }
 235   },
 236   {
 237     MSG_AWAY,
 238     TOK_AWAY,
 239     0, MAXPARA, MFLG_SLOW, 0,
 240     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 241     { m_unregistered, m_away, ms_away, m_away, m_ignore }
 242   },
 243   {
 244     MSG_ISON,
 245     TOK_ISON,
 246     0, 1, MFLG_SLOW, 0,
 247     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 248     { m_unregistered, m_ison, m_ignore, m_ison, m_ignore }
 249   },
 250   {
 251     MSG_SERVER,
 252     TOK_SERVER,
 253     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 254     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 255     { mr_server, m_registered, ms_server, m_registered, m_ignore }
 256   },
 257   {
 258     MSG_SQUIT,
 259     TOK_SQUIT,
 260     0, MAXPARA, MFLG_SLOW, 0,
 261     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 262     { m_unregistered, m_not_oper, ms_squit, mo_squit, m_ignore }
 263   },
 264   {
 265     MSG_WHOIS,
 266     TOK_WHOIS,
 267     0, MAXPARA, MFLG_SLOW, 0,
 268     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 269     { m_unregistered, m_whois, m_whois, m_whois, m_ignore }
 270   },
 271   {
 272     MSG_WHO,
 273     TOK_WHO,
 274     0, MAXPARA, MFLG_SLOW, 0,
 275     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 276     { m_unregistered, m_who, m_ignore, m_who, m_ignore }
 277   },
 278   {
 279     MSG_WHOWAS,
 280     TOK_WHOWAS,
 281     0, MAXPARA, MFLG_SLOW, 0,
 282     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 283     { m_unregistered, m_whowas, m_whowas, m_whowas, m_ignore }
 284   },
 285   {
 286     MSG_LIST,
 287     TOK_LIST,
 288     0, MAXPARA, MFLG_SLOW, 0,
 289     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 290     { m_unregistered, m_list, m_ignore, m_list, m_ignore }
 291   },
 292   {
 293     MSG_NAMES,
 294     TOK_NAMES,
 295     0, MAXPARA, MFLG_SLOW, 0,
 296     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 297     { m_unregistered, m_names, ms_names, m_names, m_ignore }
 298   },
 299   {
 300     MSG_USERHOST,
 301     TOK_USERHOST,
 302     0, 1, MFLG_SLOW, 0,
 303     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 304     { m_unregistered, m_userhost, m_ignore, m_userhost, m_ignore }
 305   },
 306   {
 307     MSG_USERIP,
 308     TOK_USERIP,
 309     0, 1, MFLG_SLOW, 0,
 310     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 311     { m_unregistered, m_userip, m_ignore, m_userip, m_ignore }
 312   },
 313   {
 314     MSG_TRACE,
 315     TOK_TRACE,
 316     0, MAXPARA, MFLG_SLOW, 0,
 317     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 318 #ifdef HEAD_IN_SAND_TRACE
 319     { m_unregistered, m_not_oper, ms_trace, mo_trace, m_ignore }
 320 #else
 321     { m_unregistered, m_trace, ms_trace, mo_trace, m_ignore }
 322 #endif
 323   },
 324   {
 325     MSG_PASS,
 326     TOK_PASS,
 327     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 328     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 329     { mr_pass, m_registered, m_ignore, m_registered, m_ignore }
 330   },
 331   {
 332     MSG_LUSERS,
 333     TOK_LUSERS,
 334     0, MAXPARA, MFLG_SLOW, 0,
 335     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 336     { m_unregistered, m_lusers, ms_lusers, m_lusers, m_ignore }
 337   },
 338   {
 339     MSG_TIME,
 340     TOK_TIME,
 341     0, MAXPARA, MFLG_SLOW, 0,
 342     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 343     { m_unregistered, m_time, m_time, m_time, m_ignore }
 344   },
 345   {
 346     MSG_SETTIME,
 347     TOK_SETTIME,
 348     0, MAXPARA, MFLG_SLOW, 0,
 349     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 350     { m_unregistered, m_ignore, ms_settime, mo_settime, m_ignore }
 351   },
 352   {
 353     MSG_RPING,
 354     TOK_RPING,
 355     0, MAXPARA, MFLG_SLOW, 0,
 356     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 357     { m_unregistered, m_not_oper, ms_rping, mo_rping, m_ignore }
 358   },
 359   {
 360     MSG_RPONG,
 361     TOK_RPONG,
 362     0, MAXPARA, MFLG_SLOW, 0,
 363     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 364     { m_unregistered, m_ignore, ms_rpong, m_ignore, m_ignore }
 365   },
 366   {
 367     MSG_OPER,
 368     TOK_OPER,
 369     0, MAXPARA, MFLG_SLOW, 0,
 370     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 371     { m_unregistered, m_oper, ms_oper, mo_oper, m_ignore }
 372   },
 373   {
 374     MSG_CONNECT,
 375     TOK_CONNECT,
 376     0, MAXPARA, MFLG_SLOW, 0,
 377     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 378     { m_unregistered, m_not_oper, ms_connect, mo_connect, m_ignore }
 379   },
 380   {
 381     MSG_MAP,
 382     TOK_MAP,
 383     0, MAXPARA, MFLG_SLOW, 0,
 384     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 385 #ifdef HEAD_IN_SAND_MAP
 386     { m_unregistered, m_map_redirect, m_ignore, m_map, m_ignore }
 387 #else
 388     { m_unregistered, m_map, m_ignore, m_map, m_ignore }
 389 #endif
 390   },
 391   {
 392     MSG_VERSION,
 393     TOK_VERSION,
 394     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 395     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 396     { m_version, m_version, ms_version, m_version, m_ignore }
 397   },
 398   {
 399     MSG_STATS,
 400     TOK_STATS,
 401     0, MAXPARA, MFLG_SLOW, 0,
 402     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 403     { m_unregistered, m_stats, ms_stats, mo_stats, m_ignore }
 404   },
 405   {
 406     MSG_LINKS,
 407     TOK_LINKS,
 408     0, MAXPARA, MFLG_SLOW, 0,
 409     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 410 #ifdef HEAD_IN_SAND_LINKS
 411     { m_unregistered, m_links_redirect, ms_links, m_links, m_ignore }
 412 #else
 413     { m_unregistered, m_links, ms_links, m_links, m_ignore }
 414 #endif
 415   },
 416   {
 417     MSG_ADMIN,
 418     TOK_ADMIN,
 419     0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0,
 420     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 421     { m_admin, m_admin, ms_admin, m_admin, m_ignore }
 422   },
 423   {
 424     MSG_HELP,
 425     TOK_HELP,
 426     0, MAXPARA, MFLG_SLOW, 0,
 427     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 428     { m_unregistered, m_help, m_ignore, m_help, m_ignore }
 429   },
 430   {
 431     MSG_INFO,
 432     TOK_INFO,
 433     0, MAXPARA, MFLG_SLOW, 0,
 434     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 435     { m_unregistered, m_info, ms_info, mo_info, m_ignore }
 436   },
 437   {
 438     MSG_MOTD,
 439     TOK_MOTD,
 440     0, MAXPARA, MFLG_SLOW, 0,
 441     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 442     { m_unregistered, m_motd, m_motd, m_motd, m_ignore }
 443   },
 444   {
 445     MSG_CLOSE,
 446     TOK_CLOSE,
 447     0, MAXPARA, MFLG_SLOW, 0,
 448     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 449     { m_unregistered, m_not_oper, m_ignore, mo_close, m_ignore }
 450   },
 451   {
 452     MSG_SILENCE,
 453     TOK_SILENCE,
 454     0, MAXPARA, MFLG_SLOW, 0,
 455     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 456     { m_unregistered, m_silence, ms_silence, m_silence, m_ignore }
 457   },
 458   {
 459     MSG_GLINE,
 460     TOK_GLINE,
 461     0, MAXPARA, MFLG_SLOW, 0,
 462     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 463     { m_unregistered, m_gline, ms_gline, mo_gline, m_ignore }
 464   },
 465   {
 466     MSG_JUPE,
 467     TOK_JUPE,
 468     0, MAXPARA, MFLG_SLOW, 0,
 469     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 470     { m_unregistered, m_jupe, ms_jupe, mo_jupe, m_ignore }
 471   },
 472   {
 473     MSG_OPMODE,
 474     TOK_OPMODE,
 475     0, MAXPARA, MFLG_SLOW, 0,
 476     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 477     { m_unregistered, m_not_oper, ms_opmode, mo_opmode, m_ignore }
 478   },
 479   {
 480     MSG_CLEARMODE,
 481     TOK_CLEARMODE,
 482     0, MAXPARA, MFLG_SLOW, 0,
 483     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 484     { m_unregistered, m_not_oper, ms_clearmode, mo_clearmode, m_ignore }
 485   },
 486   {
 487     MSG_UPING,
 488     TOK_UPING,
 489     0, MAXPARA, MFLG_SLOW, 0,
 490     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 491     { m_unregistered, m_not_oper, ms_uping, mo_uping, m_ignore }
 492   },
 493   {
 494     MSG_END_OF_BURST,
 495     TOK_END_OF_BURST,
 496     0, MAXPARA, MFLG_SLOW, 0,
 497     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 498     { m_ignore, m_ignore, ms_end_of_burst, m_ignore, m_ignore }
 499   },
 500   {
 501     MSG_END_OF_BURST_ACK,
 502     TOK_END_OF_BURST_ACK,
 503     0, MAXPARA, 1, 0,
 504     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 505     { m_ignore, m_ignore, ms_end_of_burst_ack, m_ignore, m_ignore }
 506   },
 507   {
 508     MSG_HASH,
 509     TOK_HASH,
 510     0, MAXPARA, MFLG_SLOW, 0,
 511     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 512     { m_unregistered, m_hash, m_hash, m_hash, m_ignore }
 513   },
 514   {
 515     MSG_DNS,
 516     TOK_DNS,
 517     0, MAXPARA, MFLG_SLOW, 0,
 518     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 519     { m_unregistered, m_dns, m_dns, m_dns, m_ignore }
 520   },
 521   {
 522     MSG_REHASH,
 523     TOK_REHASH,
 524     0, MAXPARA, MFLG_SLOW, 0,
 525     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 526     { m_unregistered, m_not_oper, m_ignore, mo_rehash, m_ignore }
 527   },
 528   {
 529     MSG_RESTART,
 530     TOK_RESTART,
 531     0, MAXPARA, MFLG_SLOW, 0,
 532     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 533     { m_unregistered, m_not_oper, m_ignore, mo_restart, m_ignore }
 534   },
 535   {
 536     MSG_DIE,
 537     TOK_DIE,
 538     0, MAXPARA, MFLG_SLOW, 0,
 539     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 540     { m_unregistered, m_not_oper, m_ignore, mo_die, m_ignore }
 541   },
 542   {
 543     MSG_PROTO,
 544     TOK_PROTO,
 545     0, MAXPARA, MFLG_SLOW, 0,
 546     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 547     { m_proto, m_proto, m_proto, m_proto, m_ignore }
 548   },
 549   {
 550     MSG_SET,
 551     TOK_SET,
 552     0, MAXPARA, MFLG_SLOW, 0,
 553     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 554     { m_unregistered, m_not_oper, m_ignore, mo_set, m_ignore }
 555   },
 556   {
 557     MSG_RESET,
 558     TOK_RESET,
 559     0, MAXPARA, MFLG_SLOW, 0,
 560     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 561     { m_unregistered, m_not_oper, m_ignore, mo_reset, m_ignore }
 562   },
 563   {
 564     MSG_GET,
 565     TOK_GET,
 566     0, MAXPARA, MFLG_SLOW, 0,
 567     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 568     { m_unregistered, m_not_oper, m_ignore, mo_get, m_ignore }
 569   },
 570   {
 571     MSG_PRIVS,
 572     TOK_PRIVS,
 573     0, MAXPARA, MFLG_SLOW, 0,
 574     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 575     { m_unregistered, m_not_oper, m_ignore, mo_privs, m_ignore }
 576   },
 577   /* This command is an alias for QUIT during the unregistered part of
 578    * of the server.  This is because someone jumping via a broken web
 579    * proxy will send a 'POST' as their first command - which we will
 580    * obviously disconnect them immediately for, stopping people abusing
 581    * open gateways
 582    */
 583   {
 584     MSG_POST,
 585     TOK_POST,
 586     0, MAXPARA, MFLG_SLOW, 0,
 587     /* UNREG, CLIENT, SERVER, OPER, SERVICE */
 588     { m_quit, m_ignore, m_ignore, m_ignore, m_ignore }
 589   },
 590   { 0 }
 591 };
 592
 593
 594 static char *para[MAXPARA + 2]; /* leave room for prefix and null */
 595
 596 /*
 597  * Message Tree stuff mostly written by orabidoo, with changes by Dianora.
 598  * Adapted to Undernet, adding token support, etc by comstud 10/06/97
 599  */
 600
 601 static struct MessageTree msg_tree_cmd;
 602 static struct MessageTree msg_tree_tok;
 603
 604 /*
 605  * Guts of making the token tree...
 606  */
 607 static struct Message **do_msg_tree_tok(struct MessageTree *mtree, char *prefix,
 608     struct Message **mptr)
 609 {
 610   char newprefix[64];           /* Must be longer than every command name */
 611   int c, c2, lp;
 612   struct MessageTree *mtree1;
 613
 614   lp = strlen(prefix);
 615   if (!lp || !strncmp((*mptr)->tok, prefix, lp))
 616   {
 617     if (!mptr[1] || (lp && strncmp(mptr[1]->tok, prefix, lp)))
 618     {
 619       /* last command in the message struct or last command in this prefix */
 620       mtree->final = (*mptr)->tok + lp;
 621       mtree->msg = *mptr;
 622       for (c = 0; c < 26; ++c)
 623         mtree->pointers[c] = NULL;
 624       return mptr + 1;
 625     }
 626     /* command in this prefix */
 627     if (0 == ircd_strcmp((*mptr)->tok, prefix))
 628     {
 629       mtree->final = "";
 630       mtree->msg = *mptr++;
 631     }
 632     else
 633       mtree->final = NULL;
 634
 635     for (c = 'A'; c <= 'Z'; ++c)
 636     {
 637       if ((*mptr)->tok[lp] == c)
 638       {
 639         mtree1 = (struct MessageTree *)MyMalloc(sizeof(struct MessageTree));
 640         mtree1->final = NULL;
 641         mtree->pointers[c - 'A'] = mtree1;
 642         strcpy(newprefix, prefix);
 643         newprefix[lp] = c;
 644         newprefix[lp + 1] = '\0';
 645         mptr = do_msg_tree_tok(mtree1, newprefix, mptr);
 646         if (!*mptr || strncmp((*mptr)->tok, prefix, lp))
 647         {
 648           for (c2 = c + 1 - 'A'; c2 < 26; ++c2)
 649             mtree->pointers[c2] = NULL;
 650           return mptr;
 651         }
 652       }
 653       else
 654         mtree->pointers[c - 'A'] = NULL;
 655     }
 656     return mptr;
 657   }
 658   /*
 659    * XXX - should never be here, quick hack, this can be done better
 660    */
 661   assert(0);
 662   exit(1);
 663 }
 664
 665 /*
 666  * Guts of making the command tree...
 667  */
 668 static struct Message *do_msg_tree_cmd(struct MessageTree *mtree, char *prefix,
 669     struct Message *mptr)
 670 {
 671   char newprefix[64];           /* Must be longer than every command name */
 672   int c, c2, lp;
 673   struct MessageTree *mtree1;
 674
 675   lp = strlen(prefix);
 676   if (!lp || !strncmp(mptr->cmd, prefix, lp))
 677   {
 678     if (!mptr[1].cmd || (lp && strncmp(mptr[1].cmd, prefix, lp)))
 679     {
 680       /* last command in the message struct or last command in this prefix */
 681       mtree->final = mptr->cmd + lp;
 682       mtree->msg = mptr;
 683       for (c = 0; c < 26; ++c)
 684         mtree->pointers[c] = NULL;
 685       return mptr + 1;
 686     }
 687     /* command in this prefix */
 688     if (0 == ircd_strcmp(mptr->cmd, prefix))
 689     {
 690       mtree->final = "";
 691       mtree->msg = mptr++;
 692     }
 693     else
 694       mtree->final = NULL;
 695
 696     for (c = 'A'; c <= 'Z'; ++c)
 697     {
 698       if (mptr->cmd[lp] == c)
 699       {
 700         mtree1 = (struct MessageTree *)MyMalloc(sizeof(struct MessageTree));
 701         mtree1->final = NULL;
 702         mtree->pointers[c - 'A'] = mtree1;
 703         strcpy(newprefix, prefix);
 704         newprefix[lp] = c;
 705         newprefix[lp + 1] = '\0';
 706         mptr = do_msg_tree_cmd(mtree1, newprefix, mptr);
 707         if (!mptr->cmd || strncmp(mptr->cmd, prefix, lp))
 708         {
 709           for (c2 = c + 1 - 'A'; c2 < 26; ++c2)
 710             mtree->pointers[c2] = NULL;
 711           return mptr;
 712         }
 713       }
 714       else
 715         mtree->pointers[c - 'A'] = NULL;
 716     }
 717     return mptr;
 718   }
 719   /*
 720    * This should never happen
 721    */
 722   assert(0);
 723   exit(1);
 724 }
 725
 726 static int mcmdcmp(const struct Message *m1, const struct Message *m2)
 727 {
 728   return strcmp(m1->cmd, m2->cmd);
 729 }
 730
 731 static int mtokcmp(const struct Message **m1, const struct Message **m2)
 732 {
 733   return strcmp((*m1)->tok, (*m2)->tok);
 734 }
 735
 736 /*
 737  * Sort the command names.
 738  * Create table of pointers into msgtab for tokens.
 739  * Create trees for ->cmd and ->tok and free the token pointers.
 740  */
 741 void initmsgtree(void)
 742 {
 743   int i;
 744   struct Message *msg = msgtab;
 745   int ii;
 746   struct Message **msgtab_tok;
 747   struct Message **msgtok;
 748
 749   for (i = 0; msg->cmd; ++i, ++msg)
 750     continue;
 751   qsort(msgtab, i, sizeof(struct Message),
 752       (int (*)(const void *, const void *))mcmdcmp);
 753   msgtab_tok = (struct Message **)MyMalloc((i + 1) * sizeof(struct Message *));
 754   for (ii = 0; ii < i; ++ii)
 755     msgtab_tok[ii] = msgtab + ii;
 756   msgtab_tok[i] = NULL;         /* Needed by `do_msg_tree_tok' */
 757   qsort(msgtab_tok, i, sizeof(struct Message *),
 758       (int (*)(const void *, const void *))mtokcmp);
 759   msg = do_msg_tree_cmd(&msg_tree_cmd, "", msgtab);
 760   msgtok = do_msg_tree_tok(&msg_tree_tok, "", msgtab_tok);
 761   MyFree(msgtab_tok);
 762 }
 763
 764 /*
 765  * Generic tree parser which works for both commands and tokens.
 766  * Optimized by Run.
 767  */
 768 static struct Message *msg_tree_parse(char *cmd, struct MessageTree *root)
 769 {
 770   struct MessageTree *mtree;
 771   unsigned char r = (0xdf & (unsigned char)*cmd) - 'A';
 772   if (r > 25 || !(mtree = root->pointers[r]))
 773     return NULL;
 774   for (;;)
 775   {
 776     r = 0xdf & (unsigned char)*++cmd;
 777     if (mtree->final && *mtree->final == r)
 778       return mtree->msg;
 779     if ((r -= 'A') > 25 || !(mtree = mtree->pointers[r]))
 780       return NULL;
 781   }
 782 }
 783
 784 /*
 785  * This one is identical to the one above, but it is slower because it
 786  * makes sure that `cmd' matches the _full_ command, exactly.
 787  * This is to avoid confusion with commands like /quake on clients
 788  * that send unknown commands directly to the server.
 789  */
 790 static struct Message *msg_tree_parse_client(char *cmd,
 791     struct MessageTree *root)
 792 {
 793   struct MessageTree *mtree;
 794   unsigned char q = (0xdf & (unsigned char)*cmd) - 'A';
 795   if (q > 25 || !(mtree = root->pointers[q]))
 796     return NULL;
 797   for (;;)
 798   {
 799     q = 0xdf & (unsigned char)*++cmd;
 800     if (mtree->final && 0 == ircd_strcmp(mtree->final, cmd))
 801       return mtree->msg;
 802     if ((q -= 'A') > 25 || !(mtree = mtree->pointers[q]))
 803       return NULL;
 804   }
 805 }
 806
 807 /*
 808  * parse a buffer.
 809  *
 810  * NOTE: parse_*() should not be called recusively by any other fucntions!
 811  */
 812 int parse_client(struct Client *cptr, char *buffer, char *bufend)
 813 {
 814   struct Client*  from = cptr;
 815   char*           ch;
 816   char*           s;
 817   int             i;
 818   int             paramcount;
 819   int             noprefix = 0;
 820   struct Message* mptr;
 821   MessageHandler  handler = 0;
 822
 823   Debug((DEBUG_DEBUG, "Client Parsing: %s", buffer));
 824
 825   if (IsDead(cptr))
 826     return 0;
 827
 828   para[0] = cli_name(from);
 829   for (ch = buffer; *ch == ' '; ch++);  /* Eat leading spaces */
 830   if (*ch == ':')               /* Is any client doing this ? */
 831   {
 832     for (++ch; *ch && *ch != ' '; ++ch)
 833       ; /* Ignore sender prefix from client */
 834     while (*ch == ' ')
 835       ch++;                     /* Advance to command */
 836   }
 837   else
 838     noprefix = 1;
 839   if (*ch == '\0')
 840   {
 841     ServerStats->is_empt++;
 842     Debug((DEBUG_NOTICE, "Empty message from host %s:%s",
 843         cli_name(cptr), cli_name(from)));
 844     return (-1);
 845   }
 846
 847   if ((s = strchr(ch, ' ')))
 848     *s++ = '\0';
 849
 850   /*
 851    * This is a client/unregistered entity.
 852    * Check long command list only.
 853    */
 854   if (!(mptr = msg_tree_parse_client(ch, &msg_tree_cmd)))
 855   {
 856     /*
 857      * Note: Give error message *only* to recognized
 858      * persons. It's a nightmare situation to have
 859      * two programs sending "Unknown command"'s or
 860      * equivalent to each other at full blast....
 861      * If it has got to person state, it at least
 862      * seems to be well behaving. Perhaps this message
 863      * should never be generated, though...  --msa
 864      * Hm, when is the buffer empty -- if a command
 865      * code has been found ?? -Armin
 866      */
 867     if (buffer[0] != '\0')
 868     {
 869       if (IsUser(from))
 870         send_reply(from, ERR_UNKNOWNCOMMAND, ch);
 871       Debug((DEBUG_ERROR, "Unknown (%s) from %s",
 872             ch, get_client_name(cptr, HIDE_IP)));
 873     }
 874     ServerStats->is_unco++;
 875     return (-1);
 876   }
 877
 878   paramcount = mptr->parameters;
 879   i = bufend - ((s) ? s : ch);
 880   mptr->bytes += i;
 881   if ((mptr->flags & MFLG_SLOW))
 882     cli_since(cptr) += (2 + i / 120);
 883   /*
 884    * Allow only 1 msg per 2 seconds
 885    * (on average) to prevent dumping.
 886    * to keep the response rate up,
 887    * bursts of up to 5 msgs are allowed
 888    * -SRB
 889    */
 890
 891   /*
 892    * Must the following loop really be so devious? On
 893    * surface it splits the message to parameters from
 894    * blank spaces. But, if paramcount has been reached,
 895    * the rest of the message goes into this last parameter
 896    * (about same effect as ":" has...) --msa
 897    */
 898
 899   /* Note initially true: s==NULL || *(s-1) == '\0' !! */
 900
 901   i = 0;
 902   if (s)
 903   {
 904     if (paramcount > MAXPARA)
 905       paramcount = MAXPARA;
 906     for (;;)
 907     {
 908       /*
 909        * Never "FRANCE " again!! ;-) Clean
 910        * out *all* blanks.. --msa
 911        */
 912       while (*s == ' ')
 913         *s++ = '\0';
 914
 915       if (*s == '\0')
 916         break;
 917       if (*s == ':')
 918       {
 919         /*
 920          * The rest is single parameter--can
 921          * include blanks also.
 922          */
 923         para[++i] = s + 1;
 924         break;
 925       }
 926       para[++i] = s;
 927       if (i >= paramcount)
 928         break;
 929       for (; *s != ' ' && *s; s++);
 930     }
 931   }
 932   para[++i] = NULL;
 933   ++mptr->count;
 934
 935   handler = mptr->handlers[cli_handler(cptr)];
 936   assert(0 != handler);
 937
 938   if (!feature_bool(FEAT_IDLE_FROM_MSG) && IsUser(cptr) &&
 939       handler != m_ping && handler != m_ignore)
 940     cli_user(from)->last = CurrentTime;
 941
 942   return (*handler) (cptr, from, i, para);
 943 }
 944
 945 int parse_server(struct Client *cptr, char *buffer, char *bufend)
 946 {
 947   struct Client*  from = cptr;
 948   char*           ch = buffer;
 949   char*           s;
 950   int             len;
 951   int             i;
 952   int             numeric = 0;
 953   int             paramcount;
 954   struct Message* mptr;
 955
 956   Debug((DEBUG_DEBUG, "Server Parsing: %s", buffer));
 957
 958   if (IsDead(cptr))
 959     return 0;
 960
 961   para[0] = cli_name(from);
 962
 963   /*
 964    * A server ALWAYS sends a prefix. When it starts with a ':' it's the
 965    * protocol 9 prefix: a nick or a server name. Otherwise it's a numeric
 966    * nick or server
 967    */
 968   if (*ch == ':')
 969   {
 970     /* Let para[0] point to the name of the sender */
 971     para[0] = ch + 1;
 972     if (!(ch = strchr(ch, ' ')))
 973       return -1;
 974     *ch++ = '\0';
 975
 976     /* And let `from' point to its client structure,
 977        opps.. a server is _also_ a client --Nem */
 978     from = FindClient(para[0]);
 979
 980     /*
 981      * If the client corresponding to the
 982      * prefix is not found. We must ignore it,
 983      * it is simply a lagged message travelling
 984      * upstream a SQUIT that removed the client
 985      * --Run
 986      */
 987     if (!from)
 988     {
 989       Debug((DEBUG_NOTICE, "Unknown prefix (%s)(%s) from (%s)",
 990           para[0], buffer, cli_name(cptr)));
 991       ++ServerStats->is_unpf;
 992       while (*ch == ' ')
 993         ch++;
 994       /*
 995        * However, the only thing that MUST be
 996        * allowed to travel upstream against an
 997        * squit, is an SQUIT itself (the timestamp
 998        * protects us from being used wrong)
 999        */
1000       if (ch[1] == 'Q')
1001       {
1002         para[0] = cli_name(cptr);
1003         from = cptr;
1004       }
1005       else
1006         return 0;
1007     }
1008     else if (cli_from(from) != cptr)
1009     {
1010       ++ServerStats->is_wrdi;
1011       Debug((DEBUG_NOTICE, "Fake direction: Message (%s) coming from (%s)",
1012           buffer, cli_name(cptr)));
1013       return 0;
1014     }
1015   }
1016   else {
1017     char numeric_prefix[6];
1018     int  i;
1019     for (i = 0; i < 5; ++i) {
1020       if ('\0' == ch[i] || ' ' == (numeric_prefix[i] = ch[i])) {
1021         break;
1022       }
1023     }
1024     numeric_prefix[i] = '\0';
1025
1026     /*
1027      * We got a numeric nick as prefix
1028      * 1 or 2 character prefixes are from servers
1029      * 3 or 5 chars are from clients
1030      */
1031     if (0 == i) {
1032       protocol_violation(cptr,"Missing Prefix");
1033       from = cptr;
1034     }
1035     else if (' ' == ch[1] || ' ' == ch[2])
1036       from = FindNServer(numeric_prefix);
1037     else
1038       from = findNUser(numeric_prefix);
1039
1040     do
1041     {
1042       ++ch;
1043     }
1044     while (*ch != ' ' && *ch);
1045
1046     /*
1047      * If the client corresponding to the
1048      * prefix is not found. We must ignore it,
1049      * it is simply a lagged message travelling
1050      * upstream a SQUIT that removed the client
1051      * --Run
1052      * There turned out to be other reasons that
1053      * a prefix is unknown, needing an upstream
1054      * KILL.  Also, next to an SQUIT we better
1055      * allow a KILL to pass too.
1056      * --Run
1057      */
1058     if (!from)
1059     {
1060       ServerStats->is_unpf++;
1061       while (*ch == ' ')
1062         ch++;
1063       if (*ch == 'N' && (ch[1] == ' ' || ch[1] == 'I'))
1064         /* Only sent a KILL for a nick change */
1065       {
1066         struct Client *server;
1067         /* Kill the unknown numeric prefix upstream if
1068          * it's server still exists: */
1069         if ((server = FindNServer(numeric_prefix)) && cli_from(server) == cptr)
1070           sendcmdto_one(&me, CMD_KILL, cptr, "%s :%s (Unknown numeric nick)",
1071                         numeric_prefix, cli_name(&me));
1072       }
1073       /*
1074        * Things that must be allowed to travel
1075        * upstream against an squit:
1076        */
1077       if (ch[1] == 'Q' || (*ch == 'D' && ch[1] == ' ') ||
1078           (*ch == 'K' && ch[2] == 'L'))
1079         from = cptr;
1080       else
1081         return 0;
1082     }
1083
1084     /* Let para[0] point to the name of the sender */
1085     para[0] = cli_name(from);
1086
1087     if (cli_from(from) != cptr)
1088     {
1089       ServerStats->is_wrdi++;
1090       Debug((DEBUG_NOTICE, "Fake direction: Message (%s) coming from (%s)",
1091           buffer, cli_name(cptr)));
1092       return 0;
1093     }
1094   }
1095
1096   while (*ch == ' ')
1097     ch++;
1098   if (*ch == '\0')
1099   {
1100     ServerStats->is_empt++;
1101     Debug((DEBUG_NOTICE, "Empty message from host %s:%s",
1102         cli_name(cptr), cli_name(from)));
1103     return (-1);
1104   }
1105
1106   /*
1107    * Extract the command code from the packet.   Point s to the end
1108    * of the command code and calculate the length using pointer
1109    * arithmetic.  Note: only need length for numerics and *all*
1110    * numerics must have parameters and thus a space after the command
1111    * code. -avalon
1112    */
1113   s = strchr(ch, ' ');          /* s -> End of the command code */
1114   len = (s) ? (s - ch) : 0;
1115   if (len == 3 && IsDigit(*ch))
1116   {
1117     numeric = (*ch - '0') * 100 + (*(ch + 1) - '0') * 10 + (*(ch + 2) - '0');
1118     paramcount = 2; /* destination, and the rest of it */
1119     ServerStats->is_num++;
1120     mptr = NULL;                /* Init. to avoid stupid compiler warning :/ */
1121   }
1122   else
1123   {
1124     if (s)
1125       *s++ = '\0';
1126
1127     /* Version      Receive         Send
1128      * 2.9          Long            Long
1129      * 2.10.0       Tkn/Long        Long
1130      * 2.10.10      Tkn/Long        Tkn
1131      * 2.10.20      Tkn             Tkn
1132      *
1133      * Clients/unreg servers always receive/
1134      * send long commands   -record
1135      */
1136
1137     /*
1138      * This is a server. Check the token command list.
1139      * -record!jegelhof@cloud9.net
1140      */
1141     mptr = msg_tree_parse(ch, &msg_tree_tok);
1142
1143 #if 1                           /* for 2.10.0/2.10.10 */
1144     /*
1145      * This code supports 2.9 and 2.10.0 sending long commands.
1146      * It makes more calls to ircd_strcmp() than the above
1147      * so it will be somewhat slower.
1148      */
1149     if (!mptr)
1150       mptr = msg_tree_parse(ch, &msg_tree_cmd);
1151 #endif /* 1 */
1152
1153     if (!mptr)
1154     {
1155       /*
1156        * Note: Give error message *only* to recognized
1157        * persons. It's a nightmare situation to have
1158        * two programs sending "Unknown command"'s or
1159        * equivalent to each other at full blast....
1160        * If it has got to person state, it at least
1161        * seems to be well behaving. Perhaps this message
1162        * should never be generated, though...   --msa
1163        * Hm, when is the buffer empty -- if a command
1164        * code has been found ?? -Armin
1165        */
1166 #ifdef DEBUGMODE
1167       if (buffer[0] != '\0')
1168       {
1169         Debug((DEBUG_ERROR, "Unknown (%s) from %s",
1170               ch, get_client_name(cptr, HIDE_IP)));
1171       }
1172 #endif
1173       ServerStats->is_unco++;
1174       return (-1);
1175     }
1176
1177     paramcount = mptr->parameters;
1178     i = bufend - ((s) ? s : ch);
1179     mptr->bytes += i;
1180   }
1181   /*
1182    * Must the following loop really be so devious? On
1183    * surface it splits the message to parameters from
1184    * blank spaces. But, if paramcount has been reached,
1185    * the rest of the message goes into this last parameter
1186    * (about same effect as ":" has...) --msa
1187    */
1188
1189   /* Note initially true: s==NULL || *(s-1) == '\0' !! */
1190
1191   i = 0;
1192   if (s)
1193   {
1194     if (paramcount > MAXPARA)
1195       paramcount = MAXPARA;
1196     for (;;)
1197     {
1198       /*
1199        * Never "FRANCE " again!! ;-) Clean
1200        * out *all* blanks.. --msa
1201        */
1202       while (*s == ' ')
1203         *s++ = '\0';
1204
1205       if (*s == '\0')
1206         break;
1207       if (*s == ':')
1208       {
1209         /*
1210          * The rest is single parameter--can
1211          * include blanks also.
1212          */
1213         if (numeric)
1214           para[++i] = s; /* preserve the colon to make do_numeric happy */
1215         else
1216           para[++i] = s + 1;
1217         break;
1218       }
1219       para[++i] = s;
1220       if (i >= paramcount)
1221         break;
1222       for (; *s != ' ' && *s; s++);
1223     }
1224   }
1225   para[++i] = NULL;
1226   if (numeric)
1227     return (do_numeric(numeric, (*buffer != ':'), cptr, from, i, para));
1228   mptr->count++;
1229
1230   return (*mptr->handlers[cli_handler(cptr)]) (cptr, from, i, para);
1231 }