rci_service.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 #define CONNECTOR_RCI_PARSER_INTERNAL_DATA
00013 #define CONNECTOR_CONST_PROTECTION
00014 
00015 #include "remote_config.h"
00016 
00017 #include "rci_binary.h"
00018 
00019 static uint32_t rci_get_firmware_target_zero_version(void)
00020 {
00021     return connector_rci_config_data.firmware_target_zero_version;
00022 }
00023 
00024 static void set_rci_service_error(msg_service_request_t * const service_request, connector_session_error_t const error_code)
00025 {
00026     service_request->error_value = error_code;
00027     service_request->service_type = msg_service_type_error;
00028 }
00029 
00030 static connector_status_t rci_service_callback(connector_data_t * const connector_ptr, msg_service_request_t * const service_request)
00031 {
00032     connector_status_t status = connector_working;
00033     connector_session_error_t error_status = connector_session_error_none;
00034     msg_session_t * session;
00035     rci_service_data_t * service_data;
00036 
00037     ASSERT_GOTO(connector_ptr != NULL, done);
00038     ASSERT_GOTO(service_request != NULL, done);
00039 
00040     session = service_request->session;
00041     ASSERT_GOTO(session != NULL, done);
00042 
00043     service_data = session->service_context;
00044 
00045     switch (service_request->service_type)
00046     {
00047     case msg_service_type_need_data:
00048     case msg_service_type_have_data:
00049     {
00050         rci_status_t rci_status;
00051         rci_session_t parser_action = rci_session_active;
00052 
00053         ASSERT_GOTO(service_request->have_data != NULL, done);
00054         ASSERT_GOTO(service_request->need_data != NULL, done);
00055 
00056         if (session->service_context == NULL)
00057         {
00058             /* 1st time here so let's allocate service context memory for rci parser */
00059             void * ptr;
00060 
00061             status = malloc_data_buffer(connector_ptr, sizeof *service_data, named_buffer_id(msg_service), &ptr);
00062             if (status != connector_working)
00063             {
00064                 if (status != connector_pending)
00065                 {
00066                     error_status = connector_session_error_cancel;
00067                 }
00068                 goto done;
00069             }
00070 
00071             service_data = ptr;
00072             session->service_context = service_data;
00073 
00074             MsgSetStart(service_request->need_data->flags);
00075 
00076             connector_debug_hexvalue("rci_service.request", service_request->have_data->data_ptr, service_request->have_data->length_in_bytes);
00077             parser_action = rci_session_start;
00078         }
00079 
00080         ASSERT(service_data != NULL);
00081 
00082         service_data->connector_ptr = connector_ptr;
00083 
00084         service_data->input.data = service_request->have_data->data_ptr;
00085         service_data->input.bytes = service_request->have_data->length_in_bytes;
00086 
00087         service_data->output.data = service_request->need_data->data_ptr;
00088         service_data->output.bytes = service_request->need_data->length_in_bytes;
00089 
00090         service_data->input.flags = service_request->have_data->flags;
00091         service_data->output.flags = service_request->need_data->flags;
00092         rci_status = rci_binary(parser_action, service_data);
00093 
00094         switch (rci_status)
00095         {
00096         case rci_status_complete:
00097             status = connector_working;
00098             MsgSetLastData(service_request->need_data->flags);
00099             MsgSetSendNow(service_request->need_data->flags);
00100             connector_debug_hexvalue("rci_service.response", service_data->output.data, service_data->output.bytes);
00101             service_request->need_data->length_in_bytes = service_data->output.bytes;
00102             break;
00103 
00104         case rci_status_busy:
00105             status = connector_pending;
00106             break;
00107 
00108         case rci_status_more_input:
00109             status = connector_working;
00110             break;
00111 
00112         case rci_status_flush_output:
00113             MsgSetSendNow(service_request->need_data->flags);
00114             connector_debug_hexvalue("rci_service.response", service_data->output.data, service_data->output.bytes);
00115             service_request->need_data->length_in_bytes = service_data->output.bytes;
00116             status = connector_active;
00117             break;
00118 
00119         case rci_status_error:
00120             status = connector_abort;
00121 
00122             /* no break; */
00123         case rci_status_internal_error:
00124             error_status = connector_session_error_cancel;
00125             break;
00126         }
00127         break;
00128     }
00129     case msg_service_type_error:
00130     {
00131         rci_status_t const rci_status = rci_binary(rci_session_lost, service_data);
00132 
00133         switch (rci_status)
00134         {
00135         case rci_status_complete:
00136             status = connector_working;
00137             break;
00138 
00139         case rci_status_busy:
00140             status = connector_pending;
00141             break;
00142 
00143         case rci_status_more_input:
00144         case rci_status_flush_output:
00145             ASSERT(connector_false);
00146             break;
00147 
00148         case rci_status_error:
00149             status = connector_abort;
00150             break;
00151 
00152         case rci_status_internal_error:
00153             /* just ignore */
00154             break;
00155 
00156         }
00157         break;
00158     }
00159     case msg_service_type_free:
00160         status = free_data_buffer(connector_ptr, named_buffer_id(msg_service), session->service_context);
00161         break;
00162 
00163     default:
00164         ASSERT(connector_false);
00165         break;
00166 
00167     }
00168 
00169 done:
00170     if (error_status != connector_session_error_none)
00171     {
00172         set_rci_service_error(service_request, error_status);
00173     }
00174 
00175     return status;
00176 }
00177 
00178 static connector_status_t connector_facility_rci_service_cleanup(connector_data_t * const connector_ptr)
00179 {
00180     msg_service_id_t const service_id = msg_service_id_brci;
00181     return msg_cleanup_all_sessions(connector_ptr, service_id);
00182 }
00183 
00184 static connector_status_t connector_facility_rci_service_delete(connector_data_t * const connector_ptr)
00185 {
00186     msg_service_id_t const service_id = msg_service_id_brci;
00187     return msg_delete_facility(connector_ptr, service_id);
00188 }
00189 
00190 static connector_status_t connector_facility_rci_service_init(connector_data_t * const connector_ptr, unsigned int const facility_index)
00191 {
00192     connector_status_t result;
00193 
00194     msg_service_id_t const service_id = msg_service_id_brci;
00195 
00196 #if (defined connector_request_id_remote_config_configurations)
00197     {
00198 
00199         connector_request_id_t request_id;
00200         connector_callback_status_t callback_status;
00201 
00202         request_id.remote_config_request = (connector_request_id_remote_config_t)connector_request_id_remote_config_configurations;
00203         callback_status = connector_callback(connector_ptr->callback, connector_class_id_remote_config,
00204                                              request_id, &connector_rci_config_data);
00205         switch (callback_status)
00206         {
00207             case connector_callback_unrecognized:
00208                 result = connector_idle;
00209                 goto done;
00210 
00211             case connector_callback_continue:
00212                 ASSERT(connector_rci_config_data.group_table != NULL);
00213                 if (connector_rci_config_data.global_error_count < connector_rci_error_COUNT) connector_rci_config_data.global_error_count = connector_rci_error_COUNT;
00214                 break;
00215 
00216             default:
00217                 result = connector_abort;
00218                 goto done;
00219 
00220         }
00221 
00222     }
00223 #endif
00224 
00225     result = msg_init_facility(connector_ptr, facility_index, service_id, rci_service_callback);
00226 
00227 #if (defined connector_request_id_remote_config_configurations)
00228 done:
00229 #endif
00230     return result;
00231 }
00232