ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/user.c
Revision: 2097
Committed: Sun May 19 08:47:35 2013 UTC (10 years, 10 months ago) by michael
Content type: text/x-csrc
Original Path: ircd-hybrid/trunk/src/s_user.c
File size: 39883 byte(s)
Log Message:
- Undo -r1899 for now [Changed RPL_WELCOME to comply with rfc2812]. Looks like this
  confuses mIRC in conjunction with spoofed hosts

File Contents

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

Properties

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