/* 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; }