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     HTTPHelper::Ptr _http_help(new HTTPHelper(_logger,_proxy,_proxy_port,_login,_password));
  60     HTTPHelp = _http_help;
  61     _http_help.reset();
  62
  63     BaseUrl = assemble_base_url(get_hostname(),_gnudip_server);
  64 }
  65
  66
  67 /**
  68  * Default destructor
  69  */
  70 ServiceGnudip::~ServiceGnudip()
  71 {
  72 }
  73
  74
  75 /**
  76  * Assemble the dyndns update url from the given fqhn
  77  * @param hostname The fqhn hostname to update IP for.
  78  * @return The assembled update url without IP.
  79  */
  80 string ServiceGnudip::assemble_base_url(const string& fqhn, const string& gnudip_server) const
  81 {
  82     string base_url;
  83
  84     base_url = "http://";
  85     base_url.append(gnudip_server);
  86     base_url.append("/gnudip/cgi-bin/gdipupdt.cgi");
  87
  88     return base_url;
  89 }
  90
  91
  92 /**
  93  * Parses the data received from the initial request, which should contain salt, time and sign.
  94  * @param curl_data The complete received curl data.
  95  * @return A map with salt, time and sign or an empty map.
  96  */
  97 map<string,string> ServiceGnudip::parse_initial_request(const string& curl_data) const
  98 {
  99     map<string,string> response;
 100
 101     // regex for salt
 102     boost::regex expr_salt("<meta name=\"salt\" content=\"(.*)\">");
 103     // regex for time
 104     boost::regex expr_time("<meta name=\"time\" content=\"(.*)\">");
 105     // regex for sign
 106     boost::regex expr_sign("<meta name=\"sign\" content=\"(.*)\">");
 107
 108     boost::smatch matches;
 109
 110     // Get the salt out of received http data
 111     if ( boost::regex_search(curl_data,matches,expr_salt) )
 112     {
 113         response.insert(pair<string,string>("salt",matches[1]));
 114         get_logger()->print_regex_match(expr_salt.str(),matches[1]);
 115     }
 116     else
 117     {
 118         get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
 119         response.clear();
 120         return response;
 121     }
 122
 123     // Get the time out of received http data
 124     if ( boost::regex_search(curl_data,matches,expr_time) )
 125     {
 126         response.insert(pair<string,string>("time",matches[1]));
 127         get_logger()->print_regex_match(expr_salt.str(),matches[1]);
 128     }
 129     else
 130     {
 131         get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
 132         response.clear();
 133         return response;
 134     }
 135
 136     // Get the sign out of received http data
 137     if ( boost::regex_search(curl_data,matches,expr_sign) )
 138     {
 139         response.insert(pair<string,string>("sign",matches[1]));
 140         get_logger()->print_regex_match(expr_salt.str(),matches[1]);
 141     }
 142     else
 143     {
 144         get_logger()->print_no_regex_match(expr_salt.str(),curl_data);
 145         response.clear();
 146         return response;
 147     }
 148
 149     return response;
 150 }
 151
 152
 153 /**
 154  * Get the assembled update url.
 155  * @param salt Salt from the initial request
 156  * @param time Time from the initial request
 157  * @param sign Sign from the initial request
 158  * @param secret Computed md5 secret in HEX
 159  * @param ip IP to update
 160  * @return The assembled update url.
 161  */
 162 string ServiceGnudip::assemble_update_url(const string& salt, const string& time, const string& sign, const string& secret, const string& ip) const
 163 {
 164         string url = BaseUrl;
 165
 166         url.append("?salt=");
 167         url.append(salt);
 168         url.append("&time=");
 169         url.append(time);
 170         url.append("&sign=");
 171         url.append(sign);
 172         url.append("&user=");
 173         url.append(get_login());
 174         url.append("&domn=");
 175         url.append(get_hostname());
 176         url.append("&pass=");
 177         url.append(secret);
 178         url.append("&reqc=0&addr=");
 179         url.append(ip);
 180
 181         return url;
 182 }
 183
 184
 185 /**
 186  * Performs the Service update.
 187  * @param ip IP Address to set.
 188  * @return 0 if all is fine, -1 otherwise.
 189  */
 190 int ServiceGnudip::perform_update(const std::string& ip)
 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, 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             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() || 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 = Util::compute_md5_digest(get_password());
 231
 232         // append "." and salt and compute md5 sum and get the HEX representation
 233         pw_md5_hex.append(".");
 234         pw_md5_hex.append(salt);
 235         string secret = Util::compute_md5_digest(pw_md5_hex);
 236
 237         // Now its time to issue the second http_get operation
 238         string url = assemble_update_url(salt, time, sign, secret, ip);
 239
 240         // perform the update operation
 241         http_status_code = HTTPHelp->http_get(url);
 242
 243         get_logger()->print_http_status_code(url,http_status_code);
 244
 245         if ( http_status_code == 200 )
 246         {
 247             // parse the update request return code
 248             string update_return_code = HTTPHelp->get_curl_data();
 249             if ( update_return_code == "0" )
 250             {
 251                 return 0;
 252             }
 253             else if ( update_return_code == "1" )
 254             {
 255                 get_logger()->print_http_not_authorized(url,get_login(),get_password());
 256             }
 257             else
 258             {
 259                 get_logger()->print_update_failure(url,update_return_code);
 260             }
 261         }
 262         else
 263         {
 264             // second http get operation (update) was not successful
 265             get_logger()->print_update_failure(url,http_status_code);
 266         }
 267     }
 268     else
 269     {
 270         // first http get operation was not successful
 271         get_logger()->print_update_failure(BaseUrl,http_status_code);
 272     }
 273
 274     return -1;
 275 }
 276
 277
 278 /**
 279  * Serialize function needed by boost/serialization to define which members should be stored as the object state.
 280  * @param ar Archive
 281  * @param version Version
 282  */
 283 template<class Archive>
 284 void ServiceGnudip::serialize(Archive & ar, const unsigned int version)
 285 {
 286     ar & boost::serialization::base_object<Service>(*this);
 287 }