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