release version v1.3.4

Servicebinarypackagesamename

.gitlab-ci.yml

@@ -1,17 +1,95 @@
-image: luki42/dynuiprefresher_build:latest
-
 stages:
+  - cmake
   - build
+  - post
 
+# Unix Build
+cmake:
+  stage: cmake
+  image: luki42/dynuiprefresher_build:latest
+  script:
+    - cmake -S . -B build
+  artifacts:
+    paths:
+      - build/
+      - inc/
+      - postinst
 
 build:
   stage: build
+  image: luki42/dynuiprefresher_build:latest
+  script:
+    - cd build
+    - make iprefresher
+  artifacts:
+    paths:
+      - build/
+      - inc/
+      - postinst
+  dependencies:
+    - cmake
+
+
+build_package:
+  stage: post
+  image: luki42/dynuiprefresher_build:latest
   script:
-    - cmake -S . -B build
     - cd build
-    - make
     - make package
   artifacts:
     paths:
-      - "build/bin/*"
+      - build/
-      - "build/packages/*"
+      - inc/
+      - postinst
+  dependencies:
+    - build
+
+test:
+  stage: post
+  image: luki42/dynuiprefresher_build:latest
+  script:
+    - cd build
+    - make build-test
+  artifacts:
+    reports:
+      junit: build/*.xml
+  dependencies:
+    - build
+
+# Windows Build
+cmake_win64:
+  stage: cmake
+  image: luki42/dynuiprefresher_build:windows
+  script:
+    - cmake -S . -B build -D WinBuild=ON
+  artifacts:
+    paths:
+      - build/
+      - inc/
+
+build_win64:
+  stage: build
+  image: luki42/dynuiprefresher_build:windows
+  script:
+    - cd build
+    - make iprefresher
+  artifacts:
+    paths:
+      - build/
+      - inc/
+  dependencies:
+    - cmake_win64
+
+
+build_package_win64:
+  stage: post
+  image: luki42/dynuiprefresher_build:windows
+  script:
+    - cd build
+    - make package
+  artifacts:
+    paths:
+      - build/
+      - inc/
+  dependencies:
+    - build_win64

CMakeLists.txt

@@ -5,20 +5,26 @@
 ## libcurl (with sources)
 ## libconfig (with sources)
 #
-# documenation build needs doxygen to be installed.
+# for documenation build doxygen needs to be installed.
+# for test build gtest needs to be installed.
 
 cmake_minimum_required(VERSION 3.13)
-project(iprefresher DESCRIPTION "Dynu ip refresher")
+project(dynuiprefresher DESCRIPTION "Dynu ip refresher" LANGUAGES)
-SET(PROJECT_VERSION 1.3.3)
+SET(PROJECT_VERSION 1.3.4)
-SET(CMAKE_CXX_STANDARD 17)
 
 # CONFIGURATION
 SET(CMAKE_BUILD_TYPE Release) # manually SET build type (Release / Debug)
 SET(LIB_METHOD STATIC) #SHARED / STATIC
 
-option(BUILD_DOC "Build documentation" OFF) # additional dependency for Doxygen
+option(BUILD_DOC "Build documentation" ON) # additional dependency for Doxygen
 option(PACKAGING "Allow Packaging to <exe>, <deb> or <rpm>" ON) # additional dependencies for RPMbuild,dpkg  or NSIS
-set(WinBuild false)
+option(TESTS "Build Tests" ON) # additional dependencies for GTEST - to build tests
+option(WinBuild "cross compile for Windows Platform" OFF)
+
+# helper variables
+SET(CMAKE_CXX_STANDARD 17)
+string(TIMESTAMP TIMESTAMP_NOW "%d.%m.%Y")
+SET(Application_Name "dynuiprefresher")
 
 SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
@@ -26,6 +32,7 @@ SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
 # setup winbuild compilers
 if (${WinBuild})
+    message(STATUS "setup Mingw Toolchain for cross compile.")
     set(LIBSUFFIX .dll)
     set(SUFFIX .exe)
 
@@ -35,9 +42,9 @@ if (${WinBuild})
     #set(TOOLCHAIN_PREFIX i686-w64-mingw32)
 
     # cross compilers to use for C and C++
-    set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+    set(CMAKE_C_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-gcc)
-    set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+    set(CMAKE_CXX_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-g++)
-    set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
+    set(CMAKE_RC_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-windres)
 
     # target environment on the build host system
     set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
@@ -60,17 +67,26 @@ if (${WinBuild})
     # or add_definitions(-DCURL_STATICLIB)
 
     # windows config path is same as executable
-    set(CONFIG_PATH "./iprefresher.cfg")
+    set(CONFIG_PATH "std::string(std::getenv(\"USERPROFILE\")) + \"\\\\AppData\\\\Roaming\\\\DynuIPrefresher\\\\\"")
 else ()
+    message(STATUS "using nativ gcc toolchain.")
     set(LIBSUFFIX .so)
     set(SUFFIX "")
 
     # set /etc/ config path
-    set(CONFIG_PATH "/etc/iprefresher.cfg")
+    set(CONFIG_PATH "\"/etc/\"")
 endif ()
 
+# test compiler settings and enable languages here
+message("")
+message(STATUS "Testing the C++ compiler!")
+enable_language(CXX)
+message("")
+message(STATUS "Testing the C compiler!")
+enable_language(C)
 
 # config libs
+message("")
 message(STATUS "Config of Libraries")
 # libcurl
 if (${WinBuild})
@@ -106,28 +122,46 @@ else ()
 
     message("")
     # libconfig
-    FIND_PACKAGE(libconfig++ REQUIRED)
+    FIND_PATH(LIBCONFIG++_INCLUDE_DIRS
-    if (LIBCONFIG++_INCLUDE_DIRS AND LIBCONFIG++_LIBRARY_DIRS)
+            NAMES libconfig.h++
-        message(STATUS "Found libconfig version: ${LIBCONFIG++_VERSION}")
+            PATHS /usr/include /usr/local/include) # search for libconfig include headers
+    FIND_LIBRARY(LIBCONFIG++_LIBRARIES
+            NAMES config++
+            PATHS /usr/lib /usr/local/lib) # search for actual lib
+
+    if (LIBCONFIG++_INCLUDE_DIRS AND LIBCONFIG++_LIBRARIES)
+        message(STATUS "Fount libconfig!")
         message(STATUS "Using libconfig include dir(s): ${LIBCONFIG++_INCLUDE_DIRS}")
-        message(STATUS "Using libconfig lib(s): ${LIBCONFIG++_LIBRARY_DIRS}")
+        message(STATUS "Using libconfig lib(s): ${LIBCONFIG++_LIBRARIES}")
     else ()
-        message(FATAL_ERROR "Could not find CURL")
+        message(FATAL_ERROR "Could not find LIBCONFIG")
     endif ()
-    include_directories(${LIBCONFIG++_INCLUDE_DIRS} inc)
+
+    include_directories(${LIBCONFIG_INCLUDE_DIRS})
 endif ()
 
 message("")
 
 #read sample config
-FILE(READ ${CMAKE_SOURCE_DIR}/config/iprefresher.cfg SAMPLECONFIG)
+FILE(READ ${CMAKE_SOURCE_DIR}/config/dynuiprefresher.cfg SAMPLECONFIG)
 #add version header
 FILE(WRITE ${CMAKE_SOURCE_DIR}/inc/Version.h
-        "\#pragma once
+        "/**
+ * Version header to store Version, Config dir and a Sample config
+ * Do not edit this file manually, it is generated by the cmake script!
+ *
+ * @author Lukas Heiligenbrunner
+ * @date ${TIMESTAMP_NOW}
+ */
+
+#pragma once
+
 #include <string>
+
 namespace Version {
   const std::string VERSION = \"${PROJECT_VERSION}\";
-  const std::string ConfigDir = \"${CONFIG_PATH}\";
+  const std::string ConfigDir = ${CONFIG_PATH};
+  const std::string ConfName = \"${Application_Name}.cfg\";
   const std::string SAMPLECONFIG = R\"(${SAMPLECONFIG})\";
 }"
         )
@@ -138,35 +172,33 @@ add_library(api ${LIB_METHOD}
         src/api/DynuAPI.cpp
         src/api/IPAPI.cpp)
 
-add_library(logger ${LIB_METHOD}
+add_library(libdynuiprefresher ${LIB_METHOD}
-        src/FileLogger.cpp
-        src/Logger.cpp)
-
-
-SET(SOURCE
-        src/main.cpp
         src/IPRefresher.cpp
-        src/Config.cpp)
+        src/Config.cpp
+        src/IpHelper.cpp
+        src/FileLogger.cpp
+        src/Logger.cpp
+        )
 
-add_executable(iprefresher ${SOURCE})
+add_executable(${Application_Name} src/main.cpp)
 
 # LINK generated LIBS #
-target_link_libraries(iprefresher api logger ${CURL_LIBRARIES} ${LIBCONFIG++_LIBRARIES})
+target_link_libraries(${Application_Name} libdynuiprefresher api ${CURL_LIBRARIES} ${LIBCONFIG++_LIBRARIES})
 
 # setting install targets
 IF (NOT ${WinBuild})
     # INSTALL to Linux SYSTEM #
 
     # install binaries
-    install(TARGETS iprefresher DESTINATION usr/bin)
+    install(TARGETS ${Application_Name} DESTINATION usr/bin)
     # install systemd service and enable it
-    install(FILES service/iprefresher.service DESTINATION lib/systemd/system)
+    install(FILES service/${Application_Name}.service DESTINATION lib/systemd/system)
 ELSE ()
     # INSTALL to Windows SYSTEM #
 
     # install binary to current folder
-    set_target_properties(iprefresher PROPERTIES SUFFIX ".exe")
+    set_target_properties(${Application_Name} PROPERTIES SUFFIX ".exe")
-    install(TARGETS iprefresher DESTINATION .)
+    install(TARGETS ${Application_Name} DESTINATION .)
 
     # install .dll dependencies
     # todo check if files exist...
@@ -201,11 +233,15 @@ if (${PACKAGING})
         # generate post script for checking if configuration already exists
         FILE(WRITE ${CMAKE_SOURCE_DIR}/postinst
                 "#!/bin/bash
+# Post installation script for linux packages
+# do not edit this file manually, it is generated by the cmake script
 if [ ! -f ${CONFIG_PATH} ]; then
     cat > ${CONFIG_PATH} <<- EOM
 ${SAMPLECONFIG}EOM
-fi\n"
+fi
-                )
+
+systemctl enable ${Application_Name}.service
+systemctl start ${Application_Name}.service")
 
 
         SET(CPACK_DEB_COMPONENT_INSTALL 1)
@@ -257,8 +293,8 @@ fi\n"
 
     add_custom_target(build-packages
             "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" --target package
-            DEPENDS ${PROJECT_NAME}
+            DEPENDS ${Application_Name}
-            COMMENT "Packing ${PROJECT_NAME}")
+            COMMENT "Packing ${Application_Name}")
     message("")
 ENDIF ()
 
@@ -285,4 +321,44 @@ if (BUILD_DOC)
         message(STATUS "Doxygen need to be installed to generate the doxygen documentation")
     endif (DOXYGEN_FOUND)
     message("")
-endif (BUILD_DOC)
+endif (BUILD_DOC)
+
+# Test Cases
+if (TESTS)
+    #    include(GoogleTest)
+    message(STATUS "Configuring GTEST")
+    find_package(GTest)
+    if (GTEST_FOUND)
+
+        mark_as_advanced(
+                BUILD_GMOCK BUILD_GTEST BUILD_SHARED_LIBS
+                gmock_build_tests gtest_build_samples gtest_build_tests
+                gtest_disable_pthreads gtest_force_shared_crt gtest_hide_internal_symbols
+        )
+
+        enable_testing()
+
+        macro(package_add_test TESTNAME)
+            # create an exectuable in which the tests will be stored
+            add_executable(${TESTNAME} ${ARGN})
+            # link the Google test infrastructure, mocking library, and a default main fuction to
+            target_link_libraries(${TESTNAME} gtest gtest_main -lpthread -lm libdynuiprefresher api ${CURL_LIBRARIES} ${LIBCONFIG++_LIBRARIES})
+            # see https://cmake.org/cmake/help/v3.10/module/GoogleTest.html for more options to pass to it
+            gtest_discover_tests(${TESTNAME})
+
+            add_custom_command(TARGET build-test
+                    POST_BUILD
+                    COMMAND "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" --target ${TESTNAME}
+                    COMMAND "bin/${TESTNAME}" --gtest_output=xml:${TESTNAME}-report.xml)
+        endmacro()
+
+        add_custom_target(build-test
+                DEPENDS ${PROJECT_NAME}
+                COMMENT "Testing ${PROJECT_NAME}")
+
+        package_add_test(test1 tests/UnitTest.cpp ${SOURCE})
+
+    else ()
+        message(STATUS "GTEST environment not found!")
+    endif ()
+ENDIF ()

README.md

@@ -1,3 +1,4 @@
+[![pipeline status](http://gitlab.heili.eu/lukas/dynuiprefresher/badges/master/pipeline.svg)](http://gitlab.heili.eu/lukas/dynuiprefresher/-/commits/master)
 # DynuIPRefresher
 A lightweight C++ application to setup a service for refreshing a dynamic IP to the Dynu servers. 
 Dynu.com is a free DDns service and provides an API.
@@ -8,11 +9,27 @@ I'm providing executables for Debian/Ubuntu (.deb) and RHEL/Debian (.rpm).
 But you can still compile the code my your own (see build section).
 
 ## Configuration
-There is a configuration file `/etc/iprefresher.cfg` where you have to specify the DYNU API key (get it from their homepage), the domainid and your domain.
+There is a configuration file `/etc/dynuiprefresher.cfg` where you have to specify the DYNU API key (get it from their homepage), the domainid and your domain.
 Furthermore, you can optionally specify a Telegram API key and a Chat ID if you want to be notfied when your local ip changes.
 
 To enable and start the service: 
-`systemctl enable iprefresher.service` and `systemctl start iprefresher.service`
+`systemctl enable dynuiprefresher.service` and `systemctl start dynuiprefresher.service`
+
+## Usage
+First of all configure the right keys in the `/etc/dynuiprefresher.cfg` or `%appdata%\DynuIpRefresher\dynuiprefresher.cfg` config file.
+
+Afterwards use the following options: 
+
+```
+help page: 
+[-h] [--help]  print this help page
+[-v] [--version] print the software version
+[-f] [--force] force refresh of ip
+[-l] [--loop] infinite loop to refresh ip every five minutes
+[-c] [--checkconfig] validate configuration
+[-ip] [--currentip] get current global ip
+[no argument] normal ip check and refresh
+```
 
 
 ## Build

inc/Config.h

@@ -1,6 +1,9 @@
-//
+/**
-// Created by lukas on 11.02.20.
+ * A static class to manage the configuration file, read/write parameters to it.
-//
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 11.02.2020
+ */
 
 #pragma once
 
@@ -8,20 +11,12 @@
 
 class Config {
 public:
-    static std::string dynuapikey;
-
-    static std::string domainid; //id of the dynu domain
-    static std::string domainname;
-
-    static std::string telegramApiKey;
-    static std::string chatId;
-
     /**
-     * read configuration out of config file
+    * read configuration out of config file
-     *
+    *
-     * @return success of config read
+    * @return success of config read
-     */
+    */
-    static bool readCredentials();
+    static bool readConfig();
 
     /**
      * validate config file
@@ -30,5 +25,62 @@ public:
      */
     static bool validateConfig();
 
+    /**
+     * check if telegram credentials in config are set
+     * @return is supported?
+     */
+    static bool isTelegramSupported();
+
+    /** Getters **/
+
+    /**
+     * encapsulated getter for DynuApiKey
+     * @return api key
+     */
+    static const std::string &getDynuapikey();
+
+    /**
+     * encapsulated getter for DomainId
+     * @return DomainId
+     */
+    static const std::string &getDomainid();
+
+    /**
+     * encapsulated getter for Domainname
+     * @return Domainname
+     */
+    static const std::string &getDomainname();
+
+    /**
+     * encapsulated getter for TelegramApiKey
+     * @return TelegramApiKey
+     */
+    static const std::string &getTelegramApiKey();
+
+    /**
+     * encapsulated getter for ChatId
+     * @return ChatId
+     */
+    static const std::string &getChatId();
+
+
 private:
+    /**
+     * private constructor --> don't allow instance of this class
+     */
+    Config();
+
+    /**
+     * helper variable for managing telegram Support
+     */
+    static bool telegramSupport;
+
+    /**
+     * helper variables for storing keys and ids
+     */
+    static std::string dynuapikey;
+    static std::string domainid; //id of the dynu domain
+    static std::string domainname;
+    static std::string telegramApiKey;
+    static std::string chatId;
 };

inc/FileLogger.h

@@ -1,6 +1,9 @@
-//
+/**
-// Created by lukas on 05.05.19.
+ * Read and write current ip to a temp file to remember last ip until restart
-//
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 05.05.2019
+ */
 
 #pragma once
 

inc/IPRefresher.h

@@ -1,6 +1,11 @@
-//
+/**
-// Created by lukas on 02.08.19.
+ * IPrefresher library
-//
+ * - start checking ip once
+ * - or in loop mode
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 06.04.2019
+ */
 
 #pragma once
 
@@ -14,7 +19,7 @@ public:
     /**
      * default constructor
      */
-    IPRefresher();
+    IPRefresher() = default;
 
     /**
      * start the service in loop mode

inc/IpHelper.h

@@ -0,0 +1,22 @@
+/**
+ * A helper class for general IP String actions
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 07.05.2020
+ */
+
+#pragma once
+
+#include <string>
+
+class IpHelper {
+public:
+    /**
+     * check if ip is valid
+     * @param ip ip address to test
+     * @return validity
+     */
+    static bool isIpValid(std::string ip);
+
+private:
+};

inc/Logger.h

@@ -1,6 +1,10 @@
-//
+/**
-// Created by lukas on 26.10.19.
+ * Fancy console log output format
-//
+ * todo log level support
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 26.10.2019
+ */
 
 #pragma once
 

inc/api/API.h

@@ -1,6 +1,11 @@
-//
+/**
-// Created by lukas on 06.04.19.
+ * API class
-//
+ * - manages all curl download stuff
+ * - easy POST/GET requests
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 06.04.2019
+ */
 
 #pragma once
 
@@ -25,7 +30,10 @@ public:
      * @param headers header fields
      * @return return string of server
      */
-    std::string request(std::string myurl, bool post, Hashmap<std::string, std::string> &map, std::vector<std::string> &headers);
+    std::string request(std::string myurl,
+                        bool post,
+                        Hashmap<std::string, std::string> &map,
+                        std::vector<std::string> &headers);
 
 private:
     static size_t write_data(void *buffer, size_t size, size_t buffersize, FILE *stream);

inc/api/DynuAPI.h

@@ -1,19 +1,22 @@
-//
+/**
-// Created by lukas on 18.06.19.
+ * Dynu API - Refresh the IP
-//
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 18.06.2019
+ */
 
 #pragma once
 
 #include "API.h"
 
-class DynuAPI : API{
+class DynuAPI : API {
 public:
     /**
      * refresh the ip of domain on Dynu server
      * @param ip new ip
      * @return request status
      */
-    int refreshIp(std::string ip);
+    bool refreshIp(std::string ip);
 
     /**
      * init Telegram api with apikey and chatid
@@ -21,10 +24,21 @@ public:
      * @param domainId ID of domain received by Dynu
      * @param domainName domainname to refresh
      */
-    void init(const std::string& dynuApiKey, const std::string& domainId, const std::string& domainName);
+    void init(const std::string &dynuApiKey, const std::string &domainId, const std::string &domainName);
-private:
-    std::string dynuapikey; // Dynu API key
 
-    std::string domainid; //id of the dynu domain
+private:
+    /**
+     * Dynu API Key
+     */
+    std::string dynuapikey;
+
+    /**
+     * Dynu Domain ID
+     */
+    std::string domainid;
+
+    /**
+     * Domain name eg. "mydomain.dynu.net"
+     */
     std::string domainname;
 };

inc/api/Hashmap.h

@@ -1,6 +1,9 @@
-//
+/**
-// Created by lukas on 07.04.19.
+ * A Hashmap class for easier Key-Value maps
-//
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 07.04.2019
+ */
 
 #pragma once
 

inc/api/IPAPI.h

@@ -1,6 +1,9 @@
-//
+/**
-// Created by lukas on 18.06.19.
+ * IPAPI for getting global ip of current network
-//
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 18.06.2019
+ */
 
 #pragma once
 
@@ -8,7 +11,7 @@
 
 #include <string>
 
-class IPAPI : API{
+class IPAPI : API {
 public:
     /**
      * get global ip of current internet connection

inc/api/TelegramAPI.h

@@ -1,6 +1,9 @@
-//
+/**
-// Created by lukas on 08.05.19.
+ * Telegram API for sending message to specific chat
-//
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 08.05.2019
+ */
 
 #pragma once
 
@@ -14,7 +17,7 @@ public:
      * send telegram Message to predefined destination
      * @param text message
      */
-    int sendMessage(const std::string& text);
+    int sendMessage(const std::string &text);
 
     /**
      * init Telegram api with apikey and chatid

src/Config.cpp

@@ -1,7 +1,3 @@
-//
-// Created by lukas on 11.02.20.
-//
-
 #include "Config.h"
 #include "Logger.h"
 #include "Version.h"
@@ -10,6 +6,7 @@
 #include <cstring>
 #include <fstream>
 #include <libconfig.h++>
+#include <sys/stat.h>
 
 std::string Config::dynuapikey;
 std::string Config::domainid; //id of the dynu domain
@@ -18,22 +15,48 @@ std::string Config::domainname;
 std::string Config::telegramApiKey;
 std::string Config::chatId;
 
-bool Config::readCredentials() {
+bool Config::telegramSupport;
+
+bool Config::readConfig() {
     libconfig::Config cfg;
     try {
-        // todo make dynamic here
+        cfg.readFile(std::string(Version::ConfigDir + Version::ConfName).c_str());
-        cfg.readFile(Version::ConfigDir.c_str());
     }
     catch (const libconfig::FileIOException &fioex) {
         std::cout << "I/O error while reading config file." << std::endl << "creating new config file!" << std::endl;
 
+        // check if config folder exists
+        struct stat info{};
+
+        if (stat(Version::ConfigDir.c_str(), &info) != 0) {
+            Logger::warning("The config folder doesn't exist. Trying to create it.");
+
+#ifdef __unix
+            int check = mkdir(Version::ConfigDir.c_str(), 777);
+#else
+            int check = mkdir(Version::ConfigDir.c_str());
+#endif
+
+            // check if directory is created or not
+            if (!check)
+                Logger::message("config directory successfully created. ");
+            else
+                Logger::error("unable to create config directory.");
+
+        } else if (info.st_mode & S_IFDIR) {
+            Logger::debug("config directory exists already");
+        } else {
+            Logger::error("A file exists with the same name as the config dir should be");
+        }
+
+
         std::ofstream myfile;
-        myfile.open(Version::ConfigDir);
+        myfile.open(Version::ConfigDir + Version::ConfName);
         if (myfile.is_open()) {
             myfile << Version::SAMPLECONFIG;
             myfile.close();
         } else {
-            std::cout << "error creating file" << std::endl;
+            Logger::error("error creating file");
         }
 
         return false;
@@ -52,11 +75,15 @@ bool Config::readCredentials() {
         // optional parameters
         telegramApiKey = (std::string) cfg.lookup("telegramApiKey");
         chatId = (std::string) cfg.lookup("chatId");
+        telegramSupport = true;
     }
     catch (const libconfig::SettingNotFoundException &nfex) {
         // triggered if setting is missing in config
         if (!(std::strcmp("telegramApiKey", nfex.getPath()) == 0 || std::strcmp("chatId", nfex.getPath()) == 0)) {
             std::cerr << "No '" << nfex.getPath() << "' setting in configuration file." << std::endl;
+        } else {
+            Logger::message("no Telegram support - fields in config not set");
+            telegramSupport = false;
         }
     }
     // check if needed values aren't empty
@@ -83,27 +110,57 @@ bool Config::validateConfig() {
     try {
         // needed parameters
         if (((std::string) cfg.lookup("dynuapikey")).empty()) {
-            Logger::warning("required parameter dynuapikey seems to be empty.");
+            Logger::warning("required parameter \"dynuapikey\" seems to be empty.");
             return false;
         }
         if (((std::string) cfg.lookup("domainid")).empty()) {
-            Logger::warning("required parameter domainid seems to be empty.");
+            Logger::warning("required parameter \"domainid\" seems to be empty.");
             return false;
         }
         if (((std::string) cfg.lookup("domainname")).empty()) {
-            Logger::warning("required parameter domainname seems to be empty.");
+            Logger::warning("required parameter \"domainname\" seems to be empty.");
             return false;
         }
         // optional parameters
         cfg.lookup("telegramApiKey");
         cfg.lookup("chatId");
+        telegramSupport = true;
     }
     catch (const libconfig::SettingNotFoundException &nfex) {
         // triggered if setting is missing in config
         if (!(std::strcmp("telegramApiKey", nfex.getPath()) == 0 || std::strcmp("chatId", nfex.getPath()) == 0)) {
             std::cerr << "No '" << nfex.getPath() << "' setting in configuration file." << std::endl;
             return false;
+        } else {
+            Logger::message("no Telegram support - fields in config not set");
+            telegramSupport = false;
         }
     }
     return true;
-}
+}
+
+bool Config::isTelegramSupported() {
+    return telegramSupport;
+}
+
+const std::string &Config::getDynuapikey() {
+    return dynuapikey;
+}
+
+const std::string &Config::getDomainid() {
+    return domainid;
+}
+
+const std::string &Config::getDomainname() {
+    return domainname;
+}
+
+const std::string &Config::getTelegramApiKey() {
+    return telegramApiKey;
+}
+
+const std::string &Config::getChatId() {
+    return chatId;
+}
+
+Config::Config() = default;

src/FileLogger.cpp

@@ -1,12 +1,8 @@
-//
-// Created by lukas on 05.05.19.
-//
-
 #include "FileLogger.h"
+#include "IpHelper.h"
 
 #include <fstream>
 #include <iostream>
-#include <climits>
 
 void FileLogger::safeip(std::string ip) {
     std::ofstream out;
@@ -25,8 +21,8 @@ std::string FileLogger::readip() {
 
     in >> ip;
 
-    // when received ip has no : return 0.0.0.0
+    // when received ip has no . return 0.0.0.0
-    if (ip.find(':') == ULONG_MAX)
+    if (!IpHelper::isIpValid(ip))
         return "0.0.0.0";
     else
         return ip;

src/IPRefresher.cpp

@@ -1,7 +1,3 @@
-//
-// Created by lukas on 02.08.19.
-//
-
 #include "IPRefresher.h"
 #include "FileLogger.h"
 #include "api/IPAPI.h"
@@ -9,12 +5,11 @@
 #include "api/TelegramAPI.h"
 #include "Config.h"
 #include "Version.h"
+#include "IpHelper.h"
 
-#include <string>
 #include <chrono>
 #include <thread>
 #include <Logger.h>
-#include <climits>
 
 void IPRefresher::checkIPAdress(bool force) {
     FileLogger logger;
@@ -25,7 +20,7 @@ void IPRefresher::checkIPAdress(bool force) {
     if (ip.empty()) {
         //no internet connection (or other error)
         Logger::warning("no internet connection");
-    } else if (ip.find(':') == ULONG_MAX) {
+    } else if (!IpHelper::isIpValid(ip)) {
         // error when ip doesn't contain a :
         Logger::warning("an error occured when getting the global ip");
     } else {
@@ -37,13 +32,15 @@ void IPRefresher::checkIPAdress(bool force) {
             Logger::message("ip changed! -- from :" + oldip + "to: " + ip);
 
             DynuAPI dynu;
-            dynu.init(Config::dynuapikey, Config::domainid, Config::domainname);
+            dynu.init(Config::getDynuapikey(), Config::getDomainid(), Config::getDomainname());
+            // actual refresh of IP in api - here
+            bool result = dynu.refreshIp(ip);
 
-            if (dynu.refreshIp(ip)) {
+            if (result && Config::isTelegramSupported()) {
                 TelegramAPI tele;
-                tele.init(Config::telegramApiKey, Config::chatId);
+                tele.init(Config::getTelegramApiKey(), Config::getChatId());
                 tele.sendMessage(oldip + " moved to " + ip);
-            } else {
+            } else if (!result) {
                 //error
                 Logger::error("failed to write ip to dynu api!");
             }
@@ -53,20 +50,19 @@ void IPRefresher::checkIPAdress(bool force) {
     }
 }
 
-IPRefresher::IPRefresher() = default;
-
 IPRefresher::IPRefresher(bool loop) {
     if (loop) {
         Logger::message("startup of service");
         Logger::message("Version: " + Version::VERSION);
-        if (Config::readCredentials()) {
+
-            while (true) {
+        while (true) {
-                Logger::message("starting check");
+            Logger::message("starting check");
+            if (Config::readConfig()) {
                 checkIPAdress(false);
-                std::this_thread::sleep_for(std::chrono::milliseconds(300000));
+            } else {
+                std::cout << "incorrect credentials!" << std::endl;
             }
-        } else {
+            std::this_thread::sleep_for(std::chrono::milliseconds(300000));
-            std::cout << "incorrect credentials!" << std::endl;
         }
     }
 }

src/IpHelper.cpp

@@ -0,0 +1,7 @@
+#include "IpHelper.h"
+
+#include <climits>
+
+bool IpHelper::isIpValid(std::string ip) {
+    return (ip.find('.') != ULONG_MAX);
+}

src/Logger.cpp

@@ -1,7 +1,3 @@
-//
-// Created by lukas on 26.10.19.
-//
-
 #include "Logger.h"
 
 #include <sstream>

src/api/API.cpp

@@ -1,7 +1,3 @@
-//
-// Created by lukas on 06.04.19.
-//
-
 #include "api/API.h"
 
 #include <sstream>

src/api/DynuAPI.cpp

@@ -1,10 +1,6 @@
-//
-// Created by lukas on 18.06.19.
-//
-
 #include "api/DynuAPI.h"
 
-int DynuAPI::refreshIp(std:: string ip) {
+bool DynuAPI::refreshIp(std::string ip) {
     Hashmap<std::string, std::string> args;
     args.add("name", domainname);
     args.add("ipv4Address", ip);
@@ -16,15 +12,11 @@ int DynuAPI::refreshIp(std:: string ip) {
 
     const std::string dynurepl = request("https://api.dynu.com/v2/dns/" + domainid, true, args, headers);
 
-    if (dynurepl != "{\"statusCode\":200}") {
+    return (dynurepl == "{\"statusCode\":200}");
-        return -1;
-    } else {
-        return 1;
-    }
 }
 
-void DynuAPI::init(const std::string& dynuApiKey, const std::string& domainId, const std::string& domainName) {
+void DynuAPI::init(const std::string &dynuApiKey, const std::string &domainId, const std::string &domainName) {
-    this->dynuapikey=dynuApiKey;
+    this->dynuapikey = dynuApiKey;
-    this->domainid=domainId;
+    this->domainid = domainId;
-    this->domainname=domainName;
+    this->domainname = domainName;
 }

src/api/IPAPI.cpp

@@ -1,9 +1,5 @@
-//
-// Created by lukas on 18.06.19.
-//
-
 #include "api/IPAPI.h"
 
 std::string IPAPI::getGlobalIp() {
     return request("https://api.ipify.org");
-}
+}

src/api/TelegramAPI.cpp

@@ -1,13 +1,9 @@
-//
-// Created by lukas on 08.05.19.
-//
-
 #include "api/TelegramAPI.h"
 #include "Logger.h"
 
 #include <climits>
 
-int TelegramAPI::sendMessage(const std::string& text) {
+int TelegramAPI::sendMessage(const std::string &text) {
     Hashmap<std::string, std::string> args;
     args.add("chat_id", chatid);
     args.add("text", text);

src/main.cpp

@@ -1,15 +1,9 @@
-//
-// Created by lukas on 18.06.19.
-//
-
 #include "Version.h"
 #include "IPRefresher.h"
 #include "Logger.h"
 #include "Config.h"
 #include "api/IPAPI.h"
 
-#include <iostream>
-
 /**
  * application entry point
  */
@@ -28,7 +22,7 @@ int main(int argc, char *argv[]) {
             std::cout << "Version " << Version::VERSION << std::endl;
         } else if (firstarg == "-f" || firstarg == "--force") {
             IPRefresher ipr;
-            if (Config::readCredentials()) {
+            if (Config::readConfig()) {
                 ipr.checkIPAdress(true);
             } else {
                 std::cout << "incorrect credentials!" << std::endl;
@@ -40,7 +34,7 @@ int main(int argc, char *argv[]) {
             if (Config::validateConfig()) {
                 Logger::message("Config file is OK");
             } else {
-                Logger::warning("There are errors in config file!");
+                Logger::error("There are errors in config file!");
                 return -1;
             }
         } else if (firstarg == "-ip" || firstarg == "--currentip") {
@@ -52,7 +46,7 @@ int main(int argc, char *argv[]) {
     } else {
         IPRefresher ipr;
         Logger::message("starting check");
-        if (Config::readCredentials()) {
+        if (Config::readConfig()) {
             ipr.checkIPAdress(false);
         } else {
             std::cout << "incorrect credentials!" << std::endl;

tests/UnitTest.cpp

@@ -0,0 +1,30 @@
+//
+// Created by lukas on 06.05.20.
+//
+
+#include <FileLogger.h>
+#include <api/IPAPI.h>
+#include <climits>
+#include "gtest/gtest.h"
+
+/**
+ * Test if default ip is 0.0.0.0 when last ip file doesn't exist.
+ */
+TEST(ReadIp, testzeroIpIfNotExists) {
+    FileLogger logger;
+    std::string oldip = logger.readip();
+    ASSERT_EQ(oldip, "0.0.0.0");
+}
+/**
+ * Test if default ip is 0.0.0.0 when last ip file doesn't exist.
+ */
+TEST(IPAPI, testIpAPIcheckIPSyntax) {
+    IPAPI ipapi;
+    std::string ip = ipapi.getGlobalIp();
+    if (ip.find('.') == ULONG_MAX) {
+        // error when ip doesn't contain a .
+        ASSERT_TRUE(false);
+    } else {
+        ASSERT_TRUE(true);
+    }
+}