/* command access */
int noperserv_policy_command_permitted(flag_t level, nick *user) {
no_autheduser *au;
if(level == __NO_ANYONE)
return 1;
if((level & __NO_OPERED) && !IsOper(user))
return 0;
if(level & __NO_AUTHED) {
if(!IsAccount(user))
return 0;
if(level & __NO_ACCOUNT) {
if(!(au = NOGetAuthedUser(user)))
return 0;
if((level & __NO_DEVELOPER) && !NOIsDeveloper(au)) {
return 0;
} else if((level & __NO_OPER) && !NOIsLeastOper(au)) {
return 0;
} else if((level & __NO_STAFF) && !NOIsLeastStaff(au)) {
return 0;
}
if ((level & __NO_SEC) && !NOIsLeastSec(au))
return 0;
if ((level & __NO_TRUST) && !NOIsLeastTrust(au))
return 0;
if ((level & __NO_RELAY) && !NOIsLeastRelay(au))
return 0;
}
}
return 1;
}
void versionscan_newnick(int hooknum, void* arg) {
nick* np=(nick*)arg;
/* ignore opers or auth'd users, helps cut down on spam during a burst */
if (!(IsOper(np) || IsAccount(np)) && (versionscan_mode == VS_SCAN)) {
sendmessagetouser(versionscan_nick, np, "\001VERSION\001");
}
}
void hchannels_match_accounts(void)
{
hchannel *hchan = hchannels;
hchannel_user *hchanuser;
for (;hchan;hchan = hchan->next)
for (hchanuser = hchan->channel_users;hchanuser;hchanuser = hchanuser->next)
if (hchanuser->husr->account == NULL && IsAccount(hchanuser->husr->real_user))
hchanuser->husr->account = haccount_get_by_name(huser_get_auth(hchanuser->husr));
}
int IsVersionscanGlineAccess(nick* np) {
unsigned char level;
if (!IsAccount(np)) {
return 0;
}
level=versionscan_getlevelbyauth(np->authname);
if (level & (VS_GLINE | VS_ADMIN)) {
return 1;
}
return 0;
}
int IsVersionscanAdmin(nick* np) {
unsigned char level;
if (!IsAccount(np)) {
return 0;
}
level=versionscan_getlevelbyauth(np->authname);
if (level & VS_ADMIN) {
return 1;
}
return 0;
}
void LoginState::processUsername(const std::string &input, std::shared_ptr<Connection> connection) {
connection->SetUsername(input);
auto accounts = game_data->GetAccounts();
if(accounts.IsAccount(input))
{
Sender::Send("Password: \r\n", connection);
connection->SetAccount(accounts.GetAccount(input));
m_state_map[connection->GetID()] = PASSWORD;
}
else
{
Sender::Send("No account found, would you like to make a new one? Y/N\r\n", connection);
m_state_map[connection->GetID()] = NEWACCOUNT;
}
}
/*
* ms_account - server message handler
*
* parv[0] = sender prefix
* parv[1] = numeric of client to act on
* parv[2] = account name (12 characters or less)
*/
int ms_account(struct Client* cptr, struct Client* sptr, int parc,
char* parv[])
{
struct Client *acptr;
int hidden;
if (parc < 3)
return need_more_params(sptr, "ACCOUNT");
if (!IsServer(sptr))
return protocol_violation(cptr, "ACCOUNT from non-server %s",
cli_name(sptr));
if (!(acptr = findNUser(parv[1])))
return 0; /* Ignore ACCOUNT for a user that QUIT; probably crossed */
if (IsAccount(acptr))
return protocol_violation(cptr, "ACCOUNT for already registered user %s "
"(%s -> %s)", cli_name(acptr),
cli_user(acptr)->account, parv[2]);
assert(0 == cli_user(acptr)->account[0]);
if (strlen(parv[2]) > ACCOUNTLEN) {
return protocol_violation(cptr, "Received account (%s) longer than %d for %s; ignoring.", parv[2], ACCOUNTLEN, cli_name(acptr));
}
if (parc > 3) {
cli_user(acptr)->acc_create = atoi(parv[3]);
Debug((DEBUG_DEBUG, "Received timestamped account: account \"%s\", "
"timestamp %Tu", parv[2], cli_user(acptr)->acc_create));
}
hidden = HasHiddenHost(acptr);
SetAccount(acptr);
ircd_strncpy(cli_user(acptr)->account, parv[2], ACCOUNTLEN);
if (!hidden)
hide_hostmask(acptr);
sendcmdto_serv_butone(sptr, CMD_ACCOUNT, cptr,
cli_user(acptr)->acc_create ? "%C %s %Tu" : "%C %s",
acptr, cli_user(acptr)->account,
cli_user(acptr)->acc_create);
return 0;
}
void *authedpct_exe(searchCtx *ctx, struct searchNode *thenode, void *theinput) {
int i;
int j=0;
nick *np;
chanindex *cip = (chanindex *)theinput;
if (!cip->channel)
return (void *)0;
for (i=0;i<cip->channel->users->hashsize;i++) {
if (cip->channel->users->content[i]==nouser)
continue;
if ((np=getnickbynumeric(cip->channel->users->content[i])) && IsAccount(np))
j++;
}
return (void *)(long)((j * 100) / cip->channel->users->totalusers);
}
const char *hban_ban_string(nick *nck, int banflags)
{
static char buffer[256];
buffer[0] = '\0';
if (banflags & HBAN_NICK)
strcat(buffer, nck->nick);
else
strcat(buffer, "*");
strcat(buffer, "!");
if (banflags & HBAN_IDENT)
strcat(buffer, nck->ident);
else
strcat(buffer, "*");
strcat(buffer, "@");
if ((banflags & HBAN_HOST) && IsAccount(nck) && IsHideHost(nck))
{
strcat(buffer, nck->authname);
strcat(buffer, ".users.quakenet.org");
}
else if ((banflags & HBAN_REAL_HOST) || ((banflags & HBAN_HOST)))
{
if (IsSetHost(nck))
strcat(buffer, nck->sethost->content);
else
strcat(buffer, nck->host->name->content);
}
else
strcat(buffer, "*");
assert(strcmp(buffer, "*!*@*"));
return buffer;
}
int versionscan_whois(void* sender, int cargc, char** cargv) {
nick* np=(nick*)sender;
nick* target;
vsauthdata* v;
if (cargc < 1) {
sendnoticetouser(versionscan_nick, np, "Syntax: whois <nickname>");
return CMD_ERROR;
}
if (!(target=getnickbynick(cargv[0]))) {
sendnoticetouser(versionscan_nick, np, "No such nick.");
return CMD_ERROR;
}
if (!IsAccount(target)) {
sendnoticetouser(versionscan_nick, np, "%s is not authed with the network.", target->nick);
return CMD_ERROR;
}
if (!(v=versionscan_getauthbyauth(target->authname))) {
sendnoticetouser(versionscan_nick, np, "User %s is not in my database.", target->nick);
return CMD_ERROR;
}
sendnoticetouser(versionscan_nick, np, "%s is authed as %s, with flags: %s", target->nick, target->authname, versionscan_flagstochar(v->flags));
return CMD_OK;
}
int versionscan_changelev(void* sender, int cargc, char** cargv) {
nick* np=(nick*)sender;
vsauthdata* v;
nick* target;
unsigned char flags=0;
int i; int plus=1;
if (cargc < 2) {
sendnoticetouser(versionscan_nick, np, "Syntax: changelev <nick> [+|-]<level>");
return CMD_ERROR;
}
if (!(target=getnickbynick(cargv[0]))) {
sendnoticetouser(versionscan_nick, np, "No such nick.");
return CMD_ERROR;
}
if (!IsAccount(target)) {
sendnoticetouser(versionscan_nick, np, "%s is not authed.", target->nick);
return CMD_ERROR;
}
if ((v=versionscan_getauthbyauth(target->authname))) {
i=0;
if ((cargv[1][0] == '+') || (cargv[1][0] =='-')) {
plus=(cargv[1][0] == '+')?1:0;
i++;
flags=v->flags;
}
for (; cargv[1][i]; i++) {
switch (cargv[1][i]) {
case 'a':
flags=(plus)?flags | VS_ADMIN:flags & (~VS_ADMIN);
break;
case 'g':
flags=(plus)?flags | VS_GLINE:flags & (~VS_GLINE);
break;
case 's':
flags=(plus)?flags | VS_STAFF:flags & (~VS_STAFF);
break;
default:
sendnoticetouser(versionscan_nick, np, "Invalid level '%c'.", cargv[1][i]);
return CMD_ERROR;
break;
}
}
if (!flags) {
vsauthdata* pv, *prevv;
prevv=0;
for (pv=vsauths; pv; pv++) {
if (pv == v) {
if (prevv) {
prevv->next=pv->next;
free(pv);
}
else {
vsauths=pv->next;
free(pv);
}
break;
}
prevv=pv;
}
}
else {
v->flags=flags;
}
sendnoticetouser(versionscan_nick, np, "Done.");
return CMD_OK;
}
else {
i=0;
if ((cargv[1][0] == '+') || (cargv[1][0] =='-')) {
plus=(cargv[1][0] == '+')?1:0;
i++;
}
for (; cargv[1][i]; i++) {
switch (cargv[1][i]) {
case 'a':
flags=(plus)?flags | VS_ADMIN:flags & (~VS_ADMIN);
break;
case 'g':
flags=(plus)?flags | VS_GLINE:flags & (~VS_GLINE);
break;
case 's':
flags=(plus)?flags | VS_STAFF:flags & (~VS_STAFF);
break;
default:
sendnoticetouser(versionscan_nick, np, "Invalid level '%c'.", cargv[1][i]);
return CMD_ERROR;
break;
}
}
if (flags) {
for (v=vsauths; v; v=v->next) {
if (!v->next) {
v->next=(vsauthdata*)malloc(sizeof(vsauthdata));
strncpy(v->next->account, target->authname, ACCOUNTLEN);
v->next->flags=flags;
v->next->next=0;
sendnoticetouser(versionscan_nick, np, "Done.");
return CMD_OK;
}
}
sendnoticetouser(versionscan_nick, np, "Error adding user to database.");
}
else {
sendnoticetouser(versionscan_nick, np, "No level specified.");
}
}
return CMD_ERROR;
}
/*
* Send whois information for acptr to sptr
*/
static void do_whois(struct Client* sptr, struct Client *acptr, int parc)
{
struct Client *a2cptr=0;
struct Channel *chptr=0;
int mlen;
int len;
static char buf[512];
const struct User* user = cli_user(acptr);
const char* name = (!*(cli_name(acptr))) ? "?" : cli_name(acptr);
a2cptr = feature_bool(FEAT_HIS_WHOIS_SERVERNAME) && !IsAnOper(sptr)
&& sptr != acptr ? &his : user->server;
assert(user);
send_reply(sptr, RPL_WHOISUSER, name, user->username, user->host,
cli_info(acptr));
/* Display the channels this user is on. */
if (!IsChannelService(acptr))
{
struct Membership* chan;
mlen = strlen(cli_name(&me)) + strlen(cli_name(sptr)) + 12 + strlen(name);
len = 0;
*buf = '\0';
for (chan = user->channel; chan; chan = chan->next_channel)
{
chptr = chan->channel;
if (!ShowChannel(sptr, chptr)
&& !(IsOper(sptr) && IsLocalChannel(chptr->chname)))
continue;
if (acptr != sptr && IsZombie(chan))
continue;
/* Don't show local channels when HIS is defined, unless it's a
* remote WHOIS --ULtimaTe_
*/
if (IsLocalChannel(chptr->chname) && (acptr != sptr) && (parc == 2)
&& feature_bool(FEAT_HIS_WHOIS_LOCALCHAN) && !IsAnOper(sptr))
continue;
if (len+strlen(chptr->chname) + mlen > BUFSIZE - 5)
{
send_reply(sptr, SND_EXPLICIT | RPL_WHOISCHANNELS, "%s :%s", name, buf);
*buf = '\0';
len = 0;
}
if (IsDeaf(acptr))
*(buf + len++) = '-';
if (!ShowChannel(sptr, chptr))
*(buf + len++) = '*';
if (IsDelayedJoin(chan) && (sptr != acptr))
*(buf + len++) = '<';
else if (IsChanOp(chan))
*(buf + len++) = '@';
else if (HasVoice(chan))
*(buf + len++) = '+';
else if (IsZombie(chan))
*(buf + len++) = '!';
if (len)
*(buf + len) = '\0';
strcpy(buf + len, chptr->chname);
len += strlen(chptr->chname);
strcat(buf + len, " ");
len++;
}
if (buf[0] != '\0')
send_reply(sptr, RPL_WHOISCHANNELS, name, buf);
}
send_reply(sptr, RPL_WHOISSERVER, name, cli_name(a2cptr),
cli_info(a2cptr));
if (user)
{
if (user->away)
send_reply(sptr, RPL_AWAY, name, user->away);
if (SeeOper(sptr,acptr))
send_reply(sptr, RPL_WHOISOPERATOR, name);
if (IsAccount(acptr))
send_reply(sptr, RPL_WHOISACCOUNT, name, user->account);
if (HasHiddenHost(acptr) && (IsAnOper(sptr) || acptr == sptr))
send_reply(sptr, RPL_WHOISACTUALLY, name, user->username,
user->realhost, ircd_ntoa(&cli_ip(acptr)));
/* Hint: if your looking to add more flags to a user, eg +h, here's
* probably a good place to add them :)
*/
if (MyConnect(acptr) && (!feature_bool(FEAT_HIS_WHOIS_IDLETIME) ||
(sptr == acptr || IsAnOper(sptr) || parc >= 3)))
send_reply(sptr, RPL_WHOISIDLE, name, CurrentTime - user->last,
cli_firsttime(acptr));
}
}
int dofsck(void *source, int cargc, char **cargv) {
int i,j;
nick *sender=source, *np, *np2;
host *hp;
realname *rnp;
unsigned int nickmarker;
int errors=0;
unsigned int nummask,mnum;
/* Start off with strict nick consistency checks.. */
controlreply(sender,"- Performing nickname checks");
nickmarker=nextnickmarker();
for(i=0;i<HOSTHASHSIZE;i++)
for(hp=hosttable[i];hp;hp=hp->next)
hp->marker=0;
for(i=0;i<REALNAMEHASHSIZE;i++)
for(rnp=realnametable[i];rnp;rnp=rnp->next)
rnp->marker=0;
controlreply(sender," - Scanning nick hash table");
for (i=0;i<NICKHASHSIZE;i++) {
for(np=nicktable[i];np;np=np->next) {
if (np->marker==nickmarker) {
controlreply(sender, "ERROR: bumped into the same nick %s/%s twice in hash table.",longtonumeric(np->numeric,5),np->nick);
errors++;
}
/* Mark this nick so we can check we found them all */
np->marker=nickmarker;
/* Check that we can find this nick with the lookup functions */
if (getnickbynick(np->nick) != np) {
controlreply(sender, "ERROR: can't find %s/%s using getnickbynick().",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
if (getnickbynumeric(np->numeric) != np) {
controlreply(sender, "ERROR: can't find %s/%s using getnickbynumeric().",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
/* Check that the nick appears in the list of nicks using its host */
if (findhost(np->host->name->content) != np->host) {
controlreply(sender, "ERROR: can't find %s/%s's host (%s) using findhost().",
longtonumeric(np->numeric,5),np->nick,np->host->name->content);
errors++;
}
for(np2=np->host->nicks;np2;np2=np2->nextbyhost)
if (np2==np)
break;
if (!np2) {
controlreply(sender, "ERROR: can't find %s/%s (host=%s) on the host users list.",
longtonumeric(np->numeric,5),np->nick,np->host->name->content);
errors++;
}
np->host->marker++;
/* Same for realnames */
if (findrealname(np->realname->name->content) != np->realname) {
controlreply(sender, "ERROR: can't find %s/%s's realname (%s) using findrealname().",
longtonumeric(np->numeric,5),np->nick,np->realname->name->content);
errors++;
}
for(np2=np->realname->nicks;np2;np2=np2->nextbyrealname)
if (np2==np)
break;
if (!np2) {
controlreply(sender,
"ERROR: can't find %s/%s (realname=%s) on the realname users list.",
longtonumeric(np->numeric,5),np->nick,np->realname->name->content);
errors++;
}
np->realname->marker++;
if (IsAccount(np) && !np->authname[0]) {
controlreply(sender, "ERROR: nick %s/%s is +r but no authname stored.",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
/*
if (!IsAccount(np) && np->authname[0]) {
controlreply(sender, "ERROR: nick %s/%s is -r but carries authname '%s'.",
longtonumeric(np->numeric,5),np->nick,np->authname);
errors++;
}
*/
if (IsSetHost(np) && (!np->sethost || !np->shident)) {
controlreply(sender, "ERROR: nick %s/%s is +h but nick or hostname not set.",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
if (!IsSetHost(np) && (np->sethost || np->shident)) {
controlreply(sender, "ERROR: nick %s/%s is -h but has nick or hostname set.",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
}
}
controlreply(sender," - Scanning server user tables");
for(i=0;i<MAXSERVERS;i++) {
if (serverlist[i].linkstate != LS_INVALID) {
nummask=((MAXSERVERS-1)<<18) | serverlist[i].maxusernum;
for (j=0;j<=serverlist[i].maxusernum;j++) {
if ((np=servernicks[i][j])) {
mnum=(i<<18) | j;
if ((np->numeric & nummask) != mnum) {
controlreply(sender, "ERROR: nick %s/%s has wrong masked numeric.",longtonumeric(np->numeric,5),np->nick);
errors++;
}
if (np->marker != nickmarker) {
controlreply(sender, "ERROR: nick %s/%s in server user table but not hash!",
longtonumeric(np->numeric,5),np->nick);
errors++;
}
np->marker=0;
}
}
}
}
controlreply(sender," - Scanning host and realname tables");
for (i=0;i<HOSTHASHSIZE;i++) {
for (hp=hosttable[i];hp;hp=hp->next) {
/* Check that the user counts match up */
if (hp->clonecount != hp->marker) {
controlreply(sender,
"ERROR: host %s has inconsistent clone count (stored=%d, measured=%u)",
hp->name->content,hp->clonecount,hp->marker);
errors++;
}
for (np=hp->nicks;np;np=np->nextbyhost) {
if (np->host != hp) {
controlreply(sender,
"ERROR: nick %s/%s is in list for wrong host "
"(in list for %s, actual host %s).",
longtonumeric(np->numeric,5),np->nick,hp->name->content,
np->host->name->content);
errors++;
}
}
hp->marker=0;
}
}
for (i=0;i<REALNAMEHASHSIZE;i++) {
for (rnp=realnametable[i];rnp;rnp=rnp->next) {
if (rnp->usercount != rnp->marker) {
controlreply(sender,
"ERROR: realname '%s' has inconsistent clone count "
"(stored=%d, measured=%d).",
rnp->name->content,rnp->usercount,rnp->marker);
errors++;
}
for (np=rnp->nicks;np;np=np->nextbyrealname) {
if (np->realname != rnp) {
controlreply(sender,
"ERROR: nick %s/%s is in list for wrong realname "
"(in list for '%s', actual realname '%s').",
longtonumeric(np->numeric,5),np->nick,
rnp->name->content, np->realname->name->content);
errors++;
}
}
rnp->marker=0;
}
}
if (errors)
controlreply(sender,"All checks complete. %d errors found.",errors);
else
controlreply(sender,"All checks complete. No errors found.");
return CMD_OK;
}
/**
* Exits a client of *any* type (user, server, etc)
* from this server. Also, this generates all necessary prototol
* messages that this exit may cause.
*
* This function implicitly exits all other clients depending on
* this connection.
*
* For convenience, this function returns a suitable value for
* m_function return value:
*
* CPTR_KILLED if (cptr == bcptr)
* 0 if (cptr != bcptr)
*
* This function can be called in two ways:
* 1) From before or in parse(), exiting the 'cptr', in which case it was
* invoked as exit_client(cptr, cptr, &me,...), causing it to always
* return CPTR_KILLED.
* 2) Via parse from a m_function call, in which case it was invoked as
* exit_client(cptr, acptr, sptr, ...). Here 'sptr' is known; the client
* that generated the message in a way that we can assume he already
* did remove acptr from memory himself (or in other cases we don't mind
* because he will be delinked.) Or invoked as:
* exit_client(cptr, acptr/sptr, &me, ...) when WE decide this one should
* be removed.
* In general: No generated SQUIT or QUIT should be sent to source link
* sptr->from. And CPTR_KILLED should be returned if cptr got removed (too).
*
* --Run
* @param cptr Connection currently being handled by read_message.
* @param victim Client being killed.
* @param killer Client that made the decision to remove \a victim.
* @param comment Reason for the exit.
* @return CPTR_KILLED if cptr == bcptr, else 0.
*/
int exit_client(struct Client *cptr,
struct Client* victim,
struct Client* killer,
const char* comment)
{
struct Client* acptr = 0;
struct DLink *dlp;
time_t on_for;
char comment1[HOSTLEN + HOSTLEN + 2];
assert(killer);
if (MyConnect(victim))
{
SetFlag(victim, FLAG_CLOSING);
if (feature_bool(FEAT_CONNEXIT_NOTICES) && IsUser(victim))
sendto_opmask_butone(0, SNO_CONNEXIT,
"Client exiting: %s (%s@%s) [%s] [%s] <%s%s>",
cli_name(victim), cli_user(victim)->username,
cli_user(victim)->host, comment,
ircd_ntoa(&cli_ip(victim)),
NumNick(victim) /* two %s's */);
update_load();
on_for = CurrentTime - cli_firsttime(victim);
if (IsUser(victim) || IsUserPort(victim))
auth_send_exit(victim);
if (IsUser(victim))
log_write(LS_USER, L_TRACE, 0, "%Tu %i %s@%s %s %s %s%s %s :%s",
cli_firsttime(victim), on_for,
cli_user(victim)->username, cli_sockhost(victim),
ircd_ntoa(&cli_ip(victim)),
IsAccount(victim) ? cli_username(victim) : "0",
NumNick(victim), /* two %s's */
cli_name(victim), cli_info(victim));
if (victim != cli_from(killer) /* The source knows already */
&& IsClient(victim)) /* Not a Ping struct or Log file */
{
if (IsServer(victim) || IsHandshake(victim))
sendcmdto_one(killer, CMD_SQUIT, victim, "%s 0 :%s", cli_name(&me), comment);
else if (!IsConnecting(victim)) {
if (!IsDead(victim)) {
if (IsServer(victim))
sendcmdto_one(killer, CMD_ERROR, victim,
":Closing Link: %s by %s (%s)", cli_name(victim),
cli_name(killer), comment);
else
sendrawto_one(victim, MSG_ERROR " :Closing Link: %s by %s (%s)",
cli_name(victim),
cli_name(IsServer(killer) ? &his : killer),
comment);
}
}
if ((IsServer(victim) || IsHandshake(victim) || IsConnecting(victim)) &&
(killer == &me || (IsServer(killer) &&
(strncmp(comment, "Leaf-only link", 14) ||
strncmp(comment, "Non-Hub link", 12)))))
{
/*
* Note: check user == user needed to make sure we have the same
* client
*/
if (cli_serv(victim)->user && *(cli_serv(victim))->by &&
(acptr = findNUser(cli_serv(victim)->by))) {
if (cli_user(acptr) == cli_serv(victim)->user) {
sendcmdto_one(&me, CMD_NOTICE, acptr,
"%C :Link with %s canceled: %s", acptr,
cli_name(victim), comment);
}
else {
/*
* not right client, set by to empty string
*/
acptr = 0;
*(cli_serv(victim))->by = '\0';
}
}
if (killer == &me)
sendto_opmask_butone(acptr, SNO_OLDSNO, "Link with %s canceled: %s",
cli_name(victim), comment);
}
}
/*
* Close the Client connection first.
*/
close_connection(victim);
}
if (IsServer(victim))
{
if (feature_bool(FEAT_HIS_NETSPLIT))
strcpy(comment1, "*.net *.split");
else
{
strcpy(comment1, cli_name(cli_serv(victim)->up));
strcat(comment1, " ");
strcat(comment1, cli_name(victim));
}
if (IsUser(killer))
sendto_opmask_butone(killer, SNO_OLDSNO, "%s SQUIT by %s [%s]:",
(cli_user(killer)->server == victim ||
cli_user(killer)->server == cli_serv(victim)->up) ?
"Local" : "Remote",
get_client_name(killer, HIDE_IP),
cli_name(cli_user(killer)->server));
else if (killer != &me && cli_serv(victim)->up != killer)
sendto_opmask_butone(0, SNO_OLDSNO, "Received SQUIT %s from %s :",
cli_name(victim), IsServer(killer) ? cli_name(killer) :
get_client_name(killer, HIDE_IP));
sendto_opmask_butone(0, SNO_NETWORK, "Net break: %C %C (%s)",
cli_serv(victim)->up, victim, comment);
}
/*
* First generate the needed protocol for the other server links
* except the source:
*/
for (dlp = cli_serv(&me)->down; dlp; dlp = dlp->next) {
if (dlp->value.cptr != cli_from(killer) && dlp->value.cptr != victim)
{
if (IsServer(victim))
sendcmdto_one(killer, CMD_SQUIT, dlp->value.cptr, "%s %Tu :%s",
cli_name(victim), cli_serv(victim)->timestamp, comment);
else if (IsUser(victim) && !HasFlag(victim, FLAG_KILLED))
sendcmdto_one(victim, CMD_QUIT, dlp->value.cptr, ":%s", comment);
}
}
/* Then remove the client structures */
if (IsServer(victim))
exit_downlinks(victim, killer, comment1);
exit_one_client(victim, comment);
/*
* cptr can only have been killed if it was cptr itself that got killed here,
* because cptr can never have been a dependent of victim --Run
*/
return (cptr == victim) ? CPTR_KILLED : 0;
}
void checkUsers(struct Client *sptr, struct Channel *chptr, int flags) {
struct Membership *lp;
struct SLink *slp;
struct Client *acptr;
char outbuf[BUFSIZE], ustat[64];
int cntr = 0, opcntr = 0, hopcntr = 0, vcntr = 0, clones = 0, bans = 0, excepts = 0, c = 0, authed = 0;
if (flags & CHECK_SHOWUSERS) {
if (feature_bool(FEAT_HALFOPS))
send_reply(sptr, RPL_DATASTR, "Users (@ = op, % = halfop, + = voice, * = clone)");
else
send_reply(sptr, RPL_DATASTR, "Users (@ = op, + = voice, * = clone)");
}
for (lp = chptr->members; lp; lp = lp->next_member)
{
int opped = 0;
acptr = lp->user;
if ((c = checkClones(chptr, acptr->cli_name, acptr->cli_user->realhost)) != 0)
{
ircd_snprintf(0, ustat, sizeof(ustat), "%2d ", c);
clones++;
}
else
{
strcpy(ustat, " ");
}
if (chptr && IsChanOp(lp))
{
strcat(ustat, "@");
opcntr++;
opped = 1;
}
else if (chptr && IsHalfOp(lp))
{
strcat(ustat, "%");
hopcntr++;
}
else if (chptr && HasVoice(lp))
{
strcat(ustat, "+");
vcntr++;
}
else
strcat(ustat, " ");
if ((c = IsAccount(acptr)) != 0) ++authed;
if ((flags & CHECK_SHOWUSERS) || ((flags & CHECK_OPSONLY) && opped)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), "%s%c", acptr->cli_info, COLOR_OFF);
send_reply(sptr, RPL_CHANUSER, ustat, acptr->cli_name, acptr->cli_user->realusername,
(flags & CHECK_SHOWIPS) ? ircd_ntoa((const char*)&(cli_ip(acptr))) : acptr->cli_user->realhost, outbuf,
(c ? acptr->cli_user->account : ""));
}
cntr++;
}
send_reply(sptr, RPL_DATASTR, " ");
if (feature_bool(FEAT_HALFOPS))
ircd_snprintf(0, outbuf, sizeof(outbuf),
"Total users:: %d (%d ops, %d half ops, %d voiced, %d clones, %d authed)",
cntr, opcntr, hopcntr, vcntr, clones, authed);
else
ircd_snprintf(0, outbuf, sizeof(outbuf),
"Total users:: %d (%d ops, %d voiced, %d clones, %d authed)",
cntr, opcntr, vcntr, clones, authed);
send_reply(sptr, RPL_DATASTR, outbuf);
send_reply(sptr, RPL_DATASTR, " ");
/* Do not display bans if ! flags & CHECK_SHOWUSERS */
if (!(flags & CHECK_SHOWUSERS)) {
send_reply(sptr, RPL_ENDOFCHECK, " ");
return;
}
/* Bans */
send_reply(sptr, RPL_DATASTR, "Bans on channel::");
for (slp = chptr->banlist; slp; slp = slp->next)
{
ircd_snprintf(0, outbuf, sizeof(outbuf), "[%d] - %s - Set by %s, on %s",
++bans, slp->value.ban.banstr, slp->value.ban.who, myctime(slp->value.ban.when));
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (bans == 0)
send_reply(sptr, RPL_DATASTR, "<none>");
/* Excepts */
if (feature_bool(FEAT_EXCEPTS)) {
send_reply(sptr, RPL_DATASTR, "Excepts on channel::");
for (slp = chptr->exceptlist; slp; slp = slp->next)
{
ircd_snprintf(0, outbuf, sizeof(outbuf), "[%d] - %s - Set by %s, on %s",
++excepts, slp->value.except.exceptstr, slp->value.except.who, myctime(slp->value.except.when));
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (excepts == 0)
send_reply(sptr, RPL_DATASTR, "<none>");
}
send_reply(sptr, RPL_ENDOFCHECK, " ");
}
/** Report memory usage statistics to a client.
* @param cptr Client to send data to.
* @param sd StatDesc that generated the stats request (ignored).
* @param param Extra parameter from user (ignored).
*/
void count_memory(struct Client *cptr, const struct StatDesc *sd,
char *param)
{
struct Client *acptr;
struct Invite *inv;
struct SLink *link;
struct Ban *ban;
struct Channel *chptr;
struct ConfItem *aconf;
const struct ConnectionClass* cltmp;
struct Membership* member;
int acc = 0, /* accounts */
c = 0, /* clients */
cn = 0, /* connections */
ch = 0, /* channels */
lcc = 0, /* local client conf links */
chb = 0, /* channel bans */
wwu = 0, /* whowas users */
cl = 0, /* classes */
co = 0, /* conf lines */
listeners = 0, /* listeners */
memberships = 0; /* channel memberships */
int usi = 0, /* users invited */
aw = 0, /* aways set */
wwa = 0, /* whowas aways */
gl = 0, /* glines */
ju = 0; /* jupes */
size_t chm = 0, /* memory used by channels */
chbm = 0, /* memory used by channel bans */
cm = 0, /* memory used by clients */
cnm = 0, /* memory used by connections */
us = 0, /* user structs */
usm = 0, /* memory used by user structs */
awm = 0, /* memory used by aways */
wwam = 0, /* whowas away memory used */
wwm = 0, /* whowas array memory used */
wt = 0, /* watch entrys */
wtm = 0, /* memory used by watchs */
#if defined(DDB)
dbs = 0, /* keys of database */
dbm = 0, /* memory used by DDB */
#endif
glm = 0, /* memory used by glines */
jum = 0, /* memory used by jupes */
com = 0, /* memory used by conf lines */
dbufs_allocated = 0, /* memory used by dbufs */
dbufs_used = 0, /* memory used by dbufs */
msg_allocated = 0, /* memory used by struct Msg */
msgbuf_allocated = 0, /* memory used by struct MsgBuf */
listenersm = 0, /* memory used by listetners */
rm = 0, /* res memory used */
totcl = 0, totch = 0, totww = 0, tot = 0;
count_whowas_memory(&wwu, &wwm, &wwa, &wwam);
wwm += sizeof(struct Whowas) * feature_uint(FEAT_NICKNAMEHISTORYLENGTH);
wwm += sizeof(struct Whowas *) * WW_MAX;
for (acptr = GlobalClientList; acptr; acptr = cli_next(acptr))
{
c++;
if (MyConnect(acptr))
{
cn++;
for (link = cli_confs(acptr); link; link = link->next)
lcc++;
}
if (cli_user(acptr))
{
for (inv = cli_user(acptr)->invited; inv; inv = inv->next_user)
usi++;
for (member = cli_user(acptr)->channel; member; member = member->next_channel)
++memberships;
if (cli_user(acptr)->away)
{
aw++;
awm += (strlen(cli_user(acptr)->away) + 1);
}
}
#if defined(UNDERNET)
if (IsAccount(acptr))
acc++;
#endif
}
cm = c * sizeof(struct Client);
cnm = cn * sizeof(struct Connection);
user_count_memory(&us, &usm);
for (chptr = GlobalChannelList; chptr; chptr = chptr->next)
{
ch++;
chm += (strlen(chptr->chname) + sizeof(struct Channel));
for (ban = chptr->banlist; ban; ban = ban->next)
{
chb++;
chbm += strlen(ban->who) + strlen(ban->banstr) + 2 + sizeof(*ban);
}
}
for (aconf = GlobalConfList; aconf; aconf = aconf->next)
{
co++;
com += aconf->host ? strlen(aconf->host) + 1 : 0;
com += aconf->passwd ? strlen(aconf->passwd) + 1 : 0;
com += aconf->name ? strlen(aconf->name) + 1 : 0;
com += sizeof(struct ConfItem);
}
for (cltmp = get_class_list(); cltmp; cltmp = cltmp->next)
cl++;
#if defined(USE_SSL)
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Clients %d(%zu) Connections %d(%zu) SSL %d", c, cm, cn, cnm, ssl_count());
#else
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Clients %d(%zu) Connections %d(%zu)", c, cm, cn, cnm);
#endif
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Users %zu(%zu) Accounts %d(%zu) Invites %d(%zu)",
us, usm, acc, acc * (ACCOUNTLEN + 1),
usi, usi * sizeof(struct Invite));
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":User channels %d(%zu) Aways %d(%zu)", memberships,
memberships * sizeof(struct Membership), aw, awm);
totcl = cm + cnm + us * sizeof(struct User) + memberships * sizeof(struct Membership) + awm;
totcl += lcc * sizeof(struct SLink) + usi * sizeof(struct SLink);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Conflines %d(%zu) Attached %d(%zu) Classes %d(%zu)",
co, com, lcc, lcc * sizeof(struct SLink),
cl, cl * sizeof(struct ConnectionClass));
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Channels %d(%zu) Bans %d(%zu)", ch, chm, chb, chbm);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Channel Members %d(%zu)", memberships,
memberships * sizeof(struct Membership));
totch = chm + chbm;
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Whowas Users %d(%zu) Away %d(%zu) Array %u(%zu)",
wwu, wwu * sizeof(struct User), wwa, wwam,
feature_uint(FEAT_NICKNAMEHISTORYLENGTH), wwm);
totww = wwu * sizeof(struct User) + wwam + wwm;
watch_count_memory(&wt, &wtm);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Watchs %d(%zu)", wt, wtm);
motd_memory_count(cptr);
gl = gline_memory_count(&glm);
ju = jupe_memory_count(&jum);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Glines %d(%zu) Jupes %d(%zu)", gl, glm, ju, jum);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Hash: client %d(%zu), chan is the same", HASHSIZE,
sizeof(void *) * HASHSIZE);
count_listener_memory(&listeners, &listenersm);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Listeners allocated %d(%zu)", listeners, listenersm);
#if defined(DDB)
ddb_count_memory(&dbs, &dbm);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":DDB keys allocated %d(%zu)", dbs, dbm);
#endif
/*
* NOTE: this count will be accurate only for the exact instant that this
* message is being sent, so the count is affected by the dbufs that
* are being used to send this message out. If this is not desired, move
* the dbuf_count_memory call to a place before we start sending messages
* and cache DBufAllocCount and DBufUsedCount in variables until they
* are sent.
*/
dbuf_count_memory(&dbufs_allocated, &dbufs_used);
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":DBufs allocated %u(%zu) used %u(%zu)", DBufAllocCount,
dbufs_allocated, DBufUsedCount, dbufs_used);
/* The DBuf caveats now count for this, but this routine now sends
* replies all on its own.
*/
msgq_count_memory(cptr, &msg_allocated, &msgbuf_allocated);
rm = cres_mem(cptr);
tot =
totww + totch + totcl + com + cl * sizeof(struct ConnectionClass) +
dbufs_allocated + msg_allocated + msgbuf_allocated + rm;
tot += sizeof(void *) * HASHSIZE * 3;
#if defined(MDEBUG)
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Allocations: %zu(%zu)",
fda_get_block_count(), fda_get_byte_count());
#endif
send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG,
":Total: ww %zu ch %zu cl %zu co %zu db %zu ms %zu mb %zu",
totww, totch, totcl, com, dbufs_allocated, msg_allocated,
msgbuf_allocated);
}
void versionscan_handler(nick* me, int type, void** args) {
nick* sender;
Command* cmd;
char* cargv[50];
int cargc;
vspattern* v;
char* p;
switch (type) {
case LU_PRIVMSG:
case LU_SECUREMSG:
/* nick */
sender=args[0];
if (!strncmp("\001VERSION", args[1], 8)) {
sendnoticetouser(versionscan_nick, sender, "\001VERSION QuakeNet %s v%s.\001", VS_RNDESC, VS_VERSION);
return;
}
cargc=splitline((char*)args[1], cargv, 50, 0);
cmd=findcommandintree(versionscan_commands, cargv[0], 1);
if (!cmd) {
sendnoticetouser(versionscan_nick, sender, "Unknown command.");
return;
}
if ((cmd->level & VS_AUTHED) && !IsAccount(sender)) {
sendnoticetouser(versionscan_nick, sender, "Sorry, you need to be authed to use this command.");
return;
}
if ((cmd->level & VS_OPER) && !IsOper(sender)) {
sendnoticetouser(versionscan_nick, sender, "Sorry, you need to be opered to use this command.");
return;
}
if (((cmd->level & VS_STAFF) && !IsVersionscanStaff(sender)) ||
((cmd->level & VS_GLINE) && !IsVersionscanGlineAccess(sender)) ||
((cmd->level & VS_ADMIN) && !IsVersionscanAdmin(sender))) {
sendnoticetouser(versionscan_nick, sender, "Sorry, you do not have access to this command.");
return;
}
if (cmd->maxparams < (cargc-1)) {
/* We need to do some rejoining */
rejoinline(cargv[cmd->maxparams], cargc-(cmd->maxparams));
cargc=(cmd->maxparams)+1;
}
(cmd->handler)((void*)sender, cargc-1, &(cargv[1]));
break;
case LU_PRIVNOTICE:
sender=args[0];
if (strncmp("\001VERSION ", args[1], 9)) {
break;
}
if ((p=strchr((char *)args[1] + 9, '\001'))) {
*p++='\0';
}
if (versionscan_mode == VS_SCAN) {
if (IsOper(sender)) {
break;
}
for (v=vspatterns; v; v=v->next) {
if (match2strings(v->pattern, (char *)args[1] + 9)) {
v->hitcount++;
hcount++;
switch (v->action) {
case VS_WARN:
sendnoticetouser(versionscan_nick, sender, "%s", v->data);
wcount++;
break;
case VS_KILL:
killuser(versionscan_nick, sender, "%s", v->data);
kcount++;
break;
case VS_GLUSER:
glinebynick(sender, 3600, v->data, GLINE_ALWAYS_USER, "versionscan");
gcount++;
break;
case VS_GLHOST:
glinebynick(sender, 3600, v->data, 0, "versionscan");
gcount++;
break;
default:
/* oh dear, something's f****d */
break;
}
break;
}
}
}
else if (versionscan_mode == VS_STAT) {
versionscan_addstat((char *)args[1] + 9);
}
break;
case LU_KILLED:
versionscan_nick=NULL;
scheduleoneshot(time(NULL)+1, &versionscan_createfakeuser, NULL);
break;
}
}
void do_join(struct Client *cptr, struct Client *sptr, struct JoinBuf *join,
struct JoinBuf *create, char *chan, char *key, int level)
{
struct Channel *chptr;
struct Gline *gline;
/* BADCHANed channel */
if ((gline = gline_find(chan, GLINE_BADCHAN | GLINE_EXACT)) &&
GlineIsActive(gline) && !IsAnOper(sptr)) {
send_reply(sptr, ERR_BANNEDFROMCHAN, chan);
return;
}
/* Bouncy +L joins */
if (level > feature_int(FEAT_MAX_BOUNCE)) {
sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :*** Couldn't join %s ! - Redirection (+L) setting was too bouncy", sptr, chan);
return;
}
if (!(chptr = FindChannel(chan))) {
if (((chan[0] == '&') && !feature_bool(FEAT_LOCAL_CHANNELS))
|| strlen(chan) > IRCD_MIN(CHANNELLEN, feature_int(FEAT_CHANNELLEN))) {
send_reply(sptr, ERR_NOSUCHCHANNEL, chan);
return;
}
if (feature_bool(FEAT_CHANNEL_CREATE_IRCOPONLY) && !IsAnOper(sptr) && !IsChannelService(sptr)) {
send_reply(sptr, ERR_NOSUCHCHANNEL, chan);
return;
}
if (!(chptr = get_channel(sptr, chan, CGT_CREATE)))
return;
/* Try to add the new channel as a recent target for the user. */
if (check_target_limit(sptr, chptr, chptr->chname, 0)) {
chptr->members = 0;
destruct_channel(chptr);
return;
}
joinbuf_join(create, chptr, CHFL_CHANOP | CHFL_CHANNEL_MANAGER);
} else if (find_member_link(chptr, sptr)) {
return; /* already on channel */
} else if (check_target_limit(sptr, chptr, chptr->chname, 0)) {
return;
} else {
int flags = CHFL_DEOPPED;
int err = 0;
int excepted = 0;
int exceptkli = 0;
struct Ban *ban = NULL;
if (*chptr->mode.redir && (*chptr->mode.redir != '\0')) {
if (chptr->users >= chptr->mode.limit) {
if (IsNoLink(sptr))
send_reply(sptr, ERR_LINKCHAN, chptr->chname, chptr->mode.redir);
else if (!IsChannelName(chptr->mode.redir) || !strIsIrcCh(chptr->mode.redir))
send_reply(sptr, ERR_NOSUCHCHANNEL, chptr->mode.redir);
else {
send_reply(sptr, ERR_LINKSET, chptr->chname, chptr->chname, chptr->mode.redir);
do_join(cptr, sptr, join, create, chptr->mode.redir, key, level+1);
}
return;
}
}
if (find_ban(sptr, chptr->exceptlist, EBAN_EXCEPTLIST, 0)) {
if (feature_bool(FEAT_CHMODE_e_CHMODEEXCEPTION))
exceptkli = 1;
excepted = 1;
}
/* Check Apass/Upass -- since we only ever look at a single
* "key" per channel now, this hampers brute force attacks. */
if (feature_bool(FEAT_CHMODE_Z_STRICT) && (chptr->mode.exmode & EXMODE_SSLONLY) && !IsSSL(sptr))
err = ERR_SSLONLYCHAN;
else if (key && !strcmp(key, chptr->mode.apass))
flags = CHFL_CHANOP | CHFL_CHANNEL_MANAGER;
else if (key && !strcmp(key, chptr->mode.upass))
flags = CHFL_CHANOP;
else if (chptr->users == 0 && !chptr->mode.apass[0] && !(chptr->mode.exmode & EXMODE_PERSIST)) {
/* Joining a zombie channel (zannel): give ops and increment TS. */
flags = CHFL_CHANOP;
chptr->creationtime++;
} else if (IsXtraOp(sptr)) {
/* XtraOp bypasses all other checks. */
} else if ((chptr->mode.exmode & EXMODE_SSLONLY) && !IsSSL(sptr))
err = ERR_SSLONLYCHAN;
else if (IsInvited(sptr, chptr)) {
/* Invites bypass these other checks. */
} else if (*chptr->mode.key && (!key || strcmp(key, chptr->mode.key)) && !exceptkli)
err = ERR_BADCHANNELKEY;
else if (*chptr->mode.key && feature_bool(FEAT_FLEXIBLEKEYS) && (key && !strcmp(key, chptr->mode.key))) {
/* Assume key checked by previous condition was found to be correct
and allow join because FEAT_FLEXIBLEKEYS was enabled */
} else if ((chptr->mode.mode & MODE_INVITEONLY) && !exceptkli)
err = ERR_INVITEONLYCHAN;
else if (chptr->mode.limit && (chptr->users >= chptr->mode.limit) && !exceptkli)
err = ERR_CHANNELISFULL;
else if ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(sptr))
err = ERR_NEEDREGGEDNICK;
else if ((chptr->mode.exmode & EXMODE_ADMINONLY) && !IsAdmin(sptr))
err = ERR_ADMINONLYCHAN;
else if ((chptr->mode.exmode & EXMODE_OPERONLY) && !IsAnOper(sptr))
err = ERR_OPERONLYCHAN;
else if ((ban = find_ban(sptr, chptr->banlist, EBAN_NONE, 0)) && !excepted)
err = ERR_BANNEDFROMCHAN;
/* An oper with WALK_LCHAN privilege can join a local channel
* he otherwise could not join by using "OVERRIDE" as the key.
* This will generate a HACK(4) notice, but fails if the oper
* could normally join the channel. */
if (IsLocalChannel(chptr->chname)
&& HasPriv(sptr, PRIV_WALK_LCHAN)
&& !(flags & CHFL_CHANOP)
&& key && !strcmp(key, "OVERRIDE"))
{
switch (err) {
case 0:
if (strcmp(chptr->mode.key, "OVERRIDE")
&& strcmp(chptr->mode.apass, "OVERRIDE")
&& strcmp(chptr->mode.upass, "OVERRIDE")) {
send_reply(sptr, ERR_DONTCHEAT, chptr->chname);
return;
}
break;
case ERR_INVITEONLYCHAN: err = 'i'; break;
case ERR_CHANNELISFULL: err = 'l'; break;
case ERR_BANNEDFROMCHAN: err = 'b'; break;
case ERR_BADCHANNELKEY: err = 'k'; break;
case ERR_NEEDREGGEDNICK: err = 'r'; break;
case ERR_ADMINONLYCHAN: err = 'a'; break;
case ERR_OPERONLYCHAN: err = 'O'; break;
case ERR_SSLONLYCHAN: err = 'Z'; break;
default: err = '?'; break;
}
/* send accountability notice */
if (err)
sendto_opmask_butone(0, SNO_HACK4, "OPER JOIN: %C JOIN %H "
"(overriding +%c)", sptr, chptr, err);
err = 0;
}
/* Is there some reason the user may not join? */
if (err) {
switch(err) {
case ERR_NEEDREGGEDNICK:
send_reply(sptr,
ERR_NEEDREGGEDNICK,
chptr->chname,
feature_str(FEAT_URLREG));
break;
default:
send_reply(sptr, err, chptr->chname);
break;
}
return;
}
joinbuf_join(join, chptr, flags);
if (flags & CHFL_CHANOP) {
struct ModeBuf mbuf;
/* Always let the server op him: this is needed on a net with older servers
because they 'destruct' channels immediately when they become empty without
sending out a DESTRUCT message. As a result, they would always bounce a mode
(as HACK(2)) when the user ops himself.
(There is also no particularly good reason to have the user op himself.)
*/
modebuf_init(&mbuf, &me, cptr, chptr, MODEBUF_DEST_SERVER);
modebuf_mode_client(&mbuf, MODE_ADD | MODE_CHANOP, sptr,
chptr->mode.apass[0] ? ((flags & CHFL_CHANNEL_MANAGER) ? 0 : 1) : MAXOPLEVEL);
modebuf_flush(&mbuf);
}
}
del_invite(sptr, chptr);
if (chptr->topic[0]) {
send_reply(sptr, RPL_TOPIC, chptr->chname, chptr->topic);
send_reply(sptr, RPL_TOPICWHOTIME, chptr->chname, chptr->topic_nick,
chptr->topic_time);
}
do_names(sptr, chptr, NAMES_ALL|NAMES_EON); /* send /names list */
}
/*
* m_invite - generic message handler
*
* parv[0] - sender prefix
* parv[1] - user to invite
* parv[2] - channel name
*
* - INVITE now is accepted only if who does it is chanop (this of course
* implies that channel must exist and he must be on it).
*
* - On the other side it IS processed even if channel is NOT invite only
* leaving room for other enhancements like inviting banned ppl. -- Nemesi
*
* - Invite with no parameters now lists the channels you are invited to.
* - Isomer 23 Oct 99
*/
int m_invite(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client *acptr;
struct Channel *chptr;
if (parc < 2 ) {
/*
* list the channels you have an invite to.
*/
struct SLink *lp;
for (lp = cli_user(sptr)->invited; lp; lp = lp->next)
send_reply(cptr, RPL_INVITELIST, lp->value.chptr->chname);
send_reply(cptr, RPL_ENDOFINVITELIST);
return 0;
}
if (parc < 3 || EmptyString(parv[2]))
return need_more_params(sptr, "INVITE");
if (!(acptr = FindUser(parv[1]))) {
send_reply(sptr, ERR_NOSUCHNICK, parv[1]);
return 0;
}
if (is_silenced(sptr, acptr) && !is_silence_exempted(sptr, acptr))
return 0;
clean_channelname(parv[2]);
if (!IsChannelPrefix(*parv[2]))
return 0;
/* bad channel name */
if (!IsChannelName(parv[2]) || HasCntrl(parv[2])) {
send_reply(sptr, ERR_NOSUCHCHANNEL, parv[2]);
return 0;
}
if (!(chptr = FindChannel(parv[2]))) {
send_reply(sptr, ERR_NOTONCHANNEL, parv[2]);
return 0;
}
if (!find_channel_member(sptr, chptr)) {
send_reply(sptr, ERR_NOTONCHANNEL, chptr->chname);
return 0;
}
if (find_channel_member(acptr, chptr)) {
send_reply(sptr, ERR_USERONCHANNEL, cli_name(acptr), chptr->chname);
return 0;
}
if (!is_chan_op(sptr, chptr) && !is_half_op(sptr, chptr)) {
send_reply(sptr, ERR_CHANOPRIVSNEEDED, chptr->chname);
return 0;
}
/* If we get here, it was a VALID and meaningful INVITE */
if (IsAccountOnly(acptr) && !IsAccount(sptr) && !IsOper(sptr)) {
send_reply(sptr, ERR_ACCOUNTONLY, cli_name(acptr), "INVITE");
return 0;
}
if (IsPrivDeaf(acptr) && !IsOper(sptr)) {
send_reply(sptr, ERR_PRIVDEAF, cli_name(sptr), "INVITE",
cli_name(acptr));
return 0;
}
if (IsCommonChansOnly(acptr) && !IsAnOper(sptr) && !common_chan_count(acptr, sptr, 1)) {
send_reply(sptr, ERR_COMMONCHANSONLY, cli_name(acptr), "INVITE");
return 0;
}
if (check_target_limit(sptr, acptr, cli_name(acptr), 0))
return 0;
send_reply(sptr, RPL_INVITING, cli_name(acptr), chptr->chname);
if (cli_user(acptr)->away)
send_reply(sptr, RPL_AWAY, cli_name(acptr), cli_user(acptr)->away);
if (MyConnect(acptr)) {
add_invite(acptr, chptr);
sendcmdto_one(sptr, CMD_INVITE, acptr, "%s :%H", cli_name(acptr), chptr);
} else {
sendcmdto_one(sptr, CMD_INVITE, acptr, "%s %H %Tu", cli_name(acptr), chptr,
chptr->creationtime);
}
if (!IsLocalChannel(chptr->chname) || MyConnect(acptr)) {
if (feature_bool(FEAT_ANNOUNCE_INVITES)) {
/* Announce to channel operators. */
sendcmdto_channel_butserv_butone(feature_bool(FEAT_HIS_HIDEWHO) ? &his : &me,
get_error_numeric(RPL_ISSUEDINVITE)->str,
NULL, chptr, sptr, SKIP_NONOPS,
"%H %C %C :%C has been invited by %C",
chptr, acptr, sptr, acptr, sptr);
/* Announce to servers with channel operators. */
sendcmdto_channel_servers_butone(sptr, NULL, TOK_INVITE, chptr, acptr, SKIP_NONOPS,
"%s %H %Tu", cli_name(acptr),
chptr, chptr->creationtime);
}
}
return 0;
}
/* * ms_burst - server message handler * * -- by Run [email protected] december 1995 till march 1997 * * parv[0] = sender prefix * parv[1] = channel name * parv[2] = channel timestamp * The meaning of the following parv[]'s depend on their first character: * If parv[n] starts with a '+': * Net burst, additive modes * parv[n] = <mode> * parv[n+1] = <param> (optional) * parv[n+2] = <param> (optional) * If parv[n] starts with a '%', then n will be parc-1: * parv[n] = %<ban> <ban> <ban> ... * If parv[n] starts with another character: * parv[n] = <nick>[:<mode>],<nick>[:<mode>],... * where <mode> defines the mode and op-level * for nick and all following nicks until the * next <mode> field. * Digits in the <mode> field have of two meanings: * 1) if it is the first field in this BURST message * that contains digits, and/or when a 'v' is * present in the <mode>: * The absolute value of the op-level. * 2) if there are only digits in this field and * it is not the first field with digits: * An op-level increment relative to the previous * op-level. * First all modeless nicks must be emmitted, * then all combinations of modes without ops * (currently that is only 'v') followed by the same * series but then with ops (currently 'o','ov'). * * Example: * "A8 B #test 87654321 +ntkAl key secret 123 A8AAG,A8AAC:v,A8AAA:0,A8AAF:2,A8AAD,A8AAB:v1,A8AAE:1 :%ban1 ban2" * * <mode> list example: * * "xxx,sss:v,ttt,aaa:123,bbb,ccc:2,ddd,kkk:v2,lll:2,mmm" * * means * * xxx // first modeless nicks * sss +v // then opless nicks * ttt +v // no ":<mode>": everything stays the same * aaa -123 // first field with digit: absolute value * bbb -123 * ccc -125 // only digits, not first field: increment * ddd -125 * kkk -2 +v // field with a 'v': absolute value * lll -4 +v // only digits: increment * mmm -4 +v * * Anti net.ride code. * * When the channel already exist, and its TS is larger than * the TS in the BURST message, then we cancel all existing modes. * If its is smaller then the received BURST message is ignored. * If it's equal, then the received modes are just added. * * BURST is also accepted outside a netburst now because it * is sent upstream as reaction to a DESTRUCT message. For * these BURST messages it is possible that the listed channel * members are already joined. */ int ms_burst(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) { struct ModeBuf modebuf, *mbuf = 0; struct Channel *chptr; time_t timestamp; struct Membership *member, *nmember; struct Ban *lp, **lp_p; unsigned int parse_flags = (MODE_PARSE_FORCE | MODE_PARSE_BURST); int param, nickpos = 0, banpos = 0; char modestr[BUFSIZE], nickstr[BUFSIZE], banstr[BUFSIZE]; if (parc < 3) return protocol_violation(sptr,"Too few parameters for BURST"); if (!(chptr = get_channel(sptr, parv[1], CGT_CREATE))) return 0; /* can't create the channel? */ timestamp = atoi(parv[2]); if (chptr->creationtime) /* 0 for new (empty) channels, i.e. when this server just restarted. */ { if (parc == 3) /* Zannel BURST? */ { /* An empty channel without +A set, will cause a BURST message with exactly 3 parameters (because all modes have been reset). If the timestamp on such channels is only a few seconds older from our own, then we ignore this burst: we do not deop our own side. Likewise, we expect the other (empty) side to copy our timestamp from our own BURST message, even though it is slightly larger. The reason for this is to allow people to join an empty non-A channel (a zannel) during a net.split, and not be deopped when the net reconnects (with another zannel). When someone joins a split zannel, their side increments the TS by one. If they cycle a few times then we still don't have a reason to deop them. Theoretically I see no reason not to accept ANY timestamp, but to be sure, we only accept timestamps that are just a few seconds off (one second for each time they cycled the channel). */ /* Don't even deop users who cycled four times during the net.break. */ if (timestamp < chptr->creationtime && chptr->creationtime <= timestamp + 4 && chptr->users != 0) /* Only do this when WE have users, so that if we do this the BURST that we sent has parc > 3 and the other side will use the test below: */ timestamp = chptr->creationtime; /* Do not deop our side. */ } else if (chptr->creationtime < timestamp && timestamp <= chptr->creationtime + 4 && chptr->users == 0) { /* If one side of the net.junction does the above timestamp = chptr->creationtime, then the other side must do this: */ chptr->creationtime = timestamp; /* Use the same TS on both sides. */ } /* In more complex cases, we might still end up with a creationtime desync of a few seconds, but that should be synced automatically rather quickly (every JOIN caries a timestamp and will sync it; modes by users do not carry timestamps and are accepted regardless). Only when nobody joins the channel on the side with the oldest timestamp before a new net.break occurs precisely inbetween the desync, an unexpected bounce might happen on reconnect. */ } if (!chptr->creationtime || chptr->creationtime > timestamp) { /* * Kick local members if channel is +i or +k and our TS was larger * than the burst TS (anti net.ride). The modes hack is here because * we have to do this before mode_parse, as chptr may go away. */ for (param = 3; param < parc; param++) { int check_modes; if (parv[param][0] != '+') continue; check_modes = netride_modes(parc - param, parv + param, chptr->mode.key); if (check_modes < 0) { if (chptr->users == 0) sub1_from_channel(chptr); return protocol_violation(sptr, "Invalid mode string in BURST"); } else if (check_modes) { /* Clear any outstanding rogue invites */ mode_invite_clear(chptr); for (member = chptr->members; member; member = nmember) { nmember = member->next_member; if (!MyUser(member->user) || IsZombie(member)) continue; /* Kick as netrider if key mismatch *or* remote channel is * +i (unless user is an oper) *or* remote channel is +r * (unless user has an account). */ if (!(check_modes & MODE_KEY) && (!(check_modes & MODE_INVITEONLY) || IsAnOper(member->user)) && (!(check_modes & MODE_REGONLY) || IsAccount(member->user))) continue; sendcmdto_serv_butone(&me, CMD_KICK, NULL, "%H %C :Net Rider", chptr, member->user); sendcmdto_channel_butserv_butone(&his, CMD_KICK, chptr, NULL, 0, "%H %C :Net Rider", chptr, member->user); make_zombie(member, member->user, &me, &me, chptr); } } break; } /* If the channel had only locals, it went away by now. */ if (!(chptr = get_channel(sptr, parv[1], CGT_CREATE))) return 0; /* can't create the channel? */ } /* turn off burst joined flag */ for (member = chptr->members; member; member = member->next_member) member->status &= ~(CHFL_BURST_JOINED|CHFL_BURST_ALREADY_OPPED|CHFL_BURST_ALREADY_VOICED); if (!chptr->creationtime) /* mark channel as created during BURST */ chptr->mode.mode |= MODE_BURSTADDED; /* new channel or an older one */ if (!chptr->creationtime || chptr->creationtime > timestamp) { chptr->creationtime = timestamp; modebuf_init(mbuf = &modebuf, &me, cptr, chptr, MODEBUF_DEST_CHANNEL | MODEBUF_DEST_NOKEY); modebuf_mode(mbuf, MODE_DEL | chptr->mode.mode); /* wipeout modes */ chptr->mode.mode &= MODE_BURSTADDED | MODE_WASDELJOINS; /* wipe out modes not represented in chptr->mode.mode */ if (chptr->mode.limit) { modebuf_mode_uint(mbuf, MODE_DEL | MODE_LIMIT, chptr->mode.limit); chptr->mode.limit = 0; } if (chptr->mode.key[0]) { modebuf_mode_string(mbuf, MODE_DEL | MODE_KEY, chptr->mode.key, 0); chptr->mode.key[0] = '\0'; } if (chptr->mode.upass[0]) { modebuf_mode_string(mbuf, MODE_DEL | MODE_UPASS, chptr->mode.upass, 0); chptr->mode.upass[0] = '\0'; } if (chptr->mode.apass[0]) { modebuf_mode_string(mbuf, MODE_DEL | MODE_APASS, chptr->mode.apass, 0); chptr->mode.apass[0] = '\0'; } parse_flags |= (MODE_PARSE_SET | MODE_PARSE_WIPEOUT); /* wipeout keys */ /* mark bans for wipeout */ for (lp = chptr->banlist; lp; lp = lp->next) lp->flags |= BAN_BURST_WIPEOUT; /* clear topic set by netrider (if set) */ if (*chptr->topic) { *chptr->topic = '\0'; *chptr->topic_nick = '\0'; chptr->topic_time = 0; sendcmdto_channel_butserv_butone(&his, CMD_TOPIC, chptr, NULL, 0, "%H :%s", chptr, chptr->topic); } } else if (chptr->creationtime == timestamp) { modebuf_init(mbuf = &modebuf, &me, cptr, chptr, MODEBUF_DEST_CHANNEL | MODEBUF_DEST_NOKEY); parse_flags |= MODE_PARSE_SET; /* set new modes */ } param = 3; /* parse parameters */ while (param < parc) { switch (*parv[param]) { case '+': /* parameter introduces a mode string */ param += mode_parse(mbuf, cptr, sptr, chptr, parc - param, parv + param, parse_flags, NULL); break; case '%': /* parameter contains bans */ if (parse_flags & MODE_PARSE_SET) { char *banlist = parv[param] + 1, *p = 0, *ban, *ptr; struct Ban *newban; for (ban = ircd_strtok(&p, banlist, " "); ban; ban = ircd_strtok(&p, 0, " ")) { ban = collapse(pretty_mask(ban)); /* * Yeah, we should probably do this elsewhere, and make it better * and more general; this will hold until we get there, though. * I dislike the current add_banid API... -Kev * * I wish there were a better algo. for this than the n^2 one * shown below *sigh* */ for (lp = chptr->banlist; lp; lp = lp->next) { if (!ircd_strcmp(lp->banstr, ban)) { ban = 0; /* don't add ban */ lp->flags &= ~BAN_BURST_WIPEOUT; /* not wiping out */ break; /* new ban already existed; don't even repropagate */ } else if (!(lp->flags & BAN_BURST_WIPEOUT) && !mmatch(lp->banstr, ban)) { ban = 0; /* don't add ban unless wiping out bans */ break; /* new ban is encompassed by an existing one; drop */ } else if (!mmatch(ban, lp->banstr)) lp->flags |= BAN_OVERLAPPED; /* remove overlapping ban */ if (!lp->next) break; } if (ban) { /* add the new ban to the end of the list */ /* Build ban buffer */ if (!banpos) { banstr[banpos++] = ' '; banstr[banpos++] = ':'; banstr[banpos++] = '%'; } else banstr[banpos++] = ' '; for (ptr = ban; *ptr; ptr++) /* add ban to buffer */ banstr[banpos++] = *ptr; newban = make_ban(ban); /* create new ban */ strcpy(newban->who, "*"); newban->when = TStime(); newban->flags |= BAN_BURSTED; newban->next = 0; if (lp) lp->next = newban; /* link it in */ else chptr->banlist = newban; } } } param++; /* look at next param */ break; default: /* parameter contains clients */ { struct Client *acptr; char *nicklist = parv[param], *p = 0, *nick, *ptr; int current_mode, last_mode, base_mode; int oplevel = -1; /* Mark first field with digits: means the same as 'o' (but with level). */ int last_oplevel = 0; struct Membership* member; base_mode = CHFL_DEOPPED | CHFL_BURST_JOINED; if (chptr->mode.mode & MODE_DELJOINS) base_mode |= CHFL_DELAYED; current_mode = last_mode = base_mode; for (nick = ircd_strtok(&p, nicklist, ","); nick; nick = ircd_strtok(&p, 0, ",")) { if ((ptr = strchr(nick, ':'))) { /* new flags; deal */ *ptr++ = '\0'; if (parse_flags & MODE_PARSE_SET) { int current_mode_needs_reset; for (current_mode_needs_reset = 1; *ptr; ptr++) { if (*ptr == 'o') { /* has oper status */ /* * An 'o' is pre-oplevel protocol, so this is only for * backwards compatibility. Give them an op-level of * MAXOPLEVEL so everyone can deop them. */ oplevel = MAXOPLEVEL; if (current_mode_needs_reset) { current_mode = base_mode; current_mode_needs_reset = 0; } current_mode = (current_mode & ~(CHFL_DEOPPED | CHFL_DELAYED)) | CHFL_CHANOP; /* * Older servers may send XXYYY:ov, in which case we * do not want to use the code for 'v' below. */ if (ptr[1] == 'v') { current_mode |= CHFL_VOICE; ptr++; } } else if (*ptr == 'v') { /* has voice status */ if (current_mode_needs_reset) { current_mode = base_mode; current_mode_needs_reset = 0; } current_mode = (current_mode & ~CHFL_DELAYED) | CHFL_VOICE; oplevel = -1; /* subsequent digits are an absolute op-level value. */ } else if (IsDigit(*ptr)) { int level_increment = 0; if (oplevel == -1) { /* op-level is absolute value? */ if (current_mode_needs_reset) { current_mode = base_mode; current_mode_needs_reset = 0; } oplevel = 0; } current_mode = (current_mode & ~(CHFL_DEOPPED | CHFL_DELAYED)) | CHFL_CHANOP; do { level_increment = 10 * level_increment + *ptr++ - '0'; } while (IsDigit(*ptr)); oplevel += level_increment; } else /* I don't recognize that flag */ break; /* so stop processing */ } } } if (!(acptr = findNUser(nick)) || cli_from(acptr) != cptr) continue; /* ignore this client */ /* Build nick buffer */ nickstr[nickpos] = nickpos ? ',' : ' '; /* first char */ nickpos++; for (ptr = nick; *ptr; ptr++) /* store nick */ nickstr[nickpos++] = *ptr; if (current_mode != last_mode) { /* if mode changed... */ last_mode = current_mode; last_oplevel = oplevel; nickstr[nickpos++] = ':'; /* add a specifier */ if (current_mode & CHFL_VOICE) nickstr[nickpos++] = 'v'; if (current_mode & CHFL_CHANOP) { if (chptr->mode.apass[0]) nickpos += ircd_snprintf(0, nickstr + nickpos, sizeof(nickstr) - nickpos, "%u", oplevel); else nickstr[nickpos++] = 'o'; } } else if (current_mode & CHFL_CHANOP && oplevel != last_oplevel) { /* if just op level changed... */ nickstr[nickpos++] = ':'; /* add a specifier */ nickpos += ircd_snprintf(0, nickstr + nickpos, sizeof(nickstr) - nickpos, "%u", oplevel - last_oplevel); last_oplevel = oplevel; } if (!(member = find_member_link(chptr, acptr))) { add_user_to_channel(chptr, acptr, current_mode, oplevel); if (!(current_mode & CHFL_DELAYED)) sendcmdto_channel_butserv_butone(acptr, CMD_JOIN, chptr, NULL, 0, "%H", chptr); } else { /* The member was already joined (either by CREATE or JOIN). Remember the current mode. */ if (member->status & CHFL_CHANOP) member->status |= CHFL_BURST_ALREADY_OPPED; if (member->status & CHFL_VOICE) member->status |= CHFL_BURST_ALREADY_VOICED; /* Synchronize with the burst. */ member->status |= CHFL_BURST_JOINED | (current_mode & (CHFL_CHANOP|CHFL_VOICE)); SetOpLevel(member, oplevel); } } } param++; break; } /* switch (*parv[param]) */ } /* while (param < parc) */ nickstr[nickpos] = '\0'; banstr[banpos] = '\0'; if (parse_flags & MODE_PARSE_SET) { modebuf_extract(mbuf, modestr + 1); /* for sending BURST onward */ modestr[0] = modestr[1] ? ' ' : '\0'; } else modestr[0] = '\0'; sendcmdto_serv_butone(sptr, CMD_BURST, cptr, "%H %Tu%s%s%s", chptr, chptr->creationtime, modestr, nickstr, banstr); if (parse_flags & MODE_PARSE_WIPEOUT || banpos) mode_ban_invalidate(chptr); if (parse_flags & MODE_PARSE_SET) { /* any modes changed? */ /* first deal with channel members */ for (member = chptr->members; member; member = member->next_member) { if (member->status & CHFL_BURST_JOINED) { /* joined during burst */ if ((member->status & CHFL_CHANOP) && !(member->status & CHFL_BURST_ALREADY_OPPED)) modebuf_mode_client(mbuf, MODE_ADD | CHFL_CHANOP, member->user, OpLevel(member)); if ((member->status & CHFL_VOICE) && !(member->status & CHFL_BURST_ALREADY_VOICED)) modebuf_mode_client(mbuf, MODE_ADD | CHFL_VOICE, member->user, OpLevel(member)); } else if (parse_flags & MODE_PARSE_WIPEOUT) { /* wipeout old ops */ if (member->status & CHFL_CHANOP) modebuf_mode_client(mbuf, MODE_DEL | CHFL_CHANOP, member->user, OpLevel(member)); if (member->status & CHFL_VOICE) modebuf_mode_client(mbuf, MODE_DEL | CHFL_VOICE, member->user, OpLevel(member)); member->status = (member->status & ~(CHFL_CHANNEL_MANAGER | CHFL_CHANOP | CHFL_VOICE)) | CHFL_DEOPPED; } } /* Now deal with channel bans */ lp_p = &chptr->banlist; while (*lp_p) { lp = *lp_p; /* remove ban from channel */ if (lp->flags & (BAN_OVERLAPPED | BAN_BURST_WIPEOUT)) { char *bandup; DupString(bandup, lp->banstr); modebuf_mode_string(mbuf, MODE_DEL | MODE_BAN, bandup, 1); *lp_p = lp->next; /* clip out of list */ free_ban(lp); continue; } else if (lp->flags & BAN_BURSTED) /* add ban to channel */ modebuf_mode_string(mbuf, MODE_ADD | MODE_BAN, lp->banstr, 0); /* don't free banstr */ lp->flags &= BAN_IPMASK; /* reset the flag */ lp_p = &(*lp_p)->next; } } return mbuf ? modebuf_flush(mbuf) : 0; }
/** Handle a JOIN message from a client connection.
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int m_join(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Channel *chptr;
struct JoinBuf join;
struct JoinBuf create;
struct Gline *gline;
char *p = 0;
char *chanlist;
char *name;
char *keys;
if (parc < 2 || *parv[1] == '\0')
return need_more_params(sptr, "JOIN");
joinbuf_init(&join, sptr, cptr, JOINBUF_TYPE_JOIN, 0, 0);
joinbuf_init(&create, sptr, cptr, JOINBUF_TYPE_CREATE, 0, TStime());
chanlist = last0(cptr, sptr, parv[1]); /* find last "JOIN 0" */
keys = parv[2]; /* remember where keys are */
for (name = ircd_strtok(&p, chanlist, ","); name;
name = ircd_strtok(&p, 0, ",")) {
char *key = 0;
/* If we have any more keys, take the first for this channel. */
if (!BadPtr(keys)
&& (keys = strchr(key = keys, ',')))
*keys++ = '\0';
/* Empty keys are the same as no keys. */
if (key && !key[0])
key = 0;
if (!IsChannelName(name) || !strIsIrcCh(name))
{
/* bad channel name */
send_reply(sptr, ERR_NOSUCHCHANNEL, name);
continue;
}
if (cli_user(sptr)->joined >= feature_int(FEAT_MAXCHANNELSPERUSER)
&& !HasPriv(sptr, PRIV_CHAN_LIMIT)) {
send_reply(sptr, ERR_TOOMANYCHANNELS, name);
break; /* no point processing the other channels */
}
/* BADCHANed channel */
if ((gline = gline_find(name, GLINE_BADCHAN | GLINE_EXACT)) &&
GlineIsActive(gline) && !IsAnOper(sptr)) {
send_reply(sptr, ERR_BANNEDFROMCHAN, name);
continue;
}
if (!(chptr = FindChannel(name))) {
if (((name[0] == '&') && !feature_bool(FEAT_LOCAL_CHANNELS))
|| strlen(name) > IRCD_MIN(CHANNELLEN, feature_int(FEAT_CHANNELLEN))) {
send_reply(sptr, ERR_NOSUCHCHANNEL, name);
continue;
}
if (!(chptr = get_channel(sptr, name, CGT_CREATE)))
continue;
/* Try to add the new channel as a recent target for the user. */
if (check_target_limit(sptr, chptr, chptr->chname, 0)) {
chptr->members = 0;
destruct_channel(chptr);
continue;
}
joinbuf_join(&create, chptr, CHFL_CHANOP | CHFL_CHANNEL_MANAGER);
} else if (find_member_link(chptr, sptr)) {
continue; /* already on channel */
} else if (check_target_limit(sptr, chptr, chptr->chname, 0)) {
continue;
} else {
int flags = CHFL_DEOPPED;
int err = 0;
/* Check Apass/Upass -- since we only ever look at a single
* "key" per channel now, this hampers brute force attacks. */
if (key && !strcmp(key, chptr->mode.apass))
flags = CHFL_CHANOP | CHFL_CHANNEL_MANAGER;
else if (key && !strcmp(key, chptr->mode.upass))
flags = CHFL_CHANOP;
else if (chptr->users == 0 && !chptr->mode.apass[0]) {
/* Joining a zombie channel (zannel): give ops and increment TS. */
flags = CHFL_CHANOP;
chptr->creationtime++;
} else if (IsInvited(sptr, chptr)) {
/* Invites bypass these other checks. */
} else if (chptr->mode.mode & MODE_INVITEONLY)
err = ERR_INVITEONLYCHAN;
else if (chptr->mode.limit && (chptr->users >= chptr->mode.limit))
err = ERR_CHANNELISFULL;
else if ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(sptr))
err = ERR_NEEDREGGEDNICK;
else if (find_ban(sptr, chptr->banlist))
err = ERR_BANNEDFROMCHAN;
else if (*chptr->mode.key && (!key || strcmp(key, chptr->mode.key)))
err = ERR_BADCHANNELKEY;
/* An oper with WALK_LCHAN privilege can join a local channel
* he otherwise could not join by using "OVERRIDE" as the key.
* This will generate a HACK(4) notice, but fails if the oper
* could normally join the channel. */
if (IsLocalChannel(chptr->chname)
&& HasPriv(sptr, PRIV_WALK_LCHAN)
&& !(flags & CHFL_CHANOP)
&& key && !strcmp(key, "OVERRIDE"))
{
switch (err) {
case 0:
if (strcmp(chptr->mode.key, "OVERRIDE")
&& strcmp(chptr->mode.apass, "OVERRIDE")
&& strcmp(chptr->mode.upass, "OVERRIDE")) {
send_reply(sptr, ERR_DONTCHEAT, chptr->chname);
continue;
}
break;
case ERR_INVITEONLYCHAN: err = 'i'; break;
case ERR_CHANNELISFULL: err = 'l'; break;
case ERR_BANNEDFROMCHAN: err = 'b'; break;
case ERR_BADCHANNELKEY: err = 'k'; break;
case ERR_NEEDREGGEDNICK: err = 'r'; break;
default: err = '?'; break;
}
/* send accountability notice */
if (err)
sendto_opmask_butone(0, SNO_HACK4, "OPER JOIN: %C JOIN %H "
"(overriding +%c)", sptr, chptr, err);
err = 0;
}
/* Is there some reason the user may not join? */
if (err) {
switch(err) {
case ERR_NEEDREGGEDNICK:
send_reply(sptr,
ERR_NEEDREGGEDNICK,
chptr->chname,
feature_str(FEAT_URLREG));
break;
default:
send_reply(sptr, err, chptr->chname);
break;
}
continue;
}
joinbuf_join(&join, chptr, flags);
if (flags & CHFL_CHANOP) {
struct ModeBuf mbuf;
/* Always let the server op him: this is needed on a net with older servers
because they 'destruct' channels immediately when they become empty without
sending out a DESTRUCT message. As a result, they would always bounce a mode
(as HACK(2)) when the user ops himself.
(There is also no particularly good reason to have the user op himself.)
*/
modebuf_init(&mbuf, &me, cptr, chptr, MODEBUF_DEST_SERVER);
modebuf_mode_client(&mbuf, MODE_ADD | MODE_CHANOP, sptr,
chptr->mode.apass[0] ? ((flags & CHFL_CHANNEL_MANAGER) ? 0 : 1) : MAXOPLEVEL);
modebuf_flush(&mbuf);
}
}
del_invite(sptr, chptr);
if (chptr->topic[0]) {
send_reply(sptr, RPL_TOPIC, chptr->chname, chptr->topic);
send_reply(sptr, RPL_TOPICWHOTIME, chptr->chname, chptr->topic_nick,
chptr->topic_time);
}
do_names(sptr, chptr, NAMES_ALL|NAMES_EON); /* send /names list */
}
joinbuf_flush(&join); /* must be first, if there's a JOIN 0 */
joinbuf_flush(&create);
return 0;
}
/** Searches for a K/G-line for a client. If one is found, notify the
* user and disconnect them.
* @param cptr Client to search for.
* @return 0 if client is accepted; -1 if client was locally denied
* (K-line); -2 if client was globally denied (G-line); -3 if client
* was globally IP denied (Z-line).
*/
int find_kill(struct Client *cptr)
{
const char* host;
const char* name;
const char* realname;
const char* country;
const char* continent;
const char* version;
struct DenyConf* deny;
struct Gline* agline = NULL;
struct Zline* azline = NULL;
assert(0 != cptr);
if (!cli_user(cptr))
return 0;
host = cli_sockhost(cptr);
name = cli_user(cptr)->username;
realname = cli_info(cptr);
country = cli_countrycode(cptr);
continent = cli_continentcode(cptr);
version = cli_version(cptr);
assert(strlen(host) <= HOSTLEN);
assert((name ? strlen(name) : 0) <= HOSTLEN);
assert((realname ? strlen(realname) : 0) <= REALLEN);
assert((country ? strlen(country) : 0) <= 3);
assert((continent ? strlen(continent) : 0) <= 3);
assert((version ? strlen(version) : 0) <= VERSIONLEN);
/* 2000-07-14: Rewrote this loop for massive speed increases.
* -- Isomer
*/
if (!find_except_conf(cptr, EFLAG_KLINE)) {
for (deny = denyConfList; deny; deny = deny->next) {
if (deny->usermask && match(deny->usermask, name))
continue;
if (deny->realmask && match(deny->realmask, realname))
continue;
if (deny->countrymask && country && match(deny->countrymask, country))
continue;
if (deny->continentmask && continent && match(deny->continentmask, continent))
continue;
if (feature_bool(FEAT_CTCP_VERSIONING) && feature_bool(FEAT_CTCP_VERSIONING_KILL)) {
if (deny->version && version && match(deny->version, version))
continue;
}
if (deny->bits > 0) {
if (!ipmask_check(&cli_ip(cptr), &deny->address, deny->bits))
continue;
} else if (deny->hostmask && match(deny->hostmask, host))
continue;
if ((deny->flags & DENY_FLAGS_AUTHEX) && IsAccount(cptr)) {
if (!EmptyString(deny->mark) && EmptyString(cli_killmark(cptr)))
ircd_strncpy(cli_killmark(cptr), deny->mark, BUFSIZE);
continue;
}
if (EmptyString(deny->message))
send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP,
":Connection from your host is refused on this server.");
else {
if (deny->flags & DENY_FLAGS_FILE)
killcomment(cptr, deny->message);
else
send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", deny->message);
}
return -1;
}
}
/* Check Zlines here just in case a spoofed IP matches */
if (!feature_bool(FEAT_DISABLE_ZLINES) && (azline = zline_lookup(cptr, 0))) {
/*
* find active zlines
* added a check against the user's IP address to find_zline()
*/
send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", ZlineReason(azline));
return -3;
}
/* Don't need to do an except lookup here as it's done in gline_lookup() */
if (!feature_bool(FEAT_DISABLE_GLINES) && (agline = gline_lookup(cptr, 0))) {
/*
* find active glines
* added a check against the user's IP address to find_gline() -Kev
*/
send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", GlineReason(agline));
return -2;
}
return 0;
}
