#include <boost/assert.hpp>
 
-#include <logfunc.hpp>
-
 #include "config/configurationcommandline.h"
 #include "config/configurationfile.h"
 
     bool configuration_file_processed = file.process( &vm );
     if ( configuration_file_processed )
     {
-        file.parse( vm, &Config );
+        if ( !file.parse( vm, &Config ) )
+        {
+            return false;
+        }
     }
 
     bool input_processed = command_line_processed && configuration_file_processed;
 
 
 using namespace std;
 using boost::program_options::option_description;
-using boost::program_options::option_description;
 using boost::program_options::untyped_value;
 using boost::program_options::value_semantic;
 using boost::shared_ptr;
 /**
  * @return The underlining @c boost::program_options::option_description object.
  */
-option_description ConfigurationOption::get_option_description()
+option_description ConfigurationOption::get_option_description() const
 {
     return option;
 }
 
     );
     virtual ~ConfigurationOption();
 
-    boost::program_options::option_description get_option_description();
+    boost::program_options::option_description get_option_description() const;
     std::string get_command_string() const;
     std::string get_command_description() const;
 
 
 
         GlobalLogger.debug() << "- " << protocol_string;
 
-        BOOST_ASSERT( ( PingProtocol_First <= protocol ) && ( protocol <= PingProtocol_Last ) );
+        BOOST_ASSERT( ( PingProtocol_First <= protocol ) && ( protocol <= PingProtocol_Last ) );                       //lint !e568
     }
 
     BOOST_ASSERT( 0 < protocol_list.size() );
 
     string log_level_uppercase_string( log_level_string );
     transform( log_level_string.begin(), log_level_string.end(),
                log_level_uppercase_string.begin(),
-               ::toupper );
+               ::toupper );                                                                           //lint !e534
 
     // TODO move to an init method
     log_level_string_map[ "DEBUG" ] = LogLevel::Debug;
 
         const int byte_index,
         const int bit_index,
         const bool value
-)
+) const
 {
     const int max_bit_index = 7;
     BOOST_ASSERT( ( 0 <= byte_index ) && ( byte_index < static_cast<int>(PayloadSizeInBytes) ) );
         const int left_byte_index,
         const int right_byte_index,
         const uint16_t value
-)
+) const
 {
     BOOST_ASSERT( ( 0 <= left_byte_index ) && ( left_byte_index < static_cast<int>(PayloadSizeInBytes) ) );
     BOOST_ASSERT( ( 0 <= right_byte_index ) && ( right_byte_index < static_cast<int>(PayloadSizeInBytes) ) );
         const int first_byte_index,
         const int last_byte_index,
         const uint32_t value
-)
+) const
 {
     BOOST_ASSERT( ( 0 <= first_byte_index ) && ( first_byte_index < static_cast<int>(PayloadSizeInBytes) ) );
     BOOST_ASSERT( ( 0 <= last_byte_index ) && ( last_byte_index < static_cast<int>(PayloadSizeInBytes) ) );
 
             const int byte_index,
             const int bit_index,
             const bool value
-    );
+    ) const;
 
     uint16_t decode16(
             const int left_byte_index,
             const int left_byte_index,
             const int right_byte_index,
             const uint16_t value
-    );
+    ) const;
 
     uint32_t decode32(
             const int first_byte,
             const int first_byte,
             const int last_byte,
             const uint32_t value
-    );
+    ) const;
 
     std::istream& read( std::istream &is );
     std::ostream& write( std::ostream &os ) const;
 
     catch ( ... )
     {
         GlobalLogger.error() << "Error: could not destroy network interface list."
-                << endl;
+                << endl;                                                                       //lint !e1551
     }
 } //lint !e1579
 
 
     string protocol_uppercase_string( protocol_string );
     transform( protocol_string.begin(), protocol_string.end(),
                protocol_uppercase_string.begin(),
-               ::toupper );
+               ::toupper ); //lint !e534
 
     // TODO move to an init method
     protocol_string_map[ "ICMP" ] = PingProtocol_ICMP;
 
     );
 }
 
-bool PingRotate::resolve_ping_address()
+bool PingRotate::resolve_ping_address()                                                         //lint !e1762
 {
     return IpList->resolve();
 }
     PingDoneCallback = ping_done_callback;
 }
 
-void PingRotate::ping_done_handler( bool ping_success )
+void PingRotate::ping_done_handler( bool ping_success ) const
 {
     PingDoneCallback( ping_success );
 }
     // when the protocol change, there is a chance that the IP version required by the new
     // protocol differ from the previous one, thus it is required to resolve the address again.
     // FIXME add some intelligence here to decide if the new protocol requires to update the DNS
-    resolve_ping_address();
+    resolve_ping_address();                                                                         //lint !e534
 }
 
     //
 
     void set_ping_done_callback( boost::function<void(bool)> ping_done_callback );
-    void ping_done_handler( bool ping_success );
+    void ping_done_handler( bool ping_success ) const;
 
     void init_ping_protocol();
     void update_ping_protocol();
 
  */
 bool PingScheduler::start_pinging_thread()
 {
-    Thread = thread( &PingScheduler::start_pinging, this );
+    Thread = thread( &PingScheduler::start_pinging, this );                                             //lint !e1793
 
     return true;
 }
 
     if ( configuration.get() != NULL )
     {
         int log_level = configuration->get_log_level();
-        I2n::Logger::set_log_level( log_level );
+        I2n::Logger::set_log_level( log_level );                                                    //lint !e534
 
         bool daemon_mode = configuration->get_daemon();
         if ( daemon_mode )