examples/lock-app/lock-common/gen/call-command-handler.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 #include <stdint.h>
  21
  22 #include "af-structs.h"
  23 #include "app/util/util.h"
  24 #include "call-command-handler.h"
  25 #include "callback.h"
  26 #include "cluster-id.h"
  27 #include "command-id.h"
  28
  29 using namespace chip;
  30
  31 EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd);
  32 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd);
  33 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd);
  34
  35 static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific)
  36 {
  37     if (wasHandled)
  38     {
  39         return EMBER_ZCL_STATUS_SUCCESS;
  40     }
  41     else if (mfgSpecific)
  42     {
  43         return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND;
  44     }
  45     else if (clusterExists)
  46     {
  47         return EMBER_ZCL_STATUS_UNSUP_COMMAND;
  48     }
  49     else
  50     {
  51         return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER;
  52     }
  53 }
  54
  55 // Main command parsing controller.
  56 EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd)
  57 {
  58     EmberAfStatus result = status(false, false, cmd->mfgSpecific);
  59     if (cmd->direction == (uint8_t) ZCL_DIRECTION_SERVER_TO_CLIENT &&
  60         emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  61     {
  62         switch (cmd->apsFrame->clusterId)
  63         {
  64         default:
  65             // Unrecognized cluster ID, error status will apply.
  66             break;
  67         }
  68     }
  69     else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER &&
  70              emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  71     {
  72         switch (cmd->apsFrame->clusterId)
  73         {
  74         case ZCL_BASIC_CLUSTER_ID:
  75             // No commands are enabled for cluster Basic
  76             result = status(false, true, cmd->mfgSpecific);
  77             break;
  78         case ZCL_NETWORK_COMMISSIONING_CLUSTER_ID:
  79             result = emberAfNetworkCommissioningClusterServerCommandParse(cmd);
  80             break;
  81         case ZCL_ON_OFF_CLUSTER_ID:
  82             result = emberAfOnOffClusterServerCommandParse(cmd);
  83             break;
  84         default:
  85             // Unrecognized cluster ID, error status will apply.
  86             break;
  87         }
  88     }
  89     return result;
  90 }
  91
  92 // Cluster specific command parsing
  93
  94 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd)
  95 {
  96     bool wasHandled = false;
  97
  98     if (!cmd->mfgSpecific)
  99     {
 100         switch (cmd->commandId)
 101         {
 102         case ZCL_ADD_THREAD_NETWORK_COMMAND_ID: {
 103             uint16_t payloadOffset = cmd->payloadStartIndex;
 104             chip::ByteSpan operationalDataset;
 105             uint64_t breadcrumb;
 106             uint32_t timeoutMs;
 107
 108             if (cmd->bufLen < payloadOffset + 1u)
 109             {
 110                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 111             }
 112             {
 113                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 114                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 115             }
 116             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
 117             if (cmd->bufLen < payloadOffset + 8)
 118             {
 119                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 120             }
 121             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 122             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 123             if (cmd->bufLen < payloadOffset + 4)
 124             {
 125                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 126             }
 127             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 128
 129             wasHandled = emberAfNetworkCommissioningClusterAddThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 130             break;
 131         }
 132         case ZCL_ADD_WI_FI_NETWORK_COMMAND_ID: {
 133             uint16_t payloadOffset = cmd->payloadStartIndex;
 134             chip::ByteSpan ssid;
 135             chip::ByteSpan credentials;
 136             uint64_t breadcrumb;
 137             uint32_t timeoutMs;
 138
 139             if (cmd->bufLen < payloadOffset + 1u)
 140             {
 141                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 142             }
 143             {
 144                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 145                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 146             }
 147             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 148             if (cmd->bufLen < payloadOffset + 1u)
 149             {
 150                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 151             }
 152             {
 153                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 154                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 155             }
 156             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
 157             if (cmd->bufLen < payloadOffset + 8)
 158             {
 159                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 160             }
 161             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 162             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 163             if (cmd->bufLen < payloadOffset + 4)
 164             {
 165                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 166             }
 167             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 168
 169             wasHandled = emberAfNetworkCommissioningClusterAddWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 170             break;
 171         }
 172         case ZCL_DISABLE_NETWORK_COMMAND_ID: {
 173             uint16_t payloadOffset = cmd->payloadStartIndex;
 174             chip::ByteSpan networkID;
 175             uint64_t breadcrumb;
 176             uint32_t timeoutMs;
 177
 178             if (cmd->bufLen < payloadOffset + 1u)
 179             {
 180                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 181             }
 182             {
 183                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 184                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 185             }
 186             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
 187             if (cmd->bufLen < payloadOffset + 8)
 188             {
 189                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 190             }
 191             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 192             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 193             if (cmd->bufLen < payloadOffset + 4)
 194             {
 195                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 196             }
 197             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 198
 199             wasHandled = emberAfNetworkCommissioningClusterDisableNetworkCallback(networkID, breadcrumb, timeoutMs);
 200             break;
 201         }
 202         case ZCL_ENABLE_NETWORK_COMMAND_ID: {
 203             uint16_t payloadOffset = cmd->payloadStartIndex;
 204             chip::ByteSpan networkID;
 205             uint64_t breadcrumb;
 206             uint32_t timeoutMs;
 207
 208             if (cmd->bufLen < payloadOffset + 1u)
 209             {
 210                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 211             }
 212             {
 213                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 214                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 215             }
 216             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
 217             if (cmd->bufLen < payloadOffset + 8)
 218             {
 219                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 220             }
 221             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 222             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 223             if (cmd->bufLen < payloadOffset + 4)
 224             {
 225                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 226             }
 227             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 228
 229             wasHandled = emberAfNetworkCommissioningClusterEnableNetworkCallback(networkID, breadcrumb, timeoutMs);
 230             break;
 231         }
 232         case ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID: {
 233             uint16_t payloadOffset = cmd->payloadStartIndex;
 234             uint32_t timeoutMs;
 235
 236             if (cmd->bufLen < payloadOffset + 4)
 237             {
 238                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 239             }
 240             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 241
 242             wasHandled = emberAfNetworkCommissioningClusterGetLastNetworkCommissioningResultCallback(timeoutMs);
 243             break;
 244         }
 245         case ZCL_REMOVE_NETWORK_COMMAND_ID: {
 246             uint16_t payloadOffset = cmd->payloadStartIndex;
 247             chip::ByteSpan NetworkID;
 248             uint64_t Breadcrumb;
 249             uint32_t TimeoutMs;
 250
 251             if (cmd->bufLen < payloadOffset + 1u)
 252             {
 253                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 254             }
 255             {
 256                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 257                 NetworkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 258             }
 259             payloadOffset = static_cast<uint16_t>(payloadOffset + NetworkID.size() + 1u);
 260             if (cmd->bufLen < payloadOffset + 8)
 261             {
 262                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 263             }
 264             Breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 265             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 266             if (cmd->bufLen < payloadOffset + 4)
 267             {
 268                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 269             }
 270             TimeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 271
 272             wasHandled = emberAfNetworkCommissioningClusterRemoveNetworkCallback(NetworkID, Breadcrumb, TimeoutMs);
 273             break;
 274         }
 275         case ZCL_SCAN_NETWORKS_COMMAND_ID: {
 276             uint16_t payloadOffset = cmd->payloadStartIndex;
 277             chip::ByteSpan ssid;
 278             uint64_t breadcrumb;
 279             uint32_t timeoutMs;
 280
 281             if (cmd->bufLen < payloadOffset + 1u)
 282             {
 283                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 284             }
 285             {
 286                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 287                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 288             }
 289             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 290             if (cmd->bufLen < payloadOffset + 8)
 291             {
 292                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 293             }
 294             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 295             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 296             if (cmd->bufLen < payloadOffset + 4)
 297             {
 298                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 299             }
 300             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 301
 302             wasHandled = emberAfNetworkCommissioningClusterScanNetworksCallback(ssid, breadcrumb, timeoutMs);
 303             break;
 304         }
 305         case ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID: {
 306             uint16_t payloadOffset = cmd->payloadStartIndex;
 307             chip::ByteSpan operationalDataset;
 308             uint64_t breadcrumb;
 309             uint32_t timeoutMs;
 310
 311             if (cmd->bufLen < payloadOffset + 1u)
 312             {
 313                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 314             }
 315             {
 316                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 317                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 318             }
 319             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
 320             if (cmd->bufLen < payloadOffset + 8)
 321             {
 322                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 323             }
 324             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 325             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 326             if (cmd->bufLen < payloadOffset + 4)
 327             {
 328                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 329             }
 330             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 331
 332             wasHandled = emberAfNetworkCommissioningClusterUpdateThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 333             break;
 334         }
 335         case ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID: {
 336             uint16_t payloadOffset = cmd->payloadStartIndex;
 337             chip::ByteSpan ssid;
 338             chip::ByteSpan credentials;
 339             uint64_t breadcrumb;
 340             uint32_t timeoutMs;
 341
 342             if (cmd->bufLen < payloadOffset + 1u)
 343             {
 344                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 345             }
 346             {
 347                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 348                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 349             }
 350             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 351             if (cmd->bufLen < payloadOffset + 1u)
 352             {
 353                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 354             }
 355             {
 356                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 357                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 358             }
 359             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
 360             if (cmd->bufLen < payloadOffset + 8)
 361             {
 362                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 363             }
 364             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 365             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 366             if (cmd->bufLen < payloadOffset + 4)
 367             {
 368                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 369             }
 370             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 371
 372             wasHandled = emberAfNetworkCommissioningClusterUpdateWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 373             break;
 374         }
 375         default: {
 376             // Unrecognized command ID, error status will apply.
 377             break;
 378         }
 379         }
 380     }
 381     return status(wasHandled, true, cmd->mfgSpecific);
 382 }
 383 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd)
 384 {
 385     bool wasHandled = false;
 386
 387     if (!cmd->mfgSpecific)
 388     {
 389         switch (cmd->commandId)
 390         {
 391         case ZCL_OFF_COMMAND_ID: {
 392             wasHandled = emberAfOnOffClusterOffCallback();
 393             break;
 394         }
 395         case ZCL_ON_COMMAND_ID: {
 396             wasHandled = emberAfOnOffClusterOnCallback();
 397             break;
 398         }
 399         case ZCL_TOGGLE_COMMAND_ID: {
 400             wasHandled = emberAfOnOffClusterToggleCallback();
 401             break;
 402         }
 403         default: {
 404             // Unrecognized command ID, error status will apply.
 405             break;
 406         }
 407         }
 408     }
 409     return status(wasHandled, true, cmd->mfgSpecific);
 410 }