Annotation of ircnowd/src/ngircd/irc-write.c, Revision 1.1
1.1 ! tomglok 1: /*
! 2: * ngIRCd -- The Next Generation IRC Daemon
! 3: * Copyright (c)2001-2018 Alexander Barton (alex@barton.de) and Contributors.
! 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:
! 12: #include "portab.h"
! 13:
! 14: /**
! 15: * @file
! 16: * Sending IRC commands over the network
! 17: */
! 18:
! 19: #include <assert.h>
! 20: #ifdef PROTOTYPES
! 21: # include <stdarg.h>
! 22: #else
! 23: # include <varargs.h>
! 24: #endif
! 25: #include <stdio.h>
! 26:
! 27: #include "conn-func.h"
! 28: #include "channel.h"
! 29:
! 30: #include "irc-write.h"
! 31:
! 32: #define SEND_TO_USER 1
! 33: #define SEND_TO_SERVER 2
! 34:
! 35: static const char *Get_Prefix PARAMS((CLIENT *Target, CLIENT *Client));
! 36: static void cb_writeStrServersPrefixFlag PARAMS((CLIENT *Client,
! 37: CLIENT *Prefix, void *Buffer));
! 38: static void Send_Marked_Connections PARAMS((CLIENT *Prefix, const char *Buffer));
! 39:
! 40: /**
! 41: * Send an error message to a client and enforce a penalty time.
! 42: *
! 43: * @param Client The target client.
! 44: * @param Format Format string.
! 45: * @return CONNECTED or DISCONNECTED.
! 46: */
! 47: #ifdef PROTOTYPES
! 48: GLOBAL bool
! 49: IRC_WriteErrClient( CLIENT *Client, const char *Format, ... )
! 50: #else
! 51: GLOBAL bool
! 52: IRC_WriteErrClient( Client, Format, va_alist )
! 53: CLIENT *Client;
! 54: const char *Format;
! 55: va_dcl
! 56: #endif
! 57: {
! 58: char buffer[1000];
! 59: va_list ap;
! 60:
! 61: assert(Client != NULL);
! 62: assert(Format != NULL);
! 63:
! 64: #ifdef PROTOTYPES
! 65: va_start(ap, Format);
! 66: #else
! 67: va_start(ap);
! 68: #endif
! 69: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 70: va_end(ap);
! 71:
! 72: IRC_SetPenalty(Client, 2);
! 73: return IRC_WriteStrClientPrefix(Client, Client_ThisServer(),
! 74: "%s", buffer);
! 75: }
! 76:
! 77: /**
! 78: * Send a message to a client.
! 79: *
! 80: * @param Client The target client.
! 81: * @param Format Format string.
! 82: * @return CONNECTED or DISCONNECTED.
! 83: */
! 84: #ifdef PROTOTYPES
! 85: GLOBAL bool
! 86: IRC_WriteStrClient( CLIENT *Client, const char *Format, ... )
! 87: #else
! 88: GLOBAL bool
! 89: IRC_WriteStrClient( Client, Format, va_alist )
! 90: CLIENT *Client;
! 91: const char *Format;
! 92: va_dcl
! 93: #endif
! 94: {
! 95: char buffer[1000];
! 96: va_list ap;
! 97:
! 98: assert(Client != NULL);
! 99: assert(Format != NULL);
! 100:
! 101: #ifdef PROTOTYPES
! 102: va_start(ap, Format);
! 103: #else
! 104: va_start(ap);
! 105: #endif
! 106: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 107: va_end(ap);
! 108:
! 109: return IRC_WriteStrClientPrefix(Client, Client_ThisServer(),
! 110: "%s", buffer);
! 111: }
! 112:
! 113: /**
! 114: * Send a message to a client using a specific prefix.
! 115: *
! 116: * @param Client The target client.
! 117: * @param Prefix The prefix to use.
! 118: * @param Format Format string.
! 119: * @return CONNECTED or DISCONNECTED.
! 120: */
! 121: #ifdef PROTOTYPES
! 122: GLOBAL bool
! 123: IRC_WriteStrClientPrefix(CLIENT *Client, CLIENT *Prefix, const char *Format, ...)
! 124: #else
! 125: GLOBAL bool
! 126: IRC_WriteStrClientPrefix(Client, Prefix, Format, va_alist)
! 127: CLIENT *Client;
! 128: CLIENT *Prefix;
! 129: const char *Format;
! 130: va_dcl
! 131: #endif
! 132: {
! 133: /* send text to local and remote clients */
! 134:
! 135: char buffer[1000];
! 136: va_list ap;
! 137:
! 138: assert( Client != NULL );
! 139: assert( Format != NULL );
! 140: assert( Prefix != NULL );
! 141:
! 142: #ifdef PROTOTYPES
! 143: va_start( ap, Format );
! 144: #else
! 145: va_start( ap );
! 146: #endif
! 147: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 148: va_end( ap );
! 149:
! 150: return Conn_WriteStr(Client_Conn(Client_NextHop(Client)), ":%s %s",
! 151: Get_Prefix(Client_NextHop(Client), Prefix), buffer);
! 152: }
! 153:
! 154: /**
! 155: * Send a message to all client in a channel.
! 156: *
! 157: * The message is only sent once per remote server.
! 158: *
! 159: * @param Client The sending client, excluded while forwarding the message.
! 160: * @param Channel The target channel.
! 161: * @param Remote If not set, the message is sent to local clients only.
! 162: * @param Format Format string.
! 163: */
! 164: #ifdef PROTOTYPES
! 165: GLOBAL void
! 166: IRC_WriteStrChannel(CLIENT *Client, CHANNEL *Chan, bool Remote,
! 167: const char *Format, ...)
! 168: #else
! 169: GLOBAL void
! 170: IRC_WriteStrChannel(Client, Chan, Remote, Format, va_alist)
! 171: CLIENT *Client;
! 172: CHANNEL *Chan;
! 173: bool Remote;
! 174: const char *Format;
! 175: va_dcl
! 176: #endif
! 177: {
! 178: char buffer[1000];
! 179: va_list ap;
! 180:
! 181: assert( Client != NULL );
! 182: assert( Format != NULL );
! 183:
! 184: #ifdef PROTOTYPES
! 185: va_start( ap, Format );
! 186: #else
! 187: va_start( ap );
! 188: #endif
! 189: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 190: va_end( ap );
! 191:
! 192: IRC_WriteStrChannelPrefix(Client, Chan, Client_ThisServer(),
! 193: Remote, "%s", buffer);
! 194: }
! 195:
! 196: /**
! 197: * Send a message to all client in a channel using a specific prefix.
! 198: *
! 199: * The message is only sent once per remote server.
! 200: *
! 201: * @param Client The sending client, excluded while forwarding the message.
! 202: * @param Channel The target channel.
! 203: * @param Prefix The prefix to use.
! 204: * @param Remote If not set, the message is sent to local clients only.
! 205: * @param Format Format string.
! 206: */
! 207: #ifdef PROTOTYPES
! 208: GLOBAL void
! 209: IRC_WriteStrChannelPrefix(CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix,
! 210: bool Remote, const char *Format, ...)
! 211: #else
! 212: GLOBAL void
! 213: IRC_WriteStrChannelPrefix(Client, Chan, Prefix, Remote, Format, va_alist)
! 214: CLIENT *Client;
! 215: CHANNEL *Chan;
! 216: CLIENT *Prefix;
! 217: bool Remote;
! 218: const char *Format;
! 219: va_dcl
! 220: #endif
! 221: {
! 222: char buffer[1000];
! 223: CL2CHAN *cl2chan;
! 224: CONN_ID conn;
! 225: CLIENT *c;
! 226: va_list ap;
! 227:
! 228: assert( Client != NULL );
! 229: assert( Chan != NULL );
! 230: assert( Prefix != NULL );
! 231: assert( Format != NULL );
! 232:
! 233: #ifdef PROTOTYPES
! 234: va_start( ap, Format );
! 235: #else
! 236: va_start( ap );
! 237: #endif
! 238: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 239: va_end( ap );
! 240:
! 241: Conn_ClearFlags( );
! 242:
! 243: cl2chan = Channel_FirstMember( Chan );
! 244: while(cl2chan) {
! 245: c = Channel_GetClient( cl2chan );
! 246: if (!Remote) {
! 247: if (Client_Conn(c) <= NONE)
! 248: c = NULL;
! 249: else if(Client_Type(c) == CLIENT_SERVER)
! 250: c = NULL;
! 251: }
! 252: if(c)
! 253: c = Client_NextHop(c);
! 254:
! 255: if(c && c != Client) {
! 256: /* Ok, another Client */
! 257: conn = Client_Conn(c);
! 258: if (Client_Type(c) == CLIENT_SERVER)
! 259: Conn_SetFlag(conn, SEND_TO_SERVER);
! 260: else
! 261: Conn_SetFlag(conn, SEND_TO_USER);
! 262: }
! 263: cl2chan = Channel_NextMember(Chan, cl2chan);
! 264: }
! 265: Send_Marked_Connections(Prefix, buffer);
! 266: }
! 267:
! 268: /**
! 269: * Send a message to all the servers in the network.
! 270: *
! 271: * @param Client The sending client, excluded while forwarding the message.
! 272: * @param Format Format string.
! 273: */
! 274: #ifdef PROTOTYPES
! 275: GLOBAL void
! 276: IRC_WriteStrServers(CLIENT *ExceptOf, const char *Format, ...)
! 277: #else
! 278: GLOBAL void
! 279: IRC_WriteStrServers(ExceptOf, Format, va_alist)
! 280: CLIENT *ExceptOf;
! 281: const char *Format;
! 282: va_dcl
! 283: #endif
! 284: {
! 285: char buffer[1000];
! 286: va_list ap;
! 287:
! 288: assert( Format != NULL );
! 289:
! 290: #ifdef PROTOTYPES
! 291: va_start( ap, Format );
! 292: #else
! 293: va_start( ap );
! 294: #endif
! 295: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 296: va_end( ap );
! 297:
! 298: IRC_WriteStrServersPrefix(ExceptOf, Client_ThisServer(), "%s", buffer);
! 299: }
! 300:
! 301: /**
! 302: * Send a message to all the servers in the network using a specific prefix.
! 303: *
! 304: * @param Client The sending client, excluded while forwarding the message.
! 305: * @param Prefix The prefix to use.
! 306: * @param Format Format string.
! 307: */
! 308: #ifdef PROTOTYPES
! 309: GLOBAL void
! 310: IRC_WriteStrServersPrefix(CLIENT *ExceptOf, CLIENT *Prefix,
! 311: const char *Format, ...)
! 312: #else
! 313: GLOBAL void
! 314: IRC_WriteStrServersPrefix(ExceptOf, Prefix, Format, va_alist)
! 315: CLIENT *ExceptOf;
! 316: CLIENT *Prefix;
! 317: const char *Format;
! 318: va_dcl
! 319: #endif
! 320: {
! 321: char buffer[1000];
! 322: va_list ap;
! 323:
! 324: assert( Format != NULL );
! 325: assert( Prefix != NULL );
! 326:
! 327: #ifdef PROTOTYPES
! 328: va_start( ap, Format );
! 329: #else
! 330: va_start( ap );
! 331: #endif
! 332: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 333: va_end( ap );
! 334:
! 335: IRC_WriteStrServersPrefixFlag( ExceptOf, Prefix, '\0', "%s", buffer );
! 336: }
! 337:
! 338: /**
! 339: * Send a message to all the servers in the network using a specific prefix
! 340: * and matching a "client flag".
! 341: *
! 342: * @param Client The sending client, excluded while forwarding the message.
! 343: * @param Prefix The prefix to use.
! 344: * @param Flag Client flag that must be set on the target.
! 345: * @param Format Format string.
! 346: */
! 347: #ifdef PROTOTYPES
! 348: GLOBAL void
! 349: IRC_WriteStrServersPrefixFlag(CLIENT *ExceptOf, CLIENT *Prefix, char Flag,
! 350: const char *Format, ...)
! 351: #else
! 352: GLOBAL void
! 353: IRC_WriteStrServersPrefixFlag(ExceptOf, Prefix, Flag, Format, va_alist)
! 354: CLIENT *ExceptOf;
! 355: CLIENT *Prefix;
! 356: char Flag;
! 357: const char *Format;
! 358: va_dcl
! 359: #endif
! 360: {
! 361: char buffer[1000];
! 362: va_list ap;
! 363:
! 364: assert( Format != NULL );
! 365: assert( Prefix != NULL );
! 366:
! 367: #ifdef PROTOTYPES
! 368: va_start( ap, Format );
! 369: #else
! 370: va_start( ap );
! 371: #endif
! 372: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 373: va_end( ap );
! 374:
! 375: IRC_WriteStrServersPrefixFlag_CB(ExceptOf, Prefix, Flag,
! 376: cb_writeStrServersPrefixFlag, buffer);
! 377: }
! 378:
! 379: /**
! 380: * Send a message to all the servers in the network using a specific prefix
! 381: * and matching a "client flag" using a callback function.
! 382: *
! 383: * @param ExceptOf The sending client, excluded while forwarding the message.
! 384: * @param Prefix The prefix to use.
! 385: * @param Flag Client flag that must be set on the target.
! 386: * @param callback Callback function.
! 387: */
! 388: GLOBAL void
! 389: IRC_WriteStrServersPrefixFlag_CB(CLIENT *ExceptOf, CLIENT *Prefix, char Flag,
! 390: void (*callback)(CLIENT *, CLIENT *, void *), void *cb_data)
! 391: {
! 392: CLIENT *c;
! 393:
! 394: c = Client_First();
! 395: while(c) {
! 396: if (Client_Type(c) == CLIENT_SERVER && Client_Conn(c) > NONE &&
! 397: c != Client_ThisServer() && c != ExceptOf) {
! 398: /* Found a target server, do the flags match? */
! 399: if (Flag == '\0' || Client_HasFlag(c, Flag))
! 400: callback(c, Prefix, cb_data);
! 401: }
! 402: c = Client_Next(c);
! 403: }
! 404: }
! 405:
! 406: /**
! 407: * Send a message to all "related" clients.
! 408: *
! 409: * Related clients are the one that share one ore more channels with the client
! 410: * sending this message.
! 411: *
! 412: * The message is only sent once per remote server.
! 413: *
! 414: * @param Client The sending client, excluded while forwarding the message.
! 415: * @param Prefix The prefix to use.
! 416: * @param Remote If not set, the message is sent to local clients only.
! 417: * @param Format Format string.
! 418: */
! 419: #ifdef PROTOTYPES
! 420: GLOBAL void
! 421: IRC_WriteStrRelatedPrefix(CLIENT *Client, CLIENT *Prefix, bool Remote,
! 422: const char *Format, ...)
! 423: #else
! 424: GLOBAL void
! 425: IRC_WriteStrRelatedPrefix(Client, Prefix, Remote, Format, va_alist)
! 426: CLIENT *Client;
! 427: CLIENT *Prefix;
! 428: bool Remote;
! 429: const char *Format;
! 430: va_dcl
! 431: #endif
! 432: {
! 433: CL2CHAN *chan_cl2chan, *cl2chan;
! 434: char buffer[1000];
! 435: CHANNEL *chan;
! 436: CONN_ID conn;
! 437: va_list ap;
! 438: CLIENT *c;
! 439:
! 440: assert( Client != NULL );
! 441: assert( Prefix != NULL );
! 442: assert( Format != NULL );
! 443:
! 444: #ifdef PROTOTYPES
! 445: va_start( ap, Format );
! 446: #else
! 447: va_start( ap );
! 448: #endif
! 449: vsnprintf(buffer, sizeof(buffer), Format, ap);
! 450: va_end( ap );
! 451:
! 452: Conn_ClearFlags( );
! 453:
! 454: chan_cl2chan = Channel_FirstChannelOf( Client );
! 455: while( chan_cl2chan )
! 456: {
! 457: chan = Channel_GetChannel( chan_cl2chan );
! 458: cl2chan = Channel_FirstMember( chan );
! 459: while( cl2chan )
! 460: {
! 461: c = Channel_GetClient( cl2chan );
! 462: if( ! Remote )
! 463: {
! 464: if( Client_Conn( c ) <= NONE ) c = NULL;
! 465: else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
! 466: }
! 467: if( c ) c = Client_NextHop( c );
! 468:
! 469: if( c && ( c != Client ))
! 470: {
! 471: conn = Client_Conn( c );
! 472: if( Client_Type( c ) == CLIENT_SERVER ) Conn_SetFlag( conn, SEND_TO_SERVER );
! 473: else Conn_SetFlag( conn, SEND_TO_USER );
! 474: }
! 475: cl2chan = Channel_NextMember( chan, cl2chan );
! 476: }
! 477:
! 478: chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
! 479: }
! 480: Send_Marked_Connections(Prefix, buffer);
! 481: } /* IRC_WriteStrRelatedPrefix */
! 482:
! 483: /**
! 484: * Send WALLOPS message.
! 485: *
! 486: * @param Client The sending client, excluded while forwarding the message.
! 487: * @param From The (remote) sender of the message.
! 488: * @param Format Format string.
! 489: */
! 490: #ifdef PROTOTYPES
! 491: GLOBAL void
! 492: IRC_SendWallops(CLIENT *Client, CLIENT *From, const char *Format, ...)
! 493: #else
! 494: GLOBAL void
! 495: IRC_SendWallops(Client, From, Format, va_alist )
! 496: CLIENT *Client;
! 497: CLIENT *From;
! 498: const char *Format;
! 499: va_dcl
! 500: #endif
! 501: {
! 502: va_list ap;
! 503: char msg[1000];
! 504: CLIENT *to;
! 505:
! 506: #ifdef PROTOTYPES
! 507: va_start(ap, Format);
! 508: #else
! 509: va_start(ap);
! 510: #endif
! 511: vsnprintf(msg, sizeof(msg), Format, ap);
! 512: va_end(ap);
! 513:
! 514: for (to=Client_First(); to != NULL; to=Client_Next(to)) {
! 515: if (Client_Conn(to) == NONE) /* no local connection */
! 516: continue;
! 517:
! 518: switch (Client_Type(to)) {
! 519: case CLIENT_USER:
! 520: if (Client_HasMode(to, 'w'))
! 521: IRC_WriteStrClientPrefix(to, From,
! 522: "WALLOPS :%s", msg);
! 523: break;
! 524: case CLIENT_SERVER:
! 525: if (to != Client)
! 526: IRC_WriteStrClientPrefix(to, From,
! 527: "WALLOPS :%s", msg);
! 528: break;
! 529: }
! 530: }
! 531: } /* IRC_SendWallops */
! 532:
! 533: /**
! 534: * Set a "penalty time" for an IRC client.
! 535: *
! 536: * Note: penalty times are never set for server links or remote clients!
! 537: *
! 538: * @param Client The client.
! 539: * @param Seconds The additional "penalty time" to enforce.
! 540: */
! 541: GLOBAL void
! 542: IRC_SetPenalty(CLIENT *Client, time_t Seconds)
! 543: {
! 544: CONN_ID c;
! 545:
! 546: assert(Client != NULL);
! 547: assert(Seconds > 0);
! 548:
! 549: if (Client_Type(Client) == CLIENT_SERVER)
! 550: return;
! 551:
! 552: c = Client_Conn(Client);
! 553: if (c <= NONE)
! 554: return;
! 555:
! 556: Conn_SetPenalty(c, Seconds);
! 557: } /* IRC_SetPenalty */
! 558:
! 559: static const char *
! 560: Get_Prefix(CLIENT *Target, CLIENT *Client)
! 561: {
! 562: assert (Target != NULL);
! 563: assert (Client != NULL);
! 564:
! 565: if (Client_Type(Target) == CLIENT_SERVER)
! 566: return Client_ID(Client);
! 567: else
! 568: return Client_MaskCloaked(Client);
! 569: } /* Get_Prefix */
! 570:
! 571: static void
! 572: cb_writeStrServersPrefixFlag(CLIENT *Client, CLIENT *Prefix, void *Buffer)
! 573: {
! 574: IRC_WriteStrClientPrefix(Client, Prefix, "%s", Buffer);
! 575: } /* cb_writeStrServersPrefixFlag */
! 576:
! 577: /**
! 578: * Send a message to all marked connections using a specific prefix.
! 579: *
! 580: * @param Prefix The prefix to use.
! 581: * @param Buffer The message to send.
! 582: */
! 583: static void
! 584: Send_Marked_Connections(CLIENT *Prefix, const char *Buffer)
! 585: {
! 586: CONN_ID conn;
! 587:
! 588: assert(Prefix != NULL);
! 589: assert(Buffer != NULL);
! 590:
! 591: conn = Conn_First();
! 592: while (conn != NONE) {
! 593: if (Conn_Flag(conn) == SEND_TO_SERVER)
! 594: Conn_WriteStr(conn, ":%s %s",
! 595: Client_ID(Prefix), Buffer);
! 596: else if (Conn_Flag(conn) == SEND_TO_USER)
! 597: Conn_WriteStr(conn, ":%s %s",
! 598: Client_MaskCloaked(Prefix), Buffer);
! 599: conn = Conn_Next(conn);
! 600: }
! 601: }
! 602:
! 603: /* -eof- */
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to irc-write.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / ircnowd / src / ngircd