ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/user.c
Revision: 6314
Committed: Sat Aug 1 18:06:37 2015 UTC (8 years, 7 months ago) by michael
Content type: text/x-csrc
File size: 25405 byte(s)
Log Message:
- Make use of the *Flag() macros in some more places

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 5346 * Copyright (c) 1997-2015 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 michael 4564 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19 adx 30 * USA
20     */
21    
22 michael 5564 /*! \file user.c
23 michael 2916 * \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 michael 6160 #include "id.h"
35 adx 30 #include "irc_string.h"
36     #include "ircd.h"
37     #include "listener.h"
38     #include "motd.h"
39     #include "numeric.h"
40 michael 1309 #include "conf.h"
41     #include "log.h"
42 michael 3347 #include "server.h"
43 adx 30 #include "send.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 michael 6186 #include "isupport.h"
52 adx 30
53     static char umode_buffer[IRCD_BUFSIZE];
54    
55 michael 5393 const struct user_modes *umode_map[256];
56     const struct user_modes umode_tab[] =
57 adx 30 {
58 michael 5393 { 'D', UMODE_DEAF },
59     { 'F', UMODE_FARCONNECT },
60     { 'G', UMODE_SOFTCALLERID },
61     { 'H', UMODE_HIDDEN },
62     { 'R', UMODE_REGONLY },
63     { 'S', UMODE_SSL },
64     { 'W', UMODE_WEBIRC },
65     { 'a', UMODE_ADMIN },
66     { 'b', UMODE_BOTS },
67     { 'c', UMODE_CCONN },
68     { 'd', UMODE_DEBUG },
69     { 'e', UMODE_EXTERNAL },
70     { 'f', UMODE_FULL },
71     { 'g', UMODE_CALLERID },
72     { 'i', UMODE_INVISIBLE },
73     { 'j', UMODE_REJ },
74     { 'k', UMODE_SKILL },
75     { 'l', UMODE_LOCOPS },
76     { 'n', UMODE_NCHANGE },
77     { 'o', UMODE_OPER },
78     { 'p', UMODE_HIDECHANS },
79     { 'q', UMODE_HIDEIDLE },
80     { 'r', UMODE_REGISTERED },
81     { 's', UMODE_SERVNOTICE },
82     { 'u', UMODE_UNAUTH },
83     { 'w', UMODE_WALLOP },
84     { 'x', UMODE_HIDDENHOST },
85     { 'y', UMODE_SPY },
86     { '\0', 0 }
87 adx 30 };
88    
89     void
90 michael 6190 user_modes_init(void)
91 adx 30 {
92     char *umode_buffer_ptr = umode_buffer;
93    
94 michael 5393 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
95     {
96     umode_map[tab->c] = tab;
97     *umode_buffer_ptr++ = tab->c;
98     }
99 adx 30
100     *umode_buffer_ptr = '\0';
101     }
102    
103     /* show_lusers()
104     *
105     * inputs - pointer to client
106     * output - NONE
107     * side effects - display to client user counts etc.
108     */
109     void
110 michael 2345 show_lusers(struct Client *source_p)
111 adx 30 {
112 michael 1219 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
113 michael 4723 sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
114 michael 4208 Count.invisi, dlink_list_length(&global_server_list));
115 adx 30 else
116 michael 4723 sendto_one_numeric(source_p, &me, RPL_LUSERCLIENT, (Count.total - Count.invisi),
117     Count.invisi, 1);
118 adx 30
119 michael 3375 if (Count.oper)
120 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSEROP, Count.oper);
121 adx 30
122 michael 3375 if (dlink_list_length(&unknown_list))
123 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERUNKNOWN, dlink_list_length(&unknown_list));
124 adx 30
125 michael 3945 if (dlink_list_length(&channel_list))
126     sendto_one_numeric(source_p, &me, RPL_LUSERCHANNELS, dlink_list_length(&channel_list));
127 adx 30
128 michael 1219 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
129 adx 30 {
130 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.local, Count.myserver);
131     sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.local, Count.max_loc);
132 adx 30 }
133     else
134     {
135 michael 3109 sendto_one_numeric(source_p, &me, RPL_LUSERME, Count.total, 0);
136     sendto_one_numeric(source_p, &me, RPL_LOCALUSERS, Count.total, Count.max_tot);
137 adx 30 }
138    
139 michael 3109 sendto_one_numeric(source_p, &me, RPL_GLOBALUSERS, Count.total, Count.max_tot);
140 adx 30
141 michael 1219 if (!ConfigServerHide.hide_servers || HasUMode(source_p, UMODE_OPER))
142 michael 3109 sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
143     Count.max_loc_cli, Count.totalrestartcount);
144 adx 30
145 michael 1143 if (Count.local > Count.max_loc_cli)
146     Count.max_loc_cli = Count.local;
147 adx 30
148 michael 1143 if ((Count.local + Count.myserver) > Count.max_loc_con)
149 michael 2345 Count.max_loc_con = Count.local + Count.myserver;
150 adx 30 }
151    
152 michael 3272 /* report_and_set_user_flags()
153     *
154     * inputs - pointer to source_p
155     * - pointer to conf for this user
156     * output - NONE
157     * side effects - Report to user any special flags
158     * they are getting, and set them.
159     */
160     static void
161     report_and_set_user_flags(struct Client *source_p, const struct MaskItem *conf)
162     {
163     /* If this user is being spoofed, tell them so */
164     if (IsConfDoSpoofIp(conf))
165     sendto_one_notice(source_p, &me, ":*** Spoofing your IP. Congrats.");
166    
167 michael 4855 /* If this user is in the exception class, set it "E lined" */
168 michael 3272 if (IsConfExemptKline(conf))
169     {
170 michael 6314 AddFlag(source_p, FLAGS_EXEMPTKLINE);
171 michael 5810 sendto_one_notice(source_p, &me, ":*** You are exempt from K/D lines. Congrats.");
172 michael 3272 }
173    
174 michael 5986 if (IsConfExemptXline(conf))
175     {
176 michael 6314 AddFlag(source_p, FLAGS_EXEMPTXLINE);
177 michael 5986 sendto_one_notice(source_p, &me, ":*** You are exempt from X lines. Congrats.");
178     }
179    
180 michael 3272 if (IsConfExemptResv(conf))
181     {
182 michael 6314 AddFlag(source_p, FLAGS_EXEMPTRESV);
183 michael 3272 sendto_one_notice(source_p, &me, ":*** You are exempt from resvs. Congrats.");
184     }
185    
186     /* If this user is exempt from user limits set it "F lined" */
187     if (IsConfExemptLimits(conf))
188     {
189 michael 6314 AddFlag(source_p, FLAGS_NOLIMIT);
190 michael 3272 sendto_one_notice(source_p, &me, ":*** You are exempt from user limits. Congrats.");
191     }
192    
193     if (IsConfCanFlood(conf))
194     {
195 michael 6314 AddFlag(source_p, FLAGS_CANFLOOD);
196 michael 3272 sendto_one_notice(source_p, &me, ":*** You are exempt from flood "
197     "protection, aren't you fearsome.");
198     }
199     }
200    
201     /* introduce_client()
202     *
203     * inputs - source_p
204     * output - NONE
205     * side effects - This common function introduces a client to the rest
206     * of the net, either from a local client connect or
207     * from a remote connect.
208     */
209     static void
210     introduce_client(struct Client *source_p)
211     {
212 michael 4816 dlink_node *node = NULL;
213 michael 3272 char ubuf[IRCD_BUFSIZE] = "";
214    
215     if (MyClient(source_p))
216 michael 4021 send_umode(source_p, source_p, 0, ubuf);
217 michael 3272 else
218 michael 4021 send_umode(NULL, source_p, 0, ubuf);
219 michael 3272
220     watch_check_hash(source_p, RPL_LOGON);
221    
222     if (ubuf[0] == '\0')
223     {
224     ubuf[0] = '+';
225     ubuf[1] = '\0';
226     }
227    
228 michael 4816 DLINK_FOREACH(node, local_server_list.head)
229 michael 3272 {
230 michael 4816 struct Client *server = node->data;
231 michael 3272
232     if (server == source_p->from)
233     continue;
234    
235     if (IsCapable(server, CAP_SVS))
236 michael 5785 sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s %s :%s",
237 michael 3272 source_p->servptr->id,
238     source_p->name, source_p->hopcount+1,
239     (unsigned long)source_p->tsinfo,
240     ubuf, source_p->username, source_p->host,
241 michael 4964 source_p->sockhost, source_p->id,
242 michael 4820 source_p->account,
243 michael 3272 source_p->info);
244     else
245 michael 5785 sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s :%s",
246 michael 3272 source_p->servptr->id,
247     source_p->name, source_p->hopcount+1,
248     (unsigned long)source_p->tsinfo,
249     ubuf, source_p->username, source_p->host,
250 michael 4964 source_p->sockhost, source_p->id, source_p->info);
251 michael 3272
252     if (!EmptyString(source_p->certfp))
253     sendto_one(server, ":%s CERTFP %s", source_p->id, source_p->certfp);
254     }
255     }
256    
257     /* user_welcome()
258     *
259     * inputs - client pointer to client to welcome
260     * output - NONE
261     * side effects -
262     */
263     static void
264     user_welcome(struct Client *source_p)
265     {
266     #if defined(__TIME__) && defined(__DATE__)
267     static const char built_date[] = __DATE__ " at " __TIME__;
268     #else
269     static const char built_date[] = "unknown";
270     #endif
271    
272     #ifdef HAVE_LIBCRYPTO
273     if (HasFlag(source_p, FLAGS_SSL))
274     {
275     AddUMode(source_p, UMODE_SSL);
276     sendto_one_notice(source_p, &me, ":*** Connected securely via %s",
277 michael 4589 ssl_get_cipher(source_p->connection->fd.ssl));
278 michael 3272 }
279     #endif
280    
281 michael 4341 sendto_one_numeric(source_p, &me, RPL_WELCOME, ConfigServerInfo.network_name,
282 michael 3272 source_p->name);
283     sendto_one_numeric(source_p, &me, RPL_YOURHOST,
284 michael 4589 get_listener_name(source_p->connection->listener), ircd_version);
285 michael 3272 sendto_one_numeric(source_p, &me, RPL_CREATED, built_date);
286     sendto_one_numeric(source_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
287 michael 6253
288 michael 6186 isupport_show(source_p);
289 michael 3272 show_lusers(source_p);
290     motd_signon(source_p);
291     }
292    
293     /* check_xline()
294     *
295     * inputs - pointer to client to test
296     * outupt - 1 if exiting 0 if ok
297     * side effects -
298     */
299     static int
300     check_xline(struct Client *source_p)
301     {
302     struct MaskItem *conf = NULL;
303    
304 michael 6314 if (HasFlag(source_p, FLAGS_EXEMPTXLINE))
305 michael 5986 return 0;
306    
307 michael 3272 if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
308     {
309     ++conf->count;
310     sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
311     "X-line Rejecting [%s] [%s], user %s [%s]",
312 michael 4939 source_p->info, conf->reason,
313 michael 3272 get_client_name(source_p, HIDE_IP),
314     source_p->sockhost);
315    
316     ++ServerStats.is_ref;
317     exit_client(source_p, "Bad user info");
318     return 1;
319     }
320    
321     return 0;
322     }
323    
324 michael 3317 /*! \brief This function is called when both NICK and USER messages
325 michael 3316 * have been accepted for the client, in whatever order. Only
326     * after this, is the UID message propagated.
327 michael 3317 * \param source_p Pointer to given client to introduce
328 michael 3316 */
329 adx 30 void
330 michael 1080 register_local_user(struct Client *source_p)
331 adx 30 {
332 michael 1115 const char *id = NULL;
333 michael 1632 const struct MaskItem *conf = NULL;
334 adx 30
335 michael 1080 assert(source_p == source_p->from);
336 adx 30 assert(MyConnect(source_p));
337 michael 5591 assert(IsUnknown(source_p));
338 michael 4589 assert(!source_p->connection->registration);
339 adx 30
340 michael 4341 if (ConfigGeneral.ping_cookie)
341 adx 30 {
342 michael 6314 if (!HasFlag(source_p, FLAGS_PINGSENT) && !source_p->connection->random_ping)
343 adx 30 {
344 michael 983 do
345 michael 4589 source_p->connection->random_ping = genrand_int32();
346     while (!source_p->connection->random_ping);
347 michael 983
348 michael 4723 sendto_one(source_p, "PING :%u", source_p->connection->random_ping);
349 michael 6314 AddFlag(source_p, FLAGS_PINGSENT);
350 adx 30 return;
351     }
352    
353 michael 6314 if (!HasFlag(source_p, FLAGS_PING_COOKIE))
354 adx 30 return;
355     }
356    
357 michael 4589 source_p->connection->last_privmsg = CurrentTime;
358 adx 30 /* Straight up the maximum rate of flooding... */
359 michael 4589 source_p->connection->allow_read = MAX_FLOOD_BURST;
360 adx 30
361 michael 1644 if (!check_client(source_p))
362 adx 30 return;
363    
364 michael 2314 if (!valid_hostname(source_p->host))
365 adx 30 {
366 michael 3110 sendto_one_notice(source_p, &me, ":*** Notice -- You have an illegal "
367     "character in your hostname");
368 michael 4723 strlcpy(source_p->host, source_p->sockhost, sizeof(source_p->host));
369 adx 30 }
370    
371 michael 4589 conf = source_p->connection->confs.head->data;
372 adx 30
373 michael 6314 if (!HasFlag(source_p, FLAGS_GOTID))
374 adx 30 {
375 michael 3215 char username[USERLEN + 1] = "";
376 michael 1080 const char *p = username;
377 adx 30 unsigned int i = 0;
378    
379 michael 1632 if (IsNeedIdentd(conf))
380 adx 30 {
381 michael 896 ++ServerStats.is_ref;
382 michael 3110 sendto_one_notice(source_p, &me, ":*** Notice -- You need to install "
383     "identd to use this server");
384 michael 3171 exit_client(source_p, "Install identd");
385 adx 30 return;
386     }
387    
388 michael 1080 strlcpy(username, source_p->username, sizeof(username));
389 adx 30
390 michael 1632 if (!IsNoTilde(conf))
391 adx 30 source_p->username[i++] = '~';
392    
393 michael 1080 for (; *p && i < USERLEN; ++p)
394 michael 4109 source_p->username[i++] = *p;
395 adx 30
396     source_p->username[i] = '\0';
397     }
398    
399 michael 3317 /* Password check */
400 michael 1632 if (!EmptyString(conf->passwd))
401 adx 30 {
402 michael 4589 if (!match_conf_password(source_p->connection->password, conf))
403 adx 30 {
404 michael 896 ++ServerStats.is_ref;
405 michael 3109
406     sendto_one_numeric(source_p, &me, ERR_PASSWDMISMATCH);
407 michael 3171 exit_client(source_p, "Bad Password");
408 adx 30 return;
409     }
410     }
411    
412 michael 3317 /*
413 michael 4589 * Don't free source_p->connection->password here - it can be required
414 michael 4723 * by masked /stats I if there are auth {} blocks with need_password = no;
415 adx 30 * --adx
416     */
417    
418 michael 3317 /*
419     * Report if user has &^>= etc. and set flags as needed in source_p
420     */
421 michael 1632 report_and_set_user_flags(source_p, conf);
422 adx 30
423 michael 1080 if (IsDead(source_p))
424 michael 980 return;
425    
426 michael 3317 /*
427     * Limit clients -
428 adx 30 * We want to be able to have servers and F-line clients
429     * connect, so save room for "buffer" connections.
430     * Smaller servers may want to decrease this, and it should
431     * probably be just a percentage of the MAXCLIENTS...
432     * -Taner
433     */
434 michael 5488 if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
435 michael 6314 (Count.local >= GlobalSetOptions.maxclients && !HasFlag(source_p, FLAGS_NOLIMIT)))
436 adx 30 {
437 michael 1618 sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
438 adx 30 "Too many clients, rejecting %s[%s].",
439 michael 1080 source_p->name, source_p->host);
440 michael 896 ++ServerStats.is_ref;
441 michael 3171 exit_client(source_p, "Sorry, server is full - try later");
442 adx 30 return;
443     }
444    
445 michael 2314 if (!valid_username(source_p->username, 1))
446 adx 30 {
447 michael 3375 char buf[IRCD_BUFSIZE] = "";
448 adx 30
449 michael 1618 sendto_realops_flags(UMODE_REJ, L_ALL, SEND_NOTICE,
450     "Invalid username: %s (%s@%s)",
451 michael 1080 source_p->name, source_p->username, source_p->host);
452 michael 896 ++ServerStats.is_ref;
453 michael 3375 snprintf(buf, sizeof(buf), "Invalid username [%s]", source_p->username);
454     exit_client(source_p, buf);
455 adx 30 return;
456     }
457    
458 michael 592 if (check_xline(source_p))
459 adx 30 return;
460    
461 michael 3215 while (hash_find_id((id = uid_get())))
462 michael 1115 ;
463 michael 573
464 michael 1115 strlcpy(source_p->id, id, sizeof(source_p->id));
465     hash_add_id(source_p);
466 adx 30
467 michael 1618 sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE,
468 michael 1137 "Client connecting: %s (%s@%s) [%s] {%s} [%s] <%s>",
469 michael 1080 source_p->name, source_p->username, source_p->host,
470 michael 4968 source_p->sockhost,
471 michael 4589 get_client_class(&source_p->connection->confs),
472 michael 1137 source_p->info, source_p->id);
473 adx 30
474 michael 4341 if (ConfigGeneral.invisible_on_connect)
475 michael 159 {
476 michael 1219 AddUMode(source_p, UMODE_INVISIBLE);
477 michael 980 ++Count.invisi;
478 michael 159 }
479 adx 30
480 michael 2314 if (++Count.local > Count.max_loc)
481 adx 30 {
482     Count.max_loc = Count.local;
483    
484     if (!(Count.max_loc % 10))
485 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
486 michael 4587 "New maximum local client connections: %u",
487 adx 30 Count.max_loc);
488     }
489    
490     if (++Count.total > Count.max_tot)
491     Count.max_tot = Count.total;
492 michael 948 ++Count.totalrestartcount;
493 adx 30
494 michael 1080 assert(source_p->servptr == &me);
495     SetClient(source_p);
496     dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
497 michael 4188 dlinkAdd(source_p, &source_p->node, &global_client_list);
498 michael 1080
499 michael 1125 assert(dlinkFind(&unknown_list, source_p));
500 michael 1013
501 michael 4589 dlink_move_node(&source_p->connection->lclient_node,
502 michael 1126 &unknown_list, &local_client_list);
503 adx 30
504     user_welcome(source_p);
505     add_user_host(source_p->username, source_p->host, 0);
506 michael 6314 AddFlag(source_p, FLAGS_USERHOST);
507 adx 30
508 michael 1080 introduce_client(source_p);
509 adx 30 }
510    
511     /* register_remote_user()
512     *
513 michael 1080 * inputs - source_p remote or directly connected client
514 adx 30 * - username to register as
515     * - host name to register as
516     * - server name
517     * output - NONE
518     * side effects - This function is called when a remote client
519     * is introduced by a server.
520     */
521     void
522 michael 4091 register_remote_user(struct Client *source_p)
523 adx 30 {
524 michael 4224 const struct Client *target_p = NULL;
525 adx 30
526     if ((target_p = source_p->servptr) && target_p->from != source_p->from)
527     {
528 michael 1618 sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
529 adx 30 "Bad User [%s] :%s USER %s@%s %s, != %s[%s]",
530 michael 1080 source_p->from->name, source_p->name, source_p->username,
531 adx 30 source_p->host, source_p->servptr->name,
532     target_p->name, target_p->from->name);
533 michael 3176 sendto_one(source_p->from,
534 michael 4973 ":%s KILL %s :%s (UID from wrong direction (%s != %s))",
535 michael 3186 me.id, source_p->id, me.name, source_p->servptr->name,
536 michael 3176 target_p->from->name);
537    
538 michael 1219 AddFlag(source_p, FLAGS_KILLED);
539 michael 4973 exit_client(source_p, "UID server wrong direction");
540 adx 30 return;
541     }
542    
543 michael 1167 /*
544     * If the nick has been introduced by a services server,
545     * make it a service as well.
546     */
547 michael 1219 if (HasFlag(source_p->servptr, FLAGS_SERVICE))
548     AddFlag(source_p, FLAGS_SERVICE);
549 michael 1167
550 michael 510 if (++Count.total > Count.max_tot)
551     Count.max_tot = Count.total;
552    
553 adx 30 SetClient(source_p);
554 michael 889 dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->client_list);
555 michael 4188 dlinkAdd(source_p, &source_p->node, &global_client_list);
556 adx 30 add_user_host(source_p->username, source_p->host, 1);
557 michael 6314 AddFlag(source_p, FLAGS_USERHOST);
558 adx 30
559 michael 1976 if (HasFlag(source_p->servptr, FLAGS_EOB))
560 michael 5744 sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
561     "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
562     source_p->servptr->name,
563     source_p->name, source_p->username, source_p->host,
564     source_p->sockhost, source_p->info, source_p->id);
565 michael 1976
566 michael 1080 introduce_client(source_p);
567 adx 30 }
568    
569     /* valid_hostname()
570     *
571     * Inputs - pointer to hostname
572     * Output - 1 if valid, 0 if not
573     * Side effects - check hostname for validity
574     *
575     * NOTE: this doesn't allow a hostname to begin with a dot and
576     * will not allow more dots than chars.
577     */
578     int
579     valid_hostname(const char *hostname)
580     {
581     const char *p = hostname;
582    
583 michael 3235 assert(p);
584 adx 30
585 michael 2352 if (EmptyString(p) || *p == '.' || *p == ':')
586 michael 56 return 0;
587 adx 30
588 michael 1080 for (; *p; ++p)
589 adx 30 if (!IsHostChar(*p))
590 michael 56 return 0;
591 adx 30
592 michael 1795 return p - hostname <= HOSTLEN;
593 adx 30 }
594    
595     /* valid_username()
596     *
597     * Inputs - pointer to user
598     * Output - 1 if valid, 0 if not
599     * Side effects - check username for validity
600     *
601     * Absolutely always reject any '*' '!' '?' '@' in an user name
602     * reject any odd control characters names.
603     * Allow '.' in username to allow for "first.last"
604     * style of username
605     */
606     int
607 michael 2069 valid_username(const char *username, const int local)
608 adx 30 {
609 michael 3871 unsigned int dots = 0;
610 adx 30 const char *p = username;
611    
612 michael 3235 assert(p);
613 adx 30
614 michael 1080 if (*p == '~')
615 adx 30 ++p;
616    
617 michael 2067 /*
618     * Reject usernames that don't start with an alphanum
619 adx 30 * i.e. reject jokers who have '-@somehost' or '.@somehost'
620     * or "-hi-@somehost", "h-----@somehost" would still be accepted.
621     */
622     if (!IsAlNum(*p))
623 michael 56 return 0;
624 adx 30
625 michael 2067 if (local)
626 adx 30 {
627 michael 2067 while (*++p)
628 adx 30 {
629 michael 4341 if (*p == '.' && ConfigGeneral.dots_in_ident)
630 michael 2067 {
631 michael 4341 if (++dots > ConfigGeneral.dots_in_ident)
632 michael 2067 return 0;
633     if (!IsUserChar(*(p + 1)))
634     return 0;
635     }
636     else if (!IsUserChar(*p))
637 michael 56 return 0;
638 adx 30 }
639     }
640 michael 2067 else
641     {
642     while (*++p)
643     if (!IsUserChar(*p))
644     return 0;
645     }
646 adx 30
647 michael 3657 return p - username <= USERLEN;
648 adx 30 }
649    
650 michael 1165 /* clean_nick_name()
651     *
652     * input - nickname
653     * - whether it's a local nick (1) or remote (0)
654     * output - none
655     * side effects - walks through the nickname, returning 0 if erroneous
656     */
657     int
658     valid_nickname(const char *nickname, const int local)
659     {
660     const char *p = nickname;
661 michael 3318
662 michael 4983 assert(p);
663 michael 1165
664 michael 3317 /*
665     * Nicks can't start with a digit or - or be 0 length.
666     */
667 michael 4708 if (EmptyString(p) || *p == '-' || (IsDigit(*p) && local))
668 michael 1165 return 0;
669    
670     for (; *p; ++p)
671     if (!IsNickChar(*p))
672     return 0;
673    
674 michael 1431 return p - nickname <= NICKLEN;
675 michael 1165 }
676    
677 adx 30 /* send_umode()
678     * send the MODE string for user (user) to connection client_p
679     * -avalon
680 db 849 *
681     * inputs - client_p
682     * - source_p
683     * - int old
684     * - sendmask mask of modes to send
685     * - suplied umode_buf
686     * output - NONE
687 adx 30 */
688     void
689     send_umode(struct Client *client_p, struct Client *source_p,
690 michael 4021 unsigned int old, char *umode_buf)
691 adx 30 {
692 michael 1013 char *m = umode_buf;
693 adx 30 int what = 0;
694    
695 michael 56 /*
696 michael 3317 * Build a string in umode_buf to represent the change in the user's
697 adx 30 * mode between the new (source_p->umodes) and 'old'.
698     */
699 michael 5393 for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
700 adx 30 {
701 michael 5393 if ((tab->flag & old) && !HasUMode(source_p, tab->flag))
702 adx 30 {
703     if (what == MODE_DEL)
704 michael 5393 *m++ = tab->c;
705 adx 30 else
706     {
707     what = MODE_DEL;
708     *m++ = '-';
709 michael 5393 *m++ = tab->c;
710 adx 30 }
711     }
712 michael 5393 else if (!(tab->flag & old) && HasUMode(source_p, tab->flag))
713 adx 30 {
714     if (what == MODE_ADD)
715 michael 5393 *m++ = tab->c;
716 adx 30 else
717     {
718     what = MODE_ADD;
719     *m++ = '+';
720 michael 5393 *m++ = tab->c;
721 adx 30 }
722     }
723     }
724    
725     *m = '\0';
726    
727     if (*umode_buf && client_p)
728 michael 528 sendto_one(client_p, ":%s!%s@%s MODE %s :%s",
729 michael 4705 client_p->name, client_p->username,
730     client_p->host, client_p->name, umode_buf);
731 adx 30 }
732    
733     /* send_umode_out()
734     *
735     * inputs -
736     * output - NONE
737     * side effects - Only send ubuf out to servers that know about this client
738     */
739     void
740 michael 4706 send_umode_out(struct Client *source_p, unsigned int old)
741 adx 30 {
742 michael 3215 char buf[IRCD_BUFSIZE] = "";
743 adx 30
744 michael 4706 send_umode(MyClient(source_p) ? source_p : NULL, source_p, old, buf);
745 adx 30
746 michael 573 if (buf[0])
747 michael 4963 sendto_server(source_p, 0, 0, ":%s MODE %s :%s",
748 michael 3186 source_p->id, source_p->id, buf);
749 adx 30 }
750    
751 michael 1819 void
752 michael 2137 user_set_hostmask(struct Client *target_p, const char *hostname, const int what)
753 michael 1819 {
754 michael 4816 dlink_node *node = NULL;
755 michael 2141
756 michael 2145 if (!strcmp(target_p->host, hostname))
757     return;
758 michael 2141
759 michael 2137 switch (what)
760     {
761     case MODE_ADD:
762     AddUMode(target_p, UMODE_HIDDENHOST);
763     break;
764     case MODE_DEL:
765     DelUMode(target_p, UMODE_HIDDENHOST);
766     break;
767 michael 2145 default: return;
768 michael 2137 }
769    
770 michael 4341 if (ConfigGeneral.cycle_on_host_change)
771 michael 2289 sendto_common_channels_local(target_p, 0, 0, ":%s!%s@%s QUIT :Changing hostname",
772     target_p->name, target_p->username, target_p->host);
773 michael 2145
774 michael 6314 if (HasFlag(target_p, FLAGS_USERHOST))
775 michael 2145 delete_user_host(target_p->username, target_p->host, !MyConnect(target_p));
776    
777     strlcpy(target_p->host, hostname, sizeof(target_p->host));
778    
779     add_user_host(target_p->username, target_p->host, !MyConnect(target_p));
780 michael 6314 AddFlag(target_p, FLAGS_USERHOST);
781 michael 2145
782 michael 1819 if (MyClient(target_p))
783 michael 2137 {
784 michael 4558 sendto_one_numeric(target_p, &me, RPL_VISIBLEHOST, target_p->host);
785 michael 1819 clear_ban_cache_client(target_p);
786 michael 2137 }
787 michael 2141
788 michael 4341 if (!ConfigGeneral.cycle_on_host_change)
789 michael 2283 return;
790    
791 michael 4816 DLINK_FOREACH(node, target_p->channel.head)
792 michael 2141 {
793 michael 3215 char modebuf[4], nickbuf[NICKLEN * 3 + 3] = "";
794 michael 2141 char *p = modebuf;
795     int len = 0;
796 michael 4816 const struct Membership *member = node->data;
797 michael 2141
798 michael 4816 if (has_member_flags(member, CHFL_CHANOP))
799 michael 2283 {
800 michael 2141 *p++ = 'o';
801     len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
802     }
803    
804 michael 4816 if (has_member_flags(member, CHFL_HALFOP))
805 michael 2283 {
806 michael 2141 *p++ = 'h';
807     len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
808     }
809    
810 michael 4816 if (has_member_flags(member, CHFL_VOICE))
811 michael 2283 {
812 michael 2141 *p++ = 'v';
813     len += snprintf(nickbuf + len, sizeof(nickbuf) - len, len ? " %s" : "%s", target_p->name);
814     }
815    
816     *p = '\0';
817    
818 michael 4793
819 michael 4945 sendto_channel_local_butone(target_p, CAP_EXTENDED_JOIN, 0, member->chptr, ":%s!%s@%s JOIN %s %s :%s",
820 michael 4793 target_p->name, target_p->username,
821 michael 4816 target_p->host, member->chptr->name,
822 michael 4820 (!IsDigit(target_p->account[0]) && target_p->account[0] != '*') ? target_p->account : "*",
823 michael 4793 target_p->info);
824 michael 4945 sendto_channel_local_butone(target_p, 0, CAP_EXTENDED_JOIN, member->chptr, ":%s!%s@%s JOIN :%s",
825 michael 4793 target_p->name, target_p->username,
826 michael 4816 target_p->host, member->chptr->name);
827 michael 4793
828 michael 2141 if (nickbuf[0])
829 michael 4816 sendto_channel_local_butone(target_p, 0, 0, member->chptr, ":%s MODE %s +%s %s",
830     target_p->servptr->name, member->chptr->name,
831 michael 2141 modebuf, nickbuf);
832    
833     }
834    
835     if (target_p->away[0])
836     sendto_common_channels_local(target_p, 0, CAP_AWAY_NOTIFY,
837     ":%s!%s@%s AWAY :%s",
838     target_p->name, target_p->username,
839     target_p->host, target_p->away);
840 michael 1819 }
841    
842 michael 3317 /*! \brief Blindly opers up given source_p, using conf info.
843     * All checks on passwords have already been done.
844     * \param source_p Pointer to given client to oper
845 adx 30 */
846     void
847 michael 6191 user_oper_up(struct Client *source_p)
848 adx 30 {
849 michael 1469 const unsigned int old = source_p->umodes;
850 michael 4784 const struct MaskItem *const conf = source_p->connection->confs.head->data;
851 adx 30
852 michael 56 ++Count.oper;
853 adx 30 SetOper(source_p);
854    
855 michael 1632 if (conf->modes)
856     AddUMode(source_p, conf->modes);
857 michael 4341 else if (ConfigGeneral.oper_umodes)
858     AddUMode(source_p, ConfigGeneral.oper_umodes);
859 adx 30
860 michael 1219 if (!(old & UMODE_INVISIBLE) && HasUMode(source_p, UMODE_INVISIBLE))
861 michael 882 ++Count.invisi;
862 michael 1219 if ((old & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
863 michael 882 --Count.invisi;
864    
865 adx 30 assert(dlinkFind(&oper_list, source_p) == NULL);
866     dlinkAdd(source_p, make_dlink_node(), &oper_list);
867    
868 michael 1632 AddOFlag(source_p, conf->port);
869 adx 30
870 michael 1294 if (HasOFlag(source_p, OPER_FLAG_ADMIN))
871 michael 1158 AddUMode(source_p, UMODE_ADMIN);
872 adx 30
873 michael 5559 if (!EmptyString(conf->whois))
874     {
875     client_attach_svstag(source_p, RPL_WHOISOPERATOR, "+", conf->whois);
876     sendto_server(source_p, 0, 0, ":%s SVSTAG %s %lu %u + :%s",
877     me.id, source_p->id, (unsigned long)source_p->tsinfo,
878     RPL_WHOISOPERATOR, conf->whois);
879     }
880    
881 michael 1618 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s is now an operator",
882 michael 1458 get_oper_name(source_p));
883 michael 4963 sendto_server(NULL, 0, 0, ":%s GLOBOPS :%s is now an operator",
884 michael 4441 me.id, get_oper_name(source_p));
885 michael 4706 send_umode_out(source_p, old);
886 michael 3109 sendto_one_numeric(source_p, &me, RPL_YOUREOPER);
887 adx 30 }

Properties

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