Added values for update interval and max updates within this interval for DynDNS...

[bpdyndnsd] / src / service_gnudip.cpp

/** @file
 * @brief GNUDIP Service class implementation. This class represents the GNUDIP service.
 *
 *
 *
 * @copyright Intra2net AG
 * @license GPLv2
*/

#include "service_gnudip.hpp"
#include "util.hpp"

#include <time.h>
#include <boost/foreach.hpp>
#include <boost/regex.hpp>

using namespace std;


/**
 * Default Constructor, needed for object serialization.
 */
ServiceGnudip::ServiceGnudip()
{
}


/**
 * Constructor.
 * @param _hostname The hostname to update
 * @param _login The login name.
 * @param _password The corresponding password.
 */
ServiceGnudip::ServiceGnudip(const string& _protocol, const string& _gnudip_server, const string& _hostname, const string& _login, const string& _password, const Logger::Ptr& _logger, const int _update_interval, const int _max_updates_within_interval, const int _dns_cache_ttl, const string& _proxy, const int _proxy_port)
    : GnudipServer(_gnudip_server)
{
    if ( _update_interval == -1 )        // If _update_interval is default po::option_desc (not specified via config)
        set_update_interval(15);              // use default protocol value
    else
        set_update_interval(_update_interval);

    if ( _max_updates_within_interval == -1 )
        set_max_updates_within_interval(3);
    else
        set_max_updates_within_interval(_max_updates_within_interval);

    if ( _dns_cache_ttl == -1 )
        set_dns_cache_ttl(60);
    else
        set_dns_cache_ttl(_dns_cache_ttl);

    set_protocol(_protocol);
    set_hostname(_hostname);
    set_login(_login);
    set_password(_password);
    set_logger(_logger);

    // create http helper class
    HTTPHelp = HTTPHelper::Ptr(new HTTPHelper(_logger,_proxy,_proxy_port,_login,_password));

    BaseUrl = assemble_base_url(_gnudip_server);
}


/**
 * Default destructor
 */
ServiceGnudip::~ServiceGnudip()
{
}


/**
 * Assemble the dyndns update url from the given fqhn
 * @param gnudip_server The gnudip update server.
 * @return The assembled update url without IP.
 */
string ServiceGnudip::assemble_base_url(const string& gnudip_server) const
{
    string base_url;

    base_url = "http://";
    base_url.append(gnudip_server);
    base_url.append("/gnudip/cgi-bin/gdipupdt.cgi");

    return base_url;
}


/**
 * Parses the data received from the initial request, which should contain salt, time and sign.
 * @param curl_data The complete received curl data.
 * @return A map with salt, time and sign or an empty map.
 */
map<string,string> ServiceGnudip::parse_initial_request(const string& curl_data) const
{
    map<string,string> response;

    // regex for salt
    boost::regex expr_salt("<meta name=\"salt\" content=\"([^\"]*)\"");
    // regex for time
    boost::regex expr_time("<meta name=\"time\" content=\"([^\"]*)\"");
    // regex for sign
    boost::regex expr_sign("<meta name=\"sign\" content=\"([^\"]*)\"");

    boost::smatch matches;

    // Get the salt out of received http data
    if ( boost::regex_search(curl_data,matches,expr_salt) )
    {
        response.insert(pair<string,string>("salt",matches[1].str()));  /*lint !e534 */
        get_logger()->print_regex_match(expr_salt.str(),matches[1].str());
    }
    else
    {
        get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
        response.clear();
        return response;
    }

    // Get the time out of received http data
    if ( boost::regex_search(curl_data,matches,expr_time) )
    {
        response.insert(pair<string,string>("time",matches[1].str()));  /*lint !e534 */
        get_logger()->print_regex_match(expr_salt.str(),matches[1].str());
    }
    else
    {
        get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
        response.clear();
        return response;
    }

    // Get the sign out of received http data
    if ( boost::regex_search(curl_data,matches,expr_sign) )
    {
        response.insert(pair<string,string>("sign",matches[1].str()));  /*lint !e534 */
        get_logger()->print_regex_match(expr_salt.str(),matches[1].str());
    }
    else
    {
        get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
        response.clear();
        return response;
    }

    return response;
}


/**
 * Parses the data received from the update request, which should contain the return code.
 * @param curl_data The complete received curl data.
 * @return A string containing the return code of the update request.
 */
string ServiceGnudip::parse_return_code(const string& curl_data) const
{
    string return_code;

    // regex for return code
    boost::regex expr_retc("<meta name=\"retc\" content=\"([^\"]*)\"");
    boost::smatch matches;

    // Get the return code out of received http data
    if ( boost::regex_search(curl_data,matches,expr_retc) )
    {
        return_code = matches[1].str();
        get_logger()->print_regex_match(expr_retc.str(),matches[1].str());
    }
    else
    {
        get_logger()->print_no_regex_match(expr_retc.str(),curl_data);
        return return_code;
    }

    return return_code;
}


/**
 * Get the assembled update url.
 * @param salt Salt from the initial request
 * @param time Time from the initial request
 * @param sign Sign from the initial request
 * @param secret Computed md5 secret in HEX
 * @param ip IP to update
 * @return The assembled update url.
 */
string ServiceGnudip::assemble_update_url(const string& salt, const string& curr_time, const string& sign, const string& secret, const string& ip) const
{
        string url = BaseUrl;

        url.append("?salt=");
        url.append(salt);
        url.append("&time=");
        url.append(curr_time);
        url.append("&sign=");
        url.append(sign);
        url.append("&user=");
        url.append(get_login());
        url.append("&domn=");
        string fqhn = get_hostname();
        string domain = fqhn.substr(fqhn.find('.')+1);
        url.append(domain);
        url.append("&pass=");
        url.append(secret);
        url.append("&reqc=0&addr=");
        url.append(ip);

        return url;
}


/**
 * Performs the Service update.
 * @param ip IP Address to set.
 * @return 0 if all is fine, -1 otherwise.
 */
int ServiceGnudip::perform_update(const std::string& ip)
{
    if ( HTTPHelp->is_initialized() )
    {
        // initial request
        long http_status_code = HTTPHelp->http_get(BaseUrl);

        get_logger()->print_http_status_code(BaseUrl,http_status_code);

        if ( http_status_code == 200 )
        {
            // Get the received http data which should contain the salt, time and sign
            string curl_data = HTTPHelp->get_curl_data();

            // Parse salt, time and sign out of the received data
            map<string,string> salt_time_sign = parse_initial_request(curl_data);

            if ( salt_time_sign.empty() )
            {
                get_logger()->print_could_not_parse_received_data(curl_data);
                return -1;
            }

            // at this point we have salt, time and sign parsed successfully
            string salt, sign_time, sign;

            map<string,string>::iterator iter = salt_time_sign.find("salt");
            if ( iter != salt_time_sign.end() )
                salt = iter->second;

            iter = salt_time_sign.find("time");
            if ( iter != salt_time_sign.end() )
                sign_time = iter->second;

            iter = salt_time_sign.find("sign");
            if ( iter != salt_time_sign.end() )
                sign = iter->second;

            if ( salt.empty() || sign_time.empty() || sign.empty() )
                get_logger()->print_could_not_get_initial_gnudip_data();

            // compute md5 sum from users password and get the HEX representation
            string pw_md5_hex;
            try
            {
                pw_md5_hex = Util::compute_md5_digest(get_password());
            }
            catch ( exception& e )
            {
                get_logger()->print_exception_md5_sum(e.what());
                return -1;
            }
            catch ( ... )
            {
                get_logger()->print_exception_md5_sum("Unknown exception");
                return -1;
            }

            // append "." and salt and compute md5 sum and get the HEX representation
            pw_md5_hex.append(".");
            pw_md5_hex.append(salt);

            string secret;
            try
            {
                secret = Util::compute_md5_digest(pw_md5_hex);
            }
            catch ( exception& e )
            {
                get_logger()->print_exception_md5_sum(e.what());
                return -1;
            }
            catch ( ... )
            {
                get_logger()->print_exception_md5_sum("Unknown exception");
                return -1;
            }

            // Now its time to issue the second http_get operation
            string url = assemble_update_url(salt, sign_time, sign, secret, ip);

            // perform the update operation
            http_status_code = HTTPHelp->http_get(url);

            get_logger()->print_http_status_code(url,http_status_code);

            if ( http_status_code == 200 )
            {
                // parse the update request return code
                curl_data = HTTPHelp->get_curl_data();
                string update_return_code = parse_return_code(curl_data);
                if ( update_return_code == "0" )
                {
                    return 0;
                }
                else if ( update_return_code == "1" )
                {
                    get_logger()->print_service_not_authorized(url,get_login(),get_password());
                }
                else
                {
                    get_logger()->print_update_failure(url,update_return_code);
                }
            }
            else
            {
                // second http get operation (update) was not successful
                get_logger()->print_update_failure(url,http_status_code);
            }
        }
        else
        {
            // first http get operation was not successful
            get_logger()->print_update_failure(BaseUrl,http_status_code);
        }
    }
    else
    {
        get_logger()->print_httphelper_not_initialized();
        HTTPHelp->re_initialize();
    }
    return -1;
}