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

Comparing ircd-hybrid/trunk/src/user.c (file contents):
Revision 6732 by michael, Wed Nov 4 21:56:03 2015 UTC vs.
Revision 7610 by michael, Tue Jun 21 12:54:58 2016 UTC

# Line 1 | Line 1
1   /*
2   *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (c) 1997-2015 ircd-hybrid development team
4 > *  Copyright (c) 1997-2016 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 38 | Line 38
38   #include "motd.h"
39   #include "numeric.h"
40   #include "conf.h"
41 + #include "conf_gecos.h"
42   #include "log.h"
43   #include "server.h"
44   #include "send.h"
# Line 49 | Line 50
50   #include "parse.h"
51   #include "watch.h"
52   #include "isupport.h"
53 + #include "tls.h"
54  
55   static char umode_buffer[IRCD_BUFSIZE];
56  
# Line 107 | Line 109 | user_modes_init(void)
109   * side effects - display to client user counts etc.
110   */
111   void
112 < show_lusers(struct Client *source_p)
112 > show_lusers(struct Client *client_p)
113   {
114 <  if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
115 <    sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
114 >  if (!ConfigServerHide.hide_servers || HasUMode(client_p, UMODE_OPER))
115 >    sendto_one_numeric(client_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
116                         Count.invisi, dlink_list_length(&global_server_list));
117    else
118 <    sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
118 >    sendto_one_numeric(client_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
119                         Count.invisi, 1);
120  
121    if (Count.oper)
122 <    sendto_one_numeric(source_p, &me, RPL_LUSEROP, Count.oper);
122 >    sendto_one_numeric(client_p, &me, RPL_LUSEROP, Count.oper);
123  
124    if (dlink_list_length(&unknown_list))
125 <    sendto_one_numeric(source_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
125 >    sendto_one_numeric(client_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
126  
127    if (dlink_list_length(&channel_list))
128 <    sendto_one_numeric(source_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&channel_list));
128 >    sendto_one_numeric(client_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&channel_list));
129  
130 <  if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
130 >  if (!ConfigServerHide.hide_servers || HasUMode(client_p, UMODE_OPER))
131    {
132 <    sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.local, Count.myserver);
133 <    sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
132 >    sendto_one_numeric(client_p, &me, RPL_LUSERME, Count.local, Count.myserver);
133 >    sendto_one_numeric(client_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
134    }
135    else
136    {
137 <    sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.total, 0);
138 <    sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
137 >    sendto_one_numeric(client_p, &me, RPL_LUSERME, Count.total, 0);
138 >    sendto_one_numeric(client_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
139    }
140  
141 <  sendto_one_numeric(source_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
141 >  sendto_one_numeric(client_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
142  
143 <  if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
144 <    sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
143 >  if (!ConfigServerHide.hide_servers || HasUMode(client_p, UMODE_OPER))
144 >    sendto_one_numeric(client_p, &me, RPL_STATSCONN, Count.max_loc_con,
145                         Count.max_loc_cli, Count.totalrestartcount);
146  
147    if (Count.local > Count.max_loc_cli)
# Line 151 | Line 153 | show_lusers(struct Client *source_p)
153  
154   /* report_and_set_user_flags()
155   *
156 < * inputs       - pointer to source_p
156 > * inputs       - pointer to client_p
157   *              - pointer to conf for this user
158   * output       - NONE
159   * side effects - Report to user any special flags
160   *                they are getting, and set them.
161   */
162   static void
163 < report_and_set_user_flags(struct Client *source_p, const struct MaskItem *conf)
163 > report_and_set_user_flags(struct Client *client_p, const struct MaskItem *conf)
164   {
165    /* If this user is being spoofed, tell them so */
166    if (IsConfDoSpoofIp(conf))
167 <    sendto_one_notice(source_p, &me, ":*** Spoofing your IP. Congrats.");
167 >    sendto_one_notice(client_p, &me, ":*** Spoofing your IP");
168  
169    /* If this user is in the exception class, set it "E lined" */
170    if (IsConfExemptKline(conf))
171    {
172 <    AddFlag(source_p, FLAGS_EXEMPTKLINE);
173 <    sendto_one_notice(source_p, &me, ":*** You are exempt from K/D lines. Congrats.");
172 >    AddFlag(client_p, FLAGS_EXEMPTKLINE);
173 >    sendto_one_notice(client_p, &me, ":*** You are exempt from K/D lines");
174    }
175  
176    if (IsConfExemptXline(conf))
177    {
178 <    AddFlag(source_p, FLAGS_EXEMPTXLINE);
179 <    sendto_one_notice(source_p, &me, ":*** You are exempt from X lines. Congrats.");
178 >    AddFlag(client_p, FLAGS_EXEMPTXLINE);
179 >    sendto_one_notice(client_p, &me, ":*** You are exempt from X lines");
180    }
181  
182    if (IsConfExemptResv(conf))
183    {
184 <    AddFlag(source_p, FLAGS_EXEMPTRESV);
185 <    sendto_one_notice(source_p, &me, ":*** You are exempt from resvs. Congrats.");
184 >    AddFlag(client_p, FLAGS_EXEMPTRESV);
185 >    sendto_one_notice(client_p, &me, ":*** You are exempt from resvs");
186    }
187  
188    /* If this user is exempt from user limits set it "F lined" */
189    if (IsConfExemptLimits(conf))
190    {
191 <    AddFlag(source_p, FLAGS_NOLIMIT);
192 <    sendto_one_notice(source_p, &me, ":*** You are exempt from user limits. Congrats.");
191 >    AddFlag(client_p, FLAGS_NOLIMIT);
192 >    sendto_one_notice(client_p, &me, ":*** You are exempt from user limits");
193    }
194  
195    if (IsConfCanFlood(conf))
196    {
197 <    AddFlag(source_p, FLAGS_CANFLOOD);
198 <    sendto_one_notice(source_p, &me, ":*** You are exempt from flood "
197 <                      "protection, aren't you fearsome.");
197 >    AddFlag(client_p, FLAGS_CANFLOOD);
198 >    sendto_one_notice(client_p, &me, ":*** You are exempt from flood protection");
199    }
200   }
201  
202   /* introduce_client()
203   *
204 < * inputs       - source_p
204 > * inputs       - client_p
205   * output       - NONE
206   * side effects - This common function introduces a client to the rest
207   *                of the net, either from a local client connect or
208   *                from a remote connect.
209   */
210   static void
211 < introduce_client(struct Client *source_p)
211 > introduce_client(struct Client *client_p)
212   {
213    dlink_node *node = NULL;
214    char ubuf[IRCD_BUFSIZE] = "";
215  
216 <  if (MyClient(source_p))
217 <    send_umode(source_p, source_p, 0, ubuf);
217 <  else
218 <    send_umode(NULL, source_p, 0, ubuf);
219 <
220 <  watch_check_hash(source_p, RPL_LOGON);
216 >  send_umode(client_p, MyConnect(client_p), 0, ubuf);
217 >  watch_check_hash(client_p, RPL_LOGON);
218  
219    if (ubuf[0] == '\0')
220    {
# Line 227 | Line 224 | introduce_client(struct Client *source_p
224  
225    DLINK_FOREACH(node, local_server_list.head)
226    {
227 <    struct Client *server = node->data;
227 >    struct Client *server_p = node->data;
228  
229 <    if (server == source_p->from)
229 >    if (server_p == client_p->from)
230        continue;
231  
232 <    if (IsCapable(server, CAPAB_SVS))
233 <      sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s %s :%s",
234 <                 source_p->servptr->id,
235 <                 source_p->name, source_p->hopcount+1,
236 <                 (unsigned long)source_p->tsinfo,
237 <                 ubuf, source_p->username, source_p->host,
238 <                 source_p->sockhost, source_p->id,
239 <                 source_p->account,
243 <                 source_p->info);
244 <    else
245 <      sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s :%s",
246 <                 source_p->servptr->id,
247 <                 source_p->name, source_p->hopcount+1,
248 <                 (unsigned long)source_p->tsinfo,
249 <                 ubuf, source_p->username, source_p->host,
250 <                 source_p->sockhost, source_p->id, source_p->info);
232 >    sendto_one(server_p, ":%s UID %s %u %ju %s %s %s %s %s %s :%s",
233 >               client_p->servptr->id,
234 >               client_p->name, client_p->hopcount+1,
235 >               client_p->tsinfo,
236 >               ubuf, client_p->username, client_p->host,
237 >               client_p->sockhost, client_p->id,
238 >               client_p->account,
239 >               client_p->info);
240  
241 <    if (!EmptyString(source_p->certfp))
242 <      sendto_one(server, ":%s CERTFP %s", source_p->id, source_p->certfp);
241 >    if (!EmptyString(client_p->certfp))
242 >      sendto_one(server_p, ":%s CERTFP %s", client_p->id, client_p->certfp);
243    }
244   }
245  
# Line 261 | Line 250 | introduce_client(struct Client *source_p
250   * side effects -
251   */
252   static void
253 < user_welcome(struct Client *source_p)
253 > user_welcome(struct Client *client_p)
254   {
255    static const char built_date[] = __DATE__ " at " __TIME__;
256  
257 < #ifdef HAVE_LIBCRYPTO
269 <  if (HasFlag(source_p, FLAGS_SSL))
257 >  if (HasFlag(client_p, FLAGS_SSL))
258    {
259 <    AddUMode(source_p, UMODE_SSL);
260 <    sendto_one_notice(source_p, &me, ":*** Connected securely via %s",
261 <                      ssl_get_cipher(source_p->connection->fd.ssl));
262 <  }
263 < #endif
264 <
265 <  sendto_one_numeric(source_p, &me, RPL_WELCOME, ConfigServerInfo.network_name,
266 <                     source_p->name);
267 <  sendto_one_numeric(source_p, &me, RPL_YOURHOST,
268 <                     listener_get_name(source_p->connection->listener), ircd_version);
269 <  sendto_one_numeric(source_p, &me, RPL_CREATED, built_date);
270 <  sendto_one_numeric(source_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
271 <
272 <  isupport_show(source_p);
273 <  show_lusers(source_p);
286 <  motd_signon(source_p);
259 >    AddUMode(client_p, UMODE_SSL);
260 >    sendto_one_notice(client_p, &me, ":*** Connected securely via %s",
261 >                      tls_get_cipher(&client_p->connection->fd.ssl));
262 >  }
263 >
264 >  sendto_one_numeric(client_p, &me, RPL_WELCOME, ConfigServerInfo.network_name,
265 >                     client_p->name);
266 >  sendto_one_numeric(client_p, &me, RPL_YOURHOST,
267 >                     listener_get_name(client_p->connection->listener), ircd_version);
268 >  sendto_one_numeric(client_p, &me, RPL_CREATED, built_date);
269 >  sendto_one_numeric(client_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
270 >
271 >  isupport_show(client_p);
272 >  show_lusers(client_p);
273 >  motd_signon(client_p);
274   }
275  
276   /* check_xline()
# Line 293 | Line 280 | user_welcome(struct Client *source_p)
280   * side effects -
281   */
282   static int
283 < check_xline(struct Client *source_p)
283 > check_xline(struct Client *client_p)
284   {
285 <  struct MaskItem *conf = NULL;
285 >  const struct GecosItem *gecos = NULL;
286  
287 <  if (HasFlag(source_p, FLAGS_EXEMPTXLINE))
287 >  if (HasFlag(client_p, FLAGS_EXEMPTXLINE))
288      return 0;
289  
290 <  if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
290 >  if ((gecos = gecos_find(client_p->info, match)))
291    {
305    ++conf->count;
292      sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
293                           "X-line Rejecting [%s] [%s], user %s [%s]",
294 <                         source_p->info, conf->reason,
295 <                         get_client_name(source_p, HIDE_IP),
296 <                         source_p->sockhost);
294 >                         client_p->info, gecos->reason,
295 >                         get_client_name(client_p, HIDE_IP),
296 >                         client_p->sockhost);
297  
298      ++ServerStats.is_ref;
299 <    exit_client(source_p, "Bad user info");
299 >    exit_client(client_p, "Bad user info");
300      return 1;
301    }
302  
# Line 320 | Line 306 | check_xline(struct Client *source_p)
306   /*! \brief This function is called when both NICK and USER messages
307   *      have been accepted for the client, in whatever order. Only
308   *      after this, is the UID message propagated.
309 < * \param source_p Pointer to given client to introduce
309 > * \param client_p Pointer to given client to introduce
310   */
311   void
312 < register_local_user(struct Client *source_p)
312 > register_local_user(struct Client *client_p)
313   {
328  const char *id = NULL;
314    const struct MaskItem *conf = NULL;
315  
316 <  assert(source_p == source_p->from);
317 <  assert(MyConnect(source_p));
318 <  assert(IsUnknown(source_p));
319 <  assert(!source_p->connection->registration);
316 >  assert(client_p == client_p->from);
317 >  assert(MyConnect(client_p));
318 >  assert(IsUnknown(client_p));
319 >  assert(!client_p->connection->registration);
320  
321    if (ConfigGeneral.ping_cookie)
322    {
323 <    if (!HasFlag(source_p, FLAGS_PINGSENT) && !source_p->connection->random_ping)
323 >    if (!HasFlag(client_p, FLAGS_PINGSENT) && !client_p->connection->random_ping)
324      {
325        do
326 <        source_p->connection->random_ping = genrand_int32();
327 <      while (!source_p->connection->random_ping);
326 >        client_p->connection->random_ping = genrand_int32();
327 >      while (!client_p->connection->random_ping);
328  
329 <      sendto_one(source_p, "PING :%u", source_p->connection->random_ping);
330 <      AddFlag(source_p, FLAGS_PINGSENT);
329 >      sendto_one(client_p, "PING :%u", client_p->connection->random_ping);
330 >      AddFlag(client_p, FLAGS_PINGSENT);
331        return;
332      }
333  
334 <    if (!HasFlag(source_p, FLAGS_PING_COOKIE))
334 >    if (!HasFlag(client_p, FLAGS_PING_COOKIE))
335        return;
336    }
337  
338 <  source_p->connection->last_privmsg = CurrentTime;
338 >  client_p->connection->last_privmsg = CurrentTime;
339    /* Straight up the maximum rate of flooding... */
340 <  source_p->connection->allow_read = MAX_FLOOD_BURST;
340 >  client_p->connection->allow_read = MAX_FLOOD_BURST;
341  
342 <  if (!check_client(source_p))
342 >  if (!check_client(client_p))
343      return;
344  
345 <  if (!valid_hostname(source_p->host))
345 >  if (!valid_hostname(client_p->host))
346    {
347 <    sendto_one_notice(source_p, &me, ":*** Notice -- You have an illegal "
347 >    sendto_one_notice(client_p, &me, ":*** Notice -- You have an illegal "
348                        "character in your hostname");
349 <    strlcpy(source_p->host, source_p->sockhost, sizeof(source_p->host));
349 >    strlcpy(client_p->host, client_p->sockhost, sizeof(client_p->host));
350    }
351  
352 <  conf = source_p->connection->confs.head->data;
352 >  conf = client_p->connection->confs.head->data;
353  
354 <  if (!HasFlag(source_p, FLAGS_GOTID))
354 >  if (!HasFlag(client_p, FLAGS_GOTID))
355    {
356      char username[USERLEN + 1] = "";
357      unsigned int i = 0;
# Line 374 | Line 359 | register_local_user(struct Client *sourc
359      if (IsNeedIdentd(conf))
360      {
361        ++ServerStats.is_ref;
362 <      sendto_one_notice(source_p, &me, ":*** Notice -- You need to install "
362 >      sendto_one_notice(client_p, &me, ":*** Notice -- You need to install "
363                          "identd to use this server");
364 <      exit_client(source_p, "Install identd");
364 >      exit_client(client_p, "Install identd");
365        return;
366      }
367  
368 <    strlcpy(username, source_p->username, sizeof(username));
368 >    strlcpy(username, client_p->username, sizeof(username));
369  
370      if (!IsNoTilde(conf))
371 <      source_p->username[i++] = '~';
371 >      client_p->username[i++] = '~';
372  
373      for (const char *p = username; *p && i < USERLEN; ++p)
374 <      source_p->username[i++] = *p;
374 >      client_p->username[i++] = *p;
375  
376 <    source_p->username[i] = '\0';
376 >    client_p->username[i] = '\0';
377    }
378  
379    /* Password check */
380    if (!EmptyString(conf->passwd))
381    {
382 <    if (!match_conf_password(source_p->connection->password, conf))
382 >    if (!match_conf_password(client_p->connection->password, conf))
383      {
384        ++ServerStats.is_ref;
385  
386 <      sendto_one_numeric(source_p, &me, ERR_PASSWDMISMATCH);
387 <      exit_client(source_p, "Bad Password");
386 >      sendto_one_numeric(client_p, &me, ERR_PASSWDMISMATCH);
387 >      exit_client(client_p, "Bad Password");
388        return;
389      }
390    }
391  
392    /*
393 <   * Don't free source_p->connection->password here - it can be required
393 >   * Don't free client_p->connection->password here - it can be required
394     * by masked /stats I if there are auth {} blocks with need_password = no;
395     * --adx
396     */
397  
398    /*
399 <   * Report if user has &^>= etc. and set flags as needed in source_p
399 >   * Report if user has &^>= etc. and set flags as needed in client_p
400     */
401 <  report_and_set_user_flags(source_p, conf);
401 >  report_and_set_user_flags(client_p, conf);
402  
403 <  if (IsDead(source_p))
403 >  if (IsDead(client_p))
404      return;
405  
406    /*
# Line 427 | Line 412 | register_local_user(struct Client *sourc
412     *   -Taner
413     */
414    if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
415 <      (Count.local >= GlobalSetOptions.maxclients && !HasFlag(source_p, FLAGS_NOLIMIT)))
415 >      (Count.local >= GlobalSetOptions.maxclients && !HasFlag(client_p, FLAGS_NOLIMIT)))
416    {
417      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
418                           "Too many clients, rejecting %s[%s].",
419 <                         source_p->name, source_p->host);
419 >                         client_p->name, client_p->host);
420      ++ServerStats.is_ref;
421 <    exit_client(source_p, "Sorry, server is full - try later");
421 >    exit_client(client_p, "Sorry, server is full - try later");
422      return;
423    }
424  
425 <  if (!valid_username(source_p->username, 1))
425 >  if (!valid_username(client_p->username, 1))
426    {
427      char buf[IRCD_BUFSIZE] = "";
428  
429      sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
430                           "Invalid username: %s (%s@%s)",
431 <                         source_p->name, source_p->username, source_p->host);
431 >                         client_p->name, client_p->username, client_p->host);
432      ++ServerStats.is_ref;
433 <    snprintf(buf, sizeof(buf), "Invalid username [%s]", source_p->username);
434 <    exit_client(source_p, buf);
433 >    snprintf(buf, sizeof(buf), "Invalid username [%s]", client_p->username);
434 >    exit_client(client_p, buf);
435      return;
436    }
437  
438 <  if (check_xline(source_p))
438 >  if (check_xline(client_p))
439      return;
440  
441 +  const char *id;
442    while (hash_find_id((id = uid_get())))
443      ;
444  
445 <  strlcpy(source_p->id, id, sizeof(source_p->id));
446 <  hash_add_id(source_p);
445 >  strlcpy(client_p->id, id, sizeof(client_p->id));
446 >  hash_add_id(client_p);
447  
448    sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
449                         "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
450 <                       source_p->name, source_p->username, source_p->host,
451 <                       source_p->sockhost,
452 <                       get_client_class(&source_p->connection->confs),
453 <                       source_p->info, source_p->id);
450 >                       client_p->name, client_p->username, client_p->host,
451 >                       client_p->sockhost,
452 >                       get_client_class(&client_p->connection->confs),
453 >                       client_p->info, client_p->id);
454  
455    if (ConfigGeneral.invisible_on_connect)
456    {
457 <    AddUMode(source_p, UMODE_INVISIBLE);
457 >    AddUMode(client_p, UMODE_INVISIBLE);
458      ++Count.invisi;
459    }
460  
# Line 486 | Line 472 | register_local_user(struct Client *sourc
472      Count.max_tot = Count.total;
473    ++Count.totalrestartcount;
474  
475 <  assert(source_p->servptr == &me);
476 <  SetClient(source_p);
477 <  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
478 <  dlinkAdd(source_p, &source_p->node, &global_client_list);
475 >  assert(client_p->servptr == &me);
476 >  SetClient(client_p);
477 >  dlinkAdd(client_p, &client_p->lnode, &client_p->servptr->serv->client_list);
478 >  dlinkAdd(client_p, &client_p->node, &global_client_list);
479  
480 <  assert(dlinkFind(&unknown_list, source_p));
480 >  assert(dlinkFind(&unknown_list, client_p));
481  
482 <  dlink_move_node(&source_p->connection->lclient_node,
482 >  dlink_move_node(&client_p->connection->lclient_node,
483                    &unknown_list, &local_client_list);
484  
485 <  user_welcome(source_p);
486 <  userhost_add(source_p->username, source_p->host, 0);
487 <  AddFlag(source_p, FLAGS_USERHOST);
485 >  user_welcome(client_p);
486 >  userhost_add(client_p->username, client_p->host, 0);
487 >  AddFlag(client_p, FLAGS_USERHOST);
488  
489 <  introduce_client(source_p);
489 >  introduce_client(client_p);
490   }
491  
492   /* register_remote_user()
493   *
494 < * inputs       - source_p remote or directly connected client
494 > * inputs       - client_p remote or directly connected client
495   *              - username to register as
496   *              - host name to register as
497   *              - server name
# Line 514 | Line 500 | register_local_user(struct Client *sourc
500   *                is introduced by a server.
501   */
502   void
503 < register_remote_user(struct Client *source_p)
503 > register_remote_user(struct Client *client_p)
504   {
505 <  const struct Client *target_p = NULL;
505 >  const struct Client *server_p = NULL;
506  
507 <  if ((target_p = source_p->servptr) && target_p->from != source_p->from)
507 >  if ((server_p = client_p->servptr) && server_p->from != client_p->from)
508    {
509      sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
510                           "Bad User [%s] :%s USER %s@%s %s, != %s[%s]",
511 <                         source_p->from->name, source_p->name, source_p->username,
512 <                         source_p->host, source_p->servptr->name,
513 <                         target_p->name, target_p->from->name);
514 <    sendto_one(source_p->from,
511 >                         client_p->from->name, client_p->name, client_p->username,
512 >                         client_p->host, client_p->servptr->name,
513 >                         server_p->name, server_p->from->name);
514 >    sendto_one(client_p->from,
515                 ":%s KILL %s :%s (UID from wrong direction (%s != %s))",
516 <               me.id, source_p->id, me.name, source_p->servptr->name,
517 <               target_p->from->name);
516 >               me.id, client_p->id, me.name, client_p->servptr->name,
517 >               server_p->from->name);
518  
519 <    AddFlag(source_p, FLAGS_KILLED);
520 <    exit_client(source_p, "UID server wrong direction");
519 >    AddFlag(client_p, FLAGS_KILLED);
520 >    exit_client(client_p, "UID server wrong direction");
521      return;
522    }
523  
# Line 539 | Line 525 | register_remote_user(struct Client *sour
525     * If the nick has been introduced by a services server,
526     * make it a service as well.
527     */
528 <  if (HasFlag(source_p->servptr, FLAGS_SERVICE))
529 <    AddFlag(source_p, FLAGS_SERVICE);
528 >  if (HasFlag(client_p->servptr, FLAGS_SERVICE))
529 >    AddFlag(client_p, FLAGS_SERVICE);
530  
531    if (++Count.total > Count.max_tot)
532      Count.max_tot = Count.total;
533  
534 <  SetClient(source_p);
535 <  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
536 <  dlinkAdd(source_p, &source_p->node, &global_client_list);
537 <  userhost_add(source_p->username, source_p->host, 1);
538 <  AddFlag(source_p, FLAGS_USERHOST);
534 >  SetClient(client_p);
535 >  dlinkAdd(client_p, &client_p->lnode, &client_p->servptr->serv->client_list);
536 >  dlinkAdd(client_p, &client_p->node, &global_client_list);
537 >  userhost_add(client_p->username, client_p->host, 1);
538 >  AddFlag(client_p, FLAGS_USERHOST);
539  
540 <  if (HasFlag(source_p->servptr, FLAGS_EOB))
540 >  if (HasFlag(client_p->servptr, FLAGS_EOB))
541      sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
542                           "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
543 <                         source_p->servptr->name,
544 <                         source_p->name, source_p->username, source_p->host,
545 <                         source_p->sockhost, source_p->info, source_p->id);
543 >                         client_p->servptr->name,
544 >                         client_p->name, client_p->username, client_p->host,
545 >                         client_p->sockhost, client_p->info, client_p->id);
546  
547 <  introduce_client(source_p);
547 >  introduce_client(client_p);
548   }
549  
550   /* valid_hostname()
# Line 601 | Line 587 | valid_hostname(const char *hostname)
587   int
588   valid_username(const char *username, const int local)
589   {
604  unsigned int dots = 0;
590    const char *p = username;
591  
592    assert(p);
# Line 619 | Line 604 | valid_username(const char *username, con
604  
605    if (local)
606    {
607 +    unsigned int dots = 0;
608 +
609      while (*++p)
610      {
611        if (*p == '.' && ConfigGeneral.dots_in_ident)
# Line 669 | Line 656 | valid_nickname(const char *nickname, con
656    return p - nickname <= NICKLEN;
657   }
658  
659 < /* send_umode()
660 < * send the MODE string for user (user) to connection client_p
661 < * -avalon
662 < *
663 < * inputs       - client_p
677 < *              - source_p
678 < *              - int old
679 < *              - suplied umode_buf
680 < * output       - NONE
659 > /*! \brief Builds a mode change string to buffer pointed by \a buf
660 > * \param client_p  Pointer to client
661 > * \param send      Whether to send a MODE message to client_p
662 > * \param old       Old user mode to compare against when building new mode buffer
663 > * \param buf       Pointer to buffer to build string in
664   */
665   void
666 < send_umode(struct Client *client_p, struct Client *source_p,
667 <           unsigned int old, char *umode_buf)
666 > send_umode(struct Client *client_p, unsigned int send,
667 >           unsigned int old, char *buf)
668   {
669 <  char *m = umode_buf;
669 >  char *m = buf;
670    int what = 0;
671  
672    /*
673     * Build a string in umode_buf to represent the change in the user's
674 <   * mode between the new (source_p->umodes) and 'old'.
674 >   * mode between the new (client_p->umodes) and 'old'.
675     */
676    for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
677    {
678 <    if ((tab->flag & old) && !HasUMode(source_p, tab->flag))
678 >    if ((tab->flag & old) && !HasUMode(client_p, tab->flag))
679      {
680        if (what == MODE_DEL)
681          *m++ = tab->c;
# Line 703 | Line 686 | send_umode(struct Client *client_p, stru
686          *m++ = tab->c;
687        }
688      }
689 <    else if (!(tab->flag & old) && HasUMode(source_p, tab->flag))
689 >    else if (!(tab->flag & old) && HasUMode(client_p, tab->flag))
690      {
691        if (what == MODE_ADD)
692          *m++ = tab->c;
# Line 718 | Line 701 | send_umode(struct Client *client_p, stru
701  
702    *m = '\0';
703  
704 <  if (*umode_buf && client_p)
704 >  if (send && *buf)
705      sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
706                 client_p->name, client_p->username,
707 <               client_p->host, client_p->name, umode_buf);
707 >               client_p->host, client_p->name, buf);
708   }
709  
710   /* send_umode_out()
# Line 731 | Line 714 | send_umode(struct Client *client_p, stru
714   * side effects - Only send ubuf out to servers that know about this client
715   */
716   void
717 < send_umode_out(struct Client *source_p, unsigned int old)
717 > send_umode_out(struct Client *client_p, unsigned int old)
718   {
719    char buf[IRCD_BUFSIZE] = "";
720  
721 <  send_umode(MyClient(source_p) ? source_p : NULL, source_p, old, buf);
721 >  send_umode(client_p, MyConnect(client_p), old, buf);
722  
723    if (buf[0])
724 <    sendto_server(source_p, 0, 0, ":%s MODE %s :%s",
725 <                  source_p->id, source_p->id, buf);
724 >    sendto_server(client_p, 0, 0, ":%s MODE %s :%s",
725 >                  client_p->id, client_p->id, buf);
726   }
727  
728   void
729 < user_set_hostmask(struct Client *target_p, const char *hostname, const int what)
729 > user_set_hostmask(struct Client *client_p, const char *hostname, const int what)
730   {
731    dlink_node *node = NULL;
732  
733 <  if (!strcmp(target_p->host, hostname))
733 >  if (!strcmp(client_p->host, hostname))
734      return;
735  
736    switch (what)
737    {
738      case MODE_ADD:
739 <      AddUMode(target_p, UMODE_HIDDENHOST);
739 >      AddUMode(client_p, UMODE_HIDDENHOST);
740        break;
741      case MODE_DEL:
742 <      DelUMode(target_p, UMODE_HIDDENHOST);
742 >      DelUMode(client_p, UMODE_HIDDENHOST);
743        break;
744      default: return;
745    }
746  
747    if (ConfigGeneral.cycle_on_host_change)
748 <    sendto_common_channels_local(target_p, 0, 0, ":%s!%s@%s QUIT :Changing hostname",
749 <                                 target_p->name, target_p->username, target_p->host);
748 >    sendto_common_channels_local(client_p, 0, 0, CAP_CHGHOST, ":%s!%s@%s QUIT :Changing hostname",
749 >                                 client_p->name, client_p->username, client_p->host);
750  
751 <  if (HasFlag(target_p, FLAGS_USERHOST))
752 <    userhost_del(target_p->username, target_p->host, !MyConnect(target_p));
751 >  sendto_common_channels_local(client_p, 0, CAP_CHGHOST, 0, ":%s!%s@%s CHGHOST %s %s",
752 >                               client_p->name, client_p->username,
753 >                               client_p->host, client_p->username, hostname);
754  
755 <  strlcpy(target_p->host, hostname, sizeof(target_p->host));
755 >  if (HasFlag(client_p, FLAGS_USERHOST))
756 >    userhost_del(client_p->username, client_p->host, !MyConnect(client_p));
757  
758 <  userhost_add(target_p->username, target_p->host, !MyConnect(target_p));
774 <  AddFlag(target_p, FLAGS_USERHOST);
758 >  strlcpy(client_p->host, hostname, sizeof(client_p->host));
759  
760 <  if (MyConnect(target_p))
760 >  userhost_add(client_p->username, client_p->host, !MyConnect(client_p));
761 >  AddFlag(client_p, FLAGS_USERHOST);
762 >
763 >  if (MyConnect(client_p))
764    {
765 <    sendto_one_numeric(target_p, &me, RPL_VISIBLEHOST, target_p->host);
766 <    clear_ban_cache_client(target_p);
765 >    sendto_one_numeric(client_p, &me, RPL_VISIBLEHOST, client_p->host);
766 >    clear_ban_cache_client(client_p);
767    }
768  
769    if (!ConfigGeneral.cycle_on_host_change)
770      return;
771  
772 <  DLINK_FOREACH(node, target_p->channel.head)
772 >  DLINK_FOREACH(node, client_p->channel.head)
773    {
774 <    char modebuf[4], nickbuf[NICKLEN * 3 + 3] = "";
774 >    char modebuf[CMEMBER_STATUS_FLAGS_LEN + 1];
775 >    char nickbuf[CMEMBER_STATUS_FLAGS_LEN * NICKLEN + CMEMBER_STATUS_FLAGS_LEN] = "";
776      char *p = modebuf;
777      int len = 0;
778      const struct Membership *member = node->data;
# Line 792 | Line 780 | user_set_hostmask(struct Client *target_
780      if (has_member_flags(member, CHFL_CHANOP))
781      {
782        *p++ = 'o';
783 <      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
783 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
784      }
785  
786      if (has_member_flags(member, CHFL_HALFOP))
787      {
788        *p++ = 'h';
789 <      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
789 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
790      }
791  
792      if (has_member_flags(member, CHFL_VOICE))
793      {
794        *p++ = 'v';
795 <      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
795 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", client_p->name);
796      }
797  
798      *p = '\0';
799  
800 <
801 <    sendto_channel_local_butone(target_p, CAP_EXTENDED_JOIN, 0, member->chptr, ":%s!%s@%s JOIN %s %s :%s",
802 <                                target_p->name, target_p->username,
803 <                                target_p->host, member->chptr->name,
804 <                                (!IsDigit(target_p->account[0]) && target_p->account[0] != '*') ? target_p->account : "*",
805 <                                target_p->info);
806 <    sendto_channel_local_butone(target_p, 0, CAP_EXTENDED_JOIN, member->chptr, ":%s!%s@%s JOIN :%s",
819 <                                target_p->name, target_p->username,
820 <                                target_p->host, member->chptr->name);
800 >    sendto_channel_local(client_p, member->chptr, 0, CAP_EXTENDED_JOIN, CAP_CHGHOST, ":%s!%s@%s JOIN %s %s :%s",
801 >                         client_p->name, client_p->username,
802 >                         client_p->host, member->chptr->name,
803 >                         client_p->account, client_p->info);
804 >    sendto_channel_local(client_p, member->chptr, 0, 0, CAP_EXTENDED_JOIN | CAP_CHGHOST, ":%s!%s@%s JOIN :%s",
805 >                         client_p->name, client_p->username,
806 >                         client_p->host, member->chptr->name);
807  
808      if (nickbuf[0])
809 <      sendto_channel_local_butone(target_p, 0, 0, member->chptr, ":%s MODE %s +%s %s",
810 <                                  target_p->servptr->name, member->chptr->name,
811 <                                  modebuf, nickbuf);
826 <
809 >      sendto_channel_local(client_p, member->chptr, 0, 0, CAP_CHGHOST, ":%s MODE %s +%s %s",
810 >                           client_p->servptr->name, member->chptr->name,
811 >                           modebuf, nickbuf);
812    }
813  
814 <  if (target_p->away[0])
815 <    sendto_common_channels_local(target_p, 0, CAP_AWAY_NOTIFY,
814 >  if (client_p->away[0])
815 >    sendto_common_channels_local(client_p, 0, CAP_AWAY_NOTIFY, CAP_CHGHOST,
816                                   ":%s!%s@%s AWAY :%s",
817 <                                 target_p->name, target_p->username,
818 <                                 target_p->host, target_p->away);
817 >                                 client_p->name, client_p->username,
818 >                                 client_p->host, client_p->away);
819   }

Diff Legend

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