subprojects/ncsid/src/net_config.cpp

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "net_config.h"

#include <linux/if.h>
#include <net/if_arp.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include <sdbusplus/bus.hpp>
#include <stdplus/fd/create.hpp>
#include <stdplus/fd/ops.hpp>
#include <stdplus/print.hpp>
#include <stdplus/util/string.hpp>

#include <cstdio>
#include <cstring>
#include <filesystem>
#include <format>
#include <thread>
#include <utility>
#include <variant>

/* Most of the code for interacting with DBus is from
 * phosphor-host-ipmid/utils.cpp
 */

namespace net
{

namespace
{

constexpr auto IFACE_ROOT = "/xyz/openbmc_project/network/";
constexpr auto MAC_FORMAT = "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx";
// 2 chars for every byte + 5 colons + Null byte
constexpr auto MAC_FORMAT_LENGTH = 6 * 2 + 5 + 1;
constexpr auto MAC_INTERFACE = "xyz.openbmc_project.Network.MACAddress";
constexpr auto NETWORK_SERVICE = "xyz.openbmc_project.Network";
constexpr auto PROP_INTERFACE = "org.freedesktop.DBus.Properties";

std::string format_mac(const mac_addr_t& mac)
{
    // 2 chars for every byte + 5 colons + Null byte
    char mac_str[MAC_FORMAT_LENGTH];
    snprintf(mac_str, sizeof(mac_str), MAC_FORMAT, mac.octet[0], mac.octet[1],
             mac.octet[2], mac.octet[3], mac.octet[4], mac.octet[5]);

    return std::string{mac_str};
}

} // namespace

PhosphorConfig::PhosphorConfig(const std::string& iface_name) :
    iface_name_{iface_name}, iface_path_{std::string(IFACE_ROOT) + iface_name},
    shared_host_mac_(std::experimental::nullopt),
    bus(sdbusplus::bus::new_default())
{}

int PhosphorConfig::get_mac_addr(mac_addr_t* mac)
{
    if (mac == nullptr)
    {
        stdplus::println(stderr, "mac is nullptr");
        return -1;
    }

    // Cache hit: we have stored host MAC.
    if (shared_host_mac_)
    {
        *mac = shared_host_mac_.value();
    }
    else // Cache miss: read from interface, cache it for future requests.
    {
        struct ifreq ifr = {};
        try
        {
            auto fd = stdplus::fd::socket(stdplus::fd::SocketDomain::INet6,
                                          stdplus::fd::SocketType::Datagram,
                                          stdplus::fd::SocketProto::IP);
            call_nic(fd, ifr, SIOCGIFHWADDR);
        }
        catch (const std::exception& ex)
        {
            stdplus::println(
                stderr,
                "Failed to get MAC Addr for Interface {} writing file: {}",
                iface_name_, ex.what());
            return -1;
        }
        std::copy_n(ifr.ifr_addr.sa_data, sizeof(*mac), mac->octet);
        shared_host_mac_ = *mac;
    }
    return 0;
}

void PhosphorConfig::call_nic(auto fd, struct ifreq& ifr, int op)
{
    std::copy_n(iface_name_.c_str(), iface_name_.size() + 1, ifr.ifr_name);
    fd.ioctl(op, &ifr);
}

int PhosphorConfig::set_mac_addr(const mac_addr_t& mac)
{
    std::variant<std::string> mac_value(format_mac(mac));
    struct ifreq ifr = {};
    short flags_copy;

    try
    {
        auto netdir = std::format("/run/systemd/network/00-bmc-{}.network.d",
                                  iface_name_);
        std::filesystem::create_directories(netdir);
        auto netfile = std::format("{}/60-ncsi-mac.conf", netdir);
        auto fd = stdplus::fd::open(
            netfile,
            stdplus::fd::OpenFlags(stdplus::fd::OpenAccess::WriteOnly)
                .set(stdplus::fd::OpenFlag::Create),
            0644);
        auto contents = std::format("[Link]\nMACAddress={}\n",
                                    std::get<std::string>(mac_value));
        stdplus::fd::writeExact(fd, contents);
    }
    catch (const std::exception& ex)
    {
        stdplus::println(stderr, "Failed to set MAC Addr `{}` writing file: {}",
                         std::get<std::string>(mac_value), ex.what());
        return -1;
    }
    try
    {
        auto fd = stdplus::fd::socket(stdplus::fd::SocketDomain::INet6,
                                      stdplus::fd::SocketType::Datagram,
                                      stdplus::fd::SocketProto::IP);
        // Try setting MAC Address directly without bringing interface down
        try
        {
            std::copy_n(mac.octet, 6, ifr.ifr_hwaddr.sa_data);
            call_nic(fd, ifr, SIOCSIFHWADDR);
        }
        catch (const std::exception& e)
        {
            // Regardless of error attempt to set MAC Address again after
            // bringing interface down
            stdplus::println(
                stderr,
                "Could not set MAC Address directly, retrying after bringing interface down, error = {}",
                e.what());
            try
            {
                // Read interface flags configuration and store (once interface
                // is brought down, existing state is lost)
                call_nic(fd, ifr, SIOCGIFFLAGS);
                flags_copy = ifr.ifr_flags;
                // set interface down
                ifr.ifr_flags &= ~IFF_UP;
                call_nic(fd, ifr, SIOCSIFFLAGS);
                // Wait for 1 milliseconds - sometimes interface is still
                // going down
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
                // set MAC Address
                ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
                std::copy_n(mac.octet, 6, ifr.ifr_hwaddr.sa_data);
                call_nic(fd, ifr, SIOCSIFHWADDR);
                // set interface up with the flags state prior to bringing
                // it down
                ifr.ifr_flags = flags_copy | IFF_UP;
                call_nic(fd, ifr, SIOCSIFFLAGS);
            }
            catch (const std::exception& e)
            {
                stdplus::println(
                    stderr, "Failed to set MAC Address {} writing file: {}",
                    std::get<std::string>(mac_value), e.what());
                return -1;
            }
        }
    }
    catch (const std::exception& e)
    {
        stdplus::println(stderr, "Error creating socket: {}", e.what());
        return -1;
    }
    stdplus::println(stderr, "Success setting Mac address for {}: {}",
                     iface_name_, std::get<std::string>(mac_value));
    shared_host_mac_ = std::experimental::nullopt;
    return 0;
}

int PhosphorConfig::set_nic_hostless(bool is_nic_hostless)
{
    // Ensure that we don't trigger the target multiple times. This is
    // undesirable because it will cause any inactive services to re-trigger
    // every time we run this code. Since the loop calling this executes this
    // code every 1s, we don't want to keep re-executing services. A fresh
    // start of the daemon will always trigger the service to ensure system
    // consistency.
    if (was_nic_hostless_ && is_nic_hostless == *was_nic_hostless_)
    {
        return 0;
    }

    static constexpr auto systemdService = "org.freedesktop.systemd1";
    static constexpr auto systemdRoot = "/org/freedesktop/systemd1";
    static constexpr auto systemdInterface = "org.freedesktop.systemd1.Manager";

    auto method = bus.new_method_call(systemdService, systemdRoot,
                                      systemdInterface, "StartUnit");
    if (is_nic_hostless)
    {
        method.append(
            stdplus::util::strCat("nic-hostless@", iface_name_, ".target"));
    }
    else
    {
        method.append(
            stdplus::util::strCat("nic-hostful@", iface_name_, ".target"));
    }

    // Specify --job-mode (see systemctl(1) for detail).
    method.append("replace");

    try
    {
        bus.call_noreply(method);
        was_nic_hostless_ = is_nic_hostless;
        return 0;
    }
    catch (const sdbusplus::exception::SdBusError& ex)
    {
        stdplus::println(stderr, "Failed to set systemd nic status: {}",
                         ex.what());
        return 1;
    }
}

} // namespace net