src/ngircd/irc-write.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
   4  *
   5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
   6  * der GNU General Public License (GPL), wie von der Free Software Foundation
   7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
   8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
   9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
  10  * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
  11  *
  12  * $Id: irc-write.c,v 1.10 2002/11/02 22:59:41 alex Exp $
  13  *
  14  * irc-write.c: IRC-Texte und Befehle ueber Netzwerk versenden
  15  */
  16
  17
  18 #include "portab.h"
  19
  20 #include "imp.h"
  21 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include "conn.h"
  27 #include "client.h"
  28 #include "channel.h"
  29 #include "defines.h"
  30
  31 #include "exp.h"
  32 #include "irc-write.h"
  33
  34
  35 LOCAL CHAR *Get_Prefix PARAMS(( CLIENT *Target, CLIENT *Client ));
  36
  37
  38 #ifdef PROTOTYPES
  39 GLOBAL BOOLEAN
  40 IRC_WriteStrClient( CLIENT *Client, CHAR *Format, ... )
  41 #else
  42 GLOBAL BOOLEAN
  43 IRC_WriteStrClient( Client, Format, va_alist )
  44 CLIENT *Client;
  45 CHAR *Format;
  46 va_dcl
  47 #endif
  48 {
  49         CHAR buffer[1000];
  50         BOOLEAN ok = CONNECTED;
  51         va_list ap;
  52
  53         assert( Client != NULL );
  54         assert( Format != NULL );
  55
  56 #ifdef PROTOTYPES
  57         va_start( ap, Format );
  58 #else
  59         va_start( ap );
  60 #endif
  61         vsnprintf( buffer, 1000, Format, ap );
  62         va_end( ap );
  63
  64         /* an den Client selber */
  65         ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), "%s", buffer );
  66
  67         return ok;
  68 } /* IRC_WriteStrClient */
  69
  70
  71 #ifdef PROTOTYPES
  72 GLOBAL BOOLEAN
  73 IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, CHAR *Format, ... )
  74 #else
  75 GLOBAL BOOLEAN
  76 IRC_WriteStrClientPrefix( Client, Prefix, Format, va_alist )
  77 CLIENT *Client;
  78 CLIENT *Prefix;
  79 CHAR *Format;
  80 va_dcl
  81 #endif
  82 {
  83         /* Text an Clients, lokal bzw. remote, senden. */
  84
  85         CHAR buffer[1000];
  86         va_list ap;
  87
  88         assert( Client != NULL );
  89         assert( Format != NULL );
  90         assert( Prefix != NULL );
  91
  92 #ifdef PROTOTYPES
  93         va_start( ap, Format );
  94 #else
  95         va_start( ap );
  96 #endif
  97         vsnprintf( buffer, 1000, Format, ap );
  98         va_end( ap );
  99
 100         return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Get_Prefix( Client_NextHop( Client ), Prefix ), buffer );
 101 } /* IRC_WriteStrClientPrefix */
 102
 103
 104 #ifdef PROTOTYPES
 105 GLOBAL BOOLEAN
 106 IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, BOOLEAN Remote, CHAR *Format, ... )
 107 #else
 108 GLOBAL BOOLEAN
 109 IRC_WriteStrChannel( Client, Chan, Remote, Format, va_alist )
 110 CLIENT *Client;
 111 CHANNEL *Chan;
 112 BOOLEAN Remote;
 113 CHAR *Format;
 114 va_dcl
 115 #endif
 116 {
 117         CHAR buffer[1000];
 118         va_list ap;
 119
 120         assert( Client != NULL );
 121         assert( Format != NULL );
 122
 123 #ifdef PROTOTYPES
 124         va_start( ap, Format );
 125 #else
 126         va_start( ap );
 127 #endif
 128         vsnprintf( buffer, 1000, Format, ap );
 129         va_end( ap );
 130
 131         return IRC_WriteStrChannelPrefix( Client, Chan, Client_ThisServer( ), Remote, "%s", buffer );
 132 } /* IRC_WriteStrChannel */
 133
 134
 135 #ifdef PROTOTYPES
 136 GLOBAL BOOLEAN
 137 IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
 138 #else
 139 GLOBAL BOOLEAN
 140 IRC_WriteStrChannelPrefix( Client, Chan, Prefix, Remote, Format, va_alist )
 141 CLIENT *Client;
 142 CHANNEL *Chan;
 143 CLIENT *Prefix;
 144 BOOLEAN Remote;
 145 CHAR *Format;
 146 va_dcl
 147 #endif
 148 {
 149         BOOLEAN ok = CONNECTED;
 150         CHAR buffer[1000];
 151         CL2CHAN *cl2chan;
 152         CONN_ID conn;
 153         CLIENT *c;
 154         va_list ap;
 155
 156         assert( Client != NULL );
 157         assert( Chan != NULL );
 158         assert( Prefix != NULL );
 159         assert( Format != NULL );
 160
 161 #ifdef PROTOTYPES
 162         va_start( ap, Format );
 163 #else
 164         va_start( ap  );
 165 #endif
 166         vsnprintf( buffer, 1000, Format, ap );
 167         va_end( ap );
 168
 169         Conn_ClearFlags( );
 170
 171         /* An alle Clients, die in den selben Channels sind.
 172          * Dabei aber nur einmal je Remote-Server */
 173         cl2chan = Channel_FirstMember( Chan );
 174         while( cl2chan )
 175         {
 176                 c = Channel_GetClient( cl2chan );
 177                 if( ! Remote )
 178                 {
 179                         if( Client_Conn( c ) <= NONE ) c = NULL;
 180                         else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 181                 }
 182                 if( c ) c = Client_NextHop( c );
 183
 184                 if( c && ( c != Client ))
 185                 {
 186                         /* Ok, anderer Client */
 187                         conn = Client_Conn( c );
 188                         Conn_SetFlag( conn );
 189                 }
 190                 cl2chan = Channel_NextMember( Chan, cl2chan );
 191         }
 192
 193         /* Senden ... */
 194         conn = Conn_First( );
 195         while( conn != NONE )
 196         {
 197                 if( Conn_Flag( conn ))
 198                 {
 199                         if( Client_Type( Client_GetFromConn( conn )) == CLIENT_SERVER )
 200                         {
 201                                 /* Ziel-Client ist ein anderer Server */
 202                                 ok = Conn_WriteStr( conn, ":%s %s", Client_ID( Prefix ), buffer );
 203                         }
 204                         else ok = Conn_WriteStr( conn, ":%s %s", Client_Mask( Prefix ), buffer );
 205                         if( ! ok ) break;
 206                 }
 207                 conn = Conn_Next( conn );
 208         }
 209
 210         return ok;
 211 } /* IRC_WriteStrChannelPrefix */
 212
 213
 214 #ifdef PROTOTYPES
 215 GLOBAL VOID
 216 IRC_WriteStrServers( CLIENT *ExceptOf, CHAR *Format, ... )
 217 #else
 218 GLOBAL VOID
 219 IRC_WriteStrServers( ExceptOf, Format, va_alist )
 220 CLIENT *ExceptOf;
 221 CHAR *Format;
 222 va_dcl
 223 #endif
 224 {
 225         CHAR buffer[1000];
 226         va_list ap;
 227
 228         assert( Format != NULL );
 229
 230 #ifdef PROTOTYPES
 231         va_start( ap, Format );
 232 #else
 233         va_start( ap );
 234 #endif
 235         vsnprintf( buffer, 1000, Format, ap );
 236         va_end( ap );
 237
 238         /* an den Client selber */
 239         IRC_WriteStrServersPrefix( ExceptOf, Client_ThisServer( ), "%s", buffer );
 240 } /* IRC_WriteStrServers */
 241
 242
 243 #ifdef PROTOTYPES
 244 GLOBAL VOID
 245 IRC_WriteStrServersPrefix( CLIENT *ExceptOf, CLIENT *Prefix, CHAR *Format, ... )
 246 #else
 247 GLOBAL VOID
 248 IRC_WriteStrServersPrefix( ExceptOf, Prefix, Format, va_alist )
 249 CLIENT *ExceptOf;
 250 CLIENT *Prefix;
 251 CHAR *Format;
 252 va_dcl
 253 #endif
 254 {
 255         CHAR buffer[1000];
 256         va_list ap;
 257
 258         assert( Format != NULL );
 259         assert( Prefix != NULL );
 260
 261 #ifdef PROTOTYPES
 262         va_start( ap, Format );
 263 #else
 264         va_start( ap );
 265 #endif
 266         vsnprintf( buffer, 1000, Format, ap );
 267         va_end( ap );
 268
 269         IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, '\0', "%s", buffer );
 270 } /* IRC_WriteStrServersPrefix */
 271
 272
 273 #ifdef PROTOTYPES
 274 GLOBAL VOID
 275 IRC_WriteStrServersPrefixFlag( CLIENT *ExceptOf, CLIENT *Prefix, CHAR Flag, CHAR *Format, ... )
 276 #else
 277 GLOBAL VOID
 278 IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, Flag, Format, va_alist )
 279 CLIENT *ExceptOf;
 280 CLIENT *Prefix;
 281 CHAR Flag;
 282 CHAR *Format;
 283 va_dcl
 284 #endif
 285 {
 286         CHAR buffer[1000];
 287         CLIENT *c;
 288         va_list ap;
 289
 290         assert( Format != NULL );
 291         assert( Prefix != NULL );
 292
 293 #ifdef PROTOTYPES
 294         va_start( ap, Format );
 295 #else
 296         va_start( ap );
 297 #endif
 298         vsnprintf( buffer, 1000, Format, ap );
 299         va_end( ap );
 300
 301         c = Client_First( );
 302         while( c )
 303         {
 304                 if(( Client_Type( c ) == CLIENT_SERVER ) && ( Client_Conn( c ) > NONE ) && ( c != Client_ThisServer( )) && ( c != ExceptOf ))
 305                 {
 306                         /* Ziel-Server gefunden. Nun noch pruefen, ob Flags stimmen */
 307                         if(( Flag == '\0' ) || ( strchr( Client_Flags( c ), Flag ) != NULL )) IRC_WriteStrClientPrefix( c, Prefix, "%s", buffer );
 308                 }
 309                 c = Client_Next( c );
 310         }
 311 } /* IRC_WriteStrServersPrefixFlag */
 312
 313
 314 #ifdef PROTOTYPES
 315 GLOBAL BOOLEAN
 316 IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
 317 #else
 318 GLOBAL BOOLEAN
 319 IRC_WriteStrRelatedPrefix( Client, Prefix, Remote, Format, va_alist )
 320 CLIENT *Client;
 321 CLIENT *Prefix;
 322 BOOLEAN Remote;
 323 CHAR *Format;
 324 va_dcl
 325 #endif
 326 {
 327         BOOLEAN ok = CONNECTED;
 328         CL2CHAN *chan_cl2chan, *cl2chan;
 329         CHAR buffer[1000];
 330         CHANNEL *chan;
 331         CONN_ID conn;
 332         va_list ap;
 333         CLIENT *c;
 334
 335         assert( Client != NULL );
 336         assert( Prefix != NULL );
 337         assert( Format != NULL );
 338
 339 #ifdef PROTOTYPES
 340         va_start( ap, Format );
 341 #else
 342         va_start( ap );
 343 #endif
 344         vsnprintf( buffer, 1000, Format, ap );
 345         va_end( ap );
 346
 347         /* initialisieren */
 348         Conn_ClearFlags( );
 349
 350         /* An alle Clients, die in einem Channel mit dem "Ausloeser" sind,
 351          * den Text schicken. An Remote-Server aber jeweils nur einmal. */
 352         chan_cl2chan = Channel_FirstChannelOf( Client );
 353         while( chan_cl2chan )
 354         {
 355                 /* Channel des Users durchsuchen */
 356                 chan = Channel_GetChannel( chan_cl2chan );
 357                 cl2chan = Channel_FirstMember( chan );
 358                 while( cl2chan )
 359                 {
 360                         c = Channel_GetClient( cl2chan );
 361                         if( ! Remote )
 362                         {
 363                                 if( Client_Conn( c ) <= NONE ) c = NULL;
 364                                 else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 365                         }
 366                         if( c ) c = Client_NextHop( c );
 367
 368                         if( c && ( c != Client ))
 369                         {
 370                                 /* Ok, anderer Client */
 371                                 conn = Client_Conn( c );
 372                                 Conn_Flag( conn );
 373                         }
 374                         cl2chan = Channel_NextMember( chan, cl2chan );
 375                 }
 376
 377                 /* naechsten Channel */
 378                 chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
 379         }
 380
 381         /* Senden ... */
 382         conn = Conn_First( );
 383         while( conn != NONE )
 384         {
 385                 if( Conn_Flag( conn ))
 386                 {
 387                         if( Client_Type( Client_GetFromConn( conn )) == CLIENT_SERVER )
 388                         {
 389                                 /* Ziel ist ein anderer Server */
 390                                 ok = Conn_WriteStr( conn, ":%s %s", Client_ID( Prefix ), buffer );
 391                         }
 392                         else ok = Conn_WriteStr( conn, ":%s %s", Client_Mask( Prefix ), buffer );
 393                         if( ! ok ) break;
 394                 }
 395                 conn = Conn_Next( conn );
 396         }
 397         return ok;
 398 } /* IRC_WriteStrRelatedPrefix */
 399
 400
 401 LOCAL CHAR *
 402 Get_Prefix( CLIENT *Target, CLIENT *Client )
 403 {
 404         assert( Target != NULL );
 405         assert( Client != NULL );
 406
 407         if( Client_Type( Target ) == CLIENT_SERVER ) return Client_ID( Client );
 408         else return Client_Mask( Client );
 409 } /* Get_Prefix */
 410
 411
 412 /* -eof- */