source: irc_commands.c @ 9595d2b

Last change on this file since 9595d2b was e1f3f94, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-07-03T17:39:37Z

Fix handling of outgoing CTCP ACTIONs.
  • Property mode set to 100644
File size: 18.0 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2010 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* IRC commands                                                         */
8
9/*
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2 of the License, or
13  (at your option) any later version.
14
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License for more details.
19
20  You should have received a copy of the GNU General Public License with
21  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
23  Suite 330, Boston, MA  02111-1307  USA
24*/
25
26#define BITLBEE_CORE
27#include "bitlbee.h"
28#include "ipc.h"
29
30static void irc_cmd_pass( irc_t *irc, char **cmd )
31{
32        if( irc->status & USTATUS_LOGGED_IN )
33        {
34                char *send_cmd[] = { "identify", cmd[1], NULL };
35               
36                /* We're already logged in, this client seems to send the PASS
37                   command last. (Possibly it won't send it at all if it turns
38                   out we don't require it, which will break this feature.)
39                   Try to identify using the given password. */
40                return root_command( irc, send_cmd );
41        }
42        /* Handling in pre-logged-in state, first see if this server is
43           password-protected: */
44        else if( global.conf->auth_pass &&
45            ( strncmp( global.conf->auth_pass, "md5:", 4 ) == 0 ?
46                md5_verify_password( cmd[1], global.conf->auth_pass + 4 ) == 0 :
47                strcmp( cmd[1], global.conf->auth_pass ) == 0 ) )
48        {
49                irc->status |= USTATUS_AUTHORIZED;
50                irc_check_login( irc );
51        }
52        else if( global.conf->auth_pass )
53        {
54                irc_send_num( irc, 464, ":Incorrect password" );
55        }
56        else
57        {
58                /* Remember the password and try to identify after USER/NICK. */
59                irc_setpass( irc, cmd[1] );
60                irc_check_login( irc );
61        }
62}
63
64static void irc_cmd_user( irc_t *irc, char **cmd )
65{
66        irc->user->user = g_strdup( cmd[1] );
67        irc->user->fullname = g_strdup( cmd[4] );
68       
69        irc_check_login( irc );
70}
71
72static void irc_cmd_nick( irc_t *irc, char **cmd )
73{
74        if( irc_user_by_name( irc, cmd[1] ) )
75        {
76                irc_send_num( irc, 433, ":This nick is already in use" );
77        }
78        else if( !nick_ok( cmd[1] ) )
79        {
80                /* [SH] Invalid characters. */
81                irc_send_num( irc, 432, ":This nick contains invalid characters" );
82        }
83        else if( irc->user->nick )
84        {
85                if( irc->status & USTATUS_IDENTIFIED )
86                {
87                        irc_setpass( irc, NULL );
88                        irc->status &= ~USTATUS_IDENTIFIED;
89                        irc_umode_set( irc, "-R", 1 );
90                        irc_usermsg( irc, "Changing nicks resets your identify status. "
91                                     "Re-identify or register a new account if you want "
92                                     "your configuration to be saved. See \x02help "
93                                     "nick_changes\x02." );
94                }
95               
96                irc_user_set_nick( irc->user, cmd[1] );
97        }
98        else
99        {
100                irc->user->nick = g_strdup( cmd[1] );
101               
102                irc_check_login( irc );
103        }
104}
105
106static void irc_cmd_quit( irc_t *irc, char **cmd )
107{
108        if( cmd[1] && *cmd[1] )
109                irc_abort( irc, 0, "Quit: %s", cmd[1] );
110        else
111                irc_abort( irc, 0, "Leaving..." );
112}
113
114static void irc_cmd_ping( irc_t *irc, char **cmd )
115{
116        irc_write( irc, ":%s PONG %s :%s", irc->root->host,
117                   irc->root->host, cmd[1]?cmd[1]:irc->root->host );
118}
119
120static void irc_cmd_pong( irc_t *irc, char **cmd )
121{
122        /* We could check the value we get back from the user, but in
123           fact we don't care, we're just happy s/he's still alive. */
124        irc->last_pong = gettime();
125        irc->pinging = 0;
126}
127
128static void irc_cmd_join( irc_t *irc, char **cmd )
129{
130        char *comma, *s = cmd[1];
131       
132        while( s )
133        {
134                irc_channel_t *ic;
135               
136                if( ( comma = strchr( s, ',' ) ) )
137                        *comma = '\0';
138               
139                if( ( ic = irc_channel_by_name( irc, s ) ) == NULL )
140                        ic = irc_channel_new( irc, s );
141               
142                if( ic == NULL )
143                {
144                        irc_send_num( irc, 479, "%s :Invalid channel name", s );
145                        goto next;
146                }
147               
148                if( ic->flags & IRC_CHANNEL_JOINED )
149                        /* Dude, you're already there...
150                           RFC doesn't have any reply for that though? */
151                        goto next;
152               
153                if( ic->f->join && !ic->f->join( ic ) )
154                        /* The story is: FALSE either means the handler
155                           showed an error message, or is doing some work
156                           before the join should be confirmed. (In the
157                           latter case, the caller should take care of that
158                           confirmation.) TRUE means all's good, let the
159                           user join the channel right away. */
160                        goto next;
161               
162                irc_channel_add_user( ic, irc->user );
163               
164next:
165                if( comma )
166                {
167                        s = comma + 1;
168                        *comma = ',';
169                }
170                else
171                        break;
172        }
173}
174
175static void irc_cmd_names( irc_t *irc, char **cmd )
176{
177        irc_channel_t *ic;
178       
179        if( cmd[1] && ( ic = irc_channel_by_name( irc, cmd[1] ) ) )
180                irc_send_names( ic );
181        /* With no args, we should show /names of all chans. Make the code
182           below work well if necessary.
183        else
184        {
185                GSList *l;
186               
187                for( l = irc->channels; l; l = l->next )
188                        irc_send_names( l->data );
189        }
190        */
191}
192
193static void irc_cmd_part( irc_t *irc, char **cmd )
194{
195        irc_channel_t *ic;
196       
197        if( ( ic = irc_channel_by_name( irc, cmd[1] ) ) == NULL )
198        {
199                irc_send_num( irc, 403, "%s :No such channel", cmd[1] );
200        }
201        else if( irc_channel_del_user( ic, irc->user, FALSE, cmd[2] ) )
202        {
203                if( ic->f->part )
204                        ic->f->part( ic, NULL );
205        }
206        else
207        {
208                irc_send_num( irc, 442, "%s :You're not on that channel", cmd[1] );
209        }
210}
211
212static void irc_cmd_whois( irc_t *irc, char **cmd )
213{
214        char *nick = cmd[1];
215        irc_user_t *iu = irc_user_by_name( irc, nick );
216       
217        if( iu )
218                irc_send_whois( iu );
219        else
220                irc_send_num( irc, 401, "%s :Nick does not exist", nick );
221}
222
223static void irc_cmd_whowas( irc_t *irc, char **cmd )
224{
225        /* For some reason irssi tries a whowas when whois fails. We can
226           ignore this, but then the user never gets a "user not found"
227           message from irssi which is a bit annoying. So just respond
228           with not-found and irssi users will get better error messages */
229       
230        irc_send_num( irc, 406, "%s :Nick does not exist", cmd[1] );
231        irc_send_num( irc, 369, "%s :End of WHOWAS", cmd[1] );
232}
233
234static void irc_cmd_motd( irc_t *irc, char **cmd )
235{
236        irc_send_motd( irc );
237}
238
239static void irc_cmd_mode( irc_t *irc, char **cmd )
240{
241        if( irc_channel_name_ok( cmd[1] ) )
242        {
243                irc_channel_t *ic;
244               
245                if( ( ic = irc_channel_by_name( irc, cmd[1] ) ) == NULL )
246                        irc_send_num( irc, 403, "%s :No such channel", cmd[1] );
247                else if( cmd[2] )
248                {
249                        if( *cmd[2] == '+' || *cmd[2] == '-' )
250                                irc_send_num( irc, 477, "%s :Can't change channel modes", cmd[1] );
251                        else if( *cmd[2] == 'b' )
252                                irc_send_num( irc, 368, "%s :No bans possible", cmd[1] );
253                }
254                else
255                        irc_send_num( irc, 324, "%s +%s", cmd[1], ic->mode );
256        }
257        else
258        {
259                if( nick_cmp( cmd[1], irc->user->nick ) == 0 )
260                {
261                        if( cmd[2] )
262                                irc_umode_set( irc, cmd[2], 0 );
263                        else
264                                irc_send_num( irc, 221, "+%s", irc->umode );
265                }
266                else
267                        irc_send_num( irc, 502, ":Don't touch their modes" );
268        }
269}
270
271static void irc_cmd_who( irc_t *irc, char **cmd )
272{
273        char *channel = cmd[1];
274        irc_channel_t *ic;
275       
276        if( !channel || *channel == '0' || *channel == '*' || !*channel )
277                irc_send_who( irc, irc->users, "**" );
278        else if( ( ic = irc_channel_by_name( irc, channel ) ) )
279                irc_send_who( irc, ic->users, channel );
280        else
281                irc_send_num( irc, 403, "%s :No such channel", channel );
282}
283
284static void irc_cmd_privmsg( irc_t *irc, char **cmd )
285{
286        irc_channel_t *ic;
287        irc_user_t *iu;
288       
289        if( !cmd[2] ) 
290        {
291                irc_send_num( irc, 412, ":No text to send" );
292                return;
293        }
294       
295        /* Don't treat CTCP actions as real CTCPs, just convert them right now. */
296        if( g_strncasecmp( cmd[2], "\001ACTION", 7 ) == 0 )
297        {
298                cmd[2] += 4;
299                memcpy( cmd[2], "/me", 3 );
300                if( cmd[2][strlen(cmd[2])-1] == '\001' )
301                        cmd[2][strlen(cmd[2])-1] = '\0';
302        }
303       
304        if( irc_channel_name_ok( cmd[1] ) &&
305            ( ic = irc_channel_by_name( irc, cmd[1] ) ) )
306        {
307                if( ic->f->privmsg )
308                        ic->f->privmsg( ic, cmd[2] );
309        }
310        else if( ( iu = irc_user_by_name( irc, cmd[1] ) ) )
311        {
312                if( cmd[2][0] == '\001' )
313                {
314                        char **ctcp;
315                       
316                        if( iu->f->ctcp == NULL )
317                                return;
318                        if( cmd[2][strlen(cmd[2])-1] == '\001' )
319                                cmd[2][strlen(cmd[2])-1] = '\0';
320                       
321                        ctcp = split_command_parts( cmd[2] + 1 );
322                        iu->f->ctcp( iu, ctcp );
323                }
324                else if( iu->f->privmsg )
325                {
326                        iu->last_channel = NULL;
327                        iu->f->privmsg( iu, cmd[2] );
328                }
329        }
330        else
331        {
332                irc_send_num( irc, 401, "%s :No such nick/channel", cmd[1] );
333        }
334}
335
336static void irc_cmd_notice( irc_t *irc, char **cmd )
337{
338        if( !cmd[2] ) 
339        {
340                irc_send_num( irc, 412, ":No text to send" );
341                return;
342        }
343       
344        /* At least for now just echo. IIRC some IRC clients use self-notices
345           for lag checks, so try to support that. */
346        if( nick_cmp( cmd[1], irc->user->nick ) == 0 )
347                irc_send_msg( irc->user, "NOTICE", irc->user->nick, cmd[2], NULL );
348}
349
350static void irc_cmd_nickserv( irc_t *irc, char **cmd )
351{
352        /* [SH] This aliases the NickServ command to PRIVMSG root */
353        /* [TV] This aliases the NS command to PRIVMSG root as well */
354        root_command( irc, cmd + 1 );
355}
356
357
358
359static void irc_cmd_oper( irc_t *irc, char **cmd )
360{
361        if( global.conf->oper_pass &&
362            ( strncmp( global.conf->oper_pass, "md5:", 4 ) == 0 ?
363                md5_verify_password( cmd[2], global.conf->oper_pass + 4 ) == 0 :
364                strcmp( cmd[2], global.conf->oper_pass ) == 0 ) )
365        {
366                irc_umode_set( irc, "+o", 1 );
367                irc_send_num( irc, 381, ":Password accepted" );
368        }
369        else
370        {
371                irc_send_num( irc, 432, ":Incorrect password" );
372        }
373}
374
375static void irc_cmd_invite( irc_t *irc, char **cmd )
376{
377        irc_channel_t *ic;
378        irc_user_t *iu;
379       
380        if( ( iu = irc_user_by_name( irc, cmd[1] ) ) == NULL )
381        {
382                irc_send_num( irc, 401, "%s :No such nick", cmd[1] );
383                return;
384        }
385        else if( ( ic = irc_channel_by_name( irc, cmd[2] ) ) == NULL )
386        {
387                irc_send_num( irc, 403, "%s :No such channel", cmd[2] );
388                return;
389        }
390       
391        if( !ic->f->invite )
392                irc_send_num( irc, 482, "%s :Can't invite people here", cmd[2] );
393        else if( ic->f->invite( ic, iu ) )
394                irc_send_num( irc, 341, "%s %s", iu->nick, ic->name );
395}
396
397static void irc_cmd_userhost( irc_t *irc, char **cmd )
398{
399        int i;
400       
401        /* [TV] Usable USERHOST-implementation according to
402                RFC1459. Without this, mIRC shows an error
403                while connecting, and the used way of rejecting
404                breaks standards.
405        */
406       
407        for( i = 1; cmd[i]; i ++ )
408        {
409                irc_user_t *iu = irc_user_by_name( irc, cmd[i] );
410               
411                if( iu )
412                        irc_send_num( irc, 302, ":%s=%c%s@%s", iu->nick,
413                                      irc_user_get_away( iu ) ? '-' : '+',
414                                      iu->user, iu->host );
415        }
416}
417
418static void irc_cmd_ison( irc_t *irc, char **cmd )
419{
420        char buff[IRC_MAX_LINE];
421        int lenleft, i;
422       
423        buff[0] = '\0';
424       
425        /* [SH] Leave room for : and \0 */
426        lenleft = IRC_MAX_LINE - 2;
427       
428        for( i = 1; cmd[i]; i ++ )
429        {
430                char *this, *next;
431               
432                this = cmd[i];
433                while( *this )
434                {
435                        irc_user_t *iu;
436                       
437                        if( ( next = strchr( this, ' ' ) ) )
438                                *next = 0;
439                       
440                        if( ( iu = irc_user_by_name( irc, this ) ) &&
441                            iu->bu && iu->bu->flags & BEE_USER_ONLINE )
442                        {
443                                lenleft -= strlen( iu->nick ) + 1;
444                               
445                                if( lenleft < 0 )
446                                        break;
447                               
448                                strcat( buff, iu->nick );
449                                strcat( buff, " " );
450                        }
451                       
452                        if( next )
453                        {
454                                *next = ' ';
455                                this = next + 1;
456                        }
457                        else
458                        {
459                                break;
460                        }   
461                }
462               
463                /* *sigh* */
464                if( lenleft < 0 )
465                        break;
466        }
467       
468        if( strlen( buff ) > 0 )
469                buff[strlen(buff)-1] = '\0';
470       
471        irc_send_num( irc, 303, ":%s", buff );
472}
473
474static void irc_cmd_watch( irc_t *irc, char **cmd )
475{
476        int i;
477       
478        /* Obviously we could also mark a user structure as being
479           watched, but what if the WATCH command is sent right
480           after connecting? The user won't exist yet then... */
481        for( i = 1; cmd[i]; i ++ )
482        {
483                char *nick;
484                irc_user_t *iu;
485               
486                if( !cmd[i][0] || !cmd[i][1] )
487                        break;
488               
489                nick = g_strdup( cmd[i] + 1 );
490                nick_lc( nick );
491               
492                iu = irc_user_by_name( irc, nick );
493               
494                if( cmd[i][0] == '+' )
495                {
496                        if( !g_hash_table_lookup( irc->watches, nick ) )
497                                g_hash_table_insert( irc->watches, nick, nick );
498                       
499                        if( iu && iu->bu && iu->bu->flags & BEE_USER_ONLINE )
500                                irc_send_num( irc, 604, "%s %s %s %d :%s", iu->nick, iu->user,
501                                              iu->host, (int) time( NULL ), "is online" );
502                        else
503                                irc_send_num( irc, 605, "%s %s %s %d :%s", nick, "*", "*",
504                                              (int) time( NULL ), "is offline" );
505                }
506                else if( cmd[i][0] == '-' )
507                {
508                        gpointer okey, ovalue;
509                       
510                        if( g_hash_table_lookup_extended( irc->watches, nick, &okey, &ovalue ) )
511                        {
512                                g_hash_table_remove( irc->watches, okey );
513                                g_free( okey );
514                               
515                                irc_send_num( irc, 602, "%s %s %s %d :%s", nick, "*", "*", 0, "Stopped watching" );
516                        }
517                }
518        }
519}
520
521static void irc_cmd_topic( irc_t *irc, char **cmd )
522{
523        irc_channel_t *ic = irc_channel_by_name( irc, cmd[1] );
524        const char *new = cmd[2];
525       
526        if( ic == NULL )
527        {
528                irc_send_num( irc, 403, "%s :No such channel", cmd[1] );
529        }
530        else if( new )
531        {
532                if( ic->f->topic == NULL )
533                        irc_send_num( irc, 482, "%s :Can't change this channel's topic", ic->name );
534                else if( ic->f->topic( ic, new ) )
535                        irc_send_topic( ic, TRUE );
536        }
537        else
538        {
539                irc_send_topic( ic, FALSE );
540        }
541}
542
543static void irc_cmd_away( irc_t *irc, char **cmd )
544{
545        if( cmd[1] && *cmd[1] )
546        {
547                char away[strlen(cmd[1])+1];
548                int i, j;
549               
550                /* Copy away string, but skip control chars. Mainly because
551                   Jabber really doesn't like them. */
552                for( i = j = 0; cmd[1][i]; i ++ )
553                        if( ( away[j] = cmd[1][i] ) >= ' ' )
554                                j ++;
555                away[j] = '\0';
556               
557                irc_send_num( irc, 306, ":You're now away: %s", away );
558                set_setstr( &irc->b->set, "away", away );
559        }
560        else
561        {
562                irc_send_num( irc, 305, ":Welcome back" );
563                set_setstr( &irc->b->set, "away", NULL );
564        }
565}
566
567static void irc_cmd_version( irc_t *irc, char **cmd )
568{
569        irc_send_num( irc, 351, "bitlbee-%s. %s :%s/%s ",
570                      BITLBEE_VERSION, irc->root->host, ARCH, CPU );
571}
572
573static void irc_cmd_completions( irc_t *irc, char **cmd )
574{
575        help_t *h;
576        set_t *s;
577        int i;
578       
579        irc_send_msg_raw( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS OK" );
580       
581        for( i = 0; commands[i].command; i ++ )
582                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS %s", commands[i].command );
583       
584        for( h = global.help; h; h = h->next )
585                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS help %s", h->title );
586       
587        for( s = irc->b->set; s; s = s->next )
588                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS set %s", s->key );
589       
590        irc_send_msg_raw( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS END" );
591}
592
593static void irc_cmd_rehash( irc_t *irc, char **cmd )
594{
595        if( global.conf->runmode == RUNMODE_INETD )
596                ipc_master_cmd_rehash( NULL, NULL );
597        else
598                ipc_to_master( cmd );
599       
600        irc_send_num( irc, 382, "%s :Rehashing", global.conf_file );
601}
602
603static const command_t irc_commands[] = {
604        { "pass",        1, irc_cmd_pass,        0 },
605        { "user",        4, irc_cmd_user,        IRC_CMD_PRE_LOGIN },
606        { "nick",        1, irc_cmd_nick,        0 },
607        { "quit",        0, irc_cmd_quit,        0 },
608        { "ping",        0, irc_cmd_ping,        0 },
609        { "pong",        0, irc_cmd_pong,        IRC_CMD_LOGGED_IN },
610        { "join",        1, irc_cmd_join,        IRC_CMD_LOGGED_IN },
611        { "names",       1, irc_cmd_names,       IRC_CMD_LOGGED_IN },
612        { "part",        1, irc_cmd_part,        IRC_CMD_LOGGED_IN },
613        { "whois",       1, irc_cmd_whois,       IRC_CMD_LOGGED_IN },
614        { "whowas",      1, irc_cmd_whowas,      IRC_CMD_LOGGED_IN },
615        { "motd",        0, irc_cmd_motd,        IRC_CMD_LOGGED_IN },
616        { "mode",        1, irc_cmd_mode,        IRC_CMD_LOGGED_IN },
617        { "who",         0, irc_cmd_who,         IRC_CMD_LOGGED_IN },
618        { "privmsg",     1, irc_cmd_privmsg,     IRC_CMD_LOGGED_IN },
619        { "notice",      1, irc_cmd_notice,      IRC_CMD_LOGGED_IN },
620        { "nickserv",    1, irc_cmd_nickserv,    IRC_CMD_LOGGED_IN },
621        { "ns",          1, irc_cmd_nickserv,    IRC_CMD_LOGGED_IN },
622        { "away",        0, irc_cmd_away,        IRC_CMD_LOGGED_IN },
623        { "version",     0, irc_cmd_version,     IRC_CMD_LOGGED_IN },
624        { "completions", 0, irc_cmd_completions, IRC_CMD_LOGGED_IN },
625        { "userhost",    1, irc_cmd_userhost,    IRC_CMD_LOGGED_IN },
626        { "ison",        1, irc_cmd_ison,        IRC_CMD_LOGGED_IN },
627        { "watch",       1, irc_cmd_watch,       IRC_CMD_LOGGED_IN },
628        { "invite",      2, irc_cmd_invite,      IRC_CMD_LOGGED_IN },
629        { "topic",       1, irc_cmd_topic,       IRC_CMD_LOGGED_IN },
630        { "oper",        2, irc_cmd_oper,        IRC_CMD_LOGGED_IN },
631        { "die",         0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
632        { "deaf",        0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
633        { "wallops",     1, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
634        { "wall",        1, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
635        { "rehash",      0, irc_cmd_rehash,      IRC_CMD_OPER_ONLY },
636        { "restart",     0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
637        { "kill",        2, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
638        { NULL }
639};
640
641void irc_exec( irc_t *irc, char *cmd[] )
642{       
643        int i, n_arg;
644       
645        if( !cmd[0] )
646                return;
647       
648        for( i = 0; irc_commands[i].command; i++ )
649                if( g_strcasecmp( irc_commands[i].command, cmd[0] ) == 0 )
650                {
651                        /* There should be no typo in the next line: */
652                        for( n_arg = 0; cmd[n_arg]; n_arg ++ ); n_arg --;
653                       
654                        if( irc_commands[i].flags & IRC_CMD_PRE_LOGIN && irc->status & USTATUS_LOGGED_IN )
655                        {
656                                irc_send_num( irc, 462, ":Only allowed before logging in" );
657                        }
658                        else if( irc_commands[i].flags & IRC_CMD_LOGGED_IN && !( irc->status & USTATUS_LOGGED_IN ) )
659                        {
660                                irc_send_num( irc, 451, ":Register first" );
661                        }
662                        else if( irc_commands[i].flags & IRC_CMD_OPER_ONLY && !strchr( irc->umode, 'o' ) )
663                        {
664                                irc_send_num( irc, 481, ":Permission denied - You're not an IRC operator" );
665                        }
666                        else if( n_arg < irc_commands[i].required_parameters )
667                        {
668                                irc_send_num( irc, 461, "%s :Need more parameters", cmd[0] );
669                        }
670                        else if( irc_commands[i].flags & IRC_CMD_TO_MASTER )
671                        {
672                                /* IPC doesn't make sense in inetd mode,
673                                    but the function will catch that. */
674                                ipc_to_master( cmd );
675                        }
676                        else
677                        {
678                                irc_commands[i].execute( irc, cmd );
679                        }
680                       
681                        return;
682                }
683       
684        if( irc->status >= USTATUS_LOGGED_IN )
685                irc_send_num( irc, 421, "%s :Unknown command", cmd[0] );
686}
Note: See TracBrowser for help on using the repository browser.