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