examples/tv-app/tv-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 emberAfApplicationBasicClusterServerCommandParse(EmberAfClusterCommand * cmd);
  32 EmberAfStatus emberAfBarrierControlClusterClientCommandParse(EmberAfClusterCommand * cmd);
  33 EmberAfStatus emberAfBarrierControlClusterServerCommandParse(EmberAfClusterCommand * cmd);
  34 EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd);
  35 EmberAfStatus emberAfColorControlClusterClientCommandParse(EmberAfClusterCommand * cmd);
  36 EmberAfStatus emberAfColorControlClusterServerCommandParse(EmberAfClusterCommand * cmd);
  37 EmberAfStatus emberAfDoorLockClusterClientCommandParse(EmberAfClusterCommand * cmd);
  38 EmberAfStatus emberAfDoorLockClusterServerCommandParse(EmberAfClusterCommand * cmd);
  39 EmberAfStatus emberAfGroupsClusterServerCommandParse(EmberAfClusterCommand * cmd);
  40 EmberAfStatus emberAfIasZoneClusterServerCommandParse(EmberAfClusterCommand * cmd);
  41 EmberAfStatus emberAfIdentifyClusterServerCommandParse(EmberAfClusterCommand * cmd);
  42 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd);
  43 EmberAfStatus emberAfLowPowerClusterServerCommandParse(EmberAfClusterCommand * cmd);
  44 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd);
  45 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd);
  46 EmberAfStatus emberAfScenesClusterServerCommandParse(EmberAfClusterCommand * cmd);
  47 EmberAfStatus emberAfTemperatureMeasurementClusterServerCommandParse(EmberAfClusterCommand * cmd);
  48
  49 static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific)
  50 {
  51     if (wasHandled)
  52     {
  53         return EMBER_ZCL_STATUS_SUCCESS;
  54     }
  55     else if (mfgSpecific)
  56     {
  57         return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND;
  58     }
  59     else if (clusterExists)
  60     {
  61         return EMBER_ZCL_STATUS_UNSUP_COMMAND;
  62     }
  63     else
  64     {
  65         return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER;
  66     }
  67 }
  68
  69 // Main command parsing controller.
  70 EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd)
  71 {
  72     EmberAfStatus result = status(false, false, cmd->mfgSpecific);
  73     if (cmd->direction == (uint8_t) ZCL_DIRECTION_SERVER_TO_CLIENT &&
  74         emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  75     {
  76         switch (cmd->apsFrame->clusterId)
  77         {
  78         case ZCL_BARRIER_CONTROL_CLUSTER_ID:
  79             // No commands are enabled for cluster Barrier Control
  80             result = status(false, true, cmd->mfgSpecific);
  81             break;
  82         case ZCL_COLOR_CONTROL_CLUSTER_ID:
  83             // No commands are enabled for cluster Color Control
  84             result = status(false, true, cmd->mfgSpecific);
  85             break;
  86         case ZCL_DOOR_LOCK_CLUSTER_ID:
  87             result = emberAfDoorLockClusterClientCommandParse(cmd);
  88             break;
  89         default:
  90             // Unrecognized cluster ID, error status will apply.
  91             break;
  92         }
  93     }
  94     else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER &&
  95              emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  96     {
  97         switch (cmd->apsFrame->clusterId)
  98         {
  99         case ZCL_APPLICATION_BASIC_CLUSTER_ID:
 100             // No commands are enabled for cluster Application Basic
 101             result = status(false, true, cmd->mfgSpecific);
 102             break;
 103         case ZCL_BARRIER_CONTROL_CLUSTER_ID:
 104             result = emberAfBarrierControlClusterServerCommandParse(cmd);
 105             break;
 106         case ZCL_BASIC_CLUSTER_ID:
 107             // No commands are enabled for cluster Basic
 108             result = status(false, true, cmd->mfgSpecific);
 109             break;
 110         case ZCL_COLOR_CONTROL_CLUSTER_ID:
 111             result = emberAfColorControlClusterServerCommandParse(cmd);
 112             break;
 113         case ZCL_DOOR_LOCK_CLUSTER_ID:
 114             result = emberAfDoorLockClusterServerCommandParse(cmd);
 115             break;
 116         case ZCL_GROUPS_CLUSTER_ID:
 117             result = emberAfGroupsClusterServerCommandParse(cmd);
 118             break;
 119         case ZCL_IAS_ZONE_CLUSTER_ID:
 120             result = emberAfIasZoneClusterServerCommandParse(cmd);
 121             break;
 122         case ZCL_IDENTIFY_CLUSTER_ID:
 123             result = emberAfIdentifyClusterServerCommandParse(cmd);
 124             break;
 125         case ZCL_LEVEL_CONTROL_CLUSTER_ID:
 126             result = emberAfLevelControlClusterServerCommandParse(cmd);
 127             break;
 128         case ZCL_LOW_POWER_CLUSTER_ID:
 129             result = emberAfLowPowerClusterServerCommandParse(cmd);
 130             break;
 131         case ZCL_NETWORK_COMMISSIONING_CLUSTER_ID:
 132             result = emberAfNetworkCommissioningClusterServerCommandParse(cmd);
 133             break;
 134         case ZCL_ON_OFF_CLUSTER_ID:
 135             result = emberAfOnOffClusterServerCommandParse(cmd);
 136             break;
 137         case ZCL_SCENES_CLUSTER_ID:
 138             result = emberAfScenesClusterServerCommandParse(cmd);
 139             break;
 140         case ZCL_TEMP_MEASUREMENT_CLUSTER_ID:
 141             // No commands are enabled for cluster Temperature Measurement
 142             result = status(false, true, cmd->mfgSpecific);
 143             break;
 144         default:
 145             // Unrecognized cluster ID, error status will apply.
 146             break;
 147         }
 148     }
 149     return result;
 150 }
 151
 152 // Cluster specific command parsing
 153
 154 EmberAfStatus emberAfBarrierControlClusterServerCommandParse(EmberAfClusterCommand * cmd)
 155 {
 156     bool wasHandled = false;
 157
 158     if (!cmd->mfgSpecific)
 159     {
 160         switch (cmd->commandId)
 161         {
 162         case ZCL_BARRIER_CONTROL_GO_TO_PERCENT_COMMAND_ID: {
 163             uint16_t payloadOffset = cmd->payloadStartIndex;
 164             uint8_t percentOpen;
 165
 166             if (cmd->bufLen < payloadOffset + 1)
 167             {
 168                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 169             }
 170             percentOpen = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 171
 172             wasHandled = emberAfBarrierControlClusterBarrierControlGoToPercentCallback(percentOpen);
 173             break;
 174         }
 175         case ZCL_BARRIER_CONTROL_STOP_COMMAND_ID: {
 176             wasHandled = emberAfBarrierControlClusterBarrierControlStopCallback();
 177             break;
 178         }
 179         default: {
 180             // Unrecognized command ID, error status will apply.
 181             break;
 182         }
 183         }
 184     }
 185     return status(wasHandled, true, cmd->mfgSpecific);
 186 }
 187 EmberAfStatus emberAfColorControlClusterServerCommandParse(EmberAfClusterCommand * cmd)
 188 {
 189     bool wasHandled = false;
 190
 191     if (!cmd->mfgSpecific)
 192     {
 193         switch (cmd->commandId)
 194         {
 195         case ZCL_MOVE_COLOR_COMMAND_ID: {
 196             uint16_t payloadOffset = cmd->payloadStartIndex;
 197             int16_t rateX;
 198             int16_t rateY;
 199             uint8_t optionsMask;
 200             uint8_t optionsOverride;
 201
 202             if (cmd->bufLen < payloadOffset + 2)
 203             {
 204                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 205             }
 206             rateX         = static_cast<int16_t>(emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen));
 207             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 208             if (cmd->bufLen < payloadOffset + 2)
 209             {
 210                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 211             }
 212             rateY         = static_cast<int16_t>(emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen));
 213             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 214             if (cmd->bufLen < payloadOffset + 1)
 215             {
 216                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 217             }
 218             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 219             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 220             if (cmd->bufLen < payloadOffset + 1)
 221             {
 222                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 223             }
 224             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 225
 226             wasHandled = emberAfColorControlClusterMoveColorCallback(rateX, rateY, optionsMask, optionsOverride);
 227             break;
 228         }
 229         case ZCL_MOVE_COLOR_TEMPERATURE_COMMAND_ID: {
 230             uint16_t payloadOffset = cmd->payloadStartIndex;
 231             uint8_t moveMode;
 232             uint16_t rate;
 233             uint16_t colorTemperatureMinimum;
 234             uint16_t colorTemperatureMaximum;
 235             uint8_t optionsMask;
 236             uint8_t optionsOverride;
 237
 238             if (cmd->bufLen < payloadOffset + 1)
 239             {
 240                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 241             }
 242             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 243             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 244             if (cmd->bufLen < payloadOffset + 2)
 245             {
 246                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 247             }
 248             rate          = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 249             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 250             if (cmd->bufLen < payloadOffset + 2)
 251             {
 252                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 253             }
 254             colorTemperatureMinimum = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 255             payloadOffset           = static_cast<uint16_t>(payloadOffset + 2);
 256             if (cmd->bufLen < payloadOffset + 2)
 257             {
 258                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 259             }
 260             colorTemperatureMaximum = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 261             payloadOffset           = static_cast<uint16_t>(payloadOffset + 2);
 262             if (cmd->bufLen < payloadOffset + 1)
 263             {
 264                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 265             }
 266             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 267             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 268             if (cmd->bufLen < payloadOffset + 1)
 269             {
 270                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 271             }
 272             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 273
 274             wasHandled = emberAfColorControlClusterMoveColorTemperatureCallback(
 275                 moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
 276             break;
 277         }
 278         case ZCL_MOVE_HUE_COMMAND_ID: {
 279             uint16_t payloadOffset = cmd->payloadStartIndex;
 280             uint8_t moveMode;
 281             uint8_t rate;
 282             uint8_t optionsMask;
 283             uint8_t optionsOverride;
 284
 285             if (cmd->bufLen < payloadOffset + 1)
 286             {
 287                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 288             }
 289             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 290             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 291             if (cmd->bufLen < payloadOffset + 1)
 292             {
 293                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 294             }
 295             rate          = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 296             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 297             if (cmd->bufLen < payloadOffset + 1)
 298             {
 299                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 300             }
 301             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 302             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 303             if (cmd->bufLen < payloadOffset + 1)
 304             {
 305                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 306             }
 307             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 308
 309             wasHandled = emberAfColorControlClusterMoveHueCallback(moveMode, rate, optionsMask, optionsOverride);
 310             break;
 311         }
 312         case ZCL_MOVE_SATURATION_COMMAND_ID: {
 313             uint16_t payloadOffset = cmd->payloadStartIndex;
 314             uint8_t moveMode;
 315             uint8_t rate;
 316             uint8_t optionsMask;
 317             uint8_t optionsOverride;
 318
 319             if (cmd->bufLen < payloadOffset + 1)
 320             {
 321                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 322             }
 323             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 324             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 325             if (cmd->bufLen < payloadOffset + 1)
 326             {
 327                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 328             }
 329             rate          = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 330             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 331             if (cmd->bufLen < payloadOffset + 1)
 332             {
 333                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 334             }
 335             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 336             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 337             if (cmd->bufLen < payloadOffset + 1)
 338             {
 339                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 340             }
 341             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 342
 343             wasHandled = emberAfColorControlClusterMoveSaturationCallback(moveMode, rate, optionsMask, optionsOverride);
 344             break;
 345         }
 346         case ZCL_MOVE_TO_COLOR_COMMAND_ID: {
 347             uint16_t payloadOffset = cmd->payloadStartIndex;
 348             uint16_t colorX;
 349             uint16_t colorY;
 350             uint16_t transitionTime;
 351             uint8_t optionsMask;
 352             uint8_t optionsOverride;
 353
 354             if (cmd->bufLen < payloadOffset + 2)
 355             {
 356                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 357             }
 358             colorX        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 359             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 360             if (cmd->bufLen < payloadOffset + 2)
 361             {
 362                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 363             }
 364             colorY        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 365             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 366             if (cmd->bufLen < payloadOffset + 2)
 367             {
 368                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 369             }
 370             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 371             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 372             if (cmd->bufLen < payloadOffset + 1)
 373             {
 374                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 375             }
 376             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 377             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 378             if (cmd->bufLen < payloadOffset + 1)
 379             {
 380                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 381             }
 382             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 383
 384             wasHandled =
 385                 emberAfColorControlClusterMoveToColorCallback(colorX, colorY, transitionTime, optionsMask, optionsOverride);
 386             break;
 387         }
 388         case ZCL_MOVE_TO_COLOR_TEMPERATURE_COMMAND_ID: {
 389             uint16_t payloadOffset = cmd->payloadStartIndex;
 390             uint16_t colorTemperature;
 391             uint16_t transitionTime;
 392             uint8_t optionsMask;
 393             uint8_t optionsOverride;
 394
 395             if (cmd->bufLen < payloadOffset + 2)
 396             {
 397                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 398             }
 399             colorTemperature = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 400             payloadOffset    = static_cast<uint16_t>(payloadOffset + 2);
 401             if (cmd->bufLen < payloadOffset + 2)
 402             {
 403                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 404             }
 405             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 406             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 407             if (cmd->bufLen < payloadOffset + 1)
 408             {
 409                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 410             }
 411             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 412             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 413             if (cmd->bufLen < payloadOffset + 1)
 414             {
 415                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 416             }
 417             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 418
 419             wasHandled = emberAfColorControlClusterMoveToColorTemperatureCallback(colorTemperature, transitionTime, optionsMask,
 420                                                                                   optionsOverride);
 421             break;
 422         }
 423         case ZCL_MOVE_TO_HUE_COMMAND_ID: {
 424             uint16_t payloadOffset = cmd->payloadStartIndex;
 425             uint8_t hue;
 426             uint8_t direction;
 427             uint16_t transitionTime;
 428             uint8_t optionsMask;
 429             uint8_t optionsOverride;
 430
 431             if (cmd->bufLen < payloadOffset + 1)
 432             {
 433                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 434             }
 435             hue           = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 436             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 437             if (cmd->bufLen < payloadOffset + 1)
 438             {
 439                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 440             }
 441             direction     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 442             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 443             if (cmd->bufLen < payloadOffset + 2)
 444             {
 445                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 446             }
 447             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 448             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 449             if (cmd->bufLen < payloadOffset + 1)
 450             {
 451                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 452             }
 453             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 454             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 455             if (cmd->bufLen < payloadOffset + 1)
 456             {
 457                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 458             }
 459             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 460
 461             wasHandled = emberAfColorControlClusterMoveToHueCallback(hue, direction, transitionTime, optionsMask, optionsOverride);
 462             break;
 463         }
 464         case ZCL_MOVE_TO_HUE_AND_SATURATION_COMMAND_ID: {
 465             uint16_t payloadOffset = cmd->payloadStartIndex;
 466             uint8_t hue;
 467             uint8_t saturation;
 468             uint16_t transitionTime;
 469             uint8_t optionsMask;
 470             uint8_t optionsOverride;
 471
 472             if (cmd->bufLen < payloadOffset + 1)
 473             {
 474                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 475             }
 476             hue           = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 477             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 478             if (cmd->bufLen < payloadOffset + 1)
 479             {
 480                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 481             }
 482             saturation    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 483             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 484             if (cmd->bufLen < payloadOffset + 2)
 485             {
 486                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 487             }
 488             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 489             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 490             if (cmd->bufLen < payloadOffset + 1)
 491             {
 492                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 493             }
 494             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 495             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 496             if (cmd->bufLen < payloadOffset + 1)
 497             {
 498                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 499             }
 500             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 501
 502             wasHandled = emberAfColorControlClusterMoveToHueAndSaturationCallback(hue, saturation, transitionTime, optionsMask,
 503                                                                                   optionsOverride);
 504             break;
 505         }
 506         case ZCL_MOVE_TO_SATURATION_COMMAND_ID: {
 507             uint16_t payloadOffset = cmd->payloadStartIndex;
 508             uint8_t saturation;
 509             uint16_t transitionTime;
 510             uint8_t optionsMask;
 511             uint8_t optionsOverride;
 512
 513             if (cmd->bufLen < payloadOffset + 1)
 514             {
 515                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 516             }
 517             saturation    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 518             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 519             if (cmd->bufLen < payloadOffset + 2)
 520             {
 521                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 522             }
 523             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 524             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 525             if (cmd->bufLen < payloadOffset + 1)
 526             {
 527                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 528             }
 529             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 530             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 531             if (cmd->bufLen < payloadOffset + 1)
 532             {
 533                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 534             }
 535             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 536
 537             wasHandled =
 538                 emberAfColorControlClusterMoveToSaturationCallback(saturation, transitionTime, optionsMask, optionsOverride);
 539             break;
 540         }
 541         case ZCL_STEP_COLOR_COMMAND_ID: {
 542             uint16_t payloadOffset = cmd->payloadStartIndex;
 543             int16_t stepX;
 544             int16_t stepY;
 545             uint16_t transitionTime;
 546             uint8_t optionsMask;
 547             uint8_t optionsOverride;
 548
 549             if (cmd->bufLen < payloadOffset + 2)
 550             {
 551                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 552             }
 553             stepX         = static_cast<int16_t>(emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen));
 554             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 555             if (cmd->bufLen < payloadOffset + 2)
 556             {
 557                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 558             }
 559             stepY         = static_cast<int16_t>(emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen));
 560             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 561             if (cmd->bufLen < payloadOffset + 2)
 562             {
 563                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 564             }
 565             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 566             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 567             if (cmd->bufLen < payloadOffset + 1)
 568             {
 569                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 570             }
 571             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 572             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 573             if (cmd->bufLen < payloadOffset + 1)
 574             {
 575                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 576             }
 577             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 578
 579             wasHandled = emberAfColorControlClusterStepColorCallback(stepX, stepY, transitionTime, optionsMask, optionsOverride);
 580             break;
 581         }
 582         case ZCL_STEP_COLOR_TEMPERATURE_COMMAND_ID: {
 583             uint16_t payloadOffset = cmd->payloadStartIndex;
 584             uint8_t stepMode;
 585             uint16_t stepSize;
 586             uint16_t transitionTime;
 587             uint16_t colorTemperatureMinimum;
 588             uint16_t colorTemperatureMaximum;
 589             uint8_t optionsMask;
 590             uint8_t optionsOverride;
 591
 592             if (cmd->bufLen < payloadOffset + 1)
 593             {
 594                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 595             }
 596             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 597             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 598             if (cmd->bufLen < payloadOffset + 2)
 599             {
 600                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 601             }
 602             stepSize      = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 603             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 604             if (cmd->bufLen < payloadOffset + 2)
 605             {
 606                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 607             }
 608             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 609             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 610             if (cmd->bufLen < payloadOffset + 2)
 611             {
 612                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 613             }
 614             colorTemperatureMinimum = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 615             payloadOffset           = static_cast<uint16_t>(payloadOffset + 2);
 616             if (cmd->bufLen < payloadOffset + 2)
 617             {
 618                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 619             }
 620             colorTemperatureMaximum = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 621             payloadOffset           = static_cast<uint16_t>(payloadOffset + 2);
 622             if (cmd->bufLen < payloadOffset + 1)
 623             {
 624                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 625             }
 626             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 627             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 628             if (cmd->bufLen < payloadOffset + 1)
 629             {
 630                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 631             }
 632             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 633
 634             wasHandled = emberAfColorControlClusterStepColorTemperatureCallback(
 635                 stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
 636             break;
 637         }
 638         case ZCL_STEP_HUE_COMMAND_ID: {
 639             uint16_t payloadOffset = cmd->payloadStartIndex;
 640             uint8_t stepMode;
 641             uint8_t stepSize;
 642             uint8_t transitionTime;
 643             uint8_t optionsMask;
 644             uint8_t optionsOverride;
 645
 646             if (cmd->bufLen < payloadOffset + 1)
 647             {
 648                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 649             }
 650             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 651             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 652             if (cmd->bufLen < payloadOffset + 1)
 653             {
 654                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 655             }
 656             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 657             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 658             if (cmd->bufLen < payloadOffset + 1)
 659             {
 660                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 661             }
 662             transitionTime = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 663             payloadOffset  = static_cast<uint16_t>(payloadOffset + 1);
 664             if (cmd->bufLen < payloadOffset + 1)
 665             {
 666                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 667             }
 668             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 669             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 670             if (cmd->bufLen < payloadOffset + 1)
 671             {
 672                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 673             }
 674             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 675
 676             wasHandled =
 677                 emberAfColorControlClusterStepHueCallback(stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
 678             break;
 679         }
 680         case ZCL_STEP_SATURATION_COMMAND_ID: {
 681             uint16_t payloadOffset = cmd->payloadStartIndex;
 682             uint8_t stepMode;
 683             uint8_t stepSize;
 684             uint8_t transitionTime;
 685             uint8_t optionsMask;
 686             uint8_t optionsOverride;
 687
 688             if (cmd->bufLen < payloadOffset + 1)
 689             {
 690                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 691             }
 692             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 693             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 694             if (cmd->bufLen < payloadOffset + 1)
 695             {
 696                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 697             }
 698             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 699             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 700             if (cmd->bufLen < payloadOffset + 1)
 701             {
 702                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 703             }
 704             transitionTime = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 705             payloadOffset  = static_cast<uint16_t>(payloadOffset + 1);
 706             if (cmd->bufLen < payloadOffset + 1)
 707             {
 708                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 709             }
 710             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 711             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 712             if (cmd->bufLen < payloadOffset + 1)
 713             {
 714                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 715             }
 716             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 717
 718             wasHandled =
 719                 emberAfColorControlClusterStepSaturationCallback(stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
 720             break;
 721         }
 722         case ZCL_STOP_MOVE_STEP_COMMAND_ID: {
 723             uint16_t payloadOffset = cmd->payloadStartIndex;
 724             uint8_t optionsMask;
 725             uint8_t optionsOverride;
 726
 727             if (cmd->bufLen < payloadOffset + 1)
 728             {
 729                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 730             }
 731             optionsMask   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 732             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 733             if (cmd->bufLen < payloadOffset + 1)
 734             {
 735                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 736             }
 737             optionsOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 738
 739             wasHandled = emberAfColorControlClusterStopMoveStepCallback(optionsMask, optionsOverride);
 740             break;
 741         }
 742         default: {
 743             // Unrecognized command ID, error status will apply.
 744             break;
 745         }
 746         }
 747     }
 748     return status(wasHandled, true, cmd->mfgSpecific);
 749 }
 750 EmberAfStatus emberAfDoorLockClusterClientCommandParse(EmberAfClusterCommand * cmd)
 751 {
 752     bool wasHandled = false;
 753
 754     if (!cmd->mfgSpecific)
 755     {
 756         switch (cmd->commandId)
 757         {
 758         case ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID: {
 759             uint16_t payloadOffset = cmd->payloadStartIndex;
 760             uint8_t status;
 761
 762             if (cmd->bufLen < payloadOffset + 1)
 763             {
 764                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 765             }
 766             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 767
 768             wasHandled = emberAfDoorLockClusterLockDoorResponseCallback(status);
 769             break;
 770         }
 771         case ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID: {
 772             uint16_t payloadOffset = cmd->payloadStartIndex;
 773             uint8_t status;
 774
 775             if (cmd->bufLen < payloadOffset + 1)
 776             {
 777                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 778             }
 779             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 780
 781             wasHandled = emberAfDoorLockClusterUnlockDoorResponseCallback(status);
 782             break;
 783         }
 784         default: {
 785             // Unrecognized command ID, error status will apply.
 786             break;
 787         }
 788         }
 789     }
 790     return status(wasHandled, true, cmd->mfgSpecific);
 791 }
 792 EmberAfStatus emberAfDoorLockClusterServerCommandParse(EmberAfClusterCommand * cmd)
 793 {
 794     bool wasHandled = false;
 795
 796     if (!cmd->mfgSpecific)
 797     {
 798         switch (cmd->commandId)
 799         {
 800         case ZCL_CLEAR_ALL_PINS_COMMAND_ID: {
 801             wasHandled = emberAfDoorLockClusterClearAllPinsCallback();
 802             break;
 803         }
 804         case ZCL_CLEAR_ALL_RFIDS_COMMAND_ID: {
 805             wasHandled = emberAfDoorLockClusterClearAllRfidsCallback();
 806             break;
 807         }
 808         case ZCL_CLEAR_HOLIDAY_SCHEDULE_COMMAND_ID: {
 809             uint16_t payloadOffset = cmd->payloadStartIndex;
 810             uint8_t scheduleId;
 811
 812             if (cmd->bufLen < payloadOffset + 1)
 813             {
 814                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 815             }
 816             scheduleId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 817
 818             wasHandled = emberAfDoorLockClusterClearHolidayScheduleCallback(scheduleId);
 819             break;
 820         }
 821         case ZCL_CLEAR_PIN_COMMAND_ID: {
 822             uint16_t payloadOffset = cmd->payloadStartIndex;
 823             uint16_t userId;
 824
 825             if (cmd->bufLen < payloadOffset + 2)
 826             {
 827                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 828             }
 829             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 830
 831             wasHandled = emberAfDoorLockClusterClearPinCallback(userId);
 832             break;
 833         }
 834         case ZCL_CLEAR_RFID_COMMAND_ID: {
 835             uint16_t payloadOffset = cmd->payloadStartIndex;
 836             uint16_t userId;
 837
 838             if (cmd->bufLen < payloadOffset + 2)
 839             {
 840                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 841             }
 842             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 843
 844             wasHandled = emberAfDoorLockClusterClearRfidCallback(userId);
 845             break;
 846         }
 847         case ZCL_CLEAR_WEEKDAY_SCHEDULE_COMMAND_ID: {
 848             uint16_t payloadOffset = cmd->payloadStartIndex;
 849             uint8_t scheduleId;
 850             uint16_t userId;
 851
 852             if (cmd->bufLen < payloadOffset + 1)
 853             {
 854                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 855             }
 856             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 857             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 858             if (cmd->bufLen < payloadOffset + 2)
 859             {
 860                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 861             }
 862             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 863
 864             wasHandled = emberAfDoorLockClusterClearWeekdayScheduleCallback(scheduleId, userId);
 865             break;
 866         }
 867         case ZCL_CLEAR_YEARDAY_SCHEDULE_COMMAND_ID: {
 868             uint16_t payloadOffset = cmd->payloadStartIndex;
 869             uint8_t scheduleId;
 870             uint16_t userId;
 871
 872             if (cmd->bufLen < payloadOffset + 1)
 873             {
 874                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 875             }
 876             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 877             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 878             if (cmd->bufLen < payloadOffset + 2)
 879             {
 880                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 881             }
 882             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 883
 884             wasHandled = emberAfDoorLockClusterClearYeardayScheduleCallback(scheduleId, userId);
 885             break;
 886         }
 887         case ZCL_GET_HOLIDAY_SCHEDULE_COMMAND_ID: {
 888             uint16_t payloadOffset = cmd->payloadStartIndex;
 889             uint8_t scheduleId;
 890
 891             if (cmd->bufLen < payloadOffset + 1)
 892             {
 893                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 894             }
 895             scheduleId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 896
 897             wasHandled = emberAfDoorLockClusterGetHolidayScheduleCallback(scheduleId);
 898             break;
 899         }
 900         case ZCL_GET_LOG_RECORD_COMMAND_ID: {
 901             uint16_t payloadOffset = cmd->payloadStartIndex;
 902             uint16_t logIndex;
 903
 904             if (cmd->bufLen < payloadOffset + 2)
 905             {
 906                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 907             }
 908             logIndex = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 909
 910             wasHandled = emberAfDoorLockClusterGetLogRecordCallback(logIndex);
 911             break;
 912         }
 913         case ZCL_GET_PIN_COMMAND_ID: {
 914             uint16_t payloadOffset = cmd->payloadStartIndex;
 915             uint16_t userId;
 916
 917             if (cmd->bufLen < payloadOffset + 2)
 918             {
 919                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 920             }
 921             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 922
 923             wasHandled = emberAfDoorLockClusterGetPinCallback(userId);
 924             break;
 925         }
 926         case ZCL_GET_RFID_COMMAND_ID: {
 927             uint16_t payloadOffset = cmd->payloadStartIndex;
 928             uint16_t userId;
 929
 930             if (cmd->bufLen < payloadOffset + 2)
 931             {
 932                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 933             }
 934             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 935
 936             wasHandled = emberAfDoorLockClusterGetRfidCallback(userId);
 937             break;
 938         }
 939         case ZCL_GET_USER_TYPE_COMMAND_ID: {
 940             uint16_t payloadOffset = cmd->payloadStartIndex;
 941             uint16_t userId;
 942
 943             if (cmd->bufLen < payloadOffset + 2)
 944             {
 945                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 946             }
 947             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 948
 949             wasHandled = emberAfDoorLockClusterGetUserTypeCallback(userId);
 950             break;
 951         }
 952         case ZCL_GET_WEEKDAY_SCHEDULE_COMMAND_ID: {
 953             uint16_t payloadOffset = cmd->payloadStartIndex;
 954             uint8_t scheduleId;
 955             uint16_t userId;
 956
 957             if (cmd->bufLen < payloadOffset + 1)
 958             {
 959                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 960             }
 961             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 962             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 963             if (cmd->bufLen < payloadOffset + 2)
 964             {
 965                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 966             }
 967             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 968
 969             wasHandled = emberAfDoorLockClusterGetWeekdayScheduleCallback(scheduleId, userId);
 970             break;
 971         }
 972         case ZCL_GET_YEARDAY_SCHEDULE_COMMAND_ID: {
 973             uint16_t payloadOffset = cmd->payloadStartIndex;
 974             uint8_t scheduleId;
 975             uint16_t userId;
 976
 977             if (cmd->bufLen < payloadOffset + 1)
 978             {
 979                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 980             }
 981             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 982             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 983             if (cmd->bufLen < payloadOffset + 2)
 984             {
 985                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 986             }
 987             userId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 988
 989             wasHandled = emberAfDoorLockClusterGetYeardayScheduleCallback(scheduleId, userId);
 990             break;
 991         }
 992         case ZCL_LOCK_DOOR_COMMAND_ID: {
 993             uint16_t payloadOffset = cmd->payloadStartIndex;
 994             uint8_t * PIN;
 995
 996             if (cmd->bufLen < payloadOffset + 1u)
 997             {
 998                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 999             }
1000             PIN = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1001
1002             wasHandled = emberAfDoorLockClusterLockDoorCallback(PIN);
1003             break;
1004         }
1005         case ZCL_SET_HOLIDAY_SCHEDULE_COMMAND_ID: {
1006             uint16_t payloadOffset = cmd->payloadStartIndex;
1007             uint8_t scheduleId;
1008             uint32_t localStartTime;
1009             uint32_t localEndTime;
1010             uint8_t operatingModeDuringHoliday;
1011
1012             if (cmd->bufLen < payloadOffset + 1)
1013             {
1014                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1015             }
1016             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1017             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1018             if (cmd->bufLen < payloadOffset + 4)
1019             {
1020                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1021             }
1022             localStartTime = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1023             payloadOffset  = static_cast<uint16_t>(payloadOffset + 4);
1024             if (cmd->bufLen < payloadOffset + 4)
1025             {
1026                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1027             }
1028             localEndTime  = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1029             payloadOffset = static_cast<uint16_t>(payloadOffset + 4);
1030             if (cmd->bufLen < payloadOffset + 1)
1031             {
1032                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1033             }
1034             operatingModeDuringHoliday = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1035
1036             wasHandled = emberAfDoorLockClusterSetHolidayScheduleCallback(scheduleId, localStartTime, localEndTime,
1037                                                                           operatingModeDuringHoliday);
1038             break;
1039         }
1040         case ZCL_SET_PIN_COMMAND_ID: {
1041             uint16_t payloadOffset = cmd->payloadStartIndex;
1042             uint16_t userId;
1043             uint8_t userStatus;
1044             uint8_t userType;
1045             uint8_t * pin;
1046
1047             if (cmd->bufLen < payloadOffset + 2)
1048             {
1049                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1050             }
1051             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1052             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1053             if (cmd->bufLen < payloadOffset + 1)
1054             {
1055                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1056             }
1057             userStatus    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1058             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1059             if (cmd->bufLen < payloadOffset + 1)
1060             {
1061                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1062             }
1063             userType      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1064             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1065             if (cmd->bufLen < payloadOffset + 1u)
1066             {
1067                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1068             }
1069             pin = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1070
1071             wasHandled = emberAfDoorLockClusterSetPinCallback(userId, userStatus, userType, pin);
1072             break;
1073         }
1074         case ZCL_SET_RFID_COMMAND_ID: {
1075             uint16_t payloadOffset = cmd->payloadStartIndex;
1076             uint16_t userId;
1077             uint8_t userStatus;
1078             uint8_t userType;
1079             uint8_t * id;
1080
1081             if (cmd->bufLen < payloadOffset + 2)
1082             {
1083                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1084             }
1085             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1086             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1087             if (cmd->bufLen < payloadOffset + 1)
1088             {
1089                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1090             }
1091             userStatus    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1092             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1093             if (cmd->bufLen < payloadOffset + 1)
1094             {
1095                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1096             }
1097             userType      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1098             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1099             if (cmd->bufLen < payloadOffset + 1u)
1100             {
1101                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1102             }
1103             id = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1104
1105             wasHandled = emberAfDoorLockClusterSetRfidCallback(userId, userStatus, userType, id);
1106             break;
1107         }
1108         case ZCL_SET_USER_TYPE_COMMAND_ID: {
1109             uint16_t payloadOffset = cmd->payloadStartIndex;
1110             uint16_t userId;
1111             uint8_t userType;
1112
1113             if (cmd->bufLen < payloadOffset + 2)
1114             {
1115                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1116             }
1117             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1118             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1119             if (cmd->bufLen < payloadOffset + 1)
1120             {
1121                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1122             }
1123             userType = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1124
1125             wasHandled = emberAfDoorLockClusterSetUserTypeCallback(userId, userType);
1126             break;
1127         }
1128         case ZCL_SET_WEEKDAY_SCHEDULE_COMMAND_ID: {
1129             uint16_t payloadOffset = cmd->payloadStartIndex;
1130             uint8_t scheduleId;
1131             uint16_t userId;
1132             uint8_t daysMask;
1133             uint8_t startHour;
1134             uint8_t startMinute;
1135             uint8_t endHour;
1136             uint8_t endMinute;
1137
1138             if (cmd->bufLen < payloadOffset + 1)
1139             {
1140                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1141             }
1142             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1143             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1144             if (cmd->bufLen < payloadOffset + 2)
1145             {
1146                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1147             }
1148             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1149             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1150             if (cmd->bufLen < payloadOffset + 1)
1151             {
1152                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1153             }
1154             daysMask      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1155             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1156             if (cmd->bufLen < payloadOffset + 1)
1157             {
1158                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1159             }
1160             startHour     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1161             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1162             if (cmd->bufLen < payloadOffset + 1)
1163             {
1164                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1165             }
1166             startMinute   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1167             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1168             if (cmd->bufLen < payloadOffset + 1)
1169             {
1170                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1171             }
1172             endHour       = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1173             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1174             if (cmd->bufLen < payloadOffset + 1)
1175             {
1176                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1177             }
1178             endMinute = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1179
1180             wasHandled = emberAfDoorLockClusterSetWeekdayScheduleCallback(scheduleId, userId, daysMask, startHour, startMinute,
1181                                                                           endHour, endMinute);
1182             break;
1183         }
1184         case ZCL_SET_YEARDAY_SCHEDULE_COMMAND_ID: {
1185             uint16_t payloadOffset = cmd->payloadStartIndex;
1186             uint8_t scheduleId;
1187             uint16_t userId;
1188             uint32_t localStartTime;
1189             uint32_t localEndTime;
1190
1191             if (cmd->bufLen < payloadOffset + 1)
1192             {
1193                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1194             }
1195             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1196             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1197             if (cmd->bufLen < payloadOffset + 2)
1198             {
1199                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1200             }
1201             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1202             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1203             if (cmd->bufLen < payloadOffset + 4)
1204             {
1205                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1206             }
1207             localStartTime = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1208             payloadOffset  = static_cast<uint16_t>(payloadOffset + 4);
1209             if (cmd->bufLen < payloadOffset + 4)
1210             {
1211                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1212             }
1213             localEndTime = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1214
1215             wasHandled = emberAfDoorLockClusterSetYeardayScheduleCallback(scheduleId, userId, localStartTime, localEndTime);
1216             break;
1217         }
1218         case ZCL_UNLOCK_DOOR_COMMAND_ID: {
1219             uint16_t payloadOffset = cmd->payloadStartIndex;
1220             uint8_t * PIN;
1221
1222             if (cmd->bufLen < payloadOffset + 1u)
1223             {
1224                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1225             }
1226             PIN = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1227
1228             wasHandled = emberAfDoorLockClusterUnlockDoorCallback(PIN);
1229             break;
1230         }
1231         case ZCL_UNLOCK_WITH_TIMEOUT_COMMAND_ID: {
1232             uint16_t payloadOffset = cmd->payloadStartIndex;
1233             uint16_t timeoutInSeconds;
1234             uint8_t * pin;
1235
1236             if (cmd->bufLen < payloadOffset + 2)
1237             {
1238                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1239             }
1240             timeoutInSeconds = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1241             payloadOffset    = static_cast<uint16_t>(payloadOffset + 2);
1242             if (cmd->bufLen < payloadOffset + 1u)
1243             {
1244                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1245             }
1246             pin = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1247
1248             wasHandled = emberAfDoorLockClusterUnlockWithTimeoutCallback(timeoutInSeconds, pin);
1249             break;
1250         }
1251         default: {
1252             // Unrecognized command ID, error status will apply.
1253             break;
1254         }
1255         }
1256     }
1257     return status(wasHandled, true, cmd->mfgSpecific);
1258 }
1259 EmberAfStatus emberAfGroupsClusterServerCommandParse(EmberAfClusterCommand * cmd)
1260 {
1261     bool wasHandled = false;
1262
1263     if (!cmd->mfgSpecific)
1264     {
1265         switch (cmd->commandId)
1266         {
1267         case ZCL_ADD_GROUP_COMMAND_ID: {
1268             uint16_t payloadOffset = cmd->payloadStartIndex;
1269             uint16_t groupId;
1270             uint8_t * groupName;
1271
1272             if (cmd->bufLen < payloadOffset + 2)
1273             {
1274                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1275             }
1276             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1277             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1278             if (cmd->bufLen < payloadOffset + 1u)
1279             {
1280                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1281             }
1282             groupName = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1283
1284             wasHandled = emberAfGroupsClusterAddGroupCallback(groupId, groupName);
1285             break;
1286         }
1287         case ZCL_ADD_GROUP_IF_IDENTIFYING_COMMAND_ID: {
1288             uint16_t payloadOffset = cmd->payloadStartIndex;
1289             uint16_t groupId;
1290             uint8_t * groupName;
1291
1292             if (cmd->bufLen < payloadOffset + 2)
1293             {
1294                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1295             }
1296             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1297             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1298             if (cmd->bufLen < payloadOffset + 1u)
1299             {
1300                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1301             }
1302             groupName = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1303
1304             wasHandled = emberAfGroupsClusterAddGroupIfIdentifyingCallback(groupId, groupName);
1305             break;
1306         }
1307         case ZCL_GET_GROUP_MEMBERSHIP_COMMAND_ID: {
1308             uint16_t payloadOffset = cmd->payloadStartIndex;
1309             uint8_t groupCount;
1310             /* TYPE WARNING: array array defaults to */ uint8_t * groupList;
1311
1312             if (cmd->bufLen < payloadOffset + 1)
1313             {
1314                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1315             }
1316             groupCount    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1317             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1318             groupList     = cmd->buffer + payloadOffset;
1319
1320             wasHandled = emberAfGroupsClusterGetGroupMembershipCallback(groupCount, groupList);
1321             break;
1322         }
1323         case ZCL_REMOVE_ALL_GROUPS_COMMAND_ID: {
1324             wasHandled = emberAfGroupsClusterRemoveAllGroupsCallback();
1325             break;
1326         }
1327         case ZCL_REMOVE_GROUP_COMMAND_ID: {
1328             uint16_t payloadOffset = cmd->payloadStartIndex;
1329             uint16_t groupId;
1330
1331             if (cmd->bufLen < payloadOffset + 2)
1332             {
1333                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1334             }
1335             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1336
1337             wasHandled = emberAfGroupsClusterRemoveGroupCallback(groupId);
1338             break;
1339         }
1340         case ZCL_VIEW_GROUP_COMMAND_ID: {
1341             uint16_t payloadOffset = cmd->payloadStartIndex;
1342             uint16_t groupId;
1343
1344             if (cmd->bufLen < payloadOffset + 2)
1345             {
1346                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1347             }
1348             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1349
1350             wasHandled = emberAfGroupsClusterViewGroupCallback(groupId);
1351             break;
1352         }
1353         default: {
1354             // Unrecognized command ID, error status will apply.
1355             break;
1356         }
1357         }
1358     }
1359     return status(wasHandled, true, cmd->mfgSpecific);
1360 }
1361 EmberAfStatus emberAfIasZoneClusterServerCommandParse(EmberAfClusterCommand * cmd)
1362 {
1363     bool wasHandled = false;
1364
1365     if (!cmd->mfgSpecific)
1366     {
1367         switch (cmd->commandId)
1368         {
1369         case ZCL_ZONE_ENROLL_RESPONSE_COMMAND_ID: {
1370             uint16_t payloadOffset = cmd->payloadStartIndex;
1371             uint8_t enrollResponseCode;
1372             uint8_t zoneId;
1373
1374             if (cmd->bufLen < payloadOffset + 1)
1375             {
1376                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1377             }
1378             enrollResponseCode = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1379             payloadOffset      = static_cast<uint16_t>(payloadOffset + 1);
1380             if (cmd->bufLen < payloadOffset + 1)
1381             {
1382                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1383             }
1384             zoneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1385
1386             wasHandled = emberAfIasZoneClusterZoneEnrollResponseCallback(enrollResponseCode, zoneId);
1387             break;
1388         }
1389         default: {
1390             // Unrecognized command ID, error status will apply.
1391             break;
1392         }
1393         }
1394     }
1395     return status(wasHandled, true, cmd->mfgSpecific);
1396 }
1397 EmberAfStatus emberAfIdentifyClusterServerCommandParse(EmberAfClusterCommand * cmd)
1398 {
1399     bool wasHandled = false;
1400
1401     if (!cmd->mfgSpecific)
1402     {
1403         switch (cmd->commandId)
1404         {
1405         case ZCL_IDENTIFY_COMMAND_ID: {
1406             uint16_t payloadOffset = cmd->payloadStartIndex;
1407             uint16_t identifyTime;
1408
1409             if (cmd->bufLen < payloadOffset + 2)
1410             {
1411                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1412             }
1413             identifyTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1414
1415             wasHandled = emberAfIdentifyClusterIdentifyCallback(identifyTime);
1416             break;
1417         }
1418         case ZCL_IDENTIFY_QUERY_COMMAND_ID: {
1419             wasHandled = emberAfIdentifyClusterIdentifyQueryCallback();
1420             break;
1421         }
1422         default: {
1423             // Unrecognized command ID, error status will apply.
1424             break;
1425         }
1426         }
1427     }
1428     return status(wasHandled, true, cmd->mfgSpecific);
1429 }
1430 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd)
1431 {
1432     bool wasHandled = false;
1433
1434     if (!cmd->mfgSpecific)
1435     {
1436         switch (cmd->commandId)
1437         {
1438         case ZCL_MOVE_COMMAND_ID: {
1439             uint16_t payloadOffset = cmd->payloadStartIndex;
1440             uint8_t moveMode;
1441             uint8_t rate;
1442             uint8_t optionMask;
1443             uint8_t optionOverride;
1444
1445             if (cmd->bufLen < payloadOffset + 1)
1446             {
1447                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1448             }
1449             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1450             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1451             if (cmd->bufLen < payloadOffset + 1)
1452             {
1453                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1454             }
1455             rate          = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1456             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1457             if (cmd->bufLen < payloadOffset + 1)
1458             {
1459                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1460             }
1461             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1462             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1463             if (cmd->bufLen < payloadOffset + 1)
1464             {
1465                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1466             }
1467             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1468
1469             wasHandled = emberAfLevelControlClusterMoveCallback(moveMode, rate, optionMask, optionOverride);
1470             break;
1471         }
1472         case ZCL_MOVE_TO_LEVEL_COMMAND_ID: {
1473             uint16_t payloadOffset = cmd->payloadStartIndex;
1474             uint8_t level;
1475             uint16_t transitionTime;
1476             uint8_t optionMask;
1477             uint8_t optionOverride;
1478
1479             if (cmd->bufLen < payloadOffset + 1)
1480             {
1481                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1482             }
1483             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1484             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1485             if (cmd->bufLen < payloadOffset + 2)
1486             {
1487                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1488             }
1489             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1490             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
1491             if (cmd->bufLen < payloadOffset + 1)
1492             {
1493                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1494             }
1495             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1496             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1497             if (cmd->bufLen < payloadOffset + 1)
1498             {
1499                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1500             }
1501             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1502
1503             wasHandled = emberAfLevelControlClusterMoveToLevelCallback(level, transitionTime, optionMask, optionOverride);
1504             break;
1505         }
1506         case ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID: {
1507             uint16_t payloadOffset = cmd->payloadStartIndex;
1508             uint8_t level;
1509             uint16_t transitionTime;
1510
1511             if (cmd->bufLen < payloadOffset + 1)
1512             {
1513                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1514             }
1515             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1516             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1517             if (cmd->bufLen < payloadOffset + 2)
1518             {
1519                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1520             }
1521             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1522
1523             wasHandled = emberAfLevelControlClusterMoveToLevelWithOnOffCallback(level, transitionTime);
1524             break;
1525         }
1526         case ZCL_MOVE_WITH_ON_OFF_COMMAND_ID: {
1527             uint16_t payloadOffset = cmd->payloadStartIndex;
1528             uint8_t moveMode;
1529             uint8_t rate;
1530
1531             if (cmd->bufLen < payloadOffset + 1)
1532             {
1533                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1534             }
1535             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1536             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1537             if (cmd->bufLen < payloadOffset + 1)
1538             {
1539                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1540             }
1541             rate = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1542
1543             wasHandled = emberAfLevelControlClusterMoveWithOnOffCallback(moveMode, rate);
1544             break;
1545         }
1546         case ZCL_STEP_COMMAND_ID: {
1547             uint16_t payloadOffset = cmd->payloadStartIndex;
1548             uint8_t stepMode;
1549             uint8_t stepSize;
1550             uint16_t transitionTime;
1551             uint8_t optionMask;
1552             uint8_t optionOverride;
1553
1554             if (cmd->bufLen < payloadOffset + 1)
1555             {
1556                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1557             }
1558             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1559             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1560             if (cmd->bufLen < payloadOffset + 1)
1561             {
1562                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1563             }
1564             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1565             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1566             if (cmd->bufLen < payloadOffset + 2)
1567             {
1568                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1569             }
1570             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1571             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
1572             if (cmd->bufLen < payloadOffset + 1)
1573             {
1574                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1575             }
1576             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1577             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1578             if (cmd->bufLen < payloadOffset + 1)
1579             {
1580                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1581             }
1582             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1583
1584             wasHandled = emberAfLevelControlClusterStepCallback(stepMode, stepSize, transitionTime, optionMask, optionOverride);
1585             break;
1586         }
1587         case ZCL_STEP_WITH_ON_OFF_COMMAND_ID: {
1588             uint16_t payloadOffset = cmd->payloadStartIndex;
1589             uint8_t stepMode;
1590             uint8_t stepSize;
1591             uint16_t transitionTime;
1592
1593             if (cmd->bufLen < payloadOffset + 1)
1594             {
1595                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1596             }
1597             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1598             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1599             if (cmd->bufLen < payloadOffset + 1)
1600             {
1601                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1602             }
1603             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1604             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1605             if (cmd->bufLen < payloadOffset + 2)
1606             {
1607                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1608             }
1609             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1610
1611             wasHandled = emberAfLevelControlClusterStepWithOnOffCallback(stepMode, stepSize, transitionTime);
1612             break;
1613         }
1614         case ZCL_STOP_COMMAND_ID: {
1615             uint16_t payloadOffset = cmd->payloadStartIndex;
1616             uint8_t optionMask;
1617             uint8_t optionOverride;
1618
1619             if (cmd->bufLen < payloadOffset + 1)
1620             {
1621                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1622             }
1623             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1624             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1625             if (cmd->bufLen < payloadOffset + 1)
1626             {
1627                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1628             }
1629             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1630
1631             wasHandled = emberAfLevelControlClusterStopCallback(optionMask, optionOverride);
1632             break;
1633         }
1634         case ZCL_STOP_WITH_ON_OFF_COMMAND_ID: {
1635             wasHandled = emberAfLevelControlClusterStopWithOnOffCallback();
1636             break;
1637         }
1638         default: {
1639             // Unrecognized command ID, error status will apply.
1640             break;
1641         }
1642         }
1643     }
1644     return status(wasHandled, true, cmd->mfgSpecific);
1645 }
1646 EmberAfStatus emberAfLowPowerClusterServerCommandParse(EmberAfClusterCommand * cmd)
1647 {
1648     bool wasHandled = false;
1649
1650     if (!cmd->mfgSpecific)
1651     {
1652         switch (cmd->commandId)
1653         {
1654         case ZCL_SLEEP_COMMAND_ID: {
1655             wasHandled = emberAfLowPowerClusterSleepCallback();
1656             break;
1657         }
1658         default: {
1659             // Unrecognized command ID, error status will apply.
1660             break;
1661         }
1662         }
1663     }
1664     return status(wasHandled, true, cmd->mfgSpecific);
1665 }
1666 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd)
1667 {
1668     bool wasHandled = false;
1669
1670     if (!cmd->mfgSpecific)
1671     {
1672         switch (cmd->commandId)
1673         {
1674         case ZCL_ADD_THREAD_NETWORK_COMMAND_ID: {
1675             uint16_t payloadOffset = cmd->payloadStartIndex;
1676             chip::ByteSpan operationalDataset;
1677             uint64_t breadcrumb;
1678             uint32_t timeoutMs;
1679
1680             if (cmd->bufLen < payloadOffset + 1u)
1681             {
1682                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1683             }
1684             {
1685                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1686                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1687             }
1688             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
1689             if (cmd->bufLen < payloadOffset + 8)
1690             {
1691                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1692             }
1693             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1694             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1695             if (cmd->bufLen < payloadOffset + 4)
1696             {
1697                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1698             }
1699             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1700
1701             wasHandled = emberAfNetworkCommissioningClusterAddThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
1702             break;
1703         }
1704         case ZCL_ADD_WI_FI_NETWORK_COMMAND_ID: {
1705             uint16_t payloadOffset = cmd->payloadStartIndex;
1706             chip::ByteSpan ssid;
1707             chip::ByteSpan credentials;
1708             uint64_t breadcrumb;
1709             uint32_t timeoutMs;
1710
1711             if (cmd->bufLen < payloadOffset + 1u)
1712             {
1713                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1714             }
1715             {
1716                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1717                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1718             }
1719             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
1720             if (cmd->bufLen < payloadOffset + 1u)
1721             {
1722                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1723             }
1724             {
1725                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1726                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1727             }
1728             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
1729             if (cmd->bufLen < payloadOffset + 8)
1730             {
1731                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1732             }
1733             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1734             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1735             if (cmd->bufLen < payloadOffset + 4)
1736             {
1737                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1738             }
1739             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1740
1741             wasHandled = emberAfNetworkCommissioningClusterAddWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
1742             break;
1743         }
1744         case ZCL_DISABLE_NETWORK_COMMAND_ID: {
1745             uint16_t payloadOffset = cmd->payloadStartIndex;
1746             chip::ByteSpan networkID;
1747             uint64_t breadcrumb;
1748             uint32_t timeoutMs;
1749
1750             if (cmd->bufLen < payloadOffset + 1u)
1751             {
1752                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1753             }
1754             {
1755                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1756                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1757             }
1758             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
1759             if (cmd->bufLen < payloadOffset + 8)
1760             {
1761                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1762             }
1763             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1764             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1765             if (cmd->bufLen < payloadOffset + 4)
1766             {
1767                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1768             }
1769             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1770
1771             wasHandled = emberAfNetworkCommissioningClusterDisableNetworkCallback(networkID, breadcrumb, timeoutMs);
1772             break;
1773         }
1774         case ZCL_ENABLE_NETWORK_COMMAND_ID: {
1775             uint16_t payloadOffset = cmd->payloadStartIndex;
1776             chip::ByteSpan networkID;
1777             uint64_t breadcrumb;
1778             uint32_t timeoutMs;
1779
1780             if (cmd->bufLen < payloadOffset + 1u)
1781             {
1782                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1783             }
1784             {
1785                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1786                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1787             }
1788             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
1789             if (cmd->bufLen < payloadOffset + 8)
1790             {
1791                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1792             }
1793             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1794             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1795             if (cmd->bufLen < payloadOffset + 4)
1796             {
1797                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1798             }
1799             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1800
1801             wasHandled = emberAfNetworkCommissioningClusterEnableNetworkCallback(networkID, breadcrumb, timeoutMs);
1802             break;
1803         }
1804         case ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID: {
1805             uint16_t payloadOffset = cmd->payloadStartIndex;
1806             uint32_t timeoutMs;
1807
1808             if (cmd->bufLen < payloadOffset + 4)
1809             {
1810                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1811             }
1812             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1813
1814             wasHandled = emberAfNetworkCommissioningClusterGetLastNetworkCommissioningResultCallback(timeoutMs);
1815             break;
1816         }
1817         case ZCL_REMOVE_NETWORK_COMMAND_ID: {
1818             uint16_t payloadOffset = cmd->payloadStartIndex;
1819             chip::ByteSpan NetworkID;
1820             uint64_t Breadcrumb;
1821             uint32_t TimeoutMs;
1822
1823             if (cmd->bufLen < payloadOffset + 1u)
1824             {
1825                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1826             }
1827             {
1828                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1829                 NetworkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1830             }
1831             payloadOffset = static_cast<uint16_t>(payloadOffset + NetworkID.size() + 1u);
1832             if (cmd->bufLen < payloadOffset + 8)
1833             {
1834                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1835             }
1836             Breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1837             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1838             if (cmd->bufLen < payloadOffset + 4)
1839             {
1840                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1841             }
1842             TimeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1843
1844             wasHandled = emberAfNetworkCommissioningClusterRemoveNetworkCallback(NetworkID, Breadcrumb, TimeoutMs);
1845             break;
1846         }
1847         case ZCL_SCAN_NETWORKS_COMMAND_ID: {
1848             uint16_t payloadOffset = cmd->payloadStartIndex;
1849             chip::ByteSpan ssid;
1850             uint64_t breadcrumb;
1851             uint32_t timeoutMs;
1852
1853             if (cmd->bufLen < payloadOffset + 1u)
1854             {
1855                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1856             }
1857             {
1858                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1859                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1860             }
1861             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
1862             if (cmd->bufLen < payloadOffset + 8)
1863             {
1864                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1865             }
1866             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1867             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1868             if (cmd->bufLen < payloadOffset + 4)
1869             {
1870                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1871             }
1872             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1873
1874             wasHandled = emberAfNetworkCommissioningClusterScanNetworksCallback(ssid, breadcrumb, timeoutMs);
1875             break;
1876         }
1877         case ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID: {
1878             uint16_t payloadOffset = cmd->payloadStartIndex;
1879             chip::ByteSpan operationalDataset;
1880             uint64_t breadcrumb;
1881             uint32_t timeoutMs;
1882
1883             if (cmd->bufLen < payloadOffset + 1u)
1884             {
1885                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1886             }
1887             {
1888                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1889                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1890             }
1891             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
1892             if (cmd->bufLen < payloadOffset + 8)
1893             {
1894                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1895             }
1896             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1897             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1898             if (cmd->bufLen < payloadOffset + 4)
1899             {
1900                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1901             }
1902             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1903
1904             wasHandled = emberAfNetworkCommissioningClusterUpdateThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
1905             break;
1906         }
1907         case ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID: {
1908             uint16_t payloadOffset = cmd->payloadStartIndex;
1909             chip::ByteSpan ssid;
1910             chip::ByteSpan credentials;
1911             uint64_t breadcrumb;
1912             uint32_t timeoutMs;
1913
1914             if (cmd->bufLen < payloadOffset + 1u)
1915             {
1916                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1917             }
1918             {
1919                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1920                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1921             }
1922             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
1923             if (cmd->bufLen < payloadOffset + 1u)
1924             {
1925                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1926             }
1927             {
1928                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1929                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
1930             }
1931             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
1932             if (cmd->bufLen < payloadOffset + 8)
1933             {
1934                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1935             }
1936             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
1937             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
1938             if (cmd->bufLen < payloadOffset + 4)
1939             {
1940                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1941             }
1942             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
1943
1944             wasHandled = emberAfNetworkCommissioningClusterUpdateWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
1945             break;
1946         }
1947         default: {
1948             // Unrecognized command ID, error status will apply.
1949             break;
1950         }
1951         }
1952     }
1953     return status(wasHandled, true, cmd->mfgSpecific);
1954 }
1955 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd)
1956 {
1957     bool wasHandled = false;
1958
1959     if (!cmd->mfgSpecific)
1960     {
1961         switch (cmd->commandId)
1962         {
1963         case ZCL_OFF_COMMAND_ID: {
1964             wasHandled = emberAfOnOffClusterOffCallback();
1965             break;
1966         }
1967         case ZCL_ON_COMMAND_ID: {
1968             wasHandled = emberAfOnOffClusterOnCallback();
1969             break;
1970         }
1971         case ZCL_TOGGLE_COMMAND_ID: {
1972             wasHandled = emberAfOnOffClusterToggleCallback();
1973             break;
1974         }
1975         default: {
1976             // Unrecognized command ID, error status will apply.
1977             break;
1978         }
1979         }
1980     }
1981     return status(wasHandled, true, cmd->mfgSpecific);
1982 }
1983 EmberAfStatus emberAfScenesClusterServerCommandParse(EmberAfClusterCommand * cmd)
1984 {
1985     bool wasHandled = false;
1986
1987     if (!cmd->mfgSpecific)
1988     {
1989         switch (cmd->commandId)
1990         {
1991         case ZCL_ADD_SCENE_COMMAND_ID: {
1992             uint16_t payloadOffset = cmd->payloadStartIndex;
1993             uint16_t groupId;
1994             uint8_t sceneId;
1995             uint16_t transitionTime;
1996             uint8_t * sceneName;
1997             /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets;
1998
1999             if (cmd->bufLen < payloadOffset + 2)
2000             {
2001                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2002             }
2003             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2004             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
2005             if (cmd->bufLen < payloadOffset + 1)
2006             {
2007                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2008             }
2009             sceneId       = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
2010             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
2011             if (cmd->bufLen < payloadOffset + 2)
2012             {
2013                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2014             }
2015             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2016             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
2017             if (cmd->bufLen < payloadOffset + 1u)
2018             {
2019                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2020             }
2021             sceneName          = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
2022             payloadOffset      = static_cast<uint16_t>(payloadOffset + emberAfStringLength(sceneName) + 1u);
2023             extensionFieldSets = cmd->buffer + payloadOffset;
2024
2025             wasHandled = emberAfScenesClusterAddSceneCallback(groupId, sceneId, transitionTime, sceneName, extensionFieldSets);
2026             break;
2027         }
2028         case ZCL_GET_SCENE_MEMBERSHIP_COMMAND_ID: {
2029             uint16_t payloadOffset = cmd->payloadStartIndex;
2030             uint16_t groupId;
2031
2032             if (cmd->bufLen < payloadOffset + 2)
2033             {
2034                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2035             }
2036             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2037
2038             wasHandled = emberAfScenesClusterGetSceneMembershipCallback(groupId);
2039             break;
2040         }
2041         case ZCL_RECALL_SCENE_COMMAND_ID: {
2042             uint16_t payloadOffset = cmd->payloadStartIndex;
2043             uint16_t groupId;
2044             uint8_t sceneId;
2045             uint16_t transitionTime;
2046
2047             if (cmd->bufLen < payloadOffset + 2)
2048             {
2049                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2050             }
2051             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2052             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
2053             if (cmd->bufLen < payloadOffset + 1)
2054             {
2055                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2056             }
2057             sceneId       = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
2058             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
2059             if (cmd->bufLen < payloadOffset + 2)
2060             {
2061                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2062             }
2063             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2064
2065             wasHandled = emberAfScenesClusterRecallSceneCallback(groupId, sceneId, transitionTime);
2066             break;
2067         }
2068         case ZCL_REMOVE_ALL_SCENES_COMMAND_ID: {
2069             uint16_t payloadOffset = cmd->payloadStartIndex;
2070             uint16_t groupId;
2071
2072             if (cmd->bufLen < payloadOffset + 2)
2073             {
2074                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2075             }
2076             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2077
2078             wasHandled = emberAfScenesClusterRemoveAllScenesCallback(groupId);
2079             break;
2080         }
2081         case ZCL_REMOVE_SCENE_COMMAND_ID: {
2082             uint16_t payloadOffset = cmd->payloadStartIndex;
2083             uint16_t groupId;
2084             uint8_t sceneId;
2085
2086             if (cmd->bufLen < payloadOffset + 2)
2087             {
2088                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2089             }
2090             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2091             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
2092             if (cmd->bufLen < payloadOffset + 1)
2093             {
2094                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2095             }
2096             sceneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
2097
2098             wasHandled = emberAfScenesClusterRemoveSceneCallback(groupId, sceneId);
2099             break;
2100         }
2101         case ZCL_STORE_SCENE_COMMAND_ID: {
2102             uint16_t payloadOffset = cmd->payloadStartIndex;
2103             uint16_t groupId;
2104             uint8_t sceneId;
2105
2106             if (cmd->bufLen < payloadOffset + 2)
2107             {
2108                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2109             }
2110             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2111             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
2112             if (cmd->bufLen < payloadOffset + 1)
2113             {
2114                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2115             }
2116             sceneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
2117
2118             wasHandled = emberAfScenesClusterStoreSceneCallback(groupId, sceneId);
2119             break;
2120         }
2121         case ZCL_VIEW_SCENE_COMMAND_ID: {
2122             uint16_t payloadOffset = cmd->payloadStartIndex;
2123             uint16_t groupId;
2124             uint8_t sceneId;
2125
2126             if (cmd->bufLen < payloadOffset + 2)
2127             {
2128                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2129             }
2130             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
2131             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
2132             if (cmd->bufLen < payloadOffset + 1)
2133             {
2134                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
2135             }
2136             sceneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
2137
2138             wasHandled = emberAfScenesClusterViewSceneCallback(groupId, sceneId);
2139             break;
2140         }
2141         default: {
2142             // Unrecognized command ID, error status will apply.
2143             break;
2144         }
2145         }
2146     }
2147     return status(wasHandled, true, cmd->mfgSpecific);
2148 }