pip/utils/system_daemon/daemon.cpp

#include "daemon.h"

#include "picrypt.h"
#include "piliterals_time.h"
#include "pisysteminfo.h"
#include "shared.h"

const char self_name[] = "__self__";
extern PIScreen * screen;
extern PISystemMonitor sys_mon;

Daemon::Remote::Remote(const PIString & n): PIThread() {
	setName(n);
	term = 0;
	ft.setName(n);
	ft.setPacketSize(3984);
	ft.setCRCEnabled(false);
	CONNECTU(&ft, sendRequest, this, ftSendRequest)
	CONNECTU(&ft, receiveFilesFinished, this, ftReceived)
	CONNECTU(&ft, sendFilesFinished, this, ftSended)
	CONNECTU(&term_timer, tickEvent, this, termTimerTick)
	dir_my = PIDir::current();
}


Daemon::Remote::~Remote() {
	term_timer.stopAndWait();
	shellClose();
	ft.stop();
	stopAndWait();
}


void Daemon::Remote::shellOpen() {
	if (term) return;
	piCoutObj << "shell open";
	term = new PITerminal();
	term->initialize();
	term_timer.start(20_Hz);
}


void Daemon::Remote::shellClose() {
	if (!term) return;
	piCoutObj << "shell close";
	term_timer.stopAndWait();
	term->destroy();
	delete term;
	term = 0;
	// piCoutObj << "shellClose ok";
}


void Daemon::Remote::shellResize(int w, int h) {
	if (!term) return;
	term->resize(w, h);
}


void Daemon::Remote::shellKeySend(PIKbdListener::KeyEvent k) {
	if (!term) return;
	term->write(k);
}


void Daemon::Remote::termTimerTick() {
	if (!term) return;
	PIVector<PIVector<PIScreenTypes::Cell>> cells = term->content();
	if (pcells == cells) return;
	pcells = cells;
	PIByteArray ba;
	ba << int(ShellContent) << cells;
	// piCout << ba.size_s() << pcells.back().back().symbol.unicode16Code() << cells.back().back().symbol.unicode16Code();
	sendRequest(name(), ba);
}


void Daemon::Remote::startAction(Daemon::PacketType a, const PIString & dir, const PIStringList & fl) {
	_fl = fl;
	if (!dir.isEmpty())
		for (auto & s: _fl)
			s.prepend(dir);
	// piCout << "send" << _fl;
	action = a;
	startOnce();
}


void Daemon::Remote::run() {
	PIDir d(dir_my);
	switch (action) {
	case CopyFiles: ft.send(_fl); break;
	case RemoveFiles:
		::removeFiles(d, _fl);
		updateDirEntries();
		changeDirFinished(name(), d.absolutePath());
		break;
	case RequestChangeDir:
		updateDirEntries();
		changeDirFinished(name(), d.absolutePath());
		break;
	case MkDir:
		if (!_fl.isEmpty()) PIDir::make(d.absolutePath() + PIDir::separator + _fl.at(0));
		updateDirEntries();
		changeDirFinished(name(), d.absolutePath());
		break;
	case CryptFiles:
		piCoutObj << "CryptFiles";
		if (!_fl.isEmpty()) {
			PIString p = askUserInput("Password:");
			::cryptFiles(d, _fl, PICrypt::hash(p));
		}
		updateDirEntries();
		changeDirFinished(name(), d.absolutePath());
		break;
	default: break;
	};
}


void Daemon::Remote::updateDirEntries() {
	// piCout << dir_my;
	if (!dir_my.isExists()) dir_my = PIDir::current();
	my_filelist = dir_my.entries();
	for (auto & f: my_filelist)
		f.path = f.name();
}


Daemon::TileFileProgress::TileFileProgress(): PIScreenTile() {
	size_policy = PIScreenTypes::Fixed;
	ft          = 0;
	rec         = false;
	setMargins(1, 1, 1, 1);
	spacing                = 1;
	back_format.color_back = Yellow;
	label_file             = new TileSimple();
	label_speed            = new TileSimple();
	label_cnt              = new TileSimple();
	prog_file              = new TileProgress();
	prog_all               = new TileProgress();
	buttons                = new TileButtons("fd_buttons");
	buttons->content << TileButtons::Button("Pause", CellFormat());
	buttons->content << TileButtons::Button("Cancel", CellFormat());
	label_file->content.resize(1);
	label_speed->content.resize(1);
	label_cnt->content.resize(1);
	buttons->back_format.color_back    = Yellow;
	label_file->back_format.color_back = label_speed->back_format.color_back = label_cnt->back_format.color_back = Yellow;
	label_file->content[0].second = label_speed->content[0].second = label_cnt->content[0].second = CellFormat(Black, Transparent);
	addTile(label_file);
	addTile(label_speed);
	addTile(label_cnt);
	addTile(prog_file);
	addTile(prog_all);
	addTile(buttons);
	CONNECTU((::screen), tileEvent, this, tileEvent)
}


void Daemon::TileFileProgress::resizeEvent(int w, int h) {
	PIScreenTile::resizeEvent(w, h);
	w            = ::screen->windowWidth() / 1.4;
	minimumWidth = maximumWidth = w;
}


void Daemon::TileFileProgress::sizeHint(int & w, int & h) const {
	PIScreenTile::sizeHint(w, h);
	w = ::screen->windowWidth() / 1.4;
}


void Daemon::TileFileProgress::drawEvent(PIScreenDrawer * d) {
	if (ft) {
		label_file->content[0].first = ft->stateString() + " " + ft->curFile();
		if (!label_file->content[0].first.isEmpty()) label_file->content[0].first[0] = label_file->content[0].first[0].toUpper();
		PIString spd("Speed: "), cnt;
		if (ft->isReceiving())
			spd = ft->diagnostic().receiveSpeed();
		else
			spd = ft->diagnostic().sendSpeed().expandRightTo(10, ' ');
		spd += "  ETA: ";
		if (!ft->isReceiving() && !ft->isSending()) {
			tm.reset();
			spd += "-";
		} else {
			double el = tm.elapsed_s();
			int cb    = ft->bytesCur();
			if ((el <= 0.) || (cb <= 0))
				spd += "-";
			else {
				double s = (el / cb) * (ft->bytesAll() - cb);
				spd += readableTime(PITime::fromSystemTime(PISystemTime::fromSeconds(s)));
			}
		}
		spd += "  Elapsed: " + readableTime(PITime::fromSystemTime(PISystemTime::fromSeconds(tme.elapsed_s())));
		label_speed->content[0].first = spd;
		cnt                           = "File: " + PIString::readableSize(ft->bytesFileCur()).expandLeftTo(8, ' ');
		cnt += " / " + PIString::readableSize(ft->bytesFileAll()).expandLeftTo(8, ' ');
		cnt += "  All: " + PIString::readableSize(ft->bytesCur()).expandLeftTo(8, ' ');
		cnt += " / " + PIString::readableSize(ft->bytesAll()).expandLeftTo(8, ' ');
		label_cnt->content[0].first = cnt;
		if (ft->bytesFileAll() > 0) prog_file->value = piRoundd(ft->bytesFileCur() / double(ft->bytesFileAll()) * 100.);
		if (ft->bytesAll() > 0) prog_all->value = piRoundd(ft->bytesCur() / double(ft->bytesAll()) * 100.);
	}
	PIScreenTile::drawEvent(d);
}


void Daemon::TileFileProgress::show(PIFileTransfer * f) {
	ft = f;
	if (ft) {
		conn_name = ft->name();
		::screen->setDialogTile(this);
		label_file->content[0].first = "Preparing ...";
		prog_file->value = prog_all->value = 0;
		buttons->cur                       = 0;
		buttons->setFocus();
		tm.reset();
		tme.reset();
	}
}


void Daemon::TileFileProgress::close(bool ok) {
	buttons->content[0].first = "Pause";
	ft                        = 0;
	::screen->setDialogTile(0);
	if (!ok) {
		piCout << "file transfer aborted";
		showInfo("Error while file transfer, files may be invalid");
	}
}


void Daemon::TileFileProgress::tileEvent(PIScreenTile * t, TileEvent e) {
	if (t->name() == "fd_buttons") {
		if (e.type != TileButtons::ButtonSelected || !ft) return;
		switch (e.data.toInt()) {
		case 0:
			if (buttons->content[0].first == "Pause") {
				buttons->content[0].first = "Resume";
				ft->pause();
			} else {
				buttons->content[0].first = "Pause";
				ft->resume();
			}
			break;
		case 1:
			ft->stop();
			close();
			break;
		};
	}
}


Daemon::Daemon(): PIPeer(pisd_prefix + PISystemInfo::instance()->hostname + "_" + PIString::fromNumber(randomi() % 100)) {
	//	setName("Daemon");
	dtimer.setName("_S.Daemon.timer");
	mode   = rmNone;
	offset = cur = height = 0;
	CONNECTU(screen, keyPressed, this, keyEvent)
	CONNECTU(&dtimer, tickEvent, this, timerEvent)
	CONNECTU(&fm, tileKey, this, fmKeyEvent)
	CONNECTU(&fm, actionRequest, this, fmActionRequest)
	_self = new Remote(self_name);
	CONNECTU(_self, sendRequest, this, localSend)
	CONNECTU(_self, receiveFinished, this, closeFileDialog)
	CONNECTU(_self, sendFinished, this, closeFileDialog)
	CONNECTU(_self, changeDirFinished, this, dirChanged)
	localft.setName(self_name);
	localft.setCRCEnabled(false);
	CONNECTU(&localft, sendRequest, _self, received)
	dtimer.addDelimiter(5);
	dtimer.start(5_Hz);

	tile_root                = new PIScreenTile();
	tile_root->direction     = Vertical;

	tile_header              = new TileSimple("daemon header");
	tile_header->size_policy = Fixed;

	list_daemons             = new TileList("daemons list");
	list_daemons->hide();

	list_actions = new TileList("actions list");
	list_actions->hide();
	list_actions->content << TileList::Row("Information", CellFormat());
	list_actions->content << TileList::Row("File manager", CellFormat());
	list_actions->content << TileList::Row("Shell", CellFormat());

	tile_info = new TileSimple("daemon info");
	tile_info->hide();

	fm.setRemote();
	tile_fm = fm.tile();
	tile_fm->hide();

	tile_file_progress = new TileFileProgress();

	tile_shell         = new TileTerminal("shell");
	tile_shell->hide();
	CONNECTU(tile_shell, resizeRequest, this, shResizeRequest)
	CONNECTU(tile_shell, keyPressed, this, shKeyEvent)
	CONNECTU(tile_shell, closeRequest, this, requestCloseShell)
	CONNECTU(tile_shell, closeRequest, this, escPressed)


	tile_root->addTile(tile_header);
	tile_root->addTile(list_daemons);
	tile_root->addTile(list_actions);
	tile_root->addTile(tile_info);
	tile_root->addTile(tile_fm);
	tile_root->addTile(tile_shell);

	CONNECTU(screen, tileEvent, this, tileEvent)
	reinit();
	inited__ = true;
}


Daemon::~Daemon() {
	dtimer.stopAndWait();
	requestCloseShell();
	PIVector<Remote *> rl = remotes.values();
	for (auto * r: rl) {
		r->shellClose();
		delete r;
	}
	remotes.clear();
	delete _self;
}


PIScreenTile * Daemon::tile() const {
	return tile_root;
}


void Daemon::escPressed() {
	if (mode == rmNone || mode == rmLocalFileManager)
		menuRequest();
	else {
		if (mode > rmSelectMode) {
			mode = rmSelectMode;
			screen->lock();
			tile_info->content.clear();
			screen->unlock();
			showActionList();
		} else
			disconnect();
	}
}


void Daemon::shResizeRequest() {
	Remote * r = remotes.value(conn_name, 0);
	if (!r) return;
	PIByteArray ba;
	ba << int(ShellResizeRequest) << int(tile_shell->width()) << int(tile_shell->height());
	send(conn_name, ba);
}


void Daemon::shKeyEvent(PIKbdListener::KeyEvent k) {
	Remote * r = remotes.value(conn_name, 0);
	if (!r) return;
	PIByteArray ba;
	ba << int(ShellKeyEvent) << k;
	send(conn_name, ba);
}


void Daemon::localSend(const PIString & p_name, const PIByteArray & data) {
	// piCoutObj << "localSend" << localft.stateString();
	PIByteArray h;
	h << int(FileTransfer);
	PIByteArray ba = data;
	ba.remove(0, h.size());
	localft.received(ba);
}


void Daemon::hideAll() {
	list_actions->hide();
	tile_info->hide();
	list_daemons->hide();
	tile_fm->hide();
	tile_shell->hide();
}


void Daemon::showTile(PIScreenTile * t, const PIString & header) {
	hideAll();
	t->show();
	t->setFocus();
	tile_header->content.resize(1);
	tile_header->content[0].first        = header;
	tile_header->content[0].second.flags = Bold;
	lock();
	if (!conn_name.isEmpty()) tile_header->content[0].first.insert(0, PIString("Daemon \"") + connectedDaemon() + "\": ");
	unlock();
}


void Daemon::fillInfoTile(const Daemon::HostInfo & hi) {
	screen->lock();
	tile_info->content.clear();
	tile_info->content << TileSimple::Row("Exec command: " + hi.execCommand, CellFormat());
	tile_info->content << TileSimple::Row(" Executed on  " + hi.execDateTime.toString(), CellFormat());
	tile_info->content << TileSimple::Row("    Hostname: " + hi.hostname, CellFormat());
	tile_info->content << TileSimple::Row("    Username: " + hi.user, CellFormat());
	tile_info->content << TileSimple::Row("     OS name: " + hi.OS_name, CellFormat());
	tile_info->content << TileSimple::Row("  OS version: " + hi.OS_version, CellFormat());
	tile_info->content << TileSimple::Row("Architecture: " + hi.architecture, CellFormat());
	tile_info->content << TileSimple::Row("   CPU count: " + PIString::fromNumber(hi.processorsCount), CellFormat());
	screen->unlock();
}


void Daemon::tileEvent(PIScreenTile * t, TileEvent e) {
	if (t == list_daemons) {
		if (e.type == TileList::RowPressed) {
			PIMutexLocker ml(remote_mutex);
			connectToDaemon(list_daemons->content[e.data.toInt()].first);
			showActionList();
		}
		return;
	}
	if (t == list_actions) {
		if (e.type == TileList::RowPressed) {
			PIMutexLocker ml(remote_mutex);
			switch (e.data.toInt()) {
			case 0:
				mode = rmInformation;
				showTile(tile_info, "Information");
				break;
			case 1:
				mode = rmFileManager;
				showTile(tile_fm, "File manager");
				requestChDir(".");
				break;
			case 2:
				mode = rmShell;
				showTile(tile_shell, "Shell");
				requestOpenShell();
				break;
			default: break;
			}
		}
		return;
	}
}


void Daemon::keyEvent(PIKbdListener::KeyEvent key) {
	if (!tile_root->visible) return;
	if (screen->dialogTile()) return;
	switch (key.key) {
	case PIKbdListener::Esc: escPressed(); break;
	default: break;
	}
}


void Daemon::fmKeyEvent(PIKbdListener::KeyEvent key) {
	PIMutexLocker ml(remote_mutex);
	//	piCoutObj << key.key << key.modifiers;
	switch (key.key) {
	case PIKbdListener::Return: {
		PIFile::FileInfo fi = fm.currentRemoteEntry();
		if (!fi.isDir()) break;
		requestChDir(fi.name());
	} break;
	case 'R': requestChDir("."); break;
	default: break;
	}
}


void Daemon::fmActionRequest(bool remote_tile, FileManager::Action type, PIVariant data) {
	Remote * r = 0;
	r          = remotes.value(conn_name, 0);
	if (!r && type != FileManager::LocalCopy && type != FileManager::LocalCrypt) return;
	switch (type) {
	case FileManager::Copy:
		if (remote_tile) {
			PIByteArray ba;
			// piCout << fm.selectedRemote();
			ba << int(CopyFiles) << fm.selectedRemote();
			r->ft.setDirectory(fm.localDir());
			send(conn_name, ba);
			tile_file_progress->rec = true;
			tile_file_progress->show(&(r->ft));
		} else {
			r->sendFiles(fm.localDir() + PIDir::separator, data.toStringList());
			tile_file_progress->rec = false;
			tile_file_progress->show(&(r->ft));
		}
		break;
	case FileManager::Remove:
		if (remote_tile) {
			PIByteArray ba;
			ba << int(RemoveFiles) << fm.selectedRemote();
			send(conn_name, ba);
		}
		break;
	case FileManager::MkDir:
		if (remote_tile) {
			PIByteArray ba;
			ba << int(MkDir) << data.toString();
			send(conn_name, ba);
		}
		break;
	case FileManager::LocalCopy:
		// piCoutObj << "localCopy";
		if (remote_tile) {
			localft.setDirectory(fm.localDir());
			_self->sendFiles(fm.remoteDir() + PIDir::separator, data.toStringList());
		} else {
			localft.setDirectory(fm.remoteDir());
			_self->sendFiles(fm.localDir() + PIDir::separator, data.toStringList());
		}
		tile_file_progress->rec = false;
		tile_file_progress->show(&(_self->ft));
	case FileManager::Crypt:
		if (remote_tile) {
			PIByteArray ba;
			ba << int(CryptFiles) << fm.selectedRemote();
			send(conn_name, ba);
		} else {
			_self->dir_my.setDir(fm.localDir());
			_self->cryptFiles(data.toStringList());
		}
		break;
	case FileManager::LocalCrypt:
		piCoutObj << "LocalCrypt";
		if (remote_tile) {
			_self->dir_my.setDir(fm.remoteDir());
		} else {
			_self->dir_my.setDir(fm.localDir());
		}
		_self->cryptFiles(data.toStringList());
		break;
	default: break;
	};
	// piCout << remote_tile << type << data;
}


void Daemon::timerEvent(int delim) {
	screen->lock();
	list_daemons->content.clear();
	availableDaemons();
	for (const auto & i: available_daemons)
		list_daemons->content << TileList::Row(i, CellFormat());
	screen->unlock();
	if (delim == 5 && mode == rmInformation) {
		if (conn_name.isEmpty()) return;
		PIByteArray ba;
		ba << int(RequestHostInfo);
		send(conn_name, ba);
		// std::cout << "send " << std::hex << ba;
	}
}


PIStringList Daemon::availableDaemons() {
	available_daemons.clear();
	lock();
	for (const auto & p: allPeers()) {
		if (!p.name.startsWith(pisd_prefix)) continue;
		available_daemons << p.name.mid(6);
	}
	unlock();
	return available_daemons;
}


void Daemon::connectToDaemon(const PIString & dn) {
	if (dn.isEmpty()) return;
	conn_name = pisd_prefix + dn;
	mode      = rmSelectMode;
}


void Daemon::disconnect() {
	screen->enableExitCapture(PIKbdListener::F10);
	conn_name.clear();
	mode = rmNone;
	showMainList();
}


PIString Daemon::connectedDaemon() const {
	return conn_name.mid(6);
}


void Daemon::peerConnected(const PIString & p_name) {
	while (!inited__)
		piMSleep(PIP_MIN_MSLEEP * 5);
	if (!p_name.startsWith(pisd_prefix)) return;
	Remote * r = new Remote(p_name);
	piCoutObj << "peer connected" << p_name;
	CONNECTU(r, sendRequest, this, sendRequest)
	CONNECTU(r, receiveFinished, this, filesReceived)
	CONNECTU(r, sendFinished, this, filesSended)
	CONNECTU(r, changeDirFinished, this, dirChanged)
	PIMutexLocker ml2(remote_mutex);
	remotes.insert(p_name, r);
}


void Daemon::peerDisconnected(const PIString & p_name) {
	while (!inited__)
		piMSleep(PIP_MIN_MSLEEP * 5);
	piCoutObj << "peer disconnect" << p_name;
	if (p_name == conn_name) {
		disconnect();
	}
	PIMutexLocker ml(remote_mutex);
	Remote * dt = remotes.value(p_name, 0);
	if (!dt) return;
	dt->shellClose();
	if (tile_file_progress->ft == &(dt->ft)) {
		tile_file_progress->close(false);
	}
	remotes.remove(p_name);
	delete dt;
}


void Daemon::filesReceived(const PIString & p_name, bool ok) {
	if (ok) {
		piCout << "files received from" << p_name;
	} else {
		piCout << "warning, files not received fromsended" << p_name;
	}
	closeFileDialog(p_name, ok);
	Remote * r = remotes.value(p_name, 0);
	if (!r) return;
	r->updateDir();
}


void Daemon::filesSended(const PIString & p_name, bool ok) {
	if (ok) {
		piCout << "files sended to" << p_name;
	} else {
		piCout << "warning, files not sended to" << p_name;
	}
	closeFileDialog(p_name, ok);
}


void Daemon::dirChanged(const PIString & p_name, const PIString & dir) {
	if (p_name == self_name) {
		fm.clearSelectionLocal();
		fm.clearSelectionRemote();
		fm.updateLocalDir();
		fm.updateRemoteDir();
		return;
	}
	PIMutexLocker ml(remote_mutex);
	Remote * r = remotes.value(p_name, 0);
	if (!r) return;
	if (r->dir_my.absolutePath() != dir) return;
	sendDirToRemote(r);
}


void Daemon::closeFileDialog(const PIString & p_name, bool ok) {
	// piCout << "CLOSE" << tile_file_progress->conn_name << name << ok;
	if (p_name == self_name) {
		tile_file_progress->close(ok);
		fm.clearSelectionLocal();
		fm.clearSelectionRemote();
		fm.updateLocalDir();
		fm.updateRemoteDir();
		return;
	}
	// piCout << "file transfer with" << p_name << (ok ? "success" : "failure");
	if (tile_file_progress->conn_name != p_name) return;
	tile_file_progress->close(ok);
	if (tile_file_progress->rec) {
		fm.remoteTile()->setFocus();
		fm.clearSelectionRemote();
		fm.updateLocalDir();
	} else {
		fm.localTile()->setFocus();
		fm.clearSelectionLocal();
		requestChDir(".");
	}
}


void Daemon::dataReceived(const PIString & from, const PIByteArray & data) {
	//	piCout << "rec" << data.size();
	if (data.size() < 4) return;
	PIMutexLocker ml(remote_mutex);
	//	piCout << "lock in dataReceived";
	PIByteArray ba(data), rba;
	Remote * r = remotes.value(from);
	PIString dir;
	int type;
	ba >> type;
	// piCout << "rec from " << from << type << r;
	switch (type) {
	case RequestHostInfo:
		makeMyHostInfo();
		rba << int(ReplyHostInfo) << info_my;
		break;
	case RequestChangeDir:
		if (!r) break;
		ba >> dir;
		r->dir_my.cd(dir);
		r->ft.setDirectory(r->dir_my);
		// piCout << "store to" << r->dir_my.absolutePath();
		piCoutObj << "cd to" << r->dir_my.absolutePath();
		r->updateDir();
		break;
	case ReplyHostInfo:
		ba >> info_other;
		makeOtherHostInfo();
		fillInfoTile(info_other);
		break;
	case ReplyChangeDir:
		if (!r) break;
		{
			PIVector<PIFile::FileInfo> fil;
			ba >> dir >> fil;
			fm.setRemoteDir(dir);
			fm.setRemoteContent(fil);
			fm.remoteRestoreDir();
		}
		break;
	case CopyFiles:
		if (!r) return;
		if (r->isRunning()) return;
		{
			PIStringList files;
			ba >> files;
			// piCout << "send" << files << "from" << r->dir_my.absolutePath();
			r->sendFiles(r->dir_my.absolutePath() + PIDir::separator, files);
		}
		break;
	case RemoveFiles:
		if (!r) return;
		if (r->isRunning()) return;
		{
			PIStringList files;
			ba >> files;
			// piCout << "send" << files << "from" << r->dir_my.absolutePath();
			r->removeFiles(files);
		}
		break;
	case MkDir:
		if (!r) return;
		{
			PIString dn;
			ba >> dn;
			// piCout << "send" << files << "from" << r->dir_my.absolutePath();
			r->makeDir(dn);
		}
		break;
	case FileTransfer:
		if (r) r->received(ba);
		break;
	case CryptFiles:
		if (!r) return;
		if (r->isRunning()) return;
		{
			PIStringList files;
			ba >> files;
			r->cryptFiles(files);
		}
		break;
	case ShellOpen:
		if (!r) return;
		r->shellOpen();
		break;
	case ShellClose:
		if (!r) return;
		r->shellClose();
		break;
	case ShellContent: {
		if (!r) return;
		PIVector<PIVector<PIScreenTypes::Cell>> cells;
		ba >> cells;
		tile_shell->setContent(cells);
	} break;
	case ShellResizeRequest: {
		if (!r) return;
		int w, h;
		ba >> w >> h;
		r->shellResize(w, h);
	} break;
	case ShellKeyEvent: {
		if (!r) return;
		PIKbdListener::KeyEvent k;
		ba >> k;
		r->shellKeySend(k);
	} break;
	};
	if (!rba.isEmpty()) send(from, rba);
}


void Daemon::sendDirToRemote(Remote * r) {
	if (!r) return;
	PIVector<PIFile::FileInfo> fil = r->my_filelist;
	PIByteArray ba;
	ba << int(ReplyChangeDir) << r->dir_my.absolutePath() << fil;
	send(r->name(), ba);
}


void Daemon::requestOpenShell() {
	Remote * r = remotes.value(conn_name, 0);
	if (!r) return;
	screen->disableExitCapture();
	PIByteArray ba;
	ba << int(ShellOpen);
	send(conn_name, ba);
	executeQueued(this, "shResizeRequest");
}


void Daemon::requestCloseShell() {
	Remote * r = remotes.value(conn_name, 0);
	if (!r) return;
	screen->enableExitCapture(PIKbdListener::F10);
	PIByteArray ba;
	ba << int(ShellClose);
	send(conn_name, ba);
}


void Daemon::makeMyHostInfo() {
	info_my.execCommand      = PISystemInfo::instance()->execCommand;
	info_my.hostname         = PISystemInfo::instance()->hostname;
	info_my.user             = PISystemInfo::instance()->user;
	info_my.OS_name          = PISystemInfo::instance()->OS_name;
	info_my.OS_version       = PISystemInfo::instance()->OS_version;
	info_my.architecture     = PISystemInfo::instance()->architecture;
	info_my.execDateTime     = PISystemInfo::instance()->execDateTime;
	info_my.processorsCount  = PISystemInfo::instance()->processorsCount;
	info_my.ID               = sys_mon.statistic().ID;
	info_my.threads          = sys_mon.statistic().threads;
	info_my.priority         = sys_mon.statistic().priority;
	info_my.physical_memsize = sys_mon.statistic().physical_memsize;
	info_my.share_memsize    = sys_mon.statistic().share_memsize;
	info_my.cpu_load_system  = sys_mon.statistic().cpu_load_system;
	info_my.cpu_load_user    = sys_mon.statistic().cpu_load_user;
}


void Daemon::makeOtherHostInfo() {
	PISystemMonitor::ProcessStats ps(sys_mon_other.statistic());
	ps.ID               = info_other.ID;
	ps.threads          = info_other.threads;
	ps.priority         = info_other.priority;
	ps.physical_memsize = info_other.physical_memsize;
	ps.share_memsize    = info_other.share_memsize;
	ps.cpu_load_system  = info_other.cpu_load_system;
	ps.cpu_load_user    = info_other.cpu_load_user;
	sys_mon_other.setStatistic(ps);
}


void Daemon::requestChDir(const PIString & d) {
	if (d.isEmpty()) return;
	Remote * r = remotes.value(conn_name, 0);
	if (!r) return;
	fm.remoteSaveDir();
	fm.readingRemote();
	PIByteArray ba;
	ba << int(RequestChangeDir) << d;
	send(conn_name, ba);
}