void CheckAttach(const CString& sMessage, CChan& Channel) {
if (Channel.IsDetached()) {
if (sMessage.AsLower().find(m_pNetwork->GetCurNick().AsLower()) != CString::npos) {
Channel.JoinUser();
}
}
}
void Cleanup() {
Limits::iterator it;
time_t now = time(NULL);
for (it = m_chans.begin(); it != m_chans.end(); ++it) {
// The timeout for this channel did not expire yet?
if (it->second.first + (time_t)m_iThresholdSecs >= now)
continue;
CChan *pChan = m_pNetwork->FindChan(it->first);
if (it->second.second >= m_iThresholdMsgs
&& pChan && pChan->IsDetached()) {
// The channel is detached and it is over the
// messages limit. Since we only track those
// limits for non-detached channels or for
// channels which we detached, this means that
// we detached because of a flood.
PutModule("Flood in [" + pChan->GetName() + "] is over, "
"re-attaching...");
// No buffer playback, makes sense, doesn't it?
pChan->ClearBuffer();
pChan->JoinUser();
}
Limits::iterator it2 = it++;
m_chans.erase(it2);
// Without this Bad Things (tm) could happen
if (it == m_chans.end())
break;
}
}
void TryAttach(CChan& Channel) {
const CString& sChan = Channel.GetName();
if (Channel.IsDetached() && IsAutoAttach(sChan)) {
Channel.JoinUser();
}
}
bool CClient::OnJoinMessage(CJoinMessage& Message) {
CString sChans = Message.GetTarget();
CString sKeys = Message.GetKey();
VCString vsChans;
sChans.Split(",", vsChans, false);
sChans.clear();
VCString vsKeys;
sKeys.Split(",", vsKeys, true);
sKeys.clear();
for (unsigned int a = 0; a < vsChans.size(); a++) {
Message.SetTarget(vsChans[a]);
Message.SetKey((a < vsKeys.size()) ? vsKeys[a] : "");
if (m_pNetwork) {
// May be nullptr.
Message.SetChan(m_pNetwork->FindChan(vsChans[a]));
}
bool bContinue = false;
NETWORKMODULECALL(OnUserJoinMessage(Message), m_pUser, m_pNetwork, this,
&bContinue);
if (bContinue) continue;
CString sChannel = Message.GetTarget();
CString sKey = Message.GetKey();
if (m_pNetwork) {
CChan* pChan = m_pNetwork->FindChan(sChannel);
if (pChan) {
if (pChan->IsDetached())
pChan->AttachUser(this);
else
pChan->JoinUser(sKey);
continue;
} else if (!sChannel.empty()) {
pChan = new CChan(sChannel, m_pNetwork, false);
if (m_pNetwork->AddChan(pChan)) {
pChan->SetKey(sKey);
}
}
}
if (!sChannel.empty()) {
sChans += (sChans.empty()) ? sChannel : CString("," + sChannel);
if (!vsKeys.empty()) {
sKeys += (sKeys.empty()) ? sKey : CString("," + sKey);
}
}
}
Message.SetTarget(sChans);
Message.SetKey(sKeys);
return sChans.empty();
}
virtual EModRet OnUserPart(CString& sChannel, CString& sMessage)
{
for (MCString::iterator it = BeginNV(); it != EndNV(); ++it)
{
if (sChannel.Equals(it->first))
{
CChan* pChan = m_pUser->FindChan(sChannel);
if (pChan)
{
pChan->JoinUser(true, "", m_pClient);
return HALT;
}
}
}
return CONTINUE;
}
void TryAttach(const CNick& Nick, CChan& Channel) {
const CString& sChan = Channel.GetName();
const CString& sHost = Nick.GetHostMask();
VAttachIter it;
if (!Channel.IsDetached())
return;
// Any negated match?
for (it = m_vMatches.begin(); it != m_vMatches.end(); ++it) {
if (it->IsNegated() && it->IsMatch(sChan, sHost))
return;
}
// Now check for a positive match
for (it = m_vMatches.begin(); it != m_vMatches.end(); ++it) {
if (!it->IsNegated() && it->IsMatch(sChan, sHost)) {
Channel.JoinUser();
return;
}
}
}
void Attach(CChan& channel) {
if (!channel.IsDetached())
return;
channel.JoinUser();
}