ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/client.c
(Generate patch)

Comparing ircd-hybrid/trunk/src/client.c (file contents):
Revision 3247 by michael, Sun Mar 30 17:54:34 2014 UTC vs.
Revision 4819 by michael, Sat Nov 1 16:49:40 2014 UTC

# Line 15 | Line 15
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., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18 > *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19   *  USA
20   */
21  
# Line 27 | Line 27
27   #include "stdinc.h"
28   #include "list.h"
29   #include "client.h"
30 #include "channel_mode.h"
30   #include "event.h"
32 #include "fdlist.h"
31   #include "hash.h"
32   #include "irc_string.h"
33   #include "ircd.h"
36 #include "s_gline.h"
34   #include "numeric.h"
35 < #include "packet.h"
39 < #include "s_auth.h"
35 > #include "auth.h"
36   #include "s_bsd.h"
37   #include "conf.h"
38   #include "log.h"
39 < #include "s_misc.h"
40 < #include "s_serv.h"
39 > #include "misc.h"
40 > #include "server.h"
41   #include "send.h"
42   #include "whowas.h"
43 < #include "s_user.h"
48 < #include "dbuf.h"
43 > #include "user.h"
44   #include "memory.h"
45   #include "mempool.h"
46   #include "hostmask.h"
47   #include "listener.h"
53 #include "irc_res.h"
48   #include "userhost.h"
49   #include "watch.h"
50   #include "rng_mt.h"
51   #include "parse.h"
52 + #include "ipcache.h"
53  
59 dlink_list listing_client_list = { NULL, NULL, 0 };
60 /* Pointer to beginning of Client list */
61 dlink_list global_client_list = {NULL, NULL, 0};
62 /* unknown/client pointer lists */
63 dlink_list unknown_list = {NULL, NULL, 0};
64 dlink_list local_client_list = {NULL, NULL, 0};
65 dlink_list serv_list = {NULL, NULL, 0};
66 dlink_list global_serv_list = {NULL, NULL, 0};
67 dlink_list oper_list = {NULL, NULL, 0};
54  
55 < static EVH check_pings;
56 <
57 < static mp_pool_t *client_pool  = NULL;
58 < static mp_pool_t *lclient_pool = NULL;
59 <
60 < static dlink_list dead_list  = { NULL, NULL, 0};
61 < static dlink_list abort_list = { NULL, NULL, 0};
55 > dlink_list listing_client_list;
56 > dlink_list unknown_list;
57 > dlink_list local_client_list;
58 > dlink_list local_server_list;
59 > dlink_list global_client_list;
60 > dlink_list global_server_list;
61 > dlink_list oper_list;
62  
63 + static mp_pool_t *client_pool, *connection_pool;
64 + static dlink_list dead_list, abort_list;
65   static dlink_node *eac_next;  /* next aborted client to exit */
66  
79 static void check_pings_list(dlink_list *);
80 static void check_unknowns_list(void);
81
82
83 /* client_init()
84 *
85 * inputs       - NONE
86 * output       - NONE
87 * side effects - initialize client free memory
88 */
89 void
90 client_init(void)
91 {
92  /* start off the check ping event ..  -- adrian
93   * Every 30 seconds is plenty -- db
94   */
95  client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
96  lclient_pool = mp_pool_new(sizeof(struct LocalUser), MP_CHUNK_SIZE_LCLIENT);
97  eventAdd("check_pings", check_pings, NULL, 5);
98 }
67  
68   /*
69   * make_client - create a new Client struct and set it to initial state.
# Line 117 | Line 85 | make_client(struct Client *from)
85   {
86    struct Client *client_p = mp_pool_get(client_pool);
87  
120  memset(client_p, 0, sizeof(*client_p));
121
88    if (!from)
89    {
90      client_p->from                      = client_p; /* 'from' of local client is self! */
91 <    client_p->localClient               = mp_pool_get(lclient_pool);
92 <
93 <    memset(client_p->localClient, 0, sizeof(*client_p->localClient));
94 <
95 <    client_p->localClient->since        = CurrentTime;
130 <    client_p->localClient->lasttime     = CurrentTime;
131 <    client_p->localClient->firsttime    = CurrentTime;
132 <    client_p->localClient->registration = REG_INIT;
91 >    client_p->connection               = mp_pool_get(connection_pool);
92 >    client_p->connection->since        = CurrentTime;
93 >    client_p->connection->lasttime     = CurrentTime;
94 >    client_p->connection->firsttime    = CurrentTime;
95 >    client_p->connection->registration = REG_INIT;
96  
97      /* as good a place as any... */
98 <    dlinkAdd(client_p, &client_p->localClient->lclient_node, &unknown_list);
98 >    dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list);
99    }
100    else
101      client_p->from = from; /* 'from' of local client is self! */
# Line 141 | Line 104 | make_client(struct Client *from)
104    client_p->hnext  = client_p;
105    SetUnknown(client_p);
106    strcpy(client_p->username, "unknown");
107 <  strcpy(client_p->svid, "0");
107 >  strcpy(client_p->account, "0");
108  
109    return client_p;
110   }
# Line 163 | Line 126 | free_client(struct Client *client_p)
126    assert(client_p->channel.head == NULL);
127    assert(dlink_list_length(&client_p->channel) == 0);
128    assert(dlink_list_length(&client_p->whowas) == 0);
129 <  assert(!IsServer(client_p) || (IsServer(client_p) && client_p->serv));
129 >  assert(!IsServer(client_p) || client_p->serv);
130  
131    MyFree(client_p->serv);
132    MyFree(client_p->certfp);
133  
134    if (MyConnect(client_p))
135    {
136 <    assert(client_p->localClient->invited.head == NULL);
137 <    assert(dlink_list_length(&client_p->localClient->invited) == 0);
138 <    assert(dlink_list_length(&client_p->localClient->watches) == 0);
136 >    assert(client_p->connection->invited.head == NULL);
137 >    assert(dlink_list_length(&client_p->connection->invited) == 0);
138 >    assert(dlink_list_length(&client_p->connection->watches) == 0);
139      assert(IsClosing(client_p) && IsDead(client_p));
140  
141 <    MyFree(client_p->localClient->response);
142 <    MyFree(client_p->localClient->auth_oper);
141 >    MyFree(client_p->connection->challenge_response);
142 >    MyFree(client_p->connection->challenge_operator);
143 >    client_p->connection->challenge_response = NULL;
144 >    client_p->connection->challenge_operator = NULL;
145  
146      /*
147       * clean up extra sockets from P-lines which have been discarded.
148       */
149 <    if (client_p->localClient->listener)
149 >    if (client_p->connection->listener)
150      {
151 <      assert(0 < client_p->localClient->listener->ref_count);
152 <      if (0 == --client_p->localClient->listener->ref_count &&
188 <          !client_p->localClient->listener->active)
189 <        free_listener(client_p->localClient->listener);
151 >      listener_release(client_p->connection->listener);
152 >      client_p->connection->listener = NULL;
153      }
154  
155 <    dbuf_clear(&client_p->localClient->buf_recvq);
156 <    dbuf_clear(&client_p->localClient->buf_sendq);
155 >    dbuf_clear(&client_p->connection->buf_recvq);
156 >    dbuf_clear(&client_p->connection->buf_sendq);
157  
158 <    mp_pool_release(client_p->localClient);
158 >    mp_pool_release(client_p->connection);
159    }
160  
161    mp_pool_release(client_p);
162   }
163  
201 /*
202 * check_pings - go through the local client list and check activity
203 * kill off stuff that should die
204 *
205 * inputs       - NOT USED (from event)
206 * output       - next time_t when check_pings() should be called again
207 * side effects -
208 *
209 *
210 * A PING can be sent to clients as necessary.
211 *
212 * Client/Server ping outs are handled.
213 */
214
215 /*
216 * Addon from adrian. We used to call this after nextping seconds,
217 * however I've changed it to run once a second. This is only for
218 * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
219 * run once a second makes life a lot easier - when a new client connects
220 * and they need a ping in 4 seconds, if nextping was set to 20 seconds
221 * we end up waiting 20 seconds. This is stupid. :-)
222 * I will optimise (hah!) check_pings() once I've finished working on
223 * tidying up other network IO evilnesses.
224 *     -- adrian
225 */
226
227 static void
228 check_pings(void *notused)
229 {
230  check_pings_list(&local_client_list);
231  check_pings_list(&serv_list);
232  check_unknowns_list();
233 }
234
164   /* check_pings_list()
165   *
166   * inputs       - pointer to list to check
# Line 241 | Line 170 | check_pings(void *notused)
170   static void
171   check_pings_list(dlink_list *list)
172   {
173 <  char scratch[IRCD_BUFSIZE];
173 >  char buf[IRCD_BUFSIZE] = "";
174    int ping = 0;      /* ping time value from client */
175 <  dlink_node *ptr = NULL, *next_ptr = NULL;
175 >  dlink_node *node = NULL, *node_next = NULL;
176  
177 <  DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
177 >  DLINK_FOREACH_SAFE(node, node_next, list->head)
178    {
179 <    struct Client *client_p = ptr->data;
179 >    struct Client *client_p = node->data;
180  
252    /*
253    ** Note: No need to notify opers here. It's
254    ** already done when "FLAGS_DEADSOCKET" is set.
255    */
181      if (IsDead(client_p))
182 <    {
258 <      /* Ignore it, its been exited already */
259 <      continue;
260 <    }
182 >      continue;  /* Ignore it, its been exited already */
183  
184      if (!IsRegistered(client_p))
185        ping = CONNECTTIMEOUT;
186      else
187 <      ping = get_client_ping(&client_p->localClient->confs);
187 >      ping = get_client_ping(&client_p->connection->confs);
188  
189 <    if (ping < CurrentTime - client_p->localClient->lasttime)
189 >    if (ping < CurrentTime - client_p->connection->lasttime)
190      {
191        if (!IsPingSent(client_p))
192        {
193          /*
194 <         * if we havent PINGed the connection and we havent
194 >         * If we haven't PINGed the connection and we haven't
195           * heard from it in a while, PING it to make sure
196           * it is still alive.
197           */
198          SetPingSent(client_p);
199 <        client_p->localClient->lasttime = CurrentTime - ping;
199 >        client_p->connection->lasttime = CurrentTime - ping;
200          sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
201        }
202        else
203        {
204 <        if (CurrentTime - client_p->localClient->lasttime >= 2 * ping)
204 >        if (CurrentTime - client_p->connection->lasttime >= 2 * ping)
205          {
206            /*
207             * If the client/server hasn't talked to us in 2*ping seconds
# Line 297 | Line 219 | check_pings_list(dlink_list *list)
219                   get_client_name(client_p, HIDE_IP));
220            }
221  
222 <          snprintf(scratch, sizeof(scratch), "Ping timeout: %d seconds",
223 <                   (int)(CurrentTime - client_p->localClient->lasttime));
224 <          exit_client(client_p, scratch);
222 >          snprintf(buf, sizeof(buf), "Ping timeout: %d seconds",
223 >                   (int)(CurrentTime - client_p->connection->lasttime));
224 >          exit_client(client_p, buf);
225          }
226        }
227      }
# Line 315 | Line 237 | check_pings_list(dlink_list *list)
237   static void
238   check_unknowns_list(void)
239   {
240 <  dlink_node *ptr = NULL, *ptr_next = NULL;
240 >  dlink_node *node = NULL, *node_next = NULL;
241  
242 <  DLINK_FOREACH_SAFE(ptr, ptr_next, unknown_list.head)
242 >  DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
243    {
244 <    struct Client *client_p = ptr->data;
244 >    struct Client *client_p = node->data;
245  
246      /*
247       * Check UNKNOWN connections - if they have been in this state
248       * for > 30s, close them.
249       */
250 <    if (IsAuthFinished(client_p) && (CurrentTime - client_p->localClient->firsttime) > 30)
250 >    if (IsAuthFinished(client_p) && (CurrentTime - client_p->connection->firsttime) > 30)
251        exit_client(client_p, "Registration timed out");
252    }
253   }
254  
255 + /*
256 + * check_pings - go through the local client list and check activity
257 + * kill off stuff that should die
258 + *
259 + * inputs       - NOT USED (from event)
260 + * output       - next time_t when check_pings() should be called again
261 + * side effects -
262 + *
263 + *
264 + * A PING can be sent to clients as necessary.
265 + *
266 + * Client/Server ping outs are handled.
267 + */
268 +
269 + /*
270 + * Addon from adrian. We used to call this after nextping seconds,
271 + * however I've changed it to run once a second. This is only for
272 + * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
273 + * run once a second makes life a lot easier - when a new client connects
274 + * and they need a ping in 4 seconds, if nextping was set to 20 seconds
275 + * we end up waiting 20 seconds. This is stupid. :-)
276 + * I will optimise (hah!) check_pings() once I've finished working on
277 + * tidying up other network IO evilnesses.
278 + *     -- adrian
279 + */
280 +
281 + static void
282 + check_pings(void *unused)
283 + {
284 +  check_pings_list(&local_client_list);
285 +  check_pings_list(&local_server_list);
286 +  check_unknowns_list();
287 + }
288 +
289   /* check_conf_klines()
290   *
291   * inputs       - NONE
# Line 340 | Line 296 | check_unknowns_list(void)
296   void
297   check_conf_klines(void)
298   {
343  struct Client *client_p = NULL;       /* current local client_p being examined */
299    struct MaskItem *conf = NULL;
300 <  dlink_node *ptr, *next_ptr;
300 >  dlink_node *node = NULL, *node_next = NULL;
301  
302 <  DLINK_FOREACH_SAFE(ptr, next_ptr, local_client_list.head)
302 >  DLINK_FOREACH_SAFE(node, node_next, local_client_list.head)
303    {
304 <    client_p = ptr->data;
304 >    struct Client *client_p = node->data;
305  
306      /* If a client is already being exited
307       */
308 <    if (IsDead(client_p) || !IsClient(client_p))
308 >    if (IsDead(client_p))
309        continue;
310  
311 <    if ((conf = find_dline_conf(&client_p->localClient->ip,
312 <                                  client_p->localClient->aftype)))
311 >    if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
312 >                                     client_p->connection->aftype, NULL, NULL, 1)))
313      {
359      if (conf->type == CONF_EXEMPT)
360        continue;
361
314        conf_try_ban(client_p, conf);
315        continue; /* and go examine next fd/client_p */
316      }
317  
318 <    if (ConfigFileEntry.glines)
318 >    if (ConfigGeneral.glines)
319      {
320 <      if ((conf = find_conf_by_address(client_p->host, &client_p->localClient->ip,
321 <                                       CONF_GLINE, client_p->localClient->aftype,
320 >      if ((conf = find_conf_by_address(client_p->host, &client_p->connection->ip,
321 >                                       CONF_GLINE, client_p->connection->aftype,
322                                         client_p->username, NULL, 1)))
323        {
324          conf_try_ban(client_p, conf);
# Line 375 | Line 327 | check_conf_klines(void)
327        }
328      }
329  
330 <    if ((conf = find_conf_by_address(client_p->host, &client_p->localClient->ip,
331 <                                     CONF_KLINE, client_p->localClient->aftype,
330 >    if ((conf = find_conf_by_address(client_p->host, &client_p->connection->ip,
331 >                                     CONF_KLINE, client_p->connection->aftype,
332                                       client_p->username, NULL, 1)))
333      {
334        conf_try_ban(client_p, conf);
# Line 392 | Line 344 | check_conf_klines(void)
344    }
345  
346    /* also check the unknowns list for new dlines */
347 <  DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
347 >  DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
348    {
349 <    client_p = ptr->data;
349 >    struct Client *client_p = node->data;
350  
351 <    if ((conf = find_dline_conf(&client_p->localClient->ip,
352 <                                 client_p->localClient->aftype)))
351 >    if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
352 >                                     client_p->connection->aftype, NULL, NULL, 1)))
353      {
354 <      if (conf->type == CONF_EXEMPT)
355 <        continue;
404 <
405 <      exit_client(client_p, "D-lined");
354 >      conf_try_ban(client_p, conf);
355 >      continue; /* and go examine next fd/client_p */
356      }
357    }
358   }
# Line 439 | Line 389 | conf_try_ban(struct Client *client_p, st
389        type_string = kline_string;
390        break;
391      case CONF_DLINE:
392 +      if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT,
393 +                               client_p->connection->aftype, NULL, NULL, 1))
394 +        return;
395        type_string = dline_string;
396        break;
397      case CONF_GLINE:
# Line 539 | Line 492 | find_chasing(struct Client *source_p, co
492      return NULL;
493  
494    if ((who = whowas_get_history(name,
495 <                         (time_t)ConfigFileEntry.kill_chase_time_limit))
495 >                         (time_t)ConfigGeneral.kill_chase_time_limit))
496                           == NULL)
497    {
498      sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name);
# Line 558 | Line 511 | find_chasing(struct Client *source_p, co
511   *        But, this can be used to any client structure.
512   *
513   * NOTE 1:
514 < *        Watch out the allocation of "nbuf", if either source_p->name
514 > *        Watch out the allocation of "buf", if either source_p->name
515   *        or source_p->sockhost gets changed into pointers instead of
516   *        directly allocated within the structure...
517   *
518   * NOTE 2:
519   *        Function return either a pointer to the structure (source_p) or
520 < *        to internal buffer (nbuf). *NEVER* use the returned pointer
520 > *        to internal buffer (buf). *NEVER* use the returned pointer
521   *        to modify what it points!!!
522   */
523   const char *
524   get_client_name(const struct Client *client_p, enum addr_mask_type type)
525   {
526 <  static char nbuf[HOSTLEN * 2 + USERLEN + 5];
526 >  static char buf[HOSTLEN * 2 + USERLEN + 5];
527  
528    assert(client_p);
529  
# Line 585 | Line 538 | get_client_name(const struct Client *cli
538        type = MASK_IP;
539    }
540  
541 <  if (ConfigFileEntry.hide_spoof_ips)
542 <    if (type == SHOW_IP && IsIPSpoof(client_p))
541 >  if (ConfigGeneral.hide_spoof_ips)
542 >    if (IsIPSpoof(client_p) && type == SHOW_IP)
543        type = MASK_IP;
544  
545    /* And finally, let's get the host information, ip or name */
546    switch (type)
547    {
548      case SHOW_IP:
549 <      snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]",
549 >      snprintf(buf, sizeof(buf), "%s[%s@%s]",
550                 client_p->name,
551                 client_p->username, client_p->sockhost);
552        break;
553      case MASK_IP:
554 <      if (client_p->localClient->aftype == AF_INET)
555 <        snprintf(nbuf, sizeof(nbuf), "%s[%s@255.255.255.255]",
554 >      if (client_p->connection->aftype == AF_INET)
555 >        snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]",
556                   client_p->name, client_p->username);
557        else
558 <        snprintf(nbuf, sizeof(nbuf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
558 >        snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
559                   client_p->name, client_p->username);
560        break;
561      default:
562 <      snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]",
562 >      snprintf(buf, sizeof(buf), "%s[%s@%s]",
563                 client_p->name,
564                 client_p->username, client_p->host);
565    }
566  
567 <  return nbuf;
567 >  return buf;
568   }
569  
570   void
571   free_exited_clients(void)
572   {
573 <  dlink_node *ptr = NULL, *next = NULL;
573 >  dlink_node *node = NULL, *node_next = NULL;
574  
575 <  DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
575 >  DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
576    {
577 <    free_client(ptr->data);
578 <    dlinkDelete(ptr, &dead_list);
579 <    free_dlink_node(ptr);
577 >    free_client(node->data);
578 >    dlinkDelete(node, &dead_list);
579 >    free_dlink_node(node);
580    }
581   }
582  
# Line 634 | Line 587 | free_exited_clients(void)
587   * The only messages generated are QUITs on channels.
588   */
589   static void
590 < exit_one_client(struct Client *source_p, const char *quitmsg)
590 > exit_one_client(struct Client *source_p, const char *comment)
591   {
592 <  dlink_node *ptr = NULL, *ptr_next = NULL;
592 >  dlink_node *node = NULL, *node_next = NULL;
593  
594    assert(!IsMe(source_p));
595 +  assert(source_p != &me);
596  
597    if (IsClient(source_p))
598    {
599      dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
600 +    dlinkDelete(&source_p->node, &global_client_list);
601  
602      /*
603       * If a person is on a channel, send a QUIT notice
# Line 652 | Line 607 | exit_one_client(struct Client *source_p,
607       */
608      sendto_common_channels_local(source_p, 0, 0, ":%s!%s@%s QUIT :%s",
609                                   source_p->name, source_p->username,
610 <                                 source_p->host, quitmsg);
611 <    DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->channel.head)
612 <      remove_user_from_channel(ptr->data);
610 >                                 source_p->host, comment);
611 >    DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
612 >      remove_user_from_channel(node->data);
613  
614      whowas_add_history(source_p, 0);
615      whowas_off_history(source_p);
# Line 664 | Line 619 | exit_one_client(struct Client *source_p,
619      if (MyConnect(source_p))
620      {
621        /* Clean up invitefield */
622 <      DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->localClient->invited.head)
623 <        del_invite(ptr->data, source_p);
622 >      DLINK_FOREACH_SAFE(node, node_next, source_p->connection->invited.head)
623 >        del_invite(node->data, source_p);
624  
625        del_all_accepts(source_p);
626      }
# Line 673 | Line 628 | exit_one_client(struct Client *source_p,
628    else if (IsServer(source_p))
629    {
630      dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
631 +    dlinkDelete(&source_p->node, &global_client_list);
632  
633 <    if ((ptr = dlinkFindDelete(&global_serv_list, source_p)))
634 <      free_dlink_node(ptr);
633 >    if ((node = dlinkFindDelete(&global_server_list, source_p)))
634 >      free_dlink_node(node);
635    }
636  
637    /* Remove source_p from the client lists */
# Line 687 | Line 643 | exit_one_client(struct Client *source_p,
643    if (IsUserHostIp(source_p))
644      delete_user_host(source_p->username, source_p->host, !MyConnect(source_p));
645  
690  /* remove from global client list
691   * NOTE: source_p->node.next cannot be NULL if the client is added
692   *       to global_client_list (there is always &me at its end)
693   */
694  if (source_p->node.next) /* XXX: not needed? */
695    dlinkDelete(&source_p->node, &global_client_list);
696
646    update_client_exit_stats(source_p);
647  
648    /* Check to see if the client isn't already on the dead list */
# Line 711 | Line 660 | exit_one_client(struct Client *source_p,
660   * actually removing things off llists.   tweaked from +CSr31  -orabidoo
661   */
662   static void
663 < recurse_remove_clients(struct Client *source_p, const char *quitmsg)
663 > recurse_remove_clients(struct Client *source_p, const char *comment)
664   {
665 <  dlink_node *ptr = NULL, *ptr_next = NULL;
665 >  dlink_node *node = NULL, *node_next = NULL;
666  
667 <  DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->client_list.head)
668 <    exit_one_client(ptr->data, quitmsg);
667 >  DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
668 >    exit_one_client(node->data, comment);
669  
670 <  DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->server_list.head)
670 >  DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
671    {
672 <    recurse_remove_clients(ptr->data, quitmsg);
673 <    exit_one_client(ptr->data, quitmsg);
672 >    recurse_remove_clients(node->data, comment);
673 >    exit_one_client(node->data, comment);
674    }
675   }
676  
# Line 745 | Line 694 | recurse_remove_clients(struct Client *so
694   void
695   exit_client(struct Client *source_p, const char *comment)
696   {
697 <  dlink_node *m = NULL;
697 >  dlink_node *node = NULL;
698 >
699 >  assert(!IsMe(source_p));
700 >  assert(source_p != &me);
701  
702    if (MyConnect(source_p))
703    {
# Line 757 | Line 709 | exit_client(struct Client *source_p, con
709  
710      SetClosing(source_p);
711  
712 <    if (IsIpHash(source_p))
713 <      remove_one_ip(&source_p->localClient->ip);
712 >    if (HasFlag(source_p, FLAGS_IPHASH))
713 >    {
714 >      DelFlag(source_p, FLAGS_IPHASH);
715 >      ipcache_remove_address(&source_p->connection->ip);
716 >    }
717  
718 <    delete_auth(&source_p->localClient->auth);
718 >    delete_auth(&source_p->connection->auth);
719  
720      /*
721       * This source_p could have status of one of STAT_UNKNOWN, STAT_CONNECTING
# Line 773 | Line 728 | exit_client(struct Client *source_p, con
728      {
729        assert(dlinkFind(&unknown_list, source_p));
730  
731 <      dlinkDelete(&source_p->localClient->lclient_node, &unknown_list);
731 >      dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
732      }
733      else if (IsClient(source_p))
734      {
735 <      time_t on_for = CurrentTime - source_p->localClient->firsttime;
735 >      time_t on_for = CurrentTime - source_p->connection->firsttime;
736        assert(Count.local > 0);
737        Count.local--;
738  
739        if (HasUMode(source_p, UMODE_OPER))
740 <        if ((m = dlinkFindDelete(&oper_list, source_p)))
741 <          free_dlink_node(m);
740 >        if ((node = dlinkFindDelete(&oper_list, source_p)))
741 >          free_dlink_node(node);
742  
743        assert(dlinkFind(&local_client_list, source_p));
744 <      dlinkDelete(&source_p->localClient->lclient_node, &local_client_list);
744 >      dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
745  
746 <      if (source_p->localClient->list_task)
747 <        free_list_task(source_p->localClient->list_task, source_p);
746 >      if (source_p->connection->list_task)
747 >        free_list_task(source_p);
748  
749        watch_del_watch_list(source_p);
750        sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
751                             "Client exiting: %s (%s@%s) [%s] [%s]",
752                             source_p->name, source_p->username, source_p->host, comment,
753 <                           ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
753 >                           ConfigGeneral.hide_spoof_ips && IsIPSpoof(source_p) ?
754                             "255.255.255.255" : source_p->sockhost);
755        ilog(LOG_TYPE_USER, "%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu",
756 <           myctime(source_p->localClient->firsttime), (unsigned int)(on_for / 3600),
756 >           myctime(source_p->connection->firsttime), (unsigned int)(on_for / 3600),
757             (unsigned int)((on_for % 3600)/60), (unsigned int)(on_for % 60),
758             source_p->name, source_p->username, source_p->host,
759 <           source_p->localClient->send.bytes>>10,
760 <           source_p->localClient->recv.bytes>>10);
759 >           source_p->connection->send.bytes>>10,
760 >           source_p->connection->recv.bytes>>10);
761      }
762      else if (IsServer(source_p))
763      {
764        assert(Count.myserver > 0);
765        --Count.myserver;
766  
767 <      assert(dlinkFind(&serv_list, source_p));
768 <      dlinkDelete(&source_p->localClient->lclient_node, &serv_list);
767 >      assert(dlinkFind(&local_server_list, source_p));
768 >      dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
769      }
770  
771      if (!IsDead(source_p))
# Line 829 | Line 784 | exit_client(struct Client *source_p, con
784                   source_p->host, comment);
785      }
786  
832    /*
833    ** Currently only server connections can have
834    ** depending remote clients here, but it does no
835    ** harm to check for all local clients. In
836    ** future some other clients than servers might
837    ** have remotes too...
838    **
839    ** Close the Client connection first and mark it
840    ** so that no messages are attempted to send to it.
841    ** Remember it makes source_p->from == NULL.
842    */
787      close_connection(source_p);
788    }
789    else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
# Line 865 | Line 809 | exit_client(struct Client *source_p, con
809        snprintf(splitstr, sizeof(splitstr), "%s %s",
810                 source_p->servptr->name, source_p->name);
811  
812 <    /* Send SQUIT for source_p in every direction. source_p is already off of serv_list here */
812 >    /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
813      if (!HasFlag(source_p, FLAGS_SQUIT))
814        sendto_server(NULL, NOCAPS, NOCAPS, "SQUIT %s :%s", source_p->id, comment);
815  
# Line 874 | Line 818 | exit_client(struct Client *source_p, con
818  
819      if (MyConnect(source_p))
820      {
821 +      int connected = CurrentTime - source_p->connection->firsttime;
822        sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
823 <                           "%s was connected for %d seconds.  %llu/%llu sendK/recvK.",
824 <                           source_p->name, (int)(CurrentTime - source_p->localClient->firsttime),
825 <                           source_p->localClient->send.bytes >> 10,
826 <                           source_p->localClient->recv.bytes >> 10);
827 <      ilog(LOG_TYPE_IRCD, "%s was connected for %d seconds.  %llu/%llu sendK/recvK.",
828 <           source_p->name, (int)(CurrentTime - source_p->localClient->firsttime),
829 <           source_p->localClient->send.bytes >> 10,
830 <           source_p->localClient->recv.bytes >> 10);
823 >                           "%s was connected for %d day%s, %2d:%02d:%02d. %llu/%llu sendK/recvK.",
824 >                           source_p->name, connected/86400, (connected/86400 == 1) ? "" : "s",
825 >                           (connected % 86400) / 3600, (connected % 3600) / 60, connected % 60,
826 >                           source_p->connection->send.bytes >> 10,
827 >                           source_p->connection->recv.bytes >> 10);
828 >      ilog(LOG_TYPE_IRCD, "%s was connected for %d day%s, %2d:%02d:%02d. %llu/%llu sendK/recvK.",
829 >           source_p->name, connected/86400, (connected/86400 == 1) ? "" : "s",
830 >          (connected % 86400) / 3600, (connected % 3600) / 60, connected % 60,
831 >          source_p->connection->send.bytes >> 10,
832 >          source_p->connection->recv.bytes >> 10);
833      }
834    }
835    else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
# Line 892 | Line 839 | exit_client(struct Client *source_p, con
839    /* The client *better* be off all of the lists */
840    assert(dlinkFind(&unknown_list, source_p) == NULL);
841    assert(dlinkFind(&local_client_list, source_p) == NULL);
842 <  assert(dlinkFind(&serv_list, source_p) == NULL);
842 >  assert(dlinkFind(&local_server_list, source_p) == NULL);
843    assert(dlinkFind(&oper_list, source_p) == NULL);
844  
845    exit_one_client(source_p, comment);
# Line 905 | Line 852 | exit_client(struct Client *source_p, con
852   void
853   dead_link_on_write(struct Client *client_p, int ierrno)
854   {
855 <  dlink_node *ptr;
855 >  dlink_node *node;
856  
857    if (IsDefunct(client_p))
858      return;
859  
860 <  dbuf_clear(&client_p->localClient->buf_recvq);
861 <  dbuf_clear(&client_p->localClient->buf_sendq);
860 >  dbuf_clear(&client_p->connection->buf_recvq);
861 >  dbuf_clear(&client_p->connection->buf_sendq);
862  
863    assert(dlinkFind(&abort_list, client_p) == NULL);
864 <  ptr = make_dlink_node();
864 >  node = make_dlink_node();
865    /* don't let exit_aborted_clients() finish yet */
866 <  dlinkAddTail(client_p, ptr, &abort_list);
866 >  dlinkAddTail(client_p, node, &abort_list);
867  
868    if (eac_next == NULL)
869 <    eac_next = ptr;
869 >    eac_next = node;
870  
871    SetDead(client_p); /* You are dead my friend */
872   }
# Line 937 | Line 884 | dead_link_on_read(struct Client *client_
884    if (IsDefunct(client_p))
885      return;
886  
887 <  dbuf_clear(&client_p->localClient->buf_recvq);
888 <  dbuf_clear(&client_p->localClient->buf_sendq);
887 >  dbuf_clear(&client_p->connection->buf_recvq);
888 >  dbuf_clear(&client_p->connection->buf_sendq);
889  
890 <  current_error = get_sockerr(client_p->localClient->fd.fd);
890 >  current_error = get_sockerr(client_p->connection->fd.fd);
891  
892    if (IsServer(client_p) || IsHandshake(client_p))
893    {
894 <    int connected = CurrentTime - client_p->localClient->firsttime;
894 >    int connected = CurrentTime - client_p->connection->firsttime;
895  
896      if (error == 0)
897      {
# Line 970 | Line 917 | dead_link_on_read(struct Client *client_
917      }
918  
919      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
920 <                         "%s had been connected for %d day%s, %2d:%02d:%02d",
920 >                         "%s was connected for %d day%s, %2d:%02d:%02d",
921                           client_p->name, connected/86400,
922                           (connected/86400 == 1) ? "" : "s",
923                           (connected % 86400) / 3600, (connected % 3600) / 60,
# Line 1033 | Line 980 | exit_aborted_clients(void)
980   void
981   del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
982   {
983 <  dlinkDelete(&accept_p->node, &client_p->localClient->acceptlist);
983 >  dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
984  
985    MyFree(accept_p->nickptr);
986    MyFree(accept_p->userptr);
# Line 1046 | Line 993 | find_accept(const char *nick, const char
993              const char *host, struct Client *client_p,
994              int (*cmpfunc)(const char *, const char *))
995   {
996 <  dlink_node *ptr = NULL;
996 >  dlink_node *node = NULL;
997  
998 <  DLINK_FOREACH(ptr, client_p->localClient->acceptlist.head)
998 >  DLINK_FOREACH(node, client_p->connection->acceptlist.head)
999    {
1000 <    struct split_nuh_item *accept_p = ptr->data;
1000 >    struct split_nuh_item *accept_p = node->data;
1001  
1002      if (!cmpfunc(accept_p->nickptr, nick) &&
1003          !cmpfunc(accept_p->userptr, user) &&
# Line 1072 | Line 1019 | int
1019   accept_message(struct Client *source,
1020                 struct Client *target)
1021   {
1022 <  dlink_node *ptr = NULL;
1022 >  dlink_node *node = NULL;
1023  
1024    if (source == target || find_accept(source->name, source->username,
1025                                        source->host, target, match))
1026      return 1;
1027  
1028 <  if (HasUMode(target, UMODE_SOFTCALLERID))
1029 <    DLINK_FOREACH(ptr, target->channel.head)
1030 <      if (IsMember(source, ((struct Membership *)ptr->data)->chptr))
1028 >  if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1029 >    DLINK_FOREACH(node, target->channel.head)
1030 >      if (IsMember(source, ((struct Membership *)node->data)->chptr))
1031          return 1;
1032  
1033    return 0;
# Line 1095 | Line 1042 | accept_message(struct Client *source,
1042   void
1043   del_all_accepts(struct Client *client_p)
1044   {
1045 <  dlink_node *ptr = NULL, *ptr_next = NULL;
1045 >  dlink_node *node = NULL, *node_next = NULL;
1046  
1047 <  DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->acceptlist.head)
1048 <    del_accept(ptr->data, client_p);
1047 >  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1048 >    del_accept(node->data, client_p);
1049   }
1050  
1051   unsigned int
# Line 1107 | Line 1054 | idle_time_get(const struct Client *sourc
1054    unsigned int idle = 0;
1055    unsigned int min_idle = 0;
1056    unsigned int max_idle = 0;
1057 <  const struct ClassItem *class = get_class_ptr(&target_p->localClient->confs);
1057 >  const struct ClassItem *class = get_class_ptr(&target_p->connection->confs);
1058  
1059    if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1060 <    return CurrentTime - target_p->localClient->last_privmsg;
1060 >    return CurrentTime - target_p->connection->last_privmsg;
1061    if (HasUMode(source_p, UMODE_OPER) &&
1062        !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1063 <    return CurrentTime - target_p->localClient->last_privmsg;
1063 >    return CurrentTime - target_p->connection->last_privmsg;
1064  
1065    min_idle = class->min_idle;
1066    max_idle = class->max_idle;
# Line 1124 | Line 1071 | idle_time_get(const struct Client *sourc
1071    if (class->flags & CLASS_FLAGS_RANDOM_IDLE)
1072      idle = genrand_int32();
1073    else
1074 <    idle = CurrentTime - target_p->localClient->last_privmsg;
1074 >    idle = CurrentTime - target_p->connection->last_privmsg;
1075  
1076    if (!max_idle)
1077      idle = 0;
# Line 1136 | Line 1083 | idle_time_get(const struct Client *sourc
1083  
1084    return idle;
1085   }
1086 +
1087 + /* client_init()
1088 + *
1089 + * inputs       - NONE
1090 + * output       - NONE
1091 + * side effects - initialize client free memory
1092 + */
1093 + void
1094 + client_init(void)
1095 + {
1096 +  static struct event event_ping =
1097 +  {
1098 +    .name = "check_pings",
1099 +    .handler = check_pings,
1100 +    .when = 5
1101 +  };
1102 +
1103 +  client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
1104 +  connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1105 +  event_add(&event_ping, NULL);
1106 + }

Diff Legend

Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)