networkd: Store a reference to the daemon in zone

[people/ms/network.git] / src / networkd / zones.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 <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>

#include "daemon.h"
#include "logging.h"
#include "zone.h"
#include "zones.h"

struct nw_zones_entry {
	nw_zone* zone;

	// Link to the other entries
	STAILQ_ENTRY(nw_zones_entry) nodes;
};

struct nw_zones {
	nw_daemon* daemon;
	int nrefs;

	// Zone Entries
	STAILQ_HEAD(entries, nw_zones_entry) entries;

	// A counter of the zone entries
	unsigned int num;
};

static int nw_zones_create(nw_zones** zones, nw_daemon* daemon) {
	nw_zones* z = calloc(1, sizeof(*z));
	if (!z)
		return 1;

	// Store a reference to the daemon
	z->daemon = nw_daemon_ref(daemon);

	// Initialize the reference counter
	z->nrefs = 1;

	// Initialize entries
	STAILQ_INIT(&z->entries);

	// Reference the pointer
	*zones = z;

	return 0;
}

static void nw_zones_free(nw_zones* zones) {
	struct nw_zones_entry* entry = NULL;

	while (!STAILQ_EMPTY(&zones->entries)) {
		entry = STAILQ_FIRST(&zones->entries);

		// Dereference the zone
		nw_zone_unref(entry->zone);

		// Remove the entry from the list
		STAILQ_REMOVE_HEAD(&zones->entries, nodes);

		// Free the entry
		free(entry);
	}

	if (zones->daemon)
		nw_daemon_unref(zones->daemon);

	free(zones);
}

nw_zones* nw_zones_ref(nw_zones* zones) {
	zones->nrefs++;

	return zones;
}

nw_zones* nw_zones_unref(nw_zones* zones) {
	if (--zones->nrefs > 0)
		return zones;

	nw_zones_free(zones);
	return NULL;
}

static int nw_zones_add_zone(nw_zones* zones, nw_zone* zone) {
	// Allocate a new entry
	struct nw_zones_entry* entry = calloc(1, sizeof(*entry));
	if (!entry)
		return 1;

	// Reference the zone
	entry->zone = nw_zone_ref(zone);

	// Add it to the list
	STAILQ_INSERT_TAIL(&zones->entries, entry, nodes);

	// Increment the counter
	zones->num++;

	return 0;
}

static int nw_zones_load_filter(const struct dirent* path) {
	const char* fn = path->d_name;

	// Ignore everything starting with '.'
	if (*fn == '.')
		return 0;

	// Ignore anything that isn't a directory
	if (path->d_type != DT_DIR)
		return 0;

	return 1;
}

static int __nw_zones_load(nw_zones* zones) {
	struct dirent** paths = NULL;
	int n;
	int r = 0;

	nw_zone* zone = NULL;

	// Scan the zones directory
	n = scandir(CONFIG_DIR "/zones", &paths, nw_zones_load_filter, alphasort);
	if (n < 0) {
		ERROR("Could not load zones: %m\n");
		return 1;
	}

	DEBUG("Found %d zone(s)\n", n);

	// Load all zones
	for (int i = 0; i < n; i++) {
		const char* name = paths[i]->d_name;

		DEBUG("Loading zone '%s'...\n", name);

		// Create a new zone object
		r = nw_zone_create(&zone, zones->daemon, name);
		if (r)
			goto ERROR;

		// Store the zone
		r = nw_zones_add_zone(zones, zone);
		if (r) {
			nw_zone_unref(zone);
			goto ERROR;
		}

		nw_zone_unref(zone);
	}

ERROR:
	// Free paths
	if (paths) {
		for (int i = 0; i < n; i++) {
			free(paths[i]);
		}
		free(paths);
	}

	return r;
}

int nw_zones_load(nw_zones** zones, nw_daemon* daemon) {
	int r;

	// Create a new zones object
	r = nw_zones_create(zones, daemon);
	if (r)
		return r;

	// Load all zones
	r = __nw_zones_load(*zones);
	if (r)
		goto ERROR;

	return 0;

ERROR:
	nw_zones_unref(*zones);
	return r;
}

size_t nw_zones_num(nw_zones* zones) {
	struct nw_zones_entry* entry = NULL;
	size_t length = 0;

	// Count all zones
	STAILQ_FOREACH(entry, &zones->entries, nodes)
		length++;

	return length;
}

nw_zone* nw_zones_get_by_name(nw_zones* zones, const char* name) {
	struct nw_zones_entry* entry = NULL;

	STAILQ_FOREACH(entry, &zones->entries, nodes) {
		const char* __name = nw_zone_name(entry->zone);

		// If the name matches, return a reference to the zone
		if (strcmp(name, __name) == 0)
			return nw_zone_ref(entry->zone);
	}

	// No match found
	return NULL;
}

int nw_zones_bus_paths(nw_zones* zones, char*** paths) {
	struct nw_zones_entry* entry = NULL;
	char* path = NULL;

	// Allocate an array for all paths
	char** p = calloc(zones->num + 1, sizeof(*p));
	if (!p)
		return 1;

	unsigned int i = 0;

	// Walk through all zones
	STAILQ_FOREACH(entry, &zones->entries, nodes) {
		// Generate the bus path
		path = nw_zone_bus_path(entry->zone);
		if (!path)
			goto ERROR;

		// Append the bus path to the array
		p[i++] = path;
	}

	// Return pointer
	*paths = p;

	return 0;

ERROR:
	if (p) {
		for (char** e = p; *e; e++)
			free(*e);
		free(p);
	}

	return 1;
}