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-7.2/src/s_user.c (file contents), Revision 889 by michael, Thu Nov 1 12:59:05 2007 UTC vs.
ircd-hybrid/trunk/src/user.c (file contents), Revision 6252 by michael, Fri Jul 10 15:32:00 2015 UTC

# Line 1 | Line 1
1   /*
2 < *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 < *  s_user.c: User related functions.
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-2015 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 user.c
23 > * \brief User related functions.
24 > * \version $Id$
25   */
26  
27   #include "stdinc.h"
28 < #include "tools.h"
29 < #include "s_user.h"
28 < #include "s_misc.h"
28 > #include "list.h"
29 > #include "user.h"
30   #include "channel.h"
31   #include "channel_mode.h"
32   #include "client.h"
32 #include "common.h"
33 #include "fdlist.h"
33   #include "hash.h"
34 + #include "id.h"
35   #include "irc_string.h"
36 #include "sprintf_irc.h"
37 #include "s_bsd.h"
38 #include "irc_getnameinfo.h"
36   #include "ircd.h"
40 #include "list.h"
37   #include "listener.h"
38   #include "motd.h"
39   #include "numeric.h"
40 < #include "s_conf.h"
41 < #include "s_log.h"
42 < #include "s_serv.h"
47 < #include "s_stats.h"
40 > #include "conf.h"
41 > #include "log.h"
42 > #include "server.h"
43   #include "send.h"
49 #include "supported.h"
50 #include "whowas.h"
44   #include "memory.h"
45   #include "packet.h"
46 + #include "rng_mt.h"
47   #include "userhost.h"
48 < #include "hook.h"
49 < #include "s_misc.h"
56 < #include "msg.h"
57 < #include "pcre.h"
48 > #include "misc.h"
49 > #include "parse.h"
50   #include "watch.h"
51 <
60 < int MaxClientCount     = 1;
61 < int MaxConnectionCount = 1;
62 < struct Callback *entering_umode_cb = NULL;
63 < struct Callback *umode_cb = NULL;
64 < struct Callback *uid_get_cb = NULL;
51 > #include "isupport.h"
52  
53   static char umode_buffer[IRCD_BUFSIZE];
54  
55 < static void user_welcome(struct Client *);
56 < static void report_and_set_user_flags(struct Client *, const struct AccessItem *);
70 < static int check_xline(struct Client *);
71 < static void introduce_client(struct Client *, struct Client *);
72 < static void *uid_get(va_list);
73 <
74 < /* Used for building up the isupport string,
75 < * used with init_isupport, add_isupport, delete_isupport
76 < */
77 <
78 < struct Isupport
79 < {
80 <  dlink_node node;
81 <  char *name;
82 <  char *options;
83 <  int number;
84 < };
85 <
86 < static dlink_list support_list = { NULL, NULL, 0 };
87 < MessageFile *isupportFile;
88 <
89 < /* memory is cheap. map 0-255 to equivalent mode */
90 < unsigned int user_modes[256] =
55 > const struct user_modes *umode_map[256];
56 > const struct user_modes  umode_tab[] =
57   {
58 <  /* 0x00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x0F */
59 <  /* 0x10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x1F */
60 <  /* 0x20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x2F */
61 <  /* 0x30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x3F */
62 <  0,                  /* @ */
63 <  0,                  /* A */
64 <  0,                  /* B */
65 <  UMODE_CCONN_FULL,   /* C */
66 <  UMODE_DEAF,         /* D */
67 <  0,                  /* E */
68 <  0,                  /* F */
69 <  UMODE_SOFTCALLERID, /* G */
70 <  0,                  /* H */
71 <  0,                  /* I */
72 <  0,                  /* J */
73 <  0,                  /* K */
74 <  0,                  /* L */
75 <  0,                  /* M */
76 <  0,                  /* N */
77 <  0,                  /* O */
78 <  0,                  /* P */
79 <  0,                  /* Q */
80 <  0,                  /* R */
81 <  0,                  /* S */
82 <  0,                  /* T */
83 <  0,                  /* U */
84 <  0,                  /* V */
85 <  0,                  /* W */
86 <  0,                  /* X */
121 <  0,                  /* Y */
122 <  0,                  /* Z 0x5A */
123 <  0, 0, 0, 0, 0,      /* 0x5F   */
124 <  0,                  /* 0x60   */
125 <  UMODE_ADMIN,        /* a */
126 <  UMODE_BOTS,         /* b */
127 <  UMODE_CCONN,        /* c */
128 <  UMODE_DEBUG,        /* d */
129 <  0,                  /* e */
130 <  UMODE_FULL,         /* f */
131 <  UMODE_CALLERID,     /* g */
132 <  0,                  /* h */
133 <  UMODE_INVISIBLE,    /* i */
134 <  0,                  /* j */
135 <  UMODE_SKILL,        /* k */
136 <  UMODE_LOCOPS,       /* l */
137 <  0,                  /* m */
138 <  UMODE_NCHANGE,      /* n */
139 <  UMODE_OPER,         /* o */
140 <  0,                  /* p */
141 <  0,                  /* q */
142 <  UMODE_REJ,          /* r */
143 <  UMODE_SERVNOTICE,   /* s */
144 <  0,                  /* t */
145 <  UMODE_UNAUTH,       /* u */
146 <  0,                  /* v */
147 <  UMODE_WALLOP,       /* w */
148 <  UMODE_EXTERNAL,     /* x */
149 <  UMODE_SPY,          /* y */
150 <  UMODE_OPERWALL,     /* z      0x7A */
151 <  0,0,0,0,0,          /* 0x7B - 0x7F */
152 <
153 <  /* 0x80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x8F */
154 <  /* 0x90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x9F */
155 <  /* 0xA0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xAF */
156 <  /* 0xB0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xBF */
157 <  /* 0xC0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xCF */
158 <  /* 0xD0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xDF */
159 <  /* 0xE0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xEF */
160 <  /* 0xF0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  /* 0xFF */
58 >  { 'D', UMODE_DEAF         },
59 >  { 'F', UMODE_FARCONNECT   },
60 >  { 'G', UMODE_SOFTCALLERID },
61 >  { 'H', UMODE_HIDDEN       },
62 >  { 'R', UMODE_REGONLY      },
63 >  { 'S', UMODE_SSL          },
64 >  { 'W', UMODE_WEBIRC       },
65 >  { 'a', UMODE_ADMIN        },
66 >  { 'b', UMODE_BOTS         },
67 >  { 'c', UMODE_CCONN        },
68 >  { 'd', UMODE_DEBUG        },
69 >  { 'e', UMODE_EXTERNAL     },
70 >  { 'f', UMODE_FULL         },
71 >  { 'g', UMODE_CALLERID     },
72 >  { 'i', UMODE_INVISIBLE    },
73 >  { 'j', UMODE_REJ          },
74 >  { 'k', UMODE_SKILL        },
75 >  { 'l', UMODE_LOCOPS       },
76 >  { 'n', UMODE_NCHANGE      },
77 >  { 'o', UMODE_OPER         },
78 >  { 'p', UMODE_HIDECHANS    },
79 >  { 'q', UMODE_HIDEIDLE     },
80 >  { 'r', UMODE_REGISTERED   },
81 >  { 's', UMODE_SERVNOTICE   },
82 >  { 'u', UMODE_UNAUTH       },
83 >  { 'w', UMODE_WALLOP       },
84 >  { 'x', UMODE_HIDDENHOST   },
85 >  { 'y', UMODE_SPY          },
86 >  { '\0', 0 }
87   };
88  
89   void
90 < assemble_umode_buffer(void)
90 > user_modes_init(void)
91   {
166  unsigned int idx = 0;
92    char *umode_buffer_ptr = umode_buffer;
93  
94 <  for (; idx < (sizeof(user_modes) / sizeof(int)); ++idx)
95 <    if (user_modes[idx])
96 <      *umode_buffer_ptr++ = idx;
94 >  for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
95 >  {
96 >    umode_map[tab->c] = tab;
97 >    *umode_buffer_ptr++ = tab->c;
98 >  }
99  
100    *umode_buffer_ptr = '\0';
101   }
# Line 180 | Line 107 | assemble_umode_buffer(void)
107   * side effects - display to client user counts etc.
108   */
109   void
110 < show_lusers(struct Client *source_p)
110 > show_lusers(struct Client *source_p)
111   {
112 <  const char *from, *to;
112 >  if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
113 >    sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
114 >                       Count.invisi, dlink_list_length(&global_server_list));
115 >  else
116 >    sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
117 >                       Count.invisi, 1);
118  
119 <  if (!MyConnect(source_p) && IsCapable(source_p->from, CAP_TS6) && HasID(source_p))
119 >  if (Count.oper)
120 >    sendto_one_numeric(source_p, &me, RPL_LUSEROP, Count.oper);
121 >
122 >  if (dlink_list_length(&unknown_list))
123 >    sendto_one_numeric(source_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
124 >
125 >  if (dlink_list_length(&channel_list))
126 >    sendto_one_numeric(source_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&channel_list));
127 >
128 >  if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
129    {
130 <    from = me.id;
131 <    to = source_p->id;
130 >    sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.local, Count.myserver);
131 >    sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
132    }
133    else
134    {
135 <    from = me.name;
136 <    to = source_p->name;
135 >    sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.total, 0);
136 >    sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
137    }
138  
139 <  if (!ConfigServerHide.hide_servers || IsOper(source_p))
140 <    sendto_one(source_p, form_str(RPL_LUSERCLIENT),
141 <               from, to, (Count.total-Count.invisi),
142 <               Count.invisi, dlink_list_length(&global_serv_list));
143 <  else
144 <    sendto_one(source_p, form_str(RPL_LUSERCLIENT), from, to,
145 <               (Count.total-Count.invisi), Count.invisi, 1);
139 >  sendto_one_numeric(source_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
140 >
141 >  if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
142 >    sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
143 >                       Count.max_loc_cli, Count.totalrestartcount);
144 >
145 >  if (Count.local > Count.max_loc_cli)
146 >    Count.max_loc_cli = Count.local;
147 >
148 >  if ((Count.local + Count.myserver) > Count.max_loc_con)
149 >    Count.max_loc_con = Count.local + Count.myserver;
150 > }
151 >
152 > /* report_and_set_user_flags()
153 > *
154 > * inputs       - pointer to source_p
155 > *              - pointer to conf for this user
156 > * output       - NONE
157 > * side effects - Report to user any special flags
158 > *                they are getting, and set them.
159 > */
160 > static void
161 > report_and_set_user_flags(struct Client *source_p, const struct MaskItem *conf)
162 > {
163 >  /* If this user is being spoofed, tell them so */
164 >  if (IsConfDoSpoofIp(conf))
165 >    sendto_one_notice(source_p, &me, ":*** Spoofing your IP. Congrats.");
166 >
167 >  /* If this user is in the exception class, set it "E lined" */
168 >  if (IsConfExemptKline(conf))
169 >  {
170 >    SetExemptKline(source_p);
171 >    sendto_one_notice(source_p, &me, ":*** You are exempt from K/D lines. Congrats.");
172 >  }
173  
174 <  if (Count.oper > 0)
175 <    sendto_one(source_p, form_str(RPL_LUSEROP),
176 <               from, to, Count.oper);
177 <
178 <  if (dlink_list_length(&unknown_list) > 0)
179 <    sendto_one(source_p, form_str(RPL_LUSERUNKNOWN),
180 <               from, to, dlink_list_length(&unknown_list));
181 <
182 <  if (dlink_list_length(&global_channel_list) > 0)
183 <    sendto_one(source_p, form_str(RPL_LUSERCHANNELS),
216 <               from, to, dlink_list_length(&global_channel_list));
217 <
218 <  if (!ConfigServerHide.hide_servers || IsOper(source_p))
219 <  {
220 <    sendto_one(source_p, form_str(RPL_LUSERME),
221 <               from, to, Count.local, Count.myserver);
222 <    sendto_one(source_p, form_str(RPL_LOCALUSERS),
223 <               from, to, Count.local, Count.max_loc,
224 <               Count.local, Count.max_loc);
174 >  if (IsConfExemptXline(conf))
175 >  {
176 >    SetExemptXline(source_p);
177 >    sendto_one_notice(source_p, &me, ":*** You are exempt from X lines. Congrats.");
178 >  }
179 >
180 >  if (IsConfExemptResv(conf))
181 >  {
182 >    SetExemptResv(source_p);
183 >    sendto_one_notice(source_p, &me, ":*** You are exempt from resvs. Congrats.");
184    }
185 +
186 +  /* If this user is exempt from user limits set it "F lined" */
187 +  if (IsConfExemptLimits(conf))
188 +  {
189 +    SetExemptLimits(source_p);
190 +    sendto_one_notice(source_p, &me, ":*** You are exempt from user limits. Congrats.");
191 +  }
192 +
193 +  if (IsConfCanFlood(conf))
194 +  {
195 +    SetCanFlood(source_p);
196 +    sendto_one_notice(source_p, &me, ":*** You are exempt from flood "
197 +                      "protection, aren't you fearsome.");
198 +  }
199 + }
200 +
201 + /* introduce_client()
202 + *
203 + * inputs       - source_p
204 + * output       - NONE
205 + * side effects - This common function introduces a client to the rest
206 + *                of the net, either from a local client connect or
207 + *                from a remote connect.
208 + */
209 + static void
210 + introduce_client(struct Client *source_p)
211 + {
212 +  dlink_node *node = NULL;
213 +  char ubuf[IRCD_BUFSIZE] = "";
214 +
215 +  if (MyClient(source_p))
216 +    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);
221 +
222 +  if (ubuf[0] == '\0')
223 +  {
224 +    ubuf[0] = '+';
225 +    ubuf[1] = '\0';
226 +  }
227 +
228 +  DLINK_FOREACH(node, local_server_list.head)
229    {
230 <    sendto_one(source_p, form_str(RPL_LUSERME),
229 <               from, to, Count.total, 0);
230 <    sendto_one(source_p, form_str(RPL_LOCALUSERS),
231 <               from, to, Count.total, Count.max_tot,
232 <               Count.total, Count.max_tot);
233 <  }
234 <
235 <  sendto_one(source_p, form_str(RPL_GLOBALUSERS),
236 <             from, to, Count.total, Count.max_tot,
237 <             Count.total, Count.max_tot);
238 <
239 <  if (!ConfigServerHide.hide_servers || IsOper(source_p))
240 <    sendto_one(source_p, form_str(RPL_STATSCONN), from, to,
241 <               MaxConnectionCount, MaxClientCount, Count.totalrestartcount);
230 >    struct Client *server = node->data;
231  
232 <  if (Count.local > MaxClientCount)
233 <    MaxClientCount = Count.local;
232 >    if (server == source_p->from)
233 >      continue;
234  
235 <  if ((Count.local + Count.myserver) > MaxConnectionCount)
236 <    MaxConnectionCount = Count.local + Count.myserver;
235 >    if (IsCapable(server, CAP_SVS))
236 >      sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s %s :%s",
237 >                 source_p->servptr->id,
238 >                 source_p->name, source_p->hopcount+1,
239 >                 (unsigned long)source_p->tsinfo,
240 >                 ubuf, source_p->username, source_p->host,
241 >                 source_p->sockhost, source_p->id,
242 >                 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);
251 >
252 >    if (!EmptyString(source_p->certfp))
253 >      sendto_one(server, ":%s CERTFP %s", source_p->id, source_p->certfp);
254 >  }
255   }
256  
257 < /* show_isupport()
257 > /* user_welcome()
258   *
259 < * inputs       - pointer to client
259 > * inputs       - client pointer to client to welcome
260   * output       - NONE
261 < * side effects - display to client what we support (for them)
261 > * side effects -
262   */
263 < void
264 < show_isupport(struct Client *source_p)
263 > static void
264 > user_welcome(struct Client *source_p)
265   {
266 <  send_message_file(source_p, isupportFile);
266 > #if defined(__TIME__) && defined(__DATE__)
267 >  static const char built_date[] = __DATE__ " at " __TIME__;
268 > #else
269 >  static const char built_date[] = "unknown";
270 > #endif
271 >
272 > #ifdef HAVE_LIBCRYPTO
273 >  if (HasFlag(source_p, FLAGS_SSL))
274 >  {
275 >    AddUMode(source_p, UMODE_SSL);
276 >    sendto_one_notice(source_p, &me, ":*** Connected securely via %s",
277 >                      ssl_get_cipher(source_p->connection->fd.ssl));
278 >  }
279 > #endif
280 >
281 >  sendto_one_numeric(source_p, &me, RPL_WELCOME, ConfigServerInfo.network_name,
282 >                     source_p->name);
283 >  sendto_one_numeric(source_p, &me, RPL_YOURHOST,
284 >                     get_listener_name(source_p->connection->listener), ircd_version);
285 >  sendto_one_numeric(source_p, &me, RPL_CREATED, built_date);
286 >  sendto_one_numeric(source_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
287 >
288 >  isupport_show(source_p);
289 >  show_lusers(source_p);
290 >  motd_signon(source_p);
291   }
292  
293 < /*
294 < ** register_local_user
295 < **      This function is called when both NICK and USER messages
296 < **      have been accepted for the client, in whatever order. Only
297 < **      after this, is the USER message propagated.
298 < **
299 < **      NICK's must be propagated at once when received, although
300 < **      it would be better to delay them too until full info is
301 < **      available. Doing it is not so simple though, would have
302 < **      to implement the following:
303 < **
304 < **      (actually it has been implemented already for a while) -orabidoo
305 < **
306 < **      1) user telnets in and gives only "NICK foobar" and waits
307 < **      2) another user far away logs in normally with the nick
308 < **         "foobar" (quite legal, as this server didn't propagate
309 < **         it).
310 < **      3) now this server gets nick "foobar" from outside, but
311 < **         has alread the same defined locally. Current server
312 < **         would just issue "KILL foobar" to clean out dups. But,
313 < **         this is not fair. It should actually request another
314 < **         nick from local user or kill him/her...
315 < */
293 > /* check_xline()
294 > *
295 > * inputs       - pointer to client to test
296 > * outupt       - 1 if exiting 0 if ok
297 > * side effects -
298 > */
299 > static int
300 > check_xline(struct Client *source_p)
301 > {
302 >  struct MaskItem *conf = NULL;
303 >
304 >  if (IsExemptXline(source_p))
305 >    return 0;
306 >
307 >  if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
308 >  {
309 >    ++conf->count;
310 >    sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
311 >                         "X-line Rejecting [%s] [%s], user %s [%s]",
312 >                         source_p->info, conf->reason,
313 >                         get_client_name(source_p, HIDE_IP),
314 >                         source_p->sockhost);
315 >
316 >    ++ServerStats.is_ref;
317 >    exit_client(source_p, "Bad user info");
318 >    return 1;
319 >  }
320 >
321 >  return 0;
322 > }
323 >
324 > /*! \brief This function is called when both NICK and USER messages
325 > *      have been accepted for the client, in whatever order. Only
326 > *      after this, is the UID message propagated.
327 > * \param source_p Pointer to given client to introduce
328 > */
329   void
330 < register_local_user(struct Client *client_p, struct Client *source_p,
287 <                    const char *nick, const char *username)
330 > register_local_user(struct Client *source_p)
331   {
332 <  const struct AccessItem *aconf = NULL;
333 <  char ipaddr[HOSTIPLEN];
291 <  dlink_node *ptr = NULL;
292 <  dlink_node *m = NULL;
332 >  const char *id = NULL;
333 >  const struct MaskItem *conf = NULL;
334  
335 <  assert(source_p != NULL);
335 >  assert(source_p == source_p->from);
336    assert(MyConnect(source_p));
337 <  assert(source_p->username != username);
338 <  assert(!source_p->localClient->registration);
337 >  assert(IsUnknown(source_p));
338 >  assert(!source_p->connection->registration);
339  
340 <  ClearCap(client_p, CAP_TS6);
300 <
301 <  if (ConfigFileEntry.ping_cookie)
340 >  if (ConfigGeneral.ping_cookie)
341    {
342 <    if (!IsPingSent(source_p) &&
304 <       source_p->localClient->random_ping == 0)
342 >    if (!IsPingSent(source_p) && !source_p->connection->random_ping)
343      {
344 <      source_p->localClient->random_ping = (unsigned long)rand();
345 <      sendto_one(source_p, "PING :%lu",
346 <                 source_p->localClient->random_ping);
344 >      do
345 >        source_p->connection->random_ping = genrand_int32();
346 >      while (!source_p->connection->random_ping);
347 >
348 >      sendto_one(source_p, "PING :%u", source_p->connection->random_ping);
349        SetPingSent(source_p);
350        return;
351      }
# Line 314 | Line 354 | register_local_user(struct Client *clien
354        return;
355    }
356  
357 <  source_p->localClient->last = CurrentTime;
357 >  source_p->connection->last_privmsg = CurrentTime;
358    /* Straight up the maximum rate of flooding... */
359 <  source_p->localClient->allow_read = MAX_FLOOD_BURST;
359 >  source_p->connection->allow_read = MAX_FLOOD_BURST;
360  
361 <  if (!execute_callback(client_check_cb, source_p, username))
361 >  if (!check_client(source_p))
362      return;
363  
364 <  if (valid_hostname(source_p->host) == 0)
364 >  if (!valid_hostname(source_p->host))
365    {
366 <    sendto_one(source_p, ":%s NOTICE %s :*** Notice -- You have an illegal "
367 <               "character in your hostname", me.name, source_p->name);
368 <    strlcpy(source_p->host, source_p->sockhost,
329 <            sizeof(source_p->host));
366 >    sendto_one_notice(source_p, &me, ":*** Notice -- You have an illegal "
367 >                      "character in your hostname");
368 >    strlcpy(source_p->host, source_p->sockhost, sizeof(source_p->host));
369    }
370  
371 <  ptr   = source_p->localClient->confs.head;
333 <  aconf = map_to_conf(ptr->data);
371 >  conf = source_p->connection->confs.head->data;
372  
373    if (!IsGotId(source_p))
374    {
375 <    const char *p = NULL;
375 >    char username[USERLEN + 1] = "";
376 >    const char *p = username;
377      unsigned int i = 0;
378  
379 <    if (IsNeedIdentd(aconf))
379 >    if (IsNeedIdentd(conf))
380      {
381 <      ServerStats->is_ref++;
382 <      sendto_one(source_p, ":%s NOTICE %s :*** Notice -- You need to install "
383 <                 "identd to use this server", me.name, source_p->name);
384 <      exit_client(source_p, &me, "Install identd");
381 >      ++ServerStats.is_ref;
382 >      sendto_one_notice(source_p, &me, ":*** Notice -- You need to install "
383 >                        "identd to use this server");
384 >      exit_client(source_p, "Install identd");
385        return;
386      }
387  
388 <    p = username;
388 >    strlcpy(username, source_p->username, sizeof(username));
389  
390 <    if (!IsNoTilde(aconf))
390 >    if (!IsNoTilde(conf))
391        source_p->username[i++] = '~';
392  
393 <    while (*p && i < USERLEN)
394 <    {
356 <      if (*p != '[')
357 <        source_p->username[i++] = *p;
358 <      p++;
359 <    }
393 >    for (; *p && i < USERLEN; ++p)
394 >      source_p->username[i++] = *p;
395  
396      source_p->username[i] = '\0';
397    }
398  
399 <  /* password check */
400 <  if (!EmptyString(aconf->passwd))
399 >  /* Password check */
400 >  if (!EmptyString(conf->passwd))
401    {
402 <    const char *pass = source_p->localClient->passwd;
368 <
369 <    if (!match_conf_password(pass, aconf))
402 >    if (!match_conf_password(source_p->connection->password, conf))
403      {
404 <      ServerStats->is_ref++;
405 <      sendto_one(source_p, form_str(ERR_PASSWDMISMATCH),
406 <                 me.name, source_p->name);
407 <      exit_client(source_p, &me, "Bad Password");
404 >      ++ServerStats.is_ref;
405 >
406 >      sendto_one_numeric(source_p, &me, ERR_PASSWDMISMATCH);
407 >      exit_client(source_p, "Bad Password");
408        return;
409      }
410    }
411  
412 <  /* don't free source_p->localClient->passwd here - it can be required
413 <   * by masked /stats I if there are auth{} blocks with need_password = no;
412 >  /*
413 >   * Don't free source_p->connection->password here - it can be required
414 >   * by masked /stats I if there are auth {} blocks with need_password = no;
415     * --adx
416     */
417  
418 <  /* report if user has &^>= etc. and set flags as needed in source_p */
419 <  report_and_set_user_flags(source_p, aconf);
418 >  /*
419 >   * Report if user has &^>= etc. and set flags as needed in source_p
420 >   */
421 >  report_and_set_user_flags(source_p, conf);
422 >
423 >  if (IsDead(source_p))
424 >    return;
425  
426 <  /* Limit clients -
426 >  /*
427 >   * Limit clients -
428     * We want to be able to have servers and F-line clients
429     * connect, so save room for "buffer" connections.
430     * Smaller servers may want to decrease this, and it should
431     * probably be just a percentage of the MAXCLIENTS...
432     *   -Taner
433     */
434 <  /* Except "F:" clients */
435 <  if ((Count.local >= ServerInfo.max_clients + MAX_BUFFER) ||
396 <      (Count.local >= ServerInfo.max_clients && !IsExemptLimits(source_p)))
434 >  if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
435 >      (Count.local >= GlobalSetOptions.maxclients && !IsExemptLimits(source_p)))
436    {
437 <    sendto_realops_flags(UMODE_FULL, L_ALL,
437 >    sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
438                           "Too many clients, rejecting %s[%s].",
439 <                         nick, source_p->host);
440 <    ServerStats->is_ref++;
441 <    exit_client(source_p, &me, "Sorry, server is full - try later");
439 >                         source_p->name, source_p->host);
440 >    ++ServerStats.is_ref;
441 >    exit_client(source_p, "Sorry, server is full - try later");
442      return;
443    }
444  
445 <  /* valid user name check */
407 <  if (valid_username(source_p->username) == 0)
445 >  if (!valid_username(source_p->username, 1))
446    {
447 <    char tmpstr2[IRCD_BUFSIZE];
447 >    char buf[IRCD_BUFSIZE] = "";
448  
449 <    sendto_realops_flags(UMODE_REJ, L_ALL, "Invalid username: %s (%s@%s)",
450 <                         nick, source_p->username, source_p->host);
451 <    ServerStats->is_ref++;
452 <    ircsprintf(tmpstr2, "Invalid username [%s]", source_p->username);
453 <    exit_client(source_p, &me, tmpstr2);
449 >    sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
450 >                         "Invalid username: %s (%s@%s)",
451 >                         source_p->name, source_p->username, source_p->host);
452 >    ++ServerStats.is_ref;
453 >    snprintf(buf, sizeof(buf), "Invalid username [%s]", source_p->username);
454 >    exit_client(source_p, buf);
455      return;
456    }
457  
419  assert(source_p == client_p);
420
458    if (check_xline(source_p))
459      return;
460  
461 <  if (IsDead(client_p))
462 <    return;
426 <
427 <  if (me.id[0])
428 <  {
429 <    const char *id = execute_callback(uid_get_cb, source_p);
430 <
431 <    while (hash_find_id(id) != NULL)
432 <      id = uid_get(NULL);
461 >  while (hash_find_id((id = uid_get())))
462 >    ;
463  
464 <    strlcpy(source_p->id, id, sizeof(source_p->id));
465 <    hash_add_id(source_p);
436 <  }
437 <
438 <  irc_getnameinfo((struct sockaddr *)&source_p->localClient->ip,
439 <                  source_p->localClient->ip.ss_len, ipaddr,
440 <                  HOSTIPLEN, NULL, 0, NI_NUMERICHOST);
441 <
442 <  sendto_realops_flags(UMODE_CCONN, L_ALL,
443 <                       "Client connecting: %s (%s@%s) [%s] {%s} [%s]",
444 <                       nick, source_p->username, source_p->host,
445 <                       ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
446 <                       "255.255.255.255" : ipaddr, get_client_class(source_p),
447 <                       source_p->info);
448 <
449 <  sendto_realops_flags(UMODE_CCONN_FULL, L_ALL,
450 <                       "CLICONN %s %s %s %s %s %s %s 0 %s",
451 <                       nick, source_p->username, source_p->host,
452 <                       ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
453 <                       "255.255.255.255" : ipaddr,
454 <                       get_client_class(source_p),
455 <                       ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
456 <                           "<hidden>" : source_p->client_host,
457 <                       ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
458 <                           "<hidden>" : source_p->client_server,
459 <                       source_p->info);
464 >  strlcpy(source_p->id, id, sizeof(source_p->id));
465 >  hash_add_id(source_p);
466  
467 +  sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
468 +                       "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
469 +                       source_p->name, source_p->username, source_p->host,
470 +                       source_p->sockhost,
471 +                       get_client_class(&source_p->connection->confs),
472 +                       source_p->info, source_p->id);
473  
474 <  /* If they have died in send_* don't do anything. */
463 <  if (IsDead(source_p))
464 <    return;
465 <
466 <  if (ConfigFileEntry.invisible_on_connect)
474 >  if (ConfigGeneral.invisible_on_connect)
475    {
476 <    source_p->umodes |= UMODE_INVISIBLE;
477 <    Count.invisi++;
476 >    AddUMode(source_p, UMODE_INVISIBLE);
477 >    ++Count.invisi;
478    }
479  
480 <  if ((++Count.local) > Count.max_loc)
480 >  if (++Count.local > Count.max_loc)
481    {
482      Count.max_loc = Count.local;
483  
484      if (!(Count.max_loc % 10))
485 <      sendto_realops_flags(UMODE_ALL, L_ALL, "New Max Local Clients: %d",
485 >      sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
486 >                           "New maximum local client connections: %u",
487                             Count.max_loc);
488    }
489  
481  SetClient(source_p);
482
483  source_p->servptr = &me;
484  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
485
486  /* Increment our total user count here */
490    if (++Count.total > Count.max_tot)
491      Count.max_tot = Count.total;
492 <  Count.totalrestartcount++;
492 >  ++Count.totalrestartcount;
493 >
494 >  assert(source_p->servptr == &me);
495 >  SetClient(source_p);
496 >  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
497 >  dlinkAdd(source_p, &source_p->node, &global_client_list);
498  
499 <  source_p->localClient->allow_read = MAX_FLOOD_BURST;
499 >  assert(dlinkFind(&unknown_list, source_p));
500  
501 <  if ((m = dlinkFindDelete(&unknown_list, source_p)) != NULL)
502 <  {
495 <    free_dlink_node(m);
496 <    dlinkAdd(source_p, &source_p->localClient->lclient_node, &local_client_list);
497 <  }
498 <  else assert(0);
501 >  dlink_move_node(&source_p->connection->lclient_node,
502 >                  &unknown_list, &local_client_list);
503  
504    user_welcome(source_p);
505    add_user_host(source_p->username, source_p->host, 0);
506    SetUserHost(source_p);
507  
508 <  introduce_client(client_p, source_p);
508 >  introduce_client(source_p);
509   }
510  
511   /* register_remote_user()
512   *
513 < * inputs       - client_p directly connected client
510 < *              - source_p remote or directly connected client
513 > * inputs       - source_p remote or directly connected client
514   *              - username to register as
515   *              - host name to register as
516   *              - server name
514 *              - realname (gecos)
517   * output       - NONE
518   * side effects - This function is called when a remote client
519   *                is introduced by a server.
520   */
521   void
522 < register_remote_user(struct Client *client_p, struct Client *source_p,
521 <                     const char *username, const char *host, const char *server,
522 <                     const char *realname)
522 > register_remote_user(struct Client *source_p)
523   {
524 <  struct Client *target_p = NULL;
525 <
526 <  assert(source_p != NULL);
527 <  assert(source_p->username != username);
528 <
529 <  strlcpy(source_p->host, host, sizeof(source_p->host));
530 <  strlcpy(source_p->info, realname, sizeof(source_p->info));
531 <  strlcpy(source_p->username, username, sizeof(source_p->username));
532 <
533 <  /*
534 <   * coming from another server, take the servers word for it
535 <   */
536 <  source_p->servptr = find_server(server);
537 <
538 <  /* Super GhostDetect:
539 <   * If we can't find the server the user is supposed to be on,
540 <   * then simply blow the user away.        -Taner
541 <   */
542 <  if (source_p->servptr == NULL)
543 <  {
544 <    sendto_realops_flags(UMODE_ALL, L_ALL,
545 <                         "No server %s for user %s[%s@%s] from %s",
546 <                         server, source_p->name, source_p->username,
547 <                         source_p->host, source_p->from->name);
548 <    kill_client(client_p, source_p, "%s (Server doesn't exist)", me.name);
549 <
550 <    SetKilled(source_p);
551 <    exit_client(source_p, &me, "Ghosted Client");
552 <    return;
553 <  }
524 >  const struct Client *target_p = NULL;
525  
526    if ((target_p = source_p->servptr) && target_p->from != source_p->from)
527    {
528 <    sendto_realops_flags(UMODE_DEBUG, L_ALL,
528 >    sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
529                           "Bad User [%s] :%s USER %s@%s %s, != %s[%s]",
530 <                         client_p->name, source_p->name, source_p->username,
530 >                         source_p->from->name, source_p->name, source_p->username,
531                           source_p->host, source_p->servptr->name,
532                           target_p->name, target_p->from->name);
533 <    kill_client(client_p, source_p,
534 <                "%s (NICK from wrong direction (%s != %s))",
535 <                me.name, source_p->servptr->name, target_p->from->name);
536 <    SetKilled(source_p);
537 <    exit_client(source_p, &me, "USER server wrong direction");
533 >    sendto_one(source_p->from,
534 >               ":%s KILL %s :%s (UID from wrong direction (%s != %s))",
535 >               me.id, source_p->id, me.name, source_p->servptr->name,
536 >               target_p->from->name);
537 >
538 >    AddFlag(source_p, FLAGS_KILLED);
539 >    exit_client(source_p, "UID server wrong direction");
540      return;
541    }
542  
543 <  /* Increment our total user count here */
543 >  /*
544 >   * If the nick has been introduced by a services server,
545 >   * make it a service as well.
546 >   */
547 >  if (HasFlag(source_p->servptr, FLAGS_SERVICE))
548 >    AddFlag(source_p, FLAGS_SERVICE);
549 >
550    if (++Count.total > Count.max_tot)
551      Count.max_tot = Count.total;
552  
553    SetClient(source_p);
554    dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
555 +  dlinkAdd(source_p, &source_p->node, &global_client_list);
556    add_user_host(source_p->username, source_p->host, 1);
557    SetUserHost(source_p);
558  
559 <  introduce_client(client_p, source_p);
560 < }
559 >  if (HasFlag(source_p->servptr, FLAGS_EOB))
560 >    sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
561 >                         "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
562 >                         source_p->servptr->name,
563 >                         source_p->name, source_p->username, source_p->host,
564 >                         source_p->sockhost, source_p->info, source_p->id);
565  
566 < /* introduce_client()
583 < *
584 < * inputs       - client_p
585 < *              - source_p
586 < * output       - NONE
587 < * side effects - This common function introduces a client to the rest
588 < *                of the net, either from a local client connect or
589 < *                from a remote connect.
590 < */
591 < static void
592 < introduce_client(struct Client *client_p, struct Client *source_p)
593 < {
594 <  dlink_node *server_node = NULL;
595 <  static char ubuf[12];
596 <
597 <  if (MyClient(source_p))
598 <    send_umode(source_p, source_p, 0, SEND_UMODES, ubuf);
599 <  else
600 <    send_umode(NULL, source_p, 0, SEND_UMODES, ubuf);
601 <
602 <  watch_check_hash(source_p, RPL_LOGON);
603 <
604 <  if (*ubuf == '\0')
605 <  {
606 <    ubuf[0] = '+';
607 <    ubuf[1] = '\0';
608 <  }
609 <
610 <  DLINK_FOREACH(server_node, serv_list.head)
611 <  {
612 <    struct Client *server = server_node->data;
613 <
614 <    if (server == client_p)
615 <        continue;
616 <
617 <    if (IsCapable(server, CAP_TS6) && HasID(source_p))
618 <      sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s :%s",
619 <                 source_p->servptr->id,
620 <                 source_p->name, source_p->hopcount+1,
621 <                 (unsigned long)source_p->tsinfo,
622 <                 ubuf, source_p->username, source_p->host,
623 <                 (MyClient(source_p) && IsIPSpoof(source_p)) ?
624 <                 "0" : source_p->sockhost, source_p->id, source_p->info);
625 <    else
626 <      sendto_one(server, "NICK %s %d %lu %s %s %s %s :%s",
627 <                 source_p->name, source_p->hopcount+1,
628 <                 (unsigned long)source_p->tsinfo,
629 <                 ubuf, source_p->username, source_p->host,
630 <                 source_p->servptr->name, source_p->info);
631 <  }
566 >  introduce_client(source_p);
567   }
568  
569   /* valid_hostname()
# Line 645 | Line 580 | valid_hostname(const char *hostname)
580   {
581    const char *p = hostname;
582  
583 <  assert(p != NULL);
583 >  assert(p);
584  
585 <  if ('.' == *p || ':' == *p)
585 >  if (EmptyString(p) || *p == '.' || *p == ':')
586      return 0;
587  
588 <  while (*p)
654 <  {
588 >  for (; *p; ++p)
589      if (!IsHostChar(*p))
590        return 0;
657    p++;
658  }
591  
592 <  return 1;
592 >  return p - hostname <= HOSTLEN;
593   }
594  
595   /* valid_username()
# Line 672 | Line 604 | valid_hostname(const char *hostname)
604   * style of username
605   */
606   int
607 < valid_username(const char *username)
607 > valid_username(const char *username, const int local)
608   {
609 <  int dots      = 0;
609 >  unsigned int dots = 0;
610    const char *p = username;
611  
612 <  assert(p != NULL);
612 >  assert(p);
613  
614 <  if ('~' == *p)
614 >  if (*p == '~')
615      ++p;
616  
617 <  /* reject usernames that don't start with an alphanum
617 >  /*
618 >   * Reject usernames that don't start with an alphanum
619     * i.e. reject jokers who have '-@somehost' or '.@somehost'
620     * or "-hi-@somehost", "h-----@somehost" would still be accepted.
621     */
622    if (!IsAlNum(*p))
623      return 0;
624  
625 <  while (*++p)
625 >  if (local)
626    {
627 <    if ((*p == '.') && ConfigFileEntry.dots_in_ident)
627 >    while (*++p)
628      {
629 <      dots++;
630 <
631 <      if (dots > ConfigFileEntry.dots_in_ident)
632 <        return 0;
633 <      if (!IsUserChar(p[1]))
629 >      if (*p == '.' && ConfigGeneral.dots_in_ident)
630 >      {
631 >        if (++dots > ConfigGeneral.dots_in_ident)
632 >          return 0;
633 >        if (!IsUserChar(*(p + 1)))
634 >          return 0;
635 >      }
636 >      else if (!IsUserChar(*p))
637          return 0;
638      }
703    else if (!IsUserChar(*p))
704      return 0;
639    }
640 <
707 <  return 1;
708 < }
709 <
710 < /* report_and_set_user_flags()
711 < *
712 < * inputs       - pointer to source_p
713 < *              - pointer to aconf for this user
714 < * output       - NONE
715 < * side effects - Report to user any special flags
716 < *                they are getting, and set them.
717 < */
718 < static void
719 < report_and_set_user_flags(struct Client *source_p, const struct AccessItem *aconf)
720 < {
721 <  /* If this user is being spoofed, tell them so */
722 <  if (IsConfDoSpoofIp(aconf))
723 <  {
724 <    sendto_one(source_p,
725 <               ":%s NOTICE %s :*** Spoofing your IP. congrats.",
726 <               me.name, source_p->name);
727 <  }
728 <
729 <  /* If this user is in the exception class, Set it "E lined" */
730 <  if (IsConfExemptKline(aconf))
731 <  {
732 <    SetExemptKline(source_p);
733 <    sendto_one(source_p,
734 <               ":%s NOTICE %s :*** You are exempt from K/D/G lines. congrats.",
735 <               me.name, source_p->name);
736 <  }
737 <
738 <  /* The else here is to make sure that G line exempt users
739 <   * do not get noticed twice.
740 <   */
741 <  else if (IsConfExemptGline(aconf))
742 <  {
743 <    SetExemptGline(source_p);
744 <    sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from G lines.",
745 <               me.name, source_p->name);
746 <  }
747 <
748 <  if (IsConfExemptResv(aconf))
749 <  {
750 <    SetExemptResv(source_p);
751 <    sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from resvs.",
752 <               me.name, source_p->name);
753 <  }
754 <
755 <  /* If this user is exempt from user limits set it "F lined" */
756 <  if (IsConfExemptLimits(aconf))
757 <  {
758 <    SetExemptLimits(source_p);
759 <    sendto_one(source_p,
760 <               ":%s NOTICE %s :*** You are exempt from user limits. congrats.",
761 <               me.name,source_p->name);
762 <  }
763 <
764 <  /* If this user is exempt from idle time outs */
765 <  if (IsConfIdlelined(aconf))
640 >  else
641    {
642 <    SetIdlelined(source_p);
643 <    sendto_one(source_p,
644 <               ":%s NOTICE %s :*** You are exempt from idle limits. congrats.",
770 <               me.name, source_p->name);
642 >    while (*++p)
643 >      if (!IsUserChar(*p))
644 >        return 0;
645    }
646  
647 <  if (IsConfCanFlood(aconf))
774 <  {
775 <    SetCanFlood(source_p);
776 <    sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from flood "
777 <               "protection, aren't you fearsome.",
778 <               me.name, source_p->name);
779 <  }
647 >  return p - username <= USERLEN;
648   }
649  
650 < /* do_local_user()
650 > /* clean_nick_name()
651   *
652 < * inputs       -
653 < * output       - NONE
654 < * side effects -
652 > * input        - nickname
653 > *              - whether it's a local nick (1) or remote (0)
654 > * output       - none
655 > * side effects - walks through the nickname, returning 0 if erroneous
656   */
657 < void
658 < do_local_user(const char *nick, struct Client *client_p, struct Client *source_p,
790 <              const char *username, const char *host, const char *server,
791 <              const char *realname)
657 > int
658 > valid_nickname(const char *nickname, const int local)
659   {
660 <  assert(source_p != NULL);
794 <  assert(source_p->username != username);
795 <
796 <  if (source_p == NULL)
797 <    return;
798 <
799 <  if (!IsUnknown(source_p))
800 <  {
801 <    sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
802 <               me.name, nick);
803 <    return;
804 <  }
660 >  const char *p = nickname;
661  
662 <  source_p->localClient->registration &= ~REG_NEED_USER;
662 >  assert(p);
663  
664    /*
665 <   * don't take the clients word for it, ever
665 >   * Nicks can't start with a digit or - or be 0 length.
666     */
667 <  source_p->servptr = &me;
668 <
813 <  strlcpy(source_p->info, realname, sizeof(source_p->info));
814 <
815 <  /* stash for later */
816 <  strlcpy(source_p->client_host, host, sizeof(source_p->client_host));
817 <  strlcpy(source_p->client_server, server, sizeof(source_p->client_server));
818 <
819 <  if (!IsGotId(source_p))
820 <  {
821 <    /* save the username in the client
822 <     * If you move this you'll break ping cookies..you've been warned
823 <     */
824 <    strlcpy(source_p->username, username, sizeof(source_p->username));
825 <  }
826 <
827 <  if (!source_p->localClient->registration)
828 <    /* NICK already received, now I have USER... */
829 <    register_local_user(client_p, source_p, source_p->name, username);
830 < }
831 <
832 < /* change_simple_umode()
833 < *
834 < * this callback can be hooked to allow special handling of
835 < * certain usermodes
836 < */
837 < static void *
838 < change_simple_umode(va_list args)
839 < {
840 <  struct Client *client_p;
841 <  struct Client *source_p;
842 <  int what;
843 <  unsigned int flag;
844 <
845 <  client_p = va_arg(args, struct Client *);
846 <  source_p = va_arg(args, struct Client *);
847 <  what = va_arg(args, int);
848 <  flag = va_arg(args, unsigned int);
849 <
850 <  if (what == MODE_ADD)
851 <    source_p->umodes |= flag;
852 <  else
853 <    source_p->umodes &= ~flag;
854 <
855 <  return NULL;
856 < }
857 <
858 < /* set_user_mode()
859 < *
860 < * added 15/10/91 By Darren Reed.
861 < * parv[0] - sender
862 < * parv[1] - username to change mode for
863 < * parv[2] - modes to change
864 < */
865 < void
866 < set_user_mode(struct Client *client_p, struct Client *source_p,
867 <              int parc, char *parv[])
868 < {
869 <  unsigned int flag, setflags;
870 <  char **p, *m, buf[IRCD_BUFSIZE];
871 <  struct Client *target_p;
872 <  int what = MODE_ADD, badflag = 0, i;
873 <
874 <  assert(!(parc < 2));
875 <
876 <  if ((target_p = find_person(client_p, parv[1])) == NULL)
877 <  {
878 <    if (MyConnect(source_p))
879 <      sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
880 <                 me.name, source_p->name, parv[1]);
881 <    return;
882 <  }
883 <
884 <  if (IsServer(source_p))
885 <  {
886 <     sendto_realops_flags(UMODE_ALL, L_ADMIN, "*** Mode for User %s from %s",
887 <                          parv[1], source_p->name);
888 <     return;
889 <  }
890 <
891 <  if (source_p != target_p || target_p->from != source_p->from)
892 <  {
893 <     sendto_one(source_p, form_str(ERR_USERSDONTMATCH),
894 <                me.name, source_p->name);
895 <     return;
896 <  }
897 <
898 <  if (parc < 3)
899 <  {
900 <    m = buf;
901 <    *m++ = '+';
902 <
903 <    for (i = 0; i < 128; i++)
904 <      if (source_p->umodes & user_modes[i])
905 <        *m++ = (char)i;
906 <    *m = '\0';
907 <
908 <    sendto_one(source_p, form_str(RPL_UMODEIS),
909 <               me.name, source_p->name, buf);
910 <    return;
911 <  }
912 <
913 <  execute_callback(entering_umode_cb, client_p, source_p);
914 <
915 <  /* find flags already set for user */
916 <  setflags = source_p->umodes;
917 <
918 <  /* parse mode change string(s) */
919 <  for (p = &parv[2]; p && *p; p++)
920 <  {
921 <    for (m = *p; *m; m++)
922 <    {
923 <      switch (*m)
924 <      {
925 <        case '+':
926 <          what = MODE_ADD;
927 <          break;
928 <        case '-':
929 <          what = MODE_DEL;
930 <          break;
931 <        case 'o':
932 <          if (what == MODE_ADD)
933 <          {
934 <            if (IsServer(client_p) && !IsOper(source_p))
935 <            {
936 <              ++Count.oper;
937 <              SetOper(source_p);
938 <            }
939 <          }
940 <          else
941 <          {
942 <            /* Only decrement the oper counts if an oper to begin with
943 <             * found by Pat Szuta, Perly , perly@xnet.com
944 <             */
945 <            if (!IsOper(source_p))
946 <              break;
947 <
948 <            ClearOper(source_p);
949 <            source_p->umodes &= ~ConfigFileEntry.oper_only_umodes;
950 <            Count.oper--;
951 <
952 <            if (MyConnect(source_p))
953 <            {
954 <              dlink_node *dm;
955 <
956 <              detach_conf(source_p, OPER_TYPE);
957 <              ClearOperFlags(source_p);
958 <
959 <              if ((dm = dlinkFindDelete(&oper_list, source_p)) != NULL)
960 <                free_dlink_node(dm);
961 <            }
962 <          }
963 <
964 <          break;
965 <
966 <        /* we may not get these,
967 <         * but they shouldnt be in default
968 <         */
969 <        case ' ' :
970 <        case '\n':
971 <        case '\r':
972 <        case '\t':
973 <          break;
974 <
975 <        default:
976 <          if ((flag = user_modes[(unsigned char)*m]))
977 <          {
978 <            if (MyConnect(source_p) && !IsOper(source_p) &&
979 <                (ConfigFileEntry.oper_only_umodes & flag))
980 <            {
981 <              badflag = 1;
982 <            }
983 <            else
984 <              execute_callback(umode_cb, client_p, source_p, what, flag);
985 <          }
986 <          else
987 <          {
988 <            if (MyConnect(source_p))
989 <              badflag = 1;
990 <          }
991 <
992 <          break;
993 <      }
994 <    }
995 <  }
996 <
997 <  if (badflag)
998 <    sendto_one(source_p, form_str(ERR_UMODEUNKNOWNFLAG),
999 <               me.name, source_p->name);
1000 <
1001 <  if ((source_p->umodes & UMODE_NCHANGE) && !IsOperN(source_p))
1002 <  {
1003 <    sendto_one(source_p, ":%s NOTICE %s :*** You have no admin flag;",
1004 <               me.name, source_p->name);
1005 <    source_p->umodes &= ~UMODE_NCHANGE; /* only tcm's really need this */
1006 <  }
1007 <
1008 <  if (MyConnect(source_p) && (source_p->umodes & UMODE_ADMIN) &&
1009 <      !IsOperAdmin(source_p) && !IsOperHiddenAdmin(source_p))
1010 <  {
1011 <    sendto_one(source_p, ":%s NOTICE %s :*** You have no admin flag;",
1012 <               me.name, source_p->name);
1013 <    source_p->umodes &= ~UMODE_ADMIN;
1014 <  }
667 >  if (EmptyString(p) || *p == '-' || (IsDigit(*p) && local))
668 >    return 0;
669  
670 <  if (!(setflags & UMODE_INVISIBLE) && IsInvisible(source_p))
671 <    ++Count.invisi;
672 <  if ((setflags & UMODE_INVISIBLE) && !IsInvisible(source_p))
1019 <    --Count.invisi;
670 >  for (; *p; ++p)
671 >    if (!IsNickChar(*p))
672 >      return 0;
673  
674 <  /*
1022 <   * compare new flags with old flags and send string which
1023 <   * will cause servers to update correctly.
1024 <   */
1025 <  send_umode_out(client_p, source_p, setflags);
674 >  return p - nickname <= NICKLEN;
675   }
676  
677   /* send_umode()
# Line 1038 | Line 687 | set_user_mode(struct Client *client_p, s
687   */
688   void
689   send_umode(struct Client *client_p, struct Client *source_p,
690 <           unsigned int old, unsigned int sendmask, char *umode_buf)
690 >           unsigned int old, char *umode_buf)
691   {
1043  int what = 0;
1044  unsigned int i;
1045  unsigned int flag;
692    char *m = umode_buf;
693 +  int what = 0;
694  
695    /*
696 <   * build a string in umode_buf to represent the change in the user's
696 >   * Build a string in umode_buf to represent the change in the user's
697     * mode between the new (source_p->umodes) and 'old'.
698     */
699 <  for (i = 0; i < 128; i++)
699 >  for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
700    {
701 <    flag = user_modes[i];
1055 <    if (!flag)
1056 <      continue;
1057 <
1058 <    if (MyClient(source_p) && !(flag & sendmask))
1059 <      continue;
1060 <
1061 <    if ((flag & old) && !(source_p->umodes & flag))
701 >    if ((tab->flag & old) && !HasUMode(source_p, tab->flag))
702      {
703        if (what == MODE_DEL)
704 <        *m++ = (char)i;
704 >        *m++ = tab->c;
705        else
706        {
707          what = MODE_DEL;
708          *m++ = '-';
709 <        *m++ = (char)i;
709 >        *m++ = tab->c;
710        }
711      }
712 <    else if (!(flag & old) && (source_p->umodes & flag))
712 >    else if (!(tab->flag & old) && HasUMode(source_p, tab->flag))
713      {
714        if (what == MODE_ADD)
715 <        *m++ = (char)i;
715 >        *m++ = tab->c;
716        else
717        {
718          what = MODE_ADD;
719          *m++ = '+';
720 <        *m++ = (char)i;
720 >        *m++ = tab->c;
721        }
722      }
723    }
# Line 1086 | Line 726 | send_umode(struct Client *client_p, stru
726  
727    if (*umode_buf && client_p)
728      sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
729 <               source_p->name, source_p->username,
730 <               source_p->host, source_p->name, umode_buf);
729 >               client_p->name, client_p->username,
730 >               client_p->host, client_p->name, umode_buf);
731   }
732  
733   /* send_umode_out()
# Line 1097 | Line 737 | send_umode(struct Client *client_p, stru
737   * side effects - Only send ubuf out to servers that know about this client
738   */
739   void
740 < send_umode_out(struct Client *client_p, struct Client *source_p,
1101 <               unsigned int old)
740 > send_umode_out(struct Client *source_p, unsigned int old)
741   {
742 <  char buf[IRCD_BUFSIZE] = { '\0' };
1104 <  dlink_node *ptr = NULL;
742 >  char buf[IRCD_BUFSIZE] = "";
743  
744 <  send_umode(NULL, source_p, old, IsOperHiddenAdmin(source_p) ?
1107 <             SEND_UMODES & ~UMODE_ADMIN : SEND_UMODES, buf);
744 >  send_umode(MyClient(source_p) ? source_p : NULL, source_p, old, buf);
745  
746    if (buf[0])
747 <  {
748 <    DLINK_FOREACH(ptr, serv_list.head)
1112 <    {
1113 <      struct Client *target_p = ptr->data;
1114 <
1115 <      if ((target_p != client_p) && (target_p != source_p))
1116 <        sendto_one(target_p, ":%s MODE %s :%s",
1117 <                   ID_or_name(source_p, target_p),
1118 <                   ID_or_name(source_p, target_p), buf);
1119 <    }
1120 <  }
1121 <
1122 <  if (client_p && MyClient(client_p))
1123 <    send_umode(client_p, source_p, old, 0xffffffff, buf);
747 >    sendto_server(source_p, 0, 0, ":%s MODE %s :%s",
748 >                  source_p->id, source_p->id, buf);
749   }
750  
751 < /* user_welcome()
752 < *
1128 < * inputs       - client pointer to client to welcome
1129 < * output       - NONE
1130 < * side effects -
1131 < */
1132 < static void
1133 < user_welcome(struct Client *source_p)
751 > void
752 > user_set_hostmask(struct Client *target_p, const char *hostname, const int what)
753   {
754 < #if defined(__TIME__) && defined(__DATE__)
1136 <  static const char built_date[] = __DATE__ " at " __TIME__;
1137 < #else
1138 <  static const char built_date[] = "unknown";
1139 < #endif
1140 <
1141 < #ifdef HAVE_LIBCRYPTO
1142 <  if (source_p->localClient->fd.ssl != NULL)
1143 <    sendto_one(source_p, ":%s NOTICE %s :*** Connected securely via %s",
1144 <               me.name, source_p->name,
1145 <               ssl_get_cipher(source_p->localClient->fd.ssl));
1146 < #endif
1147 <
1148 <  sendto_one(source_p, form_str(RPL_WELCOME), me.name, source_p->name,
1149 <             ServerInfo.network_name, source_p->name);
1150 <  sendto_one(source_p, form_str(RPL_YOURHOST), me.name, source_p->name,
1151 <             get_listener_name(source_p->localClient->listener), ircd_version);
1152 <  sendto_one(source_p, form_str(RPL_CREATED),
1153 <             me.name, source_p->name, built_date);
1154 <  sendto_one(source_p, form_str(RPL_MYINFO),
1155 <             me.name, source_p->name, me.name, ircd_version, umode_buffer);
1156 <  show_isupport(source_p);
1157 <
1158 <  if (source_p->id[0] != '\0')
1159 <    sendto_one(source_p, form_str(RPL_YOURID), me.name,
1160 <               source_p->name, source_p->id);
754 >  dlink_node *node = NULL;
755  
756 <  show_lusers(source_p);
757 <
1164 <  if (ConfigFileEntry.short_motd)
1165 <  {
1166 <    sendto_one(source_p, "NOTICE %s :*** Notice -- motd was last changed at %s",
1167 <               source_p->name, ConfigFileEntry.motd.lastChangedDate);
1168 <    sendto_one(source_p,
1169 <               "NOTICE %s :*** Notice -- Please read the motd if you haven't "
1170 <               "read it", source_p->name);
1171 <    sendto_one(source_p, form_str(RPL_MOTDSTART),
1172 <               me.name, source_p->name, me.name);
1173 <    sendto_one(source_p, form_str(RPL_MOTD),
1174 <               me.name, source_p->name,
1175 <               "*** This is the short motd ***");
1176 <    sendto_one(source_p, form_str(RPL_ENDOFMOTD),
1177 <               me.name, source_p->name);
1178 <  }
1179 <  else  
1180 <    send_message_file(source_p, &ConfigFileEntry.motd);
1181 < }
1182 <
1183 < /* check_xline()
1184 < *
1185 < * inputs       - pointer to client to test
1186 < * outupt       - 1 if exiting 0 if ok
1187 < * side effects -
1188 < */
1189 < static int
1190 < check_xline(struct Client *source_p)
1191 < {
1192 <  struct ConfItem *conf = NULL;
1193 <  const char *reason = NULL;
756 >  if (!strcmp(target_p->host, hostname))
757 >    return;
758  
759 <  if ((conf = find_matching_name_conf(XLINE_TYPE, source_p->info, NULL, NULL, 0)) ||
1196 <      (conf = find_matching_name_conf(RXLINE_TYPE, source_p->info, NULL, NULL, 0)))
759 >  switch (what)
760    {
761 <    struct MatchItem *reg = map_to_conf(conf);
762 <
763 <    ++reg->count;
764 <
765 <    if (reg->reason != NULL)
766 <      reason = reg->reason;
767 <    else
1205 <      reason = "No Reason";
1206 <
1207 <    sendto_realops_flags(UMODE_REJ, L_ALL,
1208 <                         "X-line Rejecting [%s] [%s], user %s [%s]",
1209 <                         source_p->info, reason,
1210 <                         get_client_name(source_p, HIDE_IP),
1211 <                         source_p->sockhost);
1212 <
1213 <    ServerStats->is_ref++;
1214 <    if (REJECT_HOLD_TIME > 0)
1215 <    {
1216 <      sendto_one(source_p, ":%s NOTICE %s :Bad user info",
1217 <                 me.name, source_p->name);
1218 <      source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
1219 <      SetCaptured(source_p);
1220 <    }
1221 <    else
1222 <      exit_client(source_p, &me, "Bad user info");
1223 <    return 1;
761 >    case MODE_ADD:
762 >      AddUMode(target_p, UMODE_HIDDENHOST);
763 >      break;
764 >    case MODE_DEL:
765 >      DelUMode(target_p, UMODE_HIDDENHOST);
766 >      break;
767 >    default: return;
768    }
769  
770 <  return 0;
771 < }
772 <
1229 < /* oper_up()
1230 < *
1231 < * inputs       - pointer to given client to oper
1232 < * output       - NONE
1233 < * side effects - Blindly opers up given source_p, using aconf info
1234 < *                all checks on passwords have already been done.
1235 < *                This could also be used by rsa oper routines.
1236 < */
1237 < void
1238 < oper_up(struct Client *source_p)
1239 < {
1240 <  unsigned int old = source_p->umodes;
1241 <  const char *operprivs = "";
1242 <  const struct AccessItem *oconf = NULL;
1243 <
1244 <  assert(source_p->localClient->confs.head);
1245 <  oconf = map_to_conf((source_p->localClient->confs.head)->data);
1246 <
1247 <  ++Count.oper;
1248 <  SetOper(source_p);
1249 <
1250 <  if (oconf->modes)
1251 <    source_p->umodes |= oconf->modes;
1252 <  else if (ConfigFileEntry.oper_umodes)
1253 <    source_p->umodes |= ConfigFileEntry.oper_umodes;
1254 <  else
1255 <    source_p->umodes |= (UMODE_SERVNOTICE|UMODE_OPERWALL|
1256 <                         UMODE_WALLOP|UMODE_LOCOPS);
1257 <
1258 <  if (!(old & UMODE_INVISIBLE) && IsInvisible(source_p))
1259 <    ++Count.invisi;
1260 <  if ((old & UMODE_INVISIBLE) && !IsInvisible(source_p))
1261 <    --Count.invisi;
1262 <
1263 <  assert(dlinkFind(&oper_list, source_p) == NULL);
1264 <  dlinkAdd(source_p, make_dlink_node(), &oper_list);
1265 <
1266 <  operprivs = oper_privs_as_string(oconf->port);
1267 <
1268 <  SetOFlag(source_p, oconf->port);
1269 <
1270 <  if (IsOperAdmin(source_p) || IsOperHiddenAdmin(source_p))
1271 <    source_p->umodes |= UMODE_ADMIN;
1272 <  if (!IsOperN(source_p))
1273 <    source_p->umodes &= ~UMODE_NCHANGE;
1274 <
1275 <  sendto_realops_flags(UMODE_ALL, L_ALL, "%s (%s@%s) is now an operator",
1276 <                       source_p->name, source_p->username, source_p->host);
1277 <  send_umode_out(source_p, source_p, old);
1278 <  sendto_one(source_p, form_str(RPL_YOUREOPER), me.name, source_p->name);
1279 <  sendto_one(source_p, ":%s NOTICE %s :*** Oper privs are %s",
1280 <             me.name, source_p->name, operprivs);
1281 <  send_message_file(source_p, &ConfigFileEntry.opermotd);
1282 < }
1283 <
1284 < static char new_uid[TOTALSIDUID + 1];     /* allow for \0 */
1285 <
1286 < int
1287 < valid_sid(const char *sid)
1288 < {
1289 <
1290 <  if (strlen(sid) == IRC_MAXSID)
1291 <    if (IsDigit(*sid))
1292 <      if (IsAlNum(*(sid + 1)) && IsAlNum(*(sid + 2)))
1293 <        return 1;
770 >  if (ConfigGeneral.cycle_on_host_change)
771 >    sendto_common_channels_local(target_p, 0, 0, ":%s!%s@%s QUIT :Changing hostname",
772 >                                 target_p->name, target_p->username, target_p->host);
773  
774 <  return 0;
775 < }
774 >  if (IsUserHostIp(target_p))
775 >    delete_user_host(target_p->username, target_p->host, !MyConnect(target_p));
776  
777 < /*
1299 < * init_uid()
1300 < *
1301 < * inputs       - NONE
1302 < * output       - NONE
1303 < * side effects - new_uid is filled in with server id portion (sid)
1304 < *                (first 3 bytes) or defaulted to 'A'.
1305 < *                Rest is filled in with 'A'
1306 < */
1307 < void
1308 < init_uid(void)
1309 < {
1310 <  int i;
777 >  strlcpy(target_p->host, hostname, sizeof(target_p->host));
778  
779 <  memset(new_uid, 0, sizeof(new_uid));
779 >  add_user_host(target_p->username, target_p->host, !MyConnect(target_p));
780 >  SetUserHost(target_p);
781  
782 <  if (ServerInfo.sid != NULL)
782 >  if (MyClient(target_p))
783    {
784 <    strlcpy(new_uid, ServerInfo.sid, sizeof(new_uid));
785 <    strlcpy(me.id, ServerInfo.sid, sizeof(me.id));
1318 <
1319 <    hash_add_id(&me);
784 >    sendto_one_numeric(target_p, &me, RPL_VISIBLEHOST, target_p->host);
785 >    clear_ban_cache_client(target_p);
786    }
787  
788 <  for (i = 0; i < IRC_MAXSID; i++)
789 <    if (new_uid[i] == '\0')
1324 <      new_uid[i] = 'A';
1325 <
1326 <  /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1327 <  /* Yes nenolod, I have known it was off by one ever since I wrote it
1328 <   * But *JUST* for you, though, it really doesn't look as *pretty*
1329 <   * -Dianora
1330 <   */
1331 <  memcpy(new_uid + IRC_MAXSID, "AAAAA@", IRC_MAXUID);
1332 <
1333 <  entering_umode_cb = register_callback("entering_umode", NULL);
1334 <  umode_cb = register_callback("changing_umode", change_simple_umode);
1335 <  uid_get_cb = register_callback("uid_get", uid_get);
1336 < }
788 >  if (!ConfigGeneral.cycle_on_host_change)
789 >    return;
790  
791 < /*
1339 < * add_one_to_uid
1340 < *
1341 < * inputs       - index number into new_uid
1342 < * output       - NONE
1343 < * side effects - new_uid is incremented by one
1344 < *                note this is a recursive function
1345 < */
1346 < static void
1347 < add_one_to_uid(int i)
1348 < {
1349 <  if (i != IRC_MAXSID)    /* Not reached server SID portion yet? */
791 >  DLINK_FOREACH(node, target_p->channel.head)
792    {
793 <    if (new_uid[i] == 'Z')
794 <      new_uid[i] = '0';
795 <    else if (new_uid[i] == '9')
793 >    char modebuf[4], nickbuf[NICKLEN * 3 + 3] = "";
794 >    char *p = modebuf;
795 >    int len = 0;
796 >    const struct Membership *member = node->data;
797 >
798 >    if (has_member_flags(member, CHFL_CHANOP))
799      {
800 <      new_uid[i] = 'A';
801 <      add_one_to_uid(i-1);
800 >      *p++ = 'o';
801 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
802      }
1358    else
1359      ++new_uid[i];
1360  }
1361  else
1362  {
1363    /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1364    if (new_uid[i] == 'Z')
1365      memcpy(new_uid + IRC_MAXSID, "AAAAAA", IRC_MAXUID);
1366    else
1367      ++new_uid[i];
1368  }
1369 }
1370
1371 /*
1372 * uid_get
1373 *
1374 * inputs       - struct Client *
1375 * output       - new UID is returned to caller
1376 * side effects - new_uid is incremented by one.
1377 */
1378 static void *
1379 uid_get(va_list args)
1380 {
1381  add_one_to_uid(TOTALSIDUID - 1);    /* index from 0 */
1382  return new_uid;
1383 }
1384
1385 /*
1386 * init_isupport()
1387 *
1388 * input        - NONE
1389 * output       - NONE
1390 * side effects - Must be called before isupport is enabled
1391 */
1392 void
1393 init_isupport(void)
1394 {
1395  isupportFile = init_MessageLine();
803  
804 <  add_isupport("CALLERID", NULL, -1);
805 <  add_isupport("CASEMAPPING", CASEMAP, -1);
806 <  add_isupport("DEAF", "D", -1);
807 <  add_isupport("KICKLEN", NULL, KICKLEN);
808 <  add_isupport("MODES", NULL, MAXMODEPARAMS);
1402 <  add_isupport("NICKLEN", NULL, NICKLEN-1);
1403 < #ifdef HALFOPS
1404 <  add_isupport("PREFIX", "(ohv)@%+", -1);
1405 <  add_isupport("STATUSMSG", "@%+", -1);
1406 < #else
1407 <  add_isupport("PREFIX", "(ov)@+", -1);
1408 <  add_isupport("STATUSMSG", "@+", -1);
1409 < #endif
1410 <  add_isupport("TOPICLEN", NULL, TOPICLEN);
1411 < }
1412 <
1413 < /*
1414 < * add_isupport()
1415 < *
1416 < * input        - name of supported function
1417 < *              - options if any
1418 < *              - number if any
1419 < * output       - NONE
1420 < * side effects - Each supported item must call this when activated
1421 < */
1422 < void
1423 < add_isupport(const char *name, const char *options, int n)
1424 < {
1425 <  dlink_node *ptr;
1426 <  struct Isupport *support;
804 >    if (has_member_flags(member, CHFL_HALFOP))
805 >    {
806 >      *p++ = 'h';
807 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
808 >    }
809  
810 <  DLINK_FOREACH(ptr, support_list.head)
1429 <  {
1430 <    support = ptr->data;
1431 <    if (irccmp(support->name, name) == 0)
810 >    if (has_member_flags(member, CHFL_VOICE))
811      {
812 <      MyFree(support->name);
813 <      MyFree(support->options);
1435 <      break;
812 >      *p++ = 'v';
813 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
814      }
1437  }
815  
816 <  if (ptr == NULL)
1440 <  {
1441 <    support = MyMalloc(sizeof(*support));
1442 <    dlinkAddTail(support, &support->node, &support_list);
1443 <  }
816 >    *p = '\0';
817  
1445  DupString(support->name, name);
1446  if (options != NULL)
1447    DupString(support->options, options);
1448  support->number = n;
818  
819 <  rebuild_isupport_message_line();
820 < }
819 >    sendto_channel_local_butone(target_p, CAP_EXTENDED_JOIN, 0, member->chptr, ":%s!%s@%s JOIN %s %s :%s",
820 >                                target_p->name, target_p->username,
821 >                                target_p->host, member->chptr->name,
822 >                                (!IsDigit(target_p->account[0]) && target_p->account[0] != '*') ? target_p->account : "*",
823 >                                target_p->info);
824 >    sendto_channel_local_butone(target_p, 0, CAP_EXTENDED_JOIN, member->chptr, ":%s!%s@%s JOIN :%s",
825 >                                target_p->name, target_p->username,
826 >                                target_p->host, member->chptr->name);
827  
828 < /*
829 < * delete_isupport()
830 < *
831 < * input        - name of supported function
1457 < * output       - NONE
1458 < * side effects - Each supported item must call this when deactivated
1459 < */
1460 < void
1461 < delete_isupport(const char *name)
1462 < {
1463 <  dlink_node *ptr;
1464 <  struct Isupport *support;
828 >    if (nickbuf[0])
829 >      sendto_channel_local_butone(target_p, 0, 0, member->chptr, ":%s MODE %s +%s %s",
830 >                                  target_p->servptr->name, member->chptr->name,
831 >                                  modebuf, nickbuf);
832  
1466  DLINK_FOREACH(ptr, support_list.head)
1467  {
1468    support = ptr->data;
1469    if (irccmp(support->name, name) == 0)
1470    {
1471      dlinkDelete(ptr, &support_list);
1472      MyFree(support->name);
1473      MyFree(support->options);
1474      MyFree(support);
1475      break;
1476    }
833    }
834  
835 <  rebuild_isupport_message_line();
835 >  if (target_p->away[0])
836 >    sendto_common_channels_local(target_p, 0, CAP_AWAY_NOTIFY,
837 >                                 ":%s!%s@%s AWAY :%s",
838 >                                 target_p->name, target_p->username,
839 >                                 target_p->host, target_p->away);
840   }
841  
842 < /*
843 < * rebuild_isupport_message_line
844 < *
1485 < * input        - NONE
1486 < * output       - NONE
1487 < * side effects - Destroy the isupport MessageFile lines, and rebuild.
842 > /*! \brief Blindly opers up given source_p, using conf info.
843 > *         All checks on passwords have already been done.
844 > * \param source_p Pointer to given client to oper
845   */
846   void
847 < rebuild_isupport_message_line(void)
847 > user_oper_up(struct Client *source_p)
848   {
849 <  char isupportbuffer[IRCD_BUFSIZE];
850 <  char *p = isupportbuffer;
1494 <  dlink_node *ptr = NULL;
1495 <  int n = 0;
1496 <  int tokens = 0;
1497 <  size_t len = 0;
1498 <  size_t reserve = strlen(me.name) + HOSTLEN + strlen(form_str(RPL_ISUPPORT));
849 >  const unsigned int old = source_p->umodes;
850 >  const struct MaskItem *const conf = source_p->connection->confs.head->data;
851  
852 <  destroy_MessageLine(isupportFile);
852 >  assert(source_p->connection->confs.head);
853  
854 <  DLINK_FOREACH(ptr, support_list.head)
855 <  {
1504 <    struct Isupport *support = ptr->data;
854 >  ++Count.oper;
855 >  SetOper(source_p);
856  
857 <    p += (n = ircsprintf(p, "%s", support->name));
858 <    len += n;
857 >  if (conf->modes)
858 >    AddUMode(source_p, conf->modes);
859 >  else if (ConfigGeneral.oper_umodes)
860 >    AddUMode(source_p, ConfigGeneral.oper_umodes);
861  
862 <    if (support->options != NULL)
863 <    {
864 <      p += (n = ircsprintf(p, "=%s", support->options));
865 <      len += n;
1513 <    }
862 >  if (!(old & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
863 >    ++Count.invisi;
864 >  if ((old & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
865 >    --Count.invisi;
866  
867 <    if (support->number > 0)
868 <    {
1517 <      p += (n = ircsprintf(p, "=%d", support->number));
1518 <      len += n;
1519 <    }
867 >  assert(dlinkFind(&oper_list, source_p) == NULL);
868 >  dlinkAdd(source_p, make_dlink_node(), &oper_list);
869  
870 <    *p++ = ' ';
1522 <    len++;
1523 <    *p = '\0';
870 >  AddOFlag(source_p, conf->port);
871  
872 <    if (++tokens == (MAXPARA-2) || len >= (sizeof(isupportbuffer)-reserve))
873 <    { /* arbritrary for now */
1527 <      if (*--p == ' ')
1528 <        *p = '\0';
1529 <
1530 <      addto_MessageLine(isupportFile, isupportbuffer);
1531 <      p = isupportbuffer;
1532 <      len = 0;
1533 <      n = tokens = 0;
1534 <    }
1535 <  }
872 >  if (HasOFlag(source_p, OPER_FLAG_ADMIN))
873 >    AddUMode(source_p, UMODE_ADMIN);
874  
875 <  if (len != 0)
875 >  if (!EmptyString(conf->whois))
876    {
877 <    if (*--p == ' ')
878 <      *p = '\0';
879 <    addto_MessageLine(isupportFile, isupportbuffer);
877 >    client_attach_svstag(source_p, RPL_WHOISOPERATOR, "+", conf->whois);
878 >    sendto_server(source_p, 0, 0, ":%s SVSTAG %s %lu %u + :%s",
879 >                  me.id, source_p->id, (unsigned long)source_p->tsinfo,
880 >                  RPL_WHOISOPERATOR, conf->whois);
881    }
882 +
883 +  sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s is now an operator",
884 +                       get_oper_name(source_p));
885 +  sendto_server(NULL, 0, 0, ":%s GLOBOPS :%s is now an operator",
886 +                me.id, get_oper_name(source_p));
887 +  send_umode_out(source_p, old);
888 +  sendto_one_numeric(source_p, &me, RPL_YOUREOPER);
889   }

Diff Legend

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