/*
Creates global config structure from config entry at plugin startup
*/
int
acct_policy_load_config_startup( Slapi_PBlock* pb, void* plugin_id ) {
acctPluginCfg *newcfg;
Slapi_Entry *config_entry = NULL;
Slapi_DN *config_sdn = NULL;
int rc;
/* Retrieve the config entry */
config_sdn = slapi_sdn_new_normdn_byref( PLUGIN_CONFIG_DN );
rc = slapi_search_internal_get_entry( config_sdn, NULL, &config_entry,
plugin_id);
slapi_sdn_free( &config_sdn );
if( rc != LDAP_SUCCESS || config_entry == NULL ) {
slapi_log_err(SLAPI_LOG_ERR, PLUGIN_NAME,
"acct_policy_load_config_startup - Failed to retrieve configuration entry %s: %d\n",
PLUGIN_CONFIG_DN, rc );
return( -1 );
}
config_wr_lock();
free_config();
newcfg = get_config();
rc = acct_policy_entry2config( config_entry, newcfg );
config_unlock();
slapi_entry_free( config_entry );
return( rc );
}
static
int
s1ap_mme_compare_plmn (
S1ap_PLMNidentity_t * plmn)
{
int i;
uint16_t mcc;
uint16_t mnc;
uint16_t mnc_len;
DevAssert (plmn != NULL);
TBCD_TO_MCC_MNC (plmn, mcc, mnc, mnc_len);
config_read_lock (&mme_config);
for (i = 0; i < mme_config.gummei.nb_mme_gid; i++) {
S1AP_DEBUG ("Comparing plmn_mcc %d/%d, plmn_mnc %d/%d plmn_mnc_len %d/%d\n", mme_config.gummei.plmn_mcc[i], mcc, mme_config.gummei.plmn_mnc[i], mnc, mme_config.gummei.plmn_mnc_len[i], mnc_len);
if ((mme_config.gummei.plmn_mcc[i] == mcc) && (mme_config.gummei.plmn_mnc[i] == mnc) && (mme_config.gummei.plmn_mnc_len[i] == mnc_len))
/*
* There is a matching plmn
*/
return TA_LIST_AT_LEAST_ONE_MATCH;
}
config_unlock (&mme_config);
return TA_LIST_NO_MATCH;
}
static int modbus_after_write_table(struct modbus_instance *instance, enum modbus_table table, uint16_t address, uint16_t count)
{
if (table == MODBUS_TABLE_HOLDING_REGISTERS)
{
uint16_t offset = ELEMENT_OFFSET(common_values, now);
if (ELEMENT_IN(0x0000, offset, address * 2, count * 2))
{
// SYNC CLOCK
DateTime dt(common_values.now.year, common_values.now.month, common_values.now.day,
common_values.now.hours, common_values.now.minutes, common_values.now.seconds);
OS::TSysTimerLocker lock;
RTC_DS1307 rtc;
rtc.begin();
rtc.adjust(dt);
}
offset = ELEMENT_OFFSET(common_values, modbus_address);
if (ELEMENT_IN(0x0000, offset, address * 2, count * 2))
{
config_lock();
config_set_address(common_values.modbus_address & 0xFF);
config_unlock();
// instance->address = common_values.modbus_address;
}
}
if (table == MODBUS_TABLE_COILS)
{
uint16_t offset = ELEMENT_OFFSET(controls, restart_programs);
if (ELEMENT_IN(0x0000, offset, address, count))
{
if (controls.restart_programs == 0x01)
{
controls.restart_programs = 0x00;
controls.pause_flag = 0x00;
program_reset();
config_set_pause_flag(controls.pause_flag);
}
}
offset = ELEMENT_OFFSET(controls, pause_flag);
if (ELEMENT_IN(0x0000, offset, address, count))
{
config_set_pause_flag(controls.pause_flag);
}
}
MODBUS_RETURN(instance, MODBUS_SUCCESS);
}
static int modbus_write_file(struct modbus_instance *instance, uint16_t filenum, uint16_t address, uint16_t count, const uint8_t *data)
{
uint16_t start_address;
bool found = false;
if (filenum == 0x0001)
{
start_address = IOSLOT_START_ADDRESS;
found = true;
}
else if (filenum == 0x0002)
{
start_address = PROGRAM_START_ADDRESS;
found = true;
}
if (found)
{
uint16_t i;
uint16_t j;
config_lock();
for (i = 0, j = 0; i < count; ++i, ++address, j += 2)
{
uint8_t w[2];
w[0] = data[j + 1];
w[1] = data[j];
config_write(start_address + (address << 1), w, 2);
}
config_unlock();
if (filenum == 0x0001)
{
io_reset();
}
else if (filenum == 0x0002)
{
program_reset();
}
MODBUS_RETURN(instance, MODBUS_SUCCESS);
}
MODBUS_RETURN(instance, MODBUS_BAD_PARAMS);
}
/* @brief compare a TAC
*/
static
int
s1ap_mme_compare_tac (
S1ap_TAC_t * tac)
{
int i;
uint16_t tac_value;
DevAssert (tac != NULL);
OCTET_STRING_TO_TAC (tac, tac_value);
config_read_lock (&mme_config);
for (i = 0; i < mme_config.gummei.nb_plmns; i++) {
S1AP_DEBUG ("Comparing config tac %d, received tac = %d\n", mme_config.gummei.plmn_tac[i], tac_value);
if (mme_config.gummei.plmn_tac[i] == tac_value)
return TA_LIST_AT_LEAST_ONE_MATCH;
}
config_unlock (&mme_config);
return TA_LIST_NO_MATCH;
}
/*
Given an entry, provide the account policy in effect for that entry.
Returns non-0 if function fails. If account policy comes back NULL, it's
not an error; the entry is simply not covered by a policy.
*/
int
get_acctpolicy( Slapi_PBlock *pb, Slapi_Entry *target_entry, void *plugin_id,
acctPolicy **policy )
{
Slapi_DN *sdn = NULL;
Slapi_Entry *policy_entry = NULL;
Slapi_Attr *attr;
Slapi_Value *sval = NULL;
int ldrc;
char *attr_name;
char *policy_dn = NULL;
acctPluginCfg *cfg;
int rc = 0;
if( policy == NULL ) {
/* Bad parameter */
return( -1 );
}
*policy = NULL;
config_rd_lock();
cfg = get_config();
/* Return success and NULL policy */
policy_dn = get_attr_string_val( target_entry, cfg->spec_attr_name );
if( policy_dn == NULL ) {
slapi_log_err(SLAPI_LOG_PLUGIN, PLUGIN_NAME,
"get_acctpolicy - \"%s\" is not governed by an account inactivity "
"policy subentry\n", slapi_entry_get_ndn( target_entry ) );
if (cfg->inactivitylimit != ULONG_MAX) {
goto dopolicy;
}
slapi_log_err(SLAPI_LOG_PLUGIN, PLUGIN_NAME,
"get_acctpolicy - \"%s\" is not governed by an account inactivity "
"global policy\n", slapi_entry_get_ndn( target_entry ) );
config_unlock();
return rc;
}
sdn = slapi_sdn_new_dn_byref( policy_dn );
ldrc = slapi_search_internal_get_entry( sdn, NULL, &policy_entry,
plugin_id );
slapi_sdn_free( &sdn );
/* There should be a policy but it can't be retrieved; fatal error */
if( policy_entry == NULL ) {
if( ldrc != LDAP_NO_SUCH_OBJECT ) {
slapi_log_err(SLAPI_LOG_ERR, PLUGIN_NAME,
"get_acctpolicy - Error retrieving policy entry \"%s\": %d\n", policy_dn, ldrc );
} else {
slapi_log_err(SLAPI_LOG_PLUGIN, PLUGIN_NAME,
"get_acctpolicy - Policy entry \"%s\" is missing: %d\n", policy_dn, ldrc );
}
rc = -1;
goto done;
}
dopolicy:
*policy = (acctPolicy *)slapi_ch_calloc( 1, sizeof( acctPolicy ) );
if ( !policy_entry ) { /* global policy */
(*policy)->inactivitylimit = cfg->inactivitylimit;
goto done;
}
for( slapi_entry_first_attr( policy_entry, &attr ); attr != NULL;
slapi_entry_next_attr( policy_entry, attr, &attr ) ) {
slapi_attr_get_type(attr, &attr_name);
if( !strcasecmp( attr_name, cfg->limit_attr_name ) ) {
if( slapi_attr_first_value( attr, &sval ) == 0 ) {
(*policy)->inactivitylimit = slapi_value_get_ulong( sval );
}
}
}
done:
config_unlock();
slapi_ch_free_string( &policy_dn );
slapi_entry_free( policy_entry );
return( rc );
}
int s11_sgw_init(const mme_config_t *mme_config_p)
{
int ret = 0;
NwGtpv2cUlpEntityT ulp;
NwGtpv2cUdpEntityT udp;
NwGtpv2cTimerMgrEntityT tmrMgr;
NwGtpv2cLogMgrEntityT logMgr;
struct in_addr addr;
char *s11_address_str = NULL;
S11_DEBUG("Initializing S11 interface\n");
if (nwGtpv2cInitialize(&s11_sgw_stack_handle) != NW_OK) {
S11_ERROR("Failed to initialize gtpv2-c stack\n");
goto fail;
}
/* Set ULP entity */
ulp.hUlp = (NwGtpv2cUlpHandleT)NULL;
ulp.ulpReqCallback = s11_sgw_ulp_process_stack_req_cb;
DevAssert(NW_OK == nwGtpv2cSetUlpEntity(s11_sgw_stack_handle, &ulp));
/* Set UDP entity */
udp.hUdp = (NwGtpv2cUdpHandleT)NULL;
udp.udpDataReqCallback = s11_sgw_send_udp_msg;
DevAssert(NW_OK == nwGtpv2cSetUdpEntity(s11_sgw_stack_handle, &udp));
/* Set Timer entity */
tmrMgr.tmrMgrHandle = (NwGtpv2cTimerMgrHandleT)NULL;
tmrMgr.tmrStartCallback = s11_sgw_start_timer_wrapper;
tmrMgr.tmrStopCallback = s11_sgw_stop_timer_wrapper;
DevAssert(NW_OK == nwGtpv2cSetTimerMgrEntity(s11_sgw_stack_handle, &tmrMgr));
logMgr.logMgrHandle = 0;
logMgr.logReqCallback = s11_sgw_log_wrapper;
DevAssert(NW_OK == nwGtpv2cSetLogMgrEntity(s11_sgw_stack_handle, &logMgr));
if (itti_create_task(TASK_S11, &s11_sgw_thread, NULL) < 0) {
S11_ERROR("gtpv1u phtread_create: %s\n", strerror(errno));
goto fail;
}
DevAssert(NW_OK == nwGtpv2cSetLogLevel(s11_sgw_stack_handle,
NW_LOG_LEVEL_DEBG));
config_read_lock(&mme_config);
addr.s_addr = mme_config.ipv4.sgw_ip_address_for_S11;
config_unlock(&mme_config);
s11_address_str = inet_ntoa(addr);
DevAssert(s11_address_str != NULL);
s11_send_init_udp(s11_address_str, 2123);
S11_DEBUG("Initializing S11 interface: DONE\n");
return ret;
fail:
S11_DEBUG("Initializing S11 interface: FAILURE\n");
return -1;
}
