zigbee-daemon/zigbee-lib/src/zblib_request.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Contact: Suresh Kumar N (suresh.n@samsung.com)
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <zblib.h>
  20 #include <zblib_request.h>
  21 #include <zblib_service.h>
  22 #include <zblib_service_interface.h>
  23
  24 #include <zblib_driver.h>
  25 #include <zblib_driver_alarm.h>
  26 #include <zblib_driver_custom.h>
  27 #include <zblib_driver_door_lock.h>
  28 #include <zblib_driver_fan_control.h>
  29 #include <zblib_driver_level_control.h>
  30 #include <zblib_driver_mfglib_control.h>
  31 #include <zblib_driver_on_off.h>
  32 #include <zblib_driver_service.h>
  33 #include <zblib_driver_thermostat.h>
  34 #include <zblib_driver_zclbasic_control.h>
  35 #include <zblib_driver_zclglobal_control.h>
  36 #include <zblib_driver_zclias_control.h>
  37 #include <zblib_driver_zclidentify_control.h>
  38 #include <zblib_driver_zcl_color.h>
  39 #include <zblib_driver_zcl_group.h>
  40 #include <zblib_driver_zcl_poll_control.h>
  41 #include <zblib_driver_zcl_scene.h>
  42 #include <zblib_driver_zdodev_control.h>
  43 #include <zblib_driver_zdo_bind.h>
  44
  45 /**< ZigBee Request object */
  46 struct zblib_request_type {
  47         gint request_id; /**< Request ID */
  48         guint request_type; /**< Request type */
  49         guint ref_count; /* Reference count */
  50
  51         gpointer request_data; /**< Request data */
  52
  53         ZigBeeServiceInterface *service_interface; /* Service interface */
  54 };
  55
  56 static ZblibDriverType_e __zblib_request_get_driver_type(guint request_type)
  57 {
  58         ZblibDriverType_e driver_type;
  59
  60         driver_type = ((request_type && 0xFF000000) >> 24);
  61
  62         return driver_type;
  63 }
  64
  65 static ZblibDriverType_e __zblib_request_get_ops_id(guint request_type)
  66 {
  67         guint ops_id;
  68
  69         ops_id = (request_type && 0x000000FF);
  70
  71         return ops_id;
  72 }
  73
  74 static gpointer __zblib_request_create_alarm_request_data(guint request_type,
  75         gpointer request_data, guint request_data_len)
  76 {
  77         gpointer alarm_request_data = NULL;
  78         guint ops_id;
  79
  80         NOT_USED(request_data);
  81         NOT_USED(request_data_len);
  82
  83         /* Fetch ops ID */
  84         ops_id = __zblib_request_get_ops_id(request_type);
  85         switch (ops_id) {
  86         case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
  87         }
  88         break;
  89
  90         case ZBLIB_ALARM_OPS_RESET_ALARM: {
  91         }
  92         break;
  93
  94         case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
  95         }
  96         break;
  97
  98         case ZBLIB_ALARM_OPS_ALARM: {
  99         }
 100         break;
 101
 102         case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
 103         }
 104         break;
 105
 106         case ZBLIB_ALARM_OPS_GET_ALARM: {
 107         }
 108         break;
 109
 110         default:
 111         break;
 112         }
 113
 114         return alarm_request_data;
 115 }
 116
 117 static gpointer __zblib_request_create_custom_request_data(guint request_type,
 118         gpointer request_data, guint request_data_len)
 119 {
 120         gpointer custom_request_data = NULL;
 121         guint ops_id;
 122
 123         NOT_USED(request_data);
 124         NOT_USED(request_data_len);
 125
 126         /* Fetch ops ID */
 127         ops_id = __zblib_request_get_ops_id(request_type);
 128         switch (ops_id) {
 129         case ZBLIB_CUSTOM_OPS_APS_SEND: {
 130         }
 131         break;
 132
 133         case ZBLIB_CUSTOM_OPS_ZCL_SEND: {
 134         }
 135         break;
 136
 137         case ZBLIB_CUSTOM_OPS_SEND_TO_LOCAL: {
 138         }
 139         break;
 140
 141         default:
 142         break;
 143         }
 144
 145         return custom_request_data;
 146 }
 147
 148 static gpointer __zblib_request_create_door_lock_request_data(guint request_type,
 149         gpointer request_data, guint request_data_len)
 150 {
 151         gpointer door_lock_request_data = NULL;
 152         guint ops_id;
 153
 154         NOT_USED(request_data);
 155         NOT_USED(request_data_len);
 156
 157         /* Fetch ops ID */
 158         ops_id = __zblib_request_get_ops_id(request_type);
 159         switch (ops_id) {
 160         case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
 161         }
 162         break;
 163
 164         case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
 165         }
 166         break;
 167
 168         case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
 169         }
 170         break;
 171
 172         case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
 173         }
 174         break;
 175
 176         default:
 177         break;
 178         }
 179
 180         return door_lock_request_data;
 181 }
 182
 183 static gpointer __zblib_request_create_fan_control_request_data(guint request_type,
 184         gpointer request_data, guint request_data_len)
 185 {
 186         gpointer fan_control_request_data = NULL;
 187         guint ops_id;
 188
 189         NOT_USED(request_data);
 190         NOT_USED(request_data_len);
 191
 192         /* Fetch ops ID */
 193         ops_id = __zblib_request_get_ops_id(request_type);
 194         switch (ops_id) {
 195         case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
 196         }
 197         break;
 198
 199         case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
 200         }
 201         break;
 202
 203         case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
 204         }
 205         break;
 206
 207         case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
 208         }
 209         break;
 210
 211         default:
 212         break;
 213         }
 214
 215         return fan_control_request_data;
 216 }
 217
 218 static gpointer __zblib_request_create_level_control_request_data(guint request_type,
 219         gpointer request_data, guint request_data_len)
 220 {
 221         gpointer level_control_request_data = NULL;
 222         guint ops_id;
 223
 224         NOT_USED(request_data);
 225         NOT_USED(request_data_len);
 226
 227         /* Fetch ops ID */
 228         ops_id = __zblib_request_get_ops_id(request_type);
 229         switch (ops_id) {
 230         case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
 231         }
 232         break;
 233
 234         case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
 235         }
 236         break;
 237
 238         case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
 239         }
 240         break;
 241
 242         case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
 243         }
 244         break;
 245
 246         case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
 247         }
 248         break;
 249
 250         case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
 251         }
 252         break;
 253
 254         case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
 255         }
 256         break;
 257
 258         default:
 259         break;
 260         }
 261
 262         return level_control_request_data;
 263 }
 264
 265 static gpointer __zblib_request_create_mfglib_control_request_data(guint request_type,
 266         gpointer request_data, guint request_data_len)
 267 {
 268         gpointer mfglib_control_request_data = NULL;
 269         guint ops_id;
 270
 271         NOT_USED(request_data);
 272         NOT_USED(request_data_len);
 273
 274         /* Fetch ops ID */
 275         ops_id = __zblib_request_get_ops_id(request_type);
 276         switch (ops_id) {
 277         case ZBLIB_MFGLIB_CONTROL_OPS_START: {
 278         }
 279         break;
 280
 281         case ZBLIB_MFGLIB_CONTROL_OPS_END: {
 282         }
 283         break;
 284
 285         case ZBLIB_MFGLIB_CONTROL_OPS_START_TONE: {
 286         }
 287         break;
 288
 289         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE: {
 290         }
 291         break;
 292
 293         case ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM: {
 294         }
 295         break;
 296
 297         case ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM: {
 298         }
 299         break;
 300
 301         case ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET: {
 302         }
 303         break;
 304
 305         case ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL: {
 306         }
 307         break;
 308
 309         case ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL: {
 310         }
 311         break;
 312
 313         case ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER: {
 314         }
 315         break;
 316
 317         case ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER: {
 318         }
 319         break;
 320
 321         case ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET: {
 322         }
 323         break;
 324
 325         case ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET: {
 326         }
 327         break;
 328
 329         case ZBLIB_MFGLIB_CONTROL_OPS_RX_START: {
 330         }
 331         break;
 332
 333         case ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP: {
 334         }
 335         break;
 336
 337         case ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY: {
 338         }
 339         break;
 340
 341         case ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI: {
 342         }
 343         break;
 344
 345         default:
 346         break;
 347         }
 348
 349         return mfglib_control_request_data;
 350 }
 351
 352 static gpointer __zblib_request_create_on_off_request_data(guint request_type,
 353         gpointer request_data, guint request_data_len)
 354 {
 355         gpointer on_off_request_data = NULL;
 356         guint ops_id;
 357
 358         NOT_USED(request_data);
 359         NOT_USED(request_data_len);
 360
 361         /* Fetch ops ID */
 362         ops_id = __zblib_request_get_ops_id(request_type);
 363         switch (ops_id) {
 364         case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
 365         }
 366         break;
 367
 368         case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
 369         }
 370         break;
 371
 372         default:
 373         break;
 374         }
 375
 376         return on_off_request_data;
 377 }
 378
 379 static gpointer __zblib_request_create_service_request_data(guint request_type,
 380         gpointer request_data, guint request_data_len)
 381 {
 382         gpointer service_request_data = NULL;
 383         guint ops_id;
 384
 385         NOT_USED(request_data);
 386         NOT_USED(request_data_len);
 387
 388         /* Fetch ops ID */
 389         ops_id = __zblib_request_get_ops_id(request_type);
 390         switch (ops_id) {
 391         case ZBLIB_SERVICE_OPS_ENABLE: {
 392         }
 393         break;
 394
 395         case ZBLIB_SERVICE_OPS_DISABLE: {
 396         }
 397         break;
 398
 399         case ZBLIB_SERVICE_OPS_ZB_HW_RESET: {
 400         }
 401         break;
 402
 403         case ZBLIB_SERVICE_OPS_FORM_NETWORK: {
 404         }
 405         break;
 406
 407         case ZBLIB_SERVICE_OPS_COEX_START: {
 408         }
 409         break;
 410
 411         case ZBLIB_SERVICE_OPS_COEX_STOP: {
 412         }
 413         break;
 414
 415         case ZBLIB_SERVICE_OPS_LEAVE_NETWORK: {
 416         }
 417         break;
 418
 419         case ZBLIB_SERVICE_OPS_GET_NETWORK_INFO: {
 420         }
 421         break;
 422
 423         case ZBLIB_SERVICE_OPS_PERMIT_JOIN: {
 424         }
 425         break;
 426
 427         case ZBLIB_SERVICE_OPS_LEAVE_REQUEST: {
 428         }
 429         break;
 430
 431         case ZBLIB_SERVICE_OPS_GET_DEVICE_LIST: {
 432         }
 433         break;
 434
 435         case ZBLIB_SERVICE_OPS_GET_MAC: {
 436         }
 437         break;
 438
 439         case ZBLIB_SERVICE_OPS_GET_DEVICE_INFO: {
 440         }
 441         break;
 442
 443         case ZBLIB_SERVICE_OPS_GET_ENDPOINT_LIST: {
 444         }
 445         break;
 446
 447         case ZBLIB_SERVICE_OPS_GET_CLUSTER_LIST: {
 448         }
 449         break;
 450
 451         case ZBLIB_SERVICE_OPS_GET_NODE_TYPE: {
 452         }
 453         break;
 454
 455         default:
 456         break;
 457         }
 458
 459         return service_request_data;
 460 }
 461
 462 static gpointer __zblib_request_create_thermostat_request_data(guint request_type,
 463         gpointer request_data, guint request_data_len)
 464 {
 465         gpointer thermostat_request_data = NULL;
 466         guint ops_id;
 467
 468         NOT_USED(request_data);
 469         NOT_USED(request_data_len);
 470
 471         /* Fetch ops ID */
 472         ops_id = __zblib_request_get_ops_id(request_type);
 473         switch (ops_id) {
 474         case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
 475         }
 476         break;
 477
 478         case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
 479         }
 480         break;
 481
 482         case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
 483         }
 484         break;
 485
 486         case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
 487         }
 488         break;
 489
 490         case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
 491         }
 492         break;
 493
 494         default:
 495         break;
 496         }
 497
 498         return thermostat_request_data;
 499 }
 500
 501 static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type,
 502         gpointer request_data, guint request_data_len)
 503 {
 504         gpointer zclbasic_control_request_data = NULL;
 505         guint ops_id;
 506
 507         NOT_USED(request_data);
 508         NOT_USED(request_data_len);
 509
 510         /* Fetch ops ID */
 511         ops_id = __zblib_request_get_ops_id(request_type);
 512         switch (ops_id) {
 513         case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
 514         }
 515         break;
 516
 517         default:
 518         break;
 519         }
 520
 521         return zclbasic_control_request_data;
 522 }
 523
 524 static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type,
 525         gpointer request_data, guint request_data_len)
 526 {
 527         gpointer zclglobal_control_request_data = NULL;
 528         guint ops_id;
 529
 530         NOT_USED(request_data);
 531         NOT_USED(request_data_len);
 532
 533         /* Fetch ops ID */
 534         ops_id = __zblib_request_get_ops_id(request_type);
 535         switch (ops_id) {
 536         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
 537         }
 538         break;
 539
 540         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
 541         }
 542         break;
 543
 544         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
 545         }
 546         break;
 547
 548         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
 549         }
 550         break;
 551
 552         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
 553         }
 554         break;
 555
 556         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
 557         }
 558         break;
 559
 560         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
 561         }
 562         break;
 563
 564         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
 565         }
 566         break;
 567
 568         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
 569         }
 570         break;
 571
 572         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
 573         }
 574         break;
 575
 576         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
 577         }
 578         break;
 579
 580         case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
 581         }
 582         break;
 583
 584         default:
 585         break;
 586         }
 587
 588         return zclglobal_control_request_data;
 589 }
 590
 591 static gpointer __zblib_request_create_zclias_control_request_data(guint request_type,
 592         gpointer request_data, guint request_data_len)
 593 {
 594         gpointer zclias_control_request_data = NULL;
 595         guint ops_id;
 596
 597         NOT_USED(request_data);
 598         NOT_USED(request_data_len);
 599
 600         /* Fetch ops ID */
 601         ops_id = __zblib_request_get_ops_id(request_type);
 602         switch (ops_id) {
 603         case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
 604         }
 605         break;
 606
 607         default:
 608         break;
 609         }
 610
 611         return zclias_control_request_data;
 612 }
 613
 614 static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type,
 615         gpointer request_data, guint request_data_len)
 616 {
 617         gpointer zclidentify_control_request_data = NULL;
 618         guint ops_id;
 619
 620         NOT_USED(request_data);
 621         NOT_USED(request_data_len);
 622
 623         /* Fetch ops ID */
 624         ops_id = __zblib_request_get_ops_id(request_type);
 625         switch (ops_id) {
 626         case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
 627         }
 628         break;
 629
 630         case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
 631         }
 632         break;
 633
 634         default:
 635         break;
 636         }
 637
 638         return zclidentify_control_request_data;
 639 }
 640
 641 static gpointer __zblib_request_create_zcl_color_request_data(guint request_type,
 642         gpointer request_data, guint request_data_len)
 643 {
 644         gpointer zcl_color_request_data = NULL;
 645         guint ops_id;
 646
 647         NOT_USED(request_data);
 648         NOT_USED(request_data_len);
 649
 650         /* Fetch ops ID */
 651         ops_id = __zblib_request_get_ops_id(request_type);
 652         switch (ops_id) {
 653         case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
 654         }
 655         break;
 656
 657         case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
 658         }
 659         break;
 660
 661         case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
 662         }
 663         break;
 664
 665         case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
 666         }
 667         break;
 668
 669         case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
 670         }
 671         break;
 672
 673         case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
 674         }
 675         break;
 676
 677         case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
 678         }
 679         break;
 680
 681         case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
 682         }
 683         break;
 684
 685         case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
 686         }
 687         break;
 688
 689         case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
 690         }
 691         break;
 692
 693         case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
 694         }
 695         break;
 696
 697         default:
 698         break;
 699         }
 700
 701         return zcl_color_request_data;
 702 }
 703
 704 static gpointer __zblib_request_create_zcl_group_request_data(guint request_type,
 705         gpointer request_data, guint request_data_len)
 706 {
 707         gpointer zcl_group_request_data = NULL;
 708         guint ops_id;
 709
 710         NOT_USED(request_data);
 711         NOT_USED(request_data_len);
 712
 713         /* Fetch ops ID */
 714         ops_id = __zblib_request_get_ops_id(request_type);
 715         switch (ops_id) {
 716         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP: {
 717         }
 718         break;
 719
 720         case ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP: {
 721         }
 722         break;
 723
 724         case ZBLIB_ZCL_GROUP_OPS_GET_GROUP_MEMBERSHIP: {
 725         }
 726         break;
 727
 728         case ZBLIB_ZCL_GROUP_OPS_REMOVE_GROUP: {
 729         }
 730         break;
 731
 732         case ZBLIB_ZCL_GROUP_OPS_REMOVE_ALL_GROUP: {
 733         }
 734         break;
 735
 736         case ZBLIB_ZCL_GROUP_OPS_ADD_GROUP_IF_IDENTIFYING: {
 737         }
 738         break;
 739
 740         default:
 741         break;
 742         }
 743
 744         return zcl_group_request_data;
 745 }
 746
 747 static gpointer __zblib_request_create_zcl_poll_control_request_data(guint request_type,
 748         gpointer request_data, guint request_data_len)
 749 {
 750         gpointer zcl_poll_control_request_data = NULL;
 751         guint ops_id;
 752
 753         NOT_USED(request_data);
 754         NOT_USED(request_data_len);
 755
 756         /* Fetch ops ID */
 757         ops_id = __zblib_request_get_ops_id(request_type);
 758         switch (ops_id) {
 759         case ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE: {
 760         }
 761         break;
 762
 763         case ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP: {
 764         }
 765         break;
 766
 767         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_LONG_POLL_INTERVAL: {
 768         }
 769         break;
 770
 771         case ZBLIB_ZCL_POLL_CONTROL_OPS_SET_SHORT_POLL_INTERVAL: {
 772         }
 773         break;
 774
 775         default:
 776         break;
 777         }
 778
 779         return zcl_poll_control_request_data;
 780 }
 781
 782 static gpointer __zblib_request_create_zcl_scene_request_data(guint request_type,
 783         gpointer request_data, guint request_data_len)
 784 {
 785         gpointer zcl_scene_request_data = NULL;
 786         guint ops_id;
 787
 788         NOT_USED(request_data);
 789         NOT_USED(request_data_len);
 790
 791         /* Fetch ops ID */
 792         ops_id = __zblib_request_get_ops_id(request_type);
 793         switch (ops_id) {
 794         case ZBLIB_ZCL_SCENE_OPS_ADD_SCENE: {
 795         }
 796         break;
 797
 798         case ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE: {
 799         }
 800         break;
 801
 802         case ZBLIB_ZCL_SCENE_OPS_REMOVE_SCENE: {
 803         }
 804         break;
 805
 806         case ZBLIB_ZCL_SCENE_OPS_STORE_SCENE: {
 807         }
 808         break;
 809
 810         case ZBLIB_ZCL_SCENE_OPS_RECALL_SCENE: {
 811         }
 812         break;
 813
 814         case ZBLIB_ZCL_SCENE_OPS_REMOVE_ALL_SCENE: {
 815         }
 816         break;
 817
 818         case ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP: {
 819         }
 820         break;
 821
 822         default:
 823         break;
 824         }
 825
 826         return zcl_scene_request_data;
 827 }
 828
 829 static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type,
 830         gpointer request_data, guint request_data_len)
 831 {
 832         gpointer zdodev_control_request_data = NULL;
 833         guint ops_id;
 834
 835         NOT_USED(request_data);
 836         NOT_USED(request_data_len);
 837
 838         /* Fetch ops ID */
 839         ops_id = __zblib_request_get_ops_id(request_type);
 840         switch (ops_id) {
 841         case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
 842         }
 843         break;
 844
 845         case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
 846         }
 847         break;
 848
 849         case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
 850         }
 851         break;
 852
 853         case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
 854         }
 855         break;
 856
 857         case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
 858         }
 859         break;
 860
 861         case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
 862         }
 863         break;
 864
 865         case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
 866         }
 867         break;
 868
 869         case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
 870         }
 871         break;
 872
 873         case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
 874         }
 875         break;
 876
 877         case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
 878         }
 879         break;
 880
 881         case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
 882         }
 883         break;
 884
 885         case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
 886         }
 887         break;
 888
 889         case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
 890         }
 891         break;
 892
 893         case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
 894         }
 895         break;
 896
 897         case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
 898         }
 899         break;
 900
 901         case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
 902         }
 903         break;
 904
 905         case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
 906         }
 907         break;
 908
 909         default:
 910         break;
 911         }
 912
 913         return zdodev_control_request_data;
 914 }
 915
 916 static gpointer __zblib_request_create_zdo_bind_request_data(guint request_type,
 917         gpointer request_data, guint request_data_len)
 918 {
 919         gpointer zdo_bind_request_data = NULL;
 920         guint ops_id;
 921
 922         NOT_USED(request_data);
 923         NOT_USED(request_data_len);
 924
 925         /* Fetch ops ID */
 926         ops_id = __zblib_request_get_ops_id(request_type);
 927         switch (ops_id) {
 928         case ZBLIB_ZDO_BIND_OPS_BIND_REQ: {
 929         }
 930         break;
 931
 932         case ZBLIB_ZDO_BIND_OPS_UNBIND_REQ: {
 933         }
 934         break;
 935
 936         default:
 937         break;
 938         }
 939
 940         return zdo_bind_request_data;
 941 }
 942
 943 static gpointer __zblib_request_create_request_data(guint request_type,
 944         gpointer request_data, guint request_data_len)
 945 {
 946         gpointer _request_data = NULL;
 947         ZblibDriverType_e driver_type;
 948
 949         /* Fetch driver type */
 950         driver_type = __zblib_request_get_driver_type(request_type);
 951         switch (driver_type) {
 952         case ZBLIB_DRIVER_TYPE_ALARM: {
 953                 _request_data = __zblib_request_create_alarm_request_data(request_type,
 954                         request_data, request_data_len);
 955         }
 956         break;
 957
 958         case ZBLIB_DRIVER_TYPE_CUSTOM: {
 959                 _request_data = __zblib_request_create_custom_request_data(request_type,
 960                         request_data, request_data_len);
 961         }
 962         break;
 963
 964         case ZBLIB_DRIVER_TYPE_DOOR_LOCK: {
 965                 _request_data = __zblib_request_create_door_lock_request_data(request_type,
 966                         request_data, request_data_len);
 967         }
 968         break;
 969
 970         case ZBLIB_DRIVER_TYPE_FAN_CONTROL: {
 971                 _request_data = __zblib_request_create_fan_control_request_data(request_type,
 972                         request_data, request_data_len);
 973         }
 974         break;
 975
 976         case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: {
 977                 _request_data = __zblib_request_create_level_control_request_data(request_type,
 978                         request_data, request_data_len);
 979         }
 980         break;
 981
 982         case ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL: {
 983                 _request_data = __zblib_request_create_mfglib_control_request_data(request_type,
 984                         request_data, request_data_len);
 985         }
 986         break;
 987
 988         case ZBLIB_DRIVER_TYPE_ON_OFF: {
 989                 _request_data = __zblib_request_create_on_off_request_data(request_type,
 990                         request_data, request_data_len);
 991         }
 992         break;
 993         case ZBLIB_DRIVER_TYPE_SERVICE: {
 994                 _request_data = __zblib_request_create_service_request_data(request_type,
 995                         request_data, request_data_len);
 996         }
 997         break;
 998
 999         case ZBLIB_DRIVER_TYPE_THERMOSTAT: {
1000                 _request_data = __zblib_request_create_thermostat_request_data(request_type,
1001                         request_data, request_data_len);
1002         }
1003         break;
1004
1005         case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: {
1006                 _request_data = __zblib_request_create_zclbasic_control_request_data(request_type,
1007                         request_data, request_data_len);
1008         }
1009         break;
1010
1011         case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: {
1012                 _request_data = __zblib_request_create_zclglobal_control_request_data(request_type,
1013                         request_data, request_data_len);
1014         }
1015         break;
1016
1017         case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: {
1018                 _request_data = __zblib_request_create_zclias_control_request_data(request_type,
1019                         request_data, request_data_len);
1020         }
1021         break;
1022
1023         case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: {
1024                 _request_data = __zblib_request_create_zclidentify_control_request_data(request_type,
1025                         request_data, request_data_len);
1026         }
1027         break;
1028
1029         case ZBLIB_DRIVER_TYPE_ZCL_COLOR: {
1030                 _request_data = __zblib_request_create_zcl_color_request_data(request_type,
1031                         request_data, request_data_len);
1032         }
1033         break;
1034
1035         case ZBLIB_DRIVER_TYPE_ZCL_GROUP: {
1036                 _request_data = __zblib_request_create_zcl_group_request_data(request_type,
1037                         request_data, request_data_len);
1038         }
1039         break;
1040
1041         case ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL: {
1042                 _request_data = __zblib_request_create_zcl_poll_control_request_data(request_type,
1043                         request_data, request_data_len);
1044         }
1045         break;
1046
1047         case ZBLIB_DRIVER_TYPE_ZCL_SCENE: {
1048                 _request_data = __zblib_request_create_zcl_scene_request_data(request_type,
1049                         request_data, request_data_len);
1050         }
1051         break;
1052
1053         case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: {
1054                 _request_data = __zblib_request_create_zdodev_control_request_data(request_type,
1055                         request_data, request_data_len);
1056         }
1057         break;
1058
1059         case ZBLIB_DRIVER_TYPE_ZDO_BIND: {
1060                 _request_data = __zblib_request_create_zdo_bind_request_data(request_type,
1061                         request_data, request_data_len);
1062         }
1063         break;
1064
1065         case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */
1066         default: {
1067                 Z_LOGE("Unhandled driver type: [%d]", driver_type);
1068         }
1069         break;
1070         }
1071
1072         return _request_data;
1073 }
1074
1075 static void __zblib_request_free_request_data(gpointer request_data)
1076 {
1077         if (NULL == request_data) {
1078                 Z_LOGE("request_data is NULL");
1079                 return;
1080         }
1081
1082         /* Free resources */
1083         g_free(request_data);
1084 }
1085
1086 gint zblib_request_new(ZigBeeServiceInterface *service_interface,
1087         guint request_type, gpointer request_data, guint request_data_len)
1088 {
1089         ZigBeeService *service = NULL;
1090         ZigBeeRequest *request = NULL;
1091         GHashTable *request_table = NULL;
1092
1093         if (NULL == service_interface) {
1094                 Z_LOGE("service_interface is NULL");
1095                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
1096         }
1097
1098         service = zblib_service_interface_ref_service(service_interface);
1099         if (NULL == service) {
1100                 Z_LOGE("service is NULL");
1101                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
1102         }
1103
1104         /* Allocate ZigBee request memory */
1105         request = g_malloc0(sizeof(ZigBeeRequest));
1106
1107         /* Update request */
1108         request->service_interface = service_interface;
1109         request->ref_count = 1; /* Initialize reference count to '1' for new request */
1110
1111         /* Update request data for specific request */
1112         request->request_data = __zblib_request_create_request_data(request_type,
1113                 request_data, request_data_len);
1114         request->request_type = request_type;
1115
1116         /* Generate request ID */
1117         request->request_id = zblib_service_generate_request_id(service);
1118         if (ZIGBEE_REQUEST_INVALID_REQUEST_ID == request->request_id) {
1119                 Z_LOGE("zblib_service_genrate_request_id failed!");
1120
1121                 /* Free resources */
1122                 g_free(request);
1123
1124                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
1125         }
1126
1127         /* Fetch request table from service */
1128         request_table = zblib_service_ref_request_hash_table(service);
1129         if (NULL == request_table) {
1130                 Z_LOGE("zblib_service_ref_request_hash_table failed!");
1131
1132                 /* Free resources */
1133                 g_free(request);
1134
1135                 return ZIGBEE_REQUEST_INVALID_REQUEST_ID;
1136         }
1137
1138         /* Insert request to request table */
1139         g_hash_table_insert(request_table, (gpointer)(request->request_id), request);
1140
1141         return request->request_id;
1142 }
1143
1144 void zblib_request_free(ZigBeeRequest *request)
1145 {
1146         if (NULL == request) {
1147                 Z_LOGE("request is NULL");
1148                 return;
1149         }
1150
1151         /* Free resources */
1152         __zblib_request_free_request_data(request->request_data);
1153         g_free(request);
1154 }
1155
1156 ZigBeeRequest *zblib_request_ref(ZigBeeRequest *request)
1157 {
1158         if (NULL == request) {
1159                 Z_LOGE("request is NULL");
1160                 return request;
1161         }
1162
1163         request->ref_count++;
1164
1165         return request;
1166 }
1167
1168 void zblib_request_unref(ZigBeeRequest *request)
1169 {
1170         if (NULL == request) {
1171                 Z_LOGE("request is NULL");
1172                 return;
1173         }
1174
1175         request->ref_count--;
1176         if (0 == request->ref_count) {
1177                 Z_LOGD("Reference count is ZERO!");
1178
1179                 /* Free 'request' */
1180                 zblib_request_free(request);
1181         }
1182 }
1183
1184 guint zblib_request_ref_request_type(ZigBeeRequest *request)
1185 {
1186         if (NULL == request) {
1187                 Z_LOGE("request is NULL");
1188                 return 0;
1189         }
1190
1191         return request->request_type;
1192 }
1193
1194 ZigBeeServiceInterface *zblib_request_ref_service_interface(ZigBeeRequest *request)
1195 {
1196         if (NULL == request) {
1197                 Z_LOGE("request is NULL");
1198                 return NULL;
1199         }
1200
1201         return request->service_interface;
1202 }
1203
1204 gpointer zblib_request_ref_request_data(ZigBeeRequest *request)
1205 {
1206         if (NULL == request) {
1207                 Z_LOGE("request is NULL");
1208                 return NULL;
1209         }
1210
1211         return request->request_data;
1212 }
1213
1214 guint zblib_request_generate_request_type(ZblibDriverType_e driver_type,
1215         guint ops_id)
1216 {
1217         guint request_type;
1218
1219         /*
1220          * request_type consists of driver_type and ops_id
1221          *      request_type = driver_type | 0x00 | 0x00 | ops_id
1222          */
1223         request_type = (driver_type << 24) | (ops_id);
1224
1225         return request_type;
1226 }
1227
1228 gint zblib_request_ref_request_type_by_request_id(ZigBeeService *service,
1229         guint request_id)
1230 {
1231         ZigBeeRequest *request = NULL;
1232         GHashTable *request_table = NULL;
1233
1234         /* Fetch request table from service */
1235         request_table = zblib_service_ref_request_hash_table(service);
1236         if (NULL == request_table) {
1237                 Z_LOGE("zblib_service_ref_request_hash_table failed!");
1238                 return -1;
1239         }
1240
1241         /* Look-up requets_id in request hash table */
1242         request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
1243         if (NULL == request_table) {
1244                 Z_LOGE("No request availabel for request_id: [%d]", request_id);
1245                 return -1;
1246         }
1247
1248         return (gint)(request->request_type);
1249 }
1250
1251 ZblibDriverType_e zblib_request_get_driver_type(guint request_type)
1252 {
1253         return __zblib_request_get_driver_type(request_type);
1254 }
1255
1256 guint zblib_request_get_ops_id(guint request_type)
1257 {
1258         return __zblib_request_get_ops_id(request_type);
1259 }