examples/temperature-measurement-app/esp32/main/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 emberAfTemperatureMeasurementClusterServerCommandParse(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_TEMP_MEASUREMENT_CLUSTER_ID:
  82             // No commands are enabled for cluster Temperature Measurement
  83             result = status(false, true, cmd->mfgSpecific);
  84             break;
  85         default:
  86             // Unrecognized cluster ID, error status will apply.
  87             break;
  88         }
  89     }
  90     return result;
  91 }
  92
  93 // Cluster specific command parsing
  94
  95 EmberAfStatus emberAfNetworkCommissioningClusterServerCommandParse(EmberAfClusterCommand * cmd)
  96 {
  97     bool wasHandled = false;
  98
  99     if (!cmd->mfgSpecific)
 100     {
 101         switch (cmd->commandId)
 102         {
 103         case ZCL_ADD_THREAD_NETWORK_COMMAND_ID: {
 104             uint16_t payloadOffset = cmd->payloadStartIndex;
 105             chip::ByteSpan operationalDataset;
 106             uint64_t breadcrumb;
 107             uint32_t timeoutMs;
 108
 109             if (cmd->bufLen < payloadOffset + 1u)
 110             {
 111                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 112             }
 113             {
 114                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 115                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 116             }
 117             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
 118             if (cmd->bufLen < payloadOffset + 8)
 119             {
 120                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 121             }
 122             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 123             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 124             if (cmd->bufLen < payloadOffset + 4)
 125             {
 126                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 127             }
 128             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 129
 130             wasHandled = emberAfNetworkCommissioningClusterAddThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 131             break;
 132         }
 133         case ZCL_ADD_WI_FI_NETWORK_COMMAND_ID: {
 134             uint16_t payloadOffset = cmd->payloadStartIndex;
 135             chip::ByteSpan ssid;
 136             chip::ByteSpan credentials;
 137             uint64_t breadcrumb;
 138             uint32_t timeoutMs;
 139
 140             if (cmd->bufLen < payloadOffset + 1u)
 141             {
 142                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 143             }
 144             {
 145                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 146                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 147             }
 148             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 149             if (cmd->bufLen < payloadOffset + 1u)
 150             {
 151                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 152             }
 153             {
 154                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 155                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 156             }
 157             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
 158             if (cmd->bufLen < payloadOffset + 8)
 159             {
 160                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 161             }
 162             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 163             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 164             if (cmd->bufLen < payloadOffset + 4)
 165             {
 166                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 167             }
 168             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 169
 170             wasHandled = emberAfNetworkCommissioningClusterAddWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 171             break;
 172         }
 173         case ZCL_DISABLE_NETWORK_COMMAND_ID: {
 174             uint16_t payloadOffset = cmd->payloadStartIndex;
 175             chip::ByteSpan networkID;
 176             uint64_t breadcrumb;
 177             uint32_t timeoutMs;
 178
 179             if (cmd->bufLen < payloadOffset + 1u)
 180             {
 181                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 182             }
 183             {
 184                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 185                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 186             }
 187             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
 188             if (cmd->bufLen < payloadOffset + 8)
 189             {
 190                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 191             }
 192             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 193             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 194             if (cmd->bufLen < payloadOffset + 4)
 195             {
 196                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 197             }
 198             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 199
 200             wasHandled = emberAfNetworkCommissioningClusterDisableNetworkCallback(networkID, breadcrumb, timeoutMs);
 201             break;
 202         }
 203         case ZCL_ENABLE_NETWORK_COMMAND_ID: {
 204             uint16_t payloadOffset = cmd->payloadStartIndex;
 205             chip::ByteSpan networkID;
 206             uint64_t breadcrumb;
 207             uint32_t timeoutMs;
 208
 209             if (cmd->bufLen < payloadOffset + 1u)
 210             {
 211                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 212             }
 213             {
 214                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 215                 networkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 216             }
 217             payloadOffset = static_cast<uint16_t>(payloadOffset + networkID.size() + 1u);
 218             if (cmd->bufLen < payloadOffset + 8)
 219             {
 220                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 221             }
 222             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 223             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 224             if (cmd->bufLen < payloadOffset + 4)
 225             {
 226                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 227             }
 228             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 229
 230             wasHandled = emberAfNetworkCommissioningClusterEnableNetworkCallback(networkID, breadcrumb, timeoutMs);
 231             break;
 232         }
 233         case ZCL_GET_LAST_NETWORK_COMMISSIONING_RESULT_COMMAND_ID: {
 234             uint16_t payloadOffset = cmd->payloadStartIndex;
 235             uint32_t timeoutMs;
 236
 237             if (cmd->bufLen < payloadOffset + 4)
 238             {
 239                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 240             }
 241             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 242
 243             wasHandled = emberAfNetworkCommissioningClusterGetLastNetworkCommissioningResultCallback(timeoutMs);
 244             break;
 245         }
 246         case ZCL_REMOVE_NETWORK_COMMAND_ID: {
 247             uint16_t payloadOffset = cmd->payloadStartIndex;
 248             chip::ByteSpan NetworkID;
 249             uint64_t Breadcrumb;
 250             uint32_t TimeoutMs;
 251
 252             if (cmd->bufLen < payloadOffset + 1u)
 253             {
 254                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 255             }
 256             {
 257                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 258                 NetworkID         = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 259             }
 260             payloadOffset = static_cast<uint16_t>(payloadOffset + NetworkID.size() + 1u);
 261             if (cmd->bufLen < payloadOffset + 8)
 262             {
 263                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 264             }
 265             Breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 266             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 267             if (cmd->bufLen < payloadOffset + 4)
 268             {
 269                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 270             }
 271             TimeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 272
 273             wasHandled = emberAfNetworkCommissioningClusterRemoveNetworkCallback(NetworkID, Breadcrumb, TimeoutMs);
 274             break;
 275         }
 276         case ZCL_SCAN_NETWORKS_COMMAND_ID: {
 277             uint16_t payloadOffset = cmd->payloadStartIndex;
 278             chip::ByteSpan ssid;
 279             uint64_t breadcrumb;
 280             uint32_t timeoutMs;
 281
 282             if (cmd->bufLen < payloadOffset + 1u)
 283             {
 284                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 285             }
 286             {
 287                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 288                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 289             }
 290             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 291             if (cmd->bufLen < payloadOffset + 8)
 292             {
 293                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 294             }
 295             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 296             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 297             if (cmd->bufLen < payloadOffset + 4)
 298             {
 299                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 300             }
 301             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 302
 303             wasHandled = emberAfNetworkCommissioningClusterScanNetworksCallback(ssid, breadcrumb, timeoutMs);
 304             break;
 305         }
 306         case ZCL_UPDATE_THREAD_NETWORK_COMMAND_ID: {
 307             uint16_t payloadOffset = cmd->payloadStartIndex;
 308             chip::ByteSpan operationalDataset;
 309             uint64_t breadcrumb;
 310             uint32_t timeoutMs;
 311
 312             if (cmd->bufLen < payloadOffset + 1u)
 313             {
 314                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 315             }
 316             {
 317                 uint8_t * rawData  = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 318                 operationalDataset = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 319             }
 320             payloadOffset = static_cast<uint16_t>(payloadOffset + operationalDataset.size() + 1u);
 321             if (cmd->bufLen < payloadOffset + 8)
 322             {
 323                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 324             }
 325             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 326             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 327             if (cmd->bufLen < payloadOffset + 4)
 328             {
 329                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 330             }
 331             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 332
 333             wasHandled = emberAfNetworkCommissioningClusterUpdateThreadNetworkCallback(operationalDataset, breadcrumb, timeoutMs);
 334             break;
 335         }
 336         case ZCL_UPDATE_WI_FI_NETWORK_COMMAND_ID: {
 337             uint16_t payloadOffset = cmd->payloadStartIndex;
 338             chip::ByteSpan ssid;
 339             chip::ByteSpan credentials;
 340             uint64_t breadcrumb;
 341             uint32_t timeoutMs;
 342
 343             if (cmd->bufLen < payloadOffset + 1u)
 344             {
 345                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 346             }
 347             {
 348                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 349                 ssid              = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 350             }
 351             payloadOffset = static_cast<uint16_t>(payloadOffset + ssid.size() + 1u);
 352             if (cmd->bufLen < payloadOffset + 1u)
 353             {
 354                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 355             }
 356             {
 357                 uint8_t * rawData = emberAfGetString(cmd->buffer, payloadOffset, cmd->bufLen);
 358                 credentials       = chip::ByteSpan(rawData + 1u, emberAfStringLength(rawData));
 359             }
 360             payloadOffset = static_cast<uint16_t>(payloadOffset + credentials.size() + 1u);
 361             if (cmd->bufLen < payloadOffset + 8)
 362             {
 363                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 364             }
 365             breadcrumb    = emberAfGetInt64u(cmd->buffer, payloadOffset, cmd->bufLen);
 366             payloadOffset = static_cast<uint16_t>(payloadOffset + 8);
 367             if (cmd->bufLen < payloadOffset + 4)
 368             {
 369                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 370             }
 371             timeoutMs = emberAfGetInt32u(cmd->buffer, payloadOffset, cmd->bufLen);
 372
 373             wasHandled = emberAfNetworkCommissioningClusterUpdateWiFiNetworkCallback(ssid, credentials, breadcrumb, timeoutMs);
 374             break;
 375         }
 376         default: {
 377             // Unrecognized command ID, error status will apply.
 378             break;
 379         }
 380         }
 381     }
 382     return status(wasHandled, true, cmd->mfgSpecific);
 383 }