connector_edp_util.h

00001 /*
00002  * Copyright (c) 2013 Digi International Inc.,
00003  * All rights not expressly granted are reserved.
00004  *
00005  * This Source Code Form is subject to the terms of the Mozilla Public
00006  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
00007  * You can obtain one at http://mozilla.org/MPL/2.0/.
00008  *
00009  * Digi International Inc. 11001 Bren Road East, Minnetonka, MN 55343
00010  * =======================================================================
00011  */
00012 
00013 #define edp_set_active_state(connector_ptr, value)  (connector_ptr)->edp_data.state.active = (value)
00014 #define edp_get_active_state(connector_ptr)         (connector_ptr)->edp_data.state.active
00015 
00016 #define edp_set_initiate_state(connector_ptr, value)  (connector_ptr)->edp_data.state.initiate = (value)
00017 #define edp_get_initiate_state(connector_ptr)         (connector_ptr)->edp_data.state.initiate
00018 
00019 /* #define edp_get_error(connector_ptr)                (connector_ptr)->edp_data.error_code
00020 #define edp_set_error(connector_ptr, error)         (connector_ptr)->edp_data.error_code = (error) */
00021 
00022 #define edp_get_edp_state(connector_ptr)            (connector_ptr)->edp_data.state.edp
00023 #define edp_set_edp_state(connector_ptr, value)     (connector_ptr)->edp_data.state.edp = (value)
00024 
00025 #define edp_get_close_status(connector_ptr)                (connector_ptr)->edp_data.close_status
00026 #define edp_set_close_status(connector_ptr, value)         (connector_ptr)->edp_data.close_status = (value)
00027 
00028 #define edp_set_stop_condition(connector_ptr, value)    (connector_ptr)->edp_data.stop.condition = (value)
00029 #define edp_is_stop_immediately(connector_ptr)          connector_bool((connector_ptr)->edp_data.stop.condition == connector_stop_immediately)
00030 #define edp_is_stop_request(connector_ptr)              connector_bool((connector_ptr)->edp_data.stop.is_set == connector_true)
00031 #define edp_set_stop_request(connector_ptr, context)             (connector_ptr)->edp_data.stop.is_set = connector_true; (connector_ptr)->edp_data.stop.user_context = (context)
00032 #define edp_clear_stop_request(connector_ptr)           (connector_ptr)->edp_data.stop.is_set = connector_false
00033 
00034 static void edp_reset_initial_data(connector_data_t * const connector_ptr)
00035 {
00036     edp_set_edp_state(connector_ptr, edp_communication_connect_to_cloud);
00037 
00038     connector_ptr->edp_data.facilities.current = NULL;
00039     connector_ptr->edp_data.keepalive.last_rx_sent_time = 0;
00040     connector_ptr->edp_data.keepalive.last_tx_received_time = 0;
00041     connector_ptr->edp_data.keepalive.miss_tx_count = 0;
00042 
00043     connector_ptr->edp_data.send_packet.total_length = 0;
00044     connector_ptr->edp_data.send_packet.bytes_sent = 0;
00045     connector_ptr->edp_data.send_packet.ptr = NULL;
00046     connector_ptr->edp_data.send_packet.complete_cb = NULL;
00047 
00048     connector_ptr->edp_data.receive_packet.total_length = 0;
00049     connector_ptr->edp_data.receive_packet.bytes_received = 0;
00050     connector_ptr->edp_data.receive_packet.index = 0;
00051     connector_ptr->edp_data.receive_packet.ptr = NULL;
00052     connector_ptr->edp_data.receive_packet.data_packet = NULL;
00053     connector_ptr->edp_data.receive_packet.timeout = MAX_RECEIVE_TIMEOUT_IN_SECONDS;
00054     connector_ptr->edp_data.close_status = (connector_close_status_t)0;
00055 
00056     edp_set_stop_condition(connector_ptr, connector_stop_immediately);
00057 
00058 }
00059 
00060 static connector_bool_t is_valid_timing_limit(connector_data_t * const connector_ptr, unsigned long const start, unsigned long const limit)
00061 {
00062     unsigned long elapsed = start;
00063     connector_bool_t rc = connector_false;
00064 
00065     if (get_system_time(connector_ptr, &elapsed) == connector_working)
00066     {
00067         elapsed -= start;
00068         rc = (elapsed < limit) ? connector_true : connector_false;
00069     }
00070 
00071     return rc;
00072 }
00073 
00074 static void * get_facility_data(connector_data_t * const connector_ptr, uint16_t const facility_num)
00075 {
00076     connector_facility_t * fac_ptr;
00077     void * ptr = NULL;
00078 
00079     /* search and return the facility data which allocated from add_facility_data() */
00080     for (fac_ptr = connector_ptr->edp_data.facilities.list; fac_ptr != NULL; fac_ptr = fac_ptr->next)
00081     {
00082         if (fac_ptr->facility_num == facility_num)
00083         {
00084             ptr = fac_ptr->facility_data;
00085             break;
00086         }
00087     }
00088 
00089     return ptr;
00090 }
00091 
00092 static connector_static_buffer_id_t get_facility_buffer_id(uint16_t const facility_num)
00093 {
00094     connector_static_buffer_id_t id;
00095 
00096     switch(facility_num)
00097     {
00098         case E_MSG_FAC_CC_NUM:
00099             id = named_buffer_id(cc_facility);
00100             break;
00101         case E_MSG_FAC_FW_NUM:
00102             id = named_buffer_id(fw_facility);
00103             break;
00104         case E_MSG_FAC_MSG_NUM:
00105             id = named_buffer_id(msg_facility);
00106             break;
00107         default:
00108             id = named_buffer_id(none);
00109     }
00110     return id;
00111 }
00112 
00113 static connector_status_t add_facility_data(connector_data_t * const connector_ptr, unsigned int const service_index,
00114                                                  uint16_t const facility_num, void ** fac_ptr, size_t const size)
00115 {
00116     connector_status_t status;
00117     connector_facility_t * facility;
00118     void * ptr;
00119     size_t const facility_size = sizeof *facility;
00120 
00121     /* allocate facility data and buffer*/
00122 
00123     *fac_ptr = NULL;
00124     status = malloc_data_buffer(connector_ptr, size + facility_size, get_facility_buffer_id(facility_num), &ptr);
00125     if (status == connector_working)
00126     {
00127         /* add facility to the facility list */
00128         facility = ptr;
00129         facility->facility_num = facility_num;
00130         facility->size = size;
00131         facility->service_index = service_index;
00132 
00133         add_node(&connector_ptr->edp_data.facilities.list, facility);
00134 
00135         /* setup facility data which is at the end of connector_facility_t */
00136         facility->facility_data = facility + 1;
00137          *fac_ptr = facility->facility_data;
00138     }
00139 
00140     return status;
00141 }
00142 
00143 static connector_status_t del_facility_data(connector_data_t * const connector_ptr, uint16_t const facility_num)
00144 {
00145     connector_status_t status = connector_working;
00146     connector_facility_t * fac_ptr;
00147 
00148     /* find and free the facility */
00149     for (fac_ptr = connector_ptr->edp_data.facilities.list; fac_ptr != NULL; fac_ptr = fac_ptr->next)
00150     {
00151         if (fac_ptr->facility_num == facility_num)
00152         {
00153 
00154             remove_node(&connector_ptr->edp_data.facilities.list, fac_ptr);
00155             /* Ignore the return status. Just continue freeing next facility */
00156             free_data_buffer(connector_ptr, get_facility_buffer_id(facility_num), fac_ptr);
00157             break;
00158         }
00159     }
00160     return status;
00161 }
00162 
00163 static connector_status_t notify_status(connector_callback_t  const callback, connector_tcp_status_t const status)
00164 {
00165     connector_status_t result;
00166     connector_request_id_t request_id;
00167     connector_status_tcp_event_t tcp_event;
00168 
00169     tcp_event.status = status;
00170 
00171     request_id.status_request = connector_request_id_status_tcp;
00172 
00173     {
00174         connector_callback_status_t const callback_status =  connector_callback(callback, connector_class_id_status, request_id, &tcp_event);
00175 
00176         switch (callback_status)
00177         {
00178             case connector_callback_continue:
00179             case connector_callback_unrecognized:
00180                 result = connector_working;
00181                 break;
00182             default:
00183                 result = connector_abort;
00184                 break;
00185         }
00186     }
00187 
00188     return result;
00189 }
00190 
00191 static void edp_get_device_cloud(connector_data_t * const connector_ptr)
00192 {
00193     memcpy(connector_ptr->edp_data.config.cloud_url, connector_ptr->device_cloud_url, connector_ptr->device_cloud_url_length);
00194     connector_ptr->edp_data.config.cloud_url[connector_ptr->device_cloud_url_length] = 0x0;
00195     connector_ptr->edp_data.config.cloud_url_length = connector_ptr->device_cloud_url_length;
00196 }
00197 
00198