/*
** m_svsguest()
** parv[0] = sender
** parv[1] = target nick
** parv[2] = guest prefix
** parv[3] = max guest number (9999)
**
*/
int m_svsguest(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
int randnum;
int maxnum;
int scount; /* search count */
char guestnick[NICKLEN];
struct Client* acptr;
/* Check if received from services */
if(!IsServer(cptr) || !IsService(sptr))
{
if (IsServer(cptr))
{
ts_warn("Got SVSGUEST from non-service: %s",
sptr->name);
sendto_one(cptr, ":%s WALLOPS :ignoring SVSGUEST from non-service %s",
me.name, sptr->name);
}
return 0;
}
if( parc < 4 ) /* Check for arguments count */
{
ts_warn("Invalid SVSGUEST (%s) from %s",
(parc==2 ) ? parv[1]: "-", parv[0]);
return 0;
}
if ((acptr = find_person(parv[1], NULL)) && MyClient(acptr)) /* person found connected here */
{
maxnum = atoi(parv[3]);
randnum = 1+ (random() % (maxnum+1));
snprintf(guestnick, NICKLEN, "%s%d", parv[2], randnum);
scount = 0;
while((scount++<maxnum+1) &&
find_client(guestnick, (aClient *)NULL))
{
randnum = 1+ (random() % (maxnum+1));
snprintf(guestnick, NICKLEN, "%s%d", parv[2], randnum);
}
if(scount<maxnum+1) /* check if we reached max guests count */
{
change_nick(acptr, guestnick);
}
else
exit_client(acptr, acptr, &me, "Maximum guests count reached!!!");
}
else if (acptr) /* nick was found but is not our client */
{
if ( (acptr->from != cptr)) /* this should never happen */
sendto_one(acptr,
":%s SVSGUEST %s %s %s", parv[0], parv[1], parv[2], parv[3]);
}
return 0;
}
static void
ms_join(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
char *name;
int new_ts;
if (!(source_p->user))
return;
name = parv[1];
if ((name[0] == '0') && (name[1] == '\0'))
{
do_join_0(client_p, source_p);
}
else
{
if(parc > 2)
{
new_ts = atoi(parv[2]);
}
else
{
ts_warn("User on %s remotely JOINing new channel with no TS",
source_p->user->server);
}
}
}
int ts_fseek(ts_file_t *fp, long offset, int whence)
{
TS_TRY(fp);
switch(fp->type)
{
case TS_FILE_STD: return( fseek(fp->fp.std, offset, whence));
case TS_FILE_ZLB: return(gzseek(fp->fp.zlb, offset, whence));
case TS_FILE_XZ:
(void)ts_warn(stderr, "seek not implement in xz file format\n");
goto fail;
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
fail:
return(-1);
}
size_t ts_fwrite(ts_file_t *fp, const char *buf, int len)
{
TS_TRY(fp && buf && len > 0);
switch(fp->type) {
case TS_FILE_STD: return(fwrite((const void*)buf, 1, len, fp->fp.std));
case TS_FILE_ZLB: return(gzwrite(fp->fp.zlb, (const void*)buf, len));
case TS_FILE_XZ: return(xzwrite(fp->fp.xz, (const void*) buf, len));
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
fail:
return(-1);
}
int ts_feof(ts_file_t *fp)
{
TS_TRY(fp);
switch(fp->type)
{
case TS_FILE_STD: return( feof(fp->fp.std));
case TS_FILE_ZLB: return(gzeof(fp->fp.zlb));
case TS_FILE_XZ: return (xzeof(fp->fp.xz));
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
fail:
return(0);
}
char *ts_fgets(char *s, int size, ts_file_t *fp)
{
TS_TRY(fp);
switch(fp->type)
{
case TS_FILE_STD: return( fgets(s, size, fp->fp.std));
case TS_FILE_ZLB: return(gzgets(fp->fp.zlb, s, size)); // different arg order
case TS_FILE_XZ: return (xzgets(fp->fp.xz, s, size));
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
fail:
return(0);
}
int ts_fclose(ts_file_t *fp)
{
TS_TRY(fp);
switch(fp->type)
{
case TS_FILE_STD: TS_TRY( 0 == fclose(fp->fp.std) ); break;
case TS_FILE_ZLB: TS_TRY( 0 == gzclose(fp->fp.zlb) ); break;
case TS_FILE_XZ: TS_TRY( 0 == xzclose(fp->fp.xz) ); break;
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
free(fp); fp=0;
return(0);
fail:
return(EOF);
}
int ts_fflush(ts_file_t *fp)
{
TS_TRY(fp);
int rv = -1;
switch(fp->type) {
case TS_FILE_STD: return(fflush(fp->fp.std));
case TS_FILE_ZLB:
rv = gzflush(fp->fp.zlb, Z_SYNC_FLUSH);
if(rv == Z_OK)
return 0;
else
return EOF;
break;
case TS_FILE_XZ: return (xzflush(fp->fp.xz));
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
fail:
return(-1);
}
ts_file_t *ts_fopen(const char *filepath, const char *mode)
{
ts_file_t *qfile=0;
int len=0;
TS_TRY(filepath); TS_TRY(*filepath); TS_TRY(mode); TS_TRY(*mode);
if(filepath){
len=strlen(filepath);
}
TS_TRY( qfile=calloc(1, sizeof(ts_file_t)) );
if( ts_file_is_gz(filepath) ) {
qfile->type = TS_FILE_ZLB;
} else if( ts_file_is_xz(filepath) ) {
qfile->type = TS_FILE_XZ;
}
else {
qfile->type = TS_FILE_STD;
}
switch(qfile->type){
case TS_FILE_STD: TS_TRY( qfile->fp.std = fopen(filepath, mode)); break;
case TS_FILE_ZLB: TS_TRY( qfile->fp.zlb = gzopen(filepath, mode)); break;
case TS_FILE_XZ: TS_TRY( qfile->fp.xz = xzopen(filepath, mode)); break;
default:
(void)ts_warn(stderr, "\n");
goto fail;
}
return(qfile);
fail:
if(qfile) {
free(qfile);
qfile=0;
}
return(0);
}
int ts_file_size(const char *filename, size_t *size)
{
TS_TRY(filename && size);
if(ts_file_is_gz(filename)) {
int isize;
FILE* fd = fopen(filename, "r");
TS_TRY(fd);
fseek(fd, -4, SEEK_END);
fread(&isize, sizeof(int), 1, fd);
*size = isize;
fclose(fd);
} else if(ts_file_is_xz(filename)) {
(void)ts_warn(stderr, "\n");
goto fail;
} else {
struct stat buf;
TS_TRY(0 == stat(filename, &buf));
*size = buf.st_size;
}
return 1;
fail:
return 0;
}
/*
* nick_from_server()
*/
static void
nick_from_server(struct Client *client_p, struct Client *source_p, int parc,
char *parv[], time_t newts, const char *svsid, char *nick, char *ngecos)
{
int samenick = 0;
if (IsServer(source_p))
{
/* A server introducing a new client, change source */
source_p = make_client(client_p);
dlinkAdd(source_p, &source_p->node, &global_client_list);
if (parc > 2)
source_p->hopcount = atoi(parv[2]);
if (newts)
source_p->tsinfo = newts;
else
{
newts = source_p->tsinfo = CurrentTime;
ts_warn("Remote nick %s (%s) introduced without a TS", nick, parv[0]);
}
strlcpy(source_p->svid, svsid, sizeof(source_p->svid));
strlcpy(source_p->info, ngecos, sizeof(source_p->info));
/* copy the nick in place */
strlcpy(source_p->name, nick, sizeof(source_p->name));
hash_add_client(source_p);
if (parc > 8)
{
const char *m;
/* parse usermodes */
for (m = &parv[4][1]; *m; ++m)
{
unsigned int flag = user_modes[(unsigned char)*m];
if ((flag & UMODE_INVISIBLE) && !HasUMode(source_p, UMODE_INVISIBLE))
++Count.invisi;
if ((flag & UMODE_OPER) && !HasUMode(source_p, UMODE_OPER))
++Count.oper;
source_p->umodes |= flag & SEND_UMODES;
}
register_remote_user(source_p, parv[5], parv[6],
parv[7], ngecos);
return;
}
}
else if (source_p->name[0])
{
samenick = !irccmp(source_p->name, nick);
/* Client changing their nick */
if (!samenick)
{
DelUMode(source_p, UMODE_REGISTERED);
watch_check_hash(source_p, RPL_LOGOFF);
source_p->tsinfo = newts ? newts : CurrentTime;
}
sendto_common_channels_local(source_p, 1, 0, ":%s!%s@%s NICK :%s",
source_p->name,source_p->username,
source_p->host, nick);
add_history(source_p, 1);
sendto_server(client_p, CAP_TS6, NOCAPS,
":%s NICK %s :%lu",
ID(source_p), nick, (unsigned long)source_p->tsinfo);
sendto_server(client_p, NOCAPS, CAP_TS6,
":%s NICK %s :%lu",
source_p->name, nick, (unsigned long)source_p->tsinfo);
}
/* set the new nick name */
if (source_p->name[0])
hash_del_client(source_p);
strlcpy(source_p->name, nick, sizeof(source_p->name));
hash_add_client(source_p);
if (!samenick)
watch_check_hash(source_p, RPL_LOGON);
}
/*
* m_nick
* parv[0] = sender prefix
* parv[1] = nickname
* parv[2] = hopcount when new user; TS when nick change
* parv[3] = TS
* ---- new user only below ----
* parv[4] = umode
* parv[5] = username
* parv[6] = hostname
* parv[7] = server
* parv[8] = serviceid
* parv[9] = IP
* parv[10] = ircname
* -- endif
*/
int m_nick(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
struct simBan *ban;
aClient *acptr, *uplink;
Link *lp, *lp2;
char nick[NICKLEN + 2];
ts_val newts = 0;
int sameuser = 0, samenick = 0;
if (parc < 2)
{
sendto_one(sptr, err_str(ERR_NONICKNAMEGIVEN),
me.name, parv[0]);
return 0;
}
if (!IsServer(sptr) && IsServer(cptr) && parc > 2)
newts = atol(parv[2]);
else if (IsServer(sptr) && parc > 3)
newts = atol(parv[3]);
else
parc = 2;
/*
* parc == 2 on a normal client sign on (local) and a normal client
* nick change
* parc == 4 on a normal server-to-server client nick change
* parc == 11 on a normal TS style server-to-server NICK introduction
*/
if ((IsServer(sptr) || (parc > 4)) && (parc < 11))
{
/*
* We got the wrong number of params. Someone is trying to trick
* us. Kill it. -ThemBones As discussed with ThemBones, not much
* point to this code now sending a whack of global kills would
* also be more annoying then its worth, just note the problem,
* and continue -Dianora
*/
sendto_realops("IGNORING BAD NICK: %s[%s@%s] on %s (from %s)", parv[1],
(parc >= 6) ? parv[5] : "-",
(parc >= 7) ? parv[6] : "-",
(parc >= 8) ? parv[7] : "-", parv[0]);
return 0;
}
strncpyzt(nick, parv[1], NICKLEN + 1);
/*
* if do_nick_name() returns a null name OR if the server sent a
* nick name and do_nick_name() changed it in some way (due to rules
* of nick creation) then reject it. If from a server and we reject
* it, and KILL it. -avalon 4/4/92
*/
if (do_nick_name(nick) == 0 || (IsServer(cptr) && strcmp(nick, parv[1])))
{
sendto_one(sptr, err_str(ERR_ERRONEUSNICKNAME),
me.name, parv[0], parv[1], "Erroneous Nickname");
if (IsServer(cptr))
{
ircstp->is_kill++;
sendto_realops_lev(DEBUG_LEV, "Bad Nick: %s From: %s Via: %s",
parv[1], parv[0],
get_client_name(cptr, HIDEME));
sendto_one(cptr, ":%s KILL %s :%s (Bad Nick)",
me.name, parv[1], me.name);
if (sptr != cptr) { /* bad nick change */
sendto_serv_butone(cptr, ":%s KILL %s :%s (Bad Nick)", me.name,
parv[0], me.name);
sptr->flags |= FLAGS_KILLED;
return exit_client(cptr, sptr, &me, "BadNick");
}
}
return 0;
}
/*
* Check against nick name collisions.
*
* Put this 'if' here so that the nesting goes nicely on the screen
* :) We check against server name list before determining if the
* nickname is present in the nicklist (due to the way the below
* for loop is constructed). -avalon
*/
do
{
if ((acptr = find_server(nick, NULL)))
if (MyConnect(sptr))
{
sendto_one(sptr, err_str(ERR_NICKNAMEINUSE), me.name,
BadPtr(parv[0]) ? "*" : parv[0], nick);
return 0;
}
/*
* acptr already has result from find_server
* Well. unless we have a capricious server on the net, a nick can
* never be the same as a server name - Dianora
* That's not the only case; maybe someone broke do_nick_name
* or changed it so they could use "." in nicks on their network
* - sedition
*/
if (acptr)
{
/*
* We have a nickname trying to use the same name as a
* server. Send out a nick collision KILL to remove the
* nickname. As long as only a KILL is sent out, there is no
* danger of the server being disconnected. Ultimate way to
* jupiter a nick ? >;-). -avalon
*/
sendto_realops_lev(SKILL_LEV, "Nick collision on %s", sptr->name);
ircstp->is_kill++;
sendto_one(cptr, ":%s KILL %s :%s (Nick Collision)", me.name,
sptr->name, me.name);
sptr->flags |= FLAGS_KILLED;
return exit_client(cptr, sptr, &me, "Nick/Server collision");
}
if (!(acptr = find_client(nick, NULL)))
break;
/*
* If acptr == sptr, then we have a client doing a nick change
* between *equivalent* nicknames as far as server is concerned
* (user is changing the case of his/her nickname or somesuch)
*/
if (acptr == sptr)
{
if (strcmp(acptr->name, nick) == 0)
return 0;
else
break;
} /* If user is changing nick to itself no point in propogating */
/*
* Note: From this point forward it can be assumed that acptr !=
* sptr (point to different client structures).
*
* If the older one is "non-person", the new entry is just
* allowed to overwrite it. Just silently drop non-person, and
* proceed with the nick. This should take care of the "dormant
* nick" way of generating collisions...
*/
if (IsUnknown(acptr))
{
if (MyConnect(acptr))
{
exit_client(NULL, acptr, &me, "Overridden");
break;
}
else if (!(acptr->user))
{
sendto_realops_lev(SKILL_LEV, "Nick Collision on %s", parv[1]);
sendto_serv_butone(NULL, ":%s KILL %s :%s (Nick Collision)",
me.name, acptr->name, me.name);
acptr->flags |= FLAGS_KILLED;
/* Having no USER struct should be ok... */
return exit_client(cptr, acptr, &me,
"Got TS NICK before Non-TS USER");
}
}
if (!IsServer(cptr))
{
/*
* NICK is coming from local client connection. Just send
* error reply and ignore the command.
* parv[0] is empty on connecting clients
*/
sendto_one(sptr, err_str(ERR_NICKNAMEINUSE),
me.name, BadPtr(parv[0]) ? "*" : parv[0], nick);
return 0;
}
/*
* NICK was coming from a server connection. Means that the same
* nick is registered for different users by different server.
* This is either a race condition (two users coming online about
* same time, or net reconnecting) or just two net fragments
* becoming joined and having same nicks in use. We cannot have
* TWO users with same nick--purge this NICK from the system with
* a KILL... >;)
*
* Changed to something reasonable like IsServer(sptr) (true if
* "NICK new", false if ":old NICK new") -orabidoo
*/
if (IsServer(sptr))
{
/*
* A new NICK being introduced by a neighbouring server (e.g.
* message type "NICK new" received)
*/
if (!newts || !acptr->tsinfo || (newts == acptr->tsinfo))
{
sendto_realops_lev(SKILL_LEV, "Nick collision on %s", parv[1]);
ircstp->is_kill++;
sendto_one(acptr, err_str(ERR_NICKCOLLISION),
me.name, acptr->name, acptr->name);
sendto_serv_butone(NULL, ":%s KILL %s :%s (Nick Collision)",
me.name, acptr->name, me.name);
acptr->flags |= FLAGS_KILLED;
return exit_client(cptr, acptr, &me, "Nick collision");
}
else
{
/* XXX This looks messed up to me XXX - Raist */
sameuser = (acptr->user) &&
mycmp(acptr->user->username, parv[5]) == 0 &&
mycmp(acptr->user->host, parv[6]) == 0;
if ((sameuser && newts < acptr->tsinfo) ||
(!sameuser && newts > acptr->tsinfo))
{
return 0;
}
else
{
sendto_realops_lev(SKILL_LEV, "Nick collision on %s",parv[1]);
ircstp->is_kill++;
sendto_one(acptr, err_str(ERR_NICKCOLLISION),
me.name, acptr->name, acptr->name);
sendto_serv_butone(sptr, ":%s KILL %s :%s (Nick Collision)",
me.name, acptr->name, me.name);
acptr->flags |= FLAGS_KILLED;
(void) exit_client(cptr, acptr, &me, "Nick collision");
break;
}
}
}
/*
* * A NICK change has collided (e.g. message type * ":old NICK
* new". This requires more complex cleanout. * Both clients must be
* purged from this server, the "new" * must be killed from the
* incoming connection, and "old" must * be purged from all outgoing
* connections.
*/
if (!newts || !acptr->tsinfo || (newts == acptr->tsinfo) ||
!sptr->user)
{
sendto_realops_lev(SKILL_LEV, "Nick change collision: %s", parv[1]);
ircstp->is_kill++;
sendto_one(acptr, err_str(ERR_NICKCOLLISION),
me.name, acptr->name, acptr->name);
sendto_serv_butone(NULL, ":%s KILL %s :%s (Nick Collision)",me.name,
sptr->name, me.name);
ircstp->is_kill++;
sendto_serv_butone(NULL, ":%s KILL %s :%s (Nick Collision)",me.name,
acptr->name, me.name);
acptr->flags |= FLAGS_KILLED;
(void) exit_client(NULL, acptr, &me, "Nick collision(new)");
sptr->flags |= FLAGS_KILLED;
return exit_client(cptr, sptr, &me, "Nick collision(old)");
}
else
{
/* XXX This looks messed up XXX */
sameuser = mycmp(acptr->user->username, sptr->user->username) == 0
&& mycmp(acptr->user->host, sptr->user->host) == 0;
if ((sameuser && newts < acptr->tsinfo) ||
(!sameuser && newts > acptr->tsinfo)) {
if (sameuser)
sendto_realops_lev(SKILL_LEV,
"Nick change collision from %s to %s",
sptr->name, acptr->name);
ircstp->is_kill++;
sendto_serv_butone(cptr, ":%s KILL %s :%s (Nick Collision)", me.name,
sptr->name, me.name);
sptr->flags |= FLAGS_KILLED;
if (sameuser)
return exit_client(cptr, sptr, &me, "Nick collision(old)");
else
return exit_client(cptr, sptr, &me, "Nick collision(new)");
}
else
{
sendto_realops_lev(SKILL_LEV, "Nick collision on %s", acptr->name);
ircstp->is_kill++;
sendto_one(acptr, err_str(ERR_NICKCOLLISION),
me.name, acptr->name, acptr->name);
sendto_serv_butone(sptr, ":%s KILL %s :%s (Nick Collision)",me.name,
acptr->name, me.name);
acptr->flags |= FLAGS_KILLED;
(void) exit_client(cptr, acptr, &me, "Nick collision");
}
}
} while (0);
if (IsServer(sptr))
{
uplink = find_server(parv[7], NULL);
if(!uplink)
{
/* if we can't find the server this nick is on,
* complain loudly and ignore it. - lucas */
sendto_realops("Remote nick %s on UNKNOWN server %s",
nick, parv[7]);
return 0;
}
sptr = make_client(cptr, uplink);
/* If this is on a U: lined server, it's a U: lined client. */
if(IsULine(uplink))
sptr->flags|=FLAGS_ULINE;
add_client_to_list(sptr);
if (parc > 2)
sptr->hopcount = atoi(parv[2]);
if (newts)
{
sptr->tsinfo = newts;
}
else
{
newts = sptr->tsinfo = (ts_val) timeofday;
ts_warn("Remote nick %s introduced without a TS", nick);
}
/* copy the nick in place */
(void) strcpy(sptr->name, nick);
(void) add_to_client_hash_table(nick, sptr);
if (parc >= 10)
{
int *s, flag;
char *m;
/* parse the usermodes -orabidoo */
m = &parv[4][1];
while (*m)
{
for (s = user_modes; (flag = *s); s += 2)
if (*m == *(s + 1))
{
if ((flag == UMODE_o) || (flag == UMODE_O))
Count.oper++;
sptr->umode |= flag & SEND_UMODES;
break;
}
m++;
}
if (parc==10)
{
return do_user(nick, cptr, sptr, parv[5], parv[6],
parv[7], strtoul(parv[8], NULL, 0),
"0.0.0.0", parv[9]);
} else if (parc==11)
{
return do_user(nick, cptr, sptr, parv[5], parv[6], parv[7],
strtoul(parv[8], NULL, 0),
parv[9], parv[10]);
}
}
}
else if (sptr->name[0])
{
#ifdef DONT_CHECK_QLINE_REMOTE
if (MyConnect(sptr))
{
#endif
if ((ban = check_mask_simbanned(nick, SBAN_NICK)))
{
#ifndef DONT_CHECK_QLINE_REMOTE
if (!MyConnect(sptr))
sendto_realops("Restricted nick %s from %s on %s", nick,
(*sptr->name != 0 && !IsServer(sptr)) ?
sptr->name : "<unregistered>",
(sptr->user == NULL) ? ((IsServer(sptr)) ?
parv[6] : me.name) :
sptr->user->server);
#endif
if (MyConnect(sptr) && (!IsServer(cptr)) && (!IsOper(cptr))
&& (!IsULine(sptr)))
{
sendto_one(sptr, err_str(ERR_ERRONEUSNICKNAME), me.name,
BadPtr(parv[0]) ? "*" : parv[0], nick,
BadPtr(ban->reason) ? "Erroneous Nickname" :
ban->reason);
if (call_hooks(CHOOK_FORBID, cptr, nick, ban) != FLUSH_BUFFER)
sendto_realops_lev(REJ_LEV,
"Forbidding restricted nick %s from %s",
nick, get_client_name(cptr, FALSE));
return 0;
}
}
#ifdef DONT_CHECK_QLINE_REMOTE
}
#endif
if (MyConnect(sptr))
{
if (IsRegisteredUser(sptr))
{
/* before we change their nick, make sure they're not banned
* on any channels, and!! make sure they're not changing to
* a banned nick -sed */
/* a little cleaner - lucas */
for (lp = sptr->user->channel; lp; lp = lp->next)
{
if (can_send(sptr, lp->value.chptr, NULL))
{
sendto_one(sptr, err_str(ERR_BANNICKCHANGE), me.name,
sptr->name, lp->value.chptr->chname);
return 0;
}
if (nick_is_banned(lp->value.chptr, nick, sptr) != NULL)
{
sendto_one(sptr, err_str(ERR_BANONCHAN), me.name,
sptr->name, nick, lp->value.chptr->chname);
return 0;
}
}
#ifdef ANTI_NICK_FLOOD
if ((sptr->last_nick_change + MAX_NICK_TIME) < NOW)
sptr->number_of_nick_changes = 0;
sptr->last_nick_change = NOW;
sptr->number_of_nick_changes++;
if (sptr->number_of_nick_changes > MAX_NICK_CHANGES &&
!IsAnOper(sptr))
{
sendto_one(sptr,
":%s NOTICE %s :*** Notice -- Too many nick "
"changes. Wait %d seconds before trying again.",
me.name, sptr->name, MAX_NICK_TIME);
return 0;
}
#endif
/* If it changed nicks, -r it */
if ((sptr->umode & UMODE_r) && (mycmp(parv[0], nick) != 0))
{
unsigned int oldumode;
char mbuf[BUFSIZE];
oldumode = sptr->umode;
sptr->umode &= ~UMODE_r;
send_umode(sptr, sptr, oldumode, ALL_UMODES, mbuf);
}
/* LOCAL NICKHANGE */
/*
* Client just changing his/her nick. If he/she is on a
* channel, send note of change to all clients on that channel.
* Propagate notice to other servers.
*/
/* if the nickname is different, set the TS */
if (mycmp(parv[0], nick))
{
sptr->tsinfo = newts ? newts : (ts_val) timeofday;
}
sendto_common_channels(sptr, ":%s NICK :%s", parv[0],
nick);
if (sptr->user)
{
add_history(sptr, 1);
sendto_serv_butone(cptr, ":%s NICK %s :%ld",
parv[0], nick, sptr->tsinfo);
}
}
}
else
{
/* REMOTE NICKCHANGE */
/*
* Client just changing his/her nick. If he/she is on a
* channel, send note of change to all clients on that channel.
* Propagate notice to other servers.
*/
/* if the nickname is different, set the TS */
if (mycmp(parv[0], nick))
{
sptr->tsinfo = newts ? newts : (ts_val) timeofday;
}
sendto_common_channels(sptr, ":%s NICK :%s", parv[0], nick);
if (sptr->user)
{
add_history(sptr, 1);
sendto_serv_butone(cptr, ":%s NICK %s :%ld",
parv[0], nick, sptr->tsinfo);
}
/* If it changed nicks, -r it */
if (mycmp(parv[0], nick))
sptr->umode &= ~UMODE_r;
/*
* Flush the banserial for the channels the user is in, since this
* could be a SVSNICK induced nick change, which overrides any ban
* checking on the originating server.
*/
flush_user_banserial(sptr);
}
/* Remove dccallow entries for users who don't share common channel(s) unless they only change their nick capitalization -Kobi_S */
if(sptr->user && mycmp(parv[0], nick))
{
for(lp = sptr->user->dccallow; lp; lp = lp2)
{
lp2 = lp->next;
if(lp->flags == DCC_LINK_ME)
continue;
if(!find_shared_chan(sptr, lp->value.cptr))
{
sendto_one(lp->value.cptr, ":%s %d %s :%s has been removed from "
"your DCC allow list for signing off",
me.name, RPL_DCCINFO, lp->value.cptr->name, parv[0]);
del_dccallow(lp->value.cptr, sptr, 1);
}
}
}
}
else
{
/* Client setting NICK the first time */
if (MyConnect(sptr))
{
if ((ban = check_mask_simbanned(nick, SBAN_NICK)))
{
if (MyConnect(sptr) && (!IsServer(cptr)) && (!IsOper(cptr))
&& (!IsULine(sptr)))
{
sendto_one(sptr, err_str(ERR_ERRONEUSNICKNAME), me.name,
BadPtr(parv[0]) ? "*" : parv[0], nick,
BadPtr(ban->reason) ? "Erroneous Nickname" :
ban->reason);
if (call_hooks(CHOOK_FORBID, cptr, nick, ban) != FLUSH_BUFFER)
sendto_realops_lev(REJ_LEV,
"Forbidding restricted nick %s from %s", nick,
get_client_name(cptr, FALSE));
return 0;
}
}
}
strcpy(sptr->name, nick);
sptr->tsinfo = timeofday;
if (sptr->user)
{
/* USER already received, now we have NICK */
if (register_user(cptr, sptr, nick, sptr->user->username, NULL)
== FLUSH_BUFFER)
return FLUSH_BUFFER;
}
}
/* Finally set new nick name. */
if (sptr->name[0])
{
del_from_client_hash_table(sptr->name, sptr);
samenick = mycmp(sptr->name, nick) ? 0 : 1;
if (IsPerson(sptr))
{
if (!samenick)
hash_check_watch(sptr, RPL_LOGOFF);
#ifdef RWHO_PROBABILITY
probability_change(sptr->name, nick);
#endif
}
}
strcpy(sptr->name, nick);
add_to_client_hash_table(nick, sptr);
if (IsPerson(sptr) && !samenick)
hash_check_watch(sptr, RPL_LOGON);
return 0;
}
/*
** Exit one client, local or remote. Assuming all dependents have
** been already removed, and socket closed for local client.
*/
static void exit_one_client(struct Client *client_p,
struct Client *source_p,
struct Client *from, const char *comment)
{
struct Client* target_p;
dlink_node *lp;
dlink_node *next_lp;
if (IsServer(source_p))
{
if (source_p->servptr && source_p->servptr->serv)
del_client_from_llist(&(source_p->servptr->serv->servers),
source_p);
else
ts_warn("server %s without servptr!", source_p->name);
if(!IsMe(source_p))
remove_server_from_list(source_p);
}
else if (source_p->servptr && source_p->servptr->serv)
{
del_client_from_llist(&(source_p->servptr->serv->users), source_p);
}
/* there are clients w/o a servptr: unregistered ones */
/*
** For a server or user quitting, propogate the information to
** other servers (except to the one where is came from (client_p))
*/
if (IsMe(source_p))
{
sendto_realops_flags(FLAGS_ALL, L_ALL,
"ERROR: tried to exit me! : %s", comment);
return; /* ...must *never* exit self!! */
}
else if (IsServer(source_p))
{
/*
** Old sendto_serv_but_one() call removed because we now
** need to send different names to different servers
** (domain name matching)
*/
/*
** The bulk of this is done in remove_dependents now, all
** we have left to do is send the SQUIT upstream. -orabidoo
*/
if (source_p->localClient)
{
if(source_p->localClient->ctrlfd > -1)
{
fd_close(source_p->localClient->ctrlfd);
source_p->localClient->ctrlfd = -1;
#ifndef HAVE_SOCKETPAIR
fd_close(source_p->localClient->ctrlfd_r);
fd_close(source_p->localClient->fd_r);
source_p->localClient->ctrlfd_r = -1;
source_p->localClient->fd_r = -1;
#endif
}
}
target_p = source_p->from;
if (target_p && IsServer(target_p) && target_p != client_p && !IsMe(target_p) &&
(source_p->flags & FLAGS_KILLED) == 0)
sendto_one(target_p, ":%s SQUIT %s :%s", from->name, source_p->name, comment);
}
else if (source_p->name[0]) /* ...just clean all others with QUIT... */
{
/*
** If this exit is generated from "m_kill", then there
** is no sense in sending the QUIT--KILL's have been
** sent instead.
*/
if ((source_p->flags & FLAGS_KILLED) == 0)
{
sendto_server(client_p, source_p, NULL, NOCAPS, NOCAPS,
NOFLAGS, ":%s QUIT :%s", source_p->name, comment);
}
/*
** If a person is on a channel, send a QUIT notice
** to every client (person) on the same channel (so
** that the client can show the "**signoff" message).
** (Note: The notice is to the local clients *only*)
*/
if (source_p->user)
{
sendto_common_channels_local(source_p, ":%s!%s@%s QUIT :%s",
source_p->name,
source_p->username,
source_p->host,
comment);
for (lp = source_p->user->channel.head; lp; lp = next_lp)
{
next_lp = lp->next;
remove_user_from_channel(lp->data, source_p);
}
/* Should not be in any channels now */
assert(source_p->user->channel.head == NULL);
/* Clean up invitefield */
for (lp = source_p->user->invited.head; lp; lp = next_lp)
{
next_lp = lp->next;
del_invite(lp->data, source_p);
}
/* Clean up allow lists */
del_all_accepts(source_p);
add_history(source_p, 0);
off_history(source_p);
if (HasID(source_p))
del_from_id_hash_table(source_p->user->id, source_p);
/* again, this is all that is needed */
}
}
/*
* Remove source_p from the client lists
*/
del_from_client_hash_table(source_p->name, source_p);
/* remove from global client list */
remove_client_from_list(source_p);
/* Check to see if the client isn't already on the dead list */
assert(dlinkFind(&dead_list, source_p) == NULL);
/* add to dead client dlist */
lp = make_dlink_node();
SetDead(source_p);
dlinkAdd(source_p, lp, &dead_list);
}
/*
* nick_from_server()
*/
static int
nick_from_server(struct Client *client_p, struct Client *source_p, int parc,
char *parv[], time_t newts, char *nick)
{
if(IsServer(source_p))
{
/* A server introducing a new client, change source */
source_p = make_client(client_p);
add_client_to_list(source_p);
if(parc > 2)
source_p->hopcount = atoi(parv[2]);
if(newts)
source_p->tsinfo = newts;
else
{
newts = source_p->tsinfo = CurrentTime;
ts_warn("Remote nick %s (%s) introduced without a TS", nick, parv[0]);
}
/* copy the nick in place */
(void) strcpy(source_p->name, nick);
(void) add_to_client_hash_table(nick, source_p);
if(parc > 8)
{
int flag;
char *m;
/* parse usermodes */
m = &parv[4][1];
while (*m)
{
flag = user_modes_from_c_to_bitmask[(unsigned char) *m];
if(!(source_p->umodes & UMODE_INVISIBLE)
&& (flag & UMODE_INVISIBLE))
Count.invisi++;
if(!(source_p->umodes & UMODE_OPER) && (flag & UMODE_OPER))
Count.oper++;
source_p->umodes |= flag & SEND_UMODES;
m++;
}
return do_remote_user(nick, client_p, source_p, parv[5], parv[6],
parv[7], (parc > 9)? parv[8] : NULL,
parv[(parc > 9)? 9 : 8]);
}
}
else if(source_p->name[0])
{
/* client changing their nick */
if(irccmp(parv[0], nick))
source_p->tsinfo = newts ? newts : CurrentTime;
sendto_common_channels_local(source_p, ":%s!%s@%s NICK :%s",
source_p->name, source_p->username, source_p->host,
nick);
if(source_p->user)
{
add_history(source_p, 1);
sendto_server(client_p, NULL, NOCAPS, NOCAPS,
":%s NICK %s :%lu",
parv[0], nick, (unsigned long) source_p->tsinfo);
}
}
/* set the new nick name */
if(source_p->name[0])
del_from_client_hash_table(source_p->name, source_p);
strcpy(source_p->name, nick);
add_to_client_hash_table(nick, source_p);
/* remove all accepts pointing to the client */
del_all_accepts(source_p);
return 0;
}
