Examples with AuthType org.eclipse.kura.net.modem.ModemConfig.AuthType used on opensource projects

Example 1 with AuthType

use of org.eclipse.kura.net.modem.ModemConfig.AuthType in project kura by eclipse.

the class NetworkConfiguration method getModemConfig.

private static ModemConfig getModemConfig(String prefix, Map<String, Object> properties) throws KuraException {
    String key;
    ModemConfig modemConfig = new ModemConfig();
    // apn
    key = prefix + "apn";
    String apn = (String) properties.get(key);
    s_logger.trace("APN is {}", apn);
    modemConfig.setApn(apn);
    // auth type
    key = prefix + "authType";
    String authTypeString = (String) properties.get(key);
    AuthType authType = AuthType.NONE;
    s_logger.trace("Auth type is {}", authTypeString);
    if (authTypeString != null && !authTypeString.isEmpty()) {
        try {
            authType = AuthType.valueOf(authTypeString);
        } catch (IllegalArgumentException e) {
            throw new KuraException(KuraErrorCode.INTERNAL_ERROR, "Could not parse auth type " + authTypeString);
        }
    } else {
        s_logger.trace("Auth type is null");
    }
    modemConfig.setAuthType(authType);
    // data compression
    key = prefix + "dataCompression";
    if (properties.get(key) != null) {
        int dataCompression = (Integer) properties.get(key);
        s_logger.trace("Data compression is {}", dataCompression);
        modemConfig.setDataCompression(dataCompression);
    } else {
        s_logger.trace("Data compression is null");
    }
    // dial string
    key = prefix + "dialString";
    String dialString = (String) properties.get(key);
    s_logger.trace("Dial string is {}", dialString);
    modemConfig.setDialString(dialString);
    // header compression
    key = prefix + "headerCompression";
    if (properties.get(key) != null) {
        int headerCompression = (Integer) properties.get(key);
        s_logger.trace("Header compression is {}", headerCompression);
        modemConfig.setHeaderCompression(headerCompression);
    } else {
        s_logger.trace("Header compression is null");
    }
    // ip address
    String ipAddressString = (String) properties.get(prefix + "ipAddress");
    IPAddress ipAddress = null;
    s_logger.trace("IP address is {}", ipAddressString);
    if (ipAddressString != null && !ipAddressString.isEmpty()) {
        try {
            IPAddress.parseHostAddress(ipAddressString);
        } catch (UnknownHostException e) {
            throw new KuraException(KuraErrorCode.INTERNAL_ERROR, "Could not parse ip address " + ipAddressString);
        }
    } else {
        s_logger.trace("IP address is null");
    }
    modemConfig.setIpAddress(ipAddress);
    // password
    String password = (String) properties.get(prefix + "password");
    s_logger.trace("Password is {}", password);
    modemConfig.setPassword(password);
    // pdp type
    String pdpTypeString = (String) properties.get(prefix + "pdpType");
    PdpType pdpType = PdpType.UNKNOWN;
    if (pdpTypeString != null && !pdpTypeString.isEmpty()) {
        try {
            pdpType = PdpType.valueOf(pdpTypeString);
        } catch (IllegalArgumentException e) {
            throw new KuraException(KuraErrorCode.INTERNAL_ERROR, "Could not parse pdp type " + pdpTypeString);
        }
    }
    s_logger.trace("Pdp type is {}", pdpTypeString);
    modemConfig.setPdpType(pdpType);
    // profile id
    key = prefix + "profileId";
    if (properties.get(key) != null) {
        int profileId = (Integer) properties.get(key);
        s_logger.trace("Profile id is {}", profileId);
        modemConfig.setProfileID(profileId);
    } else {
        s_logger.trace("Profile id is null");
    }
    // ppp number
    key = prefix + "pppNum";
    if (properties.get(key) != null) {
        int pppNum = (Integer) properties.get(key);
        s_logger.trace("PPP number is {}", pppNum);
        modemConfig.setPppNumber(pppNum);
    } else {
        s_logger.trace("PPP number is null");
    }
    // persist
    key = prefix + "persist";
    if (properties.get(key) != null) {
        boolean persist = (Boolean) properties.get(key);
        s_logger.trace("persist is {}", persist);
        modemConfig.setPersist(persist);
    } else {
        s_logger.trace("persist is null");
    }
    // max fail
    key = prefix + "maxFail";
    if (properties.get(key) != null) {
        int maxFail = (Integer) properties.get(key);
        s_logger.trace("maxfail is {}", maxFail);
        modemConfig.setMaxFail(maxFail);
    } else {
        s_logger.trace("maxfail is null");
    }
    // resetTimeout
    key = prefix + "resetTimeout";
    if (properties.get(key) != null) {
        int resetTimeout = (Integer) properties.get(key);
        s_logger.trace("resetTimeout is {}", resetTimeout);
        modemConfig.setResetTimeout(resetTimeout);
    } else {
        s_logger.trace("resetTimeout is null");
    }
    // idle
    key = prefix + "idle";
    if (properties.get(key) != null) {
        int idle = (Integer) properties.get(key);
        s_logger.trace("idle is {}", idle);
        modemConfig.setIdle(idle);
    } else {
        s_logger.trace("idle is null");
    }
    // active filter
    key = prefix + "activeFilter";
    if (properties.get(key) != null) {
        String activeFilter = (String) properties.get(key);
        s_logger.trace("activeFilter is {}", activeFilter);
        modemConfig.setActiveFilter(activeFilter);
    } else {
        s_logger.trace("activeFilter is null");
    }
    // LCP echo interval
    key = prefix + "lcpEchoInterval";
    if (properties.get(key) != null) {
        int lcpEchoInterval = (Integer) properties.get(key);
        s_logger.trace("LCP Echo Interval is {}", lcpEchoInterval);
        modemConfig.setLcpEchoInterval(lcpEchoInterval);
    } else {
        s_logger.trace("LCP Echo Interval is null");
    }
    // LCP echo failure
    key = prefix + "lcpEchoFailure";
    if (properties.get(key) != null) {
        int lcpEchoFailure = (Integer) properties.get(key);
        s_logger.trace("LCP Echo Failure is {}", lcpEchoFailure);
        modemConfig.setLcpEchoFailure(lcpEchoFailure);
    } else {
        s_logger.trace("LCP Echo Failure is null");
    }
    // username
    String username = (String) properties.get(prefix + "username");
    s_logger.trace("Username is {}", username);
    modemConfig.setUsername(username);
    // enabled
    key = prefix + "enabled";
    boolean enabled = false;
    if (properties.get(key) != null) {
        enabled = (Boolean) properties.get(key);
        s_logger.trace("Enabled is {}", enabled);
    } else {
        s_logger.trace("Enabled is null");
    }
    modemConfig.setEnabled(enabled);
    // GPS enabled
    key = prefix + "gpsEnabled";
    boolean gpsEnabled = false;
    if (properties.get(key) != null) {
        gpsEnabled = (Boolean) properties.get(key);
        s_logger.trace("GPS Enabled is {}", gpsEnabled);
    } else {
        s_logger.trace("GPS Enabled is null");
    }
    modemConfig.setGpsEnabled(gpsEnabled);
    return modemConfig;
}

Example 2 with AuthType

use of org.eclipse.kura.net.modem.ModemConfig.AuthType in project kura by eclipse.

the class PppConfigReader method getModemConfig.

private static ModemConfig getModemConfig(String ifaceName, UsbDevice usbDevice) throws KuraException {
    s_logger.debug("parsePppPeerConfig()");
    boolean isGsmGprsUmtsHspa = false;
    List<ModemTechnologyType> technologyTypes = null;
    if (usbDevice != null) {
        SupportedUsbModemInfo usbModemInfo = SupportedUsbModemsInfo.getModem(usbDevice);
        if (usbModemInfo != null) {
            technologyTypes = usbModemInfo.getTechnologyTypes();
        }
    } else {
        SupportedSerialModemInfo serialModemInfo = SupportedSerialModemsInfo.getModem();
        if (serialModemInfo != null) {
            technologyTypes = serialModemInfo.getTechnologyTypes();
        }
    }
    if (technologyTypes != null) {
        for (ModemTechnologyType technologyType : technologyTypes) {
            if (technologyType == ModemTechnologyType.GSM_GPRS || technologyType == ModemTechnologyType.UMTS || technologyType == ModemTechnologyType.HSDPA || technologyType == ModemTechnologyType.HSPA) {
                isGsmGprsUmtsHspa = true;
                break;
            }
        }
    }
    boolean enabled = true;
    int unitNum = getUnitNum(ifaceName);
    String apn = "";
    String pdpType = "UNKNOWN";
    String dialString = "";
    String username = "";
    String password = "";
    String model = "";
    AuthType authType = AuthType.NONE;
    boolean persist = false;
    int maxFail = 0;
    int idle = 0;
    String activeFilter = "";
    int lcpEchoInterval = 0;
    int lcpEchoFailure = 0;
    String peerFilename = getPeerFilename(ifaceName, usbDevice);
    File peerFile = new File(peerFilename);
    if (!peerFile.exists()) {
        persist = true;
        maxFail = 5;
        idle = 95;
        activeFilter = "inbound";
        s_logger.warn("getModemConfig() :: PPPD peer file does not exist - {}", peerFilename);
    } else {
        s_logger.debug("getModemConfig() :: PPPD peer file exists - {}", peerFilename);
        // Check if peer file is a symlink. If so, get information from the linked filename.
        try {
            if (!peerFile.getCanonicalPath().equals(peerFile.getAbsolutePath())) {
                Map<String, String> fileInfo = PppUtil.parsePeerFilename(peerFile.getCanonicalFile().getName());
                fileInfo.get("technology");
                model = fileInfo.get("model");
                fileInfo.get("serialNum");
                fileInfo.get("modemId");
            }
        } catch (IOException e) {
            s_logger.error("Error checking for symlink", e);
        }
        Properties props = new Properties();
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(peerFilename);
            props.load(fis);
        } catch (Exception e) {
            throw new KuraException(KuraErrorCode.INTERNAL_ERROR, "Error getting modem config", e);
        } finally {
            if (null != fis) {
                try {
                    fis.close();
                } catch (IOException e) {
                    throw new KuraException(KuraErrorCode.INTERNAL_ERROR, "Error getting modem config", e);
                }
            }
        }
        s_logger.debug("peer properties: {}", props);
        if (props.getProperty("unit") != null) {
            unitNum = Integer.parseInt(props.getProperty("unit"));
        }
        if (props.getProperty("user") != null) {
            username = removeQuotes(props.getProperty("user"));
        }
        if (props.getProperty("persist") != null) {
            persist = true;
        }
        if (props.getProperty("maxfail") != null) {
            maxFail = Integer.parseInt(props.getProperty("maxfail"));
        }
        if (props.getProperty("idle") != null) {
            idle = Integer.parseInt(props.getProperty("idle"));
        }
        if (props.getProperty("active-filter") != null) {
            activeFilter = removeQuotes(props.getProperty("active-filter"));
        }
        if (props.getProperty("lcp-echo-interval") != null) {
            lcpEchoInterval = Integer.parseInt(props.getProperty("lcp-echo-interval"));
        }
        if (props.getProperty("lcp-echo-failure") != null) {
            lcpEchoFailure = Integer.parseInt(props.getProperty("lcp-echo-failure"));
        }
        String chatFilename = "";
        String connectProperty = removeQuotes(props.getProperty("connect"));
        String[] args = connectProperty.split("\\s+");
        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("-f") && args.length > i + 1) {
                chatFilename = args[i + 1];
                break;
            }
        }
        // String disconnectFilename = "";
        // String disconnectProperty = removeQuotes(props.getProperty("disconnect"));
        // args = disconnectProperty.split("\\s+");
        // for(int i=0; i<args.length; i++) {
        // if(args[i].equals("-f") && args.length > i+1) {
        // disconnectFilename = args[i+1];
        // break;
        // }
        // }
        // Parse the connect script
        ModemXchangeScript connectScript = null;
        try {
            connectScript = ModemXchangeScript.parseFile(chatFilename);
        } catch (Exception e) {
            throw new KuraException(KuraErrorCode.INTERNAL_ERROR, "Error parsing " + chatFilename, e);
        }
        if (connectScript != null) {
            ModemXchangePair modemXchangePair = connectScript.getFirstModemXchangePair();
            ModemXchangePair prevXchangePair = null;
            String expectedStr, sendStr;
            while (modemXchangePair != null) {
                expectedStr = modemXchangePair.getExpectString();
                sendStr = removeQuotes(modemXchangePair.getSendString());
                if (expectedStr.equals("OK")) {
                    // apn
                    if (sendStr.contains(",")) {
                        String[] sendArgs = sendStr.split(",");
                        if (sendArgs.length == 3 && isGsmGprsUmtsHspa) {
                            pdpType = removeQuotes(sendArgs[1]);
                            apn = removeQuotes(sendArgs[2]);
                        }
                    }
                // } else if(expectedStr.equals("\"\"")) {
                } else if (expectedStr.equals("CONNECT")) {
                    // dial string
                    if (prevXchangePair != null) {
                        dialString = removeQuotes(prevXchangePair.getSendString());
                    }
                }
                prevXchangePair = modemXchangePair;
                modemXchangePair = connectScript.getNextModemXchangePair();
            }
        }
        s_logger.debug("* Enabled: {}", enabled);
        s_logger.debug("* CHAT file: {}", chatFilename);
        s_logger.debug("* UnitNum: {}", unitNum);
        s_logger.debug("* dial string: {}", dialString);
        s_logger.debug("* persist: {}", persist);
        s_logger.debug("* maxfail: {}", maxFail);
        s_logger.debug("* idle: {}", idle);
        s_logger.debug("* active-filter: {}", activeFilter);
        s_logger.debug("* LCP Echo Interval: {}", lcpEchoInterval);
        s_logger.debug("* LCP Echo Failure: {}", lcpEchoFailure);
        // Get the auth type and credentials
        // pppd will use CHAP if available, else PAP
        password = "";
        if (isGsmGprsUmtsHspa) {
            String chapSecret = ChapLinux.getInstance().getSecret(model, username, "*", "*");
            String papSecret = PapLinux.getInstance().getSecret(model, username, "*", "*");
            if (chapSecret != null && papSecret != null && chapSecret.equals(papSecret)) {
                authType = AuthType.AUTO;
                password = chapSecret;
            } else if (chapSecret != null) {
                authType = AuthType.CHAP;
                password = chapSecret;
            } else if (papSecret != null) {
                authType = AuthType.PAP;
                password = papSecret;
            }
            s_logger.debug("* APN: {}", apn);
            s_logger.debug("* auth: {}", authType);
            s_logger.debug("* username: {}", username);
            s_logger.debug("* password: {}", password);
        }
    }
    boolean gpsEnabled = false;
    StringBuilder key = new StringBuilder().append("net.interface.").append(ifaceName).append(".config.gpsEnabled");
    String statusString = KuranetConfig.getProperty(key.toString());
    if (statusString != null && !statusString.isEmpty()) {
        gpsEnabled = Boolean.parseBoolean(statusString);
    }
    int resetTout = 5;
    key = new StringBuilder().append("net.interface.").append(ifaceName).append(".config.resetTimeout");
    statusString = KuranetConfig.getProperty(key.toString());
    if (statusString != null && !statusString.isEmpty()) {
        resetTout = Integer.parseInt(statusString);
    }
    // Populate the modem config
    ModemConfig modemConfig = new ModemConfig();
    modemConfig.setPppNumber(unitNum);
    modemConfig.setPersist(persist);
    modemConfig.setMaxFail(maxFail);
    modemConfig.setIdle(idle);
    modemConfig.setActiveFilter(activeFilter);
    modemConfig.setLcpEchoInterval(lcpEchoInterval);
    modemConfig.setLcpEchoFailure(lcpEchoFailure);
    // TODO - from self configuring properties
    modemConfig.setEnabled(enabled);
    // FIXME
    modemConfig.setDataCompression(0);
    modemConfig.setDialString(dialString);
    // FIXME
    modemConfig.setHeaderCompression(0);
    modemConfig.setGpsEnabled(gpsEnabled);
    modemConfig.setResetTimeout(resetTout);
    if (isGsmGprsUmtsHspa) {
        modemConfig.setApn(apn);
        modemConfig.setAuthType(authType);
        modemConfig.setPassword(password);
        modemConfig.setPdpType(PdpType.valueOf(pdpType.toUpperCase()));
        modemConfig.setUsername(username);
    }
    return modemConfig;
}

Example 3 with AuthType

use of org.eclipse.kura.net.modem.ModemConfig.AuthType in project kura by eclipse.

the class GwtNetworkServiceImpl method privateFindNetInterfaceConfigurations.

@SuppressWarnings({ "unchecked", "rawtypes" })
private List<GwtNetInterfaceConfig> privateFindNetInterfaceConfigurations() throws GwtKuraException {
    s_logger.debug("Starting");
    List<GwtNetInterfaceConfig> gwtNetConfigs = new ArrayList<GwtNetInterfaceConfig>();
    NetworkAdminService nas = null;
    try {
        nas = ServiceLocator.getInstance().getService(NetworkAdminService.class);
    } catch (Throwable t) {
        s_logger.warn("Exception", t);
        return gwtNetConfigs;
    }
    ModemManagerService modemManagerService = null;
    try {
        modemManagerService = ServiceLocator.getInstance().getService(ModemManagerService.class);
    } catch (Throwable t) {
        s_logger.warn("{ModemManagerService} Exception", t);
    }
    WifiClientMonitorService wifiClientMonitorService = null;
    try {
        wifiClientMonitorService = ServiceLocator.getInstance().getService(WifiClientMonitorService.class);
    } catch (Throwable t) {
        s_logger.warn("{WifiClientMonitorService} Exception", t);
    }
    try {
        GwtNetInterfaceConfig gwtNetConfig = null;
        for (NetInterfaceConfig<? extends NetInterfaceAddressConfig> netIfConfig : nas.getNetworkInterfaceConfigs()) {
            s_logger.debug("Getting config for {} with type {}", netIfConfig.getName(), netIfConfig.getType());
            s_logger.debug("Interface State: {}", netIfConfig.getState());
            if (netIfConfig.getType() == NetInterfaceType.WIFI) {
                gwtNetConfig = new GwtWifiNetInterfaceConfig();
            } else if (netIfConfig.getType() == NetInterfaceType.MODEM) {
                gwtNetConfig = new GwtModemInterfaceConfig();
                ((GwtModemInterfaceConfig) gwtNetConfig).setModemId(((ModemInterface) netIfConfig).getModemIdentifier());
                ((GwtModemInterfaceConfig) gwtNetConfig).setManufacturer(((ModemInterface) netIfConfig).getManufacturer());
                ((GwtModemInterfaceConfig) gwtNetConfig).setModel(((ModemInterface) netIfConfig).getModel());
                List<String> technologyList = new ArrayList<String>();
                List<ModemTechnologyType> technologyTypes = ((ModemInterface) netIfConfig).getTechnologyTypes();
                if (technologyTypes != null) {
                    for (ModemTechnologyType techType : technologyTypes) {
                        technologyList.add(techType.name());
                    }
                }
                ((GwtModemInterfaceConfig) gwtNetConfig).setNetworkTechnology(technologyList);
            } else {
                gwtNetConfig = new GwtNetInterfaceConfig();
                gwtNetConfig.setHwRssi("N/A");
            }
            gwtNetConfig.setName(netIfConfig.getName());
            gwtNetConfig.setHwName(netIfConfig.getName());
            if (netIfConfig.getType() != null) {
                gwtNetConfig.setHwType(netIfConfig.getType().name());
            }
            if (netIfConfig.getState() != null) {
                gwtNetConfig.setHwState(netIfConfig.getState().name());
            }
            s_logger.debug("MAC: {}", NetUtil.hardwareAddressToString(netIfConfig.getHardwareAddress()));
            gwtNetConfig.setHwAddress(NetUtil.hardwareAddressToString(netIfConfig.getHardwareAddress()));
            gwtNetConfig.setHwDriver(netIfConfig.getDriver());
            gwtNetConfig.setHwDriverVersion(netIfConfig.getDriverVersion());
            gwtNetConfig.setHwFirmware(netIfConfig.getFirmwareVersion());
            gwtNetConfig.setHwMTU(netIfConfig.getMTU());
            if (netIfConfig.getUsbDevice() != null) {
                gwtNetConfig.setHwUsbDevice(netIfConfig.getUsbDevice().getUsbDevicePath());
            } else {
                gwtNetConfig.setHwUsbDevice("N/A");
            }
            List<? extends NetInterfaceAddressConfig> addressConfigs = netIfConfig.getNetInterfaceAddresses();
            if (addressConfigs != null && !addressConfigs.isEmpty()) {
                for (NetInterfaceAddressConfig addressConfig : addressConfigs) {
                    // current status - not configuration!
                    if (addressConfig.getAddress() != null) {
                        s_logger.debug("current address: {}", addressConfig.getAddress().getHostAddress());
                    }
                    if (addressConfig.getNetworkPrefixLength() >= 0 && addressConfig.getNetworkPrefixLength() <= 32) {
                        s_logger.debug("current prefix length: {}", addressConfig.getNetworkPrefixLength());
                    }
                    if (addressConfig.getNetmask() != null) {
                        s_logger.debug("current netmask: {}", addressConfig.getNetmask().getHostAddress());
                    }
                    List<NetConfig> netConfigs = addressConfig.getConfigs();
                    if (netConfigs != null && !netConfigs.isEmpty()) {
                        boolean isNatEnabled = false;
                        boolean isDhcpServerEnabled = false;
                        for (NetConfig netConfig : netConfigs) {
                            if (netConfig instanceof NetConfigIP4) {
                                s_logger.debug("Setting up NetConfigIP4 with status {}", ((NetConfigIP4) netConfig).getStatus().toString());
                                // we are enabled - for LAN or WAN?
                                if (((NetConfigIP4) netConfig).getStatus() == NetInterfaceStatus.netIPv4StatusEnabledLAN) {
                                    gwtNetConfig.setStatus(GwtNetIfStatus.netIPv4StatusEnabledLAN.name());
                                } else if (((NetConfigIP4) netConfig).getStatus() == NetInterfaceStatus.netIPv4StatusEnabledWAN) {
                                    gwtNetConfig.setStatus(GwtNetIfStatus.netIPv4StatusEnabledWAN.name());
                                } else {
                                    gwtNetConfig.setStatus(GwtNetIfStatus.netIPv4StatusDisabled.name());
                                }
                                if (((NetConfigIP4) netConfig).isDhcp()) {
                                    gwtNetConfig.setConfigMode(GwtNetIfConfigMode.netIPv4ConfigModeDHCP.name());
                                    // since DHCP - populate current data
                                    if (addressConfig.getAddress() != null) {
                                        gwtNetConfig.setIpAddress(addressConfig.getAddress().getHostAddress());
                                    } else {
                                        gwtNetConfig.setIpAddress("");
                                    }
                                    if (addressConfig.getNetworkPrefixLength() >= 0 && addressConfig.getNetworkPrefixLength() <= 32) {
                                        gwtNetConfig.setSubnetMask(NetworkUtil.getNetmaskStringForm(addressConfig.getNetworkPrefixLength()));
                                    } else {
                                        if (addressConfig.getNetmask() != null) {
                                            gwtNetConfig.setSubnetMask(addressConfig.getNetmask().getHostAddress());
                                        } else {
                                            gwtNetConfig.setSubnetMask("");
                                        }
                                    }
                                    if (addressConfig.getGateway() != null) {
                                        gwtNetConfig.setGateway(addressConfig.getGateway().getHostAddress());
                                    } else {
                                        gwtNetConfig.setGateway("");
                                    }
                                    // DHCP supplied DNS servers
                                    StringBuffer sb = new StringBuffer();
                                    List<? extends IPAddress> dnsServers = addressConfig.getDnsServers();
                                    if (dnsServers != null && !dnsServers.isEmpty()) {
                                        String sep = "";
                                        for (IPAddress dnsServer : dnsServers) {
                                            sb.append(sep).append(dnsServer.getHostAddress());
                                            sep = "\n";
                                        }
                                        s_logger.debug("DNS Servers: {}", sb);
                                        gwtNetConfig.setReadOnlyDnsServers(sb.toString());
                                    } else {
                                        s_logger.debug("DNS Servers: [empty String]");
                                        gwtNetConfig.setReadOnlyDnsServers("");
                                    }
                                } else {
                                    gwtNetConfig.setConfigMode(GwtNetIfConfigMode.netIPv4ConfigModeManual.name());
                                    // TODO - should we throw an error if current state doesn't match configuration?
                                    if (((NetConfigIP4) netConfig).getAddress() != null) {
                                        gwtNetConfig.setIpAddress(((NetConfigIP4) netConfig).getAddress().getHostAddress());
                                    } else {
                                        gwtNetConfig.setIpAddress("");
                                    }
                                    if (((NetConfigIP4) netConfig).getSubnetMask() != null) {
                                        gwtNetConfig.setSubnetMask(((NetConfigIP4) netConfig).getSubnetMask().getHostAddress());
                                    } else {
                                        gwtNetConfig.setSubnetMask("");
                                    }
                                    if (((NetConfigIP4) netConfig).getGateway() != null) {
                                        s_logger.debug("Gateway for {} is: {}", netIfConfig.getName(), ((NetConfigIP4) netConfig).getGateway().getHostAddress());
                                        gwtNetConfig.setGateway(((NetConfigIP4) netConfig).getGateway().getHostAddress());
                                    } else {
                                        gwtNetConfig.setGateway("");
                                    }
                                }
                                // Custom DNS servers
                                StringBuffer sb = new StringBuffer();
                                List<IP4Address> dnsServers = ((NetConfigIP4) netConfig).getDnsServers();
                                if (dnsServers != null && !dnsServers.isEmpty()) {
                                    for (IP4Address dnsServer : dnsServers) {
                                        if (!dnsServer.getHostAddress().equals("127.0.0.1")) {
                                            sb.append(' ').append(dnsServer.getHostAddress());
                                        }
                                    }
                                    s_logger.debug("DNS Servers: {}", sb);
                                    gwtNetConfig.setDnsServers(sb.toString().trim());
                                } else {
                                    s_logger.debug("DNS Servers: [empty String]");
                                    gwtNetConfig.setDnsServers("");
                                }
                                // Search domains
                                sb = new StringBuffer();
                                List<IP4Address> winsServers = ((NetConfigIP4) netConfig).getWinsServers();
                                if (winsServers != null && !winsServers.isEmpty()) {
                                    for (IP4Address winServer : winsServers) {
                                        sb.append(winServer.getHostAddress());
                                        sb.append("\n");
                                    }
                                    s_logger.debug("Search Domains: {}", sb);
                                    gwtNetConfig.setSearchDomains(sb.toString());
                                } else {
                                    s_logger.debug("Search Domains: [empty String]");
                                    gwtNetConfig.setSearchDomains("");
                                }
                            }
                            // config
                            if (netConfig instanceof WifiConfig) {
                                s_logger.debug("Setting up WifiConfigIP4");
                                WifiConfig wifiConfig = (WifiConfig) netConfig;
                                GwtWifiConfig gwtWifiConfig = new GwtWifiConfig();
                                // mode
                                if (wifiConfig.getMode() == WifiMode.MASTER) {
                                    gwtWifiConfig.setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.name());
                                    // set as the access point config for this interface
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setAccessPointWifiConfig(gwtWifiConfig);
                                } else if (wifiConfig.getMode() == WifiMode.INFRA) {
                                    gwtWifiConfig.setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeStation.name());
                                    // set as the station config for this interface
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setStationWifiConfig(gwtWifiConfig);
                                } else if (wifiConfig.getMode() == WifiMode.ADHOC) {
                                    gwtWifiConfig.setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAdHoc.name());
                                    // set as the adhoc config for this interface
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setAdhocWifiConfig(gwtWifiConfig);
                                }
                                // ssid
                                gwtWifiConfig.setWirelessSsid(wifiConfig.getSSID());
                                // driver
                                gwtWifiConfig.setDriver(wifiConfig.getDriver());
                                // security
                                if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WPA) {
                                    gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWPA.name());
                                } else if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WPA2) {
                                    gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWPA2.name());
                                } else if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WPA_WPA2) {
                                    gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWPA_WPA2.name());
                                } else if (wifiConfig.getSecurity() == WifiSecurity.SECURITY_WEP) {
                                    gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityWEP.name());
                                } else {
                                    gwtWifiConfig.setSecurity(GwtWifiSecurity.netWifiSecurityNONE.name());
                                }
                                if (wifiConfig.getPairwiseCiphers() == WifiCiphers.CCMP_TKIP) {
                                    gwtWifiConfig.setPairwiseCiphers(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name());
                                } else if (wifiConfig.getPairwiseCiphers() == WifiCiphers.TKIP) {
                                    gwtWifiConfig.setPairwiseCiphers(GwtWifiCiphers.netWifiCiphers_TKIP.name());
                                } else if (wifiConfig.getPairwiseCiphers() == WifiCiphers.CCMP) {
                                    gwtWifiConfig.setPairwiseCiphers(GwtWifiCiphers.netWifiCiphers_CCMP.name());
                                }
                                if (wifiConfig.getGroupCiphers() == WifiCiphers.CCMP_TKIP) {
                                    gwtWifiConfig.setGroupCiphers(GwtWifiCiphers.netWifiCiphers_CCMP_TKIP.name());
                                } else if (wifiConfig.getGroupCiphers() == WifiCiphers.TKIP) {
                                    gwtWifiConfig.setGroupCiphers(GwtWifiCiphers.netWifiCiphers_TKIP.name());
                                } else if (wifiConfig.getGroupCiphers() == WifiCiphers.CCMP) {
                                    gwtWifiConfig.setGroupCiphers(GwtWifiCiphers.netWifiCiphers_CCMP.name());
                                }
                                // bgscan
                                WifiBgscan wifiBgscan = wifiConfig.getBgscan();
                                if (wifiBgscan != null) {
                                    if (wifiBgscan.getModule() == WifiBgscanModule.NONE) {
                                        gwtWifiConfig.setBgscanModule(GwtWifiBgscanModule.netWifiBgscanMode_NONE.name());
                                    } else if (wifiBgscan.getModule() == WifiBgscanModule.SIMPLE) {
                                        gwtWifiConfig.setBgscanModule(GwtWifiBgscanModule.netWifiBgscanMode_SIMPLE.name());
                                    } else if (wifiBgscan.getModule() == WifiBgscanModule.LEARN) {
                                        gwtWifiConfig.setBgscanModule(GwtWifiBgscanModule.netWifiBgscanMode_LEARN.name());
                                    }
                                    gwtWifiConfig.setBgscanRssiThreshold(wifiBgscan.getRssiThreshold());
                                    gwtWifiConfig.setBgscanShortInterval(wifiBgscan.getShortInterval());
                                    gwtWifiConfig.setBgscanLongInterval(wifiBgscan.getLongInterval());
                                }
                                // ping access point?
                                gwtWifiConfig.setPingAccessPoint(wifiConfig.pingAccessPoint());
                                // ignore SSID?
                                gwtWifiConfig.setIgnoreSSID(wifiConfig.ignoreSSID());
                                // passkey
                                Password psswd = wifiConfig.getPasskey();
                                if (psswd != null) {
                                    String password = new String(psswd.getPassword());
                                    gwtWifiConfig.setPassword(password);
                                }
                                // channel
                                int[] channels = wifiConfig.getChannels();
                                if (channels != null) {
                                    ArrayList<Integer> alChannels = new ArrayList<Integer>();
                                    for (int channel : channels) {
                                        alChannels.add(new Integer(channel));
                                    }
                                    gwtWifiConfig.setChannels(alChannels);
                                }
                                // radio mode
                                GwtWifiRadioMode gwtWifiRadioMode = null;
                                if (wifiConfig.getRadioMode() != null) {
                                    switch(wifiConfig.getRadioMode()) {
                                        case RADIO_MODE_80211a:
                                            gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeA;
                                            break;
                                        case RADIO_MODE_80211b:
                                            gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeB;
                                            break;
                                        case RADIO_MODE_80211g:
                                            gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeBG;
                                            break;
                                        case RADIO_MODE_80211nHT20:
                                        case RADIO_MODE_80211nHT40above:
                                        case RADIO_MODE_80211nHT40below:
                                            gwtWifiRadioMode = GwtWifiRadioMode.netWifiRadioModeBGN;
                                            break;
                                        default:
                                            break;
                                    }
                                }
                                if (gwtWifiRadioMode != null) {
                                    gwtWifiConfig.setRadioMode(gwtWifiRadioMode.name());
                                }
                                // set the currently active mode based on the address config
                                WifiMode activeWirelessMode = ((WifiInterfaceAddressConfig) addressConfig).getMode();
                                if (activeWirelessMode == WifiMode.MASTER) {
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAccessPoint.name());
                                    gwtNetConfig.setHwRssi("N/A");
                                } else if (activeWirelessMode == WifiMode.INFRA) {
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeStation.name());
                                    if (wifiClientMonitorService != null) {
                                        if (wifiConfig.getMode().equals(WifiMode.INFRA)) {
                                            if (gwtNetConfig.getStatus().equals(GwtNetIfStatus.netIPv4StatusDisabled.name())) {
                                                gwtNetConfig.setHwRssi("N/A");
                                            } else {
                                                try {
                                                    int rssi = wifiClientMonitorService.getSignalLevel(netIfConfig.getName(), wifiConfig.getSSID());
                                                    s_logger.debug("Setting Received Signal Strength to {}", rssi);
                                                    gwtNetConfig.setHwRssi(Integer.toString(rssi));
                                                } catch (KuraException e) {
                                                    s_logger.warn("Failed", e);
                                                }
                                            }
                                        }
                                    }
                                } else if (activeWirelessMode == WifiMode.ADHOC) {
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeAdHoc.name());
                                    gwtNetConfig.setHwRssi("N/A");
                                } else {
                                    ((GwtWifiNetInterfaceConfig) gwtNetConfig).setWirelessMode(GwtWifiWirelessMode.netWifiWirelessModeDisabled.name());
                                    gwtNetConfig.setHwRssi("N/A");
                                }
                            }
                            if (netConfig instanceof ModemConfig) {
                                s_logger.debug("Setting up ModemConfig");
                                ModemConfig modemConfig = (ModemConfig) netConfig;
                                GwtModemInterfaceConfig gwtModemConfig = (GwtModemInterfaceConfig) gwtNetConfig;
                                if (modemManagerService != null) {
                                    UsbDevice usbDevice = netIfConfig.getUsbDevice();
                                    String modemServiceId = null;
                                    if (usbDevice != null) {
                                        modemServiceId = netIfConfig.getUsbDevice().getUsbPort();
                                    } else {
                                        Collection<CellularModem> modemServices = modemManagerService.getAllModemServices();
                                        for (CellularModem modemService : modemServices) {
                                            ModemDevice modemDevice = modemService.getModemDevice();
                                            if (modemDevice instanceof SerialModemDevice) {
                                                modemServiceId = modemDevice.getProductName();
                                                break;
                                            }
                                        }
                                    }
                                    if (modemServiceId != null) {
                                        CellularModem cellModemService = modemManagerService.getModemService(modemServiceId);
                                        if (cellModemService != null) {
                                            try {
                                                String imei = cellModemService.getSerialNumber();
                                                s_logger.debug("Setting IMEI/MEID to {}", imei);
                                                gwtModemConfig.setHwSerial(imei);
                                            } catch (KuraException e) {
                                                s_logger.warn("Failed to get IMEI from modem", e);
                                            }
                                            try {
                                                int rssi = cellModemService.getSignalStrength();
                                                s_logger.debug("Setting Received Signal Strength to {}", rssi);
                                                gwtModemConfig.setHwRssi(Integer.toString(rssi));
                                            } catch (KuraException e) {
                                                s_logger.warn("Failed to get Received Signal Strength from modem", e);
                                            }
                                            try {
                                                String sModel = cellModemService.getModel();
                                                ((GwtModemInterfaceConfig) gwtNetConfig).setModel(sModel);
                                            } catch (KuraException e) {
                                                s_logger.warn("Failed to get model information from modem", e);
                                            }
                                            try {
                                                boolean gpsSupported = cellModemService.isGpsSupported();
                                                s_logger.debug("Setting GPS supported to {}", gpsSupported);
                                                ((GwtModemInterfaceConfig) gwtNetConfig).setGpsSupported(gpsSupported);
                                            } catch (KuraException e) {
                                                s_logger.warn("Failed to get GPS supported from modem", e);
                                            }
                                        }
                                    }
                                }
                                // set as DHCP - populate current address
                                gwtModemConfig.setConfigMode(GwtNetIfConfigMode.netIPv4ConfigModeDHCP.name());
                                if (addressConfig.getAddress() != null) {
                                    gwtModemConfig.setIpAddress(addressConfig.getAddress().getHostAddress());
                                }
                                if (addressConfig.getNetmask() != null) {
                                    gwtModemConfig.setSubnetMask(addressConfig.getNetmask().getHostAddress());
                                }
                                gwtModemConfig.setDialString(modemConfig.getDialString());
                                AuthType authType = modemConfig.getAuthType();
                                if (authType == AuthType.AUTO) {
                                    gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthAUTO);
                                } else if (authType == AuthType.CHAP) {
                                    gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthCHAP);
                                } else if (authType == AuthType.PAP) {
                                    gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthPAP);
                                } else {
                                    gwtModemConfig.setAuthType(GwtModemAuthType.netModemAuthNONE);
                                }
                                gwtModemConfig.setUsername(modemConfig.getUsername());
                                gwtModemConfig.setPassword(modemConfig.getPassword());
                                gwtModemConfig.setPppNum(modemConfig.getPppNumber());
                                gwtModemConfig.setResetTimeout(modemConfig.getResetTimeout());
                                gwtModemConfig.setPersist(modemConfig.isPersist());
                                gwtModemConfig.setMaxFail(modemConfig.getMaxFail());
                                gwtModemConfig.setIdle(modemConfig.getIdle());
                                gwtModemConfig.setActiveFilter(modemConfig.getActiveFilter());
                                gwtModemConfig.setLcpEchoInterval(modemConfig.getLcpEchoInterval());
                                gwtModemConfig.setLcpEchoFailure(modemConfig.getLcpEchoFailure());
                                gwtModemConfig.setGpsEnabled(modemConfig.isGpsEnabled());
                                gwtModemConfig.setProfileID(modemConfig.getProfileID());
                                PdpType pdpType = modemConfig.getPdpType();
                                if (pdpType == PdpType.IP) {
                                    gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpIP);
                                } else if (pdpType == PdpType.PPP) {
                                    gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpPPP);
                                } else if (pdpType == PdpType.IPv6) {
                                    gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpIPv6);
                                } else {
                                    gwtModemConfig.setPdpType(GwtModemPdpType.netModemPdpUnknown);
                                }
                                gwtModemConfig.setApn(modemConfig.getApn());
                                gwtModemConfig.setDataCompression(modemConfig.getDataCompression());
                                gwtModemConfig.setHeaderCompression(modemConfig.getHeaderCompression());
                                ModemConnectionStatus connectionStatus = ((ModemInterfaceAddressConfig) addressConfig).getConnectionStatus();
                                if (connectionStatus == ModemConnectionStatus.DISCONNECTED) {
                                    gwtModemConfig.setHwState(NetInterfaceState.DISCONNECTED.name());
                                } else if (connectionStatus == ModemConnectionStatus.CONNECTING) {
                                    gwtModemConfig.setHwState(NetInterfaceState.IP_CONFIG.name());
                                } else if (connectionStatus == ModemConnectionStatus.CONNECTED) {
                                    gwtModemConfig.setHwState(NetInterfaceState.ACTIVATED.name());
                                } else {
                                    gwtModemConfig.setHwState(NetInterfaceState.UNKNOWN.name());
                                }
                                gwtModemConfig.setConnectionType(((ModemInterfaceAddressConfig) addressConfig).getConnectionType().name());
                            }
                            if (netConfig instanceof DhcpServerConfigIP4) {
                                s_logger.debug("Setting up DhcpServerConfigIP4: {} to {}", ((DhcpServerConfigIP4) netConfig).getRangeStart().getHostAddress(), ((DhcpServerConfigIP4) netConfig).getRangeEnd().getHostAddress());
                                s_logger.debug("Setting up DhcpServerConfigIP4: {}", ((DhcpServerConfigIP4) netConfig).toString());
                                isDhcpServerEnabled = ((DhcpServerConfigIP4) netConfig).isEnabled();
                                gwtNetConfig.setRouterDhcpBeginAddress(((DhcpServerConfigIP4) netConfig).getRangeStart().getHostAddress());
                                gwtNetConfig.setRouterDhcpEndAddress(((DhcpServerConfigIP4) netConfig).getRangeEnd().getHostAddress());
                                gwtNetConfig.setRouterDhcpSubnetMask(((DhcpServerConfigIP4) netConfig).getSubnetMask().getHostAddress());
                                gwtNetConfig.setRouterDhcpDefaultLease(((DhcpServerConfigIP4) netConfig).getDefaultLeaseTime());
                                gwtNetConfig.setRouterDhcpMaxLease(((DhcpServerConfigIP4) netConfig).getMaximumLeaseTime());
                                gwtNetConfig.setRouterDnsPass(((DhcpServerConfigIP4) netConfig).isPassDns());
                            }
                            if (netConfig instanceof FirewallAutoNatConfig) {
                                s_logger.debug("Setting up FirewallAutoNatConfig");
                                isNatEnabled = true;
                            }
                        // TODO - only dealing with IPv4 right now
                        }
                        // set up the DHCP and NAT config
                        if (isDhcpServerEnabled && isNatEnabled) {
                            s_logger.debug("setting router mode to DHCP and NAT");
                            gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterDchpNat.name());
                        } else if (isDhcpServerEnabled && !isNatEnabled) {
                            s_logger.debug("setting router mode to DHCP only");
                            gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterDchp.name());
                        } else if (!isDhcpServerEnabled && isNatEnabled) {
                            s_logger.debug("setting router mode to NAT only");
                            gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterNat.name());
                        } else {
                            s_logger.debug("setting router mode to disabled");
                            gwtNetConfig.setRouterMode(GwtNetRouterMode.netRouterOff.name());
                        }
                    }
                }
            }
            gwtNetConfigs.add(gwtNetConfig);
        }
    } catch (Throwable t) {
        KuraExceptionHandler.handle(t);
    }
    s_logger.debug("Returning");
    return gwtNetConfigs;
}