nsdl_support.cpp

00001 // NSDL library support functions
00002 
00003 #include "mbed.h"
00004 #include "nsdl_support.h"
00005 
00006 #include "mbedConnectorInterface.h"
00007 
00008 // we have to redefine DBG as its used differently here...
00009 #ifdef DBG
00010     #undef DBG
00011 #endif
00012 #define DBG  std::printf
00013 
00014 #include "UDPSocket.h"
00015 #include "Endpoint.h"
00016 
00017 #include "BLEDevice.h"
00018 
00019 #define NSDL_BUFFER_LENGTH  1024
00020 
00021 extern BLEDevice ble;
00022 
00023 Endpoint nsp;
00024 UDPSocket server;
00025 Endpoint from; 
00026 
00027 uint8_t nsp_received_address[4];
00028 char nsp_buffer[NSDL_BUFFER_LENGTH];
00029 
00030 char null_endpoint_name[] = "";
00031 char null_domain[] = "";
00032 uint8_t null_ep_type[] = "";
00033 uint8_t null_lifetime_ptr[] = "";
00034 bool endpoint_registered = false;
00035 
00036 void *nsdl_alloc(uint16_t size) {
00037     void *chunk = NULL;
00038     if (size > 0) chunk = malloc(size);
00039     if (chunk != NULL && size > 0) memset(chunk,0,size);
00040     return chunk;
00041 }
00042 
00043 void nsdl_free(void* ptr_to_free) {
00044     if (ptr_to_free != NULL) free(ptr_to_free);
00045 }
00046 
00047 /*
00048  * Create a static resoure
00049  * Only get is allowed
00050  */
00051 void nsdl_create_static_resource(sn_nsdl_resource_info_s *resource_structure, uint16_t pt_len, uint8_t *pt, uint16_t rpp_len, uint8_t *rpp_ptr, uint8_t *rsc, uint16_t rsc_len)
00052 {
00053     resource_structure->access = SN_GRS_GET_ALLOWED;
00054     resource_structure->mode = SN_GRS_STATIC;
00055     resource_structure->pathlen = pt_len;
00056     resource_structure->path = pt;
00057     resource_structure->resource_parameters_ptr->resource_type_len = rpp_len;
00058     resource_structure->resource_parameters_ptr->resource_type_ptr = rpp_ptr;
00059     resource_structure->resource = rsc;
00060     resource_structure->resourcelen = rsc_len;
00061     sn_nsdl_create_resource(resource_structure);
00062 }
00063 
00064 void nsdl_create_dynamic_resource(sn_nsdl_resource_info_s *resource_structure, uint16_t pt_len, uint8_t *pt, uint16_t rpp_len, uint8_t *rpp_ptr, uint8_t is_observable, sn_grs_dyn_res_callback_t callback_ptr, int access_right)
00065 {
00066     resource_structure->access = (sn_grs_resource_acl_e)access_right;
00067     resource_structure->resource = 0;
00068     resource_structure->resourcelen = 0;
00069     resource_structure->sn_grs_dyn_res_callback = callback_ptr;
00070     resource_structure->mode = SN_GRS_DYNAMIC;
00071     resource_structure->pathlen = pt_len;
00072     resource_structure->path = pt;
00073     resource_structure->resource_parameters_ptr->resource_type_len = rpp_len;
00074     resource_structure->resource_parameters_ptr->resource_type_ptr = rpp_ptr;
00075     resource_structure->resource_parameters_ptr->observable = is_observable;
00076     sn_nsdl_create_resource(resource_structure);
00077 }
00078 
00079 sn_nsdl_ep_parameters_s* nsdl_init_register_endpoint(sn_nsdl_ep_parameters_s *endpoint_structure, uint8_t *domain, uint8_t* name, uint8_t* typename_ptr, uint8_t *lifetime_ptr) {
00080     if (endpoint_structure == NULL) {   
00081         endpoint_structure = (sn_nsdl_ep_parameters_s*)nsdl_alloc(sizeof(sn_nsdl_ep_parameters_s));
00082     }
00083     
00084     if (endpoint_structure != NULL) {
00085         memset(endpoint_structure, 0, sizeof(sn_nsdl_ep_parameters_s));
00086         endpoint_structure->endpoint_name_ptr = name;
00087         endpoint_structure->endpoint_name_len = strlen((char*)name);
00088         endpoint_structure->domain_name_ptr = domain;
00089         endpoint_structure->domain_name_len = strlen((char *)domain);
00090         endpoint_structure->type_ptr = typename_ptr;
00091         endpoint_structure->type_len =  strlen((char*)typename_ptr);
00092         endpoint_structure->lifetime_ptr = lifetime_ptr;
00093         endpoint_structure->lifetime_len =  strlen((char*)lifetime_ptr);
00094     }
00095     
00096     return endpoint_structure;
00097 }
00098 
00099 void nsdl_clean_register_endpoint(sn_nsdl_ep_parameters_s **endpoint_structure) {
00100     if (endpoint_structure != NULL) {
00101         if (*endpoint_structure != NULL) {
00102             nsdl_free(*endpoint_structure);
00103             *endpoint_structure = NULL;
00104         }
00105     }
00106 }
00107 
00108 static uint8_t tx_cb(sn_nsdl_capab_e protocol, uint8_t *data_ptr, uint16_t data_len, sn_nsdl_addr_s *address_ptr) {
00109     //DBG("NSP: tx_cb(): sending %d bytes...\r\n",data_len);
00110     int sent = server.sendTo(nsp,(char*)data_ptr, data_len);
00111     return 1;
00112 }
00113 
00114 static uint8_t rx_cb(sn_coap_hdr_s *coap_packet_ptr, sn_nsdl_addr_s *address_ptr) {
00115     // Rx callback process it...
00116     //DBG("NSP: rx_cb(): received data. processing...\r\n");
00117     return 0;
00118 }
00119 
00120 void register_endpoint(bool init) {
00121     sn_nsdl_ep_parameters_s *endpoint_ptr = NULL;
00122     if (init) {
00123         endpoint_ptr = nsdl_init_register_endpoint(endpoint_ptr, (uint8_t *)domain_name, (uint8_t*)endpoint_name, ep_type, lifetime_ptr);
00124         if(sn_nsdl_register_endpoint(endpoint_ptr) != 0) {
00125             DBG("NSP initial registration failed\r\n");
00126             endpoint_registered = false;
00127         }
00128         else {
00129             //DBG("NSP initial registration OK\r\n");
00130             endpoint_registered = true;
00131         }
00132     }
00133     else {
00134         endpoint_ptr = nsdl_init_register_endpoint(endpoint_ptr, (uint8_t *)null_domain, (uint8_t*)null_endpoint_name, null_ep_type, null_lifetime_ptr);
00135         if(sn_nsdl_update_registration(endpoint_ptr) != 0) {
00136             //DBG("NSP re-registration failed\r\n");
00137             endpoint_registered = false;
00138         }
00139         else {
00140             //DBG("NSP re-registration OK\r\n");
00141             endpoint_registered = true;
00142         }
00143     }
00144     nsdl_clean_register_endpoint(&endpoint_ptr);
00145 }
00146 
00147 bool nsdl_endpoint_is_registered(void) {
00148     return endpoint_registered;
00149 }
00150 
00151 // Simple Ticker-based re-registration updating... 
00152 void registration_update_tick(void) {
00153     register_endpoint(!endpoint_registered);
00154 }
00155 
00156 void nsdl_init() {    
00157     sn_nsdl_mem_s memory_cbs;
00158     
00159     // initilize the UDP channel
00160     server.init();
00161     server.bind(nsp_port);
00162     
00163     /* Initialize libNsdl */
00164     memset(&memory_cbs,0,sizeof(memory_cbs));
00165     memory_cbs.sn_nsdl_alloc = &nsdl_alloc;
00166     memory_cbs.sn_nsdl_free = &nsdl_free;
00167     if(sn_nsdl_init(&tx_cb, &rx_cb, &memory_cbs) == -1) {
00168         DBG("NSP: libNsdl init failed.\r\n");
00169     }
00170     else {
00171         DBG("NSP: libNsdl init successful.\r\n");
00172     }
00173 }
00174 
00175 void nsdl_set_nsp_address(void) {
00176     char NSP_address_str[16];
00177     
00178     /* Set nsp address for library */
00179     sprintf(NSP_address_str,"%d.%d.%d.%d",NSP_address_bytes[0],NSP_address_bytes[1],NSP_address_bytes[2],NSP_address_bytes[3]);
00180     DBG("NSP: libNsdl NSP_ADDRESS: %s port: %d\r\n",NSP_address_str,nsp_port);
00181     set_NSP_address(NSP_address_bytes, nsp_port, SN_NSDL_ADDRESS_TYPE_IPV4);
00182     nsp.set_address(NSP_address_str,nsp_port);
00183 }
00184 
00185 extern "C" volatile bool __registered;
00186 
00187 // NSP event loop - spawn a re-registration thread AFTER we have initially registered and begun event processing...     
00188 void nsdl_event_loop() {    
00189     sn_nsdl_addr_s received_packet_address; 
00190    
00191     memset(&received_packet_address, 0, sizeof(sn_nsdl_addr_s));
00192     memset(nsp_received_address, 0, sizeof(nsp_received_address));
00193     received_packet_address.addr_ptr = nsp_received_address;  
00194             
00195     // re-registration update ticker...
00196     Ticker ticker;
00197     ticker.attach(registration_update_tick,NSP_TICKERUPDATE_PERIOD);
00198     
00199     // FOREVER: main loop for event processing  
00200     while(true) {   
00201         // wait for BLE events...  
00202         ble.waitForEvent();
00203         
00204         // only process if we are registered and thus connected... otherwise ignore
00205         if (endpoint_registered == true) {
00206             //DBG("NSP: waiting for data...\r\n");
00207             memset(nsp_buffer,0,NSDL_BUFFER_LENGTH);
00208             int n = server.receiveFrom(from,nsp_buffer,NSDL_BUFFER_LENGTH);
00209             if (n > 0) {
00210                 //DBG("NSP: received %d bytes... processing..\r\n.",n);
00211                 sn_nsdl_process_coap((uint8_t*)nsp_buffer,n,&received_packet_address); 
00212             } 
00213         }      
00214      }
00215 }