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 "app/util/util.h"
  24 #include "call-command-handler.h"
  25 #include "callback.h"
  26 #include "cluster-id.h"
  27 #include "command-id.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             chip::ByteSpan 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             {
 333                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 334                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 335             }
 336             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
 337             if (cmd->bufLen < payloadOffset + 8)
 338             {
 339                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 340             }
 341             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 342             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 343             if (cmd->bufLen < payloadOffset + 4)
 344             {
 345                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 346             }
 347             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 348
 349             wasHandled = emberAfNetworkCommissioningClusterAddThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 350             break;
 351         }
 352         case ZCL_ADD_WI_FI_NETWORK_COMMAND_ID: {
 353             uint16_t payloadOffset = cmd->payloadStartIndex;
 354             chip::ByteSpan ssid;
 355             chip::ByteSpan credentials;
 356             uint64_t breadcrumb;
 357             uint32_t timeoutMs;
 358
 359             if (cmd->bufLen < payloadOffset + 1u)
 360             {
 361                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 362             }
 363             {
 364                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 365                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 366             }
 367             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 368             if (cmd->bufLen < payloadOffset + 1u)
 369             {
 370                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 371             }
 372             {
 373                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 374                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 375             }
 376             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
 377             if (cmd->bufLen < payloadOffset + 8)
 378             {
 379                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 380             }
 381             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 382             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 383             if (cmd->bufLen < payloadOffset + 4)
 384             {
 385                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 386             }
 387             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 388
 389             wasHandled = emberAfNetworkCommissioningClusterAddWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 390             break;
 391         }
 392         case ZCL_DISABLE_NETWORK_COMMAND_ID: {
 393             uint16_t payloadOffset = cmd->payloadStartIndex;
 394             chip::ByteSpan networkID;
 395             uint64_t breadcrumb;
 396             uint32_t timeoutMs;
 397
 398             if (cmd->bufLen < payloadOffset + 1u)
 399             {
 400                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 401             }
 402             {
 403                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 404                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 405             }
 406             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
 407             if (cmd->bufLen < payloadOffset + 8)
 408             {
 409                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 410             }
 411             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 412             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 413             if (cmd->bufLen < payloadOffset + 4)
 414             {
 415                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 416             }
 417             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 418
 419             wasHandled = emberAfNetworkCommissioningClusterDisableNetworkCallback(networkID, breadcrumb, timeoutMs);
 420             break;
 421         }
 422         case ZCL_ENABLE_NETWORK_COMMAND_ID: {
 423             uint16_t payloadOffset = cmd->payloadStartIndex;
 424             chip::ByteSpan networkID;
 425             uint64_t breadcrumb;
 426             uint32_t timeoutMs;
 427
 428             if (cmd->bufLen < payloadOffset + 1u)
 429             {
 430                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 431             }
 432             {
 433                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 434                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 435             }
 436             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
 437             if (cmd->bufLen < payloadOffset + 8)
 438             {
 439                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 440             }
 441             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 442             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 443             if (cmd->bufLen < payloadOffset + 4)
 444             {
 445                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 446             }
 447             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 448
 449             wasHandled = emberAfNetworkCommissioningClusterEnableNetworkCallback(networkID, breadcrumb, timeoutMs);
 450             break;
 451         }
 452         case ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID: {
 453             uint16_t payloadOffset = cmd->payloadStartIndex;
 454             uint32_t timeoutMs;
 455
 456             if (cmd->bufLen < payloadOffset + 4)
 457             {
 458                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 459             }
 460             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 461
 462             wasHandled = emberAfNetworkCommissioningClusterGetLastNetworkCommissioningResultCallback(timeoutMs);
 463             break;
 464         }
 465         case ZCL_REMOVE_NETWORK_COMMAND_ID: {
 466             uint16_t payloadOffset = cmd->payloadStartIndex;
 467             chip::ByteSpan NetworkID;
 468             uint64_t Breadcrumb;
 469             uint32_t TimeoutMs;
 470
 471             if (cmd->bufLen < payloadOffset + 1u)
 472             {
 473                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 474             }
 475             {
 476                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 477                 NetworkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 478             }
 479             payloadOffset = static_cast<uint16_t>(payloadOffset + NetworkID.size() + 1u);
 480             if (cmd->bufLen < payloadOffset + 8)
 481             {
 482                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 483             }
 484             Breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 485             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 486             if (cmd->bufLen < payloadOffset + 4)
 487             {
 488                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 489             }
 490             TimeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 491
 492             wasHandled = emberAfNetworkCommissioningClusterRemoveNetworkCallback(NetworkID, Breadcrumb, TimeoutMs);
 493             break;
 494         }
 495         case ZCL_SCAN_NETWORKS_COMMAND_ID: {
 496             uint16_t payloadOffset = cmd->payloadStartIndex;
 497             chip::ByteSpan ssid;
 498             uint64_t breadcrumb;
 499             uint32_t timeoutMs;
 500
 501             if (cmd->bufLen < payloadOffset + 1u)
 502             {
 503                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 504             }
 505             {
 506                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 507                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 508             }
 509             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 510             if (cmd->bufLen < payloadOffset + 8)
 511             {
 512                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 513             }
 514             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 515             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 516             if (cmd->bufLen < payloadOffset + 4)
 517             {
 518                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 519             }
 520             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 521
 522             wasHandled = emberAfNetworkCommissioningClusterScanNetworksCallback(ssid, breadcrumb, timeoutMs);
 523             break;
 524         }
 525         case ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID: {
 526             uint16_t payloadOffset = cmd->payloadStartIndex;
 527             chip::ByteSpan operationalDataset;
 528             uint64_t breadcrumb;
 529             uint32_t timeoutMs;
 530
 531             if (cmd->bufLen < payloadOffset + 1u)
 532             {
 533                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 534             }
 535             {
 536                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 537                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 538             }
 539             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
 540             if (cmd->bufLen < payloadOffset + 8)
 541             {
 542                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 543             }
 544             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 545             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 546             if (cmd->bufLen < payloadOffset + 4)
 547             {
 548                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 549             }
 550             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 551
 552             wasHandled = emberAfNetworkCommissioningClusterUpdateThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 553             break;
 554         }
 555         case ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID: {
 556             uint16_t payloadOffset = cmd->payloadStartIndex;
 557             chip::ByteSpan ssid;
 558             chip::ByteSpan credentials;
 559             uint64_t breadcrumb;
 560             uint32_t timeoutMs;
 561
 562             if (cmd->bufLen < payloadOffset + 1u)
 563             {
 564                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 565             }
 566             {
 567                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 568                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 569             }
 570             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 571             if (cmd->bufLen < payloadOffset + 1u)
 572             {
 573                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 574             }
 575             {
 576                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 577                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 578             }
 579             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
 580             if (cmd->bufLen < payloadOffset + 8)
 581             {
 582                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 583             }
 584             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 585             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 586             if (cmd->bufLen < payloadOffset + 4)
 587             {
 588                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 589             }
 590             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 591
 592             wasHandled = emberAfNetworkCommissioningClusterUpdateWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 593             break;
 594         }
 595         default: {
 596             // Unrecognized command ID, error status will apply.
 597             break;
 598         }
 599         }
 600     }
 601     return status(wasHandled, true, cmd->mfgSpecific);
 602 }
 603 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd)
 604 {
 605     bool wasHandled = false;
 606
 607     if (!cmd->mfgSpecific)
 608     {
 609         switch (cmd->commandId)
 610         {
 611         case ZCL_OFF_COMMAND_ID: {
 612             wasHandled = emberAfOnOffClusterOffCallback();
 613             break;
 614         }
 615         case ZCL_ON_COMMAND_ID: {
 616             wasHandled = emberAfOnOffClusterOnCallback();
 617             break;
 618         }
 619         case ZCL_TOGGLE_COMMAND_ID: {
 620             wasHandled = emberAfOnOffClusterToggleCallback();
 621             break;
 622         }
 623         default: {
 624             // Unrecognized command ID, error status will apply.
 625             break;
 626         }
 627         }
 628     }
 629     return status(wasHandled, true, cmd->mfgSpecific);
 630 }