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 56 by michael, Mon Oct 3 11:33:30 2005 UTC vs.
ircd-hybrid/trunk/src/user.c (file contents), Revision 6357 by michael, Mon Aug 17 16:38:13 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"
50 < #include "msg.h"
51 < #include "pcre.h"
58 <
59 < int MaxClientCount     = 1;
60 < int MaxConnectionCount = 1;
61 < struct Callback *entering_umode_cb = NULL;
62 < struct Callback *umode_cb = NULL;
63 < struct Callback *uid_get_cb = NULL;
48 > #include "misc.h"
49 > #include "parse.h"
50 > #include "watch.h"
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 *);
69 < static int check_xline(struct Client *);
70 < static int check_regexp_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
55 > const struct user_modes *umode_map[256];
56 > const struct user_modes  umode_tab[] =
57   {
58 <  dlink_node node;
59 <  char *name;
60 <  char *options;
61 <  int number;
62 < };
63 <
64 < static dlink_list support_list = { NULL, NULL, 0 };
65 < MessageFile *isupportFile;
66 <
67 < /* memory is cheap. map 0-255 to equivalent mode */
68 < unsigned int user_modes[256] =
69 < {
70 <  /* 0x00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x0F */
71 <  /* 0x10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x1F */
72 <  /* 0x20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x2F */
73 <  /* 0x30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x3F */
74 <  0,                  /* @ */
75 <  0,                  /* A */
76 <  0,                  /* B */
77 <  0,                  /* C */
78 <  UMODE_DEAF,         /* D */
79 <  0,                  /* E */
80 <  0,                  /* F */
81 <  UMODE_SOFTCALLERID, /* G */
82 <  0,                  /* H */
83 <  0,                  /* I */
84 <  0,                  /* J */
85 <  0,                  /* K */
86 <  0,                  /* L */
109 <  0,                  /* M */
110 <  0,                  /* N */
111 <  0,                  /* O */
112 <  0,                  /* P */
113 <  0,                  /* Q */
114 <  0,                  /* R */
115 <  0,                  /* S */
116 <  0,                  /* T */
117 <  0,                  /* U */
118 <  0,                  /* V */
119 <  0,                  /* W */
120 <  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 (Count.oper)
120 >    sendto_one_numeric(source_p, &me, RPL_LUSEROP, Count.oper);
121  
122 <  if (!MyConnect(source_p) && IsCapable(source_p->from, CAP_TS6) && HasID(source_p))
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 >    AddFlag(source_p, FLAGS_EXEMPTKLINE);
171 >    sendto_one_notice(source_p, &me, ":*** You are exempt from K/D lines. Congrats.");
172 >  }
173 >
174 >  if (IsConfExemptXline(conf))
175 >  {
176 >    AddFlag(source_p, FLAGS_EXEMPTXLINE);
177 >    sendto_one_notice(source_p, &me, ":*** You are exempt from X lines. Congrats.");
178 >  }
179  
180 <  if (Count.oper > 0)
181 <    sendto_one(source_p, form_str(RPL_LUSEROP),
182 <               from, to, Count.oper);
183 <
184 <  if (dlink_list_length(&unknown_list) > 0)
185 <    sendto_one(source_p, form_str(RPL_LUSERUNKNOWN),
186 <               from, to, dlink_list_length(&unknown_list));
187 <
188 <  if (dlink_list_length(&global_channel_list) > 0)
189 <    sendto_one(source_p, form_str(RPL_LUSERCHANNELS),
190 <               from, to, dlink_list_length(&global_channel_list));
191 <
192 <  if (!ConfigServerHide.hide_servers || IsOper(source_p))
193 <  {
194 <    sendto_one(source_p, form_str(RPL_LUSERME),
195 <               from, to, Count.local, Count.myserver);
196 <    sendto_one(source_p, form_str(RPL_LOCALUSERS),
197 <               from, to, Count.local, Count.max_loc,
224 <               Count.local, Count.max_loc);
180 >  if (IsConfExemptResv(conf))
181 >  {
182 >    AddFlag(source_p, FLAGS_EXEMPTRESV);
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 >    AddFlag(source_p, FLAGS_NOLIMIT);
190 >    sendto_one_notice(source_p, &me, ":*** You are exempt from user limits. Congrats.");
191 >  }
192 >
193 >  if (IsConfCanFlood(conf))
194 >  {
195 >    AddFlag(source_p, FLAGS_CANFLOOD);
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),
231 <               from, to, Count.total, 0);
232 <    sendto_one(source_p, form_str(RPL_LOCALUSERS),
233 <               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 (server == source_p->from)
233 >      continue;
234  
235 <  if (Count.local > MaxClientCount)
236 <    MaxClientCount = Count.local;
235 >    if (IsCapable(server, CAPAB_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 ((Count.local + Count.myserver) > MaxConnectionCount)
253 <    MaxConnectionCount = Count.local + Count.myserver;
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 > #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 > /* 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 <  send_message_file(source_p, isupportFile);
302 >  struct MaskItem *conf = NULL;
303 >
304 >  if (HasFlag(source_p, FLAGS_EXEMPTXLINE))
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 < /*
325 < ** register_local_user
326 < **      This function is called when both NICK and USER messages
327 < **      have been accepted for the client, in whatever order. Only
328 < **      after this, is the USER message propagated.
267 < **
268 < **      NICK's must be propagated at once when received, although
269 < **      it would be better to delay them too until full info is
270 < **      available. Doing it is not so simple though, would have
271 < **      to implement the following:
272 < **
273 < **      (actually it has been implemented already for a while) -orabidoo
274 < **
275 < **      1) user telnets in and gives only "NICK foobar" and waits
276 < **      2) another user far away logs in normally with the nick
277 < **         "foobar" (quite legal, as this server didn't propagate
278 < **         it).
279 < **      3) now this server gets nick "foobar" from outside, but
280 < **         has alread the same defined locally. Current server
281 < **         would just issue "KILL foobar" to clean out dups. But,
282 < **         this is not fair. It should actually request another
283 < **         nick from local user or kill him/her...
284 < */
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);
337 >  assert(IsUnknown(source_p));
338 >  assert(!source_p->connection->registration);
339  
340 <  if (ConfigFileEntry.ping_cookie)
340 >  if (ConfigGeneral.ping_cookie)
341    {
342 <    if (!IsPingSent(source_p) &&
301 <       source_p->localClient->random_ping == 0)
342 >    if (!HasFlag(source_p, FLAGS_PINGSENT) && !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);
347 <      SetPingSent(source_p);
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 >      AddFlag(source_p, FLAGS_PINGSENT);
350        return;
351      }
352  
353 <    if (!HasPingCookie(source_p))
353 >    if (!HasFlag(source_p, FLAGS_PING_COOKIE))
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,
326 <            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;
330 <  aconf = map_to_conf(ptr->data);
371 >  conf = source_p->connection->confs.head->data;
372  
373 <  if (!IsGotId(source_p))
373 >  if (!HasFlag(source_p, FLAGS_GOTID))
374    {
375 <    const char *p = NULL;
375 >    char username[USERLEN + 1] = "";
376      unsigned int i = 0;
377  
378 <    if (IsNeedIdentd(aconf))
378 >    if (IsNeedIdentd(conf))
379      {
380 <      ServerStats->is_ref++;
381 <      sendto_one(source_p, ":%s NOTICE %s :*** Notice -- You need to install "
382 <                 "identd to use this server", me.name, source_p->name);
383 <      exit_client(source_p, &me, "Install identd");
380 >      ++ServerStats.is_ref;
381 >      sendto_one_notice(source_p, &me, ":*** Notice -- You need to install "
382 >                        "identd to use this server");
383 >      exit_client(source_p, "Install identd");
384        return;
385      }
386  
387 <    p = username;
387 >    strlcpy(username, source_p->username, sizeof(username));
388  
389 <    if (!IsNoTilde(aconf))
389 >    if (!IsNoTilde(conf))
390        source_p->username[i++] = '~';
391  
392 <    while (*p && i < USERLEN)
393 <    {
353 <      if (*p != '[')
354 <        source_p->username[i++] = *p;
355 <      p++;
356 <    }
392 >    for (const char *p = username; *p && i < USERLEN; ++p)
393 >      source_p->username[i++] = *p;
394  
395      source_p->username[i] = '\0';
396    }
397  
398 <  /* password check */
399 <  if (!EmptyString(aconf->passwd))
398 >  /* Password check */
399 >  if (!EmptyString(conf->passwd))
400    {
401 <    const char *pass = source_p->localClient->passwd;
365 <
366 <    if (!match_conf_password(pass, aconf))
401 >    if (!match_conf_password(source_p->connection->password, conf))
402      {
403 <      ServerStats->is_ref++;
404 <      sendto_one(source_p, form_str(ERR_PASSWDMISMATCH),
405 <                 me.name, source_p->name);
406 <      exit_client(source_p, &me, "Bad Password");
403 >      ++ServerStats.is_ref;
404 >
405 >      sendto_one_numeric(source_p, &me, ERR_PASSWDMISMATCH);
406 >      exit_client(source_p, "Bad Password");
407        return;
408      }
409    }
410  
411 <  /* don't free source_p->localClient->passwd here - it can be required
412 <   * by masked /stats I if there are auth{} blocks with need_password = no;
411 >  /*
412 >   * Don't free source_p->connection->password here - it can be required
413 >   * by masked /stats I if there are auth {} blocks with need_password = no;
414     * --adx
415     */
416  
417 <  /* report if user has &^>= etc. and set flags as needed in source_p */
418 <  report_and_set_user_flags(source_p, aconf);
417 >  /*
418 >   * Report if user has &^>= etc. and set flags as needed in source_p
419 >   */
420 >  report_and_set_user_flags(source_p, conf);
421 >
422 >  if (IsDead(source_p))
423 >    return;
424  
425 <  /* Limit clients -
425 >  /*
426 >   * Limit clients -
427     * We want to be able to have servers and F-line clients
428     * connect, so save room for "buffer" connections.
429     * Smaller servers may want to decrease this, and it should
430     * probably be just a percentage of the MAXCLIENTS...
431     *   -Taner
432     */
433 <  /* Except "F:" clients */
434 <  if ((Count.local >= ServerInfo.max_clients + MAX_BUFFER) ||
393 <      (Count.local >= ServerInfo.max_clients && !IsExemptLimits(source_p)))
433 >  if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
434 >      (Count.local >= GlobalSetOptions.maxclients && !HasFlag(source_p, FLAGS_NOLIMIT)))
435    {
436 <    sendto_realops_flags(UMODE_FULL, L_ALL,
436 >    sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
437                           "Too many clients, rejecting %s[%s].",
438 <                         nick, source_p->host);
439 <    ServerStats->is_ref++;
440 <    exit_client(source_p, &me, "Sorry, server is full - try later");
438 >                         source_p->name, source_p->host);
439 >    ++ServerStats.is_ref;
440 >    exit_client(source_p, "Sorry, server is full - try later");
441      return;
442    }
443  
444 <  /* valid user name check */
404 <  if (valid_username(source_p->username) == 0)
444 >  if (!valid_username(source_p->username, 1))
445    {
446 <    char tmpstr2[IRCD_BUFSIZE];
446 >    char buf[IRCD_BUFSIZE] = "";
447  
448 <    sendto_realops_flags(UMODE_REJ, L_ALL, "Invalid username: %s (%s@%s)",
449 <                         nick, source_p->username, source_p->host);
450 <    ServerStats->is_ref++;
451 <    ircsprintf(tmpstr2, "Invalid username [%s]", source_p->username);
452 <    exit_client(source_p, &me, tmpstr2);
448 >    sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
449 >                         "Invalid username: %s (%s@%s)",
450 >                         source_p->name, source_p->username, source_p->host);
451 >    ++ServerStats.is_ref;
452 >    snprintf(buf, sizeof(buf), "Invalid username [%s]", source_p->username);
453 >    exit_client(source_p, buf);
454      return;
455    }
456  
457 <  assert(source_p == client_p);
417 <
418 <  /* end of valid user name check */
419 <  if (check_xline(source_p) || check_regexp_xline(source_p))
420 <    return;
421 <
422 <  if (IsDead(client_p))
457 >  if (check_xline(source_p))
458      return;
459  
460 <  if (source_p->id[0] == '\0' && me.id[0])
461 <  {
427 <    char *id = (char *) execute_callback(uid_get_cb, source_p);
428 <    while (hash_find_id(id) != NULL)
429 <      id = uid_get(NULL);
430 <
431 <    strlcpy(source_p->id, id, sizeof(source_p->id));
432 <    hash_add_id(source_p);
433 <  }
434 <
435 <  irc_getnameinfo((struct sockaddr *)&source_p->localClient->ip,
436 <                  source_p->localClient->ip.ss_len, ipaddr,
437 <                  HOSTIPLEN, NULL, 0, NI_NUMERICHOST);
460 >  while (hash_find_id((id = uid_get())))
461 >    ;
462  
463 <  sendto_realops_flags(UMODE_CCONN, L_ALL,
464 <                       "Client connecting: %s (%s@%s) [%s] {%s} [%s]",
441 <                       nick, source_p->username, source_p->host,
442 <                       ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
443 <                       "255.255.255.255" : ipaddr, get_client_class(source_p),
444 <                       source_p->info);
463 >  strlcpy(source_p->id, id, sizeof(source_p->id));
464 >  hash_add_id(source_p);
465  
466 <  /* If they have died in send_* don't do anything. */
467 <  if (IsDead(source_p))
468 <    return;
466 >  sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
467 >                       "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
468 >                       source_p->name, source_p->username, source_p->host,
469 >                       source_p->sockhost,
470 >                       get_client_class(&source_p->connection->confs),
471 >                       source_p->info, source_p->id);
472  
473 <  if (ConfigFileEntry.invisible_on_connect)
474 <    source_p->umodes |= UMODE_INVISIBLE;
475 <  Count.invisi++;
473 >  if (ConfigGeneral.invisible_on_connect)
474 >  {
475 >    AddUMode(source_p, UMODE_INVISIBLE);
476 >    ++Count.invisi;
477 >  }
478  
479 <  if ((++Count.local) > Count.max_loc)
479 >  if (++Count.local > Count.max_loc)
480    {
481      Count.max_loc = Count.local;
482  
483      if (!(Count.max_loc % 10))
484 <      sendto_realops_flags(UMODE_ALL, L_ALL, "New Max Local Clients: %d",
484 >      sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
485 >                           "New maximum local client connections: %u",
486                             Count.max_loc);
487    }
488  
463  SetClient(source_p);
464
465  source_p->servptr = &me;
466  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->users);
467
468  /* Increment our total user count here */
489    if (++Count.total > Count.max_tot)
490      Count.max_tot = Count.total;
491 <  Count.totalrestartcount++;
491 >  ++Count.totalrestartcount;
492  
493 <  source_p->localClient->allow_read = MAX_FLOOD_BURST;
493 >  assert(source_p->servptr == &me);
494 >  SetClient(source_p);
495 >  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
496 >  dlinkAdd(source_p, &source_p->node, &global_client_list);
497  
498 <  if ((m = dlinkFindDelete(&unknown_list, source_p)) != NULL)
499 <  {
500 <    free_dlink_node(m);
501 <    dlinkAdd(source_p, &source_p->localClient->lclient_node, &local_client_list);
479 <  }
480 <  else assert(0);
498 >  assert(dlinkFind(&unknown_list, source_p));
499 >
500 >  dlink_move_node(&source_p->connection->lclient_node,
501 >                  &unknown_list, &local_client_list);
502  
503    user_welcome(source_p);
504    add_user_host(source_p->username, source_p->host, 0);
505 <  SetUserHost(source_p);
505 >  AddFlag(source_p, FLAGS_USERHOST);
506  
507 <  introduce_client(client_p, source_p);
507 >  introduce_client(source_p);
508   }
509  
510   /* register_remote_user()
511   *
512 < * inputs       - client_p directly connected client
492 < *              - source_p remote or directly connected client
512 > * inputs       - source_p remote or directly connected client
513   *              - username to register as
514   *              - host name to register as
515   *              - server name
496 *              - realname (gecos)
516   * output       - NONE
517   * side effects - This function is called when a remote client
518   *                is introduced by a server.
519   */
520   void
521 < register_remote_user(struct Client *client_p, struct Client *source_p,
503 <                     const char *username, const char *host, const char *server,
504 <                     const char *realname)
521 > register_remote_user(struct Client *source_p)
522   {
523 <  struct Client *target_p = NULL;
507 <
508 <  assert(source_p != NULL);
509 <  assert(source_p->username != username);
510 <
511 <  strlcpy(source_p->host, host, sizeof(source_p->host));
512 <  strlcpy(source_p->info, realname, sizeof(source_p->info));
513 <  strlcpy(source_p->username, username, sizeof(source_p->username));
514 <
515 <  /* Increment our total user count here */
516 <  if (++Count.total > Count.max_tot)
517 <    Count.max_tot = Count.total;
518 <
519 <  source_p->from->serv->dep_users++;
520 <
521 <  /*
522 <   * coming from another server, take the servers word for it
523 <   */
524 <  source_p->servptr = find_server(server);
525 <
526 <  /* Super GhostDetect:
527 <   * If we can't find the server the user is supposed to be on,
528 <   * then simply blow the user away.        -Taner
529 <   */
530 <  if (source_p->servptr == NULL)
531 <  {
532 <    sendto_realops_flags(UMODE_ALL, L_ALL,
533 <                         "No server %s for user %s[%s@%s] from %s",
534 <                         server, source_p->name, source_p->username,
535 <                         source_p->host, source_p->from->name);
536 <    kill_client(client_p, source_p, "%s (Server doesn't exist)", me.name);
537 <
538 <    /* XXX */
539 <    SetKilled(source_p);
540 <    exit_client(source_p, &me, "Ghosted Client");
541 <    return;
542 <  }
523 >  const struct Client *target_p = NULL;
524  
525    if ((target_p = source_p->servptr) && target_p->from != source_p->from)
526    {
527 <    sendto_realops_flags(UMODE_DEBUG, L_ALL,
527 >    sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
528                           "Bad User [%s] :%s USER %s@%s %s, != %s[%s]",
529 <                         client_p->name, source_p->name, source_p->username,
529 >                         source_p->from->name, source_p->name, source_p->username,
530                           source_p->host, source_p->servptr->name,
531                           target_p->name, target_p->from->name);
532 <    kill_client(client_p, source_p,
533 <                "%s (NICK from wrong direction (%s != %s))",
534 <                me.name, source_p->servptr->name, target_p->from->name);
535 <    SetKilled(source_p);
555 <    exit_client(source_p, &me, "USER server wrong direction");
556 <    return;
557 <  }
558 <
559 <  SetClient(source_p);
560 <  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->users);
561 <  add_user_host(source_p->username, source_p->host, 1);
562 <  SetUserHost(source_p);
563 <
564 <  introduce_client(client_p, source_p);
565 < }
566 <
567 < /* introduce_client()
568 < *
569 < * inputs       - client_p
570 < *              - source_p
571 < * output       - NONE
572 < * side effects - This common function introduces a client to the rest
573 < *                of the net, either from a local client connect or
574 < *                from a remote connect.
575 < */
576 < static void
577 < introduce_client(struct Client *client_p, struct Client *source_p)
578 < {
579 <  dlink_node *server_node = NULL;
580 <  static char ubuf[12];
581 <
582 <  if (MyClient(source_p))
583 <    send_umode(source_p, source_p, 0, SEND_UMODES, ubuf);
584 <  else
585 <    send_umode(NULL, source_p, 0, SEND_UMODES, ubuf);
532 >    sendto_one(source_p->from,
533 >               ":%s KILL %s :%s (UID from wrong direction (%s != %s))",
534 >               me.id, source_p->id, me.name, source_p->servptr->name,
535 >               target_p->from->name);
536  
537 <  if (*ubuf == '\0')
538 <  {
539 <    ubuf[0] = '+';
590 <    ubuf[1] = '\0';
537 >    AddFlag(source_p, FLAGS_KILLED);
538 >    exit_client(source_p, "UID server wrong direction");
539 >    return;
540    }
541  
542 <  /* arghhh one could try not introducing new nicks to ll leafs
543 <   * but then you have to introduce them "on the fly" in SJOIN
544 <   * not fun.
596 <   * Its not going to cost much more bandwidth to simply let new
597 <   * nicks just ride on through.
542 >  /*
543 >   * If the nick has been introduced by a services server,
544 >   * make it a service as well.
545     */
546 +  if (HasFlag(source_p->servptr, FLAGS_SERVICE))
547 +    AddFlag(source_p, FLAGS_SERVICE);
548  
549 <  /* We now introduce nicks "on the fly" in SJOIN anyway --
550 <   * you _need_ to if you aren't going to burst everyone initially.
602 <   *
603 <   * Only send to non CAP_LL servers, unless we're a lazylink leaf,
604 <   * in that case just send it to the uplink.
605 <   * -davidt
606 <   * rewritten to cope with SIDs .. eww eww eww --is
607 <   */
549 >  if (++Count.total > Count.max_tot)
550 >    Count.max_tot = Count.total;
551  
552 <  /* XXX THESE NEED A PREFIX!?!?!? */
553 <  if (!ServerInfo.hub && uplink && IsCapable(uplink, CAP_LL) &&
554 <      client_p != uplink)
555 <  {
556 <    if (IsCapable(uplink, CAP_TS6) && HasID(source_p))
614 <    {
615 <      sendto_one(uplink, ":%s UID %s %d %lu %s %s %s %s %s :%s",
616 <                 source_p->servptr->id,
617 <                 source_p->name, source_p->hopcount+1,
618 <                 (unsigned long)source_p->tsinfo,
619 <                 ubuf, source_p->username, source_p->host,
620 <                 ((MyClient(source_p) && !IsIPSpoof(source_p)) ?
621 <                 source_p->sockhost : "0"),
622 <                 source_p->id, source_p->info);
623 <    }
624 <    else
625 <    {
626 <      sendto_one(uplink, "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,
631 <                 source_p->info);
632 <    }
633 <  }
634 <  else
635 <  {
636 <    DLINK_FOREACH(server_node, serv_list.head)
637 <    {
638 <      struct Client *server = server_node->data;
552 >  SetClient(source_p);
553 >  dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
554 >  dlinkAdd(source_p, &source_p->node, &global_client_list);
555 >  add_user_host(source_p->username, source_p->host, 1);
556 >  AddFlag(source_p, FLAGS_USERHOST);
557  
558 <      if (IsCapable(server, CAP_LL) || server == client_p)
559 <        continue;
558 >  if (HasFlag(source_p->servptr, FLAGS_EOB))
559 >    sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
560 >                         "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
561 >                         source_p->servptr->name,
562 >                         source_p->name, source_p->username, source_p->host,
563 >                         source_p->sockhost, source_p->info, source_p->id);
564  
565 <      if (IsCapable(server, CAP_TS6) && HasID(source_p))
644 <        sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s :%s",
645 <                   source_p->servptr->id,
646 <                   source_p->name, source_p->hopcount+1,
647 <                   (unsigned long)source_p->tsinfo,
648 <                   ubuf, source_p->username, source_p->host,
649 <                   ((MyClient(source_p)&&!IsIPSpoof(source_p))?source_p->sockhost:"0"),
650 <                   source_p->id, source_p->info);
651 <      else
652 <        sendto_one(server, "NICK %s %d %lu %s %s %s %s :%s",
653 <                   source_p->name, source_p->hopcount+1,
654 <                   (unsigned long)source_p->tsinfo,
655 <                   ubuf, source_p->username, source_p->host,
656 <                   source_p->servptr->name,
657 <                   source_p->info);
658 <    }
659 <  }
565 >  introduce_client(source_p);
566   }
567  
568   /* valid_hostname()
# Line 673 | Line 579 | valid_hostname(const char *hostname)
579   {
580    const char *p = hostname;
581  
582 <  assert(p != NULL);
582 >  assert(p);
583  
584 <  if ('.' == *p || ':' == *p)
584 >  if (EmptyString(p) || *p == '.' || *p == ':')
585      return 0;
586  
587 <  while (*p)
682 <  {
587 >  for (; *p; ++p)
588      if (!IsHostChar(*p))
589        return 0;
685    p++;
686  }
590  
591 <  return 1;
591 >  return p - hostname <= HOSTLEN;
592   }
593  
594   /* valid_username()
# Line 700 | Line 603 | valid_hostname(const char *hostname)
603   * style of username
604   */
605   int
606 < valid_username(const char *username)
606 > valid_username(const char *username, const int local)
607   {
608 <  int dots      = 0;
608 >  unsigned int dots = 0;
609    const char *p = username;
610  
611 <  assert(p != NULL);
611 >  assert(p);
612  
613 <  if ('~' == *p)
613 >  if (*p == '~')
614      ++p;
615  
616 <  /* reject usernames that don't start with an alphanum
616 >  /*
617 >   * Reject usernames that don't start with an alphanum
618     * i.e. reject jokers who have '-@somehost' or '.@somehost'
619     * or "-hi-@somehost", "h-----@somehost" would still be accepted.
620     */
621    if (!IsAlNum(*p))
622      return 0;
623  
624 <  while (*++p)
624 >  if (local)
625    {
626 <    if ((*p == '.') && ConfigFileEntry.dots_in_ident)
626 >    while (*++p)
627      {
628 <      dots++;
629 <
630 <      if (dots > ConfigFileEntry.dots_in_ident)
631 <        return 0;
632 <      if (!IsUserChar(p[1]))
628 >      if (*p == '.' && ConfigGeneral.dots_in_ident)
629 >      {
630 >        if (++dots > ConfigGeneral.dots_in_ident)
631 >          return 0;
632 >        if (!IsUserChar(*(p + 1)))
633 >          return 0;
634 >      }
635 >      else if (!IsUserChar(*p))
636          return 0;
637      }
731    else if (!IsUserChar(*p))
732      return 0;
733  }
734
735  return 1;
736 }
737
738 /* report_and_set_user_flags()
739 *
740 * inputs       - pointer to source_p
741 *              - pointer to aconf for this user
742 * output       - NONE
743 * side effects - Report to user any special flags
744 *                they are getting, and set them.
745 */
746 static void
747 report_and_set_user_flags(struct Client *source_p, const struct AccessItem *aconf)
748 {
749  /* If this user is being spoofed, tell them so */
750  if (IsConfDoSpoofIp(aconf))
751  {
752    sendto_one(source_p,
753               ":%s NOTICE %s :*** Spoofing your IP. congrats.",
754               me.name, source_p->name);
755  }
756
757  /* If this user is in the exception class, Set it "E lined" */
758  if (IsConfExemptKline(aconf))
759  {
760    SetExemptKline(source_p);
761    sendto_one(source_p,
762               ":%s NOTICE %s :*** You are exempt from K/D/G lines. congrats.",
763               me.name, source_p->name);
638    }
639 <
766 <  /* The else here is to make sure that G line exempt users
767 <   * do not get noticed twice.
768 <   */
769 <  else if (IsConfExemptGline(aconf))
770 <  {
771 <    SetExemptGline(source_p);
772 <    sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from G lines.",
773 <               me.name, source_p->name);
774 <  }
775 <
776 <  if (IsConfExemptResv(aconf))
777 <  {
778 <    SetExemptResv(source_p);
779 <    sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from resvs.",
780 <               me.name, source_p->name);
781 <  }
782 <
783 <  /* If this user is exempt from user limits set it "F lined" */
784 <  if (IsConfExemptLimits(aconf))
785 <  {
786 <    SetExemptLimits(source_p);
787 <    sendto_one(source_p,
788 <               ":%s NOTICE %s :*** You are exempt from user limits. congrats.",
789 <               me.name,source_p->name);
790 <  }
791 <
792 <  /* If this user is exempt from idle time outs */
793 <  if (IsConfIdlelined(aconf))
639 >  else
640    {
641 <    SetIdlelined(source_p);
642 <    sendto_one(source_p,
643 <               ":%s NOTICE %s :*** You are exempt from idle limits. congrats.",
798 <               me.name, source_p->name);
641 >    while (*++p)
642 >      if (!IsUserChar(*p))
643 >        return 0;
644    }
645  
646 <  if (IsConfCanFlood(aconf))
802 <  {
803 <    SetCanFlood(source_p);
804 <    sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from flood "
805 <               "protection, aren't you fearsome.",
806 <               me.name, source_p->name);
807 <  }
646 >  return p - username <= USERLEN;
647   }
648  
649 < /* do_local_user()
649 > /* clean_nick_name()
650   *
651 < * inputs       -
652 < * output       - NONE
653 < * side effects -
651 > * input        - nickname
652 > *              - whether it's a local nick (1) or remote (0)
653 > * output       - none
654 > * side effects - walks through the nickname, returning 0 if erroneous
655   */
656 < void
657 < do_local_user(const char *nick, struct Client *client_p, struct Client *source_p,
818 <              const char *username, const char *host, const char *server,
819 <              const char *realname)
656 > int
657 > valid_nickname(const char *nickname, const int local)
658   {
659 <  assert(source_p != NULL);
822 <  assert(source_p->username != username);
823 <
824 <  if (source_p == NULL)
825 <    return;
826 <
827 <  if (!IsUnknown(source_p))
828 <  {
829 <    sendto_one(source_p, form_str(ERR_ALREADYREGISTRED),
830 <               me.name, nick);
831 <    return;
832 <  }
659 >  const char *p = nickname;
660  
661 <  source_p->flags |= FLAGS_GOTUSER;
661 >  assert(p);
662  
663    /*
664 <   * don't take the clients word for it, ever
664 >   * Nicks can't start with a digit or - or be 0 length.
665     */
666 <  source_p->servptr = &me;
667 <
841 <  strlcpy(source_p->info, realname, sizeof(source_p->info));
842 <
843 <  if (!IsGotId(source_p))
844 <  {
845 <    /* save the username in the client
846 <     * If you move this you'll break ping cookies..you've been warned
847 <     */
848 <    strlcpy(source_p->username, username, sizeof(source_p->username));
849 <  }
850 <
851 <  if (source_p->name[0])
852 <  {
853 <    /* NICK already received, now I have USER... */
854 <    register_local_user(client_p, source_p, source_p->name, username);
855 <  }
856 < }
857 <
858 < /* change_simple_umode()
859 < *
860 < * this callback can be hooked to allow special handling of
861 < * certain usermodes
862 < */
863 < static void *
864 < change_simple_umode(va_list args)
865 < {
866 <  struct Client *source_p;
867 <  int what;
868 <  unsigned int flag;
869 <
870 <  va_arg(args, struct Client *);
871 <  source_p = va_arg(args, struct Client *);
872 <  what = va_arg(args, int);
873 <  flag = va_arg(args, unsigned int);
874 <
875 <  if (what == MODE_ADD)
876 <    source_p->umodes |= flag;
877 <  else
878 <    source_p->umodes &= ~flag;
879 <
880 <  return NULL;
881 < }
882 <
883 < /* set_user_mode()
884 < *
885 < * added 15/10/91 By Darren Reed.
886 < * parv[0] - sender
887 < * parv[1] - username to change mode for
888 < * parv[2] - modes to change
889 < */
890 < void
891 < set_user_mode(struct Client *client_p, struct Client *source_p,
892 <              int parc, char *parv[])
893 < {
894 <  unsigned int flag, setflags;
895 <  char **p, *m, buf[IRCD_BUFSIZE];
896 <  struct Client *target_p;
897 <  int what = MODE_ADD, badflag = 0, i;
898 <
899 <  assert(!(parc < 2));
900 <
901 <  if ((target_p = find_person(client_p, parv[1])) == NULL)
902 <  {
903 <    if (MyConnect(source_p))
904 <      sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
905 <                 me.name, source_p->name, parv[1]);
906 <    return;
907 <  }
908 <
909 <  if (IsServer(source_p))
910 <  {
911 <     sendto_realops_flags(UMODE_ALL, L_ADMIN, "*** Mode for User %s from %s",
912 <                          parv[1], source_p->name);
913 <     return;
914 <  }
915 <
916 <  if (source_p != target_p || target_p->from != source_p->from)
917 <  {
918 <     sendto_one(source_p, form_str(ERR_USERSDONTMATCH),
919 <                me.name, source_p->name);
920 <     return;
921 <  }
922 <
923 <  if (parc < 3)
924 <  {
925 <    m = buf;
926 <    *m++ = '+';
927 <
928 <    for (i = 0; i < 128; i++)
929 <      if (source_p->umodes & user_modes[i])
930 <        *m++ = (char)i;
931 <    *m = '\0';
932 <
933 <    sendto_one(source_p, form_str(RPL_UMODEIS),
934 <               me.name, source_p->name, buf);
935 <    return;
936 <  }
937 <
938 <  execute_callback(entering_umode_cb, client_p, source_p);
939 <
940 <  /* find flags already set for user */
941 <  setflags = source_p->umodes;
942 <
943 <  /* parse mode change string(s) */
944 <  for (p = &parv[2]; p && *p; p++)
945 <  {
946 <    for (m = *p; *m; m++)
947 <    {
948 <      switch (*m)
949 <      {
950 <        case '+':
951 <          what = MODE_ADD;
952 <          break;
953 <        case '-':
954 <          what = MODE_DEL;
955 <          break;
956 <        case 'o':
957 <          if (what == MODE_ADD)
958 <          {
959 <            if (IsServer(client_p) && !IsOper(source_p))
960 <            {
961 <              ++Count.oper;
962 <              SetOper(source_p);
963 <            }
964 <          }
965 <          else
966 <          {
967 <            /* Only decrement the oper counts if an oper to begin with
968 <             * found by Pat Szuta, Perly , perly@xnet.com
969 <             */
970 <            if (!IsOper(source_p))
971 <              break;
972 <
973 <            ClearOper(source_p);
974 <            source_p->umodes &= ~ConfigFileEntry.oper_only_umodes;
975 <            Count.oper--;
976 <
977 <            if (MyConnect(source_p))
978 <            {
979 <              dlink_node *dm;
980 <
981 <              detach_conf(source_p, OPER_TYPE);
982 <              ClearOperFlags(source_p);
983 <
984 <              if ((dm = dlinkFindDelete(&oper_list, source_p)) != NULL)
985 <                free_dlink_node(dm);
986 <            }
987 <          }
988 <
989 <          break;
990 <
991 <        /* we may not get these,
992 <         * but they shouldnt be in default
993 <         */
994 <        case ' ' :
995 <        case '\n':
996 <        case '\r':
997 <        case '\t':
998 <          break;
999 <
1000 <        default:
1001 <          if ((flag = user_modes[(unsigned char)*m]))
1002 <          {
1003 <            if (MyConnect(source_p) && !IsOper(source_p) &&
1004 <                (ConfigFileEntry.oper_only_umodes & flag))
1005 <            {
1006 <              badflag = 1;
1007 <            }
1008 <            else
1009 <              execute_callback(umode_cb, client_p, source_p, what, flag);
1010 <          }
1011 <          else
1012 <          {
1013 <            if (MyConnect(source_p))
1014 <              badflag = 1;
1015 <          }
1016 <
1017 <          break;
1018 <      }
1019 <    }
1020 <  }
1021 <
1022 <  if (badflag)
1023 <    sendto_one(source_p, form_str(ERR_UMODEUNKNOWNFLAG),
1024 <               me.name, source_p->name);
1025 <
1026 <  if ((source_p->umodes & UMODE_NCHANGE) && !IsOperN(source_p))
1027 <  {
1028 <    sendto_one(source_p, ":%s NOTICE %s :*** You have no admin flag;",
1029 <               me.name, source_p->name);
1030 <    source_p->umodes &= ~UMODE_NCHANGE; /* only tcm's really need this */
1031 <  }
1032 <
1033 <  if (MyConnect(source_p) && (source_p->umodes & UMODE_ADMIN) &&
1034 <      !IsOperAdmin(source_p) && !IsOperHiddenAdmin(source_p))
1035 <  {
1036 <    sendto_one(source_p, ":%s NOTICE %s :*** You have no admin flag;",
1037 <               me.name, source_p->name);
1038 <    source_p->umodes &= ~UMODE_ADMIN;
1039 <  }
666 >  if (EmptyString(p) || *p == '-' || (IsDigit(*p) && local))
667 >    return 0;
668  
669 <  if (!(setflags & UMODE_INVISIBLE) && IsInvisible(source_p))
670 <    ++Count.invisi;
671 <  if ((setflags & UMODE_INVISIBLE) && !IsInvisible(source_p))
1044 <    --Count.invisi;
669 >  for (; *p; ++p)
670 >    if (!IsNickChar(*p))
671 >      return 0;
672  
673 <  /*
1047 <   * compare new flags with old flags and send string which
1048 <   * will cause servers to update correctly.
1049 <   */
1050 <  send_umode_out(client_p, source_p, setflags);
673 >  return p - nickname <= NICKLEN;
674   }
675  
676   /* send_umode()
677   * send the MODE string for user (user) to connection client_p
678   * -avalon
679 + *
680 + * inputs       - client_p
681 + *              - source_p
682 + *              - int old
683 + *              - suplied umode_buf
684 + * output       - NONE
685   */
686   void
687   send_umode(struct Client *client_p, struct Client *source_p,
688 <           unsigned int old, unsigned int sendmask, char *umode_buf)
688 >           unsigned int old, char *umode_buf)
689   {
1061  int what = 0;
1062  unsigned int i;
1063  unsigned int flag;
690    char *m = umode_buf;
691 +  int what = 0;
692  
693    /*
694 <   * build a string in umode_buf to represent the change in the user's
694 >   * Build a string in umode_buf to represent the change in the user's
695     * mode between the new (source_p->umodes) and 'old'.
696     */
697 <  for (i = 0; i < 128; i++)
697 >  for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
698    {
699 <    flag = user_modes[i];
1073 <    if (!flag)
1074 <      continue;
1075 <
1076 <    if (MyClient(source_p) && !(flag & sendmask))
1077 <      continue;
1078 <
1079 <    if ((flag & old) && !(source_p->umodes & flag))
699 >    if ((tab->flag & old) && !HasUMode(source_p, tab->flag))
700      {
701        if (what == MODE_DEL)
702 <        *m++ = (char)i;
702 >        *m++ = tab->c;
703        else
704        {
705          what = MODE_DEL;
706          *m++ = '-';
707 <        *m++ = (char)i;
707 >        *m++ = tab->c;
708        }
709      }
710 <    else if (!(flag & old) && (source_p->umodes & flag))
710 >    else if (!(tab->flag & old) && HasUMode(source_p, tab->flag))
711      {
712        if (what == MODE_ADD)
713 <        *m++ = (char)i;
713 >        *m++ = tab->c;
714        else
715        {
716          what = MODE_ADD;
717          *m++ = '+';
718 <        *m++ = (char)i;
718 >        *m++ = tab->c;
719        }
720      }
721    }
# Line 1103 | Line 723 | send_umode(struct Client *client_p, stru
723    *m = '\0';
724  
725    if (*umode_buf && client_p)
726 <    sendto_one(client_p, ":%s MODE %s :%s",
727 <               source_p->name, source_p->name, umode_buf);
726 >    sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
727 >               client_p->name, client_p->username,
728 >               client_p->host, client_p->name, umode_buf);
729   }
730  
731   /* send_umode_out()
# Line 1114 | Line 735 | send_umode(struct Client *client_p, stru
735   * side effects - Only send ubuf out to servers that know about this client
736   */
737   void
738 < send_umode_out(struct Client *client_p, struct Client *source_p,
1118 <               unsigned int old)
738 > send_umode_out(struct Client *source_p, unsigned int old)
739   {
740 <  char buf[IRCD_BUFSIZE];
1121 <  dlink_node *ptr = NULL;
1122 <
1123 <  send_umode(NULL, source_p, old, IsOperHiddenAdmin(source_p) ?
1124 <             SEND_UMODES & ~UMODE_ADMIN : SEND_UMODES, buf);
1125 <
1126 <  if (*buf)
1127 <  {
1128 <    DLINK_FOREACH(ptr, serv_list.head)
1129 <    {
1130 <      struct Client *target_p = ptr->data;
740 >  char buf[IRCD_BUFSIZE] = "";
741  
742 <      if ((target_p != client_p) && (target_p != source_p))
1133 <      {
1134 <        if ((!(ServerInfo.hub && IsCapable(target_p, CAP_LL))) ||
1135 <            (target_p->localClient->serverMask &
1136 <             source_p->lazyLinkClientExists))
1137 <          sendto_one(target_p, ":%s MODE %s :%s",
1138 <                     ID_or_name(source_p, target_p),
1139 <                     ID_or_name(source_p, target_p), buf);
1140 <      }
1141 <    }
1142 <  }
742 >  send_umode(MyClient(source_p) ? source_p : NULL, source_p, old, buf);
743  
744 <  if (client_p && MyClient(client_p))
745 <    send_umode(client_p, source_p, old, 0xffffffff, buf);
744 >  if (buf[0])
745 >    sendto_server(source_p, 0, 0, ":%s MODE %s :%s",
746 >                  source_p->id, source_p->id, buf);
747   }
748  
749 < /* user_welcome()
750 < *
1150 < * inputs       - client pointer to client to welcome
1151 < * output       - NONE
1152 < * side effects -
1153 < */
1154 < static void
1155 < user_welcome(struct Client *source_p)
749 > void
750 > user_set_hostmask(struct Client *target_p, const char *hostname, const int what)
751   {
752 < #if defined(__TIME__) && defined(__DATE__)
1158 <  static const char built_date[] = __DATE__ " at " __TIME__;
1159 < #else
1160 <  static const char built_date[] = "unknown";
1161 < #endif
1162 <
1163 < #ifdef HAVE_LIBCRYPTO
1164 <  if (source_p->localClient->fd.ssl != NULL)
1165 <    sendto_one(source_p, ":%s NOTICE %s :*** Connected securely via %s",
1166 <               me.name, source_p->name,
1167 <               ssl_get_cipher(source_p->localClient->fd.ssl));
1168 < #endif
1169 <
1170 <  sendto_one(source_p, form_str(RPL_WELCOME), me.name, source_p->name,
1171 <             ServerInfo.network_name, source_p->name);
1172 <  sendto_one(source_p, form_str(RPL_YOURHOST), me.name, source_p->name,
1173 <             get_listener_name(source_p->localClient->listener), ircd_version);
1174 <  sendto_one(source_p, form_str(RPL_CREATED),
1175 <             me.name, source_p->name, built_date);
1176 <  sendto_one(source_p, form_str(RPL_MYINFO),
1177 <             me.name, source_p->name, me.name, ircd_version, umode_buffer);
1178 <  show_isupport(source_p);
1179 <
1180 <  if (source_p->id[0] != '\0')
1181 <    sendto_one(source_p, form_str(RPL_YOURID), me.name,
1182 <               source_p->name, source_p->id);
752 >  dlink_node *node = NULL;
753  
754 <  show_lusers(source_p);
754 >  if (!strcmp(target_p->host, hostname))
755 >    return;
756  
757 <  if (ConfigFileEntry.short_motd)
757 >  switch (what)
758    {
759 <    sendto_one(source_p, "NOTICE %s :*** Notice -- motd was last changed at %s",
760 <               source_p->name, ConfigFileEntry.motd.lastChangedDate);
761 <    sendto_one(source_p,
762 <               "NOTICE %s :*** Notice -- Please read the motd if you haven't "
763 <               "read it", source_p->name);
764 <    sendto_one(source_p, form_str(RPL_MOTDSTART),
765 <               me.name, source_p->name, me.name);
1195 <    sendto_one(source_p, form_str(RPL_MOTD),
1196 <               me.name, source_p->name,
1197 <               "*** This is the short motd ***");
1198 <    sendto_one(source_p, form_str(RPL_ENDOFMOTD),
1199 <               me.name, source_p->name);
759 >    case MODE_ADD:
760 >      AddUMode(target_p, UMODE_HIDDENHOST);
761 >      break;
762 >    case MODE_DEL:
763 >      DelUMode(target_p, UMODE_HIDDENHOST);
764 >      break;
765 >    default: return;
766    }
1201  else  
1202    send_message_file(source_p, &ConfigFileEntry.motd);
1203 }
1204
1205 /* check_xline()
1206 *
1207 * inputs       - pointer to client to test
1208 * outupt       - 1 if exiting 0 if ok
1209 * side effects -
1210 */
1211 static int
1212 check_xline(struct Client *source_p)
1213 {
1214  struct ConfItem *conf;
1215  struct MatchItem *xconf;
1216  const char *reason;
767  
768 <  if ((conf = find_matching_name_conf(XLINE_TYPE, source_p->info,
769 <                                      NULL, NULL, 0)) != NULL)
770 <  {
1221 <    xconf = map_to_conf(conf);
1222 <    xconf->count++;
768 >  if (ConfigGeneral.cycle_on_host_change)
769 >    sendto_common_channels_local(target_p, 0, 0, ":%s!%s@%s QUIT :Changing hostname",
770 >                                 target_p->name, target_p->username, target_p->host);
771  
772 <    if (xconf->reason != NULL)
773 <      reason = xconf->reason;
1226 <    else
1227 <      reason = "No Reason";
772 >  if (HasFlag(target_p, FLAGS_USERHOST))
773 >    delete_user_host(target_p->username, target_p->host, !MyConnect(target_p));
774  
775 <    sendto_realops_flags(UMODE_REJ, L_ALL,
1230 <                         "X-line Rejecting [%s] [%s], user %s [%s]",
1231 <                         source_p->info, reason,
1232 <                         get_client_name(source_p, HIDE_IP),
1233 <                         source_p->sockhost);
775 >  strlcpy(target_p->host, hostname, sizeof(target_p->host));
776  
777 <    ServerStats->is_ref++;      
778 <    if (REJECT_HOLD_TIME > 0)
1237 <    {
1238 <      sendto_one(source_p, ":%s NOTICE %s :Bad user info",
1239 <                 me.name, source_p->name);
1240 <      source_p->localClient->reject_delay = CurrentTime + REJECT_HOLD_TIME;
1241 <      SetCaptured(source_p);
1242 <    }
1243 <    else
1244 <      exit_client(source_p, &me, "Bad user info");
1245 <    return 1;
1246 <  }
777 >  add_user_host(target_p->username, target_p->host, !MyConnect(target_p));
778 >  AddFlag(target_p, FLAGS_USERHOST);
779  
780 <  return 0;
1249 < }
1250 <
1251 < static int
1252 < check_regexp_xline(struct Client *source_p)
1253 < {
1254 <  struct ConfItem *conf = NULL;
1255 <  const char *reason = NULL;
1256 <
1257 <  if ((conf = find_matching_name_conf(RXLINE_TYPE, source_p->info, NULL, NULL, 0)))
780 >  if (MyClient(target_p))
781    {
782 <    struct MatchItem *reg = map_to_conf(conf);
783 <
1261 <    ++reg->count;
1262 <
1263 <    if (reg->reason != NULL)
1264 <      reason = reg->reason;
1265 <    else
1266 <      reason = "No Reason";
1267 <
1268 <    sendto_realops_flags(UMODE_REJ, L_ALL,
1269 <                         "X-line (REGEX) Rejecting [%s] [%s], user %s [%s]",
1270 <                         source_p->info, reason,
1271 <                         get_client_name(source_p, HIDE_IP),
1272 <                         source_p->sockhost);
1273 <
1274 <    ServerStats->is_ref++;
1275 <    exit_client(source_p, &me, "Bad user info");
1276 <    return 1;
782 >    sendto_one_numeric(target_p, &me, RPL_VISIBLEHOST, target_p->host);
783 >    clear_ban_cache_client(target_p);
784    }
785  
786 <  return 0;
787 < }
1281 <
1282 < /* oper_up()
1283 < *
1284 < * inputs       - pointer to given client to oper
1285 < * output       - NONE
1286 < * side effects - Blindly opers up given source_p, using aconf info
1287 < *                all checks on passwords have already been done.
1288 < *                This could also be used by rsa oper routines.
1289 < */
1290 < void
1291 < oper_up(struct Client *source_p)
1292 < {
1293 <  unsigned int old = source_p->umodes;
1294 <  const char *operprivs = "";
1295 <  const struct AccessItem *oconf = NULL;
1296 <
1297 <  assert(source_p->localClient->confs.head);
1298 <  oconf = map_to_conf((source_p->localClient->confs.head)->data);
1299 <
1300 <  ++Count.oper;
1301 <  SetOper(source_p);
1302 <
1303 <  if (oconf->modes)
1304 <    source_p->umodes |= oconf->modes;
1305 <  else if (ConfigFileEntry.oper_umodes)
1306 <    source_p->umodes |= ConfigFileEntry.oper_umodes;
1307 <  else
1308 <    source_p->umodes |= (UMODE_SERVNOTICE|UMODE_OPERWALL|
1309 <                         UMODE_WALLOP|UMODE_LOCOPS);
1310 <
1311 <  assert(dlinkFind(&oper_list, source_p) == NULL);
1312 <  dlinkAdd(source_p, make_dlink_node(), &oper_list);
1313 <
1314 <  operprivs = oper_privs_as_string(oconf->port);
1315 <
1316 <  SetOFlag(source_p, oconf->port);
1317 <
1318 <  if (IsOperAdmin(source_p) || IsOperHiddenAdmin(source_p))
1319 <    source_p->umodes |= UMODE_ADMIN;
1320 <  if (!IsOperN(source_p))
1321 <    source_p->umodes &= ~UMODE_NCHANGE;
1322 <
1323 <  sendto_realops_flags(UMODE_ALL, L_ALL, "%s (%s@%s) is now an operator",
1324 <                       source_p->name, source_p->username, source_p->host);
1325 <  send_umode_out(source_p, source_p, old);
1326 <  sendto_one(source_p, form_str(RPL_YOUREOPER), me.name, source_p->name);
1327 <  sendto_one(source_p, ":%s NOTICE %s :*** Oper privs are %s",
1328 <             me.name, source_p->name, operprivs);
1329 <  send_message_file(source_p, &ConfigFileEntry.opermotd);
1330 < }
1331 <
1332 < /*
1333 < * Quick and dirty UID code for new proposed SID on EFnet
1334 < *
1335 < */
1336 <
1337 < static char new_uid[TOTALSIDUID+1];     /* allow for \0 */
1338 < static void add_one_to_uid(int i);
1339 <
1340 < /*
1341 < * init_uid()
1342 < *
1343 < * inputs       - NONE
1344 < * output       - NONE
1345 < * side effects - new_uid is filled in with server id portion (sid)
1346 < *                (first 3 bytes) or defaulted to 'A'.
1347 < *                Rest is filled in with 'A'
1348 < */
1349 < void
1350 < init_uid(void)
1351 < {
1352 <  int i;
1353 <
1354 <  memset(new_uid, 0, sizeof(new_uid));
786 >  if (!ConfigGeneral.cycle_on_host_change)
787 >    return;
788  
789 <  if (ServerInfo.sid != NULL)
789 >  DLINK_FOREACH(node, target_p->channel.head)
790    {
791 <    memcpy(new_uid, ServerInfo.sid, IRCD_MIN(strlen(ServerInfo.sid),
792 <                                             IRC_MAXSID));
793 <    memcpy(&me.id, ServerInfo.sid, IRCD_MIN(strlen(ServerInfo.sid),
794 <                                            IRC_MAXSID));
1362 <    hash_add_id(&me);
1363 <  }
791 >    char modebuf[4], nickbuf[NICKLEN * 3 + 3] = "";
792 >    char *p = modebuf;
793 >    int len = 0;
794 >    const struct Membership *member = node->data;
795  
796 <  for (i = 0; i < IRC_MAXSID; i++)
1366 <    if (new_uid[i] == '\0')
1367 <      new_uid[i] = 'A';
1368 <
1369 <  /* XXX if IRC_MAXUID != 6, this will have to be rewritten */
1370 <  /* Yes nenolod, I have known it was off by one ever since I wrote it
1371 <   * But *JUST* for you, though, it really doesn't look as *pretty*
1372 <   * -Dianora
1373 <   */
1374 <  memcpy(new_uid+IRC_MAXSID, "AAAAA@", IRC_MAXUID);
1375 <
1376 <  entering_umode_cb = register_callback("entering_umode", NULL);
1377 <  umode_cb = register_callback("changing_umode", change_simple_umode);
1378 <  uid_get_cb = register_callback("uid_get", uid_get);
1379 < }
1380 <
1381 < /*
1382 < * uid_get
1383 < *
1384 < * inputs       - struct Client *
1385 < * output       - new UID is returned to caller
1386 < * side effects - new_uid is incremented by one.
1387 < */
1388 < static void *
1389 < uid_get(va_list args)
1390 < {
1391 <  add_one_to_uid(TOTALSIDUID-1);    /* index from 0 */
1392 <  return ((void *) new_uid);
1393 < }
1394 <
1395 < /*
1396 < * add_one_to_uid
1397 < *
1398 < * inputs       - index number into new_uid
1399 < * output       - NONE
1400 < * side effects - new_uid is incremented by one
1401 < *                note this is a recursive function
1402 < */
1403 < static void
1404 < add_one_to_uid(int i)
1405 < {
1406 <  if (i != IRC_MAXSID)    /* Not reached server SID portion yet? */
1407 <  {
1408 <    if (new_uid[i] == 'Z')
1409 <      new_uid[i] = '0';
1410 <    else if (new_uid[i] == '9')
796 >    if (has_member_flags(member, CHFL_CHANOP))
797      {
798 <      new_uid[i] = 'A';
799 <      add_one_to_uid(i-1);
798 >      *p++ = 'o';
799 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
800      }
1415    else new_uid[i] = new_uid[i] + 1;
1416  }
1417  else
1418  {
1419    /* XXX if IRC_MAXUID != 6, this will have to be rewritten */
1420    if (new_uid[i] == 'Z')
1421      memcpy(new_uid+IRC_MAXSID, "AAAAAA", IRC_MAXUID);
1422    else
1423      new_uid[i] = new_uid[i] + 1;
1424  }
1425 }
1426
1427 /*
1428 * init_isupport()
1429 *
1430 * input        - NONE
1431 * output       - NONE
1432 * side effects - Must be called before isupport is enabled
1433 */
1434 void
1435 init_isupport(void)
1436 {
1437  isupportFile = init_MessageLine();
1438
1439  add_isupport("CALLERID", NULL, -1);
1440  add_isupport("CASEMAPPING", CASEMAP, -1);
1441  add_isupport("KICKLEN", NULL, KICKLEN);
1442  add_isupport("MODES", NULL, MAXMODEPARAMS);
1443  add_isupport("NICKLEN", NULL, NICKLEN-1);
1444 #ifdef HALFOPS
1445  add_isupport("PREFIX", "(ohv)@%+", -1);
1446  add_isupport("STATUSMSG", "@%+", -1);
1447 #else
1448  add_isupport("PREFIX", "(ov)@+", -1);
1449  add_isupport("STATUSMSG", "@+", -1);
1450 #endif
1451  add_isupport("TOPICLEN", NULL, TOPICLEN);
1452 }
801  
802 < /*
803 < * add_isupport()
804 < *
805 < * input        - name of supported function
806 < *              - options if any
1459 < *              - number if any
1460 < * output       - NONE
1461 < * side effects - Each supported item must call this when activated
1462 < */
1463 < void
1464 < add_isupport(const char *name, const char *options, int n)
1465 < {
1466 <  dlink_node *ptr;
1467 <  struct Isupport *support;
802 >    if (has_member_flags(member, CHFL_HALFOP))
803 >    {
804 >      *p++ = 'h';
805 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
806 >    }
807  
808 <  DLINK_FOREACH(ptr, support_list.head)
1470 <  {
1471 <    support = ptr->data;
1472 <    if (irccmp(support->name, name) == 0)
808 >    if (has_member_flags(member, CHFL_VOICE))
809      {
810 <      MyFree(support->name);
811 <      MyFree(support->options);
1476 <      break;
810 >      *p++ = 'v';
811 >      len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
812      }
1478  }
813  
814 <  if (ptr == NULL)
1481 <  {
1482 <    support = MyMalloc(sizeof(*support));
1483 <    dlinkAddTail(support, &support->node, &support_list);
1484 <  }
814 >    *p = '\0';
815  
1486  DupString(support->name, name);
1487  if (options != NULL)
1488    DupString(support->options, options);
1489  support->number = n;
816  
817 <  rebuild_isupport_message_line();
818 < }
817 >    sendto_channel_local_butone(target_p, CAP_EXTENDED_JOIN, 0, member->chptr, ":%s!%s@%s JOIN %s %s :%s",
818 >                                target_p->name, target_p->username,
819 >                                target_p->host, member->chptr->name,
820 >                                (!IsDigit(target_p->account[0]) && target_p->account[0] != '*') ? target_p->account : "*",
821 >                                target_p->info);
822 >    sendto_channel_local_butone(target_p, 0, CAP_EXTENDED_JOIN, member->chptr, ":%s!%s@%s JOIN :%s",
823 >                                target_p->name, target_p->username,
824 >                                target_p->host, member->chptr->name);
825  
826 < /*
827 < * delete_isupport()
828 < *
829 < * input        - name of supported function
1498 < * output       - NONE
1499 < * side effects - Each supported item must call this when deactivated
1500 < */
1501 < void
1502 < delete_isupport(const char *name)
1503 < {
1504 <  dlink_node *ptr;
1505 <  struct Isupport *support;
826 >    if (nickbuf[0])
827 >      sendto_channel_local_butone(target_p, 0, 0, member->chptr, ":%s MODE %s +%s %s",
828 >                                  target_p->servptr->name, member->chptr->name,
829 >                                  modebuf, nickbuf);
830  
1507  DLINK_FOREACH(ptr, support_list.head)
1508  {
1509    support = ptr->data;
1510    if (irccmp(support->name, name) == 0)
1511    {
1512      dlinkDelete(ptr, &support_list);
1513      MyFree(support->name);
1514      MyFree(support->options);
1515      MyFree(support);
1516      break;
1517    }
831    }
832  
833 <  rebuild_isupport_message_line();
833 >  if (target_p->away[0])
834 >    sendto_common_channels_local(target_p, 0, CAP_AWAY_NOTIFY,
835 >                                 ":%s!%s@%s AWAY :%s",
836 >                                 target_p->name, target_p->username,
837 >                                 target_p->host, target_p->away);
838   }
839  
840 < /*
841 < * rebuild_isupport_message_line
842 < *
1526 < * input        - NONE
1527 < * output       - NONE
1528 < * side effects - Destroy the isupport MessageFile lines, and rebuild.
840 > /*! \brief Blindly opers up given source_p, using conf info.
841 > *         All checks on passwords have already been done.
842 > * \param source_p Pointer to given client to oper
843   */
844   void
845 < rebuild_isupport_message_line(void)
845 > user_oper_up(struct Client *source_p)
846   {
847 <  char isupportbuffer[IRCD_BUFSIZE];
848 <  char *p = isupportbuffer;
1535 <  dlink_node *ptr = NULL;
1536 <  int n = 0;
1537 <  int tokens = 0;
1538 <  size_t len = 0;
1539 <  size_t reserve = strlen(me.name) + HOSTLEN + strlen(form_str(RPL_ISUPPORT));
1540 <
1541 <  destroy_MessageLine(isupportFile);
847 >  const unsigned int old = source_p->umodes;
848 >  const struct MaskItem *const conf = source_p->connection->confs.head->data;
849  
850 <  DLINK_FOREACH(ptr, support_list.head)
851 <  {
1545 <    struct Isupport *support = ptr->data;
850 >  ++Count.oper;
851 >  SetOper(source_p);
852  
853 <    p += (n = ircsprintf(p, "%s", support->name));
854 <    len += n;
853 >  if (conf->modes)
854 >    AddUMode(source_p, conf->modes);
855 >  else if (ConfigGeneral.oper_umodes)
856 >    AddUMode(source_p, ConfigGeneral.oper_umodes);
857  
858 <    if (support->options != NULL)
859 <    {
860 <      p += (n = ircsprintf(p, "=%s", support->options));
861 <      len += n;
1554 <    }
858 >  if (!(old & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
859 >    ++Count.invisi;
860 >  if ((old & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
861 >    --Count.invisi;
862  
863 <    if (support->number > 0)
864 <    {
1558 <      p += (n = ircsprintf(p, "=%d", support->number));
1559 <      len += n;
1560 <    }
863 >  assert(dlinkFind(&oper_list, source_p) == NULL);
864 >  dlinkAdd(source_p, make_dlink_node(), &oper_list);
865  
866 <    *p++ = ' ';
1563 <    len++;
1564 <    *p = '\0';
866 >  AddOFlag(source_p, conf->port);
867  
868 <    if (++tokens == (MAXPARA-2) || len >= (sizeof(isupportbuffer)-reserve))
869 <    { /* arbritrary for now */
1568 <      if (*--p == ' ')
1569 <        *p = '\0';
1570 <
1571 <      addto_MessageLine(isupportFile, isupportbuffer);
1572 <      p = isupportbuffer;
1573 <      len = 0;
1574 <      n = tokens = 0;
1575 <    }
1576 <  }
868 >  if (HasOFlag(source_p, OPER_FLAG_ADMIN))
869 >    AddUMode(source_p, UMODE_ADMIN);
870  
871 <  if (len != 0)
871 >  if (!EmptyString(conf->whois))
872    {
873 <    if (*--p == ' ')
874 <      *p = '\0';
875 <    addto_MessageLine(isupportFile, isupportbuffer);
873 >    client_attach_svstag(source_p, RPL_WHOISOPERATOR, "+", conf->whois);
874 >    sendto_server(source_p, 0, 0, ":%s SVSTAG %s %lu %u + :%s",
875 >                  me.id, source_p->id, (unsigned long)source_p->tsinfo,
876 >                  RPL_WHOISOPERATOR, conf->whois);
877    }
878 +
879 +  sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE, "%s is now an operator",
880 +                       get_oper_name(source_p));
881 +  sendto_server(NULL, 0, 0, ":%s GLOBOPS :%s is now an operator",
882 +                me.id, get_oper_name(source_p));
883 +  send_umode_out(source_p, old);
884 +  sendto_one_numeric(source_p, &me, RPL_YOUREOPER);
885   }

Diff Legend

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