summaryrefslogtreecommitdiff
path: root/polux/application/agent/src/underlayer.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'polux/application/agent/src/underlayer.cpp')
-rwxr-xr-xpolux/application/agent/src/underlayer.cpp592
1 files changed, 592 insertions, 0 deletions
diff --git a/polux/application/agent/src/underlayer.cpp b/polux/application/agent/src/underlayer.cpp
new file mode 100755
index 0000000000..1552d02314
--- /dev/null
+++ b/polux/application/agent/src/underlayer.cpp
@@ -0,0 +1,592 @@
+
+#include "underlayer.h"
+#include "systemmanager.h"
+
+void Underlayer::setIsInit(bool enabled) {
+ // nothing to do for the real underlayer
+}
+
+int DEBUG_METH(Underlayer::mib_getPlcSystem(struct plc_system * plcSystem) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getPlcSystem begin");
+ LOG_END;
+ return ::mib_getPlcSystem(plcSystem);
+};
+
+int Underlayer::mib_getSysname(char *sysname) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getSysname begin");
+ LOG_END;
+ return ::mib_getSysname(sysname);
+};
+
+int Underlayer::mib_setSysname(char *sysname) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setSysname begin");
+ LOG_END;
+ return ::mib_setSysname(sysname);
+};
+
+int Underlayer::mib_getBridgeMac(struct bridge_mac * bridgeMac) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getBridgeMac begin");
+ LOG_END;
+ return ::mib_getBridgeMac(bridgeMac);
+};
+
+int Underlayer::mib_setBridgeMac(struct bridge_mac * bridgeMac) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setBridgeMac begin");
+ LOG_END;
+ return ::mib_setBridgeMac(bridgeMac);
+};
+
+int Underlayer::mib_getPlcAnalyser(struct plc_analyser * plcAnalyser) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getPlcAnalyser begin");
+ LOG_END;
+ return ::mib_getPlcAnalyser(plcAnalyser);
+};
+
+int Underlayer::mib_setPlcAnalyser(struct plc_analyser * plcAnalyser) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setPlcAnalyser begin");
+ LOG_END;
+ return ::mib_setPlcAnalyser(plcAnalyser);
+};
+
+int Underlayer::mib_setAgcAnalyser(struct agc_analyser * agcAnalyser) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setAgcAnalyser begin");
+ LOG_END;
+ return ::mib_setAgcAnalyser(agcAnalyser);
+};
+
+int Underlayer::mib_getAgcAnalyser(struct agc_analyser * agcAnalyser) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getAgcAnalyser begin");
+ LOG_END;
+ agcAnalyser->period=_DEFAULT_AGC_PERIOD;
+ agcAnalyser->samples=MAX_AGC_SAMPLES;
+ return ::mib_getAgcAnalyser(agcAnalyser);
+};
+
+int Underlayer::mib_getEthMac(struct eth_mac * ethMac) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getEthMac begin");
+ LOG_END;
+ int result = ::mib_getEthMac(ethMac);
+ //ethMac->ifGeneralInformationGroup.ifHighSpeed = ::mib_getEthCurrentSpeed(); // for ETH_STATIC comment this line
+ DEBUG_TXT(ethMac->ifGeneralInformationGroup.ifHighSpeed);
+ return result;
+};
+
+int Underlayer::mib_setEthMac(struct eth_mac * ethMac) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setEthMac begin");
+ LOG_END;
+ return ::mib_setEthMac(ethMac);
+};
+
+int Underlayer::mib_getPlcMac(struct plc_mac * plcMac) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getPlcMac begin");
+ LOG_END;
+ return ::mib_getPlcMac(plcMac);
+};
+
+int Underlayer::mib_setPlcMac(struct plc_mac * plcMac) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setPlcMac begin");
+ LOG_END;
+ return ::mib_setPlcMac(plcMac);
+};
+
+int Underlayer::mib_getHostNb(void) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getHostNb begin");
+ LOG_END;
+ return ::mib_getHostNb();
+};
+
+int Underlayer::mib_getPlcHost(int hostNb, struct plc_host * plcHost) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getPlcHost begin");
+ LOG_END;
+
+
+ struct timeval ct;
+ gettimeofday(&ct, 0);
+ //TEST60slaves
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("BEFORE REFRESH HOST: ");LOG(hostNb);LOG(ct.tv_sec);LOG(" : ");LOG(ct.tv_usec);
+ LOG_END;
+
+ int i = ::mib_getPlcHost(hostNb,plcHost);
+
+ gettimeofday(&ct, 0);
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("AFTER REFRESH HOST: ");LOG(hostNb);LOG(ct.tv_sec);LOG(" : ");LOG(ct.tv_usec);
+ LOG(" with MAC obtained: ");
+ LOG((int)plcHost->macAddress[0]);
+ LOG((int)plcHost->macAddress[1]);
+ LOG((int)plcHost->macAddress[2]);
+ LOG((int)plcHost->macAddress[3]);
+ LOG((int)plcHost->macAddress[4]);
+ LOG((int)plcHost->macAddress[5]);
+ LOG_END;
+
+ return i;
+ //return ::mib_getPlcHost(hostNb,plcHost);
+};
+int Underlayer::mib_setPlcHost(int hostNb, struct plc_host * plcHost) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setPlcHost begin");
+ LOG_END;
+ return ::mib_setPlcHost(hostNb,plcHost);
+};
+
+int Underlayer::mib_getPlcLightHost(int hostNb, struct plc_host * plcHost) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getPlcLightHost begin");
+ LOG_END;
+ return ::mib_getPlcLightHost(hostNb,plcHost);
+};
+
+int Underlayer::mib_getIndexByMac(const unsigned char iMacAddress[6]) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getIndexByMac begin with Mac Address: ");
+ LOG((int)iMacAddress[0]);
+ LOG((int)iMacAddress[1]);
+ LOG((int)iMacAddress[2]);
+ LOG((int)iMacAddress[3]);
+ LOG((int)iMacAddress[4]);
+ LOG((int)iMacAddress[5]);
+ LOG_END;
+ return ::mib_getIndexByMac( iMacAddress);
+};
+
+int Underlayer::mib_getPlcBasePortByIndex(int hostNb, struct plc_base_port * plcBasePort) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getPlcBasePortByIndex begin");
+ LOG_END;
+ return ::mib_getPlcBasePortByIndex(hostNb, plcBasePort);
+};
+
+/* No context for the system_carrier_tab, as the system is unique */
+int Underlayer::mib_getSystemCarrier(struct system_carrier_tab * systemCarrierTab) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getSystemCarrier begin");
+ LOG_END;
+ return ::mib_getSystemCarrier(systemCarrierTab);
+};
+
+int Underlayer::mib_setSystemCarrier(struct system_carrier_tab * systemCarrierTab) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setSystemCarrier begin");
+ LOG_END;
+ return ::mib_setSystemCarrier(systemCarrierTab);
+};
+
+int Underlayer::mib_setFlatAdapt(void) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setFlatAdapt begin");
+ LOG_END;
+ return ::mib_setFlatAdapt();
+};
+
+void Underlayer::mib_commit(void) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_commit begin");
+ LOG_END;
+ ::mib_commit();
+};
+
+void Underlayer::mib_boardReset(void) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_boardReset begin");
+ LOG_END;
+ ::mib_boardReset();
+};
+
+#ifdef __LINUX__
+int Underlayer::init_socket(void) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("init_socket begin");
+ LOG_END;
+ return ::init_socket();
+};
+
+void Underlayer::close_socket(void) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("close_socket begin");
+ LOG_END;
+ return ::close_socket();
+};
+
+#endif /*__LINUX__*/
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_openFTP(char ftpServerIp[16], uint16_t ftpServerPort, char* login, char* passwd) {)
+ DEBUG_VAR(ftpServerIp);
+ DEBUG_VAR(ftpServerPort);
+ DEBUG_VAR(login);
+ DEBUG_VAR(passwd);
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_openFTP begin");
+ LOG_END;
+ return ::mib_openFTP(ftpServerIp,ftpServerPort,login,passwd);
+};
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_closeFTP(void) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_closeFTP begin");
+ LOG_END;
+ return ::mib_closeFTP();
+};
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_upgradeSoftware(char *ftpIp, uint16_t ftp_port, char* login, char* passwd, char* remoteFile) {)
+ DEBUG_VAR(ftpIp);
+ DEBUG_VAR(ftp_port);
+ DEBUG_VAR(login);
+ DEBUG_VAR(passwd);
+ DEBUG_VAR(remoteFile);
+
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_upgradeSoftware begin");
+ LOG_END;
+ return ::mib_upgradeSoftware(ftpIp,ftp_port,login,passwd,remoteFile);
+};
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_getLastUploadStatus(void) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getLastUploadStatus begin");
+ LOG_END;
+ return ::mib_getLastUploadStatus();
+};
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_getSoftwareRelease(char releaseName[10][32]) {)
+ return ::mib_getSoftwareRelease(releaseName);
+};
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_commitSoftwareUpgrade(char* softwareName) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_commitSoftwareUpgrade begin");
+ LOG_END;
+ DEBUG_VAR(softwareName);
+ enum mib_softUpgRc returnValue = ::mib_commitSoftwareUpgrade(softwareName);
+ SystemManager::instance()->PlcSystem();
+ return returnValue;
+};
+
+enum mib_softUpgRc DEBUG_METH(Underlayer::mib_eraseRelease(char *releaseName) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_eraseRelease begin");
+ LOG_END;
+ DEBUG_VAR(releaseName);
+ enum mib_softUpgRc returnValue = ::mib_eraseRelease(releaseName);
+ SystemManager::instance()->PlcSystem();
+ return returnValue;
+};
+
+void DEBUG_METH(Underlayer::mib_get_bootstats(int *boot, int *manual_reset, int *failure_reset) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_bootstats begin");
+ LOG_END;
+ return ::mib_get_bootstats(boot,manual_reset,failure_reset);
+};
+
+// development for SPiDmonitor v2.0
+
+bool DEBUG_METH(Underlayer::mib_get_stp_enabled(unsigned char Interface ) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_stp_enabled begin");
+ LOG_END;
+ return ( ::mib_getSTPMode() == BRIDGE_STP_ON );
+}
+
+void DEBUG_METH(Underlayer::mib_set_stp_enabled(bool enabled,unsigned char Interface) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_stp_enabled begin");
+ LOG_END;
+ ::mib_setSTPMode(( enabled ? BRIDGE_STP_ON : BRIDGE_STP_OFF));
+}
+
+int DEBUG_METH(Underlayer::mib_getEthCurrentMode(enumDuplex_t& oMode) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getEthCurrentMode begin");
+ LOG_END;
+ int result = ::mib_getEthCurrentMode(&oMode);
+ DEBUG_VAR(result);
+ DEBUG_VAR(oMode);
+ return result;
+}
+
+enumDuplex_t DEBUG_METH(Underlayer::mib_getWishedEthMode() {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getWishedEthMode begin");
+ LOG_END;
+ return ::mib_getWishedEthMode();
+}
+
+int DEBUG_METH(Underlayer::mib_setWishedEthMode(int mode) {)
+ DEBUG_TXT("Underlayer::mib_setWishedEthMode begin");
+
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setWishedEthMode begin");
+ LOG_END;
+ if (mode == ETH_MODE_HD)
+ return ::mib_setWishedEthMode(ETH_MODE_HD);
+ else if (mode == ETH_MODE_FD)
+ return ::mib_setWishedEthMode(ETH_MODE_FD);
+ else if (mode == ETH_MODE_AUTO )
+ return ::mib_setWishedEthMode(ETH_MODE_AUTO);
+ else
+ return -1;
+
+
+}
+
+/*bool DEBUG_METH(Underlayer::mib_get_eth_auto_mode() {)
+ return m_isEthModeAutoNeg;
+}
+
+void DEBUG_METH(Underlayer::mib_set_eth_auto_mode(bool enabled) {)
+ if ( enabled ) {
+ DEBUG_TXT("Underlayer::mib_set_eth_auto_mode, before mib_setEthMode()");
+ ::mib_setWishedEthSpeed(ETH_SPEED_AUTO);
+ DEBUG_TXT("Underlayer::mib_set_eth_auto_mode, after mib_setEthMode()");
+ m_isEthModeAutoNeg = true;
+ }
+ else {
+ m_isEthModeAutoNeg = false;
+ }
+}*/
+
+int DEBUG_METH(Underlayer::mib_get_bridge_admin_status() {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_bridge_admin_status begin");
+ LOG_END;
+ return ::mib_getBridgeForwarding();
+}
+
+void DEBUG_METH(Underlayer::mib_set_bridge_admin_status(int status) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_bridge_admin_status begin");
+ LOG_END;
+ ::mib_setBridgeForwarding(status);
+}
+
+int DEBUG_METH(Underlayer::mib_getEthCurrentSpeed(enumSpeed_t& oSpeed) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getEthCurrentSpeed begin");
+ LOG_END;
+ int result = ::mib_getEthCurrentSpeed(&oSpeed);
+ DEBUG_VAR(result);
+ DEBUG_VAR(oSpeed);
+ return result;
+ //long result = ETHERNET_SPEED_FACTOR *
+ //DEBUG_TXT(result);
+ //return result;
+}
+
+enumSpeed_t DEBUG_METH(Underlayer::mib_getWishedEthSpeed(void) {)
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getWishedEthSpeed begin");
+ LOG_END;
+ enumSpeed_t result = ::mib_getWishedEthSpeed();
+ DEBUG_TXT(result);
+ return result;
+}
+
+
+int DEBUG_METH(Underlayer::mib_setWishedEthSpeed(long speed) {)
+ DEBUG_TXT("Underlayer::mib_set_eth_speed, before mib_setEthSpeed()");
+ DEBUG_TXT(speed);
+
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_setWishedEthSpeed begin");
+ LOG_END;
+
+ if (speed == ETH_SPEED_10 )
+ return ::mib_setWishedEthSpeed(ETH_SPEED_10);
+ else if (speed == ETH_SPEED_100 )
+ return ::mib_setWishedEthSpeed(ETH_SPEED_100);
+ else if (speed == ETH_SPEED_AUTO )
+ return ::mib_setWishedEthSpeed(ETH_SPEED_AUTO);
+ else
+ return -1;
+}
+
+/*bool DEBUG_METH(Underlayer::mib_get_eth_auto_speed() {)
+ return m_isEthSpeedAutoNeg;
+}
+
+void DEBUG_METH(Underlayer::mib_set_eth_auto_speed(bool enabled) {)
+ if ( enabled ) {
+ DEBUG_TXT("Underlayer::mib_set_eth_auto_speed, before mib_setEthSpeed()");
+ ::mib_setWishedEthSpeed(ETH_SPEED_AUTO);
+ DEBUG_TXT("Underlayer::mib_set_eth_auto_speed, after mib_setEthSpeed()");
+ m_isEthSpeedAutoNeg = true;
+ }
+ else {
+ m_isEthSpeedAutoNeg = false;
+ }
+} */
+
+bool Underlayer::mib_get_plc_is_spy_dynamic() {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_plc_is_spy_dynamic begin");
+ LOG_END;
+ return ::mib_get_plc_spy();
+}
+
+void Underlayer::mib_set_plc_is_spy_dynamic(bool enabled) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_plc_is_spy_dynamic begin");
+ LOG_END;
+ ::mib_set_plc_spy(enabled);
+}
+
+unsigned int Underlayer::mib_get_plc_static_spy_synch_band_nb() {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_plc_static_spy_synch_band_nb begin");
+ LOG_END;
+ return ::mib_getStaticBand();
+}
+
+void Underlayer::mib_set_plc_static_spy_synch_band_nb(unsigned int bandNb) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_plc_static_spy_synch_band_nb begin");
+ LOG_END;
+ ::mib_setStaticBand(bandNb);
+}
+
+bool Underlayer::mib_get_plc_segmentation_and_reassembly() {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_plc_segmentation_and_reassembly begin");
+ LOG_END;
+ return ::mib_get_plc_segmentation_and_reassembly();
+}
+
+void Underlayer::mib_set_plc_segmentation_and_reassembly(bool enabled) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_plc_segmentation_and_reassembly begin");
+ LOG_END;
+ ::mib_set_plc_segmentation_and_reassembly(enabled);
+}
+
+bool Underlayer::mib_get_plc_power_equalization() {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_plc_power_equalization begin");
+ LOG_END;
+ return ::mib_get_plc_power_equalization();
+}
+
+void Underlayer::mib_set_plc_power_equalization(bool enabled) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_plc_power_equalization begin");
+ LOG_END;
+ ::mib_set_plc_power_equalization(enabled);
+}
+
+unsigned int Underlayer::mib_get_plc_bss_id() {
+ return ::mib_get_plc_bssid();
+}
+
+void Underlayer::mib_set_plc_bss_id(unsigned int bssId) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_plc_bss_id begin");
+ LOG_END;
+ ::mib_set_plc_bssid(bssId);
+}
+
+
+unsigned int Underlayer::mib_get_plc_preferred_bss_id() {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_plc_preferred_bss_id begin");
+ LOG_END;
+ return ::mib_get_plc_preferred_bssid();
+}
+
+void Underlayer::mib_set_plc_preferred_bss_id(unsigned int bssId) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_plc_preferred_bss_id begin");
+ LOG_END;
+ ::mib_set_plc_preferred_bssid(bssId);
+}
+
+
+
+unsigned long int Underlayer::mib_get_radius_auth_ip() {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return 0;
+}
+
+int Underlayer::mib_get_radius_auth_port() {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return 0;
+}
+
+char *Underlayer::mib_get_radius_auth_password() {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return 0;
+}
+
+int Underlayer::mib_get_radius_auth_method() {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return 0;
+}
+
+char* Underlayer::mib_get_radius_auth_username() {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return 0;
+}
+
+bool Underlayer::mib_set_radius_master_authentication(int authMethod,
+ unsigned long radiusAuthServerAddressInt,
+ long radiusAuthClientServerPortNumber,
+ const char *radiusPassword) {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return true;
+}
+
+bool Underlayer::mib_set_radius_slave_authentication(const char *radiusUserName,
+ const char *radiusPassword) {
+ // TO DO, CODE THE REAL CALL TO THE KERNEL SNMP_AGENT_WORK
+ return true;
+}
+
+
+void Underlayer::mib_set_is_ip_dynamic(bool isDynamic) {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_set_is_ip_dynamic begin");
+ LOG_END;
+ ::mib_setDHCPMode(isDynamic);
+}
+
+bool Underlayer::mib_get_is_ip_dynamic() {
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_get_is_ip_dynamic begin");
+ LOG_END;
+ return mib_getDHCPMode();
+}
+
+
+//---- FD01: BEGIN SNMP community
+bool Underlayer::mib_get_SNMP_community(char * pSnmp_GET_community_name, char * pSnmp_SET_community_name){
+ LOG_BEGIN(DEBUG_LOG);
+ LOG("mib_getSNMPCommunity begin");
+ LOG_END;
+ bool result = false;
+
+ if (0 == ::mib_get_SNMP_community(pSnmp_GET_community_name,pSnmp_SET_community_name ) ){
+ result = true;}
+
+ return result;
+}
+//---- FD01: END SNMP community
+
+/*void Underlayer::mib_mac_add_to_str_ip(char* strIp,const unsigned char macAdd[],const char* dev) {
+ DEBUG_TXT("mib_mac_add_to_str_ip");
+ ::mib_mac_add_to_str_ip(strIp,macAdd,dev);
+}*/