diff options
Diffstat (limited to 'docs/man/man3/users.cpp.3')
| -rw-r--r-- | docs/man/man3/users.cpp.3 | 689 |
1 files changed, 687 insertions, 2 deletions
diff --git a/docs/man/man3/users.cpp.3 b/docs/man/man3/users.cpp.3 index 05915282e..af36eb556 100644 --- a/docs/man/man3/users.cpp.3 +++ b/docs/man/man3/users.cpp.3 @@ -1,4 +1,4 @@ -.TH "users.cpp" 3 "15 Dec 2005" "Version 1.0Betareleases" "InspIRCd" \" -*- nroff -*- +.TH "users.cpp" 3 "19 Dec 2005" "Version 1.0Betareleases" "InspIRCd" \" -*- nroff -*- .ad l .nh .SH NAME @@ -24,23 +24,708 @@ users.cpp \- .br \fC#include 'helperfuncs.h'\fP .br +\fC#include 'typedefs.h'\fP +.br +\fC#include 'socketengine.h'\fP +.br +\fC#include 'hashcomp.h'\fP +.br +\fC#include 'message.h'\fP +.br +\fC#include 'wildcard.h'\fP +.br +\fC#include 'xline.h'\fP +.br +.SS "Functions" + +.in +1c +.ti -1c +.RI "template<typename T> \fBstring\fP \fBConvToStr\fP (const T &in)" +.br +.ti -1c +.RI "void \fBAddOper\fP (\fBuserrec\fP *user)" +.br +.ti -1c +.RI "void \fBDeleteOper\fP (\fBuserrec\fP *user)" +.br +.ti -1c +.RI "void \fBkill_link\fP (\fBuserrec\fP *user, const char *r)" +.br +.ti -1c +.RI "void \fBkill_link_silent\fP (\fBuserrec\fP *user, const char *r)" +.br +.ti -1c +.RI "void \fBAddWhoWas\fP (\fBuserrec\fP *u)" +.br +.ti -1c +.RI "void \fBAddClient\fP (int socket, char *host, int port, bool iscached, char *ip)" +.br +.ti -1c +.RI "void \fBFullConnectUser\fP (\fBuserrec\fP *user)" +.br +.ti -1c +.RI "void \fBConnectUser\fP (\fBuserrec\fP *user)" +.br +.ti -1c +.RI "\fBuserrec\fP * \fBReHashNick\fP (char *Old, char *New)" +.br +.ti -1c +.RI "void \fBforce_nickchange\fP (\fBuserrec\fP *user, const char *newnick)" +.br +.in -1c .SS "Variables" .in +1c .ti -1c -.RI "\fBServerConfig\fP * \fBConfig\fP" +.RI "\fBInspIRCd\fP * \fBServerInstance\fP" +.br +.ti -1c +.RI "int \fBWHOWAS_STALE\fP" +.br +.ti -1c +.RI "int \fBWHOWAS_MAX\fP" +.br +.ti -1c +.RI "std::vector< \fBModule\fP * > \fBmodules\fP" +.br +.ti -1c +.RI "std::vector< \fBircd_module\fP * > \fBfactory\fP" +.br +.ti -1c +.RI "std::vector< \fBInspSocket\fP * > \fBmodule_sockets\fP" +.br +.ti -1c +.RI "int \fBMODCOUNT\fP" +.br +.ti -1c +.RI "\fBInspSocket\fP * \fBsocket_ref\fP [65535]" .br .ti -1c .RI "time_t \fBTIME\fP" .br +.ti -1c +.RI "\fBuserrec\fP * \fBfd_ref_table\fP [65536]" +.br +.ti -1c +.RI "\fBServerConfig\fP * \fBConfig\fP" +.br +.ti -1c +.RI "\fBuser_hash\fP \fBclientlist\fP" +.br +.ti -1c +.RI "\fBwhowas_hash\fP \fBwhowas\fP" +.br +.ti -1c +.RI "std::vector< \fBuserrec\fP * > \fBlocal_users\fP" +.br +.ti -1c +.RI "std::vector< \fBuserrec\fP * > \fBall_opers\fP" +.br .in -1c +.SH "Function Documentation" +.PP +.SS "void AddClient (int socket, char * host, int port, bool iscached, char * ip)" +.PP +Definition at line 524 of file users.cpp. +.PP +References SocketEngine::AddFd(), CC_ALLOW, ucrec::channel, ServerConfig::Classes, clientlist, ConvToStr(), DEBUG, ServerConfig::dns_timeout, FindServerNamePtr(), kill_link(), local_users, log(), matches_exception(), matches_zline(), InspIRCd::SE, ServerConfig::ServerName, ServerConfig::SoftLimit, TIME, ucrec::uc_modes, and X_ESTAB_CLIENT. +.PP +.nf +525 { +526 string tempnick; +527 char tn2[MAXBUF]; +528 user_hash::iterator iter; +529 +530 tempnick = ConvToStr(socket) + '-unknown'; +531 sprintf(tn2,'%lu-unknown',(unsigned long)socket); +532 +533 iter = clientlist.find(tempnick); +534 +535 // fix by brain. +536 // as these nicknames are 'RFC impossible', we can be sure nobody is going to be +537 // using one as a registered connection. As theyre per fd, we can also safely assume +538 // that we wont have collisions. Therefore, if the nick exists in the list, its only +539 // used by a dead socket, erase the iterator so that the new client may reclaim it. +540 // this was probably the cause of 'server ignores me when i hammer it with reconnects' +541 // issue in earlier alphas/betas +542 if (iter != clientlist.end()) +543 { +544 userrec* goner = iter->second; +545 delete goner; +546 clientlist.erase(iter); +547 } +548 +549 /* +550 * It is OK to access the value here this way since we know +551 * it exists, we just created it above. +552 * +553 * At NO other time should you access a value in a map or a +554 * hash_map this way. +555 */ +556 clientlist[tempnick] = new userrec(); +557 +558 log(DEBUG,'AddClient: %lu %s %d %s',(unsigned long)socket,host,port,ip); +559 +560 clientlist[tempnick]->fd = socket; +561 strlcpy(clientlist[tempnick]->nick, tn2,NICKMAX); +562 strlcpy(clientlist[tempnick]->host, host,160); +563 strlcpy(clientlist[tempnick]->dhost, host,160); +564 clientlist[tempnick]->server = (char*)FindServerNamePtr(Config->ServerName); +565 strlcpy(clientlist[tempnick]->ident, 'unknown',IDENTMAX); +566 clientlist[tempnick]->registered = 0; +567 clientlist[tempnick]->signon = TIME + Config->dns_timeout; +568 clientlist[tempnick]->lastping = 1; +569 clientlist[tempnick]->port = port; +570 strlcpy(clientlist[tempnick]->ip,ip,16); +571 +572 // set the registration timeout for this user +573 unsigned long class_regtimeout = 90; +574 int class_flood = 0; +575 long class_threshold = 5; +576 long class_sqmax = 262144; // 256kb +577 long class_rqmax = 4096; // 4k +578 +579 for (ClassVector::iterator i = Config->Classes.begin(); i != Config->Classes.end(); i++) +580 { +581 if (match(clientlist[tempnick]->host,i->host) && (i->type == CC_ALLOW)) +582 { +583 class_regtimeout = (unsigned long)i->registration_timeout; +584 class_flood = i->flood; +585 clientlist[tempnick]->pingmax = i->pingtime; +586 class_threshold = i->threshold; +587 class_sqmax = i->sendqmax; +588 class_rqmax = i->recvqmax; +589 break; +590 } +591 } +592 +593 clientlist[tempnick]->nping = TIME+clientlist[tempnick]->pingmax + Config->dns_timeout; +594 clientlist[tempnick]->timeout = TIME+class_regtimeout; +595 clientlist[tempnick]->flood = class_flood; +596 clientlist[tempnick]->threshold = class_threshold; +597 clientlist[tempnick]->sendqmax = class_sqmax; +598 clientlist[tempnick]->recvqmax = class_rqmax; +599 +600 ucrec a; +601 a.channel = NULL; +602 a.uc_modes = 0; +603 for (int i = 0; i < MAXCHANS; i++) +604 clientlist[tempnick]->chans.push_back(a); +605 +606 if (clientlist.size() > Config->SoftLimit) +607 { +608 kill_link(clientlist[tempnick],'No more connections allowed'); +609 return; +610 } +611 +612 if (clientlist.size() >= MAXCLIENTS) +613 { +614 kill_link(clientlist[tempnick],'No more connections allowed'); +615 return; +616 } +617 +618 // this is done as a safety check to keep the file descriptors within range of fd_ref_table. +619 // its a pretty big but for the moment valid assumption: +620 // file descriptors are handed out starting at 0, and are recycled as theyre freed. +621 // therefore if there is ever an fd over 65535, 65536 clients must be connected to the +622 // irc server at once (or the irc server otherwise initiating this many connections, files etc) +623 // which for the time being is a physical impossibility (even the largest networks dont have more +624 // than about 10,000 users on ONE server!) +625 if ((unsigned)socket > 65534) +626 { +627 kill_link(clientlist[tempnick],'Server is full'); +628 return; +629 } +630 char* e = matches_exception(ip); +631 if (!e) +632 { +633 char* r = matches_zline(ip); +634 if (r) +635 { +636 char reason[MAXBUF]; +637 snprintf(reason,MAXBUF,'Z-Lined: %s',r); +638 kill_link(clientlist[tempnick],reason); +639 return; +640 } +641 } +642 fd_ref_table[socket] = clientlist[tempnick]; +643 local_users.push_back(clientlist[tempnick]); +644 ServerInstance->SE->AddFd(socket,true,X_ESTAB_CLIENT); +645 } +.fi +.PP +.SS "void AddOper (\fBuserrec\fP * user)" +.PP +Definition at line 330 of file users.cpp. +.PP +References all_opers, DEBUG, and log(). +.PP +.nf +331 { +332 log(DEBUG,'Oper added to optimization list'); +333 all_opers.push_back(user); +334 } +.fi +.PP +.SS "void AddWhoWas (\fBuserrec\fP * u)" +.PP +Definition at line 471 of file users.cpp. +.PP +References DEBUG, WhoWasUser::dhost, userrec::dhost, WhoWasUser::fullname, userrec::fullname, WhoWasUser::host, connection::host, WhoWasUser::ident, userrec::ident, log(), userrec::nick, WhoWasUser::nick, WhoWasUser::server, userrec::server, WhoWasUser::signon, connection::signon, TIME, whowas, WHOWAS_MAX, and WHOWAS_STALE. +.PP +Referenced by kill_link(). +.PP +.nf +472 { +473 whowas_hash::iterator iter = whowas.find(u->nick); +474 WhoWasUser *a = new WhoWasUser(); +475 strlcpy(a->nick,u->nick,NICKMAX); +476 strlcpy(a->ident,u->ident,IDENTMAX); +477 strlcpy(a->dhost,u->dhost,160); +478 strlcpy(a->host,u->host,160); +479 strlcpy(a->fullname,u->fullname,MAXGECOS); +480 strlcpy(a->server,u->server,256); +481 a->signon = u->signon; +482 +483 /* MAX_WHOWAS: max number of /WHOWAS items +484 * WHOWAS_STALE: number of hours before a WHOWAS item is marked as stale and +485 * can be replaced by a newer one +486 */ +487 +488 if (iter == whowas.end()) +489 { +490 if (whowas.size() >= (unsigned)WHOWAS_MAX) +491 { +492 for (whowas_hash::iterator i = whowas.begin(); i != whowas.end(); i++) +493 { +494 // 3600 seconds in an hour ;) +495 if ((i->second->signon)<(TIME-(WHOWAS_STALE*3600))) +496 { +497 // delete the old one +498 if (i->second) delete i->second; +499 // replace with new one +500 i->second = a; +501 log(DEBUG,'added WHOWAS entry, purged an old record'); +502 return; +503 } +504 } +505 // no space left and user doesnt exist. Don't leave ram in use! +506 log(DEBUG,'Not able to update whowas (list at WHOWAS_MAX entries and trying to add new?), freeing excess ram'); +507 delete a; +508 } +509 else +510 { +511 log(DEBUG,'added fresh WHOWAS entry'); +512 whowas[a->nick] = a; +513 } +514 } +515 else +516 { +517 log(DEBUG,'updated WHOWAS entry'); +518 if (iter->second) delete iter->second; +519 iter->second = a; +520 } +521 } +.fi +.PP +.SS "void ConnectUser (\fBuserrec\fP * user)" +.PP +Definition at line 731 of file users.cpp. +.PP +References userrec::dns_done, FullConnectUser(), and connection::registered. +.PP +.nf +732 { +733 // dns is already done, things are fast. no need to wait for dns to complete just pass them straight on +734 if ((user->dns_done) && (user->registered >= 3) && (AllModulesReportReady(user))) +735 { +736 FullConnectUser(user); +737 } +738 } +.fi +.PP +.SS "template<typename T> \fBstring\fP ConvToStr (const T & in)\fC [inline]\fP" +.PP +Definition at line 56 of file users.cpp. +.PP +Referenced by AddClient(). +.PP +.nf +57 { +58 stringstream tmp; +59 if (!(tmp << in)) return string(); +60 return tmp.str(); +61 } +.fi +.PP +.SS "void DeleteOper (\fBuserrec\fP * user)" +.PP +Definition at line 336 of file users.cpp. +.PP +References all_opers, DEBUG, and log(). +.PP +.nf +337 { +338 for (std::vector<userrec*>::iterator a = all_opers.begin(); a < all_opers.end(); a++) +339 { +340 if (*a == user) +341 { +342 log(DEBUG,'Oper removed from optimization list'); +343 all_opers.erase(a); +344 return; +345 } +346 } +347 } +.fi +.PP +.SS "void force_nickchange (\fBuserrec\fP * user, const char * newnick)" +.PP +Definition at line 769 of file users.cpp. +.PP +References FOREACH_RESULT, kill_link(), matches_qline(), InspIRCd::Parser, connection::registered, InspIRCd::stats, and serverstats::statsCollisions. +.PP +Referenced by Server::ChangeUserNick(). +.PP +.nf +770 { +771 char nick[MAXBUF]; +772 int MOD_RESULT = 0; +773 +774 strcpy(nick,''); +775 +776 FOREACH_RESULT(OnUserPreNick(user,newnick)); +777 if (MOD_RESULT) { +778 ServerInstance->stats->statsCollisions++; +779 kill_link(user,'Nickname collision'); +780 return; +781 } +782 if (matches_qline(newnick)) +783 { +784 ServerInstance->stats->statsCollisions++; +785 kill_link(user,'Nickname collision'); +786 return; +787 } +788 +789 if (user) +790 { +791 if (newnick) +792 { +793 strncpy(nick,newnick,MAXBUF); +794 } +795 if (user->registered == 7) +796 { +797 char* pars[1]; +798 pars[0] = nick; +799 std::string cmd = 'NICK'; +800 ServerInstance->Parser->CallHandler(cmd,pars,1,user); +801 } +802 } +803 } +.fi +.PP +.SS "void FullConnectUser (\fBuserrec\fP * user)" +.PP +Definition at line 647 of file users.cpp. +.PP +References DEBUG, connection::fd, FOREACH_MOD, connection::haspassed, connection::host, userrec::ident, connection::idle_lastmsg, connection::ip, kill_link(), kill_link_silent(), log(), matches_exception(), matches_gline(), matches_kline(), ServerConfig::Network, userrec::nick, connection::port, connection::registered, ServerConfig::ServerName, InspIRCd::stats, serverstats::statsConnects, TIME, WriteOpers(), and WriteServ(). +.PP +Referenced by ConnectUser(). +.PP +.nf +648 { +649 ServerInstance->stats->statsConnects++; +650 user->idle_lastmsg = TIME; +651 log(DEBUG,'ConnectUser: %s',user->nick); +652 +653 if ((strcmp(Passwd(user),'')) && (!user->haspassed)) +654 { +655 kill_link(user,'Invalid password'); +656 return; +657 } +658 if (IsDenied(user)) +659 { +660 kill_link(user,'Unauthorised connection'); +661 return; +662 } +663 +664 char match_against[MAXBUF]; +665 snprintf(match_against,MAXBUF,'%s@%s',user->ident,user->host); +666 char* e = matches_exception(match_against); +667 if (!e) +668 { +669 char* r = matches_gline(match_against); +670 if (r) +671 { +672 char reason[MAXBUF]; +673 snprintf(reason,MAXBUF,'G-Lined: %s',r); +674 kill_link_silent(user,reason); +675 return; +676 } +677 r = matches_kline(user->host); +678 if (r) +679 { +680 char reason[MAXBUF]; +681 snprintf(reason,MAXBUF,'K-Lined: %s',r); +682 kill_link_silent(user,reason); +683 return; +684 } +685 } +686 +687 +688 WriteServ(user->fd,'NOTICE Auth :Welcome to \002%s\002!',Config->Network); +689 WriteServ(user->fd,'001 %s :Welcome to the %s IRC Network %s!%s@%s',user->nick,Config->Network,user->nick,user->ident,user->host); +690 WriteServ(user->fd,'002 %s :Your host is %s, running version %s',user->nick,Config->ServerName,VERSION); +691 WriteServ(user->fd,'003 %s :This server was created %s %s',user->nick,__TIME__,__DATE__); +692 WriteServ(user->fd,'004 %s %s %s iowghraAsORVSxNCWqBzvdHtGI lvhopsmntikrRcaqOALQbSeKVfHGCuzN',user->nick,Config->ServerName,VERSION); +693 // the neatest way to construct the initial 005 numeric, considering the number of configure constants to go in it... +694 std::stringstream v; +695 v << 'WALLCHOPS MODES=13 CHANTYPES=# PREFIX=(ohv)@%+ MAP SAFELIST MAXCHANNELS=' << MAXCHANS; +696 v << ' MAXBANS=60 NICKLEN=' << NICKMAX; +697 v << ' TOPICLEN=' << MAXTOPIC << ' KICKLEN=' << MAXKICK << ' MAXTARGETS=20 AWAYLEN=' << MAXAWAY << ' CHANMODES=ohvb,k,l,psmnti NETWORK='; +698 v << Config->Network; +699 std::string data005 = v.str(); +700 FOREACH_MOD On005Numeric(data005); +701 // anfl @ #ratbox, efnet reminded me that according to the RFC this cant contain more than 13 tokens per line... +702 // so i'd better split it :) +703 std::stringstream out(data005); +704 std::string token = ''; +705 std::string line5 = ''; +706 int token_counter = 0; +707 while (!out.eof()) +708 { +709 out >> token; +710 line5 = line5 + token + ' '; +711 token_counter++; +712 if ((token_counter >= 13) || (out.eof() == true)) +713 { +714 WriteServ(user->fd,'005 %s %s:are supported by this server',user->nick,line5.c_str()); +715 line5 = ''; +716 token_counter = 0; +717 } +718 } +719 ShowMOTD(user); +720 +721 // fix 3 by brain, move registered = 7 below these so that spurious modes and host changes dont go out +722 // onto the network and produce 'fake direction' +723 FOREACH_MOD OnUserConnect(user); +724 FOREACH_MOD OnGlobalConnect(user); +725 user->registered = 7; +726 WriteOpers('*** Client connecting on port %lu: %s!%s@%s [%s]',(unsigned long)user->port,user->nick,user->ident,user->host,user->ip); +727 } +.fi +.PP +.SS "void kill_link (\fBuserrec\fP * user, const char * r)" +.PP +Definition at line 349 of file users.cpp. +.PP +References AddWhoWas(), clientlist, userrec::CloseSocket(), DEBUG, SocketEngine::DelFd(), connection::fd, userrec::FlushWriteBuf(), FOREACH_MOD, ServerConfig::GetIOHook(), connection::host, userrec::ident, local_users, log(), userrec::nick, Module::OnRawSocketClose(), connection::port, connection::registered, InspIRCd::SE, Write(), WriteCommonExcept(), and WriteOpers(). +.PP +Referenced by AddClient(), force_nickchange(), FullConnectUser(), Server::PseudoToUser(), and Server::QuitUser(). +.PP +.nf +350 { +351 user_hash::iterator iter = clientlist.find(user->nick); +352 +353 char reason[MAXBUF]; +354 +355 strncpy(reason,r,MAXBUF); +356 +357 if (strlen(reason)>MAXQUIT) +358 { +359 reason[MAXQUIT-1] = '\0'; +360 } +361 +362 log(DEBUG,'kill_link: %s '%s'',user->nick,reason); +363 Write(user->fd,'ERROR :Closing link (%s@%s) [%s]',user->ident,user->host,reason); +364 log(DEBUG,'closing fd %lu',(unsigned long)user->fd); +365 +366 if (user->registered == 7) { +367 FOREACH_MOD OnUserQuit(user,reason); +368 WriteCommonExcept(user,'QUIT :%s',reason); +369 } +370 +371 user->FlushWriteBuf(); +372 +373 FOREACH_MOD OnUserDisconnect(user); +374 +375 if (user->fd > -1) +376 { +377 if (Config->GetIOHook(user->port)) +378 { +379 Config->GetIOHook(user->port)->OnRawSocketClose(user->fd); +380 } +381 ServerInstance->SE->DelFd(user->fd); +382 user->CloseSocket(); +383 } +384 +385 // this must come before the WriteOpers so that it doesnt try to fill their buffer with anything +386 // if they were an oper with +s. +387 if (user->registered == 7) { +388 purge_empty_chans(user); +389 // fix by brain: only show local quits because we only show local connects (it just makes SENSE) +390 if (user->fd > -1) +391 WriteOpers('*** Client exiting: %s!%s@%s [%s]',user->nick,user->ident,user->host,reason); +392 AddWhoWas(user); +393 } +394 +395 if (iter != clientlist.end()) +396 { +397 log(DEBUG,'deleting user hash value %lu',(unsigned long)user); +398 if (user->fd > -1) +399 { +400 fd_ref_table[user->fd] = NULL; +401 if (find(local_users.begin(),local_users.end(),user) != local_users.end()) +402 { +403 local_users.erase(find(local_users.begin(),local_users.end(),user)); +404 log(DEBUG,'Delete local user'); +405 } +406 } +407 clientlist.erase(iter); +408 } +409 delete user; +410 } +.fi +.PP +.SS "void kill_link_silent (\fBuserrec\fP * user, const char * r)" +.PP +Definition at line 412 of file users.cpp. +.PP +References clientlist, userrec::CloseSocket(), DEBUG, SocketEngine::DelFd(), connection::fd, userrec::FlushWriteBuf(), FOREACH_MOD, ServerConfig::GetIOHook(), connection::host, userrec::ident, local_users, log(), userrec::nick, Module::OnRawSocketClose(), connection::port, connection::registered, InspIRCd::SE, Write(), and WriteCommonExcept(). +.PP +Referenced by FullConnectUser(). +.PP +.nf +413 { +414 user_hash::iterator iter = clientlist.find(user->nick); +415 +416 char reason[MAXBUF]; +417 +418 strncpy(reason,r,MAXBUF); +419 +420 if (strlen(reason)>MAXQUIT) +421 { +422 reason[MAXQUIT-1] = '\0'; +423 } +424 +425 log(DEBUG,'kill_link: %s '%s'',user->nick,reason); +426 Write(user->fd,'ERROR :Closing link (%s@%s) [%s]',user->ident,user->host,reason); +427 log(DEBUG,'closing fd %lu',(unsigned long)user->fd); +428 +429 user->FlushWriteBuf(); +430 +431 if (user->registered == 7) { +432 FOREACH_MOD OnUserQuit(user,reason); +433 WriteCommonExcept(user,'QUIT :%s',reason); +434 } +435 +436 FOREACH_MOD OnUserDisconnect(user); +437 +438 if (user->fd > -1) +439 { +440 if (Config->GetIOHook(user->port)) +441 { +442 Config->GetIOHook(user->port)->OnRawSocketClose(user->fd); +443 } +444 ServerInstance->SE->DelFd(user->fd); +445 user->CloseSocket(); +446 } +447 +448 if (user->registered == 7) { +449 purge_empty_chans(user); +450 } +451 +452 if (iter != clientlist.end()) +453 { +454 log(DEBUG,'deleting user hash value %lu',(unsigned long)user); +455 if (user->fd > -1) +456 { +457 fd_ref_table[user->fd] = NULL; +458 if (find(local_users.begin(),local_users.end(),user) != local_users.end()) +459 { +460 log(DEBUG,'Delete local user'); +461 local_users.erase(find(local_users.begin(),local_users.end(),user)); +462 } +463 } +464 clientlist.erase(iter); +465 } +466 delete user; +467 } +.fi +.PP +.SS "\fBuserrec\fP* ReHashNick (char * Old, char * New)" +.PP +Definition at line 743 of file users.cpp. +.PP +References clientlist, DEBUG, and log(). +.PP +.nf +744 { +745 //user_hash::iterator newnick; +746 user_hash::iterator oldnick = clientlist.find(Old); +747 +748 log(DEBUG,'ReHashNick: %s %s',Old,New); +749 +750 if (!strcasecmp(Old,New)) +751 { +752 log(DEBUG,'old nick is new nick, skipping'); +753 return oldnick->second; +754 } +755 +756 if (oldnick == clientlist.end()) return NULL; /* doesnt exist */ +757 +758 log(DEBUG,'ReHashNick: Found hashed nick %s',Old); +759 +760 userrec* olduser = oldnick->second; +761 clientlist[New] = olduser; +762 clientlist.erase(oldnick); +763 +764 log(DEBUG,'ReHashNick: Nick rehashed as %s',New); +765 +766 return clientlist[New]; +767 } +.fi +.PP .SH "Variable Documentation" .PP +.SS "std::vector<\fBuserrec\fP*> \fBall_opers\fP" +.PP +Definition at line 54 of file users.cpp. +.PP +Referenced by AddOper(), and DeleteOper(). +.SS "\fBuser_hash\fP \fBclientlist\fP" +.PP .SS "\fBServerConfig\fP* \fBConfig\fP" .PP +.SS "std::vector<\fBircd_module\fP*> factory" +.PP +.SS "\fBuserrec\fP* \fBfd_ref_table\fP[65536]" +.PP +.SS "std::vector<\fBuserrec\fP*> \fBlocal_users\fP" +.PP +Definition at line 52 of file users.cpp. +.PP +Referenced by AddClient(), kill_link(), and kill_link_silent(). +.SS "int \fBMODCOUNT\fP" +.PP +.SS "std::vector<\fBInspSocket\fP*> \fBmodule_sockets\fP" +.PP +.SS "std::vector<\fBModule\fP*> modules" +.PP +.SS "\fBInspIRCd\fP* \fBServerInstance\fP" +.PP +.SS "\fBInspSocket\fP* \fBsocket_ref\fP[65535]" +.PP +Definition at line 43 of file socket.cpp. .SS "time_t \fBTIME\fP" .PP +.SS "\fBwhowas_hash\fP \fBwhowas\fP" +.PP +Referenced by AddWhoWas(). +.SS "int \fBWHOWAS_MAX\fP" +.PP +.SS "int \fBWHOWAS_STALE\fP" +.PP .SH "Author" .PP Generated automatically by Doxygen for InspIRCd from the source code. |