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