src/darwin/Framework/CHIP/gen/call-command-handler.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 #include <stdint.h>
  21
  22 #include "af-structs.h"
  23 #include "call-command-handler.h"
  24 #include "callback.h"
  25 #include "cluster-id.h"
  26 #include "command-id.h"
  27 #include "util.h"
  28
  29 using namespace chip;
  30
  31 EmberAfStatus emberAfApplicationBasicClusterClientCommandParse(EmberAfClusterCommand * cmd);
  32 EmberAfStatus emberAfBarrierControlClusterClientCommandParse(EmberAfClusterCommand * cmd);
  33 EmberAfStatus emberAfBasicClusterClientCommandParse(EmberAfClusterCommand * cmd);
  34 EmberAfStatus emberAfBindingClusterClientCommandParse(EmberAfClusterCommand * cmd);
  35 EmberAfStatus emberAfColorControlClusterClientCommandParse(EmberAfClusterCommand * cmd);
  36 EmberAfStatus emberAfContentLaunchClusterClientCommandParse(EmberAfClusterCommand * cmd);
  37 EmberAfStatus emberAfDoorLockClusterClientCommandParse(EmberAfClusterCommand * cmd);
  38 EmberAfStatus emberAfGeneralCommissioningClusterClientCommandParse(EmberAfClusterCommand * cmd);
  39 EmberAfStatus emberAfGroupsClusterClientCommandParse(EmberAfClusterCommand * cmd);
  40 EmberAfStatus emberAfIdentifyClusterClientCommandParse(EmberAfClusterCommand * cmd);
  41 EmberAfStatus emberAfLevelControlClusterClientCommandParse(EmberAfClusterCommand * cmd);
  42 EmberAfStatus emberAfLowPowerClusterClientCommandParse(EmberAfClusterCommand * cmd);
  43 EmberAfStatus emberAfMediaPlaybackClusterClientCommandParse(EmberAfClusterCommand * cmd);
  44 EmberAfStatus emberAfOnOffClusterClientCommandParse(EmberAfClusterCommand * cmd);
  45 EmberAfStatus emberAfScenesClusterClientCommandParse(EmberAfClusterCommand * cmd);
  46 EmberAfStatus emberAfTemperatureMeasurementClusterClientCommandParse(EmberAfClusterCommand * cmd);
  47
  48 static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific)
  49 {
  50     if (wasHandled)
  51     {
  52         return EMBER_ZCL_STATUS_SUCCESS;
  53     }
  54     else if (mfgSpecific)
  55     {
  56         return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND;
  57     }
  58     else if (clusterExists)
  59     {
  60         return EMBER_ZCL_STATUS_UNSUP_COMMAND;
  61     }
  62     else
  63     {
  64         return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER;
  65     }
  66 }
  67
  68 // Main command parsing controller.
  69 EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd)
  70 {
  71     EmberAfStatus result = status(false, false, cmd->mfgSpecific);
  72     if (cmd->direction == (uint8_t) ZCL_DIRECTION_SERVER_TO_CLIENT &&
  73         emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  74     {
  75         switch (cmd->apsFrame->clusterId)
  76         {
  77         case ZCL_APPLICATION_BASIC_CLUSTER_ID:
  78             // No commands are enabled for cluster Application Basic
  79             result = status(false, true, cmd->mfgSpecific);
  80             break;
  81         case ZCL_BARRIER_CONTROL_CLUSTER_ID:
  82             // No commands are enabled for cluster Barrier Control
  83             result = status(false, true, cmd->mfgSpecific);
  84             break;
  85         case ZCL_BASIC_CLUSTER_ID:
  86             // No commands are enabled for cluster Basic
  87             result = status(false, true, cmd->mfgSpecific);
  88             break;
  89         case ZCL_BINDING_CLUSTER_ID:
  90             // No commands are enabled for cluster Binding
  91             result = status(false, true, cmd->mfgSpecific);
  92             break;
  93         case ZCL_COLOR_CONTROL_CLUSTER_ID:
  94             // No commands are enabled for cluster Color Control
  95             result = status(false, true, cmd->mfgSpecific);
  96             break;
  97         case ZCL_CONTENT_LAUNCH_CLUSTER_ID:
  98             result = emberAfContentLaunchClusterClientCommandParse(cmd);
  99             break;
 100         case ZCL_DOOR_LOCK_CLUSTER_ID:
 101             result = emberAfDoorLockClusterClientCommandParse(cmd);
 102             break;
 103         case ZCL_GENERAL_COMMISSIONING_CLUSTER_ID:
 104             result = emberAfGeneralCommissioningClusterClientCommandParse(cmd);
 105             break;
 106         case ZCL_GROUPS_CLUSTER_ID:
 107             result = emberAfGroupsClusterClientCommandParse(cmd);
 108             break;
 109         case ZCL_IDENTIFY_CLUSTER_ID:
 110             result = emberAfIdentifyClusterClientCommandParse(cmd);
 111             break;
 112         case ZCL_LEVEL_CONTROL_CLUSTER_ID:
 113             // No commands are enabled for cluster Level Control
 114             result = status(false, true, cmd->mfgSpecific);
 115             break;
 116         case ZCL_LOW_POWER_CLUSTER_ID:
 117             // No commands are enabled for cluster Low Power
 118             result = status(false, true, cmd->mfgSpecific);
 119             break;
 120         case ZCL_MEDIA_PLAYBACK_CLUSTER_ID:
 121             result = emberAfMediaPlaybackClusterClientCommandParse(cmd);
 122             break;
 123         case ZCL_ON_OFF_CLUSTER_ID:
 124             // No commands are enabled for cluster On/off
 125             result = status(false, true, cmd->mfgSpecific);
 126             break;
 127         case ZCL_SCENES_CLUSTER_ID:
 128             result = emberAfScenesClusterClientCommandParse(cmd);
 129             break;
 130         case ZCL_TEMP_MEASUREMENT_CLUSTER_ID:
 131             // No commands are enabled for cluster Temperature Measurement
 132             result = status(false, true, cmd->mfgSpecific);
 133             break;
 134         default:
 135             // Unrecognized cluster ID, error status will apply.
 136             break;
 137         }
 138     }
 139     else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER &&
 140              emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
 141     {
 142         switch (cmd->apsFrame->clusterId)
 143         {
 144         default:
 145             // Unrecognized cluster ID, error status will apply.
 146             break;
 147         }
 148     }
 149     return result;
 150 }
 151
 152 // Cluster specific command parsing
 153
 154 EmberAfStatus emberAfContentLaunchClusterClientCommandParse(EmberAfClusterCommand * cmd)
 155 {
 156     bool wasHandled = false;
 157
 158     if (!cmd->mfgSpecific)
 159     {
 160         switch (cmd->commandId)
 161         {
 162         case ZCL_LAUNCH_CONTENT_RESPONSE_COMMAND_ID: {
 163             uint16_t payloadOffset = cmd->payloadStartIndex;
 164             uint8_t contentLaunchStatus;
 165
 166             if (cmd->bufLen < payloadOffset + 1)
 167             {
 168                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 169             }
 170             contentLaunchStatus = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 171
 172             wasHandled = emberAfContentLaunchClusterLaunchContentResponseCallback(contentLaunchStatus);
 173             break;
 174         }
 175         case ZCL_LAUNCH_URL_RESPONSE_COMMAND_ID: {
 176             uint16_t payloadOffset = cmd->payloadStartIndex;
 177             uint8_t contentLaunchStatus;
 178
 179             if (cmd->bufLen < payloadOffset + 1)
 180             {
 181                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 182             }
 183             contentLaunchStatus = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 184
 185             wasHandled = emberAfContentLaunchClusterLaunchURLResponseCallback(contentLaunchStatus);
 186             break;
 187         }
 188         default: {
 189             // Unrecognized command ID, error status will apply.
 190             break;
 191         }
 192         }
 193     }
 194     return status(wasHandled, true, cmd->mfgSpecific);
 195 }
 196 EmberAfStatus emberAfDoorLockClusterClientCommandParse(EmberAfClusterCommand * cmd)
 197 {
 198     bool wasHandled = false;
 199
 200     if (!cmd->mfgSpecific)
 201     {
 202         switch (cmd->commandId)
 203         {
 204         case ZCL_CLEAR_ALL_PINS_RESPONSE_COMMAND_ID: {
 205             uint16_t payloadOffset = cmd->payloadStartIndex;
 206             uint8_t status;
 207
 208             if (cmd->bufLen < payloadOffset + 1)
 209             {
 210                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 211             }
 212             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 213
 214             wasHandled = emberAfDoorLockClusterClearAllPinsResponseCallback(status);
 215             break;
 216         }
 217         case ZCL_CLEAR_ALL_RFIDS_RESPONSE_COMMAND_ID: {
 218             uint16_t payloadOffset = cmd->payloadStartIndex;
 219             uint8_t status;
 220
 221             if (cmd->bufLen < payloadOffset + 1)
 222             {
 223                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 224             }
 225             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 226
 227             wasHandled = emberAfDoorLockClusterClearAllRfidsResponseCallback(status);
 228             break;
 229         }
 230         case ZCL_CLEAR_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 231             uint16_t payloadOffset = cmd->payloadStartIndex;
 232             uint8_t status;
 233
 234             if (cmd->bufLen < payloadOffset + 1)
 235             {
 236                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 237             }
 238             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 239
 240             wasHandled = emberAfDoorLockClusterClearHolidayScheduleResponseCallback(status);
 241             break;
 242         }
 243         case ZCL_CLEAR_PIN_RESPONSE_COMMAND_ID: {
 244             uint16_t payloadOffset = cmd->payloadStartIndex;
 245             uint8_t status;
 246
 247             if (cmd->bufLen < payloadOffset + 1)
 248             {
 249                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 250             }
 251             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 252
 253             wasHandled = emberAfDoorLockClusterClearPinResponseCallback(status);
 254             break;
 255         }
 256         case ZCL_CLEAR_RFID_RESPONSE_COMMAND_ID: {
 257             uint16_t payloadOffset = cmd->payloadStartIndex;
 258             uint8_t status;
 259
 260             if (cmd->bufLen < payloadOffset + 1)
 261             {
 262                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 263             }
 264             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 265
 266             wasHandled = emberAfDoorLockClusterClearRfidResponseCallback(status);
 267             break;
 268         }
 269         case ZCL_CLEAR_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 270             uint16_t payloadOffset = cmd->payloadStartIndex;
 271             uint8_t status;
 272
 273             if (cmd->bufLen < payloadOffset + 1)
 274             {
 275                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 276             }
 277             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 278
 279             wasHandled = emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(status);
 280             break;
 281         }
 282         case ZCL_CLEAR_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 283             uint16_t payloadOffset = cmd->payloadStartIndex;
 284             uint8_t status;
 285
 286             if (cmd->bufLen < payloadOffset + 1)
 287             {
 288                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 289             }
 290             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 291
 292             wasHandled = emberAfDoorLockClusterClearYeardayScheduleResponseCallback(status);
 293             break;
 294         }
 295         case ZCL_GET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 296             uint16_t payloadOffset = cmd->payloadStartIndex;
 297             uint8_t scheduleId;
 298             uint8_t status;
 299             uint32_t localStartTime;
 300             uint32_t localEndTime;
 301             uint8_t operatingModeDuringHoliday;
 302
 303             if (cmd->bufLen < payloadOffset + 1)
 304             {
 305                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 306             }
 307             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 308             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 309             if (cmd->bufLen < payloadOffset + 1)
 310             {
 311                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 312             }
 313             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 314             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 315             if (cmd->bufLen < payloadOffset + 4)
 316             {
 317                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 318             }
 319             localStartTime = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 320             payloadOffset  = static_cast<uint16_t>(payloadOffset + 4);
 321             if (cmd->bufLen < payloadOffset + 4)
 322             {
 323                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 324             }
 325             localEndTime  = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 326             payloadOffset = static_cast<uint16_t>(payloadOffset + 4);
 327             if (cmd->bufLen < payloadOffset + 1)
 328             {
 329                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 330             }
 331             operatingModeDuringHoliday = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 332
 333             wasHandled = emberAfDoorLockClusterGetHolidayScheduleResponseCallback(scheduleId, status, localStartTime, localEndTime,
 334                                                                                   operatingModeDuringHoliday);
 335             break;
 336         }
 337         case ZCL_GET_LOG_RECORD_RESPONSE_COMMAND_ID: {
 338             uint16_t payloadOffset = cmd->payloadStartIndex;
 339             uint16_t logEntryId;
 340             uint32_t timestamp;
 341             uint8_t eventType;
 342             uint8_t source;
 343             uint8_t eventIdOrAlarmCode;
 344             uint16_t userId;
 345             uint8_t * pin;
 346
 347             if (cmd->bufLen < payloadOffset + 2)
 348             {
 349                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 350             }
 351             logEntryId    = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 352             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 353             if (cmd->bufLen < payloadOffset + 4)
 354             {
 355                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 356             }
 357             timestamp     = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 358             payloadOffset = static_cast<uint16_t>(payloadOffset + 4);
 359             if (cmd->bufLen < payloadOffset + 1)
 360             {
 361                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 362             }
 363             eventType     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 364             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 365             if (cmd->bufLen < payloadOffset + 1)
 366             {
 367                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 368             }
 369             source        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 370             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 371             if (cmd->bufLen < payloadOffset + 1)
 372             {
 373                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 374             }
 375             eventIdOrAlarmCode = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 376             payloadOffset      = static_cast<uint16_t>(payloadOffset + 1);
 377             if (cmd->bufLen < payloadOffset + 2)
 378             {
 379                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 380             }
 381             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 382             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 383             if (cmd->bufLen < payloadOffset + 1u)
 384             {
 385                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 386             }
 387             pin = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 388
 389             wasHandled = emberAfDoorLockClusterGetLogRecordResponseCallback(logEntryId, timestamp, eventType, source,
 390                                                                             eventIdOrAlarmCode, userId, pin);
 391             break;
 392         }
 393         case ZCL_GET_PIN_RESPONSE_COMMAND_ID: {
 394             uint16_t payloadOffset = cmd->payloadStartIndex;
 395             uint16_t userId;
 396             uint8_t userStatus;
 397             uint8_t userType;
 398             uint8_t * pin;
 399
 400             if (cmd->bufLen < payloadOffset + 2)
 401             {
 402                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 403             }
 404             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 405             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 406             if (cmd->bufLen < payloadOffset + 1)
 407             {
 408                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 409             }
 410             userStatus    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 411             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 412             if (cmd->bufLen < payloadOffset + 1)
 413             {
 414                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 415             }
 416             userType      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 417             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 418             if (cmd->bufLen < payloadOffset + 1u)
 419             {
 420                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 421             }
 422             pin = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 423
 424             wasHandled = emberAfDoorLockClusterGetPinResponseCallback(userId, userStatus, userType, pin);
 425             break;
 426         }
 427         case ZCL_GET_RFID_RESPONSE_COMMAND_ID: {
 428             uint16_t payloadOffset = cmd->payloadStartIndex;
 429             uint16_t userId;
 430             uint8_t userStatus;
 431             uint8_t userType;
 432             uint8_t * rfid;
 433
 434             if (cmd->bufLen < payloadOffset + 2)
 435             {
 436                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 437             }
 438             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 439             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 440             if (cmd->bufLen < payloadOffset + 1)
 441             {
 442                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 443             }
 444             userStatus    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 445             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 446             if (cmd->bufLen < payloadOffset + 1)
 447             {
 448                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 449             }
 450             userType      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 451             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 452             if (cmd->bufLen < payloadOffset + 1u)
 453             {
 454                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 455             }
 456             rfid = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 457
 458             wasHandled = emberAfDoorLockClusterGetRfidResponseCallback(userId, userStatus, userType, rfid);
 459             break;
 460         }
 461         case ZCL_GET_USER_TYPE_RESPONSE_COMMAND_ID: {
 462             uint16_t payloadOffset = cmd->payloadStartIndex;
 463             uint16_t userId;
 464             uint8_t userType;
 465
 466             if (cmd->bufLen < payloadOffset + 2)
 467             {
 468                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 469             }
 470             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 471             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 472             if (cmd->bufLen < payloadOffset + 1)
 473             {
 474                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 475             }
 476             userType = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 477
 478             wasHandled = emberAfDoorLockClusterGetUserTypeResponseCallback(userId, userType);
 479             break;
 480         }
 481         case ZCL_GET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 482             uint16_t payloadOffset = cmd->payloadStartIndex;
 483             uint8_t scheduleId;
 484             uint16_t userId;
 485             uint8_t status;
 486             uint8_t daysMask;
 487             uint8_t startHour;
 488             uint8_t startMinute;
 489             uint8_t endHour;
 490             uint8_t endMinute;
 491
 492             if (cmd->bufLen < payloadOffset + 1)
 493             {
 494                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 495             }
 496             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 497             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 498             if (cmd->bufLen < payloadOffset + 2)
 499             {
 500                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 501             }
 502             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 503             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 504             if (cmd->bufLen < payloadOffset + 1)
 505             {
 506                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 507             }
 508             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 509             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 510             if (cmd->bufLen < payloadOffset + 1)
 511             {
 512                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 513             }
 514             daysMask      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 515             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 516             if (cmd->bufLen < payloadOffset + 1)
 517             {
 518                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 519             }
 520             startHour     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 521             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 522             if (cmd->bufLen < payloadOffset + 1)
 523             {
 524                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 525             }
 526             startMinute   = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 527             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 528             if (cmd->bufLen < payloadOffset + 1)
 529             {
 530                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 531             }
 532             endHour       = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 533             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 534             if (cmd->bufLen < payloadOffset + 1)
 535             {
 536                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 537             }
 538             endMinute = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 539
 540             wasHandled = emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(scheduleId, userId, status, daysMask, startHour,
 541                                                                                   startMinute, endHour, endMinute);
 542             break;
 543         }
 544         case ZCL_GET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 545             uint16_t payloadOffset = cmd->payloadStartIndex;
 546             uint8_t scheduleId;
 547             uint16_t userId;
 548             uint8_t status;
 549             uint32_t localStartTime;
 550             uint32_t localEndTime;
 551
 552             if (cmd->bufLen < payloadOffset + 1)
 553             {
 554                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 555             }
 556             scheduleId    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 557             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 558             if (cmd->bufLen < payloadOffset + 2)
 559             {
 560                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 561             }
 562             userId        = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 563             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 564             if (cmd->bufLen < payloadOffset + 1)
 565             {
 566                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 567             }
 568             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 569             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 570             if (cmd->bufLen < payloadOffset + 4)
 571             {
 572                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 573             }
 574             localStartTime = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 575             payloadOffset  = static_cast<uint16_t>(payloadOffset + 4);
 576             if (cmd->bufLen < payloadOffset + 4)
 577             {
 578                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 579             }
 580             localEndTime = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 581
 582             wasHandled =
 583                 emberAfDoorLockClusterGetYeardayScheduleResponseCallback(scheduleId, userId, status, localStartTime, localEndTime);
 584             break;
 585         }
 586         case ZCL_LOCK_DOOR_RESPONSE_COMMAND_ID: {
 587             uint16_t payloadOffset = cmd->payloadStartIndex;
 588             uint8_t status;
 589
 590             if (cmd->bufLen < payloadOffset + 1)
 591             {
 592                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 593             }
 594             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 595
 596             wasHandled = emberAfDoorLockClusterLockDoorResponseCallback(status);
 597             break;
 598         }
 599         case ZCL_SET_HOLIDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 600             uint16_t payloadOffset = cmd->payloadStartIndex;
 601             uint8_t status;
 602
 603             if (cmd->bufLen < payloadOffset + 1)
 604             {
 605                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 606             }
 607             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 608
 609             wasHandled = emberAfDoorLockClusterSetHolidayScheduleResponseCallback(status);
 610             break;
 611         }
 612         case ZCL_SET_PIN_RESPONSE_COMMAND_ID: {
 613             uint16_t payloadOffset = cmd->payloadStartIndex;
 614             uint8_t status;
 615
 616             if (cmd->bufLen < payloadOffset + 1)
 617             {
 618                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 619             }
 620             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 621
 622             wasHandled = emberAfDoorLockClusterSetPinResponseCallback(status);
 623             break;
 624         }
 625         case ZCL_SET_RFID_RESPONSE_COMMAND_ID: {
 626             uint16_t payloadOffset = cmd->payloadStartIndex;
 627             uint8_t status;
 628
 629             if (cmd->bufLen < payloadOffset + 1)
 630             {
 631                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 632             }
 633             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 634
 635             wasHandled = emberAfDoorLockClusterSetRfidResponseCallback(status);
 636             break;
 637         }
 638         case ZCL_SET_USER_TYPE_RESPONSE_COMMAND_ID: {
 639             uint16_t payloadOffset = cmd->payloadStartIndex;
 640             uint8_t status;
 641
 642             if (cmd->bufLen < payloadOffset + 1)
 643             {
 644                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 645             }
 646             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 647
 648             wasHandled = emberAfDoorLockClusterSetUserTypeResponseCallback(status);
 649             break;
 650         }
 651         case ZCL_SET_WEEKDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 652             uint16_t payloadOffset = cmd->payloadStartIndex;
 653             uint8_t status;
 654
 655             if (cmd->bufLen < payloadOffset + 1)
 656             {
 657                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 658             }
 659             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 660
 661             wasHandled = emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(status);
 662             break;
 663         }
 664         case ZCL_SET_YEARDAY_SCHEDULE_RESPONSE_COMMAND_ID: {
 665             uint16_t payloadOffset = cmd->payloadStartIndex;
 666             uint8_t status;
 667
 668             if (cmd->bufLen < payloadOffset + 1)
 669             {
 670                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 671             }
 672             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 673
 674             wasHandled = emberAfDoorLockClusterSetYeardayScheduleResponseCallback(status);
 675             break;
 676         }
 677         case ZCL_UNLOCK_DOOR_RESPONSE_COMMAND_ID: {
 678             uint16_t payloadOffset = cmd->payloadStartIndex;
 679             uint8_t status;
 680
 681             if (cmd->bufLen < payloadOffset + 1)
 682             {
 683                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 684             }
 685             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 686
 687             wasHandled = emberAfDoorLockClusterUnlockDoorResponseCallback(status);
 688             break;
 689         }
 690         case ZCL_UNLOCK_WITH_TIMEOUT_RESPONSE_COMMAND_ID: {
 691             uint16_t payloadOffset = cmd->payloadStartIndex;
 692             uint8_t status;
 693
 694             if (cmd->bufLen < payloadOffset + 1)
 695             {
 696                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 697             }
 698             status = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 699
 700             wasHandled = emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(status);
 701             break;
 702         }
 703         default: {
 704             // Unrecognized command ID, error status will apply.
 705             break;
 706         }
 707         }
 708     }
 709     return status(wasHandled, true, cmd->mfgSpecific);
 710 }
 711 EmberAfStatus emberAfGeneralCommissioningClusterClientCommandParse(EmberAfClusterCommand * cmd)
 712 {
 713     bool wasHandled = false;
 714
 715     if (!cmd->mfgSpecific)
 716     {
 717         switch (cmd->commandId)
 718         {
 719         case ZCL_ARM_FAIL_SAFE_RESPONSE_COMMAND_ID: {
 720             uint16_t payloadOffset = cmd->payloadStartIndex;
 721             uint8_t errorCode;
 722             uint8_t * debugText;
 723
 724             if (cmd->bufLen < payloadOffset + 1)
 725             {
 726                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 727             }
 728             errorCode     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 729             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 730             if (cmd->bufLen < payloadOffset + 1u)
 731             {
 732                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 733             }
 734             debugText = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 735
 736             wasHandled = emberAfGeneralCommissioningClusterArmFailSafeResponseCallback(errorCode, debugText);
 737             break;
 738         }
 739         case ZCL_COMMISSIONING_COMPLETE_RESPONSE_COMMAND_ID: {
 740             uint16_t payloadOffset = cmd->payloadStartIndex;
 741             uint8_t errorCode;
 742             uint8_t * debugText;
 743
 744             if (cmd->bufLen < payloadOffset + 1)
 745             {
 746                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 747             }
 748             errorCode     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 749             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 750             if (cmd->bufLen < payloadOffset + 1u)
 751             {
 752                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 753             }
 754             debugText = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 755
 756             wasHandled = emberAfGeneralCommissioningClusterCommissioningCompleteResponseCallback(errorCode, debugText);
 757             break;
 758         }
 759         case ZCL_SET_FABRIC_RESPONSE_COMMAND_ID: {
 760             uint16_t payloadOffset = cmd->payloadStartIndex;
 761             uint8_t errorCode;
 762             uint8_t * debugText;
 763
 764             if (cmd->bufLen < payloadOffset + 1)
 765             {
 766                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 767             }
 768             errorCode     = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 769             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 770             if (cmd->bufLen < payloadOffset + 1u)
 771             {
 772                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 773             }
 774             debugText = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 775
 776             wasHandled = emberAfGeneralCommissioningClusterSetFabricResponseCallback(errorCode, debugText);
 777             break;
 778         }
 779         default: {
 780             // Unrecognized command ID, error status will apply.
 781             break;
 782         }
 783         }
 784     }
 785     return status(wasHandled, true, cmd->mfgSpecific);
 786 }
 787 EmberAfStatus emberAfGroupsClusterClientCommandParse(EmberAfClusterCommand * cmd)
 788 {
 789     bool wasHandled = false;
 790
 791     if (!cmd->mfgSpecific)
 792     {
 793         switch (cmd->commandId)
 794         {
 795         case ZCL_ADD_GROUP_RESPONSE_COMMAND_ID: {
 796             uint16_t payloadOffset = cmd->payloadStartIndex;
 797             uint8_t status;
 798             uint16_t groupId;
 799
 800             if (cmd->bufLen < payloadOffset + 1)
 801             {
 802                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 803             }
 804             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 805             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 806             if (cmd->bufLen < payloadOffset + 2)
 807             {
 808                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 809             }
 810             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 811
 812             wasHandled = emberAfGroupsClusterAddGroupResponseCallback(status, groupId);
 813             break;
 814         }
 815         case ZCL_GET_GROUP_MEMBERSHIP_RESPONSE_COMMAND_ID: {
 816             uint16_t payloadOffset = cmd->payloadStartIndex;
 817             uint8_t capacity;
 818             uint8_t groupCount;
 819             /* TYPE WARNING: array array defaults to */ uint8_t * groupList;
 820
 821             if (cmd->bufLen < payloadOffset + 1)
 822             {
 823                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 824             }
 825             capacity      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 826             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 827             if (cmd->bufLen < payloadOffset + 1)
 828             {
 829                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 830             }
 831             groupCount    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 832             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 833             groupList     = cmd->buffer + payloadOffset;
 834
 835             wasHandled = emberAfGroupsClusterGetGroupMembershipResponseCallback(capacity, groupCount, groupList);
 836             break;
 837         }
 838         case ZCL_REMOVE_GROUP_RESPONSE_COMMAND_ID: {
 839             uint16_t payloadOffset = cmd->payloadStartIndex;
 840             uint8_t status;
 841             uint16_t groupId;
 842
 843             if (cmd->bufLen < payloadOffset + 1)
 844             {
 845                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 846             }
 847             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 848             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 849             if (cmd->bufLen < payloadOffset + 2)
 850             {
 851                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 852             }
 853             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 854
 855             wasHandled = emberAfGroupsClusterRemoveGroupResponseCallback(status, groupId);
 856             break;
 857         }
 858         case ZCL_VIEW_GROUP_RESPONSE_COMMAND_ID: {
 859             uint16_t payloadOffset = cmd->payloadStartIndex;
 860             uint8_t status;
 861             uint16_t groupId;
 862             uint8_t * groupName;
 863
 864             if (cmd->bufLen < payloadOffset + 1)
 865             {
 866                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 867             }
 868             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 869             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 870             if (cmd->bufLen < payloadOffset + 2)
 871             {
 872                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 873             }
 874             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 875             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 876             if (cmd->bufLen < payloadOffset + 1u)
 877             {
 878                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 879             }
 880             groupName = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 881
 882             wasHandled = emberAfGroupsClusterViewGroupResponseCallback(status, groupId, groupName);
 883             break;
 884         }
 885         default: {
 886             // Unrecognized command ID, error status will apply.
 887             break;
 888         }
 889         }
 890     }
 891     return status(wasHandled, true, cmd->mfgSpecific);
 892 }
 893 EmberAfStatus emberAfIdentifyClusterClientCommandParse(EmberAfClusterCommand * cmd)
 894 {
 895     bool wasHandled = false;
 896
 897     if (!cmd->mfgSpecific)
 898     {
 899         switch (cmd->commandId)
 900         {
 901         case ZCL_IDENTIFY_QUERY_RESPONSE_COMMAND_ID: {
 902             uint16_t payloadOffset = cmd->payloadStartIndex;
 903             uint16_t timeout;
 904
 905             if (cmd->bufLen < payloadOffset + 2)
 906             {
 907                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 908             }
 909             timeout = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 910
 911             wasHandled = emberAfIdentifyClusterIdentifyQueryResponseCallback(timeout);
 912             break;
 913         }
 914         default: {
 915             // Unrecognized command ID, error status will apply.
 916             break;
 917         }
 918         }
 919     }
 920     return status(wasHandled, true, cmd->mfgSpecific);
 921 }
 922 EmberAfStatus emberAfMediaPlaybackClusterClientCommandParse(EmberAfClusterCommand * cmd)
 923 {
 924     bool wasHandled = false;
 925
 926     if (!cmd->mfgSpecific)
 927     {
 928         switch (cmd->commandId)
 929         {
 930         case ZCL_PLAYBACK_COMMAND_ID: {
 931             wasHandled = emberAfMediaPlaybackClusterPlaybackCallback();
 932             break;
 933         }
 934         default: {
 935             // Unrecognized command ID, error status will apply.
 936             break;
 937         }
 938         }
 939     }
 940     return status(wasHandled, true, cmd->mfgSpecific);
 941 }
 942 EmberAfStatus emberAfScenesClusterClientCommandParse(EmberAfClusterCommand * cmd)
 943 {
 944     bool wasHandled = false;
 945
 946     if (!cmd->mfgSpecific)
 947     {
 948         switch (cmd->commandId)
 949         {
 950         case ZCL_ADD_SCENE_RESPONSE_COMMAND_ID: {
 951             uint16_t payloadOffset = cmd->payloadStartIndex;
 952             uint8_t status;
 953             uint16_t groupId;
 954             uint8_t sceneId;
 955
 956             if (cmd->bufLen < payloadOffset + 1)
 957             {
 958                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 959             }
 960             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 961             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 962             if (cmd->bufLen < payloadOffset + 2)
 963             {
 964                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 965             }
 966             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 967             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
 968             if (cmd->bufLen < payloadOffset + 1)
 969             {
 970                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 971             }
 972             sceneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 973
 974             wasHandled = emberAfScenesClusterAddSceneResponseCallback(status, groupId, sceneId);
 975             break;
 976         }
 977         case ZCL_GET_SCENE_MEMBERSHIP_RESPONSE_COMMAND_ID: {
 978             uint16_t payloadOffset = cmd->payloadStartIndex;
 979             uint8_t status;
 980             uint8_t capacity;
 981             uint16_t groupId;
 982             uint8_t sceneCount;
 983             /* TYPE WARNING: array array defaults to */ uint8_t * sceneList;
 984
 985             if (cmd->bufLen < payloadOffset + 1)
 986             {
 987                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 988             }
 989             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 990             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 991             if (cmd->bufLen < payloadOffset + 1)
 992             {
 993                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 994             }
 995             capacity      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 996             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 997             if (cmd->bufLen < payloadOffset + 2)
 998             {
 999                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1000             }
1001             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1002             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1003             if (status == 0)
1004             {
1005                 if (cmd->bufLen < payloadOffset + 1)
1006                 {
1007                     return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1008                 }
1009                 sceneCount    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1010                 payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1011             }
1012             else
1013             {
1014                 sceneCount = UINT8_MAX;
1015             }
1016             if (status == 0)
1017             {
1018                 sceneList = cmd->buffer + payloadOffset;
1019             }
1020             else
1021             {
1022                 sceneList = NULL;
1023             }
1024
1025             wasHandled = emberAfScenesClusterGetSceneMembershipResponseCallback(status, capacity, groupId, sceneCount, sceneList);
1026             break;
1027         }
1028         case ZCL_REMOVE_ALL_SCENES_RESPONSE_COMMAND_ID: {
1029             uint16_t payloadOffset = cmd->payloadStartIndex;
1030             uint8_t status;
1031             uint16_t groupId;
1032
1033             if (cmd->bufLen < payloadOffset + 1)
1034             {
1035                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1036             }
1037             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1038             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1039             if (cmd->bufLen < payloadOffset + 2)
1040             {
1041                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1042             }
1043             groupId = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1044
1045             wasHandled = emberAfScenesClusterRemoveAllScenesResponseCallback(status, groupId);
1046             break;
1047         }
1048         case ZCL_REMOVE_SCENE_RESPONSE_COMMAND_ID: {
1049             uint16_t payloadOffset = cmd->payloadStartIndex;
1050             uint8_t status;
1051             uint16_t groupId;
1052             uint8_t sceneId;
1053
1054             if (cmd->bufLen < payloadOffset + 1)
1055             {
1056                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1057             }
1058             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1059             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1060             if (cmd->bufLen < payloadOffset + 2)
1061             {
1062                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1063             }
1064             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1065             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1066             if (cmd->bufLen < payloadOffset + 1)
1067             {
1068                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1069             }
1070             sceneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1071
1072             wasHandled = emberAfScenesClusterRemoveSceneResponseCallback(status, groupId, sceneId);
1073             break;
1074         }
1075         case ZCL_STORE_SCENE_RESPONSE_COMMAND_ID: {
1076             uint16_t payloadOffset = cmd->payloadStartIndex;
1077             uint8_t status;
1078             uint16_t groupId;
1079             uint8_t sceneId;
1080
1081             if (cmd->bufLen < payloadOffset + 1)
1082             {
1083                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1084             }
1085             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1086             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1087             if (cmd->bufLen < payloadOffset + 2)
1088             {
1089                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1090             }
1091             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1092             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1093             if (cmd->bufLen < payloadOffset + 1)
1094             {
1095                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1096             }
1097             sceneId = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1098
1099             wasHandled = emberAfScenesClusterStoreSceneResponseCallback(status, groupId, sceneId);
1100             break;
1101         }
1102         case ZCL_VIEW_SCENE_RESPONSE_COMMAND_ID: {
1103             uint16_t payloadOffset = cmd->payloadStartIndex;
1104             uint8_t status;
1105             uint16_t groupId;
1106             uint8_t sceneId;
1107             uint16_t transitionTime;
1108             uint8_t * sceneName;
1109             /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets;
1110
1111             if (cmd->bufLen < payloadOffset + 1)
1112             {
1113                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1114             }
1115             status        = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1116             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1117             if (cmd->bufLen < payloadOffset + 2)
1118             {
1119                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1120             }
1121             groupId       = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1122             payloadOffset = static_cast<uint16_t>(payloadOffset + 2);
1123             if (cmd->bufLen < payloadOffset + 1)
1124             {
1125                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1126             }
1127             sceneId       = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
1128             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
1129             if (status == 0)
1130             {
1131                 if (cmd->bufLen < payloadOffset + 2)
1132                 {
1133                     return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1134                 }
1135                 transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
1136                 payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
1137             }
1138             else
1139             {
1140                 transitionTime = UINT16_MAX;
1141             }
1142             if (status == 0)
1143             {
1144                 if (cmd->bufLen < payloadOffset + 1u)
1145                 {
1146                     return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
1147                 }
1148                 sceneName     = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
1149                 payloadOffset = static_cast<uint16_t>(payloadOffset + emberAfStringLength(sceneName) + 1u);
1150             }
1151             else
1152             {
1153                 sceneName = NULL;
1154             }
1155             if (status == 0)
1156             {
1157                 extensionFieldSets = cmd->buffer + payloadOffset;
1158             }
1159             else
1160             {
1161                 extensionFieldSets = NULL;
1162             }
1163
1164             wasHandled = emberAfScenesClusterViewSceneResponseCallback(status, groupId, sceneId, transitionTime, sceneName,
1165                                                                        extensionFieldSets);
1166             break;
1167         }
1168         default: {
1169             // Unrecognized command ID, error status will apply.
1170             break;
1171         }
1172         }
1173     }
1174     return status(wasHandled, true, cmd->mfgSpecific);
1175 }