examples/lighting-app/lighting-common/gen/call-command-handler.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 #include <stdint.h>
  21
  22 #include "af-structs.h"
  23 #include "call-command-handler.h"
  24 #include "callback.h"
  25 #include "cluster-id.h"
  26 #include "command-id.h"
  27 #include "util.h"
  28
  29 using namespace chip;
  30
  31 EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd);
  32 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd);
  33 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd);
  34 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd);
  35
  36 static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific)
  37 {
  38     if (wasHandled)
  39     {
  40         return EMBER_ZCL_STATUS_SUCCESS;
  41     }
  42     else if (mfgSpecific)
  43     {
  44         return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND;
  45     }
  46     else if (clusterExists)
  47     {
  48         return EMBER_ZCL_STATUS_UNSUP_COMMAND;
  49     }
  50     else
  51     {
  52         return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER;
  53     }
  54 }
  55
  56 // Main command parsing controller.
  57 EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd)
  58 {
  59     EmberAfStatus result = status(false, false, cmd->mfgSpecific);
  60     if (cmd->direction == (uint8_t) ZCL_DIRECTION_SERVER_TO_CLIENT &&
  61         emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  62     {
  63         switch (cmd->apsFrame->clusterId)
  64         {
  65         default:
  66             // Unrecognized cluster ID, error status will apply.
  67             break;
  68         }
  69     }
  70     else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER &&
  71              emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  72     {
  73         switch (cmd->apsFrame->clusterId)
  74         {
  75         case ZCL_BASIC_CLUSTER_ID:
  76             // No commands are enabled for cluster Basic
  77             result = status(false, true, cmd->mfgSpecific);
  78             break;
  79         case ZCL_LEVEL_CONTROL_CLUSTER_ID:
  80             result = emberAfLevelControlClusterServerCommandParse(cmd);
  81             break;
  82         case ZCL_NETWORK_COMMISSIONING_CLUSTER_ID:
  83             result = emberAfNetworkCommissioningClusterServerCommandParse(cmd);
  84             break;
  85         case ZCL_ON_OFF_CLUSTER_ID:
  86             result = emberAfOnOffClusterServerCommandParse(cmd);
  87             break;
  88         default:
  89             // Unrecognized cluster ID, error status will apply.
  90             break;
  91         }
  92     }
  93     return result;
  94 }
  95
  96 // Cluster specific command parsing
  97
  98 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd)
  99 {
 100     bool wasHandled = false;
 101
 102     if (!cmd->mfgSpecific)
 103     {
 104         switch (cmd->commandId)
 105         {
 106         case ZCL_MOVE_COMMAND_ID: {
 107             uint16_t payloadOffset = cmd->payloadStartIndex;
 108             uint8_t moveMode;
 109             uint8_t rate;
 110             uint8_t optionMask;
 111             uint8_t optionOverride;
 112
 113             if (cmd->bufLen < payloadOffset + 1)
 114             {
 115                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 116             }
 117             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 118             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 119             if (cmd->bufLen < payloadOffset + 1)
 120             {
 121                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 122             }
 123             rate          = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 124             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 125             if (cmd->bufLen < payloadOffset + 1)
 126             {
 127                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 128             }
 129             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 130             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 131             if (cmd->bufLen < payloadOffset + 1)
 132             {
 133                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 134             }
 135             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 136
 137             wasHandled = emberAfLevelControlClusterMoveCallback(moveMode, rate, optionMask, optionOverride);
 138             break;
 139         }
 140         case ZCL_MOVE_TO_LEVEL_COMMAND_ID: {
 141             uint16_t payloadOffset = cmd->payloadStartIndex;
 142             uint8_t level;
 143             uint16_t transitionTime;
 144             uint8_t optionMask;
 145             uint8_t optionOverride;
 146
 147             if (cmd->bufLen < payloadOffset + 1)
 148             {
 149                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 150             }
 151             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 152             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 153             if (cmd->bufLen < payloadOffset + 2)
 154             {
 155                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 156             }
 157             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 158             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 159             if (cmd->bufLen < payloadOffset + 1)
 160             {
 161                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 162             }
 163             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 164             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 165             if (cmd->bufLen < payloadOffset + 1)
 166             {
 167                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 168             }
 169             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 170
 171             wasHandled = emberAfLevelControlClusterMoveToLevelCallback(level, transitionTime, optionMask, optionOverride);
 172             break;
 173         }
 174         case ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID: {
 175             uint16_t payloadOffset = cmd->payloadStartIndex;
 176             uint8_t level;
 177             uint16_t transitionTime;
 178
 179             if (cmd->bufLen < payloadOffset + 1)
 180             {
 181                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 182             }
 183             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 184             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 185             if (cmd->bufLen < payloadOffset + 2)
 186             {
 187                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 188             }
 189             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 190
 191             wasHandled = emberAfLevelControlClusterMoveToLevelWithOnOffCallback(level, transitionTime);
 192             break;
 193         }
 194         case ZCL_MOVE_WITH_ON_OFF_COMMAND_ID: {
 195             uint16_t payloadOffset = cmd->payloadStartIndex;
 196             uint8_t moveMode;
 197             uint8_t rate;
 198
 199             if (cmd->bufLen < payloadOffset + 1)
 200             {
 201                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 202             }
 203             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 204             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 205             if (cmd->bufLen < payloadOffset + 1)
 206             {
 207                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 208             }
 209             rate = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 210
 211             wasHandled = emberAfLevelControlClusterMoveWithOnOffCallback(moveMode, rate);
 212             break;
 213         }
 214         case ZCL_STEP_COMMAND_ID: {
 215             uint16_t payloadOffset = cmd->payloadStartIndex;
 216             uint8_t stepMode;
 217             uint8_t stepSize;
 218             uint16_t transitionTime;
 219             uint8_t optionMask;
 220             uint8_t optionOverride;
 221
 222             if (cmd->bufLen < payloadOffset + 1)
 223             {
 224                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 225             }
 226             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 227             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 228             if (cmd->bufLen < payloadOffset + 1)
 229             {
 230                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 231             }
 232             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 233             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 234             if (cmd->bufLen < payloadOffset + 2)
 235             {
 236                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 237             }
 238             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 239             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 240             if (cmd->bufLen < payloadOffset + 1)
 241             {
 242                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 243             }
 244             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 245             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 246             if (cmd->bufLen < payloadOffset + 1)
 247             {
 248                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 249             }
 250             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 251
 252             wasHandled = emberAfLevelControlClusterStepCallback(stepMode, stepSize, transitionTime, optionMask, optionOverride);
 253             break;
 254         }
 255         case ZCL_STEP_WITH_ON_OFF_COMMAND_ID: {
 256             uint16_t payloadOffset = cmd->payloadStartIndex;
 257             uint8_t stepMode;
 258             uint8_t stepSize;
 259             uint16_t transitionTime;
 260
 261             if (cmd->bufLen < payloadOffset + 1)
 262             {
 263                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 264             }
 265             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 266             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 267             if (cmd->bufLen < payloadOffset + 1)
 268             {
 269                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 270             }
 271             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 272             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 273             if (cmd->bufLen < payloadOffset + 2)
 274             {
 275                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 276             }
 277             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 278
 279             wasHandled = emberAfLevelControlClusterStepWithOnOffCallback(stepMode, stepSize, transitionTime);
 280             break;
 281         }
 282         case ZCL_STOP_COMMAND_ID: {
 283             uint16_t payloadOffset = cmd->payloadStartIndex;
 284             uint8_t optionMask;
 285             uint8_t optionOverride;
 286
 287             if (cmd->bufLen < payloadOffset + 1)
 288             {
 289                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 290             }
 291             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 292             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 293             if (cmd->bufLen < payloadOffset + 1)
 294             {
 295                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 296             }
 297             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 298
 299             wasHandled = emberAfLevelControlClusterStopCallback(optionMask, optionOverride);
 300             break;
 301         }
 302         case ZCL_STOP_WITH_ON_OFF_COMMAND_ID: {
 303             wasHandled = emberAfLevelControlClusterStopWithOnOffCallback();
 304             break;
 305         }
 306         default: {
 307             // Unrecognized command ID, error status will apply.
 308             break;
 309         }
 310         }
 311     }
 312     return status(wasHandled, true, cmd->mfgSpecific);
 313 }
 314 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd)
 315 {
 316     bool wasHandled = false;
 317
 318     if (!cmd->mfgSpecific)
 319     {
 320         switch (cmd->commandId)
 321         {
 322         case ZCL_ADD_THREAD_NETWORK_COMMAND_ID: {
 323             uint16_t payloadOffset = cmd->payloadStartIndex;
 324             uint8_t * operationalDataset;
 325             uint64_t breadcrumb;
 326             uint32_t timeoutMs;
 327
 328             if (cmd->bufLen < payloadOffset + 1u)
 329             {
 330                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 331             }
 332             operationalDataset = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 333             payloadOffset      = static_cast<uint16_t>(payloadOffset + emberAfStringLength(operationalDataset) + 1u);
 334             if (cmd->bufLen < payloadOffset + 8)
 335             {
 336                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 337             }
 338             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 339             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 340             if (cmd->bufLen < payloadOffset + 4)
 341             {
 342                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 343             }
 344             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 345
 346             wasHandled = emberAfNetworkCommissioningClusterAddThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 347             break;
 348         }
 349         case ZCL_ADD_WI_FI_NETWORK_COMMAND_ID: {
 350             uint16_t payloadOffset = cmd->payloadStartIndex;
 351             uint8_t * ssid;
 352             uint8_t * credentials;
 353             uint64_t breadcrumb;
 354             uint32_t timeoutMs;
 355
 356             if (cmd->bufLen < payloadOffset + 1u)
 357             {
 358                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 359             }
 360             ssid          = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 361             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(ssid) + 1u);
 362             if (cmd->bufLen < payloadOffset + 1u)
 363             {
 364                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 365             }
 366             credentials   = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 367             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(credentials) + 1u);
 368             if (cmd->bufLen < payloadOffset + 8)
 369             {
 370                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 371             }
 372             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 373             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 374             if (cmd->bufLen < payloadOffset + 4)
 375             {
 376                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 377             }
 378             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 379
 380             wasHandled = emberAfNetworkCommissioningClusterAddWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 381             break;
 382         }
 383         case ZCL_DISABLE_NETWORK_COMMAND_ID: {
 384             uint16_t payloadOffset = cmd->payloadStartIndex;
 385             uint8_t * networkID;
 386             uint64_t breadcrumb;
 387             uint32_t timeoutMs;
 388
 389             if (cmd->bufLen < payloadOffset + 1u)
 390             {
 391                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 392             }
 393             networkID     = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 394             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(networkID) + 1u);
 395             if (cmd->bufLen < payloadOffset + 8)
 396             {
 397                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 398             }
 399             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 400             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 401             if (cmd->bufLen < payloadOffset + 4)
 402             {
 403                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 404             }
 405             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 406
 407             wasHandled = emberAfNetworkCommissioningClusterDisableNetworkCallback(networkID, breadcrumb, timeoutMs);
 408             break;
 409         }
 410         case ZCL_ENABLE_NETWORK_COMMAND_ID: {
 411             uint16_t payloadOffset = cmd->payloadStartIndex;
 412             uint8_t * networkID;
 413             uint64_t breadcrumb;
 414             uint32_t timeoutMs;
 415
 416             if (cmd->bufLen < payloadOffset + 1u)
 417             {
 418                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 419             }
 420             networkID     = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 421             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(networkID) + 1u);
 422             if (cmd->bufLen < payloadOffset + 8)
 423             {
 424                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 425             }
 426             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 427             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 428             if (cmd->bufLen < payloadOffset + 4)
 429             {
 430                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 431             }
 432             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 433
 434             wasHandled = emberAfNetworkCommissioningClusterEnableNetworkCallback(networkID, breadcrumb, timeoutMs);
 435             break;
 436         }
 437         case ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID: {
 438             uint16_t payloadOffset = cmd->payloadStartIndex;
 439             uint32_t timeoutMs;
 440
 441             if (cmd->bufLen < payloadOffset + 4)
 442             {
 443                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 444             }
 445             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 446
 447             wasHandled = emberAfNetworkCommissioningClusterGetLastNetworkCommissioningResultCallback(timeoutMs);
 448             break;
 449         }
 450         case ZCL_REMOVE_NETWORK_COMMAND_ID: {
 451             uint16_t payloadOffset = cmd->payloadStartIndex;
 452             uint8_t * NetworkID;
 453             uint64_t Breadcrumb;
 454             uint32_t TimeoutMs;
 455
 456             if (cmd->bufLen < payloadOffset + 1u)
 457             {
 458                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 459             }
 460             NetworkID     = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 461             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(NetworkID) + 1u);
 462             if (cmd->bufLen < payloadOffset + 8)
 463             {
 464                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 465             }
 466             Breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 467             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 468             if (cmd->bufLen < payloadOffset + 4)
 469             {
 470                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 471             }
 472             TimeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 473
 474             wasHandled = emberAfNetworkCommissioningClusterRemoveNetworkCallback(NetworkID, Breadcrumb, TimeoutMs);
 475             break;
 476         }
 477         case ZCL_SCAN_NETWORKS_COMMAND_ID: {
 478             uint16_t payloadOffset = cmd->payloadStartIndex;
 479             uint8_t * ssid;
 480             uint64_t breadcrumb;
 481             uint32_t timeoutMs;
 482
 483             if (cmd->bufLen < payloadOffset + 1u)
 484             {
 485                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 486             }
 487             ssid          = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 488             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(ssid) + 1u);
 489             if (cmd->bufLen < payloadOffset + 8)
 490             {
 491                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 492             }
 493             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 494             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 495             if (cmd->bufLen < payloadOffset + 4)
 496             {
 497                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 498             }
 499             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 500
 501             wasHandled = emberAfNetworkCommissioningClusterScanNetworksCallback(ssid, breadcrumb, timeoutMs);
 502             break;
 503         }
 504         case ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID: {
 505             uint16_t payloadOffset = cmd->payloadStartIndex;
 506             uint8_t * operationalDataset;
 507             uint64_t breadcrumb;
 508             uint32_t timeoutMs;
 509
 510             if (cmd->bufLen < payloadOffset + 1u)
 511             {
 512                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 513             }
 514             operationalDataset = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 515             payloadOffset      = static_cast<uint16_t>(payloadOffset + emberAfStringLength(operationalDataset) + 1u);
 516             if (cmd->bufLen < payloadOffset + 8)
 517             {
 518                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 519             }
 520             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 521             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 522             if (cmd->bufLen < payloadOffset + 4)
 523             {
 524                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 525             }
 526             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 527
 528             wasHandled = emberAfNetworkCommissioningClusterUpdateThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 529             break;
 530         }
 531         case ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID: {
 532             uint16_t payloadOffset = cmd->payloadStartIndex;
 533             uint8_t * ssid;
 534             uint8_t * credentials;
 535             uint64_t breadcrumb;
 536             uint32_t timeoutMs;
 537
 538             if (cmd->bufLen < payloadOffset + 1u)
 539             {
 540                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 541             }
 542             ssid          = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 543             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(ssid) + 1u);
 544             if (cmd->bufLen < payloadOffset + 1u)
 545             {
 546                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 547             }
 548             credentials   = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 549             payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(credentials) + 1u);
 550             if (cmd->bufLen < payloadOffset + 8)
 551             {
 552                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 553             }
 554             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 555             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 556             if (cmd->bufLen < payloadOffset + 4)
 557             {
 558                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 559             }
 560             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 561
 562             wasHandled = emberAfNetworkCommissioningClusterUpdateWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 563             break;
 564         }
 565         default: {
 566             // Unrecognized command ID, error status will apply.
 567             break;
 568         }
 569         }
 570     }
 571     return status(wasHandled, true, cmd->mfgSpecific);
 572 }
 573 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd)
 574 {
 575     bool wasHandled = false;
 576
 577     if (!cmd->mfgSpecific)
 578     {
 579         switch (cmd->commandId)
 580         {
 581         case ZCL_OFF_COMMAND_ID: {
 582             wasHandled = emberAfOnOffClusterOffCallback();
 583             break;
 584         }
 585         case ZCL_ON_COMMAND_ID: {
 586             wasHandled = emberAfOnOffClusterOnCallback();
 587             break;
 588         }
 589         case ZCL_TOGGLE_COMMAND_ID: {
 590             wasHandled = emberAfOnOffClusterToggleCallback();
 591             break;
 592         }
 593         default: {
 594             // Unrecognized command ID, error status will apply.
 595             break;
 596         }
 597         }
 598     }
 599     return status(wasHandled, true, cmd->mfgSpecific);
 600 }