Added implementation of gnudip protocol.

[bpdyndnsd] / src / updater.cpp

/** @file
 * @brief The updater class implementation. This class implements the updater logic.
 *
 *
 *
 * @copyright Intra2net AG
 * @license GPLv2
*/

#include "updater.h"

#include "serviceholder.h"
#include "service_dhs.h"
#include "service_ods.h"
#include "service_dyndns.h"
#include "service_dyns.h"
#include "service_easydns.h"
#include "service_tzo.h"
#include "service_zoneedit.h"
#include "service_gnudip.h"

#include <boost/foreach.hpp>


// Following boost macros are needed for serialization of derived classes through a base class pointer (Service *).
BOOST_CLASS_EXPORT_GUID(ServiceOds, "ServiceOds")
BOOST_CLASS_EXPORT_GUID(ServiceDhs, "ServiceDhs")
BOOST_CLASS_EXPORT_GUID(ServiceDyns, "ServiceDyns")
BOOST_CLASS_EXPORT_GUID(ServiceDyndns, "ServiceDyndns")
BOOST_CLASS_EXPORT_GUID(ServiceEasydns, "ServiceEasydns")
BOOST_CLASS_EXPORT_GUID(ServiceTzo, "ServiceTzo")
BOOST_CLASS_EXPORT_GUID(ServiceZoneedit, "ServiceZoneedit")
BOOST_CLASS_EXPORT_GUID(ServiceGnudip, "ServiceGnudip")


namespace fs = boost::filesystem;

using namespace std;

/**
 * Default constructor which initializes the member Conf.
 */
Updater::Updater()
    : IPHelp(new IPHelper)
{
    // Initialize program wide Logger, at this point we don't know where to log and with which loglevel.
    Logger::Ptr _log(new Logger);
    Log = _log;
    _log.reset();

    // initialize Serviceholder
    Serviceholder::Ptr _serviceholder(new Serviceholder(Log));
    ServiceHolder = _serviceholder;
    _serviceholder.reset();

    // initialize Config
    Config::Ptr _config(new Config(Log,ServiceHolder));
    Conf = _config;
    _config.reset();
}


/**
 * Default destructor.
 */
Updater::~Updater()
{
}



/**
 * Load config and initialize helper classes.
 * @param argc Number of arguments in array
 * @param argv Array with cmd options
 */
int Updater::load_config(int argc, char *argv[])
{
    // load the cmd options
    if ( init_config_from_cmd(argc,argv) != 0 )
        return -1;

    // load the config and service files
    if ( init_config_from_files() != 0 )
        return -1;

    // init all helper classes
    if ( init_helper_classes() != 0 )
        return -1;

    return 0;
}


/**
 * Reloading the config. Delete all Service objects and then init new Service objects from config files.
 */
int Updater::reload_config()
{
    // serialize all service objects
    if ( ServiceHolder->serialize_services() != 0 )
        return -1;

    // delete all service objects
    ServiceHolder->delete_services();

    // delete the actual Variables_map, perhaps with old cmd options which would overwrite new config file options.
    Conf->delete_variables_map();

    // load only config files
    if ( init_config_from_files() != 0 )
        return -1;

    // init all helper classes
    if ( init_helper_classes() != 0 )
        return -1;

    return 0;
}


/**
 * Parse the command line arguments and initialize corresponding options.
 * @param argc Number command line arguments.
 * @param argv[] Array with arguments.
 * @return 0 if cmd options successfully parsed, 1 if usage or version.
 */
int Updater::init_config_from_cmd(int argc, char *argv[])
{
    // Load the command line parameters
    if( Conf->parse_cmd_line( argc, argv) != 0)
        return -1;

    // If we have loaded the cmd options we need to init the log facility immediately in case debugging is enabled from cmd.
    init_log_facility();

    // successful parsed
    Log->print_cmd_parsed();
    return 0;
}


/**
 * Load the main config and the service definition files in config path.
 * @return 0 if all is fine, 
 */
int Updater::init_config_from_files()
{
    // Load the main and service config files in config path
    if ( Conf->load_config_from_files() != 0 )
        return -1;

    // Re-init log facility, perhaps new config file options for logger are set.
    // These config file options will only overwrite the cmd options if the SIGHUP (reload config) is caught.
    init_log_facility();

    // Here we are. All Service Objects should be initialized, so it is time to deserialize the old service objects and compare them.
    if ( ServiceHolder->deserialize_services() != 0 )
        return -1;

    // successful loaded
    Log->print_conf_files_parsed();
    return 0;
}


/**
 * Init all Helper classes
 * @return 
 */
int Updater::init_helper_classes()
{
    // Initialize IPHelper
    if ( init_ip_helper() != 0 )
        return -1;

    return 0;
}


/**
 * Init the IPHelp member with needed values.
 * @return 0 if all is fine, -1 otherwise.
 */
int Updater::init_ip_helper()
{
    // initialize IPHelper
    IPHelper::Ptr _iphelp(new IPHelper(Log,Conf->get_webcheck_ip_url(),Conf->get_webcheck_ip_url_alt(),Conf->get_enable_ipv6(),Conf->get_proxy(),Conf->get_proxy_port()));
    IPHelp = _iphelp;
    _iphelp.reset();

    return 0;
}


/**
 * Getter for member Config.
 * @return Member Config.
 */
Config::Ptr Updater::get_config() const
{
    return Conf;
}


/**
 * Getter for member Logger.
 * @return Member Logger.
 */
Logger::Ptr Updater::get_logger() const
{
    return Log;
}


/**
 * Initialize the logging facility with loglevel and syslog.
 */
void Updater::init_log_facility()
{
    Log->set_log_facility(Conf->get_loglevel(),Conf->get_syslog(),Conf->get_external_warning_log(),Conf->get_external_warning_level());
    Log->print_init_log_facility();
}


/**
 * Update all configured services.
 */
void Updater::update_services()
{
    list<Service::Ptr> services = ServiceHolder->get_services();

    string ip = IPHelp->get_actual_ip();

    if ( !ip.empty() )
    {
        BOOST_FOREACH(Service::Ptr &service, services )
        {
            string dns_recheck_ip = ip;
            int current_time = time(NULL);

            int lastupdated = 0;
            if ( service->get_last_updates()->size() > 0 )
                lastupdated = service->get_last_updates()->front();

            // If the dns cache ttl is expired or the service is updated for the first time, then get the actual ip of the dns record (this should be the IP in the last update)
            if ( ((lastupdated != 0) && ((lastupdated + service->get_dns_cache_ttl()) < current_time)) || (lastupdated == 0) )
            {
                Log->print_recheck_dns_entry(service->get_hostname(),lastupdated,service->get_dns_cache_ttl(),current_time);
                string _dns_recheck_ip = IPHelp->dns_query(service->get_hostname());
                Log->print_cached_dns_entry(service->get_hostname(), _dns_recheck_ip, service->get_actual_ip());
                if (!_dns_recheck_ip.empty())
                    dns_recheck_ip = _dns_recheck_ip;
            }

            // In case the local hosts IP (ip) differ from the IP set in the last update (actual_ip) or
            // the IP of the dns record (dns_recheck_ip) differs from the IP of the local host (ip)
            // then perform an update. This implies that the update is not performed if actual_ip == dns_recheck_ip.
            // Special case when latupdated == 0 then only perform the update if dns_rechek_ip differs from ip
            if ( ((service->get_actual_ip() != ip) && (lastupdated != 0)) || (dns_recheck_ip != ip)  )
                service->update(ip,current_time);
            else if ( (service->get_actual_ip() != ip) && (lastupdated == 0)  )
                service->set_actual_ip(ip);
        }
    }
}


/**
 * Getter for member ServiceHolder.
 * @return ServiceHolder
 */
Serviceholder::Ptr Updater::get_service_holder() const
{
    return ServiceHolder;
}