test/zdo-network.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <sys/time.h>
  22 #include <unistd.h>
  23 #include <glib.h>
  24 #include <gio/gio.h>
  25
  26 #include <zigbee.h>
  27
  28 #include "main.h"
  29 #include "menu.h"
  30
  31 extern zigbee_h  handle;
  32
  33 extern nwk_addr  dest_addr16;
  34 extern ieee_addr dest_addr64;
  35
  36 static char data_duration[MENU_DATA_SIZE + 1] = "5";
  37 static char data_count[MENU_DATA_SIZE + 1] = "4";
  38 static char data_start_idx[MENU_DATA_SIZE + 1] = "0";
  39 static char data_nwk_update_id[MENU_DATA_SIZE + 1] = "0";
  40 static char data_remove_children[MENU_DATA_SIZE + 1] = "1";
  41 static char data_rejoin[MENU_DATA_SIZE + 1] = "1";
  42 static char data_permit_duration[MENU_DATA_SIZE + 1] = "1";
  43 static char data_tc[MENU_DATA_SIZE + 1] = "1";
  44
  45 static void zigbee_zdo_mgmt_nwk_disc_rsp(unsigned char status,
  46         unsigned char network_count, unsigned char start_idx, unsigned char network_list_count,
  47         const zb_zdo_network_list_record_h *records, void *user_data)
  48 {
  49         int i = 0;
  50         ieee_addr extended_pan_id;
  51         unsigned char logical_channel;
  52         unsigned char stack_profile;
  53         unsigned char zigbee_version;
  54         unsigned char beacon_order;
  55         unsigned char superframe_order;
  56         unsigned char permit_joining;
  57
  58         msg("");
  59         msgp("zb_zdo_mgmt_nwk_disc_rsp() status = 0x%02X", status);
  60
  61         if (!status) {
  62                 msg("  network_count 0x%02X", network_count);
  63                 msg("  start_idx  0x%02X", start_idx);
  64                 msg("  network_list_count  0x%02X", network_list_count);
  65                 for (i = 0; i < network_list_count; i++) {
  66                         zb_network_list_record_get_extended_pan_id(records[i], extended_pan_id);
  67                         msg("  Extended PanId %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
  68                                 extended_pan_id[7], extended_pan_id[6],
  69                                 extended_pan_id[5], extended_pan_id[4],
  70                                 extended_pan_id[3],     extended_pan_id[2],
  71                                 extended_pan_id[1],     extended_pan_id[0]);
  72                         zb_network_list_record_get_logical_channel(records[i], &logical_channel);
  73                         msg("  Logical Channel  0x%02X", logical_channel);
  74                         zb_network_list_record_get_stack_profile(records[i], &stack_profile);
  75                         msg("  stack_profile    0x%02X", stack_profile);
  76                         zb_network_list_record_get_zigbee_version(records[i], &zigbee_version);
  77                         msg("  zigbee_version   0x%02X", zigbee_version);
  78                         zb_network_list_record_get_beacon_order(records[i], &beacon_order);
  79                         msg("  Beacon_order     0x%02X", beacon_order);
  80                         zb_network_list_record_get_superframe_order(records[i], &superframe_order);
  81                         msg("  Superframe_order 0x%02X", superframe_order);
  82                         zb_network_list_record_get_permit_joining(records[i], &permit_joining);
  83                         msg("  Permit joining   0x%02X", permit_joining);
  84                 }
  85         } else {
  86                 msg("  Unsuccessful Nwk discovery");
  87         }
  88 }
  89
  90 static void zigbee_zdo_mgmt_lqi_rsp(unsigned char status,
  91         unsigned char neighbor_table_entries, unsigned char start_idx,
  92         unsigned char neighbor_table_list_count,
  93         const zb_zdo_neighbor_table_desc_h *neighbor_table_list, void *user_data)
  94 {
  95         int i;
  96         ieee_addr extended_pan_id;
  97         ieee_addr addr64;
  98         nwk_addr addr16;
  99         unsigned char device_type;
 100         unsigned char rx_on_when_idle;
 101         unsigned char releationship;
 102         unsigned char permit_joining;
 103         unsigned char depth;
 104         unsigned char lqi;
 105
 106         msg("");
 107         msgp("zb_zdo_mgmt_lqi_rsp()");
 108         msgp("  status = 0x%02X start_idx=%d count=%d", status, start_idx, neighbor_table_list_count);
 109         for (i = start_idx; i < neighbor_table_list_count; i++) {
 110                 zb_neighbor_table_desc_get_extended_pan_id(neighbor_table_list[i], extended_pan_id);
 111                 msg("  ext PAN ID      = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
 112                 extended_pan_id[0], extended_pan_id[1], extended_pan_id[2], extended_pan_id[3],
 113                 extended_pan_id[4], extended_pan_id[5], extended_pan_id[6], extended_pan_id[7]);
 114                 zb_neighbor_table_desc_get_ieee_addr(neighbor_table_list[i], addr64);
 115                 msg("  IEEE address    = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
 116                 addr64[0], addr64[1], addr64[2], addr64[3], addr64[4], addr64[5], addr64[6], addr64[7]);
 117                 zb_neighbor_table_desc_get_nwk_addr(neighbor_table_list[i], &addr16);
 118                 msg("  Network address = 0x%04X", addr16);
 119                 zb_neighbor_table_desc_get_device_type(neighbor_table_list[i], &device_type);
 120                 msg("  Device Type     = 0x%02X", device_type);
 121                 zb_neighbor_table_desc_get_rx_on_when_idle(neighbor_table_list[i], &rx_on_when_idle);
 122                 msg("  Rx on idle      = 0x%02X", rx_on_when_idle);
 123                 zb_neighbor_table_desc_get_relationship(neighbor_table_list[i], &releationship);
 124                 msg("  Relationship    = 0x%02X", releationship);
 125                 zb_neighbor_table_desc_get_permit_joining(neighbor_table_list[i], &permit_joining);
 126                 msg("  Permit Joining  = 0x%02X", permit_joining);
 127                 zb_neighbor_table_desc_get_depth(neighbor_table_list[i], &depth);
 128                 msg("  Depth           = 0x%02X", depth);
 129                 zb_neighbor_table_desc_get_lqi(neighbor_table_list[i], &lqi);
 130                 msg("  LQI             = 0x%02X", lqi);
 131         }
 132 }
 133
 134 static void zigbee_zdo_mgmt_rtg_rsp(unsigned char status,
 135         unsigned char routing_table_entries, unsigned char start_idx,
 136         unsigned char routing_table_list_count,
 137         const zb_zdo_routing_table_h *routing_table_list, void *user_data)
 138 {
 139         int i;
 140         nwk_addr dst_addr;
 141         unsigned char mode;
 142         unsigned char memory_constrained;
 143         unsigned char many_to_one;
 144         unsigned char route_record_required;
 145         nwk_addr next_hop_addr;
 146
 147         msg("");
 148         msgp("zb_zdo_mgmt_rtg_rsp()");
 149         msgp("  status = 0x%02X routing_table_entries=%d start_idx=%d count=%d",
 150                         status, routing_table_entries, start_idx, routing_table_list_count);
 151         for (i = start_idx; i < routing_table_list_count; i++) {
 152                 zb_routing_table_get_dst_addr(routing_table_list[i], &dst_addr);
 153                 msg("  [%d] Destination address   = 0x%04X", i, dst_addr);
 154                 zb_routing_table_get_dst_status(routing_table_list[i], &mode);
 155                 msg("  [%d] Status                = 0x%02X", i, mode);
 156                 zb_routing_table_get_memory_constrained(routing_table_list[i], &memory_constrained);
 157                 msg("  [%d] memory_constrained    = 0x%02X", i, memory_constrained);
 158                 zb_routing_table_get_many_to_one(routing_table_list[i], &many_to_one);
 159                 msg("  [%d] many_to_one           = 0x%02X", i, many_to_one);
 160                 zb_routing_table_get_route_record_required(routing_table_list[i], &route_record_required);
 161                 msg("  [%d] route_record_required = 0x%02X", i, route_record_required);
 162                 zb_routing_table_get_next_hop_addr(routing_table_list[i], &next_hop_addr);
 163                 msg("  [%d] next_hop_addr         = 0x%04X", i, next_hop_addr);
 164                 msg("");
 165         }
 166 }
 167
 168 static void zigbee_zdo_mgmt_bind_rsp(unsigned char status, unsigned char entries,
 169         unsigned char start_idx, unsigned char binding_table_list_count, const zb_zdo_binding_table_h *list,
 170         void *user_data)
 171 {
 172         int i;
 173         nwk_addr addr16;
 174         ieee_addr addr64;
 175         unsigned short cluster_id;
 176         unsigned char src_ep, dst_ep, dst_addr_mode;
 177
 178         msg("");
 179         msgp("zb_zdo_mgmt_bind_rsp()");
 180         msgp("  status = 0x%02X start_idx = %d number of records = %d",
 181                 status, start_idx, binding_table_list_count);
 182
 183         for (i = 0; i < binding_table_list_count; i++) {
 184                 zb_binding_table_get_src_addr(list[i], addr64);
 185                 msg("  Src IEEE address    = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
 186                         addr64[0], addr64[1], addr64[2], addr64[3], addr64[4], addr64[5], addr64[6], addr64[7]);
 187                 zb_binding_table_get_src_ep(list[i], &src_ep);
 188                 msg("  Src End-Point       = 0x%02X", src_ep);
 189                 zb_binding_table_get_cluster_id(list[i], &cluster_id);
 190                 msg("  Cluster ID          = 0x%04X", cluster_id);
 191                 zb_binding_table_get_dst_addr_mode(list[i], &dst_addr_mode);
 192                 msg("  Dst Address Mode    = 0x%02X", dst_addr_mode);
 193                 zb_binding_table_get_dst_addr16(list[i], &addr16);
 194                 msg("  Dst Network address = 0x%04X", addr16);
 195                 memset(addr64, 0, sizeof(ieee_addr));
 196                 zb_binding_table_get_dst_addr64(list[i], addr64);
 197                 msg("  Dst IEEE address    = %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X",
 198                         addr64[0], addr64[1], addr64[2], addr64[3], addr64[4], addr64[5], addr64[6], addr64[7]);
 199                 zb_binding_table_get_dst_ep(list[i], &dst_ep);
 200                 msg("  Dst End-Point       = 0x%02X", src_ep);
 201                 msg("");
 202         }
 203 }
 204
 205 static void zigbee_zdo_mgmt_leave_rsp(unsigned char status, void *user_data)
 206 {
 207         msg("");
 208         msgp("zb_zdo_mgmt_leave_rsp() status = 0x%02X", status);
 209 }
 210
 211 static void zigbee_zdo_mgmt_permit_joining_rsp(unsigned char status, void *user_data)
 212 {
 213         msg("");
 214         msgp("zb_zdo_mgmt_permit_joining_rsp() status = 0x%02X", status);
 215 }
 216
 217 static int run_mgmt_nwk_disc_req(MManager *mm, struct menu_data *menu)
 218 {
 219         int ret = ZIGBEE_ERROR_NONE;
 220         unsigned int scan_channels = ZB_802_15_4_CHANNELS_MASK;
 221         unsigned char scan_duration = 5;
 222         unsigned char scan_count = 4;
 223         unsigned char start_idx = 0;
 224
 225         if (strlen(data_duration))
 226                 scan_duration = (unsigned char)strtol(data_duration, NULL, 10);
 227         if (strlen(data_count))
 228                 scan_count = (unsigned char)strtol(data_count, NULL, 10);
 229         if (strlen(data_start_idx))
 230                 start_idx = (unsigned char)strtol(data_start_idx, NULL, 10);
 231
 232         ret = zb_zdo_mgmt_nwk_disc_req(handle, dest_addr16, scan_channels,
 233                         scan_duration, scan_count, start_idx,
 234                         zigbee_zdo_mgmt_nwk_disc_rsp, NULL);
 235         if (ZIGBEE_ERROR_NONE != ret) {
 236                 msg("zb_zdo_mgmt_nwk_disc_req(0x%X) - FAILED!!!", ret);
 237                 return RET_FAILURE;
 238         }
 239
 240         msg(" - zb_zdo_mgmt_nwk_disc_req() ret: [0x%X]", ret);
 241         msg("");
 242
 243         return RET_SUCCESS;
 244 }
 245
 246 static int run_mgmt_nwk_update_req(MManager *mm, struct menu_data *menu)
 247 {
 248         int ret = ZIGBEE_ERROR_NONE;
 249         unsigned int scan_channels = ZB_802_15_4_CHANNELS_MASK;
 250         unsigned char nwk_update_id = 0x00;
 251         unsigned char scan_duration = 5;
 252         unsigned char scan_count = 4;
 253
 254         if (strlen(data_duration))
 255                 scan_duration = (unsigned char)strtol(data_duration, NULL, 10);
 256         if (strlen(data_count))
 257                 scan_count = (unsigned char)strtol(data_count, NULL, 10);
 258         if (strlen(data_nwk_update_id))
 259                 nwk_update_id = (unsigned char)strtol(data_nwk_update_id, NULL, 10);
 260
 261         ret = zb_zdo_mgmt_nwk_update_req(handle, scan_channels, scan_duration,
 262                         scan_count, nwk_update_id, dest_addr16);
 263         if (ZIGBEE_ERROR_NONE != ret) {
 264                 msg("zb_zdo_mgmt_nwk_update_req(0x%X) - FAILED!!!", ret);
 265                 return RET_FAILURE;
 266         }
 267
 268         msg(" - zb_zdo_mgmt_nwk_update_req() ret: [0x%X]", ret);
 269         msg("");
 270
 271         return RET_SUCCESS;
 272 }
 273
 274 static int run_mgmt_lqi_req(MManager *mm, struct menu_data *menu)
 275 {
 276         int ret = ZIGBEE_ERROR_NONE;
 277         unsigned char start_idx = 0;
 278
 279         if (strlen(data_start_idx))
 280                 start_idx = (unsigned char)strtol(data_start_idx, NULL, 10);
 281
 282         ret = zb_zdo_mgmt_lqi_req(handle, dest_addr16, start_idx,
 283                         zigbee_zdo_mgmt_lqi_rsp, NULL);
 284         if (ZIGBEE_ERROR_NONE != ret) {
 285                 msg("zb_zdo_mgmt_lqi_req(0x%X) - FAILED!!!", ret);
 286                 return RET_FAILURE;
 287         }
 288
 289         msg(" - zb_zdo_mgmt_lqi_req() ret: [0x%X]", ret);
 290         msg("");
 291
 292         return RET_SUCCESS;
 293 }
 294
 295 static int run_mgmt_rtg_req(MManager *mm, struct menu_data *menu)
 296 {
 297         int ret = ZIGBEE_ERROR_NONE;
 298         unsigned char start_idx = 0;
 299
 300         if (strlen(data_start_idx))
 301                 start_idx = (unsigned char)strtol(data_start_idx, NULL, 10);
 302
 303         ret = zb_zdo_mgmt_rtg_req(handle, dest_addr16, start_idx,
 304                         zigbee_zdo_mgmt_rtg_rsp, NULL);
 305         if (ZIGBEE_ERROR_NONE != ret) {
 306                 msg("zb_zdo_mgmt_rtg_req(0x%X) - FAILED!!!", ret);
 307                 return RET_FAILURE;
 308         }
 309
 310         msg(" - zb_zdo_mgmt_rtg_req() ret: [0x%X]", ret);
 311         msg("");
 312
 313         return RET_SUCCESS;
 314 }
 315
 316 static int run_mgmt_bind_req(MManager *mm, struct menu_data *menu)
 317 {
 318         int ret = ZIGBEE_ERROR_NONE;
 319         unsigned char start_idx = 0;
 320
 321         if (strlen(data_start_idx))
 322                 start_idx = (unsigned char)strtol(data_start_idx, NULL, 10);
 323
 324         ret = zb_zdo_mgmt_bind_req(handle, dest_addr16, start_idx,
 325                         zigbee_zdo_mgmt_bind_rsp, NULL);
 326         if (ZIGBEE_ERROR_NONE != ret) {
 327                 msg("zb_zdo_mgmt_bind_req(0x%X) - FAILED!!!", ret);
 328                 return RET_FAILURE;
 329         }
 330
 331         msg(" - zb_zdo_mgmt_bind_req() ret: [0x%X]", ret);
 332         msg("");
 333
 334         return RET_SUCCESS;
 335 }
 336
 337 static int run_mgmt_leave_req(MManager *mm, struct menu_data *menu)
 338 {
 339         int ret = ZIGBEE_ERROR_NONE;
 340         unsigned char var = 0;
 341         bool remove_children = true;
 342         bool rejoin = true;
 343
 344         if (strlen(data_remove_children)) {
 345                 var = (unsigned char)strtol(data_remove_children, NULL, 10);
 346                 remove_children = (var == 0) ? false : true;
 347         }
 348         if (strlen(data_rejoin)) {
 349                 var = (unsigned char)strtol(data_rejoin, NULL, 10);
 350                 rejoin = (var == 0) ? false : true;
 351         }
 352
 353         ret = zb_zdo_mgmt_leave_req(handle, dest_addr64, remove_children, rejoin,
 354                         zigbee_zdo_mgmt_leave_rsp, NULL);
 355         if (ZIGBEE_ERROR_NONE != ret) {
 356                 msg("zb_zdo_mgmt_leave_req(0x%X) - FAILED!!!", ret);
 357                 return RET_FAILURE;
 358         }
 359
 360         msg(" - zb_zdo_mgmt_leave_req() ret: [0x%X]", ret);
 361         msg("");
 362
 363         return RET_SUCCESS;
 364 }
 365
 366 static int run_mgmt_permit_joining_req(MManager *mm, struct menu_data *menu)
 367 {
 368         int ret = ZIGBEE_ERROR_NONE;
 369         unsigned char permit_duration = 1;
 370         unsigned char tc_significance = 1;
 371
 372         if (strlen(data_permit_duration))
 373                 permit_duration = (unsigned char)strtol(data_permit_duration, NULL, 10);
 374         if (strlen(data_tc))
 375                 tc_significance = (unsigned char)strtol(data_tc, NULL, 10);
 376
 377         ret = zb_zdo_mgmt_permit_joining_req(handle, dest_addr16,
 378                         permit_duration, tc_significance,
 379                         zigbee_zdo_mgmt_permit_joining_rsp, NULL);
 380         if (ZIGBEE_ERROR_NONE != ret) {
 381                 msg("zb_zdo_mgmt_permit_joining_req(0x%X) - FAILED!!!", ret);
 382                 return RET_FAILURE;
 383         }
 384
 385         msg(" - zb_zdo_mgmt_permit_joining_req() ret: [0x%X]", ret);
 386         msg("");
 387
 388         return RET_SUCCESS;
 389 }
 390
 391 static struct menu_data _menu_nwk_disc[] = {
 392         { "1", "Scan duration", NULL, NULL, data_duration },
 393         { "2", "Scan count", NULL, NULL, data_count },
 394         { "3", "Start index", NULL, NULL, data_start_idx },
 395         { "4", "Run", NULL, run_mgmt_nwk_disc_req, NULL },
 396         { NULL, NULL, },
 397 };
 398
 399 static struct menu_data _menu_nwk_update[] = {
 400         { "1", "Scan duration", NULL, NULL, data_duration },
 401         { "2", "Scan count", NULL, NULL, data_count },
 402         { "3", "Start index", NULL, NULL, data_start_idx },
 403         { "4", "Run", NULL, run_mgmt_nwk_update_req, NULL },
 404         { NULL, NULL, },
 405 };
 406
 407 static struct menu_data _menu_lqi[] = {
 408         { "1", "Start index", NULL, NULL, data_start_idx },
 409         { "2", "Run", NULL, run_mgmt_lqi_req, NULL },
 410         { NULL, NULL, },
 411 };
 412
 413 static struct menu_data _menu_rtg[] = {
 414         { "1", "Start index", NULL, NULL, data_start_idx },
 415         { "2", "Run", NULL, run_mgmt_rtg_req, NULL },
 416         { NULL, NULL, },
 417 };
 418
 419 static struct menu_data _menu_bind[] = {
 420         { "1", "Start index", NULL, NULL, data_start_idx },
 421         { "2", "Run", NULL, run_mgmt_bind_req, NULL },
 422         { NULL, NULL, },
 423 };
 424
 425 static struct menu_data _menu_leave[] = {
 426         { "1", "Remove children", NULL, NULL, data_remove_children },
 427         { "2", "Rejoin", NULL, NULL, data_rejoin },
 428         { "3", "Run", NULL, run_mgmt_leave_req, NULL },
 429         { NULL, NULL, },
 430 };
 431
 432 static struct menu_data _menu_permit[] = {
 433         { "1", "Permit duration", NULL, NULL, data_permit_duration },
 434         { "2", "TC significance", NULL, NULL, data_tc },
 435         { "3", "Run", NULL, run_mgmt_permit_joining_req, NULL },
 436         { NULL, NULL, },
 437 };
 438
 439 struct menu_data menu_zdo_network[] = {
 440         { "1", "zb_zdo_mgmt_nwk_disc_req", _menu_nwk_disc, NULL, NULL },
 441         { "2", "zb_zdo_mgmt_nwk_update_req", _menu_nwk_update, NULL, NULL },
 442         { "3", "zb_zdo_mgmt_lqi_req", _menu_lqi, NULL, NULL },
 443         { "4", "zb_zdo_mgmt_rtg_req", _menu_rtg, NULL, NULL },
 444         { "5", "zb_zdo_mgmt_bind_req", _menu_bind, NULL, NULL },
 445         { "6", "zb_zdo_mgmt_leave_req", _menu_leave, NULL, NULL },
 446         { "7", "zb_zdo_mgmt_permit_joining_req", _menu_permit, NULL, NULL },
 447         { NULL, NULL, },
 448 };