rci_binary_callback.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 state_call(rci, value)  ((rci)->parser.state = (value))
00014 
00015 static connector_bool_t is_set_command(connector_remote_action_t const action)
00016 {
00017     return connector_bool(action == connector_remote_action_set);
00018 
00019 }
00020 
00021 static void rci_error(rci_t * const rci, unsigned int const id, char const * const description, char const * const hint)
00022 {
00023     rci->shared.callback_data.error_id = id;
00024     rci->shared.callback_data.response.error_hint = hint;
00025 
00026     rci->error.description = description;
00027 }
00028 
00029 #if defined RCI_PARSER_USES_ERROR_DESCRIPTIONS
00030 #define get_rci_global_error(rci, id)   connector_rci_config_data.error_table[(id) - connector_rci_error_OFFSET]
00031 static char const * get_rci_group_error(rci_t * const rci, unsigned int const id)
00032 {
00033     connector_group_t const * const group = get_current_group(rci);
00034     unsigned int const index = (id - connector_rci_config_data.global_error_count);
00035 
00036     ASSERT(id >= connector_rci_config_data.global_error_count);
00037     ASSERT(index < group->errors.count);
00038 
00039     return group->errors.description[index];
00040 }
00041 #else
00042 #define get_rci_global_error(rci, id)   ((void) (rci), (void) (id), NULL)
00043 #define get_rci_group_error(rci, id)    ((void) (rci), (void) (id), NULL)
00044 #endif
00045 
00046 static void rci_global_error(rci_t * const rci, unsigned int const id, char const * const hint)
00047 {
00048     char const * const description = get_rci_global_error(rci, id);
00049 
00050     rci_error(rci, id, description, hint);
00051 }
00052 
00053 static void rci_group_error(rci_t * const rci, unsigned int const id, char const * const hint)
00054 {
00055     if (id < connector_rci_config_data.global_error_count)
00056     {
00057         rci_global_error(rci, id, hint);
00058     }
00059     else
00060     {
00061         char const * const description = get_rci_group_error(rci, id);
00062 
00063         rci_error(rci, id, description, hint);
00064     }
00065 }
00066 
00067 static connector_bool_t pending_rci_callback(rci_t * const rci)
00068 {
00069     connector_bool_t const pending = connector_bool(rci->callback.status == connector_callback_busy);
00070 
00071     return pending;
00072 }
00073 
00074 static void trigger_rci_callback(rci_t * const rci, connector_request_id_remote_config_t const remote_config_request)
00075 {
00076     switch (remote_config_request)
00077     {
00078     case connector_request_id_remote_config_session_cancel:
00079         break;
00080 
00081     case connector_request_id_remote_config_session_start:
00082     case connector_request_id_remote_config_session_end:
00083     case connector_request_id_remote_config_action_start:
00084     case connector_request_id_remote_config_action_end:
00085         break;
00086 
00087     case connector_request_id_remote_config_group_start:
00088         ASSERT(have_group_id(rci));
00089         ASSERT(have_group_index(rci));
00090 
00091         rci->shared.callback_data.group.id = get_group_id(rci);
00092         rci->shared.callback_data.group.index = get_group_index(rci);
00093         break;
00094 
00095     case connector_request_id_remote_config_group_end:
00096         ASSERT(have_group_id(rci));
00097         ASSERT(have_group_index(rci));
00098         break;
00099 
00100     case connector_request_id_remote_config_group_process:
00101         ASSERT(have_group_id(rci));
00102         ASSERT(have_group_index(rci));
00103         ASSERT(have_element_id(rci));
00104 
00105         rci->shared.callback_data.element.id = get_element_id(rci);
00106         {
00107             connector_group_element_t const * const element = get_current_element(rci);
00108 
00109             rci->shared.callback_data.element.type = element->type;
00110         }
00111 
00112         rci->shared.callback_data.element.value = is_set_command(rci->shared.callback_data.action) ? &rci->shared.value : NULL;
00113         break;
00114     }
00115 
00116     rci->callback.request.remote_config_request = remote_config_request;
00117     rci->callback.status = connector_callback_busy;
00118 }
00119 
00120 static connector_bool_t rci_callback(rci_t * const rci)
00121 {
00122     connector_bool_t callback_complete;
00123     connector_remote_config_t * remote_config = &rci->shared.callback_data;
00124     connector_remote_config_cancel_t remote_cancel;
00125     void * callback_data = NULL;
00126 
00127     switch (rci->callback.request.remote_config_request)
00128     {
00129     case connector_request_id_remote_config_session_start:
00130     case connector_request_id_remote_config_session_end:
00131     case connector_request_id_remote_config_action_start:
00132     case connector_request_id_remote_config_action_end:
00133     case connector_request_id_remote_config_group_start:
00134     case connector_request_id_remote_config_group_end:
00135     case connector_request_id_remote_config_group_process:
00136     {
00137         remote_config->error_id = connector_success;
00138         callback_data = remote_config;
00139         break;
00140     }
00141 
00142     case connector_request_id_remote_config_session_cancel:
00143     {
00144         remote_cancel.user_context = remote_config->user_context;
00145         callback_data =  &remote_cancel;
00146         break;
00147     }
00148     }
00149 
00150     rci->callback.status = connector_callback(rci->service_data->connector_ptr->callback, connector_class_id_remote_config, rci->callback.request, callback_data);
00151 
00152     switch (rci->callback.status)
00153     {
00154     case connector_callback_abort:
00155         callback_complete = connector_false;
00156         rci->status = rci_status_error;
00157         break;
00158 
00159     case connector_callback_continue:
00160         callback_complete = connector_true;
00161 #if 0
00162         if (response_data->error_id != connector_success)
00163         {
00164             switch (rci->callback.request.remote_config_request)
00165             {
00166             case connector_request_id_remote_config_session_end:
00167                 callback_complete = connector_false;
00168                 rci->status = rci_status_internal_error;
00169                 break;
00170             default:
00171                 break;
00172             }
00173         }
00174 #endif
00175         break;
00176 
00177     case connector_callback_busy:
00178         callback_complete = connector_false;
00179         break;
00180 
00181     default:
00182         callback_complete = connector_false;
00183         rci->status = rci_status_error;
00184         break;
00185     }
00186 
00187     return callback_complete;
00188 }
00189 
00190 
00191