internal.hxx

// dawn/src/proto/wakaama/internal.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include "dawn/proto/wakaama/wakaama.hxx"
 
extern "C"
{
#include <liblwm2m.h>
}
 
#include <cstddef>
#include <cstdint>
 
namespace dawn
{
namespace wakaama_internal
{
constexpr size_t WAKAAMA_SECURITY_URI_CAP = CProtoWakaama::RX_BUFFER_SIZE;
 
constexpr size_t WAKAAMA_SECURITY_CREDENTIAL_CAP = CProtoWakaama::RX_BUFFER_SIZE;
 
constexpr uint32_t WAKAAMA_SERVER_EXT_MAGIC = 0x574b4131; // WKA1
 
constexpr uint32_t WAKAAMA_SERVER_FLAG_COAPS = (1 << 0);
 
constexpr uint32_t WAKAAMA_SERVER_FLAG_BOOTSTRAP = (1 << 16);
 
constexpr unsigned int WAKAAMA_SERVER_FLAG_SECURITY_SHIFT = 8;
 
constexpr unsigned int WAKAAMA_SERVER_FLAG_SECURITY_MASK = 0xff;
 
struct security_instance_s
{
  security_instance_s *next;
  uint16_t id;
  const char *uri;
  const uint8_t *publicIdentity;
  size_t publicIdentityLen;
  const uint8_t *secretKey;
  size_t secretKeyLen;
  uint16_t shortServerId;
  uint32_t holdoff;
  uint32_t bootstrapTimeout;
  uint8_t securityMode;
  bool bootstrap;
  bool allocated;
  char uriBuffer[WAKAAMA_SECURITY_URI_CAP];
  uint8_t publicIdentityBuffer[WAKAAMA_SECURITY_CREDENTIAL_CAP];
  uint8_t secretKeyBuffer[WAKAAMA_SECURITY_CREDENTIAL_CAP];
};
 
struct server_instance_s
{
  server_instance_s *next;
  uint16_t id;
  uint16_t shortServerId;
  uint32_t lifetime;
  uint32_t defaultMinPeriod;
  uint32_t defaultMaxPeriod;
  uint32_t disableTimeout;
  uint32_t initialRegistrationDelay;
  uint32_t communicationRetryTimer;
  uint32_t communicationSequenceDelayTimer;
  uint16_t registrationOrder;
  uint8_t communicationRetryCount;
  uint8_t communicationSequenceRetryCount;
  bool storing;
  bool registrationFailureBlock;
  bool bootstrapOnRegistrationFailure;
  bool muteSend;
  bool allocated;
  char binding[4];
  char preferredTransport[4];
};
 
struct device_instance_s
{
  device_instance_s *next;
  uint16_t id;
};
 
struct InstancePools
{
  security_instance_s *security;
  server_instance_s *server;
  size_t securityCapacity;
  size_t serverCapacity;
};
 
security_instance_s *allocateSecurityInstance(InstancePools *pools);
 
void releaseSecurityInstance(security_instance_s *inst);
 
server_instance_s *allocateServerInstance(InstancePools *pools);
 
void releaseServerInstance(server_instance_s *inst);
 
bool assignSecurityString(security_instance_s &inst, const uint8_t *src, size_t len);
 
bool assignSecurityBuffer(const uint8_t *src,
                          size_t len,
                          uint8_t *buffer,
                          size_t capacity,
                          const uint8_t **dst,
                          size_t *dstLen);
 
uint8_t securityRead(lwm2m_context_t *ctx,
                     uint16_t instanceId,
                     int *numData,
                     lwm2m_data_t **dataArray,
                     lwm2m_object_t *object);
 
uint8_t securityDiscover(lwm2m_context_t *ctx,
                         uint16_t instanceId,
                         int *numData,
                         lwm2m_data_t **dataArray,
                         lwm2m_object_t *object);
#ifdef CONFIG_WAKAAMA_BOOTSTRAP
uint8_t securityWrite(lwm2m_context_t *ctx,
                      uint16_t instanceId,
                      int numData,
                      lwm2m_data_t *dataArray,
                      lwm2m_object_t *object,
                      lwm2m_write_type_t writeType);
 
uint8_t securityCreate(lwm2m_context_t *ctx,
                       uint16_t instanceId,
                       int numData,
                       lwm2m_data_t *dataArray,
                       lwm2m_object_t *object);
 
uint8_t securityDelete(lwm2m_context_t *ctx, uint16_t instanceId, lwm2m_object_t *object);
#endif
 
uint8_t serverRead(lwm2m_context_t *ctx,
                   uint16_t instanceId,
                   int *numData,
                   lwm2m_data_t **dataArray,
                   lwm2m_object_t *object);
 
uint8_t serverDiscover(lwm2m_context_t *ctx,
                       uint16_t instanceId,
                       int *numData,
                       lwm2m_data_t **dataArray,
                       lwm2m_object_t *object);
 
uint8_t serverExecute(lwm2m_context_t *ctx,
                      uint16_t instanceId,
                      uint16_t resourceId,
                      uint8_t *buffer,
                      int length,
                      lwm2m_object_t *object);
 
uint8_t serverWrite(lwm2m_context_t *ctx,
                    uint16_t instanceId,
                    int numData,
                    lwm2m_data_t *dataArray,
                    lwm2m_object_t *object,
                    lwm2m_write_type_t writeType);
#ifdef CONFIG_WAKAAMA_BOOTSTRAP
uint8_t serverCreate(lwm2m_context_t *ctx,
                     uint16_t instanceId,
                     int numData,
                     lwm2m_data_t *dataArray,
                     lwm2m_object_t *object);
 
uint8_t serverDelete(lwm2m_context_t *ctx, uint16_t instanceId, lwm2m_object_t *object);
#endif
 
uint8_t deviceRead(lwm2m_context_t *ctx,
                   uint16_t instanceId,
                   int *numData,
                   lwm2m_data_t **dataArray,
                   lwm2m_object_t *object);
 
uint8_t deviceDiscover(lwm2m_context_t *ctx,
                       uint16_t instanceId,
                       int *numData,
                       lwm2m_data_t **dataArray,
                       lwm2m_object_t *object);
 
void deviceResolveBatteryBindings(CProtoWakaama *proto);
 
} // namespace wakaama_internal
} // namespace dawn