oc_core_res.h

Go to the documentation of this file.

/*
// Copyright (c) 2016 Intel Corporation
// Copyright (c) 2021 Cascoda Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/
#ifndef OC_CORE_RES_H
#define OC_CORE_RES_H
 
#include "oc_ri.h"
#include "oc_programming_mode.h"
#include "oc_knx.h"
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define OC_CORE_EXTERN_CONST_RESOURCE(resource_name)                           \
  extern const oc_resource_t core_resource_##resource_name;
#define OC_CORE_RESOURCE_NAME(name) core_resource_##name
 
#if defined _MSC_VER && !defined __INTEL_COMPILER
#define OC_CORE_CREATE_CONST_RESOURCE_INTERNAL(                                \
  resource_name, next_resource, device_index, uri, iface_mask, content_format, \
  properties, get_cb, put_cb, post_cb, delete_cb, dpt, num_resource_types,     \
  ...)                                                                         \
  _Pragma("warning(disable:4090)");                                            \
  oc_ri_internal_expand_call(                                                  \
    oc_ri_create_const_resource_internal, core_resource_##next_resource,       \
    core_resource_##resource_name, device_index, NULL, uri, dpt, iface_mask,   \
    content_format, properties, get_cb, put_cb, post_cb, delete_cb, NULL, 0,   \
    0, num_resource_types, __VA_ARGS__) _Pragma("warning(default:4090)")
#else
#define OC_CORE_CREATE_CONST_RESOURCE_INTERNAL(                                \
  resource_name, next_resource, device_index, uri, iface_mask, content_format, \
  properties, get_cb, put_cb, post_cb, delete_cb, dpt, num_resource_types,     \
  ...)                                                                         \
  _Pragma("GCC diagnostic push");                                              \
  _Pragma("GCC diagnostic ignored \"-Wdiscarded-array-qualifiers\"");          \
  oc_ri_create_const_resource_internal(                                        \
    core_resource_##next_resource, core_resource_##resource_name,              \
    device_index, NULL, uri, dpt, iface_mask, content_format, properties,      \
    get_cb, put_cb, post_cb, delete_cb, NULL, 0, 0, num_resource_types,        \
    __VA_ARGS__);                                                              \
  _Pragma("GCC diagnostic pop")
#endif
#if defined _MSC_VER && !defined __INTEL_COMPILER
#define OC_CORE_CREATE_CONST_RESOURCE_LINKED(resource_name, next_resource,     \
                                             ...)                              \
  extern const oc_resource_t core_resource_##next_resource;                    \
  oc_ri_internal_expand_call(OC_CORE_CREATE_CONST_RESOURCE_INTERNAL,           \
                             resource_name, next_resource, __VA_ARGS__)
#else
#define OC_CORE_CREATE_CONST_RESOURCE_LINKED(resource_name, next_resource,     \
                                             ...)                              \
  extern const oc_resource_t core_resource_##next_resource;                    \
  OC_CORE_CREATE_CONST_RESOURCE_INTERNAL(resource_name, next_resource,         \
                                         __VA_ARGS__)
#endif
 
#if defined _MSC_VER && !defined __INTEL_COMPILER
#define OC_CORE_CREATE_CONST_RESOURCE_FINAL(resource_name, ...)                \
  oc_resource_dummy_t core_resource_##resource_name##_final = { NULL, -1 };    \
  oc_ri_internal_expand_call(OC_CORE_CREATE_CONST_RESOURCE_INTERNAL,           \
                             resource_name, resource_name##_final,             \
                             __VA_ARGS__)
#else
#define OC_CORE_CREATE_CONST_RESOURCE_FINAL(resource_name, ...)                \
  oc_resource_dummy_t core_resource_##resource_name##_final = { NULL, -1 };    \
  OC_CORE_CREATE_CONST_RESOURCE_INTERNAL(resource_name, resource_name##_final, \
                                         __VA_ARGS__)
#endif
 
typedef void (*oc_core_init_platform_cb_t)(void *data);
 
typedef void (*oc_core_add_device_cb_t)(void *data);
 
typedef struct oc_platform_info_t
{
  oc_string_t mfg_name;                        
  oc_core_init_platform_cb_t init_platform_cb; 
  void *data; 
} oc_platform_info_t;
 
typedef struct oc_knx_version_info_t
{
  int major; 
  int minor; 
  int patch; 
} oc_knx_version_info_t;
 
typedef struct oc_device_info_t
{
  oc_string_t serialnumber;  
  oc_knx_version_info_t hwv; 
  oc_knx_version_info_t fwv; 
  oc_knx_version_info_t ap;  
  oc_string_t hwt; 
  oc_string_t model;    
  oc_string_t hostname; 
  uint32_t mid;         
  uint64_t fid;         
  uint32_t ia;          
  uint64_t iid;         
  uint32_t port;        
  uint32_t mport;       
  bool pm;              
  oc_lsm_state_t lsm_s; 
  oc_core_add_device_cb_t add_device_cb; 
  void *data;                            
} oc_device_info_t;
 
void oc_core_init(void);
 
void oc_core_shutdown(void);
 
oc_platform_info_t *oc_core_init_platform(const char *mfg_name,
                                          oc_core_init_platform_cb_t init_cb,
                                          void *data);
 
oc_device_info_t *oc_core_add_device(const char *name, const char *version,
                                     const char *base,
                                     const char *serial_number,
                                     oc_core_add_device_cb_t add_device_cb,
                                     void *data);
 
int oc_core_set_device_fwv(size_t device_index, int major, int minor,
                           int patch);
 
int oc_core_set_device_hwv(size_t device_index, int major, int minor,
                           int patch);
int oc_core_set_device_ap(size_t device_index, int major, int minor, int patch);
 
int oc_core_set_device_mid(size_t device_index, uint32_t mid);
 
int oc_core_set_device_ia(size_t device_index, uint32_t ia);
 
int oc_core_set_mid(size_t device_index, int32_t mid);
 
int oc_core_set_and_store_device_ia(size_t device_index, uint32_t ia);
 
int oc_core_set_device_hwt(size_t device_index, const char *hardware_type);
 
int oc_core_set_device_pm(size_t device_index, bool pm);
 
int oc_core_set_device_model(size_t device_index, const char *model);
 
int oc_core_set_device_hostname(size_t device_index, const char *host_name);
 
int oc_core_set_device_iid(size_t device_index, uint64_t iid);
 
int oc_core_set_and_store_device_iid(size_t device_index, uint64_t iid);
 
int oc_core_set_device_fid(size_t device_index, uint64_t fid);
 
uint64_t oc_core_get_device_iid(size_t device_index);
 
size_t oc_core_get_num_devices(void);
 
oc_device_info_t *oc_core_get_device_info(size_t device);
 
oc_platform_info_t *oc_core_get_platform_info(void);
 
void oc_core_encode_interfaces_mask(CborEncoder *parent,
                                    oc_interface_mask_t iface_mask);
 
const oc_resource_t *oc_core_get_resource_by_index(int type, size_t device);
 
const oc_resource_t *oc_core_get_resource_by_uri(const char *uri,
                                                 size_t device);
 
void oc_check_uri(const char *uri);
 
void oc_core_populate_resource(int core_resource, size_t device_index,
                               const char *uri, oc_interface_mask_t iface_mask,
                               oc_content_format_t content_format,
                               int properties, oc_request_callback_t get_cb,
                               oc_request_callback_t put_cb,
                               oc_request_callback_t post_cb,
                               oc_request_callback_t delete_cb,
                               int num_resource_types, ...);
 
void oc_core_bind_dpt_resource(int core_resource, size_t device_index,
                               const char *dpt);
 
int oc_filter_resource_by_urn(const oc_resource_t *resource,
                              oc_request_t *request);
 
bool oc_filter_resource_by_rt(const oc_resource_t *resource,
                              oc_request_t *request);
 
bool oc_filter_resource_by_if(const oc_resource_t *resource,
                              oc_request_t *request);
 
int oc_frame_interfaces_mask_in_response(oc_interface_mask_t iface_mask,
                                         int truncated);
 
#ifdef __cplusplus
}
#endif
 
#endif /* OC_CORE_RES_H */