cb21075d |
1 | // Commands.C -*- C++ -*- |
2 | // Copyright (c) 1998 Etienne BERNARD |
a6339323 |
3 | // Copyright (C) 2002,2005 Clinton Ebadi |
cb21075d |
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 | // any later version. |
9 | |
10 | // This program is distributed in the hope that it will be useful, |
11 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
13 | // GNU General Public License for more details. |
14 | |
15 | // You should have received a copy of the GNU General Public License |
16 | // along with this program; if not, write to the Free Software |
17 | // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. |
18 | |
19 | #include "Macros.H" |
20 | #include "Message.H" |
21 | #include "Commands.H" |
22 | #include "Utils.H" |
23 | |
cb21075d |
24 | |
25 | #define CHECK_CONNECTION if (!bot->serverConnection) return NotConnected |
26 | |
27 | Message |
28 | Commands::Action(Bot *bot, String channel, String message) |
29 | { |
30 | CHECK_CONNECTION; |
31 | |
32 | if (!CHANNEL(channel)) |
33 | return NotOnChannel(channel); |
34 | |
35 | if (message.length() == 0) |
36 | return InvalidParameters; |
37 | |
fd7440f1 |
38 | QUEUE->sendCTCP (channel, "ACTION", message); |
cb21075d |
39 | |
40 | return Ok; |
41 | } |
42 | |
43 | Message |
44 | Commands::AddUser(Bot *bot, String who, String maskChannel, int level, |
45 | int prot, bool aop, std::time_t expire, String password) |
46 | { |
47 | // Gah, fix this (makes bot segfault) |
48 | if (who.length() == 0 || |
49 | maskChannel.length() == 0 || |
50 | level < 0 || |
51 | level > User::FRIEND || |
52 | prot < 0 || |
53 | prot > User::NO_DEOP) |
54 | return InvalidParameters; |
55 | |
56 | String mask; |
57 | |
a6339323 |
58 | if (!Utils::wildcard_p(who)) |
cb21075d |
59 | { |
0316e2c1 |
60 | mask = bot->getUserhost("", who); |
61 | if (mask.length() == 0) |
62 | { |
63 | return NotFound(who); |
64 | } |
65 | } |
cb21075d |
66 | // Aha! This was before the brace...segfault gone |
a6339323 |
67 | mask = Utils::make_wildcard(mask); |
cb21075d |
68 | |
69 | if (bot->userList->isInUserList(mask, maskChannel)) |
0316e2c1 |
70 | { |
71 | return AlreadyInUserlist(mask, maskChannel); |
72 | } |
cb21075d |
73 | |
74 | bot->userList->addUser(mask, maskChannel, level, prot, aop, |
75 | expire, password); |
76 | bot->rehash(); |
77 | |
78 | return Ok; |
79 | } |
80 | |
81 | |
82 | Message |
83 | Commands::AddServer(Bot *bot, String servername, int port) |
84 | { |
85 | if (port <= 0) |
86 | return InvalidPort(port); |
87 | |
88 | bot->serverList->addServer(new class Server(servername, port)); |
89 | |
90 | return Ok; |
91 | } |
92 | |
93 | |
94 | Message |
95 | Commands::AddShit(Bot *bot, String mask, String maskChannel, |
96 | int level, time_t expiration, String reason) |
97 | { |
98 | if (mask.length() == 0 || maskChannel.length() == 0 || |
99 | level < 0 || level > ShitEntry::SHIT_NODEBAN) |
100 | return InvalidParameters; |
101 | |
102 | if (reason == "") |
103 | reason = "You're on my shitlist, lamer"; |
104 | |
105 | String who = mask; |
106 | |
a6339323 |
107 | if (!Utils::wildcard_p(mask)) { |
cb21075d |
108 | mask = bot->getUserhost("", who); |
109 | if (mask.length() == 0) |
110 | return NotFound(who); |
a6339323 |
111 | mask = Utils::make_wildcard(mask); |
cb21075d |
112 | if (bot->shitList->getShit(mask, maskChannel)) |
113 | return AlreadyInShitlist(mask, maskChannel); |
114 | } |
115 | |
116 | if (bot->userList->getMaxProt(mask, maskChannel) > 0) |
117 | return UserProtected(who, maskChannel); |
118 | |
119 | bot->shitList->addShit(mask, maskChannel, level, expiration, reason); |
120 | |
121 | return Ok; |
122 | } |
123 | |
124 | |
125 | Message |
126 | Commands::Ban(Bot *bot, String channel, String who) |
127 | { |
128 | CHECK_CONNECTION; |
129 | |
130 | Channel *c = CHANNEL(channel); |
131 | |
132 | if (!c) |
133 | return NotOnChannel(channel); |
134 | |
135 | if (!bot->iAmOp(channel)) |
136 | return NotChannelOp(channel); |
137 | |
138 | String dest; |
139 | |
a6339323 |
140 | if (!Utils::wildcard_p(who)) |
cb21075d |
141 | dest = bot->getUserhost(channel, who); |
142 | else |
143 | dest = who; |
144 | |
145 | if (dest.length() == 0) |
146 | return NotFound(who); |
147 | |
a6339323 |
148 | dest = Utils::make_wildcard(dest); |
cb21075d |
149 | Mask m(dest); |
150 | |
151 | for (std::list<UserListItem *>::iterator it = bot->userList->l.begin(); |
152 | it != bot->userList->l.end(); |
153 | it++) |
154 | if (m.matches((*it)->mask) && |
155 | (*it)->channelMask.matches(channel) && |
156 | (*it)->prot >= User::NO_BAN) |
157 | return UserProtected(who, channel); |
158 | |
159 | for (std::vector<BanEntry *>::iterator it = c->channelBanlist.begin(); |
160 | it != c->channelBanlist.end(); ++it) |
161 | if (m.matches((*it)->banMask) && (*it)->banMask.getMask() != m.getMask()) |
162 | QUEUE->sendChannelMode(channel, "-b", (*it)->banMask.getMask()); |
163 | |
164 | QUEUE->sendChannelMode(channel, "+b", dest); |
165 | |
166 | return Ok; |
167 | } |
168 | |
169 | Message |
170 | Commands::Cycle(Bot *bot, String channel) |
171 | { |
172 | CHECK_CONNECTION; |
173 | |
174 | if (!CHANNEL(channel)) |
175 | return NotOnChannel(channel); |
176 | |
177 | QUEUE->sendPart(channel); |
178 | QUEUE->sendJoin(channel, bot->wantedChannels[channel]->key); |
179 | |
180 | return Ok; |
181 | } |
182 | |
183 | Message |
184 | Commands::Deban(Bot *bot, String channel, String who) |
185 | { |
186 | CHECK_CONNECTION; |
187 | |
188 | Channel *c = CHANNEL(channel); |
189 | |
190 | if (!c) |
191 | return NotOnChannel(channel); |
192 | |
193 | if (!bot->iAmOp(channel)) |
194 | return NotChannelOp(channel); |
195 | |
196 | String dest; |
197 | |
a6339323 |
198 | if (!Utils::wildcard_p(who)) |
cb21075d |
199 | dest = bot->getUserhost(channel, who); |
200 | else |
201 | dest = who; |
202 | |
203 | if (dest.length() == 0) |
204 | return UserNotFound(who, channel); |
205 | |
a6339323 |
206 | dest = Utils::make_wildcard(dest); |
cb21075d |
207 | Mask m(dest); |
208 | |
209 | for (std::vector<BanEntry *>::iterator it = c->channelBanlist.begin(); |
210 | it != c->channelBanlist.end(); ++it) |
211 | if (m.matches((*it)->getMask())) { |
212 | // Let's see if the ban is in the shitlist |
213 | ShitEntry *se = bot->shitList->getShit((*it)->getMask(), channel); |
214 | if (!se || !se->isStillValid() || |
215 | se->getShitLevel() < ShitEntry::SHIT_NODEBAN) |
216 | QUEUE->sendChannelMode(channel, "-b", (*it)->getMask()); |
217 | } |
218 | |
219 | return Ok; |
220 | } |
221 | |
222 | Message |
223 | Commands::DelServer(Bot *bot, int number) |
224 | { |
225 | if (number < 0 || number >= bot->serverList->size()) |
226 | return InvalidServerNumber(number); |
227 | |
228 | bot->serverList->delServer(number); |
229 | |
230 | return Ok; |
231 | } |
232 | |
233 | Message |
234 | Commands::DelUser(Bot *bot, String who, String maskChannel) |
235 | { |
236 | if (who.length() == 0 || maskChannel.length() == 0) |
237 | return InvalidParameters; |
238 | |
239 | String dest; |
240 | |
a6339323 |
241 | if (!Utils::wildcard_p(who)) { |
cb21075d |
242 | dest = bot->getUserhost("", who); |
243 | if (dest.length() == 0) |
244 | return NotFound(who); |
a6339323 |
245 | dest = Utils::make_wildcard(who); |
cb21075d |
246 | } |
247 | |
248 | if (!bot->userList->isInUserList(dest, maskChannel)) |
249 | return NotInUserlist(who); |
250 | |
251 | bot->userList->removeUser(dest, maskChannel); |
252 | bot->rehash(); |
253 | |
254 | return Ok; |
255 | } |
256 | |
257 | Message |
258 | Commands::DelShit(Bot *bot, String who, String maskChannel) |
259 | { |
260 | if (who.length() == 0 || maskChannel.length() == 0) |
261 | return InvalidParameters; |
262 | |
263 | String dest; |
264 | |
a6339323 |
265 | if (!Utils::wildcard_p(who)) { |
cb21075d |
266 | dest = bot->getUserhost("", who); |
267 | if (dest.length() == 0) |
268 | return NotFound(who); |
a6339323 |
269 | dest = Utils::make_wildcard(who); |
cb21075d |
270 | } |
271 | |
272 | if (!bot->shitList->getShit(dest, maskChannel)) |
273 | return NotInShitlist(who); |
274 | |
275 | bot->shitList->delShit(dest, maskChannel); |
276 | |
277 | return Ok; |
278 | } |
279 | |
280 | Message |
281 | Commands::Deop(Bot *bot, String channel, String who) |
282 | { |
283 | CHECK_CONNECTION; |
284 | |
285 | Channel *c = CHANNEL(channel); |
286 | |
287 | if (!c) |
288 | return NotOnChannel(channel); |
289 | |
290 | if (!bot->iAmOp(channel)) |
291 | return NotChannelOp(channel); |
292 | |
a6339323 |
293 | if (!Utils::wildcard_p(who)) { |
cb21075d |
294 | User *u = c->getUser(who); |
295 | if (!u) |
296 | return UserNotFound(who, channel); |
297 | if (!(u->mode & User::OP_MODE)) |
298 | return UserNotOp(who, channel); |
299 | if (u->getProt() >= User::NO_DEOP) |
300 | return UserProtected(who, channel); |
301 | QUEUE->sendChannelMode(channel, "-o", who); |
302 | } else { |
303 | Mask m(who); |
304 | for (std::map<String, User *, std::less<String> >::iterator |
305 | it = c->channelMemory.begin(); |
306 | it != c->channelMemory.end(); ++it) { |
307 | if (m.matches((*it).second->nick + "!" + |
308 | (*it).second->userhost) && |
309 | (*it).second->getProt() < User::NO_DEOP && |
310 | ((*it).second->mode & User::OP_MODE)) |
311 | QUEUE->sendChannelMode(channel, "-o", (*it).second->nick); |
312 | } |
313 | } |
314 | |
315 | return Ok; |
316 | } |
317 | |
318 | Message |
319 | Commands::Die(Bot *bot, String reason) |
320 | { |
321 | CHECK_CONNECTION; |
322 | |
323 | QUEUE->sendQuit(reason); |
324 | bot->stop = true; |
325 | |
326 | return Ok; |
327 | } |
328 | |
329 | Message |
330 | Commands::Do(Bot *bot, String command) |
331 | { |
332 | CHECK_CONNECTION; |
333 | |
334 | QUEUE->addLine(command, 0, 0, ServerQueueItem::OTHER); |
335 | return Ok; |
336 | } |
337 | |
338 | Message |
339 | Commands::Invite(Bot *bot, String channel, String who) |
340 | { |
341 | CHECK_CONNECTION; |
342 | |
343 | if (!bot->iAmOp(channel)) |
344 | return NotChannelOp(channel); |
345 | |
346 | QUEUE->sendInvite(channel, who); |
347 | |
348 | return Ok; |
349 | } |
350 | |
351 | Message |
352 | Commands::Join(Bot *bot, String channel, String key) |
353 | { |
354 | CHECK_CONNECTION; |
355 | |
a6339323 |
356 | if (!Utils::valid_channel_name_p(channel)) |
cb21075d |
357 | return InvalidChannel(channel); |
358 | |
359 | // We change the key only if we are not on the channel. |
360 | // We don't trust the user... |
361 | if (!CHANNEL(channel)) { |
362 | if (bot->wantedChannels[channel]) |
363 | bot->wantedChannels[channel]->key = key; |
364 | else { |
365 | bot->wantedChannels[channel] = new wantedChannel("", "", key); |
366 | } |
367 | } |
368 | QUEUE->sendJoin(channel, bot->wantedChannels[channel]->key); |
369 | |
370 | return Ok; |
371 | } |
372 | |
373 | Message |
374 | Commands::Keep(Bot *bot, String channel, String modes) |
375 | { |
376 | CHECK_CONNECTION; |
377 | |
378 | Channel *c = CHANNEL(channel); |
379 | |
380 | if (!c) |
381 | return NotOnChannel(channel); |
382 | |
383 | c->keepModes = modes; |
384 | |
385 | return Ok; |
386 | } |
387 | |
388 | Message |
389 | Commands::Kick(Bot *bot, String channel, String who, String reason) |
390 | { |
391 | CHECK_CONNECTION; |
392 | |
393 | Channel *c = CHANNEL(channel); |
394 | |
395 | if (!c) |
396 | return NotOnChannel(channel); |
397 | |
398 | if (!bot->iAmOp(channel)) |
399 | return NotChannelOp(channel); |
400 | |
a6339323 |
401 | if (Utils::wildcard_p(who)) { |
cb21075d |
402 | Mask m(who); |
403 | for (std::map<String, User *, std::less<String> >::iterator it = |
404 | c->channelMemory.begin(); |
405 | it != c->channelMemory.end(); |
406 | ++it) |
407 | if (m.matches((*it).second->nick + "!" + |
408 | (*it).second->userhost) && |
409 | (*it).second->getProt() < User::NO_KICK) |
410 | QUEUE->sendKick(channel, (*it).second->nick, reason); |
411 | } else { |
412 | User * u = c->getUser(who); |
413 | if (!u) |
414 | return UserNotFound(who, channel); |
415 | if (u->getProt() < User::NO_KICK) |
416 | QUEUE->sendKick(channel, who, reason); |
417 | else |
418 | return UserProtected(who, channel); |
419 | } |
420 | |
421 | return Ok; |
422 | } |
423 | |
424 | Message |
425 | Commands::KickBan(Bot *bot, String channel, String who, String reason) |
426 | { |
427 | CHECK_CONNECTION; |
428 | |
429 | Message m = Commands::Ban(bot, channel, who); |
430 | |
431 | if (m.getCode() == 0) |
432 | m = Commands::Kick(bot, channel, who, reason); |
433 | |
434 | return m; |
435 | } |
436 | |
437 | Message |
438 | Commands::Lock(Bot *bot, String channel) |
439 | { |
440 | CHECK_CONNECTION; |
441 | |
442 | Channel *c = CHANNEL(channel); |
443 | |
444 | if (!c) |
445 | return NotOnChannel(channel); |
446 | |
447 | c->lockedTopic = true; |
448 | |
449 | return Ok; |
450 | } |
451 | |
452 | Message |
453 | Commands::Mode(Bot *bot, String channel, String mode) |
454 | { |
455 | CHECK_CONNECTION; |
456 | |
457 | if (!CHANNEL(channel)) |
458 | return NotOnChannel(channel); |
459 | |
460 | if (!bot->iAmOp(channel)) |
461 | return NotChannelOp(channel); |
462 | |
463 | QUEUE->sendChannelMode(String("MODE ") + channel + " " + mode); |
464 | |
465 | return Ok; |
466 | } |
467 | |
468 | Message |
469 | Commands::Msg(Bot *bot, String who, String message) |
470 | { |
471 | CHECK_CONNECTION; |
472 | |
473 | if (who == "") |
474 | return EmptyAddressee; |
475 | |
a6339323 |
476 | if (Utils::channel_p(who)) |
cb21075d |
477 | return NotToChannel; |
478 | |
479 | if (message == "") |
480 | return EmptyMessage; |
481 | |
482 | QUEUE->sendPrivmsg(who, message); |
483 | |
484 | return Ok; |
485 | } |
486 | |
487 | Message |
488 | Commands::NextServer(Bot *bot) |
489 | { |
490 | CHECK_CONNECTION; |
491 | |
492 | if (bot->serverList->size() == 0) |
493 | return EmptyServerList; |
494 | |
495 | if (!bot->canChangeServer()) |
496 | return CanNotChangeServer; |
497 | |
498 | QUEUE->sendQuit("Changing server"); |
499 | bot->nextServer(); |
500 | |
501 | return Ok; |
502 | } |
503 | |
504 | Message |
505 | Commands::Nick(Bot *bot, String nick) |
506 | { |
507 | CHECK_CONNECTION; |
508 | |
a6339323 |
509 | if (nick == "" || !Utils::valid_nickname_p(nick)) |
cb21075d |
510 | return InvalidNick(nick); |
511 | |
512 | bot->wantedNickName = nick; |
513 | QUEUE->sendNick(nick); |
514 | |
515 | return Ok; |
516 | } |
517 | |
518 | Message |
519 | Commands::Notice(Bot *bot, String who, String message) |
520 | { |
521 | CHECK_CONNECTION; |
522 | |
523 | if (who == "") |
524 | return EmptyAddressee; |
525 | |
5aec4622 |
526 | // if (Utils::channel_p(who)) |
527 | // return NotToChannel; |
cb21075d |
528 | |
529 | if (message == "") |
530 | return EmptyMessage; |
531 | |
532 | QUEUE->sendNotice(who, message); |
533 | |
534 | return Ok; |
535 | } |
536 | |
537 | Message |
538 | Commands::Op(Bot *bot, String channel, String who) |
539 | { |
540 | CHECK_CONNECTION; |
541 | |
542 | Channel *c = CHANNEL(channel); |
543 | |
544 | if (!c) |
545 | return NotOnChannel(channel); |
546 | |
547 | if (!bot->iAmOp(channel)) |
548 | return NotChannelOp(channel); |
549 | |
a6339323 |
550 | if (Utils::wildcard_p(who)) |
cb21075d |
551 | return MassOpNotAllowed; |
552 | |
553 | User *u = c->getUser(who); |
554 | if (!u) |
555 | return UserNotFound(who, channel); |
556 | |
557 | ShitEntry *se = bot->shitList->getShit(who, channel); |
558 | if (se && se->isStillValid() && se->getShitLevel() >= ShitEntry::SHIT_NOOP) |
559 | return UserOnShitList(who); |
560 | |
561 | QUEUE->sendChannelMode(channel, "+o", who); |
562 | |
563 | return Ok; |
564 | } |
565 | |
566 | |
567 | Message |
568 | Commands::Part(Bot *bot, String channel) |
569 | { |
570 | CHECK_CONNECTION; |
571 | |
572 | if (!CHANNEL(channel)) |
573 | return NotOnChannel(channel); |
574 | |
575 | wantedChannel *w = bot->wantedChannels[channel]; |
576 | bot->wantedChannels.erase(channel); |
577 | delete w; |
578 | QUEUE->sendPart(channel); |
579 | |
580 | return Ok; |
581 | } |
582 | |
583 | Message |
584 | Commands::Reconnect(Bot *bot) |
585 | { |
586 | CHECK_CONNECTION; |
587 | |
588 | if (!bot->canChangeServer()) |
589 | return CanNotChangeServer; |
590 | |
591 | QUEUE->sendQuit("Reconnecting"); |
592 | bot->reconnect(); |
593 | |
594 | return Ok; |
595 | } |
596 | |
597 | Message |
598 | Commands::Say(Bot *bot, String channel, String message) |
599 | { |
600 | CHECK_CONNECTION; |
601 | |
602 | // if (!CHANNEL(channel)) |
603 | // return NotOnChannel(channel); |
604 | |
605 | QUEUE->sendPrivmsg(channel, message); |
606 | |
607 | return Ok; |
608 | } |
609 | |
610 | |
611 | Message |
612 | Commands::Server(Bot *bot, int number) |
613 | { |
614 | CHECK_CONNECTION; |
615 | |
616 | if (number < 0 || number >= bot->serverList->size()) |
617 | return InvalidServerNumber(number); |
618 | |
619 | if (!bot->canChangeServer()) |
620 | return CanNotChangeServer; |
621 | |
622 | QUEUE->sendQuit("Changing server"); |
623 | QUEUE->flush(); |
624 | bot->connect(number); |
625 | |
626 | return Ok; |
627 | } |
628 | |
e171dcce |
629 | Message |
630 | Commands::SetFloodRate(Bot *bot, unsigned int num_messages) |
631 | { |
632 | if (num_messages > 0) |
633 | { |
634 | bot->MAX_MESSAGES = num_messages; |
635 | return Ok; |
636 | } |
637 | return InvalidParameters; |
638 | } |
639 | |
cb21075d |
640 | Message |
641 | Commands::SetVersion(Bot *bot, String str) |
642 | { |
643 | if (str.length() == 0) |
644 | return InvalidParameters; |
645 | |
646 | bot->versionString = str; |
647 | return Ok; |
648 | } |
649 | |
650 | Message |
651 | Commands::TBan(Bot *bot, String channel, String who, int seconds) |
652 | { |
653 | CHECK_CONNECTION; |
654 | |
655 | Channel *c = CHANNEL(channel); |
cf8ea873 |
656 | String dest; |
cb21075d |
657 | |
cf8ea873 |
658 | // Make sure all of the inputs are valid |
cb21075d |
659 | if (!c) |
cf8ea873 |
660 | { |
661 | return NotOnChannel(channel); |
662 | } |
cb21075d |
663 | |
664 | if (!bot->iAmOp(channel)) |
cf8ea873 |
665 | { |
666 | return NotChannelOp(channel); |
667 | } |
cb21075d |
668 | |
669 | if (seconds <= 0) |
cf8ea873 |
670 | { |
671 | return InvalidTime(seconds); |
672 | } |
cb21075d |
673 | |
cf8ea873 |
674 | // Look for user |
a6339323 |
675 | if (!Utils::wildcard_p(who)) |
cf8ea873 |
676 | { |
677 | dest = bot->getUserhost(channel, who); |
678 | } |
cb21075d |
679 | else |
cf8ea873 |
680 | { |
681 | dest = who; |
682 | } |
cb21075d |
683 | |
684 | if (dest.length() == 0) |
cf8ea873 |
685 | { |
686 | return UserNotFound(who, channel); |
687 | } |
688 | |
cb21075d |
689 | |
a6339323 |
690 | dest = Utils::make_wildcard(dest); |
cb21075d |
691 | Mask m(dest); |
692 | |
cf8ea873 |
693 | // Make sure the user isn't protected from bans |
cb21075d |
694 | for (std::list<UserListItem *>::iterator it = bot->userList->l.begin(); |
695 | it != bot->userList->l.end(); |
696 | it++) |
cf8ea873 |
697 | { |
698 | if (m.matches((*it)->mask) && |
699 | (*it)->channelMask.matches(channel) && |
700 | (*it)->prot >= User::NO_BAN) |
701 | { |
702 | return UserProtected(who, channel); |
703 | } |
704 | } |
cb21075d |
705 | |
cf8ea873 |
706 | // Clear existing bans on the user |
cb21075d |
707 | for (std::vector<BanEntry *>::iterator it = c->channelBanlist.begin(); |
708 | it != c->channelBanlist.end(); ++it) |
cf8ea873 |
709 | { |
710 | if (m.matches((*it)->banMask)) |
711 | { |
712 | QUEUE->sendChannelMode(channel, "-b", (*it)->banMask.getMask()); |
713 | } |
714 | } |
cb21075d |
715 | |
cf8ea873 |
716 | // Ban them |
cb21075d |
717 | CHANNEL(channel)->addBan(dest, seconds); |
718 | QUEUE->sendChannelMode(channel, "+b", dest); |
719 | bot->todoList->addDeban(channel, dest, seconds); |
cf8ea873 |
720 | |
721 | return Ok; |
cb21075d |
722 | } |
723 | |
724 | |
725 | Message |
726 | Commands::TKBan(Bot *bot, String channel, String who, int seconds, String reason) |
727 | { |
728 | CHECK_CONNECTION; |
729 | |
730 | Message m = Commands::TBan(bot, channel, who, seconds); |
731 | |
732 | if (m.getCode() == 0) |
733 | m = Commands::Kick(bot, channel, who, reason); |
734 | |
735 | return m; |
736 | } |
737 | |
738 | |
739 | Message |
740 | Commands::Topic(Bot *bot, String channel, String topic) |
741 | { |
742 | CHECK_CONNECTION; |
743 | |
744 | Channel *c = CHANNEL(channel); |
745 | |
746 | if (!c) |
747 | return NotOnChannel(channel); |
748 | |
749 | if (!bot->iAmOp(channel) && !(c->channelMode & Channel::TOPIC_RESTRICTED)) |
750 | return CanNotChangeTopic(channel); |
751 | |
752 | if (c->lockedTopic) |
753 | return TopicLocked(channel); |
754 | |
755 | QUEUE->sendTopic(channel, topic); |
756 | |
757 | return Ok; |
758 | } |
759 | |
760 | |
761 | Message |
762 | Commands::Unlock(Bot *bot, String channel) |
763 | { |
764 | CHECK_CONNECTION; |
765 | |
766 | Channel *c = CHANNEL(channel); |
767 | |
768 | if (!c) |
769 | return NotOnChannel(channel); |
770 | |
771 | c->lockedTopic = false; |
772 | |
773 | return Ok; |
774 | } |