{
public:
- Channel_r(InspIRCd* Instance) : ModeHandler(Instance, 'r', 0, 0, false, MODETYPE_CHANNEL, false) { }
+ Channel_r(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'r', 0, 0, false, MODETYPE_CHANNEL, false) { }
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool)
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
// only a u-lined server may add or remove the +r mode.
if (IS_REMOTE(source) || ServerInstance->ULine(source->nick.c_str()) || ServerInstance->ULine(source->server))
{
public:
- User_r(InspIRCd* Instance) : ModeHandler(Instance, 'r', 0, 0, false, MODETYPE_USER, false) { }
+ User_r(InspIRCd* Instance, Module* Creator) : ModeHandler(Instance, Creator, 'r', 0, 0, false, MODETYPE_USER, false) { }
- ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding, bool servermode)
+ ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
- if (servermode || IS_REMOTE(source) || ServerInstance->ULine(source->nick.c_str()) || ServerInstance->ULine(source->server))
+ if (IS_REMOTE(source) || ServerInstance->ULine(source->nick.c_str()) || ServerInstance->ULine(source->server))
{
if ((adding && !dest->IsModeSet('r')) || (!adding && dest->IsModeSet('r')))
{
class AChannel_R : public SimpleChannelModeHandler
{
public:
- AChannel_R(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'R') { }
+ AChannel_R(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'R') { }
};
/** User mode +R - unidentified users cannot message
class AUser_R : public SimpleUserModeHandler
{
public:
- AUser_R(InspIRCd* Instance) : SimpleUserModeHandler(Instance, 'R') { }
+ AUser_R(InspIRCd* Instance, Module* Creator) : SimpleUserModeHandler(Instance, Creator, 'R') { }
};
/** Channel mode +M - unidentified users cannot message channel
class AChannel_M : public SimpleChannelModeHandler
{
public:
- AChannel_M(InspIRCd* Instance) : SimpleChannelModeHandler(Instance, 'M') { }
+ AChannel_M(InspIRCd* Instance, Module* Creator) : SimpleChannelModeHandler(Instance, Creator, 'M') { }
};
class ModuleServicesAccount : public Module
User_r m5;
public:
ModuleServicesAccount(InspIRCd* Me) : Module(Me),
- m1(Me), m2(Me), m3(Me), m4(Me), m5(Me)
+ m1(Me, this), m2(Me, this), m3(Me, this), m4(Me, this), m5(Me, this)
{
if (!ServerInstance->Modes->AddMode(&m1) || !ServerInstance->Modes->AddMode(&m2) ||
throw ModuleException("Some other module has claimed our modes!");
Implementation eventlist[] = { I_OnWhois, I_OnUserPreMessage, I_OnUserPreNotice, I_OnUserPreJoin, I_OnCheckBan,
- I_OnSyncUserMetaData, I_OnUserQuit, I_OnCleanup, I_OnDecodeMetaData, I_On005Numeric, I_OnUserPostNick };
+ I_OnSyncUser, I_OnUserQuit, I_OnCleanup, I_OnDecodeMetaData, I_On005Numeric, I_OnUserPostNick };
ServerInstance->Modules->Attach(eventlist, this, 10);
}
}
}
- virtual int OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list)
+ virtual ModResult OnUserPreMessage(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list)
{
if (!IS_LOCAL(user))
- return 0;
+ return MOD_RES_PASSTHRU;
std::string *account;
bool is_registered = user->GetExt("accountname", account);
if ((ServerInstance->ULine(user->nick.c_str())) || (ServerInstance->ULine(user->server)))
{
// user is ulined, can speak regardless
- return 0;
+ return MOD_RES_PASSTHRU;
}
if (target_type == TYPE_CHANNEL)
{
// user messaging a +M channel and is not registered
user->WriteNumeric(477, ""+std::string(user->nick)+" "+std::string(c->name)+" :You need to be identified to a registered account to message this channel");
- return 1;
+ return MOD_RES_DENY;
}
if (account)
{
- if (c->GetExtBanStatus(*account, 'M') < 0)
+ if (c->GetExtBanStatus(*account, 'M') == MOD_RES_DENY)
{
// may not speak (text is deliberately vague, so they don't know which restriction to evade)
user->WriteNumeric(477, ""+std::string(user->nick)+" "+std::string(c->name)+" :You may not speak in this channel");
- return 1;
+ return MOD_RES_DENY;
}
}
}
{
// user messaging a +R user and is not registered
user->WriteNumeric(477, ""+ user->nick +" "+ u->nick +" :You need to be identified to a registered account to message this user");
- return 1;
+ return MOD_RES_DENY;
}
}
- return 0;
+ return MOD_RES_PASSTHRU;
}
- virtual int OnCheckBan(User* user, Channel* chan)
+ virtual ModResult OnCheckBan(User* user, Channel* chan)
{
std::string* account;
if (!user->GetExt("accountname", account))
- return 0;
+ return MOD_RES_PASSTHRU;
return chan->GetExtBanStatus(*account, 'R');
}
- virtual int OnUserPreNotice(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list)
+ virtual ModResult OnUserPreNotice(User* user,void* dest,int target_type, std::string &text, char status, CUList &exempt_list)
{
return OnUserPreMessage(user, dest, target_type, text, status, exempt_list);
}
- virtual int OnUserPreJoin(User* user, Channel* chan, const char* cname, std::string &privs, const std::string &keygiven)
+ virtual ModResult OnUserPreJoin(User* user, Channel* chan, const char* cname, std::string &privs, const std::string &keygiven)
{
if (!IS_LOCAL(user))
- return 0;
+ return MOD_RES_PASSTHRU;
std::string *account;
bool is_registered = user->GetExt("accountname", account);
if ((ServerInstance->ULine(user->nick.c_str())) || (ServerInstance->ULine(user->server)))
{
// user is ulined, won't be stopped from joining
- return 0;
+ return MOD_RES_PASSTHRU;
}
if (chan->IsModeSet('R'))
{
// joining a +R channel and not identified
user->WriteNumeric(477, user->nick + " " + chan->name + " :You need to be identified to a registered account to join this channel");
- return 1;
+ return MOD_RES_DENY;
}
}
}
- return 0;
+ return MOD_RES_PASSTHRU;
}
// Whenever the linking module wants to send out data, but doesnt know what the data
// this method is called. We should use the ProtoSendMetaData function after we've
// corrected decided how the data should look, to send the metadata on its way if
// it is ours.
- virtual void OnSyncUserMetaData(User* user, Module* proto, void* opaque, const std::string &extname, bool displayable)
+ virtual void OnSyncUser(User* user, Module* proto, void* opaque)
{
- // check if the linking module wants to know about OUR metadata
- if (extname == "accountname")
+ // check if this user has an swhois field to send
+ std::string* account;
+ user->GetExt("accountname", account);
+ if (account)
{
- // check if this user has an swhois field to send
- std::string* account;
- user->GetExt("accountname", account);
- if (account)
- {
- // remove any accidental leading/trailing spaces
- trim(*account);
+ // remove any accidental leading/trailing spaces
+ trim(*account);
- // call this function in the linking module, let it format the data how it
- // sees fit, and send it on its way. We dont need or want to know how.
- proto->ProtoSendMetaData(opaque,TYPE_USER,user,extname,*account);
- }
+ // call this function in the linking module, let it format the data how it
+ // sees fit, and send it on its way. We dont need or want to know how.
+ proto->ProtoSendMetaData(opaque,user,"accountname",*account);
}
}
// In our case we're only sending a single string around, so we just construct a std::string.
// Some modules will probably get much more complex and format more detailed structs and classes
// in a textual way for sending over the link.
- virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata)
+ virtual void OnDecodeMetaData(Extensible* target, const std::string &extname, const std::string &extdata)
{
+ User* dest = dynamic_cast<User*>(target);
// check if its our metadata key, and its associated with a user
- if ((target_type == TYPE_USER) && (extname == "accountname"))
+ if (dest && (extname == "accountname"))
{
- User* dest = (User*)target;
-
std::string* account;
if (dest->GetExt("accountname", account)) {
// remove old account so that we can set new (or leave unset)
projects / user / henk / code / inspircd.git / blobdiff