oc_api.h

Go to the documentation of this file.

/*
// Copyright (c) 2016-2019 Intel Corporation
// Copyright (c) 2021-2022 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_API_H
#define OC_API_H
 
#include "messaging/coap/oc_coap.h"
#include "oc_buffer_settings.h"
#include "oc_knx.h"
#include "oc_rep.h"
#include "oc_ri.h"
#include "oc_client_state.h"
#include "oc_signal_event_loop.h"
#include "port/oc_storage.h"
#include "api/oc_knx_client.h"
#include "api/oc_knx_swu.h"
 
#include "oc_programming_mode.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define OC_MAX_URL_LENGTH (30)
 
typedef struct
{
  int (*init)(void);
 
  void (*signal_event_loop)(void);
 
#ifdef OC_SERVER
  void (*register_resources)(void);
#endif /* OC_SERVER */
 
#ifdef OC_CLIENT
  void (*requests_entry)(void);
#endif /* OC_CLIENT */
} oc_handler_t;
 
typedef void (*oc_init_platform_cb_t)(void *data);
 
typedef void (*oc_add_device_cb_t)(void *data);
 
int oc_main_init(const oc_handler_t *handler);
 
oc_clock_time_t oc_main_poll(void);
 
void oc_main_shutdown(void);
 
typedef void (*oc_factory_presets_cb_t)(size_t device, void *data);
 
void oc_set_factory_presets_cb(oc_factory_presets_cb_t cb, void *data);
 
typedef void (*oc_reset_cb_t)(size_t device, int reset_value, void *data);
 
void oc_set_reset_cb(oc_reset_cb_t cb, void *data);
 
typedef void (*oc_restart_cb_t)(size_t device, void *data);
 
void oc_set_restart_cb(oc_restart_cb_t cb, void *data);
 
typedef void (*oc_hostname_cb_t)(size_t device, oc_string_t host_name,
                                 void *data);
 
void oc_set_hostname_cb(oc_hostname_cb_t cb, void *data);
 
typedef void (*oc_programming_mode_cb_t)(size_t device, bool programming_mode,
                                         void *data);
 
void oc_set_programming_mode_cb(oc_programming_mode_cb_t cb, void *data);
 
int oc_add_device(const char *name, const char *version, const char *base,
                  const char *serial_number, oc_add_device_cb_t add_device_cb,
                  void *data);
 
#define oc_set_custom_device_property(prop, value)                             \
  oc_rep_set_text_string(root, prop, value)
 
int oc_init_platform(const char *mfg_name,
                     oc_init_platform_cb_t init_platform_cb, void *data);
 
#define oc_set_custom_platform_property(prop, value)                           \
  oc_rep_set_text_string(root, prop, value)
 
/* Server side */
oc_resource_t *oc_new_resource(const char *name, const char *uri,
                               uint8_t num_resource_types, size_t device);
 
void oc_resource_bind_resource_interface(oc_resource_t *resource,
                                         oc_interface_mask_t iface_mask);
 
void oc_resource_bind_resource_type(oc_resource_t *resource, const char *type);
 
void oc_resource_bind_content_type(oc_resource_t *resource,
                                   oc_content_format_t content_type);
 
void oc_resource_bind_dpt(oc_resource_t *resource, const char *dpt);
 
void oc_resource_make_public(oc_resource_t *resource);
 
void oc_resource_set_discoverable(oc_resource_t *resource, bool state);
 
void oc_resource_set_observable(oc_resource_t *resource, bool state);
 
void oc_resource_set_periodic_observable(oc_resource_t *resource,
                                         uint16_t seconds);
 
void oc_resource_set_request_handler(oc_resource_t *resource,
                                     oc_method_t method,
                                     oc_request_callback_t callback,
                                     void *user_data);
 
void oc_resource_set_properties_cbs(oc_resource_t *resource,
                                    oc_get_properties_cb_t get_properties,
                                    void *get_props_user_data,
                                    oc_set_properties_cb_t set_properties,
                                    void *set_props_user_data);
 
void oc_resource_set_function_block_instance(oc_resource_t *resource,
                                             uint8_t instance);
 
bool oc_add_resource(oc_resource_t *resource);
 
bool oc_delete_resource(oc_resource_t *resource);
 
void oc_delayed_delete_resource(oc_resource_t *resource);
 
void oc_init_query_iterator(void);
 
int oc_iterate_query(oc_request_t *request, char **key, size_t *key_len,
                     char **value, size_t *value_len);
 
bool oc_iterate_query_get_values(oc_request_t *request, const char *key,
                                 char **value, int *value_len);
 
int oc_get_query_value(oc_request_t *request, const char *key, char **value);
 
int oc_query_value_exists(oc_request_t *request, const char *key);
 
bool oc_query_values_available(oc_request_t *request);
 
void oc_send_response(oc_request_t *request, oc_status_t response_code);
 
void oc_send_cbor_response(oc_request_t *request, oc_status_t response_code);
 
void oc_send_cbor_response_with_payload_size(oc_request_t *request,
                                             oc_status_t response_code,
                                             size_t payload_size);
 
void oc_send_json_response(oc_request_t *request, oc_status_t response_code);
 
void oc_send_linkformat_response(oc_request_t *request,
                                 oc_status_t response_code,
                                 size_t response_length);
 
void oc_send_response_no_format(oc_request_t *request,
                                oc_status_t response_code);
 
bool oc_get_request_payload_raw(oc_request_t *request, const uint8_t **payload,
                                size_t *size,
                                oc_content_format_t *content_format);
 
void oc_send_response_raw(oc_request_t *request, const uint8_t *payload,
                          size_t size, oc_content_format_t content_format,
                          oc_status_t response_code);
 
bool oc_get_response_payload_raw(oc_client_response_t *response,
                                 const uint8_t **payload, size_t *size,
                                 oc_content_format_t *content_format);
 
void oc_send_diagnostic_message(oc_request_t *request, const char *msg,
                                size_t msg_len, oc_status_t response_code);
 
bool oc_get_diagnostic_message(oc_client_response_t *response, const char **msg,
                               size_t *size);
 
void oc_ignore_request(oc_request_t *request);
 
void oc_indicate_separate_response(oc_request_t *request,
                                   oc_separate_response_t *response);
 
void oc_set_separate_response_buffer(oc_separate_response_t *handle);
 
void oc_send_separate_response(oc_separate_response_t *handle,
                               oc_status_t response_code);
 
void oc_send_empty_separate_response(oc_separate_response_t *handle,
                                     oc_status_t response_code);
 
int oc_notify_observers(const oc_resource_t *resource);
 
#ifdef __cplusplus
}
#endif // end of doc_module_tag_server_side
 
#include "oc_client_state.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
bool oc_do_wk_discovery_all(const char *uri_query, int scope,
                            oc_discovery_all_handler_t handler,
                            void *user_data);
 
int oc_lf_number_of_entries(const char *payload, int payload_len);
 
int oc_lf_get_entry_uri(const char *payload, int payload_len, int entry,
                        const char **uri, int *uri_len);
 
int oc_lf_get_entry_param(const char *payload, int payload_len, int entry,
                          const char *param, const char **p_out, int *p_len);
 
bool oc_do_get(const char *uri, oc_endpoint_t *endpoint, const char *query,
               oc_response_handler_t handler, oc_qos_t qos, void *user_data);
 
bool oc_do_get_ex(const char *uri, oc_endpoint_t *endpoint, const char *query,
                  oc_response_handler_t handler, oc_qos_t qos,
                  oc_content_format_t content, oc_content_format_t accept,
                  void *user_data);
 
bool oc_do_delete(const char *uri, oc_endpoint_t *endpoint, const char *query,
                  oc_response_handler_t handler, oc_qos_t qos, void *user_data);
 
bool oc_init_put(const char *uri, oc_endpoint_t *endpoint, const char *query,
                 oc_response_handler_t handler, oc_qos_t qos, void *user_data);
 
bool oc_do_put(void);
 
bool oc_do_put_ex(oc_content_format_t content, oc_content_format_t accept);
 
bool oc_init_post(const char *uri, oc_endpoint_t *endpoint, const char *query,
                  oc_response_handler_t handler, oc_qos_t qos, void *user_data);
 
bool oc_do_post(void);
 
bool oc_do_post_ex(oc_content_format_t content, oc_content_format_t accept);
 
bool oc_do_observe(const char *uri, oc_endpoint_t *endpoint, const char *query,
                   oc_response_handler_t handler, oc_qos_t qos,
                   void *user_data);
 
bool oc_stop_observe(const char *uri, oc_endpoint_t *endpoint);
 
void oc_stop_multicast(oc_client_response_t *response);
 
bool oc_init_multicast_update(oc_endpoint_t *mcast, const char *uri,
                              const char *query);
 
bool oc_do_multicast_update(void);
 
void oc_free_server_endpoints(oc_endpoint_t *endpoint);
 
void oc_close_session(oc_endpoint_t *endpoint);
 
#ifdef OC_TCP
bool oc_send_ping(bool custody, oc_endpoint_t *endpoint,
                  uint16_t timeout_seconds, oc_response_handler_t handler,
                  void *user_data);
#endif    /* OC_TCP */ // end of doc_module_tag_client_state
 
void oc_set_delayed_callback(void *cb_data, oc_trigger_t callback,
                             uint16_t seconds);
 
void oc_set_delayed_callback_ms(void *cb_data, oc_trigger_t callback,
                                uint16_t miliseconds);
 
void oc_remove_delayed_callback(void *cb_data, oc_trigger_t callback);
 
#define oc_signal_interrupt_handler(name)                                      \
  do {                                                                         \
    oc_process_poll(&(name##_interrupt_x));                                    \
    _oc_signal_event_loop();                                                   \
  } while (0)
 
#define oc_activate_interrupt_handler(name)                                    \
  (oc_process_start(&(name##_interrupt_x), 0))
 
#define oc_define_interrupt_handler(name)                                      \
  void name##_interrupt_x_handler(void);                                       \
  OC_PROCESS(name##_interrupt_x, "");                                          \
  OC_PROCESS_THREAD(name##_interrupt_x, ev, data)                              \
  {                                                                            \
    (void)data;                                                                \
    OC_PROCESS_POLLHANDLER(name##_interrupt_x_handler());                      \
    OC_PROCESS_BEGIN();                                                        \
    while (oc_process_is_running(&(name##_interrupt_x))) {                     \
      OC_PROCESS_YIELD();                                                      \
    }                                                                          \
    OC_PROCESS_END();                                                          \
  }                                                                            \
  void name##_interrupt_x_handler(void) // end of doc_module_tag_common_operations
#ifdef __cplusplus
}
#endif
 
#endif /* OC_API_H */