/*
 * Copyright 2022, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */

#include <AutoDeleter.h>
#include <util/KMessage.h>

extern "C" {
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/endian.h>
#include <sys/errno.h>
#include <sys/task.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_media.h>

#include <netinet/in.h>
#include <netinet/if_ether.h>

#include <net80211/ieee80211_var.h>
#include <net80211/ieee80211_node.h>
#include <net80211/ieee80211_ioctl.h>

#undef _NET80211_IEEE80211_IOCTL_H_
#define IEEE80211_IOCTLS_ABBREVIATED
#include "../../freebsd_wlan/net80211/ieee80211_ioctl.h"
}

#include <shared.h>

#include <ether_driver.h>
#include <NetworkDevice.h>
#include <net_notifications.h>


#define TRACE_WLAN
#ifdef TRACE_WLAN
#	define TRACE(x...) dprintf(x);
#else
#	define TRACE(x...) ;
#endif


static net_notifications_module_info* sNotificationModule;


static struct ifnet*
get_ifnet(device_t device, int& i)
{
	void* softc = device_get_softc(device);

	for (i = 0; i < MAX_DEVICES; i++) {
		if (gDevices[i] != NULL && gDevices[i]->if_softc == softc)
			return gDevices[i];
	}

	return NULL;
}


status_t
init_wlan_stack(void)
{
	get_module(NET_NOTIFICATIONS_MODULE_NAME,
		(module_info**)&sNotificationModule);

	return B_OK;
}


void
uninit_wlan_stack(void)
{
	if (sNotificationModule != NULL)
		put_module(NET_NOTIFICATIONS_MODULE_NAME);
}


static void
ieee80211_init()
{
}


status_t
start_wlan(device_t device)
{
	int i;
	struct ifnet* ifp = get_ifnet(device, i);
	if (ifp == NULL)
		return B_BAD_VALUE;

	struct ieee80211com* ic = (ieee80211com*)ifp;

	if (ifp->if_init == NULL)
		ifp->if_init = ieee80211_init;
	ifp->if_flags |= IFF_NEEDSGIANT;

	if_initname(ifp, device_get_name(device), i);

	TRACE("%s: wlan started.\n", __func__);
	return B_OK;
}


status_t
stop_wlan(device_t device)
{
	int i;
	struct ifnet* ifp = get_ifnet(device, i);
	if (ifp == NULL)
		return B_BAD_VALUE;

	struct ieee80211com* ic = (ieee80211com*)ifp;

	return B_OK;
}


status_t
wlan_close(void* cookie)
{
	TRACE("wlan_close(%p)\n", cookie);
	struct ifnet* ifp = (struct ifnet*)cookie;

	ifp->if_flags &= ~IFF_UP;
	ifp->if_ioctl(ifp, SIOCSIFFLAGS, NULL);

	return B_OK;
}


static uint8_t
fbsd_capinfo_from_obsd(uint16_t obsd_capinfo)
{
	// FreeBSD only exposes the first 8 bits of the capinfo,
	// and these are identical in OpenBSD. Makes things easy.
	return uint8_t(obsd_capinfo);
}


static uint32
obsd_ciphers_from_haiku(uint32 ciphers)
{
	uint32 obsd_ciphers = 0;
	if ((ciphers & B_NETWORK_CIPHER_WEP_40) != 0)
		obsd_ciphers |= IEEE80211_WPA_CIPHER_WEP40;
	if ((ciphers & B_NETWORK_CIPHER_WEP_104) != 0)
		obsd_ciphers |= IEEE80211_WPA_CIPHER_WEP104;
	if ((ciphers & B_NETWORK_CIPHER_TKIP) != 0)
		obsd_ciphers |= IEEE80211_WPA_CIPHER_TKIP;
	if ((ciphers & B_NETWORK_CIPHER_CCMP) != 0)
		obsd_ciphers |= IEEE80211_WPA_CIPHER_CCMP;
	return obsd_ciphers;
}


status_t
wlan_control(void* cookie, uint32 op, void* arg, size_t length)
{
	if (op != SIOCG80211 && op != SIOCS80211)
		return B_BAD_VALUE;

	struct ifnet* ifp = (struct ifnet*)cookie;
	struct ieee80211com* ic = (ieee80211com*)ifp;

	struct ieee80211req ireq;
	if (user_memcpy(&ireq, arg, sizeof(struct ieee80211req)) != B_OK)
		return B_BAD_ADDRESS;

	switch (ireq.i_type) {
		case IEEE80211_IOC_SCAN_REQ: {
			if (op != SIOCS80211)
				return B_BAD_VALUE;

			// SIOCS80211SCAN is a no-op, scans cannot actually be initiated.
			// But we can at least check if one is already in progress.
			status_t status = EBUSY;

			IFF_LOCKGIANT(ifp);
			if (ic->ic_state == IEEE80211_S_SCAN || (ic->ic_flags & IEEE80211_F_BGSCAN) != 0)
				status = EINPROGRESS;
			IFF_UNLOCKGIANT(ifp);

			return status;
		}

		case IEEE80211_IOC_SCAN_RESULTS: {
			if (op != SIOCG80211)
				return B_BAD_VALUE;

			struct ieee80211_nodereq nodereq;
			struct ieee80211_nodereq_all nodereq_all = {};

			// We need a scan_result of maximum possible size to work with.
			struct ieee80211req_scan_result* sr = (struct ieee80211req_scan_result*)
				alloca(sizeof(struct ieee80211req_scan_result) + IEEE80211_NWID_LEN + 257);

			uint16 remaining = ireq.i_len, offset = 0;
			for (int i = 0; remaining > 0; i++) {
				nodereq_all.na_node = &nodereq;
				nodereq_all.na_size = sizeof(struct ieee80211_nodereq);
				nodereq_all.na_startnode = i;

				IFF_LOCKGIANT(ifp);
				status_t status = ifp->if_ioctl(ifp, SIOCG80211ALLNODES, (caddr_t)&nodereq_all);
				IFF_UNLOCKGIANT(ifp);
				if (status != B_OK)
					return status;
				if (nodereq_all.na_nodes == 0)
					break;

				int32 size = sizeof(struct ieee80211req_scan_result) + nodereq.nr_nwid_len;
				uint16_t ieLen = 0;
				if (nodereq.nr_rsnie[1] != 0) {
					ieLen = 2 + nodereq.nr_rsnie[1];
					size += ieLen;
				}
				const int32 roundedSize = roundup(size, 4);
				if (remaining < roundedSize)
					break;

				sr->isr_ie_off = sizeof(struct ieee80211req_scan_result);
				sr->isr_ie_len = ieLen;
				sr->isr_freq = ieee80211_ieee2mhz(nodereq.nr_channel, nodereq.nr_chan_flags);
				sr->isr_flags = 0; /* not actually used by userland */
				sr->isr_noise = 0; /* unknown */
				sr->isr_rssi = nodereq.nr_rssi;
				sr->isr_intval = nodereq.nr_intval;
				sr->isr_capinfo = fbsd_capinfo_from_obsd(nodereq.nr_capinfo);
				sr->isr_erp = nodereq.nr_erp;
				memcpy(sr->isr_bssid, nodereq.nr_bssid, IEEE80211_ADDR_LEN);
				sr->isr_nrates = nodereq.nr_nrates;
				memcpy(sr->isr_rates, nodereq.nr_rates, IEEE80211_RATE_MAXSIZE);
				sr->isr_ssid_len = nodereq.nr_nwid_len;
				sr->isr_meshid_len = 0;
				memcpy((uint8*)sr + sr->isr_ie_off, nodereq.nr_nwid, sr->isr_ssid_len);
				memcpy((uint8*)sr + sr->isr_ie_off + sr->isr_ssid_len, nodereq.nr_rsnie, ieLen);

				sr->isr_len = roundedSize;
				if (user_memcpy((uint8*)ireq.i_data + offset, sr, size) != B_OK)
					return B_BAD_ADDRESS;

				offset += sr->isr_len;
				remaining -= sr->isr_len;
			}
			ireq.i_len = offset;

			IFF_LOCKGIANT(ifp);
			const bigtime_t RAISE_INACT_INTERVAL = 5 * 1000 * 1000 /* 5s */;
			if (ic->ic_opmode == IEEE80211_M_STA
					&& system_time() >= (ic->ic_last_raise_inact + RAISE_INACT_INTERVAL)) {
				// net80211 only raises and checks inactivity during active scans, or background
				// scans performed in S_RUN, so we need to do it here so that stale nodes are
				// evicted for S_SCAN, too. (This means "inact" will be raised a bit more often
				// and nodes evicted faster during other modes, but that's acceptable.)
				ieee80211_iterate_nodes(ic, ieee80211_node_raise_inact, NULL);
				ieee80211_clean_inactive_nodes(ic, IEEE80211_INACT_SCAN);
				ic->ic_last_raise_inact = system_time();
			}
			IFF_UNLOCKGIANT(ifp);

			break;
		}

		case IEEE80211_IOC_BSSID: {
			if (ireq.i_len != IEEE80211_ADDR_LEN)
				return EINVAL;

			struct ieee80211_bssid bssid;
			if (op == SIOCS80211) {
				if (user_memcpy(bssid.i_bssid, ireq.i_data, ireq.i_len) != B_OK)
					return B_BAD_ADDRESS;
			}

			IFF_LOCKGIANT(ifp);
			status_t status = ifp->if_ioctl(ifp, op == SIOCG80211 ?
				SIOCG80211BSSID : SIOCS80211BSSID, (caddr_t)&bssid);
			IFF_UNLOCKGIANT(ifp);
			if (status != B_OK)
				return status;

			if (op == SIOCG80211) {
				if (user_memcpy(ireq.i_data, bssid.i_bssid, ireq.i_len) != B_OK)
					return B_BAD_ADDRESS;
			}

			break;
		}

		case IEEE80211_IOC_SSID: {
			struct ifreq ifr;
			struct ieee80211_nwid nwid;
			ifr.ifr_data = (uint8_t*)&nwid;

			if (op == SIOCS80211) {
				nwid.i_len = ireq.i_len;
				if (user_memcpy(nwid.i_nwid, ireq.i_data, ireq.i_len) != B_OK)
					return B_BAD_ADDRESS;
			}

			IFF_LOCKGIANT(ifp);
			status_t status = ifp->if_ioctl(ifp, op == SIOCG80211 ?
				SIOCG80211NWID : SIOCS80211NWID, (caddr_t)&ifr);
			ieee80211_state state = ic->ic_state;
			IFF_UNLOCKGIANT(ifp);
			if (status != B_OK)
				return status;

			if (op == SIOCG80211) {
				if (state == IEEE80211_S_INIT || state == IEEE80211_S_SCAN) {
					// The returned NWID will be the one we want to join, not connected to.
					ireq.i_len = 0;
				} else {
					if (ireq.i_len < nwid.i_len)
						return E2BIG;
					ireq.i_len = nwid.i_len;
					if (user_memcpy(ireq.i_data, nwid.i_nwid, ireq.i_len) != B_OK)
						return B_BAD_ADDRESS;
				}
			}

			break;
		}

		case IEEE80211_IOC_MLME: {
			if (op != SIOCS80211)
				return B_BAD_VALUE;

			struct ieee80211req_mlme mlme;
			if (user_memcpy(&mlme, ireq.i_data, min_c(sizeof(mlme), ireq.i_len)) != B_OK)
				return B_BAD_ADDRESS;

			switch (mlme.im_op) {
				case IEEE80211_MLME_DISASSOC:
				case IEEE80211_MLME_DEAUTH: {
					struct ifreq ifr;
					struct ieee80211_nwid nwid;
					ifr.ifr_data = (uint8_t*)&nwid;
					nwid.i_len = 0;

					IFF_LOCKGIANT(ifp);
					status_t status = ifp->if_ioctl(ifp, SIOCS80211NWID, (caddr_t)&ifr);
					IFF_UNLOCKGIANT(ifp);
					if (status != 0)
						return status;
					break;
				}

				default:
					TRACE("openbsd wlan_control: unsupported MLME operation %" B_PRIu8 "\n",
						mlme.im_op);
					return EOPNOTSUPP;
			}

			break;
		}

		case IEEE80211_IOC_HAIKU_JOIN: {
			if (op != SIOCS80211)
				return B_BAD_VALUE;

			struct ieee80211_haiku_join_req* haiku_join =
				(struct ieee80211_haiku_join_req*)calloc(1, ireq.i_len);
			MemoryDeleter haikuJoinDeleter(haiku_join);
			if (!haikuJoinDeleter.IsSet())
				return B_NO_MEMORY;

			if (user_memcpy(haiku_join, ireq.i_data, ireq.i_len) != B_OK)
				return B_BAD_ADDRESS;

			struct ifreq ifr;
			struct ieee80211_nwid nwid;
			struct ieee80211_wpaparams wpaparams;
			struct ieee80211_wpapsk wpapsk;
			memset(&wpaparams, 0, sizeof(wpaparams));
			memset(&wpapsk, 0, sizeof(wpapsk));

			// Convert join information.
			ifr.ifr_data = (uint8_t*)&nwid;
			nwid.i_len = haiku_join->i_nwid_len;
			memcpy(nwid.i_nwid, haiku_join->i_nwid, nwid.i_len);

			switch (haiku_join->i_authentication_mode) {
				case B_NETWORK_AUTHENTICATION_NONE:
					break;

				case B_NETWORK_AUTHENTICATION_WPA:
				case B_NETWORK_AUTHENTICATION_WPA2:
					wpaparams.i_enabled = 1;
					wpaparams.i_protos |=
						(haiku_join->i_authentication_mode == B_NETWORK_AUTHENTICATION_WPA2) ?
							IEEE80211_WPA_PROTO_WPA2 : IEEE80211_WPA_PROTO_WPA1;

					// NOTE: i_wpaparams.i_groupcipher is not a flags field!
					wpaparams.i_ciphers = obsd_ciphers_from_haiku(haiku_join->i_ciphers);
					wpaparams.i_groupcipher =
						fls(obsd_ciphers_from_haiku(haiku_join->i_group_ciphers));

					if ((haiku_join->i_key_mode & B_KEY_MODE_IEEE802_1X) != 0)
						wpaparams.i_akms |= IEEE80211_WPA_AKM_8021X;
					if ((haiku_join->i_key_mode & B_KEY_MODE_PSK) != 0)
						wpaparams.i_akms |= IEEE80211_WPA_AKM_PSK;
					if ((haiku_join->i_key_mode & B_KEY_MODE_IEEE802_1X_SHA256) != 0)
						wpaparams.i_akms |= IEEE80211_WPA_AKM_SHA256_8021X;
					if ((haiku_join->i_key_mode & B_KEY_MODE_PSK_SHA256) != 0)
						wpaparams.i_akms |= IEEE80211_WPA_AKM_SHA256_PSK;

					if (haiku_join->i_key_len != 0) {
						wpapsk.i_enabled = 1;
						memcpy(wpapsk.i_psk, haiku_join->i_key, haiku_join->i_key_len);
						memset(&wpapsk.i_psk[haiku_join->i_key_len], 0,
							sizeof(wpapsk.i_psk) - haiku_join->i_key_len);
					}
					break;

				default:
					TRACE("openbsd wlan_control: unsupported authentication mode %" B_PRIu32 "\n",
						haiku_join->i_authentication_mode);
					return EOPNOTSUPP;
			}

			IFF_LOCKGIANT(ifp);
			status_t status = ifp->if_ioctl(ifp, SIOCS80211NWID, (caddr_t)&ifr);
			if (status != B_OK) {
				IFF_UNLOCKGIANT(ifp);
				return status;
			}
			if (wpapsk.i_enabled) {
				status = ifp->if_ioctl(ifp, SIOCS80211WPAPSK, (caddr_t)&wpapsk);
				if (status != B_OK) {
					IFF_UNLOCKGIANT(ifp);
					return status;
				}
			}
			if (wpaparams.i_enabled) {
				status = ifp->if_ioctl(ifp, SIOCS80211WPAPARMS, (caddr_t)&wpaparams);
				if (status != B_OK) {
					IFF_UNLOCKGIANT(ifp);
					return status;
				}
			}
			IFF_UNLOCKGIANT(ifp);
			if (status != B_OK)
				return status;

			break;
		}

		default:
			TRACE("openbsd wlan_control: %" B_PRIu32 ", %d (not supported)\n", op, ireq.i_type);
			return EOPNOTSUPP;
	}

	if (op == SIOCG80211 && user_memcpy(arg, &ireq,
			sizeof(struct ieee80211req)) != B_OK)
		return B_BAD_ADDRESS;
	return B_OK;
}


void
ieee80211_rtm_80211info_task(void* arg)
{
	struct ieee80211com *ic = arg;
	struct ifnet *ifp = &ic->ic_if;

	if (sNotificationModule != NULL) {
		char messageBuffer[512];
		KMessage message;
		message.SetTo(messageBuffer, sizeof(messageBuffer), B_NETWORK_MONITOR);
		if (ifp->if_link_state == LINK_STATE_UP)
			message.AddInt32("opcode", B_NETWORK_WLAN_JOINED);
		else
			message.AddInt32("opcode", B_NETWORK_WLAN_LEFT);
		message.AddString("interface", ifp->device_name);
		// TODO: add data about the node

		sNotificationModule->send_notification(&message);
	}
}


#if 0
void
ieee80211_notify_scan_done(struct ieee80211vap* vap)
{
	release_sem_etc(vap->iv_ifp->scan_done_sem, 1,
		B_DO_NOT_RESCHEDULE | B_RELEASE_ALL);

	TRACE("%s\n", __FUNCTION__);

	if (sNotificationModule != NULL) {
		char messageBuffer[512];
		KMessage message;
		message.SetTo(messageBuffer, sizeof(messageBuffer), B_NETWORK_MONITOR);
		message.AddInt32("opcode", B_NETWORK_WLAN_SCANNED);
		message.AddString("interface", vap->iv_ifp->device_name);

		sNotificationModule->send_notification(&message);
	}
}
#endif