ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/user.c
Revision: 3375
Committed: Wed Apr 23 16:03:50 2014 UTC (9 years, 11 months ago) by michael
Content type: text/x-csrc
Original Path: ircd-hybrid/trunk/src/user.c
File size: 33698 byte(s)
Log Message:
- Style corrections

File Contents

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

Properties

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