/*
*===========================================================================
* ipcom_getenv
*===========================================================================
* Description:
* Parameters:
* Returns:
*
*/
IP_PUBLIC char *
ipcom_getenv(const char *name)
{
#if IPCOM_USE_ENV == IPCOM_ENV_IPCOM
Ip_err retval;
Ipcom_proc *proc;
Ipcom_env_entry *env;
char *value = IP_NULL;
proc = ipcom_proc_self();
ip_assert(proc != IP_NULL);
retval = ipcom_once(&proc->env_once, ipcom_env_init, proc);
if (retval != IPCOM_SUCCESS)
{
IP_PANIC();
return IP_NULL;
}
ipcom_mutex_lock(proc->env_mutex);
env = ipcom_hash_get(proc->env_tree, name);
if (env != IP_NULL)
value = (char *)env->value;
ipcom_mutex_unlock(proc->env_mutex);
return value;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE && (defined(IP_PORT_OSE) || defined(IP_PORT_OSE5))
char *env;
static char buf[256];
env = get_env(current_process(), name);
if (env != IP_NULL)
{
ipcom_strncpy(buf, env, sizeof(buf));
free_buf((union SIGNAL **)&env);
return (char *)buf;
}
return IP_NULL;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE
return getenv(name);
#elif defined(IPCOM_USE_SYSVAR) && IPCOM_VR_MAX == 1
static char buf[256];
Ip_size_t buf_size = sizeof(buf);
return ipcom_sysvar_get(name, buf, &buf_size);
#else
return IP_NULL;
#endif /* #if IPCOM_USE_ENV == IPCOM_ENV_IPCOM */
}
/*
*===========================================================================
* ipnet_vrrp_get_addr_entry
*===========================================================================
* Description: Returns the matching virtual router address entry.
* Parameters: netif - The network interface the VRIP must be assigned to.
* vrid - The VRID the address must be assigned to.
* Returns: A pointer to the entry or IP_NULL if no match exists.
*
*/
IP_GLOBAL Ipnet_vrrp_addr_t *
ipnet_vrrp_get_addr_entry(Ipnet_netif *netif, Ip_u8 vrid)
{
Ipnet_vrrp_addr_t key;
if (ipnet->vrrp_addrs == IP_NULL)
return IP_NULL;
key.netif = netif;
key.vrid = vrid;
return ipcom_hash_get(ipnet->vrrp_addrs, &key);
}
/*
*===========================================================================
* ipcom_unsetenv
*===========================================================================
* Description:
* Parameters:
* Returns:
*
*/
IP_PUBLIC int
ipcom_unsetenv(const char *name)
{
#if IPCOM_USE_ENV == IPCOM_ENV_IPCOM
Ip_err retval;
Ipcom_proc *proc;
Ipcom_env_entry *env;
proc = ipcom_proc_self();
ip_assert(proc != IP_NULL);
retval = ipcom_once(&proc->env_once, ipcom_env_init, proc);
if (retval != IPCOM_SUCCESS)
{
IP_PANIC();
return -1;
}
ipcom_mutex_lock(proc->env_mutex);
env = ipcom_hash_get(proc->env_tree, name);
if (env != IP_NULL)
ipcom_env_delete(env, proc->env_tree);
ipcom_mutex_unlock(proc->env_mutex);
return 0;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE && (defined(IP_PORT_OSE) || defined(IP_PORT_OSE5))
set_env(current_process(), name, NULL);
return 0;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE && defined(IP_PORT_VXWORKS)
{
char buf[256];
int ret;
ipcom_snprintf(buf, sizeof(buf), "%s=", name);
ret = (int)putenv(buf);
return ret == 0 ? 0 : -1;
}
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE
return unsetenv(name);
#elif defined(IPCOM_USE_SYSVAR) && IPCOM_VR_MAX == 1
(void)ipcom_sysvar_unset(name);
return 0;
#else
return 0;
#endif /* #if IPCOM_USE_ENV == IPCOM_ENV_IPCOM */
}
/*
*===========================================================================
* ipcom_sysvar_unset
*===========================================================================
* Description:
* Parameters:
* Returns:
*/
IP_PUBLIC Ip_err
ipcom_sysvar_unset(const char *name)
{
Ipcom_sysvar_entry *sysvar;
Ip_err retval;
Ip_size_t namelen;
Ipcom_sysvar_tree *tree;
retval = ipcom_once(&ipcom_sysvar_once, ipcom_sysvar_init, IP_NULL);
if (retval != IPCOM_SUCCESS)
return retval;
namelen = ipcom_strlen(name);
if (name[namelen-1] == '*')
return ipcom_sysvar_for_each(name, ipcom_sysvar_unset_cb, IP_NULL);
IPCOM_CODE_LOCK();
tree = ipcom_sysvar_tree_get(-1);
if (tree == IP_NULL)
{
retval = IPCOM_ERR_NO_MEMORY;
goto leave;
}
retval = IPCOM_ERR_NOT_FOUND;
sysvar = ipcom_hash_get(tree->sysvars, name);
if (sysvar)
{
if(IP_BIT_ISSET(sysvar->flags, IPCOM_SYSVAR_FLAG_READONLY))
retval = IPCOM_ERR_READONLY;
else
{
ipcom_sysvar_release(tree, sysvar);
retval = IPCOM_SUCCESS;
}
}
leave:
ipcom_sysvar_tree_done(tree);
IPCOM_CODE_UNLOCK();
return retval;
}
/*
*===========================================================================
* ipcom_sysvar_set_internal
*===========================================================================
* Description:
* Parameters:
* Returns:
*/
IP_GLOBAL Ip_err
ipcom_sysvar_set_tree(const char *name, const char *value, int flags, Ipcom_sysvar_tree *tree)
{
Ip_size_t name_length;
Ip_size_t value_length;
Ipcom_sysvar_entry *sysvar;
Ip_err retval = IPCOM_SUCCESS;
/* Check for duplicate. */
sysvar = ipcom_hash_get(tree->sysvars, name);
if (sysvar)
{
if (IP_BIT_ISSET(sysvar->flags, IPCOM_SYSVAR_FLAG_READONLY))
{
retval = IPCOM_ERR_READONLY;
goto leave;
}
else if (IP_BIT_ISFALSE(flags, IPCOM_SYSVAR_FLAG_OVERWRITE))
{
retval = IPCOM_ERR_DUPLICATE;
goto leave;
}
else
{
flags |= sysvar->flags & IPCOM_SYSVAR_FLAG_KERNEL;
ipcom_hash_remove(tree->sysvars, sysvar);
ipcom_free(sysvar);
goto set;
}
}
/* No current entry found and not allowed to create a new entry. */
if(IP_BIT_ISSET(flags, IPCOM_SYSVAR_FLAG_NOCREATE))
{
retval = IPCOM_ERR_FAILED;
goto leave;
}
/* Add the new sysvar. */
set:
name_length = ipcom_strlen(name) + 1;
value_length = ipcom_strlen(value) + 1;
sysvar = ipcom_malloc(sizeof(Ipcom_sysvar_entry) + name_length + value_length);
if(sysvar == IP_NULL)
{
retval = IPCOM_ERR_NO_MEMORY;
goto leave;
}
sysvar->refcount = 1;
sysvar->flags = flags;
if (IP_BIT_ISFALSE(flags, IPCOM_SYSVAR_FLAG_INIT))
{
tree->modified = IP_TRUE;
sysvar->flags |= IPCOM_SYSVAR_FLAG_MODIFIED;
}
sysvar->name = (const char *)sysvar + sizeof(Ipcom_sysvar_entry);
ipcom_memcpy((void *)sysvar->name, name, name_length);
sysvar->value = sysvar->name + name_length;
ipcom_memcpy((void *)sysvar->value, value, value_length);
retval = ipcom_hash_add(tree->sysvars, sysvar);
leave:
return retval; /*lint !e429 Custodial pointer 'sysvar' has not been freed or returned */
}
/*
*===========================================================================
* ipcom_sysvar_getvr
*===========================================================================
* Description:
* Parameters:
* Returns:
*/
IP_GLOBAL char *
ipcom_sysvar_getvr(const char *name, char *value, Ip_size_t *value_size, Ip_bool usr, int vr)
{
Ipcom_sysvar_entry *sysvar;
Ip_size_t value_length;
char *ret_value = IP_NULL;
Ip_err retval;
Ipcom_sysvar_tree *tree;
if (name == IP_NULL)
return IP_NULL;
retval = ipcom_once(&ipcom_sysvar_once, ipcom_sysvar_init, IP_NULL);
if (retval != IPCOM_SUCCESS)
{
IP_PANIC();
return IP_NULL;
}
IPCOM_CODE_LOCK();
tree = ipcom_sysvar_tree_get(vr);
if (tree == IP_NULL)
goto leave;
sysvar = ipcom_hash_get(tree->sysvars, name);
if (sysvar)
{
if (value == IP_NULL)
{
#ifdef IP_PORT_OSE5
if (usr)
ret_value = ipcom_strdup_usr(sysvar->value);
else
#else
(void)usr;
#endif
ret_value = ipcom_strdup(sysvar->value);
}
else
{
value_length = ipcom_strlen(sysvar->value) + 1;
if (value_length > *value_size)
{
ret_value = IP_NULL;
*value_size = value_length;
}
else
{
ret_value = value;
ipcom_memcpy(ret_value, sysvar->value, value_length);
*value_size = value_length - 1;
}
}
}
#ifdef IP_PORT_OSE5
else
{
ret_value = ipcom_sysvar_get_ose5(name, value, value_size);
}
#endif /* IP_PORT_OSE5 */
leave:
ipcom_sysvar_tree_done(tree);
IPCOM_CODE_UNLOCK();
return ret_value;
}
/*
*===========================================================================
* ipcom_setenv
*===========================================================================
* Description:
* Parameters:
* Returns:
*
*/
IP_PUBLIC int
ipcom_setenv(const char *name, const char *value, int rewrite)
{
#if IPCOM_USE_ENV == IPCOM_ENV_IPCOM
Ip_err retval;
Ipcom_proc *proc;
Ipcom_env_entry *env;
proc = ipcom_proc_self();
ip_assert(proc != IP_NULL);
retval = ipcom_once(&proc->env_once, ipcom_env_init, proc);
if (retval != IPCOM_SUCCESS)
{
IP_PANIC();
return -1;
}
ipcom_mutex_lock(proc->env_mutex);
/* Check for duplicate. */
env = ipcom_hash_get(proc->env_tree, name);
if (env != IP_NULL)
{
if (rewrite == 0)
goto leave;
ipcom_env_delete(env, proc->env_tree);
}
/* Create environment variable. */
env = ipcom_env_create(name, value);
if (env == IP_NULL)
{
ipcom_mutex_unlock(proc->env_mutex);
return -1;
}
(void)ipcom_hash_add(proc->env_tree, env);
leave:
ipcom_mutex_unlock(proc->env_mutex);
return 0;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE && (defined(IP_PORT_OSE) || defined(IP_PORT_OSE5))
(void)rewrite;
set_env(current_process(), name, value);
return 0;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE && defined(IP_PORT_VXWORKS)
char buf[256];
int ret;
(void)rewrite;
ipcom_snprintf(buf, sizeof(buf), "%s=%s", name, value);
ret = (int)putenv(buf);
return ret == 0 ? 0 : -1;
#elif IPCOM_USE_ENV == IPCOM_ENV_NATIVE
return setenv(name, value, rewrite);
#elif defined(IPCOM_USE_SYSVAR) && IPCOM_VR_MAX == 1
(void)ipcom_sysvar_set(name, value, rewrite ? IPCOM_SYSVAR_FLAG_OVERWRITE : 0);
return 0;
#else
(void)name;
(void)value;
(void)rewrite;
return -1;
#endif /* #if IPCOM_USE_ENV == IPCOM_ENV_IPCOM */
}
