lssb_minimal_all.c

Go to the documentation of this file.

/*
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 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 DOXYGEN
// Force doxygen to document static inline
#define STATIC static
#endif
 
#define _WIN32_WINNT 0x8000
#include "oc_api.h"
#include "oc_core_res.h"
#include "api/oc_knx_fp.h"
#include "port/oc_clock.h"
#include <signal.h>
// test purpose only
#include "api/oc_knx_dev.h"
#ifdef OC_SPAKE
#include "security/oc_spake2plus.h"
#endif
#ifdef INCLUDE_EXTERNAL
/* import external definitions from header file*/
/* this file should be externally supplied */
#include "external_header.h"
#endif
 
#ifdef __linux__
#include <pthread.h>
#ifndef NO_MAIN
static pthread_mutex_t mutex;
static pthread_cond_t cv;
static struct timespec ts;
#endif /* NO_MAIN */
#endif
 
#include <stdio.h> /* defines FILENAME_MAX */
 
#define MY_NAME "Sensor (LSSB) 421.61" 
#ifdef WIN32
#include <windows.h>
STATIC CONDITION_VARIABLE cv; 
STATIC CRITICAL_SECTION cs;   
#include <direct.h>
#define GetCurrentDir _getcwd
#else
#include <unistd.h>
#define GetCurrentDir getcwd
#endif
 
#define btoa(x) ((x) ? "true" : "false")
 
bool g_mystate = false; 
volatile int quit = 0;  
bool g_reset = false;   
void
oc_add_s_mode_response_cb(char *url, oc_rep_t *rep, oc_rep_t *rep_value)
{
  (void)rep;
  (void)rep_value;
 
  PRINT("oc_add_s_mode_response_cb %s\n", url);
}
 
int
app_init(void)
{
  int ret = oc_init_platform("Cascoda", NULL, NULL);
 
  /* set the application name, version, base url, device serial number */
  ret |= oc_add_device(MY_NAME, "1.0.0", "//", "00FA10010401", NULL, NULL);
 
  oc_device_info_t *device = oc_core_get_device_info(0);
  PRINT("Serial Number: %s\n", oc_string_checked(device->serialnumber));
 
  /* set the hardware version 1.0.0 */
  oc_core_set_device_hwv(0, 1, 0, 0);
 
  /* set the firmware version 1.0.0 */
  oc_core_set_device_fwv(0, 1, 0, 0);
 
  /* set the hardware type*/
  oc_core_set_device_hwt(0, "Pi");
 
  /* set the model */
  oc_core_set_device_model(0, "my model");
 
  /* set the application info*/
  oc_core_set_device_ap(0, 1, 0, 0);
 
  /* set the manufacturer info*/
  oc_core_set_device_mid(0, 12);
 
  oc_set_s_mode_response_cb(oc_add_s_mode_response_cb);
 
#ifdef OC_SPAKE
#define PASSWORD "LETTUCE"
  oc_spake_set_password(PASSWORD);
  PRINT(" SPAKE password %s\n", PASSWORD);
#endif
  return ret;
}
 
STATIC void
get_o_1_1(oc_request_t *request, oc_interface_mask_t interfaces,
          void *user_data)
{
  (void)user_data; /* variable not used */
 
  /* TODO: SENSOR add here the code to talk to the HW if one implements a
     sensor. the call to the HW needs to fill in the global variable before it
     returns to this function here. alternative is to have a callback from the
     hardware that sets the global variables.
  */
  bool error_state = false; /* the error state, the generated code */
  int oc_status_code = OC_STATUS_OK;
 
  PRINT("-- Begin get_dpa_421_61: interface %d\n", interfaces);
  /* check if the accept header is CBOR */
  if (oc_check_accept_header(request, APPLICATION_CBOR) == false) {
    oc_send_response_no_format(request, OC_STATUS_BAD_OPTION);
    return;
  }
 
  // check the query parameter m with the various values
  char *m;
  char *m_key;
  size_t m_key_len;
  size_t m_len = (int)oc_get_query_value(request, "m", &m);
  if (m_len != -1) {
    PRINT("  Query param: %.*s", (int)m_len, m);
    oc_init_query_iterator();
    size_t device_index = request->resource->device;
    oc_device_info_t *device = oc_core_get_device_info(device_index);
    if (device != NULL) {
      oc_rep_begin_root_object();
      while (oc_iterate_query(request, &m_key, &m_key_len, &m, &m_len) != -1) {
        // unique identifier
        if ((strncmp(m, "id", m_len) == 0) | (strncmp(m, "*", m_len) == 0)) {
          char mystring[100];
          snprintf(mystring, 99, "urn:knx:sn:%s%s",
                   oc_string(device->serialnumber),
                   oc_string(request->resource->uri));
          oc_rep_i_set_text_string(root, 0, mystring);
        }
        // resource types
        if ((strncmp(m, "rt", m_len) == 0) | (strncmp(m, "*", m_len) == 0)) {
          oc_rep_set_text_string(root, rt, "urn:knx:dpa.421.6");
        }
        // interfaces
        if ((strncmp(m, "if", m_len) == 0) | (strncmp(m, "*", m_len) == 0)) {
          oc_rep_set_text_string(root, if, "if.s");
        }
        if ((strncmp(m, "dpt", m_len) == 0) | (strncmp(m, "*", m_len) == 0)) {
          oc_rep_set_text_string(root, dpt, oc_string(request->resource->dpt));
        }
        // ga
        if ((strncmp(m, "ga", m_len) == 0) | (strncmp(m, "*", m_len) == 0)) {
          int index = oc_core_find_group_object_table_url(
            oc_string(request->resource->uri));
          if (index > -1) {
            oc_group_object_table_t *got_table_entry =
              oc_core_get_group_object_table_entry(index);
            if (got_table_entry) {
              oc_rep_set_int_array(root, ga, got_table_entry->ga,
                                   got_table_entry->ga_len);
            }
          }
        }
      } /* query iterator */
      oc_rep_end_root_object();
    } else {
      /* device is NULL */
      oc_send_response_no_format(request, OC_STATUS_BAD_OPTION);
    }
    oc_send_cbor_response(request, OC_STATUS_OK);
    return;
  }
 
  CborError error;
  oc_rep_begin_root_object();
  oc_rep_i_set_boolean(root, 1, g_mystate);
  oc_rep_end_root_object();
  error = g_err;
 
  if (error) {
    oc_status_code = true;
  }
  PRINT("CBOR encoder size %d\n", oc_rep_get_encoded_payload_size());
 
  if (error_state == false) {
    oc_send_cbor_response(request, oc_status_code);
  } else {
    oc_send_response_no_format(request, OC_STATUS_BAD_OPTION);
  }
  PRINT("-- End get_dpa_421_61\n");
}
 
void
register_resources(void)
{
  PRINT("Register Resource with local path \"/p/o_1_1\"\n");
  PRINT("Light Switching Sensor 421.61 (LSSB) : SwitchOnOff \n");
  PRINT("Data point 61 (DPT_Switch) \n");
  PRINT("Register Resource with local path \"/p/o_1_1\"\n");
 
  oc_resource_t *res_pushbutton =
    oc_new_resource("push button", "/p/o_1_1", 2, 0);
  oc_resource_bind_resource_type(res_pushbutton, "urn:knx:dpa.421.61");
  oc_resource_bind_dpt(res_pushbutton, "urn:knx:dpt.Switch");
  oc_resource_bind_content_type(res_pushbutton, APPLICATION_CBOR);
  oc_resource_bind_resource_interface(res_pushbutton, OC_IF_S); /* if.s */
  oc_resource_set_discoverable(res_pushbutton, true);
  /* periodic observable
     to be used when one wants to send an event per time slice
     period is 1 second */
  // oc_resource_set_periodic_observable(res_pushbutton, 1);
  /* set observable
     events are send when oc_notify_observers(oc_resource_t *resource) is
    called. this function must be called when the value changes, preferable on
    an interrupt when something is read from the hardware. */
  /*oc_resource_set_observable(res_352, true); */
  oc_resource_set_request_handler(res_pushbutton, OC_GET, get_o_1_1, NULL);
  oc_add_resource(res_pushbutton);
}
 
void
factory_presets_cb(size_t device_index, void *data)
{
  (void)device_index;
  (void)data;
 
  if (g_reset) {
    PRINT("factory_presets_cb: resetting device\n");
    oc_knx_device_storage_reset(0, 2);
  }
}
 
void
reset_cb(size_t device_index, int reset_value, void *data)
{
  (void)device_index;
 
  PRINT("reset_cb %d\n", reset_value);
}
 
void
restart_cb(size_t device_index, void *data)
{
  (void)device_index;
  (void)data;
 
  PRINT("-----restart_cb -------\n");
  // exit(0);
}
 
void
hostname_cb(size_t device_index, oc_string_t host_name, void *data)
{
  (void)device_index;
  (void)data;
 
  PRINT("-----host name ------- %s\n", oc_string_checked(host_name));
}
 
static oc_event_callback_retval_t
send_delayed_response(void *context)
{
  oc_separate_response_t *response = (oc_separate_response_t *)context;
 
  if (response->active) {
    oc_set_separate_response_buffer(response);
    oc_send_separate_response(response, OC_STATUS_CHANGED);
    PRINT("Delayed response sent\n");
  } else {
    PRINT("Delayed response NOT active\n");
  }
 
  return OC_EVENT_DONE;
}
 
void
swu_cb(size_t device, oc_separate_response_t *response, size_t binary_size,
       size_t offset, uint8_t *payload, size_t len, void *data)
{
  (void)device;
  (void)binary_size;
  char filename[] = "./downloaded.bin";
  PRINT(" swu_cb %s block=%d size=%d \n", filename, (int)offset, (int)len);
 
  FILE *write_ptr = fopen("downloaded_bin", "ab");
  size_t r = fwrite(payload, sizeof(*payload), len, write_ptr);
  fclose(write_ptr);
 
  oc_set_delayed_callback(response, &send_delayed_response, 0);
}
 
void
initialize_variables(void)
{
  /* initialize global variables for resources */
  /* if wanted read them from persistent storage */
}
 
static void
issue_requests_s_mode(void)
{
  PRINT("issue_requests_s_mode: Demo \n\n");
 
  oc_do_s_mode_with_scope(2, "p/o_1_1", "w");
  oc_do_s_mode_with_scope(5, "p/o_1_1", "w");
}
 
#ifndef NO_MAIN
#ifdef WIN32
STATIC void
signal_event_loop(void)
{
  WakeConditionVariable(&cv);
}
#endif /* WIN32 */
 
#ifdef __linux__
STATIC void
signal_event_loop(void)
{
  pthread_mutex_lock(&mutex);
  pthread_cond_signal(&cv);
  pthread_mutex_unlock(&mutex);
}
#endif /* __linux__ */
 
void
handle_signal(int signal)
{
  (void)signal;
  signal_event_loop();
  quit = 1;
}
 
void
print_usage()
{
  PRINT("Usage:\n");
  PRINT("no arguments : starts the server\n");
  PRINT("-help  : this message\n");
  PRINT("s-mode : starts the server and issue a s-mode message at start up "
        "according the application/config\n");
  PRINT("reset  : does an full reset of the device\n");
  exit(0);
}
 
int
main(int argc, char *argv[])
{
  int init;
  oc_clock_time_t next_event;
  bool do_send_s_mode = false;
  char *fname = "my_software_image";
 
#ifdef WIN32
  /* windows specific */
  InitializeCriticalSection(&cs);
  InitializeConditionVariable(&cv);
  /* install Ctrl-C */
  signal(SIGINT, handle_signal);
#endif
#ifdef __linux__
  /* Linux specific */
  struct sigaction sa;
  sigfillset(&sa.sa_mask);
  sa.sa_flags = 0;
  sa.sa_handler = handle_signal;
  /* install Ctrl-C */
  sigaction(SIGINT, &sa, NULL);
#endif
 
  for (int i = 0; i < argc; i++) {
    PRINT("argv[%d] = %s\n", i, argv[i]);
  }
  if (argc > 1) {
    PRINT("s-mode: %s\n", argv[1]);
    if (strcmp(argv[1], "s-mode") == 0) {
      do_send_s_mode = true;
    }
    if (strcmp(argv[1], "reset") == 0) {
      PRINT(" internal reset\n");
      g_reset = true;
    }
    if (strcmp(argv[1], "-help") == 0) {
      print_usage();
    }
  }
 
  PRINT("KNX-IOT Server name : \"%s\"\n", MY_NAME);
 
  // show the current working folder
  char buff[FILENAME_MAX];
  char *retbuf = NULL;
  retbuf = GetCurrentDir(buff, FILENAME_MAX);
  if (retbuf != NULL) {
    PRINT("Current working dir: %s\n", buff);
  }
 
  /*
   The storage folder depends on the build system
   the folder is created in the makefile, with $target as name with _cred as
   post fix.
  */
  PRINT("\tstorage at './LSSB_minimal_all_creds' \n");
  oc_storage_config("./LSSB_minimal_all_creds");
 
  /*initialize the variables */
  initialize_variables();
 
  /* initializes the handlers structure */
  STATIC oc_handler_t handler = { .init = app_init,
                                  .signal_event_loop = signal_event_loop,
                                  .register_resources = register_resources,
                                  .requests_entry = NULL };
 
  if (do_send_s_mode) {
 
    handler.requests_entry = issue_requests_s_mode;
  }
 
  /* set the application callbacks */
  oc_set_hostname_cb(hostname_cb, NULL);
  oc_set_reset_cb(reset_cb, NULL);
  oc_set_restart_cb(restart_cb, NULL);
  oc_set_factory_presets_cb(factory_presets_cb, NULL);
  oc_set_swu_cb(swu_cb, (void *)fname);
 
  /* start the stack */
  init = oc_main_init(&handler);
 
  if (init < 0) {
    PRINT("oc_main_init failed %d, exiting.\n", init);
    return init;
  }
 
#ifdef OC_OSCORE
  PRINT("OSCORE - Enabled\n");
#else
  PRINT("OSCORE - Disabled\n");
#endif /* OC_OSCORE */
 
  oc_device_info_t *device = oc_core_get_device_info(0);
  PRINT("serial number: %s\n", oc_string_checked(device->serialnumber));
 
  oc_endpoint_t *my_ep = oc_connectivity_get_endpoints(0);
  if (my_ep != NULL) {
    PRINTipaddr(*my_ep);
    PRINT("\n");
  }
  PRINT("Server \"%s\" running, waiting on incoming "
        "connections.\n",
        MY_NAME);
 
#ifdef WIN32
  /* windows specific loop */
  while (quit != 1) {
    next_event = oc_main_poll();
    if (next_event == 0) {
      SleepConditionVariableCS(&cv, &cs, INFINITE);
    } else {
      oc_clock_time_t now = oc_clock_time();
      if (now < next_event) {
        SleepConditionVariableCS(
          &cv, &cs, (DWORD)((next_event - now) * 1000 / OC_CLOCK_SECOND));
      }
    }
  }
#endif
 
#ifdef __linux__
  /* Linux specific loop */
  while (quit != 1) {
    next_event = oc_main_poll();
    pthread_mutex_lock(&mutex);
    if (next_event == 0) {
      pthread_cond_wait(&cv, &mutex);
    } else {
      ts.tv_sec = (next_event / OC_CLOCK_SECOND);
      ts.tv_nsec = (next_event % OC_CLOCK_SECOND) * 1.e09 / OC_CLOCK_SECOND;
      pthread_cond_timedwait(&cv, &mutex, &ts);
    }
    pthread_mutex_unlock(&mutex);
  }
#endif
 
  /* shut down the stack */
 
  oc_main_shutdown();
  return 0;
}
#endif /* NO_MAIN */