ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/s_user.c
Revision: 2022
Committed: Sun May 12 18:07:07 2013 UTC (10 years, 10 months ago) by michael
Content type: text/x-csrc
File size: 39894 byte(s)
Log Message:
- Remove entering_umode and change_umode callbacks in preparation for the 
  modular usermode subsystem

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     if (valid_username(source_p->username) == 0)
394     {
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     valid_username(const char *username)
678     {
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     /* reject usernames that don't start with an alphanum
688     * i.e. reject jokers who have '-@somehost' or '.@somehost'
689     * or "-hi-@somehost", "h-----@somehost" would still be accepted.
690     */
691     if (!IsAlNum(*p))
692 michael 56 return 0;
693 adx 30
694     while (*++p)
695     {
696     if ((*p == '.') && ConfigFileEntry.dots_in_ident)
697     {
698 michael 1080 if (++dots > ConfigFileEntry.dots_in_ident)
699 michael 56 return 0;
700 michael 1080 if (!IsUserChar(*(p + 1)))
701 michael 56 return 0;
702 adx 30 }
703     else if (!IsUserChar(*p))
704 michael 56 return 0;
705 adx 30 }
706    
707 michael 56 return 1;
708 adx 30 }
709    
710 michael 1165 /* clean_nick_name()
711     *
712     * input - nickname
713     * - whether it's a local nick (1) or remote (0)
714     * output - none
715     * side effects - walks through the nickname, returning 0 if erroneous
716     */
717     int
718     valid_nickname(const char *nickname, const int local)
719     {
720     const char *p = nickname;
721     assert(nickname && *nickname);
722    
723     /* nicks can't start with a digit or - or be 0 length */
724     /* This closer duplicates behaviour of hybrid-6 */
725     if (*p == '-' || (IsDigit(*p) && local) || *p == '\0')
726     return 0;
727    
728     for (; *p; ++p)
729     if (!IsNickChar(*p))
730     return 0;
731    
732 michael 1431 return p - nickname <= NICKLEN;
733 michael 1165 }
734    
735 adx 30 /* report_and_set_user_flags()
736     *
737     * inputs - pointer to source_p
738 michael 1632 * - pointer to conf for this user
739 adx 30 * output - NONE
740     * side effects - Report to user any special flags
741     * they are getting, and set them.
742     */
743     static void
744 michael 1632 report_and_set_user_flags(struct Client *source_p, const struct MaskItem *conf)
745 adx 30 {
746     /* If this user is being spoofed, tell them so */
747 michael 1632 if (IsConfDoSpoofIp(conf))
748 adx 30 {
749     sendto_one(source_p,
750     ":%s NOTICE %s :*** Spoofing your IP. congrats.",
751     me.name, source_p->name);
752     }
753    
754     /* If this user is in the exception class, Set it "E lined" */
755 michael 1632 if (IsConfExemptKline(conf))
756 adx 30 {
757     SetExemptKline(source_p);
758     sendto_one(source_p,
759     ":%s NOTICE %s :*** You are exempt from K/D/G lines. congrats.",
760     me.name, source_p->name);
761     }
762    
763     /* The else here is to make sure that G line exempt users
764     * do not get noticed twice.
765     */
766 michael 1632 else if (IsConfExemptGline(conf))
767 adx 30 {
768     SetExemptGline(source_p);
769     sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from G lines.",
770     me.name, source_p->name);
771     }
772    
773 michael 1632 if (IsConfExemptResv(conf))
774 adx 30 {
775     SetExemptResv(source_p);
776     sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from resvs.",
777     me.name, source_p->name);
778     }
779    
780     /* If this user is exempt from user limits set it "F lined" */
781 michael 1632 if (IsConfExemptLimits(conf))
782 adx 30 {
783     SetExemptLimits(source_p);
784     sendto_one(source_p,
785     ":%s NOTICE %s :*** You are exempt from user limits. congrats.",
786     me.name,source_p->name);
787     }
788    
789 michael 1632 if (IsConfCanFlood(conf))
790 adx 30 {
791     SetCanFlood(source_p);
792     sendto_one(source_p, ":%s NOTICE %s :*** You are exempt from flood "
793     "protection, aren't you fearsome.",
794     me.name, source_p->name);
795     }
796     }
797    
798     /* set_user_mode()
799     *
800     * added 15/10/91 By Darren Reed.
801     * parv[0] - sender
802     * parv[1] - username to change mode for
803     * parv[2] - modes to change
804     */
805     void
806     set_user_mode(struct Client *client_p, struct Client *source_p,
807 michael 1857 const int parc, char *parv[])
808 adx 30 {
809     unsigned int flag, setflags;
810     char **p, *m, buf[IRCD_BUFSIZE];
811     struct Client *target_p;
812     int what = MODE_ADD, badflag = 0, i;
813 michael 56
814     assert(!(parc < 2));
815    
816 adx 30 if ((target_p = find_person(client_p, parv[1])) == NULL)
817     {
818     if (MyConnect(source_p))
819 michael 1834 sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
820 adx 30 me.name, source_p->name, parv[1]);
821     return;
822     }
823    
824 michael 1115 if (source_p != target_p)
825 adx 30 {
826 michael 1834 sendto_one(source_p, form_str(ERR_USERSDONTMATCH),
827 adx 30 me.name, source_p->name);
828     return;
829     }
830    
831     if (parc < 3)
832     {
833     m = buf;
834     *m++ = '+';
835    
836     for (i = 0; i < 128; i++)
837 michael 1219 if (HasUMode(source_p, user_modes[i]))
838 adx 30 *m++ = (char)i;
839     *m = '\0';
840    
841 michael 1834 sendto_one(source_p, form_str(RPL_UMODEIS),
842 adx 30 me.name, source_p->name, buf);
843     return;
844     }
845    
846     /* find flags already set for user */
847     setflags = source_p->umodes;
848    
849     /* parse mode change string(s) */
850     for (p = &parv[2]; p && *p; p++)
851     {
852     for (m = *p; *m; m++)
853     {
854     switch (*m)
855     {
856     case '+':
857     what = MODE_ADD;
858     break;
859     case '-':
860     what = MODE_DEL;
861     break;
862     case 'o':
863     if (what == MODE_ADD)
864     {
865 michael 1219 if (IsServer(client_p) && !HasUMode(source_p, UMODE_OPER))
866 adx 30 {
867     ++Count.oper;
868     SetOper(source_p);
869     }
870     }
871     else
872     {
873     /* Only decrement the oper counts if an oper to begin with
874     * found by Pat Szuta, Perly , perly@xnet.com
875     */
876 michael 1219 if (!HasUMode(source_p, UMODE_OPER))
877 adx 30 break;
878    
879     ClearOper(source_p);
880     Count.oper--;
881    
882     if (MyConnect(source_p))
883     {
884     dlink_node *dm;
885    
886 michael 1632 detach_conf(source_p, CONF_OPER);
887 michael 1219 ClrOFlag(source_p);
888     DelUMode(source_p, ConfigFileEntry.oper_only_umodes);
889 adx 30
890     if ((dm = dlinkFindDelete(&oper_list, source_p)) != NULL)
891     free_dlink_node(dm);
892     }
893     }
894    
895     break;
896    
897 michael 2022 /*
898     * We may not get these, but they shouldnt be in default
899 adx 30 */
900 michael 1158 case 'r':
901 adx 30 case ' ' :
902     case '\n':
903     case '\r':
904     case '\t':
905     break;
906    
907     default:
908     if ((flag = user_modes[(unsigned char)*m]))
909     {
910 michael 1219 if (MyConnect(source_p) && !HasUMode(source_p, UMODE_OPER) &&
911 adx 30 (ConfigFileEntry.oper_only_umodes & flag))
912 michael 2022 badflag = 1;
913     else
914 adx 30 {
915 michael 2022 if (what == MODE_ADD)
916     AddUMode(source_p, flag);
917     else
918     DelUMode(source_p, flag);
919 adx 30 }
920     }
921     else
922     {
923     if (MyConnect(source_p))
924     badflag = 1;
925     }
926    
927     break;
928     }
929     }
930     }
931    
932     if (badflag)
933 michael 1834 sendto_one(source_p, form_str(ERR_UMODEUNKNOWNFLAG),
934 adx 30 me.name, source_p->name);
935    
936 michael 1219 if (MyConnect(source_p) && HasUMode(source_p, UMODE_ADMIN) &&
937 michael 1294 !HasOFlag(source_p, OPER_FLAG_ADMIN))
938 adx 30 {
939     sendto_one(source_p, ":%s NOTICE %s :*** You have no admin flag;",
940     me.name, source_p->name);
941 michael 1219 DelUMode(source_p, UMODE_ADMIN);
942 adx 30 }
943    
944 michael 1219 if (!(setflags & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
945 adx 30 ++Count.invisi;
946 michael 1219 if ((setflags & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
947 adx 30 --Count.invisi;
948    
949 michael 56 /*
950     * compare new flags with old flags and send string which
951 adx 30 * will cause servers to update correctly.
952     */
953     send_umode_out(client_p, source_p, setflags);
954     }
955    
956     /* send_umode()
957     * send the MODE string for user (user) to connection client_p
958     * -avalon
959 db 849 *
960     * inputs - client_p
961     * - source_p
962     * - int old
963     * - sendmask mask of modes to send
964     * - suplied umode_buf
965     * output - NONE
966 adx 30 */
967     void
968     send_umode(struct Client *client_p, struct Client *source_p,
969     unsigned int old, unsigned int sendmask, char *umode_buf)
970     {
971 michael 1013 char *m = umode_buf;
972 adx 30 int what = 0;
973     unsigned int i;
974     unsigned int flag;
975    
976 michael 56 /*
977     * build a string in umode_buf to represent the change in the user's
978 adx 30 * mode between the new (source_p->umodes) and 'old'.
979     */
980     for (i = 0; i < 128; i++)
981     {
982     flag = user_modes[i];
983     if (!flag)
984     continue;
985    
986     if (MyClient(source_p) && !(flag & sendmask))
987     continue;
988    
989 michael 1219 if ((flag & old) && !HasUMode(source_p, flag))
990 adx 30 {
991     if (what == MODE_DEL)
992     *m++ = (char)i;
993     else
994     {
995     what = MODE_DEL;
996     *m++ = '-';
997     *m++ = (char)i;
998     }
999     }
1000 michael 1219 else if (!(flag & old) && HasUMode(source_p, flag))
1001 adx 30 {
1002     if (what == MODE_ADD)
1003     *m++ = (char)i;
1004     else
1005     {
1006     what = MODE_ADD;
1007     *m++ = '+';
1008     *m++ = (char)i;
1009     }
1010     }
1011     }
1012    
1013     *m = '\0';
1014    
1015     if (*umode_buf && client_p)
1016 michael 528 sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
1017     source_p->name, source_p->username,
1018     source_p->host, source_p->name, umode_buf);
1019 adx 30 }
1020    
1021     /* send_umode_out()
1022     *
1023     * inputs -
1024     * output - NONE
1025     * side effects - Only send ubuf out to servers that know about this client
1026     */
1027     void
1028     send_umode_out(struct Client *client_p, struct Client *source_p,
1029     unsigned int old)
1030     {
1031 michael 573 char buf[IRCD_BUFSIZE] = { '\0' };
1032 adx 30 dlink_node *ptr = NULL;
1033    
1034 michael 1294 send_umode(NULL, source_p, old, SEND_UMODES, buf);
1035 adx 30
1036 michael 573 if (buf[0])
1037 adx 30 {
1038     DLINK_FOREACH(ptr, serv_list.head)
1039     {
1040     struct Client *target_p = ptr->data;
1041    
1042     if ((target_p != client_p) && (target_p != source_p))
1043 michael 885 sendto_one(target_p, ":%s MODE %s :%s",
1044     ID_or_name(source_p, target_p),
1045     ID_or_name(source_p, target_p), buf);
1046 adx 30 }
1047     }
1048    
1049     if (client_p && MyClient(client_p))
1050     send_umode(client_p, source_p, old, 0xffffffff, buf);
1051     }
1052    
1053 michael 1819 void
1054     user_set_hostmask(struct Client *target_p, const char *hostname)
1055     {
1056     if (!valid_hostname(hostname))
1057     return;
1058    
1059     if (IsUserHostIp(target_p))
1060     delete_user_host(target_p->username, target_p->host, !MyConnect(target_p));
1061    
1062     strlcpy(target_p->host, hostname, sizeof(target_p->host));
1063     SetIPSpoof(target_p);
1064    
1065     add_user_host(target_p->username, target_p->host, !MyConnect(target_p));
1066     SetUserHost(target_p);
1067    
1068     if (MyClient(target_p))
1069     clear_ban_cache_client(target_p);
1070     }
1071    
1072 adx 30 /* user_welcome()
1073     *
1074     * inputs - client pointer to client to welcome
1075     * output - NONE
1076     * side effects -
1077     */
1078     static void
1079     user_welcome(struct Client *source_p)
1080     {
1081     #if defined(__TIME__) && defined(__DATE__)
1082     static const char built_date[] = __DATE__ " at " __TIME__;
1083     #else
1084     static const char built_date[] = "unknown";
1085     #endif
1086    
1087     #ifdef HAVE_LIBCRYPTO
1088     if (source_p->localClient->fd.ssl != NULL)
1089     sendto_one(source_p, ":%s NOTICE %s :*** Connected securely via %s",
1090     me.name, source_p->name,
1091     ssl_get_cipher(source_p->localClient->fd.ssl));
1092     #endif
1093    
1094 michael 1834 sendto_one(source_p, form_str(RPL_WELCOME), me.name, source_p->name,
1095 michael 1899 ServerInfo.network_name, source_p->name,
1096     source_p->username, source_p->host);
1097 michael 1834 sendto_one(source_p, form_str(RPL_YOURHOST), me.name, source_p->name,
1098 michael 56 get_listener_name(source_p->localClient->listener), ircd_version);
1099 michael 1834 sendto_one(source_p, form_str(RPL_CREATED),
1100 michael 56 me.name, source_p->name, built_date);
1101 michael 1834 sendto_one(source_p, form_str(RPL_MYINFO),
1102 adx 30 me.name, source_p->name, me.name, ircd_version, umode_buffer);
1103     show_isupport(source_p);
1104    
1105     if (source_p->id[0] != '\0')
1106 michael 1834 sendto_one(source_p, form_str(RPL_YOURID), me.name,
1107 adx 30 source_p->name, source_p->id);
1108    
1109     show_lusers(source_p);
1110    
1111     if (ConfigFileEntry.short_motd)
1112     {
1113 michael 1115 sendto_one(source_p, ":%s NOTICE %s :*** Notice -- motd was last changed at %s",
1114     me.name, source_p->name, ConfigFileEntry.motd.lastChangedDate);
1115 adx 30 sendto_one(source_p,
1116 michael 1115 ":%s NOTICE %s :*** Notice -- Please read the motd if you haven't "
1117     "read it", me.name, source_p->name);
1118 michael 1834 sendto_one(source_p, form_str(RPL_MOTDSTART),
1119 adx 30 me.name, source_p->name, me.name);
1120 michael 1834 sendto_one(source_p, form_str(RPL_MOTD),
1121 adx 30 me.name, source_p->name,
1122     "*** This is the short motd ***");
1123 michael 1834 sendto_one(source_p, form_str(RPL_ENDOFMOTD),
1124 adx 30 me.name, source_p->name);
1125     }
1126     else
1127     send_message_file(source_p, &ConfigFileEntry.motd);
1128     }
1129    
1130     /* check_xline()
1131     *
1132     * inputs - pointer to client to test
1133     * outupt - 1 if exiting 0 if ok
1134     * side effects -
1135     */
1136     static int
1137     check_xline(struct Client *source_p)
1138     {
1139 michael 1632 struct MaskItem *conf = NULL;
1140 michael 592 const char *reason = NULL;
1141 adx 30
1142 michael 1921 if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
1143 adx 30 {
1144 michael 1632 ++conf->count;
1145 adx 30
1146 michael 1632 if (conf->reason != NULL)
1147     reason = conf->reason;
1148 adx 30 else
1149     reason = "No Reason";
1150    
1151 michael 1618 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
1152 michael 56 "X-line Rejecting [%s] [%s], user %s [%s]",
1153     source_p->info, reason,
1154     get_client_name(source_p, HIDE_IP),
1155     source_p->sockhost);
1156 adx 30
1157 michael 896 ++ServerStats.is_ref;
1158 michael 1549 exit_client(source_p, &me, "Bad user info");
1159 adx 30 return 1;
1160     }
1161    
1162     return 0;
1163     }
1164    
1165     /* oper_up()
1166     *
1167     * inputs - pointer to given client to oper
1168     * output - NONE
1169 michael 1632 * side effects - Blindly opers up given source_p, using conf info
1170 adx 30 * all checks on passwords have already been done.
1171     * This could also be used by rsa oper routines.
1172     */
1173     void
1174     oper_up(struct Client *source_p)
1175     {
1176 michael 1469 const unsigned int old = source_p->umodes;
1177 michael 1644 const struct MaskItem *conf = source_p->localClient->confs.head->data;
1178 adx 30
1179 michael 56 assert(source_p->localClient->confs.head);
1180    
1181     ++Count.oper;
1182 adx 30 SetOper(source_p);
1183    
1184 michael 1632 if (conf->modes)
1185     AddUMode(source_p, conf->modes);
1186 michael 56 else if (ConfigFileEntry.oper_umodes)
1187 michael 1219 AddUMode(source_p, ConfigFileEntry.oper_umodes);
1188 adx 30
1189 michael 1219 if (!(old & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
1190 michael 882 ++Count.invisi;
1191 michael 1219 if ((old & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
1192 michael 882 --Count.invisi;
1193    
1194 adx 30 assert(dlinkFind(&oper_list, source_p) == NULL);
1195     dlinkAdd(source_p, make_dlink_node(), &oper_list);
1196    
1197 michael 1632 AddOFlag(source_p, conf->port);
1198 adx 30
1199 michael 1294 if (HasOFlag(source_p, OPER_FLAG_ADMIN))
1200 michael 1158 AddUMode(source_p, UMODE_ADMIN);
1201 adx 30
1202 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s is now an operator",
1203 michael 1458 get_oper_name(source_p));
1204 adx 30 send_umode_out(source_p, source_p, old);
1205 michael 1834 sendto_one(source_p, form_str(RPL_YOUREOPER), me.name, source_p->name);
1206 adx 30 }
1207    
1208 michael 573 static char new_uid[TOTALSIDUID + 1]; /* allow for \0 */
1209 adx 30
1210 michael 573 int
1211     valid_sid(const char *sid)
1212     {
1213     if (strlen(sid) == IRC_MAXSID)
1214     if (IsDigit(*sid))
1215 michael 582 if (IsAlNum(*(sid + 1)) && IsAlNum(*(sid + 2)))
1216 michael 573 return 1;
1217    
1218     return 0;
1219     }
1220    
1221 adx 30 /*
1222     * init_uid()
1223     *
1224     * inputs - NONE
1225     * output - NONE
1226     * side effects - new_uid is filled in with server id portion (sid)
1227     * (first 3 bytes) or defaulted to 'A'.
1228     * Rest is filled in with 'A'
1229     */
1230     void
1231     init_uid(void)
1232     {
1233 michael 1857 unsigned int i;
1234 adx 30
1235     memset(new_uid, 0, sizeof(new_uid));
1236    
1237 michael 1115 if (!EmptyString(ServerInfo.sid))
1238 michael 573 strlcpy(new_uid, ServerInfo.sid, sizeof(new_uid));
1239    
1240 michael 1115 for (i = 0; i < IRC_MAXSID; ++i)
1241 adx 30 if (new_uid[i] == '\0')
1242     new_uid[i] = 'A';
1243    
1244 michael 573 /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1245 adx 30 /* Yes nenolod, I have known it was off by one ever since I wrote it
1246     * But *JUST* for you, though, it really doesn't look as *pretty*
1247     * -Dianora
1248     */
1249 michael 573 memcpy(new_uid + IRC_MAXSID, "AAAAA@", IRC_MAXUID);
1250 adx 30 }
1251    
1252     /*
1253     * add_one_to_uid
1254     *
1255     * inputs - index number into new_uid
1256     * output - NONE
1257     * side effects - new_uid is incremented by one
1258     * note this is a recursive function
1259     */
1260     static void
1261     add_one_to_uid(int i)
1262     {
1263 michael 56 if (i != IRC_MAXSID) /* Not reached server SID portion yet? */
1264 adx 30 {
1265     if (new_uid[i] == 'Z')
1266     new_uid[i] = '0';
1267     else if (new_uid[i] == '9')
1268     {
1269     new_uid[i] = 'A';
1270     add_one_to_uid(i-1);
1271     }
1272 michael 573 else
1273     ++new_uid[i];
1274 adx 30 }
1275     else
1276     {
1277 michael 573 /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1278 adx 30 if (new_uid[i] == 'Z')
1279 michael 573 memcpy(new_uid + IRC_MAXSID, "AAAAAA", IRC_MAXUID);
1280 adx 30 else
1281 michael 573 ++new_uid[i];
1282 adx 30 }
1283     }
1284    
1285     /*
1286 michael 573 * uid_get
1287     *
1288     * inputs - struct Client *
1289     * output - new UID is returned to caller
1290     * side effects - new_uid is incremented by one.
1291     */
1292 michael 1080 static const char *
1293     uid_get(void)
1294 michael 573 {
1295     add_one_to_uid(TOTALSIDUID - 1); /* index from 0 */
1296     return new_uid;
1297     }
1298    
1299     /*
1300 adx 30 * init_isupport()
1301     *
1302     * input - NONE
1303     * output - NONE
1304     * side effects - Must be called before isupport is enabled
1305     */
1306     void
1307     init_isupport(void)
1308     {
1309     isupportFile = init_MessageLine();
1310    
1311     add_isupport("CALLERID", NULL, -1);
1312     add_isupport("CASEMAPPING", CASEMAP, -1);
1313 adx 716 add_isupport("DEAF", "D", -1);
1314 adx 30 add_isupport("KICKLEN", NULL, KICKLEN);
1315     add_isupport("MODES", NULL, MAXMODEPARAMS);
1316     #ifdef HALFOPS
1317     add_isupport("PREFIX", "(ohv)@%+", -1);
1318     add_isupport("STATUSMSG", "@%+", -1);
1319     #else
1320     add_isupport("PREFIX", "(ov)@+", -1);
1321     add_isupport("STATUSMSG", "@+", -1);
1322     #endif
1323     }
1324    
1325     /*
1326     * add_isupport()
1327     *
1328     * input - name of supported function
1329     * - options if any
1330     * - number if any
1331     * output - NONE
1332     * side effects - Each supported item must call this when activated
1333     */
1334     void
1335     add_isupport(const char *name, const char *options, int n)
1336     {
1337     dlink_node *ptr;
1338     struct Isupport *support;
1339    
1340     DLINK_FOREACH(ptr, support_list.head)
1341     {
1342     support = ptr->data;
1343     if (irccmp(support->name, name) == 0)
1344     {
1345     MyFree(support->name);
1346     MyFree(support->options);
1347     break;
1348     }
1349     }
1350    
1351     if (ptr == NULL)
1352     {
1353     support = MyMalloc(sizeof(*support));
1354     dlinkAddTail(support, &support->node, &support_list);
1355     }
1356    
1357 michael 1646 support->name = xstrdup(name);
1358 adx 30 if (options != NULL)
1359 michael 1646 support->options = xstrdup(options);
1360 adx 30 support->number = n;
1361    
1362     rebuild_isupport_message_line();
1363     }
1364    
1365     /*
1366     * delete_isupport()
1367     *
1368     * input - name of supported function
1369     * output - NONE
1370     * side effects - Each supported item must call this when deactivated
1371     */
1372     void
1373     delete_isupport(const char *name)
1374     {
1375     dlink_node *ptr;
1376     struct Isupport *support;
1377    
1378     DLINK_FOREACH(ptr, support_list.head)
1379     {
1380     support = ptr->data;
1381     if (irccmp(support->name, name) == 0)
1382     {
1383     dlinkDelete(ptr, &support_list);
1384     MyFree(support->name);
1385     MyFree(support->options);
1386     MyFree(support);
1387     break;
1388     }
1389     }
1390    
1391     rebuild_isupport_message_line();
1392     }
1393    
1394     /*
1395     * rebuild_isupport_message_line
1396     *
1397     * input - NONE
1398     * output - NONE
1399     * side effects - Destroy the isupport MessageFile lines, and rebuild.
1400     */
1401     void
1402     rebuild_isupport_message_line(void)
1403     {
1404     char isupportbuffer[IRCD_BUFSIZE];
1405     char *p = isupportbuffer;
1406     dlink_node *ptr = NULL;
1407     int n = 0;
1408     int tokens = 0;
1409     size_t len = 0;
1410 michael 1834 size_t reserve = strlen(me.name) + HOSTLEN + strlen(form_str(RPL_ISUPPORT));
1411 adx 30
1412     destroy_MessageLine(isupportFile);
1413    
1414     DLINK_FOREACH(ptr, support_list.head)
1415     {
1416     struct Isupport *support = ptr->data;
1417    
1418 michael 1793 p += (n = sprintf(p, "%s", support->name));
1419 adx 30 len += n;
1420    
1421     if (support->options != NULL)
1422     {
1423 michael 1793 p += (n = sprintf(p, "=%s", support->options));
1424 adx 30 len += n;
1425     }
1426    
1427     if (support->number > 0)
1428     {
1429 michael 1793 p += (n = sprintf(p, "=%d", support->number));
1430 adx 30 len += n;
1431     }
1432    
1433     *p++ = ' ';
1434     len++;
1435     *p = '\0';
1436    
1437     if (++tokens == (MAXPARA-2) || len >= (sizeof(isupportbuffer)-reserve))
1438     { /* arbritrary for now */
1439     if (*--p == ' ')
1440 michael 56 *p = '\0';
1441 adx 30
1442     addto_MessageLine(isupportFile, isupportbuffer);
1443     p = isupportbuffer;
1444     len = 0;
1445     n = tokens = 0;
1446     }
1447     }
1448    
1449     if (len != 0)
1450     {
1451     if (*--p == ' ')
1452     *p = '\0';
1453     addto_MessageLine(isupportFile, isupportbuffer);
1454     }
1455     }

Properties

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