src/ngircd/irc-write.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2008 Alexander Barton (alex@barton.de)
   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  * Sending IRC commands over the network
  12  */
  13
  14
  15 #include "portab.h"
  16
  17 #include "imp.h"
  18 #include <assert.h>
  19 #ifdef PROTOTYPES
  20 #       include <stdarg.h>
  21 #else
  22 #       include <varargs.h>
  23 #endif
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #include "defines.h"
  28 #include "conn-func.h"
  29 #include "client.h"
  30 #include "channel.h"
  31
  32 #include "exp.h"
  33 #include "irc-write.h"
  34
  35
  36 #define SEND_TO_USER 1
  37 #define SEND_TO_SERVER 2
  38
  39
  40 static char *Get_Prefix PARAMS((CLIENT *Target, CLIENT *Client));
  41 static void cb_writeStrServersPrefixFlag PARAMS((CLIENT *Client,
  42                                          CLIENT *Prefix, void *Buffer));
  43
  44
  45 #ifdef PROTOTYPES
  46 GLOBAL bool
  47 IRC_WriteStrClient( CLIENT *Client, char *Format, ... )
  48 #else
  49 GLOBAL bool
  50 IRC_WriteStrClient( Client, Format, va_alist )
  51 CLIENT *Client;
  52 char *Format;
  53 va_dcl
  54 #endif
  55 {
  56         char buffer[1000];
  57         bool ok = CONNECTED;
  58         va_list ap;
  59
  60         assert( Client != NULL );
  61         assert( Format != NULL );
  62
  63 #ifdef PROTOTYPES
  64         va_start( ap, Format );
  65 #else
  66         va_start( ap );
  67 #endif
  68         vsnprintf( buffer, 1000, Format, ap );
  69         va_end( ap );
  70
  71         /* to the client itself */
  72         ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), "%s", buffer );
  73
  74         return ok;
  75 } /* IRC_WriteStrClient */
  76
  77
  78 #ifdef PROTOTYPES
  79 GLOBAL bool
  80 IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, char *Format, ... )
  81 #else
  82 GLOBAL bool
  83 IRC_WriteStrClientPrefix( Client, Prefix, Format, va_alist )
  84 CLIENT *Client;
  85 CLIENT *Prefix;
  86 char *Format;
  87 va_dcl
  88 #endif
  89 {
  90         /* send text to local and remote clients */
  91
  92         char buffer[1000];
  93         va_list ap;
  94
  95         assert( Client != NULL );
  96         assert( Format != NULL );
  97         assert( Prefix != NULL );
  98
  99 #ifdef PROTOTYPES
 100         va_start( ap, Format );
 101 #else
 102         va_start( ap );
 103 #endif
 104         vsnprintf( buffer, 1000, Format, ap );
 105         va_end( ap );
 106
 107         return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Get_Prefix( Client_NextHop( Client ), Prefix ), buffer );
 108 } /* IRC_WriteStrClientPrefix */
 109
 110
 111 #ifdef PROTOTYPES
 112 GLOBAL bool
 113 IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, bool Remote, char *Format, ... )
 114 #else
 115 GLOBAL bool
 116 IRC_WriteStrChannel( Client, Chan, Remote, Format, va_alist )
 117 CLIENT *Client;
 118 CHANNEL *Chan;
 119 bool Remote;
 120 char *Format;
 121 va_dcl
 122 #endif
 123 {
 124         char buffer[1000];
 125         va_list ap;
 126
 127         assert( Client != NULL );
 128         assert( Format != NULL );
 129
 130 #ifdef PROTOTYPES
 131         va_start( ap, Format );
 132 #else
 133         va_start( ap );
 134 #endif
 135         vsnprintf( buffer, 1000, Format, ap );
 136         va_end( ap );
 137
 138         return IRC_WriteStrChannelPrefix( Client, Chan, Client_ThisServer( ), Remote, "%s", buffer );
 139 } /* IRC_WriteStrChannel */
 140
 141
 142
 143 /**
 144  * send message to all clients in the same channel, but only send message
 145  * once per remote server.
 146  */
 147 #ifdef PROTOTYPES
 148 GLOBAL bool
 149 IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, bool Remote, char *Format, ... )
 150 #else
 151 GLOBAL bool
 152 IRC_WriteStrChannelPrefix( Client, Chan, Prefix, Remote, Format, va_alist )
 153 CLIENT *Client;
 154 CHANNEL *Chan;
 155 CLIENT *Prefix;
 156 bool Remote;
 157 char *Format;
 158 va_dcl
 159 #endif
 160 {
 161         bool ok = CONNECTED;
 162         char buffer[1000];
 163         CL2CHAN *cl2chan;
 164         CONN_ID conn;
 165         CLIENT *c;
 166         va_list ap;
 167
 168         assert( Client != NULL );
 169         assert( Chan != NULL );
 170         assert( Prefix != NULL );
 171         assert( Format != NULL );
 172
 173 #ifdef PROTOTYPES
 174         va_start( ap, Format );
 175 #else
 176         va_start( ap  );
 177 #endif
 178         vsnprintf( buffer, 1000, Format, ap );
 179         va_end( ap );
 180
 181         Conn_ClearFlags( );
 182
 183         cl2chan = Channel_FirstMember( Chan );
 184         while( cl2chan )
 185         {
 186                 c = Channel_GetClient( cl2chan );
 187                 if( ! Remote )
 188                 {
 189                         if( Client_Conn( c ) <= NONE ) c = NULL;
 190                         else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 191                 }
 192                 if( c ) c = Client_NextHop( c );
 193
 194                 if( c && ( c != Client ))
 195                 {
 196                         /* Ok, another Client */
 197                         conn = Client_Conn( c );
 198                         if( Client_Type( c ) == CLIENT_SERVER ) Conn_SetFlag( conn, SEND_TO_SERVER );
 199                         else Conn_SetFlag( conn, SEND_TO_USER );
 200                 }
 201                 cl2chan = Channel_NextMember( Chan, cl2chan );
 202         }
 203
 204         conn = Conn_First( );
 205         while( conn != NONE )
 206         {
 207                 /* do we need to send data via this connection? */
 208                 if( Conn_Flag( conn ) == SEND_TO_SERVER) ok = Conn_WriteStr( conn, ":%s %s", Client_ID( Prefix ), buffer );
 209                 else if( Conn_Flag( conn ) == SEND_TO_USER ) ok = Conn_WriteStr( conn, ":%s %s", Client_Mask( Prefix ), buffer );
 210                 if( ! ok ) break;
 211
 212                 conn = Conn_Next( conn );
 213         }
 214
 215         return ok;
 216 } /* IRC_WriteStrChannelPrefix */
 217
 218
 219 #ifdef PROTOTYPES
 220 GLOBAL void
 221 IRC_WriteStrServers( CLIENT *ExceptOf, char *Format, ... )
 222 #else
 223 GLOBAL void
 224 IRC_WriteStrServers( ExceptOf, Format, va_alist )
 225 CLIENT *ExceptOf;
 226 char *Format;
 227 va_dcl
 228 #endif
 229 {
 230         char buffer[1000];
 231         va_list ap;
 232
 233         assert( Format != NULL );
 234
 235 #ifdef PROTOTYPES
 236         va_start( ap, Format );
 237 #else
 238         va_start( ap );
 239 #endif
 240         vsnprintf( buffer, 1000, Format, ap );
 241         va_end( ap );
 242
 243         IRC_WriteStrServersPrefix( ExceptOf, Client_ThisServer( ), "%s", buffer );
 244 } /* IRC_WriteStrServers */
 245
 246
 247 #ifdef PROTOTYPES
 248 GLOBAL void
 249 IRC_WriteStrServersPrefix( CLIENT *ExceptOf, CLIENT *Prefix, char *Format, ... )
 250 #else
 251 GLOBAL void
 252 IRC_WriteStrServersPrefix( ExceptOf, Prefix, Format, va_alist )
 253 CLIENT *ExceptOf;
 254 CLIENT *Prefix;
 255 char *Format;
 256 va_dcl
 257 #endif
 258 {
 259         char buffer[1000];
 260         va_list ap;
 261
 262         assert( Format != NULL );
 263         assert( Prefix != NULL );
 264
 265 #ifdef PROTOTYPES
 266         va_start( ap, Format );
 267 #else
 268         va_start( ap );
 269 #endif
 270         vsnprintf( buffer, 1000, Format, ap );
 271         va_end( ap );
 272
 273         IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, '\0', "%s", buffer );
 274 } /* IRC_WriteStrServersPrefix */
 275
 276
 277 #ifdef PROTOTYPES
 278 GLOBAL void
 279 IRC_WriteStrServersPrefixFlag( CLIENT *ExceptOf, CLIENT *Prefix, char Flag, char *Format, ... )
 280 #else
 281 GLOBAL void
 282 IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, Flag, Format, va_alist )
 283 CLIENT *ExceptOf;
 284 CLIENT *Prefix;
 285 char Flag;
 286 char *Format;
 287 va_dcl
 288 #endif
 289 {
 290         char buffer[1000];
 291         va_list ap;
 292
 293         assert( Format != NULL );
 294         assert( Prefix != NULL );
 295
 296 #ifdef PROTOTYPES
 297         va_start( ap, Format );
 298 #else
 299         va_start( ap );
 300 #endif
 301         vsnprintf( buffer, 1000, Format, ap );
 302         va_end( ap );
 303
 304         IRC_WriteStrServersPrefixFlag_CB(ExceptOf, Prefix, Flag,
 305                                          cb_writeStrServersPrefixFlag, buffer);
 306 } /* IRC_WriteStrServersPrefixFlag */
 307
 308
 309 GLOBAL void
 310 IRC_WriteStrServersPrefixFlag_CB(CLIENT *ExceptOf, CLIENT *Prefix, char Flag,
 311                 void (*callback)(CLIENT *, CLIENT *, void *), void *cb_data)
 312 {
 313         CLIENT *c;
 314
 315         c = Client_First();
 316         while(c) {
 317                 if (Client_Type(c) == CLIENT_SERVER && Client_Conn(c) > NONE &&
 318                     c != Client_ThisServer() && c != ExceptOf) {
 319                         /* Found a target server, do the flags match? */
 320                         if (Flag == '\0' || strchr(Client_Flags(c), Flag))
 321                                 callback(c, Prefix, cb_data);
 322                 }
 323                 c = Client_Next(c);
 324         }
 325 } /* IRC_WriteStrServersPrefixFlag */
 326
 327
 328 /**
 329  * send message to all clients that are in the same channels as the client sending this message.
 330  * only send message once per reote server.
 331  */
 332 #ifdef PROTOTYPES
 333 GLOBAL bool
 334 IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, bool Remote, char *Format, ... )
 335 #else
 336 GLOBAL bool
 337 IRC_WriteStrRelatedPrefix( Client, Prefix, Remote, Format, va_alist )
 338 CLIENT *Client;
 339 CLIENT *Prefix;
 340 bool Remote;
 341 char *Format;
 342 va_dcl
 343 #endif
 344 {
 345         bool ok = CONNECTED;
 346         CL2CHAN *chan_cl2chan, *cl2chan;
 347         char buffer[1000];
 348         CHANNEL *chan;
 349         CONN_ID conn;
 350         va_list ap;
 351         CLIENT *c;
 352
 353         assert( Client != NULL );
 354         assert( Prefix != NULL );
 355         assert( Format != NULL );
 356
 357 #ifdef PROTOTYPES
 358         va_start( ap, Format );
 359 #else
 360         va_start( ap );
 361 #endif
 362         vsnprintf( buffer, 1000, Format, ap );
 363         va_end( ap );
 364
 365         Conn_ClearFlags( );
 366
 367         chan_cl2chan = Channel_FirstChannelOf( Client );
 368         while( chan_cl2chan )
 369         {
 370                 chan = Channel_GetChannel( chan_cl2chan );
 371                 cl2chan = Channel_FirstMember( chan );
 372                 while( cl2chan )
 373                 {
 374                         c = Channel_GetClient( cl2chan );
 375                         if( ! Remote )
 376                         {
 377                                 if( Client_Conn( c ) <= NONE ) c = NULL;
 378                                 else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 379                         }
 380                         if( c ) c = Client_NextHop( c );
 381
 382                         if( c && ( c != Client ))
 383                         {
 384                                 conn = Client_Conn( c );
 385                                 if( Client_Type( c ) == CLIENT_SERVER ) Conn_SetFlag( conn, SEND_TO_SERVER );
 386                                 else Conn_SetFlag( conn, SEND_TO_USER );
 387                         }
 388                         cl2chan = Channel_NextMember( chan, cl2chan );
 389                 }
 390
 391                 chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
 392         }
 393
 394         conn = Conn_First( );
 395         while( conn != NONE )
 396         {
 397                 /* send data via this connection? */
 398                 if( Conn_Flag( conn ) == SEND_TO_SERVER ) ok = Conn_WriteStr( conn, ":%s %s", Client_ID( Prefix ), buffer );
 399                 else if( Conn_Flag( conn ) == SEND_TO_USER ) ok = Conn_WriteStr( conn, ":%s %s", Client_Mask( Prefix ), buffer );
 400                 if( ! ok ) break;
 401
 402                 conn = Conn_Next( conn );
 403         }
 404         return ok;
 405 } /* IRC_WriteStrRelatedPrefix */
 406
 407
 408 /**
 409  * Send WALLOPS message.
 410  */
 411 #ifdef PROTOTYPES
 412 GLOBAL void
 413 IRC_SendWallops(CLIENT *Client, CLIENT *From, const char *Format, ...)
 414 #else
 415 GLOBAL void
 416 IRC_SendWallops(Client, From, Format, va_alist )
 417 CLIENT *Client;
 418 CLIENT *From;
 419 char *Format;
 420 va_dcl
 421 #endif
 422 {
 423         va_list ap;
 424         char msg[1000];
 425         CLIENT *to;
 426
 427 #ifdef PROTOTYPES
 428         va_start(ap, Format);
 429 #else
 430         va_start(ap);
 431 #endif
 432         vsnprintf(msg, 1000, Format, ap);
 433         va_end(ap);
 434
 435         for (to=Client_First(); to != NULL; to=Client_Next(to)) {
 436                 if (Client_Conn(to) == NONE) /* no local connection */
 437                         continue;
 438
 439                 switch (Client_Type(to)) {
 440                 case CLIENT_USER:
 441                         if (Client_HasMode(to, 'w'))
 442                                 IRC_WriteStrClientPrefix(to, From,
 443                                                          "WALLOPS :%s", msg);
 444                                 break;
 445                 case CLIENT_SERVER:
 446                         if (to != Client)
 447                                 IRC_WriteStrClientPrefix(to, From,
 448                                                          "WALLOPS :%s", msg);
 449                                 break;
 450                 }
 451         }
 452 } /* IRC_SendWallops */
 453
 454
 455 GLOBAL void
 456 IRC_SetPenalty( CLIENT *Client, time_t Seconds )
 457 {
 458         CONN_ID c;
 459
 460         assert( Client != NULL );
 461         assert( Seconds > 0 );
 462
 463         if( Client_Type( Client ) == CLIENT_SERVER ) return;
 464
 465         c = Client_Conn( Client );
 466         if (c > NONE)
 467                 Conn_SetPenalty(c, Seconds);
 468 } /* IRC_SetPenalty */
 469
 470
 471 static char *
 472 Get_Prefix( CLIENT *Target, CLIENT *Client )
 473 {
 474         assert( Target != NULL );
 475         assert( Client != NULL );
 476
 477         if( Client_Type( Target ) == CLIENT_SERVER ) return Client_ID( Client );
 478         else return Client_Mask( Client );
 479 } /* Get_Prefix */
 480
 481
 482 static void
 483 cb_writeStrServersPrefixFlag(CLIENT *Client, CLIENT *Prefix, void *Buffer)
 484 {
 485         IRC_WriteStrClientPrefix(Client, Prefix, "%s", Buffer);
 486 } /* cb_writeStrServersPrefixFlag */
 487
 488
 489 /* -eof- */