ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/user.c
Revision: 3117
Committed: Fri Mar 7 19:28:54 2014 UTC (10 years ago) by michael
Content type: text/x-csrc
Original Path: ircd-hybrid/trunk/src/s_user.c
File size: 39636 byte(s)
Log Message:
- Removed unused header includes here and there

File Contents

# User Rev Content
1 adx 30 /*
2 michael 2916 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 adx 30 *
4 michael 2916 * Copyright (c) 1997-2014 ircd-hybrid development team
5 adx 30 *
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
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * This program is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     * GNU General Public License for more details.
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
19     * USA
20     */
21    
22 michael 2916 /*! \file s_user.c
23     * \brief User related functions.
24     * \version $Id$
25     */
26    
27 adx 30 #include "stdinc.h"
28 michael 1011 #include "list.h"
29 adx 30 #include "s_user.h"
30     #include "s_misc.h"
31     #include "channel.h"
32     #include "channel_mode.h"
33     #include "client.h"
34     #include "hash.h"
35     #include "irc_string.h"
36     #include "ircd.h"
37     #include "listener.h"
38     #include "motd.h"
39     #include "numeric.h"
40 michael 1309 #include "conf.h"
41     #include "log.h"
42 adx 30 #include "s_serv.h"
43     #include "send.h"
44     #include "supported.h"
45     #include "memory.h"
46     #include "packet.h"
47 michael 982 #include "rng_mt.h"
48 adx 30 #include "userhost.h"
49     #include "s_misc.h"
50 michael 1243 #include "parse.h"
51 michael 876 #include "watch.h"
52 adx 30
53     static char umode_buffer[IRCD_BUFSIZE];
54    
55     static void user_welcome(struct Client *);
56 michael 1632 static void report_and_set_user_flags(struct Client *, const struct MaskItem *);
57 adx 30 static int check_xline(struct Client *);
58 michael 1080 static void introduce_client(struct Client *);
59     static const char *uid_get(void);
60 adx 30
61     /* Used for building up the isupport string,
62     * used with init_isupport, add_isupport, delete_isupport
63     */
64    
65 michael 2345 struct Isupport
66 adx 30 {
67     dlink_node node;
68     char *name;
69     char *options;
70     int number;
71     };
72    
73 michael 2159 static dlink_list support_list;
74     static dlink_list support_list_lines;
75 adx 30
76     /* memory is cheap. map 0-255 to equivalent mode */
77 michael 2022 const unsigned int user_modes[256] =
78 adx 30 {
79     /* 0x00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x0F */
80     /* 0x10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x1F */
81     /* 0x20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x2F */
82     /* 0x30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x3F */
83     0, /* @ */
84     0, /* A */
85     0, /* B */
86 michael 2185 0, /* C */
87 adx 30 UMODE_DEAF, /* D */
88     0, /* E */
89 michael 1976 UMODE_FARCONNECT, /* F */
90 adx 30 UMODE_SOFTCALLERID, /* G */
91 michael 1294 UMODE_HIDDEN, /* H */
92 adx 30 0, /* I */
93     0, /* J */
94     0, /* K */
95     0, /* L */
96     0, /* M */
97     0, /* N */
98     0, /* O */
99     0, /* P */
100     0, /* Q */
101 michael 1175 UMODE_REGONLY, /* R */
102 michael 2246 UMODE_SSL, /* S */
103 adx 30 0, /* T */
104     0, /* U */
105     0, /* V */
106 michael 2511 UMODE_WEBIRC, /* W */
107 adx 30 0, /* X */
108     0, /* Y */
109     0, /* Z 0x5A */
110 michael 2345 0, 0, 0, 0, 0, /* 0x5F */
111 adx 30 0, /* 0x60 */
112     UMODE_ADMIN, /* a */
113     UMODE_BOTS, /* b */
114     UMODE_CCONN, /* c */
115     UMODE_DEBUG, /* d */
116 michael 1818 UMODE_EXTERNAL, /* e */
117 adx 30 UMODE_FULL, /* f */
118     UMODE_CALLERID, /* g */
119     0, /* h */
120     UMODE_INVISIBLE, /* i */
121 michael 1158 UMODE_REJ, /* j */
122 adx 30 UMODE_SKILL, /* k */
123     UMODE_LOCOPS, /* l */
124     0, /* m */
125     UMODE_NCHANGE, /* n */
126     UMODE_OPER, /* o */
127     0, /* p */
128     0, /* q */
129 michael 1158 UMODE_REGISTERED, /* r */
130 adx 30 UMODE_SERVNOTICE, /* s */
131     0, /* t */
132     UMODE_UNAUTH, /* u */
133     0, /* v */
134     UMODE_WALLOP, /* w */
135 michael 2137 UMODE_HIDDENHOST, /* x */
136 adx 30 UMODE_SPY, /* y */
137     UMODE_OPERWALL, /* z 0x7A */
138     0,0,0,0,0, /* 0x7B - 0x7F */
139    
140     /* 0x80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x8F */
141     /* 0x90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x9F */
142     /* 0xA0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xAF */
143     /* 0xB0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xBF */
144     /* 0xC0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xCF */
145     /* 0xD0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xDF */
146     /* 0xE0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xEF */
147     /* 0xF0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* 0xFF */
148     };
149    
150     void
151     assemble_umode_buffer(void)
152     {
153     unsigned int idx = 0;
154     char *umode_buffer_ptr = umode_buffer;
155    
156 michael 1013 for (; idx < (sizeof(user_modes) / sizeof(user_modes[0])); ++idx)
157 adx 30 if (user_modes[idx])
158     *umode_buffer_ptr++ = idx;
159    
160     *umode_buffer_ptr = '\0';
161     }
162    
163     /* show_lusers()
164     *
165     * inputs - pointer to client
166     * output - NONE
167     * side effects - display to client user counts etc.
168     */
169     void
170 michael 2345 show_lusers(struct Client *source_p)
171 adx 30 {
172 michael 1219 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
173 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total-Count.invisi),
174     Count.invisi, dlink_list_length(&global_serv_list));
175 adx 30 else
176 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT,
177     (Count.total-Count.invisi), Count.invisi, 1);
178 adx 30
179     if (Count.oper > 0)
180 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSEROP, Count.oper);
181 adx 30
182     if (dlink_list_length(&unknown_list) > 0)
183 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
184 adx 30
185     if (dlink_list_length(&global_channel_list) > 0)
186 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&global_channel_list));
187 adx 30
188 michael 1219 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
189 adx 30 {
190 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.local, Count.myserver);
191     sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
192 adx 30 }
193     else
194     {
195 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.total, 0);
196     sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
197 adx 30 }
198    
199 michael 3109 sendto_one_numeric(source_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
200 adx 30
201 michael 1219 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
202 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
203     Count.max_loc_cli, Count.totalrestartcount);
204 adx 30
205 michael 1143 if (Count.local > Count.max_loc_cli)
206     Count.max_loc_cli = Count.local;
207 adx 30
208 michael 1143 if ((Count.local + Count.myserver) > Count.max_loc_con)
209 michael 2345 Count.max_loc_con = Count.local + Count.myserver;
210 adx 30 }
211    
212     /* show_isupport()
213     *
214     * inputs - pointer to client
215     * output - NONE
216     * side effects - display to client what we support (for them)
217     */
218     void
219 michael 2345 show_isupport(struct Client *source_p)
220 adx 30 {
221 michael 2159 const dlink_node *ptr = NULL;
222    
223     DLINK_FOREACH(ptr, support_list_lines.head)
224 michael 3109 sendto_one_numeric(source_p, &me, RPL_ISUPPORT, ptr->data);
225 adx 30 }
226    
227     /*
228     ** register_local_user
229     ** This function is called when both NICK and USER messages
230     ** have been accepted for the client, in whatever order. Only
231     ** after this, is the USER message propagated.
232     **
233     ** NICK's must be propagated at once when received, although
234     ** it would be better to delay them too until full info is
235     ** available. Doing it is not so simple though, would have
236     ** to implement the following:
237     **
238     ** (actually it has been implemented already for a while) -orabidoo
239     **
240     ** 1) user telnets in and gives only "NICK foobar" and waits
241     ** 2) another user far away logs in normally with the nick
242     ** "foobar" (quite legal, as this server didn't propagate
243     ** it).
244     ** 3) now this server gets nick "foobar" from outside, but
245     ** has alread the same defined locally. Current server
246     ** would just issue "KILL foobar" to clean out dups. But,
247     ** this is not fair. It should actually request another
248     ** nick from local user or kill him/her...
249     */
250     void
251 michael 1080 register_local_user(struct Client *source_p)
252 adx 30 {
253 michael 1115 const char *id = NULL;
254 michael 1632 const struct MaskItem *conf = NULL;
255 adx 30
256     assert(source_p != NULL);
257 michael 1080 assert(source_p == source_p->from);
258 adx 30 assert(MyConnect(source_p));
259 michael 503 assert(!source_p->localClient->registration);
260 adx 30
261 michael 1080 ClearCap(source_p, CAP_TS6);
262 michael 589
263 adx 30 if (ConfigFileEntry.ping_cookie)
264     {
265 michael 2314 if (!IsPingSent(source_p) && !source_p->localClient->random_ping)
266 adx 30 {
267 michael 983 do
268     source_p->localClient->random_ping = genrand_int32();
269     while (!source_p->localClient->random_ping);
270    
271 michael 982 sendto_one(source_p, "PING :%u",
272 adx 30 source_p->localClient->random_ping);
273     SetPingSent(source_p);
274     return;
275     }
276    
277     if (!HasPingCookie(source_p))
278     return;
279     }
280    
281 michael 1176 source_p->localClient->last_privmsg = CurrentTime;
282 adx 30 /* Straight up the maximum rate of flooding... */
283     source_p->localClient->allow_read = MAX_FLOOD_BURST;
284    
285 michael 1644 if (!check_client(source_p))
286 adx 30 return;
287    
288 michael 2314 if (!valid_hostname(source_p->host))
289 adx 30 {
290 michael 3110 sendto_one_notice(source_p, &me, ":*** Notice -- You have an illegal "
291     "character in your hostname");
292 adx 30 strlcpy(source_p->host, source_p->sockhost,
293     sizeof(source_p->host));
294     }
295    
296 michael 1632 conf = source_p->localClient->confs.head->data;
297 adx 30
298     if (!IsGotId(source_p))
299     {
300 michael 1080 char username[USERLEN + 1];
301     const char *p = username;
302 adx 30 unsigned int i = 0;
303    
304 michael 1632 if (IsNeedIdentd(conf))
305 adx 30 {
306 michael 896 ++ServerStats.is_ref;
307 michael 3110 sendto_one_notice(source_p, &me, ":*** Notice -- You need to install "
308     "identd to use this server");
309 adx 30 exit_client(source_p, &me, "Install identd");
310     return;
311     }
312    
313 michael 1080 strlcpy(username, source_p->username, sizeof(username));
314 adx 30
315 michael 1632 if (!IsNoTilde(conf))
316 adx 30 source_p->username[i++] = '~';
317    
318 michael 1080 for (; *p && i < USERLEN; ++p)
319 adx 30 if (*p != '[')
320     source_p->username[i++] = *p;
321    
322     source_p->username[i] = '\0';
323     }
324    
325     /* password check */
326 michael 1632 if (!EmptyString(conf->passwd))
327 adx 30 {
328     const char *pass = source_p->localClient->passwd;
329    
330 michael 1632 if (!match_conf_password(pass, conf))
331 adx 30 {
332 michael 896 ++ServerStats.is_ref;
333 michael 3109
334     sendto_one_numeric(source_p, &me, ERR_PASSWDMISMATCH);
335 adx 30 exit_client(source_p, &me, "Bad Password");
336     return;
337     }
338     }
339    
340     /* don't free source_p->localClient->passwd here - it can be required
341     * by masked /stats I if there are auth{} blocks with need_password = no;
342     * --adx
343     */
344    
345     /* report if user has &^>= etc. and set flags as needed in source_p */
346 michael 1632 report_and_set_user_flags(source_p, conf);
347 adx 30
348 michael 1080 if (IsDead(source_p))
349 michael 980 return;
350    
351 adx 30 /* Limit clients -
352     * We want to be able to have servers and F-line clients
353     * connect, so save room for "buffer" connections.
354     * Smaller servers may want to decrease this, and it should
355     * probably be just a percentage of the MAXCLIENTS...
356     * -Taner
357     */
358     /* Except "F:" clients */
359     if ((Count.local >= ServerInfo.max_clients + MAX_BUFFER) ||
360     (Count.local >= ServerInfo.max_clients && !IsExemptLimits(source_p)))
361     {
362 michael 1618 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
363 adx 30 "Too many clients, rejecting %s[%s].",
364 michael 1080 source_p->name, source_p->host);
365 michael 896 ++ServerStats.is_ref;
366 adx 30 exit_client(source_p, &me, "Sorry, server is full - try later");
367     return;
368     }
369    
370     /* valid user name check */
371 michael 2314 if (!valid_username(source_p->username, 1))
372 adx 30 {
373     char tmpstr2[IRCD_BUFSIZE];
374    
375 michael 1618 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
376     "Invalid username: %s (%s@%s)",
377 michael 1080 source_p->name, source_p->username, source_p->host);
378 michael 896 ++ServerStats.is_ref;
379 michael 1124 snprintf(tmpstr2, sizeof(tmpstr2), "Invalid username [%s]",
380     source_p->username);
381 adx 30 exit_client(source_p, &me, tmpstr2);
382     return;
383     }
384    
385 michael 592 if (check_xline(source_p))
386 adx 30 return;
387    
388 michael 1115 while (hash_find_id((id = uid_get())) != NULL)
389     ;
390 michael 573
391 michael 1115 strlcpy(source_p->id, id, sizeof(source_p->id));
392     hash_add_id(source_p);
393 adx 30
394 michael 1618 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
395 michael 1137 "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
396 michael 1080 source_p->name, source_p->username, source_p->host,
397 adx 30 ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ?
398 michael 891 "255.255.255.255" : source_p->sockhost,
399 michael 1632 get_client_class(&source_p->localClient->confs),
400 michael 1137 source_p->info, source_p->id);
401 adx 30
402     if (ConfigFileEntry.invisible_on_connect)
403 michael 159 {
404 michael 1219 AddUMode(source_p, UMODE_INVISIBLE);
405 michael 980 ++Count.invisi;
406 michael 159 }
407 adx 30
408 michael 2314 if (++Count.local > Count.max_loc)
409 adx 30 {
410     Count.max_loc = Count.local;
411    
412     if (!(Count.max_loc % 10))
413 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
414     "New Max Local Clients: %d",
415 adx 30 Count.max_loc);
416     }
417    
418     /* Increment our total user count here */
419     if (++Count.total > Count.max_tot)
420     Count.max_tot = Count.total;
421 michael 948 ++Count.totalrestartcount;
422 adx 30
423 michael 1080 assert(source_p->servptr == &me);
424     SetClient(source_p);
425     dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
426    
427 adx 30 source_p->localClient->allow_read = MAX_FLOOD_BURST;
428    
429 michael 1125 assert(dlinkFind(&unknown_list, source_p));
430 michael 1013
431 michael 1126 dlink_move_node(&source_p->localClient->lclient_node,
432     &unknown_list, &local_client_list);
433 adx 30
434     user_welcome(source_p);
435     add_user_host(source_p->username, source_p->host, 0);
436     SetUserHost(source_p);
437    
438 michael 1080 introduce_client(source_p);
439 adx 30 }
440    
441     /* register_remote_user()
442     *
443 michael 1080 * inputs - source_p remote or directly connected client
444 adx 30 * - username to register as
445     * - host name to register as
446     * - server name
447     * output - NONE
448     * side effects - This function is called when a remote client
449     * is introduced by a server.
450     */
451     void
452 michael 2955 register_remote_user(struct Client *source_p, const char *username,
453     const char *host, const char *server)
454 adx 30 {
455 michael 56 struct Client *target_p = NULL;
456 adx 30
457     assert(source_p != NULL);
458     assert(source_p->username != username);
459    
460 michael 2345 strlcpy(source_p->host, host, sizeof(source_p->host));
461 adx 30 strlcpy(source_p->username, username, sizeof(source_p->username));
462    
463     /*
464     * coming from another server, take the servers word for it
465     */
466 michael 1169 source_p->servptr = hash_find_server(server);
467 adx 30
468 michael 1618 /*
469     * Super GhostDetect:
470 adx 30 * If we can't find the server the user is supposed to be on,
471     * then simply blow the user away. -Taner
472     */
473     if (source_p->servptr == NULL)
474     {
475 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
476 adx 30 "No server %s for user %s[%s@%s] from %s",
477     server, source_p->name, source_p->username,
478     source_p->host, source_p->from->name);
479 michael 1080 kill_client(source_p->from, source_p, "%s (Server doesn't exist)", me.name);
480 adx 30
481 michael 1219 AddFlag(source_p, FLAGS_KILLED);
482 adx 30 exit_client(source_p, &me, "Ghosted Client");
483     return;
484     }
485    
486     if ((target_p = source_p->servptr) && target_p->from != source_p->from)
487     {
488 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
489 adx 30 "Bad User [%s] :%s USER %s@%s %s, != %s[%s]",
490 michael 1080 source_p->from->name, source_p->name, source_p->username,
491 adx 30 source_p->host, source_p->servptr->name,
492     target_p->name, target_p->from->name);
493 michael 1080 kill_client(source_p->from, source_p,
494 adx 30 "%s (NICK from wrong direction (%s != %s))",
495     me.name, source_p->servptr->name, target_p->from->name);
496 michael 1219 AddFlag(source_p, FLAGS_KILLED);
497 adx 30 exit_client(source_p, &me, "USER server wrong direction");
498     return;
499     }
500    
501 michael 1167 /*
502     * If the nick has been introduced by a services server,
503     * make it a service as well.
504     */
505 michael 1219 if (HasFlag(source_p->servptr, FLAGS_SERVICE))
506     AddFlag(source_p, FLAGS_SERVICE);
507 michael 1167
508 michael 510 /* Increment our total user count here */
509     if (++Count.total > Count.max_tot)
510     Count.max_tot = Count.total;
511    
512 adx 30 SetClient(source_p);
513 michael 889 dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
514 adx 30 add_user_host(source_p->username, source_p->host, 1);
515     SetUserHost(source_p);
516    
517 michael 1976 if (HasFlag(source_p->servptr, FLAGS_EOB))
518     sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
519     "Client connecting at %s: %s (%s@%s) [%s] <%s>",
520     source_p->servptr->name,
521     source_p->name, source_p->username, source_p->host,
522     source_p->info, source_p->id);
523    
524 michael 1080 introduce_client(source_p);
525 adx 30 }
526    
527     /* introduce_client()
528     *
529 michael 1080 * inputs - source_p
530 adx 30 * output - NONE
531     * side effects - This common function introduces a client to the rest
532     * of the net, either from a local client connect or
533     * from a remote connect.
534     */
535     static void
536 michael 1080 introduce_client(struct Client *source_p)
537 adx 30 {
538 michael 56 dlink_node *server_node = NULL;
539 michael 2691 char ubuf[IRCD_BUFSIZE];
540 adx 30
541     if (MyClient(source_p))
542     send_umode(source_p, source_p, 0, SEND_UMODES, ubuf);
543     else
544     send_umode(NULL, source_p, 0, SEND_UMODES, ubuf);
545    
546 michael 876 watch_check_hash(source_p, RPL_LOGON);
547    
548 michael 2688 if (ubuf[0] == '\0')
549 adx 30 {
550     ubuf[0] = '+';
551     ubuf[1] = '\0';
552     }
553    
554 michael 885 DLINK_FOREACH(server_node, serv_list.head)
555     {
556     struct Client *server = server_node->data;
557 adx 30
558 michael 1080 if (server == source_p->from)
559 michael 885 continue;
560    
561 michael 1196 if (IsCapable(server, CAP_SVS))
562     {
563     if (IsCapable(server, CAP_TS6) && HasID(source_p))
564 michael 1559 sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s %s :%s",
565 michael 1196 source_p->servptr->id,
566     source_p->name, source_p->hopcount+1,
567     (unsigned long)source_p->tsinfo,
568     ubuf, source_p->username, source_p->host,
569     (MyClient(source_p) && IsIPSpoof(source_p)) ?
570     "0" : source_p->sockhost, source_p->id,
571 michael 1559 source_p->svid,
572 michael 1196 source_p->info);
573     else
574 michael 1559 sendto_one(server, "NICK %s %d %lu %s %s %s %s %s :%s",
575 michael 1196 source_p->name, source_p->hopcount+1,
576     (unsigned long)source_p->tsinfo,
577     ubuf, source_p->username, source_p->host,
578 michael 1559 source_p->servptr->name, source_p->svid,
579 michael 1196 source_p->info);
580    
581     }
582 adx 30 else
583 michael 1196 {
584     if (IsCapable(server, CAP_TS6) && HasID(source_p))
585     sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s :%s",
586     source_p->servptr->id,
587     source_p->name, source_p->hopcount+1,
588     (unsigned long)source_p->tsinfo,
589     ubuf, source_p->username, source_p->host,
590     (MyClient(source_p) && IsIPSpoof(source_p)) ?
591     "0" : source_p->sockhost, source_p->id, source_p->info);
592     else
593     sendto_one(server, "NICK %s %d %lu %s %s %s %s :%s",
594     source_p->name, source_p->hopcount+1,
595     (unsigned long)source_p->tsinfo,
596     ubuf, source_p->username, source_p->host,
597     source_p->servptr->name, source_p->info);
598     }
599 michael 2231
600     if (!EmptyString(source_p->certfp))
601     sendto_one(server, ":%s CERTFP %s", ID(source_p), source_p->certfp);
602 adx 30 }
603     }
604    
605     /* valid_hostname()
606     *
607     * Inputs - pointer to hostname
608     * Output - 1 if valid, 0 if not
609     * Side effects - check hostname for validity
610     *
611     * NOTE: this doesn't allow a hostname to begin with a dot and
612     * will not allow more dots than chars.
613     */
614     int
615     valid_hostname(const char *hostname)
616     {
617     const char *p = hostname;
618    
619     assert(p != NULL);
620    
621 michael 2352 if (EmptyString(p) || *p == '.' || *p == ':')
622 michael 56 return 0;
623 adx 30
624 michael 1080 for (; *p; ++p)
625 adx 30 if (!IsHostChar(*p))
626 michael 56 return 0;
627 adx 30
628 michael 1795 return p - hostname <= HOSTLEN;
629 adx 30 }
630    
631     /* valid_username()
632     *
633     * Inputs - pointer to user
634     * Output - 1 if valid, 0 if not
635     * Side effects - check username for validity
636     *
637     * Absolutely always reject any '*' '!' '?' '@' in an user name
638     * reject any odd control characters names.
639     * Allow '.' in username to allow for "first.last"
640     * style of username
641     */
642     int
643 michael 2069 valid_username(const char *username, const int local)
644 adx 30 {
645     int dots = 0;
646     const char *p = username;
647    
648     assert(p != NULL);
649    
650 michael 1080 if (*p == '~')
651 adx 30 ++p;
652    
653 michael 2067 /*
654     * Reject usernames that don't start with an alphanum
655 adx 30 * i.e. reject jokers who have '-@somehost' or '.@somehost'
656     * or "-hi-@somehost", "h-----@somehost" would still be accepted.
657     */
658     if (!IsAlNum(*p))
659 michael 56 return 0;
660 adx 30
661 michael 2067 if (local)
662 adx 30 {
663 michael 2067 while (*++p)
664 adx 30 {
665 michael 2067 if ((*p == '.') && ConfigFileEntry.dots_in_ident)
666     {
667     if (++dots > ConfigFileEntry.dots_in_ident)
668     return 0;
669     if (!IsUserChar(*(p + 1)))
670     return 0;
671     }
672     else if (!IsUserChar(*p))
673 michael 56 return 0;
674 adx 30 }
675     }
676 michael 2067 else
677     {
678     while (*++p)
679     if (!IsUserChar(*p))
680     return 0;
681     }
682 adx 30
683 michael 2067 return p - username <= USERLEN;;
684 adx 30 }
685    
686 michael 1165 /* clean_nick_name()
687     *
688     * input - nickname
689     * - whether it's a local nick (1) or remote (0)
690     * output - none
691     * side effects - walks through the nickname, returning 0 if erroneous
692     */
693     int
694     valid_nickname(const char *nickname, const int local)
695     {
696     const char *p = nickname;
697     assert(nickname && *nickname);
698    
699     /* nicks can't start with a digit or - or be 0 length */
700     /* This closer duplicates behaviour of hybrid-6 */
701     if (*p == '-' || (IsDigit(*p) && local) || *p == '\0')
702     return 0;
703    
704     for (; *p; ++p)
705     if (!IsNickChar(*p))
706     return 0;
707    
708 michael 1431 return p - nickname <= NICKLEN;
709 michael 1165 }
710    
711 adx 30 /* report_and_set_user_flags()
712     *
713     * inputs - pointer to source_p
714 michael 1632 * - pointer to conf for this user
715 adx 30 * output - NONE
716     * side effects - Report to user any special flags
717     * they are getting, and set them.
718     */
719     static void
720 michael 1632 report_and_set_user_flags(struct Client *source_p, const struct MaskItem *conf)
721 adx 30 {
722     /* If this user is being spoofed, tell them so */
723 michael 1632 if (IsConfDoSpoofIp(conf))
724 michael 3110 sendto_one_notice(source_p, &me, ":*** Spoofing your IP. Congrats.");
725 adx 30
726     /* If this user is in the exception class, Set it "E lined" */
727 michael 1632 if (IsConfExemptKline(conf))
728 adx 30 {
729     SetExemptKline(source_p);
730 michael 3110 sendto_one_notice(source_p, &me, ":*** You are exempt from K/D/G lines. Congrats.");
731 adx 30 }
732    
733 michael 2314 /*
734     * The else here is to make sure that G line exempt users
735 adx 30 * do not get noticed twice.
736     */
737 michael 1632 else if (IsConfExemptGline(conf))
738 adx 30 {
739     SetExemptGline(source_p);
740 michael 3110 sendto_one_notice(source_p, &me, ":*** You are exempt from G lines. Congrats.");
741 adx 30 }
742    
743 michael 1632 if (IsConfExemptResv(conf))
744 adx 30 {
745     SetExemptResv(source_p);
746 michael 3110 sendto_one_notice(source_p, &me, ":*** You are exempt from resvs. Congrats.");
747 adx 30 }
748    
749     /* If this user is exempt from user limits set it "F lined" */
750 michael 1632 if (IsConfExemptLimits(conf))
751 adx 30 {
752     SetExemptLimits(source_p);
753 michael 3110 sendto_one_notice(source_p, &me, ":*** You are exempt from user limits. Congrats.");
754 adx 30 }
755    
756 michael 1632 if (IsConfCanFlood(conf))
757 adx 30 {
758     SetCanFlood(source_p);
759 michael 3110 sendto_one_notice(source_p, &me, ":*** You are exempt from flood "
760     "protection, aren't you fearsome.");
761 adx 30 }
762     }
763    
764     /* set_user_mode()
765     *
766     * added 15/10/91 By Darren Reed.
767     * parv[0] - sender
768     * parv[1] - username to change mode for
769     * parv[2] - modes to change
770     */
771     void
772     set_user_mode(struct Client *client_p, struct Client *source_p,
773 michael 1857 const int parc, char *parv[])
774 adx 30 {
775     unsigned int flag, setflags;
776     char **p, *m, buf[IRCD_BUFSIZE];
777     struct Client *target_p;
778     int what = MODE_ADD, badflag = 0, i;
779 michael 56
780     assert(!(parc < 2));
781    
782 adx 30 if ((target_p = find_person(client_p, parv[1])) == NULL)
783     {
784     if (MyConnect(source_p))
785 michael 3109 sendto_one_numeric(source_p, &me, ERR_NOSUCHCHANNEL, parv[1]);
786 adx 30 return;
787     }
788    
789 michael 1115 if (source_p != target_p)
790 adx 30 {
791 michael 3109 sendto_one_numeric(source_p, &me, ERR_USERSDONTMATCH);
792 adx 30 return;
793     }
794    
795     if (parc < 3)
796     {
797     m = buf;
798     *m++ = '+';
799    
800 michael 2314 for (i = 0; i < 128; ++i)
801 michael 1219 if (HasUMode(source_p, user_modes[i]))
802 adx 30 *m++ = (char)i;
803     *m = '\0';
804    
805 michael 3109 sendto_one_numeric(source_p, &me, RPL_UMODEIS, buf);
806 adx 30 return;
807     }
808    
809     /* find flags already set for user */
810     setflags = source_p->umodes;
811    
812     /* parse mode change string(s) */
813 michael 2314 for (p = &parv[2]; p && *p; ++p)
814 adx 30 {
815 michael 2314 for (m = *p; *m; ++m)
816 adx 30 {
817     switch (*m)
818     {
819     case '+':
820     what = MODE_ADD;
821     break;
822     case '-':
823     what = MODE_DEL;
824     break;
825     case 'o':
826     if (what == MODE_ADD)
827     {
828 michael 1219 if (IsServer(client_p) && !HasUMode(source_p, UMODE_OPER))
829 adx 30 {
830     ++Count.oper;
831     SetOper(source_p);
832     }
833     }
834     else
835     {
836 michael 1219 if (!HasUMode(source_p, UMODE_OPER))
837 adx 30 break;
838    
839     ClearOper(source_p);
840     Count.oper--;
841    
842     if (MyConnect(source_p))
843     {
844 michael 2314 dlink_node *dm = NULL;
845 adx 30
846 michael 1632 detach_conf(source_p, CONF_OPER);
847 michael 1219 ClrOFlag(source_p);
848     DelUMode(source_p, ConfigFileEntry.oper_only_umodes);
849 adx 30
850     if ((dm = dlinkFindDelete(&oper_list, source_p)) != NULL)
851     free_dlink_node(dm);
852     }
853     }
854    
855     break;
856    
857 michael 2246 case 'S': /* Only servers may set +S in a burst */
858 michael 2511 case 'W': /* Only servers may set +W in a burst */
859 michael 2025 case 'r': /* Only services may set +r */
860 michael 2137 case 'x': /* Only services may set +x */
861 adx 30 break;
862    
863     default:
864     if ((flag = user_modes[(unsigned char)*m]))
865     {
866 michael 1219 if (MyConnect(source_p) && !HasUMode(source_p, UMODE_OPER) &&
867 adx 30 (ConfigFileEntry.oper_only_umodes & flag))
868 michael 2022 badflag = 1;
869     else
870 adx 30 {
871 michael 2022 if (what == MODE_ADD)
872     AddUMode(source_p, flag);
873     else
874     DelUMode(source_p, flag);
875 adx 30 }
876     }
877 michael 2314 else if (MyConnect(source_p))
878     badflag = 1;
879 adx 30
880     break;
881     }
882     }
883     }
884    
885     if (badflag)
886 michael 3109 sendto_one_numeric(source_p, &me, ERR_UMODEUNKNOWNFLAG);
887 adx 30
888 michael 1219 if (MyConnect(source_p) && HasUMode(source_p, UMODE_ADMIN) &&
889 michael 1294 !HasOFlag(source_p, OPER_FLAG_ADMIN))
890 adx 30 {
891 michael 3110 sendto_one_notice(source_p, &me, ":*** You have no admin flag;");
892 michael 1219 DelUMode(source_p, UMODE_ADMIN);
893 adx 30 }
894    
895 michael 1219 if (!(setflags & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
896 adx 30 ++Count.invisi;
897 michael 1219 if ((setflags & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
898 adx 30 --Count.invisi;
899    
900 michael 56 /*
901     * compare new flags with old flags and send string which
902 adx 30 * will cause servers to update correctly.
903     */
904     send_umode_out(client_p, source_p, setflags);
905     }
906    
907     /* send_umode()
908     * send the MODE string for user (user) to connection client_p
909     * -avalon
910 db 849 *
911     * inputs - client_p
912     * - source_p
913     * - int old
914     * - sendmask mask of modes to send
915     * - suplied umode_buf
916     * output - NONE
917 adx 30 */
918     void
919     send_umode(struct Client *client_p, struct Client *source_p,
920     unsigned int old, unsigned int sendmask, char *umode_buf)
921     {
922 michael 1013 char *m = umode_buf;
923 adx 30 int what = 0;
924     unsigned int i;
925     unsigned int flag;
926    
927 michael 56 /*
928     * build a string in umode_buf to represent the change in the user's
929 adx 30 * mode between the new (source_p->umodes) and 'old'.
930     */
931 michael 2314 for (i = 0; i < 128; ++i)
932 adx 30 {
933     flag = user_modes[i];
934     if (!flag)
935     continue;
936    
937     if (MyClient(source_p) && !(flag & sendmask))
938     continue;
939    
940 michael 1219 if ((flag & old) && !HasUMode(source_p, flag))
941 adx 30 {
942     if (what == MODE_DEL)
943     *m++ = (char)i;
944     else
945     {
946     what = MODE_DEL;
947     *m++ = '-';
948     *m++ = (char)i;
949     }
950     }
951 michael 1219 else if (!(flag & old) && HasUMode(source_p, flag))
952 adx 30 {
953     if (what == MODE_ADD)
954     *m++ = (char)i;
955     else
956     {
957     what = MODE_ADD;
958     *m++ = '+';
959     *m++ = (char)i;
960     }
961     }
962     }
963    
964     *m = '\0';
965    
966     if (*umode_buf && client_p)
967 michael 528 sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
968     source_p->name, source_p->username,
969     source_p->host, source_p->name, umode_buf);
970 adx 30 }
971    
972     /* send_umode_out()
973     *
974     * inputs -
975     * output - NONE
976     * side effects - Only send ubuf out to servers that know about this client
977     */
978     void
979     send_umode_out(struct Client *client_p, struct Client *source_p,
980     unsigned int old)
981     {
982 michael 573 char buf[IRCD_BUFSIZE] = { '\0' };
983 adx 30 dlink_node *ptr = NULL;
984    
985 michael 1294 send_umode(NULL, source_p, old, SEND_UMODES, buf);
986 adx 30
987 michael 573 if (buf[0])
988 adx 30 {
989     DLINK_FOREACH(ptr, serv_list.head)
990     {
991     struct Client *target_p = ptr->data;
992    
993     if ((target_p != client_p) && (target_p != source_p))
994 michael 885 sendto_one(target_p, ":%s MODE %s :%s",
995     ID_or_name(source_p, target_p),
996     ID_or_name(source_p, target_p), buf);
997 adx 30 }
998     }
999    
1000     if (client_p && MyClient(client_p))
1001     send_umode(client_p, source_p, old, 0xffffffff, buf);
1002     }
1003    
1004 michael 1819 void
1005 michael 2137 user_set_hostmask(struct Client *target_p, const char *hostname, const int what)
1006 michael 1819 {
1007 michael 2141 dlink_node *ptr = NULL;
1008    
1009 michael 2145 if (!strcmp(target_p->host, hostname))
1010     return;
1011 michael 2141
1012 michael 2137 switch (what)
1013     {
1014     case MODE_ADD:
1015     AddUMode(target_p, UMODE_HIDDENHOST);
1016     AddFlag(target_p, FLAGS_IP_SPOOFING);
1017     break;
1018     case MODE_DEL:
1019     DelUMode(target_p, UMODE_HIDDENHOST);
1020 michael 2138
1021 michael 2141 if (!HasFlag(target_p, FLAGS_AUTH_SPOOF))
1022 michael 2138 DelFlag(target_p, FLAGS_IP_SPOOFING);
1023 michael 2137 break;
1024 michael 2145 default: return;
1025 michael 2137 }
1026    
1027 michael 2289 if (ConfigFileEntry.cycle_on_host_change)
1028     sendto_common_channels_local(target_p, 0, 0, ":%s!%s@%s QUIT :Changing hostname",
1029     target_p->name, target_p->username, target_p->host);
1030 michael 2145
1031     if (IsUserHostIp(target_p))
1032     delete_user_host(target_p->username, target_p->host, !MyConnect(target_p));
1033    
1034     strlcpy(target_p->host, hostname, sizeof(target_p->host));
1035    
1036     add_user_host(target_p->username, target_p->host, !MyConnect(target_p));
1037     SetUserHost(target_p);
1038    
1039 michael 1819 if (MyClient(target_p))
1040 michael 2137 {
1041 michael 3109 sendto_one_numeric(target_p, &me, RPL_NEWHOSTIS, target_p->host);
1042 michael 1819 clear_ban_cache_client(target_p);
1043 michael 2137 }
1044 michael 2141
1045 michael 2283 if (!ConfigFileEntry.cycle_on_host_change)
1046     return;
1047    
1048 michael 2141 DLINK_FOREACH(ptr, target_p->channel.head)
1049     {
1050 michael 2143 char modebuf[4], nickbuf[NICKLEN * 3 + 3] = { '\0' };
1051 michael 2141 char *p = modebuf;
1052     int len = 0;
1053     const struct Membership *ms = ptr->data;
1054    
1055 michael 2283 if (has_member_flags(ms, CHFL_CHANOP))
1056     {
1057 michael 2141 *p++ = 'o';
1058     len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
1059     }
1060    
1061 michael 2283 if (has_member_flags(ms, CHFL_HALFOP))
1062     {
1063 michael 2141 *p++ = 'h';
1064     len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
1065     }
1066    
1067 michael 2283 if (has_member_flags(ms, CHFL_VOICE))
1068     {
1069 michael 2141 *p++ = 'v';
1070     len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
1071     }
1072    
1073     *p = '\0';
1074    
1075     sendto_channel_local_butone(target_p, 0, 0, ms->chptr, ":%s!%s@%s JOIN :%s",
1076     target_p->name, target_p->username, target_p->host,
1077     ms->chptr->chname);
1078     if (nickbuf[0])
1079     sendto_channel_local_butone(target_p, 0, 0, ms->chptr, ":%s MODE %s +%s %s",
1080     target_p->servptr->name, ms->chptr->chname,
1081     modebuf, nickbuf);
1082    
1083     }
1084    
1085     if (target_p->away[0])
1086     sendto_common_channels_local(target_p, 0, CAP_AWAY_NOTIFY,
1087     ":%s!%s@%s AWAY :%s",
1088     target_p->name, target_p->username,
1089     target_p->host, target_p->away);
1090 michael 1819 }
1091    
1092 adx 30 /* user_welcome()
1093     *
1094     * inputs - client pointer to client to welcome
1095     * output - NONE
1096     * side effects -
1097     */
1098     static void
1099     user_welcome(struct Client *source_p)
1100     {
1101     #if defined(__TIME__) && defined(__DATE__)
1102     static const char built_date[] = __DATE__ " at " __TIME__;
1103     #else
1104     static const char built_date[] = "unknown";
1105     #endif
1106    
1107     #ifdef HAVE_LIBCRYPTO
1108 michael 2246 if (HasFlag(source_p, FLAGS_SSL))
1109     {
1110     AddUMode(source_p, UMODE_SSL);
1111 michael 3110 sendto_one_notice(source_p, &me, ":*** Connected securely via %s",
1112     ssl_get_cipher(source_p->localClient->fd.ssl));
1113 michael 2246 }
1114 adx 30 #endif
1115    
1116 michael 3109 sendto_one_numeric(source_p, &me, RPL_WELCOME, ServerInfo.network_name,
1117     source_p->name);
1118     sendto_one_numeric(source_p, &me, RPL_YOURHOST,
1119     get_listener_name(source_p->localClient->listener), ircd_version);
1120     sendto_one_numeric(source_p, &me, RPL_CREATED, built_date);
1121     sendto_one_numeric(source_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
1122 adx 30 show_isupport(source_p);
1123    
1124     if (source_p->id[0] != '\0')
1125 michael 3109 sendto_one_numeric(source_p, &me, RPL_YOURID, source_p->id);
1126 adx 30
1127     show_lusers(source_p);
1128 michael 2150 motd_signon(source_p);
1129 adx 30 }
1130    
1131     /* check_xline()
1132     *
1133     * inputs - pointer to client to test
1134     * outupt - 1 if exiting 0 if ok
1135     * side effects -
1136     */
1137     static int
1138     check_xline(struct Client *source_p)
1139     {
1140 michael 1632 struct MaskItem *conf = NULL;
1141 michael 592 const char *reason = NULL;
1142 adx 30
1143 michael 1921 if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
1144 adx 30 {
1145 michael 1632 ++conf->count;
1146 adx 30
1147 michael 1632 if (conf->reason != NULL)
1148     reason = conf->reason;
1149 adx 30 else
1150     reason = "No Reason";
1151    
1152 michael 1618 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
1153 michael 56 "X-line Rejecting [%s] [%s], user %s [%s]",
1154     source_p->info, reason,
1155     get_client_name(source_p, HIDE_IP),
1156     source_p->sockhost);
1157 adx 30
1158 michael 896 ++ServerStats.is_ref;
1159 michael 1549 exit_client(source_p, &me, "Bad user info");
1160 adx 30 return 1;
1161     }
1162    
1163     return 0;
1164     }
1165    
1166     /* oper_up()
1167     *
1168     * inputs - pointer to given client to oper
1169     * output - NONE
1170 michael 1632 * side effects - Blindly opers up given source_p, using conf info
1171 adx 30 * all checks on passwords have already been done.
1172 michael 2345 * This could also be used by rsa oper routines.
1173 adx 30 */
1174     void
1175     oper_up(struct Client *source_p)
1176     {
1177 michael 1469 const unsigned int old = source_p->umodes;
1178 michael 1644 const struct MaskItem *conf = source_p->localClient->confs.head->data;
1179 adx 30
1180 michael 56 assert(source_p->localClient->confs.head);
1181    
1182     ++Count.oper;
1183 adx 30 SetOper(source_p);
1184    
1185 michael 1632 if (conf->modes)
1186     AddUMode(source_p, conf->modes);
1187 michael 56 else if (ConfigFileEntry.oper_umodes)
1188 michael 1219 AddUMode(source_p, ConfigFileEntry.oper_umodes);
1189 adx 30
1190 michael 1219 if (!(old & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
1191 michael 882 ++Count.invisi;
1192 michael 1219 if ((old & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
1193 michael 882 --Count.invisi;
1194    
1195 adx 30 assert(dlinkFind(&oper_list, source_p) == NULL);
1196     dlinkAdd(source_p, make_dlink_node(), &oper_list);
1197    
1198 michael 1632 AddOFlag(source_p, conf->port);
1199 adx 30
1200 michael 1294 if (HasOFlag(source_p, OPER_FLAG_ADMIN))
1201 michael 1158 AddUMode(source_p, UMODE_ADMIN);
1202 adx 30
1203 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s is now an operator",
1204 michael 1458 get_oper_name(source_p));
1205 adx 30 send_umode_out(source_p, source_p, old);
1206 michael 3109 sendto_one_numeric(source_p, &me, RPL_YOUREOPER);
1207 adx 30 }
1208    
1209 michael 573 static char new_uid[TOTALSIDUID + 1]; /* allow for \0 */
1210 adx 30
1211 michael 573 int
1212     valid_sid(const char *sid)
1213     {
1214     if (strlen(sid) == IRC_MAXSID)
1215     if (IsDigit(*sid))
1216 michael 582 if (IsAlNum(*(sid + 1)) && IsAlNum(*(sid + 2)))
1217 michael 573 return 1;
1218    
1219     return 0;
1220     }
1221    
1222 adx 30 /*
1223     * init_uid()
1224 michael 2345 *
1225 adx 30 * inputs - NONE
1226     * output - NONE
1227     * side effects - new_uid is filled in with server id portion (sid)
1228     * (first 3 bytes) or defaulted to 'A'.
1229     * Rest is filled in with 'A'
1230     */
1231     void
1232     init_uid(void)
1233     {
1234 michael 1857 unsigned int i;
1235 adx 30
1236     memset(new_uid, 0, sizeof(new_uid));
1237    
1238 michael 1115 if (!EmptyString(ServerInfo.sid))
1239 michael 573 strlcpy(new_uid, ServerInfo.sid, sizeof(new_uid));
1240    
1241 michael 1115 for (i = 0; i < IRC_MAXSID; ++i)
1242 michael 2345 if (new_uid[i] == '\0')
1243 adx 30 new_uid[i] = 'A';
1244    
1245 michael 573 /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1246     memcpy(new_uid + IRC_MAXSID, "AAAAA@", IRC_MAXUID);
1247 adx 30 }
1248    
1249     /*
1250     * add_one_to_uid
1251     *
1252     * inputs - index number into new_uid
1253     * output - NONE
1254     * side effects - new_uid is incremented by one
1255     * note this is a recursive function
1256     */
1257     static void
1258     add_one_to_uid(int i)
1259     {
1260 michael 56 if (i != IRC_MAXSID) /* Not reached server SID portion yet? */
1261 adx 30 {
1262     if (new_uid[i] == 'Z')
1263     new_uid[i] = '0';
1264     else if (new_uid[i] == '9')
1265     {
1266     new_uid[i] = 'A';
1267     add_one_to_uid(i-1);
1268     }
1269 michael 573 else
1270     ++new_uid[i];
1271 adx 30 }
1272     else
1273     {
1274 michael 573 /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1275 adx 30 if (new_uid[i] == 'Z')
1276 michael 573 memcpy(new_uid + IRC_MAXSID, "AAAAAA", IRC_MAXUID);
1277 adx 30 else
1278 michael 573 ++new_uid[i];
1279 adx 30 }
1280     }
1281    
1282     /*
1283 michael 573 * uid_get
1284     *
1285     * inputs - struct Client *
1286     * output - new UID is returned to caller
1287     * side effects - new_uid is incremented by one.
1288     */
1289 michael 1080 static const char *
1290     uid_get(void)
1291 michael 573 {
1292     add_one_to_uid(TOTALSIDUID - 1); /* index from 0 */
1293     return new_uid;
1294     }
1295    
1296     /*
1297 adx 30 * init_isupport()
1298     *
1299     * input - NONE
1300     * output - NONE
1301     * side effects - Must be called before isupport is enabled
1302     */
1303     void
1304     init_isupport(void)
1305     {
1306     add_isupport("CALLERID", NULL, -1);
1307     add_isupport("CASEMAPPING", CASEMAP, -1);
1308 adx 716 add_isupport("DEAF", "D", -1);
1309 adx 30 add_isupport("KICKLEN", NULL, KICKLEN);
1310     add_isupport("MODES", NULL, MAXMODEPARAMS);
1311     #ifdef HALFOPS
1312     add_isupport("PREFIX", "(ohv)@%+", -1);
1313     add_isupport("STATUSMSG", "@%+", -1);
1314     #else
1315     add_isupport("PREFIX", "(ov)@+", -1);
1316     add_isupport("STATUSMSG", "@+", -1);
1317     #endif
1318 michael 2175 add_isupport("EXCEPTS", "e", -1);
1319     add_isupport("INVEX", "I", -1);
1320 adx 30 }
1321    
1322     /*
1323     * add_isupport()
1324     *
1325     * input - name of supported function
1326     * - options if any
1327     * - number if any
1328     * output - NONE
1329     * side effects - Each supported item must call this when activated
1330     */
1331     void
1332     add_isupport(const char *name, const char *options, int n)
1333     {
1334     dlink_node *ptr;
1335     struct Isupport *support;
1336    
1337     DLINK_FOREACH(ptr, support_list.head)
1338     {
1339     support = ptr->data;
1340     if (irccmp(support->name, name) == 0)
1341     {
1342     MyFree(support->name);
1343     MyFree(support->options);
1344     break;
1345     }
1346     }
1347    
1348     if (ptr == NULL)
1349     {
1350     support = MyMalloc(sizeof(*support));
1351     dlinkAddTail(support, &support->node, &support_list);
1352     }
1353    
1354 michael 1646 support->name = xstrdup(name);
1355 adx 30 if (options != NULL)
1356 michael 1646 support->options = xstrdup(options);
1357 adx 30 support->number = n;
1358    
1359     rebuild_isupport_message_line();
1360     }
1361    
1362     /*
1363     * delete_isupport()
1364     *
1365     * input - name of supported function
1366     * output - NONE
1367     * side effects - Each supported item must call this when deactivated
1368     */
1369     void
1370     delete_isupport(const char *name)
1371     {
1372     dlink_node *ptr;
1373     struct Isupport *support;
1374    
1375     DLINK_FOREACH(ptr, support_list.head)
1376     {
1377     support = ptr->data;
1378     if (irccmp(support->name, name) == 0)
1379     {
1380     dlinkDelete(ptr, &support_list);
1381     MyFree(support->name);
1382     MyFree(support->options);
1383     MyFree(support);
1384     break;
1385     }
1386     }
1387    
1388     rebuild_isupport_message_line();
1389     }
1390    
1391     /*
1392     * rebuild_isupport_message_line
1393     *
1394     * input - NONE
1395     * output - NONE
1396     * side effects - Destroy the isupport MessageFile lines, and rebuild.
1397     */
1398     void
1399     rebuild_isupport_message_line(void)
1400     {
1401     char isupportbuffer[IRCD_BUFSIZE];
1402     char *p = isupportbuffer;
1403 michael 2159 dlink_node *ptr = NULL, *ptr_next = NULL;
1404 adx 30 int n = 0;
1405     int tokens = 0;
1406     size_t len = 0;
1407 michael 3109 size_t reserve = strlen(me.name) + HOSTLEN + strlen(numeric_form(RPL_ISUPPORT));
1408 adx 30
1409 michael 2159 DLINK_FOREACH_SAFE(ptr, ptr_next, support_list_lines.head)
1410     {
1411     dlinkDelete(ptr, &support_list_lines);
1412     MyFree(ptr->data);
1413     free_dlink_node(ptr);
1414     }
1415 adx 30
1416     DLINK_FOREACH(ptr, support_list.head)
1417     {
1418     struct Isupport *support = ptr->data;
1419    
1420 michael 1793 p += (n = sprintf(p, "%s", support->name));
1421 adx 30 len += n;
1422    
1423     if (support->options != NULL)
1424     {
1425 michael 1793 p += (n = sprintf(p, "=%s", support->options));
1426 adx 30 len += n;
1427     }
1428    
1429     if (support->number > 0)
1430     {
1431 michael 1793 p += (n = sprintf(p, "=%d", support->number));
1432 adx 30 len += n;
1433     }
1434    
1435     *p++ = ' ';
1436     len++;
1437     *p = '\0';
1438    
1439     if (++tokens == (MAXPARA-2) || len >= (sizeof(isupportbuffer)-reserve))
1440     { /* arbritrary for now */
1441     if (*--p == ' ')
1442 michael 56 *p = '\0';
1443 adx 30
1444 michael 2159 dlinkAddTail(xstrdup(isupportbuffer), make_dlink_node(), &support_list_lines);
1445 adx 30 p = isupportbuffer;
1446     len = 0;
1447     n = tokens = 0;
1448     }
1449     }
1450    
1451     if (len != 0)
1452     {
1453     if (*--p == ' ')
1454     *p = '\0';
1455 michael 2159 dlinkAddTail(xstrdup(isupportbuffer), make_dlink_node(), &support_list_lines);
1456 adx 30 }
1457     }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision