src/ngircd/irc-write.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2005 by 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 static char UNUSED id[] = "$Id: irc-write.c,v 1.21 2006/08/12 11:56:24 fw Exp $";
  18
  19 #include "imp.h"
  20 #include <assert.h>
  21 #ifdef PROTOTYPES
  22 #       include <stdarg.h>
  23 #else
  24 #       include <varargs.h>
  25 #endif
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "defines.h"
  30 #include "conn-func.h"
  31 #include "client.h"
  32 #include "channel.h"
  33
  34 #include "exp.h"
  35 #include "irc-write.h"
  36
  37
  38 #define SEND_TO_USER 1
  39 #define SEND_TO_SERVER 2
  40
  41
  42 static char *Get_Prefix PARAMS((CLIENT *Target, CLIENT *Client));
  43 static void cb_writeStrServersPrefixFlag PARAMS((CLIENT *Client,
  44                                          CLIENT *Prefix, void *Buffer));
  45
  46
  47 #ifdef PROTOTYPES
  48 GLOBAL bool
  49 IRC_WriteStrClient( CLIENT *Client, char *Format, ... )
  50 #else
  51 GLOBAL bool
  52 IRC_WriteStrClient( Client, Format, va_alist )
  53 CLIENT *Client;
  54 char *Format;
  55 va_dcl
  56 #endif
  57 {
  58         char buffer[1000];
  59         bool ok = CONNECTED;
  60         va_list ap;
  61
  62         assert( Client != NULL );
  63         assert( Format != NULL );
  64
  65 #ifdef PROTOTYPES
  66         va_start( ap, Format );
  67 #else
  68         va_start( ap );
  69 #endif
  70         vsnprintf( buffer, 1000, Format, ap );
  71         va_end( ap );
  72
  73         /* an den Client selber */
  74         ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), "%s", buffer );
  75
  76         return ok;
  77 } /* IRC_WriteStrClient */
  78
  79
  80 #ifdef PROTOTYPES
  81 GLOBAL bool
  82 IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, char *Format, ... )
  83 #else
  84 GLOBAL bool
  85 IRC_WriteStrClientPrefix( Client, Prefix, Format, va_alist )
  86 CLIENT *Client;
  87 CLIENT *Prefix;
  88 char *Format;
  89 va_dcl
  90 #endif
  91 {
  92         /* Text an Clients, lokal bzw. remote, senden. */
  93
  94         char buffer[1000];
  95         va_list ap;
  96
  97         assert( Client != NULL );
  98         assert( Format != NULL );
  99         assert( Prefix != NULL );
 100
 101 #ifdef PROTOTYPES
 102         va_start( ap, Format );
 103 #else
 104         va_start( ap );
 105 #endif
 106         vsnprintf( buffer, 1000, Format, ap );
 107         va_end( ap );
 108
 109         return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Get_Prefix( Client_NextHop( Client ), Prefix ), buffer );
 110 } /* IRC_WriteStrClientPrefix */
 111
 112
 113 #ifdef PROTOTYPES
 114 GLOBAL bool
 115 IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, bool Remote, 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 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 #ifdef PROTOTYPES
 145 GLOBAL bool
 146 IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, bool Remote, char *Format, ... )
 147 #else
 148 GLOBAL bool
 149 IRC_WriteStrChannelPrefix( Client, Chan, Prefix, Remote, Format, va_alist )
 150 CLIENT *Client;
 151 CHANNEL *Chan;
 152 CLIENT *Prefix;
 153 bool Remote;
 154 char *Format;
 155 va_dcl
 156 #endif
 157 {
 158         bool ok = CONNECTED;
 159         char buffer[1000];
 160         CL2CHAN *cl2chan;
 161         CONN_ID conn;
 162         CLIENT *c;
 163         va_list ap;
 164
 165         assert( Client != NULL );
 166         assert( Chan != NULL );
 167         assert( Prefix != NULL );
 168         assert( Format != NULL );
 169
 170 #ifdef PROTOTYPES
 171         va_start( ap, Format );
 172 #else
 173         va_start( ap  );
 174 #endif
 175         vsnprintf( buffer, 1000, Format, ap );
 176         va_end( ap );
 177
 178         Conn_ClearFlags( );
 179
 180         /* An alle Clients, die in den selben Channels sind.
 181          * Dabei aber nur einmal je Remote-Server */
 182         cl2chan = Channel_FirstMember( Chan );
 183         while( cl2chan )
 184         {
 185                 c = Channel_GetClient( cl2chan );
 186                 if( ! Remote )
 187                 {
 188                         if( Client_Conn( c ) <= NONE ) c = NULL;
 189                         else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 190                 }
 191                 if( c ) c = Client_NextHop( c );
 192
 193                 if( c && ( c != Client ))
 194                 {
 195                         /* Ok, anderer Client */
 196                         conn = Client_Conn( c );
 197                         if( Client_Type( c ) == CLIENT_SERVER ) Conn_SetFlag( conn, SEND_TO_SERVER );
 198                         else Conn_SetFlag( conn, SEND_TO_USER );
 199                 }
 200                 cl2chan = Channel_NextMember( Chan, cl2chan );
 201         }
 202
 203         /* Senden: alle Verbindungen durchgehen ... */
 204         conn = Conn_First( );
 205         while( conn != NONE )
 206         {
 207                 /* muessen Daten ueber diese Verbindung verschickt werden? */
 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                 /* naechste Verbindung testen */
 213                 conn = Conn_Next( conn );
 214         }
 215
 216         return ok;
 217 } /* IRC_WriteStrChannelPrefix */
 218
 219
 220 #ifdef PROTOTYPES
 221 GLOBAL void
 222 IRC_WriteStrServers( CLIENT *ExceptOf, char *Format, ... )
 223 #else
 224 GLOBAL void
 225 IRC_WriteStrServers( ExceptOf, Format, va_alist )
 226 CLIENT *ExceptOf;
 227 char *Format;
 228 va_dcl
 229 #endif
 230 {
 231         char buffer[1000];
 232         va_list ap;
 233
 234         assert( Format != NULL );
 235
 236 #ifdef PROTOTYPES
 237         va_start( ap, Format );
 238 #else
 239         va_start( ap );
 240 #endif
 241         vsnprintf( buffer, 1000, Format, ap );
 242         va_end( ap );
 243
 244         /* an den Client selber */
 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, char *Format, ... )
 252 #else
 253 GLOBAL void
 254 IRC_WriteStrServersPrefix( ExceptOf, Prefix, Format, va_alist )
 255 CLIENT *ExceptOf;
 256 CLIENT *Prefix;
 257 char *Format;
 258 va_dcl
 259 #endif
 260 {
 261         char buffer[1000];
 262         va_list ap;
 263
 264         assert( Format != NULL );
 265         assert( Prefix != NULL );
 266
 267 #ifdef PROTOTYPES
 268         va_start( ap, Format );
 269 #else
 270         va_start( ap );
 271 #endif
 272         vsnprintf( buffer, 1000, Format, ap );
 273         va_end( ap );
 274
 275         IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, '\0', "%s", buffer );
 276 } /* IRC_WriteStrServersPrefix */
 277
 278
 279 #ifdef PROTOTYPES
 280 GLOBAL void
 281 IRC_WriteStrServersPrefixFlag( CLIENT *ExceptOf, CLIENT *Prefix, char Flag, char *Format, ... )
 282 #else
 283 GLOBAL void
 284 IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, Flag, Format, va_alist )
 285 CLIENT *ExceptOf;
 286 CLIENT *Prefix;
 287 char Flag;
 288 char *Format;
 289 va_dcl
 290 #endif
 291 {
 292         char buffer[1000];
 293         va_list ap;
 294
 295         assert( Format != NULL );
 296         assert( Prefix != NULL );
 297
 298 #ifdef PROTOTYPES
 299         va_start( ap, Format );
 300 #else
 301         va_start( ap );
 302 #endif
 303         vsnprintf( buffer, 1000, Format, ap );
 304         va_end( ap );
 305
 306         IRC_WriteStrServersPrefixFlag_CB(ExceptOf, Prefix, Flag,
 307                                          cb_writeStrServersPrefixFlag, buffer);
 308 } /* IRC_WriteStrServersPrefixFlag */
 309
 310
 311 GLOBAL void
 312 IRC_WriteStrServersPrefixFlag_CB(CLIENT *ExceptOf, CLIENT *Prefix, char Flag,
 313                 void (*callback)(CLIENT *, CLIENT *, void *), void *cb_data)
 314 {
 315         CLIENT *c;
 316
 317         c = Client_First();
 318         while(c) {
 319                 if (Client_Type(c) == CLIENT_SERVER && Client_Conn(c) > NONE &&
 320                     c != Client_ThisServer() && c != ExceptOf) {
 321                         /* Found a target server, do the flags match? */
 322                         if (Flag == '\0' || strchr(Client_Flags(c), Flag))
 323                                 callback(c, Prefix, cb_data);
 324                 }
 325                 c = Client_Next(c);
 326         }
 327 } /* IRC_WriteStrServersPrefixFlag */
 328
 329
 330 #ifdef PROTOTYPES
 331 GLOBAL bool
 332 IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, bool Remote, char *Format, ... )
 333 #else
 334 GLOBAL bool
 335 IRC_WriteStrRelatedPrefix( Client, Prefix, Remote, Format, va_alist )
 336 CLIENT *Client;
 337 CLIENT *Prefix;
 338 bool Remote;
 339 char *Format;
 340 va_dcl
 341 #endif
 342 {
 343         bool ok = CONNECTED;
 344         CL2CHAN *chan_cl2chan, *cl2chan;
 345         char buffer[1000];
 346         CHANNEL *chan;
 347         CONN_ID conn;
 348         va_list ap;
 349         CLIENT *c;
 350
 351         assert( Client != NULL );
 352         assert( Prefix != NULL );
 353         assert( Format != NULL );
 354
 355 #ifdef PROTOTYPES
 356         va_start( ap, Format );
 357 #else
 358         va_start( ap );
 359 #endif
 360         vsnprintf( buffer, 1000, Format, ap );
 361         va_end( ap );
 362
 363         /* initialisieren */
 364         Conn_ClearFlags( );
 365
 366         /* An alle Clients, die in einem Channel mit dem "Ausloeser" sind,
 367          * den Text schicken. An Remote-Server aber jeweils nur einmal. */
 368         chan_cl2chan = Channel_FirstChannelOf( Client );
 369         while( chan_cl2chan )
 370         {
 371                 /* Channel des Users durchsuchen */
 372                 chan = Channel_GetChannel( chan_cl2chan );
 373                 cl2chan = Channel_FirstMember( chan );
 374                 while( cl2chan )
 375                 {
 376                         c = Channel_GetClient( cl2chan );
 377                         if( ! Remote )
 378                         {
 379                                 if( Client_Conn( c ) <= NONE ) c = NULL;
 380                                 else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 381                         }
 382                         if( c ) c = Client_NextHop( c );
 383
 384                         if( c && ( c != Client ))
 385                         {
 386                                 /* Ok, anderer Client */
 387                                 conn = Client_Conn( c );
 388                                 if( Client_Type( c ) == CLIENT_SERVER ) Conn_SetFlag( conn, SEND_TO_SERVER );
 389                                 else Conn_SetFlag( conn, SEND_TO_USER );
 390                         }
 391                         cl2chan = Channel_NextMember( chan, cl2chan );
 392                 }
 393
 394                 /* naechsten Channel */
 395                 chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
 396         }
 397
 398         /* Senden: alle Verbindungen durchgehen ... */
 399         conn = Conn_First( );
 400         while( conn != NONE )
 401         {
 402                 /* muessen ueber diese Verbindung Daten gesendet werden? */
 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                 /* naechste Verbindung testen */
 408                 conn = Conn_Next( conn );
 409         }
 410         return ok;
 411 } /* IRC_WriteStrRelatedPrefix */
 412
 413
 414 GLOBAL void
 415 IRC_SetPenalty( CLIENT *Client, time_t Seconds )
 416 {
 417         CONN_ID c;
 418
 419         assert( Client != NULL );
 420         assert( Seconds > 0 );
 421
 422         if( Client_Type( Client ) == CLIENT_SERVER ) return;
 423
 424         c = Client_Conn( Client );
 425         if (c > NONE)
 426                 Conn_SetPenalty(c, Seconds);
 427 } /* IRC_SetPenalty */
 428
 429
 430 static char *
 431 Get_Prefix( CLIENT *Target, CLIENT *Client )
 432 {
 433         assert( Target != NULL );
 434         assert( Client != NULL );
 435
 436         if( Client_Type( Target ) == CLIENT_SERVER ) return Client_ID( Client );
 437         else return Client_Mask( Client );
 438 } /* Get_Prefix */
 439
 440
 441 static void
 442 cb_writeStrServersPrefixFlag(CLIENT *Client, CLIENT *Prefix, void *Buffer)
 443 {
 444         IRC_WriteStrClientPrefix(Client, Prefix, "%s", Buffer);
 445 } /* cb_writeStrServersPrefixFlag */
 446
 447
 448 /* -eof- */