connector_tcp_config.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 
00014 #if !(defined CONNECTOR_VENDOR_ID)
00015 static connector_status_t get_config_vendor_id(connector_data_t * const connector_ptr)
00016 {
00017     connector_status_t result = connector_working;
00018     connector_config_vendor_id_t config_vendor;
00019 
00020     {
00021         connector_callback_status_t status;
00022         connector_request_id_t request_id;
00023 
00024         request_id.config_request = connector_request_id_config_vendor_id;
00025         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &config_vendor);
00026 
00027         switch (status)
00028         {
00029         case connector_callback_continue:
00030             {
00031                 uint32_t const max_vendor_id = CONNECTOR_MAX_VENDOR_ID_NUMBER;
00032                 /* coverity[uninit_use] */
00033                 if ((config_vendor.id == 0) || (config_vendor.id >= max_vendor_id))
00034                 {
00035                     notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, connector_invalid_data_range);
00036                     result = connector_abort;
00037                 }
00038                 else
00039                     connector_ptr->edp_data.config.vendor_id = config_vendor.id;
00040 
00041             }
00042             break;
00043 
00044         case connector_callback_busy:
00045         case connector_callback_abort:
00046         case connector_callback_error:
00047         case connector_callback_unrecognized:
00048             result =  connector_abort;
00049             break;
00050         }
00051     }
00052 
00053     return result;
00054 }
00055 #endif
00056 
00057 #if !(defined CONNECTOR_DEVICE_TYPE)
00058 static connector_status_t get_config_device_type(connector_data_t * const connector_ptr)
00059 {
00060     connector_status_t result = connector_working;
00061     connector_config_pointer_string_t device_type;
00062     connector_request_id_t request_id;
00063 
00064     {
00065         connector_callback_status_t status;
00066 
00067         request_id.config_request = connector_request_id_config_device_type;
00068         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &device_type);
00069 
00070         switch (status)
00071         {
00072         case connector_callback_continue:
00073             /* coverity[uninit_use] */
00074             if (device_type.string == NULL)
00075                 result = connector_invalid_data;
00076             /* coverity[uninit_use] */
00077             else if ((device_type.length == 0) || (device_type.length > DEVICE_TYPE_LENGTH))
00078                 result = connector_invalid_data_size;
00079             else
00080             {
00081                 connector_ptr->edp_data.config.device_type_length = device_type.length;
00082                 connector_ptr->edp_data.config.device_type = device_type.string;
00083             }
00084             break;
00085 
00086         case connector_callback_busy:
00087         case connector_callback_abort:
00088         case connector_callback_error:
00089         case connector_callback_unrecognized:
00090             result =  connector_abort;
00091             goto done;
00092         }
00093     }
00094 
00095     if (result != connector_working)
00096     {
00097         notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, result);
00098         result = connector_abort;
00099     }
00100 
00101 done:
00102     return result;
00103 }
00104 #endif
00105 
00106 #if !(defined CONNECTOR_RX_KEEPALIVE_IN_SECONDS) || !(defined CONNECTOR_TX_KEEPALIVE_IN_SECONDS)
00107 static connector_status_t get_config_keepalive(connector_data_t * const connector_ptr, connector_request_id_config_t const config_request)
00108 {
00109     connector_status_t result = connector_working;
00110     connector_config_keepalive_t keepalive;
00111 
00112     ASSERT((config_request == connector_request_id_config_rx_keepalive) || (config_request == connector_request_id_config_tx_keepalive));
00113     {
00114         connector_callback_status_t status;
00115         connector_request_id_t request_id;
00116 
00117         request_id.config_request = config_request;
00118         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &keepalive);
00119 
00120         switch (status)
00121         {
00122             case connector_callback_continue:
00123             {
00124 
00125 #if !defined(CONNECTOR_TX_KEEPALIVE_IN_SECONDS) && !defined(CONNECTOR_RX_KEEPALIVE_IN_SECONDS)
00126                 connector_bool_t const is_tx = connector_bool(config_request == connector_request_id_config_tx_keepalive);
00127                 uint16_t const min_interval = is_tx ? MIN_TX_KEEPALIVE_INTERVAL_IN_SECONDS : MIN_RX_KEEPALIVE_INTERVAL_IN_SECONDS;
00128                 uint16_t const max_interval = is_tx ? MAX_TX_KEEPALIVE_INTERVAL_IN_SECONDS : MAX_RX_KEEPALIVE_INTERVAL_IN_SECONDS;
00129 
00130 #elif !(defined CONNECTOR_TX_KEEPALIVE_IN_SECONDS)
00131                 uint16_t const min_interval = MIN_TX_KEEPALIVE_INTERVAL_IN_SECONDS;
00132                 uint16_t const max_interval = MAX_TX_KEEPALIVE_INTERVAL_IN_SECONDS;
00133 
00134 #elif !(defined CONNECTOR_RX_KEEPALIVE_IN_SECONDS)
00135                 uint16_t const min_interval = MIN_RX_KEEPALIVE_INTERVAL_IN_SECONDS;
00136                 uint16_t const max_interval = MAX_RX_KEEPALIVE_INTERVAL_IN_SECONDS;
00137 #endif
00138                 /* coverity[uninit_use] */
00139                 if ((keepalive.interval_in_seconds < min_interval) || (keepalive.interval_in_seconds > max_interval))
00140                 {
00141                     notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, connector_invalid_data_range);
00142                     result = connector_abort;
00143                     goto done;
00144                 }
00145 
00146                 {
00147 #if !defined(CONNECTOR_TX_KEEPALIVE_IN_SECONDS) && !defined(CONNECTOR_RX_KEEPALIVE_IN_SECONDS)
00148                     uint16_t * const keepalive_store_at = is_tx ? &connector_ptr->edp_data.config.tx_keepalive_interval : &connector_ptr->edp_data.config.rx_keepalive_interval;
00149 #elif !defined(CONNECTOR_TX_KEEPALIVE_IN_SECONDS)
00150                     uint16_t * const keepalive_store_at = &connector_ptr->edp_data.config.tx_keepalive_interval;
00151 #elif !defined(CONNECTOR_RX_KEEPALIVE_IN_SECONDS)
00152                     uint16_t * const keepalive_store_at = &connector_ptr->edp_data.config.rx_keepalive_interval;
00153 #endif
00154                     *keepalive_store_at = keepalive.interval_in_seconds;
00155                 }
00156                 break;
00157             }
00158             case connector_callback_busy:
00159             case connector_callback_abort:
00160             case connector_callback_error:
00161             case connector_callback_unrecognized:
00162                 result =  connector_abort;
00163                 goto done;
00164         }
00165     }
00166 
00167 done:
00168     return result;
00169 }
00170 #endif
00171 
00172 #if !(defined CONNECTOR_WAIT_COUNT)
00173 static connector_status_t get_config_wait_count(connector_data_t * const connector_ptr)
00174 {
00175     connector_status_t result = connector_working;
00176     connector_config_wait_count_t wait_count;
00177 
00178     {
00179         connector_callback_status_t status;
00180         connector_request_id_t request_id;
00181 
00182         request_id.config_request = connector_request_id_config_wait_count;
00183         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &wait_count);
00184 
00185         switch (status)
00186         {
00187         case connector_callback_continue:
00188             /* coverity[uninit_use] */
00189             if ((wait_count.count < WAIT_COUNT_MIN) ||
00190                 (wait_count.count > WAIT_COUNT_MAX))
00191             {
00192                 notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, connector_invalid_data_range);
00193                 result = connector_abort;
00194             }
00195             else
00196             {
00197                 connector_ptr->edp_data.config.wait_count = wait_count.count;
00198             }
00199             break;
00200 
00201         case connector_callback_busy:
00202         case connector_callback_abort:
00203         case connector_callback_error:
00204         case connector_callback_unrecognized:
00205             result = connector_abort;
00206             break;
00207         }
00208     }
00209     return result;
00210 }
00211 #endif
00212 
00213 
00214 static connector_status_t get_config_ip_addr(connector_data_t * const connector_ptr)
00215 {
00216 #define CC_IPV6_ADDRESS_LENGTH 16
00217 #define CC_IPV4_ADDRESS_LENGTH 4
00218 
00219     connector_status_t result = connector_working;
00220     connector_config_ip_address_t config_ip;
00221     connector_request_id_t request_id;
00222 
00223     {
00224         connector_callback_status_t status;
00225 
00226         request_id.config_request = connector_request_id_config_ip_addr;
00227         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &config_ip);
00228 
00229         switch (status)
00230         {
00231         case connector_callback_continue:
00232         {
00233             #define CC_ZERO_IP_ADDR         0x00000000
00234             #define CC_BROADCAST_IP_ADDR    0xFFFFFFFF
00235 
00236             /* coverity[uninit_use] */
00237             if (config_ip.address == NULL)
00238             {
00239                 result = connector_invalid_data;
00240                 goto error;
00241             }
00242             /* coverity[uninit_use] */
00243             if ((config_ip.ip_address_type != connector_ip_address_ipv6) && (config_ip.ip_address_type != connector_ip_address_ipv4))
00244             {
00245                 result =  connector_invalid_data_size;
00246                 goto error;
00247             }
00248 
00249             if (config_ip.ip_address_type == connector_ip_address_ipv4)
00250             {
00251                 static uint32_t const zero_ip_addr = CC_ZERO_IP_ADDR;
00252                 static uint32_t const broadcast_ip_addr = CC_BROADCAST_IP_ADDR;
00253 
00254                 uint32_t const ip =  LoadBE32(config_ip.address);
00255 
00256                 if ((ip == LoadBE32(&zero_ip_addr)) || (ip == LoadBE32(&broadcast_ip_addr)))
00257                 {
00258                     result = connector_invalid_data_range;
00259                     goto error;
00260                 }
00261             }
00262 
00263             connector_ptr->edp_data.config.ip_addr_length = (config_ip.ip_address_type == connector_ip_address_ipv4) ? CC_IPV4_ADDRESS_LENGTH : CC_IPV6_ADDRESS_LENGTH;
00264             connector_ptr->edp_data.config.ip_addr = config_ip.address;
00265             break;
00266         }
00267 
00268         case connector_callback_busy:
00269         case connector_callback_abort:
00270         case connector_callback_error:
00271         case connector_callback_unrecognized:
00272             result =  connector_abort;
00273             goto done;
00274         }
00275     }
00276 
00277 
00278 error:
00279     if (result != connector_working)
00280     {
00281         notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, result);
00282         result = connector_abort;
00283     }
00284 
00285 done:
00286     return result;
00287 }
00288 
00289 #if !(defined CONNECTOR_IDENTITY_VERIFICATION)
00290 static connector_status_t get_config_identity_verification(connector_data_t * const connector_ptr)
00291 {
00292     connector_status_t result = connector_working;
00293     connector_config_identity_verification_t config_identity;
00294 
00295 
00296     {
00297         connector_callback_status_t status;
00298         connector_request_id_t request_id;
00299 
00300         request_id.config_request = connector_request_id_config_identity_verification;
00301         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &config_identity);
00302 
00303         switch (status)
00304         {
00305         case connector_callback_continue:
00306             /* coverity[uninit_use] */
00307             switch (config_identity.type)
00308             {
00309             case connector_identity_verification_simple:
00310             case connector_identity_verification_password:
00311                 connector_ptr->edp_data.config.identity_verification = config_identity.type;
00312                 break;
00313             default:
00314                 notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, connector_invalid_data_range);
00315                 result = connector_abort;
00316                 break;
00317             }
00318             break;
00319 
00320         case connector_callback_busy:
00321         case connector_callback_abort:
00322         case connector_callback_error:
00323             result = connector_abort;
00324             break;
00325 
00326         case connector_callback_unrecognized:
00327             connector_ptr->edp_data.config.identity_verification = connector_identity_verification_simple;
00328             break;
00329         }
00330     }
00331     return result;
00332 }
00333 #endif
00334 
00335 static connector_status_t get_config_password(connector_data_t * const connector_ptr)
00336 {
00337     connector_status_t result = connector_working;
00338     connector_config_pointer_string_t config_password;
00339 
00340 
00341     {
00342         connector_callback_status_t status;
00343         connector_request_id_t request_id;
00344 
00345         request_id.config_request = connector_request_id_config_password;
00346         status = connector_callback(connector_ptr->callback, connector_class_id_config, request_id, &config_password);
00347 
00348         switch (status)
00349         {
00350         case connector_callback_continue:
00351             /* coverity[uninit_use] */
00352             if (config_password.string == NULL)
00353             {
00354                 notify_error_status(connector_ptr->callback, connector_class_id_config, request_id, connector_invalid_data);
00355                 result = connector_abort;
00356             }
00357             else
00358             {
00359                 /* coverity[uninit_use] */
00360                 connector_ptr->edp_data.config.password_length = config_password.length;
00361                 connector_ptr->edp_data.config.password = config_password.string;
00362 
00363             }
00364             break;
00365 
00366         case connector_callback_busy:
00367         case connector_callback_abort:
00368         case connector_callback_error:
00369         case connector_callback_unrecognized:
00370             result = connector_abort;
00371             break;
00372         }
00373     }
00374 
00375     return result;
00376 }
00377