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