TDE
/
tdenetwork
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdenetwork
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8f8f58d043'
${ noResults }
tdenetwork/ksirc/ksircprocess.cpp

664 lines
20 KiB
Raw Blame History

/*************************************************************************
KSircProcess, sirc controller
$$Id$$
KSircProcess cerate and controls toplevel widgets and sirc process'.
Each sirc process has 1 and only 1 KSircProcess to control it. KSirc
process passes all IO to IOController which is it's friend.
Interface:
public:
KSircProcess(*server=0L, *parent=0, *name=0)
server: is the name of the server to connect to. It must be
provided or else start sirc will barf. :(
parent: parent window, this _should_ be null
name: name, passed to TQObject...
~KSirProcess:
kill the sirc process, and iocontrollller, emit delete_toplevel
getWindowList:
returns the TopList, see bellow.
Signals:
made_toplevel(server, window)
made a new toplevel window for the "server" we are connected to
with "window" as the title.
dalete_toplevel(server, window)
delete toplevel with server and called window. If we emit null
as the window name it means to destroy all info about the
server and ksircprocess.
changeChannel(server, old_name, new_name)
toplevel with old_name has been changed to new_name and all
future refrences will use new_name.
public slots:
new_toplevel(window):
create a new window with name window. This MAY only change the
name of an existing window that's now idle.
close_topevel(KsircTopLevel*, window):
deletes all refrences to window and if needed finds a new
default toplevel.
default_window(KSricTopLevel*):
KSircTopLevel is requesting change to !default. Be carefull
with this one.
recvChangeChannel(old, new):
window old is changing to new. emit ChangeChannel with server
name added. Without server name we can uniqely id the window. :(
Implementation:
Bassic process is to create a new KSircProcess and it takes care of
the rest. It emits signals for each new window and every time a
window is delete so you can update external display (like
servercontroller uses).
Startup:
1. Creates a case insensitive TopList. This is a list of ALL
KSircReceivers under control of this server, and includes such
items as "!all" and "!default". All !name are control windows.
2. Forks off a KProcess for sirc and passes it over to IOController
which grabs and control's it's IO.
3. It then opens a "!default" window. This will receive all
initial input and such. It WILL change it's name on the first
join.
4. The IO broadcast object is created and setup.
5. everything is put into run mode.
Operation, see code bellow for inline comments.
*************************************************************************/
#include "baserules.h"
#include "ksopts.h"
#include "control_message.h"
#include "displayMgr.h"
#include "ioBroadcast.h"
#include "ioDCC.h"
#include "ioDiscard.h"
#include "ioLAG.h"
#include "ioNotify.h"
#include "iocontroller.h"
#include "ksircprocess.h"
#include "objFinder.h"
#include "servercontroller.h"
#include "toplevel.h"
#include "version.h"
#include "KSProgress/ksprogress.h"
#include <stdlib.h>
#include <time.h>
#include <tqtimer.h>
#include <kapplication.h>
#include <kconfig.h>
#include <kdebug.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kprocess.h>
#include <kstandarddirs.h>
extern DisplayMgr *displayMgr;
KSircProcess::KSircProcess( TQString &server_id, KSircServer &kss, TQObject * parent, const char * name )
: TQObject(parent, name), m_kss(kss), m_serverid(server_id)
{
proc = new KProcess();
#ifndef NDEBUG
if(getuid() != 0)
proc->setRunPrivileged(true); /* make ksirc run under gdb as a user */
#endif
//server = tqstrdup(kss.server());
TQDict<KSircMessageReceiver> nTopList(17, FALSE);
TopList = nTopList;
// TopList.setAutoDelete(TRUE)
auto_create_really = FALSE;
// Create the ksopts server structure
ksopts->serverSetup(kss);
// Setup the environment for KSirc
TQString qsNick, qsRealname, qsUserID, qsAltNick;
KConfig *kConfig = kapp->config();
kConfig->setGroup("StartUp");
qsNick = ksopts->serv(kss).nick;
qsAltNick = ksopts->serv(kss).altNick;
qsRealname = ksopts->serv(kss).realName;
qsUserID = ksopts->serv(kss).userID;
kdDebug(5008) << "qsNick: " << qsNick << " qsAltNick: " << qsAltNick << " qsRealname: " << qsRealname << "qsUserID: " << qsUserID << endl;
m_nick = qsNick;
if((qsNick.isEmpty() == FALSE)){
proc->setEnvironment("SIRCNICK", qsNick);
}
if((qsAltNick.isEmpty() == FALSE)){
proc->setEnvironment("BACKUPNICK", qsAltNick);
}
if((qsRealname.isEmpty() == FALSE)){
proc->setEnvironment("SIRCNAME", qsRealname);
}
if((qsUserID.isEmpty() == FALSE)){
proc->setEnvironment("SIRCUSER", qsUserID);
kdDebug(5008) << "Set SIRCUSER to: " << qsUserID << endl;
}
proc->setEnvironment("SIRCLIB", KGlobal::dirs()->findResourceDir("appdata", "ksirc.pl"));
proc->setEnvironment("SIRCWAIT", "1");
TQString env = locate("appdata", "ksircrc");
if (!env.isEmpty())
proc->setEnvironment("SIRCRC", env);
env = locate("appdata", "ksircrc.pl");
if (!env.isEmpty())
proc->setEnvironment("SIRCRCPL", env);
// Setup the proc now, so iocontroller can use it. It's latter
// though. started bellow though.
proc->setName(TQCString(name) + "_kprocess");
objFinder::insert(proc);
// insertChild(proc);
// pass the server string using an environment variable, because it might contain
// a password that could be spyed out, as the commandline option is readable to others.
// Fixes 47157.
proc->setEnvironment( "SIRCSERVER", "[" + kss.server() + "]:" + kss.port() + ":" + kss.password());
TQString sslopt;
if(kss.usessl())
sslopt = "-S";
*proc << "perl" << KGlobal::dirs()->findExe("dsirc") << "-8" << "-r" << sslopt;
// Finally start the iocontroller.
iocontrol = new KSircIOController(proc, this);
iocontrol->setName(TQCString(name) + "_iocontrol");
// Create toplevel before iocontroller so it has somewhere to write stuff.
running_window = TRUE; // True so we do create the default
default_follow_focus = TRUE;
KSircChannel ci(kss.server(), "!no_channel");
new_toplevel(ci, true); //
TopList.replace("!default", TopList[ci.channel()]);
running_window = FALSE; // set false so next changes the first name
// Write default commands, and open default windows.
TopList.insert("!all", new KSircIOBroadcast(this));
TopList.insert("!discard", new KSircIODiscard(this));
KSircIODCC *dcc = new KSircIODCC(this);
TopList.insert("!dcc", dcc);
dcc = static_cast<KSircIODCC *>( TopList["!dcc"] ); // g++ bug
connect(dcc, TQT_SIGNAL(outputLine(TQCString)),
iocontrol, TQT_SLOT(stdin_write(TQCString)));
KSircIOLAG *lag = new KSircIOLAG(this);
TopList.insert("!lag", lag);
lag = static_cast<KSircIOLAG*>( TopList["!lag"] ); // g++ bug!
connect(lag, TQT_SIGNAL(outputLine(TQCString)),
iocontrol, TQT_SLOT(stdin_write(TQCString)));
KSircIONotify *notify = new KSircIONotify(this);
TopList.insert("!notify", notify);
notify = static_cast<KSircIONotify *>( TopList["!notify"] ); // g++ bug
connect(notify, TQT_SIGNAL(notify_online(TQString)),
this, TQT_SLOT(notify_forw_online(TQString)));
connect(notify, TQT_SIGNAL(notify_offline(TQString)),
this, TQT_SLOT(notify_forw_offline(TQString)));
TopList.insert("!base_rules", new KSMBaseRules(this));
// Now that all windows are up, start sirc.
proc->start(KProcess::NotifyOnExit, KProcess::All);
// Intial commands to load ASAP.
// turn on sirc ssfe mode
TQCString command = "/eval $ssfe=1\n";
iocontrol->stdin_write(command);
command = "/eval $version .= \"+KSIRC/" + TQCString(KSIRC_VERSION) + "\"\n";
iocontrol->stdin_write(command);
command = "/load " + locate("appdata", "filters.pl").local8Bit() + "\n";
iocontrol->stdin_write(command);
command = "/load " + locate("appdata", "ksirc.pl").local8Bit() + "\n";
iocontrol->stdin_write(command);
/*
command = "/load " + locate("appdata", "puke.pl") + "\n";
iocontrol->stdin_write(command);
command = "/load " + locate("appdata", "dcc_status.pm") + "\n";
iocontrol->stdin_write(command);
*/
command = "/eval $ready = 1\n";
iocontrol->stdin_write(command);
// Load all the filter rules. Must be after /load filtes.pl so all
// the functions are available
filters_update();
// We do this after filters_update() since filters_update loads the
// require notify filters, etc.
command = "/notify ";
command += ksopts->serv(kss).notifyList.join(" ").latin1();
command += "\n";
kdDebug(5008) << "Notify: " << command << endl;
iocontrol->stdin_write(command);
}
KSircProcess::~KSircProcess()
{
cleanup();
}
TQPtrList<KSircMessageReceiver> KSircProcess::messageReceivers() const
{
TQPtrList<KSircMessageReceiver> res;
res.setAutoDelete( false );
TQDictIterator<KSircMessageReceiver> it( TopList );
for (; it.current(); ++it )
if ( it.currentKey() != "!default" &&
it.currentKey() != "!no_channel" )
res.append( it.current() );
return res;
}
const TQDict<KSircMessageReceiver> &KSircProcess::mrList() const
{
return TopList;
}
void KSircProcess::cleanup()
{
if(TopList["!default"]){
TopList.remove("!default"); // remove default so we don't delete it twice.
}
TopList.setAutoDelete(true);
TopList.clear();
emit ProcMessage(m_serverid, ProcCommand::procClose, TQString());
// Do closing down commands, this should release all puke widgets
#if 0
dsirc does this on SIGTERM (malte)
TQString quit_cmd = "/eval &dohooks(\"quit\");\n";
proc->writeStdin(quit_cmd.ascii(), quit_cmd.length());
sleep(1);
#endif
if(proc->isRunning()){
proc->kill(SIGTERM);
}
delete proc; // Delete process, seems to kill sirc, good.
delete iocontrol; // Take out io controller
// delete []server;
proc = 0L;
iocontrol = 0L;
// server = 0L;
}
void KSircProcess::new_toplevel(const KSircChannel &channelInfo, bool safe)
{
static time_t last_window_open = 0;
static int number_open = 0;
static bool flood_dlg = FALSE;
if(running_window == FALSE){ // If we're not fully running, reusing
// !default window for next chan.
running_window = TRUE;
// insert and remove is done as a side effect of the control_message call
// TopList.insert(str, TopList["!no_channel"]);
// TopList.remove("!no_channel"); // We're no longer !no_channel
TopList["!no_channel"]->control_message(CHANGE_CHANNEL, channelInfo.server() + "!!!" + channelInfo.channel() + "!!!" + channelInfo.key());
}
else if(TopList.find(channelInfo.channel()) == 0x0){ // If the window doesn't exist, continue
// If AutoCreate windows is on, let's make sure we're not being flooded.
if(ksopts->autoCreateWin == TRUE && safe == false){
time_t current_time = time(NULL);
if((channelInfo.channel()[0] != '#' || channelInfo.channel()[0] != '&') &&
((current_time - last_window_open) < 5)){
if(number_open > 4 && flood_dlg == FALSE){
flood_dlg = TRUE;
int res = KMessageBox::warningYesNo(0,
i18n("5 Channel windows were opened "
"in less than 5 seconds. Someone "
"may be trying to flood your X server "
"with windows.\n"
"Shall I turn off AutoCreate windows?"),
i18n("Flood Warning"), i18n("Turn Off"), i18n("Keep Enabled"));
switch(res) {
case KMessageBox::Yes:
emit ProcMessage(serverID(), ProcCommand::turnOffAutoCreate, TQString());
}
last_window_open = current_time;
number_open = 0;
}
else{
// Joining channels can't be a flood, can it?
if(channelInfo.channel()[0] != '#' || channelInfo.channel()[0] != '&')
if(!safe)
number_open++;
}
flood_dlg = FALSE;
}
else{
last_window_open = current_time;
}
}
// Create a new toplevel, and add it to the toplist.
// TopList is a list of KSircReceivers so we still need wm.
KSircTopLevel *wm = new KSircTopLevel(this, channelInfo, (serverID() +"_" + channelInfo.channel()).ascii() );
TopList.insert(channelInfo.channel(), wm);
// Connect needed signals. For a message window we never want it
// becomming the default so we ignore focusIn events into it.
connect(wm, TQT_SIGNAL(outputLine(TQCString)),
iocontrol, TQT_SLOT(stdin_write(TQCString)));
connect(wm, TQT_SIGNAL(open_toplevel(const KSircChannel &)),
this,TQT_SLOT(new_toplevel (const KSircChannel &)));
connect(wm, TQT_SIGNAL(closing(KSircTopLevel *, TQString)),
this,TQT_SLOT(close_toplevel(KSircTopLevel *, TQString)));
connect(wm, TQT_SIGNAL(currentWindow(KSircTopLevel *)),
this,TQT_SLOT(default_window(KSircTopLevel *)));
connect(wm, TQT_SIGNAL(changeChannel(const TQString &, const TQString &)),
this,TQT_SLOT(recvChangeChannel(const TQString &, const TQString &)));
connect(wm, TQT_SIGNAL(destroyed(TQObject *)),
this,TQT_SLOT(clean_toplevel(TQObject *)));
connect( wm, TQT_SIGNAL( requestQuit( const TQCString& ) ),
TQT_SLOT( request_quit( const TQCString& ) ) );
default_window(wm); // Set it to the default window.
emit ProcMessage(serverID(), ProcCommand::addTopLevel, channelInfo.channel());
displayMgr->newTopLevel(wm, TRUE);
displayMgr->setCaption(wm, channelInfo.channel());
// displayMgr->show(wm);
wm->lineEdit()->setFocus(); // Give focus back to the linee, someone takes it away on new create
}
else {
TQWidget *w = dynamic_cast<TQWidget *>(TopList.find(channelInfo.channel()));
if(w)
displayMgr->raise(w);
}
}
void KSircProcess::close_toplevel(KSircTopLevel *wm, TQString name)
{
if(auto_create_really == TRUE)
turn_on_autocreate();
kdDebug(5008) << "KSP: get close_toplevel: " << name << endl;
// the removeTopLevel below also deletes the mditoplevel (in case
// we are using mdi) , which deletes its children, which deletes
// 'wm' , so watch out not to delete twice! (Simon)
TQGuardedPtr<KSircTopLevel> guardedwm = wm;
// Do this now or we get junk left on the screen
displayMgr->removeTopLevel(wm);
while(TopList.remove(name)); // In case multiple copies exist remove them all
bool isDefault = (wm == TopList["!default"]);
// Ok, now if we just deleted the default we have a problem, we need
// a new default. BUT don't make the default "!all" or !message.
// So let's go grab a default, and make sure it's not "!" control
// object.
TQDictIterator<KSircMessageReceiver> it(TopList);
for(;it.current() && it.currentKey().startsWith("!"); ++it);
if (!it.current())
{
// No top-level windows left.
TQCString command = "/quit\n"; // "/signoff" ?
iocontrol->stdin_write(command); // kill sirc
kdDebug(5008) << "KSP closing: " << m_kss.server() << endl;
delete guardedwm;
delete this; // Delete ourself, WARNING MUST RETURN SINCE WE NO
// LONGER EXIST!!!!
return; // ^^^^^^^^^^^^^^^
}
if (isDefault)
TopList.replace("!default", it.current());
// Let's let em know she's deleted!
if(ksopts->autoCreateWin == TRUE){
emit ProcMessage(serverID(), ProcCommand::turnOffAutoCreate, TQString());
TQTimer::singleShot(5000, this, TQT_SLOT(turn_on_autocreate()));
auto_create_really = TRUE;
}
else{
auto_create_really = FALSE;
}
delete guardedwm;
emit ProcMessage(serverID(), ProcCommand::deleteTopLevel, name);
}
void KSircProcess::clean_toplevel(TQObject *clean){
if(!clean){
tqWarning("Passed null to cleaner!!");
return;
}
bool cont = FALSE;
do{
cont = FALSE;
TQDictIterator<KSircMessageReceiver> it(TopList);
while(it.current() != 0x0){
if((TQObject *)it.current() == clean){
TQString key = it.currentKey();
while(TopList[key] != 0x0){
TopList.remove(key);
}
cont = TRUE;
break;
}
++it;
}
} while(cont == TRUE);
}
void KSircProcess::request_quit( const TQCString& command )
{
iocontrol->stdin_write( command );
// Since removing the toplevels will delete the one that emitted this
// signal as well, we need to defer this a little (malte)
TQTimer::singleShot( 0, this, TQT_SLOT( do_quit() ) );
}
void KSircProcess::do_quit()
{
for ( TQDictIterator< KSircMessageReceiver > it( TopList ); it.current(); ++it )
{
if ( it.currentKey() == "!default" ) continue;
if ( KSircTopLevel* topLevel = dynamic_cast< KSircTopLevel* >( it.current() ) )
{
TQGuardedPtr< KSircTopLevel > guardedTL = topLevel;
displayMgr->removeTopLevel( topLevel );
delete guardedTL;
}
else delete it.current();
}
// cleanup() would otherwise delete them a second time
TopList.clear();
delete this;
}
void KSircProcess::default_window(KSircTopLevel *w)
{
//
// If we want to track the default as it goes around, change the
// window on focus changes.
//
if(w && (default_follow_focus == TRUE))
TopList.replace("!default", w);
}
void KSircProcess::recvChangeChannel(const TQString &old_chan, const TQString &new_chan)
{
//
// Channel changed name, add our own name and off we go.
// ServerController needs our name so it can have a uniq handle for
// the window name.
//
if(TopList[old_chan]) {
kdDebug(5008) << "In change channel, found it" << endl;
TopList.insert(new_chan, TopList.take(old_chan));
}
else {
kdDebug(5008) << "In change channel, didn;t find it" << endl;
}
emit ProcMessage(serverID(), ProcCommand::changeChannel,
old_chan + " " + new_chan);
}
void KSircProcess::filters_update()
{
TQString command, next_part, key, data;
command = "/crule\n";
iocontrol->stdin_write(command.ascii());
TQDictIterator<KSircMessageReceiver> it(TopList);
KSircMessageReceiver *cur, *br;
filterRuleList *frl;
filterRule *fr;
cur = TopList["!base_rules"];
br = cur;
while(cur){
frl = cur->defaultRules();
for ( fr=frl->first(); fr != 0; fr=frl->next() ){
command.truncate(0);
command += "/ksircappendrule DESC==";
command += fr->desc;
command += " !!! SEARCH==";
command += fr->search;
command += " !!! FROM==";
command += fr->from;
command += " !!! TO==\"";
command += fr->to;
command += "\"\n";
iocontrol->stdin_write(command.local8Bit());
}
delete frl;
++it;
cur = it.current();
if(cur == br){
++it;
cur = it.current();
}
}
KConfig *kConfig = kapp->config();
kConfig->setGroup("FilterRules");
int max = kConfig->readNumEntry("Rules", 0);
for(int number = 1; number <= max; number++){
command.truncate(0);
key.sprintf("name-%d", number);
next_part.sprintf("/ksircappendrule DESC==%s !!! ", kConfig->readEntry(key).ascii());
command += next_part;
key.sprintf("search-%d", number);
next_part.sprintf("SEARCH==%s !!! ", kConfig->readEntry(key).ascii());
command += next_part;
key.sprintf("from-%d", number);
next_part.sprintf("FROM==%s !!! ", kConfig->readEntry(key).ascii());
command += next_part;
key.sprintf("to-%d", number);
next_part.sprintf("TO==\"%s\"\n", kConfig->readEntry(key).ascii());
command += next_part;
iocontrol->stdin_write(command.ascii());
}
}
void KSircProcess::notify_forw_online(TQString nick)
{
emit ProcMessage(serverID(), ProcCommand::nickOnline, nick);
}
void KSircProcess::notify_forw_offline(TQString nick)
{
emit ProcMessage(serverID(), ProcCommand::nickOffline, nick);
}
void KSircProcess::ServMessage(TQString dst_server, int command, TQString args)
{
if(dst_server.isEmpty() || (dst_server == serverID())){
switch(command){
case ServCommand::updateFilters:
filters_update();
break;
default:
kdDebug(5008) << "Unkown command: " << command << " to " << command << " args " << args << endl;
break;
}
}
}
void KSircProcess::turn_on_autocreate()
{
emit ProcMessage(serverID(), ProcCommand::turnOnAutoCreate, TQString());
auto_create_really = FALSE;
}
void KSircProcess::setNick(const TQString nick)
{
TQString new_nick = nick;
while (!new_nick.isEmpty() &&
(new_nick[0].latin1() == '@' || new_nick[0].latin1() == '*'))
new_nick.remove(0, 1);
if(new_nick != m_nick){
m_nick = new_nick;
/*
* redo the filter rules since they use
* our nick
*/
kdDebug(5008) << "Redo filters" << endl;
filters_update();
}
}
const TQString KSircProcess::getNick() const
{
return m_nick;
}
#include "ksircprocess.moc"
// vim: ts=4 sw=4 et
View Git Blame Copy Permalink