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