libnetwork: Initialise netlink connection when initialising context

[network.git] / src / libnetwork / libnetwork.c

/*#############################################################################
#                                                                             #
# IPFire.org - A linux based firewall                                         #
# Copyright (C) 2017 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 <ctype.h>
#include <errno.h>
#include <netlink/genl/ctrl.h>
#include <netlink/genl/genl.h>
#include <netlink/netlink.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>

#include <network/libnetwork.h>
#include <network/logging.h>
#include "libnetwork-private.h"

struct network_ctx {
	int refcount;

	// Logging
	void (*log_fn)(struct network_ctx* ctx,
		int priority, const char *file, int line, const char *fn,
		const char *format, va_list args);
	int log_priority;

	// Netlink
	struct nl_sock* nl_socket;
	int nl80211_id;
};

void network_log(struct network_ctx* ctx,
		int priority, const char* file, int line, const char* fn,
		const char* format, ...) {
	va_list args;

	va_start(args, format);
	ctx->log_fn(ctx, priority, file, line, fn, format, args);
	va_end(args);
}

static void log_stderr(struct network_ctx* ctx,
		int priority, const char* file, int line, const char* fn,
		const char* format, va_list args) {
	fprintf(stderr, "libnetwork: %s: ", fn);
	vfprintf(stderr, format, args);
}

static int log_priority(const char* priority) {
	char *endptr;

	int prio = strtol(priority, &endptr, 10);

	if (endptr[0] == '\0' || isspace(endptr[0]))
		return prio;

	if (strncmp(priority, "err", 3) == 0)
		return LOG_ERR;

	if (strncmp(priority, "info", 4) == 0)
		return LOG_INFO;

	if (strncmp(priority, "debug", 5) == 0)
		return LOG_DEBUG;

	return 0;
}

static int init_netlink(struct network_ctx* ctx) {
	// Allocate netlink socket
	ctx->nl_socket = nl_socket_alloc();
	if (!ctx->nl_socket) {
		ERROR(ctx, "Failed to allocate netlink socket\n");
		return -ENOMEM;
	}

	// Connect the socket
	if (genl_connect(ctx->nl_socket)) {
		ERROR(ctx, "Failed to connect to generic netlink");
		return -ENOLINK;
	}

	// Set buffer size
	nl_socket_set_buffer_size(ctx->nl_socket, 8192, 8192);

	// Get nl80211 id
	ctx->nl80211_id = genl_ctrl_resolve(ctx->nl_socket, "nl80211");
	if (ctx->nl80211_id < 0) {
		ERROR(ctx, "Could not find nl80211\n");
		return -ENOENT;
	}

	return 0;
}

static void network_free(struct network_ctx* ctx) {
	DEBUG(ctx, "network ctx %p released\n", ctx);

	// Free netlink socket
	if (ctx->nl_socket)
		nl_socket_free(ctx->nl_socket);

	free(ctx);
}

NETWORK_EXPORT int network_new(struct network_ctx** ctx) {
	struct network_ctx* c = calloc(1, sizeof(*c));
	if (!c)
		return -ENOMEM;

	// Initialise basic variables
	c->refcount = 1;

	// Initialise logging
	c->log_fn = log_stderr;
	c->log_priority = LOG_ERR;

	const char* env = secure_getenv("NETWORK_LOG");
	if (env)
		network_set_log_priority(c, log_priority(env));

	// Initiate netlink connection
	int r = init_netlink(c);
	if (r) {
		network_free(c);
		return r;
	}

	INFO(c, "network ctx %p created\n", c);
	DEBUG(c, "log_priority=%d\n", c->log_priority);

	*ctx = c;
	return 0;
}

NETWORK_EXPORT struct network_ctx* network_ref(struct network_ctx* ctx) {
	if (!ctx)
		return NULL;

	ctx->refcount++;
	return ctx;
}

NETWORK_EXPORT struct network_ctx* network_unref(struct network_ctx* ctx) {
	if (!ctx)
		return NULL;

	if (--ctx->refcount > 0)
		return ctx;

	network_free(ctx);
	return NULL;
}

NETWORK_EXPORT void network_set_log_fn(struct network_ctx* ctx,
		void (*log_fn)(struct network_ctx* ctx, int priority, const char* file,
		int line, const char* fn, const char* format, va_list args)) {
	ctx->log_fn = log_fn;
	INFO(ctx, "custom logging function %p registered\n", log_fn);
}

NETWORK_EXPORT int network_get_log_priority(struct network_ctx* ctx) {
	return ctx->log_priority;
}

NETWORK_EXPORT void network_set_log_priority(struct network_ctx* ctx, int priority) {
	ctx->log_priority = priority;
}

NETWORK_EXPORT const char* network_version() {
	return "network " VERSION;
}