developer.intra2net.com Git - bpdyndnsd/blob - src/service_gnudip.cpp

   1 /** @file
   2  * @brief GNUDIP Service class implementation. This class represents the GNUDIP service.
   3  *
   4  *
   5  *
   6  * @copyright Intra2net AG
   7  * @license GPLv2
   8 */
   9
  10 #include "service_gnudip.h"
  11 #include "util.h"
  12
  13 #include <time.h>
  14 #include <boost/foreach.hpp>
  15 #include <boost/regex.hpp>
  16
  17 using namespace std;
  18
  19
  20 /**
  21  * Default Constructor, needed for object serialization.
  22  */
  23 ServiceGnudip::ServiceGnudip()
  24 {
  25 }
  26
  27
  28 /**
  29  * Constructor.
  30  * @param _hostname The hostname to update
  31  * @param _login The login name.
  32  * @param _password The corresponding password.
  33  */
  34 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)
  35     : GnudipServer(_gnudip_server)
  36 {
  37     if ( _update_interval == -1 )        // If _update_interval is default po::option_desc (not specified via config)
  38         set_update_interval(0);              // use default protocol value
  39     else
  40         set_update_interval(_update_interval);
  41
  42     if ( _max_updates_within_interval == -1 )
  43         set_max_updates_within_interval(0);
  44     else
  45         set_max_updates_within_interval(_max_updates_within_interval);
  46
  47     if ( _dns_cache_ttl == -1 )
  48         set_dns_cache_ttl(60);
  49     else
  50         set_dns_cache_ttl(_dns_cache_ttl);
  51
  52     set_protocol(_protocol);
  53     set_hostname(_hostname);
  54     set_login(_login);
  55     set_password(_password);
  56     set_logger(_logger);
  57
  58     // create http helper class
  59     HTTPHelp = HTTPHelper::Ptr(new HTTPHelper(_logger,_proxy,_proxy_port,_login,_password));
  60
  61     BaseUrl = assemble_base_url(_gnudip_server);
  62 }
  63
  64
  65 /**
  66  * Default destructor
  67  */
  68 ServiceGnudip::~ServiceGnudip()
  69 {
  70 }
  71
  72
  73 /**
  74  * Assemble the dyndns update url from the given fqhn
  75  * @param gnudip_server The gnudip update server.
  76  * @return The assembled update url without IP.
  77  */
  78 string ServiceGnudip::assemble_base_url(const string& gnudip_server) const
  79 {
  80     string base_url;
  81
  82     base_url = "http://";
  83     base_url.append(gnudip_server);
  84     base_url.append("/gnudip/cgi-bin/gdipupdt.cgi");
  85
  86     return base_url;
  87 }
  88
  89
  90 /**
  91  * Parses the data received from the initial request, which should contain salt, time and sign.
  92  * @param curl_data The complete received curl data.
  93  * @return A map with salt, time and sign or an empty map.
  94  */
  95 map<string,string> ServiceGnudip::parse_initial_request(const string& curl_data) const
  96 {
  97     map<string,string> response;
  98
  99     // regex for salt
 100     boost::regex expr_salt("<meta name=\"salt\" content=\"(.*)\">");
 101     // regex for time
 102     boost::regex expr_time("<meta name=\"time\" content=\"(.*)\">");
 103     // regex for sign
 104     boost::regex expr_sign("<meta name=\"sign\" content=\"(.*)\">");
 105
 106     boost::smatch matches;
 107
 108     // Get the salt out of received http data
 109     if ( boost::regex_search(curl_data,matches,expr_salt) )
 110     {
 111         response.insert(pair<string,string>("salt",matches[1].str()));  /*lint !e534 */
 112         get_logger()->print_regex_match(expr_salt.str(),matches[1].str());
 113     }
 114     else
 115     {
 116         get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
 117         response.clear();
 118         return response;
 119     }
 120
 121     // Get the time out of received http data
 122     if ( boost::regex_search(curl_data,matches,expr_time) )
 123     {
 124         response.insert(pair<string,string>("time",matches[1].str()));  /*lint !e534 */
 125         get_logger()->print_regex_match(expr_salt.str(),matches[1].str());
 126     }
 127     else
 128     {
 129         get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
 130         response.clear();
 131         return response;
 132     }
 133
 134     // Get the sign out of received http data
 135     if ( boost::regex_search(curl_data,matches,expr_sign) )
 136     {
 137         response.insert(pair<string,string>("sign",matches[1].str()));  /*lint !e534 */
 138         get_logger()->print_regex_match(expr_salt.str(),matches[1].str());
 139     }
 140     else
 141     {
 142         get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
 143         response.clear();
 144         return response;
 145     }
 146
 147     return response;
 148 }
 149
 150
 151 /**
 152  * Get the assembled update url.
 153  * @param salt Salt from the initial request
 154  * @param time Time from the initial request
 155  * @param sign Sign from the initial request
 156  * @param secret Computed md5 secret in HEX
 157  * @param ip IP to update
 158  * @return The assembled update url.
 159  */
 160 string ServiceGnudip::assemble_update_url(const string& salt, const string& curr_time, const string& sign, const string& secret, const string& ip) const
 161 {
 162         string url = BaseUrl;
 163
 164         url.append("?salt=");
 165         url.append(salt);
 166         url.append("&time=");
 167         url.append(curr_time);
 168         url.append("&sign=");
 169         url.append(sign);
 170         url.append("&user=");
 171         url.append(get_login());
 172         url.append("&domn=");
 173         url.append(get_hostname());
 174         url.append("&pass=");
 175         url.append(secret);
 176         url.append("&reqc=0&addr=");
 177         url.append(ip);
 178
 179         return url;
 180 }
 181
 182
 183 /**
 184  * Performs the Service update.
 185  * @param ip IP Address to set.
 186  * @return 0 if all is fine, -1 otherwise.
 187  */
 188 int ServiceGnudip::perform_update(const std::string& ip)
 189 {
 190     if ( HTTPHelp->is_initialized() )
 191     {
 192         // initial request
 193         long http_status_code = HTTPHelp->http_get(BaseUrl);
 194
 195         get_logger()->print_http_status_code(BaseUrl,http_status_code);
 196
 197         if ( http_status_code == 200 )
 198         {
 199             // Get the received http data which should contain the salt, time and sign
 200             string curl_data = HTTPHelp->get_curl_data();
 201
 202             // Parse salt, time and sign out of the received data
 203             map<string,string> salt_time_sign = parse_initial_request(curl_data);
 204
 205             if ( salt_time_sign.empty() )
 206             {
 207                 get_logger()->print_could_not_parse_received_data(curl_data);
 208                 return -1;
 209             }
 210
 211             // at this point we have salt, time and sign parsed successfully
 212             string salt, sign_time, sign;
 213
 214             map<string,string>::iterator iter = salt_time_sign.find("salt");
 215             if ( iter != salt_time_sign.end() )
 216                 salt = iter->second;
 217
 218             iter = salt_time_sign.find("time");
 219             if ( iter != salt_time_sign.end() )
 220                 sign_time = iter->second;
 221
 222             iter = salt_time_sign.find("sign");
 223             if ( iter != salt_time_sign.end() )
 224                 sign = iter->second;
 225
 226             if ( salt.empty() || sign_time.empty() || sign.empty() )
 227                 get_logger()->print_could_not_get_initial_gnudip_data();
 228
 229             // compute md5 sum from users password and get the HEX representation
 230             string pw_md5_hex;
 231             try
 232             {
 233                 pw_md5_hex = Util::compute_md5_digest(get_password());
 234             }
 235             catch ( exception& e )
 236             {
 237                 get_logger()->print_exception_md5_sum(e.what());
 238                 return -1;
 239             }
 240             catch ( ... )
 241             {
 242                 get_logger()->print_exception_md5_sum("Unknown exception");
 243                 return -1;
 244             }
 245
 246             // append "." and salt and compute md5 sum and get the HEX representation
 247             pw_md5_hex.append(".");
 248             pw_md5_hex.append(salt);
 249
 250             string secret;
 251             try
 252             {
 253                 secret = Util::compute_md5_digest(pw_md5_hex);
 254             }
 255             catch ( exception& e )
 256             {
 257                 get_logger()->print_exception_md5_sum(e.what());
 258                 return -1;
 259             }
 260             catch ( ... )
 261             {
 262                 get_logger()->print_exception_md5_sum("Unknown exception");
 263                 return -1;
 264             }
 265
 266             // Now its time to issue the second http_get operation
 267             string url = assemble_update_url(salt, sign_time, sign, secret, ip);
 268
 269             // perform the update operation
 270             http_status_code = HTTPHelp->http_get(url);
 271
 272             get_logger()->print_http_status_code(url,http_status_code);
 273
 274             if ( http_status_code == 200 )
 275             {
 276                 // parse the update request return code
 277                 string update_return_code = HTTPHelp->get_curl_data();
 278                 if ( update_return_code == "0" )
 279                 {
 280                     return 0;
 281                 }
 282                 else if ( update_return_code == "1" )
 283                 {
 284                     get_logger()->print_service_not_authorized(url,get_login(),get_password());
 285                 }
 286                 else
 287                 {
 288                     get_logger()->print_update_failure(url,update_return_code);
 289                 }
 290             }
 291             else
 292             {
 293                 // second http get operation (update) was not successful
 294                 get_logger()->print_update_failure(url,http_status_code);
 295             }
 296         }
 297         else
 298         {
 299             // first http get operation was not successful
 300             get_logger()->print_update_failure(BaseUrl,http_status_code);
 301         }
 302     }
 303     else
 304     {
 305         get_logger()->print_service_not_initialized(BaseUrl);
 306     }
 307     return -1;
 308 }