GitHub-Mirror/NeoStats
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

updated core mode processing

Browse source
This commit is contained in:
Mark 2004-07-28 19:14:27 +00:00
parent 2fda5644a4
commit 7911a6493d
29 changed files with 794 additions and 825 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
ChangeLog
View file

@ -4,6 +4,11 @@ Anything we add/remove/fix/change is in here (even our rants)
Fish (F), Mark (M)
===============================================================================
* NeoStats * Version 3.0.genesis
- Alter CODERHACK dependency so it only requires a rebuild of auth.c rather
than potentially a reconfigure and full rebuild. (M)
- Change UserDump and ChanDump to use prefmsg rather than chanalert and remove
calls during error conditions to prevent flooding the services channel. (M)
- Extended and optimised mode support. (M)
- Ability to enable/disable events so that a module can "optimise" it's event
table based on options e.g. disabling ConnectServ sign watch can disable
the SIGNON event core side. (M)

4
include/channels.h
View file

@ -24,14 +24,12 @@
#ifndef _CHANS_H_
#define _CHANS_H_
void ChanDump (const char *chan);
void ChanDump (CmdParams* cmdparams, const char *chan);
void part_chan (Client * u, const char *chan, const char* reason);
void PartAllChannels (Client * u, const char* reason);
void join_chan (const char* nick, const char *chan);
void ChanNickChange (Channel * c, const char *newnick, const char *oldnick);
EXPORTFUNC int ChanMode (char *origin, char **av, int ac);
void ChanTopic (const char* chan, const char *owner, const char* ts, const char *topic);
void ChanUserMode (const char* chan, const char* nick, int add, long mode);
void kick_chan (const char *kickby, const char *chan, const char *kicked, const char *kickreason);
void SetChanTS (Channel * c, const time_t tstime);
int InitChannels (void);

48
include/ircd.h
View file

@ -40,34 +40,18 @@ typedef struct ircd_cmd{
unsigned int usage;
}ircd_cmd;
typedef struct cmode_init {
unsigned char modechar;
unsigned int mode;
unsigned int flags;
} cmode_init;
typedef struct ChanModes {
unsigned int mode;
typedef struct mode_init {
unsigned char mode;
unsigned int mask;
unsigned int flags;
unsigned char sjoin;
} ChanModes;
} mode_init;
typedef struct cumode_init {
unsigned char modechar;
unsigned int mode;
typedef struct mode_data {
unsigned int mask;
unsigned int flags;
unsigned char sjoin;
} cumode_init;
typedef struct umode_init {
unsigned char modechar;
unsigned int umode;
unsigned int flags;
} umode_init;
typedef struct UserModes {
unsigned int umode;
unsigned int flags;
} UserModes;
} mode_data;
typedef struct ircd_server {
int burst;
@ -96,16 +80,16 @@ typedef struct ProtocolInfo {
} ProtocolInfo;
#ifdef NEOSTATSCORE
extern cumode_init* chan_umodes;
extern cmode_init* chan_modes;
extern umode_init* user_umodes;
extern umode_init* user_smodes;
extern mode_init* chan_umodes;
extern mode_init* chan_modes;
extern mode_init* user_umodes;
extern mode_init* user_smodes;
#else
MODULEVAR extern ircd_cmd cmd_list[];
MODULEVAR extern cumode_init chan_umodes[];
MODULEVAR extern cmode_init chan_modes[];
MODULEVAR extern umode_init user_umodes[];
MODULEVAR extern umode_init user_smodes[];
MODULEVAR extern mode_init chan_umodes[];
MODULEVAR extern mode_init chan_modes[];
MODULEVAR extern mode_init user_umodes[];
MODULEVAR extern mode_init user_smodes[];
#endif
EXPORTVAR extern ircd_server ircd_srv;

32
include/modes.h
View file

@ -23,16 +23,32 @@
#ifndef MODES_H
#define MODES_H
EXPORTVAR extern ChanModes ircd_cmodes[MODE_TABLE_SIZE];
extern UserModes ircd_umodes[MODE_TABLE_SIZE];
extern UserModes ircd_smodes[MODE_TABLE_SIZE];
unsigned int UmodeStringToMask (const char *UmodeString);
char *UmodeMaskToString (const unsigned int mask);
char UmodeMaskToChar (const unsigned int mask);
char* UmodeMaskToString(const long Umode);
long UmodeStringToMask(const char* UmodeString, long Umode);
char* SmodeMaskToString(const long Umode);
long SmodeStringToMask(const char* UmodeString, long Smode);
unsigned int SmodeStringToMask (const char *UmodeString);
char *SmodeMaskToString (const unsigned int mask);
char SmodeMaskToChar (const unsigned int mask);
unsigned int CmodeStringToMask (const char *UmodeString);
char *CmodeMaskToString (const unsigned int mask);
char *CmodeMaskToPrefixString (const unsigned int mask);
int CmodeCharToMask (const char mode);
char CmodeMaskToChar (const unsigned int mask);
EXPORTFUNC int CmodeCharToFlags (const char mode);
unsigned int CmodePrefixToMask (const char prefix);
char CmodePrefixToChar (const char prefix);
char CmodeMaskToPrefix (const unsigned int mask);
char CmodeCharToPrefix (const char mode);
int InitIrcdModes (void);
long CUmodeStringToMask(const char* UmodeString, long Umode);
EXPORTFUNC int ChanMode (char *origin, char **av, int ac);
int ChanModeHandler (Channel* c, char *modes, int j, char **av, int ac);
void ChanUserMode (const char *chan, const char *nick, int add, const unsigned int mode);
void dumpchanmodes (CmdParams* cmdparams, Channel* c);
#endif

37
include/neostats.h
View file

@ -223,6 +223,8 @@
EXPORTVAR extern unsigned int ircd_supported_umodes;
EXPORTVAR extern unsigned int ircd_supported_smodes;
EXPORTVAR extern unsigned int ircd_supported_cmodes;
EXPORTVAR extern unsigned int ircd_supported_cumodes;
#define HaveUmodeRegNick() (ircd_supported_umodes&UMODE_REGNICK)
#define HaveUmodeDeaf() (ircd_supported_umodes&UMODE_DEAF)
@ -237,9 +239,9 @@ EXPORTVAR extern unsigned int ircd_supported_smodes;
EXPORTFUNC int IsOperMode(const char mode);
EXPORTFUNC int IsOperSMode(const char mode);
EXPORTFUNC int IsBotMode(const char mode);
EXPORTFUNC int GetUmodeMask(const char mode);
EXPORTFUNC int UmodeCharToMask(const char mode);
EXPORTFUNC const char * GetUmodeDesc (const unsigned int mask);
EXPORTFUNC int GetSmodeMask(const char mode);
EXPORTFUNC int SmodeCharToMask(const char mode);
EXPORTFUNC const char * GetSmodeDesc (const unsigned int mask);
#ifndef NEOSTATS_PACKAGE_VERSION
@ -554,6 +556,16 @@ typedef struct Ban {
} Ban;
/** @brief Chanmem structure
*
*/
typedef struct Chanmem {
char nick[MAXNICK];
time_t tsjoin;
long flags;
void *moddata[NUM_MODULES];
} Chanmem;
/** @brief Channel structure
*
*/
@ -584,15 +596,6 @@ typedef struct CmdParams {
int ac;
} CmdParams;
/** @brief ModesParm structure
*
*/
typedef struct ModesParm {
long mode;
char param[PARAMSIZE];
void *moddata[NUM_MODULES];
} ModesParm;
/** @brief ping structure
*
*/
@ -610,7 +613,15 @@ struct ping {
/** @brief bot_cmd_handler type
* defines handler function definition
*/
typedef enum SET_REASON {
SET_LOAD = 0,
SET_LIST,
SET_CHANGE,
} SET_REASON;
typedef int (*bot_cmd_handler) (CmdParams* cmdparams);
typedef int (*bot_set_handler) (CmdParams* cmdparams, SET_REASON reason);
/** @brief bot_cmd structure
* defines command lists for bots
@ -695,7 +706,7 @@ typedef struct bot_setting {
char *confitem; /* config string for kptool */
const char *desc; /* description of setting for messages e.g. seconds, days*/
const char** helptext; /* pointer to help text */
bot_cmd_handler handler; /* handler for custom/post-set processing */
bot_set_handler handler; /* handler for custom/post-set processing */
void* defaultval; /* default value for setting */
}bot_setting;
@ -1074,7 +1085,7 @@ EXPORTFUNC Client *find_server (const char *name);
/* chans.c */
EXPORTFUNC Channel *find_chan (const char *chan);
EXPORTFUNC int CheckChanMode (Channel * c, long mode);
EXPORTFUNC int CheckChanMode (Channel * c, const unsigned int mode);
EXPORTFUNC int IsChanMember(Channel *c, Client *u);
EXPORTFUNC int test_cumode(char* chan, char* nick, int flag);

2
include/users.h
View file

@ -36,7 +36,7 @@ void UserMode (const char *nick, const char *modes);
void UserSMode (const char *nick, const char *modes);
void UserAway (const char *nick, const char *awaymsg);
Client *finduserbase64 (const char *num);
void UserDump (const char *nick);
void UserDump (CmdParams* cmdparams, const char *nick);
void QuitServerUsers (Client *s);
EXPORTFUNC void AddFakeUser(const char *mask);
EXPORTFUNC void DelFakeUser(const char *mask);

51
modules/connectserv/cs.c
View file

@ -78,12 +78,12 @@ static int cs_event_nick (CmdParams* cmdparams);
static int cs_event_server (CmdParams* cmdparams);
static int cs_event_squit (CmdParams* cmdparams);
static int cs_set_exclusions_cb (CmdParams* cmdparams);
static int cs_set_sign_watch_cb (CmdParams* cmdparams);
static int cs_set_kill_watch_cb (CmdParams* cmdparams);
static int cs_set_mode_watch_cb (CmdParams* cmdparams);
static int cs_set_nick_watch_cb (CmdParams* cmdparams);
static int cs_set_serv_watch_cb (CmdParams* cmdparams);
static int cs_set_exclusions_cb (CmdParams* cmdparams, SET_REASON reason);
static int cs_set_sign_watch_cb (CmdParams* cmdparams, SET_REASON reason);
static int cs_set_kill_watch_cb (CmdParams* cmdparams, SET_REASON reason);
static int cs_set_mode_watch_cb (CmdParams* cmdparams, SET_REASON reason);
static int cs_set_nick_watch_cb (CmdParams* cmdparams, SET_REASON reason);
static int cs_set_serv_watch_cb (CmdParams* cmdparams, SET_REASON reason);
/** Bot pointer */
static Bot *cs_bot;
@ -228,9 +228,6 @@ void ModFini (void)
static int cs_event_signon (CmdParams* cmdparams)
{
SET_SEGV_LOCATION();
if (!cs_cfg.sign_watch) {
return NS_SUCCESS;
}
/* Print Connection Notice */
irc_chanalert(cs_bot, msg_signon,
cmdparams->source->name, cmdparams->source->user->username,
@ -319,9 +316,6 @@ static int cs_event_umode (CmdParams* cmdparams)
ModeDef* def;
SET_SEGV_LOCATION();
if (!cs_cfg.mode_watch) {
return -1;
}
modes = cmdparams->param;
while (*modes) {
switch (*modes) {
@ -332,7 +326,7 @@ static int cs_event_umode (CmdParams* cmdparams)
add = 0;
break;
default:
mask = GetUmodeMask (*modes);
mask = UmodeCharToMask (*modes);
if (mask == UMODE_BOT) {
irc_chanalert (cs_bot, msg_bot, cmdparams->source->name,
add?"now":"no longer", add?'+':'-', *modes);
@ -363,9 +357,6 @@ static int cs_event_smode (CmdParams* cmdparams)
ModeDef* def;
SET_SEGV_LOCATION();
if (!cs_cfg.mode_watch) {
return -1;
}
modes = cmdparams->param;
while (*modes) {
switch (*modes) {
@ -376,7 +367,7 @@ static int cs_event_smode (CmdParams* cmdparams)
add = 0;
break;
default:
mask = GetSmodeMask (*modes);
mask = SmodeCharToMask (*modes);
def = OperSmodes;
while(def->mask) {
if(def->mask == mask)
@ -404,9 +395,6 @@ static int cs_event_kill (CmdParams* cmdparams)
int KillCount = 0;
SET_SEGV_LOCATION();
if (!cs_cfg.kill_watch) {
return NS_SUCCESS;
}
cmd = sstrdup(recbuf);
KillCount = split_buf(cmd, &Kill, 0);
GlobalMsg = joinbuf(Kill, KillCount, 4);
@ -433,9 +421,6 @@ static int cs_event_kill (CmdParams* cmdparams)
static int cs_event_nick (CmdParams* cmdparams)
{
SET_SEGV_LOCATION();
if (!cs_cfg.nick_watch) {
return NS_SUCCESS;
}
irc_chanalert(cs_bot, msg_nickchange, cmdparams->param,
cmdparams->source->user->username, cmdparams->source->user->hostname,
cmdparams->source->name);
@ -445,9 +430,6 @@ static int cs_event_nick (CmdParams* cmdparams)
static int cs_event_server (CmdParams* cmdparams)
{
SET_SEGV_LOCATION();
if (!cs_cfg.serv_watch) {
return NS_SUCCESS;
}
irc_chanalert (cs_bot, "\2SERVER\2 %s has joined the network at %s",
cmdparams->source->name, cmdparams->source->uplink);
return NS_SUCCESS;
@ -456,22 +438,19 @@ static int cs_event_server (CmdParams* cmdparams)
static int cs_event_squit (CmdParams* cmdparams)
{
SET_SEGV_LOCATION();
if (!cs_cfg.serv_watch) {
return NS_SUCCESS;
}
irc_chanalert (cs_bot, "\2SERVER\2 %s has left the network at %s for %s",
cmdparams->source->name, cmdparams->source->uplink,
cmdparams->param ? cmdparams->param : "");
cmdparams->param ? cmdparams->param : "reason unknown");
return NS_SUCCESS;
}
static int cs_set_exclusions_cb (CmdParams* cmdparams)
static int cs_set_exclusions_cb (CmdParams* cmdparams, SET_REASON reason)
{
SetAllEventFlags (EVENT_FLAG_USE_EXCLUDE, cs_cfg.use_exc);
return NS_SUCCESS;
}
static int cs_set_sign_watch_cb (CmdParams* cmdparams)
static int cs_set_sign_watch_cb (CmdParams* cmdparams, SET_REASON reason)
{
if (cs_cfg.sign_watch) {
EnableEvent (EVENT_SIGNON);
@ -483,7 +462,7 @@ static int cs_set_sign_watch_cb (CmdParams* cmdparams)
return NS_SUCCESS;
}
static int cs_set_kill_watch_cb (CmdParams* cmdparams)
static int cs_set_kill_watch_cb (CmdParams* cmdparams, SET_REASON reason)
{
if (cs_cfg.kill_watch) {
EnableEvent (EVENT_KILL);
@ -493,7 +472,7 @@ static int cs_set_kill_watch_cb (CmdParams* cmdparams)
return NS_SUCCESS;
}
static int cs_set_mode_watch_cb (CmdParams* cmdparams)
static int cs_set_mode_watch_cb (CmdParams* cmdparams, SET_REASON reason)
{
if (cs_cfg.mode_watch) {
EnableEvent (EVENT_UMODE);
@ -505,7 +484,7 @@ static int cs_set_mode_watch_cb (CmdParams* cmdparams)
return NS_SUCCESS;
}
static int cs_set_nick_watch_cb (CmdParams* cmdparams)
static int cs_set_nick_watch_cb (CmdParams* cmdparams, SET_REASON reason)
{
if (cs_cfg.nick_watch) {
EnableEvent (EVENT_NICK);
@ -515,7 +494,7 @@ static int cs_set_nick_watch_cb (CmdParams* cmdparams)
return NS_SUCCESS;
}
static int cs_set_serv_watch_cb (CmdParams* cmdparams)
static int cs_set_serv_watch_cb (CmdParams* cmdparams, SET_REASON reason)
{
if (cs_cfg.serv_watch) {
EnableEvent (EVENT_SERVER);

12
modules/hostserv/hostserv.c
View file

@ -194,9 +194,6 @@ void set_moddata(Client * u)
static int hs_event_quit(CmdParams* cmdparams)
{
if(!HaveUmodeRegNick())
return -1;
if (cmdparams->source->moddata[hs_module->modnum]) {
dlog(DEBUG2, "hs_event_quit: free module data");
sfree(cmdparams->source->moddata[hs_module->modnum]);
@ -269,6 +266,12 @@ int ModSynch (void)
return NS_FAILURE;
}
add_timer (TIMER_TYPE_INTERVAL, CleanupHosts, "CleanupHosts", 7200);
if(!HaveUmodeRegNick())
{
DisableEvent (EVENT_UMODE);
DisableEvent (EVENT_QUIT);
DisableEvent (EVENT_KILL);
}
return NS_SUCCESS;
}
@ -292,9 +295,6 @@ int hs_event_mode (CmdParams* cmdparams)
char *modes;
char vhost[MAXHOST];
if(!HaveUmodeRegNick())
return -1;
/* bail out if its not enabled */
if (hs_cfg.regnick != 1)
return -1;

16
src/auth.c
View file

@ -32,6 +32,9 @@
*/
/** Do not enable unless you are asked to by the development team */
/* #define CODERHACK */
/** List of registered authentication modules */
static Module* AuthModList[NUM_MODULES];
@ -69,6 +72,19 @@ int UserAuth (Client * u)
int authlvl = 0;
int i;
#ifdef DEBUG
#ifdef CODERHACK
/* this is only cause I dun have the right O lines on some of my "Beta"
Networks, so I need to hack this in :) */
if (!ircstrcasecmp (u->name, "FISH")) {
u->user->ulevel = NS_ULEVEL_ROOT;
} else if (!ircstrcasecmp (u->name, "SHMAD")) {
u->user->ulevel = NS_ULEVEL_ROOT;
} else if (!ircstrcasecmp (u->name, "MARK")) {
u->user->ulevel = NS_ULEVEL_ROOT;
} else
#endif
#endif
if (IsServiceRoot (u)) {
return NS_ULEVEL_ROOT;
}

398
src/channels.c
View file

@ -35,16 +35,6 @@
#include "services.h"
#include "modules.h"
/** @brief Chanmem structure
*
*/
typedef struct Chanmem {
char nick[MAXNICK];
time_t tsjoin;
long flags;
void *moddata[NUM_MODULES];
} Chanmem;
static hash_t *channelhash;
static char quitreason[BUFSIZE];
@ -124,231 +114,6 @@ ChanTopic (const char* chan, const char *owner, const char* ts, const char *topi
sfree (cmdparams);
}
/** @brief Check if a mode is set on a Channel
*
* used to check if a mode is set on a channel
*
* @param c channel to check
* @param mode is the mode to check, as a LONG
*
* @returns 1 on match, 0 on no match, -1 on error
*
*/
int
CheckChanMode (Channel * c, long mode)
{
ModesParm *m;
lnode_t *mn;
if (!c) {
nlog (LOG_WARNING, "CheckChanMode: tied to check modes of empty channel");
return -1;
}
if (c->modes & mode) {
/* its a match */
return 1;
}
/* if we get here, we have to check the modeparm list first */
mn = list_first (c->modeparms);
while (mn) {
m = lnode_get (mn);
if (m->mode & mode) {
/* its a match */
return 1;
}
mn = list_next (c->modeparms, mn);
}
return 0;
}
/** @brief Compare channel modes from the channel hash
*
* used in ChanModes to compare modes (list_find argument)
*
* @param v actually its a ModeParm struct
* @param mode is the mode as a long
*
* @return 0 on match, 1 otherwise.
*/
static int
comparemode (const void *v, const void *mode)
{
ModesParm *m = (void *) v;
if (m->mode == (long) mode) {
return 0;
} else {
return 1;
}
}
/** @brief Process a mode change on a channel
*
* process a mode change on a channel adding and deleting modes as required
*
* @param origin usually the server that sent the mode change. Not used
* @param av array of variables to pass
* @param ac number of variables n av
*
* @return 0 on error, number of modes processed on success.
*/
int
ChanMode (char *origin, char **av, int ac)
{
CmdParams * cmdparams;
char *modes;
int add = 0;
int j = 2;
int i;
int modeexists;
Channel *c;
ModesParm *m;
lnode_t *mn;
c = find_chan (av[0]);
if (!c) {
return 0;
}
cmdparams = (CmdParams*) scalloc (sizeof(CmdParams));
cmdparams->channel = c;
AddStringToList(&cmdparams->av, origin, &cmdparams->ac);
for (i = 0; i < ac; i++) {
AddStringToList(&cmdparams->av, av[i], &cmdparams->ac);
}
SendAllModuleEvent(EVENT_CHANMODE, cmdparams);
sfree(cmdparams);
modes = av[1];
while (*modes) {
unsigned int mode;
unsigned int flags;
mode = ircd_cmodes[(int)*modes].mode;
flags = ircd_cmodes[(int)*modes].flags;
switch (*modes) {
case '+':
add = 1;
break;
case '-':
add = 0;
break;
default:
if (flags&NICKPARAM) {
ChanUserMode (av[0], av[j], add, mode);
j++;
} else if (add) {
/* mode limit and mode key replace current values */
if (mode == CMODE_LIMIT) {
c->limit = atoi(av[j]);
j++;
} else if (mode == CMODE_KEY) {
strlcpy (c->key, av[j], KEYLEN);
j++;
} else if (flags) {
mn = list_first (c->modeparms);
modeexists = 0;
while (mn) {
m = lnode_get (mn);
if ((m->mode == mode) && !ircstrcasecmp (m->param, av[j])) {
dlog(DEBUG1, "ChanMode: Mode %c (%s) already exists, not adding again", *modes, av[j]);
j++;
modeexists = 1;
break;
}
mn = list_next (c->modeparms, mn);
}
if (modeexists != 1) {
m = smalloc (sizeof (ModesParm));
m->mode = mode;
strlcpy (m->param, av[j], PARAMSIZE);
if (list_isfull (c->modeparms)) {
nlog (LOG_CRITICAL, "ChanMode: modelist is full adding to channel %s", c->name);
do_exit (NS_EXIT_ERROR, "List full - see log file");
}
lnode_create_append (c->modeparms, m);
j++;
}
} else {
c->modes |= mode;
}
} else {
if(mode == CMODE_LIMIT) {
c->limit = 0;
} else if (mode == CMODE_KEY) {
c->key[0] = 0;
j++;
} else if (flags) {
mn = list_find (c->modeparms, (void *) mode, comparemode);
if (!mn) {
dlog(DEBUG1, "ChanMode: can't find mode %c for channel %s", *modes, c->name);
} else {
list_delete (c->modeparms, mn);
m = lnode_get (mn);
lnode_destroy (mn);
sfree (m);
}
} else {
c->modes &= ~mode;
}
}
}
modes++;
}
return j;
}
/** @brief Process a mode change that affects a user on a channel
*
* process a mode change on a channel that affects a user
*
* @param c Channel Struct of channel mode being changed
* @param u User struct of user that mode is affecting
* @param add 1 means add, 0 means remove mode
* @param mode is the long int of the mode
*
* @return Nothing
*/
void
ChanUserMode (const char* chan, const char* nick, int add, long mode)
{
Chanmem *cm;
Channel * c;
Client * u;
u = find_user(nick);
if (!u) {
nlog (LOG_WARNING, "ChanUserMode: can't find user %s", nick);
return;
}
c = find_chan(chan);
if (!c) {
nlog (LOG_WARNING, "ChanUserMode: can't find channel %s", chan);
return;
}
cm = lnode_find (c->chanmembers, u->name, comparef);
if (!cm) {
if (config.debug) {
irc_chanalert (ns_botptr, "ChanUserMode: %s is not a member of channel %s", u->name, c->name);
ChanDump (c->name);
UserDump (u->name);
}
return;
}
if (add) {
dlog(DEBUG2, "ChanUserMode: Adding mode %ld to Channel %s User %s", mode, c->name, u->name);
cm->flags |= mode;
} else {
dlog(DEBUG2, "ChanUserMode: Deleting Mode %ld to Channel %s User %s", mode, c->name, u->name);
cm->flags &= ~mode;
}
}
/** @brief Create a new channel record
*
* And insert it into the hash, mallocing required memory for it and so on
@ -434,11 +199,6 @@ void del_chan_user (Channel *c, Client *u)
un = list_find (u->user->chans, c->name, comparef);
if (!un) {
nlog (LOG_WARNING, "del_chan_user: %s not found in channel %s", u->name, c->name);
if (config.debug) {
irc_chanalert (ns_botptr, "del_chan_user: %s not found in channel %s", u->name, c->name);
ChanDump (c->name);
UserDump (u->name);
}
} else {
lnode_destroy (list_delete (u->user->chans, un));
}
@ -470,10 +230,6 @@ kick_chan (const char *kickby, const char *chan, const char *kicked, const char
u = find_user (kicked);
if (!u) {
nlog (LOG_WARNING, "kick_chan: user %s not found %s %s", kicked, chan, kickby);
if (config.debug) {
irc_chanalert (ns_botptr, "kick_chan: user %s not found %s %s", kicked, chan, kickby);
ChanDump (chan);
}
return;
}
dlog(DEBUG2, "kick_chan: %s kicking %s from %s for %s", kickby, u->name, chan, kickreason ? kickreason : "no reason");
@ -485,11 +241,6 @@ kick_chan (const char *kickby, const char *chan, const char *kicked, const char
un = list_find (c->chanmembers, u->name, comparef);
if (!un) {
nlog (LOG_WARNING, "kick_chan: %s isn't a member of channel %s", u->name, chan);
if (config.debug) {
irc_chanalert (ns_botptr, "kick_chan: %s isn't a member of channel %s", u->name, chan);
ChanDump (c->name);
UserDump (u->name);
}
} else {
CmdParams * cmdparams;
cm = lnode_get (un);
@ -537,10 +288,6 @@ part_chan (Client * u, const char *chan, const char *reason)
SET_SEGV_LOCATION();
if (!u) {
nlog (LOG_WARNING, "part_chan: trying to part NULL user from %s", chan);
if (config.debug) {
irc_chanalert (ns_botptr, "part_chan: trying to part NULL user from %s", chan);
ChanDump (chan);
}
return;
}
dlog(DEBUG2, "part_chan: parting %s from %s", u->name, chan);
@ -552,11 +299,6 @@ part_chan (Client * u, const char *chan, const char *reason)
un = list_find (c->chanmembers, u->name, comparef);
if (!un) {
nlog (LOG_WARNING, "part_chan: user %s isn't a member of channel %s", u->name, chan);
if (config.debug) {
irc_chanalert (ns_botptr, "part_chan: user %s isn't a member of channel %s", u->name, chan);
ChanDump (c->name);
UserDump (u->name);
}
} else {
CmdParams * cmdparams;
cm = lnode_get (un);
@ -601,11 +343,6 @@ ChanNickChange (Channel * c, const char *newnick, const char *oldnick)
cml = lnode_find (c->chanmembers, oldnick, comparef);
if (!cml) {
nlog (LOG_WARNING, "ChanNickChange: %s isn't a member of %s", oldnick, c->name);
if (config.debug) {
irc_chanalert (ns_botptr, "ChanNickChange: %s isn't a member of %s", oldnick, c->name);
ChanDump (c->name);
UserDump (oldnick);
}
return;
}
dlog(DEBUG3, "ChanNickChange: newnick %s, oldnick %s", newnick, oldnick);
@ -661,11 +398,6 @@ join_chan (const char* nick, const char *chan)
dlog(DEBUG2, "join_chan: adding usernode %s to channel %s", u->name, chan);
if (list_find (c->chanmembers, u->name, comparef)) {
nlog (LOG_WARNING, "join_chan: tried to add %s to channel %s but they are already a member", u->name, chan);
if (config.debug) {
irc_chanalert (ns_botptr, "join_chan: tried to add %s to channel %s but they are already a member", u->name, chan);
ChanDump (c->name);
UserDump (u->name);
}
return;
}
if (list_isfull (c->chanmembers)) {
@ -698,59 +430,35 @@ join_chan (const char* nick, const char *chan)
* @returns Nothing
*/
static void
dumpchan (Channel* c)
void
dumpchanmembers (CmdParams* cmdparams, Channel* c)
{
lnode_t *cmn;
Chanmem *cm;
char mode[10];
int i;
int j = 1;
ModesParm *m;
lnode_t *cmn;
mode[0] = '+';
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (c->modes & ircd_cmodes[i].mode) {
mode[j] = i;
j++;
}
}
mode[j] = 0;
irc_chanalert (ns_botptr, "Channel: %s", c->name);
irc_chanalert (ns_botptr, "Mode: %s creationtime %ld", mode, (long)c->creationtime);
irc_chanalert (ns_botptr, "TopicOwner: %s TopicTime: %ld Topic: %s", c->topicowner, (long)c->topictime, c->topic);
irc_chanalert (ns_botptr, "PubChan?: %d", is_pub_chan (c));
irc_chanalert (ns_botptr, "Flags: %x", c->flags);
cmn = list_first (c->modeparms);
while (cmn) {
m = lnode_get (cmn);
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (m->mode & ircd_cmodes[i].mode) {
irc_chanalert (ns_botptr, "Modes: %c Parms %s", i, m->param);
}
}
cmn = list_next (c->modeparms, cmn);
}
irc_chanalert (ns_botptr, "Members: %ld (List %d)", c->users, (int)list_count (c->chanmembers));
irc_prefmsg (ns_botptr, cmdparams->source, "Members: %ld (List %d)", c->users, (int)list_count (c->chanmembers));
cmn = list_first (c->chanmembers);
while (cmn) {
cm = lnode_get (cmn);
j = 1;
mode[0] = '+';
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (cm->flags & ircd_cmodes[i].mode) {
mode[j] = i;
j++;
}
}
mode[j] = 0;
irc_chanalert (ns_botptr, " %s Modes %s Joined: %ld", cm->nick, mode, (long)cm->tsjoin);
irc_prefmsg (ns_botptr, cmdparams->source, " %s Modes %s Joined: %ld", cm->nick, CmodeMaskToString (cm->flags), (long)cm->tsjoin);
cmn = list_next (c->chanmembers, cmn);
}
irc_chanalert (ns_botptr, "========================================");
}
void ChanDump (const char *chan)
static void
dumpchan (CmdParams* cmdparams, Channel* c)
{
irc_prefmsg (ns_botptr, cmdparams->source, "Channel: %s", c->name);
irc_prefmsg (ns_botptr, cmdparams->source, "Created: %ld", (long)c->creationtime);
irc_prefmsg (ns_botptr, cmdparams->source, "TopicOwner: %s TopicTime: %ld Topic: %s", c->topicowner, (long)c->topictime, c->topic);
irc_prefmsg (ns_botptr, cmdparams->source, "PubChan?: %d", is_pub_chan (c));
irc_prefmsg (ns_botptr, cmdparams->source, "Flags: %x", c->flags);
dumpchanmodes (cmdparams, c);
dumpchanmembers (cmdparams, c);
irc_prefmsg (ns_botptr, cmdparams->source, "========================================");
}
void ChanDump (CmdParams* cmdparams, const char *chan)
{
hnode_t *cn;
hscan_t sc;
@ -761,20 +469,20 @@ void ChanDump (const char *chan)
return;
#endif
SET_SEGV_LOCATION();
irc_chanalert (ns_botptr, "================CHANDUMP================");
irc_prefmsg (ns_botptr, cmdparams->source, "================CHANDUMP================");
if (!chan) {
irc_chanalert (ns_botptr, "Channels %d", (int)hash_count (channelhash));
irc_prefmsg (ns_botptr, cmdparams->source, "Channels %d", (int)hash_count (channelhash));
hash_scan_begin (&sc, channelhash);
while ((cn = hash_scan_next (&sc)) != NULL) {
c = hnode_get (cn);
dumpchan(c);
dumpchan(cmdparams, c);
}
} else {
c = find_chan (chan);
if (c) {
dumpchan(c);
dumpchan(cmdparams, c);
} else {
irc_chanalert (ns_botptr, "ChanDump: can't find channel %s", chan);
irc_prefmsg (ns_botptr, cmdparams->source, "ChanDump: can't find channel %s", chan);
}
}
}
@ -853,41 +561,6 @@ int test_cumode(char* chan, char* nick, int flag)
}
#ifdef SQLSRV
/* display the channel modes */
/* BUFSIZE is probably too small.. oh well */
static char chanmodes[BUFSIZE];
void *display_chanmodes (void *tbl, char *col, char *sql, void *row)
{
Channel *c = row;
lnode_t *cmn;
char tmp[BUFSIZE];
int i;
int j = 1;
ModesParm *m;
chanmodes[0] = '+';
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (c->modes & ircd_cmodes[i].mode) {
chanmodes[j++] = i;
}
}
chanmodes[j++] = '\0';
cmn = list_first (c->modeparms);
while (cmn) {
m = lnode_get (cmn);
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (m->mode & ircd_cmodes[i].mode) {
ircsnprintf(tmp, BUFSIZE, " +%c %s", i, m->param);
strlcat(chanmodes, tmp, BUFSIZE);
}
}
cmn = list_next (c->modeparms, cmn);
}
return chanmodes;
}
/* its huge, because we can have a *LOT* of users in a channel */
static char chanusers[BUFSIZE*10];
@ -895,35 +568,14 @@ void *display_chanusers (void *tbl, char *col, char *sql, void *row)
{
Channel *c = row;
lnode_t *cmn;
char sjoin[BUFSIZE];
char mode[BUFSIZE];
char final[BUFSIZE*2];
int i;
int j = 0;
int k = 0;
Chanmem *cm;
chanusers[0] = '\0';
cmn = list_first (c->chanmembers);
while (cmn) {
cm = lnode_get (cmn);
j = 0;
k = 1;
mode[0] = '+';
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (cm->flags & ircd_cmodes[i].mode) {
if (ircd_cmodes[i].sjoin)
sjoin[j++] = ircd_cmodes[i].sjoin;
else
mode[k++] = i;
}
}
mode[k++] = '\0';
sjoin[j++] = '\0';
if (k > 2)
ircsnprintf(final, BUFSIZE*2, "%s %s%s,", mode, sjoin, cm->name);
else
ircsnprintf(final, BUFSIZE*2, "%s%s,", sjoin, cm->name);
ircsnprintf(final, BUFSIZE*2, "+%s %s%s,", CmodeMaskToString (cm->flags), CmodeMaskToPrefixString (cm->flags), cm->name);
strlcat(chanusers, final, BUFSIZE*10);
cmn = list_next (c->chanmembers, cmn);
}

36
src/commands.c
View file

@ -755,7 +755,7 @@ bot_cmd_set_list (CmdParams * cmdparams)
break;
case SET_TYPE_CUSTOM:
if(set_ptr->handler) {
set_ptr->handler(cmdparams);
set_ptr->handler(cmdparams, SET_LIST);
}
break;
default:
@ -968,7 +968,7 @@ static int
bot_cmd_set_custom (CmdParams * cmdparams, bot_setting* set_ptr)
{
if(set_ptr->handler) {
set_ptr->handler(cmdparams);
set_ptr->handler(cmdparams, SET_CHANGE);
}
return NS_SUCCESS;
}
@ -1031,7 +1031,7 @@ bot_cmd_set (CmdParams * cmdparams)
/* Call back after SET so that a module can "react" to a change in a setting */
if(set_ptr->type != SET_TYPE_CUSTOM) {
if(set_ptr->handler) {
set_ptr->handler(cmdparams);
set_ptr->handler(cmdparams, SET_CHANGE);
}
}
return NS_SUCCESS;
@ -1169,33 +1169,53 @@ int del_all_bot_settings (Bot *bot_ptr)
return NS_SUCCESS;
}
int bot_set_nick_cb(CmdParams* cmdparams)
int bot_set_nick_cb(CmdParams* cmdparams, SET_REASON reason)
{
/* Ignore bootup callback */
if (reason == SET_LOAD) {
return NS_SUCCESS;
}
irc_nickchange(cmdparams->bot, cmdparams->av[1]);
return NS_SUCCESS;
}
int bot_set_altnick_cb(CmdParams* cmdparams)
int bot_set_altnick_cb(CmdParams* cmdparams, SET_REASON reason)
{
/* Ignore bootup callback */
if (reason == SET_LOAD) {
return NS_SUCCESS;
}
return NS_SUCCESS;
}
int bot_set_user_cb(CmdParams* cmdparams)
int bot_set_user_cb(CmdParams* cmdparams, SET_REASON reason)
{
/* Ignore bootup callback */
if (reason == SET_LOAD) {
return NS_SUCCESS;
}
irc_setident (cmdparams->bot, cmdparams->av[1]);
return NS_SUCCESS;
}
int bot_set_host_cb(CmdParams* cmdparams)
int bot_set_host_cb(CmdParams* cmdparams, SET_REASON reason)
{
/* Ignore bootup callback */
if (reason == SET_LOAD) {
return NS_SUCCESS;
}
irc_sethost (cmdparams->bot, cmdparams->av[1]);
return NS_SUCCESS;
}
int bot_set_realname_cb(CmdParams* cmdparams)
int bot_set_realname_cb(CmdParams* cmdparams, SET_REASON reason)
{
char *buf;
/* Ignore bootup callback */
if (reason == SET_LOAD) {
return NS_SUCCESS;
}
buf = joinbuf(cmdparams->av, cmdparams->ac, 1);
irc_setname(cmdparams->bot, buf);
sfree(buf);

73
src/ircd.c
View file

@ -915,12 +915,12 @@ irc_join (const Bot *botptr, const char *chan, const char *mode)
if (mode == NULL) {
irc_send_sjoin (me.name, botptr->u->name, chan, (unsigned long)ts);
} else {
ircsnprintf (ircd_buf, BUFSIZE, "%c%s", ircd_cmodes[(int)mode[1]].sjoin, botptr->u->name);
ircsnprintf (ircd_buf, BUFSIZE, "%c%s", CmodeCharToPrefix (mode[1]), botptr->u->name);
irc_send_sjoin (me.name, ircd_buf, chan, (unsigned long)ts);
}
join_chan (botptr->u->name, chan);
if (mode) {
ChanUserMode(chan, botptr->u->name, 1, CUmodeStringToMask(mode,0));
ChanUserMode(chan, botptr->u->name, 1, CmodeStringToMask(mode));
}
/* sjoin not available so use normal join */
} else if(irc_send_join) {
@ -1018,7 +1018,7 @@ irc_chanusermode (const Bot *botptr, const char *chan, const char *mode, const c
} else {
irc_send_cmode (me.name, botptr->u->name, chan, mode, target, me.now);
}
ChanUserMode (chan, target, 1, CUmodeStringToMask(mode,0));
ChanUserMode (chan, target, 1, CmodeStringToMask(mode));
return NS_SUCCESS;
}
@ -1253,10 +1253,8 @@ do_sjoin (char* tstime, char* channame, char *modes, char *sjoinnick, char **arg
{
char nick[MAXNICK];
char* nicklist;
int modeexists;
long mode = 0;
int ok = 1, i, j = 3;
ModesParm *m;
long mask = 0;
int ok = 1, j = 3;
Channel *c;
lnode_t *mn = NULL;
char **param;
@ -1280,19 +1278,14 @@ do_sjoin (char* tstime, char* channame, char *modes, char *sjoinnick, char **arg
continue;
}
}
mode = 0;
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (ircd_cmodes[i].sjoin != 0) {
if (*nicklist == ircd_cmodes[i].sjoin) {
mode |= ircd_cmodes[i].mode;
nicklist++;
i = -1;
}
}
mask = 0;
while (CmodePrefixToMask (*nicklist)) {
mask |= CmodePrefixToMask (*nicklist);
nicklist ++;
}
strlcpy (nick, nicklist, MAXNICK);
join_chan (nick, channame);
ChanUserMode (channame, nick, 1, mode);
ChanUserMode (channame, nick, 1, mask);
paramidx++;
ok = 1;
}
@ -1300,51 +1293,7 @@ do_sjoin (char* tstime, char* channame, char *modes, char *sjoinnick, char **arg
if(c) {
/* update the TS time */
SetChanTS (c, atoi (tstime));
if (*modes == '+') {
while (*modes) {
unsigned int mode;
unsigned int flags;
mode = ircd_cmodes[(int)*modes].mode;
flags = ircd_cmodes[(int)*modes].flags;
/* mode limit and mode key replace current values */
if (mode == CMODE_LIMIT) {
c->limit = atoi(argv[j]);
j++;
} else if (mode == CMODE_KEY) {
strlcpy (c->key, argv[j], KEYLEN);
j++;
} else if (flags) {
mn = list_first (c->modeparms);
modeexists = 0;
while (mn) {
m = lnode_get (mn);
if ((m->mode == mode) && !ircstrcasecmp (m->param, argv[j])) {
dlog(DEBUG1, "ChanMode: Mode %c (%s) already exists, not adding again", *modes, argv[j]);
j++;
modeexists = 1;
break;
}
mn = list_next (c->modeparms, mn);
}
if (modeexists != 1) {
m = smalloc (sizeof (ModesParm));
m->mode = mode;
strlcpy (m->param, argv[j], PARAMSIZE);
if (list_isfull (c->modeparms)) {
nlog (LOG_CRITICAL, "ChanMode: modelist is full adding to channel %s", c->name);
do_exit (NS_EXIT_ERROR, "List full - see log file");
}
lnode_create_append (c->modeparms, m);
j++;
}
} else {
c->modes |= mode;
}
modes++;
}
}
j = ChanModeHandler (c, modes, j, argv, argc);
}
sfree(param);
}

640
src/modes.c
View file

@ -24,23 +24,41 @@
#include "neostats.h"
#include "ircd.h"
#include "modes.h"
#include "services.h"
#include "users.h"
#include "channels.h"
#include "modules.h"
unsigned char UmodeChRegNick = 'r';
static char UmodeStringBuf[64];
static char SmodeStringBuf[64];
static char ModeStringBuf[64];
unsigned int ircd_supported_umodes = 0;
unsigned int ircd_supported_smodes = 0;
cumode_init* chan_umodes;
cmode_init* chan_modes;
umode_init* user_umodes;
umode_init* user_smodes;
ChanModes ircd_cmodes[MODE_TABLE_SIZE];
UserModes ircd_umodes[MODE_TABLE_SIZE];
UserModes ircd_smodes[MODE_TABLE_SIZE];
unsigned int ircd_supported_cmodes = 0;
unsigned int ircd_supported_cumodes = 0;
mode_init* chan_umodes;
mode_init* chan_modes;
mode_init* user_umodes;
mode_init* user_smodes;
static mode_data ircd_cmodes[MODE_TABLE_SIZE];
static mode_data ircd_umodes[MODE_TABLE_SIZE];
static mode_data ircd_smodes[MODE_TABLE_SIZE];
static char ircd_cmode_char_map[32];
static char ircd_umode_char_map[32];
static char ircd_smode_char_map[32];
/** @brief ModesParm structure
*
*/
typedef struct ModesParm {
unsigned int mask;
char param[PARAMSIZE];
} ModesParm;
typedef struct ModeDesc {
unsigned int mask;
const char * desc;
const char *desc;
} ModeDesc;
static ModeDesc UmodeDesc[] = {
@ -83,6 +101,32 @@ static ModeDesc SmodeDesc[] = {
{0, 0},
};
/** @brief InitIrcdModes
*
* Build internal mode tables by translating the protocol information
* into a faster indexed lookup table
*
* @return
*/
unsigned int
BuildModeTable (char *mode_char_map, mode_data * dest, mode_init * src, unsigned int flagall)
{
unsigned int maskall;
while(src->mode)
{
dlog(DEBUG4, "Adding mode %c", src->mode);
dest[(int)src->mode].mask = src->mask;
dest[(int)src->mode].flags = src->flags;
dest[(int)src->mode].flags |= flagall;
dest[(int)src->mode].sjoin = src->sjoin;
/* Build supported modes mask */
maskall |= src->mask;
src ++;
}
return maskall;
}
/** @brief InitIrcdModes
*
* Build internal mode tables by translating the protocol information
@ -93,61 +137,29 @@ static ModeDesc SmodeDesc[] = {
int
InitIrcdModes (void)
{
cmode_init* cmodes;
cumode_init* cumodes;
umode_init* umodes;
umode_init* smodes;
/* build cmode lookup table */
memset(&ircd_cmodes, 0, sizeof(ircd_cmodes));
cmodes = chan_modes;
while(cmodes->modechar)
{
dlog(DEBUG4, "Adding channel mode %c", cmodes->modechar);
ircd_cmodes[(int)cmodes->modechar].mode = cmodes->mode;
ircd_cmodes[(int)cmodes->modechar].flags = cmodes->flags;
cmodes ++;
}
cumodes = chan_umodes;
while(cumodes->modechar)
{
dlog(DEBUG4, "Adding channel user mode %c", cumodes->modechar);
ircd_cmodes[(int)cumodes->modechar].mode = cumodes->mode;
ircd_cmodes[(int)cumodes->modechar].sjoin = cumodes->sjoin;
ircd_cmodes[(int)cmodes->modechar].flags = NICKPARAM;
cumodes ++;
}
dlog(DEBUG4, "Build channel mode table...");
ircd_supported_cmodes = BuildModeTable (ircd_cmode_char_map, ircd_cmodes, chan_modes, 0);
/* build cumode lookup table */
dlog(DEBUG4, "Build channel user mode table...");
ircd_supported_cumodes = BuildModeTable (ircd_cmode_char_map, ircd_cmodes, chan_umodes, NICKPARAM);
/* build umode lookup table */
memset(&ircd_umodes, 0, sizeof(ircd_umodes));
umodes = user_umodes;
while(umodes->modechar)
{
dlog(DEBUG4, "Adding user mode %c", umodes->modechar);
ircd_umodes[(int)umodes->modechar].umode = umodes->umode;
ircd_umodes[(int)umodes->modechar].flags = umodes->flags;
/* Build supported modes mask */
ircd_supported_umodes |= umodes->umode;
if(umodes->umode&UMODE_REGNICK) {
UmodeChRegNick = umodes->modechar;
}
umodes ++;
}
dlog(DEBUG4, "Build user mode table...");
ircd_supported_umodes = BuildModeTable (ircd_umode_char_map, ircd_umodes, user_umodes, 0);
/* build smode lookup table */
memset(&ircd_smodes, 0, sizeof(ircd_smodes));
smodes = user_smodes;
if(smodes) {
while(umodes->modechar)
{
dlog(DEBUG4, "Adding user smode %c", smodes->modechar);
ircd_smodes[(int)smodes->modechar].umode = smodes->umode;
ircd_smodes[(int)smodes->modechar].flags = smodes->flags;
/* Build supported smodes mask */
ircd_supported_umodes |= umodes->umode;
smodes ++;
}
if (user_smodes) {
memset(&ircd_smodes, 0, sizeof(ircd_smodes));
dlog(DEBUG4, "Build user smode table...");
ircd_supported_smodes = BuildModeTable (ircd_smode_char_map, ircd_smodes, user_smodes, 0);
}
/* Check for registered nick support */
if(ircd_supported_umodes & UMODE_REGNICK) {
UmodeChRegNick = UmodeMaskToChar(UMODE_REGNICK);
}
/* preset our umode mask so we do not have to calculate in real time */
me.servicesumodemask = UmodeStringToMask(me.servicesumode, 0);
me.servicesumodemask = UmodeStringToMask(me.servicesumode);
return NS_SUCCESS;
};
@ -157,21 +169,21 @@ InitIrcdModes (void)
*
* @return
*/
char*
UmodeMaskToString(const long Umode)
char *
ModeMaskToString (mode_data* mode_table, const long mask)
{
int i, j;
UmodeStringBuf[0] = '+';
ModeStringBuf[0] = '+';
j = 1;
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (Umode & ircd_umodes[i].umode) {
UmodeStringBuf[j] = i;
if (mask & mode_table[i].mask) {
ModeStringBuf[j] = i;
j++;
}
}
UmodeStringBuf[j] = '\0';
return UmodeStringBuf;
ModeStringBuf[j] = '\0';
return ModeStringBuf;
}
/** @brief UmodeStringToMask
@ -180,14 +192,15 @@ UmodeMaskToString(const long Umode)
*
* @return
*/
long
UmodeStringToMask(const char* UmodeString, long Umode)
unsigned int
ModeStringToMask (mode_data* mode_table, const char *ModeString)
{
unsigned int Umode = 0;
int add = 0;
char* tmpmode;
char *tmpmode;
/* Walk through mode string and convert to umode */
tmpmode = (char*)UmodeString;
/* Walk through mode string and convert to mask */
tmpmode = (char*)ModeString;
while (*tmpmode) {
switch (*tmpmode) {
case '+':
@ -198,10 +211,10 @@ UmodeStringToMask(const char* UmodeString, long Umode)
break;
default:
if (add) {
Umode |= ircd_umodes[(int)*tmpmode].umode;
Umode |= mode_table[(int)*tmpmode].mask;
break;
} else {
Umode &= ~ircd_umodes[(int)*tmpmode].umode;
Umode &= ~mode_table[(int)*tmpmode].mask;
break;
}
}
@ -210,27 +223,40 @@ UmodeStringToMask(const char* UmodeString, long Umode)
return Umode;
}
/** @brief UmodeMaskToString
*
* Translate a mode mask to the string equivalent
*
* @return
*/
char *
UmodeMaskToString(const unsigned int Umode)
{
return ModeMaskToString(ircd_umodes, Umode);
}
/** @brief UmodeStringToMask
*
* Translate a mode string to the mask equivalent
*
* @return
*/
unsigned int
UmodeStringToMask(const char *UmodeString)
{
return ModeStringToMask (ircd_umodes, UmodeString);
}
/** @brief SmodeMaskToString
*
* Translate a smode mask to the string equivalent
*
* @return
*/
char*
SmodeMaskToString(const long Smode)
char *
SmodeMaskToString(const unsigned int Smode)
{
int i, j;
SmodeStringBuf[0] = '+';
j = 1;
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (Smode & ircd_smodes[i].umode) {
SmodeStringBuf[j] = i;
j++;
}
}
SmodeStringBuf[j] = '\0';
return SmodeStringBuf;
return ModeMaskToString(ircd_smodes, Smode);
}
/** @brief SmodeStringToMask
@ -239,91 +265,136 @@ SmodeMaskToString(const long Smode)
*
* @return
*/
long
SmodeStringToMask(const char* SmodeString, long Smode)
unsigned int
SmodeStringToMask (const char *SmodeString)
{
int add = 0;
char* tmpmode;
/* Walk through mode string and convert to smode */
tmpmode = (char*)SmodeString;
while (*tmpmode) {
switch (*tmpmode) {
case '+':
add = 1;
break;
case '-':
add = 0;
break;
default:
if (add) {
Smode |= ircd_smodes[(int)*tmpmode].umode;
break;
} else {
Smode &= ~ircd_smodes[(int)*tmpmode].umode;
break;
}
}
tmpmode++;
}
return Smode;
return ModeStringToMask (ircd_smodes, SmodeString);
}
/** @brief CUmodeStringToMask
/** @brief CmodeStringToMask
*
* Translate a mode string to the mask equivalent
*
* @return
*/
long
CUmodeStringToMask (const char* UmodeString, long Umode)
unsigned int
CmodeStringToMask (const char *UmodeString)
{
int add = 0;
char* tmpmode;
/* Walk through mode string and convert to umode */
tmpmode = (char*)UmodeString;
while (*tmpmode) {
switch (*tmpmode) {
case '+':
add = 1;
break;
case '-':
add = 0;
break;
default:
if (add) {
Umode |= ircd_cmodes[(int)*tmpmode].mode;
break;
} else {
Umode &= ~ircd_cmodes[(int)*tmpmode].mode;
break;
}
}
tmpmode++;
}
return Umode;
return ModeStringToMask (ircd_cmodes, UmodeString);
}
char *CmodeMaskToString (const unsigned int mask)
{
return ModeMaskToString (ircd_cmodes, mask);
}
char *CmodeMaskToPrefixString (const unsigned int mask)
{
int i, j;
ModeStringBuf[0] = '+';
j = 1;
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (mask & ircd_cmodes[i].mask) {
ModeStringBuf[j] = ircd_cmodes[i].sjoin;
j++;
}
}
ModeStringBuf[j] = '\0';
return ModeStringBuf;
}
int IsBotMode (const char mode)
{
if(ircd_umodes[(int)mode].umode & UMODE_BOT) {
if(ircd_umodes[(int)mode].mask & UMODE_BOT) {
return NS_TRUE;
}
return NS_FALSE;
}
int GetUmodeMask (const char mode)
int UmodeCharToMask (const char mode)
{
return ircd_umodes[(int)mode].umode;
return ircd_umodes[(int)mode].mask;
}
int GetSmodeMask (const char mode)
int SmodeCharToMask (const char mode)
{
return ircd_smodes[(int)mode].umode;
return ircd_smodes[(int)mode].mask;
}
const char * GetUmodeDesc (const unsigned int mask)
int CmodeCharToMask (const char mode)
{
return ircd_cmodes[(int)mode].mask;
}
int CmodeCharToFlags (const char mode)
{
return ircd_cmodes[(int)mode].flags;
}
char ModeMaskToChar (char *mode_char_map, unsigned int mask)
{
int bitcount = 0;
while (mask >>= 1) {
bitcount ++;
}
return mode_char_map[bitcount];
}
char UmodeMaskToChar (const unsigned int mask)
{
return ModeMaskToChar (ircd_umode_char_map, mask);
}
char SmodeMaskToChar (const unsigned int mask)
{
return ModeMaskToChar (ircd_smode_char_map, mask);
}
char CmodeMaskToChar (const unsigned int mask)
{
return ModeMaskToChar (ircd_cmode_char_map, mask);
}
unsigned int CmodePrefixToMask (const char prefix)
{
int i;
for (i = 0; i < MODE_TABLE_SIZE; i++)
{
if (ircd_cmodes[i].sjoin == prefix) {
return ircd_cmodes[i].mask;
}
}
return 0;
}
char CmodePrefixToChar (const char prefix)
{
int i;
for (i = 0; i < MODE_TABLE_SIZE; i++)
{
if (ircd_cmodes[i].sjoin == prefix) {
return i;
}
}
return 0;
}
char CmodeMaskToPrefix (const unsigned int mask)
{
return ircd_cmodes[(int) ModeMaskToChar (ircd_umode_char_map, mask)].sjoin;
}
char CmodeCharToPrefix (const char mode)
{
return (ircd_cmodes[(int)mode].sjoin);
}
const char *GetUmodeDesc (const unsigned int mask)
{
ModeDesc* entry;
@ -337,7 +408,7 @@ const char * GetUmodeDesc (const unsigned int mask)
return NULL;
}
const char * GetSmodeDesc (const unsigned int mask)
const char *GetSmodeDesc (const unsigned int mask)
{
ModeDesc* entry;
@ -351,3 +422,276 @@ const char * GetSmodeDesc (const unsigned int mask)
return NULL;
}
/** @brief Check if a mode is set on a Channel
*
* used to check if a mode is set on a channel
*
* @param c channel to check
* @param mode is the mode to check, as a LONG
*
* @returns 1 on match, 0 on no match, -1 on error
*
*/
int
CheckChanMode (Channel *c, const unsigned int mask)
{
ModesParm *m;
lnode_t *mn;
if (!c) {
nlog (LOG_WARNING, "CheckChanMode: tied to check modes of empty channel");
return -1;
}
if (c->modes & mask) {
/* its a match */
return 1;
}
/* if we get here, we have to check the modeparm list first */
mn = list_first (c->modeparms);
while (mn) {
m = lnode_get (mn);
if (m->mask & mask) {
/* its a match */
return 1;
}
mn = list_next (c->modeparms, mn);
}
return 0;
}
/** @brief Compare channel modes from the channel hash
*
* used in mode_data to compare modes (list_find argument)
*
* @param v actually its a ModeParm struct
* @param mask is the mode as a long
*
* @return 0 on match, 1 otherwise.
*/
static int
comparemode (const void *v, const void *mask)
{
ModesParm *m = (void *) v;
if (m->mask == (unsigned int) mask) {
return 0;
} else {
return 1;
}
}
/** @brief Process a mode change on a channel
*
* process a mode change on a channel adding and deleting modes as required
*
* @param origin usually the server that sent the mode change. Not used
* @param av array of variables to pass
* @param ac number of variables n av
*
* @return 0 on error, number of modes processed on success.
*/
int ChanModeHandler (Channel* c, char *modes, int j, char **av, int ac)
{
int modeexists;
ModesParm *m;
lnode_t *mn;
int add = 0;
while (*modes) {
unsigned int mask;
unsigned int flags;
mask = CmodeCharToMask (*modes);
flags = CmodeCharToFlags (*modes);
switch (*modes) {
case '+':
add = 1;
break;
case '-':
add = 0;
break;
default:
if (flags&NICKPARAM) {
ChanUserMode (av[0], av[j], add, mask);
j++;
} else if (add) {
/* mode limit and mode key replace current values */
if (mask == CMODE_LIMIT) {
c->limit = atoi(av[j]);
j++;
} else if (mask == CMODE_KEY) {
strlcpy (c->key, av[j], KEYLEN);
j++;
} else if (flags) {
mn = list_first (c->modeparms);
modeexists = 0;
while (mn) {
m = lnode_get (mn);
if ((m->mask == mask) && !ircstrcasecmp (m->param, av[j])) {
dlog(DEBUG1, "ChanMode: Mode %c (%s) already exists, not adding again", *modes, av[j]);
j++;
modeexists = 1;
break;
}
mn = list_next (c->modeparms, mn);
}
if (modeexists != 1) {
m = smalloc (sizeof (ModesParm));
m->mask = mask;
strlcpy (m->param, av[j], PARAMSIZE);
if (list_isfull (c->modeparms)) {
nlog (LOG_CRITICAL, "ChanMode: modelist is full adding to channel %s", c->name);
do_exit (NS_EXIT_ERROR, "List full - see log file");
}
lnode_create_append (c->modeparms, m);
j++;
}
} else {
c->modes |= mask;
}
} else {
if(mask == CMODE_LIMIT) {
c->limit = 0;
} else if (mask == CMODE_KEY) {
c->key[0] = 0;
j++;
} else if (flags) {
mn = list_find (c->modeparms, (void *) mask, comparemode);
if (!mn) {
dlog(DEBUG1, "ChanMode: can't find mode %c for channel %s", *modes, c->name);
} else {
list_delete (c->modeparms, mn);
m = lnode_get (mn);
lnode_destroy (mn);
sfree (m);
}
} else {
c->modes &= ~mask;
}
}
}
modes++;
}
return j;
}
int
ChanMode (char *origin, char **av, int ac)
{
Channel *c;
CmdParams * cmdparams;
int j = 2;
int i;
c = find_chan (av[0]);
if (!c) {
return 0;
}
cmdparams = (CmdParams*) scalloc (sizeof(CmdParams));
cmdparams->channel = c;
AddStringToList(&cmdparams->av, origin, &cmdparams->ac);
for (i = 0; i < ac; i++) {
AddStringToList(&cmdparams->av, av[i], &cmdparams->ac);
}
SendAllModuleEvent(EVENT_CHANMODE, cmdparams);
sfree(cmdparams);
j = ChanModeHandler (c, av[1], j, av, ac);
return j;
}
/** @brief Process a mode change that affects a user on a channel
*
* process a mode change on a channel that affects a user
*
* @param c Channel Struct of channel mode being changed
* @param u User struct of user that mode is affecting
* @param add 1 means add, 0 means remove mode
* @param mask is the long int of the mode
*
* @return Nothing
*/
void
ChanUserMode (const char *chan, const char *nick, int add, const unsigned int mask)
{
Chanmem *cm;
Channel *c;
Client *u;
u = find_user(nick);
if (!u) {
nlog (LOG_WARNING, "ChanUserMode: can't find user %s", nick);
return;
}
c = find_chan(chan);
if (!c) {
nlog (LOG_WARNING, "ChanUserMode: can't find channel %s", chan);
return;
}
cm = lnode_find (c->chanmembers, u->name, comparef);
if (!cm) {
nlog (LOG_WARNING, "ChanUserMode: %s is not a member of channel %s", u->name, c->name);
return;
}
if (add) {
dlog(DEBUG2, "ChanUserMode: Adding mode %ld to Channel %s User %s", mask, c->name, u->name);
cm->flags |= mask;
} else {
dlog(DEBUG2, "ChanUserMode: Deleting Mode %ld to Channel %s User %s", mask, c->name, u->name);
cm->flags &= ~mask;
}
}
void
dumpchanmodes (CmdParams* cmdparams, Channel* c)
{
lnode_t *cmn;
ModesParm *m;
int i;
irc_prefmsg (ns_botptr, cmdparams->source, "Mode: %s", UmodeMaskToString (c->modes));
cmn = list_first (c->modeparms);
while (cmn) {
m = lnode_get (cmn);
for (i = 0; i < MODE_TABLE_SIZE; i++) {
if (m->mask & ircd_cmodes[i].mask) {
irc_prefmsg (ns_botptr, cmdparams->source, "Modes: %c Parms %s", i, m->param);
}
}
cmn = list_next (c->modeparms, cmn);
}
}
#ifdef SQLSRV
/* display the channel modes */
/* BUFSIZE is probably too small.. oh well */
static char chanmodes[BUFSIZE];
void *display_chanmodes (void *tbl, char *col, char *sql, void *row)
{
Channel *c = row;
lnode_t *cmn;
char tmp[BUFSIZE];
ModesParm *m;
strlcpy (chanmodes, CmodeMaskToString (c->modes), BUFSIZE);
cmn = list_first (c->modeparms);
while (cmn) {
m = lnode_get (cmn);
ircsnprintf(tmp, BUFSIZE, " +%c %s", CmodeMaskToChar (m->mask), m->param);
strlcat(chanmodes, tmp, BUFSIZE);
cmn = list_next (c->modeparms, cmn);
}
return chanmodes;
}
#endif

11
src/modules.c
View file

@ -616,11 +616,17 @@ ModuleConfig(bot_setting* set_ptr)
if (GetConf((void *)set_ptr->varptr, CFGBOOL, set_ptr->confitem) <= 0) {
*(int *)set_ptr->varptr = (int)set_ptr->defaultval;
}
if(set_ptr->handler) {
set_ptr->handler(NULL, SET_LOAD);
}
break;
case SET_TYPE_INT:
if (GetConf((void *)set_ptr->varptr, CFGINT, set_ptr->confitem) <= 0) {
*(int *)set_ptr->varptr = (int)set_ptr->defaultval;
}
if(set_ptr->handler) {
set_ptr->handler(NULL, SET_LOAD);
}
break;
case SET_TYPE_STRING:
case SET_TYPE_CHANNEL:
@ -637,10 +643,13 @@ ModuleConfig(bot_setting* set_ptr)
strlcpy(set_ptr->varptr, set_ptr->defaultval, set_ptr->max);
}
if(set_ptr->handler) {
set_ptr->handler(NULL, SET_LOAD);
}
break;
case SET_TYPE_CUSTOM:
if(set_ptr->handler) {
set_ptr->handler(NULL);
set_ptr->handler(NULL, SET_LOAD);
}
break;
default:

10
src/protocol/bahamut.c
View file

@ -103,14 +103,14 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'v', CUMODE_VOICE, '+'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'v', CUMODE_VOICE, 0, '+'},
/* CMODE_DEOPPED */
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'p', CMODE_PRIVATE, 0},
{'s', CMODE_SECRET, 0},
{'m', CMODE_MODERATED, 0},
@ -129,7 +129,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'a', UMODE_SADMIN},
{'A', UMODE_ADMIN},
{'o', UMODE_OPER},

16
src/protocol/client.c
View file

@ -85,16 +85,16 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'v', CUMODE_VOICE, '+'},
{'h', CUMODE_HALFOP, '%'},
{'o', CUMODE_CHANOP, '@'},
{'a', CUMODE_CHANPROT, '*'},
{'q', CUMODE_CHANOWNER, '~'},
mode_init chan_umodes[] = {
{'v', CUMODE_VOICE, 0, '+'},
{'h', CUMODE_HALFOP, 0, '%'},
{'o', CUMODE_CHANOP, 0, '@'},
{'a', CUMODE_CHANPROT, 0, '*'},
{'q', CUMODE_CHANOWNER, 0, '~'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'l', CMODE_LIMIT, MODEPARAM},
{'p', CMODE_PRIVATE, 0},
{'s', CMODE_SECRET, 0},
@ -125,7 +125,7 @@ cmode_init chan_modes[] = {
{0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'S', UMODE_SERVICES},
{'N', UMODE_NETADMIN},
{'a', UMODE_SADMIN},

12
src/protocol/hybrid7.c
View file

@ -101,16 +101,16 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
mode_init chan_umodes[] = {
/* CMODE_PEON */
{'o', CUMODE_CHANOP, '@'},
{'v', CUMODE_VOICE, '+'},
{'h', CUMODE_HALFOP, '%'},
{'o', CUMODE_CHANOP, 0, '@'},
{'v', CUMODE_VOICE, 0, '+'},
{'h', CUMODE_HALFOP, 0, '%'},
/* CMODE_DEOPPED */
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'p', CMODE_PRIVATE, 0},
{'s', CMODE_SECRET, 0},
{'m', CMODE_MODERATED, 0},
@ -126,7 +126,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'d', UMODE_DEBUG},
{'a', UMODE_ADMIN},
{'o', UMODE_OPER},

14
src/protocol/ircup10.c
View file

@ -111,13 +111,13 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'v', CUMODE_VOICE, '+'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'v', CUMODE_VOICE, 0, '+'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'s', CMODE_SECRET, 0},
{'p', CMODE_PRIVATE, 0},
{'m', CMODE_MODERATED, 0},
@ -151,7 +151,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'o', UMODE_OPER},
{'O', UMODE_LOCOP},
{'g', UMODE_DEBUG},
@ -746,7 +746,7 @@ m_burst (char *origin, char **argv, int argc, int srv)
param++;
modes++;
while(*modes) {
if (ircd_cmodes[(int)*modes].flags&MODEPARAM) {
if (CmodeCharToFlags (*modes) & MODEPARAM) {
param ++;
}
modes++;
@ -800,7 +800,7 @@ m_burst (char *origin, char **argv, int argc, int srv)
char **av;
int ac;
if (ircd_cmodes[(int)*modes].flags&MODEPARAM) {
if (CmodeCharToFlags (*modes) & MODEPARAM) {
ircsnprintf (ircd_buf, BUFSIZE, "%s +%c %s", argv[0], *modes, argv[param]);
param ++;
} else {

20
src/protocol/liquid.c
View file

@ -105,22 +105,22 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
mode_init chan_umodes[] = {
/* CMODE_DECHANOWNER */
/* CMODE_DECHANPROT */
/* CMODE_DEOPPED */
/* CMODE_DEHALFOPPED */
/* CMODE_DEUOP */
{'q', CUMODE_CHANOWNER, '!'},
{'a', CUMODE_CHANPROT, '*'},
{'o', CUMODE_CHANOP, '@'},
{'h', CUMODE_HALFOP, '%'},
{'v', CUMODE_VOICE, '+'},
{'u', CMODE_UOP, '-'},
{'q', CUMODE_CHANOWNER, 0, '!'},
{'a', CUMODE_CHANPROT, 0, '*'},
{'o', CUMODE_CHANOP, 0, '@'},
{'h', CUMODE_HALFOP, 0, '%'},
{'v', CUMODE_VOICE, 0, '+'},
{'u', CMODE_UOP, 0, '-'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'b', CMODE_BAN, MODEPARAM},
{'c', CMODE_NOCOLOR, 0},
{'i', CMODE_INVITEONLY, 0},
@ -142,7 +142,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'a', UMODE_SADMIN},
{'T', UMODE_TECHADMIN},
{'N', UMODE_NETADMIN},
@ -178,7 +178,7 @@ umode_init user_umodes[] = {
{0, 0},
};
umode_init user_smodes[] = {
mode_init user_smodes[] = {
{'s', SMODE_SSL},
{0, 0},
};

12
src/protocol/mystic.c
View file

@ -106,14 +106,14 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'h', CUMODE_HALFOP, '%'},
{'v', CUMODE_VOICE, '+'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'h', CUMODE_HALFOP, 0, '%'},
{'v', CUMODE_VOICE, 0, '+'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'b', CMODE_BAN, MODEPARAM},
{'e', CMODE_EXCEPT, MODEPARAM},
{'f', CMODE_FLOODLIMIT, MODEPARAM},
@ -138,7 +138,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'S', UMODE_SERVICES},
{'P', UMODE_SADMIN},
{'T', UMODE_TECHADMIN},

14
src/protocol/neoircd.c
View file

@ -100,15 +100,15 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'h', CUMODE_HALFOP, '%'},
{'o', CUMODE_CHANOP, '@'},
{'v', CUMODE_VOICE, '+'},
{'a', CUMODE_CHANADMIN, '!'},
mode_init chan_umodes[] = {
{'h', CUMODE_HALFOP, 0, '%'},
{'o', CUMODE_CHANOP, 0, '@'},
{'v', CUMODE_VOICE, 0, '+'},
{'a', CUMODE_CHANADMIN, 0, '!'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'s', CMODE_SECRET, 0},
{'p', CMODE_PRIVATE, 0},
{'m', CMODE_MODERATED, 0},
@ -126,7 +126,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'S', UMODE_SERVICES},
{'d', UMODE_DEBUG},
{'A', UMODE_ADMIN},

20
src/protocol/quantum.c
View file

@ -114,17 +114,17 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'h', CUMODE_HALFOP, '%'},
{'a', CUMODE_CHANADMIN, '!'},
{'v', CUMODE_VOICE, '+'},
{'V', CMODE_VIP, '='},
{'d', CMODE_SILENCE, '-'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'h', CUMODE_HALFOP, 0, '%'},
{'a', CUMODE_CHANADMIN, 0, '!'},
{'v', CUMODE_VOICE, 0, '+'},
{'V', CMODE_VIP, 0, '='},
{'d', CMODE_SILENCE, 0, '-'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'b', CMODE_BAN, MODEPARAM},
{'e', CMODE_EXCEPT, MODEPARAM},
{'f', CMODE_FLOODLIMIT, MODEPARAM},
@ -150,7 +150,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'Z', UMODE_IRCADMIN},
{'S', UMODE_SERVICES},
{'P', UMODE_SADMIN},
@ -182,7 +182,7 @@ umode_init user_umodes[] = {
{0, 0},
};
umode_init user_smodes[] = {
mode_init user_smodes[] = {
{'N', SMODE_NETADMIN},
{'n', SMODE_CONETADMIN},
{'T', SMODE_TECHADMIN},

14
src/protocol/ultimate2.c
View file

@ -111,15 +111,15 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'h', CUMODE_HALFOP, '%'},
{'a', CUMODE_CHANADMIN, '!'},
{'v', CUMODE_VOICE, '+'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'h', CUMODE_HALFOP, 0, '%'},
{'a', CUMODE_CHANADMIN, 0, '!'},
{'v', CUMODE_VOICE, 0, '+'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'b', CMODE_BAN, MODEPARAM},
{'e', CMODE_EXCEPT, MODEPARAM},
{'f', CMODE_FLOODLIMIT, MODEPARAM},
@ -143,7 +143,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'S', UMODE_SERVICES},
{'P', UMODE_SADMIN},
{'T', UMODE_TECHADMIN},

16
src/protocol/ultimate3.c
View file

@ -120,15 +120,15 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'h', CUMODE_HALFOP, '%'},
{'a', CUMODE_CHANADMIN, '!'},
{'v', CUMODE_VOICE, '+'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'h', CUMODE_HALFOP, 0, '%'},
{'a', CUMODE_CHANADMIN, 0, '!'},
{'v', CUMODE_VOICE, 0, '+'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'b', CMODE_BAN, MODEPARAM},
{'e', CMODE_EXCEPT, MODEPARAM},
{'f', CMODE_FLOODLIMIT, MODEPARAM},
@ -152,7 +152,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'Z', UMODE_SRA},
{'S', UMODE_SERVICES},
{'P', UMODE_SADMIN},
@ -186,7 +186,7 @@ umode_init user_umodes[] = {
{0, 0},
};
umode_init user_smodes[] = {
mode_init user_smodes[] = {
{'N', SMODE_NETADMIN},
{'n', SMODE_CONETADMIN},
{'T', SMODE_TECHADMIN},

16
src/protocol/unreal31.c
View file

@ -118,16 +118,16 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'v', CUMODE_VOICE, '+'},
{'h', CUMODE_HALFOP, '%'},
{'o', CUMODE_CHANOP, '@'},
{'a', CUMODE_CHANPROT, '*'},
{'q', CUMODE_CHANOWNER, '~'},
mode_init chan_umodes[] = {
{'v', CUMODE_VOICE, 0, '+'},
{'h', CUMODE_HALFOP, 0, '%'},
{'o', CUMODE_CHANOP, 0, '@'},
{'a', CUMODE_CHANPROT, 0, '*'},
{'q', CUMODE_CHANOWNER, 0, '~'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'l', CMODE_LIMIT, MODEPARAM},
{'p', CMODE_PRIVATE, 0},
{'s', CMODE_SECRET, 0},
@ -158,7 +158,7 @@ cmode_init chan_modes[] = {
{0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'S', UMODE_SERVICES},
{'N', UMODE_NETADMIN},
{'a', UMODE_SADMIN},

16
src/protocol/unreal32.c
View file

@ -127,16 +127,16 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'v', CUMODE_VOICE, '+'},
{'h', CUMODE_HALFOP, '%'},
{'o', CUMODE_CHANOP, '@'},
{'a', CUMODE_CHANPROT, '*'},
{'q', CUMODE_CHANOWNER, '~'},
mode_init chan_umodes[] = {
{'v', CUMODE_VOICE, 0, '+'},
{'h', CUMODE_HALFOP, 0, '%'},
{'o', CUMODE_CHANOP, 0, '@'},
{'a', CUMODE_CHANPROT, 0, '*'},
{'q', CUMODE_CHANOWNER, 0, '~'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'l', CMODE_LIMIT, MODEPARAM},
{'p', CMODE_PRIVATE, 0},
{'s', CMODE_SECRET, 0},
@ -167,7 +167,7 @@ cmode_init chan_modes[] = {
{0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'S', UMODE_SERVICES, OPERMODE},
{'N', UMODE_NETADMIN, OPERMODE},
{'a', UMODE_SADMIN, OPERMODE},

16
src/protocol/viagra.c
View file

@ -103,16 +103,16 @@ ircd_cmd cmd_list[] = {
{0, 0, 0, 0},
};
cumode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, '@'},
{'h', CUMODE_HALFOP, '%'},
{'a', CUMODE_CHANADMIN, '*'},
{'q', CUMODE_CHANOWNER, '!'},
{'v', CUMODE_VOICE, '+'},
mode_init chan_umodes[] = {
{'o', CUMODE_CHANOP, 0, '@'},
{'h', CUMODE_HALFOP, 0, '%'},
{'a', CUMODE_CHANADMIN, 0, '*'},
{'q', CUMODE_CHANOWNER, 0, '!'},
{'v', CUMODE_VOICE, 0, '+'},
{0, 0, 0},
};
cmode_init chan_modes[] = {
mode_init chan_modes[] = {
{'b', CMODE_BAN, MODEPARAM},
{'i', CMODE_INVITEONLY, 0},
{'k', CMODE_KEY, MODEPARAM},
@ -129,7 +129,7 @@ cmode_init chan_modes[] = {
{0, 0, 0},
};
umode_init user_umodes[] = {
mode_init user_umodes[] = {
{'a', UMODE_SADMIN},
{'A', UMODE_ADMIN},
{'i', UMODE_ALTADMIN},

4
src/services.c
View file

@ -290,7 +290,7 @@ ns_userdump (CmdParams* cmdparams)
return NS_FAILURE;
}
#endif
UserDump ((cmdparams->ac < 1)? NULL : cmdparams->av[0]);
UserDump (cmdparams, (cmdparams->ac < 1)? NULL : cmdparams->av[0]);
return NS_SUCCESS;
}
@ -332,7 +332,7 @@ ns_chandump (CmdParams* cmdparams)
return NS_FAILURE;
}
#endif
ChanDump ((cmdparams->ac < 1)? NULL : cmdparams->av[0]);
ChanDump (cmdparams, (cmdparams->ac < 1)? NULL : cmdparams->av[0]);
return NS_SUCCESS;
}

54
src/users.c
View file

@ -565,41 +565,41 @@ InitUsers (void)
}
static void
dumpuser (Client * u)
dumpuser (CmdParams* cmdparams, Client * u)
{
lnode_t *cm;
int i = 0;
if (ircd_srv.protocol & PROTOCOL_B64SERVER) {
irc_chanalert (ns_botptr, "User: %s!%s@%s (%s)", u->name, u->user->username, u->user->hostname, u->name64);
irc_prefmsg (ns_botptr, cmdparams->source, "User: %s!%s@%s (%s)", u->name, u->user->username, u->user->hostname, u->name64);
} else {
irc_chanalert (ns_botptr, "User: %s!%s@%s", u->name, u->user->username, u->user->hostname);
irc_prefmsg (ns_botptr, cmdparams->source, "User: %s!%s@%s", u->name, u->user->username, u->user->hostname);
}
irc_chanalert (ns_botptr, "IP: %s", u->hostip);
irc_chanalert (ns_botptr, "Vhost: %s", u->user->vhost);
irc_chanalert (ns_botptr, "Flags: 0x%x", u->flags);
irc_chanalert (ns_botptr, "Modes: %s (0x%x)", UmodeMaskToString(u->user->Umode), u->user->Umode);
irc_chanalert (ns_botptr, "Smodes: %s (0x%x)", SmodeMaskToString(u->user->Smode), u->user->Smode);
irc_prefmsg (ns_botptr, cmdparams->source, "IP: %s", u->hostip);
irc_prefmsg (ns_botptr, cmdparams->source, "Vhost: %s", u->user->vhost);
irc_prefmsg (ns_botptr, cmdparams->source, "Flags: 0x%x", u->flags);
irc_prefmsg (ns_botptr, cmdparams->source, "Modes: %s (0x%x)", UmodeMaskToString(u->user->Umode), u->user->Umode);
irc_prefmsg (ns_botptr, cmdparams->source, "Smodes: %s (0x%x)", SmodeMaskToString(u->user->Smode), u->user->Smode);
if(u->user->is_away) {
irc_chanalert (ns_botptr, "Away: %s", u->user->awaymsg);
irc_prefmsg (ns_botptr, cmdparams->source, "Away: %s", u->user->awaymsg);
}
irc_chanalert (ns_botptr, "Version: %s", u->version);
irc_prefmsg (ns_botptr, cmdparams->source, "Version: %s", u->version);
cm = list_first (u->user->chans);
while (cm) {
if(i==0) {
irc_chanalert (ns_botptr, "Channels: %s", (char *) lnode_get (cm));
irc_prefmsg (ns_botptr, cmdparams->source, "Channels: %s", (char *) lnode_get (cm));
} else {
irc_chanalert (ns_botptr, " %s", (char *) lnode_get (cm));
irc_prefmsg (ns_botptr, cmdparams->source, " %s", (char *) lnode_get (cm));
}
cm = list_next (u->user->chans, cm);
i++;
}
irc_chanalert (ns_botptr, "========================================");
irc_prefmsg (ns_botptr, cmdparams->source, "========================================");
}
void
UserDump (const char *nick)
UserDump (CmdParams* cmdparams, const char *nick)
{
Client *u;
hscan_t us;
@ -609,21 +609,21 @@ UserDump (const char *nick)
return;
#endif
SET_SEGV_LOCATION();
irc_chanalert (ns_botptr, "================USERDUMP================");
irc_prefmsg (ns_botptr, cmdparams->source, "================USERDUMP================");
if (!nick) {
hnode_t* un;
hash_scan_begin (&us, userhash);
while ((un = hash_scan_next (&us)) != NULL) {
u = hnode_get (un);
dumpuser (u);
dumpuser (cmdparams, u);
}
} else {
u = (Client *)hnode_find (userhash, nick);
if (u) {
dumpuser (u);
dumpuser (cmdparams, u);
} else {
irc_chanalert (ns_botptr, "UserDump: can't find user %s", nick);
irc_prefmsg (ns_botptr, cmdparams->source, "UserDump: can't find user %s", nick);
}
}
}
@ -635,20 +635,6 @@ UserLevel (Client * u)
if(u->user->ulevel != -1) {
return u->user->ulevel;
}
#ifdef DEBUG
#ifdef CODERHACK
/* this is only cause I dun have the right O lines on some of my "Beta"
Networks, so I need to hack this in :) */
if (!ircstrcasecmp (u->name, "FISH"))
u->user->ulevel = NS_ULEVEL_ROOT;
else if (!ircstrcasecmp (u->name, "SHMAD"))
u->user->ulevel = NS_ULEVEL_ROOT;
else if (!ircstrcasecmp (u->name, "MARK"))
u->user->ulevel = NS_ULEVEL_ROOT;
else
#endif
#endif
u->user->ulevel = UserAuth(u);
/* Set user level so we no longer need to calculate */
dlog(DEBUG1, "UserLevel for %s is %d", u->name, u->user->ulevel);
@ -691,7 +677,7 @@ UserMode (const char *nick, const char *modes)
u->user->ulevel = -1;
strlcpy (u->user->modes, modes, MODESIZE);
oldmode = u->user->Umode;
u->user->Umode = UmodeStringToMask(modes, u->user->Umode);
u->user->Umode |= UmodeStringToMask (modes);
if (ircd_srv.features&FEATURE_UMODECLOAK) {
/* Do we have a hidden host any more? */
if((oldmode & UMODE_HIDE) && (!(u->user->Umode & UMODE_HIDE))) {
@ -721,7 +707,7 @@ UserSMode (const char *nick, const char *modes)
}
/* Reset user level so it will be recalculated */
u->user->ulevel = -1;
u->user->Smode = SmodeStringToMask(modes, u->user->Smode);
u->user->Smode |= SmodeStringToMask(modes);
dlog(DEBUG1, "UserSMode: smode for %s is now %x", u->name, u->user->Smode);
cmdparams = (CmdParams*) scalloc (sizeof(CmdParams));
cmdparams->source = u;