/*

 *

 *  BlueZ - Bluetooth protocol stack for Linux

 *

 *  Copyright (C) 2018-2019  Intel Corporation. All rights reserved.

 *

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2.1 of the License, or (at your option) any later version.

 *

 *  This library 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

 *  Lesser General Public License for more details.

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <ell/ell.h>

#include "mesh/mesh-defs.h"

#include "mesh/net-keys.h"

#include "mesh/net.h"

#include "mesh/model.h"

#include "mesh/util.h"

#include "mesh/friend.h"

#define MAX_FRND_GROUPS		20

#define FRND_RELAY_WINDOW	250		/* 250 ms */

#define FRND_CACHE_SIZE		16

#define FRND_SUB_LIST_SIZE	8

#define RESPONSE_DELAY		(100 - 12)	/*  100  ms - 12ms hw delay */

#define MIN_RESP_DELAY		10		/*   10  ms */

#define MAX_RESP_DELAY		255		/*  255  ms */

/* Absolute maximum time to wait for LPN to choose us. */

#define RESPONSE_POLL_DELAY	1300		/* 1.300  s */

static uint8_t frnd_relay_window = FRND_RELAY_WINDOW;

static uint8_t frnd_cache_size = FRND_CACHE_SIZE;

static uint8_t frnd_sublist_size = FRND_SUB_LIST_SIZE;

struct frnd_negotiation {

	struct l_timeout	*timeout;

	struct mesh_net		*net;

	uint32_t		key_id;

	uint32_t		poll_timeout;

	uint16_t		low_power_node;

	uint16_t		old_relay;

	uint8_t			num_ele;

	uint8_t			lp_cnt;

	uint8_t			fn_cnt;

	uint8_t			wrfrw;

	uint8_t			receive_delay;

	int8_t			rssi;

	bool			clearing;

};

static struct l_queue *frnd_negotiations;

static uint16_t counter;

static void response_timeout(struct l_timeout *timeout, void *user_data)

{

	struct frnd_negotiation *neg = user_data;

	/* LPN did not choose us */

	l_debug("Did not win negotiation for %4.4x", neg->low_power_node);

	net_key_unref(neg->key_id);

	l_queue_remove(frnd_negotiations, neg);

	l_timeout_remove(timeout);

	l_free(neg);

}

static void response_delay(struct l_timeout *timeout, void *user_data)

{

	struct frnd_negotiation *neg = user_data;

	uint16_t net_idx = mesh_net_get_primary_idx(neg->net);

	uint32_t key_id;

	uint8_t msg[8];

	uint16_t n = 0;

	bool res;

	l_timeout_remove(timeout);

	/* Create key Set for this offer */

	res = mesh_net_get_key(neg->net, false, net_idx, &key_id);

	if (!res)

		goto cleanup;

	neg->key_id = net_key_frnd_add(key_id, neg->low_power_node,

						mesh_net_get_address(neg->net),

						neg->lp_cnt, counter);

	if (!neg->key_id)

		goto cleanup;

	neg->fn_cnt = counter++;

	msg[n++] = NET_OP_FRND_OFFER;

	msg[n++] = frnd_relay_window;

	msg[n++] = frnd_cache_size;

	msg[n++] = frnd_sublist_size;

	msg[n++] = neg->rssi;

	l_put_be16(neg->fn_cnt, msg + n);

	n += 2;

	print_packet("Tx-NET_OP_FRND_OFFER", msg, n);

	mesh_net_transport_send(neg->net, 0, true,

			mesh_net_get_iv_index(neg->net), 0,

			0, 0, neg->low_power_node,

			msg, n);

	/* Offer expires in 1.3 seconds, which is the max time for LPN to

	 * receive all offers, 1 second to make decision, and a little extra

	 */

	neg->timeout = l_timeout_create_ms(1000 + MAX_RESP_DELAY,

						response_timeout, neg, NULL);

	return;

cleanup:

	net_key_unref(neg->key_id);

	l_queue_remove(frnd_negotiations, neg);

	l_free(neg);

}

static uint8_t cache_size(uint8_t power)

{

	return 1 << power;

}

static bool match_by_lpn(const void *a, const void *b)

{

	const struct frnd_negotiation *neg = a;

	uint16_t lpn = L_PTR_TO_UINT(b);

	return neg->low_power_node == lpn;

}

static bool match_by_dst(const void *a, const void *b)

{

	const struct mesh_friend *frnd = a;

	uint16_t dst = L_PTR_TO_UINT(b);

	return frnd->dst == dst;

}

/* Scaling factors in 1/10 ms */

static const int32_t scaling[] = {

	10,

	15,

	20,

	15,

};

void friend_request(struct mesh_net *net, uint16_t src,

		uint8_t minReq, uint8_t delay, uint32_t timeout,

		uint16_t prev, uint8_t num_ele, uint16_t cntr,

		int8_t rssi)

{

	struct frnd_negotiation *neg;

	uint8_t rssiScale = (minReq >> 5) & 3;

	uint8_t winScale = (minReq >> 3) & 3;

	uint8_t minCache = (minReq >> 0) & 7;

	int32_t rsp_delay;

	l_debug("RSSI of Request: %d dbm", rssi);

	l_debug("Delay: %d ms", delay);

	l_debug("Poll Timeout of Request: %d ms", timeout * 100);

	l_debug("Previous Friend: %4.4x", prev);

	l_debug("Num Elem: %2.2x", num_ele);

	l_debug("Cache Requested: %d", cache_size(minCache));

	l_debug("Cache to offer: %d", frnd_cache_size);

	/* Determine our own suitability before

	 * deciding to participate in negotiation

	 */

	if (minCache == 0 || num_ele == 0)

		return;

	if (delay < 0x0A)

		return;

	if (timeout < 0x00000A || timeout > 0x34BBFF)

		return;

	if (cache_size(minCache) > frnd_cache_size)

		return;

	if (frnd_negotiations == NULL)

		frnd_negotiations = l_queue_new();

	/* TODO: Check RSSI, and then start Negotiation if appropriate */

	/* We are participating in this Negotiation */

	neg = l_new(struct frnd_negotiation, 1);

	l_queue_push_head(frnd_negotiations, neg);

	neg->net = net;

	neg->low_power_node = src;

	neg->lp_cnt = cntr;

	neg->rssi = rssi;

	neg->receive_delay = delay;

	neg->poll_timeout = timeout;

	neg->old_relay = prev;

	neg->num_ele = num_ele;

	/* RSSI (Negative Factor, larger values == less time)

	 * Scaling factor 0-3 == multiplier of 1.0 - 2.5

	 * Minimum factor of 1. Bit 1 adds additional factor

	 * of 1, bit zero and additional 0.5

	 */

	rsp_delay = -(rssi * scaling[rssiScale]);

	l_debug("RSSI Factor: %d ms", rsp_delay / 10);

	/* Relay Window (Positive Factor, larger values == more time)

	 * Scaling factor 0-3 == multiplier of 1.0 - 2.5

	 * Minimum factor of 1. Bit 1 adds additional factor

	 * of 1, bit zero and additional 0.5

	 */

	rsp_delay += frnd_relay_window * scaling[winScale];

	l_debug("Win Size Factor: %d ms",

			(frnd_relay_window * scaling[winScale]) / 10);

	/* Normalize to ms */

	rsp_delay /= 10;

	/* Range limits are 10-255 ms */

	if (rsp_delay < MIN_RESP_DELAY)

		rsp_delay = MIN_RESP_DELAY;

	else if (rsp_delay > MAX_RESP_DELAY)

		rsp_delay = MAX_RESP_DELAY;

	l_debug("Total Response Delay: %d ms", rsp_delay);

	/* Add in 100ms delay before start of "Offer Period" */

	rsp_delay += RESPONSE_DELAY;

	neg->timeout = l_timeout_create_ms(rsp_delay,

						response_delay, neg, NULL);

}

static struct l_queue *retired_lpns;

void friend_clear_confirm(struct mesh_net *net, uint16_t src,

					uint16_t lpn, uint16_t lpnCounter)

{

	struct frnd_negotiation *neg = l_queue_remove_if(frnd_negotiations,

					match_by_lpn, L_UINT_TO_PTR(lpn));

	l_debug("Friend Clear confirmed %4.4x (cnt %4.4x)", lpn, lpnCounter);

	if (!neg)

		return;

	l_timeout_remove(neg->timeout);

	l_queue_remove(frnd_negotiations, neg);

	l_free(neg);

}

static void friend_poll_timeout(struct l_timeout *timeout, void *user_data)

{

	struct mesh_friend *frnd = user_data;

	if (mesh_friend_clear(frnd->net, frnd))

		l_debug("Friend Poll Timeout %4.4x", frnd->dst);

	l_timeout_remove(frnd->timeout);

	frnd->timeout = NULL;

	/* Friend may be in either Network or Retired list, so try both */

	l_queue_remove(retired_lpns, frnd);

	mesh_friend_free(frnd);

}

void friend_clear(struct mesh_net *net, uint16_t src, uint16_t lpn,

				uint16_t lpnCounter, struct mesh_friend *frnd)

{

	uint8_t msg[5] = { NET_OP_FRND_CLEAR_CONFIRM };

	bool removed = false;

	uint16_t lpnDelta;

	if (frnd) {

		lpnDelta = lpnCounter - frnd->lp_cnt;

		/* Ignore old Friend Clear commands */

		if (lpnDelta > 0x100)

			return;

		/* Move friend from Network list to Retired list */

		removed = mesh_friend_clear(net, frnd);

		if (removed) {

			struct mesh_friend *old;

			struct frnd_negotiation *neg = l_queue_remove_if(

						frnd_negotiations,

						match_by_lpn,

						L_UINT_TO_PTR(frnd->dst));

			/* Cancel any negotiations or clears */

			if (neg) {

				l_timeout_remove(neg->timeout);

				l_free(neg);

			}

			/* Create Retired LPN list if needed */

			if (retired_lpns == NULL)

				retired_lpns = l_queue_new();

			/* Find any duplicates */

			old = l_queue_find(retired_lpns, match_by_dst,

						L_UINT_TO_PTR(lpn));

			/* Force time-out of old friendship */

			if (old)

				friend_poll_timeout(old->timeout, old);

			/* Retire this LPN (keeps timeout running) */

			l_queue_push_tail(retired_lpns, frnd);

		}

	} else {

		frnd = l_queue_find(retired_lpns, match_by_dst,

						L_UINT_TO_PTR(lpn));

		if (!frnd)

			return;

		lpnDelta = lpnCounter - frnd->lp_cnt;

		/* Ignore old Friend Clear commands */

		if (!lpnDelta || (lpnDelta > 0x100))

			return;

	}

	l_debug("Friend Cleared %4.4x (%4.4x)", lpn, lpnCounter);

	l_put_be16(lpn, msg + 1);

	l_put_be16(lpnCounter, msg + 3);

	mesh_net_transport_send(net, 0, false,

			mesh_net_get_iv_index(net), DEFAULT_TTL,

			0, 0, src,

			msg, sizeof(msg));

}

static void clear_retry(struct l_timeout *timeout, void *user_data)

{

	struct frnd_negotiation *neg = user_data;

	uint8_t msg[5] = { NET_OP_FRND_CLEAR };

	uint32_t secs = 1 << neg->receive_delay;

	l_put_be16(neg->low_power_node, msg + 1);

	l_put_be16(neg->lp_cnt, msg + 3);

	mesh_net_transport_send(neg->net, 0, false,

			mesh_net_get_iv_index(neg->net), DEFAULT_TTL,

			0, 0, neg->old_relay,

			msg, sizeof(msg));

	if (secs && ((secs << 1) < neg->poll_timeout/10)) {

		neg->receive_delay++;

		l_debug("Try FRND_CLR again in %d seconds (total timeout %d)",

						secs, neg->poll_timeout/10);

		l_timeout_modify(neg->timeout, secs);

	} else {

		l_debug("FRND_CLR timed out %d", secs);

		l_timeout_remove(timeout);

		l_queue_remove(frnd_negotiations, neg);

		l_free(neg);

	}

}

static void friend_delay_rsp(struct l_timeout *timeout, void *user_data)

{

	struct mesh_friend *frnd = user_data;

	struct mesh_friend_msg *pkt = frnd->pkt;

	struct mesh_net *net = frnd->net;

	uint32_t net_seq, iv_index;

	uint8_t upd[7] = { NET_OP_FRND_UPDATE };

	l_timeout_remove(timeout);

	if (pkt == NULL)

		goto update;

	if (pkt->ctl) {

		/* Make sure we don't change the bit-sense of MD,

		 * once it has been set because that would cause

		 * a "Dirty Nonce" security violation

		 */

		if (((pkt->u.one[0].hdr >> OPCODE_HDR_SHIFT) & OPCODE_MASK) ==

						NET_OP_SEG_ACKNOWLEDGE) {

			bool rly = !!((pkt->u.one[0].hdr >> RELAY_HDR_SHIFT) &

									true);

			uint16_t seqZero = pkt->u.one[0].hdr >>

							SEQ_ZERO_HDR_SHIFT;

			seqZero &= SEQ_ZERO_MASK;

			l_debug("Fwd ACK pkt %6.6x-%8.8x",

					pkt->u.one[0].seq,

					pkt->iv_index);

			pkt->u.one[0].sent = true;

			mesh_net_ack_send(net, frnd->net_key_cur,

					pkt->iv_index, pkt->ttl,

					pkt->u.one[0].seq, pkt->src, pkt->dst,

					rly, seqZero,

					l_get_be32(pkt->u.one[0].data));

		} else {

			l_debug("Fwd CTL pkt %6.6x-%8.8x",

					pkt->u.one[0].seq,

					pkt->iv_index);

			print_packet("Frnd-CTL",

					pkt->u.one[0].data, pkt->last_len);

			pkt->u.one[0].sent = true;

			mesh_net_transport_send(net, frnd->net_key_cur, false,

					pkt->iv_index, pkt->ttl,

					pkt->u.one[0].seq, pkt->src, pkt->dst,

					pkt->u.one[0].data, pkt->last_len);

		}

	} else {

		/* If segments after this one, then More Data must be TRUE */

		uint8_t len;

		if (pkt->cnt_out < pkt->cnt_in)

			len = sizeof(pkt->u.s12[0].data);

		else

			len = pkt->last_len;

		l_debug("Fwd FRND pkt %6.6x",

				pkt->u.s12[pkt->cnt_out].seq);

		print_packet("Frnd-Msg", pkt->u.s12[pkt->cnt_out].data, len);

		pkt->u.s12[pkt->cnt_out].sent = true;

		mesh_net_send_seg(net, frnd->net_key_cur,

				pkt->iv_index,

				pkt->ttl,

				pkt->u.s12[pkt->cnt_out].seq,

				pkt->src, pkt->dst,

				pkt->u.s12[pkt->cnt_out].hdr,

				pkt->u.s12[pkt->cnt_out].data, len);

	}

	return;

update:

	/* No More Data -- send Update message with md = false */

	net_seq = mesh_net_get_seq_num(net);

	l_debug("Fwd FRND UPDATE %6.6x with MD == 0", net_seq);

	frnd->last = frnd->seq;

	mesh_net_get_snb_state(net, upd + 1, &iv_index);

	l_put_be32(iv_index, upd + 2);

	upd[6] = false; /* Queue is Empty */

	print_packet("Update", upd, sizeof(upd));

	mesh_net_transport_send(net, frnd->net_key_cur, false,

			mesh_net_get_iv_index(net), 0,

			net_seq, 0, frnd->dst,

			upd, sizeof(upd));

	mesh_net_next_seq_num(net);

}

void friend_poll(struct mesh_net *net, uint16_t src, bool seq,

					struct mesh_friend *frnd)

{

	struct frnd_negotiation *neg;

	struct mesh_friend_msg *pkt;

	bool md;

	neg = l_queue_find(frnd_negotiations, match_by_lpn, L_UINT_TO_PTR(src));

	if (neg && !neg->clearing) {

		uint8_t msg[5] = { NET_OP_FRND_CLEAR };

		l_debug("Won negotiation for %4.4x", neg->low_power_node);

		/* This call will clean-up and replace if already friends */

		frnd = mesh_friend_new(net, src, neg->num_ele,

						neg->receive_delay,

						neg->wrfrw,

						neg->poll_timeout,

						neg->fn_cnt, neg->lp_cnt);

		frnd->timeout = l_timeout_create_ms(

					frnd->poll_timeout * 100,

					friend_poll_timeout, frnd, NULL);

		l_timeout_remove(neg->timeout);

		net_key_unref(neg->key_id);

		neg->key_id = 0;

		if (neg->old_relay == 0 ||

				neg->old_relay == mesh_net_get_address(net)) {

			l_queue_remove(frnd_negotiations, neg);

			l_free(neg);

		} else {

			neg->clearing = true;

			l_put_be16(neg->low_power_node, msg + 1);

			l_put_be16(neg->lp_cnt, msg + 3);

			mesh_net_transport_send(net, 0, false,

					mesh_net_get_iv_index(net), DEFAULT_TTL,

					0, 0, neg->old_relay,

					msg, sizeof(msg));

			/* Reuse receive_delay as a shift counter to

			 * time-out FRIEND_CLEAR

			 */

			neg->receive_delay = 1;

			neg->timeout = l_timeout_create(1, clear_retry,

								neg, NULL);

		}

	}

	if (!frnd)

		return;

	/* Reset Poll Timeout */

	l_timeout_modify_ms(frnd->timeout, frnd->poll_timeout * 100);

	if (!l_queue_length(frnd->pkt_cache))

		goto update;

	if (frnd->seq != frnd->last && frnd->seq != seq) {

		pkt = l_queue_peek_head(frnd->pkt_cache);

		if (pkt->cnt_out < pkt->cnt_in) {

			pkt->cnt_out++;

		} else {

			pkt = l_queue_pop_head(frnd->pkt_cache);

			l_free(pkt);

		}

	}

	pkt = l_queue_peek_head(frnd->pkt_cache);

	if (!pkt)

		goto update;

	frnd->seq = seq;

	frnd->last = !seq;

	md = !!(l_queue_length(frnd->pkt_cache) > 1);

	if (pkt->ctl) {

		/* Make sure we don't change the bit-sense of MD,

		 * once it has been set because that would cause

		 * a "Dirty Nonce" security violation

		 */

		if (!(pkt->u.one[0].sent))

			pkt->u.one[0].md = md;

	} else {

		/* If segments after this one, then More Data must be TRUE */

		if (pkt->cnt_out < pkt->cnt_in)

			md = true;

		/* Make sure we don't change the bit-sense of MD, once

		 * it has been set because that would cause a

		 * "Dirty Nonce" security violation

		 */

		if (!(pkt->u.s12[pkt->cnt_out].sent))

			pkt->u.s12[pkt->cnt_out].md = md;

	}

	frnd->pkt = pkt;

	l_timeout_create_ms(frnd->frd, friend_delay_rsp, frnd, NULL);

	return;

update:

	frnd->pkt = NULL;

	l_timeout_create_ms(frnd->frd, friend_delay_rsp, frnd, NULL);

}

void friend_sub_add(struct mesh_net *net, struct mesh_friend *frnd,

					const uint8_t *pkt, uint8_t len)

{

	uint16_t *new_list;

	uint32_t net_seq;

	uint8_t plen = len;

	uint8_t msg[] = { NET_OP_PROXY_SUB_CONFIRM, 0 };

	if (!frnd || MAX_FRND_GROUPS < frnd->grp_cnt + (len/2))

		return;

	msg[1] = *pkt++;

	plen--;

	/* Sanity Check Values, abort if any illegal */

	while (plen >= 2) {

		plen -= 2;

		if (l_get_be16(pkt + plen) < 0x8000)

			return;

	}

	new_list = l_malloc(frnd->grp_cnt * sizeof(uint16_t) + len);

	if (frnd->grp_list)

		memcpy(new_list, frnd->grp_list,

				frnd->grp_cnt * sizeof(uint16_t));

	while (len >= 2) {

		new_list[frnd->grp_cnt++] = l_get_be16(pkt);

		pkt += 2;

		len -= 2;

	}

	l_free(frnd->grp_list);

	frnd->grp_list = new_list;

	print_packet("Tx-NET_OP_PROXY_SUB_CONFIRM", msg, sizeof(msg));

	net_seq = mesh_net_get_seq_num(net);

	mesh_net_transport_send(net, frnd->net_key_cur, false,

			mesh_net_get_iv_index(net), 0,

			net_seq, 0, frnd->dst,

			msg, sizeof(msg));

	mesh_net_next_seq_num(net);

}

void friend_sub_del(struct mesh_net *net, struct mesh_friend *frnd,

					const uint8_t *pkt, uint8_t len)

{

	uint32_t net_seq;

	uint8_t msg[] = { NET_OP_PROXY_SUB_CONFIRM, 0 };

	int i;

	if (!frnd)

		return;

	msg[1] = *pkt++;

	len--;

	while (len >= 2) {

		uint16_t grp = l_get_be16(pkt);

		for (i = frnd->grp_cnt - 1; i >= 0; i--) {

			if (frnd->grp_list[i] == grp) {

				frnd->grp_cnt--;

				memcpy(&frnd->grp_list[i],

						&frnd->grp_list[i + 1],

						(frnd->grp_cnt - i) * 2);

				break;

			}

		}

		len -= 2;

		pkt += 2;

	}

	print_packet("Tx-NET_OP_PROXY_SUB_CONFIRM", msg, sizeof(msg));

	net_seq = mesh_net_get_seq_num(net);

	mesh_net_transport_send(net, frnd->net_key_cur, false,

			mesh_net_get_iv_index(net), 0,

			net_seq, 0, frnd->dst,

			msg, sizeof(msg));

	mesh_net_next_seq_num(net);

}

/* Low-Power-Node role */

struct frnd_offers {

	uint16_t fn_cnt;

	uint16_t src;

	uint8_t window;

	uint8_t cache;

	uint8_t sub_list_size;

	int8_t local_rssi;

	int8_t remote_rssi;

};

#define MAX_POLL_RETRIES	5

static bool quick_pick;

static uint8_t poll_cnt;

static struct l_queue *offers;

static uint16_t old_friend;

static uint16_t fn_cnt, cnt = 0xffff;

static uint32_t poll_period_ms;

static struct l_timeout *poll_retry_to;

static struct l_timeout *poll_period_to;

static uint32_t lpn_key_id;

static uint32_t new_lpn_id;

void frnd_offer(struct mesh_net *net, uint16_t src, uint8_t window,

			uint8_t cache, uint8_t sub_list_size,

			int8_t r_rssi, int8_t l_rssi, uint16_t fn_cnt)

{

	struct frnd_offers *offer;

	l_debug("RSSI of Offer: %d dbm", l_rssi);

	/* Ignore RFU window value 0 */

	if (window == 0)

		return;

	if (mesh_net_get_friend(net))

		return;

	if (quick_pick) {

		if (mesh_net_set_friend(net, src)) {

			old_friend = src;

			frnd_poll(net, false);

		}

		return;

	}

	offer = l_new(struct frnd_offers, 1);

	offer->src = src;

	offer->window = window;

	offer->cache = cache;

	offer->sub_list_size = sub_list_size;

	offer->local_rssi = l_rssi;

	offer->remote_rssi = r_rssi;

	offer->fn_cnt = fn_cnt;

	l_queue_push_tail(offers, offer);

}

static void frnd_poll_timeout(struct l_timeout *timeout, void *user_data)

{

	struct mesh_net *net = user_data;

	frnd_poll(net, true);

}

static void frnd_negotiated_to(struct l_timeout *timeout, void *user_data)

{

	struct mesh_net *net = user_data;

	l_debug("frnd_negotiated_to");

	if (!mesh_net_get_friend(net)) {

		l_timeout_remove(poll_period_to);

		poll_period_to = NULL;

		return;

	}

	if (!poll_retry_to)

		frnd_poll(net, false);

}

void frnd_poll_cancel(struct mesh_net *net)

{

	l_timeout_remove(poll_retry_to);

	poll_retry_to = NULL;

}

void frnd_poll(struct mesh_net *net, bool retry)

{

	uint32_t key_id = lpn_key_id;

	uint32_t net_seq;

	uint8_t msg[2] = { NET_OP_FRND_POLL };

	bool seq = mesh_net_get_frnd_seq(net);

	/* Check if we are in Phase 2 of Key Refresh */

	if (new_lpn_id) {

		uint8_t phase;

		uint16_t net_idx = mesh_net_get_primary_idx(net);

		uint8_t status =

			mesh_net_key_refresh_phase_get(net, net_idx, &phase);

		if (status == MESH_STATUS_SUCCESS &&

				phase == KEY_REFRESH_PHASE_TWO)

			key_id = new_lpn_id;

	}

	if (!retry) {

		poll_cnt = MAX_POLL_RETRIES;

		seq = !seq;

		mesh_net_set_frnd_seq(net, seq);

	} else if (!(poll_cnt--)) {

		l_debug("Lost Friendship with %4.4x", old_friend);

		l_timeout_remove(poll_period_to);

		poll_period_to = NULL;

		frnd_poll_cancel(net);

		net_key_unref(lpn_key_id);

		net_key_unref(new_lpn_id);

		new_lpn_id = lpn_key_id = 0;

		mesh_net_set_friend(net, 0);

		return;

	}

	if (poll_retry_to)

		l_timeout_remove(poll_retry_to);

	l_debug("TX-FRIEND POLL %d", seq);

	msg[1] = seq;

	net_seq = mesh_net_get_seq_num(net);

	mesh_net_transport_send(net, key_id, true,

			mesh_net_get_iv_index(net), 0,

			net_seq, 0, mesh_net_get_friend(net),

			msg, sizeof(msg));

	mesh_net_next_seq_num(net);

	poll_retry_to = l_timeout_create_ms(1000, frnd_poll_timeout, net, NULL);

	/* Reset Poll Period for next "Wake Up" */

	if (poll_period_to)

		l_timeout_modify_ms(poll_period_to, poll_period_ms);

	else

		poll_period_to = l_timeout_create_ms(poll_period_ms,

						frnd_negotiated_to, net, NULL);

}

void frnd_ack_poll(struct mesh_net *net)

{

	/* Start new POLL, but only if not already Polling */

	if (poll_retry_to == NULL)

		frnd_poll(net, false);

}

static void req_timeout(struct l_timeout *timeout, void *user_data)

{

	struct mesh_net *net = user_data;

	struct frnd_offers *best;

	struct frnd_offers *offer = l_queue_pop_head(offers);

	uint32_t key_id = 0;

	bool res;

	l_timeout_remove(timeout);

	best = offer;

	while (offer) {

		/* Screen out clearly inferior RSSI friends first */

		if (offer->local_rssi < -40 && offer->remote_rssi < -40) {

			if (best->local_rssi + 20 < offer->local_rssi ||

				best->remote_rssi + 20 < offer->remote_rssi) {

				l_free(best);

				best = offer;

				offer = l_queue_pop_head(offers);

				continue;

			}

		}

		/* Otherwise use best Windows, with Cache size as tie breaker */

		if (best->window > offer->window ||

				(best->window == offer->window &&

				 best->cache < offer->cache)) {

			l_free(best);

			best = offer;

		} else if (best != offer)

			l_free(offer);

		offer = l_queue_pop_head(offers);

	}

	net_key_unref(lpn_key_id);

	net_key_unref(new_lpn_id);

	new_lpn_id = lpn_key_id = 0;

	if (mesh_net_get_friend(net)) {

		l_free(best);

		return;

	} else if (!best) {

		l_debug("No Offers Received");

		return;

	}

	fn_cnt = best->fn_cnt;

	res = mesh_net_get_key(net, false, mesh_net_get_primary_idx(net),

								&key_id);

	if (!res)

		return;

	lpn_key_id = net_key_frnd_add(key_id, mesh_net_get_address(net),

						best->src, cnt, best->fn_cnt);

	if (!lpn_key_id)

		return;

	res = mesh_net_get_key(net, true, mesh_net_get_primary_idx(net),

								&key_id);

	if (!res)

		goto old_keys_only;

	new_lpn_id = net_key_frnd_add(key_id, mesh_net_get_address(net),

						best->src, cnt, best->fn_cnt);

old_keys_only: