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