Annotation of ircnowd/src/ngircd/client.c, Revision 1.1
1.1 ! tomglok 1: /*
! 2: * ngIRCd -- The Next Generation IRC Daemon
! 3: * Copyright (c)2001-2014 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: #define __client_c__
! 13:
! 14: #include "portab.h"
! 15:
! 16: /**
! 17: * @file
! 18: * Client management.
! 19: */
! 20:
! 21: #include <assert.h>
! 22: #include <unistd.h>
! 23: #include <stdio.h>
! 24: #include <stdlib.h>
! 25: #include <string.h>
! 26: #include <strings.h>
! 27: #include <time.h>
! 28: #include <netdb.h>
! 29:
! 30: #include "conn.h"
! 31: #include "ngircd.h"
! 32: #include "channel.h"
! 33: #include "conf.h"
! 34: #include "conn-func.h"
! 35: #include "hash.h"
! 36: #include "irc-write.h"
! 37: #include "log.h"
! 38: #include "match.h"
! 39: #include "messages.h"
! 40:
! 41: #define GETID_LEN (CLIENT_NICK_LEN-1) + 1 + (CLIENT_USER_LEN-1) + 1 + (CLIENT_HOST_LEN-1) + 1
! 42:
! 43: static CLIENT *This_Server, *My_Clients;
! 44:
! 45: static WHOWAS My_Whowas[MAX_WHOWAS];
! 46: static int Last_Whowas = -1;
! 47: static long Max_Users, My_Max_Users;
! 48:
! 49:
! 50: static unsigned long Count PARAMS(( CLIENT_TYPE Type ));
! 51: static unsigned long MyCount PARAMS(( CLIENT_TYPE Type ));
! 52:
! 53: static CLIENT *New_Client_Struct PARAMS(( void ));
! 54: static void Generate_MyToken PARAMS(( CLIENT *Client ));
! 55: static void Adjust_Counters PARAMS(( CLIENT *Client ));
! 56:
! 57: static void Free_Client PARAMS(( CLIENT **Client ));
! 58:
! 59: static CLIENT *Init_New_Client PARAMS((CONN_ID Idx, CLIENT *Introducer,
! 60: CLIENT *TopServer, int Type, const char *ID,
! 61: const char *User, const char *Hostname, const char *Info,
! 62: int Hops, int Token, const char *Modes,
! 63: bool Idented));
! 64:
! 65: static void Destroy_UserOrService PARAMS((CLIENT *Client,const char *Txt, const char *FwdMsg,
! 66: bool SendQuit));
! 67:
! 68: static void cb_introduceClient PARAMS((CLIENT *Client, CLIENT *Prefix,
! 69: void *i));
! 70:
! 71: GLOBAL void
! 72: Client_Init( void )
! 73: {
! 74: struct hostent *h;
! 75:
! 76: This_Server = New_Client_Struct( );
! 77: if( ! This_Server )
! 78: {
! 79: Log( LOG_EMERG, "Can't allocate client structure for server! Going down." );
! 80: Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE_NAME );
! 81: exit( 1 );
! 82: }
! 83:
! 84: /* Client structure for this server */
! 85: This_Server->next = NULL;
! 86: This_Server->type = CLIENT_SERVER;
! 87: This_Server->conn_id = NONE;
! 88: This_Server->introducer = This_Server;
! 89: This_Server->mytoken = 1;
! 90: This_Server->hops = 0;
! 91:
! 92: gethostname( This_Server->host, CLIENT_HOST_LEN );
! 93: if (Conf_DNS) {
! 94: h = gethostbyname( This_Server->host );
! 95: if (h) strlcpy(This_Server->host, h->h_name, sizeof(This_Server->host));
! 96: }
! 97: Client_SetID( This_Server, Conf_ServerName );
! 98: Client_SetInfo( This_Server, Conf_ServerInfo );
! 99:
! 100: My_Clients = This_Server;
! 101:
! 102: memset( &My_Whowas, 0, sizeof( My_Whowas ));
! 103: } /* Client_Init */
! 104:
! 105:
! 106: GLOBAL void
! 107: Client_Exit( void )
! 108: {
! 109: CLIENT *c, *next;
! 110: int cnt;
! 111:
! 112: if( NGIRCd_SignalRestart ) Client_Destroy( This_Server, "Server going down (restarting).", NULL, false );
! 113: else Client_Destroy( This_Server, "Server going down.", NULL, false );
! 114:
! 115: cnt = 0;
! 116: c = My_Clients;
! 117: while(c) {
! 118: cnt++;
! 119: next = (CLIENT *)c->next;
! 120: Free_Client(&c);
! 121: c = next;
! 122: }
! 123: if (cnt)
! 124: Log(LOG_INFO, "Freed %d client structure%s.",
! 125: cnt, cnt == 1 ? "" : "s");
! 126: } /* Client_Exit */
! 127:
! 128:
! 129: GLOBAL CLIENT *
! 130: Client_ThisServer( void )
! 131: {
! 132: return This_Server;
! 133: } /* Client_ThisServer */
! 134:
! 135:
! 136: /**
! 137: * Initialize new local client; wrapper function for Init_New_Client().
! 138: * @return New CLIENT structure.
! 139: */
! 140: GLOBAL CLIENT *
! 141: Client_NewLocal(CONN_ID Idx, const char *Hostname, int Type, bool Idented)
! 142: {
! 143: return Init_New_Client(Idx, This_Server, NULL, Type, NULL, NULL,
! 144: Hostname, NULL, 0, 0, NULL, Idented);
! 145: } /* Client_NewLocal */
! 146:
! 147:
! 148: /**
! 149: * Initialize new remote server; wrapper function for Init_New_Client().
! 150: * @return New CLIENT structure.
! 151: */
! 152: GLOBAL CLIENT *
! 153: Client_NewRemoteServer(CLIENT *Introducer, const char *Hostname, CLIENT *TopServer,
! 154: int Hops, int Token, const char *Info, bool Idented)
! 155: {
! 156: return Init_New_Client(NONE, Introducer, TopServer, CLIENT_SERVER,
! 157: Hostname, NULL, Hostname, Info, Hops, Token, NULL, Idented);
! 158: } /* Client_NewRemoteServer */
! 159:
! 160:
! 161: /**
! 162: * Initialize new remote client; wrapper function for Init_New_Client().
! 163: * @return New CLIENT structure.
! 164: */
! 165: GLOBAL CLIENT *
! 166: Client_NewRemoteUser(CLIENT *Introducer, const char *Nick, int Hops, const char *User,
! 167: const char *Hostname, int Token, const char *Modes, const char *Info, bool Idented)
! 168: {
! 169: return Init_New_Client(NONE, Introducer, NULL, CLIENT_USER, Nick,
! 170: User, Hostname, Info, Hops, Token, Modes, Idented);
! 171: } /* Client_NewRemoteUser */
! 172:
! 173:
! 174: /**
! 175: * Initialize new client and set up the given parameters like client type,
! 176: * user name, host name, introducing server etc. ...
! 177: * @return New CLIENT structure.
! 178: */
! 179: static CLIENT *
! 180: Init_New_Client(CONN_ID Idx, CLIENT *Introducer, CLIENT *TopServer,
! 181: int Type, const char *ID, const char *User, const char *Hostname,
! 182: const char *Info, int Hops, int Token, const char *Modes, bool Idented)
! 183: {
! 184: CLIENT *client;
! 185:
! 186: assert(Idx >= NONE);
! 187: assert(Introducer != NULL);
! 188:
! 189: client = New_Client_Struct();
! 190: if (!client)
! 191: return NULL;
! 192:
! 193: client->starttime = time(NULL);
! 194: client->conn_id = Idx;
! 195: client->introducer = Introducer;
! 196: client->topserver = TopServer;
! 197: client->type = Type;
! 198: if (ID)
! 199: Client_SetID(client, ID);
! 200: if (User) {
! 201: Client_SetUser(client, User, Idented);
! 202: Client_SetOrigUser(client, User);
! 203: }
! 204: if (Hostname)
! 205: Client_SetHostname(client, Hostname);
! 206: if (Info)
! 207: Client_SetInfo(client, Info);
! 208: client->hops = Hops;
! 209: client->token = Token;
! 210: if (Modes)
! 211: Client_SetModes(client, Modes);
! 212: if (Type == CLIENT_SERVER)
! 213: Generate_MyToken(client);
! 214:
! 215: if (Client_HasMode(client, 'a'))
! 216: client->away = strndup(DEFAULT_AWAY_MSG, CLIENT_AWAY_LEN - 1);
! 217:
! 218: client->next = (POINTER *)My_Clients;
! 219: My_Clients = client;
! 220:
! 221: Adjust_Counters(client);
! 222:
! 223: return client;
! 224: } /* Init_New_Client */
! 225:
! 226:
! 227: GLOBAL void
! 228: Client_Destroy( CLIENT *Client, const char *LogMsg, const char *FwdMsg, bool SendQuit )
! 229: {
! 230: /* remove a client */
! 231:
! 232: CLIENT *last, *c;
! 233: char msg[COMMAND_LEN];
! 234: const char *txt;
! 235:
! 236: assert( Client != NULL );
! 237:
! 238: txt = LogMsg ? LogMsg : FwdMsg;
! 239: if (!txt)
! 240: txt = "Reason unknown";
! 241:
! 242: /* netsplit message */
! 243: if( Client->type == CLIENT_SERVER ) {
! 244: strlcpy(msg, This_Server->id, sizeof (msg));
! 245: strlcat(msg, " ", sizeof (msg));
! 246: strlcat(msg, Client->id, sizeof (msg));
! 247: }
! 248:
! 249: last = NULL;
! 250: c = My_Clients;
! 251: while( c )
! 252: {
! 253: if(( Client->type == CLIENT_SERVER ) && ( c->introducer == Client ) && ( c != Client ))
! 254: {
! 255: /*
! 256: * The client that is about to be removed is a server,
! 257: * the client we are checking right now is a child of that
! 258: * server and thus has to be removed, too.
! 259: *
! 260: * Call Client_Destroy() recursively with the server as the
! 261: * new "object to be removed". This starts the cycle again, until
! 262: * all servers that are linked via the original server have been
! 263: * removed.
! 264: */
! 265: Client_Destroy( c, NULL, msg, false );
! 266: last = NULL;
! 267: c = My_Clients;
! 268: continue;
! 269: }
! 270: if( c == Client )
! 271: {
! 272: /* found the client: remove it */
! 273: if( last ) last->next = c->next;
! 274: else My_Clients = (CLIENT *)c->next;
! 275:
! 276: if(c->type == CLIENT_USER || c->type == CLIENT_SERVICE)
! 277: Destroy_UserOrService(c, txt, FwdMsg, SendQuit);
! 278: else if( c->type == CLIENT_SERVER )
! 279: {
! 280: if (c != This_Server) {
! 281: if (c->conn_id != NONE)
! 282: Log(LOG_NOTICE|LOG_snotice,
! 283: "Server \"%s\" unregistered (connection %d): %s.",
! 284: c->id, c->conn_id, txt);
! 285: else
! 286: Log(LOG_NOTICE|LOG_snotice,
! 287: "Server \"%s\" unregistered: %s.",
! 288: c->id, txt);
! 289: }
! 290:
! 291: /* inform other servers */
! 292: if( ! NGIRCd_SignalQuit )
! 293: {
! 294: if( FwdMsg ) IRC_WriteStrServersPrefix( Client_NextHop( c ), c, "SQUIT %s :%s", c->id, FwdMsg );
! 295: else IRC_WriteStrServersPrefix( Client_NextHop( c ), c, "SQUIT %s :", c->id );
! 296: }
! 297: }
! 298: else
! 299: {
! 300: if (c->conn_id != NONE) {
! 301: if (c->id[0])
! 302: Log(LOG_NOTICE,
! 303: "Client \"%s\" unregistered (connection %d): %s.",
! 304: c->id, c->conn_id, txt);
! 305: else
! 306: Log(LOG_NOTICE,
! 307: "Client unregistered (connection %d): %s.",
! 308: c->conn_id, txt);
! 309: } else {
! 310: Log(LOG_WARNING,
! 311: "Unregistered unknown client \"%s\": %s",
! 312: c->id[0] ? c->id : "(No Nick)", txt);
! 313: }
! 314: }
! 315:
! 316: Free_Client(&c);
! 317: break;
! 318: }
! 319: last = c;
! 320: c = (CLIENT *)c->next;
! 321: }
! 322: } /* Client_Destroy */
! 323:
! 324:
! 325: /**
! 326: * Set client hostname.
! 327: *
! 328: * If global hostname cloaking is in effect, don't set the real hostname
! 329: * but the configured one.
! 330: *
! 331: * @param Client The client of which the hostname should be set.
! 332: * @param Hostname The new hostname.
! 333: */
! 334: GLOBAL void
! 335: Client_SetHostname( CLIENT *Client, const char *Hostname )
! 336: {
! 337: assert(Client != NULL);
! 338: assert(Hostname != NULL);
! 339:
! 340: /* Only cloak the hostmask if it has not yet been cloaked.
! 341: * The period or colon indicates it's still an IP address.
! 342: * An empty string means a rDNS lookup did not happen (yet). */
! 343: if (Conf_CloakHost[0] && (!Client->host[0] || strchr(Client->host, '.')
! 344: || strchr(Client->host, ':'))) {
! 345: char cloak[GETID_LEN];
! 346:
! 347: strlcpy(cloak, Hostname, GETID_LEN);
! 348: strlcat(cloak, Conf_CloakHostSalt, GETID_LEN);
! 349: snprintf(cloak, GETID_LEN, Conf_CloakHost, Hash(cloak));
! 350:
! 351: LogDebug("Updating hostname of \"%s\": \"%s\" -> \"%s\"",
! 352: Client_ID(Client), Client->host, cloak);
! 353: strlcpy(Client->host, cloak, sizeof(Client->host));
! 354: } else {
! 355: LogDebug("Updating hostname of \"%s\": \"%s\" -> \"%s\"",
! 356: Client_ID(Client), Client->host, Hostname);
! 357: strlcpy(Client->host, Hostname, sizeof(Client->host));
! 358: }
! 359: } /* Client_SetHostname */
! 360:
! 361:
! 362: /**
! 363: * Set IP address to display for a client.
! 364: *
! 365: * @param Client The client.
! 366: * @param IPAText Textual representation of the IP address or NULL to unset.
! 367: */
! 368: GLOBAL void
! 369: Client_SetIPAText(CLIENT *Client, const char *IPAText)
! 370: {
! 371: assert(Client != NULL);
! 372:
! 373: if (Client->ipa_text)
! 374: free(Client->ipa_text);
! 375:
! 376: if (*IPAText)
! 377: Client->ipa_text = strndup(IPAText, CLIENT_HOST_LEN - 1);
! 378: else
! 379: Client->ipa_text = NULL;
! 380: }
! 381:
! 382:
! 383: GLOBAL void
! 384: Client_SetID( CLIENT *Client, const char *ID )
! 385: {
! 386: assert( Client != NULL );
! 387: assert( ID != NULL );
! 388:
! 389: strlcpy( Client->id, ID, sizeof( Client->id ));
! 390:
! 391: if (Conf_CloakUserToNick) {
! 392: strlcpy( Client->user, ID, sizeof( Client->user ));
! 393: strlcpy( Client->info, ID, sizeof( Client->info ));
! 394: }
! 395:
! 396: /* Hash */
! 397: Client->hash = Hash( Client->id );
! 398: } /* Client_SetID */
! 399:
! 400:
! 401: GLOBAL void
! 402: Client_SetUser( CLIENT *Client, const char *User, bool Idented )
! 403: {
! 404: /* set clients username */
! 405:
! 406: assert( Client != NULL );
! 407: assert( User != NULL );
! 408:
! 409: if (Conf_CloakUserToNick) {
! 410: strlcpy(Client->user, Client->id, sizeof(Client->user));
! 411: } else if (Idented) {
! 412: strlcpy(Client->user, User, sizeof(Client->user));
! 413: } else {
! 414: Client->user[0] = '~';
! 415: strlcpy(Client->user + 1, User, sizeof(Client->user) - 1);
! 416: }
! 417: } /* Client_SetUser */
! 418:
! 419:
! 420: /**
! 421: * Set "original" user name of a client.
! 422: * This function saves the "original" user name, the user name specified by
! 423: * the peer using the USER command, into the CLIENT structure. This user
! 424: * name may be used for authentication, for example.
! 425: * @param Client The client.
! 426: * @param User User name to set.
! 427: */
! 428: GLOBAL void
! 429: Client_SetOrigUser(CLIENT UNUSED *Client, const char UNUSED *User)
! 430: {
! 431: assert(Client != NULL);
! 432: assert(User != NULL);
! 433:
! 434: #if defined(PAM)
! 435: strlcpy(Client->orig_user, User, sizeof(Client->orig_user));
! 436: #endif
! 437: } /* Client_SetOrigUser */
! 438:
! 439:
! 440: GLOBAL void
! 441: Client_SetInfo( CLIENT *Client, const char *Info )
! 442: {
! 443: /* set client hostname */
! 444:
! 445: assert( Client != NULL );
! 446: assert( Info != NULL );
! 447:
! 448: if (Conf_CloakUserToNick)
! 449: strlcpy(Client->info, Client->id, sizeof(Client->info));
! 450: else
! 451: strlcpy(Client->info, Info, sizeof(Client->info));
! 452: } /* Client_SetInfo */
! 453:
! 454:
! 455: GLOBAL void
! 456: Client_SetModes( CLIENT *Client, const char *Modes )
! 457: {
! 458: assert( Client != NULL );
! 459: assert( Modes != NULL );
! 460:
! 461: strlcpy(Client->modes, Modes, sizeof( Client->modes ));
! 462: } /* Client_SetModes */
! 463:
! 464:
! 465: GLOBAL void
! 466: Client_SetFlags( CLIENT *Client, const char *Flags )
! 467: {
! 468: assert( Client != NULL );
! 469: assert( Flags != NULL );
! 470:
! 471: strlcpy(Client->flags, Flags, sizeof(Client->flags));
! 472: } /* Client_SetFlags */
! 473:
! 474:
! 475: GLOBAL void
! 476: Client_SetAccountName(CLIENT *Client, const char *AccountName)
! 477: {
! 478: assert(Client != NULL);
! 479:
! 480: if (Client->account_name)
! 481: free(Client->account_name);
! 482:
! 483: if (*AccountName)
! 484: Client->account_name = strndup(AccountName,
! 485: CLIENT_NICK_LEN - 1);
! 486: else
! 487: Client->account_name = NULL;
! 488: }
! 489:
! 490:
! 491: GLOBAL void
! 492: Client_SetAway( CLIENT *Client, const char *Txt )
! 493: {
! 494: /* Set AWAY reason of client */
! 495:
! 496: assert( Client != NULL );
! 497: assert( Txt != NULL );
! 498:
! 499: if (Client->away)
! 500: free(Client->away);
! 501:
! 502: Client->away = strndup(Txt, CLIENT_AWAY_LEN - 1);
! 503:
! 504: LogDebug("%s \"%s\" is away: %s", Client_TypeText(Client),
! 505: Client_Mask(Client), Txt);
! 506: } /* Client_SetAway */
! 507:
! 508:
! 509: GLOBAL void
! 510: Client_SetType( CLIENT *Client, int Type )
! 511: {
! 512: assert( Client != NULL );
! 513: Client->type = Type;
! 514: if( Type == CLIENT_SERVER ) Generate_MyToken( Client );
! 515: Adjust_Counters( Client );
! 516: } /* Client_SetType */
! 517:
! 518:
! 519: GLOBAL void
! 520: Client_SetHops( CLIENT *Client, int Hops )
! 521: {
! 522: assert( Client != NULL );
! 523: Client->hops = Hops;
! 524: } /* Client_SetHops */
! 525:
! 526:
! 527: GLOBAL void
! 528: Client_SetToken( CLIENT *Client, int Token )
! 529: {
! 530: assert( Client != NULL );
! 531: Client->token = Token;
! 532: } /* Client_SetToken */
! 533:
! 534:
! 535: GLOBAL void
! 536: Client_SetIntroducer( CLIENT *Client, CLIENT *Introducer )
! 537: {
! 538: assert( Client != NULL );
! 539: assert( Introducer != NULL );
! 540: Client->introducer = Introducer;
! 541: } /* Client_SetIntroducer */
! 542:
! 543:
! 544: GLOBAL bool
! 545: Client_ModeAdd( CLIENT *Client, char Mode )
! 546: {
! 547: /* Set Mode.
! 548: * If Client already had Mode, return false.
! 549: * If the Mode was newly set, return true.
! 550: */
! 551:
! 552: char x[2];
! 553:
! 554: assert( Client != NULL );
! 555:
! 556: x[0] = Mode; x[1] = '\0';
! 557: if (!Client_HasMode(Client, x[0])) {
! 558: strlcat( Client->modes, x, sizeof( Client->modes ));
! 559: return true;
! 560: }
! 561: else return false;
! 562: } /* Client_ModeAdd */
! 563:
! 564:
! 565: GLOBAL bool
! 566: Client_ModeDel( CLIENT *Client, char Mode )
! 567: {
! 568: /* Delete Mode.
! 569: * If Mode was removed, return true.
! 570: * If Client did not have Mode, return false.
! 571: */
! 572:
! 573: char x[2], *p;
! 574:
! 575: assert( Client != NULL );
! 576:
! 577: x[0] = Mode; x[1] = '\0';
! 578:
! 579: p = strchr( Client->modes, x[0] );
! 580: if( ! p ) return false;
! 581:
! 582: /* Client has Mode -> delete */
! 583: while( *p )
! 584: {
! 585: *p = *(p + 1);
! 586: p++;
! 587: }
! 588: return true;
! 589: } /* Client_ModeDel */
! 590:
! 591:
! 592: /**
! 593: * Search CLIENT structure of a given nick name.
! 594: *
! 595: * @return Pointer to CLIENT structure or NULL if not found.
! 596: */
! 597: GLOBAL CLIENT *
! 598: Client_Search( const char *Nick )
! 599: {
! 600: char search_id[CLIENT_ID_LEN], *ptr;
! 601: CLIENT *c = NULL;
! 602: UINT32 search_hash;
! 603:
! 604: assert( Nick != NULL );
! 605:
! 606: /* copy Nick and truncate hostmask if necessary */
! 607: strlcpy( search_id, Nick, sizeof( search_id ));
! 608: ptr = strchr( search_id, '!' );
! 609: if( ptr ) *ptr = '\0';
! 610:
! 611: search_hash = Hash(search_id);
! 612:
! 613: c = My_Clients;
! 614: while (c) {
! 615: if (c->hash == search_hash && strcasecmp(c->id, search_id) == 0)
! 616: return c;
! 617: c = (CLIENT *)c->next;
! 618: }
! 619: return NULL;
! 620: }
! 621:
! 622:
! 623: /**
! 624: * Search first CLIENT structure matching a given mask of a server.
! 625: *
! 626: * The order of servers is arbitrary, but this function makes sure that the
! 627: * local server is always returned if the mask matches it.
! 628: *
! 629: * @return Pointer to CLIENT structure or NULL if no server could be found.
! 630: */
! 631: GLOBAL CLIENT *
! 632: Client_SearchServer(const char *Mask)
! 633: {
! 634: CLIENT *c;
! 635:
! 636: assert(Mask != NULL);
! 637:
! 638: /* First check if mask matches the local server */
! 639: if (MatchCaseInsensitive(Mask, Client_ID(Client_ThisServer())))
! 640: return Client_ThisServer();
! 641:
! 642: c = My_Clients;
! 643: while (c) {
! 644: if (Client_Type(c) == CLIENT_SERVER) {
! 645: /* This is a server: check if Mask matches */
! 646: if (MatchCaseInsensitive(Mask, c->id))
! 647: return c;
! 648: }
! 649: c = (CLIENT *)c->next;
! 650: }
! 651: return NULL;
! 652: }
! 653:
! 654:
! 655: /**
! 656: * Get client structure ("introducer") identfied by a server token.
! 657: * @return CLIENT structure or NULL if none could be found.
! 658: */
! 659: GLOBAL CLIENT *
! 660: Client_GetFromToken( CLIENT *Client, int Token )
! 661: {
! 662: CLIENT *c;
! 663:
! 664: assert( Client != NULL );
! 665:
! 666: if (!Token)
! 667: return NULL;
! 668:
! 669: c = My_Clients;
! 670: while (c) {
! 671: if ((c->type == CLIENT_SERVER) && (c->introducer == Client) &&
! 672: (c->token == Token))
! 673: return c;
! 674: c = (CLIENT *)c->next;
! 675: }
! 676: return NULL;
! 677: } /* Client_GetFromToken */
! 678:
! 679:
! 680: GLOBAL int
! 681: Client_Type( CLIENT *Client )
! 682: {
! 683: assert( Client != NULL );
! 684: return Client->type;
! 685: } /* Client_Type */
! 686:
! 687:
! 688: GLOBAL CONN_ID
! 689: Client_Conn( CLIENT *Client )
! 690: {
! 691: assert( Client != NULL );
! 692: return Client->conn_id;
! 693: } /* Client_Conn */
! 694:
! 695:
! 696: GLOBAL char *
! 697: Client_ID( CLIENT *Client )
! 698: {
! 699: assert( Client != NULL );
! 700:
! 701: #ifdef DEBUG
! 702: if(Client->type == CLIENT_USER)
! 703: assert(strlen(Client->id) < Conf_MaxNickLength);
! 704: #endif
! 705:
! 706: if( Client->id[0] ) return Client->id;
! 707: else return "*";
! 708: } /* Client_ID */
! 709:
! 710:
! 711: GLOBAL char *
! 712: Client_Info( CLIENT *Client )
! 713: {
! 714: assert( Client != NULL );
! 715: return Client->info;
! 716: } /* Client_Info */
! 717:
! 718:
! 719: GLOBAL char *
! 720: Client_User( CLIENT *Client )
! 721: {
! 722: assert( Client != NULL );
! 723: return Client->user[0] ? Client->user : "~";
! 724: } /* Client_User */
! 725:
! 726:
! 727: #ifdef PAM
! 728:
! 729: /**
! 730: * Get the "original" user name as supplied by the USER command.
! 731: * The user name as given by the client is used for authentication instead
! 732: * of the one detected using IDENT requests.
! 733: * @param Client The client.
! 734: * @return Original user name.
! 735: */
! 736: GLOBAL char *
! 737: Client_OrigUser(CLIENT *Client) {
! 738: return Client->orig_user;
! 739: } /* Client_OrigUser */
! 740:
! 741: #endif
! 742:
! 743: /**
! 744: * Return the hostname of a client.
! 745: * @param Client Pointer to client structure
! 746: * @return Pointer to client hostname
! 747: */
! 748: GLOBAL char *
! 749: Client_Hostname(CLIENT *Client)
! 750: {
! 751: assert (Client != NULL);
! 752: return Client->host;
! 753: }
! 754:
! 755: /**
! 756: * Return the cloaked hostname of a client, if set.
! 757: * @param Client Pointer to the client structure.
! 758: * @return Pointer to the cloaked hostname or NULL if not set.
! 759: */
! 760: GLOBAL char *
! 761: Client_HostnameCloaked(CLIENT *Client)
! 762: {
! 763: assert(Client != NULL);
! 764: return Client->cloaked;
! 765: }
! 766:
! 767: /**
! 768: * Get (potentially cloaked) hostname of a client to display it to other users.
! 769: *
! 770: * If the client has not enabled cloaking, the real hostname is used.
! 771: *
! 772: * @param Client Pointer to client structure
! 773: * @return Pointer to client hostname
! 774: */
! 775: GLOBAL char *
! 776: Client_HostnameDisplayed(CLIENT *Client)
! 777: {
! 778: assert(Client != NULL);
! 779:
! 780: /* Client isn't cloaked at all, return real hostname: */
! 781: if (!Client_HasMode(Client, 'x'))
! 782: return Client_Hostname(Client);
! 783:
! 784: /* Use an already saved cloaked hostname, if there is one */
! 785: if (Client->cloaked)
! 786: return Client->cloaked;
! 787:
! 788: Client_UpdateCloakedHostname(Client, NULL, NULL);
! 789: return Client->cloaked;
! 790: }
! 791:
! 792: GLOBAL const char *
! 793: Client_IPAText(CLIENT *Client)
! 794: {
! 795: assert(Client != NULL);
! 796:
! 797: /* Not a local client? */
! 798: if (Client_Conn(Client) <= NONE)
! 799: return "0.0.0.0";
! 800:
! 801: if (!Client->ipa_text)
! 802: return Conn_GetIPAInfo(Client_Conn(Client));
! 803: else
! 804: return Client->ipa_text;
! 805: }
! 806:
! 807: /**
! 808: * Update (and generate, if necessary) the cloaked hostname of a client.
! 809: *
! 810: * The newly set cloaked hostname is announced in the network using METADATA
! 811: * commands to peers that support this feature.
! 812: *
! 813: * @param Client The client of which the cloaked hostname should be updated.
! 814: * @param Origin The originator of the hostname change, or NULL if this server.
! 815: * @param Hostname The new cloaked hostname, or NULL if it should be generated.
! 816: */
! 817: GLOBAL void
! 818: Client_UpdateCloakedHostname(CLIENT *Client, CLIENT *Origin,
! 819: const char *Hostname)
! 820: {
! 821: char Cloak_Buffer[CLIENT_HOST_LEN];
! 822:
! 823: assert(Client != NULL);
! 824: if (!Origin)
! 825: Origin = Client_ThisServer();
! 826:
! 827: if (!Client->cloaked) {
! 828: Client->cloaked = malloc(CLIENT_HOST_LEN);
! 829: if (!Client->cloaked)
! 830: return;
! 831: }
! 832:
! 833: if (!Hostname) {
! 834: /* Generate new cloaked hostname */
! 835: if (*Conf_CloakHostModeX) {
! 836: strlcpy(Cloak_Buffer, Client->host,
! 837: sizeof(Cloak_Buffer));
! 838: strlcat(Cloak_Buffer, Conf_CloakHostSalt,
! 839: sizeof(Cloak_Buffer));
! 840: snprintf(Client->cloaked, CLIENT_HOST_LEN,
! 841: Conf_CloakHostModeX, Hash(Cloak_Buffer));
! 842: } else
! 843: strlcpy(Client->cloaked, Client_ID(Client->introducer),
! 844: CLIENT_HOST_LEN);
! 845: } else
! 846: strlcpy(Client->cloaked, Hostname, CLIENT_HOST_LEN);
! 847: LogDebug("Cloaked hostname of \"%s\" updated to \"%s\"",
! 848: Client_ID(Client), Client->cloaked);
! 849:
! 850: /* Inform other servers in the network */
! 851: IRC_WriteStrServersPrefixFlag(Client_NextHop(Origin), Origin, 'M',
! 852: "METADATA %s cloakhost :%s",
! 853: Client_ID(Client), Client->cloaked);
! 854: }
! 855:
! 856: GLOBAL char *
! 857: Client_Modes( CLIENT *Client )
! 858: {
! 859: assert( Client != NULL );
! 860: return Client->modes;
! 861: } /* Client_Modes */
! 862:
! 863:
! 864: GLOBAL char *
! 865: Client_Flags( CLIENT *Client )
! 866: {
! 867: assert( Client != NULL );
! 868: return Client->flags;
! 869: } /* Client_Flags */
! 870:
! 871:
! 872: GLOBAL int
! 873: Client_Hops( CLIENT *Client )
! 874: {
! 875: assert( Client != NULL );
! 876: return Client->hops;
! 877: } /* Client_Hops */
! 878:
! 879:
! 880: GLOBAL int
! 881: Client_Token( CLIENT *Client )
! 882: {
! 883: assert( Client != NULL );
! 884: return Client->token;
! 885: } /* Client_Token */
! 886:
! 887:
! 888: GLOBAL int
! 889: Client_MyToken( CLIENT *Client )
! 890: {
! 891: assert( Client != NULL );
! 892: return Client->mytoken;
! 893: } /* Client_MyToken */
! 894:
! 895:
! 896: GLOBAL CLIENT *
! 897: Client_NextHop( CLIENT *Client )
! 898: {
! 899: CLIENT *c;
! 900:
! 901: assert( Client != NULL );
! 902:
! 903: c = Client;
! 904: while( c->introducer && ( c->introducer != c ) && ( c->introducer != This_Server ))
! 905: c = c->introducer;
! 906:
! 907: return c;
! 908: } /* Client_NextHop */
! 909:
! 910:
! 911: /**
! 912: * Return ID of a client: "client!user@host"
! 913: * This client ID is used for IRC prefixes, for example.
! 914: * Please note that this function uses a global static buffer, so you can't
! 915: * nest invocations without overwriting earlier results!
! 916: * @param Client Pointer to client structure
! 917: * @return Pointer to global buffer containing the client ID
! 918: */
! 919: GLOBAL char *
! 920: Client_Mask( CLIENT *Client )
! 921: {
! 922: static char Mask_Buffer[GETID_LEN];
! 923:
! 924: assert (Client != NULL);
! 925:
! 926: /* Servers: return name only, there is no "mask" */
! 927: if (Client->type == CLIENT_SERVER)
! 928: return Client->id;
! 929:
! 930: snprintf(Mask_Buffer, GETID_LEN, "%s!%s@%s",
! 931: Client->id, Client->user, Client->host);
! 932: return Mask_Buffer;
! 933: } /* Client_Mask */
! 934:
! 935:
! 936: /**
! 937: * Return ID of a client with cloaked hostname: "client!user@server-name"
! 938: *
! 939: * This client ID is used for IRC prefixes, for example.
! 940: * Please note that this function uses a global static buffer, so you can't
! 941: * nest invocations without overwriting earlier results!
! 942: * If the client has not enabled cloaking, the real hostname is used.
! 943: *
! 944: * @param Client Pointer to client structure
! 945: * @return Pointer to global buffer containing the client ID
! 946: */
! 947: GLOBAL char *
! 948: Client_MaskCloaked(CLIENT *Client)
! 949: {
! 950: static char Mask_Buffer[GETID_LEN];
! 951:
! 952: assert (Client != NULL);
! 953:
! 954: /* Is the client using cloaking at all? */
! 955: if (!Client_HasMode(Client, 'x'))
! 956: return Client_Mask(Client);
! 957:
! 958: snprintf(Mask_Buffer, GETID_LEN, "%s!%s@%s", Client->id, Client->user,
! 959: Client_HostnameDisplayed(Client));
! 960:
! 961: return Mask_Buffer;
! 962: } /* Client_MaskCloaked */
! 963:
! 964:
! 965: GLOBAL CLIENT *
! 966: Client_Introducer( CLIENT *Client )
! 967: {
! 968: assert( Client != NULL );
! 969: return Client->introducer;
! 970: } /* Client_Introducer */
! 971:
! 972:
! 973: GLOBAL CLIENT *
! 974: Client_TopServer( CLIENT *Client )
! 975: {
! 976: assert( Client != NULL );
! 977: return Client->topserver;
! 978: } /* Client_TopServer */
! 979:
! 980:
! 981: GLOBAL bool
! 982: Client_HasMode( CLIENT *Client, char Mode )
! 983: {
! 984: assert( Client != NULL );
! 985: return strchr( Client->modes, Mode ) != NULL;
! 986: } /* Client_HasMode */
! 987:
! 988:
! 989: GLOBAL bool
! 990: Client_HasFlag( CLIENT *Client, char Flag )
! 991: {
! 992: assert( Client != NULL );
! 993: return strchr( Client->flags, Flag ) != NULL;
! 994: } /* Client_HasFlag */
! 995:
! 996:
! 997: GLOBAL char *
! 998: Client_Away( CLIENT *Client )
! 999: {
! 1000: assert( Client != NULL );
! 1001: return Client->away;
! 1002: } /* Client_Away */
! 1003:
! 1004:
! 1005: GLOBAL char *
! 1006: Client_AccountName(CLIENT *Client)
! 1007: {
! 1008: assert(Client != NULL);
! 1009: return Client->account_name;
! 1010: }
! 1011:
! 1012:
! 1013: /**
! 1014: * Make sure that a given nickname is valid.
! 1015: *
! 1016: * If the nickname is not valid for the given client, this function sends back
! 1017: * the appropriate error messages.
! 1018: *
! 1019: * @param Client Client that wants to change the nickname.
! 1020: * @param Nick New nickname.
! 1021: * @returns true if nickname is valid, false otherwise.
! 1022: */
! 1023: GLOBAL bool
! 1024: Client_CheckNick(CLIENT *Client, char *Nick)
! 1025: {
! 1026: assert(Client != NULL);
! 1027: assert(Nick != NULL);
! 1028:
! 1029: if (!Client_IsValidNick(Nick)) {
! 1030: if (strlen(Nick ) >= Conf_MaxNickLength)
! 1031: IRC_WriteErrClient(Client, ERR_NICKNAMETOOLONG_MSG,
! 1032: Client_ID(Client), Nick,
! 1033: Conf_MaxNickLength - 1);
! 1034: else
! 1035: IRC_WriteErrClient(Client, ERR_ERRONEUSNICKNAME_MSG,
! 1036: Client_ID(Client), Nick);
! 1037: return false;
! 1038: }
! 1039:
! 1040: if (Client_Type(Client) != CLIENT_SERVER
! 1041: && Client_Type(Client) != CLIENT_SERVICE) {
! 1042: /* Make sure that this isn't a restricted/forbidden nickname */
! 1043: if (Conf_NickIsBlocked(Nick)) {
! 1044: IRC_WriteErrClient(Client, ERR_FORBIDDENNICKNAME_MSG,
! 1045: Client_ID(Client), Nick);
! 1046: return false;
! 1047: }
! 1048: }
! 1049:
! 1050: /* Nickname already registered? */
! 1051: if (Client_Search(Nick)) {
! 1052: IRC_WriteErrClient(Client, ERR_NICKNAMEINUSE_MSG,
! 1053: Client_ID(Client), Nick);
! 1054: return false;
! 1055: }
! 1056:
! 1057: return true;
! 1058: } /* Client_CheckNick */
! 1059:
! 1060:
! 1061: GLOBAL bool
! 1062: Client_CheckID( CLIENT *Client, char *ID )
! 1063: {
! 1064: char str[COMMAND_LEN];
! 1065: CLIENT *c;
! 1066:
! 1067: assert( Client != NULL );
! 1068: assert( Client->conn_id > NONE );
! 1069: assert( ID != NULL );
! 1070:
! 1071: /* ID too long? */
! 1072: if (strlen(ID) > CLIENT_ID_LEN) {
! 1073: IRC_WriteErrClient(Client, ERR_ERRONEUSNICKNAME_MSG,
! 1074: Client_ID(Client), ID);
! 1075: return false;
! 1076: }
! 1077:
! 1078: /* ID already in use? */
! 1079: c = My_Clients;
! 1080: while (c) {
! 1081: if (strcasecmp(c->id, ID) == 0) {
! 1082: snprintf(str, sizeof(str), "ID \"%s\" already registered", ID);
! 1083: if (c->conn_id != NONE)
! 1084: Log(LOG_ERR, "%s (on connection %d)!", str, c->conn_id);
! 1085: else
! 1086: Log(LOG_ERR, "%s (via network)!", str);
! 1087: Conn_Close(Client->conn_id, str, str, true);
! 1088: return false;
! 1089: }
! 1090: c = (CLIENT *)c->next;
! 1091: }
! 1092:
! 1093: return true;
! 1094: } /* Client_CheckID */
! 1095:
! 1096:
! 1097: GLOBAL CLIENT *
! 1098: Client_First( void )
! 1099: {
! 1100: return My_Clients;
! 1101: } /* Client_First */
! 1102:
! 1103:
! 1104: GLOBAL CLIENT *
! 1105: Client_Next( CLIENT *c )
! 1106: {
! 1107: assert( c != NULL );
! 1108: return (CLIENT *)c->next;
! 1109: } /* Client_Next */
! 1110:
! 1111:
! 1112: GLOBAL long
! 1113: Client_UserCount( void )
! 1114: {
! 1115: return Count( CLIENT_USER );
! 1116: } /* Client_UserCount */
! 1117:
! 1118:
! 1119: GLOBAL long
! 1120: Client_ServiceCount( void )
! 1121: {
! 1122: return Count( CLIENT_SERVICE );;
! 1123: } /* Client_ServiceCount */
! 1124:
! 1125:
! 1126: GLOBAL long
! 1127: Client_ServerCount( void )
! 1128: {
! 1129: return Count( CLIENT_SERVER );
! 1130: } /* Client_ServerCount */
! 1131:
! 1132:
! 1133: GLOBAL long
! 1134: Client_MyUserCount( void )
! 1135: {
! 1136: return MyCount( CLIENT_USER );
! 1137: } /* Client_MyUserCount */
! 1138:
! 1139:
! 1140: GLOBAL long
! 1141: Client_MyServiceCount( void )
! 1142: {
! 1143: return MyCount( CLIENT_SERVICE );
! 1144: } /* Client_MyServiceCount */
! 1145:
! 1146:
! 1147: GLOBAL unsigned long
! 1148: Client_MyServerCount( void )
! 1149: {
! 1150: CLIENT *c;
! 1151: unsigned long cnt = 0;
! 1152:
! 1153: c = My_Clients;
! 1154: while( c )
! 1155: {
! 1156: if(( c->type == CLIENT_SERVER ) && ( c->hops == 1 )) cnt++;
! 1157: c = (CLIENT *)c->next;
! 1158: }
! 1159: return cnt;
! 1160: } /* Client_MyServerCount */
! 1161:
! 1162:
! 1163: GLOBAL unsigned long
! 1164: Client_OperCount( void )
! 1165: {
! 1166: CLIENT *c;
! 1167: unsigned long cnt = 0;
! 1168:
! 1169: c = My_Clients;
! 1170: while( c )
! 1171: {
! 1172: if (c && c->type == CLIENT_USER && Client_HasMode(c, 'o' ))
! 1173: cnt++;
! 1174: c = (CLIENT *)c->next;
! 1175: }
! 1176: return cnt;
! 1177: } /* Client_OperCount */
! 1178:
! 1179:
! 1180: GLOBAL unsigned long
! 1181: Client_UnknownCount( void )
! 1182: {
! 1183: CLIENT *c;
! 1184: unsigned long cnt = 0;
! 1185:
! 1186: c = My_Clients;
! 1187: while( c )
! 1188: {
! 1189: if( c && ( c->type != CLIENT_USER ) && ( c->type != CLIENT_SERVICE ) && ( c->type != CLIENT_SERVER )) cnt++;
! 1190: c = (CLIENT *)c->next;
! 1191: }
! 1192:
! 1193: return cnt;
! 1194: } /* Client_UnknownCount */
! 1195:
! 1196:
! 1197: GLOBAL long
! 1198: Client_MaxUserCount( void )
! 1199: {
! 1200: return Max_Users;
! 1201: } /* Client_MaxUserCount */
! 1202:
! 1203:
! 1204: GLOBAL long
! 1205: Client_MyMaxUserCount( void )
! 1206: {
! 1207: return My_Max_Users;
! 1208: } /* Client_MyMaxUserCount */
! 1209:
! 1210:
! 1211: /**
! 1212: * Check that a given nickname is valid.
! 1213: *
! 1214: * @param Nick the nickname to check.
! 1215: * @returns true if nickname is valid, false otherwise.
! 1216: */
! 1217: GLOBAL bool
! 1218: Client_IsValidNick(const char *Nick)
! 1219: {
! 1220: const char *ptr;
! 1221: static const char goodchars[] = ";0123456789-";
! 1222:
! 1223: assert (Nick != NULL);
! 1224:
! 1225: if (strchr(goodchars, Nick[0]))
! 1226: return false;
! 1227: if (strlen(Nick ) >= Conf_MaxNickLength)
! 1228: return false;
! 1229:
! 1230: ptr = Nick;
! 1231: while (*ptr) {
! 1232: if (*ptr < 'A' && !strchr(goodchars, *ptr ))
! 1233: return false;
! 1234: if (*ptr > '}')
! 1235: return false;
! 1236: ptr++;
! 1237: }
! 1238:
! 1239: return true;
! 1240: } /* Client_IsValidNick */
! 1241:
! 1242:
! 1243: /**
! 1244: * Return pointer to "My_Whowas" structure.
! 1245: */
! 1246: GLOBAL WHOWAS *
! 1247: Client_GetWhowas( void )
! 1248: {
! 1249: return My_Whowas;
! 1250: } /* Client_GetWhowas */
! 1251:
! 1252: /**
! 1253: * Return the index of the last used WHOWAS entry.
! 1254: */
! 1255: GLOBAL int
! 1256: Client_GetLastWhowasIndex( void )
! 1257: {
! 1258: return Last_Whowas;
! 1259: } /* Client_GetLastWhowasIndex */
! 1260:
! 1261:
! 1262: /**
! 1263: * Get the start time of this client.
! 1264: * The result is the start time in seconds since 1970-01-01, as reported
! 1265: * by the C function time(NULL).
! 1266: */
! 1267: GLOBAL time_t
! 1268: Client_StartTime(CLIENT *Client)
! 1269: {
! 1270: assert( Client != NULL );
! 1271: return Client->starttime;
! 1272: } /* Client_Uptime */
! 1273:
! 1274:
! 1275: /**
! 1276: * Reject a client when logging in.
! 1277: *
! 1278: * This function is called when a client isn't allowed to connect to this
! 1279: * server. Possible reasons are bad server password, bad PAM password,
! 1280: * or that the client is G/K-Line'd.
! 1281: *
! 1282: * After calling this function, the client isn't connected any more.
! 1283: *
! 1284: * @param Client The client to reject.
! 1285: * @param Reason The reason why the client has been rejected.
! 1286: * @param InformClient If true, send the exact reason to the client.
! 1287: */
! 1288: GLOBAL void
! 1289: Client_Reject(CLIENT *Client, const char *Reason, bool InformClient)
! 1290: {
! 1291: char info[COMMAND_LEN];
! 1292:
! 1293: assert(Client != NULL);
! 1294: assert(Reason != NULL);
! 1295:
! 1296: if (InformClient)
! 1297: snprintf(info, sizeof(info), "Access denied: %s", Reason);
! 1298: else
! 1299: strcpy(info, "Access denied: Bad password?");
! 1300:
! 1301: Log(LOG_ERR,
! 1302: "User \"%s\" rejected (connection %d): %s!",
! 1303: Client_Mask(Client), Client_Conn(Client), Reason);
! 1304: Conn_Close(Client_Conn(Client), Reason, info, true);
! 1305: }
! 1306:
! 1307:
! 1308: /**
! 1309: * Introduce a new user or service client in the network.
! 1310: *
! 1311: * @param From Remote server introducing the client or NULL (local).
! 1312: * @param Client New client.
! 1313: * @param Type Type of the client (CLIENT_USER or CLIENT_SERVICE).
! 1314: */
! 1315: GLOBAL void
! 1316: Client_Introduce(CLIENT *From, CLIENT *Client, int Type)
! 1317: {
! 1318: /* Set client type (user or service) */
! 1319: Client_SetType(Client, Type);
! 1320:
! 1321: if (From) {
! 1322: if (Conf_NickIsService(Conf_GetServer(Client_Conn(From)),
! 1323: Client_ID(Client)))
! 1324: Client_SetType(Client, CLIENT_SERVICE);
! 1325: LogDebug("%s \"%s\" (+%s) registered (via %s, on %s, %d hop%s).",
! 1326: Client_TypeText(Client), Client_Mask(Client),
! 1327: Client_Modes(Client), Client_ID(From),
! 1328: Client_ID(Client_Introducer(Client)),
! 1329: Client_Hops(Client), Client_Hops(Client) > 1 ? "s": "");
! 1330: } else {
! 1331: Log(LOG_NOTICE, "%s \"%s\" registered (connection %d).",
! 1332: Client_TypeText(Client), Client_Mask(Client),
! 1333: Client_Conn(Client));
! 1334: Log_ServerNotice('c', "Client connecting: %s (%s@%s) [%s] - %s",
! 1335: Client_ID(Client), Client_User(Client),
! 1336: Client_Hostname(Client),
! 1337: Conn_IPA(Client_Conn(Client)),
! 1338: Client_TypeText(Client));
! 1339: }
! 1340:
! 1341: /* Inform other servers */
! 1342: IRC_WriteStrServersPrefixFlag_CB(From,
! 1343: From != NULL ? From : Client_ThisServer(),
! 1344: '\0', cb_introduceClient, (void *)Client);
! 1345: } /* Client_Introduce */
! 1346:
! 1347:
! 1348: static unsigned long
! 1349: Count( CLIENT_TYPE Type )
! 1350: {
! 1351: CLIENT *c;
! 1352: unsigned long cnt = 0;
! 1353:
! 1354: c = My_Clients;
! 1355: while( c )
! 1356: {
! 1357: if( c->type == Type ) cnt++;
! 1358: c = (CLIENT *)c->next;
! 1359: }
! 1360: return cnt;
! 1361: } /* Count */
! 1362:
! 1363:
! 1364: static unsigned long
! 1365: MyCount( CLIENT_TYPE Type )
! 1366: {
! 1367: CLIENT *c;
! 1368: unsigned long cnt = 0;
! 1369:
! 1370: c = My_Clients;
! 1371: while( c )
! 1372: {
! 1373: if(( c->introducer == This_Server ) && ( c->type == Type )) cnt++;
! 1374: c = (CLIENT *)c->next;
! 1375: }
! 1376: return cnt;
! 1377: } /* MyCount */
! 1378:
! 1379:
! 1380: /**
! 1381: * Allocate and initialize new CLIENT strcuture.
! 1382: *
! 1383: * @return Pointer to CLIENT structure or NULL on error.
! 1384: */
! 1385: static CLIENT *
! 1386: New_Client_Struct( void )
! 1387: {
! 1388: CLIENT *c;
! 1389:
! 1390: c = (CLIENT *)malloc( sizeof( CLIENT ));
! 1391: if( ! c )
! 1392: {
! 1393: Log( LOG_EMERG, "Can't allocate memory! [New_Client_Struct]" );
! 1394: return NULL;
! 1395: }
! 1396:
! 1397: memset( c, 0, sizeof ( CLIENT ));
! 1398:
! 1399: c->type = CLIENT_UNKNOWN;
! 1400: c->conn_id = NONE;
! 1401: c->hops = -1;
! 1402: c->token = -1;
! 1403: c->mytoken = -1;
! 1404:
! 1405: return c;
! 1406: }
! 1407:
! 1408: /**
! 1409: * Free a CLIENT structure and its member variables.
! 1410: */
! 1411: static void
! 1412: Free_Client(CLIENT **Client)
! 1413: {
! 1414: assert(Client != NULL);
! 1415: assert(*Client != NULL);
! 1416:
! 1417: if ((*Client)->account_name)
! 1418: free((*Client)->account_name);
! 1419: if ((*Client)->away)
! 1420: free((*Client)->away);
! 1421: if ((*Client)->cloaked)
! 1422: free((*Client)->cloaked);
! 1423: if ((*Client)->ipa_text)
! 1424: free((*Client)->ipa_text);
! 1425:
! 1426: free(*Client);
! 1427: *Client = NULL;
! 1428: }
! 1429:
! 1430: static void
! 1431: Generate_MyToken( CLIENT *Client )
! 1432: {
! 1433: CLIENT *c;
! 1434: int token;
! 1435:
! 1436: c = My_Clients;
! 1437: token = 2;
! 1438: while( c )
! 1439: {
! 1440: if( c->mytoken == token )
! 1441: {
! 1442: /* The token is already in use */
! 1443: token++;
! 1444: c = My_Clients;
! 1445: continue;
! 1446: }
! 1447: else c = (CLIENT *)c->next;
! 1448: }
! 1449: Client->mytoken = token;
! 1450: LogDebug("Assigned token %d to server \"%s\".", token, Client->id);
! 1451: } /* Generate_MyToken */
! 1452:
! 1453:
! 1454: static void
! 1455: Adjust_Counters( CLIENT *Client )
! 1456: {
! 1457: long count;
! 1458:
! 1459: assert( Client != NULL );
! 1460:
! 1461: if( Client->type != CLIENT_USER ) return;
! 1462:
! 1463: if( Client->conn_id != NONE )
! 1464: {
! 1465: /* Local connection */
! 1466: count = Client_MyUserCount( );
! 1467: if( count > My_Max_Users ) My_Max_Users = count;
! 1468: }
! 1469: count = Client_UserCount( );
! 1470: if( count > Max_Users ) Max_Users = count;
! 1471: } /* Adjust_Counters */
! 1472:
! 1473:
! 1474: /**
! 1475: * Register client in My_Whowas structure for further recall by WHOWAS.
! 1476: * Note: Only clients that have been connected at least 30 seconds will be
! 1477: * registered to prevent automated IRC bots to "destroy" a nice server
! 1478: * history database.
! 1479: */
! 1480: GLOBAL void
! 1481: Client_RegisterWhowas( CLIENT *Client )
! 1482: {
! 1483: int slot;
! 1484: time_t now;
! 1485:
! 1486: assert( Client != NULL );
! 1487:
! 1488: /* Don't register WHOWAS information when "MorePrivacy" is enabled. */
! 1489: if (Conf_MorePrivacy)
! 1490: return;
! 1491:
! 1492: now = time(NULL);
! 1493: /* Don't register clients that were connected less than 30 seconds. */
! 1494: if( now - Client->starttime < 30 )
! 1495: return;
! 1496:
! 1497: slot = Last_Whowas + 1;
! 1498: if( slot >= MAX_WHOWAS || slot < 0 ) slot = 0;
! 1499:
! 1500: #ifdef DEBUG
! 1501: Log( LOG_DEBUG, "Saving WHOWAS information to slot %d ...", slot );
! 1502: #endif
! 1503:
! 1504: My_Whowas[slot].time = now;
! 1505: strlcpy( My_Whowas[slot].id, Client_ID( Client ),
! 1506: sizeof( My_Whowas[slot].id ));
! 1507: strlcpy( My_Whowas[slot].user, Client_User( Client ),
! 1508: sizeof( My_Whowas[slot].user ));
! 1509: strlcpy( My_Whowas[slot].host, Client_HostnameDisplayed( Client ),
! 1510: sizeof( My_Whowas[slot].host ));
! 1511: strlcpy( My_Whowas[slot].info, Client_Info( Client ),
! 1512: sizeof( My_Whowas[slot].info ));
! 1513: strlcpy( My_Whowas[slot].server, Client_ID( Client_Introducer( Client )),
! 1514: sizeof( My_Whowas[slot].server ));
! 1515:
! 1516: Last_Whowas = slot;
! 1517: } /* Client_RegisterWhowas */
! 1518:
! 1519:
! 1520: GLOBAL const char *
! 1521: Client_TypeText(CLIENT *Client)
! 1522: {
! 1523: assert(Client != NULL);
! 1524: switch (Client_Type(Client)) {
! 1525: case CLIENT_USER:
! 1526: return "User";
! 1527: break;
! 1528: case CLIENT_SERVICE:
! 1529: return "Service";
! 1530: break;
! 1531: case CLIENT_SERVER:
! 1532: return "Server";
! 1533: break;
! 1534: default:
! 1535: return "Client";
! 1536: }
! 1537: } /* Client_TypeText */
! 1538:
! 1539:
! 1540: /**
! 1541: * Destroy user or service client.
! 1542: */
! 1543: static void
! 1544: Destroy_UserOrService(CLIENT *Client, const char *Txt, const char *FwdMsg, bool SendQuit)
! 1545: {
! 1546: if(Client->conn_id != NONE) {
! 1547: /* Local (directly connected) client */
! 1548: Log(LOG_NOTICE,
! 1549: "%s \"%s\" unregistered (connection %d): %s.",
! 1550: Client_TypeText(Client), Client_Mask(Client),
! 1551: Client->conn_id, Txt);
! 1552: Log_ServerNotice('c', "Client exiting: %s (%s@%s) [%s]",
! 1553: Client_ID(Client), Client_User(Client),
! 1554: Client_Hostname(Client), Txt);
! 1555:
! 1556: if (SendQuit) {
! 1557: /* Inforam all the other servers */
! 1558: if (FwdMsg)
! 1559: IRC_WriteStrServersPrefix(NULL,
! 1560: Client, "QUIT :%s", FwdMsg );
! 1561: else
! 1562: IRC_WriteStrServersPrefix(NULL,
! 1563: Client, "QUIT :");
! 1564: }
! 1565: } else {
! 1566: /* Remote client */
! 1567: LogDebug("%s \"%s\" unregistered: %s.",
! 1568: Client_TypeText(Client), Client_Mask(Client), Txt);
! 1569:
! 1570: if(SendQuit) {
! 1571: /* Inform all the other servers, but the ones in the
! 1572: * direction we got the QUIT from */
! 1573: if(FwdMsg)
! 1574: IRC_WriteStrServersPrefix(Client_NextHop(Client),
! 1575: Client, "QUIT :%s", FwdMsg );
! 1576: else
! 1577: IRC_WriteStrServersPrefix(Client_NextHop(Client),
! 1578: Client, "QUIT :" );
! 1579: }
! 1580: }
! 1581:
! 1582: /* Unregister client from channels */
! 1583: Channel_Quit(Client, FwdMsg ? FwdMsg : Client->id);
! 1584:
! 1585: /* Register client in My_Whowas structure */
! 1586: Client_RegisterWhowas(Client);
! 1587: } /* Destroy_UserOrService */
! 1588:
! 1589:
! 1590: /**
! 1591: * Introduce a new user or service client to a remote server.
! 1592: *
! 1593: * @param To The remote server to inform.
! 1594: * @param Prefix Prefix for the generated commands.
! 1595: * @param data CLIENT structure of the new client.
! 1596: */
! 1597: static void
! 1598: cb_introduceClient(CLIENT *To, CLIENT *Prefix, void *data)
! 1599: {
! 1600: CLIENT *c = (CLIENT *)data;
! 1601:
! 1602: (void)Client_Announce(To, Prefix, c);
! 1603:
! 1604: } /* cb_introduceClient */
! 1605:
! 1606:
! 1607: /**
! 1608: * Announce an user or service to a server.
! 1609: *
! 1610: * This function differentiates between RFC1459 and RFC2813 server links and
! 1611: * generates the appropriate commands to register the user or service.
! 1612: *
! 1613: * @param Client Server
! 1614: * @param Prefix Prefix for the generated commands
! 1615: * @param User User to announce
! 1616: */
! 1617: GLOBAL bool
! 1618: Client_Announce(CLIENT * Client, CLIENT * Prefix, CLIENT * User)
! 1619: {
! 1620: CONN_ID conn;
! 1621: char *modes, *user, *host;
! 1622:
! 1623: modes = Client_Modes(User);
! 1624: user = Client_User(User) ? Client_User(User) : "-";
! 1625: host = Client_Hostname(User) ? Client_Hostname(User) : "-";
! 1626:
! 1627: conn = Client_Conn(Client);
! 1628: if (Conn_Options(conn) & CONN_RFC1459) {
! 1629: /* RFC 1459 mode: separate NICK and USER commands */
! 1630: if (! Conn_WriteStr(conn, "NICK %s :%d",
! 1631: Client_ID(User), Client_Hops(User) + 1))
! 1632: return DISCONNECTED;
! 1633: if (! Conn_WriteStr(conn, ":%s USER %s %s %s :%s",
! 1634: Client_ID(User), user, host,
! 1635: Client_ID(Client_Introducer(User)),
! 1636: Client_Info(User)))
! 1637: return DISCONNECTED;
! 1638: if (modes[0]) {
! 1639: if (! Conn_WriteStr(conn, ":%s MODE %s +%s",
! 1640: Client_ID(User), Client_ID(User),
! 1641: modes))
! 1642: return DISCONNECTED;
! 1643: }
! 1644: } else {
! 1645: /* RFC 2813 mode: one combined NICK or SERVICE command */
! 1646: if (Client_Type(User) == CLIENT_SERVICE
! 1647: && Client_HasFlag(Client, 'S')) {
! 1648: if (!IRC_WriteStrClientPrefix(Client, Prefix,
! 1649: "SERVICE %s %d * +%s %d :%s",
! 1650: Client_Mask(User),
! 1651: Client_MyToken(Client_Introducer(User)),
! 1652: modes, Client_Hops(User) + 1,
! 1653: Client_Info(User)))
! 1654: return DISCONNECTED;
! 1655: } else {
! 1656: if (!IRC_WriteStrClientPrefix(Client, Prefix,
! 1657: "NICK %s %d %s %s %d +%s :%s",
! 1658: Client_ID(User), Client_Hops(User) + 1,
! 1659: user, host,
! 1660: Client_MyToken(Client_Introducer(User)),
! 1661: modes, Client_Info(User)))
! 1662: return DISCONNECTED;
! 1663: }
! 1664: }
! 1665:
! 1666: if (Client_HasFlag(Client, 'M')) {
! 1667: /* Synchronize metadata */
! 1668: if (Client_HostnameCloaked(User)) {
! 1669: if (!IRC_WriteStrClientPrefix(Client, Prefix,
! 1670: "METADATA %s cloakhost :%s",
! 1671: Client_ID(User),
! 1672: Client_HostnameCloaked(User)))
! 1673: return DISCONNECTED;
! 1674: }
! 1675:
! 1676: if (Client_AccountName(User)) {
! 1677: if (!IRC_WriteStrClientPrefix(Client, Prefix,
! 1678: "METADATA %s accountname :%s",
! 1679: Client_ID(User),
! 1680: Client_AccountName(User)))
! 1681: return DISCONNECTED;
! 1682: }
! 1683:
! 1684: if (Conn_GetCertFp(Client_Conn(User))) {
! 1685: if (!IRC_WriteStrClientPrefix(Client, Prefix,
! 1686: "METADATA %s certfp :%s",
! 1687: Client_ID(User),
! 1688: Conn_GetCertFp(Client_Conn(User))))
! 1689: return DISCONNECTED;
! 1690: }
! 1691: }
! 1692:
! 1693: return CONNECTED;
! 1694: } /* Client_Announce */
! 1695:
! 1696:
! 1697: #ifdef DEBUG
! 1698:
! 1699: GLOBAL void
! 1700: Client_DebugDump(void)
! 1701: {
! 1702: CLIENT *c;
! 1703:
! 1704: Log(LOG_DEBUG, "Client status:");
! 1705: c = My_Clients;
! 1706: while (c) {
! 1707: Log(LOG_DEBUG,
! 1708: " - %s: type=%d, host=%s, user=%s, conn=%d, start=%ld, flags=%s",
! 1709: Client_ID(c), Client_Type(c), Client_Hostname(c),
! 1710: Client_User(c), Client_Conn(c), Client_StartTime(c),
! 1711: Client_Flags(c));
! 1712: c = (CLIENT *)c->next;
! 1713: }
! 1714: } /* Client_DumpClients */
! 1715:
! 1716: #endif
! 1717:
! 1718:
! 1719: /* -eof- */
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to client.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / ircnowd / src / ngircd