/**
* \fn Flux::string search(Flux::string s, Flux::string command)
* \brief generates search links for url's
* This is what generates the search links.
*/
Flux::string search(const Flux::string &text, const Flux::string &command)
{
Flux::string searchstring = text.url_str();
if(searchstring.empty())
return "Empty searchstring.";
else
{
if(command.equals_ci("google"))
return "http://www.google.com/search?q=" + searchstring;
else if(command.equals_ci("youtube"))
return "http://www.youtube.com/results?search_query=" + searchstring;
else if(command.equals_ci("tpb"))
return "http://thepiratebay.org/search/" + searchstring;
else if(command.equals_ci("define"))
return "http://dictionary.reference.com/browse/" + searchstring;
else if(command.equals_ci("urban"))
return "http://www.urbandictionary.com/define.php?term=" + searchstring;
else if(command.equals_ci("movie"))
return "www.letmewatchthis.ch/index.php?search_keywords=" + searchstring;
else if(command.equals_ci("lmgtfy"))
return "http://lmgtfy.com/?q=" + searchstring;
else
return "http://www.google.com/search?q=" + searchstring;
}
}
/**
* \fn bool ModuleHandler::DeleteModule(Module *m)
* \brief Delete the Module from Module lists and unload it from navn completely
* \param Module the Module to be removed
*/
bool ModuleHandler::DeleteModule(Module *m)
{
SET_SEGV_LOCATION();
if(!m || !m->handle)
return false;
void *handle = m->handle;
Flux::string filepath = m->filepath;
dlerror();
void (*df)(Module *) = function_cast<void ( *)(Module *)>(dlsym(m->handle, "ModunInit"));
const char *err = dlerror();
if(!df && err && *err)
{
Log(LOG_WARN) << "No destroy function found for " << m->name << ", chancing delete...";
delete m; /* we just have to chance they haven't overwrote the delete operator then... */
}
else
df(m); /* Let the Module delete it self, just in case */
if(handle)
if(dlclose(handle))
Log() << "[" << m->name << ".so] " << dlerror();
if(!filepath.empty())
Delete(filepath.c_str());
return true;
}
void User::SetNewNick(const Flux::string &newnick)
{
if(newnick.empty())
throw CoreException("User::SetNewNick() was called with empty arguement");
Log(LOG_TERMINAL) << "Setting new nickname: " << this->nick << " -> " << newnick;
this->n->UserNickList.erase(this->nick);
this->nick = newnick;
this->n->UserNickList[this->nick] = this;
}
// Private Function! used by Flux::string.implode()
Flux::string __ConcatenateString(const Flux::vector &str, char delim = ' ')
{
Flux::string temp;
for (unsigned i = 0; i < str.size(); ++i)
{
if(!temp.empty())
temp += delim;
temp += str[i];
}
return temp;
}
User::User(Network *net, const Flux::string &snick, const Flux::string &sident, const Flux::string &shost, const Flux::string &srealname, const Flux::string &sserver) : nick(snick), host(shost), realname(srealname), ident(sident), fullhost(snick+"!"+sident+"@"+shost), server(sserver), n(net)
{
/* check to see if a empty string was passed into the constructor */
if(snick.empty() || sident.empty() || shost.empty())
throw CoreException("Bad args sent to User constructor");
if(!net)
throw CoreException("User created with no network??");
this->n->UserNickList[snick] = this;
CUserMap[this] = std::vector<Channel*>();
Log(LOG_RAWIO) << "New user! " << this->nick << '!' << this->ident << '@' << this->host << (this->realname.empty()?"":" :"+this->realname);
++usercnt;
if(usercnt > maxusercnt)
{
maxusercnt = usercnt;
Log(LOG_TERMINAL) << "New maximum user count: " << maxusercnt;
}
}
void Run(CommandSource &source, const Flux::vector ¶ms)
{
User *u = source.u;
Flux::string chan = params[1];
if(!u->IsOwner())
{
source.Reply(ACCESS_DENIED);
Log(u) << "attempted to make the bot join " << chan;
return;
}
if(!IsValidChannel(chan))
source.Reply(CHANNEL_X_INVALID, chan.c_str());
else
{
Log(u) << "made the bot join " << chan;
Channel *c = findchannel(chan);
if(!c)
{
ircproto->join(chan);
Flux::string WelcomeMessage = Config->WelcomeMessage.replace_all_ci("{botnick}", Config->BotNick);
WelcomeMessage.trim();
if(!WelcomeMessage.empty())
ircproto->privmsg(chan, WelcomeMessage);
}
else
{
Log(u) << "tried to make bot join " << c->name << " but we're already in that channel";
source.Reply("Already in \2%s\2", c->name.c_str());
}
}
}
/**
* \fn ModErr ModuleHandler::LoadModule(const Flux::string &modname)
* \brief Load a Module into the bot
* \param Module the Module to load
*/
ModErr ModuleHandler::LoadModule(const Flux::string &modname)
{
SET_SEGV_LOCATION();
if(modname.empty())
return MOD_ERR_PARAMS;
if(FindModule(modname))
return MOD_ERR_EXISTS;
Log() << "Attempting to load Module [" << modname << ']';
Flux::string mdir = binary_dir + "/runtime/" + (modname.search(".so") ? modname + ".XXXXXX" : modname + ".so.XXXXXX");
Flux::string input = Flux::string(binary_dir + "/" + (Config->ModuleDir.empty() ? modname : Config->ModuleDir + "/" + modname) + ".so").replace_all_cs("//", "/");
TextFile mod(input);
Flux::string output = TextFile::TempFile(mdir);
Log(LOG_RAWIO) << "Runtime Module location: " << output;
mod.Copy(output);
if(mod.GetLastError() != FILE_IO_OK)
{
Log(LOG_RAWIO) << "Runtime Copy Error: " << mod.DecodeLastError();
return MOD_ERR_FILE_IO;
}
dlerror();
// FIXME: Somehow the binary_dir variable is lost when this executes >:|
void *handle = dlopen(output.c_str(), RTLD_LAZY | RTLD_LOCAL);
const char *err = dlerror();
if(!handle && err && *err)
{
Log() << '[' << modname << "] " << err;
return MOD_ERR_NOLOAD;
}
dlerror();
Module *(*f)(const Flux::string &) = function_cast<Module * ( *)(const Flux::string &)>(dlsym(handle, "ModInit"));
err = dlerror();
if(!f && err && *err)
{
Log() << "No Module init function, moving on.";
dlclose(handle);
return MOD_ERR_NOLOAD;
}
if(!f)
throw CoreException("Can't find Module constructor, yet no moderr?");
Module *m;
try
{
m = f(modname);
}
catch(const ModuleException &e)
{
Log() << "Error while loading " << modname << ": " << e.GetReason();
return MOD_ERR_EXCEPTION;
}
m->filepath = output;
m->filename = (modname.search(".so") ? modname : modname + ".so");
m->handle = handle;
FOREACH_MOD(OnModuleLoad, m);
return MOD_ERR_OK;
}
/** Segmentation Fault Handler
* \fn void HandleSegfault(module *m)
* \brief A segfault handler to report what happened and where it happened.
* \param module the module class in which the segfault happened include
*/
void HandleSegfault(Module *m)
{
#ifdef HAVE_BACKTRACE
void *array[10];
char **strings;
char tbuf[256];
Flux::string mbuf;
size_t size;
time_t now = time(NULL);
size = backtrace(array, 10);
if(TextFile::IsFile("SEGFAULT.log"))
Delete("SEGFAULT.log");
std::stringstream slog;
std::fstream sslog("SEGFAULT.log", std::ifstream::out | std::ifstream::app);
if(sslog.is_open())
{
struct utsname uts;
if(uname(&uts) < 0)
throw CoreException("uname() Error");
strftime(tbuf, sizeof(tbuf), "[%b %d %H:%M:%S %Y]", localtime(&now));
slog << "====================== Segmentation Fault ======================" << std::endl;
slog << "Please report this bug to http://bugs.Azuru.net/ and submit a bug report." << std::endl;
slog << "Please note that the Azuru developers may ask you to re-run this under gdb!" << std::endl;
slog << "Time of crash: " << tbuf << std::endl;
slog << Flux::string(COMPILED_NAME).toupper() << " version: " << VERSION_FULL << std::endl;
slog << "System info: " << uts.sysname << " " << uts.nodename << " " << uts.release << " " << uts.machine << std::endl;
slog << "System version: " << uts.version << std::endl;
slog << "C++ Version: " << __VERSION__ << std::endl;
slog << "Socket Buffer: " << LastBuf << std::endl;
slog << "Location: " << segv_location << std::endl;
if(m)
{
slog << "Module: " << m->name << std::endl;
slog << "Module Version: " << m->GetVersion() << std::endl;
slog << "Module Author: " << m->GetAuthor() << std::endl;
}
for(auto it : Modules)
mbuf += it->name+" ";
mbuf.trim();
slog << "Modules Loaded: " << (mbuf.empty()?"None":mbuf) << std::endl;
strings = backtrace_symbols(array, size);
for(unsigned i=1; i < size; i++)
slog << "BackTrace(" << (i - 1) << "): " << strings[i] << std::endl;
free(strings);
slog << "======================== END OF REPORT ==========================" << std::endl;
sslog << slog.str() << std::endl; //Write to SEGFAULT.log
sslog.close(); //Close pointer to SEGFAULT.log
std::cout << slog.str(); //Write to terminal.
std::cout.flush(); //Clear output
if(m)
Log() << "Segmentation Fault in module " << m->name << ", please review SEGFAULT.log";
else
Log(LOG_SILENT) << "\033[0mSegmentation Fault, Please read SEGFAULT.log";
}
else
throw CoreException("Segmentation Fault, cannot write backtrace!");
#else
Log(LOG_SILENT) << "Segmentation Fault";
printf("\033[0mOh no! A Segmentation Fault has occured!\n");
printf("This system does not support backtracing, please use gdb or a similar debugger!\n");
printf("Please follow these instructions on how to file a bug report of Flux-Net:\n");
printf("1) type \"gdb ant\"\n2) type \"r -n --protocoldebug\"\n3) Cause the program to crash\n4) Type \"bt full\" and copy and paste the output to http://www.pastebin.com/\n5) File a bug report at http://flux-net.net/bugs/\n");
#endif
}
/** Construct the object, sets everything to 0
*/
sockaddrs::sockaddrs(const Flux::string &address)
{
this->clear();
if (!address.empty())
this->pton(address.find(':') != Flux::string::npos ? AF_INET6 : AF_INET, address);
}