mirror-games/glest-source
1
0
Fork 0
mirror of https://github.com/glest/glest-source.git synced 2025-09-30 17:39:02 +02:00
Code Issues Projects Releases Wiki Activity
Files
35b7b1f1a61c61cc5c2b1beaa5ecd02b5d402d07
glest-source/source/shared_lib/sources/platform/posix/ircclient.cpp
mathusummut 35b7b1f1a6 Fixed the god-awful indentation
2018-05-06 00:01:36 +02:00

1100 lines
41 KiB
C++
Raw Blame History

// ==============================================================
// This file is part of MegaGlest Shared Library (www.glest.org)
//
// Copyright (C) 2009-2010 Titus Tscharntke (info@titusgames.de) and
// Mark Vejvoda (mark_vejvoda@hotmail.com)
//
// You can redistribute this code and/or modify it under
// the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version
// ==============================================================
#include "ircclient.h"
#include "util.h"
#include "platform_common.h"
#include "socket.h"
#include "cache_manager.h"
#if !defined(DISABLE_IRCCLIENT)
#include <libircclient.h>
// upstream moved some defines into new headers as of 1.6
#ifndef LIBIRCCLIENT_PRE1_6
#include <libirc_rfcnumeric.h>
#endif
#endif
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include "conversion.h"
using namespace Shared::Util;
using namespace Shared::PlatformCommon;
namespace Shared {
namespace PlatformCommon {
const char *IRCThread::globalCacheContainerName = NULL;
const int IRC_SERVER_PORT = 6667;
//bool IRCThread::debugEnabled = true;
bool IRCThread::debugEnabled = false;
#if !defined(DISABLE_IRCCLIENT)
void addlog(const char * fmt, ...) {
//FILE * fp;
char buf[8096];
va_list va_alist;
va_start(va_alist, fmt);
#if defined (WIN32)
_vsnprintf(buf, sizeof(buf), fmt, va_alist);
#else
vsnprintf(buf, sizeof(buf), fmt, va_alist);
#endif
va_end(va_alist);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: %s\n", buf);
//if(SystemFlags::VERBOSE_MODE_ENABLED == true) {
// if ( (fp = fopen ("irctest.log", "ab")) != 0 ) {
// fprintf (fp, "%s\n", buf);
// fclose (fp);
// }
//}
}
void dump_event(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
char buf[512] = "";
unsigned int cnt = 0;
buf[0] = '\0';
for (cnt = 0; cnt < count; cnt++) {
if (cnt) {
strcat(buf, "|");
}
#ifdef WIN32
strncat(buf, params[cnt], min((int) strlen(params[cnt]), 511));
#else
strncat(buf, params[cnt], std::min((int) strlen(params[cnt]), 511));
#endif
}
addlog("Event \"%s\", origin: \"%s\", params: %d [%s]", event, origin ? origin : "NULL", cnt, buf);
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
if (ctx != NULL) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (ctx->getQuitStatus()) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
return;
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (difftime(time(NULL), ctx->getLastNickListUpdate()) >= 7) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
ctx->setLastNickListUpdate(time(NULL));
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
ctx->GetIRCConnectedNickList(ctx->getChannel(), false);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
}
}
void get_nickname(const char *sourceNick, char *destNick, size_t maxDestBufferSize) {
string sourceNickStr = sourceNick;
if (sourceNickStr != "" && sourceNickStr[0] == '@') {
sourceNickStr.erase(0, 1);
}
irc_target_get_nick(sourceNickStr.c_str(), destNick, maxDestBufferSize);
}
void event_notice(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
dump_event(session, event, origin, params, count);
if (origin == NULL) {
return;
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("NOTICE from '%s': %s", origin, params[1]);
//if(strcasecmp (origin, "nickserv")) {
// return;
//}
if (strstr(params[1], "This nick is not registered") == params[1]) {
//std::string regcmd = "REGISTER " + gCfg.irc_nickserv_pass + " NOMAIL";
//gLog.Add (CLog::INFO, "Registering our nick with NICKSERV");
//irc_cmd_msg (session, "nickserv", regcmd.c_str());
} else if (strstr(params[1], "This nickname is registered and protected") == params[1]) {
//std::string identcmd = "IDENTIFY " + gCfg.irc_nickserv_pass;
//gLog.Add (CLog::INFO, "Identifying our nick with NICKSERV");
//irc_cmd_msg (session, "nickserv", identcmd.c_str());
// IRCThread *ctx = (IRCThread *)irc_get_ctx(session);
// if(ctx != NULL) {
// if(ctx->getExecute_cmd_onconnect() != "") {
// irc_cmd_msg(session, "nickserv", ctx->getExecute_cmd_onconnect().c_str());
// }
// }
} else if (strstr(params[1], "Password accepted - you are now recognized") == params[1]) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("Nickserv authentication succeed.");
}
}
void event_join(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
dump_event(session, event, origin, params, count);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (ctx != NULL) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (ctx->getHasJoinedChannel() == false) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
irc_cmd_user_mode(session, "+i");
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
//irc_cmd_msg (session, params[0], "MG Bot says hello!");
ctx->setHasJoinedChannel(true);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
//ctx->GetIRCConnectedNickList(ctx->getChannel(),true);
ctx->GetIRCConnectedNickList(ctx->getChannel(), false);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
} else {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
char realNick[128] = "";
get_nickname(origin, realNick, 127);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: user joined channel realNick [%s] origin [%s]\n", realNick, origin);
bool foundNick = false;
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
MutexSafeWrapper safeMutex(ctx->getMutexNickList(), string(__FILE__) + "_" + intToStr(__LINE__));
std::vector<string> nickList = ctx->getCachedNickList();
for (unsigned int i = 0;
i < nickList.size(); ++i) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: looking for match [%s] realNick [%s]\n", nickList[i].c_str(), realNick);
if (nickList[i] == realNick) {
foundNick = true;
break;
}
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (foundNick == false) {
nickList.push_back(realNick);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (ctx->getWantToLeaveChannel() == true) {
ctx->leaveChannel();
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
}
}
void event_connect(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
dump_event(session, event, origin, params, count);
//IRC: Event "433", origin: "leguin.freenode.net", params: 3 [*|softcoder|Nickname is already in use.]
// printf("In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__);
// if(strstr (params[1], "Nickname is already in use") == params[1]) {
// IRCThread *ctx = (IRCThread *)irc_get_ctx(session);
// if(ctx != NULL) {
// if(ctx->getExecute_cmd_onconnect() != "") {
// irc_cmd_msg(session, "nickserv", ctx->getExecute_cmd_onconnect().c_str());
// }
// }
// }
// else
if (ctx != NULL) {
irc_cmd_join(session, ctx->getChannel().c_str(), 0);
}
}
void event_privmsg(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
dump_event(session, event, origin, params, count);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("'%s' said me (%s): %s\n", origin ? origin : "someone", params[0], params[1]);
}
void dcc_recv_callback(irc_session_t * session, irc_dcc_t id, int status, void * ctx, const char * data, unsigned int length) {
switch (status) {
case LIBIRC_ERR_CLOSED:
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("DCC %d: chat closed\n", id);
break;
case 0:
if (!data) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("DCC %d: chat connected\n", id);
irc_dcc_msg(session, id, "Hehe");
} else {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("DCC %d: %s\n", id, data);
static int count = 1;
char buf[12] = "";
sprintf(buf, "DCC [%d]: %d", id, count++);
irc_dcc_msg(session, id, buf);
}
break;
default:
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("DCC %d: error %s\n", id, irc_strerror(status));
break;
}
}
void dcc_file_recv_callback(irc_session_t * session, irc_dcc_t id, int status, void * ctx, const char * data, unsigned int length) {
if (status == 0 && length == 0) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("File sent successfully\n");
if (ctx) {
fclose((FILE*) ctx);
}
} else if (status) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("File sent error: %d\n", status);
if (ctx) {
fclose((FILE*) ctx);
}
} else {
if (ctx) {
fwrite(data, 1, length, (FILE*) ctx);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("File sent progress: %u\n", length);
}
}
void event_channel(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count) {
//IRC: Event "433", origin: "leguin.freenode.net", params: 3 [*|softcoder|Nickname is already in use.]
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("In [%s::%s] Line: %d count = %u origin = %s\n", __FILE__, __FUNCTION__, __LINE__, count, (origin ? origin : "null"));
if (count != 2)
return;
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: '%s' said in channel %s: %s\n", origin ? origin : "someone", params[0], params[1]);
if (!origin) {
return;
}
char realNick[128] = "";
get_nickname(origin, realNick, 127);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: event signalled realNick [%s] origin [%s]\n", realNick, origin);
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
if (ctx != NULL) {
MutexSafeWrapper safeMutex(ctx->getMutexIRCCB(), string(__FILE__) + "_" + intToStr(__LINE__));
IRCCallbackInterface *cb = ctx->getCallbackObj(false);
if (cb != NULL) {
cb->IRC_CallbackEvent(IRC_evt_chatText, realNick, params, count);
}
}
// if ( !strcmp (params[1], "quit") )
// irc_cmd_quit (session, "of course, Master!");
//
// if ( !strcmp (params[1], "help") ) {
// irc_cmd_msg (session, params[0], "quit, help, dcc chat, dcc send, ctcp");
// }
//
// if ( !strcmp (params[1], "ctcp") ) {
// irc_cmd_ctcp_request (session, realNick, "PING 223");
// irc_cmd_ctcp_request (session, realNick, "FINGER");
// irc_cmd_ctcp_request (session, realNick, "VERSION");
// irc_cmd_ctcp_request (session, realNick, "TIME");
// }
//
// if ( !strcmp (params[1], "dcc chat") ) {
// irc_dcc_t dccid;
// irc_dcc_chat (session, 0, realNick, dcc_recv_callback, &dccid);
// if(SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf ("DCC chat ID: %d\n", dccid);
// }
//
// if ( !strcmp (params[1], "dcc send") ) {
// irc_dcc_t dccid;
// irc_dcc_sendfile (session, 0, realNick, "irctest.c", dcc_file_recv_callback, &dccid);
// if(SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf ("DCC send ID: %d\n", dccid);
// }
//
// if ( !strcmp (params[1], "topic") ) {
// irc_cmd_topic (session, params[0], 0);
// }
// else if ( strstr (params[1], "topic ") == params[1] ) {
// irc_cmd_topic (session, params[0], params[1] + 6);
// }
//
// if ( strstr (params[1], "mode ") == params[1] )
// irc_cmd_channel_mode (session, params[0], params[1] + 5);
//
// if ( strstr (params[1], "nick ") == params[1] )
// irc_cmd_nick (session, params[1] + 5);
//
// if ( strstr (params[1], "whois ") == params[1] )
// irc_cmd_whois (session, params[1] + 5);
}
void irc_event_dcc_chat(irc_session_t * session, const char * nick, const char * addr, irc_dcc_t dccid) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("DCC chat [%d] requested from '%s' (%s)\n", dccid, nick, addr);
irc_dcc_accept(session, dccid, 0, dcc_recv_callback);
}
void irc_event_dcc_send(irc_session_t * session, const char * nick, const char * addr, const char * filename, unsigned long size, irc_dcc_t dccid) {
FILE * fp;
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("DCC send [%d] requested from '%s' (%s): %s (%lu bytes)\n", dccid, nick, addr, filename, size);
if ((fp = fopen("file", "wb")) == 0) {
abort();
}
irc_dcc_accept(session, dccid, fp, dcc_file_recv_callback);
}
void event_leave(irc_session_t *session, const char *event, const char *origin, const char ** params, unsigned count) {
char buf[24] = "";
sprintf(buf, "%s", event);
// someone left the channel.
if (origin) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: user left channel [%s]\n", origin);
char realNick[128] = "";
get_nickname(origin, realNick, 127);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: user left channel realNick [%s] origin [%s]\n", realNick, origin);
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
if (ctx != NULL) {
MutexSafeWrapper safeMutex(ctx->getMutexNickList(), string(__FILE__) + "_" + intToStr(__LINE__));
std::vector<string> &nickList = ctx->getCachedNickList();
for (unsigned int i = 0;
i < nickList.size(); ++i) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: lookingfor match [%s] realNick [%s]\n", nickList[i].c_str(), realNick);
if (nickList[i] == realNick) {
nickList.erase(nickList.begin() + i);
break;
}
}
}
}
dump_event(session, buf, origin, params, count);
}
void event_numeric(irc_session_t * session, unsigned int event, const char * origin, const char ** params, unsigned int count) {
char buf[24] = "";
sprintf(buf, "%u", event);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d event = %u\n", __LINE__, event);
switch (event) {
case LIBIRC_RFC_ERR_NICKNAMEINUSE:
case LIBIRC_RFC_ERR_NICKCOLLISION:
//irc_auto_rename_nick(session);
//IRCThread *ctx = (IRCThread *)irc_get_ctx(session);
//if(ctx != NULL) {
// {
// //IRC: Event "433", origin: "leguin.freenode.net", params: 3 [*|softcoder|Nickname is already in use.]
// printf("In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__);
// //if(strstr (params[1], "Nickname is already in use") == params[1]) {
// IRCThread *ctx = (IRCThread *)irc_get_ctx(session);
// if(ctx != NULL) {
// if(ctx->getExecute_cmd_onconnect() != "") {
// irc_cmd_msg(session, "nickserv", ctx->getExecute_cmd_onconnect().c_str());
// }
// }
// //}
// }
break;
case LIBIRC_RFC_ERR_NOTREGISTERED:
//irc_auto_rename_nick(session);
//IRCThread *ctx = (IRCThread *)irc_get_ctx(session);
//if(ctx != NULL) {
// {
//===> IRC: Event "451", origin: "leguin.freenode.net", params: 2 [*|You have not registered]
// printf("In [%s::%s] Line: %d\n",__FILE__,__FUNCTION__,__LINE__);
// //if(strstr (params[1], "Nickname is already in use") == params[1]) {
// IRCThread *ctx = (IRCThread *)irc_get_ctx(session);
// if(ctx != NULL) {
// //if(ctx->getExecute_cmd_onconnect() != "") {
// //irc_cmd_msg(session, "nickserv", ctx->getExecute_cmd_onconnect().c_str());
// string cmd = "REGISTER " + ctx->getNick() + " NOMAIL";
// irc_cmd_msg (session, "nickserv", cmd.c_str());
// //}
// }
// //}
// }
break;
case LIBIRC_RFC_RPL_TOPIC:
break;
case LIBIRC_RFC_RPL_NAMREPLY:
{
if (event == LIBIRC_RFC_RPL_NAMREPLY) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: LIBIRC_RFC_RPL_NAMREPLY count = %u\n", count);
std::vector<string> nickList;
if (count >= 4) {
for (unsigned int i = 3; i < count && params[i]; ++i) {
vector<string> tokens;
Tokenize(params[i], tokens, " ");
for (unsigned int j = 0; j < tokens.size(); ++j) {
char realNick[128] = "";
get_nickname(tokens[j].c_str(), realNick, 127);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: LIBIRC_RFC_RPL_NAMREPLY user joined channel realNick [%s] tokens[j] [%s]\n", realNick, tokens[j].c_str());
// Only show MegaGlest users in the user list
//if(strncmp(&realNick[0],"MG_",3) == 0) {
nickList.push_back(realNick);
//}
}
}
}
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
if (ctx != NULL) {
MutexSafeWrapper safeMutex(ctx->getMutexNickList(), string(__FILE__) + "_" + intToStr(__LINE__));
ctx->setCachedNickList(nickList);
}
}
break;
}
case LIBIRC_RFC_RPL_ENDOFNAMES:
{
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("!!!!! ===> IRC: Line: %d event = %u\n", __LINE__, event);
IRCThread *ctx = (IRCThread *) irc_get_ctx(session);
if (ctx != NULL) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d event = %u\n", __LINE__, event);
ctx->setEventDataDone(true);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d event = %u\n", __LINE__, event);
}
break;
}
dump_event(session, buf, origin, params, count);
}
#endif
bool IRCThread::getEventDataDone() {
MutexSafeWrapper safeMutex(&mutexEventDataDone, string(__FILE__) + "_" + intToStr(__LINE__));
bool result = eventDataDone;
safeMutex.ReleaseLock();
return result;
}
void IRCThread::setEventDataDone(bool value) {
MutexSafeWrapper safeMutex(&mutexEventDataDone, string(__FILE__) + "_" + intToStr(__LINE__));
eventDataDone = value;
}
IRCThread::IRCThread(const std::vector<string> &argv, IRCCallbackInterface *callbackObj) : BaseThread() {
uniqueID = "IRCThread";
this->argv = argv;
this->callbackObj = callbackObj;
ircSession = NULL;
eventData.clear();
setEventDataDone(false);
hasJoinedChannel = false;
lastNickListUpdate = time(NULL);
wantToLeaveChannel = false;
playerName = "";
glestVersionString = "";
}
void IRCThread::disconnect() {
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutex.ReleaseLock();
if (validSession == true) {
setCallbackObj(NULL);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Quitting Channel\n");
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
if (ircSession != NULL) {
irc_disconnect(ircSession);
}
safeMutex1.ReleaseLock();
BaseThread::signalQuit();
hasJoinedChannel = false;
}
#else
BaseThread::signalQuit();
#endif
}
void IRCThread::signalQuit() {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: signalQuit [%p]\n", ircSession);
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutex.ReleaseLock();
if (validSession == true) {
setCallbackObj(NULL);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Quitting Channel\n");
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
if (ircSession != NULL) {
irc_cmd_quit(ircSession, "ZG Bot is closing!");
}
safeMutex1.ReleaseLock();
hasJoinedChannel = false;
}
BaseThread::signalQuit();
#else
BaseThread::signalQuit();
#endif
}
bool IRCThread::shutdownAndWait() {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: shutdownAndWait [%p]\n", ircSession);
signalQuit();
return BaseThread::shutdownAndWait();
}
void IRCThread::SendIRCCmdMessage(string target, string msg) {
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutex.ReleaseLock();
if (validSession == true && hasJoinedChannel == true) {
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] sending IRC command to [%s] cmd [%s]\n", __FILE__, __FUNCTION__, __LINE__, target.c_str(), msg.c_str());
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
int ret = 0;
if (ircSession != NULL) {
ret = irc_cmd_msg(ircSession, target.c_str(), msg.c_str());
}
safeMutex1.ReleaseLock();
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] sending IRC command to [%s] cmd [%s] ret = %d\n", __FILE__, __FUNCTION__, __LINE__, target.c_str(), msg.c_str(), ret);
#endif
}
}
std::vector<string> IRCThread::GetIRCConnectedNickList(string target, bool waitForCompletion) {
setEventDataDone(false);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
MutexSafeWrapper safeMutexSession(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutexSession.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (validSession == true && hasJoinedChannel == true) {
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] sending IRC nick list command to [%s]\n", __FILE__, __FUNCTION__, __LINE__, target.c_str());
#if !defined(DISABLE_IRCCLIENT)
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
int ret = irc_cmd_names(ircSession, target.c_str());
safeMutex1.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] sending IRC nick list command to [%s] ret = %d\n", __FILE__, __FUNCTION__, __LINE__, target.c_str(), ret);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (waitForCompletion == true) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
for (time_t tElapsed = time(NULL);
getEventDataDone() == false &&
this->getQuitStatus() == false &&
difftime(time(NULL), tElapsed) <= 5;) {
sleep(50);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
#endif
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
MutexSafeWrapper safeMutex(&mutexNickList, string(__FILE__) + "_" + intToStr(__LINE__));
std::vector<string> nickList = eventData;
safeMutex.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
return nickList;
}
bool IRCThread::isConnected(bool mutexLockRequired) {
bool ret = false;
if (this->getQuitStatus() == false) {
MutexSafeWrapper safeMutex(NULL, string(__FILE__) + "_" + intToStr(__LINE__));
int lockStatus = 0;
if (mutexLockRequired == true) {
lockStatus = safeMutex.setMutexAndTryLock(&mutexIRCSession);
}
bool validSession = (lockStatus == SDL_MUTEX_TIMEDOUT || (lockStatus == 0 && ircSession != NULL));
if (mutexLockRequired == true && lockStatus == 0) {
safeMutex.ReleaseLock();
}
if (validSession == true) {
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex1(NULL, string(__FILE__) + "_" + intToStr(__LINE__));
if (ircSession != NULL) {
lockStatus = 0;
if (mutexLockRequired == true) {
lockStatus = safeMutex1.setMutexAndTryLock(&mutexIRCSession);
}
ret = (lockStatus == SDL_MUTEX_TIMEDOUT || (lockStatus == 0 && irc_is_connected(ircSession) != 0));
}
if (mutexLockRequired == true && lockStatus == 0) {
safeMutex1.ReleaseLock();
}
}
#endif
}
return ret;
}
std::vector<string> IRCThread::getNickList() {
MutexSafeWrapper safeMutex(&mutexNickList, string(__FILE__) + "_" + intToStr(__LINE__));
std::vector<string> nickList = eventData;
safeMutex.ReleaseLock();
return nickList;
}
IRCCallbackInterface * IRCThread::getCallbackObj(bool lockObj) {
MutexSafeWrapper safeMutex(NULL, string(__FILE__) + "_" + intToStr(__LINE__));
if (lockObj == true) {
safeMutex.setMutex(&mutexIRCCB);
}
return callbackObj;
}
void IRCThread::setCallbackObj(IRCCallbackInterface *cb) {
MutexSafeWrapper safeMutex(&mutexIRCCB, string(__FILE__) + "_" + intToStr(__LINE__));
callbackObj = cb;
}
void IRCThread::execute() {
{
RunningStatusSafeWrapper runningStatus(this);
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] argv.size() = %d\n", __FILE__, __FUNCTION__, __LINE__, argv.size());
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: IRCThread::execute Line: %d\n", __LINE__);
if (getQuitStatus() == true) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
return;
}
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "IRC thread is running\n");
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
try {
#if !defined(DISABLE_IRCCLIENT)
irc_callbacks_t callbacks;
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
ircSession = NULL;
safeMutex.ReleaseLock(true);
if (argv.size() != 5) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC Usage: <server> <nick> <channel> : got params [%ld]\n", (long int) argv.size());
return;
}
memset(&callbacks, 0, sizeof(callbacks));
callbacks.event_connect = event_connect;
callbacks.event_join = event_join;
callbacks.event_nick = dump_event;
callbacks.event_quit = dump_event;
callbacks.event_part = event_leave;
callbacks.event_mode = dump_event;
callbacks.event_topic = dump_event;
callbacks.event_kick = dump_event;
callbacks.event_channel = event_channel;
callbacks.event_privmsg = event_privmsg;
callbacks.event_notice = event_notice;
callbacks.event_invite = dump_event;
callbacks.event_umode = dump_event;
callbacks.event_ctcp_rep = dump_event;
callbacks.event_ctcp_action = dump_event;
callbacks.event_unknown = dump_event;
callbacks.event_numeric = event_numeric;
callbacks.event_dcc_chat_req = irc_event_dcc_chat;
callbacks.event_dcc_send_req = irc_event_dcc_send;
if (this->getQuitStatus() == true) {
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
return;
}
safeMutex.Lock();
ircSession = irc_create_session(&callbacks);
bool validSession = (ircSession != NULL);
if (validSession == false) {
safeMutex.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC Could not create session\n");
return;
}
safeMutex.ReleaseLock(true);
// this->execute_cmd_onconnect = "";
// if(argv.size() >= 5) {
// this->execute_cmd_onconnect = argv[4]; // /msg NickServ identify <password>.
// }
// this->password = "";
// if(argv.size() >= 5) {
// this->password = argv[4];
// }
this->username = argv[1];
if (argv.size() >= 4) {
this->username = argv[3];
}
this->channel = argv[2];
this->nick = argv[1];
safeMutex.Lock();
irc_set_ctx(ircSession, this);
safeMutex.ReleaseLock(true);
if (this->getQuitStatus() == true) {
return;
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
safeMutex.Lock();
if (irc_connect(ircSession, argv[0].c_str(), IRC_SERVER_PORT, 0, this->nick.c_str(), this->username.c_str(), ("MegagGlest " + glestVersionString).c_str())) {
safeMutex.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC Could not connect: %s\n", irc_strerror(irc_errno(ircSession)));
return;
}
safeMutex.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
if (this->getQuitStatus() == true) {
return;
}
if (this->getQuitStatus() == true) {
return;
}
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
for (int iAttempts = 1;
this->getQuitStatus() == false && iAttempts <= 7; ++iAttempts) {
//if(irc_run(ircSession)) {
int run_result = irc_run_session(ircSession);
if (run_result && this->getQuitStatus() == false) {
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC Could not run the session: %s run_result = %d\n", irc_strerror(irc_errno(ircSession)), run_result);
printf("===> IRC Could not run the session: %s run_result = %d\n", irc_strerror(irc_errno(ircSession)), run_result);
}
}
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
#else
for (; this->getQuitStatus() == false;) {
sleep(50);
}
#endif
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC exiting IRC CLient!\n");
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
} catch (const exception &ex) {
SystemFlags::OutputDebug(SystemFlags::debugError, "In [%s::%s Line: %d] Error [%s]\n", __FILE__, __FUNCTION__, __LINE__, ex.what());
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] error [%s]\n", __FILE__, __FUNCTION__, __LINE__, ex.what());
} catch (...) {
SystemFlags::OutputDebug(SystemFlags::debugError, "In [%s::%s Line: %d] UNKNOWN Error\n", __FILE__, __FUNCTION__, __LINE__);
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] unknown error\n", __FILE__, __FUNCTION__, __LINE__);
}
if (SystemFlags::getSystemSettingType(SystemFlags::debugNetwork).enabled) SystemFlags::OutputDebug(SystemFlags::debugNetwork, "In [%s::%s Line: %d] IRC thread is exiting\n", __FILE__, __FUNCTION__, __LINE__);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
// Delete ourself when the thread is done (no other actions can happen after this
// such as the mutex which modifies the running status of this method
MutexSafeWrapper safeMutex(&mutexIRCCB, string(__FILE__) + "_" + intToStr(__LINE__));
IRCCallbackInterface *cb = getCallbackObj(false);
if (cb != NULL) {
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC: Line: %d\n", __LINE__);
cb->IRC_CallbackEvent(IRC_evt_exitThread, NULL, NULL, 0);
}
safeMutex.ReleaseLock();
}
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
if (SystemFlags::VERBOSE_MODE_ENABLED) printf("In IRCThread() calling delete ...\n");
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
setDeleteAfterExecute(true);
}
int IRCThread::irc_run_session(irc_session_t * session) {
// if ( session->state != LIBIRC_STATE_CONNECTING )
// {
// session->lasterror = LIBIRC_ERR_STATE;
// return 1;
// }
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
if (isConnected(false) == false) {
//session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
safeMutex.ReleaseLock(true);
bool isSessionConnected = true;
while (isSessionConnected == true && this->getQuitStatus() == false) {
struct timeval tv;
fd_set in_set, out_set;
int maxfd = 0;
tv.tv_usec = 250000;
tv.tv_sec = 0;
// Init sets
FD_ZERO(&in_set);
FD_ZERO(&out_set);
safeMutex.Lock();
irc_add_select_descriptors(session, &in_set, &out_set, &maxfd);
safeMutex.ReleaseLock(true);
if (select(maxfd + 1, &in_set, &out_set, 0, &tv) < 0) {
int lastSocketError = Socket::getLastSocketError();
if (lastSocketError == PLATFORM_SOCKET_INTERRUPTED) {
continue;
}
//session->lasterror = LIBIRC_ERR_TERMINATED;
return 2;
}
safeMutex.Lock();
if (irc_process_select_descriptors(session, &in_set, &out_set)) {
safeMutex.ReleaseLock();
return 3;
}
isSessionConnected = isConnected(false);
safeMutex.ReleaseLock(true);
}
return 0;
}
IRCThread::~IRCThread() {
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
if (SystemFlags::VERBOSE_MODE_ENABLED) printf("In ~IRCThread() ...\n");
if (IRCThread::globalCacheContainerName != NULL) {
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
IRCThread * &ircClient = CacheManager::getCachedItem< IRCThread * >(IRCThread::globalCacheContainerName);
ircClient = NULL;
}
//printf("In ~IRCThread Line: %d [%p]\n",__LINE__,this);
}
void normalizeNick(char *nick) {
// http://tools.ietf.org/html/rfc1459#section-2.3.1
// <target> ::= <to> [ "," <target> ]
// <to> ::= <channel> | <user> '@' <servername> | <nick> | <mask>
// <channel> ::= ('#' | '&') <chstring>
// <servername> ::= <host>
// <host> ::= see RFC 952 [DNS:4] for details on allowed hostnames
// <nick> ::= <letter> { <letter> | <number> | <special> }
// <mask> ::= ('#' | '$') <chstring>
// <chstring> ::= <any 8bit code except SPACE, BELL, NUL, CR, LF and
// comma (',')>
//
// Other parameter syntaxes are:
//
// <user> ::= <nonwhite> { <nonwhite> }
// <letter> ::= 'a' ... 'z' | 'A' ... 'Z'
// <number> ::= '0' ... '9'
// <special> ::= '-' | '[' | ']' | '\' | '`' | '^' | '{' | '}'
if (nick != NULL && strlen(nick) > 0) {
char *newNick = new char[strlen(nick) + 1];
memset(newNick, 0, strlen(nick) + 1);
bool nickChanged = false;
for (unsigned int i = 0; i < strlen(nick); ++i) {
if (nick[i] == '-' || nick[i] == '[' || nick[i] == ']' || nick[i] == '_' ||
nick[i] == '\\' || nick[i] == '`' || nick[i] == '^' ||
nick[i] == '{' || nick[i] == '}' ||
(nick[i] >= '0' && nick[i] <= '9') ||
(nick[i] >= 'a' && nick[i] <= 'z') ||
(nick[i] >= 'A' && nick[i] <= 'Z')) {
strncat(newNick, &nick[i], 1);
} else {
strcat(newNick, "-");
nickChanged = true;
}
}
if (nickChanged == true) {
strcpy(nick, newNick);
}
delete[] newNick;
}
}
void IRCThread::connectToHost() {
bool connectRequired = false;
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutex.ReleaseLock();
if (validSession == false) {
connectRequired = true;
} else {
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
int result = irc_is_connected(ircSession);
if (result != 1) {
connectRequired = true;
}
safeMutex1.ReleaseLock();
#endif
}
if (connectRequired == false) {
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
if (irc_connect(ircSession, argv[0].c_str(), IRC_SERVER_PORT, 0, this->nick.c_str(), this->username.c_str(), "zetaglest")) {
safeMutex1.ReleaseLock();
if (SystemFlags::VERBOSE_MODE_ENABLED || IRCThread::debugEnabled) printf("===> IRC Could not connect: %s\n", irc_strerror(irc_errno(ircSession)));
return;
}
safeMutex1.ReleaseLock();
#endif
}
}
void IRCThread::joinChannel() {
wantToLeaveChannel = false;
connectToHost();
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutex.ReleaseLock();
if (validSession == true) {
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
IRCThread *ctx = (IRCThread *) irc_get_ctx(ircSession);
if (ctx != NULL) {
eventData.clear();
setEventDataDone(false);
hasJoinedChannel = false;
lastNickListUpdate = time(NULL);
irc_cmd_join(ircSession, ctx->getChannel().c_str(), 0);
safeMutex.ReleaseLock();
}
safeMutex.ReleaseLock();
#endif
}
}
void IRCThread::leaveChannel() {
wantToLeaveChannel = true;
MutexSafeWrapper safeMutex(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
bool validSession = (ircSession != NULL);
safeMutex.ReleaseLock();
if (validSession == true) {
#if !defined(DISABLE_IRCCLIENT)
MutexSafeWrapper safeMutex1(&mutexIRCSession, string(__FILE__) + "_" + intToStr(__LINE__));
IRCThread *ctx = (IRCThread *) irc_get_ctx(ircSession);
if (ctx != NULL) {
irc_cmd_part(ircSession, ctx->getChannel().c_str());
safeMutex.ReleaseLock();
}
safeMutex.ReleaseLock();
#endif
}
}
}
}//end namespace
Reference in New Issue View Git Blame Copy Permalink