{
uint32_t seq = net->seq_num++;
- /* Cap out-of-range seq_num max value to +1. Out of range
+ /*
+ * Cap out-of-range seq_num max value to +1. Out of range
* seq_nums will not be sent as they would violate spec.
* This condition signals a runaway seq_num condition, and
* the node must wait for a completed IV Index update procedure
struct mesh_sar *sar;
sar = l_malloc(size);
-
memset(sar, 0, size);
-
return sar;
}
void *old = l_queue_remove_if(frnd->pkt_cache,
match_ack, rx);
- if (old) {
- if (old_head == old) {
- /*
- * If we are discarding head for any
- * reason, reset FRND SEQ
- */
- frnd->u.active.last =
- frnd->u.active.seq;
- }
-
- l_free(old);
- } else
+ if (!old)
break;
+ if (old_head == old)
+ /*
+ * If we are discarding head for any
+ * reason, reset FRND SEQ
+ */
+ frnd->u.active.last = frnd->u.active.seq;
+
+ l_free(old);
+
} while (true);
}
data += 12;
hdr += (1 << SEGO_HDR_SHIFT);
}
+
frnd_msg->u.s12[seg_max].seq = seq;
frnd_msg->cnt_in = seg_max;
frnd_msg->last_len = size % 12;
memcpy(frnd_msg->u.one[0].data, data, size);
frnd_msg->last_len = size;
}
+
frnd_msg->u.one[0].hdr = hdr;
frnd_msg->u.one[0].seq = seq;
}
return;
sar->msg_timeout = NULL;
-
mesh_sar_free(sar);
}
send_net_ack(net, sar_in, expected);
msg_rxed(net, frnd, iv_index, ttl, seq, net_idx,
- sar_in->remote, dst,
- key_aid, true, szmic,
- sar_in->seqZero,
- sar_in->buf, sar_in->len);
+ sar_in->remote, dst, key_aid, true, szmic,
+ sar_in->seqZero, sar_in->buf, sar_in->len);
/* Kill Inter-Seg timeout */
l_timeout_remove(sar_in->seg_timeout);
uint32_t hdr = opcode << OPCODE_HDR_SHIFT;
uint8_t frnd_ttl = ttl - 1;
- if (friend_packet_queue(net, iv_index,
- true, frnd_ttl,
- seq,
- src, dst,
- hdr,
- pkt, len))
+ if (friend_packet_queue(net, iv_index, true, frnd_ttl, seq,
+ src, dst, hdr, pkt, len))
return true;
}
return false;
print_packet("Rx-NET_OP_FRND_POLL", pkt, len);
- friend_poll(net, src, !!(pkt[0]),
- l_queue_find(net->friends,
- match_by_friend,
- L_UINT_TO_PTR(src)));
+ friend_poll(net, src, !!(pkt[0]), l_queue_find(net->friends,
+ match_by_friend, L_UINT_TO_PTR(src)));
break;
case NET_OP_FRND_REQUEST:
print_packet("Rx-NET_OP_FRND_CLEAR", pkt, len);
friend_clear(net, src, l_get_be16(pkt), l_get_be16(pkt + 2),
- l_queue_find(net->friends,
- match_by_friend,
+ l_queue_find(net->friends, match_by_friend,
L_UINT_TO_PTR(l_get_be16(pkt))));
l_debug("Remaining Friends: %d", l_queue_length(net->friends));
break;
return false;
print_packet("Rx-NET_OP_PROXY_SUB_REMOVE", pkt, len);
- friend_sub_del(net, l_queue_find(net->friends,
- match_by_friend, L_UINT_TO_PTR(src)),
- pkt, len);
+ friend_sub_del(net, l_queue_find(net->friends, match_by_friend,
+ L_UINT_TO_PTR(src)), pkt, len);
break;
case NET_OP_PROXY_SUB_CONFIRM:
break;
}
- if (n) {
- mesh_net_transport_send(net, 0, 0,
- mesh_net_get_iv_index(net), rsp_ttl,
- 0, dst & 0x8000 ? 0 : dst, src,
- msg, n);
- }
+ if (n)
+ mesh_net_transport_send(net, 0, 0, mesh_net_get_iv_index(net),
+ rsp_ttl, 0, dst & 0x8000 ? 0 : dst,
+ src, msg, n);
return true;
}
print_packet("RX: Network [clr] :", packet + 2, size);
- if (!mesh_crypto_packet_parse(packet + 2, size,
- &net_ctl, &net_ttl,
- &net_seq,
- &net_src, &net_dst,
- &cache_cookie,
- &net_opcode,
- &net_segmented,
- &net_key_id,
- &net_szmic, &net_relay, &net_seqZero,
- &net_segO, &net_segN,
- &msg, &app_msg_len)) {
+ if (!mesh_crypto_packet_parse(packet + 2, size, &net_ctl, &net_ttl,
+ &net_seq, &net_src, &net_dst,
+ &cache_cookie, &net_opcode,
+ &net_segmented, &net_key_id, &net_szmic,
+ &net_relay, &net_seqZero, &net_segO,
+ &net_segN, &msg, &app_msg_len)) {
l_error("Failed to parse packet content");
return RELAY_NONE;
}
if (is_us(net, net_src, true))
return RELAY_NONE;
- /* As a Relay, suppress repeats of last N packets that pass through */
- /* The "cache_cookie" should be unique part of App message */
+ /*
+ * As a Relay, suppress repeats of last N packets that pass through
+ * The "cache_cookie" should be unique part of App message.
+ */
if (msg_in_cache(net, net_src, net_seq, cache_cookie))
return RELAY_NONE;
/* If this is an ACK to our friend queue-only */
if (is_lpn_friend(net, net_dst))
friend_ack_rxed(net, iv_index, net_seq,
- net_src, net_dst,
- msg);
+ net_src, net_dst, msg);
else
ack_received(net, false,
net_src, net_dst,
net_seqZero,
l_get_be32(msg + 3));
} else {
- ctl_received(net, key_id,
- iv_index,
- net_ttl, net_seq, net_src,
- net_dst, net_opcode, rssi,
- msg, app_msg_len);
+ ctl_received(net, key_id, iv_index, net_ttl,
+ net_seq, net_src, net_dst,
+ net_opcode, rssi, msg,
+ app_msg_len);
}
} else if (net_segmented) {
- /* If we accept SAR packets to non-Unicast, then
+ /*
+ * If we accept SAR packets to non-Unicast, then
* Friend Sar at least needs to be Unicast Only
*/
if (is_lpn_friend(net, net_dst) &&
!(net_dst & 0x8000)) {
- /* Check TTL >= 2 before accepting segments
+ /*
+ * Check TTL >= 2 before accepting segments
* for Friends
*/
if (net_ttl >= 2) {
- friend_seg_rxed(net, iv_index,
- net_ttl, net_seq,
- net_src, net_dst,
+ friend_seg_rxed(net, iv_index, net_ttl,
+ net_seq, net_src, net_dst,
l_get_be32(packet + 2 + 9),
msg, app_msg_len);
}
} else {
seg_rxed(net, NULL, iv_index, net_ttl,
- net_seq, net_idx,
- net_src, net_dst,
- net_key_id,
- net_szmic, net_seqZero,
- net_segO, net_segN,
+ net_seq, net_idx, net_src,
+ net_dst, net_key_id, net_szmic,
+ net_seqZero, net_segO, net_segN,
msg, app_msg_len);
}
} else {
- msg_rxed(net, NULL,
- iv_index,
- net_ttl,
- net_seq,
- net_idx,
- net_src, net_dst,
- net_key_id,
- false, false,
- net_seq & SEQ_ZERO_MASK,
- msg, app_msg_len);
+ msg_rxed(net, NULL, iv_index, net_ttl, net_seq, net_idx,
+ net_src, net_dst, net_key_id, false,
+ false, net_seq & SEQ_ZERO_MASK, msg,
+ app_msg_len);
}
/* If this is one of our Unicast addresses, disallow relay */
rssi = data->info->rssi;
}
- relay_advice = packet_received(net, key_id, iv_index,
- out, out_size, rssi);
+ relay_advice = packet_received(net, key_id, iv_index, out, out_size,
+ rssi);
if (relay_advice > data->relay_advice) {
data->iv_index = iv_index;
data->relay_advice = relay_advice;
l_debug("iv_upd_state = IV_UPD_NORMAL_HOLD");
net->iv_upd_state = IV_UPD_NORMAL_HOLD;
l_timeout_modify(net->iv_update_timeout, IV_IDX_UPD_MIN);
+
if (net->iv_update)
mesh_net_set_seq_num(net, 0);
net->iv_update_timeout = NULL;
l_debug("iv_upd_state = IV_UPD_NORMAL");
net->iv_upd_state = IV_UPD_NORMAL;
+
if (net->iv_update)
mesh_net_set_seq_num(net, 0);
net->iv_update = false;
+
if (net->seq_num > IV_UPDATE_SEQ_TRIGGER)
mesh_net_iv_index_update(net);
break;
l_debug("Key refresh procedure phase 2: start using new net TX keys");
subnet->key_refresh = 1;
subnet->net_key_tx = subnet->net_key_upd;
- /* TODO: Provisioner may need to stay in phase three until
+ /*
+ * TODO: Provisioner may need to stay in phase three until
* it hears beacons from all the nodes
*/
subnet->kr_phase = KEY_REFRESH_PHASE_TWO;
if (iv_index == net->iv_index && !net->iv_update)
return;
- /* Other devices will be accepting old or new iv_index,
+ /*
+ * Other devices will be accepting old or new iv_index,
* but we don't know how far through update they are.
* Starting permissive state will allow us maximum
* (96 hours) to resync
l_debug("iv_upd_state = IV_UPD_UPDATING");
net->iv_upd_state = IV_UPD_UPDATING;
net->iv_update_timeout = l_timeout_create(
- IV_IDX_UPD_MIN, iv_upd_to, net, NULL);
+ IV_IDX_UPD_MIN, iv_upd_to, net, NULL);
} else {
l_debug("iv_upd_state = IV_UPD_NORMAL");
net->iv_upd_state = IV_UPD_NORMAL;
* Ignore the beacon if it doesn't change anything, unless we're
* doing IV Recovery
*/
- if (net->iv_upd_state == IV_UPD_INIT ||
- ivi != net->iv_index || ivu != net->iv_update)
+ if (net->iv_upd_state == IV_UPD_INIT || ivi != net->iv_index ||
+ ivu != net->iv_update)
update_iv_ivu_state(net, ivi, ivu);
if (kr != local_kr)
if (phase == KEY_REFRESH_PHASE_TWO) {
subnet->key_refresh = 1;
subnet->net_key_tx = subnet->net_key_upd;
+
if (net->beacon_enable) {
/* Switch beaconing key */
net_key_beacon_disable(subnet->net_key_cur);
l_debug("iv_upd_state = IV_UPD_UPDATING");
mesh_net_flush_msg_queues(net);
+
if (!mesh_config_write_iv_index(node_config_get(net->node),
net->iv_index + 1, true))
return false;
return false;
if (!net_key_encrypt(subnet->net_key_tx, msg->iv_index, packet + 1,
- packet_len)) {
+ packet_len)) {
l_error("Failed to encode packet");
return false;
}
}
void mesh_net_send_seg(struct mesh_net *net, uint32_t net_key_id,
- uint32_t iv_index,
- uint8_t ttl,
- uint32_t seq,
- uint16_t src, uint16_t dst,
- uint32_t hdr,
- const void *seg, uint16_t seg_len)
+ uint32_t iv_index, uint8_t ttl, uint32_t seq,
+ uint16_t src, uint16_t dst, uint32_t hdr,
+ const void *seg, uint16_t seg_len)
{
uint8_t packet[30];
uint8_t packet_len;
l_debug("SEQ0: %6.6x", seq);
l_debug("segO: %d", segO);
- if (!mesh_crypto_packet_build(false, ttl,
- seq,
- src, dst,
- 0,
- segmented, app_key_id,
- szmic, false, seqZero,
- segO, segN,
- seg, seg_len,
- packet + 1, &packet_len)) {
+ if (!mesh_crypto_packet_build(false, ttl, seq, src, dst, 0,
+ segmented, app_key_id, szmic, false,
+ seqZero, segO, segN, seg, seg_len,
+ packet + 1, &packet_len)) {
l_error("Failed to build packet");
return;
}
segmented |= !!(seg_max);
/* First enqueue to any Friends and internal models */
- result = msg_rxed(net, false, iv_index, ttl,
- seq,
- net_idx,
- src, dst,
- key_aid, segmented,
- szmic, seq & SEQ_ZERO_MASK,
+ result = msg_rxed(net, false, iv_index, ttl, seq, net_idx, src, dst,
+ key_aid, segmented, szmic, seq & SEQ_ZERO_MASK,
msg, msg_len);
/*
payload->id = ++net->sar_id_next;
/* Single thread SAR messages to same Unicast DST */
- if (NULL != l_queue_find(net->sar_out, match_sar_remote,
+ if (l_queue_find(net->sar_out, match_sar_remote,
L_UINT_TO_PTR(dst))) {
/* Delay sending Outbound SAR unless prior
* SAR to same DST has completed */
return result;
}
-void mesh_net_ack_send(struct mesh_net *net, uint32_t key_id,
- uint32_t iv_index,
- uint8_t ttl,
- uint32_t seq,
- uint16_t src, uint16_t dst,
- bool rly, uint16_t seqZero,
- uint32_t ack_flags)
+void mesh_net_ack_send(struct mesh_net *net, uint32_t key_id, uint32_t iv_index,
+ uint8_t ttl, uint32_t seq, uint16_t src, uint16_t dst,
+ bool rly, uint16_t seqZero, uint32_t ack_flags)
{
uint32_t hdr;
uint8_t data[7];
hdr |= (seqZero & SEQ_ZERO_MASK) << SEQ_ZERO_HDR_SHIFT;
l_put_be32(hdr, data);
l_put_be32(ack_flags, data + 3);
- if (!mesh_crypto_packet_build(true, ttl,
- seq,
- src, dst,
- NET_OP_SEG_ACKNOWLEDGE,
- false, /* Not Segmented */
- 0, /* No Key ID associated */
- false, rly, seqZero,
- 0, 0, /* no segO or segN */
- data + 1, 6,
- pkt + 1, &pkt_len)) {
+
+ /* Not Segmented, no Key ID associated, no segO or segN */
+ if (!mesh_crypto_packet_build(true, ttl, seq, src, dst,
+ NET_OP_SEG_ACKNOWLEDGE, false, 0, false,
+ rly, seqZero, 0, 0, data + 1, 6,
+ pkt + 1, &pkt_len))
return;
- }
if (!key_id) {
struct mesh_subnet *subnet = get_primary_subnet(net);
uint32_t hdr = msg[0] << OPCODE_HDR_SHIFT;
uint8_t frnd_ttl = ttl;
- if (friend_packet_queue(net, iv_index,
- true, frnd_ttl,
- mesh_net_next_seq_num(net),
- src, dst,
- hdr,
- msg + 1, msg_len - 1)) {
+ if (friend_packet_queue(net, iv_index, true, frnd_ttl,
+ mesh_net_next_seq_num(net), src, dst,
+ hdr, msg + 1, msg_len - 1))
return;
- }
}
/* Deliver to Local entities if applicable */
- if (!(dst & 0x8000) && src >= net->src_addr && src <= net->last_addr) {
- result = ctl_received(net, key_id,
- iv_index, ttl,
- mesh_net_next_seq_num(net),
- src, dst,
+ if (!(dst & 0x8000) && src >= net->src_addr && src <= net->last_addr)
+ result = ctl_received(net, key_id, iv_index, ttl,
+ mesh_net_next_seq_num(net), src, dst,
msg[0], 0, msg + 1, msg_len - 1);
- }
if (!key_id) {
struct mesh_subnet *subnet = l_queue_find(net->subnets,
return;
}
- if (!mesh_crypto_packet_build(true, ttl,
- use_seq,
- src, dst,
- msg[0],
- false, 0,
- false, false, 0,
- 0, 0,
- msg + 1, msg_len - 1,
- pkt + 1, &pkt_len))
+ if (!mesh_crypto_packet_build(true, ttl, use_seq, src, dst, msg[0],
+ false, 0, false, false, 0, 0, 0, msg + 1,
+ msg_len - 1, pkt + 1, &pkt_len))
return;
if (!net_key_encrypt(key_id, iv_index, pkt + 1, pkt_len)) {
n += 2;
mesh_net_transport_send(net, 0, 0, mesh_net_get_iv_index(net),
- hb->pub_ttl, 0, 0, hb->pub_dst, msg, n);
+ hb->pub_ttl, 0, 0, hb->pub_dst, msg, n);
}
void mesh_net_heartbeat_init(struct mesh_net *net)
uint32_t mesh_net_friend_timeout(struct mesh_net *net, uint16_t addr)
{
struct mesh_friend *frnd = l_queue_find(net->friends, match_by_friend,
- L_UINT_TO_PTR(addr));
+ L_UINT_TO_PTR(addr));
if (!frnd)
return 0;
projects / platform / upstream / bluez.git / commitdiff