workflows/ci: add clang-format job

4 files changed, 264 insertions, 310 deletions

diff --git a/um/service/src/device.cpp b/um/service/src/device.cpp
index 870930f..2634a9a 100644
--- a/um/service/src/device.cpp
+++ b/um/service/src/device.cpp
@@ -8,108 +8,105 @@
 #include <Windows.h>
 
 #include <cstddef>
-
 #include <limits>
 #include <stdexcept>
 #include <string>
 
-namespace service
-{
-    namespace
-    {
-        Handle open_device(const std::string& path)
-        {
-            const auto raw = CreateFileA(
-                path.c_str(),
-                GENERIC_READ | GENERIC_WRITE,
-                0,
-                NULL,
-                OPEN_EXISTING,
-                FILE_ATTRIBUTE_NORMAL,
-                NULL);
+namespace service {
+namespace {
 
-            if (INVALID_HANDLE_VALUE == raw)
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
+Handle open_device(const std::string& path) {
+    const auto raw = CreateFileA(
+        path.c_str(),
+        GENERIC_READ | GENERIC_WRITE,
+        0,
+        NULL,
+        OPEN_EXISTING,
+        FILE_ATTRIBUTE_NORMAL,
+        NULL
+    );
 
-            return Handle(raw);
-        }
+    if (INVALID_HANDLE_VALUE == raw) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
     }
 
-    Device Device::open(const std::string& path)
-    {
-        return Device(open_device(path));
-    }
+    return Handle(raw);
+}
 
-    std::size_t Device::get_required_output_size(
-        Code code,
-        const void* in_buf,
-        std::size_t in_buf_size) const
-    {
-        DWORD nbreq;
+} // namespace
 
-        if (in_buf_size > std::numeric_limits<DWORD>::max())
-            throw std::range_error("input buffer size is too large");
+Device Device::open(const std::string& path) {
+    return Device(open_device(path));
+}
 
-        std::size_t nbwritten = DeviceIoControl(
-            handle,
-            code,
-            const_cast<void*>(in_buf),
-            static_cast<DWORD>(in_buf_size),
-            NULL,
-            0,
-            &nbreq,
-            NULL);
+std::size_t Device::get_required_output_size(
+    Code code,
+    const void* in_buf,
+    std::size_t in_buf_size
+) const {
+    DWORD nbreq;
 
-        if (0 == nbwritten)
-        {
-            const auto ec = GetLastError();
+    if (in_buf_size > std::numeric_limits<DWORD>::max())
+        throw std::range_error("input buffer size is too large");
 
-            switch (ec)
-            {
-                case ERROR_MORE_DATA:
-                    return nbreq;
+    std::size_t nbwritten = DeviceIoControl(
+        handle,
+        code,
+        const_cast<void*>(in_buf),
+        static_cast<DWORD>(in_buf_size),
+        NULL,
+        0,
+        &nbreq,
+        NULL
+    );
 
-                default:
-                    throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
-        }
+    if (0 == nbwritten) {
+        const auto ec = GetLastError();
 
-        return nbwritten;
+        switch (ec) {
+            case ERROR_MORE_DATA:
+                return nbreq;
+
+            default:
+                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+        }
     }
 
-    std::size_t Device::send_control_code(
-        Code code,
-        const void* in_buf,
-        std::size_t in_buf_size,
-        void* out_buf,
-        std::size_t out_buf_size) const
-    {
-        DWORD nbreq;
+    return nbwritten;
+}
 
-        if (in_buf_size > std::numeric_limits<DWORD>::max())
-            throw std::range_error("input buffer size is too large");
-        if (out_buf_size > std::numeric_limits<DWORD>::max())
-            throw std::range_error("output buffer size is too large");
+std::size_t Device::send_control_code(
+    Code code,
+    const void* in_buf,
+    std::size_t in_buf_size,
+    void* out_buf,
+    std::size_t out_buf_size
+) const {
+    DWORD nbreq;
 
-        std::size_t nbwritten = DeviceIoControl(
-            handle,
-            code,
-            const_cast<void*>(in_buf),
-            static_cast<DWORD>(in_buf_size),
-            out_buf,
-            static_cast<DWORD>(out_buf_size),
-            &nbreq,
-            NULL);
+    if (in_buf_size > std::numeric_limits<DWORD>::max())
+        throw std::range_error("input buffer size is too large");
+    if (out_buf_size > std::numeric_limits<DWORD>::max())
+        throw std::range_error("output buffer size is too large");
 
-        if (0 == nbwritten)
-        {
-            const auto ec = GetLastError();
-            throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-        }
+    std::size_t nbwritten = DeviceIoControl(
+        handle,
+        code,
+        const_cast<void*>(in_buf),
+        static_cast<DWORD>(in_buf_size),
+        out_buf,
+        static_cast<DWORD>(out_buf_size),
+        &nbreq,
+        NULL
+    );
 
-        return nbwritten;
+    if (0 == nbwritten) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
     }
+
+    return nbwritten;
 }
+
+} // namespace service
diff --git a/um/service/src/service.cpp b/um/service/src/service.cpp
index b7384ce..698a9d9 100644
--- a/um/service/src/service.cpp
+++ b/um/service/src/service.cpp
@@ -9,242 +9,203 @@
 
 #include <string>
 
-namespace service
-{
-    namespace
-    {
-        ServiceHandle open_service(
-            const ServiceManager& mgr,
-            const std::string& name)
-        {
-            const auto raw = OpenServiceA(
-                mgr,
-                name.c_str(),
-                SERVICE_ALL_ACCESS);
+namespace service {
+namespace {
 
-            if (NULL == raw)
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
+ServiceHandle open_service(const ServiceManager& mgr, const std::string& name) {
+    const auto raw = OpenServiceA(mgr, name.c_str(), SERVICE_ALL_ACCESS);
 
-            return raw;
-        }
+    if (NULL == raw) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
 
-        ServiceHandle install_service(
-            const ServiceManager& mgr,
-            const std::string& name,
-            const std::string& bin_path)
-        {
-            const auto raw = CreateServiceA(
-                mgr,
-                name.c_str(),
-                name.c_str(),
-                SERVICE_ALL_ACCESS,
-                SERVICE_KERNEL_DRIVER,
-                SERVICE_DEMAND_START,
-                SERVICE_ERROR_NORMAL,
-                bin_path.c_str(),
-                NULL,
-                NULL,
-                NULL,
-                NULL,
-                NULL);
+    return raw;
+}
 
-            if (NULL == raw)
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
+ServiceHandle install_service(
+    const ServiceManager& mgr,
+    const std::string& name,
+    const std::string& bin_path
+) {
+    const auto raw = CreateServiceA(
+        mgr,
+        name.c_str(),
+        name.c_str(),
+        SERVICE_ALL_ACCESS,
+        SERVICE_KERNEL_DRIVER,
+        SERVICE_DEMAND_START,
+        SERVICE_ERROR_NORMAL,
+        bin_path.c_str(),
+        NULL,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+    );
 
-            return raw;
-        }
+    if (NULL == raw) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
 
-        void start_service(const ServiceHandle& handle)
-        {
-            if (!StartService(handle, 0, NULL))
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
-        }
+    return raw;
+}
 
-        void stop_service(const ServiceHandle& handle)
-        {
-            SERVICE_STATUS service_status;
+void start_service(const ServiceHandle& handle) {
+    if (!StartService(handle, 0, NULL)) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
+}
 
-            if (!ControlService(handle, SERVICE_CONTROL_STOP, &service_status))
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
-        }
+void stop_service(const ServiceHandle& handle) {
+    SERVICE_STATUS service_status;
 
-        void uninstall_service(const ServiceHandle& handle)
-        {
-            if (!DeleteService(handle))
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
-        }
+    if (!ControlService(handle, SERVICE_CONTROL_STOP, &service_status)) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
+}
 
-        bool service_exists(
-            const ServiceManager& mgr,
-            const std::string& name)
-        {
-            const auto raw = OpenServiceA(
-                mgr,
-                name.c_str(),
-                SERVICE_QUERY_STATUS);
+void uninstall_service(const ServiceHandle& handle) {
+    if (!DeleteService(handle)) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
+}
 
-            if (NULL != raw)
-            {
-                ServiceHandle handle(raw);
-                return true;
-            }
+bool service_exists(const ServiceManager& mgr, const std::string& name) {
+    const auto raw = OpenServiceA(mgr, name.c_str(), SERVICE_QUERY_STATUS);
 
-            const auto ec = GetLastError();
+    if (NULL != raw) {
+        ServiceHandle handle(raw);
+        return true;
+    }
 
-            switch (ec)
-            {
-                case ERROR_SERVICE_DOES_NOT_EXIST:
-                    return false;
+    const auto ec = GetLastError();
 
-                default:
-                    throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
-        }
+    switch (ec) {
+        case ERROR_SERVICE_DOES_NOT_EXIST:
+            return false;
 
-        SERVICE_STATUS_PROCESS query_service_status(const ServiceHandle& handle)
-        {
-            SERVICE_STATUS_PROCESS status;
-            DWORD nbreq;
+        default:
+            throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
+}
 
-            const auto buf_ptr = reinterpret_cast<BYTE*>(&status);
-            const auto buf_size = sizeof(status);
+SERVICE_STATUS_PROCESS query_service_status(const ServiceHandle& handle) {
+    SERVICE_STATUS_PROCESS status;
+    DWORD nbreq;
 
-            if (!QueryServiceStatusEx(
-                handle, SC_STATUS_PROCESS_INFO, buf_ptr, buf_size, &nbreq))
-            {
-                const auto ec = GetLastError();
-                throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-            }
+    const auto buf_ptr = reinterpret_cast<BYTE*>(&status);
+    const auto buf_size = sizeof(status);
 
-            return status;
-        }
+    if (!QueryServiceStatusEx(handle, SC_STATUS_PROCESS_INFO, buf_ptr, buf_size, &nbreq)) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
+    }
 
-        DWORD query_service_state(const ServiceHandle& handle)
-        {
-            return query_service_status(handle).dwCurrentState;
-        }
+    return status;
+}
 
-        SERVICE_STATUS_PROCESS wait_for_service_state(
-            const ServiceHandle& handle,
-            const DWORD desired_state)
-        {
-            auto status = query_service_status(handle);
+DWORD query_service_state(const ServiceHandle& handle) {
+    return query_service_status(handle).dwCurrentState;
+}
 
-            DWORD old_timestamp = GetTickCount();
+SERVICE_STATUS_PROCESS wait_for_service_state(
+    const ServiceHandle& handle,
+    const DWORD desired_state
+) {
+    auto status = query_service_status(handle);
 
-            DWORD old_check_point = status.dwCheckPoint;
-            DWORD old_wait_hint = status.dwWaitHint;
+    DWORD old_timestamp = GetTickCount();
 
-            while (desired_state != status.dwCurrentState)
-            {
-                DWORD wait_time = old_wait_hint / 10;
+    DWORD old_check_point = status.dwCheckPoint;
+    DWORD old_wait_hint = status.dwWaitHint;
 
-                if (wait_time < 1000)
-                    wait_time = 1000;
-                else if (wait_time > 10000)
-                    wait_time = 10000;
+    while (desired_state != status.dwCurrentState) {
+        DWORD wait_time = old_wait_hint / 10;
 
-                Sleep(wait_time);
+        if (wait_time < 1000)
+            wait_time = 1000;
+        else if (wait_time > 10000)
+            wait_time = 10000;
 
-                status = query_service_status(handle);
+        Sleep(wait_time);
 
-                if (desired_state == status.dwCurrentState)
-                    break;
+        status = query_service_status(handle);
 
-                if (status.dwCheckPoint > old_check_point)
-                {
-                    old_timestamp = GetTickCount();
+        if (desired_state == status.dwCurrentState)
+            break;
 
-                    old_check_point = status.dwCheckPoint;
-                    old_wait_hint = status.dwWaitHint;
-                }
-                else if (GetTickCount() - old_timestamp > old_wait_hint)
-                {
-                    return status;
-                }
-            }
+        if (status.dwCheckPoint > old_check_point) {
+            old_timestamp = GetTickCount();
 
+            old_check_point = status.dwCheckPoint;
+            old_wait_hint = status.dwWaitHint;
+        } else if (GetTickCount() - old_timestamp > old_wait_hint) {
             return status;
         }
     }
 
-    Service Service::open(
-        const ServiceManager& mgr,
-        const std::string& name)
-    {
-        return open_service(mgr, name);
-    }
+    return status;
+}
 
-    Service Service::install(
-        const ServiceManager& mgr,
-        const std::string& name,
-        const std::string& bin_path)
-    {
-        return install_service(mgr, name, bin_path);
-    }
+} // namespace
 
-    bool Service::exists(
-        const ServiceManager& mgr,
-        const std::string& name)
-    {
-        return service_exists(mgr, name);
-    }
+Service Service::open(const ServiceManager& mgr, const std::string& name) {
+    return open_service(mgr, name);
+}
 
-    void Service::start() const
-    {
-        const auto state = query_service_state(handle);
+Service Service::install(
+    const ServiceManager& mgr,
+    const std::string& name,
+    const std::string& bin_path
+) {
+    return install_service(mgr, name, bin_path);
+}
 
-        switch (state)
-        {
-            case SERVICE_STOPPED:
-                break;
+bool Service::exists(const ServiceManager& mgr, const std::string& name) {
+    return service_exists(mgr, name);
+}
 
-            case SERVICE_STOP_PENDING:
-                wait_for_service_state(handle, SERVICE_STOPPED);
-                break;
+void Service::start() const {
+    const auto state = query_service_state(handle);
 
-            default:
-                return;
-        }
+    switch (state) {
+        case SERVICE_STOPPED:
+            break;
 
-        start_service(handle);
-        wait_for_service_state(handle, SERVICE_RUNNING);
+        case SERVICE_STOP_PENDING:
+            wait_for_service_state(handle, SERVICE_STOPPED);
+            break;
+
+        default:
+            return;
     }
 
-    void Service::stop() const
-    {
-        switch (query_service_state(handle))
-        {
-            case SERVICE_STOPPED:
-                return;
+    start_service(handle);
+    wait_for_service_state(handle, SERVICE_RUNNING);
+}
 
-            case SERVICE_STOP_PENDING:
-                wait_for_service_state(handle, SERVICE_STOPPED);
-                return;
-        }
+void Service::stop() const {
+    switch (query_service_state(handle)) {
+        case SERVICE_STOPPED:
+            return;
 
-        stop_service(handle);
-        wait_for_service_state(handle, SERVICE_STOPPED);
+        case SERVICE_STOP_PENDING:
+            wait_for_service_state(handle, SERVICE_STOPPED);
+            return;
     }
 
-    void Service::uninstall() const
-    {
-        stop();
-        uninstall_service(handle);
-    }
+    stop_service(handle);
+    wait_for_service_state(handle, SERVICE_STOPPED);
 }
+
+void Service::uninstall() const {
+    stop();
+    uninstall_service(handle);
+}
+
+} // namespace service
diff --git a/um/service/src/service_manager.cpp b/um/service/src/service_manager.cpp
index 48c6bfe..b0e58fe 100644
--- a/um/service/src/service_manager.cpp
+++ b/um/service/src/service_manager.cpp
@@ -7,18 +7,17 @@
 
 #include <Windows.h>
 
-namespace service
-{
-    ServiceManager ServiceManager::open()
-    {
-        const auto raw = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
+namespace service {
 
-        if (NULL == raw)
-        {
-            const auto ec = GetLastError();
-            throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
-        }
+ServiceManager ServiceManager::open() {
+    const auto raw = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 
-        return ServiceHandle(raw);
+    if (NULL == raw) {
+        const auto ec = GetLastError();
+        throw windows_error::make(ec, __FILE__, __LINE__, __FUNCTION__);
     }
+
+    return ServiceHandle(raw);
 }
+
+} // namespace service
diff --git a/um/service/src/windows_error.cpp b/um/service/src/windows_error.cpp
index c228536..c6cca1e 100644
--- a/um/service/src/windows_error.cpp
+++ b/um/service/src/windows_error.cpp
@@ -9,34 +9,31 @@
 
 #include <string>
 
-namespace service
-{
-    namespace windows_error
-    {
-        std::string Category::message(int code) const
-        {
-            char* buf_ptr;
+namespace service {
+namespace windows_error {
 
-            const auto nbwritten = FormatMessageA(
-                FORMAT_MESSAGE_ALLOCATE_BUFFER
-                    | FORMAT_MESSAGE_FROM_SYSTEM
-                    | FORMAT_MESSAGE_IGNORE_INSERTS,
-                NULL,
-                code,
-                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                reinterpret_cast<char*>(&buf_ptr),
-                0,
-                NULL);
+std::string Category::message(int code) const {
+    char* buf_ptr;
 
-            if (0 == nbwritten)
-            {
-                LocalFree(buf_ptr);
-                return "Couldn't format the error message";
-            }
+    const auto nbwritten = FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,
+        code,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        reinterpret_cast<char*>(&buf_ptr),
+        0,
+        NULL
+    );
 
-            std::string str(buf_ptr, nbwritten - 2);
-            LocalFree(buf_ptr);
-            return str;
-        }
+    if (0 == nbwritten) {
+        LocalFree(buf_ptr);
+        return "Couldn't format the error message";
     }
+
+    std::string str(buf_ptr, nbwritten - 2);
+    LocalFree(buf_ptr);
+    return str;
 }
+
+} // namespace windows_error
+} // namespace service