/* Routines to maintain a list of online users.
*
* (C) 2003 Anope Team
* Contact us at info@anope.org
*
* Please read COPYING and README for furhter details.
*
* Based on the original code of Epona by Lara.
* Based on the original code of Services by Andy Church.
*
* $Id: users.c 420 2004-10-23 23:42:15Z trystan $
*
*/
#include "services.h"
#define HASH(nick) (((nick)[0]&31)<<5 | ((nick)[1]&31))
User *userlist[1024];
int32 usercnt = 0, opcnt = 0, maxusercnt = 0;
time_t maxusertime;
static unsigned long umodes[128] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, UMODE_A, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#if defined(IRC_ULTIMATE) || defined(IRC_ULTIMATE3)
UMODE_P,
#else
0,
#endif
0,
#if defined(IRC_BAHAMUT) || defined(IRC_ULTIMATE)
UMODE_R,
#else
0,
#endif
0, 0, 0, 0, 0, 0, 0,
#ifdef IRC_ULTIMATE3
UMODE_Z,
#else
0,
#endif
0, 0, 0, 0, 0,
0, UMODE_a, 0, 0, 0, 0, 0,
#ifdef IRC_DREAMFORGE
UMODE_g,
#else
0,
#endif
UMODE_h, UMODE_i, 0, 0, 0, 0, 0, UMODE_o,
#if defined(IRC_ULTIMATE) || defined(IRC_ULTIMATE3)
UMODE_p,
#else
0,
#endif
0, UMODE_r, 0, 0, 0, 0, UMODE_w,
#if defined(IRC_ULTIMATE) || defined(IRC_UNREAL) || defined(IRC_ULTIMATE3) || defined(IRC_VIAGRA)
UMODE_x,
#else
0,
#endif
0, 0, 0, 0, 0, 0, 0
};
/*************************************************************************/
/*************************************************************************/
/* Allocate a new User structure, fill in basic values, link it to the
* overall list, and return it. Always successful.
*/
static User *new_user(const char *nick)
{
User *user, **list;
user = scalloc(sizeof(User), 1);
if (!nick)
nick = "";
strscpy(user->nick, nick, NICKMAX);
list = &userlist[HASH(user->nick)];
user->next = *list;
if (*list)
(*list)->prev = user;
*list = user;
user->na = findnick(nick);
if (user->na)
user->na->u = user;
usercnt++;
if (usercnt > maxusercnt) {
maxusercnt = usercnt;
maxusertime = time(NULL);
if (LogMaxUsers)
alog("user: New maximum user count: %d", maxusercnt);
}
user->isSuperAdmin = 0; /* always set SuperAdmin to 0 for new users */
return user;
}
/*************************************************************************/
/* Change the nickname of a user, and move pointers as necessary. */
static void change_user_nick(User * user, const char *nick)
{
User **list;
int is_same = (!stricmp(user->nick, nick) ? 1 : 0);
if (user->prev)
user->prev->next = user->next;
else
userlist[HASH(user->nick)] = user->next;
if (user->next)
user->next->prev = user->prev;
user->nick[1] = 0; /* paranoia for zero-length nicks */
strscpy(user->nick, nick, NICKMAX);
list = &userlist[HASH(user->nick)];
user->next = *list;
user->prev = NULL;
if (*list)
(*list)->prev = user;
*list = user;
/* Only if old and new nick aren't the same; no need to waste time */
if (!is_same) {
if (user->na)
user->na->u = NULL;
user->na = findnick(nick);
if (user->na)
user->na->u = user;
}
}
/*************************************************************************/
#ifdef HAS_VHOST
static void update_host(User * user)
{
if (user->na && (nick_identified(user)
|| (!(user->na->nc->flags & NI_SECURE)
&& nick_recognized(user)))) {
if (user->na->last_usermask)
free(user->na->last_usermask);
user->na->last_usermask =
smalloc(strlen(GetIdent(user)) + strlen(GetHost(user)) + 2);
sprintf(user->na->last_usermask, "%s@%s", GetIdent(user),
GetHost(user));
}
if (debug)
alog("debug: %s changes its host to %s", user->nick,
GetHost(user));
}
#endif
/*************************************************************************/
#if defined(IRC_ULTIMATE) || defined(IRC_UNREAL) || defined(IRC_ULTIMATE3) || defined(IRC_VIAGRA) || defined(IRC_PTLINK)
/* Change the (virtual) hostname of a user. */
void change_user_host(User * user, const char *host)
{
if (user->vhost)
free(user->vhost);
user->vhost = sstrdup(host);
if (debug)
alog("debug: %s changes its vhost to %s", user->nick, host);
update_host(user);
}
#endif
/*************************************************************************/
#if defined(IRC_ULTIMATE) || defined(IRC_UNREAL) || defined(IRC_VIAGRA) || defined(IRC_PTLINK)
/* Change the realname of a user. */
void change_user_realname(User * user, const char *realname)
{
if (user->realname)
free(user->realname);
user->realname = sstrdup(realname);
if (user->na && (nick_identified(user)
|| (!(user->na->nc->flags & NI_SECURE)
&& nick_recognized(user)))) {
if (user->na->last_realname)
free(user->na->last_realname);
user->na->last_realname = sstrdup(realname);
}
if (debug)
alog("debug: %s changes its realname to %s", user->nick, realname);
}
/*************************************************************************/
/* Change the username of a user. */
void change_user_username(User * user, const char *username)
{
if (user->username)
free(user->username);
user->username = sstrdup(username);
if (user->na && (nick_identified(user)
|| (!(user->na->nc->flags & NI_SECURE)
&& nick_recognized(user)))) {
if (user->na->last_usermask)
free(user->na->last_usermask);
user->na->last_usermask =
smalloc(strlen(GetIdent(user)) + strlen(GetHost(user)) + 2);
sprintf(user->na->last_usermask, "%s@%s", GetIdent(user),
GetHost(user));
}
if (debug)
alog("debug: %s changes its username to %s", user->nick, username);
}
#endif
/*************************************************************************/
void set_umode(User * user, int ac, char **av)
{
int add = 1; /* 1 if adding modes, 0 if deleting */
char *modes = av[0];
ac--;
if (debug)
alog("debug: Changing mode for %s to %s", user->nick, modes);
while (*modes) {
add ? (user->mode |= umodes[(int) *modes]) : (user->mode &=
~umodes[(int)
*modes]);
switch (*modes++) {
case '+':
add = 1;
break;
case '-':
add = 0;
break;
#if defined(IRC_ULTIMATE) || defined(IRC_ULTIMATE3)
case 'a':
if (add && !is_services_oper(user)) {
send_cmd(ServerName, "SVSMODE %s -a", user->nick);
user->mode &= ~UMODE_a;
}
break;
case 'P':
if (add && !is_services_admin(user)) {
send_cmd(ServerName, "SVSMODE %s -P", user->nick);
user->mode &= ~UMODE_P;
}
break;
#endif
#if defined(IRC_ULTIMATE)
case 'R':
if (add && !is_services_root(user)) {
send_cmd(ServerName, "SVSMODE %s -R", user->nick);
user->mode &= ~UMODE_R;
}
break;
#endif
#if defined(IRC_ULTIMATE3)
case 'Z':
if (add && !is_services_root(user)) {
send_cmd(ServerName, "SVSMODE %s -Z", user->nick);
user->mode &= ~UMODE_Z;
}
break;
#endif
case 'd':
if (ac == 0) {
#if !defined(IRC_ULTIMATE) && !defined(IRC_UNREAL)
alog("user: umode +d with no parameter (?) for user %s",
user->nick);
#endif
break;
}
ac--;
av++;
user->svid = strtoul(*av, NULL, 0);
break;
case 'o':
if (add) {
opcnt++;
if (WallOper)
wallops(s_OperServ, "\2%s\2 is now an IRC operator.",
user->nick);
display_news(user, NEWS_OPER);
#if defined(IRC_PTLINK)
if (is_services_admin(user)) {
send_cmd(ServerName, "SVSMODE %s +a", user->nick);
user->mode |= UMODE_a;
}
#endif
#if defined(IRC_ULTIMATE) || defined(IRC_ULTIMATE3)
if (is_services_oper(user)) {
send_cmd(ServerName, "SVSMODE %s +a", user->nick);
user->mode |= UMODE_a;
}
if (is_services_admin(user)) {
send_cmd(ServerName, "SVSMODE %s +P", user->nick);
user->mode |= UMODE_P;
}
#endif
#ifdef IRC_ULTIMATE
if (is_services_root(user)) {
send_cmd(ServerName, "SVSMODE %s +R", user->nick);
user->mode |= UMODE_R;
}
#endif
#ifdef IRC_ULTIMATE3
if (is_services_root(user)) {
send_cmd(ServerName, "SVSMODE %s +Z", user->nick);
user->mode |= UMODE_Z;
}
#endif
} else {
opcnt--;
}
break;
case 'r':
if (add && !nick_identified(user)) {
send_cmd(ServerName, "SVSMODE %s -r", user->nick);
user->mode &= ~UMODE_r;
}
break;
#if defined(IRC_ULTIMATE) || defined(IRC_UNREAL) || defined(IRC_ULTIMATE3) || defined(IRC_VIAGRA)
case 'x':
update_host(user);
break;
#endif
}
}
}
/*************************************************************************/
/* Remove and free a User structure. */
static void delete_user(User * user)
{
struct u_chanlist *c, *c2;
struct u_chaninfolist *ci, *ci2;
if (LogUsers) {
#ifdef HAS_VHOST
alog("LOGUSERS: %s (%s@%s => %s) (%s) left the network (%s).",
user->nick, user->username, user->host,
(user->vhost ? user->vhost : "(none)"), user->realname,
user->server);
#else
alog("LOGUSERS: %s (%s@%s) (%s) left the network (%s).",
user->nick, user->username, user->host,
user->realname, user->server);
#endif
}
if (debug >= 2)
alog("debug: delete_user() called");
usercnt--;
if (is_oper(user))
opcnt--;
if (debug >= 2)
alog("debug: delete_user(): free user data");
free(user->username);
free(user->host);
#ifdef HAS_VHOST
if (user->vhost)
free(user->vhost);
#endif
free(user->realname);
free(user->server);
if (debug >= 2)
alog("debug: delete_user(): remove from channels");
c = user->chans;
while (c) {
c2 = c->next;
chan_deluser(user, c->chan);
free(c);
c = c2;
}
/* This called only here now */
cancel_user(user);
if (user->na)
user->na->u = NULL;
if (debug >= 2)
alog("debug: delete_user(): free founder data");
ci = user->founder_chans;
while (ci) {
ci2 = ci->next;
free(ci);
ci = ci2;
}
if (debug >= 2)
alog("debug: delete_user(): delete from list");
if (user->prev)
user->prev->next = user->next;
else
userlist[HASH(user->nick)] = user->next;
if (user->next)
user->next->prev = user->prev;
if (debug >= 2)
alog("debug: delete_user(): free user structure");
free(user);
if (debug >= 2)
alog("debug: delete_user() done");
}
/*************************************************************************/
/*************************************************************************/
/* Return statistics. Pointers are assumed to be valid. */
void get_user_stats(long *nusers, long *memuse)
{
long count = 0, mem = 0;
int i;
User *user;
struct u_chanlist *uc;
struct u_chaninfolist *uci;
for (i = 0; i < 1024; i++) {
for (user = userlist[i]; user; user = user->next) {
count++;
mem += sizeof(*user);
if (user->username)
mem += strlen(user->username) + 1;
if (user->host)
mem += strlen(user->host) + 1;
#ifdef HAS_VHOST
if (user->vhost)
mem += strlen(user->vhost) + 1;
#endif
if (user->realname)
mem += strlen(user->realname) + 1;
if (user->server)
mem += strlen(user->server) + 1;
for (uc = user->chans; uc; uc = uc->next)
mem += sizeof(*uc);
for (uci = user->founder_chans; uci; uci = uci->next)
mem += sizeof(*uci);
}
}
*nusers = count;
*memuse = mem;
}
/*************************************************************************/
/* Find a user by nick. Return NULL if user could not be found. */
User *finduser(const char *nick)
{
User *user;
if (debug >= 3)
alog("debug: finduser(%p)", nick);
user = userlist[HASH(nick)];
while (user && stricmp(user->nick, nick) != 0)
user = user->next;
if (debug >= 3)
alog("debug: finduser(%s) -> %p", nick, user);
return user;
}
/*************************************************************************/
/* Iterate over all users in the user list. Return NULL at end of list. */
static User *current;
static int next_index;
User *firstuser(void)
{
next_index = 0;
while (next_index < 1024 && current == NULL)
current = userlist[next_index++];
if (debug)
alog("debug: firstuser() returning %s",
current ? current->nick : "NULL (end of list)");
return current;
}
User *nextuser(void)
{
if (current)
current = current->next;
if (!current && next_index < 1024) {
while (next_index < 1024 && current == NULL)
current = userlist[next_index++];
}
if (debug)
alog("debug: nextuser() returning %s",
current ? current->nick : "NULL (end of list)");
return current;
}
/*************************************************************************/
/*************************************************************************/
/* Handle a server NICK command. */
User *do_nick(const char *source, char *nick, char *username, char *host,
char *server, char *realname, time_t ts, uint32 svid, ...)
{
User *user;
char *tmp = NULL;
NickAlias *old_na; /* Old nick rec */
int nc_changed = 1; /* Did nick core change? */
int status = 0; /* Status to apply */
char mask[USERMAX + HOSTMAX + 2];
if (!*source) {
#ifdef HAS_NICKIP
char ipbuf[16];
struct in_addr addr;
uint32 ip;
#endif
#ifdef HAS_VHOST
char *vhost = NULL;
#endif
#if defined(HAS_NICKIP) || defined(HAS_NICKVHOST)
va_list args;
va_start(args, svid);
#endif
#ifdef HAS_NICKIP
ip = va_arg(args, uint32);
addr.s_addr = htonl(ip);
ntoa(addr, ipbuf, sizeof(ipbuf));
#endif
#ifdef HAS_NICKVHOST
vhost = va_arg(args, char *);
if (!strcmp(vhost, "*")) {
vhost = NULL;
if (debug)
alog("debug: new user with no vhost in NICK command: %s",
nick);
}
#endif
/* This is a new user; create a User structure for it. */
if (debug)
alog("debug: new user: %s", nick);
if (LogUsers) {
/**
* Ugly swap routine for Flop's bug :)
**/
tmp = strchr(realname, '%');
while (tmp) {
*tmp = '-';
tmp = strchr(realname, '%');
}
/**
* End of ugly swap
**/
#ifdef HAS_NICKVHOST
# ifdef HAS_NICKIP
alog("LOGUSERS: %s (%s@%s => %s) (%s) [%s] connected to the network (%s).", nick, username, host, vhost, realname, ipbuf, server);
# else
alog("LOGUSERS: %s (%s@%s => %s) (%s) connected to the network (%s).", nick, username, host, vhost, realname, server);
# endif
#else
# ifdef HAS_NICKIP
alog("LOGUSERS: %s (%s@%s) (%s) [%s] connected to the network (%s).", nick, username, host, realname, ipbuf, server);
# else
alog("LOGUSERS: %s (%s@%s) (%s) connected to the network (%s).", nick, username, host, realname, server);
# endif
#endif
}
/* We used to ignore the ~ which a lot of ircd's use to indicate no
* identd response. That caused channel bans to break, so now we
* just take what the server gives us. People are still encouraged
* to read the RFCs and stop doing anything to usernames depending
* on the result of an identd lookup.
*/
/* First check for AKILLs. */
/* DONT just return null if its an akill match anymore - yes its more efficent to, however, now that ircd's are
* starting to use things like E/F lines, we cant be 100% sure the client will be removed from the network :/
* as such, create a user_struct, and if the client is removed, we'll delete it again when the QUIT notice
* comes in from the ircd.
**/
if (check_akill(nick, username, host,
#ifdef HAS_NICKVHOST
vhost,
#else
NULL,
#endif
#ifdef HAS_NICKIP
ipbuf)) {
#else
NULL)) {
#endif
/* return NULL; */
}
/**
* DefCon AKILL system, if we want to akill all connecting user's here's where to do it
* then force check_akill again on them...
**/
if (checkDefCon(DEFCON_AKILL_NEW_CLIENTS)) {
strncpy(mask, "*@", 3);
strncat(mask, host, HOSTMAX);
alog("DEFCON: adding akill for %s", mask);
add_akill(NULL, mask, s_OperServ,
time(NULL) + dotime(DefConAKILL),
DefConAkillReason ? DefConAkillReason :
"DEFCON AKILL");
if (check_akill(nick, username, host,
#ifdef HAS_NICKVHOST
vhost,
#else
NULL,
#endif
#ifdef HAS_NICKIP
ipbuf)) {
#else
NULL)) {
#endif
/* return NULL; */
}
}
#ifdef IRC_BAHAMUT
/* Next for SGLINEs */
if (check_sgline(nick, realname))
return NULL;
#endif
/* And for SQLINEs */
if (check_sqline(nick, 0))
return NULL;
#ifndef STREAMLINED
/* Now check for session limits */
if (LimitSessions && !add_session(nick, host))
return NULL;
#endif
/* And finally, for proxy ;) */
#ifdef USE_THREADS
# ifdef HAS_NICKIP
if (ProxyDetect && proxy_check(nick, host, ip))
# else
if (ProxyDetect && proxy_check(nick, host, 0))
# endif
return NULL;
#endif
/* Allocate User structure and fill it in. */
user = new_user(nick);
user->username = sstrdup(username);
user->host = sstrdup(host);
user->server = sstrdup(server);
user->realname = sstrdup(realname);
user->timestamp = ts;
user->my_signon = time(NULL);
#ifdef HAS_VHOST
user->vhost = vhost ? sstrdup(vhost) : sstrdup(host);
#endif
if (CheckClones) {
/* Check to see if it looks like clones. */
check_clones(user);
}
if (svid == 0) {
display_news(user, NEWS_LOGON);
display_news(user, NEWS_RANDOM);
}
if (svid == ts && user->na) {
/* Timestamp and svid match, and nick is registered; automagically identify the nick */
user->svid = svid;
user->na->status |= NS_IDENTIFIED;
check_memos(user);
nc_changed = 0;
} else if (svid != 1) {
/* Resets the svid because it doesn't match */
user->svid = 1;
#ifdef IRC_BAHAMUT
send_cmd(ServerName, "SVSMODE %s %lu +d 1", user->nick,
(unsigned long int) user->timestamp);
#else
#ifndef IRC_PTLINK
send_cmd(ServerName, "SVSMODE %s +d 1", user->nick);
#endif
#endif
} else {
user->svid = 1;
}
} else {
/* An old user changing nicks. */
user = finduser(source);
if (!user) {
alog("user: NICK from nonexistent nick %s", source);
return NULL;
}
user->isSuperAdmin = 0; /* Dont let people nick change and stay SuperAdmins */
if (debug)
alog("debug: %s changes nick to %s", source, nick);
if (LogUsers) {
#ifdef HAS_VHOST
alog("LOGUSERS: %s (%s@%s => %s) (%s) changed his nick to %s (%s).", user->nick, user->username, user->host, (user->vhost ? user->vhost : "(none)"), user->realname, nick, user->server);
#else
alog("LOGUSERS: %s (%s@%s) (%s) changed his nick to %s (%s).",
user->nick, user->username, user->host,
user->realname, nick, user->server);
#endif
}
user->timestamp = ts;
if (stricmp(nick, user->nick) == 0) {
/* No need to redo things */
change_user_nick(user, nick);
nc_changed = 0;
} else {
/* Update this only if nicks aren't the same */
user->my_signon = time(NULL);
old_na = user->na;
if (old_na) {
if (nick_recognized(user))
user->na->last_seen = time(NULL);
status = old_na->status & NS_TRANSGROUP;
cancel_user(user);
}
change_user_nick(user, nick);
if ((old_na ? old_na->nc : NULL) ==
(user->na ? user->na->nc : NULL))
nc_changed = 0;
if (!nc_changed && (user->na))
user->na->status |= status;
else {
#if !defined(IRC_BAHAMUT) && !defined(IRC_PTLINK)
/* Because on Bahamut it would be already -r */
change_user_mode(user, "-r+d", "1");
#else
change_user_mode(user, "+d", "1");
#endif
}
}
if (!is_oper(user) && check_sqline(user->nick, 1))
return NULL;
} /* if (!*source) */
if (nc_changed || !nick_recognized(user)) {
if (validate_user(user))
check_memos(user);
} else {
if (nick_identified(user)) {
user->na->last_seen = time(NULL);
if (user->na->last_usermask)
free(user->na->last_usermask);
user->na->last_usermask =
smalloc(strlen(GetIdent(user)) + strlen(GetHost(user)) +
2);
sprintf(user->na->last_usermask, "%s@%s", GetIdent(user),
GetHost(user));
#ifdef IRC_PTLINK
change_user_mode(user, "+r", NULL);
#endif
#if !defined(IRC_BAHAMUT) && !defined(IRC_PTLINK)
if (user->svid != user->timestamp) {
char tsbuf[16];
snprintf(tsbuf, sizeof(tsbuf), "%lu", user->timestamp);
change_user_mode(user, "+rd", tsbuf);
} else {
change_user_mode(user, "+r", NULL);
}
#endif
alog("%s: %s!%s@%s automatically identified for nick %s",
s_NickServ, user->nick, user->username, GetHost(user),
user->nick);
}
}
/* Bahamut sets -r on every nick changes, so we must test it even if nc_changed == 0 */
#ifdef IRC_BAHAMUT
if (nick_identified(user)) {
if (user->svid != user->timestamp) {
char tsbuf[16];
snprintf(tsbuf, sizeof(tsbuf), "%lu", user->timestamp);
change_user_mode(user, "+rd", tsbuf);
} else {
change_user_mode(user, "+r", NULL);
}
}
#endif
return user;
}
/*************************************************************************/
/* Handle a MODE command for a user.
* av[0] = nick to change mode for
* av[1] = modes
*/
void do_umode(const char *source, int ac, char **av)
{
User *user;
if (stricmp(source, av[0]) != 0) {
alog("user: MODE %s %s from different nick %s!", av[0], av[1],
source);
wallops(NULL, "%s attempted to change mode %s for %s", source,
av[1], av[0]);
return;
}
user = finduser(source);
if (!user) {
alog("user: MODE %s for nonexistent nick %s: %s", av[1], source,
merge_args(ac, av));
return;
}
set_umode(user, ac - 1, &av[1]);
}
/*************************************************************************/
/* Handle a QUIT command.
* av[0] = reason
*/
void do_quit(const char *source, int ac, char **av)
{
User *user;
NickAlias *na;
user = finduser(source);
if (!user) {
alog("user: QUIT from nonexistent user %s: %s", source,
merge_args(ac, av));
return;
}
if (debug)
alog("debug: %s quits", source);
if ((na = user->na) && (!(na->status & NS_VERBOTEN))
&& (na->status & (NS_IDENTIFIED | NS_RECOGNIZED))) {
na->last_seen = time(NULL);
if (na->last_quit)
free(na->last_quit);
na->last_quit = *av[0] ? sstrdup(av[0]) : NULL;
}
#ifndef STREAMLINED
if (LimitSessions)
del_session(user->host);
#endif
delete_user(user);
}
/*************************************************************************/
/* Handle a KILL command.
* av[0] = nick being killed
* av[1] = reason
*/
void do_kill(const char *source, int ac, char **av)
{
User *user;
NickAlias *na;
user = finduser(av[0]);
if (!user)
return;
if (debug)
alog("debug: %s killed", av[0]);
if ((na = user->na) && (!(na->status & NS_VERBOTEN))
&& (na->status & (NS_IDENTIFIED | NS_RECOGNIZED))) {
na->last_seen = time(NULL);
if (na->last_quit)
free(na->last_quit);
na->last_quit = *av[1] ? sstrdup(av[1]) : NULL;
}
#ifndef STREAMLINED
if (LimitSessions)
del_session(user->host);
#endif
delete_user(user);
}
/*************************************************************************/
/*************************************************************************/
#if defined(IRC_ULTIMATE) || defined(IRC_ULTIMATE3)
/* Is the given user protected from kicks and negative mode changes? */
int is_protected(User * user)
{
return (user->mode & UMODE_p);
}
#endif
/*************************************************************************/
/* Is the given nick an oper? */
int is_oper(User * user)
{
return (user->mode & UMODE_o);
}
/*************************************************************************/
/*************************************************************************/
#if defined (IRC_ULTIMATE) || defined(IRC_ULTIMATE3) || defined(IRC_UNREAL) || defined(IRC_VIAGRA) || defined(IRC_HYBRID)
/* Is the given user ban-excepted? */
int is_excepted(ChannelInfo * ci, User * user)
{
int count, i;
int isexcepted = 0;
char **excepts;
if (!ci->c)
return 0;
count = ci->c->exceptcount;
excepts = scalloc(sizeof(char *) * count, 1);
memcpy(excepts, ci->c->excepts, sizeof(char *) * count);
for (i = 0; i < count; i++) {
if (match_usermask(excepts[i], user)) {
isexcepted = 1;
}
}
free(excepts);
return isexcepted;
}
/*************************************************************************/
/* Is the given MASK ban-excepted? */
int is_excepted_mask(ChannelInfo * ci, char *mask)
{
int count, i;
int isexcepted = 0;
char **excepts;
if (!ci->c)
return 0;
count = ci->c->exceptcount;
excepts = scalloc(sizeof(char *) * count, 1);
memcpy(excepts, ci->c->excepts, sizeof(char *) * count);
for (i = 0; i < count; i++) {
if (match_wild_nocase(excepts[i], mask)) {
isexcepted = 1;
}
}
free(excepts);
return isexcepted;
}
#endif
/*************************************************************************/
/* Does the user's usermask match the given mask (either nick!user@host or
* just user@host)?
*/
int match_usermask(const char *mask, User * user)
{
char *mask2 = sstrdup(mask);
char *nick, *username, *host;
int result;
if (strchr(mask2, '!')) {
nick = strtok(mask2, "!");
username = strtok(NULL, "@");
} else {
nick = NULL;
username = strtok(mask2, "@");
}
host = strtok(NULL, "");
if (!username || !host) {
free(mask2);
return 0;
}
if (nick) {
result = match_wild_nocase(nick, user->nick)
&& match_wild_nocase(username, user->username)
&& (match_wild_nocase(host, user->host)
#ifdef HAS_VHOST
|| match_wild_nocase(host, user->vhost)
#endif
);
} else {
result = match_wild_nocase(username, user->username)
&& (match_wild_nocase(host, user->host)
#ifdef HAS_VHOST
|| match_wild_nocase(host, user->vhost)
#endif
);
}
free(mask2);
return result;
}
/*************************************************************************/
/* Split a usermask up into its constitutent parts. Returned strings are
* malloc()'d, and should be free()'d when done with. Returns "*" for
* missing parts.
*/
void split_usermask(const char *mask, char **nick, char **user,
char **host)
{
char *mask2 = sstrdup(mask);
*nick = strtok(mask2, "!");
*user = strtok(NULL, "@");
*host = strtok(NULL, "");
/* Handle special case: mask == user@host */
if (*nick && !*user && strchr(*nick, '@')) {
*nick = NULL;
*user = strtok(mask2, "@");
*host = strtok(NULL, "");
}
if (!*nick)
*nick = "*";
if (!*user)
*user = "*";
if (!*host)
*host = "*";
*nick = sstrdup(*nick);
*user = sstrdup(*user);
*host = sstrdup(*host);
free(mask2);
}
/*************************************************************************/
/* Given a user, return a mask that will most likely match any address the
* user will have from that location. For IP addresses, wildcards the
* appropriate subnet mask (e.g. 35.1.1.1 -> 35.*; 128.2.1.1 -> 128.2.*);
* for named addresses, wildcards the leftmost part of the name unless the
* name only contains two parts. If the username begins with a ~, delete
* it. The returned character string is malloc'd and should be free'd
* when done with.
*/
char *create_mask(User * u)
{
char *mask, *s, *end;
int ulen = strlen(GetIdent(u));
/* Get us a buffer the size of the username plus hostname. The result
* will never be longer than this (and will often be shorter), thus we
* can use strcpy() and sprintf() safely.
*/
end = mask = smalloc(ulen + strlen(GetHost(u)) + 3);
end += sprintf(end, "%s%s@",
(ulen <
(*(GetIdent(u)) ==
'~' ? USERMAX + 1 : USERMAX) ? "*" : ""),
(*(GetIdent(u)) ==
'~' ? GetIdent(u) + 1 : GetIdent(u)));
if (strspn(GetHost(u), "0123456789.") == strlen(GetHost(u))
&& (s = strchr(GetHost(u), '.'))
&& (s = strchr(s + 1, '.'))
&& (s = strchr(s + 1, '.'))
&& (!strchr(s + 1, '.'))) { /* IP addr */
s = sstrdup(GetHost(u));
*strrchr(s, '.') = 0;
sprintf(end, "%s.*", s);
free(s);
} else {
if ((s = strchr(GetHost(u), '.')) && strchr(s + 1, '.')) {
s = sstrdup(strchr(GetHost(u), '.') - 1);
*s = '*';
strcpy(end, s);
free(s);
} else {
strcpy(end, GetHost(u));
}
}
return mask;
}
/*************************************************************************/
syntax highlighted by Code2HTML, v. 0.9.1