![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to irc-mode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / ircnowd / src / ngircd|
Return to irc-mode.c CVS log | Up to [local] / ircnowd / src / ngircd |
1.1 tomglok 1: /*
2: * ngIRCd -- The Next Generation IRC Daemon
3: * Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
4: *
5: * This program is free software; you can redistribute it and/or modify
6: * it under the terms of the GNU General Public License as published by
7: * the Free Software Foundation; either version 2 of the License, or
8: * (at your option) any later version.
9: * Please read the file COPYING, README and AUTHORS for more information.
10: */
11:
12: #include "portab.h"
13:
14: /**
15: * @file
16: * IRC commands for mode changes (like MODE, AWAY, etc.)
17: */
18:
19: #include <assert.h>
20: #include <stdio.h>
21: #include <stdlib.h>
22: #include <string.h>
23:
24: #include "conn.h"
25: #include "channel.h"
26: #include "irc-macros.h"
27: #include "irc-write.h"
28: #include "lists.h"
29: #include "log.h"
30: #include "parse.h"
31: #include "messages.h"
32: #include "conf.h"
33:
34: #include "irc-mode.h"
35:
36: static bool Client_Mode PARAMS((CLIENT *Client, REQUEST *Req, CLIENT *Origin,
37: CLIENT *Target));
38: static bool Channel_Mode PARAMS((CLIENT *Client, REQUEST *Req, CLIENT *Origin,
39: CHANNEL *Channel));
40:
41: static bool Add_To_List PARAMS((char what, CLIENT *Prefix, CLIENT *Client,
42: CHANNEL *Channel, const char *Pattern));
43: static bool Del_From_List PARAMS((char what, CLIENT *Prefix, CLIENT *Client,
44: CHANNEL *Channel, const char *Pattern));
45:
46: static bool Send_ListChange PARAMS((const bool IsAdd, const char ModeChar,
47: CLIENT *Prefix, CLIENT *Client,
48: CHANNEL *Channel, const char *Mask));
49:
50: /**
51: * Handler for the IRC "MODE" command.
52: *
53: * This function detects whether user or channel modes should be modified
54: * and calls the appropriate sub-functions.
55: *
56: * @param Client The client from which this command has been received.
57: * @param Req Request structure with prefix and all parameters.
58: * @return CONNECTED or DISCONNECTED.
59: */
60: GLOBAL bool
61: IRC_MODE( CLIENT *Client, REQUEST *Req )
62: {
63: CLIENT *cl, *origin;
64: CHANNEL *chan;
65:
66: assert(Client != NULL);
67: assert(Req != NULL);
68:
69: _IRC_GET_SENDER_OR_RETURN_(origin, Req, Client)
70:
71: /* Test for "fake" MODE commands injected by this local instance,
72: * for example when handling the "DefaultUserModes" settings.
73: * This doesn't harm real commands, because prefixes of regular
74: * clients are checked in Validate_Prefix() and can't be faked. */
75: if (Req->prefix && Client_Search(Req->prefix) == Client_ThisServer())
76: Client = Client_Search(Req->prefix);
77:
78: /* Channel or user mode? */
79: cl = NULL; chan = NULL;
80: if (Client_IsValidNick(Req->argv[0]))
81: cl = Client_Search(Req->argv[0]);
82: if (Channel_IsValidName(Req->argv[0]))
83: chan = Channel_Search(Req->argv[0]);
84:
85: if (cl)
86: return Client_Mode(Client, Req, origin, cl);
87: if (chan)
88: return Channel_Mode(Client, Req, origin, chan);
89:
90: /* No target found! */
91: return IRC_WriteErrClient(Client, ERR_NOSUCHNICK_MSG,
92: Client_ID(Client), Req->argv[0]);
93: } /* IRC_MODE */
94:
95: /**
96: * Check if the "mode limit" for a client has been reached.
97: *
98: * This limit doesn't apply for servers or services!
99: *
100: * @param Client The client to check.
101: * @param Count The number of modes already handled.
102: * @return true if the limit has been reached.
103: */
104: static bool
105: Mode_Limit_Reached(CLIENT *Client, int Count)
106: {
107: if (Client_Type(Client) == CLIENT_SERVER
108: || Client_Type(Client) == CLIENT_SERVICE)
109: return false;
110: if (Count < MAX_HNDL_MODES_ARG)
111: return false;
112: return true;
113: }
114:
115: /**
116: * Handle client mode requests
117: *
118: * @param Client The client from which this command has been received.
119: * @param Req Request structure with prefix and all parameters.
120: * @param Origin The originator of the MODE command (prefix).
121: * @param Target The target (client) of this MODE command.
122: * @return CONNECTED or DISCONNECTED.
123: */
124: static bool
125: Client_Mode( CLIENT *Client, REQUEST *Req, CLIENT *Origin, CLIENT *Target )
126: {
127: char the_modes[COMMAND_LEN], x[2], *mode_ptr;
128: bool ok, set;
129: bool send_RPL_HOSTHIDDEN_MSG = false;
130: int mode_arg;
131: size_t len;
132:
133: /* Is the client allowed to request or change the modes? */
134: if (Client_Type(Client) == CLIENT_USER) {
135: /* Users are only allowed to manipulate their own modes! */
136: if (Target != Client)
137: return IRC_WriteErrClient(Client,
138: ERR_USERSDONTMATCH_MSG,
139: Client_ID(Client));
140: }
141:
142: /* Mode request: let's answer it :-) */
143: if (Req->argc == 1)
144: return IRC_WriteStrClient(Origin, RPL_UMODEIS_MSG,
145: Client_ID(Target),
146: Client_Modes(Target));
147:
148: mode_arg = 1;
149: mode_ptr = Req->argv[mode_arg];
150:
151: /* Initial state: set or unset modes? */
152: if (*mode_ptr == '+') {
153: set = true;
154: strcpy(the_modes, "+");
155: } else if (*mode_ptr == '-') {
156: set = false;
157: strcpy(the_modes, "-");
158: } else
159: return IRC_WriteErrClient(Origin, ERR_UMODEUNKNOWNFLAG_MSG,
160: Client_ID(Origin));
161:
162: x[1] = '\0';
163: ok = CONNECTED;
164: while (mode_ptr) {
165: mode_ptr++;
166: if (!*mode_ptr) {
167: /* Try next argument if there's any */
168: mode_arg++;
169: if (mode_arg < Req->argc)
170: mode_ptr = Req->argv[mode_arg];
171: else
172: break;
173: }
174:
175: switch(*mode_ptr) {
176: case '+':
177: case '-':
178: if ((*mode_ptr == '+' && !set)
179: || (*mode_ptr == '-' && set)) {
180: /* Action modifier ("+"/"-") must be changed */
181: len = strlen(the_modes) - 1;
182: if (the_modes[len] == '+'
183: || the_modes[len] == '-') {
184: /* Last character in the "result
185: * string" was an "action", so just
186: * overwrite it with the new action */
187: the_modes[len] = *mode_ptr;
188: } else {
189: /* Append new modifier character to
190: * the resulting mode string */
191: x[0] = *mode_ptr;
192: strlcat(the_modes, x,
193: sizeof(the_modes));
194: }
195: if (*mode_ptr == '+')
196: set = true;
197: else
198: set = false;
199: }
200: continue;
201: }
202:
203: /* Validate modes */
204: x[0] = '\0';
205: switch (*mode_ptr) {
206: case 'b': /* Block private msgs */
207: case 'C': /* Only messages from clients sharing a channel */
208: case 'i': /* Invisible */
209: case 'I': /* Hide channel list from WHOIS */
210: case 's': /* Server messages */
211: case 'w': /* Wallops messages */
212: x[0] = *mode_ptr;
213: break;
214: case 'a': /* Away */
215: if (Client_Type(Client) == CLIENT_SERVER) {
216: x[0] = 'a';
217: Client_SetAway(Origin, DEFAULT_AWAY_MSG);
218: } else
219: ok = IRC_WriteErrClient(Origin,
220: ERR_NOPRIVILEGES_MSG,
221: Client_ID(Origin));
222: break;
223: case 'B': /* Bot */
224: if (Client_HasMode(Client, 'r'))
225: ok = IRC_WriteErrClient(Origin,
226: ERR_RESTRICTED_MSG,
227: Client_ID(Origin));
228: else
229: x[0] = 'B';
230: break;
231: case 'c': /* Receive connect notices */
232: case 'q': /* KICK-protected user */
233: case 'F': /* disable flood protection */
234: /* (only settable by IRC operators!) */
235: if (!set || Client_Type(Client) == CLIENT_SERVER
236: || Client_HasMode(Origin, 'o'))
237: x[0] = *mode_ptr;
238: else
239: ok = IRC_WriteErrClient(Origin,
240: ERR_NOPRIVILEGES_MSG,
241: Client_ID(Origin));
242: break;
243: case 'o': /* IRC operator (only unsettable!) */
244: if (!set || Client_Type(Client) == CLIENT_SERVER) {
245: x[0] = 'o';
246: } else
247: ok = IRC_WriteErrClient(Origin,
248: ERR_NOPRIVILEGES_MSG,
249: Client_ID(Origin));
250: break;
251: case 'r': /* Restricted (only settable) */
252: if (set || Client_Type(Client) == CLIENT_SERVER)
253: x[0] = 'r';
254: else
255: ok = IRC_WriteErrClient(Origin,
256: ERR_RESTRICTED_MSG,
257: Client_ID(Origin));
258: break;
259: case 'R': /* Registered (not [un]settable by clients) */
260: if (Client_Type(Client) == CLIENT_SERVER)
261: x[0] = 'R';
262: else
263: ok = IRC_WriteErrClient(Origin,
264: ERR_NICKREGISTER_MSG,
265: Client_ID(Origin));
266: break;
267: case 'x': /* Cloak hostname */
268: if (Client_HasMode(Client, 'r'))
269: ok = IRC_WriteErrClient(Origin,
270: ERR_RESTRICTED_MSG,
271: Client_ID(Origin));
272: else if (!set || Conf_CloakHostModeX[0]
273: || Client_Type(Client) == CLIENT_SERVER
274: || Client_HasMode(Origin, 'o')) {
275: x[0] = 'x';
276: send_RPL_HOSTHIDDEN_MSG = true;
277: } else
278: ok = IRC_WriteErrClient(Origin,
279: ERR_NOPRIVILEGES_MSG,
280: Client_ID(Origin));
281: break;
282: default:
283: if (Client_Type(Client) != CLIENT_SERVER) {
284: Log(LOG_DEBUG,
285: "Unknown mode \"%c%c\" from \"%s\"!?",
286: set ? '+' : '-', *mode_ptr,
287: Client_ID(Origin));
288: ok = IRC_WriteErrClient(Origin,
289: ERR_UMODEUNKNOWNFLAG2_MSG,
290: Client_ID(Origin),
291: set ? '+' : '-',
292: *mode_ptr);
293: x[0] = '\0';
294: } else {
295: Log(LOG_DEBUG,
296: "Handling unknown mode \"%c%c\" from \"%s\" for \"%s\" ...",
297: set ? '+' : '-', *mode_ptr,
298: Client_ID(Origin), Client_ID(Target));
299: x[0] = *mode_ptr;
300: }
301: }
302:
303: if (!ok)
304: break;
305:
306: /* Is there a valid mode change? */
307: if (!x[0])
308: continue;
309:
310: if (set) {
311: if (Client_ModeAdd(Target, x[0]))
312: strlcat(the_modes, x, sizeof(the_modes));
313: } else {
314: if (Client_ModeDel(Target, x[0]))
315: strlcat(the_modes, x, sizeof(the_modes));
316: }
317: }
318:
319: /* Are there changed modes? */
320: if (the_modes[1]) {
321: /* Remove needless action modifier characters */
322: len = strlen(the_modes) - 1;
323: if (the_modes[len] == '+' || the_modes[len] == '-')
324: the_modes[len] = '\0';
325:
326: if (Client_Type(Client) == CLIENT_SERVER) {
327: /* Forward modes to other servers */
328: if (Client_Conn(Target) != NONE) {
329: /* Remote server (service?) changed modes
330: * for one of our clients. Inform it! */
331: IRC_WriteStrClientPrefix(Target, Origin,
332: "MODE %s :%s",
333: Client_ID(Target),
334: the_modes);
335: }
336: IRC_WriteStrServersPrefix(Client, Origin,
337: "MODE %s :%s",
338: Client_ID(Target),
339: the_modes);
340: } else {
341: /* Send reply to client and inform other servers */
342: ok = IRC_WriteStrClientPrefix(Client, Origin,
343: "MODE %s :%s",
344: Client_ID(Target),
345: the_modes);
346: IRC_WriteStrServersPrefix(Client, Origin,
347: "MODE %s :%s",
348: Client_ID(Target),
349: the_modes);
350: }
351:
352: if (send_RPL_HOSTHIDDEN_MSG && Client_Conn(Target) > NONE) {
353: /* A new (cloaked) hostname must be announced */
354: IRC_WriteStrClientPrefix(Target, Origin,
355: RPL_HOSTHIDDEN_MSG,
356: Client_ID(Target),
357: Client_HostnameDisplayed(Target));
358:
359: }
360:
361: LogDebug("%s \"%s\": Mode change, now \"%s\".",
362: Client_TypeText(Target), Client_Mask(Target),
363: Client_Modes(Target));
364: }
365:
366: return ok;
367: } /* Client_Mode */
368:
369: /*
370: * Reply to a channel mode request.
371: *
372: * @param Origin The originator of the MODE command (prefix).
373: * @param Channel The channel of which the modes should be sent.
374: * @return CONNECTED or DISCONNECTED.
375: */
376: static bool
377: Channel_Mode_Answer_Request(CLIENT *Origin, CHANNEL *Channel)
378: {
379: char the_modes[COMMAND_LEN], the_args[COMMAND_LEN], argadd[CLIENT_PASS_LEN];
380: const char *mode_ptr;
381:
382: if (!Channel_IsMemberOf(Channel, Origin)) {
383: /* Not a member: "simple" mode reply */
384: if (!IRC_WriteStrClient(Origin, RPL_CHANNELMODEIS_MSG,
385: Client_ID(Origin), Channel_Name(Channel),
386: Channel_Modes(Channel)))
387: return DISCONNECTED;
388: } else {
389: /* The sender is a member: generate extended reply */
390: strlcpy(the_modes, Channel_Modes(Channel), sizeof(the_modes));
391: mode_ptr = the_modes;
392: the_args[0] = '\0';
393:
394: while(*mode_ptr) {
395: switch(*mode_ptr) {
396: case 'l':
397: snprintf(argadd, sizeof(argadd), " %lu",
398: Channel_MaxUsers(Channel));
399: strlcat(the_args, argadd, sizeof(the_args));
400: break;
401: case 'k':
402: strlcat(the_args, " ", sizeof(the_args));
403: strlcat(the_args, Channel_Key(Channel),
404: sizeof(the_args));
405: break;
406: }
407: mode_ptr++;
408: }
409: if (the_args[0])
410: strlcat(the_modes, the_args, sizeof(the_modes));
411:
412: if (!IRC_WriteStrClient(Origin, RPL_CHANNELMODEIS_MSG,
413: Client_ID(Origin), Channel_Name(Channel),
414: the_modes))
415: return DISCONNECTED;
416: }
417:
418: #ifndef STRICT_RFC
419: /* Channel creation time */
420: if (!IRC_WriteStrClient(Origin, RPL_CREATIONTIME_MSG,
421: Client_ID(Origin), Channel_Name(Channel),
422: Channel_CreationTime(Channel)))
423: return DISCONNECTED;
424: #endif
425: return CONNECTED;
426: }
427:
428: /**
429: * Handle channel mode and channel-user mode changes
430: *
431: * @param Client The client from which this command has been received.
432: * @param Req Request structure with prefix and all parameters.
433: * @param Origin The originator of the MODE command (prefix).
434: * @param Channel The target channel of this MODE command.
435: * @return CONNECTED or DISCONNECTED.
436: */
437: static bool
438: Channel_Mode(CLIENT *Client, REQUEST *Req, CLIENT *Origin, CHANNEL *Channel)
439: {
440: char the_modes[COMMAND_LEN], the_args[COMMAND_LEN], x[2],
441: argadd[CLIENT_PASS_LEN], *mode_ptr;
442: bool connected, set, skiponce, retval, use_servermode,
443: is_halfop, is_op, is_admin, is_owner, is_machine, is_oper;
444: int mode_arg, arg_arg, mode_arg_count = 0;
445: CLIENT *client;
446: long l;
447: size_t len;
448:
449: is_halfop = is_op = is_admin = is_owner = is_machine = is_oper = false;
450:
451: if (Channel_IsModeless(Channel))
452: return IRC_WriteErrClient(Client, ERR_NOCHANMODES_MSG,
453: Client_ID(Client), Channel_Name(Channel));
454:
455: /* Mode request: let's answer it :-) */
456: if (Req->argc <= 1)
457: return Channel_Mode_Answer_Request(Origin, Channel);
458:
459: /* Check if origin is oper and opers can use mode */
460: use_servermode = Conf_OperServerMode;
461: if(Client_HasMode(Client, 'o') && Conf_OperCanMode) {
462: is_oper = true;
463: }
464:
465: /* Check if client is a server/service */
466: if(Client_Type(Client) == CLIENT_SERVER ||
467: Client_Type(Client) == CLIENT_SERVICE) {
468: is_machine = true;
469: }
470:
471: /* Check if client is member of channel or an oper or an server/service */
472: if(!Channel_IsMemberOf(Channel, Client) && !is_oper && !is_machine)
473: return IRC_WriteErrClient(Origin, ERR_NOTONCHANNEL_MSG,
474: Client_ID(Origin),
475: Channel_Name(Channel));
476:
477: mode_arg = 1;
478: mode_ptr = Req->argv[mode_arg];
479: if (Req->argc > mode_arg + 1)
480: arg_arg = mode_arg + 1;
481: else
482: arg_arg = -1;
483:
484: /* Initial state: set or unset modes? */
485: skiponce = false;
486: switch (*mode_ptr) {
487: case '-':
488: set = false;
489: break;
490: case '+':
491: set = true;
492: break;
493: default:
494: set = true;
495: skiponce = true;
496: }
497:
498: /* Prepare reply string */
499: strcpy(the_modes, set ? "+" : "-");
500: the_args[0] = '\0';
501:
502: x[1] = '\0';
503: connected = CONNECTED;
504: while (mode_ptr) {
505: if (!skiponce)
506: mode_ptr++;
507: if (!*mode_ptr) {
508: /* Try next argument if there's any */
509: if (arg_arg < 0)
510: break;
511: if (arg_arg > mode_arg)
512: mode_arg = arg_arg;
513: else
514: mode_arg++;
515:
516: if (mode_arg >= Req->argc)
517: break;
518: mode_ptr = Req->argv[mode_arg];
519:
520: if (Req->argc > mode_arg + 1)
521: arg_arg = mode_arg + 1;
522: else
523: arg_arg = -1;
524: }
525: skiponce = false;
526:
527: switch (*mode_ptr) {
528: case '+':
529: case '-':
530: if (((*mode_ptr == '+') && !set)
531: || ((*mode_ptr == '-') && set)) {
532: /* Action modifier ("+"/"-") must be changed ... */
533: len = strlen(the_modes) - 1;
534: if (the_modes[len] == '+' || the_modes[len] == '-') {
535: /* Adjust last action modifier in result */
536: the_modes[len] = *mode_ptr;
537: } else {
538: /* Append modifier character to result string */
539: x[0] = *mode_ptr;
540: strlcat(the_modes, x, sizeof(the_modes));
541: }
542: set = *mode_ptr == '+';
543: }
544: continue;
545: }
546:
547: /* Are there arguments left? */
548: if (arg_arg >= Req->argc)
549: arg_arg = -1;
550:
551: if(!is_machine && !is_oper) {
552: if (Channel_UserHasMode(Channel, Client, 'q'))
553: is_owner = true;
554: if (Channel_UserHasMode(Channel, Client, 'a'))
555: is_admin = true;
556: if (Channel_UserHasMode(Channel, Client, 'o'))
557: is_op = true;
558: if (Channel_UserHasMode(Channel, Client, 'h'))
559: is_halfop = true;
560: }
561:
562: /* Validate modes */
563: x[0] = '\0';
564: argadd[0] = '\0';
565: client = NULL;
566: switch (*mode_ptr) {
567: /* --- Channel modes --- */
568: case 'R': /* Registered users only */
569: case 's': /* Secret channel */
570: case 'z': /* Secure connections only */
571: if(!is_oper && !is_machine && !is_owner &&
572: !is_admin && !is_op) {
573: connected = IRC_WriteErrClient(Origin,
574: ERR_CHANOPRIVSNEEDED_MSG,
575: Client_ID(Origin), Channel_Name(Channel));
576: goto chan_exit;
577: }
578: case 'i': /* Invite only */
579: case 'V': /* Invite disallow */
580: case 'M': /* Only identified nicks can write */
581: case 'm': /* Moderated */
582: case 'n': /* Only members can write */
583: case 'N': /* Can't change nick while on this channel */
584: case 'Q': /* No kicks */
585: case 't': /* Topic locked */
586: if(is_oper || is_machine || is_owner ||
587: is_admin || is_op || is_halfop)
588: x[0] = *mode_ptr;
589: else
590: connected = IRC_WriteErrClient(Origin,
591: ERR_CHANOPRIVSNEEDED_MSG,
592: Client_ID(Origin), Channel_Name(Channel));
593: break;
594: case 'k': /* Channel key */
595: if (Mode_Limit_Reached(Client, mode_arg_count++))
596: goto chan_exit;
597: if (!set) {
598: if (is_oper || is_machine || is_owner ||
599: is_admin || is_op || is_halfop) {
600: x[0] = *mode_ptr;
601: if (Channel_HasMode(Channel, 'k'))
602: strlcpy(argadd, "*", sizeof(argadd));
603: if (arg_arg > mode_arg)
604: arg_arg++;
605: } else
606: connected = IRC_WriteErrClient(Origin,
607: ERR_CHANOPRIVSNEEDED_MSG,
608: Client_ID(Origin),
609: Channel_Name(Channel));
610: break;
611: }
612: if (arg_arg > mode_arg) {
613: if (is_oper || is_machine || is_owner ||
614: is_admin || is_op || is_halfop) {
615: Channel_ModeDel(Channel, 'k');
616: Channel_SetKey(Channel,
617: Req->argv[arg_arg]);
618: strlcpy(argadd, Channel_Key(Channel),
619: sizeof(argadd));
620: x[0] = *mode_ptr;
621: } else {
622: connected = IRC_WriteErrClient(Origin,
623: ERR_CHANOPRIVSNEEDED_MSG,
624: Client_ID(Origin),
625: Channel_Name(Channel));
626: }
627: Req->argv[arg_arg][0] = '\0';
628: arg_arg++;
629: } else {
630: #ifdef STRICT_RFC
631: /* Only send error message in "strict" mode,
632: * this is how ircd2.11 and others behave ... */
633: connected = IRC_WriteErrClient(Origin,
634: ERR_NEEDMOREPARAMS_MSG,
635: Client_ID(Origin), Req->command);
636: #endif
637: goto chan_exit;
638: }
639: break;
640: case 'l': /* Member limit */
641: if (Mode_Limit_Reached(Client, mode_arg_count++))
642: goto chan_exit;
643: if (!set) {
644: if (is_oper || is_machine || is_owner ||
645: is_admin || is_op || is_halfop)
646: x[0] = *mode_ptr;
647: else
648: connected = IRC_WriteErrClient(Origin,
649: ERR_CHANOPRIVSNEEDED_MSG,
650: Client_ID(Origin),
651: Channel_Name(Channel));
652: break;
653: }
654: if (arg_arg > mode_arg) {
655: if (is_oper || is_machine || is_owner ||
656: is_admin || is_op || is_halfop) {
657: l = atol(Req->argv[arg_arg]);
658: if (l > 0 && l < 0xFFFF) {
659: Channel_ModeDel(Channel, 'l');
660: Channel_SetMaxUsers(Channel, l);
661: snprintf(argadd, sizeof(argadd),
662: "%ld", l);
663: x[0] = *mode_ptr;
664: }
665: } else {
666: connected = IRC_WriteErrClient(Origin,
667: ERR_CHANOPRIVSNEEDED_MSG,
668: Client_ID(Origin),
669: Channel_Name(Channel));
670: }
671: Req->argv[arg_arg][0] = '\0';
672: arg_arg++;
673: } else {
674: #ifdef STRICT_RFC
675: /* Only send error message in "strict" mode,
676: * this is how ircd2.11 and others behave ... */
677: connected = IRC_WriteErrClient(Origin,
678: ERR_NEEDMOREPARAMS_MSG,
679: Client_ID(Origin), Req->command);
680: #endif
681: goto chan_exit;
682: }
683: break;
684: case 'O': /* IRC operators only */
685: if (set) {
686: /* Only IRC operators are allowed to
687: * set the 'O' channel mode! */
688: if(is_oper || is_machine)
689: x[0] = 'O';
690: else
691: connected = IRC_WriteErrClient(Origin,
692: ERR_NOPRIVILEGES_MSG,
693: Client_ID(Origin));
694: } else if(is_oper || is_machine || is_owner ||
695: is_admin || is_op)
696: x[0] = 'O';
697: else
698: connected = IRC_WriteErrClient(Origin,
699: ERR_CHANOPRIVSNEEDED_MSG,
700: Client_ID(Origin),
701: Channel_Name(Channel));
702: break;
703: case 'P': /* Persistent channel */
704: if (set) {
705: /* Only IRC operators are allowed to
706: * set the 'P' channel mode! */
707: if(is_oper || is_machine)
708: x[0] = 'P';
709: else
710: connected = IRC_WriteErrClient(Origin,
711: ERR_NOPRIVILEGES_MSG,
712: Client_ID(Origin));
713: } else if(is_oper || is_machine || is_owner ||
714: is_admin || is_op)
715: x[0] = 'P';
716: else
717: connected = IRC_WriteErrClient(Origin,
718: ERR_CHANOPRIVSNEEDED_MSG,
719: Client_ID(Origin),
720: Channel_Name(Channel));
721: break;
722: /* --- Channel user modes --- */
723: case 'q': /* Owner */
724: case 'a': /* Channel admin */
725: if(!is_oper && !is_machine && !is_owner && !is_admin) {
726: connected = IRC_WriteErrClient(Origin,
727: ERR_CHANOPPRIVTOOLOW_MSG,
728: Client_ID(Origin),
729: Channel_Name(Channel));
730: goto chan_exit;
731: }
732: case 'o': /* Channel operator */
733: if(!is_oper && !is_machine && !is_owner &&
734: !is_admin && !is_op) {
735: connected = IRC_WriteErrClient(Origin,
736: ERR_CHANOPRIVSNEEDED_MSG,
737: Client_ID(Origin),
738: Channel_Name(Channel));
739: goto chan_exit;
740: }
741: case 'h': /* Half Op */
742: if(!is_oper && !is_machine && !is_owner &&
743: !is_admin && !is_op) {
744: connected = IRC_WriteErrClient(Origin,
745: ERR_CHANOPRIVSNEEDED_MSG,
746: Client_ID(Origin),
747: Channel_Name(Channel));
748: goto chan_exit;
749: }
750: case 'v': /* Voice */
751: if (arg_arg > mode_arg) {
752: if (is_oper || is_machine || is_owner ||
753: is_admin || is_op || is_halfop) {
754: client = Client_Search(Req->argv[arg_arg]);
755: if (client)
756: x[0] = *mode_ptr;
757: else
758: connected = IRC_WriteErrClient(Origin,
759: ERR_NOSUCHNICK_MSG,
760: Client_ID(Origin),
761: Req->argv[arg_arg]);
762: } else {
763: connected = IRC_WriteErrClient(Origin,
764: ERR_CHANOPRIVSNEEDED_MSG,
765: Client_ID(Origin),
766: Channel_Name(Channel));
767: }
768: Req->argv[arg_arg][0] = '\0';
769: arg_arg++;
770: } else {
771: #ifdef STRICT_RFC
772: /* Report an error to the client, when a user
773: * mode should be changed but no nickname is
774: * given. But don't do it when not in "strict"
775: * mode, because most other servers don't do
776: * it as well and some clients send "wired"
777: * MODE commands like "MODE #chan -ooo nick". */
778: connected = IRC_WriteErrClient(Origin,
779: ERR_NEEDMOREPARAMS_MSG,
780: Client_ID(Origin), Req->command);
781: #endif
782: goto chan_exit;
783: }
784: break;
785: /* --- Channel lists --- */
786: case 'I': /* Invite lists */
787: case 'b': /* Ban lists */
788: case 'e': /* Channel exception lists */
789: if (Mode_Limit_Reached(Client, mode_arg_count++))
790: goto chan_exit;
791: if (arg_arg > mode_arg) {
792: /* modify list */
793: if (is_oper || is_machine || is_owner ||
794: is_admin || is_op || is_halfop) {
795: connected = set
796: ? Add_To_List(*mode_ptr, Origin,
797: Client, Channel,
798: Req->argv[arg_arg])
799: : Del_From_List(*mode_ptr, Origin,
800: Client, Channel,
801: Req->argv[arg_arg]);
802: } else {
803: connected = IRC_WriteErrClient(Origin,
804: ERR_CHANOPRIVSNEEDED_MSG,
805: Client_ID(Origin),
806: Channel_Name(Channel));
807: }
808: Req->argv[arg_arg][0] = '\0';
809: arg_arg++;
810: } else {
811: switch (*mode_ptr) {
812: case 'I':
813: Channel_ShowInvites(Origin, Channel);
814: break;
815: case 'b':
816: Channel_ShowBans(Origin, Channel);
817: break;
818: case 'e':
819: Channel_ShowExcepts(Origin, Channel);
820: break;
821: }
822: }
823: break;
824: default:
825: if (Client_Type(Client) != CLIENT_SERVER) {
826: Log(LOG_DEBUG,
827: "Unknown mode \"%c%c\" from \"%s\" on %s!?",
828: set ? '+' : '-', *mode_ptr,
829: Client_ID(Origin), Channel_Name(Channel));
830: connected = IRC_WriteErrClient(Origin,
831: ERR_UNKNOWNMODE_MSG,
832: Client_ID(Origin), *mode_ptr,
833: Channel_Name(Channel));
834: x[0] = '\0';
835: } else {
836: Log(LOG_DEBUG,
837: "Handling unknown mode \"%c%c\" from \"%s\" on %s ...",
838: set ? '+' : '-', *mode_ptr,
839: Client_ID(Origin), Channel_Name(Channel));
840: x[0] = *mode_ptr;
841: }
842: }
843:
844: if (!connected)
845: break;
846:
847: /* Is there a valid mode change? */
848: if (!x[0])
849: continue;
850:
851: /* Validate target client */
852: if (client && (!Channel_IsMemberOf(Channel, client))) {
853: if (!IRC_WriteErrClient(Origin, ERR_USERNOTINCHANNEL_MSG,
854: Client_ID(Origin),
855: Client_ID(client),
856: Channel_Name(Channel)))
857: break;
858: continue;
859: }
860:
861: if (client) {
862: /* Channel-User-Mode */
863: retval = set
864: ? Channel_UserModeAdd(Channel, client, x[0])
865: : Channel_UserModeDel(Channel, client, x[0]);
866: if (retval) {
867: strlcat(the_args, " ", sizeof(the_args));
868: strlcat(the_args, Client_ID(client),
869: sizeof(the_args));
870: strlcat(the_modes, x, sizeof(the_modes));
871: LogDebug
872: ("User \"%s\": Mode change on %s, now \"%s\"",
873: Client_Mask(client), Channel_Name(Channel),
874: Channel_UserModes(Channel, client));
875: }
876: } else {
877: /* Channel-Mode */
878: retval = set
879: ? Channel_ModeAdd(Channel, x[0])
880: : Channel_ModeDel(Channel, x[0]);
881: if (retval) {
882: strlcat(the_modes, x, sizeof(the_modes));
883: LogDebug("Channel %s: Mode change, now \"%s\".",
884: Channel_Name(Channel),
885: Channel_Modes(Channel));
886: }
887: }
888:
889: /* Are there additional arguments to add? */
890: if (argadd[0]) {
891: strlcat(the_args, " ", sizeof(the_args));
892: strlcat(the_args, argadd, sizeof(the_args));
893: }
894: }
895:
896: chan_exit:
897: /* Are there changed modes? */
898: if (the_modes[1]) {
899: /* Clean up mode string */
900: len = strlen(the_modes) - 1;
901: if ((the_modes[len] == '+') || (the_modes[len] == '-'))
902: the_modes[len] = '\0';
903:
904: if (Client_Type(Client) == CLIENT_SERVER) {
905: /* MODE requests for local channels from other servers
906: * are definitely invalid! */
907: if (Channel_IsLocal(Channel)) {
908: Log(LOG_ALERT, "Got remote MODE command for local channel!? Ignored.");
909: return CONNECTED;
910: }
911:
912: /* Forward mode changes to channel users and all the
913: * other remote servers: */
914: IRC_WriteStrServersPrefix(Client, Origin,
915: "MODE %s %s%s", Channel_Name(Channel),
916: the_modes, the_args);
917: IRC_WriteStrChannelPrefix(Client, Channel, Origin,
918: false, "MODE %s %s%s", Channel_Name(Channel),
919: the_modes, the_args);
920: } else {
921: if (use_servermode)
922: Origin = Client_ThisServer();
923: /* Send reply to client and inform other servers and channel users */
924: connected = IRC_WriteStrClientPrefix(Client, Origin,
925: "MODE %s %s%s", Channel_Name(Channel),
926: the_modes, the_args);
927: /* Only forward requests for non-local channels */
928: if (!Channel_IsLocal(Channel))
929: IRC_WriteStrServersPrefix(Client, Origin,
930: "MODE %s %s%s", Channel_Name(Channel),
931: the_modes, the_args);
932: IRC_WriteStrChannelPrefix(Client, Channel, Origin,
933: false, "MODE %s %s%s", Channel_Name(Channel),
934: the_modes, the_args);
935: }
936: }
937:
938: return connected;
939: } /* Channel_Mode */
940:
941: /**
942: * Handler for the IRC "AWAY" command.
943: *
944: * @param Client The client from which this command has been received.
945: * @param Req Request structure with prefix and all parameters.
946: * @return CONNECTED or DISCONNECTED.
947: */
948: GLOBAL bool
949: IRC_AWAY( CLIENT *Client, REQUEST *Req )
950: {
951: assert (Client != NULL);
952: assert (Req != NULL);
953:
954: if (Req->argc == 1 && Req->argv[0][0]) {
955: Client_SetAway(Client, Req->argv[0]);
956: Client_ModeAdd(Client, 'a');
957: IRC_WriteStrServersPrefix(Client, Client, "MODE %s :+a",
958: Client_ID( Client));
959: return IRC_WriteStrClient(Client, RPL_NOWAWAY_MSG,
960: Client_ID( Client));
961: } else {
962: Client_ModeDel(Client, 'a');
963: IRC_WriteStrServersPrefix(Client, Client, "MODE %s :-a",
964: Client_ID( Client));
965: return IRC_WriteStrClient(Client, RPL_UNAWAY_MSG,
966: Client_ID( Client));
967: }
968: } /* IRC_AWAY */
969:
970: /**
971: * Add entries to channel invite, ban and exception lists.
972: *
973: * @param what Can be 'I' for invite, 'b' for ban, and 'e' for exception list.
974: * @param Prefix The originator of the command.
975: * @param Client The sender of the command.
976: * @param Channel The channel of which the list should be modified.
977: * @param Pattern The pattern to add to the list.
978: * @return CONNECTED or DISCONNECTED.
979: */
980: static bool
981: Add_To_List(char what, CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel,
982: const char *Pattern)
983: {
984: char mask[MASK_LEN];
985: struct list_head *list = NULL;
986: long int current_count;
987:
988: assert(Client != NULL);
989: assert(Channel != NULL);
990: assert(Pattern != NULL);
991: assert(what == 'I' || what == 'b' || what == 'e');
992:
993: Lists_MakeMask(Pattern, mask, sizeof(mask));
994: current_count = Lists_Count(Channel_GetListInvites(Channel))
995: + Lists_Count(Channel_GetListExcepts(Channel))
996: + Lists_Count(Channel_GetListBans(Channel));
997:
998: switch(what) {
999: case 'I':
1000: list = Channel_GetListInvites(Channel);
1001: break;
1002: case 'b':
1003: list = Channel_GetListBans(Channel);
1004: break;
1005: case 'e':
1006: list = Channel_GetListExcepts(Channel);
1007: break;
1008: }
1009:
1010: if (Lists_CheckDupeMask(list, mask))
1011: return CONNECTED;
1012: if (Client_Type(Client) == CLIENT_USER &&
1013: current_count >= MAX_HNDL_CHANNEL_LISTS)
1014: return IRC_WriteErrClient(Client, ERR_LISTFULL_MSG,
1015: Client_ID(Client),
1016: Channel_Name(Channel), mask,
1017: MAX_HNDL_CHANNEL_LISTS);
1018:
1019: switch (what) {
1020: case 'I':
1021: if (!Channel_AddInvite(Channel, mask, false, Client_ID(Client)))
1022: return CONNECTED;
1023: break;
1024: case 'b':
1025: if (!Channel_AddBan(Channel, mask, Client_ID(Client)))
1026: return CONNECTED;
1027: break;
1028: case 'e':
1029: if (!Channel_AddExcept(Channel, mask, Client_ID(Client)))
1030: return CONNECTED;
1031: break;
1032: }
1033: return Send_ListChange(true, what, Prefix, Client, Channel, mask);
1034: }
1035:
1036: /**
1037: * Delete entries from channel invite, ban and exception lists.
1038: *
1039: * @param what Can be 'I' for invite, 'b' for ban, and 'e' for exception list.
1040: * @param Prefix The originator of the command.
1041: * @param Client The sender of the command.
1042: * @param Channel The channel of which the list should be modified.
1043: * @param Pattern The pattern to add to the list.
1044: * @return CONNECTED or DISCONNECTED.
1045: */
1046: static bool
1047: Del_From_List(char what, CLIENT *Prefix, CLIENT *Client, CHANNEL *Channel,
1048: const char *Pattern)
1049: {
1050: char mask[MASK_LEN];
1051: struct list_head *list = NULL;
1052:
1053: assert(Client != NULL);
1054: assert(Channel != NULL);
1055: assert(Pattern != NULL);
1056: assert(what == 'I' || what == 'b' || what == 'e');
1057:
1058: Lists_MakeMask(Pattern, mask, sizeof(mask));
1059:
1060: switch (what) {
1061: case 'I':
1062: list = Channel_GetListInvites(Channel);
1063: break;
1064: case 'b':
1065: list = Channel_GetListBans(Channel);
1066: break;
1067: case 'e':
1068: list = Channel_GetListExcepts(Channel);
1069: break;
1070: }
1071:
1072: if (!Lists_CheckDupeMask(list, mask))
1073: return CONNECTED;
1074: Lists_Del(list, mask);
1075:
1076: return Send_ListChange(false, what, Prefix, Client, Channel, mask);
1077: }
1078:
1079: /**
1080: * Send information about changed channel invite/ban/exception lists to clients.
1081: *
1082: * @param IsAdd true if the list item has been added, false otherwise.
1083: * @param ModeChar The mode to use (e. g. 'b' or 'I')
1084: * @param Prefix The originator of the mode list change.
1085: * @param Client The sender of the command.
1086: * @param Channel The channel of which the list has been modified.
1087: * @param Mask The mask which has been added or removed.
1088: * @return CONNECTED or DISCONNECTED.
1089: */
1090: static bool
1091: Send_ListChange(const bool IsAdd, const char ModeChar, CLIENT *Prefix,
1092: CLIENT *Client, CHANNEL *Channel, const char *Mask)
1093: {
1094: bool ok = true;
1095:
1096: /* Send confirmation to the client */
1097: if (Client_Type(Client) == CLIENT_USER)
1098: ok = IRC_WriteStrClientPrefix(Client, Prefix, "MODE %s %c%c %s",
1099: Channel_Name(Channel),
1100: IsAdd ? '+' : '-',
1101: ModeChar, Mask);
1102:
1103: /* to other servers */
1104: IRC_WriteStrServersPrefix(Client, Prefix, "MODE %s %c%c %s",
1105: Channel_Name(Channel), IsAdd ? '+' : '-',
1106: ModeChar, Mask);
1107:
1108: /* and local users in channel */
1109: IRC_WriteStrChannelPrefix(Client, Channel, Prefix, false,
1110: "MODE %s %c%c %s", Channel_Name(Channel),
1111: IsAdd ? '+' : '-', ModeChar, Mask );
1112:
1113: return ok;
1114: } /* Send_ListChange */
1115:
1116: /* -eof- */