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

   1 /** @file
   2  * @brief Logger class implementation. This class implements the Logging facility.
   3  *
   4  *
   5  *
   6  * @copyright Intra2net AG
   7  * @license GPLv2
   8 */
   9
  10
  11 #include "logger.h"
  12
  13 #include <iostream>
  14 #include <syslog.h>
  15 #include <sstream>
  16
  17 #include <boost/foreach.hpp>
  18
  19 #define VERSION     0
  20 #define REVISION    1
  21 #define RELEASE     0
  22
  23 namespace po = boost::program_options;
  24
  25 typedef boost::shared_ptr<boost::program_options::options_description> Options_descriptionPtr;
  26
  27 using namespace std;
  28
  29 /**
  30  * Default Constructor
  31  */
  32 Logger::Logger()
  33     : Loglevel(0)
  34     , Syslog(false)
  35     , ExternalWarningLevel(0)
  36 {
  37     set_log_facility(Loglevel,Syslog,ExternalWarningLog,ExternalWarningLevel);
  38 }
  39
  40
  41 /**
  42  * Default Destructor
  43  */
  44 Logger::~Logger()
  45 {
  46 }
  47
  48
  49 /**
  50  * Decides if Logging through syslog if enabled or through std.
  51  * @param msg The message to log.
  52  */
  53 void Logger::log_notice(const string& msg) const
  54 {
  55     if ( Syslog )
  56         syslog(LOG_NOTICE,msg.c_str());
  57     else
  58         cout << msg << endl;;
  59 }
  60
  61
  62 /**
  63  * Decides if Logging through syslog if enabled or through std.
  64  * @param msg The message to log.
  65  */
  66 void Logger::log_warning(const string& msg, int level) const
  67 {
  68     if ( Syslog )
  69         syslog(LOG_WARNING,msg.c_str());
  70     else
  71         cout << msg << endl;
  72
  73     if ( (level <= ExternalWarningLevel) && (!ExternalWarningLog.empty()) )
  74     {
  75         string external = ExternalWarningLog;
  76         external.append(" ");
  77         external.append("\"");
  78         external.append(msg);
  79         external.append("\"");
  80         if ( system(external.c_str()) != 0 )
  81             print_error_external_logging(external);
  82     }
  83 }
  84
  85
  86 /**
  87  * Decides if Logging through syslog if enabled or through std.
  88  * @param msg The message to log.
  89  */
  90 void Logger::log_error(const string& msg) const
  91 {
  92     if ( Syslog )
  93         syslog(LOG_ERR,msg.c_str());
  94     else
  95         cerr << msg << endl;
  96 }
  97
  98
  99 /**
 100  * Setter for member Loglevel.
 101  * @param _loglevel Value to set Loglevel to.
 102  */
 103 void Logger::set_loglevel(const int _loglevel)
 104 {
 105     Loglevel = _loglevel;
 106     cout << "Loglevel set" << endl;
 107 }
 108
 109
 110 /**
 111  * Getter for member Loglevel.
 112  * @return Loglevel.
 113  */
 114 int Logger::get_loglevel() const
 115 {
 116     return Loglevel;
 117 }
 118
 119
 120 /**
 121  * Setter for member Syslog.
 122  * @param _syslog Wether to log through syslog or not.
 123  */
 124 void Logger::set_syslog(const bool _syslog)
 125 {
 126     Syslog = _syslog;
 127 }
 128
 129
 130 /**
 131  * Getter for member Syslog.
 132  * @return True if logging through syslog is enabled, false otherwise.
 133  */
 134 bool Logger::get_syslog() const
 135 {
 136     return Syslog;
 137 }
 138
 139
 140 /**
 141  * Initialize the logging facility.
 142  */
 143 void Logger::set_log_facility(const int _loglevel, const bool _syslog, const string& _external_error_log, const int _external_error_level)
 144 {
 145     Loglevel = _loglevel;
 146     Syslog = _syslog;
 147     ExternalWarningLog = _external_error_log;
 148     ExternalWarningLevel = _external_error_level;
 149
 150
 151     if ( Syslog )
 152         openlog("bpdyndnsd",LOG_PID,LOG_DAEMON);
 153 }
 154
 155
 156 /**
 157  * Prints out the usage to the command line.
 158  */
 159 void Logger::print_usage(const Options_descriptionPtr opt_desc) const
 160 {
 161     int level = 0;
 162     if ( level <= Loglevel )
 163     {
 164         ostringstream msg;
 165         msg << "Usage: bpdyndnsd [Command line options]" << "\n" << endl;
 166         msg << *opt_desc << endl;
 167         log_notice(msg.str());
 168     }
 169 }
 170
 171
 172 /**
 173  * Prints out the programm name and the given version string on stdout.
 174  * @param version Version string.
 175  */
 176 void Logger::print_version() const
 177 {
 178     int level = 0;
 179     if ( level <= Loglevel )
 180     {
 181         ostringstream msg;
 182         msg << "Bullet proof dynamic dns daemon.\nbpdyndnsd " << VERSION << "." << REVISION << "." << RELEASE << endl;
 183         log_notice(msg.str());
 184     }
 185 }
 186
 187
 188 /**
 189  * Prints out the successful parsing of the command line options.
 190  */
 191 void Logger::print_cmd_parsed() const
 192 {
 193     int level = 1;
 194     if ( level <= Loglevel )
 195     {
 196         log_notice("Command line options successfully parsed.");
 197     }
 198 }
 199
 200
 201 void Logger::print_conf_files_parsed() const
 202 {
 203     int level = 1;
 204     if ( level <= Loglevel )
 205     {
 206         log_notice("Config files successfully parsed.");
 207     }
 208 }
 209
 210
 211 /**
 212  * Prints out the successful parsing of the config files.
 213  * @param config_path The specified config path.
 214  */
 215 void Logger::print_conf_loaded(const string& config_path) const
 216 {
 217     int level = 1;
 218     if ( level <= Loglevel )
 219     {
 220         ostringstream msg;
 221         msg << "Config files successfully loaded in: " << config_path << endl;
 222         log_notice(msg.str());
 223     }
 224 }
 225
 226
 227 /**
 228  * Prints out the unsuccessful parsing of the config files.
 229  * @param config_path The specified config path.
 230  */
 231 void Logger::print_conf_not_loaded(const string& config_path) const
 232 {
 233     int level = 0;
 234     if ( level <= Loglevel )
 235     {
 236         ostringstream msg;
 237         msg << "Config files couldn't be loaded in: " << config_path << endl;
 238         log_error(msg.str());
 239     }
 240 }
 241
 242
 243 /**
 244  * A file could not be opened for reading.
 245  * @param filename The filename.
 246  */
 247 void Logger::print_error_opening_r(const string& filename) const
 248 {
 249     int level = 0;
 250     if ( level <= Loglevel )
 251     {
 252         ostringstream msg;
 253         msg << "Error opening file for reading: " << filename << endl;
 254         log_error(msg.str());
 255     }
 256 }
 257
 258
 259 /**
 260  * A file could not be opened for writing.
 261  * @param filename The filename.
 262  */
 263 void Logger::print_error_opening_rw(const string& filename) const
 264 {
 265     int level = 0;
 266     if ( level <= Loglevel )
 267     {
 268         ostringstream msg;
 269         msg << "Error opening file for writing: " << filename << endl;
 270         log_error(msg.str());
 271     }
 272 }
 273
 274
 275 /**
 276  * Desctructor of specified class was called.
 277  * @param _class Name of the class.
 278  */
 279 void Logger::print_destructor_call(const string& _class) const
 280 {
 281     int level = 1;
 282     if ( level <= Loglevel )
 283     {
 284         ostringstream msg;
 285         msg << "Destructor call: " << _class << endl;
 286         log_notice(msg.str());
 287     }
 288 }
 289
 290
 291 /**
 292  * Constructor of specified class was called.
 293  * @param _class Name of the class.
 294  */
 295 void Logger::print_constructor_call(const string& _class) const
 296 {
 297     int level = 1;
 298     if ( level <= Loglevel )
 299     {
 300         ostringstream msg;
 301         msg << "Constructor call: " << _class << endl;
 302         log_notice(msg.str());
 303     }
 304 }
 305
 306
 307 /**
 308  * Update method for specified service was called.
 309  * @param service The service for which is the update running.
 310  */
 311 void Logger::print_update_service(const string& service) const
 312 {
 313     int level = 0;
 314     if ( level <= Loglevel )
 315     {
 316         ostringstream msg;
 317         msg << "Running update for service: " << service << endl;
 318         log_notice(msg.str());
 319     }
 320 }
 321
 322
 323 /**
 324  * An unknown option on the command line was detected.
 325  * @param unknown_option The unknown option.
 326  */
 327 void Logger::print_unknown_cmd_option(const string& unknown_option) const
 328 {
 329     int level = 0;
 330     if ( level <= Loglevel )
 331     {
 332         ostringstream msg;
 333         msg << "Unknown option on command line detected: " << unknown_option << endl;
 334         log_error(msg.str());
 335     }
 336 }
 337
 338
 339 /**
 340  * An unknown protocol was specified.
 341  * @param protocol The unknown protocol.
 342  */
 343 void Logger::print_unknown_protocol(const string& protocol) const
 344 {
 345     int level = 0;
 346     if ( level <= Loglevel )
 347     {
 348         ostringstream msg;
 349         msg << "Unknown protocol defined: " << protocol << endl;
 350         log_error(msg.str());
 351     }
 352 }
 353
 354
 355 /**
 356  * Loading a service config file.
 357  * @param filename The service config file.
 358  */
 359 void Logger::print_load_service_conf(const string& filename) const
 360 {
 361     int level = 1;
 362     if ( level <= Loglevel )
 363     {
 364         ostringstream msg;
 365         msg << "Loading service config file: " << filename << endl;
 366         log_notice(msg.str());
 367     }
 368 }
 369
 370
 371 /**
 372  * Loading the main config file.
 373  * @param filename The main config file.
 374  */
 375 void Logger::print_load_main_conf(const string& filename) const
 376 {
 377     int level = 1;
 378     if ( level <= Loglevel )
 379     {
 380         ostringstream msg;
 381         msg << "Loading main config file: " << filename << endl;
 382         log_notice(msg.str());
 383     }
 384 }
 385
 386
 387 /**
 388  * There is an unknown option in a service config file.
 389  * @param unknown_option The unknown option.
 390  */
 391 void Logger::print_unknown_service_conf_option(const string& service_conf_file, const string& unknown_option) const
 392 {
 393     int level = 0;
 394     if ( level <= Loglevel )
 395     {
 396         ostringstream msg;
 397         msg << "Unknown option in service config file detected: " << service_conf_file << " Unknown option: " << unknown_option << endl;
 398         log_error(msg.str());
 399     }
 400 }
 401
 402
 403 /**
 404  * There is an unknown option in the main config file.
 405  * @param unknown_option The unknown option.
 406  */
 407 void Logger::print_unknown_main_conf_option(const string& unknown_option) const
 408 {
 409     int level = 0;
 410     if ( level <= Loglevel )
 411     {
 412         ostringstream msg;
 413         msg << "Unknown option in main config file detected: " << unknown_option << endl;
 414         log_error(msg.str());
 415     }
 416 }
 417
 418
 419 /**
 420  * The defined config path doesn't exist or is not a directory.
 421  * @param config_path The defined config path.
 422  */
 423 void Logger::print_error_config_path(const string& config_path) const
 424 {
 425     int level = 0;
 426     if ( level <= Loglevel )
 427     {
 428         ostringstream msg;
 429         msg << "Config path doesn't exists or is not a diretory: " << config_path << endl;
 430         log_error(msg.str());
 431     }
 432 }
 433
 434
 435 /**
 436  * There is a missing command line option to initialize a service object.
 437  */
 438 void Logger::print_missing_cmd_service_option() const
 439 {
 440     int level = 0;
 441     if ( level <= Loglevel )
 442     {
 443         log_error("Missing option to initialize service. Protocol, host, login and password must be specified.");
 444     }
 445 }
 446
 447
 448 /**
 449  * Missing option in service config file.
 450  * @param service_conf_file Service config file
 451  */
 452 void Logger::print_missing_service_conf_option(const string& service_conf_file) const
 453 {
 454     int level = 0;
 455     if ( level <= Loglevel )
 456     {
 457         ostringstream msg;
 458         msg << "Missing option in service config file " << service_conf_file << " to initialize service. Protocol, host, login and password must be specified." << endl;
 459         log_error(msg.str());
 460     }
 461 }
 462
 463
 464 /**
 465  * Process running as daemon.
 466  * @param pid The pid of the daemon.
 467  */
 468 void Logger::print_runnig_as_daemon(const int pid) const
 469 {
 470     int level = 1;
 471     if ( level <= Loglevel )
 472     {
 473         ostringstream msg;
 474         msg << "Runnig as daemon: " << pid << endl;
 475         log_notice(msg.str());
 476     }
 477 }
 478
 479
 480 /**
 481  * Prints out the daemon mode.
 482  * @param daemon_mode The daemon mode.
 483  */
 484 void Logger::print_daemon_mode(const bool daemon_mode) const
 485 {
 486     int level = 1;
 487     if ( level <= Loglevel )
 488     {
 489         string mode = "disabled";
 490         if (daemon_mode == true)
 491             mode = "enabled";
 492         ostringstream msg;
 493         msg << "Daemon mode is " << mode << "." << endl;
 494         log_notice(msg.str());
 495     }
 496 }
 497
 498
 499 /**
 500  * There was an error while trying to fork.
 501  */
 502 void Logger::print_error_fork() const
 503 {
 504     int level = 0;
 505     if ( level <= Loglevel )
 506     {
 507         log_error("Error while trying to fork.");
 508     }
 509 }
 510
 511
 512 /**
 513  * A pid in the pidfile was found.
 514  * @param pid The pid found in the pidfile.
 515  */
 516 void Logger::print_pid_found(const int pid) const
 517 {
 518     int level = 1;
 519     if ( level <= Loglevel )
 520     {
 521         ostringstream msg;
 522         msg << "Pidfile found: " << pid << ". Checking if process is still runnig..." << endl;
 523         log_notice(msg.str());
 524     }
 525 }
 526
 527
 528 /**
 529  * Another process is already running.
 530  * @param pid The pid of the other process.
 531  */
 532 void Logger::print_process_already_running(const int pid) const
 533 {
 534     int level = 0;
 535     if ( level <= Loglevel )
 536     {
 537         ostringstream msg;
 538         msg << "Another bpdyndnsd process with PID " << pid << " is already running!" << endl;
 539         log_error(msg.str());
 540     }
 541 }
 542
 543
 544 /**
 545  * SIGTERM caught.
 546  */
 547 void Logger::print_caught_sigterm() const
 548 {
 549     int level = 0;
 550     if ( level <= Loglevel )
 551     {
 552         log_notice("Caught SIGTERM. Exiting...");
 553     }
 554 }
 555
 556
 557 /**
 558  * SIGUSR1 caught.
 559  */
 560 void Logger::print_caught_siguser1() const
 561 {
 562     int level = 0;
 563     if ( level <= Loglevel )
 564     {
 565         log_notice("Caught SIGUSR1. Switching to offline mode...");
 566     }
 567 }
 568
 569
 570 /**
 571  * SIGHUP caught.
 572  */
 573 void Logger::print_caught_sighup() const
 574 {
 575     int level = 1;
 576     if ( level <= Loglevel )
 577     {
 578         log_notice("Caught SIGHUP. Reloading config and switching to online mode...");
 579     }
 580 }
 581
 582
 583 /**
 584  * Error while setting signal handler.
 585  */
 586 void Logger::print_error_setting_signal(const string& signal) const
 587 {
 588     int level = 0;
 589     if ( level <= Loglevel )
 590     {
 591         ostringstream msg;
 592         msg << "Error while setting signal handler for: " << signal << endl;
 593         log_error(msg.str());
 594     }
 595 }
 596
 597
 598 /**
 599  * Error while setting signal handler.
 600  */
 601 void Logger::print_init_log_facility() const
 602 {
 603     int level = 1;
 604     if ( level <= Loglevel )
 605     {
 606         ostringstream msg;
 607         msg << "Initialized logging facility." << " Loglevel: " << Loglevel << " Syslog: " << Syslog << endl;
 608         log_notice(msg.str());
 609     }
 610 }
 611
 612
 613 /**
 614  * Be verbose. Currently we are in offline mode.
 615  */
 616 void Logger::print_offline_mode() const
 617 {
 618     int level = 0;
 619     if ( level <= Loglevel )
 620     {
 621         log_notice("Offline mode...");
 622     }
 623 }
 624
 625
 626 /**
 627  * Objects successfully serialized.
 628  */
 629 void Logger::print_serialized_objects_success() const
 630 {
 631     int level = 1;
 632     if ( level <= Loglevel )
 633     {
 634         log_notice("Serialized objects successfully.");
 635     }
 636 }
 637
 638
 639 /**
 640  * Objects successfully de-serialized.
 641  */
 642 void Logger::print_deserialized_objects_success() const
 643 {
 644     int level = 1;
 645     if ( level <= Loglevel )
 646     {
 647         log_notice("De-serialized objects successfully.");
 648     }
 649 }
 650
 651
 652 /**
 653  * Prints out the content of a service object.
 654  * @param message Message to be added on output first.
 655  * @param protocol Service's protocol.
 656  * @param hostname Service's hostname.
 657  * @param login Service's login.
 658  * @param password Service's password.
 659  * @param actual_ip Service's actual_ip.
 660  * @param lastupdated Service's lastupdated.
 661  */
 662 void Logger::print_service_object(const string& message, const string& protocol, const string& hostname, const string& login, const string& password, const int update_interval, const int max_updates_within_interval, const int dns_cache_ttl , const string& actual_ip, list<time_t> lastupdated) const
 663 {
 664     int level = 1;
 665     if ( level <= Loglevel )
 666     {
 667         ostringstream msg;
 668         msg << message << endl;
 669         msg << "\t" << "Protocol:         " << protocol << endl;
 670         msg << "\t" << "Hostname:         " << hostname << endl;
 671         msg << "\t" << "Login:            " << login << endl;
 672         msg << "\t" << "Password:         " << password << endl;
 673         msg << "\t" << "Update Interval:  " << update_interval << endl;
 674         msg << "\t" << "Max Updates:      " << max_updates_within_interval << endl;
 675         msg << "\t" << "DNS Cache TTL:    " << dns_cache_ttl << endl;
 676         msg << "\t" << "Actual_IP:        " << actual_ip << endl;
 677         BOOST_FOREACH( time_t update_time, lastupdated)
 678         {
 679             msg << "\t" << "Lastupdated:      " << update_time << endl;
 680         }
 681         log_notice(msg.str());
 682     }
 683 }
 684
 685
 686 /**
 687  * Caught exception while serialize.
 688  * @param exception Exception message.
 689  */
 690 void Logger::print_exception_serialize(const string& errMsg) const
 691 {
 692     int level = 0;
 693     if ( level <= Loglevel )
 694     {
 695         ostringstream msg;
 696         msg << "Error while trying to serialize Serviceholder object: " << errMsg << endl;
 697         log_error(msg.str());
 698     }
 699 }
 700
 701
 702 /**
 703  * Caught exception while de-serialize.
 704  * @param exception Exception message.
 705  */
 706 void Logger::print_exception_deserialize(const string& errMsg) const
 707 {
 708     int level = 0;
 709     if ( level <= Loglevel )
 710     {
 711         ostringstream msg;
 712         msg << "Error while trying to de-serialize Serviceholder object: " << errMsg << endl;
 713         log_error(msg.str());
 714     }
 715 }
 716
 717
 718 /**
 719  * Child couldn't be killed by parent.
 720  * @param pid Pid of the child.
 721  */
 722 void Logger::print_error_kill_child(const int pid) const
 723 {
 724     int level = 0;
 725     if ( level <= Loglevel )
 726     {
 727         ostringstream msg;
 728         msg << "Could not kill child process with PID: " << pid << endl;
 729         log_error(msg.str());
 730     }
 731 }
 732
 733
 734 /**
 735  * Child was killed by parent because of error.
 736  * @param pid The pid (child) killed.
 737  */
 738 void Logger::print_child_killed(const int pid) const
 739 {
 740     int level = 1;
 741     if ( level <= Loglevel )
 742     {
 743         ostringstream msg;
 744         msg << "Killed child process with PID: " << pid << endl;
 745         log_notice(msg.str());
 746     }
 747 }
 748
 749
 750 /**
 751  * There is no object file.
 752  * @param object_file The object file.
 753  */
 754 void Logger::print_no_object_file(const string& object_file) const
 755 {
 756     int level = 1;
 757     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 758     {
 759         ostringstream msg;
 760         msg << "There is no object file: " << object_file << ". Continue without recovering state from old services!" << endl;
 761         log_warning(msg.str(),level);
 762     }
 763 }
 764
 765
 766 /**
 767  * Prints out the given hostname
 768  * @param hostname Hostname as string.
 769  */
 770 void Logger::print_hostname(const string& hostname) const
 771 {
 772     int level = 1;
 773     if ( level <= Loglevel )
 774     {
 775         ostringstream msg;
 776         msg << "Detected following hostname of localhost: " << hostname << endl;
 777         log_notice(msg.str());
 778     }
 779 }
 780
 781
 782 /**
 783  * Prints out the detected own ipv4 address
 784  * @param ip_addr String representation of the detected ip.
 785  */
 786 void Logger::print_own_ipv4(const string& ip_addr_v4, const string& hostname) const
 787 {
 788     int level = 1;
 789     if ( level <= Loglevel )
 790     {
 791         ostringstream msg;
 792         msg << "Detected following IPv4-Address of host: " << hostname << " : " << ip_addr_v4 << endl;
 793         log_notice(msg.str());
 794     }
 795 }
 796
 797
 798 /**
 799  * Prints out the detected own ipv5 address
 800  * @param ip_addr String representation of the detected ip.
 801  */
 802 void Logger::print_own_ipv6(const string& ip_addr_v6, const string& hostname) const
 803 {
 804     int level = 1;
 805     if ( level <= Loglevel )
 806     {
 807         ostringstream msg;
 808         msg << "Detected following IPv6-Address of host: " << hostname << " : " << ip_addr_v6 << endl;
 809         log_notice(msg.str());
 810     }
 811 }
 812
 813
 814 /**
 815  * Exception while trying to resolve hostname to ip.
 816  * @param exception The exception caught.
 817  * @param hostname The hostname.
 818  */
 819 void Logger::print_error_hostname_to_ip(const string& errMsg, const string& hostname) const
 820 {
 821     int level = 0;
 822     if ( level <= Loglevel )
 823     {
 824         ostringstream msg;
 825         msg << "Could not resolve the hostname: " << hostname << " to an IP-Address: " << errMsg << endl;
 826         log_warning(msg.str(),level);
 827     }
 828 }
 829
 830
 831 /**
 832  * The update of the given service was successful.
 833  * @param service The service.
 834  */
 835 void Logger::print_update_service_successful(const string& service) const
 836 {
 837     int level = 0;
 838     if ( level <= Loglevel )
 839     {
 840         ostringstream msg;
 841         msg << "Updated service successful: " << service << endl;
 842         log_notice(msg.str());
 843     }
 844 }
 845
 846
 847 /**
 848  * No ip could be determined through webcheck
 849  */
 850 void Logger::print_webcheck_no_ip() const
 851 {
 852     int level = 0;
 853     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 854     {
 855         log_warning("IP-Address of this host could not be determined through any configured webcheck url.",level);
 856     }
 857 }
 858
 859
 860 /**
 861  * Connection problem while trying to get ip through webcheck url
 862  * @param curl_err_buff Curl error message
 863  * @param url the url
 864  */
 865 void Logger::print_webcheck_url_connection_problem(const char * curl_err_buff, const string& url) const
 866 {
 867     int level = 1;
 868     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 869     {
 870         ostringstream msg;
 871         msg << "There was a problem while trying to connect to following URL: " << url << " CURL error: " << curl_err_buff << endl;
 872         log_warning(msg.str(),level);
 873     }
 874 }
 875
 876
 877 /**
 878  * Prints out curl error.
 879  * @param curl_err_buff Curl error message.
 880  * @param url URL
 881  */
 882 void Logger::print_webcheck_error(const char * curl_err_buff, const string& url) const
 883 {
 884     int level = 0;
 885     if ( level <= Loglevel )
 886     {
 887         ostringstream msg;
 888         msg << "There was an error while trying to connect to following URL: " << url << " CURL error: " << curl_err_buff << endl;
 889         log_error(msg.str());
 890     }
 891 }
 892
 893
 894 /**
 895  * Prints out the received data through curl.
 896  * @param curl_data Data string
 897  */
 898 void Logger::print_received_curl_data(const string& curl_data) const
 899 {
 900     int level = 1;
 901     if ( level <= Loglevel )
 902     {
 903         ostringstream msg;
 904         msg << "Received CURL data: " << curl_data << endl;
 905         log_notice(msg.str());
 906     }
 907 }
 908
 909
 910 /**
 911  * IP was foudn through regex
 912  * @param ip The IP found.
 913  */
 914 void Logger::print_regex_found_ip(const string& ip) const
 915 {
 916     int level = 1;
 917     if ( level <= Loglevel )
 918     {
 919         ostringstream msg;
 920         msg << "Found IP-Address via regex: " << ip << endl;
 921         log_notice(msg.str());
 922     }
 923 }
 924
 925
 926 /**
 927  * No IP was found through regex.
 928  * @param data The data string which should contain a valid IP.s
 929  */
 930 void Logger::print_regex_ip_not_found(const string& data) const
 931 {
 932     int level = 1;
 933     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 934     {
 935         ostringstream msg;
 936         msg << "Could not extract an IP-Address via regex from following data:\n" << data << endl;
 937         log_warning(msg.str(),level);
 938     }
 939 }
 940
 941
 942 /**
 943  * Detected multiple occurrences of the same option.
 944  * @param message Error message.
 945  */
 946 void Logger::print_multiple_cmd_option(const string& message) const
 947 {
 948     int level = 0;
 949     if ( level <= Loglevel )
 950     {
 951         ostringstream msg;
 952         msg << "The same option is only allowed once: " << message << endl;
 953         log_error(msg.str());
 954     }
 955 }
 956
 957
 958 /**
 959  * An update would exceed the update interval. Prints out a warning message.
 960  * @param current_time Current time.
 961  * @param old_time Time of update #MaxUpdatesWithinInterval ago.
 962  * @param MaxUpdatesWithinInterval Number of allowed updates in one update interval.
 963  * @param service The service which exceeds update interval.
 964  */
 965 void Logger::print_update_not_allowed(const int current_time, const int old_time, const int MaxUpdatesWithinInterval, const string& service) const
 966 {
 967     int level = 1;
 968     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 969     {
 970         ostringstream msg;
 971         msg << "Update not allowed for service: " << service << ". Too many updates within max update interval. Current time: " << current_time << ". Update time before " << MaxUpdatesWithinInterval << " updates: " << old_time << endl;
 972         log_warning(msg.str(),level);
 973     }
 974 }
 975
 976
 977 /**
 978  * Failure while running update for service.
 979  * @param service Services' name.
 980  */
 981 void Logger::print_update_service_failure(const string& service) const
 982 {
 983     int level = 0;
 984     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 985     {
 986         ostringstream msg;
 987         msg << "Could not update service: " << service << endl;
 988         log_warning(msg.str(),level);
 989     }
 990 }
 991
 992
 993 /**
 994  * Starting shutdown
 995  */
 996 void Logger::print_starting_shutdown() const
 997 {
 998     int level = 0;
 999     if ( level <= Loglevel )
1000     {
1001         log_notice("Shutting down ...");
1002     }
1003 }
1004
1005
1006 /**
1007  * Shutdown complete
1008  */
1009 void Logger::print_shutdown_succeeded() const
1010 {
1011     int level = 0;
1012     if ( level <= Loglevel )
1013     {
1014         log_notice("Shutting down complete ...");
1015     }
1016 }
1017
1018
1019 /**
1020  * Shutdown parent succeeded
1021  */
1022 void Logger::print_shutdown_parent_succeeded() const
1023 {
1024     int level = 0;
1025     if ( level <= Loglevel )
1026     {
1027         log_notice("Shutting down parent process completed ...");
1028     }
1029 }
1030
1031
1032 /**
1033  * Starting shutdown parent
1034  */
1035 void Logger::print_starting_shutdown_parent() const
1036 {
1037     int level = 0;
1038     if ( level <= Loglevel )
1039     {
1040         log_notice("Shutting down parent process ...");
1041     }
1042 }
1043
1044
1045 /**
1046  * DNS cache record timeout
1047  * @param hostname Hostname
1048  * @param lastupdated Lastupdated
1049  * @param dns_cache_ttl DNS cache TTL
1050  * @param current_time Current time
1051  */
1052 void Logger::print_recheck_dns_entry(const string& hostname, const int lastupdated, const int dns_cache_ttl, const int current_time) const
1053 {
1054     int level = 1;
1055     if ( level <= Loglevel )
1056     {
1057         ostringstream msg;
1058         msg << "DNS cache record for host <" << hostname << "> expired or host will be updated for the first time: Lastupdated: " << lastupdated << " DNS cache ttl: " << dns_cache_ttl << " Current time: " << current_time << " Checking current DNS cache status." << endl;
1059         log_notice(msg.str());
1060     }
1061 }
1062
1063
1064 /**
1065  * Missing proxy option on command line.
1066  */
1067 void Logger::print_missing_cmd_proxy_option() const
1068 {
1069     int level = 0;
1070     if ( level <= Loglevel )
1071     {
1072         log_error("Missing option to initialize proxy. http_proxy and http_proxy_port must be specified.");
1073     }
1074 }
1075
1076
1077 /**
1078  * Multiple option in service config file.
1079  * @param service_conf_file Service config file
1080  * @param message Multiple option text
1081  */
1082 void Logger::print_multiple_service_conf_option(const string& service_conf_file, const string& message) const
1083 {
1084     int level = 0;
1085     if ( level <= Loglevel )
1086     {
1087         ostringstream msg;
1088         msg << "Multiple occurrences of the same option in service config file detected: " << service_conf_file << " " << message << endl;
1089         log_error(msg.str());
1090     }
1091 }
1092
1093
1094 /**
1095  * Multiple option in main config file.
1096  * @param service_conf_file Service config file
1097  * @param message Multiple option text
1098  */
1099 void Logger::print_multiple_main_conf_option(const string& main_conf_file, const string& message) const
1100 {
1101     int level = 0;
1102     if ( level <= Loglevel )
1103     {
1104         ostringstream msg;
1105         msg << "Multiple occurrences of the same option in main config file detected: " << main_conf_file << " " << message << endl;
1106         log_error(msg.str());
1107     }
1108 }
1109
1110
1111 /**
1112  * Missing proxy option in main config file.
1113  * @param main_conf_filename The concerning config file.
1114  */
1115 void Logger::print_missing_conf_proxy_option(const string& main_conf_filename) const
1116 {
1117     int level = 0;
1118     if ( level <= Loglevel )
1119     {
1120         ostringstream msg;
1121         msg << "Missing option to initialize proxy in main config file: " << main_conf_filename << " http_proxy and http_proxy_port must be specified." << endl;
1122         log_error(msg.str());
1123     }
1124 }
1125
1126
1127 /**
1128  * There is no domain part in the given hostname
1129  * @param hostname The hostname with no domain part in it.
1130  */
1131 void Logger::print_no_domain_part(const string& hostname) const
1132 {
1133     int level = 0;
1134     if ( level <= Loglevel )
1135     {
1136         ostringstream msg;
1137         msg << "There is no domain part in the given hostname: " << hostname << endl;
1138         log_notice(msg.str());
1139     }
1140 }
1141
1142
1143 /**
1144  * Service is not initialized properly.
1145  * @param service The service.
1146  */
1147 void Logger::print_service_not_initialized(const std::string& service) const
1148 {
1149     int level = 0;
1150     if ( level <= Loglevel )
1151     {
1152         ostringstream msg;
1153         msg << "Service: " << service << " is not initialized properly." << endl;
1154         log_warning(msg.str(),level);
1155     }
1156 }
1157
1158
1159 /**
1160  * An curl error occured.
1161  * @param msg The error message
1162  * @param curl_err_code The resulting curl error code
1163  */
1164 void Logger::print_curl_error_init(const std::string& err_msg, const CURLcode curl_err_code) const
1165 {
1166     string curl_err = "";
1167
1168     if ( curl_err_code == CURLE_FAILED_INIT )
1169         curl_err = "CURLE_FAILED_INIT";
1170     else
1171         curl_err = "UNKNOWN";
1172
1173     int level = 0;
1174     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1175     {
1176         ostringstream msg;
1177         msg << "Curl error: " << err_msg << " Curl error code: " << curl_err_code << " " << curl_err << endl; /*lint !e641 */
1178         log_error(msg.str());
1179     }
1180 }
1181
1182
1183 /**
1184  * An curl error occured.
1185  * @param url The url requested by the curl operation
1186  * @param curl_err_code The resulting curl error code
1187  */
1188 void Logger::print_curl_error(const string& url, const CURLcode curl_err_code) const
1189 {
1190     string curl_err = "";
1191
1192     if ( curl_err_code == CURLE_URL_MALFORMAT )
1193         curl_err = "CURLE_URL_MALFORMAT";
1194     else if ( curl_err_code == CURLE_COULDNT_RESOLVE_HOST )
1195         curl_err = "CURLE_COULDNT_RESOLVE_HOST";
1196     else if ( curl_err_code == CURLE_COULDNT_CONNECT )
1197         curl_err = "CURLE_COULDNT_CONNECT";
1198     else
1199         curl_err = "UNKNOWN";
1200
1201     int level = 0;
1202     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1203     {
1204         ostringstream msg;
1205         msg << "Curl error while requesting following url: " << url << " Curl error code: " << curl_err_code << " " << curl_err << endl; /*lint !e641 */
1206         log_warning(msg.str(),level);
1207     }
1208 }
1209
1210
1211 /**
1212  * An curl error occured.
1213  * @param url The url requested by the curl operation
1214  * @param curl_err_code The resulting curl error code
1215  * @param curl_err_buff The curl error buffer
1216  */
1217 void Logger::print_curl_error(const string& url, const CURLcode curl_err_code, const char * curl_err_buff) const
1218 {
1219     string curl_err = "";
1220
1221     if ( curl_err_code == CURLE_URL_MALFORMAT )
1222         curl_err = "CURLE_URL_MALFORMAT";
1223     else if ( curl_err_code == CURLE_COULDNT_RESOLVE_HOST )
1224         curl_err = "CURLE_COULDNT_RESOLVE_HOST";
1225     else if ( curl_err_code == CURLE_COULDNT_CONNECT )
1226         curl_err = "CURLE_COULDNT_CONNECT";
1227     else
1228         curl_err = "UNKNOWN";
1229
1230     int level = 0;
1231     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1232     {
1233         ostringstream msg;
1234         msg << "Curl error while requesting following url: " << url << " Curl error code: " << curl_err_code << " " << curl_err << " " << curl_err_buff << endl; /*lint !e641 */
1235         log_warning(msg.str(),level);
1236     }
1237 }
1238
1239
1240 /**
1241  * Prints out the data received by curl operation
1242  * @param CurlWritedataBuff
1243  */
1244 void Logger::print_curl_data(const string& curl_writedata_buff) const
1245 {
1246     int level = 1;
1247     if ( level <= Loglevel )
1248     {
1249         ostringstream msg;
1250         msg << "Data received by curl: " << curl_writedata_buff << endl;
1251         log_notice(msg.str());
1252     }
1253 }
1254
1255
1256 /**
1257  * Not authorized to perform requested update operation
1258  * @param service The requested service.
1259  * @param username Username
1260  * @param password Password
1261  */
1262 void Logger::print_service_not_authorized(const string& service, const string& username, const string& password) const
1263 {
1264     int level = 0;
1265     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1266     {
1267         ostringstream msg;
1268         msg << "Not authorized to perform update operation on service: " << service << " Please check username and password: " << username << ":" << password << endl;
1269         log_warning(msg.str(),level);
1270     }
1271 }
1272
1273
1274 /**
1275  * Prints out the http status code
1276  * @param url Url
1277  * @param output HTTP status code
1278  */
1279 void Logger::print_http_status_code(const string& url, const long http_code) const
1280 {
1281     int level = 1;
1282     if ( level <= Loglevel )
1283     {
1284         ostringstream msg;
1285         msg << "Requested URL: " << url << " Received HTTP status code: " << http_code << endl;
1286         log_notice(msg.str());
1287     }
1288 }
1289
1290
1291 /**
1292  * Generic failure while trying to update service
1293  * @param url The requested URL
1294  * @param curl_data The received curl_data from the server
1295  */
1296 void Logger::print_update_failure(const string& url, const string& curl_data) const
1297 {
1298     int level = 0;
1299     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1300     {
1301         ostringstream msg;
1302         msg << "Problem while trying to updating service. Requested URL: " << url << " Error Code from Server: " << curl_data << endl;
1303         log_warning(msg.str(),level);
1304     }
1305 }
1306
1307
1308 /**
1309  * Generic failure while trying to update service
1310  * @param url The requested URL
1311  * @param http_status_code The received http status code
1312  */
1313 void Logger::print_update_failure(const string& url, const long http_status_code) const
1314 {
1315     int level = 0;
1316     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1317     {
1318         ostringstream msg;
1319         msg << "Problem while trying to updating service. Requested URL: " << url << " Error Code from Server: " << http_status_code << endl;
1320         log_warning(msg.str(),level);
1321     }
1322 }
1323
1324 /**
1325  * Hostname is invalid, contains no or only one domain part.
1326  * @param hostname The full qualified host name.
1327  */
1328 void Logger::print_invalid_hostname(const string& hostname) const
1329 {
1330     int level = 0;
1331     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1332     {
1333         ostringstream msg;
1334         msg << "The configured hostname: " << hostname << " is invalid. Please add the corresponding domain part." << endl;
1335         log_warning(msg.str(),level);
1336     }
1337 }
1338
1339
1340 /**
1341  * An IP in a private range was detected
1342  * @param ip The private IP
1343  */
1344 void Logger::print_ip_is_local(const string& ip) const
1345 {
1346     int level = 0;
1347     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1348     {
1349         ostringstream msg;
1350         msg << "The detected IP is within a private IP range: " << ip << endl;
1351         log_warning(msg.str(),level);
1352     }
1353 }
1354
1355
1356 /**
1357  * Regex is matching in string
1358  * @param regex The regex pattern
1359  * @param matching_string The string
1360  */
1361 void Logger::print_regex_match(const string& regex, const string& matching_string) const
1362 {
1363     int level = 1;
1364     if ( level <= Loglevel )
1365     {
1366         ostringstream msg;
1367         msg << "Regex: " << regex << " is matching in: " << matching_string << endl;
1368         log_notice(msg.str());
1369     }
1370 }
1371
1372
1373 /**
1374  * Regex is not matching
1375  * @param regex Regex
1376  * @param not_matching_string String
1377  */
1378 void Logger::print_no_regex_match(const string& regex, const string& not_matching_string) const
1379 {
1380     int level = 1;
1381     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1382     {
1383         ostringstream msg;
1384         msg << "Regex: " << regex << " is not matching in: " << not_matching_string << endl;
1385         log_warning(msg.str(),level);
1386     }
1387 }
1388
1389
1390 /**
1391  * Could not parse gnudip initial reply.
1392  * @param curl_data The data received from gnudip server which should contain salt, time and sign.
1393  */
1394 void Logger::print_could_not_parse_received_data(const string& curl_data) const
1395 {
1396     int level = 0;
1397     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1398     {
1399         ostringstream msg;
1400         msg << "Could not parse salt, time and sign from initial gnudip server reply: " << curl_data << endl;
1401         log_warning(msg.str(),level);
1402     }
1403 }
1404
1405
1406 /**
1407  * Gnudip salt, time and sign could not be got from map
1408  */
1409 void Logger::print_could_not_get_initial_gnudip_data() const
1410 {
1411     int level = 0;
1412     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1413     {
1414         log_warning("Could not get salt, time and sign from map.",level);
1415     }
1416 }
1417
1418
1419
1420 /**
1421  * Gnudip protocol requires explicit declaration of a servername.
1422  */
1423 void Logger::print_gnudip_requires_servername() const
1424 {
1425     int level = 0;
1426     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1427     {
1428         log_warning("Gnudip requires explicit definition of servername via config!",level);
1429     }
1430 }
1431
1432
1433 /**
1434  * An exception occured while computing the md5 sum.
1435  * @param what The exception occured.
1436  */
1437 void Logger::print_exception_md5_sum(const string& what) const
1438 {
1439     int level = 0;
1440     if ( level <= Loglevel )
1441     {
1442         ostringstream msg;
1443         msg << "An exception occured while computing a md5 sum: " << what << endl;
1444         log_error(msg.str());
1445     }
1446 }
1447
1448
1449 /**
1450  * An network exception occured.
1451  * @param what The exception occured.
1452  */
1453 void Logger::print_network_error(const string& what) const
1454 {
1455     int level = 0;
1456     if ( level <= Loglevel )
1457     {
1458         ostringstream msg;
1459         msg << "An netowrk exception occured: " << what << endl;
1460         log_error(msg.str());
1461     }
1462 }
1463
1464
1465 /**
1466  * An undefined protocol error occured.
1467  * @param protocol The protocol
1468  * @param error The error
1469  */
1470 void Logger::print_undefined_protocol_error(const string& protocol, const string& error) const
1471 {
1472     int level = 0;
1473     if ( level <= Loglevel )
1474     {
1475         ostringstream msg;
1476         msg << "An undefined protocol error occured. Protocol: " << protocol << " Error: " << error << endl;
1477         log_error(msg.str());
1478     }
1479 }
1480
1481 /**
1482  * Error while trying to log through external program.
1483  * @param external_prog The external program called.
1484  */
1485 void Logger::print_error_external_logging(const string& external_prog) const
1486 {
1487     int level = 0;
1488     if ( level <= Loglevel )
1489     {
1490         ostringstream msg;
1491         msg << "Error while trying to log through external program: " << external_prog << endl;
1492         log_notice(msg.str());
1493     }
1494 }
1495
1496
1497 /**
1498  * Error while parsing config file.
1499  * @param error Error occured.
1500  * @param config_file Config file.
1501  */
1502 void Logger::print_error_parsing_config_file(const string& filename, const string& error) const
1503 {
1504     int level = 0;
1505     if ( level <= Loglevel )
1506     {
1507         ostringstream msg;
1508         msg << "Error while parsing config file: " << filename << " Error: " << error << endl;
1509         log_notice(msg.str());
1510     }
1511 }
1512
1513
1514 /**
1515  * Error while parsing cmd option
1516  * @param error Error
1517  */
1518 void Logger::print_error_parsing_cmd(const string& error) const
1519 {
1520     int level = 0;
1521     if ( level <= Loglevel )
1522     {
1523         ostringstream msg;
1524         msg << "Error while parsing cmd options: " << error << endl;
1525         log_error(msg.str());
1526     }
1527 }
1528
1529
1530 /**
1531  * The webcheck interval was exceeded, so webcheck not allowed.
1532  * @param last_webcheck Time of last webcheck.
1533  * @param webcheck_interval Webcheck interval time.
1534  * @param current_time Current system time.
1535  */
1536 void Logger::print_webcheck_exceed_interval( const time_t last_webcheck, const int webcheck_interval, const time_t current_time ) const
1537 {
1538     int level = 0;
1539     if ( level <= Loglevel )
1540     {
1541         ostringstream msg;
1542         msg << "Exceeding webcheck interval: LastWebcheck " << last_webcheck << " + WebcheckInterval(sec) " << webcheck_interval << " >= CurrentTime " << current_time << endl;
1543         log_notice(msg.str());
1544     }
1545 }
1546
1547
1548 /**
1549  * Checking if hosts needs update.
1550  * @param hostname Hostname
1551  * @param current_time Current time
1552  * @param lastupdated Last updated
1553  */
1554 void Logger::print_check_service_update(const string& hostname, const time_t current_time, const time_t lastupdated) const
1555 {
1556     int level = 1;
1557     if ( level <= Loglevel )
1558     {
1559         ostringstream msg;
1560         msg << "Checking if host: " << hostname << " needs update. Current time: " << current_time << " Last updated: " << lastupdated << endl;
1561         log_notice(msg.str());
1562     }
1563 }
1564
1565
1566 /**
1567  * Cached DNS entry
1568  * @param hostname Hostname
1569  * @param ip_dns_recheck DNS recheck IP
1570  * @param ip_last_update IP set in last update
1571  * @param ip_host Hosts' IP
1572  */
1573 void Logger::print_cached_dns_entry(const string& hostname, const string& ip_dns_recheck, const string& ip_last_update, const string& ip_host) const
1574 {
1575     int level = 1;
1576     if ( level <= Loglevel )
1577     {
1578         ostringstream msg;
1579         msg << "Cached DNS record for host <" << hostname << "> : " << ip_dns_recheck << " Last updated IP: " << ip_last_update << " Hosts IP: " << ip_host << endl;
1580         log_notice(msg.str());
1581     }
1582 }
1583
1584
1585 /**
1586  * Updating service for the first time.
1587  * @param hostname Hostname
1588  * @param ip_dns_recheck Cached DNS entry
1589  * @param ip_host Hosts IP
1590  */
1591 void Logger::print_update_service_firttime(const string& hostname, const string& ip_dns_recheck, const string& ip_host) const
1592 {
1593     int level = 1;
1594     if ( level <= Loglevel )
1595     {
1596         ostringstream msg;
1597         msg << "Updating service for the first time. Hostname: " << hostname << " DNS-Record: " << ip_dns_recheck << " Hosts IP: " << ip_host << endl;
1598         log_notice(msg.str());
1599     }
1600 }
1601
1602
1603 /**
1604  * Updating service
1605  * @param hostname Hostname
1606  * @param ip_dns_recheck Cached DNS entry
1607  * @param ip_last_update IP set in last update
1608  * @param ip_host Hosts IP
1609  * @param lastupdated Lastupdated
1610  */
1611 void Logger::print_update_service(const string& hostname, const string& ip_dns_recheck, const string& ip_last_update, const string& ip_host, const int lastupdated) const{
1612     int level = 1;
1613     if ( level <= Loglevel )
1614     {
1615         ostringstream msg;
1616         msg << "Updating service. Hostname: " << hostname << " DNS-Record: " << ip_dns_recheck << " IP set in last update: " << ip_last_update << " Lastupdated: " << lastupdated << " Hosts IP: " << ip_host << endl;
1617         log_notice(msg.str());
1618     }
1619 }
1620
1621
1622 /**
1623  * TTL expired
1624  * @param hostname Hostname
1625  * @param ip_dns_recheck Cached DNS entry
1626  * @param ip_last_update IP set in last update
1627  * @param ip_host Hosts IP
1628  * @param lastupdated Last updated
1629  * @param dns_cache_ttl DNS cache ttl
1630  * @param current_time Current time
1631  */
1632 void Logger::print_update_service_ttl_expired(const string& hostname, const string& ip_dns_recheck, const string& ip_last_update, const string& ip_host, const int lastupdated, const int dns_cache_ttl, const int current_time) const
1633 {
1634     int level = 1;
1635     if ( level <= Loglevel )
1636     {
1637         ostringstream msg;
1638         msg << "TTL for service expired and still pointing to old IP. Hostname: " << hostname << " DNS-Record: " << ip_dns_recheck << " IP set in last update: " << ip_last_update << " Lastupdated: " << lastupdated << "DNS Cache TTL: " << dns_cache_ttl << " Current Time: " << current_time << " Hosts IP: " << ip_host << endl;
1639         log_notice(msg.str());
1640     }
1641 }
1642
1643
1644 /**
1645  * TTL expired
1646  * @param hostname Hostname
1647  * @param ip_dns_recheck Cached DNS entry
1648  * @param ip_last_update IP set in last update
1649  * @param ip_host Hosts IP
1650  * @param lastupdated Last updated
1651  * @param dns_cache_ttl DNS cache ttl
1652  * @param current_time Current time
1653  */
1654 void Logger::print_update_service_ttl_not_expired(const string& hostname, const string& ip_dns_recheck, const string& ip_last_update, const string& ip_host, const int lastupdated, const int dns_cache_ttl, const int current_time) const
1655 {
1656     int level = 1;
1657     if ( level <= Loglevel )
1658     {
1659         ostringstream msg;
1660         msg << "Waiting for DNS cache TTL to expire. Hostname: " << hostname << " DNS-Record: " << ip_dns_recheck << " IP set in last update: " << ip_last_update << " Lastupdated: " << lastupdated << "DNS Cache TTL: " << dns_cache_ttl << " Current Time: " << current_time << " Hosts IP: " << ip_host << endl;
1661         log_notice(msg.str());
1662     }
1663 }
1664
1665
1666 /**
1667  * No update needed
1668  * @param hostname Hostname
1669  * @param ip_dns_recheck Cached DNS entry
1670  * @param ip_last_update IP set in last update
1671  * @param ip_host Hosts IP
1672  * @param lastupdated Last updated
1673  */
1674 void Logger::print_no_update_needed(const string& hostname, const string& ip_dns_recheck, const string& ip_last_update, const string& ip_host, const int lastupdated) const
1675 {
1676     int level = 1;
1677     if ( level <= Loglevel )
1678     {
1679         ostringstream msg;
1680         msg << "No update needed for host: " << hostname << " Cached DNS record: " << ip_dns_recheck << " IP set in last update: " << ip_last_update << " Hosts IP: " << ip_host << " Last updated: " << lastupdated << endl;
1681         log_notice(msg.str());
1682     }
1683 }
1684
1685
1686 /**
1687  * Error while trying to get local wan interface IP address through getifaddrs.
1688  * @param error The system call which raised the error.
1689  * @param error The error set by getifaddrs.
1690  */
1691 void Logger::print_error_getting_local_wan_ip(const std::string& system_call, const std::string& error) const
1692 {
1693     int level = 0;
1694     if ( level <= Loglevel )
1695     {
1696         ostringstream msg;
1697         msg << "Error while trying to get local wan interface IP address through '" << system_call << "': " << error << endl;
1698         log_error(msg.str());
1699     }
1700 }
1701
1702
1703 /**
1704  * Could not get IP address of local wan interface.
1705  */
1706 void Logger::print_no_wan_ip() const
1707 {
1708     int level = 0;
1709     if ( level <= Loglevel )
1710     {
1711         ostringstream msg;
1712         msg << "Could not get IP address of local wan interface." << endl;
1713         log_error(msg.str());
1714     }
1715 }