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-8/src/client.c (file contents), Revision 1243 by michael, Fri Sep 30 10:47:53 2011 UTC vs.
ircd-hybrid/trunk/src/client.c (file contents), Revision 8337 by michael, Thu Mar 1 23:06:49 2018 UTC

# Line 1 | Line 1
1   /*
2 < *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 < *  client.c: Controls clients.
2 > *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (C) 2002 by the past and present ircd coders, and others.
4 > *  Copyright (c) 1997-2018 ircd-hybrid development team
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
# Line 16 | 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 < *  $Id$
20 > */
21 >
22 > /*! \file client.c
23 > * \brief Controls clients.
24 > * \version $Id$
25   */
26  
27   #include "stdinc.h"
28   #include "list.h"
29   #include "client.h"
28 #include "channel_mode.h"
30   #include "event.h"
30 #include "fdlist.h"
31   #include "hash.h"
32   #include "irc_string.h"
33   #include "ircd.h"
34 #include "s_gline.h"
34   #include "numeric.h"
35 < #include "packet.h"
37 < #include "s_auth.h"
35 > #include "auth.h"
36   #include "s_bsd.h"
37 < #include "s_conf.h"
38 < #include "s_log.h"
39 < #include "s_misc.h"
40 < #include "s_serv.h"
37 > #include "conf.h"
38 > #include "conf_gecos.h"
39 > #include "log.h"
40 > #include "misc.h"
41 > #include "server.h"
42   #include "send.h"
43   #include "whowas.h"
44 < #include "s_user.h"
46 < #include "dbuf.h"
44 > #include "user.h"
45   #include "memory.h"
46 + #include "mempool.h"
47   #include "hostmask.h"
49 #include "balloc.h"
48   #include "listener.h"
51 #include "irc_res.h"
49   #include "userhost.h"
50   #include "watch.h"
51 + #include "rng_mt.h"
52 + #include "parse.h"
53 + #include "ipcache.h"
54  
55 dlink_list listing_client_list = { NULL, NULL, 0 };
56 /* Pointer to beginning of Client list */
57 dlink_list global_client_list = {NULL, NULL, 0};
58 /* unknown/client pointer lists */
59 dlink_list unknown_list = {NULL, NULL, 0};
60 dlink_list local_client_list = {NULL, NULL, 0};
61 dlink_list serv_list = {NULL, NULL, 0};
62 dlink_list global_serv_list = {NULL, NULL, 0};
63 dlink_list oper_list = {NULL, NULL, 0};
64
65 static EVH check_pings;
66
67 static BlockHeap *client_heap  = NULL;
68 static BlockHeap *lclient_heap = NULL;
55  
56 < static dlink_list dead_list  = { NULL, NULL, 0};
57 < static dlink_list abort_list = { NULL, NULL, 0};
56 > dlink_list listing_client_list;
57 > dlink_list unknown_list;
58 > dlink_list local_client_list;
59 > dlink_list local_server_list;
60 > dlink_list global_client_list;
61 > dlink_list global_server_list;
62 > dlink_list oper_list;
63  
64 + static mp_pool_t *client_pool, *connection_pool;
65 + static dlink_list dead_list, abort_list;
66   static dlink_node *eac_next;  /* next aborted client to exit */
67  
75 static void check_pings_list(dlink_list *);
76 static void check_unknowns_list(void);
77 static void ban_them(struct Client *, struct ConfItem *);
78
79
80 /* init_client()
81 *
82 * inputs       - NONE
83 * output       - NONE
84 * side effects - initialize client free memory
85 */
86 void
87 init_client(void)
88 {
89  /* start off the check ping event ..  -- adrian
90   * Every 30 seconds is plenty -- db
91   */
92  client_heap = BlockHeapCreate("client", sizeof(struct Client), CLIENT_HEAP_SIZE);
93  lclient_heap = BlockHeapCreate("local client", sizeof(struct LocalUser), LCLIENT_HEAP_SIZE);
94  eventAdd("check_pings", check_pings, NULL, 5);
95 }
68  
69   /*
70   * make_client - create a new Client struct and set it to initial state.
# Line 110 | Line 82 | init_client(void)
82   *                      'from'). ('from' is a local client!!).
83   */
84   struct Client *
85 < make_client(struct Client *from)
85 > client_make(struct Client *from)
86   {
87 <  struct Client *client_p = BlockHeapAlloc(client_heap);
87 >  struct Client *const client_p = mp_pool_get(client_pool);
88  
89 <  if (from == NULL)
89 >  if (from)
90 >    client_p->from = from;
91 >  else
92    {
93 <    client_p->from                      = client_p; /* 'from' of local client is self! */
94 <    client_p->localClient               = BlockHeapAlloc(lclient_heap);
95 <    client_p->localClient->since        = CurrentTime;
96 <    client_p->localClient->lasttime     = CurrentTime;
97 <    client_p->localClient->firsttime    = CurrentTime;
98 <    client_p->localClient->registration = REG_INIT;
93 >    client_p->from = client_p;  /* 'from' of local client is self! */
94 >    client_p->connection = mp_pool_get(connection_pool);
95 >    client_p->connection->since = CurrentTime;
96 >    client_p->connection->lasttime = CurrentTime;
97 >    client_p->connection->firsttime = CurrentTime;
98 >    client_p->connection->registration = REG_INIT;
99  
100      /* as good a place as any... */
101 <    dlinkAdd(client_p, &client_p->localClient->lclient_node, &unknown_list);
101 >    dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list);
102    }
129  else
130    client_p->from = from; /* 'from' of local client is self! */
103  
104 <  client_p->hnext  = client_p;
105 <  client_p->status = STAT_UNKNOWN;
104 >  client_p->idhnext = client_p;
105 >  client_p->hnext = client_p;
106 >  SetUnknown(client_p);
107    strcpy(client_p->username, "unknown");
108 +  strcpy(client_p->account, "*");
109  
110    return client_p;
111   }
112  
113   /*
114 < * free_client
114 > * client_free
115   *
116   * inputs       - pointer to client
117   * output       - NONE
118   * side effects - client pointed to has its memory freed
119   */
120   static void
121 < free_client(struct Client *client_p)
121 > client_free(struct Client *client_p)
122   {
123 <  assert(client_p != NULL);
123 >  assert(!IsMe(client_p));
124    assert(client_p != &me);
125    assert(client_p->hnext == client_p);
126 <  assert(client_p->channel.head == NULL);
126 >  assert(client_p->idhnext == client_p);
127 >
128 >  assert(client_p->node.data == NULL);
129 >  assert(client_p->node.prev == NULL);
130 >  assert(client_p->node.next == NULL);
131 >
132 >  assert(client_p->lnode.data == NULL);
133 >  assert(client_p->lnode.prev == NULL);
134 >  assert(client_p->lnode.next == NULL);
135 >
136 >  assert(dlink_list_length(&client_p->whowas_list) == 0);
137 >  assert(client_p->whowas_list.head == NULL);
138 >  assert(client_p->whowas_list.tail == NULL);
139 >
140    assert(dlink_list_length(&client_p->channel) == 0);
141 +  assert(client_p->channel.head == NULL);
142 +  assert(client_p->channel.tail == NULL);
143 +
144 +  assert(dlink_list_length(&client_p->svstags) == 0);
145 +  assert(client_p->svstags.head == NULL);
146 +  assert(client_p->svstags.tail == NULL);
147 +
148  
149 <  MyFree(client_p->away);
150 <  MyFree(client_p->serv);
149 >  xfree(client_p->serv);
150 >  xfree(client_p->certfp);
151  
152    if (MyConnect(client_p))
153    {
154 <    assert(client_p->localClient->invited.head == NULL);
155 <    assert(dlink_list_length(&client_p->localClient->invited) == 0);
156 <    assert(IsClosing(client_p) && IsDead(client_p));
154 >    assert(client_p->connection->lclient_node.data == NULL);
155 >    assert(client_p->connection->lclient_node.prev == NULL);
156 >    assert(client_p->connection->lclient_node.next == NULL);
157 >
158 >    assert(client_p->connection->list_task == NULL);
159 >
160 >    assert(client_p->connection->auth.node.data == NULL);
161 >    assert(client_p->connection->auth.node.prev == NULL);
162 >    assert(client_p->connection->auth.node.next == NULL);
163 >    assert(client_p->connection->auth.flags == 0);
164 >    assert(client_p->connection->auth.fd.fd == 0);
165 >    assert(client_p->connection->auth.client == NULL || client_p->connection->auth.client == client_p);
166 >
167 >    assert(dlink_list_length(&client_p->connection->acceptlist) == 0);
168 >    assert(client_p->connection->acceptlist.head == NULL);
169 >    assert(client_p->connection->acceptlist.tail == NULL);
170 >
171 >
172 >    assert(dlink_list_length(&client_p->connection->watches) == 0);
173 >    assert(client_p->connection->watches.head == NULL);
174 >    assert(client_p->connection->watches.tail == NULL);
175 >
176 >    assert(dlink_list_length(&client_p->connection->confs) == 0);
177 >    assert(client_p->connection->confs.head == NULL);
178 >    assert(client_p->connection->confs.tail == NULL);
179  
180 <    MyFree(client_p->localClient->response);
181 <    MyFree(client_p->localClient->auth_oper);
180 >    assert(dlink_list_length(&client_p->connection->invited) == 0);
181 >    assert(client_p->connection->invited.head == NULL);
182 >    assert(client_p->connection->invited.tail == NULL);
183 >
184 >    assert(client_p->connection->fd.fd == 0);
185 >
186 >    assert(HasFlag(client_p, FLAGS_CLOSING) && IsDead(client_p));
187  
188      /*
189 <     * clean up extra sockets from P-lines which have been discarded.
189 >     * Clean up extra sockets from listen {} blocks which have been discarded.
190       */
191 <    if (client_p->localClient->listener)
191 >    if (client_p->connection->listener)
192      {
193 <      assert(0 < client_p->localClient->listener->ref_count);
194 <      if (0 == --client_p->localClient->listener->ref_count &&
174 <          !client_p->localClient->listener->active)
175 <        free_listener(client_p->localClient->listener);
193 >      listener_release(client_p->connection->listener);
194 >      client_p->connection->listener = NULL;
195      }
196  
197 <    dbuf_clear(&client_p->localClient->buf_recvq);
198 <    dbuf_clear(&client_p->localClient->buf_sendq);
197 >    dbuf_clear(&client_p->connection->buf_recvq);
198 >    dbuf_clear(&client_p->connection->buf_sendq);
199  
200 <    BlockHeapFree(lclient_heap, client_p->localClient);
200 >    mp_pool_release(client_p->connection);
201 >    client_p->connection = NULL;
202    }
203  
204 <  BlockHeapFree(client_heap, client_p);
204 >  mp_pool_release(client_p);
205   }
206  
207 < /*
208 < * check_pings - go through the local client list and check activity
209 < * kill off stuff that should die
210 < *
211 < * inputs       - NOT USED (from event)
192 < * output       - next time_t when check_pings() should be called again
193 < * side effects -
194 < *
195 < *
196 < * A PING can be sent to clients as necessary.
197 < *
198 < * Client/Server ping outs are handled.
199 < */
207 > void
208 > client_attach_svstag(struct Client *client_p, unsigned int numeric,
209 >                     const char *umodes, const char *tag)
210 > {
211 >  const struct user_modes *tab = NULL;
212  
213 < /*
214 < * Addon from adrian. We used to call this after nextping seconds,
203 < * however I've changed it to run once a second. This is only for
204 < * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
205 < * run once a second makes life a lot easier - when a new client connects
206 < * and they need a ping in 4 seconds, if nextping was set to 20 seconds
207 < * we end up waiting 20 seconds. This is stupid. :-)
208 < * I will optimise (hah!) check_pings() once I've finished working on
209 < * tidying up other network IO evilnesses.
210 < *     -- adrian
211 < */
213 >  if (numeric >= ERR_LAST_ERR_MSG || *umodes != '+')
214 >    return;
215  
216 < static void
217 < check_pings(void *notused)
218 < {              
219 <  check_pings_list(&local_client_list);
220 <  check_pings_list(&serv_list);
221 <  check_unknowns_list();
216 >  struct ServicesTag *svstag = xcalloc(sizeof(*svstag));
217 >  svstag->numeric = numeric;
218 >  svstag->tag = xstrdup(tag);
219 >
220 >  for (const char *m = umodes + 1; *m; ++m)
221 >    if ((tab = umode_map[(unsigned char)*m]))
222 >      svstag->umodes |= tab->flag;
223 >
224 >  if (numeric != RPL_WHOISOPERATOR)
225 >    dlinkAddTail(svstag, &svstag->node, &client_p->svstags);
226 >  else
227 >    dlinkAdd(svstag, &svstag->node, &client_p->svstags);
228 > }
229 >
230 > void
231 > client_clear_svstags(struct Client *client_p)
232 > {
233 >  while (client_p->svstags.head)
234 >  {
235 >    struct ServicesTag *svstag = client_p->svstags.head->data;
236 >
237 >    dlinkDelete(&svstag->node, &client_p->svstags);
238 >    xfree(svstag->tag);
239 >    xfree(svstag);
240 >  }
241   }
242  
243   /* check_pings_list()
244   *
245   * inputs       - pointer to list to check
246   * output       - NONE
247 < * side effects -
247 > * side effects -
248   */
249   static void
250   check_pings_list(dlink_list *list)
251   {
252 <  char scratch[32];        /* way too generous but... */
253 <  struct Client *client_p; /* current local client_p being examined */
254 <  int ping, pingwarn;      /* ping time value from client */
233 <  dlink_node *ptr, *next_ptr;
252 >  char buf[32] = "";  /* 32 = sizeof("Ping timeout: 999999999 seconds") */
253 >  unsigned int ping = 0;      /* ping time value from client */
254 >  dlink_node *node = NULL, *node_next = NULL;
255  
256 <  DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
256 >  DLINK_FOREACH_SAFE(node, node_next, list->head)
257    {
258 <    client_p = ptr->data;
258 >    struct Client *client_p = node->data;
259  
239    /*
240    ** Note: No need to notify opers here. It's
241    ** already done when "FLAGS_DEADSOCKET" is set.
242    */
260      if (IsDead(client_p))
261 <    {
245 <      /* Ignore it, its been exited already */
246 <      continue;
247 <    }
261 >      continue;  /* Ignore it, its been exited already */
262  
263 <    if (client_p->localClient->reject_delay > 0)
264 <    {
251 <      if (client_p->localClient->reject_delay <= CurrentTime)
252 <        exit_client(client_p, &me, "Rejected");
253 <      continue;
254 <    }
255 <
256 <    if (!IsRegistered(client_p))
257 <      ping = CONNECTTIMEOUT, pingwarn = 0;
263 >    if (IsClient(client_p) || IsServer(client_p))
264 >      ping = get_client_ping(&client_p->connection->confs);
265      else
266 <      ping = get_client_ping(client_p, &pingwarn);
266 >      ping = CONNECTTIMEOUT;
267  
268 <    if (ping < CurrentTime - client_p->localClient->lasttime)
268 >    if (ping < CurrentTime - client_p->connection->lasttime)
269      {
270 <      if (!IsPingSent(client_p))
270 >      if (!HasFlag(client_p, FLAGS_PINGSENT))
271        {
272 <        /*
273 <         * if we havent PINGed the connection and we havent
274 <         * heard from it in a while, PING it to make sure
275 <         * it is still alive.
276 <         */
277 <        SetPingSent(client_p);
278 <        ClearPingWarning(client_p);
279 <        client_p->localClient->lasttime = CurrentTime - ping;
273 <        sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
272 >        /*
273 >         * If we haven't PINGed the connection and we haven't
274 >         * heard from it in a while, PING it to make sure
275 >         * it is still alive.
276 >         */
277 >        AddFlag(client_p, FLAGS_PINGSENT);
278 >        client_p->connection->lasttime = CurrentTime - ping;
279 >        sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p));
280        }
281        else
282        {
283 <        if (CurrentTime - client_p->localClient->lasttime >= 2 * ping)
283 >        if (CurrentTime - client_p->connection->lasttime >= 2 * ping)
284          {
285            /*
286             * If the client/server hasn't talked to us in 2*ping seconds
287             * and it has a ping time, then close its connection.
288             */
289            if (IsServer(client_p) || IsHandshake(client_p))
290 <          {
291 <            sendto_realops_flags(UMODE_ALL, L_ADMIN,
292 <                                 "No response from %s, closing link",
293 <                                 get_client_name(client_p, HIDE_IP));
294 <            sendto_realops_flags(UMODE_ALL, L_OPER,
295 <                                 "No response from %s, closing link",
296 <                                 get_client_name(client_p, MASK_IP));
297 <            ilog(L_NOTICE, "No response from %s, closing link",
298 <                 get_client_name(client_p, HIDE_IP));
299 <          }
300 <
301 <          snprintf(scratch, sizeof(scratch), "Ping timeout: %d seconds",
302 <                   (int)(CurrentTime - client_p->localClient->lasttime));
303 <          exit_client(client_p, &me, scratch);
298 <        }
299 <        else if (!IsPingWarning(client_p) && pingwarn > 0 &&
300 <                 (IsServer(client_p) || IsHandshake(client_p)) &&
301 <                 CurrentTime - client_p->localClient->lasttime >= ping + pingwarn)
302 <        {
303 <          /*
304 <           * If the server hasn't replied in pingwarn seconds after sending
305 <           * the PING, notify the opers so that they are aware of the problem.
306 <           */
307 <          SetPingWarning(client_p);
308 <          sendto_realops_flags(UMODE_ALL, L_ADMIN,
309 <                               "Warning, no response from %s in %d seconds",
310 <                               get_client_name(client_p, HIDE_IP), pingwarn);
311 <          sendto_realops_flags(UMODE_ALL, L_OPER,
312 <                               "Warning, no response from %s in %d seconds",
313 <                               get_client_name(client_p, MASK_IP), pingwarn);
314 <          ilog(L_NOTICE, "No response from %s in %d seconds",
315 <               get_client_name(client_p, HIDE_IP), pingwarn);
290 >          {
291 >            sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
292 >                                 "No response from %s, closing link",
293 >                                 client_get_name(client_p, SHOW_IP));
294 >            sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
295 >                                 "No response from %s, closing link",
296 >                                 client_get_name(client_p, MASK_IP));
297 >            ilog(LOG_TYPE_IRCD, "No response from %s, closing link",
298 >                 client_get_name(client_p, SHOW_IP));
299 >          }
300 >
301 >          snprintf(buf, sizeof(buf), "Ping timeout: %ji seconds",
302 >                   (CurrentTime - client_p->connection->lasttime));
303 >          exit_client(client_p, buf);
304          }
305        }
306      }
# Line 328 | Line 316 | check_pings_list(dlink_list *list)
316   static void
317   check_unknowns_list(void)
318   {
319 <  dlink_node *ptr, *next_ptr;
319 >  dlink_node *node = NULL, *node_next = NULL;
320  
321 <  DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
321 >  DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
322    {
323 <    struct Client *client_p = ptr->data;
336 <
337 <    if (client_p->localClient->reject_delay > 0)
338 <    {
339 <      if (client_p->localClient->reject_delay <= CurrentTime)
340 <        exit_client(client_p, &me, "Rejected");
341 <      continue;
342 <    }
323 >    struct Client *client_p = node->data;
324  
325      /*
326       * Check UNKNOWN connections - if they have been in this state
327       * for > 30s, close them.
328       */
329 <    if (IsAuthFinished(client_p) && (CurrentTime - client_p->localClient->firsttime) > 30)
330 <      exit_client(client_p, &me, "Registration timed out");
329 >    if (HasFlag(client_p, FLAGS_FINISHED_AUTH) && (CurrentTime - client_p->connection->firsttime) > 30)
330 >      exit_client(client_p, "Registration timed out");
331    }
332   }
333  
334 + /*
335 + * check_pings - go through the local client list and check activity
336 + * kill off stuff that should die
337 + *
338 + * inputs       - NOT USED (from event)
339 + * side effects -
340 + *
341 + *
342 + * A PING can be sent to clients as necessary.
343 + *
344 + * Client/Server ping outs are handled.
345 + */
346 +
347 + /*
348 + * Addon from adrian. We used to call this after nextping seconds,
349 + * however I've changed it to run once a second. This is only for
350 + * PING timeouts, not K/etc-line checks (thanks dianora!). Having it
351 + * run once a second makes life a lot easier - when a new client connects
352 + * and they need a ping in 4 seconds, if nextping was set to 20 seconds
353 + * we end up waiting 20 seconds. This is stupid. :-)
354 + * I will optimise (hah!) check_pings() once I've finished working on
355 + * tidying up other network IO evilnesses.
356 + *     -- adrian
357 + */
358 +
359 + static void
360 + check_pings(void *unused)
361 + {
362 +  check_pings_list(&local_client_list);
363 +  check_pings_list(&local_server_list);
364 +  check_unknowns_list();
365 + }
366 +
367   /* check_conf_klines()
368   *
369   * inputs       - NONE
# Line 357 | Line 371 | check_unknowns_list(void)
371   * side effects - Check all connections for a pending kline against the
372   *                client, exit the client if a kline matches.
373   */
374 < void
374 > void
375   check_conf_klines(void)
376 < {              
377 <  struct Client *client_p = NULL;       /* current local client_p being examined */
378 <  struct AccessItem *aconf = NULL;
365 <  struct ConfItem *conf = NULL;
366 <  dlink_node *ptr, *next_ptr;
376 > {
377 >  dlink_node *node = NULL, *node_next = NULL;
378 >  const void *ptr;
379  
380 <  DLINK_FOREACH_SAFE(ptr, next_ptr, local_client_list.head)
380 >  DLINK_FOREACH_SAFE(node, node_next, local_client_list.head)
381    {
382 <    client_p = ptr->data;
382 >    struct Client *client_p = node->data;
383  
384 <    /* If a client is already being exited
385 <     */
374 <    if (IsDead(client_p) || !IsClient(client_p))
384 >    /* If a client is already being exited */
385 >    if (IsDead(client_p))
386        continue;
387  
388 <    /* if there is a returned struct ConfItem then kill it */
389 <    if ((aconf = find_dline_conf(&client_p->localClient->ip,
379 <                                  client_p->localClient->aftype)) != NULL)
388 >    if ((ptr = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
389 >                                    client_p->connection->aftype, NULL, NULL, 1)))
390      {
391 <      if (aconf->status & CONF_EXEMPTDLINE)
392 <        continue;
393 <
384 <      conf = unmap_conf_item(aconf);
385 <      ban_them(client_p, conf);
386 <      continue; /* and go examine next fd/client_p */
391 >      const struct MaskItem *conf = ptr;
392 >      conf_try_ban(client_p, CLIENT_BAN_DLINE, conf->reason);
393 >      continue;  /* and go examine next Client */
394      }
395  
396 <    if (ConfigFileEntry.glines && (aconf = find_gline(client_p)))
397 <    {
398 <      if (IsExemptKline(client_p) ||
392 <          IsExemptGline(client_p))
393 <      {
394 <        sendto_realops_flags(UMODE_ALL, L_ALL,
395 <                             "GLINE over-ruled for %s, client is %sline_exempt",
396 <                             get_client_name(client_p, HIDE_IP), IsExemptKline(client_p) ? "k" : "g");
397 <        continue;
398 <      }
399 <
400 <      conf = unmap_conf_item(aconf);
401 <      ban_them(client_p, conf);
402 <      /* and go examine next fd/client_p */    
403 <      continue;
404 <    }
405 <
406 <    if ((aconf = find_kill(client_p)) != NULL)
396 >    if ((ptr = find_conf_by_address(client_p->host, &client_p->connection->ip,
397 >                                    CONF_KLINE, client_p->connection->aftype,
398 >                                    client_p->username, NULL, 1)))
399      {
400 <
401 <      /* if there is a returned struct AccessItem.. then kill it */
402 <      if (IsExemptKline(client_p))
411 <      {
412 <        sendto_realops_flags(UMODE_ALL, L_ALL,
413 <                             "KLINE over-ruled for %s, client is kline_exempt",
414 <                             get_client_name(client_p, HIDE_IP));
415 <        continue;
416 <      }
417 <
418 <      conf = unmap_conf_item(aconf);
419 <      ban_them(client_p, conf);
420 <      continue;
400 >      const struct MaskItem *conf = ptr;
401 >      conf_try_ban(client_p, CLIENT_BAN_KLINE, conf->reason);
402 >      continue;  /* and go examine next Client */
403      }
404  
405 <    /* if there is a returned struct MatchItem then kill it */
424 <    if ((conf = find_matching_name_conf(XLINE_TYPE,  client_p->info,
425 <                                        NULL, NULL, 0)) != NULL ||
426 <        (conf = find_matching_name_conf(RXLINE_TYPE, client_p->info,
427 <                                        NULL, NULL, 0)) != NULL)
405 >    if ((ptr = gecos_find(client_p->info, match)))
406      {
407 <      ban_them(client_p, conf);
408 <      continue;
407 >      const struct GecosItem *conf = ptr;
408 >      conf_try_ban(client_p, CLIENT_BAN_XLINE, conf->reason);
409 >      continue;  /* and go examine next Client */
410      }
411    }
412  
413 <  /* also check the unknowns list for new dlines */
414 <  DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
413 >  /* Also check the unknowns list for new dlines */
414 >  DLINK_FOREACH_SAFE(node, node_next, unknown_list.head)
415    {
416 <    client_p = ptr->data;
416 >    struct Client *client_p = node->data;
417  
418 <    if ((aconf = find_dline_conf(&client_p->localClient->ip,
419 <                                  client_p->localClient->aftype)))
418 >    if ((ptr = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE,
419 >                                    client_p->connection->aftype, NULL, NULL, 1)))
420      {
421 <      if (aconf->status & CONF_EXEMPTDLINE)
422 <        continue;
423 <
445 <      exit_client(client_p, &me, "D-lined");
421 >      const struct MaskItem *conf = ptr;
422 >      conf_try_ban(client_p, CLIENT_BAN_DLINE, conf->reason);
423 >      continue;  /* and go examine next Client */
424      }
425    }
426   }
427  
428   /*
429 < * ban_them
429 > * conf_try_ban
430   *
431   * inputs       - pointer to client to ban
432 < *              - pointer to ConfItem
432 > *              - pointer to MaskItem
433   * output       - NONE
434   * side effects - given client_p is banned
435   */
436 < static void
437 < ban_them(struct Client *client_p, struct ConfItem *conf)
436 > void
437 > conf_try_ban(struct Client *client_p, int type, const char *reason)
438   {
439 <  const char *user_reason = NULL;       /* What is sent to user */
440 <  const char *channel_reason = NULL;    /* What is sent to channel */
441 <  struct AccessItem *aconf = NULL;
442 <  struct MatchItem *xconf = NULL;
443 <  const char *type_string = NULL;
444 <  const char dline_string[] = "D-line";
445 <  const char kline_string[] = "K-line";
446 <  const char gline_string[] = "G-line";
447 <  const char xline_string[] = "X-line";
448 <
449 <  switch (conf->type)
450 <  {
451 <    case RKLINE_TYPE:
452 <    case KLINE_TYPE:
475 <      type_string = kline_string;
476 <      aconf = map_to_conf(conf);
477 <      break;
478 <    case DLINE_TYPE:
479 <      type_string = dline_string;
480 <      aconf = map_to_conf(conf);
439 >  char ban_type = '?';
440 >
441 >  switch (type)
442 >  {
443 >    case CLIENT_BAN_KLINE:
444 >      if (HasFlag(client_p, FLAGS_EXEMPTKLINE))
445 >      {
446 >        sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
447 >                             "KLINE over-ruled for %s, client is kline_exempt",
448 >                             client_get_name(client_p, HIDE_IP));
449 >        return;
450 >      }
451 >
452 >      ban_type = 'K';
453        break;
454 <    case GLINE_TYPE:
455 <      type_string = gline_string;
456 <      aconf = map_to_conf(conf);
454 >    case CLIENT_BAN_DLINE:
455 >      if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT,
456 >                               client_p->connection->aftype, NULL, NULL, 1))
457 >        return;
458 >      ban_type = 'D';
459        break;
460 <    case RXLINE_TYPE:
461 <    case XLINE_TYPE:
462 <      type_string = xline_string;
463 <      xconf = map_to_conf(conf);
464 <      ++xconf->count;
460 >    case CLIENT_BAN_XLINE:
461 >      if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
462 >      {
463 >        sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
464 >                             "XLINE over-ruled for %s, client is xline_exempt",
465 >                             client_get_name(client_p, HIDE_IP));
466 >        return;
467 >      }
468 >
469 >      ban_type = 'X';
470        break;
471      default:
472        assert(0);
473        break;
474    }
475  
476 <  if (ConfigFileEntry.kline_with_reason)
477 <  {
499 <    if (aconf != NULL)
500 <      user_reason = aconf->reason ? aconf->reason : type_string;
501 <    if (xconf != NULL)
502 <      user_reason = xconf->reason ? xconf->reason : type_string;
503 <  }
504 <  else
505 <    user_reason = type_string;
506 <
507 <  if (ConfigFileEntry.kline_reason != NULL)
508 <    channel_reason = ConfigFileEntry.kline_reason;
509 <  else
510 <    channel_reason = user_reason;
511 <
512 <  sendto_realops_flags(UMODE_ALL, L_ALL, "%s active for %s",
513 <                       type_string, get_client_name(client_p, HIDE_IP));
476 >  sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "%c-line active for %s",
477 >                       ban_type, client_get_name(client_p, HIDE_IP));
478  
479    if (IsClient(client_p))
480 <    sendto_one(client_p, form_str(ERR_YOUREBANNEDCREEP),
517 <               me.name, client_p->name, user_reason);
480 >    sendto_one_numeric(client_p, &me, ERR_YOUREBANNEDCREEP, reason);
481  
482 <  exit_client(client_p, &me, channel_reason);
520 < }
521 <
522 < /* update_client_exit_stats()
523 < *
524 < * input        - pointer to client
525 < * output       - NONE
526 < * side effects -
527 < */
528 < static void
529 < update_client_exit_stats(struct Client *client_p)
530 < {
531 <  if (IsClient(client_p))
532 <  {
533 <    assert(Count.total > 0);
534 <    --Count.total;
535 <    if (HasUMode(client_p, UMODE_OPER))
536 <      --Count.oper;
537 <    if (HasUMode(client_p, UMODE_INVISIBLE))
538 <      --Count.invisi;
539 <  }
540 <  else if (IsServer(client_p))
541 <    sendto_realops_flags(UMODE_EXTERNAL, L_ALL, "Server %s split from %s",
542 <                         client_p->name, client_p->servptr->name);
543 <
544 <  if (splitchecking && !splitmode)
545 <    check_splitmode(NULL);
482 >  exit_client(client_p, reason);
483   }
484  
485   /* find_person()
# Line 551 | Line 488 | update_client_exit_stats(struct Client *
488   * output       - return client pointer
489   * side effects - find person by (nick)name
490   */
554 /* XXX - ugly wrapper */
491   struct Client *
492 < find_person(const struct Client *client_p, const char *name)
492 > find_person(const struct Client *source_p, const char *name)
493   {
494 <  struct Client *c2ptr;
494 >  struct Client *target_p = NULL;
495  
496    if (IsDigit(*name))
497    {
498 <    if ((c2ptr = hash_find_id(name)) != NULL)
499 <    {
564 <      /* invisible users shall not be found by UID guessing */
565 <      if (HasUMode(c2ptr, UMODE_INVISIBLE) && !IsServer(client_p))
566 <        c2ptr = NULL;
567 <    }
498 >    if (IsServer(source_p->from))
499 >      target_p = hash_find_id(name);
500    }
501    else
502 <    c2ptr = hash_find_client(name);
502 >    target_p = hash_find_client(name);
503  
504 <  return ((c2ptr != NULL && IsClient(c2ptr)) ? c2ptr : NULL);
504 >  return (target_p && IsClient(target_p)) ? target_p : NULL;
505   }
506  
507   /*
508 < * find_chasing - find the client structure for a nick name (user)
509 < *      using history mechanism if necessary. If the client is not found,
510 < *      an error message (NO SUCH NICK) is generated. If the client was found
579 < *      through the history, chasing will be 1 and otherwise 0.
508 > * find_chasing - find the client structure for a nick name (name)
509 > *      using history mechanism if necessary. If the client is not found,
510 > *      an error message (NO SUCH NICK) is generated.
511   */
512   struct Client *
513 < find_chasing(struct Client *client_p, struct Client *source_p, const char *user, int *chasing)
513 > find_chasing(struct Client *source_p, const char *name)
514   {
515 <  struct Client *who = find_person(client_p, user);
515 >  struct Client *target_p = find_person(source_p, name);
516  
517 <  if (chasing)
518 <    *chasing = 0;
517 >  if (target_p)
518 >    return target_p;
519  
520 <  if (who)
590 <    return who;
591 <
592 <  if (IsDigit(*user))
593 <    return NULL;
594 <
595 <  if ((who = get_history(user,
596 <                        (time_t)ConfigFileEntry.kill_chase_time_limit))
597 <                         == NULL)
598 <  {
599 <    sendto_one(source_p, form_str(ERR_NOSUCHNICK),
600 <               me.name, source_p->name, user);
520 >  if (IsDigit(*name))
521      return NULL;
602  }
522  
523 <  if (chasing)
524 <    *chasing = 1;
523 >  target_p = whowas_get_history(name, ConfigGeneral.kill_chase_time_limit);
524 >  if (!target_p)
525 >    sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name);
526  
527 <  return who;
527 >  return target_p;
528   }
529  
530   /*
531 < * get_client_name -  Return the name of the client
531 > * client_get_name -  Return the name of the client
532   *    for various tracking and
533   *      admin purposes. The main purpose of this function is to
534   *      return the "socket host" name of the client, if that
# Line 616 | Line 536 | find_chasing(struct Client *client_p, st
536   *        But, this can be used to any client structure.
537   *
538   * NOTE 1:
539 < *        Watch out the allocation of "nbuf", if either source_p->name
539 > *        Watch out the allocation of "buf", if either source_p->name
540   *        or source_p->sockhost gets changed into pointers instead of
541   *        directly allocated within the structure...
542   *
543   * NOTE 2:
544   *        Function return either a pointer to the structure (source_p) or
545 < *        to internal buffer (nbuf). *NEVER* use the returned pointer
545 > *        to internal buffer (buf). *NEVER* use the returned pointer
546   *        to modify what it points!!!
547   */
548   const char *
549 < get_client_name(const struct Client *client, int showip)
549 > client_get_name(const struct Client *client_p, enum addr_mask_type type)
550   {
551 <  static char nbuf[HOSTLEN * 2 + USERLEN + 5];
551 >  static char buf[HOSTLEN * 2 + USERLEN + 4];  /* +4 for [,@,],\0 */
552  
553 <  assert(client != NULL);
553 >  if (!MyConnect(client_p))
554 >    return client_p->name;
555  
556 <  if (irccmp(client->name, client->host) == 0)
557 <    return client->name;
558 <
559 <  if (ConfigServerHide.hide_server_ips)
560 <    if (IsServer(client) || IsConnecting(client) || IsHandshake(client))
561 <      showip = MASK_IP;
562 <
642 <  if (ConfigFileEntry.hide_spoof_ips)
643 <    if (showip == SHOW_IP && IsIPSpoof(client))
644 <      showip = MASK_IP;
556 >  if (IsServer(client_p) || IsConnecting(client_p) || IsHandshake(client_p))
557 >  {
558 >    if (!irccmp(client_p->name, client_p->host))
559 >      return client_p->name;
560 >    else if (ConfigServerHide.hide_server_ips)
561 >      type = MASK_IP;
562 >  }
563  
564    /* And finally, let's get the host information, ip or name */
565 <  switch (showip)
565 >  switch (type)
566    {
567      case SHOW_IP:
568 <      if (MyConnect(client))
569 <      {
570 <        snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]",
571 <                 client->name,
654 <                 client->username, client->sockhost);
655 <        break;
656 <      }
568 >      snprintf(buf, sizeof(buf), "%s[%s@%s]",
569 >               client_p->name,
570 >               client_p->username, client_p->sockhost);
571 >      break;
572      case MASK_IP:
573 <      snprintf(nbuf, sizeof(nbuf), "%s[%s@255.255.255.255]",
574 <               client->name, client->username);
573 >      if (client_p->connection->aftype == AF_INET)
574 >        snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]",
575 >                 client_p->name, client_p->username);
576 >      else
577 >        snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]",
578 >                 client_p->name, client_p->username);
579        break;
580 <    default:
581 <      snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]",
582 <               client->name,
583 <               client->username, client->host);
580 >    default:  /* HIDE_IP */
581 >      snprintf(buf, sizeof(buf), "%s[%s@%s]",
582 >               client_p->name,
583 >               client_p->username, client_p->host);
584    }
585  
586 <  return nbuf;
586 >  return buf;
587   }
588  
589   void
590   free_exited_clients(void)
591   {
592 <  dlink_node *ptr = NULL, *next = NULL;
593 <  
594 <  DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
592 >  dlink_node *node, *node_next;
593 >
594 >  DLINK_FOREACH_SAFE(node, node_next, dead_list.head)
595    {
596 <    free_client(ptr->data);
597 <    dlinkDelete(ptr, &dead_list);
598 <    free_dlink_node(ptr);
596 >    client_free(node->data);
597 >    dlinkDelete(node, &dead_list);
598 >    free_dlink_node(node);
599    }
600   }
601  
# Line 687 | Line 606 | free_exited_clients(void)
606   * The only messages generated are QUITs on channels.
607   */
608   static void
609 < exit_one_client(struct Client *source_p, const char *quitmsg)
609 > exit_one_client(struct Client *source_p, const char *comment)
610   {
611 <  dlink_node *lp = NULL, *next_lp = NULL;
611 >  dlink_node *node, *node_next;
612  
613    assert(!IsMe(source_p));
614 +  assert(source_p != &me);
615  
616    if (IsClient(source_p))
617    {
618 <    if (source_p->servptr->serv != NULL)
619 <      dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
618 >    if (HasUMode(source_p, UMODE_OPER))
619 >      --Count.oper;
620 >    if (HasUMode(source_p, UMODE_INVISIBLE))
621 >      --Count.invisi;
622 >
623 >    dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list);
624 >    dlinkDelete(&source_p->node, &global_client_list);
625  
626      /*
627       * If a person is on a channel, send a QUIT notice
# Line 704 | Line 629 | exit_one_client(struct Client *source_p,
629       * that the client can show the "**signoff" message).
630       * (Note: The notice is to the local clients *only*)
631       */
632 <    sendto_common_channels_local(source_p, 0, ":%s!%s@%s QUIT :%s",
632 >    sendto_common_channels_local(source_p, 0, 0, 0, ":%s!%s@%s QUIT :%s",
633                                   source_p->name, source_p->username,
634 <                                 source_p->host, quitmsg);
635 <    DLINK_FOREACH_SAFE(lp, next_lp, source_p->channel.head)
636 <      remove_user_from_channel(lp->data);
634 >                                 source_p->host, comment);
635 >
636 >    DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head)
637 >      remove_user_from_channel(node->data);
638 >
639 >    client_clear_svstags(source_p);
640  
641 <    add_history(source_p, 0);
642 <    off_history(source_p);
641 >    whowas_add_history(source_p, 0);
642 >    whowas_off_history(source_p);
643  
644      watch_check_hash(source_p, RPL_LOGOFF);
645  
646      if (MyConnect(source_p))
647      {
648 <      /* Clean up invitefield */
721 <      DLINK_FOREACH_SAFE(lp, next_lp, source_p->localClient->invited.head)
722 <        del_invite(lp->data, source_p);
723 <
648 >      clear_invite_list(&source_p->connection->invited);
649        del_all_accepts(source_p);
650      }
651    }
652    else if (IsServer(source_p))
653    {
654 <    dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
654 >    sendto_realops_flags(UMODE_EXTERNAL, L_ALL, SEND_NOTICE,
655 >                         "Server %s split from %s",
656 >                         source_p->name, source_p->servptr->name);
657  
658 <    if ((lp = dlinkFindDelete(&global_serv_list, source_p)) != NULL)
659 <      free_dlink_node(lp);
658 >    dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list);
659 >    dlinkDelete(&source_p->node, &global_server_list);
660    }
661  
662    /* Remove source_p from the client lists */
663 <  if (HasID(source_p))
663 >  if (source_p->id[0])
664      hash_del_id(source_p);
665 +
666    if (source_p->name[0])
667      hash_del_client(source_p);
668  
669 <  if (IsUserHostIp(source_p))
670 <    delete_user_host(source_p->username, source_p->host, !MyConnect(source_p));
743 <
744 <  /* remove from global client list
745 <   * NOTE: source_p->node.next cannot be NULL if the client is added
746 <   *       to global_client_list (there is always &me at its end)
747 <   */
748 <  if (source_p != NULL && source_p->node.next != NULL)
749 <    dlinkDelete(&source_p->node, &global_client_list);
750 <
751 <  update_client_exit_stats(source_p);
669 >  if (HasFlag(source_p, FLAGS_USERHOST))
670 >    userhost_del(source_p->sockhost, !MyConnect(source_p));
671  
672    /* Check to see if the client isn't already on the dead list */
673    assert(dlinkFind(&dead_list, source_p) == NULL);
# Line 758 | Line 677 | exit_one_client(struct Client *source_p,
677    dlinkAdd(source_p, make_dlink_node(), &dead_list);
678   }
679  
680 < /* Recursively send QUITs and SQUITs for source_p and all its dependent clients
762 < * and servers to those servers that need them.  A server needs the client
763 < * QUITs if it can't figure them out from the SQUIT (ie pre-TS4) or if it
764 < * isn't getting the SQUIT because of @#(*&@)# hostmasking.  With TS4, once
765 < * a link gets a SQUIT, it doesn't need any QUIT/SQUITs for clients depending
766 < * on that one -orabidoo
767 < *
768 < * This is now called on each local server -adx
769 < */
770 < static void
771 < recurse_send_quits(struct Client *original_source_p, struct Client *source_p,
772 <                   struct Client *from, struct Client *to, const char *comment,
773 <                   const char *splitstr)
774 < {
775 <  dlink_node *ptr, *next;
776 <  struct Client *target_p;
777 <  int hidden = match(me.name, source_p->name); /* XXX */
778 <
779 <  assert(to != source_p);  /* should be already removed from serv_list */
780 <
781 <  /* If this server can handle quit storm (QS) removal
782 <   * of dependents, just send the SQUIT
783 <   *
784 <   * Always check *all* dependent servers if some of them are
785 <   * hidden behind fakename. If so, send out the QUITs -adx
786 <   */
787 <  if (hidden || !IsCapable(to, CAP_QS))
788 <    DLINK_FOREACH_SAFE(ptr, next, source_p->serv->client_list.head)
789 <    {
790 <      target_p = ptr->data;
791 <      sendto_one(to, ":%s QUIT :%s", target_p->name, splitstr);
792 <    }
793 <
794 <  DLINK_FOREACH_SAFE(ptr, next, source_p->serv->server_list.head)
795 <    recurse_send_quits(original_source_p, ptr->data, from, to,
796 <                       comment, splitstr);
797 <
798 <  if (!hidden && ((source_p == original_source_p && to != from) ||
799 <                  !IsCapable(to, CAP_QS)))
800 <  {
801 <    /* don't use a prefix here - we have to be 100% sure the message
802 <     * will be accepted without Unknown prefix etc.. */
803 <    sendto_one(to, "SQUIT %s :%s", ID_or_name(source_p, to), comment);
804 <  }
805 < }
806 <
807 < /*
680 > /*
681   * Remove all clients that depend on source_p; assumes all (S)QUITs have
682 < * already been sent.  we make sure to exit a server's dependent clients
683 < * and servers before the server itself; exit_one_client takes care of
682 > * already been sent.  we make sure to exit a server's dependent clients
683 > * and servers before the server itself; exit_one_client takes care of
684   * actually removing things off llists.   tweaked from +CSr31  -orabidoo
685   */
686   static void
687 < recurse_remove_clients(struct Client *source_p, const char *quitmsg)
687 > recurse_remove_clients(struct Client *source_p, const char *comment)
688   {
689 <  dlink_node *ptr, *next;
689 >  dlink_node *node, *node_next;
690  
691 <  DLINK_FOREACH_SAFE(ptr, next, source_p->serv->client_list.head)
692 <    exit_one_client(ptr->data, quitmsg);
691 >  DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head)
692 >    exit_one_client(node->data, comment);
693  
694 <  DLINK_FOREACH_SAFE(ptr, next, source_p->serv->server_list.head)
694 >  DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head)
695    {
696 <    recurse_remove_clients(ptr->data, quitmsg);
697 <    exit_one_client(ptr->data, quitmsg);
696 >    recurse_remove_clients(node->data, comment);
697 >    exit_one_client(node->data, comment);
698    }
699   }
700  
701   /*
829 ** Remove *everything* that depends on source_p, from all lists, and sending
830 ** all necessary QUITs and SQUITs.  source_p itself is still on the lists,
831 ** and its SQUITs have been sent except for the upstream one  -orabidoo
832 */
833 static void
834 remove_dependents(struct Client *source_p, struct Client *from,
835                  const char *comment, const char *splitstr)
836 {
837  dlink_node *ptr = NULL;
838
839  DLINK_FOREACH(ptr, serv_list.head)
840    recurse_send_quits(source_p, source_p, from, ptr->data,
841                       comment, splitstr);
842
843  recurse_remove_clients(source_p, splitstr);
844 }
845
846 /*
702   * exit_client - exit a client of any type. Generally, you can use
703   * this on any struct Client, regardless of its state.
704   *
705   * Note, you shouldn't exit remote _users_ without first doing
706   * AddFlag(x, FLAGS_KILLED) and propagating a kill or similar message.
707 + *
708   * However, it is perfectly correct to call exit_client to force a _server_
709   * quit (either local or remote one).
710   *
711 + *
712   * inputs:       - a client pointer that is going to be exited
856 *               - for servers, the second argument is a pointer to who
857 *                 is firing the server. This side won't get any generated
858 *                 messages. NEVER NULL!
713   * output:       none
714   * side effects: the client is delinked from all lists, disconnected,
715   *               and the rest of IRC network is notified of the exit.
716   *               Client memory is scheduled to be freed
717   */
718   void
719 < exit_client(struct Client *source_p, struct Client *from, const char *comment)
719 > exit_client(struct Client *source_p, const char *comment)
720   {
721 <  dlink_node *m = NULL;
721 >  assert(!IsMe(source_p));
722 >  assert(source_p != &me);
723  
724    if (MyConnect(source_p))
725    {
726 <    /* DO NOT REMOVE. exit_client can be called twice after a failed
727 <     * read/write.
726 >    /*
727 >     * DO NOT REMOVE. exit_client can be called twice after a failed read/write.
728       */
729 <    if (IsClosing(source_p))
729 >    if (HasFlag(source_p, FLAGS_CLOSING))
730        return;
731  
732 <    SetClosing(source_p);
732 >    AddFlag(source_p, FLAGS_CLOSING);
733  
734 <    if (IsIpHash(source_p))
880 <      remove_one_ip(&source_p->localClient->ip);
881 <
882 <    if (source_p->localClient->auth)
734 >    if (HasFlag(source_p, FLAGS_IPHASH))
735      {
736 <      delete_auth(source_p->localClient->auth);
737 <      source_p->localClient->auth = NULL;
736 >      DelFlag(source_p, FLAGS_IPHASH);
737 >      ipcache_remove_address(&source_p->connection->ip);
738      }
739  
740 <    /* This source_p could have status of one of STAT_UNKNOWN, STAT_CONNECTING
889 <     * STAT_HANDSHAKE or STAT_UNKNOWN
890 <     * all of which are lumped together into unknown_list
891 <     *
892 <     * In all above cases IsRegistered() will not be true.
893 <     */
894 <    if (!IsRegistered(source_p))
895 <    {
896 <      assert(dlinkFind(&unknown_list, source_p));
740 >    auth_delete(&source_p->connection->auth);
741  
742 <      dlinkDelete(&source_p->localClient->lclient_node, &unknown_list);
899 <    }
900 <    else if (IsClient(source_p))
742 >    if (IsClient(source_p))
743      {
744 <      assert(Count.local > 0);
903 <      Count.local--;
744 >      dlink_node *node;
745  
746        if (HasUMode(source_p, UMODE_OPER))
747 <      {
748 <        if ((m = dlinkFindDelete(&oper_list, source_p)) != NULL)
908 <          free_dlink_node(m);
909 <      }
747 >        if ((node = dlinkFindDelete(&oper_list, source_p)))
748 >          free_dlink_node(node);
749  
750        assert(dlinkFind(&local_client_list, source_p));
751 <      dlinkDelete(&source_p->localClient->lclient_node, &local_client_list);
751 >      dlinkDelete(&source_p->connection->lclient_node, &local_client_list);
752  
753 <      if (source_p->localClient->list_task != NULL)
754 <        free_list_task(source_p->localClient->list_task, source_p);
753 >      if (source_p->connection->list_task)
754 >        free_list_task(source_p);
755  
756        watch_del_watch_list(source_p);
918      sendto_realops_flags(UMODE_CCONN, L_ALL, "Client exiting: %s (%s@%s) [%s] [%s]",
919                           source_p->name, source_p->username, source_p->host, comment,
920                           ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
921                           "255.255.255.255" : source_p->sockhost);
922      sendto_realops_flags(UMODE_CCONN_FULL, L_ALL, "CLIEXIT: %s %s %s %s 0 %s",
923                           source_p->name,
924                           source_p->username,
925                           source_p->host,
926
927                           ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
928                           "255.255.255.255" : source_p->sockhost,
929                           comment);
930    }
757  
758 <    /* As soon as a client is known to be a server of some sort
759 <     * it has to be put on the serv_list, or SJOIN's to this new server
760 <     * from the connect burst will not be seen.
761 <     * XXX - TBV.  This is not true. The only place where we put a server on
762 <     * serv_list is in server_estab right now after registration process.
763 <     * And only after this, a burst is sent to the remote server, i.e. we never
764 <     * send a burst to STAT_CONNECTING, or STAT_HANDSHAKE. This will need
765 <     * more investigation later on, but for now, it's not a problem after all.
766 <     */
767 <    if (IsServer(source_p) || IsConnecting(source_p) ||
768 <        IsHandshake(source_p))
758 >      sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
759 >                           "Client exiting: %s (%s@%s) [%s] [%s]",
760 >                           source_p->name, source_p->username, source_p->realhost,
761 >                           source_p->sockhost, comment);
762 >
763 >      ilog(LOG_TYPE_USER, "%s (%ju): %s!%s@%s %s %s %ju/%ju :%s",
764 >           date_ctime(source_p->connection->firsttime),
765 >           CurrentTime - source_p->connection->firsttime,
766 >           source_p->name, source_p->username, source_p->host,
767 >           source_p->sockhost, source_p->account,
768 >           source_p->connection->send.bytes >> 10,
769 >           source_p->connection->recv.bytes >> 10, source_p->info);
770 >    }
771 >    else if (IsServer(source_p))
772      {
773 <      if (dlinkFind(&serv_list, source_p))
774 <      {
775 <        dlinkDelete(&source_p->localClient->lclient_node, &serv_list);
776 <        unset_chcap_usage_counts(source_p);
777 <      }
778 <
779 <      if (IsServer(source_p))
951 <        Count.myserver--;
773 >      assert(dlinkFind(&local_server_list, source_p));
774 >      dlinkDelete(&source_p->connection->lclient_node, &local_server_list);
775 >    }
776 >    else
777 >    {
778 >      assert(dlinkFind(&unknown_list, source_p));
779 >      dlinkDelete(&source_p->connection->lclient_node, &unknown_list);
780      }
953
954    log_user_exit(source_p);
781  
782      if (!IsDead(source_p))
783      {
784        if (IsServer(source_p))
785        {
786 <        /* for them, we are exiting the network */
787 <        sendto_one(source_p, ":%s SQUIT %s :%s",
788 <                   ID_or_name(from, source_p), me.name, comment);
786 >        if (!HasFlag(source_p, FLAGS_SQUIT))
787 >        {
788 >          /* for them, we are exiting the network */
789 >          sendto_one(source_p, ":%s SQUIT %s :%s",
790 >                     me.id, me.id, comment);
791 >        }
792        }
793  
794        sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
795                   source_p->host, comment);
796      }
797  
969    /*
970    ** Currently only server connections can have
971    ** depending remote clients here, but it does no
972    ** harm to check for all local clients. In
973    ** future some other clients than servers might
974    ** have remotes too...
975    **
976    ** Close the Client connection first and mark it
977    ** so that no messages are attempted to send to it.
978    ** Remember it makes source_p->from == NULL.
979    */
798      close_connection(source_p);
799    }
800 +  else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB))
801 +    sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
802 +                         "Client exiting at %s: %s (%s@%s) [%s] [%s]",
803 +                         source_p->servptr->name, source_p->name,
804 +                         source_p->username, source_p->realhost, source_p->sockhost, comment);
805  
806    if (IsServer(source_p))
807    {
808 <    char splitstr[HOSTLEN + HOSTLEN + 2];
808 >    char splitstr[HOSTLEN + HOSTLEN + 2] = "";
809  
810 <    /* This shouldn't ever happen */
811 <    assert(source_p->serv != NULL && source_p->servptr != NULL);
810 >    assert(source_p->serv);
811 >    assert(source_p->servptr);
812  
813      if (ConfigServerHide.hide_servers)
814        /*
815 <       * Set netsplit message to "*.net *.split" to still show
815 >       * Set netsplit message to "*.net *.split" to still show
816         * that its a split, but hide the servers splitting
817         */
818 <      strcpy(splitstr, "*.net *.split");
818 >      strlcpy(splitstr, "*.net *.split", sizeof(splitstr));
819      else
820        snprintf(splitstr, sizeof(splitstr), "%s %s",
821                 source_p->servptr->name, source_p->name);
822  
823 <    remove_dependents(source_p, from->from, comment, splitstr);
823 >    /* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */
824 >    if (!HasFlag(source_p, FLAGS_SQUIT))
825 >      sendto_server(NULL, 0, 0, "SQUIT %s :%s", source_p->id, comment);
826 >
827 >    /* Now exit the clients internally */
828 >    recurse_remove_clients(source_p, splitstr);
829  
830 <    if (source_p->servptr == &me)
830 >    if (MyConnect(source_p))
831      {
832 <      sendto_realops_flags(UMODE_ALL, L_ALL,
833 <                           "%s was connected for %d seconds.  %llu/%llu sendK/recvK.",
834 <                           source_p->name, (int)(CurrentTime - source_p->localClient->firsttime),
835 <                           source_p->localClient->send.bytes >> 10,
836 <                           source_p->localClient->recv.bytes >> 10);
837 <      ilog(L_NOTICE, "%s was connected for %d seconds.  %llu/%llu sendK/recvK.",
838 <           source_p->name, (int)(CurrentTime - source_p->localClient->firsttime),
839 <           source_p->localClient->send.bytes >> 10,
840 <           source_p->localClient->recv.bytes >> 10);
832 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
833 >                           "%s was connected for %s. %ju/%ju sendK/recvK.",
834 >                           source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
835 >                           source_p->connection->send.bytes >> 10,
836 >                           source_p->connection->recv.bytes >> 10);
837 >      ilog(LOG_TYPE_IRCD, "%s was connected for %s. %ju/%ju sendK/recvK.",
838 >           source_p->name, time_dissect(CurrentTime - source_p->connection->firsttime),
839 >           source_p->connection->send.bytes >> 10,
840 >           source_p->connection->recv.bytes >> 10);
841      }
842    }
843    else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED))
844 <  {
1017 <    sendto_server(from->from, NULL, CAP_TS6, NOCAPS,
1018 <                  ":%s QUIT :%s", ID(source_p), comment);
1019 <    sendto_server(from->from, NULL, NOCAPS, CAP_TS6,
1020 <                  ":%s QUIT :%s", source_p->name, comment);
1021 <  }
844 >    sendto_server(source_p->from, 0, 0, ":%s QUIT :%s", source_p->id, comment);
845  
846    /* The client *better* be off all of the lists */
847    assert(dlinkFind(&unknown_list, source_p) == NULL);
848    assert(dlinkFind(&local_client_list, source_p) == NULL);
849 <  assert(dlinkFind(&serv_list, source_p) == NULL);
849 >  assert(dlinkFind(&local_server_list, source_p) == NULL);
850    assert(dlinkFind(&oper_list, source_p) == NULL);
851 +  assert(dlinkFind(&listing_client_list, source_p) == NULL);
852  
853    exit_one_client(source_p, comment);
854   }
# Line 1036 | Line 860 | exit_client(struct Client *source_p, str
860   void
861   dead_link_on_write(struct Client *client_p, int ierrno)
862   {
863 <  dlink_node *ptr;
863 >  dlink_node *node;
864  
865    if (IsDefunct(client_p))
866      return;
867  
868 <  dbuf_clear(&client_p->localClient->buf_recvq);
869 <  dbuf_clear(&client_p->localClient->buf_sendq);
868 >  dbuf_clear(&client_p->connection->buf_recvq);
869 >  dbuf_clear(&client_p->connection->buf_sendq);
870  
871    assert(dlinkFind(&abort_list, client_p) == NULL);
872 <  ptr = make_dlink_node();
872 >  node = make_dlink_node();
873    /* don't let exit_aborted_clients() finish yet */
874 <  dlinkAddTail(client_p, ptr, &abort_list);
874 >  dlinkAddTail(client_p, node, &abort_list);
875  
876    if (eac_next == NULL)
877 <    eac_next = ptr;
877 >    eac_next = node;
878  
879    SetDead(client_p); /* You are dead my friend */
880   }
# Line 1062 | Line 886 | dead_link_on_write(struct Client *client
886   void
887   dead_link_on_read(struct Client *client_p, int error)
888   {
889 <  char errmsg[255];
889 >  char errmsg[IRCD_BUFSIZE];
890    int current_error;
891  
892    if (IsDefunct(client_p))
893      return;
894  
895 <  dbuf_clear(&client_p->localClient->buf_recvq);
896 <  dbuf_clear(&client_p->localClient->buf_sendq);
895 >  dbuf_clear(&client_p->connection->buf_recvq);
896 >  dbuf_clear(&client_p->connection->buf_sendq);
897  
898 <  current_error = get_sockerr(client_p->localClient->fd.fd);
898 >  current_error = get_sockerr(client_p->connection->fd.fd);
899  
900    if (IsServer(client_p) || IsHandshake(client_p))
901    {
1078    int connected = CurrentTime - client_p->localClient->firsttime;
1079      
902      if (error == 0)
903      {
904        /* Admins get the real IP */
905 <      sendto_realops_flags(UMODE_ALL, L_ADMIN,
906 <                           "Server %s closed the connection",
907 <                           get_client_name(client_p, SHOW_IP));
905 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ADMIN, SEND_NOTICE,
906 >                           "Server %s closed the connection",
907 >                           client_get_name(client_p, SHOW_IP));
908  
909        /* Opers get a masked IP */
910 <      sendto_realops_flags(UMODE_ALL, L_OPER,
911 <                           "Server %s closed the connection",
912 <                           get_client_name(client_p, MASK_IP));
910 >      sendto_realops_flags(UMODE_SERVNOTICE, L_OPER, SEND_NOTICE,
911 >                           "Server %s closed the connection",
912 >                           client_get_name(client_p, MASK_IP));
913  
914 <      ilog(L_NOTICE, "Server %s closed the connection",
915 <           get_client_name(client_p, SHOW_IP));
914 >      ilog(LOG_TYPE_IRCD, "Server %s closed the connection",
915 >           client_get_name(client_p, SHOW_IP));
916      }
917      else
918      {
919        report_error(L_ADMIN, "Lost connection to %s: %s",
920 <                   get_client_name(client_p, SHOW_IP), current_error);
920 >                   client_get_name(client_p, SHOW_IP), current_error);
921        report_error(L_OPER, "Lost connection to %s: %s",
922 <                   get_client_name(client_p, MASK_IP), current_error);
922 >                   client_get_name(client_p, MASK_IP), current_error);
923      }
924  
925 <    sendto_realops_flags(UMODE_ALL, L_ALL,
926 <                         "%s had been connected for %d day%s, %2d:%02d:%02d",
927 <                         client_p->name, connected/86400,
1106 <                         (connected/86400 == 1) ? "" : "s",
1107 <                         (connected % 86400) / 3600, (connected % 3600) / 60,
1108 <                         connected % 60);
925 >    sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
926 >                         "%s was connected for %s",
927 >                         client_p->name, time_dissect(CurrentTime - client_p->connection->firsttime));
928    }
929  
930    if (error == 0)
# Line 1115 | Line 934 | dead_link_on_read(struct Client *client_
934      snprintf(errmsg, sizeof(errmsg), "Read error: %s",
935               strerror(current_error));
936  
937 <  exit_client(client_p, &me, errmsg);
937 >  exit_client(client_p, errmsg);
938   }
939  
940   void
# Line 1130 | Line 949 | exit_aborted_clients(void)
949      target_p = ptr->data;
950      eac_next = ptr->next;
951  
952 +    dlinkDelete(ptr, &abort_list);
953 +    free_dlink_node(ptr);
954 +
955      if (target_p == NULL)
956      {
957 <      sendto_realops_flags(UMODE_ALL, L_ALL,
957 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
958                             "Warning: null client on abort_list!");
1137      dlinkDelete(ptr, &abort_list);
1138      free_dlink_node(ptr);
959        continue;
960      }
961  
962 <    dlinkDelete(ptr, &abort_list);
1143 <
1144 <    if (IsSendQExceeded(target_p))
962 >    if (HasFlag(target_p, FLAGS_SENDQEX))
963        notice = "Max SendQ exceeded";
964      else
965        notice = "Write error: connection closed";
966  
967 <    exit_client(target_p, &me, notice);  
1150 <    free_dlink_node(ptr);
967 >    exit_client(target_p, notice);
968    }
969   }
970  
# Line 1164 | Line 981 | exit_aborted_clients(void)
981   void
982   del_accept(struct split_nuh_item *accept_p, struct Client *client_p)
983   {
984 <  dlinkDelete(&accept_p->node, &client_p->localClient->acceptlist);
984 >  dlinkDelete(&accept_p->node, &client_p->connection->acceptlist);
985  
986 <  MyFree(accept_p->nickptr);
987 <  MyFree(accept_p->userptr);
988 <  MyFree(accept_p->hostptr);
989 <  MyFree(accept_p);
986 >  xfree(accept_p->nickptr);
987 >  xfree(accept_p->userptr);
988 >  xfree(accept_p->hostptr);
989 >  xfree(accept_p);
990   }
991  
992   struct split_nuh_item *
993   find_accept(const char *nick, const char *user,
994 <            const char *host, struct Client *client_p, int do_match)
994 >            const char *host, struct Client *client_p,
995 >            int (*cmpfunc)(const char *, const char *))
996   {
997 <  dlink_node *ptr = NULL;
1180 <  /* XXX We wouldn't need that if match() would return 0 on match */
1181 <  int (*cmpfunc)(const char *, const char *) = do_match ? match : irccmp;
997 >  dlink_node *node;
998  
999 <  DLINK_FOREACH(ptr, client_p->localClient->acceptlist.head)
999 >  DLINK_FOREACH(node, client_p->connection->acceptlist.head)
1000    {
1001 <    struct split_nuh_item *accept_p = ptr->data;
1001 >    struct split_nuh_item *accept_p = node->data;
1002  
1003 <    if (cmpfunc(accept_p->nickptr, nick) == do_match &&
1004 <        cmpfunc(accept_p->userptr, user) == do_match &&
1005 <        cmpfunc(accept_p->hostptr, host) == do_match)
1003 >    if (!cmpfunc(accept_p->nickptr, nick) &&
1004 >        !cmpfunc(accept_p->userptr, user) &&
1005 >        !cmpfunc(accept_p->hostptr, host))
1006        return accept_p;
1007    }
1008  
# Line 1204 | Line 1020 | int
1020   accept_message(struct Client *source,
1021                 struct Client *target)
1022   {
1023 <  dlink_node *ptr = NULL;
1023 >  dlink_node *node;
1024 >
1025 >  if (HasFlag(source, FLAGS_SERVICE) ||
1026 >      (HasUMode(source, UMODE_OPER) && ConfigGeneral.opers_bypass_callerid))
1027 >    return 1;
1028  
1029    if (source == target || find_accept(source->name, source->username,
1030 <                                      source->host, target, 1))
1030 >                                      source->host, target, match))
1031      return 1;
1032  
1033 <  if (HasUMode(target, UMODE_SOFTCALLERID))
1034 <    DLINK_FOREACH(ptr, target->channel.head)
1035 <      if (IsMember(source, ((struct Membership *)ptr->data)->chptr))
1033 >  if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID))
1034 >    DLINK_FOREACH(node, target->channel.head)
1035 >      if (IsMember(source, ((struct Membership *)node->data)->chptr))
1036          return 1;
1037  
1038    return 0;
# Line 1227 | Line 1047 | accept_message(struct Client *source,
1047   void
1048   del_all_accepts(struct Client *client_p)
1049   {
1050 <  dlink_node *ptr = NULL, *next_ptr = NULL;
1050 >  dlink_node *node, *node_next;
1051 >
1052 >  DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head)
1053 >    del_accept(node->data, client_p);
1054 > }
1055 >
1056 > unsigned int
1057 > client_get_idle_time(const struct Client *source_p,
1058 >                     const struct Client *target_p)
1059 > {
1060 >  unsigned int idle = 0;
1061 >  const struct ClassItem *const class = get_class_ptr(&target_p->connection->confs);
1062 >
1063 >  if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p)
1064 >    return CurrentTime - target_p->connection->last_privmsg;
1065  
1066 <  DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->acceptlist.head)
1067 <    del_accept(ptr->data, client_p);
1066 >  if (HasUMode(source_p, UMODE_OPER) &&
1067 >      !(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS))
1068 >    return CurrentTime - target_p->connection->last_privmsg;
1069 >
1070 >  const unsigned int min_idle = class->min_idle;
1071 >  const unsigned int max_idle = class->max_idle;
1072 >
1073 >  if (min_idle == max_idle)
1074 >    return min_idle;
1075 >
1076 >  if (class->flags & CLASS_FLAGS_RANDOM_IDLE)
1077 >    idle = genrand_int32();
1078 >  else
1079 >    idle = CurrentTime - target_p->connection->last_privmsg;
1080 >
1081 >  if (max_idle)
1082 >    idle %= max_idle;
1083 >  else
1084 >    idle = 0;
1085 >
1086 >  if (idle < min_idle)
1087 >    idle = min_idle + (idle % (max_idle - min_idle));
1088 >
1089 >  return idle;
1090 > }
1091 >
1092 > /* client_init()
1093 > *
1094 > * inputs       - NONE
1095 > * output       - NONE
1096 > * side effects - initialize client free memory
1097 > */
1098 > void
1099 > client_init(void)
1100 > {
1101 >  static struct event event_ping =
1102 >  {
1103 >    .name = "check_pings",
1104 >    .handler = check_pings,
1105 >    .when = 5
1106 >  };
1107 >
1108 >  client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT);
1109 >  connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION);
1110 >  event_add(&event_ping, NULL);
1111   }

Comparing:
ircd-hybrid-8/src/client.c (property svn:keywords), Revision 1243 by michael, Fri Sep 30 10:47:53 2011 UTC vs.
ircd-hybrid/trunk/src/client.c (property svn:keywords), Revision 8337 by michael, Thu Mar 1 23:06:49 2018 UTC

# Line 1 | Line 1
1 < Id Revision
1 > Id

Diff Legend

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