DEV Community: Mehmet YILMAZ

Manage Ubuntu Linux Networking Programmatically with Netplan and D-Bus in C/C++

Mehmet YILMAZ — Tue, 30 Jul 2024 15:08:49 +0000

When we need to manage network adapter settings programmatically, we often encounter the challenge of using system calls to override static configurations. These attempts frequently lead to panic and crashes in the network services. At best, we might temporarily achieve our objectives until the next reboot, and even then, a correct implementation is rare.

If DHCP enters the picture, things become even more complicated. In addition to handling other complexities, we might need to implement or interact with a DHCP client.

As we've all seen, getting sidetracked by unrelated and complex issues during development often leads to major setbacks and failures.

In light of these challenges, we need to consider alternative approaches. Given that network management is operated by OS-provided services, we should aim to communicate correctly with these services instead of attempting to take over their roles.

https://github.com/mehmet-yilmaz/netplan-dbus-example

PS: If you work on a remote host, remember that changing the network settings may cause the connection lost. Do not apply any changes to your active connection interface if you are not sure what are you doing.

How Do OS Services Communicate with Each Other?

Inter-Process Communication

Operating systems consist of multiple services and processes that need to work together smoothly. IPC is the communication layer that allows these services to exchange data and synchronize actions effectively.

What is D-Bus?

D-Bus (Desktop Bus) is a message-oriented bus system and Remote Procedure Call (RPC) mechanism in Linux that enables communication between different processes on the same machine. It is designed to be simple and lightweight, suitable for both desktop and embedded environments.

Key Features of D-Bus:

Message Passing: Processes can send and receive messages, including signals, method calls, and return values.
Service Registration: Processes can register services on the bus, making functionalities available to others.
Introspection: D-Bus supports dynamic discovery of services and their capabilities.
Security: Includes mechanisms for authenticating and authorizing messages.
Efficiency: Designed to be efficient in both performance and resource usage.
Using Netplan on Ubuntu
For this article, we will use Ubuntu Server 22.04 LTS and its default network configuration service, Netplan. However, you can choose any OS and network service that provides a D-Bus API.

What is Netplan?

Netplan is a tool that provides a high-level configuration interface for network settings using YAML files. It abstracts the network configuration by communicating with supported network services like NetworkManager and systemd-networkd.

For more information: Netplan Documentation

Netplan also provides a simple D-Bus API and a CLI example for communication with the Netplan service over D-Bus:

Netplan D-Bus API
CLI Example

How to use D-Bus configuration API

See also: Netplan D-Bus reference, busctl reference. Copy the current state from/{etc,run,lib}/netplan/*.yaml by…
netplan.readthedocs.io

DBus CLI Example:

Before diving in, please try the following CLI example to get the current configuration for ensuring that all services working correctly.

busctl is a DBus communication CLI tool already installed in the Ubuntu system, there are some other alternatives that you can install if needed.

We will use the following command to call the Config() method, which starts a session and returns the Netplan-DBus configuration path.

Netplan-DBus service runs on the System Session, so you will need sudo privileges to communicate with it.

sudo busctl call io.netplan.Netplan /io/netplan/Netplan io.netplan.Netplan Config

Expected output:

o "/io/netplan/Netplan/config/ULJIU0"

o represents the output type OBJECT_PATH and the ”/io/netplan/Netplan/config/ULJIU0" as value.

OBJECT_PATH value is a session-based dynamic value, we will do all the configuration with this path during the session, but it will be changed on the next session after the timeout or if you call the Config method again.

Now we can call the Get() method to this configuration path as busctl call io.netplan.Netplan [ConfigurationPath] io.netplan.Netplan.Config Get to read the current configuration as examples here.

sudo busctl call io.netplan.Netplan /io/netplan/Netplan/config/ULJIU0 io.netplan.Netplan.Config Get

Expected output depends on your existing network configuration differs:

s "network:\n  ethernets:\n    eth0:\n      dhcp4: true\n  renderer: networkd\n  version: 2\n"

s represents the output type STRING and the value is the string parse output of the Netplans .yaml current configuration file.

Now we can move to the programming.

PS: If you work on a remote host, remember that changing the network settings may cause the connection lost. Do not apply any changes to your active connection interface if you are not sure what are you doing.

Lets Coding…

After this introduction, we can focus on implementing this in our C++ Program.

Dependencies

There are different DBus libraries you can choose from. I prefer the dbus-cxx library because it provides the native C++ implementation with Smart pointers support.

Please take a look at the project: https://dbus-cxx.github.io

Installation of the dbus-cxx library on Ubuntu 22.04 LTS.

Install the pre-requirements

≥ C++17
cmake(≥3.8)
make
g++
libsig++(≥3.0)
expat
libdbus

sudo apt install build-essentials cmake libdbus-1-dev libexpat1-dev

git clone https://github.com/dbus-cxx/libsigc--3.0.git
cd libsigc--3.0
cd build
cmake ..
make install

Please refer to the documentation for your operation system.

dbus-cxx: dbus-cxx Library - dbus-cxx.github.io
Do not forget to link the library dbus-cxx to your compiler with -ldbus-cxx flag for using it.

Finally, we are ready to hands-on.

I will create a service class that will interface the Netplan-DBus API and a basic CLI to interact with.

Project Structure

netplan-dbus-example/
├─ netplan.service.hpp
├─ cli.class.hpp
├─ main.cpp

First of all, I will create the netplan.service.hpp file

#ifndef ___NETPLAN_DBUS_SERVICE_HPP___
#define ___NETPLAN_DBUS_SERVICE_HPP___

#include <memory>
#include <string>
#include <dbus-cxx-2.0/dbus-cxx.h>
#include <dbus-cxx-2.0/dbus-cxx/path.h>
#include <dbus-cxx-2.0/dbus-cxx/dispatcher.h>
#include <dbus-cxx-2.0/dbus-cxx/connection.h>
#include <dbus-cxx-2.0/dbus-cxx/objectproxy.h>
#include <dbus-cxx-2.0/dbus-cxx/methodproxybase.h>

class NetplanService
{
public:
    NetplanService()
    {
        this->m_path.clear(); // Ensure that it will return "True" when we call ".empty()" method as default to start a new session!
        this->setConfigurationFile();
        this->connect();
    };

    void connect()
    {
        try
        {
            this->m_dispatcher = DBus::StandaloneDispatcher::create();

            // Netplan DBus service runs on the System Bus.
            // For connecting to Netplan, we have to create a connection in the System Bus
            // !!! IMPORTANT: System Bus requires ROOT Privilages!!!
            this->m_connection = this->m_dispatcher->create_connection(DBus::BusType::SYSTEM);
            this->m_object_proxy = this->m_connection->create_object_proxy("io.netplan.Netplan", "/io/netplan/Netplan");

            this->m_path.clear(); // Ensure that it will return "True" when we call ".empty()" method as default to start a new session!
        }
        catch (const DBus::Error &err)
        {
            this->handleDBusError(err);
        }
    };

    // Confguration .yaml file will be stored and processed with this filename under the default netplan configuration folder.
    void setConfigurationFile(const char *filename = "dbus-test-config")
    {
        this->m_filename = filename;
    };

    const std::string configurationPath()
    {
        if (this->m_path.empty())
            this->initConfigurationPath();
        return this->m_path;
    };

    const std::string getConfiguration()
    {
        try
        {
            const std::string path = this->configurationPath();
            this->m_object_proxy->set_path(path);
            DBus::MethodProxy<std::string()> &Get = *(this->m_object_proxy->create_method<std::string()>("io.netplan.Netplan.Config", "Get"));
            return Get();
        }
        catch (const DBus::Error &err)
        {
            this->handleDBusError(err);
        }
    };

    const bool setConfiguration(const std::string &target, const std::string &value)
    {
        try
        {
            const std::string path = this->configurationPath();
            this->m_object_proxy->set_path(path);
            std::string config = target + "=" + value;
            DBus::MethodProxy<bool(std::string, std::string)> &Set = *(this->m_object_proxy->create_method<bool(std::string, std::string)>("io.netplan.Netplan.Config", "Set"));
            return Set(config, this->m_filename);
        }
        catch (const DBus::Error &err)
        {
            this->handleDBusError(err);
        }
    };
    bool tryConfiguration(const uint32_t &timeout)
    {
        try
        {
            const std::string path = this->configurationPath();
            this->m_object_proxy->set_path(path);
            DBus::MethodProxy<bool(uint32_t)> &Try = *(this->m_object_proxy->create_method<bool(uint32_t)>("io.netplan.Netplan.Config", "Try"));
            return Try(timeout);
        }
        catch (DBus::Error &err)
        {
            this->handleDBusError(err);
        };
    };
    bool applyConfiguration()
    {
        try
        {
            const std::string path = this->configurationPath();
            this->m_object_proxy->set_path(path);
            DBus::MethodProxy<bool()> &Apply = *(this->m_object_proxy->create_method<bool()>("io.netplan.Netplan.Config", "Apply"));
            return Apply();
        }
        catch (DBus::Error &err)
        {
            this->handleDBusError(err);
        };
    };

    bool cancelConfiguration()
    {
        try
        {
            const std::string path = this->configurationPath();
            this->m_object_proxy->set_path(path);
            DBus::MethodProxy<bool()> &Cancel = *(this->m_object_proxy->create_method<bool()>("io.netplan.Netplan.Config", "Cancel"));
            const bool result = Cancel();
            this->m_path.clear();
            return result;
        }
        catch (DBus::Error &err)
        {
            this->handleDBusError(err);
        };
    };

private:
    std::shared_ptr<DBus::Dispatcher> m_dispatcher{nullptr};
    std::shared_ptr<DBus::Connection> m_connection{nullptr};
    std::shared_ptr<DBus::ObjectProxy> m_object_proxy{nullptr};
    std::string m_path{NULL};
    std::string m_filename{NULL};

    void initConfigurationPath()
    {
        try
        {
            // Ensure that object path corrected!
            this->m_object_proxy->set_path("/io/netplan/Netplan");
            // Create a Method Proxy to represent Config Method of the Netplan-DBus API
            DBus::MethodProxy<DBus::Path()> &Config = *(this->m_object_proxy->create_method<DBus::Path()>("io.netplan.Netplan", "Config"));
            // Run the proxy method to start a new Session and get the Configuration path as a return value and assing it to the m_configuratoin_path
            this->m_path = Config();
        }
        catch (const DBus::Error &err)
        {
            this->handleDBusError(err);
        }
    };
    void handleDBusError(const DBus::Error &err)
    {
        // Reset the session in case of error
        this->m_path.clear();

        // Print out the error.
        printf("ERROR \n\tDBus Error: %s \n\tType: %s \n\tMessage: %s\n", err.name().c_str(), err.what().c_str(), err.message().c_str());
    };
};

#endif // !___NETPLAN_DBUS_SERVICE_HPP___

then the cli.hpp file;

#ifndef ___CLI_HPP___
#define ___CLI_HPP___

#include <iostream>
#include <stdio.h>
#include "netplan.service.hpp"

class Cli
{
public:
    Cli() {};
    void run()
    {
        this->m_running = true;
        while (this->m_running)
        {
            this->printmenu();
        }
    };
    void printmenu()
    {
        printf("\n------------MENU-------------\n");
        for (const auto &item : menu)
        {
            printf("\n%c \t %s", item.first, item.second.c_str());
        }
        printf("\nPlease Enter Your Selection: ");
        this->readmenu();
    };

    void readmenu()
    {
        char c;
        std::cin >> c;
        switch (c)
        {
        case 'P':
            this->configurationPath();
            break;
        case 'G':
            this->getConfiguration();
            break;
        case 'S':
            this->setMenu();
            break;
        case 'Q':
            this->stop();
            break;
        default:
            break;
        }
    };

private:
    std::atomic_bool m_running = true;
    std::unique_ptr<NetplanService>
        netplanService = std::make_unique<NetplanService>();
    std::map<const char, const std::string> menu{
        {'P', "Configuration Path"},
        {'G', "Get Configuration"},
        {'S', "Set Configuration"},
        {'Q', "Quit"}};

    void stop()
    {
        this->m_running = false;
    };

    void configurationPath()
    {
        const std::string path = this->netplanService->configurationPath();
        printf("\n\t\tConfigiration Path: %s", path.c_str());
    };

    void getConfiguration()
    {
        const std::string configuration = this->netplanService->getConfiguration();
        printf("\nConfiguration\n%s\n", configuration.c_str());
    };

    void setConfiguration(const std::string &target, const std::string &value)
    {
        this->netplanService->setConfiguration(target, value);
    };

    void setMenu()
    {
        printf("\n------------------");
        this->getConfiguration();
        printf("\n\tSet Configuration");
        printf("\n\tEnter the configuration target: ");
        std::string target;
        std::cin >> target;
        printf("\n\tEnter the configuration value: ");
        std::string value;
        std::cin >> value;
        this->setConfiguration(target, value);
    };

protected:
};

#endif // !___CLI_HPP___

and the main.cpp file

#include "cli.hpp"
int main(int argc, char *argv[])
{

    const auto cli = std::make_unique<Cli>();
    if (cli)
        cli->run();
    return 0;
}

Since the Netplan runs on the System Session, we have to run our application with sudo privileges

Running Application Output:

------------MENU-------------

G        Get Configuration
P        Configuration Path
Q        Quit
S        Set Configuration
Please Enter Your Selection:

Configuration Path Selection:

------------MENU-------------

G        Get Configuration
P        Configuration Path
Q        Quit
S        Set Configuration
Please Enter Your Selection: P

                Configiration Path: /io/netplan/Netplan/config/EF2OR2

Get Configuration Selection:

------------MENU-------------

G        Get Configuration
P        Configuration Path
Q        Quit
S        Set Configuration
Please Enter Your Selection: G

Configuration
network:
  version: 2
  ethernets:
    enxf8e43b893689:
      dhcp4: true
    eno1:
      dhcp4: true

Set Configuration:

------------MENU-------------

G        Get Configuration
P        Configuration Path
Q        Quit
S        Set Configuration
Please Enter Your Selection: S

------------------
Configuration
network:
  version: 2
  ethernets:
    enxf8e43b893689:
      dhcp4: true
    eno1:
      dhcp4: true


        Set Configuration
        Enter the configuration target:

Here we can test and change the interface.

I have plug a USB-ETH adaptor for testing, if you are not sure which interface you are working on, do not try this.

ethernets.enxf8e43b893689.dhcp4 value to false .

------------MENU-------------

G        Get Configuration
P        Configuration Path
Q        Quit
S        Set Configuration
Please Enter Your Selection: S

------------------
Configuration
network:
  version: 2
  ethernets:
    enxf8e43b893689:
      dhcp4: true
    eno1:
      dhcp4: true


        Set Configuration
        Enter the configuration target: ethernets.enxf8e43b893689.dhcp4

        Enter the configuration value: false

It will change the interface enxf8e43b893689.dhcp4 to false but since we do not apply this. It will not affect anything in this application.

Complete example could be inspected on github.
mehmet-yilmaz/netplan-dbus-example

This was all, you can implement your requirements and communicate with Netplan or any other service over DBus.

I hope this helps you.

Serving Static Files and Single Page Applications on Oat++ (OatPP)

Mehmet YILMAZ — Tue, 23 Jul 2024 21:16:57 +0000

Oat++(OatPP) is a lightweight C++ Web framework. Out of the box, it provides REST API with built-in JSON serialization/deserialization features, which could be interfaced with your DTOs.

It also offers various modules that could be easily added and used in your application in a plug-in manner.

Since the main concept of the framework is RestAPI, it does not provide static file serving as default. It means that you must implement your solution to serve your static resources over the Oat++ Web server.

Despite sounding a little scary, it is not difficult at all. With the help of the frameworks Oatpp::String::loadFromFile method, we can easily implement our solution.

Before getting started we can list the steps that we will follow below;

Create a public static folder and files
File Mime Content Type Mapping
Define Endpoints

1- Create a public static folder and files

This folder will be used to serve static sources and will be accessible over the HTTP Protocol. So we can store our HTML, JS, CSS files, images, etc.

I will create my folder directly under the project root folder and name it as public in my example. Create a simple HTML file, a simple JS file, a simple CSS file, a favicon, and an image to simulate the widely used content types in order the following folder tree.

Folder tree

ProjectRoot/
├─ public/
│  ├─ favicon.ico
│  ├─ index.html
│  ├─ index.js
│  ├─ style.css
│  ├─ images/
│  │  ├─ logo.svg

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="icon" href="favicon.ico">
    <script src="index.js"></script>
    <link rel="stylesheet" href="style.css">
    <title>Oat++ Static File Serving Example</title>
</head>
<body>
    <div class="container">
        <div class="header">
            <img src="images/logo.png" alt="Logo">
            <h1>
                Oat++
            </h1>
            <p id="counter"> </p>
        </div>
        <div class="main">
            <button id="clicker" onclick="onCount()">Count</button>
        </div>
        <div class="footer"></div>
    </div>
</body>
</html>

index.js

var iterator = 0;
var counter = document.getElementById("counter");
function onCount() {
  counter.innerText = iterator++;
  console.log("Counter Increased: ", iterator);
};

style.css

body {
  background-color: bisque;
  color: black;
}

.header {
display: block;
}

Images

An .ico file as a favicon, and an image as a logo.

favicon would be stored in the static folder according to my HTML file and logo under the images folder which is a sub-folder of the public.

2. File Mime Content Type Mapping

Web servers usually provide a public folder, like www where you can store your static resources via S/FTP, WebUI, SSH, etc.
Or you can set your dedicated folder as a static resources folder accessible over HTTP.

So, if you have an index.html file in your static folder, you can access it over HTTP via http://localhost:port/index.html. All the other files located in the static folder would be accessible with the same path structure as well. For example, we can access the logo.png file under the images folder via this URL: http://localhost:port/images/logo.png

This is what we are looking for, right? We are almost there.
We also need a content-type mapper to respond correctly with files regarding its extension.

I will shortly create a sample function that expects the path and finds the extension by easily looking after the last. in the path and return the correct content type.

To create a full mime content type, you can reference NGINX’s map linked below.
https://github.com/nginx/nginx/blob/master/conf/mime.types

std::string* getContentType(const std::string &path) {
  const size_t i = path.find_last_of(".");
  if (i != std::string::npos) {
    const std::string extension = path.substr(i+1); 
    if(extension == "html" || extension == "htm" || extension == "shtml")
      return "text/html";
    if (extension == "js")
      return "application/javascript";
    if (extension == "css")
      return "text/css";
    if (extension == "jpg" || extension == "jpg")
      return "image/jpeg";
    if (extension == "gif")
      return "image/gif";
    if (extension == "ico")
      return "image/x-icon";
    if (extension == "png")
      return "image/png";
    if (extension == "svg" || extension == "svgz")
      return "image/svg+xml";
  }
    return nullptr; // if the path has no "." or has unknow extension we can not find the correct mime as well.
};

3. Defining Endpoints

The best way of serving static files is by defining a wildcard endpoint at the end of the routes.

Open your last controller or better create one for static routes and add it to the router as the last controller to prevent any unexpected bypass of API endpoints.
I am working on async but you can easily refactor the code in your regular endpoint.

In the following example, we will accept the wildcard route and check;

We will respond with the index.html for route (/) endpoint.
Try to read the file, and respond with 404 in case of not found.
If we find the file, then check the content type regarding its extension and add the content-type header with its mapped mime in the response.

You can also change the code and respond with the index.html for not-found files to Single-Page Application compatibility.

static-controller

ENDPOINT_ASYNC("GET", "*", Wildcard)
  {
      ENDPOINT_ASYNC_INIT(Wildcard)
      Action act() override
      {
          std::string path = request->getPathTail();
          // Load the home page in case of no path, it means calling root like: http://localhost/
          if (path.empty()) {
             path = "index.html"; // This is my default home file, you can set your own home page as well.
          }
          // We will check the file if exist and send the index.html in case of not 
          auto file = oatpp::String::loadFromFile(path.c_srt());
          // Send 404 not found in case of no file
          OATPP_ASSERT_HTTP(file.get() != nullptr, Status::CODE_404, "File not found");

          // As file already found, we can search the content type
          const std::string* contentType = getContentType(path);

          // Creating the response
          auto response = this->controller->createResponse(Status::CODE_200, file);
          if(contentType != nullptr) // Add the content-type header only if we have a known mime
            res->putHeader(Header::CONTENT_TYPE, *contentType);
          return _return(response);
      };
  };

This is the basic implementation and simple example of serving static files over Oat++ and I hope will help you.

Installing and Using The OatPP (Oat++) Library

Mehmet YILMAZ — Mon, 22 Jul 2024 21:09:29 +0000

OatPP(Oat++) is an open-source lightweight C++ Web Framework.

OatPP is a well-structured, relatively easy-to-use, multithreaded, modern C++ web framework.

The learning curve is narrower and the project shares the same approach with all the modern language web frameworks like Node.JS, Go, Java, etc. which helps developers to adapt easily.

Project website: https://oatpp.io/

Github Repo: https://github.com/oatpp/oatpp

Although installing and building the Oat++ library is straightforward, the default installation folder structure can cause some dependency errors in gcc/g++ on (as I experienced) Linux systems.

You can follow the instructions to solve this issue whenever you face it.

1- Install pre-requirements
OatPP does not offer pre-built binaries. We must download the source code from the repository and compile it on the target computer. This process requires some dependencies, which we must install on our system before this compilation process.

apt install git cmake build-essential libatomic -y

2- Download the source code
Download the source code from the OatPP (Oat++) GitHub repository to any folder in your system. I prefer a temp folder for this purpose which we could delete completely after the installation.
Download the git repository in your preferred folder.

mkdir temp && cd temp
git clone https://github.com/oatpp/oatpp.git

3- Build the OatPP (Oat++) Library
Open the oatpp folder and create a build folder under this to collect the CMake build outputs. If you want to customize the building process please consider the OatPP (Oat++) CMake Options.

cd oatpp
mkdir build && cd build
cmake ..

4- Install the OatPP (Oat++) Library
Finally use make to start installation.

make install

This will complete the installation and, normally you are ready to use it including the header files to your project and link the library to your compiler.

If you have compiler errors in finding OatPP references like me, follow the next steps to change the system's static library and header files folder structures.

OatPP Installation script targets the /usr/local/include and /usr/local/lib folders as default but it uses version numbered root folder and deeply nested folder structures in the destination. Cause of this folder structure, header files in the library could not be found as default. We will bring the library files to the upper level in the folder structure to solve this problem.

Open the /usr/local/lib/oatpp-[version.number] folder and copy the oatpp folder under the /usr/local/lib folder with sudo previlages.
After copying the library folder, you can delete the bad structured library folder.

cd /usr/loca/lib/oatpp-[version.number]
sudo cp -R oatpp /usr/local/lib/

cd /usr/local/lib
sudo rm -R /usr/local/lib/oatpp-[version.number]

Open the /usr/local/include/oatpp-[version]/oatpp/ folder and copy the oatpp folder under the /usr/local/include/ folder with sudo previlages.
After copying the header folder, you can delete the bad structured header folder.

cd /usr/local/include/oatpp-[version.number]/oatpp/oatpp
sudo cp -R oatpp /usr/local/include/

cd /usr/local/include
sudo rm -R /usr/local/include/oatpp-[version.number]

This will solve the issue you face with “unknown reference” during the compilation.