ircd/list.c

   1 /*
   2  * IRC - Internet Relay Chat, ircd/list.c
   3  * Copyright (C) 1990 Jarkko Oikarinen and
   4  *                    University of Oulu, Finland
   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 "list.h"
  25 #include "client.h"
  26 #include "ircd.h"
  27 #include "ircd_alloc.h"
  28 #include "ircd_events.h"
  29 #include "ircd_reply.h"
  30 #include "ircd_string.h"
  31 #include "listener.h"
  32 #include "match.h"
  33 #include "numeric.h"
  34 #include "res.h"
  35 #include "s_auth.h"
  36 #include "s_bsd.h"
  37 #include "s_conf.h"
  38 #include "s_debug.h"
  39 #include "s_misc.h"
  40 #include "s_user.h"
  41 #include "send.h"
  42 #include "struct.h"
  43 #include "support.h"
  44 #include "whowas.h"
  45
  46 #include <assert.h>
  47 #include <stddef.h>  /* offsetof */
  48 #include <unistd.h>  /* close */
  49 #include <string.h>
  50
  51 #ifdef DEBUGMODE
  52 static struct liststats {
  53   int inuse;
  54 } clients, connections, users, servs, links;
  55 #endif
  56
  57 static unsigned int clientAllocCount;
  58 static struct Client* clientFreeList;
  59
  60 static unsigned int connectionAllocCount;
  61 static struct Connection* connectionFreeList;
  62
  63 static unsigned int slinkAllocCount;
  64 static struct SLink* slinkFreeList;
  65
  66 void init_list(void)
  67 {
  68   struct Client* cptr;
  69   struct Connection* con;
  70   int i;
  71   /*
  72    * pre-allocate MAXCONNECTIONS clients and connections
  73    */
  74   for (i = 0; i < MAXCONNECTIONS; ++i) {
  75     cptr = (struct Client*) MyMalloc(sizeof(struct Client));
  76     cli_next(cptr) = clientFreeList;
  77     clientFreeList = cptr;
  78     ++clientAllocCount;
  79
  80     con = (struct Connection*) MyMalloc(sizeof(struct Connection));
  81     con_next(con) = connectionFreeList;
  82     connectionFreeList = con;
  83     ++connectionAllocCount;
  84   }
  85
  86 #ifdef DEBUGMODE
  87   memset(&clients, 0, sizeof(clients));
  88   memset(&connections, 0, sizeof(connections));
  89   memset(&users, 0, sizeof(users));
  90   memset(&servs, 0, sizeof(servs));
  91   memset(&links, 0, sizeof(links));
  92 #endif
  93 }
  94
  95 static struct Client* alloc_client(void)
  96 {
  97   struct Client* cptr = clientFreeList;
  98
  99   if (!cptr) {
 100     cptr = (struct Client*) MyMalloc(sizeof(struct Client));
 101     ++clientAllocCount;
 102   } else
 103     clientFreeList = cli_next(cptr);
 104
 105 #ifdef DEBUGMODE
 106   clients.inuse++;
 107 #endif
 108
 109   memset(cptr, 0, sizeof(struct Client));
 110
 111   return cptr;
 112 }
 113
 114 static void dealloc_client(struct Client* cptr)
 115 {
 116   assert(cli_verify(cptr));
 117   assert(0 == cli_connect(cptr));
 118
 119 #ifdef DEBUGMODE
 120   --clients.inuse;
 121 #endif
 122
 123   cli_next(cptr) = clientFreeList;
 124   clientFreeList = cptr;
 125
 126   cli_magic(cptr) = 0;
 127 }
 128
 129 static struct Connection* alloc_connection(void)
 130 {
 131   struct Connection* con = connectionFreeList;
 132
 133   if (!con) {
 134     con = (struct Connection*) MyMalloc(sizeof(struct Connection));
 135     ++connectionAllocCount;
 136   } else
 137     connectionFreeList = con_next(con);
 138
 139 #ifdef DEBUGMODE
 140   connections.inuse++;
 141 #endif
 142
 143   memset(con, 0, sizeof(struct Connection));
 144   timer_init(&(con_proc(con)));
 145
 146   return con;
 147 }
 148
 149 static void dealloc_connection(struct Connection* con)
 150 {
 151   assert(con_verify(con));
 152   assert(!t_active(&(con_proc(con))));
 153   assert(!t_onqueue(&(con_proc(con))));
 154
 155   Debug((DEBUG_LIST, "Deallocating connection %p", con));
 156
 157   if (con_dns_reply(con))
 158     --(con_dns_reply(con)->ref_count);
 159   if (-1 < con_fd(con))
 160     close(con_fd(con));
 161   MsgQClear(&(con_sendQ(con)));
 162   client_drop_sendq(con);
 163   DBufClear(&(con_recvQ(con)));
 164   if (con_listener(con))
 165     release_listener(con_listener(con));
 166
 167 #ifdef DEBUGMODE
 168   --connections.inuse;
 169 #endif
 170
 171   con_next(con) = connectionFreeList;
 172   connectionFreeList = con;
 173
 174   con_magic(con) = 0;
 175 }
 176
 177 /*
 178  * Create a new struct Client structure and set it to initial state.
 179  *
 180  *   from == NULL,   create local client (a client connected to a socket).
 181  *
 182  *   from != NULL,   create remote client (behind a socket associated with
 183  *                   the client defined by 'from').
 184  *                   ('from' is a local client!!).
 185  */
 186 struct Client* make_client(struct Client *from, int status)
 187 {
 188   struct Client* cptr = 0;
 189   struct Connection* con = 0;
 190
 191   assert(!from || cli_verify(from));
 192
 193   cptr = alloc_client();
 194
 195   assert(0 != cptr);
 196   assert(!cli_magic(cptr));
 197   assert(0 == from || 0 != cli_connect(from));
 198
 199   if (!from) { /* local client, allocate a struct Connection */
 200     con = alloc_connection();
 201
 202     assert(0 != con);
 203     assert(!con_magic(con));
 204
 205     con_magic(con) = CONNECTION_MAGIC;
 206     con_fd(con) = -1; /* initialize struct Connection */
 207     con_freeflag(con) = 0;
 208     con_nextnick(con) = CurrentTime - NICK_DELAY;
 209     con_nexttarget(con) = CurrentTime - (TARGET_DELAY * (STARTTARGETS - 1));
 210     con_handler(con) = UNREGISTERED_HANDLER;
 211     con_client(con) = cptr;
 212
 213     cli_local(cptr) = 1; /* Set certain fields of the struct Client */
 214     cli_since(cptr) = cli_lasttime(cptr) = cli_firsttime(cptr) = CurrentTime;
 215     cli_lastnick(cptr) = TStime();
 216   } else
 217     con = cli_connect(from); /* use 'from's connection */
 218
 219   assert(0 != con);
 220   assert(con_verify(con));
 221
 222   cli_magic(cptr) = CLIENT_MAGIC;
 223   cli_connect(cptr) = con; /* set the connection and other fields */
 224   cli_status(cptr) = status;
 225   cli_hnext(cptr) = cptr;
 226   strcpy(cli_username(cptr), "unknown");
 227
 228   return cptr;
 229 }
 230
 231 void free_connection(struct Connection* con)
 232 {
 233   if (!con)
 234     return;
 235
 236   assert(con_verify(con));
 237   assert(0 == con_client(con));
 238
 239   dealloc_connection(con); /* deallocate the connection */
 240 }
 241
 242 void free_client(struct Client* cptr)
 243 {
 244   if (!cptr)
 245     return;
 246   /*
 247    * forget to remove the client from the hash table?
 248    */
 249   assert(cli_verify(cptr));
 250   assert(cli_hnext(cptr) == cptr);
 251   /* or from linked list? */
 252   assert(cli_next(cptr) == 0);
 253   assert(cli_prev(cptr) == 0);
 254
 255   Debug((DEBUG_LIST, "Freeing client %s [%p], connection %p", cli_name(cptr),
 256          cptr, cli_connect(cptr)));
 257
 258   if (cli_auth(cptr))
 259     destroy_auth_request(cli_auth(cptr), 0);
 260
 261   /* Make sure we didn't magically get re-added to the list */
 262   assert(cli_next(cptr) == 0);
 263   assert(cli_prev(cptr) == 0);
 264
 265   if (cli_from(cptr) == cptr) { /* in other words, we're local */
 266     cli_from(cptr) = 0;
 267     /* timer must be marked as not active */
 268     if (!cli_freeflag(cptr) && !t_active(&(cli_proc(cptr))))
 269       dealloc_connection(cli_connect(cptr)); /* connection not open anymore */
 270     else {
 271       if (-1 < cli_fd(cptr) && cli_freeflag(cptr) & FREEFLAG_SOCKET)
 272         socket_del(&(cli_socket(cptr))); /* queue a socket delete */
 273       if (cli_freeflag(cptr) & FREEFLAG_TIMER)
 274         timer_del(&(cli_proc(cptr))); /* queue a timer delete */
 275     }
 276   }
 277
 278   cli_connect(cptr) = 0;
 279
 280   dealloc_client(cptr); /* actually destroy the client */
 281 }
 282
 283 struct Server *make_server(struct Client *cptr)
 284 {
 285   struct Server *serv = cli_serv(cptr);
 286
 287   assert(cli_verify(cptr));
 288
 289   if (!serv)
 290   {
 291     serv = (struct Server*) MyMalloc(sizeof(struct Server));
 292     assert(0 != serv);
 293     memset(serv, 0, sizeof(struct Server)); /* All variables are 0 by default */
 294 #ifdef  DEBUGMODE
 295     servs.inuse++;
 296 #endif
 297     cli_serv(cptr) = serv;
 298     cli_serv(cptr)->lag = 60000;
 299     *serv->by = '\0';
 300     DupString(serv->last_error_msg, "<>");      /* String must be non-empty */
 301   }
 302   return cli_serv(cptr);
 303 }
 304
 305 /*
 306  * Taken the code from ExitOneClient() for this and placed it here.
 307  * - avalon
 308  */
 309 void remove_client_from_list(struct Client *cptr)
 310 {
 311   assert(cli_verify(cptr));
 312   assert(con_verify(cli_connect(cptr)));
 313   assert(!cli_prev(cptr) || cli_verify(cli_prev(cptr)));
 314   assert(!cli_next(cptr) || cli_verify(cli_next(cptr)));
 315
 316   if (cli_prev(cptr))
 317     cli_next(cli_prev(cptr)) = cli_next(cptr);
 318   else {
 319     GlobalClientList = cli_next(cptr);
 320     if (GlobalClientList)
 321       cli_prev(GlobalClientList) = 0;
 322   }
 323   if (cli_next(cptr))
 324     cli_prev(cli_next(cptr)) = cli_prev(cptr);
 325
 326   cli_next(cptr) = cli_prev(cptr) = 0;
 327
 328   if (IsUser(cptr) && cli_user(cptr)) {
 329     add_history(cptr, 0);
 330     off_history(cptr);
 331   }
 332   if (cli_user(cptr)) {
 333     free_user(cli_user(cptr));
 334     cli_user(cptr) = 0;
 335   }
 336
 337   if (cli_serv(cptr)) {
 338     if (cli_serv(cptr)->user) {
 339       free_user(cli_serv(cptr)->user);
 340       cli_serv(cptr)->user = 0;
 341     }
 342     if (cli_serv(cptr)->client_list)
 343       MyFree(cli_serv(cptr)->client_list);
 344     MyFree(cli_serv(cptr)->last_error_msg);
 345     MyFree(cli_serv(cptr));
 346 #ifdef  DEBUGMODE
 347     --servs.inuse;
 348 #endif
 349   }
 350   free_client(cptr);
 351 }
 352
 353 /*
 354  * Although only a small routine, it appears in a number of places
 355  * as a collection of a few lines...functions like this *should* be
 356  * in this file, shouldnt they ?  after all, this is list.c, isn't it ?
 357  * -avalon
 358  */
 359 void add_client_to_list(struct Client *cptr)
 360 {
 361   assert(cli_verify(cptr));
 362   assert(cli_next(cptr) == 0);
 363   assert(cli_prev(cptr) == 0);
 364
 365   /*
 366    * Since we always insert new clients to the top of the list,
 367    * this should mean the "me" is the bottom most item in the list.
 368    * XXX - don't always count on the above, things change
 369    */
 370   cli_prev(cptr) = 0;
 371   cli_next(cptr) = GlobalClientList;
 372   GlobalClientList = cptr;
 373   if (cli_next(cptr))
 374     cli_prev(cli_next(cptr)) = cptr;
 375 }
 376
 377 #if 0
 378 /* WARNING: Major CPU sink!
 379  *
 380  * This is a debugging routine meant to verify the integrity of the client
 381  * linked list.  It is meant to be comprehensive, to detect *any* corruption
 382  * of that list.  This means that it will be majorly CPU-intensive, and
 383  * should *only* be enabled on servers that have DEBUGMODE enabled.  Ignore
 384  * this warning at your peril!
 385  */
 386 void verify_client_list(void)
 387 {
 388   struct Client *client, *prev = 0, *sentinel = 0;
 389   extern unsigned int ircrandom(void);
 390
 391   for (client = GlobalClientList; client; client = cli_next(client)) {
 392     /* Verify that this is a valid client, not a free'd one */
 393     assert(cli_verify(client));
 394     /* Verify that the list hasn't suddenly jumped around */
 395     assert(cli_prev(client) == prev);
 396     /* Verify that the list hasn't become circular */
 397     assert(cli_next(client) != GlobalClientList);
 398     assert(!sentinel || client != sentinel);
 399
 400     prev = client; /* Remember what should preceed us */
 401     if (!(ircrandom() % 50)) /* probabilistic loop detector */
 402       sentinel = client;
 403   }
 404 }
 405 #endif /* DEBUGMODE */
 406
 407 /*
 408  * Look for ptr in the linked listed pointed to by link.
 409  */
 410 struct SLink *find_user_link(struct SLink *lp, struct Client *ptr)
 411 {
 412   if (ptr) {
 413     while (lp) {
 414       if (lp->value.cptr == ptr)
 415         return (lp);
 416       lp = lp->next;
 417     }
 418   }
 419   return NULL;
 420 }
 421
 422 struct SLink* make_link(void)
 423 {
 424   struct SLink* lp = slinkFreeList;
 425   if (lp)
 426     slinkFreeList = lp->next;
 427   else {
 428     lp = (struct SLink*) MyMalloc(sizeof(struct SLink));
 429     ++slinkAllocCount;
 430   }
 431   assert(0 != lp);
 432 #ifdef  DEBUGMODE
 433   links.inuse++;
 434 #endif
 435   return lp;
 436 }
 437
 438 void free_link(struct SLink* lp)
 439 {
 440   if (lp) {
 441     lp->next = slinkFreeList;
 442     slinkFreeList = lp;
 443   }
 444 #ifdef  DEBUGMODE
 445   links.inuse--;
 446 #endif
 447 }
 448
 449 struct DLink *add_dlink(struct DLink **lpp, struct Client *cp)
 450 {
 451   struct DLink* lp = (struct DLink*) MyMalloc(sizeof(struct DLink));
 452   assert(0 != lp);
 453   lp->value.cptr = cp;
 454   lp->prev = 0;
 455   if ((lp->next = *lpp))
 456     lp->next->prev = lp;
 457   *lpp = lp;
 458   return lp;
 459 }
 460
 461 void remove_dlink(struct DLink **lpp, struct DLink *lp)
 462 {
 463   assert(0 != lpp);
 464   assert(0 != lp);
 465
 466   if (lp->prev) {
 467     if ((lp->prev->next = lp->next))
 468       lp->next->prev = lp->prev;
 469   }
 470   else if ((*lpp = lp->next))
 471     lp->next->prev = NULL;
 472   MyFree(lp);
 473 }
 474
 475 #ifdef  DEBUGMODE
 476 void send_listinfo(struct Client *cptr, char *name)
 477 {
 478   int inuse = 0, mem = 0, tmp = 0;
 479
 480   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Clients: inuse: %d(%d)",
 481              clients.inuse, tmp = clients.inuse * sizeof(struct Client));
 482   mem += tmp;
 483   inuse += clients.inuse;
 484   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, "Connections: inuse: %d(%d)",
 485              connections.inuse,
 486              tmp = connections.inuse * sizeof(struct Connection));
 487   mem += tmp;
 488   inuse += connections.inuse;
 489   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Users: inuse: %d(%d)",
 490              users.inuse, tmp = users.inuse * sizeof(struct User));
 491   mem += tmp;
 492   inuse += users.inuse;
 493   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Servs: inuse: %d(%d)",
 494              servs.inuse, tmp = servs.inuse * sizeof(struct Server));
 495   mem += tmp;
 496   inuse += servs.inuse;
 497   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Links: inuse: %d(%d)",
 498              links.inuse, tmp = links.inuse * sizeof(struct SLink));
 499   mem += tmp;
 500   inuse += links.inuse;
 501   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Confs: inuse: %d(%d)",
 502              GlobalConfCount, tmp = GlobalConfCount * sizeof(struct ConfItem));
 503   mem += tmp;
 504   inuse += GlobalConfCount;
 505   send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Totals: inuse %d %d",
 506              inuse, mem);
 507 }
 508
 509 #endif