EModRet OnUserNotice(CString& sTarget, CString& sMessage) override {
sTarget.TrimPrefix(NickPrefix());
if (sMessage.TrimPrefix("``")) {
return CONTINUE;
}
MCString::iterator it = FindNV(sTarget.AsLower());
if (it != EndNV()) {
CChan* pChan = GetNetwork()->FindChan(sTarget);
CString sNickMask = GetNetwork()->GetIRCNick().GetNickMask();
if (pChan) {
if (!pChan->AutoClearChanBuffer())
pChan->AddBuffer(":" + NickPrefix() + _NAMEDFMT(sNickMask) + " NOTICE " + _NAMEDFMT(sTarget) + " :{text}", sMessage);
GetUser()->PutUser(":" + NickPrefix() + sNickMask + " NOTICE " + sTarget + " :" + sMessage, NULL, GetClient());
}
CString sMsg = MakeIvec() + sMessage;
sMsg.Encrypt(it->second);
sMsg.Base64Encode();
sMsg = "+OK *" + sMsg;
PutIRC("NOTICE " + sTarget + " :" + sMsg);
return HALTCORE;
}
return CONTINUE;
}
bool CAI_Pathfinder::IsLinkStillStale(int moveType, CAI_Link *nodeLink)
{
if ( m_bIgnoreStaleLinks )
return false;
if ( !(nodeLink->m_LinkInfo & bits_LINK_STALE_SUGGESTED ) )
return false;
if ( gpGlobals->curtime < nodeLink->m_timeStaleExpires )
return true;
// NPC should only check one stale link per think
if (gpGlobals->curtime == m_flLastStaleLinkCheckTime)
{
return true;
}
else
{
m_flLastStaleLinkCheckTime = gpGlobals->curtime;
}
// Test movement, if suceeds, clear the stale bit
if (CheckStaleRoute(GetNetwork()->GetNode(nodeLink->m_iSrcID)->GetPosition(GetHullType()),
GetNetwork()->GetNode(nodeLink->m_iDestID)->GetPosition(GetHullType()), moveType))
{
nodeLink->m_LinkInfo &= ~bits_LINK_STALE_SUGGESTED;
return false;
}
nodeLink->m_timeStaleExpires = gpGlobals->curtime + 1.0;
return true;
}
bool OnLoad(const CString& sArgs, CString& sMessage) override {
CString sReasonArg;
// Load AwayWait
CString sFirstArg = sArgs.Token(0);
if (sFirstArg.Equals("-notimer")) {
SetAwayWait(0);
sReasonArg = sArgs.Token(1, true);
} else if (sFirstArg.Equals("-timer")) {
SetAwayWait(sArgs.Token(1).ToUInt());
sReasonArg = sArgs.Token(2, true);
} else {
CString sAwayWait = GetNV("awaywait");
if (!sAwayWait.empty())
SetAwayWait(sAwayWait.ToUInt(), false);
sReasonArg = sArgs;
}
// Load Reason
if (!sReasonArg.empty()) {
SetReason(sReasonArg);
} else {
CString sSavedReason = GetNV("reason");
if (!sSavedReason.empty())
SetReason(sSavedReason, false);
}
// Set away on load, required if loaded via webadmin
if (GetNetwork()->IsIRCConnected() && !GetNetwork()->IsUserAttached())
SetAway(false);
return true;
}
BaseBulkRound::BaseBulkRound(const Group &group,
const PrivateIdentity &ident,
const Id &round_id,
const QSharedPointer<Network> &network,
GetDataCallback &get_data,
const QSharedPointer<BuddyMonitor> &bm,
CreateRound create_shuffle) :
Round(group, ident, round_id, network, get_data, bm),
_get_shuffle_data(this, &BaseBulkRound::GetShuffleData)
{
QVariantHash headers = GetNetwork()->GetHeaders();
headers["bulk"] = true;
GetNetwork()->SetHeaders(headers);
QSharedPointer<Network> net(GetNetwork()->Clone());
headers["bulk"] = false;
net->SetHeaders(headers);
Id sr_id(Hash().ComputeHash(GetRoundId().GetByteArray()));
_shuffle_round = create_shuffle(GetGroup(), GetPrivateIdentity(), sr_id, net,
_get_shuffle_data, bm);
_shuffle_round->SetSink(&_shuffle_sink);
QObject::connect(_shuffle_round.data(), SIGNAL(Finished()),
this, SLOT(SlotShuffleFinished()));
}
void CMyV8Handler::setTransInfo( CString strContent )
{
string content=slnhelper::wchar2utf8(wstring(strContent));
int dtm=0;
int dpm=0;
int utm=0;
int upm=0;
cJSON *root;
root = cJSON_Parse(content.c_str());
if(root!=NULL)
{
cJSON *j = root->child;
while (j != NULL)
{
string key= string(j->string);
if (key=="download_task_max")
{
dtm=j->valueint;
}
else if (key=="download_peer_max")
{
dpm=j->valueint;
}
else if (key=="upload_task_max")
{
utm=j->valueint;
}
else if (key=="upload_peer_max")
{
upm=j->valueint;
}
else
{
}
j=j->next;
}
cJSON_Delete(root);
}
if (dtm>0)
{
GetUserDb()->SetDownloadMax(dtm);
GetNetwork()->SetDTaskMax(dtm);
}
if (utm>0)
{
GetUserDb()->SetUploadMax(utm);
GetNetwork()->SetUTaskMax(utm);
}
if (dpm>0)
{
GetUserDb()->SetDownloadPeerMax(dpm);
GetNetwork()->SetDPeerMax(dpm);
}
if (upm>0)
{
GetUserDb()->SetUploadPeerMax(upm);
GetNetwork()->SetUPeerMax(upm);
}
}
int CAI_TacticalServices::FindBackAwayNode(const Vector &vecThreat )
{
if ( !CAI_NetworkManager::NetworksLoaded() )
{
DevWarning( 2, "Graph not ready for FindBackAwayNode!\n" );
return NO_NODE;
}
int iMyNode = GetPathfinder()->NearestNodeToNPC();
int iThreatNode = GetPathfinder()->NearestNodeToPoint( vecThreat );
if ( iMyNode == NO_NODE )
{
DevWarning( 2, "FindBackAwayNode() - %s has no nearest node!\n", GetEntClassname());
return NO_NODE;
}
if ( iThreatNode == NO_NODE )
{
// DevWarning( 2, "FindBackAwayNode() - Threat has no nearest node!\n" );
iThreatNode = iMyNode;
// return false;
}
// A vector pointing to the threat.
Vector vecToThreat;
vecToThreat = vecThreat - GetLocalOrigin();
// Get my current distance from the threat
float flCurDist = VectorNormalize( vecToThreat );
// Check my neighbors to find a node that's further away
for (int link = 0; link < GetNetwork()->GetNode(iMyNode)->NumLinks(); link++)
{
CAI_Link *nodeLink = GetNetwork()->GetNode(iMyNode)->GetLinkByIndex(link);
if ( !m_pPathfinder->IsLinkUsable( nodeLink, iMyNode ) )
continue;
int destID = nodeLink->DestNodeID(iMyNode);
float flTestDist = ( vecThreat - GetNetwork()->GetNode(destID)->GetPosition(GetHullType()) ).Length();
if ( flTestDist > flCurDist )
{
// Make sure this node doesn't take me past the enemy's position.
Vector vecToNode;
vecToNode = GetNetwork()->GetNode(destID)->GetPosition(GetHullType()) - GetLocalOrigin();
VectorNormalize( vecToNode );
if( DotProduct( vecToNode, vecToThreat ) < 0.0 )
{
return destID;
}
}
}
return NO_NODE;
}
EModRet OnRaw(CString& sLine) override {
if (sLine.StartsWith("ERROR ")) {
//ERROR :Closing Link: nick[24.24.24.24] (Excess Flood)
//ERROR :Closing Link: nick[24.24.24.24] Killer (Local kill by Killer (reason))
CString sError(sLine.substr(6));
if (sError.Left(1) == ":")
sError.LeftChomp();
Log("[" + GetUser()->GetUserName() + "/" + GetNetwork()->GetName() + "] disconnected from IRC: " +
GetNetwork()->GetCurrentServer()->GetName() + " [" + sError + "]", LOG_NOTICE);
}
return CONTINUE;
}
void CUploadTask::Finish()
{
if(m_bStop)
return;
m_bStop=true;
GetNetwork()->m_TransDb.Update_UploadStatus(m_Item.strPathhash,TRANSTASK_FINISH);
DeleteMultipartFile();
RegularItem item;
if (GetNetwork()->m_Regular.CheckRegular(m_Item.strBucket,m_Item.strObject,item))
{
CallbackUrlInfo(item);
}
m_Item.nStatus=TRANSTASK_FINISH;
GetCallbackUploadThread()->SendCallbackInfo(m_Item);
}
EModRet OnUserRaw(CString& sLine) override {
// Handle ISON
if (sLine.Token(0).Equals("ison")) {
VCString vsNicks;
// Get the list of nicks which are being asked for
sLine.Token(1, true).TrimLeft_n(":").Split(" ", vsNicks, false);
CString sBNCNicks;
for (const CString& sNick : vsNicks) {
if (IsOnlineModNick(sNick)) {
sBNCNicks += " " + sNick;
}
}
// Remove the leading space
sBNCNicks.LeftChomp();
if (!GetNetwork()->GetIRCSock()) {
// if we are not connected to any IRC server, send
// an empty or module-nick filled response.
PutUser(":irc.znc.in 303 " + GetClient()->GetNick() + " :" +
sBNCNicks);
} else {
// We let the server handle this request and then act on
// the 303 response from the IRC server.
m_ISONRequests.push_back(sBNCNicks);
}
}
// Handle WHOIS
if (sLine.Token(0).Equals("whois")) {
CString sNick = sLine.Token(1);
if (IsOnlineModNick(sNick)) {
CIRCNetwork* pNetwork = GetNetwork();
PutUser(":znc.in 311 " + pNetwork->GetCurNick() + " " + sNick +
" znc znc.in * :" + sNick);
PutUser(":znc.in 312 " + pNetwork->GetCurNick() + " " + sNick +
" *.znc.in :Bouncer");
PutUser(":znc.in 318 " + pNetwork->GetCurNick() + " " + sNick +
" :End of /WHOIS list.");
return HALT;
}
}
return CONTINUE;
}
void HandleMessage(CNick& Nick, const CString& sMessage) {
CString sNickServName = (!GetNV("NickServName").empty())
? GetNV("NickServName")
: "NickServ";
if (!GetNV("Password").empty() && Nick.NickEquals(sNickServName) &&
(sMessage.find("msg") != CString::npos ||
sMessage.find("authenticate") != CString::npos ||
sMessage.find("choose a different nickname") != CString::npos ||
sMessage.find("please choose a different nick") != CString::npos ||
sMessage.find("If this is your nick, identify yourself with") !=
CString::npos ||
sMessage.find("If this is your nick, type") != CString::npos ||
sMessage.find("This is a registered nickname, please identify") !=
CString::npos ||
sMessage.StripControls_n().find(
"type /NickServ IDENTIFY password") != CString::npos ||
sMessage.StripControls_n().find(
"type /msg NickServ IDENTIFY password") != CString::npos) &&
sMessage.AsUpper().find("IDENTIFY") != CString::npos &&
sMessage.find("help") == CString::npos) {
MCString msValues;
msValues["password"] = GetNV("Password");
PutIRC(CString::NamedFormat(GetNV("IdentifyCmd"), msValues));
} else if(Nick.NickEquals(sNickServName) && m_bJoinAfterIdentified &&
(sMessage.find("Password accepted") != CString::npos ||
sMessage.find("now recognized") != CString::npos ||
sMessage.find("now identified") != CString::npos ||
sMessage.find("now logged in as") != CString::npos)) {
m_bIdentified = true;
GetNetwork()->JoinChans();
}
}
void OnPart(const CNick& Nick, CChan& Channel,
const CString& sMessage) override {
if (Channel.InConfig() &&
GetNetwork()->GetIRCNick().NickEquals(Nick.GetNick())) {
Channel.SetInConfig(false);
}
}
void VisionApp::AddIgnoreNick(const char* network, const char* nick, bool exclude)
{
// in case user has deleted the network in question, unlikely but better safe than sorry
BMessage netMsg(GetNetwork(network));
if (!netMsg.HasString("name")) return;
char optype[8];
memset(optype, 0, sizeof(optype));
if (exclude) {
strcpy(optype, "exclude");
} else {
strcpy(optype, "ignore");
}
type_code type;
int32 attrCount;
// make sure this nick hasn't already been added
netMsg.GetInfo(optype, &type, &attrCount);
for (int32 i = 0; i < attrCount; i++) {
if (!strcmp(netMsg.FindString(optype, i), nick)) return;
}
netMsg.AddString(optype, nick);
SetNetwork(network, &netMsg);
}
void Handle(const CString& sNick) {
CIRCSock *pIRCSock = GetNetwork()->GetIRCSock();
if (!pIRCSock)
// WTF?
return;
if (sNick == pIRCSock->GetNick())
return;
if (m_Messaged.HasItem(sNick))
return;
if (GetNetwork()->IsUserAttached())
return;
m_Messaged.AddItem(sNick);
PutIRC("NOTICE " + sNick + " :" + GetReply());
}
void CheckRequireAuth() {
if (!m_bAuthenticated && GetNV(NV_REQUIRE_AUTH).ToBool()) {
GetNetwork()->SetIRCConnectEnabled(false);
PutModule("Disabling network, we require authentication.");
PutModule("Use 'RequireAuth no' to disable.");
}
}
CUser* CUserManager::CreateUser( )
{
/*
CUserBuffer:
We merge both classes of the internal server and the exe into one:
1 'User'
+-------------------+------------------------+
| sizeof( CUser ) | sizeof( CTestUser ) |
+-------------------+-------------------------
*/
auto pNetImpl = GetNetwork( )->GetNetImpl( );
size_t nImplSize = pNetImpl->GetUserSize( );
BYTE* pBuffer = new BYTE[ sizeof( CUser ) + nImplSize ];
BYTE* pBufferPos = pBuffer;
WSocket::IUserImpl* pUserImpl = pNetImpl->ConstructUser( pBufferPos + sizeof( CUser ) );
CUser* pUser = new ( pBufferPos )CUser( pUserImpl );
return pUser;
}
/*
status：1代表开启，0代表关闭
*/
void CMyV8Handler::setCallFunctionInfo( CString strContent )
{
string content=slnhelper::wchar2utf8(wstring(strContent));
RegularItem item;
cJSON *root;
root = cJSON_Parse(content.c_str());
if(root!=NULL)
{
cJSON *j = root->child;
while (j != NULL)
{
string key= string(j->string);
if (key=="bucket")
{
if(j->valuestring)
item.strBucket=slnhelper::utf82wchar(j->valuestring);
}
else if (key=="regular")
{
if(j->valuestring)
item.strRegular=slnhelper::utf82wchar(j->valuestring);
}
else if (key=="url")
{
if(j->valuestring)
item.strUrl=slnhelper::utf82wchar(j->valuestring);
}
else if (key=="status")
{
item.nStatus=j->valueint;
}
else if (key=="num")
{
item.nNum=j->valueint;
}
else
{
}
j=j->next;
}
cJSON_Delete(root);
}
GetNetwork()->m_TransDb.AddRegular(item);
GetNetwork()->m_Regular.AddRegular(item);
}
int main(int argc, char **argv) {
if (argc == 1) {
PrintHelp();
return 0;
}
int network = atoi(argv[1]);
int num_comms = 3;
int triple_type = D3CS;
int cut_type = D3C_COND;
std::string name = NetworkStr(network);
{
Network net = GetNetwork(network, triple_type);
Cutter cutter(net, 0, cut_type, name + "_cocluster_u");
std::string file = "data/" + name + "_u";
std::vector<double> vals = ReadVector<double>(file);
Vector<double> u_vals(vals.size());
for (int i = 0; i < vals.size(); ++i) {
u_vals(i) = vals[i];
}
std::vector<int> order = GetSortedOrder(u_vals);
WriteVector(order, name + "_cocluster_u_order.txt");
//std::vector<int> cut = cutter.GetCut(order);
}
{
Network net = GetNetwork(network, triple_type);
Cutter cutter(net, 0, cut_type, name + "_cocluster_v");
std::string file = "data/" + name + "_v";
std::vector<double> vals = ReadVector<double>(file);
Vector<double> v_vals(vals.size());
for (int i = 0; i < vals.size(); ++i) {
v_vals(i) = vals[i];
}
std::vector<int> order = GetSortedOrder(v_vals);
WriteVector(order, name + "_cocluster_v_order.txt");
//std::vector<int> cut = cutter.GetCut(order);
}
std::cout << "END ---------" << std::endl;
}
void EmptyRound::OnStart()
{
qDebug() << "Starting empty round.";
Round::OnStart();
QPair<QByteArray, bool> data = GetData(1024);
GetNetwork()->Broadcast(data.first);
SetSuccessful(true);
Stop("Round successfully finished.");
}
void TwitchTMI::PutUserChanMessage(CChan *chan, const CString &from, const CString &msg)
{
std::stringstream ss;
ss << ":" << from << " PRIVMSG " << chan->GetName() << " :";
CString s = ss.str();
PutUser(s + msg);
if(!chan->AutoClearChanBuffer() || !GetNetwork()->IsUserOnline() || chan->IsDetached())
chan->AddBuffer(s + "{text}", msg);
}
status_t
BNetworkDevice::GetNextAssociatedNetwork(uint32& cookie,
wireless_network& network)
{
BNetworkAddress address;
status_t status = GetNextAssociatedNetwork(cookie, address);
if (status != B_OK)
return status;
return GetNetwork(address, network);
}
virtual void OnKick(const CNick& OpNick, const CString& sKickedNick, CChan& pChan, const CString& sMessage) override {
if (GetNetwork()->GetCurNick().Equals(sKickedNick)) {
if (!delay) {
PutIRC("JOIN " + pChan.GetName() + " " + pChan.GetKey());
pChan.Enable();
return;
}
AddTimer(new CRejoinJob(this, delay, 1, "Rejoin " + pChan.GetName(),
"Rejoin channel after a delay"));
}
}
//=========================================================
// Selecciona un nodo candidato al azar.
//=========================================================
CAI_Node *CDirector_Manager::GetRandomNode()
{
// No hay nodos candidatos.
if ( SpawnNodes.Count() == 0 )
return NULL;
int iNode = RandomInt(0, SpawnNodes.Count() - 1);
CAI_Node *pNode = GetNetwork()->GetNode(SpawnNodes[iNode]);
return pNode;
}
bool CUploadTask::CreateMultipartFile()
{
wstring multipartpath=wstring(GetStaroneControl()->GetTransCache())+m_Item.strUploadId;
bool ret;
TRY
{
BOOL res =m_FileIndex.Open(multipartpath.c_str(),CFile::modeCreate|CFile::modeNoTruncate|CFile::modeReadWrite|CFile::shareDenyNone);
if (res)
{
ULONGLONG length=m_FileIndex.GetLength();
if (length!=0&&(length%UPLOADPARTSIZE)==0)
{
char * buffer=new char[length];
int size=m_FileIndex.Read(buffer,length);
if (size!=length)
{
ret=false;
if(buffer)
delete buffer;
return ret;
}
for (int i=0;i<length/UPLOADPARTSIZE;i++)
{
char * temp=(char*)(buffer+i*UPLOADPARTSIZE);
oss_uploadpart item;
item.nIndex=*(int*)temp;
item.ullPos=*(ULONGLONG*)(temp+4);
item.ullSize=*(ULONGLONG*)(temp+12);
item.strEtag=slnhelper::utf82wchar(string(temp+20,34));
m_PartList.push_back(item);
m_UnFinish.RemovePairs(item.ullPos,item.ullPos+item.ullSize-1);
m_Finish.InsertPair(item.ullPos,item.ullPos+item.ullSize-1);
}
if (buffer)
delete buffer;
}
else
{
m_PartList.clear();
}
m_Item.ullOffset=m_Finish.Size();
GetNetwork()->m_TransDb.Update_UploadOffset(m_Item.strPathhash,m_Item.ullOffset);
ret=true;
}
else
ret=false;
return ret;
}
CATCH (CException, e)
{
}
END_CATCH
return false;
}
bool IsOnlineModNick(const CString& sNick) {
const CString& sPrefix = GetUser()->GetStatusPrefix();
if (!sNick.StartsWith(sPrefix)) return false;
CString sModNick = sNick.substr(sPrefix.length());
if (sModNick.Equals("status") ||
GetNetwork()->GetModules().FindModule(sModNick) ||
GetUser()->GetModules().FindModule(sModNick) ||
CZNC::Get().GetModules().FindModule(sModNick))
return true;
return false;
}
EModRet OnNumericMessage(CNumericMessage& msg) override {
if (msg.GetCode() == 903) {
/* SASL success! */
if (m_bVerbose) {
PutModule(m_Mechanisms.GetCurrent() + " mechanism succeeded.");
}
GetNetwork()->GetIRCSock()->ResumeCap();
m_bAuthenticated = true;
DEBUG("sasl: Authenticated with mechanism ["
<< m_Mechanisms.GetCurrent() << "]");
} else if (msg.GetCode() == 904 ||
msg.GetCode() == 905) {
DEBUG("sasl: Mechanism [" << m_Mechanisms.GetCurrent()
<< "] failed.");
if (m_bVerbose) {
PutModule(m_Mechanisms.GetCurrent() + " mechanism failed.");
}
if (m_Mechanisms.HasNext()) {
m_Mechanisms.IncrementIndex();
PutIRC("AUTHENTICATE " + m_Mechanisms.GetCurrent());
} else {
CheckRequireAuth();
GetNetwork()->GetIRCSock()->ResumeCap();
}
} else if (msg.GetCode() == 906) {
/* CAP wasn't paused? */
DEBUG("sasl: Reached 906.");
CheckRequireAuth();
} else if (msg.GetCode() == 907) {
m_bAuthenticated = true;
GetNetwork()->GetIRCSock()->ResumeCap();
DEBUG("sasl: Received 907 -- We are already registered");
} else {
return CONTINUE;
}
return HALT;
}
void CUploadTask::TaskError( int error,wstring errormsg )
{
if(m_bStop)
return;
CString strMsg;
strMsg.Format(_T("[TaskError:%s|%s][%d,%s]"),m_Item.strBucket.c_str(),m_Item.strObject.c_str(),error,errormsg.c_str());
CFileLog::GetInstance()->Log(wstring(strMsg),true);
GetNetwork()->m_TransDb.Update_UploadError(m_Item.strPathhash,error,errormsg);
m_bStop=true;
m_Item.nStatus=TRANSTASK_ERROR;
m_Item.strMsg=errormsg;
m_Item.nErrorNum=error;
GetCallbackUploadThread()->SendCallbackInfo(m_Item);
}
bool OnLoad(const CString& sArgsi, CString& sMessage) override {
switch (GetType()) {
case CModInfo::GlobalModule:
LoadUsers();
break;
case CModInfo::UserModule:
LoadUser(GetUser());
break;
case CModInfo::NetworkModule:
LoadNetwork(GetNetwork());
break;
}
return true;
}
EModRet OnUserRaw(CString& sLine) override {
CString sCmd = sLine.Token(0).AsUpper();
if (!GetNetwork()->GetIRCSock()) return CONTINUE;
if (sCmd.Equals("MODE")) {
// Check if this is a mode request that needs to be handled
// If there are arguments to a mode change,
// we must not route it.
if (!sLine.Token(3, true).empty()) return CONTINUE;
// Grab the mode change parameter
CString sMode = sLine.Token(2);
// If this is a channel mode request, znc core replies to it
if (sMode.empty()) return CONTINUE;
// Check if this is a mode change or a specific
// mode request (the later needs to be routed).
sMode.TrimPrefix("+");
if (sMode.length() != 1) return CONTINUE;
// Now just check if it's one of the supported modes
switch (sMode[0]) {
case 'I':
case 'b':
case 'e':
break;
default:
return CONTINUE;
}
// Ok, this looks like we should route it.
// Fall through to the next loop
}
for (size_t i = 0; vRouteReplies[i].szRequest != nullptr; i++) {
if (vRouteReplies[i].szRequest == sCmd) {
struct queued_req req = {sLine, vRouteReplies[i].vReplies};
m_vsPending[GetClient()].push_back(req);
SendRequest();
return HALTCORE;
}
}
return CONTINUE;
}
bool TwitchTMI::OnLoad(const CString& sArgsi, CString& sMessage)
{
OnBoot();
if(GetNetwork())
{
for(CChan *ch: GetNetwork()->GetChans())
{
ch->SetTopic(CString());
CString chname = ch->GetName().substr(1);
CThreadPool::Get().addJob(new TwitchTMIJob(this, chname));
}
}
if(GetArgs().Token(0) != "FrankerZ")
lastFrankerZ = std::numeric_limits<decltype(lastFrankerZ)>::max();
PutIRC("CAP REQ :twitch.tv/membership");
PutIRC("CAP REQ :twitch.tv/commands");
PutIRC("CAP REQ :twitch.tv/tags");
return true;
}
void VisionApp::RemoveNotifyNick(const char* network, const char* nick)
{
BMessage netMsg(GetNetwork(network));
type_code type;
int32 attrCount, i;
netMsg.GetInfo("notify", &type, &attrCount);
for (i = 0; i < attrCount; i++) {
if (!strcasecmp(netMsg.FindString("notify", i), nick)) {
netMsg.RemoveData("notify", i);
break;
}
}
if (i < attrCount) SetNetwork(network, &netMsg);
}
