networkd: Drop all capabilities except a few we would like to keep

[people/ms/network.git] / src / networkd / daemon.c

/*#############################################################################
#                                                                             #
# IPFire.org - A linux based firewall                                         #
# Copyright (C) 2023 IPFire Network Development Team                          #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <stdlib.h>

#include <systemd/sd-bus.h>
#include <systemd/sd-daemon.h>
#include <systemd/sd-device.h>
#include <systemd/sd-event.h>

#include "bus.h"
#include "config.h"
#include "daemon.h"
#include "devmon.h"
#include "logging.h"
#include "zone.h"
#include "zones.h"

// Increase the receive buffer to 128 MiB
#define RCVBUF_SIZE						128 * 1024 * 1024

struct nw_daemon {
	int nrefs;

	struct nw_config* config;

	// Event Loop
	sd_event* loop;

	// DBus Connection
	sd_bus* bus;

	// udev Connection
	sd_device_monitor* devmon;

	// Zones
	struct nw_zones* zones;
};

static int __nw_daemon_terminate(sd_event_source* source, const struct signalfd_siginfo* si,
		void* data) {
	DEBUG("Received signal to terminate...\n");

	return sd_event_exit(sd_event_source_get_event(source), 0);
}

static int __nw_daemon_reload(sd_event_source* source, const struct signalfd_siginfo* si,
		void* data) {
	struct nw_daemon* daemon = (struct nw_daemon*)daemon;

	DEBUG("Received signal to reload...\n");

	// Reload the daemon
	nw_daemon_reload(daemon);

	return 0;
}

static int nw_daemon_setup_loop(struct nw_daemon* daemon) {
	int r;

	// Fetch a reference to the default event loop
	r = sd_event_default(&daemon->loop);
	if (r < 0) {
		ERROR("Could not setup event loop: %s\n", strerror(-r));
		return 1;
	}

	// Enable the watchdog
	r = sd_event_set_watchdog(daemon->loop, 1);
	if (r < 0) {
		ERROR("Could not activate watchdog: %s\n", strerror(-r));
		return 1;
	}

	// Listen for SIGTERM
	r = sd_event_add_signal(daemon->loop, NULL, SIGTERM|SD_EVENT_SIGNAL_PROCMASK,
		__nw_daemon_terminate, daemon);
	if (r < 0) {
		ERROR("Could not register handling SIGTERM: %s\n", strerror(-r));
		return 1;
	}

	// Listen for SIGINT
	r = sd_event_add_signal(daemon->loop, NULL, SIGINT|SD_EVENT_SIGNAL_PROCMASK,
		__nw_daemon_terminate, daemon);
	if (r < 0) {
		ERROR("Could not register handling SIGINT: %s\n", strerror(-r));
		return 1;
	}

	// Listen for SIGHUP
	r = sd_event_add_signal(daemon->loop, NULL, SIGHUP|SD_EVENT_SIGNAL_PROCMASK,
		__nw_daemon_reload, daemon);
	if (r < 0) {
		ERROR("Could not register handling SIGHUP: %s\n", strerror(-r));
		return 1;
	}

	return 0;
}

static int nw_daemon_load_config(struct nw_daemon* daemon) {
	int r;

	// Read configuration file
	r = nw_config_create(&daemon->config, CONFIG_DIR "/settings");
	if (r)
		return r;

	// Load zones
	r = nw_zones_load(&daemon->zones);
	if (r)
		return r;

	return r;
}

static int nw_start_device_monitor(struct nw_daemon* daemon) {
	int r;

	const char* subsystems[] = {
		"net",
		"ieee80211",
		"rfkill",
		NULL,
	};

	// Create a new connection to monitor any devices
	r = sd_device_monitor_new(&daemon->devmon);
	if (r < 0) {
		ERROR("Could not inititalize the device monitor: %m\n");
		return 1;
	}

	// Increase the receive buffer
	r = sd_device_monitor_set_receive_buffer_size(daemon->devmon, RCVBUF_SIZE);
	if (r < 0) {
		ERROR("Could not increase buffer size for the device monitor: %m\n");
		return 1;
	}

	// Filter for events for all relevant subsystems
	for (const char** subsystem = subsystems; *subsystem; subsystem++) {
		r = sd_device_monitor_filter_add_match_subsystem_devtype(
			daemon->devmon, *subsystem, NULL);
		if (r < 1) {
			ERROR("Could not add device monitor for the %s subsystem: %m\n", *subsystem);
			return 1;
		}
	}

	// Attach the device monitor to the event loop
	r = sd_device_monitor_attach_event(daemon->devmon, daemon->loop);
	if (r < 0) {
		ERROR("Could not attach the device monitor to the event loop: %m\n");
		return 1;
	}

	// Start processing events...
	r = sd_device_monitor_start(daemon->devmon, nw_devmon_handle_uevent, daemon);
	if (r < 0) {
		ERROR("Could not start the device monitor: %m\n");
		return 1;
	}

	return 0;
}

static int nw_daemon_setup(struct nw_daemon* daemon) {
	int r;

	// Read the configuration
	r = nw_daemon_load_config(daemon);
	if (r)
		return r;

	// Setup the event loop
	r = nw_daemon_setup_loop(daemon);
	if (r)
		return r;

	// Connect to the system bus
	r = nw_bus_connect(daemon->bus, daemon->loop, daemon);
	if (r)
		return r;

	// Connect to udev
	r = nw_start_device_monitor(daemon);
	if (r)
		return r;

	return 0;
}

int nw_daemon_create(struct nw_daemon** daemon) {
	int r;

	struct nw_daemon* d = calloc(1, sizeof(*d));
	if (!d)
		return 1;

	// Initialize reference counter
	d->nrefs = 1;

	// Setup the daemon
	r = nw_daemon_setup(d);
	if (r)
		goto ERROR;

	// Set the reference
	*daemon = d;

	return 0;

ERROR:
	nw_daemon_unref(d);

	return r;
}

static void nw_daemon_free(struct nw_daemon* daemon) {
	if (daemon->zones)
		nw_zones_unref(daemon->zones);
	if (daemon->config)
		nw_config_unref(daemon->config);
	if (daemon->bus)
		sd_bus_unref(daemon->bus);
	if (daemon->loop)
		sd_event_unref(daemon->loop);

	free(daemon);
}

struct nw_daemon* nw_daemon_ref(struct nw_daemon* daemon) {
	daemon->nrefs++;

	return daemon;
}

struct nw_daemon* nw_daemon_unref(struct nw_daemon* daemon) {
	if (--daemon->nrefs > 0)
		return daemon;

	nw_daemon_free(daemon);
	return NULL;
}

/*
	This function contains the main loop of the daemon...
*/
int nw_daemon_run(struct nw_daemon* daemon) {
	int r;

	// We are now ready to process any requests
	sd_notify(0, "READY=1\n" "STATUS=Processing requests...");

	// Launch the event loop
	r = sd_event_loop(daemon->loop);
	if (r < 0) {
		ERROR("Could not run the event loop: %s\n", strerror(-r));
		goto ERROR;
	}


	// Let systemd know that we are shutting down
	sd_notify(0, "STOPPING=1\n" "STATUS=Shutting down...");

	return 0;

ERROR:
	sd_notifyf(0, "ERRNO=%i", -r);

	return 1;
}

int nw_daemon_reload(struct nw_daemon* daemon) {
	DEBUG("Reloading daemon...\n");

	// XXX TODO

	return 0;
}

/*
	Zones
*/

struct nw_zones* nw_daemon_zones(struct nw_daemon* daemon) {
	return nw_zones_ref(daemon->zones);
}

struct nw_zone* nw_daemon_get_zone_by_name(struct nw_daemon* daemon, const char* name) {
	if (!daemon->zones)
		return NULL;

	return nw_zones_get_by_name(daemon->zones, name);
}