MAIN() { ARGV_UNUSED; #ifndef KEIL if ( argc < 3 ) { printf("%s <read pipe path> <write pipe path>\n", argv[0]); return 0; } #endif #if defined ZB_NS_BUILD && defined ZB_SECURITY if ( argc > 3 && !strcmp(argv[3], "auth") ) { g_auth = 1; } #endif /* Init device, load IB values from nvram or set it to default */ #ifndef ZB8051 ZB_INIT("zdo_zed", argv[1], argv[2]); #else ZB_INIT("zdo_zed", "2", "2"); #endif /* set ieee addr */ ZB_IEEE_ADDR_COPY(ZB_PIB_EXTENDED_ADDRESS(), &g_ieee_addr); #ifndef ZB_NS_BUILD ZB_UPDATE_LONGMAC(); #endif #ifdef ZB_SECURITY /* turn security */ ZB_NIB_SECURITY_LEVEL() = g_auth ? 1 : 0; #endif /* become an ED */ ZB_NIB_DEVICE_TYPE() = ZB_NWK_DEVICE_TYPE_ED; ZB_PIB_RX_ON_WHEN_IDLE() = ZB_TRUE; if (zdo_dev_start() != RET_OK) { TRACE_MSG(TRACE_ERROR, "zdo_dev_start failed", (FMT__0)); } else { zdo_main_loop(); } TRACE_DEINIT(); MAIN_RETURN(0); }
/* 7.3.6 sends orphan notification command return RET_OK, RET_ERROR */ zb_ret_t zb_orphan_notification_command() { zb_ret_t ret; zb_uint8_t mhr_len; zb_uint8_t *ptr = NULL; zb_mac_mhr_t mhr; /* Orphan notification command 1. Fill MHR fields - set dst pan id = 0xffff - set dst addr = 0xffff 2. Fill FCF - set frame pending = 0, ack req = 0, security enabled = 0 - set dst addr mode to ZB_ADDR_16BIT_DEV_OR_BROADCAST - set src addr mode to ZB_ADDR_64BIT_DEV 3. Set command frame id = 0x07 (Beacon request) */ TRACE_MSG(TRACE_MAC2, ">>orphan_notif_cmd", (FMT__0)); mhr_len = zb_mac_calculate_mhr_length(ZB_ADDR_64BIT_DEV, ZB_ADDR_16BIT_DEV_OR_BROADCAST, 1); { zb_uint8_t packet_length = mhr_len + 1; ZB_BUF_INITIAL_ALLOC(MAC_CTX().operation_buf, packet_length, ptr); ZB_ASSERT(ptr); ZB_BZERO(ptr, packet_length); } /* TODO: optimize FC fill */ ZB_BZERO2(mhr.frame_control); ZB_FCF_SET_FRAME_TYPE(mhr.frame_control, MAC_FRAME_COMMAND); ZB_FCF_SET_DST_ADDRESSING_MODE(mhr.frame_control, ZB_ADDR_16BIT_DEV_OR_BROADCAST); ZB_FCF_SET_SRC_ADDRESSING_MODE(mhr.frame_control, ZB_ADDR_64BIT_DEV); ZB_FCF_SET_PANID_COMPRESSION_BIT(mhr.frame_control, 1); ZB_FCF_SET_FRAME_VERSION(mhr.frame_control, MAC_FRAME_VERSION); /* 7.2.1 General MAC frame format */ mhr.seq_number = ZB_MAC_DSN(); ZB_INC_MAC_DSN(); mhr.dst_pan_id = ZB_BROADCAST_PAN_ID; mhr.dst_addr.addr_short = ZB_MAC_SHORT_ADDR_NO_VALUE; ZB_IEEE_ADDR_COPY(mhr.src_addr.addr_long, ZB_PIB_EXTENDED_ADDRESS()); zb_mac_fill_mhr(ptr, &mhr); *(ptr + mhr_len) = MAC_CMD_ORPHAN_NOTIFICATION; MAC_ADD_FCS(MAC_CTX().operation_buf); ret = ZB_TRANS_SEND_COMMAND(mhr_len, MAC_CTX().operation_buf); TRACE_MSG(TRACE_MAC2, "<<orphan_notif_cmd %hd", (FMT__H, ret)); return ret; }
MAIN() { ARGV_UNUSED; #ifndef KEIL if ( argc < 3 ) { printf("%s <read pipe path> <write pipe path>\n", argv[0]); return 0; } #endif /* Init device, load IB values from nvram or set it to default */ #ifndef ZB8051 ZB_INIT("zdo_zed1_", argv[1], argv[2]); #else ZB_INIT("zdo_zed1_", "2", "2"); #endif /* set ieee addr */ ZB_IEEE_ADDR_COPY(ZB_PIB_EXTENDED_ADDRESS(), &g_ieee_addr); #ifndef ZB_NS_BUILD ZB_UPDATE_LONGMAC(); #endif #ifdef ZB_SECURITY /* turn off security */ ZB_NIB_SECURITY_LEVEL() = 0; #endif MAC_ADD_VISIBLE_LONG(g_zr_ieee_addr); MAC_ADD_INVISIBLE_SHORT(0); /* ignore beacons from ZC */ /* become an ED */ ZB_NIB_DEVICE_TYPE() = ZB_NWK_DEVICE_TYPE_ED; ZB_PIB_RX_ON_WHEN_IDLE() = ZB_FALSE; /* configure poll timer */ ZDO_CTX().conf_attr.nwk_indirect_poll_rate = 2*ZB_TIME_ONE_SECOND; if (zdo_dev_start() != RET_OK) { TRACE_MSG(TRACE_ERROR, "zdo_dev_start failed", (FMT__0)); } else { zdo_main_loop(); } TRACE_DEINIT(); MAIN_RETURN(0); }
MAIN() { ARGV_UNUSED; #ifndef KEIL if ( argc < 3 ) { printf("%s <read pipe path> <write pipe path>\n", argv[0]); return 0; } #endif /* Init device, load IB values from nvram or set it to default */ #ifndef ZB8051 ZB_INIT("zdo_zc", argv[1], argv[2]); #else ZB_INIT("zdo_zc", "1", "1"); #endif /* let's always be coordinator */ ZB_AIB().aps_designated_coordinator = 1; /* set ieee addr */ ZB_IEEE_ADDR_COPY(ZB_PIB_EXTENDED_ADDRESS(), &g_ieee_addr); #ifndef ZB_NS_BUILD ZB_UPDATE_LONGMAC(); #endif #ifdef ZB_SECURITY /* turn off security */ ZB_NIB_SECURITY_LEVEL() = 0; #endif /* accept only one child */ ZB_NWK().max_children = 3; /* configure join duration */ ZDO_CTX().conf_attr.permit_join_duration = 10; if ( zdo_dev_start() != RET_OK ) { TRACE_MSG(TRACE_ERROR, "zdo_dev_start failed", (FMT__0)); } else { zdo_main_loop(); } TRACE_DEINIT(); MAIN_RETURN(0); }
MAIN() { ARGV_UNUSED; #ifndef KEIL if ( argc < 3 ) { printf("%s <read pipe path> <write pipe path>\n", argv[0]); return 0; } #endif /* Init device, load IB values from nvram or set it to default */ #ifndef ZB8051 ZB_INIT("zdo_zr1", argv[1], argv[2]); #else ZB_INIT("zdo_zr1", "2", "2"); #endif /* set ieee addr */ ZB_IEEE_ADDR_COPY(ZB_PIB_EXTENDED_ADDRESS(), &g_ieee_addr); /* join as a router */ ZB_NIB_DEVICE_TYPE() = ZB_NWK_DEVICE_TYPE_ROUTER; ZB_NWK().max_children = 0; #ifndef ZB_NS_BUILD ZB_UPDATE_LONGMAC(); ZB_UPDATE_PAN_ID(); #endif #ifdef ZB_SECURITY /* turn off security */ ZB_NIB_SECURITY_LEVEL() = 0; #endif if (zdo_dev_start() != RET_OK) { TRACE_MSG(TRACE_ERROR, "zdo_dev_start failed", (FMT__0)); } else { zdo_main_loop(); } TRACE_DEINIT(); MAIN_RETURN(0); }
MAIN() { ARGV_UNUSED; #ifndef KEIL if ( argc < 3 ) { printf("%s <read pipe path> <write pipe path>\n", argv[0]); return 0; } #endif /* Init device, load IB values from nvram or set it to default */ #ifndef ZB8051 ZB_INIT("zdo_zc", argv[1], argv[2]); #else ZB_INIT("zdo_zc", "1", "1"); #endif /* let's always be coordinator */ ZB_AIB().aps_designated_coordinator = 1; MAC_PIB().mac_pan_id = 0x1aaa; /* set ieee addr */ ZB_IEEE_ADDR_COPY(ZB_PIB_EXTENDED_ADDRESS(), &g_ieee_addr); #ifndef ZB_NS_BUILD ZB_UPDATE_LONGMAC(); ZB_UPDATE_PAN_ID(); #endif #ifdef ZB_SECURITY /* turn off security */ ZB_NIB_SECURITY_LEVEL() = 0; #endif if ( zdo_dev_start() != RET_OK ) { TRACE_MSG(TRACE_ERROR, "zdo_dev_start failed", (FMT__0)); } else { zdo_main_loop(); } TRACE_DEINIT(); MAIN_RETURN(0); }
MAIN() { ARGV_UNUSED; #ifndef KEIL if ( argc < 3 ) { printf("%s <read pipe path> <write pipe path>\n", argv[0]); return 0; } #endif /* Init device, load IB values from nvram or set it to default */ #ifndef ZB8051 ZB_INIT("zdo_zr1", argv[1], argv[2]); #else ZB_INIT("zdo_zr1", "2", "2"); #endif ZB_IEEE_ADDR_COPY(ZB_PIB_EXTENDED_ADDRESS(), &g_ieee_addr); #ifndef ZB_NS_BUILD ZB_UPDATE_LONGMAC(); ZB_UPDATE_PAN_ID(); #endif #ifdef ZB_SECURITY ZG->nwk.nib.security_level = 0; #endif if (zdo_dev_start() != RET_OK) { TRACE_MSG(TRACE_ERROR, "zdo_dev_start failed", (FMT__0)); } else { zdo_main_loop(); } TRACE_DEINIT(); MAIN_RETURN(0); }
/** Reaction on TRANSPORT-KEY APS command */ void zb_aps_in_transport_key(zb_uint8_t param) { zb_transport_key_nwk_key_dsc_pkt_t *dsc = (zb_transport_key_nwk_key_dsc_pkt_t *)ZB_BUF_BEGIN(ZB_BUF_FROM_REF(param)); TRACE_MSG(TRACE_SECUR3, ">>zb_aps_in_transport_key %d", (FMT__H, param)); /* See 4.4.3.3 Upon Receipt of a Transport-Key Command */ switch (dsc->key_type) { case ZB_STANDARD_NETWORK_KEY: if ( /* key is for me */ ZB_IEEE_ADDR_CMP(dsc->dest_address, ZB_PIB_EXTENDED_ADDRESS()) /* key is for all */ || ZB_IEEE_ADDR_IS_ZERO(dsc->dest_address)) { /* This key is for me. Issue APSME-TRANSPORT-KEY.indication. ZDO will * setup keys and remember TC address. */ zb_apsme_transport_key_indication_t *ind = ZB_GET_BUF_PARAM(ZB_BUF_FROM_REF(param), zb_apsme_transport_key_indication_t); TRACE_MSG(TRACE_SECUR3, "in std nwk key #%d for me", (FMT__D, dsc->seq_number)); ind->key_type = dsc->key_type; ZB_IEEE_ADDR_COPY(ind->src_address, dsc->source_address); ind->key.nwk.key_seq_number = dsc->seq_number; ZB_MEMCPY(ind->key.nwk.key, dsc->key, ZB_CCM_KEY_SIZE); ZB_SCHEDULE_CALLBACK(zb_apsme_transport_key_indication, param); /* #ifdef ZB_ROUTER_ROLE */ /* This feature should be processed at request */ #if 0 if (ZB_IEEE_ADDR_IS_ZERO(dsc->dest_address) /* && check for secured transfer at nwk level */ && ZB_IEEE_ADDR_CMP(dsc->source_address, ZB_AIB().trust_center_address)) { /* * Need to pass key to all rx-off-when-idle children. Need another * packet buffer for it. * Do the rest in the calback: this is blocked * buffer alloc. Not need to save current key: it will be aleady * assigned, so can send my own key. */ ZG->aps.tmp.neighbor_table_iterator = zb_nwk_neighbor_next_ze_children_rx_off_i(0); ZG->aps.tmp.key_seq_number = ind->key.nwk.key_seq_number; if (ZG->aps.tmp.neighbor_table_iterator != (zb_ushort_t)~0) { TRACE_MSG(TRACE_SECUR3, "send key #%hd to all ZE", (FMT__H, dsc->seq_number)); zb_get_out_buf_delayed(zb_aps_pass_nwk_key_to_children); } } #endif /* ZB_ROUTER_ROLE */ } #ifdef ZB_ROUTER_ROLE else { zb_address_ieee_ref_t addr_ref; zb_neighbor_tbl_ent_t *nbe; /* Search for child in the Neighbor table, mark child as Authenticated, * send key to it using unsecured NWK transfer */ if (zb_address_by_ieee(dsc->dest_address, ZB_FALSE, ZB_FALSE, &addr_ref) == RET_OK && zb_nwk_neighbor_get(addr_ref, ZB_FALSE, &nbe) == RET_OK && (nbe->relationship == ZB_NWK_RELATIONSHIP_UNAUTHENTICATED_CHILD || nbe->relationship == ZB_NWK_RELATIONSHIP_CHILD)) { zb_uint16_t addr; zb_address_short_by_ref(&addr, addr_ref); TRACE_MSG(TRACE_SECUR3, "send key #%hd to ZE %d, auth ok", (FMT__H_D, dsc->seq_number, addr)); zb_aps_send_command(param, addr, APS_CMD_TRANSPORT_KEY, (nbe->relationship != ZB_NWK_RELATIONSHIP_UNAUTHENTICATED_CHILD)); nbe->relationship = ZB_NWK_RELATIONSHIP_CHILD; } else { TRACE_MSG(TRACE_SECUR1, "child " TRACE_FORMAT_64 " not found", (FMT__A, TRACE_ARG_64(dsc->dest_address))); zb_free_buf(ZB_BUF_FROM_REF(param)); } } #endif /* ZB_ROUTER_ROLE */ break; default: break; } TRACE_MSG(TRACE_SECUR3, "<<zb_aps_in_transport_key", (FMT__0)); }
void zb_aps_secure_frame(zb_buf_t *src, zb_uint_t mac_hdr_size, zb_buf_t *dst) { zb_uint8_t *aps_hdr; zb_uint8_t *payload; zb_secur_ccm_nonce_t nonce; zb_uint8_t *dp; zb_uint8_t *key; zb_ushort_t hdrs_size; zb_aps_nwk_aux_frame_hdr_t *aux; { zb_nwk_hdr_t *nwk_hdr = (zb_nwk_hdr_t *)(ZB_BUF_BEGIN(src) + mac_hdr_size); aps_hdr = (zb_uint8_t *)nwk_hdr + ZB_NWK_HDR_SIZE(nwk_hdr->frame_control); } aux = (zb_aps_nwk_aux_frame_hdr_t *)(aps_hdr + ZB_APS_HDR_SIZE(*aps_hdr)); if (ZB_SECUR_AUX_HDR_GET_KEY_TYPE(aux->secur_control) == ZB_SECUR_DATA_KEY) { payload = (zb_uint8_t *)aux + sizeof(zb_aps_data_aux_frame_hdr_t); /* get src and dst address from APS header, get data key */ key = 0; /* aps data key */ } else { /* nwk key */ payload = (zb_uint8_t *)aux + sizeof(zb_aps_nwk_aux_frame_hdr_t); key = ZG->nwk.nib.secur_material_set[ZG->nwk.nib.active_secur_material_i].key; } /* fill nonce - see 4.5.2.2 */ nonce.frame_counter = aux->frame_counter; nonce.secur_control = aux->secur_control; ZB_IEEE_ADDR_COPY(nonce.source_address, ZB_PIB_EXTENDED_ADDRESS()); hdrs_size = payload - ZB_BUF_BEGIN(src); /* Secure */ (void)zb_ccm_encrypt_n_auth(key, (zb_uint8_t *)&nonce, (zb_uint8_t *)aps_hdr, (payload - aps_hdr), (zb_uint8_t *)payload, (ZB_BUF_LEN(src) - hdrs_size), dst); ZB_BUF_ALLOC_LEFT(dst, (aps_hdr - ZB_BUF_BEGIN(src)), dp); /* copy headers */ ZB_MEMCPY(dp, ZB_BUF_BEGIN(src), (aps_hdr - ZB_BUF_BEGIN(src))); /* clear security level - see 4.4.1.1/11 */ aux = (zb_aps_nwk_aux_frame_hdr_t *)(ZB_BUF_BEGIN(dst) + ((zb_uint8_t*)aux - ZB_BUF_BEGIN(src))); if (ZB_SECUR_AUX_HDR_GET_KEY_TYPE(aux->secur_control) == ZB_SECUR_DATA_KEY) { aux->secur_control = ZB_APS_DATA_STD_SECUR_CONTROL_ZEROED_LEVEL; } else { aux->secur_control = ZB_APS_NWK_STD_SECUR_CONTROL_ZEROED_LEVEL; } TRACE_MSG(TRACE_SECUR3, "secured aps frm %p[%hd] -> %p hdrs_size %hd fcnt %lx", (FMT__P_H_P_H_L, src, ZB_BUF_LEN(src), dst, hdrs_size, aux->frame_counter)); }