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.3 2002/03/25 17:13:07 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
  25 #include "defines.h"
  26
  27 #include "exp.h"
  28 #include "irc-write.h"
  29
  30
  31 LOCAL CHAR *Get_Prefix( CLIENT *Target, CLIENT *Client );
  32
  33
  34 GLOBAL BOOLEAN IRC_WriteStrClient( CLIENT *Client, CHAR *Format, ... )
  35 {
  36         CHAR buffer[1000];
  37         BOOLEAN ok = CONNECTED;
  38         va_list ap;
  39
  40         assert( Client != NULL );
  41         assert( Format != NULL );
  42
  43         va_start( ap, Format );
  44         vsnprintf( buffer, 1000, Format, ap );
  45         va_end( ap );
  46
  47         /* an den Client selber */
  48         ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), buffer );
  49
  50         return ok;
  51 } /* IRC_WriteStrClient */
  52
  53
  54 GLOBAL BOOLEAN IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, CHAR *Format, ... )
  55 {
  56         /* Text an Clients, lokal bzw. remote, senden. */
  57
  58         CHAR buffer[1000];
  59         va_list ap;
  60
  61         assert( Client != NULL );
  62         assert( Format != NULL );
  63         assert( Prefix != NULL );
  64
  65         va_start( ap, Format );
  66         vsnprintf( buffer, 1000, Format, ap );
  67         va_end( ap );
  68
  69         return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Get_Prefix( Client_NextHop( Client ), Prefix ), buffer );
  70 } /* IRC_WriteStrClientPrefix */
  71
  72
  73 GLOBAL BOOLEAN IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, BOOLEAN Remote, CHAR *Format, ... )
  74 {
  75         CHAR buffer[1000];
  76         va_list ap;
  77
  78         assert( Client != NULL );
  79         assert( Format != NULL );
  80
  81         va_start( ap, Format );
  82         vsnprintf( buffer, 1000, Format, ap );
  83         va_end( ap );
  84
  85         return IRC_WriteStrChannelPrefix( Client, Chan, Client_ThisServer( ), Remote, buffer );
  86 } /* IRC_WriteStrChannel */
  87
  88
  89 GLOBAL BOOLEAN IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
  90 {
  91         BOOLEAN sock[MAX_CONNECTIONS], is_server[MAX_CONNECTIONS], ok = CONNECTED;
  92         CHAR buffer[1000];
  93         CL2CHAN *cl2chan;
  94         CLIENT *c;
  95         INT s, i;
  96         va_list ap;
  97
  98         assert( Client != NULL );
  99         assert( Chan != NULL );
 100         assert( Prefix != NULL );
 101         assert( Format != NULL );
 102
 103         va_start( ap, Format );
 104         vsnprintf( buffer, 1000, Format, ap );
 105         va_end( ap );
 106
 107         for( i = 0; i < MAX_CONNECTIONS; i++ ) sock[i] = FALSE;
 108
 109         /* An alle Clients, die in den selben Channels sind.
 110          * Dabei aber nur einmal je Remote-Server */
 111         cl2chan = Channel_FirstMember( Chan );
 112         while( cl2chan )
 113         {
 114                 c = Channel_GetClient( cl2chan );
 115                 if( ! Remote )
 116                 {
 117                         if( Client_Conn( c ) <= NONE ) c = NULL;
 118                         else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 119                 }
 120                 if( c ) c = Client_NextHop( c );
 121
 122                 if( c && ( c != Client ))
 123                 {
 124                         /* Ok, anderer Client */
 125                         s = Client_Conn( c );
 126                         assert( s >= 0 );
 127                         assert( s < MAX_CONNECTIONS );
 128                         sock[s] = TRUE;
 129                         if( Client_Type( c ) == CLIENT_SERVER ) is_server[s] = TRUE;
 130                         else is_server[s] = FALSE;
 131                 }
 132                 cl2chan = Channel_NextMember( Chan, cl2chan );
 133         }
 134
 135         /* Senden ... */
 136         for( i = 0; i < MAX_CONNECTIONS; i++ )
 137         {
 138                 if( sock[i] )
 139                 {
 140                         if( is_server[i] ) ok = Conn_WriteStr( i, ":%s %s", Client_ID( Prefix ), buffer );
 141                         else ok = Conn_WriteStr( i, ":%s %s", Client_Mask( Prefix ), buffer );
 142                         if( ! ok ) break;
 143                 }
 144         }
 145         return ok;
 146 } /* IRC_WriteStrChannelPrefix */
 147
 148
 149 GLOBAL VOID IRC_WriteStrServers( CLIENT *ExceptOf, CHAR *Format, ... )
 150 {
 151         CHAR buffer[1000];
 152         va_list ap;
 153
 154         assert( Format != NULL );
 155
 156         va_start( ap, Format );
 157         vsnprintf( buffer, 1000, Format, ap );
 158         va_end( ap );
 159
 160         /* an den Client selber */
 161         return IRC_WriteStrServersPrefix( ExceptOf, Client_ThisServer( ), buffer );
 162 } /* IRC_WriteStrServers */
 163
 164
 165 GLOBAL VOID IRC_WriteStrServersPrefix( CLIENT *ExceptOf, CLIENT *Prefix, CHAR *Format, ... )
 166 {
 167         CHAR buffer[1000];
 168         CLIENT *c;
 169         va_list ap;
 170
 171         assert( Format != NULL );
 172         assert( Prefix != NULL );
 173
 174         va_start( ap, Format );
 175         vsnprintf( buffer, 1000, Format, ap );
 176         va_end( ap );
 177
 178         c = Client_First( );
 179         while( c )
 180         {
 181                 if(( Client_Type( c ) == CLIENT_SERVER ) && ( Client_Conn( c ) > NONE ) && ( c != Client_ThisServer( )) && ( c != ExceptOf ))
 182                 {
 183                         /* Ziel-Server gefunden */
 184                         IRC_WriteStrClientPrefix( c, Prefix, buffer );
 185                 }
 186                 c = Client_Next( c );
 187         }
 188 } /* IRC_WriteStrServersPrefix */
 189
 190
 191 GLOBAL BOOLEAN IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
 192 {
 193         BOOLEAN sock[MAX_CONNECTIONS], is_server[MAX_CONNECTIONS], ok = CONNECTED;
 194         CL2CHAN *chan_cl2chan, *cl2chan;
 195         CHAR buffer[1000];
 196         CHANNEL *chan;
 197         va_list ap;
 198         CLIENT *c;
 199         INT i, s;
 200
 201         assert( Client != NULL );
 202         assert( Prefix != NULL );
 203         assert( Format != NULL );
 204
 205         va_start( ap, Format );
 206         vsnprintf( buffer, 1000, Format, ap );
 207         va_end( ap );
 208
 209         /* initialisieren */
 210         for( i = 0; i < MAX_CONNECTIONS; i++ ) sock[i] = FALSE;
 211
 212         /* An alle Clients, die in einem Channel mit dem "Ausloeser" sind,
 213          * den Text schicken. An Remote-Server aber jeweils nur einmal. */
 214         chan_cl2chan = Channel_FirstChannelOf( Client );
 215         while( chan_cl2chan )
 216         {
 217                 /* Channel des Users durchsuchen */
 218                 chan = Channel_GetChannel( chan_cl2chan );
 219                 cl2chan = Channel_FirstMember( chan );
 220                 while( cl2chan )
 221                 {
 222                         c = Channel_GetClient( cl2chan );
 223                         if( ! Remote )
 224                         {
 225                                 if( Client_Conn( c ) <= NONE ) c = NULL;
 226                                 else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 227                         }
 228                         if( c ) c = Client_NextHop( c );
 229
 230                         if( c && ( c != Client ))
 231                         {
 232                                 /* Ok, anderer Client */
 233                                 s = Client_Conn( c );
 234                                 assert( s >= 0 );
 235                                 assert( s < MAX_CONNECTIONS );
 236                                 sock[s] = TRUE;
 237                                 if( Client_Type( c ) == CLIENT_SERVER ) is_server[s] = TRUE;
 238                                 else is_server[s] = FALSE;
 239                         }
 240                         cl2chan = Channel_NextMember( chan, cl2chan );
 241                 }
 242
 243                 /* naechsten Channel */
 244                 chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
 245         }
 246
 247         /* Senden ... */
 248         for( i = 0; i < MAX_CONNECTIONS; i++ )
 249         {
 250                 if( sock[i] )
 251                 {
 252                         if( is_server[i] ) ok = Conn_WriteStr( i, ":%s %s", Client_ID( Prefix ), buffer );
 253                         else ok = Conn_WriteStr( i, ":%s %s", Client_Mask( Prefix ), buffer );
 254                         if( ! ok ) break;
 255                 }
 256         }
 257         return ok;
 258 } /* IRC_WriteStrRelatedPrefix */
 259
 260
 261 LOCAL CHAR *Get_Prefix( CLIENT *Target, CLIENT *Client )
 262 {
 263         assert( Target != NULL );
 264         assert( Client != NULL );
 265
 266         if( Client_Type( Target ) == CLIENT_SERVER ) return Client_ID( Client );
 267         else return Client_Mask( Client );
 268 } /* Get_Prefix */
 269
 270
 271 /* -eof- */