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