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