examples/all-clusters-app/all-clusters-common/gen/call-command-handler.cpp

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