// SPDX-License-Identifier: GPL-2.0+

/*

 * Copyright (C) 2017 Red Hat, Inc.

 */

#include "nm-default.h"

#include "nm-device-ovs-interface.h"

#include "nm-ovsdb.h"

#include "devices/nm-device-private.h"

#include "nm-active-connection.h"

#include "nm-setting-connection.h"

#include "nm-setting-ovs-interface.h"

#include "nm-setting-ovs-port.h"

#include "devices/nm-device-logging.h"

_LOG_DECLARE_SELF(NMDeviceOvsInterface);

/*****************************************************************************/

typedef struct {

	bool waiting_for_interface:1;

} NMDeviceOvsInterfacePrivate;

struct _NMDeviceOvsInterface {

	NMDevice parent;

	NMDeviceOvsInterfacePrivate _priv;

};

struct _NMDeviceOvsInterfaceClass {

	NMDeviceClass parent;

};

G_DEFINE_TYPE (NMDeviceOvsInterface, nm_device_ovs_interface, NM_TYPE_DEVICE)

#define NM_DEVICE_OVS_INTERFACE_GET_PRIVATE(self) _NM_GET_PRIVATE (self, NMDeviceOvsInterface, NM_IS_DEVICE_OVS_INTERFACE, NMDevice)

/*****************************************************************************/

static const char *

get_type_description (NMDevice *device)

{

	return "ovs-interface";

}

static gboolean

create_and_realize (NMDevice *device,

                    NMConnection *connection,

                    NMDevice *parent,

                    const NMPlatformLink **out_plink,

                    GError **error)

{

	/* The actual backing resources will be created once an interface is

	 * added to a port of ours, since there can be neither an empty port nor

	 * an empty bridge. */

	return TRUE;

}

static NMDeviceCapabilities

get_generic_capabilities (NMDevice *device)

{

	return NM_DEVICE_CAP_CARRIER_DETECT | NM_DEVICE_CAP_IS_SOFTWARE;

}

static gboolean

is_available (NMDevice *device, NMDeviceCheckDevAvailableFlags flags)

{

	return TRUE;

}

static gboolean

check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error)

{

	NMSettingOvsInterface *s_ovs_iface;

	if (!NM_DEVICE_CLASS (nm_device_ovs_interface_parent_class)->check_connection_compatible (device, connection, error))

		return FALSE;

	s_ovs_iface = nm_connection_get_setting_ovs_interface (connection);

	if (!NM_IN_STRSET (nm_setting_ovs_interface_get_interface_type (s_ovs_iface),

	                   "dpdk",

	                   "internal",

	                   "patch")) {

		nm_utils_error_set_literal (error, NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY,

		                            "unsupported OVS interface type in profile");

		return FALSE;

	}

	return TRUE;

}

static void

link_changed (NMDevice *device,

              const NMPlatformLink *pllink)

{

	NMDeviceOvsInterfacePrivate *priv = NM_DEVICE_OVS_INTERFACE_GET_PRIVATE (device);

	if (!pllink || !priv->waiting_for_interface)

		return;

	priv->waiting_for_interface = FALSE;

	if (nm_device_get_state (device) == NM_DEVICE_STATE_IP_CONFIG) {

		if (!nm_device_hw_addr_set_cloned (device,

		                                   nm_device_get_applied_connection (device),

		                                   FALSE)) {

			nm_device_state_changed (device,

			                         NM_DEVICE_STATE_FAILED,

			                         NM_DEVICE_STATE_REASON_CONFIG_FAILED);

			return;

		}

		nm_device_bring_up (device, TRUE, NULL);

		nm_device_activate_schedule_stage3_ip_config_start (device);

	}

}

static gboolean

_is_internal_interface (NMDevice *device)

{

	NMSettingOvsInterface *s_ovs_iface;

	s_ovs_iface = nm_device_get_applied_setting (device, NM_TYPE_SETTING_OVS_INTERFACE);

	g_return_val_if_fail (s_ovs_iface, FALSE);

	return nm_streq (nm_setting_ovs_interface_get_interface_type (s_ovs_iface), "internal");

}

static void

set_platform_mtu_cb (GError *error, gpointer user_data)

{

	NMDevice *device = user_data;

	NMDeviceOvsInterface *self = NM_DEVICE_OVS_INTERFACE (device);

	if (   error

	    && !g_error_matches (error, NM_UTILS_ERROR, NM_UTILS_ERROR_CANCELLED_DISPOSING)) {

		_LOGW (LOGD_DEVICE, "could not change mtu of '%s': %s",

		       nm_device_get_iface (device), error->message);

	}

	g_object_unref (device);

}

static gboolean

set_platform_mtu (NMDevice *device, guint32 mtu)

{

	/*

	 * If the MTU is not set in ovsdb, Open vSwitch will change

	 * the MTU of an internal interface to match the minimum of

	 * the other interfaces in the bridge.

	 */

	/* FIXME(shutdown): the function should become cancellable so

	 * that it doesn't need to hold a reference to the device, and

	 * it can be stopped during shutdown.

	 */

	if (_is_internal_interface (device)) {

		nm_ovsdb_set_interface_mtu (nm_ovsdb_get (),

		                            nm_device_get_ip_iface (device),

		                            mtu, set_platform_mtu_cb,

		                            g_object_ref (device));

	}

	return NM_DEVICE_CLASS (nm_device_ovs_interface_parent_class)->set_platform_mtu (device, mtu);

}

static NMActStageReturn

act_stage3_ip_config_start (NMDevice *device,

                            int addr_family,

                            gpointer *out_config,

                            NMDeviceStateReason *out_failure_reason)

{

	NMDeviceOvsInterface *self = NM_DEVICE_OVS_INTERFACE (device);

	NMDeviceOvsInterfacePrivate *priv = NM_DEVICE_OVS_INTERFACE_GET_PRIVATE (device);

	if (!_is_internal_interface (device))

		return NM_ACT_STAGE_RETURN_IP_FAIL;

	if (nm_device_get_ip_ifindex (device) <= 0) {

		_LOGT (LOGD_DEVICE, "waiting for link to appear");

		priv->waiting_for_interface = TRUE;

		return NM_ACT_STAGE_RETURN_POSTPONE;

	}

	if (!nm_device_hw_addr_set_cloned (device,

	                                   nm_device_get_applied_connection (device),

	                                   FALSE)) {

		*out_failure_reason = NM_DEVICE_STATE_REASON_CONFIG_FAILED;

		return NM_ACT_STAGE_RETURN_FAILURE;

	}

	return NM_DEVICE_CLASS (nm_device_ovs_interface_parent_class)->act_stage3_ip_config_start (device, addr_family, out_config, out_failure_reason);

}

static gboolean

can_unmanaged_external_down (NMDevice *self)

{

	return FALSE;

}

static void

deactivate (NMDevice *device)

{

	NMDeviceOvsInterface *self = NM_DEVICE_OVS_INTERFACE (device);

	NMDeviceOvsInterfacePrivate *priv = NM_DEVICE_OVS_INTERFACE_GET_PRIVATE (self);

	priv->waiting_for_interface = FALSE;

}

typedef struct {

	NMDeviceOvsInterface *self;

	GCancellable *cancellable;

	NMDeviceDeactivateCallback callback;

	gpointer callback_user_data;

	gulong link_changed_id;

	gulong cancelled_id;

	guint link_timeout_id;

} DeactivateData;

static void

deactivate_invoke_cb (DeactivateData *data, GError *error)

{

	NMDeviceOvsInterface *self = data->self;

	_LOGT (LOGD_CORE,

	       "deactivate: async callback (%s)",

	       error ? error->message : "success");

	data->callback (NM_DEVICE (data->self),

	                error,

	                data->callback_user_data);

	nm_clear_g_signal_handler (nm_device_get_platform (NM_DEVICE (data->self)),

	                           &data->link_changed_id);

	nm_clear_g_signal_handler (data->cancellable,

	                           &data->cancelled_id);

	nm_clear_g_source (&data->link_timeout_id);

	g_object_unref (data->self);

	g_object_unref (data->cancellable);

	nm_g_slice_free (data);

}

static void

deactivate_link_changed_cb (NMPlatform *platform,

                            int obj_type_i,

                            int ifindex,

                            NMPlatformLink *info,

                            int change_type_i,

                            DeactivateData *data)

{

	NMDeviceOvsInterface *self = data->self;

	const NMPlatformSignalChangeType change_type = change_type_i;

	if (   change_type == NM_PLATFORM_SIGNAL_REMOVED

	    && nm_streq0 (info->name, nm_device_get_iface (NM_DEVICE (self)))) {

		_LOGT (LOGD_DEVICE, "deactivate: link removed, proceeding");

		nm_device_update_from_platform_link (NM_DEVICE (self), NULL);

		deactivate_invoke_cb (data, NULL);

		return;

	}

}

static gboolean

deactivate_link_timeout (gpointer user_data)

{

	DeactivateData *data = user_data;

	NMDeviceOvsInterface *self = data->self;

	_LOGT (LOGD_DEVICE, "deactivate: timeout waiting link removal");

	deactivate_invoke_cb (data, NULL);

	return G_SOURCE_REMOVE;

}

static void

deactivate_cancelled_cb (GCancellable *cancellable,

                         gpointer user_data)

{

	gs_free_error GError *error = NULL;

	nm_utils_error_set_cancelled (&error, FALSE, NULL);

	deactivate_invoke_cb ((DeactivateData *) user_data, error);

}

static void

deactivate_cb_on_idle (gpointer user_data,

                       GCancellable *cancellable)

{

	DeactivateData *data = user_data;

	gs_free_error GError *cancelled_error = NULL;

	g_cancellable_set_error_if_cancelled (data->cancellable, &cancelled_error);

	deactivate_invoke_cb (data, cancelled_error);

}

static void

deactivate_async (NMDevice *device,

                  GCancellable *cancellable,

                  NMDeviceDeactivateCallback callback,

                  gpointer callback_user_data) {

	NMDeviceOvsInterface *self = NM_DEVICE_OVS_INTERFACE (device);

	NMDeviceOvsInterfacePrivate *priv = NM_DEVICE_OVS_INTERFACE_GET_PRIVATE (self);

	DeactivateData *data;

	_LOGT (LOGD_CORE, "deactivate: start async");

	/* We want to ensure that the kernel link for this device is

	 * removed upon disconnection so that it will not interfere with

	 * later activations of the same device. Unfortunately there is

	 * no synchronization mechanism with vswitchd, we only update

	 * ovsdb and wait that changes are picked up.

	 */

	data = g_slice_new (DeactivateData);

	*data = (DeactivateData) {

		.self = g_object_ref (self),

		.cancellable = g_object_ref (cancellable),

		.callback = callback,

		.callback_user_data = callback_user_data,

	};

	if (   !priv->waiting_for_interface

	    && !nm_platform_link_get_by_ifname (nm_device_get_platform (device),

	                                        nm_device_get_iface (device))) {

		_LOGT (LOGD_CORE, "deactivate: link not present, proceeding");

		nm_device_update_from_platform_link (NM_DEVICE (self), NULL);

		nm_utils_invoke_on_idle (cancellable, deactivate_cb_on_idle, data);

		return;

	}

	if (priv->waiting_for_interface) {

		/* At this point we have issued an INSERT and a DELETE

		 * command for the interface to ovsdb. We don't know if

		 * vswitchd will see the two updates or only one. We

		 * must add a timeout to avoid waiting forever in case

		 * the link doesn't appear.

		 */

		data->link_timeout_id = g_timeout_add (6000, deactivate_link_timeout, data);

		_LOGT (LOGD_DEVICE, "deactivate: waiting for link to disappear in 6 seconds");

	} else

		_LOGT (LOGD_DEVICE, "deactivate: waiting for link to disappear");

	data->cancelled_id = g_cancellable_connect (cancellable,

	                                            G_CALLBACK (deactivate_cancelled_cb),

	                                            data,

	                                            NULL);

	data->link_changed_id = g_signal_connect (nm_device_get_platform (device),

	                                          NM_PLATFORM_SIGNAL_LINK_CHANGED,

	                                          G_CALLBACK (deactivate_link_changed_cb),

	                                          data);

}

static gboolean

can_update_from_platform_link (NMDevice *device, const NMPlatformLink *plink)

{

	/* If the device is deactivating, we already sent the

	 * deletion command to ovsdb and we don't want to deal

	 * with any new link appearing from the previous

	 * activation.

	 */

	return    !plink

	       || nm_device_get_state (device) != NM_DEVICE_STATE_DEACTIVATING;

}

/*****************************************************************************/

static void

nm_device_ovs_interface_init (NMDeviceOvsInterface *self)

{

}

static const NMDBusInterfaceInfoExtended interface_info_device_ovs_interface = {

	.parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT (

		NM_DBUS_INTERFACE_DEVICE_OVS_INTERFACE,

		.signals = NM_DEFINE_GDBUS_SIGNAL_INFOS (

			&nm_signal_info_property_changed_legacy,

		),

	),

	.legacy_property_changed = TRUE,

};

static void

nm_device_ovs_interface_class_init (NMDeviceOvsInterfaceClass *klass)

{

	NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS (klass);

	NMDeviceClass *device_class = NM_DEVICE_CLASS (klass);

	dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS (&interface_info_device_ovs_interface);

	device_class->connection_type_supported = NM_SETTING_OVS_INTERFACE_SETTING_NAME;

	device_class->connection_type_check_compatible = NM_SETTING_OVS_INTERFACE_SETTING_NAME;

	device_class->link_types = NM_DEVICE_DEFINE_LINK_TYPES (NM_LINK_TYPE_OPENVSWITCH);

	device_class->can_update_from_platform_link = can_update_from_platform_link;

	device_class->deactivate = deactivate;

	device_class->deactivate_async = deactivate_async;

	device_class->get_type_description = get_type_description;

	device_class->create_and_realize = create_and_realize;

	device_class->get_generic_capabilities = get_generic_capabilities;

	device_class->is_available = is_available;

	device_class->check_connection_compatible = check_connection_compatible;

	device_class->link_changed = link_changed;

	device_class->act_stage3_ip_config_start = act_stage3_ip_config_start;

	device_class->can_unmanaged_external_down = can_unmanaged_external_down;

	device_class->set_platform_mtu = set_platform_mtu;

	device_class->get_configured_mtu = nm_device_get_configured_mtu_for_wired;

}