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