add a mingw profile

delete some toolchain cmake parts
install perl within docker container -- dependency of libssl
2021-04-09 15:46:53 +02:00 · 2021-03-15 20:45:31 +01:00 · 2021-03-15 20:39:51 +01:00 · 2021-03-15 20:26:22 +01:00 · 2021-03-15 20:09:14 +01:00 · 2021-03-15 20:04:53 +01:00
38 changed files with 982 additions and 394 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,17 +1,43 @@
-image: luki42/dynuiprefresher_build:latest
+include: '/Docker/Windows_Conan/.gitlab-ci.yml'
+
+image: conanio/gcc10

 stages:
+  - docker
  - build
+  - packageing

+cache:
+  paths:
+    - .conan/

-build:
+conan_linux:
  stage: build
+  before_script:
+    - conan profile new default --detect --force # Generates default profile detecting GCC and sets old ABI
+    - conan profile update settings.compiler.libcxx=libstdc++11 default  # Sets libcxx to C++11 ABI
+    - mkdir -p build # create build folder
+    - CONAN_SYSREQUIRES_MODE=enabled CONAN_SYSREQUIRES_SUDO=0 conan install . --build=missing -g cmake -if build
  script:
-    - cmake -S . -B build
+    - cmake -S . -B build -D WinBuild=OFF #cmake project
    - cd build
-    - make
-    - make package
+    - make -j4 #build
  artifacts:
    paths:
-      - "build/bin/*"
-      - "build/packages/*"
+      - build/bin/
+    expire_in: 1 days
+
+conan_windows:
+  stage: build
+  image: luki42/dynuiprefresher_build:conanbuild
+  before_script:
+    - mkdir -p build # create build folder
+    - CONAN_SYSREQUIRES_MODE=enabled CONAN_SYSREQUIRES_SUDO=0 conan install . --build=missing -g cmake -if build --profile mingw64.profile
+  script:
+    - cmake -S . -B build -D WinBuild=ON #cmake project
+    - cd build
+    - make -j4 #build
+  artifacts:
+    paths:
+      - build/bin/
+    expire_in: 1 days
--- a/CMakeLists.txt
+++ b/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")
-SET(PROJECT_VERSION 1.3.3)
-SET(CMAKE_CXX_STANDARD 17)
+project(dynuiprefresher DESCRIPTION "Dynu ip refresher" LANGUAGES)
+SET(PROJECT_VERSION 1.3.4)

 # CONFIGURATION
-SET(CMAKE_BUILD_TYPE Release) # manually SET build type (Release / Debug)
+SET(CMAKE_BUILD_TYPE Debug) # 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,161 +32,119 @@ 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)

    set(CMAKE_SYSTEM_NAME WindowsStore)
    set(CMAKE_SYSTEM_VERSION 10.0)
-    set(TOOLCHAIN_PREFIX x86_64-w64-mingw32) # x64 build toolchain
-    #set(TOOLCHAIN_PREFIX i686-w64-mingw32)

-    # cross compilers to use for C and C++
-    set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
-    set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
-    set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
-
-    # target environment on the build host system
-    set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
-
-
-    # modify default behavior of FIND_XXX() commands to
-    # search for headers/libs in the target environment and
-    # search for programs in the build host environment
-    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
-    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-    set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-
-    set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CSS_STANDARD_LIBRARIES}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
-    # currently libs are dynamically linked eg. dlls have to be copied to same folder
-    # todo link dynamically.
-    # maybe so: set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++ -static")
-    # or set(CMAKE_CXX_STANDARD_LIBRARIES -lcurl -lpthread -static-libgcc -static-libstdc++ -lcrypto -lssl -lws2_32 -static -DCURL_STATICLIB)
-    # or add_definitions(-DCURL_STATICLIB)
-
-    # windows config path is same as executable
-    set(CONFIG_PATH "./iprefresher.cfg")
+    # windows config path is in %appdata% folder of user
+    set(CONFIG_PATH "std::string(std::getenv(\"USERPROFILE\")) + \"\\\\AppData\\\\Roaming\\\\DynuIPrefresher\\\\\"")
+    # temp file is also stored in appdata folder
+    set(TempFilePath "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 linux config path
+    set(CONFIG_PATH "\"/etc/\"")
+    # set path of temp file
+    set(TempFilePath "\"/var/tmp/\"")
 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})
-    SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
-    # configure libcurl
-    FIND_PATH(CURL_INCLUDE_DIRS curl/curl.h /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/include/) # search for libconfig include headers
-    FIND_LIBRARY(CURL_LIBRARIES NAMES libcurl.dll.a HINTS /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/lib) # search for actual lib

-    message(STATUS "Using CURL include dir(s): ${CURL_INCLUDE_DIRS}")
-    message(STATUS "Using CURL lib(s): ${CURL_LIBRARIES}")
-    message(STATUS "")
+# include conan libraries
+include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+conan_basic_setup(TARGETS)

-    include_directories(${CURL_INCLUDE_DIRS} inc)
+include_directories(inc)

-    # configure libconfig
-    FIND_PATH(LIBCONFIG++_INCLUDE_DIRS libconfig.h++ /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/include/) # search for libconfig include headers
-    FIND_LIBRARY(LIBCONFIG++_LIBRARIES NAMES libconfig++.dll.a HINTS /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/lib) # search for actual lib
-
-    message(STATUS "Using LIBCONFIG++ include dir(s): ${LIBCONFIG++_INCLUDE_DIRS}")
-    message(STATUS "Using LIBCONFIG++ lib(s): ${LIBCONFIG++_LIBRARIES}")
-
-    include_directories(${LIBCONFIG++_INCLUDE_DIRS} inc)
-else ()
-    find_package(CURL REQUIRED)
-    if (CURL_INCLUDE_DIRS AND CURL_LIBRARIES)
-        message(STATUS "Found CURL version: ${CURL_VERSION_STRING}")
-        message(STATUS "Using CURL include dir(s): ${CURL_INCLUDE_DIRS}")
-        message(STATUS "Using CURL lib(s): ${CURL_LIBRARIES}")
-    else ()
-        message(FATAL_ERROR "Could not find CURL")
-    endif ()
-    include_directories(${CURL_INCLUDE_DIR} inc)
-
-    message("")
-    # libconfig
-    FIND_PACKAGE(libconfig++ REQUIRED)
-    if (LIBCONFIG++_INCLUDE_DIRS AND LIBCONFIG++_LIBRARY_DIRS)
-        message(STATUS "Found libconfig version: ${LIBCONFIG++_VERSION}")
-        message(STATUS "Using libconfig include dir(s): ${LIBCONFIG++_INCLUDE_DIRS}")
-        message(STATUS "Using libconfig lib(s): ${LIBCONFIG++_LIBRARY_DIRS}")
-    else ()
-        message(FATAL_ERROR "Could not find CURL")
-    endif ()
-    include_directories(${LIBCONFIG++_INCLUDE_DIRS} inc)
-endif ()
+# include the library headers created by conan
+include_directories(${CONAN_INCLUDE_DIRS})

 message("")

 #read sample config
-FILE(READ ${CMAKE_SOURCE_DIR}/config/iprefresher.cfg SAMPLECONFIG)
-#add version header
-FILE(WRITE ${CMAKE_SOURCE_DIR}/inc/Version.h
-        "\#pragma once
+FILE(READ ${CMAKE_SOURCE_DIR}/config/dynuiprefresher.cfg SAMPLECONFIG)
+#add StaticData header
+FILE(WRITE ${CMAKE_SOURCE_DIR}/inc/StaticData.h
+        "/**
+ * StaticData 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 {
+
+namespace StaticData {
  const std::string VERSION = \"${PROJECT_VERSION}\";
-  const std::string ConfigDir = \"${CONFIG_PATH}\";
+  const std::string TempFilePath = ${TempFilePath};
+  const std::string ConfigDir = ${CONFIG_PATH};
+  const std::string ConfName = \"${Application_Name}.cfg\";
  const std::string SAMPLECONFIG = R\"(${SAMPLECONFIG})\";
 }"
        )

+#define libraries with sources here
 add_library(api ${LIB_METHOD}
        src/api/API.cpp
        src/api/TelegramAPI.cpp
        src/api/DynuAPI.cpp
        src/api/IPAPI.cpp)

-add_library(logger ${LIB_METHOD}
-        src/FileLogger.cpp
-        src/Logger.cpp)
-
-
-SET(SOURCE
-        src/main.cpp
+add_library(libdynuiprefresher ${LIB_METHOD}
        src/IPRefresher.cpp
-        src/Config.cpp)
+        src/IpHelper.cpp
+        src/FileLogger.cpp
+        src/Logger.cpp
+        src/Config.cpp
+        src/CMDParser.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 CONAN_PKG::libcurl)

 # 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
+            COMPONENT ${Application_Name})
    # 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
+            COMPONENT ${Application_Name})
 ELSE ()
    # INSTALL to Windows SYSTEM #

    # install binary to current folder
-    set_target_properties(iprefresher PROPERTIES SUFFIX ".exe")
-    install(TARGETS iprefresher DESTINATION .)
-
-    # install .dll dependencies
-    # todo check if files exist...
-    install(FILES /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libcurl-4.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libssh2-1.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libstdc++-6.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libgcc_s_seh-1.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libcrypto-1_1-x64.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libssl-1_1-x64.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libwinpthread-1.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/zlib1.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libidn2-0.dll
-            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libconfig++-11.dll
-            DESTINATION .)
+    set_target_properties(${Application_Name} PROPERTIES SUFFIX ".exe")
+    install(
+            TARGETS ${Application_Name}
+            DESTINATION .
+            COMPONENT ${Application_Name})
 ENDIF ()

 if (${PACKAGING})
@ -201,11 +165,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)
@ -222,8 +190,19 @@ fi\n"
            message(STATUS "found rpm build executeable --> able to build rpm")
            SET(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")
            SET(CPACK_RPM_POST_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/postinst")
-            SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/lib/systemd/system" "/lib/systemd" "/lib" "/usr/local/bin" "/usr/local") # --> needed to not override existing folders
+            SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
+                    "/lib/systemd/system"
+                    "/lib/systemd"
+                    "/lib"
+                    "/usr/local/bin"
+                    "/usr/local") # --> not override existing folders
+
+            # dependency management tested with fedora!
            set(CPACK_RPM_PACKAGE_REQUIRES "libcurl,libconfig")
+            if (${GUI})
+                # append rpm GUI dependencies (qt5)
+                set(CPACK_RPM_PACKAGE_REQUIRES "${CPACK_RPM_PACKAGE_REQUIRES},qt5-qtbase")
+            endif ()
        else (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
            message(STATUS "not found rpm build tools --> not building rpm")
        endif (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
@ -233,7 +212,13 @@ fi\n"
            message(STATUS "found deb build tools --> able to build deb")
            SET(CPACK_GENERATOR "${CPACK_GENERATOR};DEB") # add deb generator
            set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_SOURCE_DIR}/postinst") # set post inst file
+
+            # dependency management tested with fedora!
            set(CPACK_DEBIAN_PACKAGE_DEPENDS "libcurl4,libconfig++9v5") # add debian dependencies
+            if (${GUI})
+                # append debian GUI dependencies (qt5)
+                set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS},qt5-default")
+            endif ()
        else (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
            message(STATUS "not found  deb build tools --> not building deb")
        endif (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
@ -248,17 +233,45 @@ fi\n"
        set(CPACK_GENERATOR NSIS)
        message(STATUS "Using NSIS Package build.")

-        set(CPACK_NSIS_testcomp_INSTALL_DIRECTORY /)
+        set(CPACK_NSIS_EXECUTABLES_DIRECTORY "DynuIpRefresher")
        set(CPACK_PACKAGE_INSTALL_DIRECTORY "DynuIpRefresher")
        SET(CPACK_NSIS_MODIFY_PATH ON)
+        set(CPACK_NSIS_MENU_LINKS
+                "${Application_Name}.exe" "DynuIpRefresher Console"
+                "${Application_Name}-gui.exe" "DynuIpRefresher GUI")
+
+        # varnames need uppercase strings
+        string(TOUPPER ${Application_Name} APPLICATION_NAME_UPPER)
+        # Define components and their display names
+        set (CPACK_COMPONENTS_ALL ${Application_Name} ${Application_Name}gui)
+        set (CPACK_COMPONENT_${APPLICATION_NAME_UPPER}_DISPLAY_NAME "Dynu IP Refresher Console")
+        set (CPACK_COMPONENT_${APPLICATION_NAME_UPPER}GUI_DISPLAY_NAME "Dynu IP Refresher GUI")
+
+        # Human readable component descriptions
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}_DESCRIPTION "An extremely useful application that makes use of MyLib")
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}GUI_DESCRIPTION "Static libraries used to build programs with MyLib")
+
+        # Define dependencies between components
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}GUI_DEPENDS ${Application_Name})
+
+        # Define groups
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}_GROUP "Runtime")
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}GUI_GROUP "Development")
+
+        set(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION "All of the tools you'll ever need to develop software")
+
+        # Define NSIS installation types
+        set(CPACK_ALL_INSTALL_TYPES Full Developer)
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}_INSTALL_TYPES Developer Full)
+        set(CPACK_COMPONENT_${APPLICATION_NAME_UPPER}GUI_INSTALL_TYPES Full)
    ENDIF ()

    INCLUDE(CPack)

    add_custom_target(build-packages
            "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" --target package
-            DEPENDS ${PROJECT_NAME}
-            COMMENT "Packing ${PROJECT_NAME}")
+            DEPENDS ${Application_Name}
+            COMMENT "Packing ${Application_Name}")
    message("")
 ENDIF ()

@ -285,4 +298,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 ()
--- a/Docker/Linux/Dockerfile
+++ b/Docker/Linux/Dockerfile
@ -0,0 +1,19 @@
+FROM gcc:latest
+MAINTAINER luki42
+
+RUN \
+    \
+    # Install texlive
+    echo "instaling cmake" && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends cmake libgtest-dev && \
+    echo "installing build dependencies" && \
+    apt-get install -y --no-install-recommends libcurl4-openssl-dev libconfig++-dev && \
+    echo "installing packaging tools" && \
+    apt-get install -y --no-install-recommends dpkg rpm && \
+    # clean up
+    apt-get clean
+
+# Expose /home as workin dir
+WORKDIR /home
+VOLUME ["/home"]
--- a/Docker/Linux_Conan/.gitlab-ci.yml
+++ b/Docker/Linux_Conan/.gitlab-ci.yml
@ -0,0 +1,23 @@
+
+# trigger docker rebuild if changes where made
+docker_linux:
+  stage: docker
+  image: docker:latest
+  tags:
+    - dind
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
+  variables:
+    DOCKER_HOST: tcp://docker:2375/
+    DOCKER_DRIVER: overlay2
+    # See https://github.com/docker-library/docker/pull/166
+    DOCKER_TLS_CERTDIR: ""
+  script:
+    - docker build -t luki42/dynuiprefresher_build:conanbuild Docker/Linux_Conan
+    - docker login -p $DockerPWD -u luki42
+    - docker push luki42/dynuiprefresher_build:conanbuild
+  only:
+    changes:
+      - Docker/Linux_Conan/*
--- a/Docker/Linux_Conan/Dockerfile
+++ b/Docker/Linux_Conan/Dockerfile
@ -0,0 +1,9 @@
+FROM mwaeckerlin/mingw:latest
+
+COPY ./build.sh /tmp/
+
+RUN bash /tmp/build.sh
+
+# Expose /home as workin dir
+WORKDIR /home
+VOLUME ["/home"]
--- a/Docker/Linux_Conan/build.sh
+++ b/Docker/Linux_Conan/build.sh
@ -0,0 +1,23 @@
+#!/bin/bash
+
+apt-get update
+apt-get install cmake python3-pip -y -qq
+pip3 install conan
+
+git clone https://gitlab.heili.eu/lukas/dynuiprefresher.git
+cd dynuiprefresher || exit
+git checkout conansupport
+
+conan profile new default --detect --force # Generates default profile detecting GCC and sets old ABI
+conan profile update settings.compiler.libcxx=libstdc++11 default  # Sets libcxx to C++11 ABI
+mkdir -p build # create build folder
+CONAN_SYSREQUIRES_MODE=enabled CONAN_SYSREQUIRES_SUDO=0 conan install . --build=missing
+
+
+# cleanup
+conan remove "*" -s -b -f
+
+cd ..
+rm -Rf ./dynuiprefresher
+rm -rf /var/lib/apt/lists/*
+rm /tmp/build.sh
--- a/Docker/Windows/Dockerfile
+++ b/Docker/Windows/Dockerfile
@ -0,0 +1,20 @@
+FROM fedora:33
+MAINTAINER luki42
+
+RUN \
+    \
+    # Install texlive
+    echo "instaling cmake" && \
+    dnf install -y mingw64-gcc-c++ mingw64-curl-static mingw64-qt5-qtbase wget cmake make tar xz mingw32-nsis gtest gtest-devel && \
+    wget http://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libconfig-1.7.2-1-any.pkg.tar.xz && \
+    tar -xf mingw-w64-x86_64-libconfig-1.7.2-1-any.pkg.tar.xz && \
+    mv ./mingw64/bin/* /usr/x86_64-w64-mingw32/sys-root/mingw/bin && \
+    mv ./mingw64/include/* /usr/x86_64-w64-mingw32/sys-root/mingw/include && \
+    mv ./mingw64/lib/*.a /usr/x86_64-w64-mingw32/sys-root/mingw/lib && \
+    mv ./mingw64/lib/cmake/* /usr/x86_64-w64-mingw32/sys-root/mingw/lib/cmake && \
+    rm -Rv mingw-w64-x86_64-libconfig-1.7.2-1-any.pkg.tar.xz mingw64 && \
+    #cleanup
+    dnf clean dbcache && dnf clean packages
+# Expose /home as workin dir
+WORKDIR /home
+VOLUME ["/home"]
--- a/Docker/Windows_Conan/.gitlab-ci.yml
+++ b/Docker/Windows_Conan/.gitlab-ci.yml
@ -0,0 +1,23 @@
+
+# trigger docker rebuild if changes where made
+docker_linux:
+  stage: docker
+  image: docker:latest
+  tags:
+    - dind
+  services:
+    - name: docker:dind
+      entrypoint: ["env", "-u", "DOCKER_HOST"]
+      command: ["dockerd-entrypoint.sh"]
+  variables:
+    DOCKER_HOST: tcp://docker:2375/
+    DOCKER_DRIVER: overlay2
+    # See https://github.com/docker-library/docker/pull/166
+    DOCKER_TLS_CERTDIR: ""
+  script:
+    - docker build -t luki42/dynuiprefresher_build:conanbuild Docker/Windows_Conan
+    - docker login -p $DockerPWD -u luki42
+    - docker push luki42/dynuiprefresher_build:conanbuild
+  only:
+    changes:
+      - Docker/Windows_Conan/*
--- a/Docker/Windows_Conan/Dockerfile
+++ b/Docker/Windows_Conan/Dockerfile
@ -0,0 +1,10 @@
+FROM fedora:33
+MAINTAINER luki42
+
+COPY ./build.sh /tmp/
+
+RUN bash /tmp/build.sh
+
+# Expose /home as workin dir
+WORKDIR /home
+VOLUME ["/home"]
--- a/Docker/Windows_Conan/build.sh
+++ b/Docker/Windows_Conan/build.sh
@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Install texlive
+echo "instaling cmake" && \
+dnf install -y mingw64-gcc-c++ cmake make mingw32-nsis gtest gtest-devel python3 python3-pip git perl
+#cleanup
+dnf clean dbcache && dnf clean packages
+
+# install conan
+pip3 install conan
+
+git clone https://gitlab.heili.eu/lukas/dynuiprefresher.git
+cd dynuiprefresher || exit
+git checkout conansupport
+
+mkdir -p build # create build folder
+CONAN_SYSREQUIRES_MODE=enabled CONAN_SYSREQUIRES_SUDO=0 conan install . --build=missing --profile mingw64.profile
+
+
+# cleanup
+conan remove "*" -s -b -f
+
+cd ..
+rm -Rf ./dynuiprefresher
+rm /tmp/build.sh
--- a/README.md
+++ b/README.md
@ -1,6 +1,8 @@
+[![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.
+There is also a GUI for Windows Users and beginners.

 ## Installation
 Download the latest Release at [Release_Page](https://github.com/Lukas-Heiligenbrunner/DynuIPRefresher/releases).
@ -8,11 +10,38 @@ 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
+```
+
+### GUI 
+
+You can also build the grapical user inteface if you want. 
+There you can manually trigger a refresh in a gui and set all the config parameters.
+
+Home Page:
+![couldn't load image](https://i.ibb.co/syDwWQg/Screenshot-20200608-104253.png)
+
+Config Page:
+![couldn't load image](https://i.ibb.co/89vnJXY/Screenshot-20200608-104308.png)


 ## Build
@ -68,6 +97,10 @@ cd into downloaded files and Generate makefiles:

 `make package`

+### GUI Build
+
+please use the predefined Docker-Image here: 
+[DockerHub](https://hub.docker.com/repository/docker/luki42/dynuiprefresher_build)


 ### Windows cross build
@ -82,5 +115,7 @@ Optional dependencies
 * NSIS Pack tool (for creating installer)
 * doxygen (for generating html doc)

-Some addition configuration of lib paths may be needed in CMakeList.txt. 
+The Simplest way to install all dependencies is the preconfigured Docker-Image:
+[DockerHub](https://hub.docker.com/repository/docker/luki42/dynuiprefresher_build)
+
 `make package` will pack it into a NSIS installer for Windows. 
--- a/conanfile.txt
+++ b/conanfile.txt
@ -0,0 +1,6 @@
+[requires]
+libcurl/7.72.0
+
+[generators]
+cmake
+
--- a/config/dynuiprefresher.cfg
+++ b/config/dynuiprefresher.cfg
@ -3,10 +3,10 @@
 # Lukas Heiligenbrunner

 ## DYNU API Config
-dynuapikey = ""
-domainid = ""
-domainname = ""
+dynuapikey=
+domainid=
+domainname=

 ## Telegram API Config (optional)
-#telegramApiKey = ""
-#chatId = ""
+#telegramApiKey=
+#chatId=
--- a/inc/CMDParser.h
+++ b/inc/CMDParser.h
@ -0,0 +1,23 @@
+//
+// Created by lukas on 15.03.21.
+//
+
+#pragma once
+
+class CMDParser {
+public:
+    class Arguments {
+    public:
+        // enable loop mode
+        bool loop = false;
+        bool force = false;
+        // enable currentIP mode
+        bool currentIP = false;
+    };
+
+    Arguments* parseArguments(int argc, char *argv[]);
+private:
+    Arguments args;
+
+    void processParameter(char *arg);
+};
--- a/inc/Config.h
+++ b/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,19 @@

 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
+    *
+    * @return success of config read
+    */
+    static bool readConfig();

    /**
-     * read configuration out of config file
+     * save back configuration to file
     *
-     * @return success of config read
+     * @return success of config write
     */
-    static bool readCredentials();
+    static bool saveConfig();

    /**
     * validate config file
@ -30,5 +32,85 @@ 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();
+
+    /**
+     * set all parameters without telegram support
+     *
+     * @param domainname Dynu Domain name
+     * @param dynuapikey Dynu api key
+     * @param domainid Dynu domain id
+     */
+    static void setValues(const std::string &domainname, const std::string &dynuapikey, const std::string &domainid);
+
+    /**
+     * set all parameters with telegram support
+     *
+     * @param domainname Dynu Domain name
+     * @param dynuapikey Dynu api key
+     * @param domainid Dynu domain id
+     * @param telegramApiKey Telegram api key
+     * @param chatId Telegram chat id
+     */
+    static void setValues(const std::string &domainname, const std::string &dynuapikey, const std::string &domainid,
+                          const std::string &telegramApiKey, const std::string &chatId);
+
 private:
+    /**
+     * private constructor --> don't allow instance of this class
+     */
+    Config() = default;
+
+    static void writeDefaultConfig();
+    static void setParam(const std::string key, const std::string value);
+
+    /**
+     * 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;
 };
--- a/inc/FileLogger.h
+++ b/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

--- a/inc/IPRefresher.h
+++ b/inc/IPRefresher.h
@ -1,25 +1,33 @@
-//
-// 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

-class IPRefresher {
-public:
+namespace IPRefresher {
+    /**
+     * Status return-codes for startUpService
+     */
+    namespace Status_Code {
+        const int SUCCESS = 1;
+        const int ERROR = -1;
+        const int ERROR_NO_INTERNET = -2;
+        const int NOREFRESH = 0;
+    }
+
    /**
     * refresh ip address on Dynu server
     */
-    void checkIPAdress(bool force);
-
-    /**
-     * default constructor
-     */
-    IPRefresher();
+    bool checkIPAdress(bool force);

    /**
     * start the service in loop mode
     * every 5 minutes the ip is checked an refreshed (needed for .service)
-     * @param loop true->loopmode on
     */
-    explicit IPRefresher(bool loop);
-};
+    void startUpService(int interval = 300);
+}
--- a/inc/IpHelper.h
+++ b/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(const std::string& ip);
+
+private:
+};
--- a/inc/Logger.h
+++ b/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

--- a/inc/api/API.h
+++ b/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);
--- a/inc/api/DynuAPI.h
+++ b/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);
-private:
-    std::string dynuapikey; // Dynu API key
+    void init(const std::string &dynuApiKey, const std::string &domainId, const std::string &domainName);

-    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;
 };
--- a/inc/api/Hashmap.h
+++ b/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

--- a/inc/api/IPAPI.h
+++ b/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
--- a/inc/api/TelegramAPI.h
+++ b/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
--- a/mingw64.profile
+++ b/mingw64.profile
@ -0,0 +1,28 @@
+toolchain=/usr/x86_64-w64-mingw32 # Adjust this path
+target_host=x86_64-w64-mingw32
+cc_compiler=gcc
+cxx_compiler=g++
+
+[env]
+CONAN_CMAKE_FIND_ROOT_PATH=$toolchain  # Optional, for CMake to find things in that folder
+CONAN_CMAKE_SYSROOT=$toolchain  # Optional, if we want to define sysroot
+CHOST=$target_host
+AR=$target_host-ar
+AS=$target_host-as
+RANLIB=$target_host-ranlib
+CC=$target_host-$cc_compiler
+CXX=$target_host-$cxx_compiler
+STRIP=$target_host-strip
+RC=$target_host-windres
+
+[settings]
+# We are cross-building to Windows
+os=Windows
+arch=x86_64
+compiler=gcc
+
+# Adjust to the gcc version of your MinGW package
+compiler.version=10
+compiler.libcxx=libstdc++11
+compiler.threads=posix
+build_type=Release
--- a/service/dynuiprefresher.service
+++ b/service/dynuiprefresher.service
--- a/src/CMDParser.cpp
+++ b/src/CMDParser.cpp
@ -0,0 +1,42 @@
+//
+// Created by lukas on 15.03.21.
+//
+
+#include <string>
+#include <iostream>
+#include <Logger.h>
+#include <StaticData.h>
+#include "CMDParser.h"
+
+CMDParser::Arguments* CMDParser::parseArguments(int argc, char **argv) {
+    for (int i = 1; i < argc; i++) {
+        this->processParameter(argv[i]);
+    }
+    return &args;
+}
+
+void CMDParser::processParameter(char *arg) {
+    const std::string param = std::string(arg);
+
+    if (param == "-h" || param == "--help") {
+        std::cout << "help page: " << std::endl << "[-h] [--help]  print this help page" << std::endl
+                  << "[-v] [--version] print the software version" << std::endl
+                  << "[-f] [--force] force refresh of ip" << std::endl
+                  << "[-l] [--loop] infinite loop to refresh ip every five minutes" << std::endl
+                  << "[-c] [--checkconfig] validate configuration" << std::endl
+                  << "[-ip] [--currentip] get current global ip" << std::endl
+                  << "[no argument] normal ip check and refresh" << std::endl;
+        exit(0);
+    } else if (param == "-v" || param == "--version") {
+        std::cout << "Version " << StaticData::VERSION << std::endl;
+        exit(0);
+    } else if (param == "-f" || param == "--force") {
+        args.force = true;
+    } else if (param == "-l" || param == "--loop") {
+        args.loop = true;
+    } else if (param == "-ip" || param == "--currentip") {
+        args.currentIP = true;
+    } else {
+        Logger::message("unknown argument: " + param + "!  -h for help");
+    }
+}
--- a/src/Config.cpp
+++ b/src/Config.cpp
@ -1,15 +1,12 @@
-//
-// Created by lukas on 11.02.20.
-//
-
 #include "Config.h"
 #include "Logger.h"
-#include "Version.h"
+#include "StaticData.h"

 #include <iostream>
 #include <cstring>
 #include <fstream>
-#include <libconfig.h++>
+#include <sys/stat.h>
+#include <sstream>

 std::string Config::dynuapikey;
 std::string Config::domainid; //id of the dynu domain
@ -18,92 +15,185 @@ std::string Config::domainname;
 std::string Config::telegramApiKey;
 std::string Config::chatId;

-bool Config::readCredentials() {
-    libconfig::Config cfg;
-    try {
-        // todo make dynamic here
-        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;
+bool Config::telegramSupport;

-        std::ofstream myfile;
-        myfile.open(Version::ConfigDir);
-        if (myfile.is_open()) {
-            myfile << Version::SAMPLECONFIG;
-            myfile.close();
-        } else {
-            std::cout << "error creating file" << std::endl;
-        }
-
-        return false;
-    }
-    catch (const libconfig::ParseException &pex) {
-        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
-                  << " - " << pex.getError() << std::endl;
+bool Config::readConfig() {
+    // Read from the text file
+    std::ifstream MyReadFile;
+    MyReadFile.open(std::string(StaticData::ConfigDir + StaticData::ConfName));
+    if (!MyReadFile) {
+        // file does not exist
+        writeDefaultConfig();
        return false;
    }

-    try {
-        // needed parameters
-        dynuapikey = (std::string) cfg.lookup("dynuapikey");
-        domainid = (std::string) cfg.lookup("domainid");
-        domainname = (std::string) cfg.lookup("domainname");
-        // optional parameters
-        telegramApiKey = (std::string) cfg.lookup("telegramApiKey");
-        chatId = (std::string) cfg.lookup("chatId");
-    }
-    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;
+    std::string line;
+    while (getline(MyReadFile, line)) {
+        // ignore line if it starts with #
+        if(line.rfind('#', 0) == 0 || line.empty()){
+            continue;
+        }
+
+        std::istringstream is_line(line);
+        std::string key;
+        if (std::getline(is_line, key, '=')) {
+            std::string value;
+            if (std::getline(is_line, value))
+                setParam(key, value);
        }
    }
+
+    // Close the file
+    MyReadFile.close();
+
    // check if needed values aren't empty
    return !(Config::dynuapikey.empty() || Config::domainid.empty() || Config::domainname.empty());
 }

-bool Config::validateConfig() {
-    libconfig::Config cfg;
-    try {
-        Logger::message("reading config file");
-        cfg.readFile(Version::ConfigDir.c_str());
-    }
-    catch (const libconfig::FileIOException &fioex) {
-        Logger::warning("config file doesn't exist or permission denied!");
-        return false;
-    }
-    catch (const libconfig::ParseException &pex) {
-        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
-                  << " - " << pex.getError() << std::endl;
-        return false;
-    }
-    Logger::message("Syntax and Permission is OK");
+bool Config::saveConfig() {
+    // todo save config
+    return false;
+}

-    try {
-        // needed parameters
-        if (((std::string) cfg.lookup("dynuapikey")).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.");
-            return false;
-        }
-        if (((std::string) cfg.lookup("domainname")).empty()) {
-            Logger::warning("required parameter domainname seems to be empty.");
-            return false;
-        }
-        // optional parameters
-        cfg.lookup("telegramApiKey");
-        cfg.lookup("chatId");
-    }
-    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;
-        }
-    }
+bool Config::validateConfig() {
+//    libconfig::Config cfg;
+//    try {
+//        Logger::message("reading config file: " + std::string(StaticData::ConfigDir + StaticData::ConfName));
+//        cfg.readFile(std::string(StaticData::ConfigDir + StaticData::ConfName).c_str());
+//    }
+//    catch (const libconfig::FileIOException &fioex) {
+//        Logger::warning("config file doesn't exist or permission denied!");
+//        return false;
+//    }
+//    catch (const libconfig::ParseException &pex) {
+//        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
+//                  << " - " << pex.getError() << std::endl;
+//        return false;
+//    }
+//    Logger::message("Syntax and Permission is OK");
+//
+//    try {
+//        // needed parameters
+//        if (((std::string) cfg.lookup("dynuapikey")).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.");
+//            return false;
+//        }
+//        if (((std::string) cfg.lookup("domainname")).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;
+}
+
+void Config::setValues(const std::string &domainname, const std::string &dynuapikey, const std::string &domainid) {
+    Config::domainname = domainname;
+    Config::dynuapikey = dynuapikey;
+    Config::domainid = domainid;
+}
+
+void Config::setValues(const std::string &domainname, const std::string &dynuapikey, const std::string &domainid,
+                       const std::string &telegramApiKey, const std::string &chatId) {
+    setValues(domainname, dynuapikey, domainid);
+    Config::telegramApiKey = telegramApiKey;
+    Config::chatId = chatId;
+}
+
+void Config::writeDefaultConfig() {
+    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(StaticData::ConfigDir.c_str(), &info) != 0) {
+        Logger::warning("The config folder doesn't exist. Trying to create it.");
+
+// mkdir command is different defined for windows
+#ifdef __unix
+        int check = mkdir(StaticData::ConfigDir.c_str(), 777);
+#else
+        int check = mkdir(StaticData::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(StaticData::ConfigDir + StaticData::ConfName);
+    if (myfile.is_open()) {
+        myfile << StaticData::SAMPLECONFIG;
+        myfile.close();
+    } else {
+        Logger::error("error creating file");
+    }
+}
+
+void Config::setParam(const std::string key, const std::string value) {
+    if (key == "dynuapikey")
+        dynuapikey = value;
+    else if (key == "domainid")
+        domainid = value;
+    else if (key == "domainname")
+        domainname = value;
+    else if (key == "telegramApiKey")
+        telegramApiKey = value;
+    else if (key == "chatId")
+        chatId = value;
+    else
+        Logger::warning("unkown key in config file: " + key);
+
+    if (!telegramApiKey.empty())
+        telegramSupport = true;
+}
--- a/src/FileLogger.cpp
+++ b/src/FileLogger.cpp
@ -1,16 +1,13 @@
-//
-// Created by lukas on 05.05.19.
-//
-
 #include "FileLogger.h"
+#include "IpHelper.h"
+#include "StaticData.h"

 #include <fstream>
 #include <iostream>
-#include <climits>

 void FileLogger::safeip(std::string ip) {
    std::ofstream out;
-    out.open("ip.txt", std::ios::out);
+    out.open(StaticData::TempFilePath + "temp-dynuiprefresher.txt", std::ios::out);

    out << ip;

@ -19,14 +16,14 @@ void FileLogger::safeip(std::string ip) {

 std::string FileLogger::readip() {
    std::ifstream in;
-    in.open("ip.txt", std::ios::in);
+    in.open(StaticData::TempFilePath + "temp-dynuiprefresher.txt", std::ios::in);

    std::string ip;

    in >> ip;

-    // when received ip has no : return 0.0.0.0
-    if (ip.find(':') == ULONG_MAX)
+    // when received ip has no . return 0.0.0.0
+    if (!IpHelper::isIpValid(ip))
        return "0.0.0.0";
    else
        return ip;
--- a/src/IPRefresher.cpp
+++ b/src/IPRefresher.cpp
@ -1,22 +1,17 @@
-//
-// Created by lukas on 02.08.19.
-//
-
 #include "IPRefresher.h"
 #include "FileLogger.h"
 #include "api/IPAPI.h"
 #include "api/DynuAPI.h"
 #include "api/TelegramAPI.h"
 #include "Config.h"
-#include "Version.h"
+#include "StaticData.h"
+#include "IpHelper.h"

-#include <string>
 #include <chrono>
 #include <thread>
 #include <Logger.h>
-#include <climits>

-void IPRefresher::checkIPAdress(bool force) {
+bool IPRefresher::checkIPAdress(bool force) {
    FileLogger logger;

    IPAPI ipapi;
@ -25,48 +20,52 @@ 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) {
+        return Status_Code::ERROR_NO_INTERNET;
+    } else if (!IpHelper::isIpValid(ip)) {
        // error when ip doesn't contain a :
        Logger::warning("an error occured when getting the global ip");
+        return Status_Code::ERROR;
    } else {
        std::string oldip = logger.readip();

        if (oldip == ip && !force) {
            Logger::message("no change -- ip: " + ip);
+            return Status_Code::NOREFRESH;
        } else {
            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!");
+                return Status_Code::ERROR;
            }

            logger.safeip(ip);
+            return result ? Status_Code::SUCCESS : Status_Code::ERROR;
        }
    }
 }

-IPRefresher::IPRefresher() = default;
+void IPRefresher::startUpService(int interval) {
+    Logger::message("startup of service");
+    Logger::message("Version: " + StaticData::VERSION);

-IPRefresher::IPRefresher(bool loop) {
-    if (loop) {
-        Logger::message("startup of service");
-        Logger::message("Version: " + Version::VERSION);
-        if (Config::readCredentials()) {
-            while (true) {
-                Logger::message("starting check");
-                checkIPAdress(false);
-                std::this_thread::sleep_for(std::chrono::milliseconds(300000));
-            }
+    while (true) {
+        Logger::message("starting check");
+        if (Config::readConfig()) {
+            checkIPAdress(false);
        } else {
            std::cout << "incorrect credentials!" << std::endl;
        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(interval * 1000));
    }
 }
--- a/src/IpHelper.cpp
+++ b/src/IpHelper.cpp
@ -0,0 +1,7 @@
+#include <regex>
+#include "IpHelper.h"
+
+bool IpHelper::isIpValid(const std::string& ip) {
+    const std::regex rgx(R"(^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$)");
+    return (std::regex_match(ip, rgx));
+}
--- a/src/Logger.cpp
+++ b/src/Logger.cpp
@ -1,7 +1,3 @@
-//
-// Created by lukas on 26.10.19.
-//
-
 #include "Logger.h"

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

 #include <sstream>
--- a/src/api/DynuAPI.cpp
+++ b/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 -1;
-    } else {
-        return 1;
-    }
+    return (dynurepl == "{\"statusCode\":200}");
 }

-void DynuAPI::init(const std::string& dynuApiKey, const std::string& domainId, const std::string& domainName) {
-    this->dynuapikey=dynuApiKey;
-    this->domainid=domainId;
-    this->domainname=domainName;
+void DynuAPI::init(const std::string &dynuApiKey, const std::string &domainId, const std::string &domainName) {
+    this->dynuapikey = dynuApiKey;
+    this->domainid = domainId;
+    this->domainname = domainName;
 }
--- a/src/api/IPAPI.cpp
+++ b/src/api/IPAPI.cpp
@ -1,9 +1,11 @@
-//
-// Created by lukas on 18.06.19.
-//
-
+#include <IpHelper.h>
+#include <Logger.h>
 #include "api/IPAPI.h"

 std::string IPAPI::getGlobalIp() {
-    return request("https://api.ipify.org");
-}
+    const std::string ip = request("https://api.ipify.org");
+    if(!IpHelper::isIpValid(ip))
+        Logger::warning("no valid ip returned from ipapi");
+
+    return ip;
+}
--- a/src/api/TelegramAPI.cpp
+++ b/src/api/TelegramAPI.cpp
@ -1,13 +1,7 @@
-//
-// 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);
@ -16,8 +10,8 @@ int TelegramAPI::sendMessage(const std::string& text) {

    std::string reply = request("https://api.telegram.org/bot" + apikey + "/sendmessage", false, args, headers);

-    if (reply.find("\"error_code\"") != ULONG_MAX) {
-        Logger::error("failed to refresh the ip (Dynu API)");
+    if (reply.find("\"error_code\"") != SIZE_MAX) {
+        Logger::error("failed to send the Telegram Message");
        return -1;
    }
    return 1;
--- a/src/main.cpp
+++ b/src/main.cpp
@ -1,62 +1,33 @@
-//
-// Created by lukas on 18.06.19.
-//
-
-#include "Version.h"
+#include <CMDParser.h>
+#include <Logger.h>
 #include "IPRefresher.h"
-#include "Logger.h"
 #include "Config.h"
 #include "api/IPAPI.h"

-#include <iostream>
-
 /**
 * application entry point
 */
 int main(int argc, char *argv[]) {
-    if (argc > 1) {
-        std::string firstarg(argv[1]);
-        if (firstarg == "-h" || firstarg == "--help") {
-            std::cout << "help page: " << std::endl << "[-h] [--help]  print this help page" << std::endl
-                      << "[-v] [--version] print the software version" << std::endl
-                      << "[-f] [--force] force refresh of ip" << std::endl
-                      << "[-l] [--loop] infinite loop to refresh ip every five minutes" << std::endl
-                      << "[-c] [--checkconfig] validate configuration" << std::endl
-                      << "[-ip] [--currentip] get current global ip" << std::endl
-                      << "[no argument] normal ip check and refresh" << std::endl;
-        } else if (firstarg == "-v" || firstarg == "--version") {
-            std::cout << "Version " << Version::VERSION << std::endl;
-        } else if (firstarg == "-f" || firstarg == "--force") {
-            IPRefresher ipr;
-            if (Config::readCredentials()) {
-                ipr.checkIPAdress(true);
-            } else {
-                std::cout << "incorrect credentials!" << std::endl;
-            }
+    CMDParser parser;
+    CMDParser::Arguments *args = parser.parseArguments(argc, argv);

-        } else if (firstarg == "-l" || firstarg == "--loop") {
-            IPRefresher(true);
-        } else if (firstarg == "-c" || firstarg == "--checkconfig") {
-            if (Config::validateConfig()) {
-                Logger::message("Config file is OK");
-            } else {
-                Logger::warning("There are errors in config file!");
-                return -1;
-            }
-        } else if (firstarg == "-ip" || firstarg == "--currentip") {
-            IPAPI ipapi;
-            std::cout << "Current global IP: " << ipapi.getGlobalIp() << std::endl;
-        } else {
-            Logger::message("wrong arguments!  -h for help");
-        }
+    if (args->currentIP) {
+        IPAPI ipapi;
+        const std::string ip = ipapi.getGlobalIp();
+
+        std::cout << "Current global IP: " << ip << std::endl;
+        return 0;
+    }
+
+    // loop mode
+    if (args->loop)
+        IPRefresher::startUpService(true);
+
+    // default mode
+    if (Config::readConfig()) {
+        IPRefresher::checkIPAdress(args->force);
    } else {
-        IPRefresher ipr;
-        Logger::message("starting check");
-        if (Config::readCredentials()) {
-            ipr.checkIPAdress(false);
-        } else {
-            std::cout << "incorrect credentials!" << std::endl;
-        }
+        Logger::error("incorrect credentials!");
    }

    return 0;
--- a/tests/UnitTest.cpp
+++ b/tests/UnitTest.cpp
@ -0,0 +1,29 @@
+//
+// Created by lukas on 06.05.20.
+//
+
+#include <FileLogger.h>
+#include <api/IPAPI.h>
+#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('.') == SIZE_MAX) {
+        // error when ip doesn't contain a .
+        ASSERT_TRUE(false);
+    } else {
+        ASSERT_TRUE(true);
+    }
+}
Author	SHA1	Message	Date
lukas	366cc46ecf	add a mingw profile	2021-04-09 15:46:53 +02:00
lukas	87c9b932ff	delete some toolchain cmake parts install perl within docker container -- dependency of libssl	2021-03-15 20:45:31 +01:00
lukas	e01697f7ad	fix profile path	2021-03-15 20:39:51 +01:00
lukas	7f9d039f94	install git within container	2021-03-15 20:26:22 +01:00
lukas	38e38fb878	fix building of wrong docker image	2021-03-15 20:09:14 +01:00
lukas	d12817feae	fix /only/changes wrong path	2021-03-15 20:04:53 +01:00
lukas	5f65ca528f	custom doker image for conan-mingw	2021-03-15 20:03:26 +01:00
lukas	9d91779f15	use profile to target correct mingw toolchain	2021-03-15 19:35:10 +01:00
lukas	0679c0a5fe	create mingw docker image	2021-03-15 18:46:42 +01:00
lukas	916bdb7358	fix docker image	2021-03-15 18:31:46 +01:00
lukas	b5aa78a59f	drop dependency of libconfig and write own simple parser	2021-03-15 17:33:20 +01:00
lukas	d364bc2ed8	correct naming of libconfig package	2021-02-01 18:24:39 +01:00
lukas	1f2dabfa82	fix libconfig version tag	2021-02-01 18:12:05 +01:00
lukas	e4861adbc2	remove unneccessary files	2021-02-01 18:07:08 +01:00
lukas	17a3722d7a	drop gui support - cmake	2021-02-01 17:28:07 +01:00
Lukas Heiligenbrunner	2b00bc61cf	fix cleanup after conan build	2020-11-04 20:28:04 +01:00
Lukas Heiligenbrunner	0d5c7a61b4	cleanup conan packages and upload package to registry	2020-11-03 20:31:33 +01:00
Lukas Heiligenbrunner	eb66222304	set docker host var	2020-11-03 20:13:53 +01:00
Lukas Heiligenbrunner	3e8b00f23e	set some dind vars	2020-11-03 20:12:35 +01:00
Lukas Heiligenbrunner	826006dcba	add tag	2020-11-03 19:56:00 +01:00
Lukas Heiligenbrunner	3f4de8ec42	build correct path	2020-10-31 21:12:39 +01:00
Lukas Heiligenbrunner	220275a617	add conan docker image and build docker image only if changes where made in its config	2020-10-31 21:07:34 +01:00
Lukas Heiligenbrunner	deb54c4f3a	do not install system requirements	2020-10-31 17:33:39 +01:00
Lukas Heiligenbrunner	154b71f50f	force remote adds	2020-10-31 17:13:07 +01:00
Lukas Heiligenbrunner	bda51e6b24	force creation of profile even if cached	2020-10-31 17:11:27 +01:00
Lukas Heiligenbrunner	789e4c9458	create default profile	2020-10-31 17:02:23 +01:00
Lukas Heiligenbrunner	c904c0701c	home flag needs to be applied for whole script	2020-10-31 16:59:10 +01:00
Lukas Heiligenbrunner	be8299e294	custom conan dir	2020-10-31 16:50:23 +01:00
Lukas Heiligenbrunner	e9e63e1c27	include directory with headers created by conan	2020-10-31 15:44:43 +01:00
Lukas Heiligenbrunner	9bfddef920	build in one job	2020-10-31 11:57:49 +01:00
Lukas Heiligenbrunner	3d29ab4b17	use var for cache path	2020-10-31 11:33:58 +01:00
Lukas Heiligenbrunner	d4d9b13b20	use job artifacts to share cmake generated files between jobs	2020-10-31 11:14:48 +01:00
Lukas Heiligenbrunner	20bd14ad95	correct cmake dir	2020-10-30 19:41:14 +01:00
Lukas Heiligenbrunner	3e5ffff839	force using cmake generator and set build folder manually	2020-10-30 19:16:16 +01:00
Lukas Heiligenbrunner	37ba7dce21	create build folder only if not existing	2020-10-30 19:04:00 +01:00
Lukas Heiligenbrunner	05f3600613	add cleanup job	2020-10-16 19:16:41 +02:00
Lukas Heiligenbrunner	2e3e4986f6	no files outside build dir allowed	2020-10-16 19:11:17 +02:00
Lukas Heiligenbrunner	346875312b	artifacts for stages	2020-10-16 19:07:29 +02:00
Lukas Heiligenbrunner	ed08771107	seperate to stages	2020-10-16 19:03:05 +02:00
Lukas Heiligenbrunner	ad11f040f2	enable sysrequires	2020-10-16 18:54:27 +02:00
Lukas Heiligenbrunner	a81c69f833	correct folder	2020-10-16 18:50:06 +02:00
Lukas Heiligenbrunner	9de1729c52	correct folder	2020-10-16 18:45:25 +02:00
Lukas Heiligenbrunner	726009a379	not set compiler	2020-10-16 18:42:03 +02:00
Lukas Heiligenbrunner	d7fb231705	another build path	2020-10-16 18:37:37 +02:00
Lukas Heiligenbrunner	9a628d60f6	rm rest	2020-10-16 18:33:17 +02:00
Lukas Heiligenbrunner	40110b13ca	global image	2020-10-16 18:25:47 +02:00
Lukas Heiligenbrunner	b3da9b64fa	new default profile	2020-10-16 18:20:30 +02:00
Lukas Heiligenbrunner	fd14c07fe8	set correct compiler flag	2020-10-16 18:15:11 +02:00
Lukas Heiligenbrunner	819803835c	install recommeneded dependencies	2020-10-16 18:07:55 +02:00
Lukas Heiligenbrunner	a140f74119	do not install recommeneded dependencies	2020-10-16 18:02:55 +02:00
Lukas Heiligenbrunner	17c5a38a0c	no error if folder exists	2020-10-16 17:56:57 +02:00
Lukas Heiligenbrunner	d6564f5647	correct cmake folder and cache paths	2020-10-16 17:53:18 +02:00
Lukas Heiligenbrunner	1254466e66	install dev requirements	2020-10-16 17:45:16 +02:00
Lukas Heiligenbrunner	fda91c380f	use libconfig from bintray	2020-10-16 17:18:08 +02:00
Lukas Heiligenbrunner	2cbbc7fe92	add also bincrafters to conan init	2020-10-14 00:36:17 +02:00
Lukas Heiligenbrunner	f64ebed804	fix failing cmake script add repo to ci	2020-10-14 00:30:55 +02:00
Lukas Heiligenbrunner	36a945eb1d	qt as conan dependency	2020-10-13 01:01:45 +02:00
Lukas Heiligenbrunner	4a040d6a85	use conan to fetch dependencies	2020-10-12 02:14:42 +02:00
Lukas Heiligenbrunner	41a8e8e7e1	readd libconfig correct regex to proof correct api	2020-10-12 01:55:58 +02:00
lukas	e7cc041bc4	add conan file rm existing configparser	2020-10-11 00:31:44 +02:00
lukas	095eb5c0cd	fixed incorrect merge of branches	2020-06-08 11:17:08 +02:00
lukas	a231e6c852	improved gitlab ci	2020-06-08 11:03:08 +02:00
Lukas-Heiligenbrunner	8d688716eb	Merge pull request #12 from Lukas-Heiligenbrunner/GUI Gui	2020-06-08 10:55:28 +02:00
lukas	4b19ecf3c3	added dockerfiles and edited readme	2020-06-08 10:54:22 +02:00
lukas	85ba334c21	added options in nsis install what to install.	2020-05-26 19:59:23 +02:00
Lukas-Heiligenbrunner	2762605ca4	Merge branch 'master' into GUI	2020-05-26 18:04:16 +02:00
lukas	81de98bf6c	rename Version.h to StaticData.h new temp file path for windows and linux temp file now writeable on windows compare string find method with SIZE_MAX instead of ULONG_MAX	2020-05-26 16:51:29 +02:00
lukas	3f75484f77	improved inc directory inclusion	2020-05-22 21:58:51 +02:00
lukas	f4069d02bf	right naming in gitlab ci	2020-05-21 14:27:16 +02:00
lukas	ce4a3a830e	release version v1.3.4	2020-05-21 14:18:29 +02:00
Lukas-Heiligenbrunner	af4a9c8350	Merge pull request #20 from Lukas-Heiligenbrunner/servicebinarypackagesamename Servicebinarypackagesamename	2020-05-21 14:16:35 +02:00
lukas	86fd995923	some minor renamings edited README.md	2020-05-21 14:09:17 +02:00
lukas	12ff16dc8e	renamed service-binarayname and config file name to dynuiprefresher	2020-05-21 11:52:55 +02:00
lukas	ea648d5946	added usage info to readme	2020-05-21 11:38:39 +02:00
Lukas-Heiligenbrunner	8c0c888472	Merge pull request #19 from Lukas-Heiligenbrunner/configfilewriteable Configfilewriteable	2020-05-21 11:28:49 +02:00
Lukas-Heiligenbrunner	fed6d251be	Merge branch 'master' into configfilewriteable	2020-05-21 11:28:33 +02:00
lukas	ca47949a38	check if config folder exists if not create it right appdata folder for windows hosts seperate config path and config name in cmake header	2020-05-21 11:26:15 +02:00
lukas	8199fc2c1e	correct build of test targets correct upload of report.xml	2020-05-20 19:37:39 +02:00
lukas	998f3ea5e8	right xml export of unit test cases for test target	2020-05-20 19:25:37 +02:00
lukas	d8c3d4ffb8	correct build of gtests in one target with xml output	2020-05-19 23:57:16 +02:00
lukas	ede1afcce3	correct build dependencies for unit test	2020-05-19 21:50:43 +02:00
lukas	1239ae015a	right ci camke dependencies for win and unix build	2020-05-19 21:29:36 +02:00
lukas	5271a25cbc	use artifacts instead of cache	2020-05-19 21:13:53 +02:00
lukas	fb65ef98fa	new gitlab ci for windows build cmake- check if gtest is installed on build system validate compiler after setting of compiler paths	2020-05-19 20:58:18 +02:00
Lukas-Heiligenbrunner	da53941cba	enable and start iprefresher service automatically after package installation (#18 ) - dont terminate service if config not valid.	2020-05-19 16:35:57 +02:00
lukas	4344e7c118	added tabbed view new config page with ability to edit config file new features in config class - setting member variables new button locations in gui	2020-05-19 16:23:00 +02:00
lukas	a356bca964	install config in other folder win	2020-05-18 19:46:19 +02:00
lukas	268aa3a1ad	hide console window - windows gui right windows gui dll dependencies linux package qt dependencies for packaging	2020-05-18 17:18:41 +02:00
lukas	3be8203111	begin of gui implementations in cmake install script	2020-05-16 20:30:23 +02:00
lukas	b5b352f83d	namespace for IPRefresher instead of class	2020-05-15 13:57:09 +02:00
lukas	3b32f60190	added return codes for IPrefresher refresh method. error messages in gui.	2020-05-14 23:08:19 +02:00
Lukas Heiligenbrunner	0eea7095e0	added better thread management cross compilation features.	2020-05-10 18:10:44 +02:00
lukas	ab772aac55	further gui developments	2020-05-10 15:00:51 +02:00
lukas	c25996a925	first qt gui steps	2020-05-09 23:08:23 +02:00
lukas	826386e849	define cached files globally/ including last test job	2020-05-08 17:28:19 +02:00
lukas	25f32dc4f4	cache whole project between jobs	2020-05-08 17:23:19 +02:00
lukas	2b863c6050	keep data between stages	2020-05-08 17:20:11 +02:00
lukas	a43b730b53	multistaging ci	2020-05-08 17:17:20 +02:00
lukas	309aefee2e	added a build badge	2020-05-08 17:02:46 +02:00
lukas	713e7a1f95	everywhere same code header reformatings cdoc	2020-05-08 16:45:27 +02:00
Lukas Heiligenbrunner	12de026842	Update .gitlab-ci.yml	2020-05-07 18:08:31 +00:00
Lukas-Heiligenbrunner	463853dbd7	Unit test framework (#10 ) * add first Unit Test with gtest and cmake dependencies * optionally build tests or not added some realistic tests * added ci compatible run configuration * added test dependencies -lpthread -lm to work in debian correctly * added some docs and option infos	2020-05-07 19:58:16 +02:00
lukas	335bcf1259	wrong variable name	2020-05-07 16:19:59 +02:00
lukas	db4c71d7fe	don't use find_package for libconfig, no default package in debian/libconfig installation	2020-05-07 16:17:47 +02:00
lukas	ba4af36df0	* new class for IP utils * method to check telegram support out of config * getters in Config.cpp * lots of reformatings and cdoc	2020-05-07 14:54:40 +02:00