src/ngircd/irc.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2012 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
  17  */
  18
  19 #include "imp.h"
  20 #include <assert.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23
  24 #include "ngircd.h"
  25 #include "conn-func.h"
  26 #include "conf.h"
  27 #include "channel.h"
  28 #include "conn-encoding.h"
  29 #include "defines.h"
  30 #include "irc-write.h"
  31 #include "log.h"
  32 #include "match.h"
  33 #include "messages.h"
  34 #include "parse.h"
  35 #include "tool.h"
  36
  37 #include "exp.h"
  38 #include "irc.h"
  39
  40
  41 static char *Option_String PARAMS((CONN_ID Idx));
  42 static bool Send_Message PARAMS((CLIENT *Client, REQUEST *Req, int ForceType,
  43                                  bool SendErrors));
  44 static bool Send_Message_Mask PARAMS((CLIENT *from, char *command,
  45                                       char *targetMask, char *message,
  46                                       bool SendErrors));
  47 static bool Help PARAMS((CLIENT *Client, const char *Topic));
  48
  49
  50 /**
  51  * Check if a list limit is reached and inform client accordingly.
  52  *
  53  * @param From The client.
  54  * @param Count Reply item count.
  55  * @param Limit Reply limit.
  56  * @param Name Name of the list.
  57  * @return true if list limit has been reached; false otherwise.
  58  */
  59 GLOBAL bool
  60 IRC_CheckListTooBig(CLIENT *From, const int Count, const int Limit,
  61                     const char *Name)
  62 {
  63         assert(From != NULL);
  64         assert(Count >= 0);
  65         assert(Limit > 0);
  66         assert(Name != NULL);
  67
  68         if (Count < Limit)
  69                 return false;
  70
  71         (void)IRC_WriteStrClient(From,
  72                                  "NOTICE %s :%s list limit (%d) reached!",
  73                                  Client_ID(From), Name, Limit);
  74         IRC_SetPenalty(From, 2);
  75         return true;
  76 }
  77
  78
  79 GLOBAL bool
  80 IRC_ERROR( CLIENT *Client, REQUEST *Req )
  81 {
  82         assert( Client != NULL );
  83         assert( Req != NULL );
  84
  85         if (Client_Type(Client) != CLIENT_GOTPASS
  86             && Client_Type(Client) != CLIENT_GOTPASS_2813
  87             && Client_Type(Client) != CLIENT_UNKNOWNSERVER
  88             && Client_Type(Client) != CLIENT_SERVER
  89             && Client_Type(Client) != CLIENT_SERVICE) {
  90                 LogDebug("Ignored ERROR command from \"%s\" ...",
  91                          Client_Mask(Client));
  92                 IRC_SetPenalty(Client, 2);
  93                 return CONNECTED;
  94         }
  95
  96         if (Req->argc < 1)
  97                 Log(LOG_NOTICE, "Got ERROR from \"%s\"!",
  98                     Client_Mask(Client));
  99         else
 100                 Log(LOG_NOTICE, "Got ERROR from \"%s\": \"%s\"!",
 101                     Client_Mask(Client), Req->argv[0]);
 102
 103         return CONNECTED;
 104 } /* IRC_ERROR */
 105
 106
 107 /**
 108  * Handler for the IRC "KILL" command.
 109  *
 110  * This function implements the IRC command "KILL" wich is used to selectively
 111  * disconnect clients. It can be used by IRC operators and servers, for example
 112  * to "solve" nick collisions after netsplits. See RFC 2812 section 3.7.1.
 113  *
 114  * Please note that this function is also called internally, without a real
 115  * KILL command being received over the network! Client is Client_ThisServer()
 116  * in this case, and the prefix in Req is NULL.
 117  *
 118  * @param Client        The client from which this command has been received
 119  *                      or Client_ThisServer() when generated interanlly.
 120  * @param Req           Request structure with prefix and all parameters.
 121  * @returns             CONNECTED or DISCONNECTED.
 122  */
 123 GLOBAL bool
 124 IRC_KILL( CLIENT *Client, REQUEST *Req )
 125 {
 126         CLIENT *prefix, *c;
 127         char reason[COMMAND_LEN], *msg;
 128         CONN_ID my_conn, conn;
 129
 130         assert (Client != NULL);
 131         assert (Req != NULL);
 132
 133         if (Client_Type(Client) != CLIENT_SERVER && !Client_OperByMe(Client))
 134                 return IRC_WriteStrClient(Client, ERR_NOPRIVILEGES_MSG,
 135                                           Client_ID(Client));
 136
 137         if (Req->argc != 2)
 138                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
 139                                           Client_ID(Client), Req->command);
 140
 141         /* Get prefix (origin); use the client if no prefix is given. */
 142         if (Req->prefix)
 143                 prefix = Client_Search(Req->prefix);
 144         else
 145                 prefix = Client;
 146
 147         /* Log a warning message and use this server as origin when the
 148          * prefix (origin) is invalid. */
 149         if (!prefix) {
 150                 Log(LOG_WARNING, "Got KILL with invalid prefix: \"%s\"!",
 151                     Req->prefix );
 152                 prefix = Client_ThisServer();
 153         }
 154
 155         if (Client != Client_ThisServer())
 156                 Log(LOG_NOTICE|LOG_snotice,
 157                     "Got KILL command from \"%s\" for \"%s\": %s",
 158                     Client_Mask(prefix), Req->argv[0], Req->argv[1]);
 159
 160         /* Build reason string: Prefix the "reason" if the originator is a
 161          * regular user, so users can't spoof KILLs of servers. */
 162         if (Client_Type(Client) == CLIENT_USER)
 163                 snprintf(reason, sizeof(reason), "KILLed by %s: %s",
 164                          Client_ID(Client), Req->argv[1]);
 165         else
 166                 strlcpy(reason, Req->argv[1], sizeof(reason));
 167
 168         /* Inform other servers */
 169         IRC_WriteStrServersPrefix(Client, prefix, "KILL %s :%s",
 170                                   Req->argv[0], reason);
 171
 172         /* Save ID of this connection */
 173         my_conn = Client_Conn( Client );
 174
 175         /* Do we host such a client? */
 176         c = Client_Search( Req->argv[0] );
 177         if( c )
 178         {
 179                 if(( Client_Type( c ) != CLIENT_USER ) &&
 180                    ( Client_Type( c ) != CLIENT_GOTNICK ))
 181                 {
 182                         /* Target of this KILL is not a regular user, this is
 183                          * invalid! So we ignore this case if we received a
 184                          * regular KILL from the network and try to kill the
 185                          * client/connection anyway (but log an error!) if the
 186                          * origin is the local server. */
 187
 188                         if( Client != Client_ThisServer( ))
 189                         {
 190                                 /* Invalid KILL received from remote */
 191                                 if( Client_Type( c ) == CLIENT_SERVER )
 192                                         msg = ERR_CANTKILLSERVER_MSG;
 193                                 else
 194                                         msg = ERR_NOPRIVILEGES_MSG;
 195                                 return IRC_WriteStrClient( Client, msg,
 196                                         Client_ID( Client ));
 197                         }
 198
 199                         Log( LOG_ERR, "Got KILL for invalid client type: %d, \"%s\"!",
 200                              Client_Type( c ), Req->argv[0] );
 201                 }
 202
 203                 /* Kill the client NOW:
 204                  *  - Close the local connection (if there is one),
 205                  *  - Destroy the CLIENT structure for remote clients.
 206                  * Note: Conn_Close() removes the CLIENT structure as well. */
 207                 conn = Client_Conn( c );
 208                 if(conn > NONE)
 209                         Conn_Close(conn, NULL, reason, true);
 210                 else
 211                         Client_Destroy(c, NULL, reason, false);
 212         }
 213         else
 214                 Log( LOG_NOTICE, "Client with nick \"%s\" is unknown here.", Req->argv[0] );
 215
 216         /* Are we still connected or were we killed, too? */
 217         if(( my_conn > NONE ) && ( Conn_GetClient( my_conn )))
 218                 return CONNECTED;
 219         else
 220                 return DISCONNECTED;
 221 } /* IRC_KILL */
 222
 223
 224 /**
 225  * Handler for the IRC command NOTICE.
 226  */
 227 GLOBAL bool
 228 IRC_NOTICE(CLIENT *Client, REQUEST *Req)
 229 {
 230         return Send_Message(Client, Req, CLIENT_USER, false);
 231 } /* IRC_NOTICE */
 232
 233
 234 /**
 235  * Handler for the IRC command PRIVMSG.
 236  */
 237 GLOBAL bool
 238 IRC_PRIVMSG(CLIENT *Client, REQUEST *Req)
 239 {
 240         return Send_Message(Client, Req, CLIENT_USER, true);
 241 } /* IRC_PRIVMSG */
 242
 243
 244 /**
 245  * Handler for the IRC command SQUERY.
 246  */
 247 GLOBAL bool
 248 IRC_SQUERY(CLIENT *Client, REQUEST *Req)
 249 {
 250         return Send_Message(Client, Req, CLIENT_SERVICE, true);
 251 } /* IRC_SQUERY */
 252
 253
 254 GLOBAL bool
 255 IRC_TRACE( CLIENT *Client, REQUEST *Req )
 256 {
 257         CLIENT *from, *target, *c;
 258         CONN_ID idx, idx2;
 259         char user[CLIENT_USER_LEN];
 260
 261         assert( Client != NULL );
 262         assert( Req != NULL );
 263
 264         /* Bad number of arguments? */
 265         if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NORECIPIENT_MSG, Client_ID( Client ), Req->command );
 266
 267         /* Search sender */
 268         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
 269         else from = Client;
 270         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 271
 272         /* Search target */
 273         if( Req->argc == 1 ) target = Client_Search( Req->argv[0] );
 274         else target = Client_ThisServer( );
 275
 276         /* Forward command to other server? */
 277         if( target != Client_ThisServer( ))
 278         {
 279                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[0] );
 280
 281                 /* Send RPL_TRACELINK back to initiator */
 282                 idx = Client_Conn( Client ); assert( idx > NONE );
 283                 idx2 = Client_Conn( Client_NextHop( target )); assert( idx2 > NONE );
 284                 if( ! IRC_WriteStrClient( from, RPL_TRACELINK_MSG, Client_ID( from ), PACKAGE_NAME, PACKAGE_VERSION, Client_ID( target ), Client_ID( Client_NextHop( target )), Option_String( idx2 ), time( NULL ) - Conn_StartTime( idx2 ), Conn_SendQ( idx ), Conn_SendQ( idx2 ))) return DISCONNECTED;
 285
 286                 /* Forward command */
 287                 IRC_WriteStrClientPrefix( target, from, "TRACE %s", Req->argv[0] );
 288                 return CONNECTED;
 289         }
 290
 291         /* Infos about all connected servers */
 292         c = Client_First( );
 293         while( c )
 294         {
 295                 if( Client_Conn( c ) > NONE )
 296                 {
 297                         /* Local client */
 298                         if( Client_Type( c ) == CLIENT_SERVER )
 299                         {
 300                                 /* Server link */
 301                                 strlcpy( user, Client_User( c ), sizeof( user ));
 302                                 if( user[0] == '~' ) strlcpy( user, "unknown", sizeof( user ));
 303                                 if( ! IRC_WriteStrClient( from, RPL_TRACESERVER_MSG, Client_ID( from ), Client_ID( c ), user, Client_Hostname( c ), Client_Mask( Client_ThisServer( )), Option_String( Client_Conn( c )))) return DISCONNECTED;
 304                         }
 305                         if(( Client_Type( c ) == CLIENT_USER ) && ( strchr( Client_Modes( c ), 'o' )))
 306                         {
 307                                 /* IRC Operator */
 308                                 if( ! IRC_WriteStrClient( from, RPL_TRACEOPERATOR_MSG, Client_ID( from ), Client_ID( c ))) return DISCONNECTED;
 309                         }
 310                 }
 311                 c = Client_Next( c );
 312         }
 313
 314         IRC_SetPenalty( Client, 3 );
 315         return IRC_WriteStrClient( from, RPL_TRACEEND_MSG, Client_ID( from ), Conf_ServerName, PACKAGE_NAME, PACKAGE_VERSION, NGIRCd_DebugLevel );
 316 } /* IRC_TRACE */
 317
 318
 319 /**
 320  * Handler for the IRC "HELP" command.
 321  *
 322  * @param Client The client from which this command has been received.
 323  * @param Req Request structure with prefix and all parameters.
 324  * @return CONNECTED or DISCONNECTED.
 325  */
 326 GLOBAL bool
 327 IRC_HELP(CLIENT *Client, REQUEST *Req)
 328 {
 329         COMMAND *cmd;
 330
 331         assert(Client != NULL);
 332         assert(Req != NULL);
 333
 334         /* Bad number of arguments? */
 335         if (Req->argc > 1)
 336                 return IRC_WriteStrClient(Client, ERR_NORECIPIENT_MSG,
 337                                           Client_ID(Client), Req->command);
 338
 339         IRC_SetPenalty(Client, 2);
 340
 341         if ((Req->argc == 0 && array_bytes(&Conf_Helptext) > 0)
 342             || (Req->argc >= 1 && strcasecmp(Req->argv[0], "Commands") != 0)) {
 343                 /* Help text available and requested */
 344                 if (Req->argc >= 1)
 345                         return Help(Client, Req->argv[0]);
 346
 347                 if (!Help(Client, "Intro"))
 348                         return DISCONNECTED;
 349                 return CONNECTED;
 350         }
 351
 352         cmd = Parse_GetCommandStruct();
 353         while(cmd->name) {
 354                 if (!IRC_WriteStrClient(Client, "NOTICE %s :%s",
 355                                         Client_ID(Client), cmd->name))
 356                         return DISCONNECTED;
 357                 cmd++;
 358         }
 359         return CONNECTED;
 360 } /* IRC_HELP */
 361
 362
 363 /**
 364  * Send help for a given topic to the client.
 365  *
 366  * @param Client The client requesting help.
 367  * @param Topoc The help topic requested.
 368  * @return CONNECTED or DISCONNECTED.
 369  */
 370 static bool
 371 Help(CLIENT *Client, const char *Topic)
 372 {
 373         char *line;
 374         size_t helptext_len, len_str, idx_start, lines = 0;
 375         bool in_article = false;
 376
 377         assert(Client != NULL);
 378         assert(Topic != NULL);
 379
 380         helptext_len = array_bytes(&Conf_Helptext);
 381         line = array_start(&Conf_Helptext);
 382         while (helptext_len > 0) {
 383                 len_str = strlen(line) + 1;
 384                 assert(helptext_len >= len_str);
 385                 helptext_len -= len_str;
 386
 387                 if (in_article) {
 388                         /* The first character in each article text line must
 389                          * be a TAB (ASCII 9) character which will be stripped
 390                          * in the output. If it is not a TAB, the end of the
 391                          * article has been reached. */
 392                         if (line[0] != '\t') {
 393                                 if (lines > 0)
 394                                         return CONNECTED;
 395                                 else
 396                                         break;
 397                         }
 398
 399                         /* A single '.' character indicates an empty line */
 400                         if (line[1] == '.' && line[2] == '\0')
 401                                 idx_start = 2;
 402                         else
 403                                 idx_start = 1;
 404
 405                         if (!IRC_WriteStrClient(Client, "NOTICE %s :%s",
 406                                                 Client_ID(Client),
 407                                                 &line[idx_start]))
 408                                 return DISCONNECTED;
 409                         lines++;
 410
 411                 } else {
 412                         if (line[0] == '-' && line[1] == ' '
 413                             && strcasecmp(&line[2], Topic) == 0)
 414                                 in_article = true;
 415                 }
 416
 417                 line += len_str;
 418         }
 419
 420         /* Help topic not found (or empty)! */
 421         if (!IRC_WriteStrClient(Client, "NOTICE %s :No help for \"%s\" found!",
 422                                 Client_ID(Client), Topic))
 423                 return DISCONNECTED;
 424
 425         return CONNECTED;
 426 }
 427
 428
 429 static char *
 430 #ifdef ZLIB
 431 Option_String(CONN_ID Idx)
 432 #else
 433 Option_String(UNUSED CONN_ID Idx)
 434 #endif
 435 {
 436         static char option_txt[8];
 437 #ifdef ZLIB
 438         UINT16 options;
 439
 440         options = Conn_Options(Idx);
 441 #endif
 442
 443         strcpy(option_txt, "F");        /* No idea what this means, but the
 444                                          * original ircd sends it ... */
 445 #ifdef ZLIB
 446         if(options & CONN_ZIP)          /* zlib compression supported. */
 447                 strcat(option_txt, "z");
 448 #endif
 449
 450         return option_txt;
 451 } /* Option_String */
 452
 453
 454 static bool
 455 Send_Message(CLIENT * Client, REQUEST * Req, int ForceType, bool SendErrors)
 456 {
 457         CLIENT *cl, *from;
 458         CL2CHAN *cl2chan;
 459         CHANNEL *chan;
 460         char *currentTarget = Req->argv[0];
 461         char *lastCurrentTarget = NULL;
 462         char *message = NULL;
 463
 464         assert(Client != NULL);
 465         assert(Req != NULL);
 466
 467         if (Req->argc == 0) {
 468                 if (!SendErrors)
 469                         return CONNECTED;
 470                 return IRC_WriteStrClient(Client, ERR_NORECIPIENT_MSG,
 471                                           Client_ID(Client), Req->command);
 472         }
 473         if (Req->argc == 1) {
 474                 if (!SendErrors)
 475                         return CONNECTED;
 476                 return IRC_WriteStrClient(Client, ERR_NOTEXTTOSEND_MSG,
 477                                           Client_ID(Client));
 478         }
 479         if (Req->argc > 2) {
 480                 if (!SendErrors)
 481                         return CONNECTED;
 482                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
 483                                           Client_ID(Client), Req->command);
 484         }
 485
 486         if (Client_Type(Client) == CLIENT_SERVER)
 487                 from = Client_Search(Req->prefix);
 488         else
 489                 from = Client;
 490         if (!from)
 491                 return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
 492                                           Client_ID(Client), Req->prefix);
 493
 494 #ifdef ICONV
 495         if (Client_Conn(Client) > NONE)
 496                 message = Conn_EncodingFrom(Client_Conn(Client), Req->argv[1]);
 497         else
 498 #endif
 499                 message = Req->argv[1];
 500
 501         /* handle msgtarget = msgto *("," msgto) */
 502         currentTarget = strtok_r(currentTarget, ",", &lastCurrentTarget);
 503         ngt_UpperStr(Req->command);
 504
 505         while (currentTarget) {
 506                 /* Check for and handle valid <msgto> of form:
 507                  * RFC 2812 2.3.1:
 508                  *   msgto =  channel / ( user [ "%" host ] "@" servername )
 509                  *   msgto =/ ( user "%" host ) / targetmask
 510                  *   msgto =/ nickname / ( nickname "!" user "@" host )
 511                  */
 512                 if (strchr(currentTarget, '!') == NULL)
 513                         /* nickname */
 514                         cl = Client_Search(currentTarget);
 515                 else
 516                         cl = NULL;
 517
 518                 if (cl == NULL) {
 519                         /* If currentTarget isn't a nickname check for:
 520                          * user ["%" host] "@" servername
 521                          * user "%" host
 522                          * nickname "!" user "@" host
 523                          */
 524                         char target[COMMAND_LEN];
 525                         char * nick = NULL;
 526                         char * user = NULL;
 527                         char * host = NULL;
 528                         char * server = NULL;
 529
 530                         strlcpy(target, currentTarget, COMMAND_LEN);
 531                         server = strchr(target, '@');
 532                         if (server) {
 533                                 *server = '\0';
 534                                 server++;
 535                         }
 536                         host = strchr(target, '%');
 537                         if (host) {
 538                                 *host = '\0';
 539                                 host++;
 540                         }
 541                         user = strchr(target, '!');
 542                         if (user) {
 543                                 /* msgto form: nick!user@host */
 544                                 *user = '\0';
 545                                 user++;
 546                                 nick = target;
 547                                 host = server; /* not "@server" but "@host" */
 548                         } else {
 549                                 user = target;
 550                         }
 551
 552                         for (cl = Client_First(); cl != NULL; cl = Client_Next(cl)) {
 553                                 if (Client_Type(cl) != CLIENT_USER &&
 554                                     Client_Type(cl) != CLIENT_SERVICE)
 555                                         continue;
 556                                 if (nick != NULL && host != NULL) {
 557                                         if (strcasecmp(nick, Client_ID(cl)) == 0 &&
 558                                             strcasecmp(user, Client_User(cl)) == 0 &&
 559                                             strcasecmp(host, Client_HostnameDisplayed(cl)) == 0)
 560                                                 break;
 561                                         else
 562                                                 continue;
 563                                 }
 564                                 if (strcasecmp(user, Client_User(cl)) != 0)
 565                                         continue;
 566                                 if (host != NULL && strcasecmp(host,
 567                                                 Client_HostnameDisplayed(cl)) != 0)
 568                                         continue;
 569                                 if (server != NULL && strcasecmp(server,
 570                                                 Client_ID(Client_Introducer(cl))) != 0)
 571                                         continue;
 572                                 break;
 573                         }
 574                 }
 575
 576                 if (cl) {
 577                         /* Target is a user, enforce type */
 578 #ifndef STRICT_RFC
 579                         if (Client_Type(cl) != ForceType &&
 580                             !(ForceType == CLIENT_USER &&
 581                               (Client_Type(cl) == CLIENT_USER ||
 582                                Client_Type(cl) == CLIENT_SERVICE))) {
 583 #else
 584                         if (Client_Type(cl) != ForceType) {
 585 #endif
 586                                 if (SendErrors && !IRC_WriteStrClient(
 587                                     from, ERR_NOSUCHNICK_MSG,Client_ID(from),
 588                                     currentTarget))
 589                                         return DISCONNECTED;
 590                                 goto send_next_target;
 591                         }
 592
 593 #ifndef STRICT_RFC
 594                         if (ForceType == CLIENT_SERVICE &&
 595                             (Conn_Options(Client_Conn(Client_NextHop(cl)))
 596                              & CONN_RFC1459)) {
 597                                 /* SQUERY command but RFC 1459 link: convert
 598                                  * request to PRIVMSG command */
 599                                 Req->command = "PRIVMSG";
 600                         }
 601 #endif
 602                         if (Client_HasMode(cl, 'b') &&
 603                             !Client_HasMode(from, 'R') &&
 604                             !Client_HasMode(from, 'o') &&
 605                             !(Client_Type(from) == CLIENT_SERVER) &&
 606                             !(Client_Type(from) == CLIENT_SERVICE)) {
 607                                 if (SendErrors && !IRC_WriteStrClient(from,
 608                                                 ERR_NONONREG_MSG,
 609                                                 Client_ID(from), Client_ID(cl)))
 610                                         return DISCONNECTED;
 611                                 goto send_next_target;
 612                         }
 613
 614                         if (Client_HasMode(cl, 'C')) {
 615                                 cl2chan = Channel_FirstChannelOf(cl);
 616                                 while (cl2chan) {
 617                                         chan = Channel_GetChannel(cl2chan);
 618                                         if (Channel_IsMemberOf(chan, from))
 619                                                 break;
 620                                         cl2chan = Channel_NextChannelOf(cl, cl2chan);
 621                                 }
 622                                 if (!cl2chan) {
 623                                         if (SendErrors && !IRC_WriteStrClient(
 624                                             from, ERR_NOTONSAMECHANNEL_MSG,
 625                                             Client_ID(from), Client_ID(cl)))
 626                                                 return DISCONNECTED;
 627                                         goto send_next_target;
 628                                 }
 629                         }
 630
 631                         if (SendErrors && (Client_Type(Client) != CLIENT_SERVER)
 632                             && strchr(Client_Modes(cl), 'a')) {
 633                                 /* Target is away */
 634                                 if (!IRC_WriteStrClient(from, RPL_AWAY_MSG,
 635                                                         Client_ID(from),
 636                                                         Client_ID(cl),
 637                                                         Client_Away(cl)))
 638                                         return DISCONNECTED;
 639                         }
 640                         if (Client_Conn(from) > NONE) {
 641                                 Conn_UpdateIdle(Client_Conn(from));
 642                         }
 643                         if (!IRC_WriteStrClientPrefix(cl, from, "%s %s :%s",
 644                                                       Req->command, Client_ID(cl),
 645                                                       message))
 646                                 return DISCONNECTED;
 647                 } else if (ForceType != CLIENT_SERVICE
 648                            && (chan = Channel_Search(currentTarget))) {
 649                         if (!Channel_Write(chan, from, Client, Req->command,
 650                                            SendErrors, message))
 651                                         return DISCONNECTED;
 652                 } else if (ForceType != CLIENT_SERVICE
 653                         /* $#: server/target mask, RFC 2812, sec. 3.3.1 */
 654                            && strchr("$#", currentTarget[0])
 655                            && strchr(currentTarget, '.')) {
 656                         /* targetmask */
 657                         if (!Send_Message_Mask(from, Req->command, currentTarget,
 658                                                message, SendErrors))
 659                                 return DISCONNECTED;
 660                 } else {
 661                         if (!SendErrors)
 662                                 return CONNECTED;
 663                         if (!IRC_WriteStrClient(from, ERR_NOSUCHNICK_MSG,
 664                                                 Client_ID(from), currentTarget))
 665                                 return DISCONNECTED;
 666                 }
 667
 668         send_next_target:
 669                 currentTarget = strtok_r(NULL, ",", &lastCurrentTarget);
 670                 if (currentTarget)
 671                         Conn_SetPenalty(Client_Conn(Client), 1);
 672         }
 673
 674         return CONNECTED;
 675 } /* Send_Message */
 676
 677
 678 static bool
 679 Send_Message_Mask(CLIENT * from, char * command, char * targetMask,
 680                   char * message, bool SendErrors)
 681 {
 682         CLIENT *cl;
 683         bool client_match;
 684         char *mask = targetMask + 1;
 685         const char *check_wildcards;
 686
 687         cl = NULL;
 688
 689         if (strchr(Client_Modes(from), 'o') == NULL) {
 690                 if (!SendErrors)
 691                         return true;
 692                 return IRC_WriteStrClient(from, ERR_NOPRIVILEGES_MSG,
 693                                           Client_ID(from));
 694         }
 695
 696         /*
 697          * RFC 2812, sec. 3.3.1 requires that targetMask have at least one
 698          * dot (".") and no wildcards ("*", "?") following the last one.
 699          */
 700         check_wildcards = strrchr(targetMask, '.');
 701         assert(check_wildcards != NULL);
 702         if (check_wildcards &&
 703                 check_wildcards[strcspn(check_wildcards, "*?")])
 704         {
 705                 if (!SendErrors)
 706                         return true;
 707                 return IRC_WriteStrClient(from, ERR_WILDTOPLEVEL, targetMask);
 708         }
 709
 710         /* #: hostmask, see RFC 2812, sec. 3.3.1 */
 711         if (targetMask[0] == '#') {
 712                 for (cl = Client_First(); cl != NULL; cl = Client_Next(cl)) {
 713                         if (Client_Type(cl) != CLIENT_USER)
 714                                 continue;
 715                         client_match = MatchCaseInsensitive(mask, Client_Hostname(cl));
 716                         if (client_match)
 717                                 if (!IRC_WriteStrClientPrefix(cl, from, "%s %s :%s",
 718                                                 command, Client_ID(cl), message))
 719                                         return false;
 720                 }
 721         } else {
 722                 assert(targetMask[0] == '$'); /* $: server mask, see RFC 2812, sec. 3.3.1 */
 723                 for (cl = Client_First(); cl != NULL; cl = Client_Next(cl)) {
 724                         if (Client_Type(cl) != CLIENT_USER)
 725                                 continue;
 726                         client_match = MatchCaseInsensitive(mask,
 727                                         Client_ID(Client_Introducer(cl)));
 728                         if (client_match)
 729                                 if (!IRC_WriteStrClientPrefix(cl, from, "%s %s :%s",
 730                                                 command, Client_ID(cl), message))
 731                                         return false;
 732                 }
 733         }
 734         return CONNECTED;
 735 } /* Send_Message_Mask */
 736
 737
 738 /* -eof- */