/*
 * Zebra L2 bridge interface handling
 *
 * Copyright (C) 2021 Cumulus Networks, Inc.
 * Sharath Ramamurthy
 *
 * This file is part of FRR.
 *
 * FRR 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 2, or (at your option) any
 * later version.
 *
 * FRR 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.
 */

#include <zebra.h>

#include "hash.h"
#include "if.h"
#include "jhash.h"
#include "linklist.h"
#include "log.h"
#include "memory.h"
#include "prefix.h"
#include "stream.h"
#include "table.h"
#include "vlan.h"
#include "vxlan.h"
#ifdef GNU_LINUX
#include <linux/neighbour.h>
#endif

#include "zebra/zebra_router.h"
#include "zebra/debug.h"
#include "zebra/interface.h"
#include "zebra/rib.h"
#include "zebra/rt.h"
#include "zebra/rt_netlink.h"
#include "zebra/zebra_errors.h"
#include "zebra/zebra_l2.h"
#include "zebra/zebra_l2_bridge_if.h"
#include "zebra/zebra_ns.h"
#include "zebra/zebra_vrf.h"
#include "zebra/zebra_vxlan.h"
#include "zebra/zebra_vxlan_if.h"
#include "zebra/zebra_evpn.h"
#include "zebra/zebra_evpn_mac.h"
#include "zebra/zebra_evpn_neigh.h"
#include "zebra/zebra_vxlan_private.h"
#include "zebra/zebra_evpn_mh.h"
#include "zebra/zebra_evpn_vxlan.h"
#include "zebra/zebra_router.h"

static unsigned int zebra_l2_bridge_vlan_hash_keymake(const void *p)
{
	const struct zebra_l2_bridge_vlan *bvlan;

	bvlan = (const struct zebra_l2_bridge_vlan *)p;
	return jhash(&bvlan->vid, sizeof(bvlan->vid), 0);
}

static bool zebra_l2_bridge_vlan_hash_cmp(const void *p1, const void *p2)
{
	const struct zebra_l2_bridge_vlan *bv1;
	const struct zebra_l2_bridge_vlan *bv2;

	bv1 = (const struct zebra_l2_bridge_vlan *)p1;
	bv2 = (const struct zebra_l2_bridge_vlan *)p2;

	return (bv1->vid == bv2->vid);
}

static int zebra_l2_bridge_if_vlan_walk_callback(struct hash_bucket *bucket,
						 void *ctxt)
{
	int ret;
	struct zebra_l2_bridge_vlan *bvlan;
	struct zebra_l2_bridge_if_ctx *ctx;

	bvlan = (struct zebra_l2_bridge_vlan *)bucket->data;
	ctx = (struct zebra_l2_bridge_if_ctx *)ctxt;

	ret = ctx->func(ctx->zif, bvlan, ctx->arg);
	return ret;
}

static void zebra_l2_bridge_if_vlan_iterate_callback(struct hash_bucket *bucket,
						     void *ctxt)
{
	struct zebra_l2_bridge_vlan *bvlan;
	struct zebra_l2_bridge_if_ctx *ctx;

	bvlan = (struct zebra_l2_bridge_vlan *)bucket->data;
	ctx = (struct zebra_l2_bridge_if_ctx *)ctxt;

	ctx->func(ctx->zif, bvlan, ctx->arg);
}

static int zebra_l2_bridge_if_vlan_clean(struct zebra_if *zif,
					 struct zebra_l2_bridge_vlan *bvlan,
					 void *ctxt)
{
	struct zebra_evpn_access_bd *acc_bd;

	if (IS_ZEBRA_DEBUG_VXLAN)
		zlog_debug("access vlan %d bridge %s cleanup", bvlan->vid,
			   zif->ifp->name);

	acc_bd = zebra_evpn_acc_vl_find(bvlan->vid, zif->ifp);
	if (acc_bd)
		zebra_evpn_access_bd_bridge_cleanup(bvlan->vid, zif->ifp,
						    acc_bd);

	bvlan->access_bd = NULL;
	return 0;
}

static void zebra_l2_bridge_vlan_free(void *arg)
{
	struct zebra_l2_bridge_vlan *bvl;

	bvl = (struct zebra_l2_bridge_vlan *)arg;
	XFREE(MTYPE_TMP, bvl);
}

static void *zebra_l2_bridge_vlan_alloc(void *p)
{
	struct zebra_l2_bridge_vlan *bvlan;
	const struct zebra_l2_bridge_vlan *bvl;

	bvl = (const struct zebra_l2_bridge_vlan *)p;
	bvlan = XCALLOC(MTYPE_TMP, sizeof(*bvlan));
	bvlan->vid = bvl->vid;
	bvlan->access_bd = bvl->access_bd;

	return (void *)bvlan;
}

static void zebra_l2_bridge_vlan_table_destroy(struct hash *vlan_table)
{
	if (vlan_table) {
		hash_clean(vlan_table, zebra_l2_bridge_vlan_free);
		hash_free(vlan_table);
	}
}

static struct hash *zebra_l2_bridge_vlan_table_create(void)
{
	return hash_create(zebra_l2_bridge_vlan_hash_keymake,
			   zebra_l2_bridge_vlan_hash_cmp,
			   "Zebra L2 Bridge Vlan Table");
}

static void zebra_l2_bridge_if_vlan_table_destroy(struct zebra_if *zif)
{
	struct zebra_l2_bridge_if *br;

	br = BRIDGE_FROM_ZEBRA_IF(zif);
	zebra_l2_bridge_if_vlan_iterate(zif, zebra_l2_bridge_if_vlan_clean,
					NULL);
	zebra_l2_bridge_vlan_table_destroy(br->vlan_table);
	br->vlan_table = NULL;
}

static int zebra_l2_bridge_if_vlan_table_create(struct zebra_if *zif)
{
	struct zebra_l2_bridge_if *br;

	br = BRIDGE_FROM_ZEBRA_IF(zif);
	if (!br->vlan_table) {
		br->vlan_table = zebra_l2_bridge_vlan_table_create();
		if (!br->vlan_table)
			return -ENOMEM;
	}

	return 0;
}

static int zebra_l2_bridge_if_vlan_del(struct interface *ifp, vlanid_t vid)
{
	struct zebra_if *zif;
	struct zebra_l2_bridge_if *br;
	struct zebra_l2_bridge_vlan bvl;
	struct zebra_l2_bridge_vlan *bvlan;

	zif = (struct zebra_if *)ifp->info;
	memset(&bvl, 0, sizeof(bvl));
	bvl.vid = vid;

	br = BRIDGE_FROM_ZEBRA_IF(zif);
	bvlan = hash_release(br->vlan_table, &bvl);

	if (bvlan)
		zebra_l2_bridge_vlan_free(bvlan);

	return 0;
}

static int zebra_l2_bridge_if_vlan_update(struct interface *ifp,
					  struct zebra_l2_bridge_vlan *bvl,
					  int chgflags)
{
	struct zebra_if *zif;
	struct zebra_l2_bridge_vlan *bvlan;

	zif = (struct zebra_if *)ifp->info;
	bvlan = zebra_l2_bridge_if_vlan_find(zif, bvl->vid);
	if (!bvlan)
		return 0;

	if (chgflags & ZEBRA_BRIDGEIF_ACCESS_BD_CHANGE)
		bvlan->access_bd = bvl->access_bd;

	if (!bvlan->access_bd)
		return zebra_l2_bridge_if_vlan_del(ifp, bvl->vid);

	return 0;
}

static int zebra_l2_bridge_if_vlan_add(struct interface *ifp,
				       struct zebra_l2_bridge_vlan *bvlan)
{
	struct zebra_if *zif;
	struct zebra_l2_bridge_if *br;

	zif = (struct zebra_if *)ifp->info;
	br = BRIDGE_FROM_ZEBRA_IF(zif);
	hash_get(br->vlan_table, (void *)bvlan, zebra_l2_bridge_vlan_alloc);

	return 0;
}

struct zebra_l2_bridge_vlan *
zebra_l2_bridge_if_vlan_find(const struct zebra_if *zif, vlanid_t vid)
{
	const struct zebra_l2_bridge_if *br;
	struct zebra_l2_bridge_vlan *bvl;
	struct zebra_l2_bridge_vlan bvlan;

	br = BRIDGE_FROM_ZEBRA_IF(zif);
	memset(&bvlan, 0, sizeof(bvlan));
	bvlan.vid = vid;
	bvl = (struct zebra_l2_bridge_vlan *)hash_lookup(br->vlan_table,
							 (void *)&bvlan);

	/* TODO: For debugging. Remove later */
	if (bvl)
		assert(bvl->vid == vid);

	return bvl;
}

vni_t zebra_l2_bridge_if_vni_find(const struct zebra_if *zif, vlanid_t vid)
{
	vni_t vni_id = 0;
	struct zebra_l2_bridge_vlan *bvlan;

	bvlan = zebra_l2_bridge_if_vlan_find(zif, vid);
	if (bvlan && bvlan->access_bd && bvlan->access_bd->vni)
		vni_id = bvlan->access_bd->vni;

	return vni_id;
}

void zebra_l2_bridge_if_vlan_iterate(struct zebra_if *zif,
				     int (*func)(struct zebra_if *zif,
						 struct zebra_l2_bridge_vlan *,
						 void *),
				     void *arg)
{
	struct zebra_l2_bridge_if *br;
	struct zebra_l2_bridge_if_ctx ctx;

	br = BRIDGE_FROM_ZEBRA_IF(zif);
	memset(&ctx, 0, sizeof(ctx));
	ctx.zif = zif;
	ctx.func = func;
	ctx.arg = arg;
	hash_iterate(br->vlan_table, zebra_l2_bridge_if_vlan_iterate_callback,
		     &ctx);
}

void zebra_l2_bridge_if_vlan_walk(struct zebra_if *zif,
				  int (*func)(struct zebra_if *zif,
					      struct zebra_l2_bridge_vlan *,
					      void *),
				  void *arg)
{
	struct zebra_l2_bridge_if *br;
	struct zebra_l2_bridge_if_ctx ctx;

	br = BRIDGE_FROM_ZEBRA_IF(zif);
	memset(&ctx, 0, sizeof(ctx));
	ctx.zif = zif;
	ctx.func = func;
	ctx.arg = arg;
	hash_walk(br->vlan_table, zebra_l2_bridge_if_vlan_walk_callback, &ctx);
}

int zebra_l2_bridge_if_vlan_access_bd_deref(struct zebra_evpn_access_bd *bd)
{
	int chgflags = 0;
	struct zebra_if *zif;
	struct zebra_l2_bridge_vlan bvl;
	struct zebra_l2_bridge_vlan *bvlan;

	zif = bd->bridge_zif;
	if (!zif)
		return -1;

	bvlan = zebra_l2_bridge_if_vlan_find(zif, bd->vid);
	if (!bvlan)
		return 0;

	memset(&bvl, 0, sizeof(bvl));
	bvl.vid = bd->vid;
	bvl.access_bd = NULL;
	chgflags = ZEBRA_BRIDGEIF_ACCESS_BD_CHANGE;
	return zebra_l2_bridge_if_vlan_update(zif->ifp, &bvl, chgflags);
}

int zebra_l2_bridge_if_vlan_access_bd_ref(struct zebra_evpn_access_bd *bd)
{
	int chgflags = 0;
	struct zebra_if *zif;
	struct zebra_l2_bridge_vlan bvl;
	struct zebra_l2_bridge_vlan *bvlan;

	zif = bd->bridge_zif;
	if (!zif)
		return -1;

	if (!bd->vid)
		return -1;

	memset(&bvl, 0, sizeof(bvl));
	bvl.vid = bd->vid;
	bvl.access_bd = bd;

	bvlan = zebra_l2_bridge_if_vlan_find(zif, bd->vid);
	if (!bvlan)
		return zebra_l2_bridge_if_vlan_add(zif->ifp, &bvl);

	chgflags = ZEBRA_BRIDGEIF_ACCESS_BD_CHANGE;
	return zebra_l2_bridge_if_vlan_update(zif->ifp, &bvl, chgflags);
}

int zebra_l2_bridge_if_cleanup(struct interface *ifp)
{
	struct zebra_if *zif;

	if (!IS_ZEBRA_IF_BRIDGE(ifp))
		return 0;

	if (IS_ZEBRA_DEBUG_VXLAN)
		zlog_debug("bridge %s cleanup", ifp->name);

	zif = (struct zebra_if *)ifp->info;
	zebra_l2_bridge_if_vlan_table_destroy(zif);
	return 0;
}

int zebra_l2_bridge_if_del(struct interface *ifp)
{
	if (IS_ZEBRA_DEBUG_VXLAN)
		zlog_debug("bridge %s delete", ifp->name);

	return zebra_l2_bridge_if_cleanup(ifp);
}

int zebra_l2_bridge_if_add(struct interface *ifp)
{
	struct zebra_if *zif;
	struct zebra_l2_bridge_if *br;

	zif = (struct zebra_if *)ifp->info;
	br = BRIDGE_FROM_ZEBRA_IF(zif);
	br->br_zif = (struct zebra_if *)ifp->info;
	zebra_l2_bridge_if_vlan_table_create(zif);
	return 0;
}