367 lines
11 KiB
C++
367 lines
11 KiB
C++
/* Pandora agents service for Win32.
|
|
|
|
Copyright (C) 2006 Artica ST.
|
|
Written by Esteban Sanchez.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this program; if not, write to the Free Software Foundation,
|
|
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include "pandora_windows_service.h"
|
|
#include "pandora.h"
|
|
#include "pandora_strutils.h"
|
|
#include "windows_service.h"
|
|
#include "modules/pandora_module_factory.h"
|
|
#include "ssh/pandora_ssh_client.h"
|
|
#include "ftp/pandora_ftp_client.h"
|
|
#include "misc/pandora_file.h"
|
|
#include "windows/pandora_windows_info.h"
|
|
|
|
#include <iostream>
|
|
#include <cstdlib>
|
|
#include <ctime>
|
|
|
|
using namespace std;
|
|
using namespace Pandora;
|
|
using namespace Pandora_Modules;
|
|
using namespace Pandora_Strutils;
|
|
|
|
string enabled_values[] = {"enabled", "1", "on", "yes", "si", "sí", "ok", ""};
|
|
|
|
/**
|
|
* Creates a new Pandora_Windows_Service.
|
|
*
|
|
* @param svc_name Internal service name
|
|
* @param svc_display_name Service name that will appear in the
|
|
* Windows service administration tool.
|
|
* @param svc_description Long description of the service.
|
|
*/
|
|
Pandora_Windows_Service::Pandora_Windows_Service (const char * svc_name,
|
|
const char * svc_display_name,
|
|
const char * svc_description)
|
|
: Windows_Service (svc_name, svc_display_name, svc_description) {
|
|
|
|
this->setInitFunction ((void (Windows_Service::*) ())
|
|
&Pandora_Windows_Service::pandora_init);
|
|
this->setRunFunction ((void (Windows_Service::*) ())
|
|
&Pandora_Windows_Service::pandora_run);
|
|
execution_number = 0;
|
|
this->modules = NULL;
|
|
this->conf = NULL;
|
|
}
|
|
|
|
/**
|
|
* Destroys a Pandora_Windows_Service object.
|
|
*/
|
|
Pandora_Windows_Service::~Pandora_Windows_Service () {
|
|
if (this->conf != NULL) {
|
|
delete this->conf;
|
|
}
|
|
|
|
if (this->modules != NULL) {
|
|
delete this->modules;
|
|
}
|
|
pandoraLog ("Pandora agent stopped");
|
|
}
|
|
|
|
bool
|
|
is_enabled (string value) {
|
|
int i = 0;
|
|
|
|
if (value == "") {
|
|
return false;
|
|
}
|
|
|
|
while (enabled_values[i] != "") {
|
|
if (enabled_values[i] == value) {
|
|
return true;
|
|
}
|
|
i++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
Pandora_Windows_Service::pandora_init () {
|
|
int interval_ms = 60000;
|
|
string conf_file, interval, debug;
|
|
|
|
setPandoraDebug (true);
|
|
|
|
conf_file = Pandora::getPandoraInstallDir ();
|
|
conf_file += "pandora_agent.conf";
|
|
|
|
this->conf = new Pandora::Pandora_Agent_Conf (conf_file);
|
|
this->modules = new Pandora_Module_List (conf_file);
|
|
|
|
/* Get the interval value (in minutes) and set it to the service */
|
|
interval = conf->getValue ("interval");
|
|
|
|
debug = conf->getValue ("debug");
|
|
setPandoraDebug (is_enabled (debug));
|
|
|
|
if (interval != "") {
|
|
try {
|
|
/* miliseconds */
|
|
interval_ms = strtoint (interval) * 1000;
|
|
} catch (Invalid_Conversion e) {
|
|
}
|
|
}
|
|
|
|
srand ((unsigned) time (0));
|
|
this->setSleepTime (interval_ms);
|
|
|
|
pandoraLog ("Pandora agent started");
|
|
}
|
|
|
|
TiXmlElement *
|
|
Pandora_Windows_Service::getXmlHeader () {
|
|
TiXmlElement *agent;
|
|
SYSTEMTIME st;
|
|
char timestamp[20];
|
|
string value;
|
|
|
|
agent = new TiXmlElement ("agent_data");
|
|
|
|
value = conf->getValue ("agent_name");
|
|
if (value == "") {
|
|
value = Pandora_Windows_Info::getSystemName ();
|
|
}
|
|
agent->SetAttribute ("agent_name", value);
|
|
|
|
agent->SetAttribute ("version", getPandoraAgentVersion ());
|
|
|
|
GetSystemTime(&st);
|
|
sprintf (timestamp, "%d-%d-%d %d:%d:%d", st.wYear, st.wMonth, st.wDay,
|
|
st.wHour, st.wMinute, st.wSecond);
|
|
agent->SetAttribute ("timestamp", timestamp);
|
|
|
|
value = conf->getValue ("interval");
|
|
agent->SetAttribute ("interval", value);
|
|
|
|
value = Pandora_Windows_Info::getOSName ();
|
|
agent->SetAttribute ("os", value);
|
|
|
|
value = Pandora_Windows_Info::getOSVersion ();
|
|
agent->SetAttribute ("os_version", value);
|
|
|
|
return agent;
|
|
}
|
|
|
|
void
|
|
Pandora_Windows_Service::copyScpDataFile (string host,
|
|
string remote_path,
|
|
string filename)
|
|
{
|
|
SSH::Pandora_Ssh_Client ssh_client;
|
|
string tmp_dir, filepath;
|
|
string pubkey_file, privkey_file;
|
|
|
|
tmp_dir = conf->getValue ("temporal");
|
|
if (tmp_dir[tmp_dir.length () - 1] != '\\') {
|
|
tmp_dir += "\\";
|
|
}
|
|
filepath = tmp_dir + filename;
|
|
|
|
pandoraDebug ("Connecting with %s", host.c_str ());
|
|
|
|
try {
|
|
pubkey_file = Pandora::getPandoraInstallDir ();
|
|
pubkey_file += "key\\id_dsa.pub";
|
|
privkey_file = Pandora::getPandoraInstallDir ();
|
|
privkey_file += "key\\id_dsa";
|
|
|
|
ssh_client.connectWithPublicKey (host.c_str (), 22, "pandora",
|
|
pubkey_file, privkey_file, "");
|
|
} catch (SSH::Authentication_Failed e) {
|
|
pandoraLog ("Pandora Agent: Authentication Failed "
|
|
"when connecting to %s",
|
|
host.c_str ());
|
|
throw e;
|
|
} catch (Pandora_Exception e) {
|
|
pandoraLog ("Pandora Agent: Failed when copying to %s",
|
|
host.c_str ());
|
|
throw e;
|
|
}
|
|
|
|
pandoraDebug ("Remote copying XML %s on server %s at %s%s",
|
|
filepath.c_str (), host.c_str (),
|
|
remote_path.c_str (), filename.c_str ());
|
|
try {
|
|
ssh_client.scpFileFilename (remote_path + filename,
|
|
filepath);
|
|
} catch (Pandora_Exception e) {
|
|
pandoraLog ("Unable to copy at %s%s", remote_path.c_str (),
|
|
filename.c_str ());
|
|
ssh_client.disconnect();
|
|
|
|
throw e;
|
|
}
|
|
|
|
ssh_client.disconnect();
|
|
}
|
|
|
|
void
|
|
Pandora_Windows_Service::copyFtpDataFile (string host,
|
|
string remote_path,
|
|
string filename)
|
|
{
|
|
FTP::Pandora_Ftp_Client ftp_client;
|
|
string filepath;
|
|
string password;
|
|
|
|
filepath = conf->getValue ("temporal");
|
|
if (filepath[filepath.length () - 1] != '\\') {
|
|
filepath += "\\";
|
|
}
|
|
filepath += filename;
|
|
|
|
password = conf->getValue ("ftp_password");
|
|
|
|
ftp_client.connect (host,
|
|
22,
|
|
"pandora",
|
|
password);
|
|
|
|
try {
|
|
ftp_client.ftpFileFilename (remote_path + filename,
|
|
filepath);
|
|
} catch (FTP::Unknown_Host e) {
|
|
pandoraLog ("Pandora Agent: Failed when copying to %s (%s)",
|
|
host.c_str (), ftp_client.getError ().c_str ());
|
|
ftp_client.disconnect ();
|
|
throw e;
|
|
} catch (FTP::Authentication_Failed e) {
|
|
pandoraLog ("Pandora Agent: Authentication Failed "
|
|
"when connecting to %s (%s)",
|
|
host.c_str (), ftp_client.getError ().c_str ());
|
|
ftp_client.disconnect ();
|
|
throw e;
|
|
} catch (FTP::FTP_Exception e) {
|
|
pandoraLog ("Pandora Agent: Failed when copying to %s (%s)",
|
|
host.c_str (), ftp_client.getError ().c_str ());
|
|
ftp_client.disconnect ();
|
|
throw e;
|
|
}
|
|
|
|
ftp_client.disconnect ();
|
|
}
|
|
|
|
void
|
|
Pandora_Windows_Service::copyDataFile (string filename)
|
|
{
|
|
string mode, host, remote_path;
|
|
|
|
mode = conf->getValue ("transfer_mode");
|
|
host = conf->getValue ("server_ip");
|
|
remote_path = conf->getValue ("server_path");
|
|
if (remote_path[remote_path.length () - 1] != '/') {
|
|
remote_path += "/";
|
|
}
|
|
|
|
try {
|
|
if (mode == "ftp") {
|
|
copyFtpDataFile (host, remote_path, filename);
|
|
} else if (mode == "ssh" || mode == "") {
|
|
copyScpDataFile (host, remote_path, filename);
|
|
} else {
|
|
pandoraLog ("Invalid transfer mode: %s."
|
|
"Please recheck transfer_mode option "
|
|
"in configuration file.");
|
|
}
|
|
|
|
pandoraDebug ("Successfuly copied XML file to server.");
|
|
} catch (Pandora_Exception e) {
|
|
}
|
|
}
|
|
|
|
void
|
|
Pandora_Windows_Service::pandora_run () {
|
|
TiXmlDocument *doc;
|
|
TiXmlElement *local_xml, *agent;
|
|
string xml_filename, random_integer;
|
|
string tmp_filename, tmp_filepath, interval;
|
|
bool saved;
|
|
|
|
pandoraDebug ("Run begin");
|
|
|
|
agent = getXmlHeader ();
|
|
|
|
execution_number++;
|
|
|
|
if (this->modules != NULL) {
|
|
this->modules->goFirst ();
|
|
|
|
while (! this->modules->isLast ()) {
|
|
Pandora_Module *module;
|
|
string result;
|
|
|
|
module = this->modules->getCurrentValue ();
|
|
|
|
pandoraDebug ("Run %s", module->getName ().c_str ());
|
|
module->run ();
|
|
|
|
local_xml = module->getXml ();
|
|
if (local_xml != NULL) {
|
|
agent->InsertEndChild (*local_xml);
|
|
|
|
delete local_xml;
|
|
}
|
|
this->modules->goNext ();
|
|
}
|
|
}
|
|
|
|
random_integer = inttostr (rand());
|
|
tmp_filename = conf->getValue ("agent_name");
|
|
if (tmp_filename == "") {
|
|
tmp_filename = Pandora_Windows_Info::getSystemName ();
|
|
}
|
|
tmp_filename += "." + random_integer + ".data";
|
|
|
|
xml_filename = conf->getValue ("temporal");
|
|
if (xml_filename[xml_filename.length () - 1] != '\\') {
|
|
xml_filename += "\\";
|
|
}
|
|
tmp_filepath = xml_filename + tmp_filename;
|
|
|
|
/* Copy the XML to a temporal file */
|
|
pandoraDebug ("Copying XML on %s", tmp_filepath.c_str ());
|
|
doc = new TiXmlDocument (tmp_filepath);
|
|
doc->InsertEndChild (*agent);
|
|
saved = doc->SaveFile();
|
|
delete doc;
|
|
delete agent;
|
|
|
|
if (!saved) {
|
|
pandoraLog ("Error when saving the XML in %s",
|
|
tmp_filepath.c_str ());
|
|
return;
|
|
}
|
|
|
|
if (getPandoraDebug () == false) {
|
|
this->copyDataFile (tmp_filename);
|
|
|
|
try {
|
|
Pandora_File::removeFile (tmp_filepath);
|
|
} catch (Pandora_File::Delete_Error e) {
|
|
}
|
|
}
|
|
|
|
/* Get the interval value (in minutes) */
|
|
interval = conf->getValue ("interval");
|
|
pandoraDebug ("Next execution on %s seconds", interval.c_str ());
|
|
|
|
return;
|
|
}
|