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  * SIGRTMAX caught.
 682  */
 683 void Logger::print_caught_sigrtmax(int new_loglevel) const
 684 {
 685     int level = 0;
 686     if ( level <= Loglevel )
 687     {
 688         ostringstream msg;
 689         msg << "Caught SIGRTMAX. Increasing log level to " << new_loglevel << endl;
 690         log_error(msg.str());
 691     }
 692 }
 693
 694
 695 /**
 696  * Error while setting signal handler.
 697  */
 698 void Logger::print_error_setting_signal(const string& signal) const
 699 {
 700     int level = 0;
 701     if ( level <= Loglevel )
 702     {
 703         ostringstream msg;
 704         msg << "Error while setting signal handler for: " << signal << endl;
 705         log_error(msg.str());
 706     }
 707 }
 708
 709
 710 /**
 711  * Error while setting signal handler.
 712  */
 713 void Logger::print_init_log_facility() const
 714 {
 715     int level = 1;
 716     if ( level <= Loglevel )
 717     {
 718         ostringstream msg;
 719         msg << "Initialized logging facility." << " Loglevel: " << Loglevel << " Syslog: " << Syslog << " ExternalLogOnlyOnce: " << ExternalLogOnlyOnce << endl;
 720         log_notice(msg.str());
 721     }
 722 }
 723
 724
 725 /**
 726  * Be verbose. Currently we are in offline mode.
 727  */
 728 void Logger::print_offline_mode() const
 729 {
 730     int level = 1;
 731     if ( level <= Loglevel )
 732     {
 733         log_notice("Offline mode...");
 734     }
 735 }
 736
 737
 738 /**
 739  * Objects successfully serialized.
 740  */
 741 void Logger::print_serialized_objects_success() const
 742 {
 743     int level = 1;
 744     if ( level <= Loglevel )
 745     {
 746         log_notice("Serialized objects successfully.");
 747     }
 748 }
 749
 750
 751 /**
 752  * Objects successfully de-serialized.
 753  */
 754 void Logger::print_deserialized_objects_success() const
 755 {
 756     int level = 1;
 757     if ( level <= Loglevel )
 758     {
 759         log_notice("De-serialized objects successfully.");
 760     }
 761 }
 762
 763
 764 /**
 765  * Prints out the content of a service object.
 766  * @param message Message to be added on output first.
 767  * @param protocol Service's protocol.
 768  * @param hostname Service's hostname.
 769  * @param login Service's login.
 770  * @param password Service's password.
 771  * @param actual_ip Service's actual_ip.
 772  * @param lastupdated Service's lastupdated.
 773  */
 774 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
 775 {
 776     int level = 1;
 777     if ( level <= Loglevel )
 778     {
 779         ostringstream msg;
 780         msg << message << endl;
 781         msg << "\t" << "Protocol:         " << protocol << endl;
 782         msg << "\t" << "Hostname:         " << hostname << endl;
 783         msg << "\t" << "Login:            " << login << endl;
 784         msg << "\t" << "Password:         " << password << endl;
 785         msg << "\t" << "Update Interval:  " << update_interval << endl;
 786         msg << "\t" << "Max Updates:      " << max_updates_within_interval << endl;
 787         msg << "\t" << "DNS Cache TTL:    " << dns_cache_ttl << endl;
 788         msg << "\t" << "Actual_IP:        " << actual_ip << endl;
 789         BOOST_FOREACH( time_t update_time, lastupdated)
 790         {
 791             msg << "\t" << "Lastupdated:      " << update_time << endl;
 792         }
 793         log_notice(msg.str());
 794     }
 795 }
 796
 797
 798 /**
 799  * Caught exception while serialize.
 800  * @param exception Exception message.
 801  */
 802 void Logger::print_exception_serialize(const string& errMsg) const
 803 {
 804     int level = 0;
 805     if ( level <= Loglevel )
 806     {
 807         ostringstream msg;
 808         msg << "Error while trying to serialize Serviceholder object: " << errMsg << endl;
 809         log_error(msg.str());
 810     }
 811 }
 812
 813
 814 /**
 815  * Caught exception while de-serialize.
 816  * @param exception Exception message.
 817  */
 818 void Logger::print_exception_deserialize(const string& errMsg) const
 819 {
 820     int level = 0;
 821     if ( level <= Loglevel )
 822     {
 823         ostringstream msg;
 824         msg << "Error while trying to de-serialize Serviceholder object: " << errMsg << endl;
 825         log_error(msg.str());
 826     }
 827 }
 828
 829
 830 /**
 831  * Child couldn't be killed by parent.
 832  * @param pid Pid of the child.
 833  */
 834 void Logger::print_error_kill_child(const int pid) const
 835 {
 836     int level = 0;
 837     if ( level <= Loglevel )
 838     {
 839         ostringstream msg;
 840         msg << "Could not kill child process with PID: " << pid << endl;
 841         log_error(msg.str());
 842     }
 843 }
 844
 845
 846 /**
 847  * Child was killed by parent because of error.
 848  * @param pid The pid (child) killed.
 849  */
 850 void Logger::print_child_killed(const int pid) const
 851 {
 852     int level = 1;
 853     if ( level <= Loglevel )
 854     {
 855         ostringstream msg;
 856         msg << "Killed child process with PID: " << pid << endl;
 857         log_notice(msg.str());
 858     }
 859 }
 860
 861
 862 /**
 863  * There is no object file.
 864  * @param object_file The object file.
 865  */
 866 void Logger::print_no_object_file(const string& object_file)
 867 {
 868     int level = 1;
 869     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 870     {
 871         ostringstream msg;
 872         msg << "There is no object file: " << object_file << ". Continue without recovering state from old services!" << endl;
 873         log_warning(msg.str(),level);
 874     }
 875 }
 876
 877
 878 /**
 879  * Prints out the given hostname
 880  * @param hostname Hostname as string.
 881  */
 882 void Logger::print_hostname(const string& hostname) const
 883 {
 884     int level = 1;
 885     if ( level <= Loglevel )
 886     {
 887         ostringstream msg;
 888         msg << "Detected following hostname of localhost: " << hostname << endl;
 889         log_notice(msg.str());
 890     }
 891 }
 892
 893
 894 /**
 895  * Prints out the detected own ipv4 address
 896  * @param ip_addr String representation of the detected ip.
 897  */
 898 void Logger::print_own_ipv4(const string& ip_addr_v4, const string& hostname) const
 899 {
 900     int level = 1;
 901     if ( level <= Loglevel )
 902     {
 903         ostringstream msg;
 904         msg << "Detected following IPv4-Address of host: " << hostname << " : " << ip_addr_v4 << endl;
 905         log_notice(msg.str());
 906     }
 907 }
 908
 909
 910 /**
 911  * Prints out the detected own ipv5 address
 912  * @param ip_addr String representation of the detected ip.
 913  */
 914 void Logger::print_own_ipv6(const string& ip_addr_v6, const string& hostname) const
 915 {
 916     int level = 1;
 917     if ( level <= Loglevel )
 918     {
 919         ostringstream msg;
 920         msg << "Detected following IPv6-Address of host: " << hostname << " : " << ip_addr_v6 << endl;
 921         log_notice(msg.str());
 922     }
 923 }
 924
 925
 926 /**
 927  * Exception while trying to resolve hostname to ip.
 928  * @param exception The exception caught.
 929  * @param hostname The hostname.
 930  */
 931 void Logger::print_error_hostname_to_ip(const string& errMsg, const string& hostname) const
 932 {
 933     int level = 0;
 934     if ( level <= Loglevel )
 935     {
 936         ostringstream msg;
 937         msg << "Could not resolve the hostname: " << hostname << " to an IP-Address: " << errMsg << endl;
 938         log_error(msg.str());
 939     }
 940 }
 941
 942
 943 /**
 944  * The update of the given service was successful.
 945  * @param service The service.
 946  */
 947 void Logger::print_update_service_successful(const string& service) const
 948 {
 949     int level = 0;
 950     if ( level <= Loglevel )
 951     {
 952         ostringstream msg;
 953         msg << "Updated service successful: " << service << endl;
 954         log_notice(msg.str());
 955     }
 956 }
 957
 958
 959 /**
 960  * No ip could be determined through webcheck
 961  */
 962 void Logger::print_webcheck_no_ip()
 963 {
 964     int level = 0;
 965     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 966     {
 967         log_warning("IP-Address of this host could not be determined through any configured webcheck url.",level);
 968     }
 969 }
 970
 971
 972 /**
 973  * Connection problem while trying to get ip through webcheck url
 974  * @param curl_err_buff Curl error message
 975  * @param url the url
 976  */
 977 void Logger::print_webcheck_url_connection_problem(const char * curl_err_buff, const string& url)
 978 {
 979     int level = 1;
 980     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
 981     {
 982         ostringstream msg;
 983         msg << "There was a problem while trying to connect to following URL: " << url << " CURL error: " << curl_err_buff << endl;
 984         log_warning(msg.str(),level);
 985     }
 986 }
 987
 988
 989 /**
 990  * Prints out curl error.
 991  * @param curl_err_buff Curl error message.
 992  * @param url URL
 993  */
 994 void Logger::print_webcheck_error(const char * curl_err_buff, const string& url) const
 995 {
 996     int level = 0;
 997     if ( level <= Loglevel )
 998     {
 999         ostringstream msg;
1000         msg << "There was an error while trying to connect to following URL: " << url << " CURL error: " << curl_err_buff << endl;
1001         log_error(msg.str());
1002     }
1003 }
1004
1005
1006 /**
1007  * Prints out the received data through curl.
1008  * @param curl_data Data string
1009  */
1010 void Logger::print_received_curl_data(const string& curl_data) const
1011 {
1012     int level = 1;
1013     if ( level <= Loglevel )
1014     {
1015         ostringstream msg;
1016         msg << "Received CURL data: " << curl_data << endl;
1017         log_notice(msg.str());
1018     }
1019 }
1020
1021
1022 /**
1023  * IP was foudn through regex
1024  * @param ip The IP found.
1025  */
1026 void Logger::print_regex_found_ip(const string& ip) const
1027 {
1028     int level = 1;
1029     if ( level <= Loglevel )
1030     {
1031         ostringstream msg;
1032         msg << "Found IP-Address via regex: " << ip << endl;
1033         log_notice(msg.str());
1034     }
1035 }
1036
1037
1038 /**
1039  * No IP was found through regex.
1040  * @param data The data string which should contain a valid IP.s
1041  */
1042 void Logger::print_regex_ip_not_found(const string& data)
1043 {
1044     int level = 1;
1045     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1046     {
1047         ostringstream msg;
1048         msg << "Could not extract an IP-Address via regex from following data:\n" << data << endl;
1049         log_warning(msg.str(),level);
1050     }
1051 }
1052
1053
1054 /**
1055  * Detected multiple occurrences of the same option.
1056  * @param message Error message.
1057  */
1058 void Logger::print_multiple_cmd_option(const string& message) const
1059 {
1060     int level = 0;
1061     if ( level <= Loglevel )
1062     {
1063         ostringstream msg;
1064         msg << "The same option is only allowed once: " << message << endl;
1065         log_error(msg.str());
1066     }
1067 }
1068
1069
1070 /**
1071  * An update would exceed the update interval. Prints out a warning message.
1072  * @param current_time Current time.
1073  * @param old_time Time of update #MaxUpdatesWithinInterval ago.
1074  * @param MaxUpdatesWithinInterval Number of allowed updates in one update interval.
1075  * @param service The service which exceeds update interval.
1076  */
1077 void Logger::print_update_not_allowed(const time_t current_time, const time_t old_time, const int MaxUpdatesWithinInterval, const string& service)
1078 {
1079     int level = 1;
1080     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1081     {
1082         ostringstream msg;
1083         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;
1084         log_warning(msg.str(),level);
1085     }
1086 }
1087
1088
1089 /**
1090  * Failure while running update for service.
1091  * @param service Services' name.
1092  */
1093 void Logger::print_update_service_failure(const string& service)
1094 {
1095     int level = 0;
1096     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1097     {
1098         ostringstream msg;
1099         msg << "Could not update service: " << service << endl;
1100         log_warning(msg.str(),level);
1101     }
1102 }
1103
1104 /**
1105  * Start message
1106  */
1107 void Logger::print_started() const
1108 {
1109     int level = 0;
1110     if ( level <= Loglevel )
1111     {
1112         log_notice("Started");
1113     }
1114 }
1115
1116
1117 /**
1118  * Starting shutdown
1119  */
1120 void Logger::print_starting_shutdown() const
1121 {
1122     int level = 0;
1123     if ( level <= Loglevel )
1124     {
1125         log_notice("Shutting down ...");
1126     }
1127 }
1128
1129
1130 /**
1131  * Shutdown complete
1132  */
1133 void Logger::print_shutdown_succeeded() const
1134 {
1135     int level = 0;
1136     if ( level <= Loglevel )
1137     {
1138         log_notice("Shutting down complete ...");
1139     }
1140 }
1141
1142
1143 /**
1144  * Shutdown parent succeeded
1145  */
1146 void Logger::print_shutdown_parent_succeeded() const
1147 {
1148     int level = 0;
1149     if ( level <= Loglevel )
1150     {
1151         log_notice("Shutting down parent process completed ...");
1152     }
1153 }
1154
1155
1156 /**
1157  * Starting shutdown parent
1158  */
1159 void Logger::print_starting_shutdown_parent() const
1160 {
1161     int level = 0;
1162     if ( level <= Loglevel )
1163     {
1164         log_notice("Shutting down parent process ...");
1165     }
1166 }
1167
1168
1169 /**
1170  * DNS cache record timeout
1171  * @param hostname Hostname
1172  * @param lastupdated Lastupdated
1173  * @param dns_cache_ttl DNS cache TTL
1174  * @param current_time Current time
1175  */
1176 void Logger::print_recheck_dns_entry(const string& hostname, const int lastupdated, const int dns_cache_ttl, const int current_time) const
1177 {
1178     int level = 1;
1179     if ( level <= Loglevel )
1180     {
1181         ostringstream msg;
1182         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;
1183         log_notice(msg.str());
1184     }
1185 }
1186
1187
1188 /**
1189  * Missing proxy option on command line.
1190  */
1191 void Logger::print_missing_cmd_proxy_option() const
1192 {
1193     int level = 0;
1194     if ( level <= Loglevel )
1195     {
1196         log_error("Missing option to initialize proxy. http_proxy and http_proxy_port must be specified.");
1197     }
1198 }
1199
1200
1201 /**
1202  * Multiple option in service config file.
1203  * @param service_conf_file Service config file
1204  * @param message Multiple option text
1205  */
1206 void Logger::print_multiple_service_conf_option(const string& service_conf_file, const string& message) const
1207 {
1208     int level = 0;
1209     if ( level <= Loglevel )
1210     {
1211         ostringstream msg;
1212         msg << "Multiple occurrences of the same option in service config file detected: " << service_conf_file << " " << message << endl;
1213         log_error(msg.str());
1214     }
1215 }
1216
1217
1218 /**
1219  * Multiple option in main config file.
1220  * @param service_conf_file Service config file
1221  * @param message Multiple option text
1222  */
1223 void Logger::print_multiple_main_conf_option(const string& main_conf_file, const string& message) const
1224 {
1225     int level = 0;
1226     if ( level <= Loglevel )
1227     {
1228         ostringstream msg;
1229         msg << "Multiple occurrences of the same option in main config file detected: " << main_conf_file << " " << message << endl;
1230         log_error(msg.str());
1231     }
1232 }
1233
1234
1235 /**
1236  * Missing proxy option in main config file.
1237  * @param main_conf_filename The concerning config file.
1238  */
1239 void Logger::print_missing_conf_proxy_option(const string& main_conf_filename) const
1240 {
1241     int level = 0;
1242     if ( level <= Loglevel )
1243     {
1244         ostringstream msg;
1245         msg << "Missing option to initialize proxy in main config file: " << main_conf_filename << " http_proxy and http_proxy_port must be specified." << endl;
1246         log_error(msg.str());
1247     }
1248 }
1249
1250
1251 /**
1252  * There is no domain part in the given hostname
1253  * @param hostname The hostname with no domain part in it.
1254  */
1255 void Logger::print_no_domain_part(const string& hostname) const
1256 {
1257     int level = 0;
1258     if ( level <= Loglevel )
1259     {
1260         ostringstream msg;
1261         msg << "There is no domain part in the given hostname: " << hostname << endl;
1262         log_notice(msg.str());
1263     }
1264 }
1265
1266
1267 /**
1268  * Service is not initialized properly.
1269  * @param service The service.
1270  */
1271 void Logger::print_httphelper_not_initialized() const
1272 {
1273     int level = 0;
1274     if ( level <= Loglevel )
1275     {
1276         log_error("HTTP-Helper is not initialized properly.");
1277     }
1278 }
1279
1280
1281 /**
1282  * An curl error occured.
1283  * @param msg The error message
1284  * @param curl_err_code The resulting curl error code
1285  */
1286 void Logger::print_curl_error_init(const std::string& err_msg, const CURLcode curl_err_code) const
1287 {
1288     string curl_err = "";
1289
1290     if ( curl_err_code == CURLE_FAILED_INIT )
1291         curl_err = "CURLE_FAILED_INIT";
1292     else
1293         curl_err = "UNKNOWN";
1294
1295     int level = 0;
1296     if ( (level <= Loglevel) )
1297     {
1298         ostringstream msg;
1299         msg << "Curl error: " << err_msg << " Curl error code: " << curl_err_code << " " << curl_err << endl; /*lint !e641 */
1300         log_error(msg.str());
1301     }
1302 }
1303
1304
1305 /**
1306  * An curl error occured.
1307  * @param url The url requested by the curl operation
1308  * @param curl_err_code The resulting curl error code
1309  */
1310 void Logger::print_curl_error(const string& url, const CURLcode curl_err_code) const
1311 {
1312     string curl_err = "";
1313
1314     if ( curl_err_code == CURLE_URL_MALFORMAT )
1315         curl_err = "CURLE_URL_MALFORMAT";
1316     else if ( curl_err_code == CURLE_COULDNT_RESOLVE_HOST )
1317         curl_err = "CURLE_COULDNT_RESOLVE_HOST";
1318     else if ( curl_err_code == CURLE_COULDNT_CONNECT )
1319         curl_err = "CURLE_COULDNT_CONNECT";
1320     else
1321         curl_err = "UNKNOWN";
1322
1323     int level = 0;
1324     if ( (level <= Loglevel) )
1325     {
1326         ostringstream msg;
1327         msg << "Curl error while requesting following url: " << url << " Curl error code: " << curl_err_code << " " << curl_err << endl; /*lint !e641 */
1328         log_error(msg.str());
1329     }
1330 }
1331
1332
1333 /**
1334  * An curl error occured.
1335  * @param url The url requested by the curl operation
1336  * @param curl_err_code The resulting curl error code
1337  * @param curl_err_buff The curl error buffer
1338  */
1339 void Logger::print_curl_error(const string& url, const CURLcode curl_err_code, const char * curl_err_buff) const
1340 {
1341     string curl_err = "";
1342
1343     if ( curl_err_code == CURLE_URL_MALFORMAT )
1344         curl_err = "CURLE_URL_MALFORMAT";
1345     else if ( curl_err_code == CURLE_COULDNT_RESOLVE_HOST )
1346         curl_err = "CURLE_COULDNT_RESOLVE_HOST";
1347     else if ( curl_err_code == CURLE_COULDNT_CONNECT )
1348         curl_err = "CURLE_COULDNT_CONNECT";
1349     else
1350         curl_err = "UNKNOWN";
1351
1352     int level = 0;
1353     if ( (level <= Loglevel) )
1354     {
1355         ostringstream msg;
1356         msg << "Curl error while requesting following url: " << url << " Curl error code: " << curl_err_code << " " << curl_err << " " << curl_err_buff << endl; /*lint !e641 */
1357         log_error(msg.str());
1358     }
1359 }
1360
1361
1362 /**
1363  * Prints out the data received by curl operation
1364  * @param CurlWritedataBuff
1365  */
1366 void Logger::print_curl_data(const string& curl_writedata_buff) const
1367 {
1368     int level = 1;
1369     if ( level <= Loglevel )
1370     {
1371         ostringstream msg;
1372         msg << "Data received by curl: " << curl_writedata_buff << endl;
1373         log_notice(msg.str());
1374     }
1375 }
1376
1377
1378 /**
1379  * Not authorized to perform requested update operation
1380  * @param service The requested service.
1381  * @param username Username
1382  * @param password Password
1383  */
1384 void Logger::print_service_not_authorized(const string& service, const string& username, const string& password) const
1385 {
1386     int level = 0;
1387     if ( level <= Loglevel )
1388     {
1389         ostringstream msg;
1390         msg << "Not authorized to perform update operation on service: " << service << " Please check username and password: " << username << ":" << password << endl;
1391         log_notice(msg.str());
1392     }
1393 }
1394
1395
1396 /**
1397  * Prints out the http status code
1398  * @param url Url
1399  * @param output HTTP status code
1400  */
1401 void Logger::print_http_status_code(const string& url, const long http_code) const
1402 {
1403     int level = 1;
1404     if ( level <= Loglevel )
1405     {
1406         ostringstream msg;
1407         msg << "Requested URL: " << url << " Received HTTP status code: " << http_code << endl;
1408         log_notice(msg.str());
1409     }
1410 }
1411
1412
1413 /**
1414  * Generic failure while trying to update service
1415  * @param url The requested URL
1416  * @param curl_data The received curl_data from the server
1417  */
1418 void Logger::print_update_failure(const string& url, const string& curl_data) const
1419 {
1420     int level = 0;
1421     if ( (level <= Loglevel) )
1422     {
1423         ostringstream msg;
1424         msg << "Problem while trying to updating service. Requested URL: " << url << " Error Code from Server: " << curl_data << endl;
1425         log_error(msg.str());
1426     }
1427 }
1428
1429
1430 /**
1431  * Generic failure while trying to update service
1432  * @param url The requested URL
1433  * @param http_status_code The received http status code
1434  */
1435 void Logger::print_update_failure(const string& url, const long http_status_code) const
1436 {
1437     int level = 0;
1438     if ( level <= Loglevel )
1439     {
1440         ostringstream msg;
1441         msg << "Problem while trying to updating service. Requested URL: " << url << " Error Code from Server: " << http_status_code << endl;
1442         log_error(msg.str());
1443     }
1444 }
1445
1446 /**
1447  * Hostname is invalid, contains no or only one domain part.
1448  * @param hostname The full qualified host name.
1449  */
1450 void Logger::print_invalid_hostname(const string& hostname)
1451 {
1452     int level = 0;
1453     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1454     {
1455         ostringstream msg;
1456         msg << "The configured hostname: " << hostname << " is invalid. Please add the corresponding domain part." << endl;
1457         log_warning(msg.str(),level);
1458     }
1459 }
1460
1461
1462 /**
1463  * An IP in a private range was detected
1464  * @param ip The private IP
1465  */
1466 void Logger::print_ip_is_local(const string& ip)
1467 {
1468     int level = 1;
1469     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1470     {
1471         ostringstream msg;
1472         msg << "The detected IP is within a private IP range: " << ip << endl;
1473         log_warning(msg.str(),level);
1474     }
1475 }
1476
1477
1478 /**
1479  * Regex is matching in string
1480  * @param regex The regex pattern
1481  * @param matching_string The string
1482  */
1483 void Logger::print_regex_match(const string& regex, const string& matching_string) const
1484 {
1485     int level = 1;
1486     if ( level <= Loglevel )
1487     {
1488         ostringstream msg;
1489         msg << "Regex: " << regex << " is matching in: " << matching_string << endl;
1490         log_notice(msg.str());
1491     }
1492 }
1493
1494
1495 /**
1496  * Regex is not matching
1497  * @param regex Regex
1498  * @param not_matching_string String
1499  */
1500 void Logger::print_no_regex_match(const string& regex, const string& not_matching_string)
1501 {
1502     int level = 1;
1503     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1504     {
1505         ostringstream msg;
1506         msg << "Regex: " << regex << " is not matching in: " << not_matching_string << endl;
1507         log_warning(msg.str(),level);
1508     }
1509 }
1510
1511
1512 /**
1513  * Could not parse gnudip initial reply.
1514  * @param curl_data The data received from gnudip server which should contain salt, time and sign.
1515  */
1516 void Logger::print_could_not_parse_received_data(const string& curl_data) const
1517 {
1518     int level = 0;
1519     if ( (level <= Loglevel) )
1520     {
1521         ostringstream msg;
1522         msg << "Could not parse salt, time and sign from initial gnudip server reply: " << curl_data << endl;
1523         log_error(msg.str());
1524     }
1525 }
1526
1527
1528 /**
1529  * Gnudip salt, time and sign could not be got from map
1530  */
1531 void Logger::print_could_not_get_initial_gnudip_data() const
1532 {
1533     int level = 0;
1534     if ( (level <= Loglevel) )
1535     {
1536         log_error("Could not get salt, time and sign from map.");
1537     }
1538 }
1539
1540
1541
1542 /**
1543  * Gnudip protocol requires explicit declaration of a servername.
1544  */
1545 void Logger::print_gnudip_requires_servername()
1546 {
1547     int level = 0;
1548     if ( (level <= Loglevel) || ((level <= ExternalWarningLevel) && (!ExternalWarningLog.empty())) )
1549     {
1550         log_warning("Gnudip requires explicit definition of servername via config!",level);
1551     }
1552 }
1553
1554
1555 /**
1556  * An exception occured while computing the md5 sum.
1557  * @param what The exception occured.
1558  */
1559 void Logger::print_exception_md5_sum(const string& what) const
1560 {
1561     int level = 0;
1562     if ( level <= Loglevel )
1563     {
1564         ostringstream msg;
1565         msg << "An exception occured while computing a md5 sum: " << what << endl;
1566         log_error(msg.str());
1567     }
1568 }
1569
1570
1571 /**
1572  * An network exception occured.
1573  * @param what The exception occured.
1574  */
1575 void Logger::print_network_error(const string& what) const
1576 {
1577     int level = 0;
1578     if ( level <= Loglevel )
1579     {
1580         ostringstream msg;
1581         msg << "An netowrk exception occured: " << what << endl;
1582         log_error(msg.str());
1583     }
1584 }
1585
1586
1587 /**
1588  * An undefined protocol error occured.
1589  * @param protocol The protocol
1590  * @param error The error
1591  */
1592 void Logger::print_undefined_protocol_error(const string& protocol, const string& error) const
1593 {
1594     int level = 0;
1595     if ( level <= Loglevel )
1596     {
1597         ostringstream msg;
1598         msg << "An undefined protocol error occured. Protocol: " << protocol << " Error: " << error << endl;
1599         log_error(msg.str());
1600     }
1601 }
1602
1603 /**
1604  * Error while trying to log through external program.
1605  * @param external_prog The external program called.
1606  */
1607 void Logger::print_error_external_logging(const string& external_prog) const
1608 {
1609     int level = 0;
1610     if ( level <= Loglevel )
1611     {
1612         ostringstream msg;
1613         msg << "Error while trying to log through external program: " << external_prog << endl;
1614         log_notice(msg.str());
1615     }
1616 }
1617
1618
1619 /**
1620  * Error while parsing config file.
1621  * @param error Error occured.
1622  * @param config_file Config file.
1623  */
1624 void Logger::print_error_parsing_config_file(const string& filename, const string& error) const
1625 {
1626     int level = 0;
1627     if ( level <= Loglevel )
1628     {
1629         ostringstream msg;
1630         msg << "Error while parsing config file: " << filename << " Error: " << error << endl;
1631         log_notice(msg.str());
1632     }
1633 }
1634
1635
1636 /**
1637  * Error while parsing cmd option
1638  * @param error Error
1639  */
1640 void Logger::print_error_parsing_cmd(const string& error) const
1641 {
1642     int level = 0;
1643     if ( level <= Loglevel )
1644     {
1645         ostringstream msg;
1646         msg << "Error while parsing cmd options: " << error << endl;
1647         log_error(msg.str());
1648     }
1649 }
1650
1651
1652 /**
1653  * The webcheck interval was exceeded, so webcheck not allowed.
1654  * @param last_webcheck Time of last webcheck.
1655  * @param webcheck_interval Webcheck interval time.
1656  * @param current_time Current system time.
1657  */
1658 void Logger::print_webcheck_exceed_interval( const time_t last_webcheck, const int webcheck_interval, const time_t current_time ) const
1659 {
1660     int level = 1;
1661     if ( level <= Loglevel )
1662     {
1663         ostringstream msg;
1664         msg << "Exceeding webcheck interval: LastWebcheck " << last_webcheck << " + WebcheckInterval(sec) " << webcheck_interval << " >= CurrentTime " << current_time << endl;
1665         log_notice(msg.str());
1666     }
1667 }
1668
1669
1670 /**
1671  * Checking if hosts needs update.
1672  * @param hostname Hostname
1673  * @param current_time Current time
1674  * @param lastupdated Last updated
1675  */
1676 void Logger::print_check_service_update(const string& hostname, const time_t current_time, const time_t lastupdated) const
1677 {
1678     int level = 1;
1679     if ( level <= Loglevel )
1680     {
1681         ostringstream msg;
1682         msg << "Checking if host: " << hostname << " needs update. Current time: " << current_time << " Last updated: " << lastupdated << endl;
1683         log_notice(msg.str());
1684     }
1685 }
1686
1687
1688 /**
1689  * Cached DNS entry
1690  * @param hostname Hostname
1691  * @param ip_dns_recheck DNS recheck IP
1692  * @param ip_last_update IP set in last update
1693  * @param ip_host Hosts' IP
1694  */
1695 void Logger::print_cached_dns_entry(const string& hostname, const string& ip_dns_recheck, const string& ip_last_update, const string& ip_host) const
1696 {
1697     int level = 1;
1698     if ( level <= Loglevel )
1699     {
1700         ostringstream msg;
1701         msg << "Cached DNS record for host <" << hostname << "> : " << ip_dns_recheck << " Last updated IP: " << ip_last_update << " Hosts IP: " << ip_host << endl;
1702         log_notice(msg.str());
1703     }
1704 }
1705
1706
1707 /**
1708  * Updating service
1709  * @param hostname Hostname
1710  * @param ip_dns_recheck Cached DNS entry
1711  * @param ip_last_update IP set in last update
1712  * @param ip_host Hosts IP
1713  * @param lastupdated Lastupdated
1714  */
1715 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{
1716     int level = 1;
1717     if ( level <= Loglevel )
1718     {
1719         ostringstream msg;
1720         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;
1721         log_notice(msg.str());
1722     }
1723 }
1724
1725
1726 /**
1727  * TTL expired
1728  * @param hostname Hostname
1729  * @param ip_dns_recheck Cached DNS entry
1730  * @param ip_last_update IP set in last update
1731  * @param ip_host Hosts IP
1732  * @param lastupdated Last updated
1733  * @param dns_cache_ttl DNS cache ttl
1734  * @param current_time Current time
1735  */
1736 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
1737 {
1738     int level = 1;
1739     if ( level <= Loglevel )
1740     {
1741         ostringstream msg;
1742         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;
1743         log_notice(msg.str());
1744     }
1745 }
1746
1747
1748 /**
1749  * TTL expired
1750  * @param override_log_level Override log level with zero if true
1751  * @param hostname Hostname
1752  * @param ip_dns_recheck Cached DNS entry
1753  * @param ip_last_update IP set in last update
1754  * @param ip_host Hosts IP
1755  * @param lastupdated Last updated
1756  * @param dns_cache_ttl DNS cache ttl
1757  * @param current_time Current time
1758  */
1759 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
1760 {
1761     int level = 1;
1762
1763     if (override_log_level)
1764         level = 0;
1765
1766     if ( level <= Loglevel )
1767     {
1768         ostringstream msg;
1769         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;
1770         log_notice(msg.str());
1771     }
1772 }
1773
1774
1775 /**
1776  * No update needed
1777  * @param override_log_level Override log level with zero if true
1778  * @param hostname Hostname
1779  * @param ip_dns_recheck Cached DNS entry
1780  * @param ip_last_update IP set in last update
1781  * @param ip_host Hosts IP
1782  * @param lastupdated Last updated
1783  */
1784 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
1785 {
1786     int level = 1;
1787
1788     if (override_log_level)
1789         level = 0;
1790
1791     if ( level <= Loglevel )
1792     {
1793         ostringstream msg;
1794         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;
1795         log_notice(msg.str());
1796     }
1797 }
1798
1799
1800 /**
1801  * Error while trying to get local wan interface IP address through getifaddrs.
1802  * @param error The system call which raised the error.
1803  * @param error The error set by getifaddrs.
1804  */
1805 void Logger::print_error_getting_local_wan_ip(const std::string& system_call, const std::string& error) const
1806 {
1807     int level = 0;
1808     if ( level <= Loglevel )
1809     {
1810         ostringstream msg;
1811         msg << "Error while trying to get local wan interface IP address through '" << system_call << "': " << error << endl;
1812         log_error(msg.str());
1813     }
1814 }
1815
1816
1817 /**
1818  * Could not get IP address of local wan interface.
1819  * @param override_log_level Override log level with zero if true
1820  */
1821 void Logger::print_no_wan_ip(bool override_log_level) const
1822 {
1823     int level = 1;
1824
1825     if (override_log_level)
1826         level = 0;
1827
1828     if ( level <= Loglevel )
1829     {
1830         ostringstream msg;
1831         msg << "Could not get IP address of local wan interface. Will retry later." << endl;
1832         log_error(msg.str());
1833     }
1834 }
1835
1836 /**
1837  * Print extenral WAN IP
1838  * @param override_log_level Override log level with zero if true
1839  * @param ip External WAN IP
1840  */
1841 void Logger::print_external_wan_ip(bool override_log_level, const std::string &ip) const
1842 {
1843     int level = 1;
1844
1845     if (override_log_level)
1846         level = 0;
1847
1848     if ( level <= Loglevel )
1849     {
1850         ostringstream msg;
1851         msg << "Determined WAN interface IP: " << ip << endl;
1852         log_error(msg.str());
1853     }
1854 }
1855
1856 /**
1857  * Could not resolve current IP for DNS name
1858  * @param override_log_level Override log level with zero if true
1859  */
1860 void Logger::print_dns_lookup_failed(bool override_log_level, const std::string &hostname) const
1861 {
1862     int level = 1;
1863
1864     if (override_log_level)
1865         level = 0;
1866
1867     if ( level <= Loglevel )
1868     {
1869         ostringstream msg;
1870         msg << "Could not resolve IP address for host " << hostname << ". Will retry later." << endl;
1871         log_error(msg.str());
1872     }
1873 }
1874
1875
1876 /**
1877  * Invalid service config was detected.
1878  */
1879 void Logger::print_invalid_service_config() const
1880 {
1881     int level = 0;
1882     if ( level <= Loglevel )
1883     {
1884         log_error("Ignoring invalid service. Please check.\n");
1885     }
1886 }
1887
1888
1889 /**
1890  * Print simple message.
1891  */
1892 void Logger::print_msg( const string& msg ) const
1893 {
1894     int level = 0;
1895     if ( level <= Loglevel )
1896     {
1897         log_error(msg);
1898     }
1899 }