Examples with EthernetInterfaceImpl org.eclipse.kura.core.net.EthernetInterfaceImpl used on opensource projects

Example 1 with EthernetInterfaceImpl

use of org.eclipse.kura.core.net.EthernetInterfaceImpl in project kura by eclipse.

the class NetworkServiceImpl method getNetworkInterface.

public NetInterface<? extends NetInterfaceAddress> getNetworkInterface(String interfaceName) throws KuraException {
    // ignore redpine vlan interface
    if (interfaceName.startsWith("rpine")) {
        s_logger.debug("Ignoring redpine vlan interface.");
        return null;
    }
    // ignore usb0 for beaglebone
    if (interfaceName.startsWith("usb0") && "beaglebone".equals(System.getProperty("target.device"))) {
        s_logger.debug("Ignoring usb0 for beaglebone.");
        return null;
    }
    LinuxIfconfig ifconfig = LinuxNetworkUtil.getInterfaceConfiguration(interfaceName);
    if (ifconfig == null) {
        s_logger.debug("Ignoring {} interface.", interfaceName);
        return null;
    }
    NetInterfaceType type = ifconfig.getType();
    boolean isUp = ifconfig.isUp();
    if (type == NetInterfaceType.UNKNOWN) {
        if (interfaceName.matches(UNCONFIGURED_MODEM_REGEX)) {
            // If the interface name is in a form such as "1-3.4", assume it is a modem
            type = NetInterfaceType.MODEM;
        } else if (this.m_serialModem != null && interfaceName.equals(this.m_serialModem.getProductName())) {
            type = NetInterfaceType.MODEM;
        }
    }
    if (type == NetInterfaceType.ETHERNET) {
        EthernetInterfaceImpl<NetInterfaceAddress> netInterface = new EthernetInterfaceImpl<NetInterfaceAddress>(interfaceName);
        Map<String, String> driver = LinuxNetworkUtil.getEthernetDriver(interfaceName);
        netInterface.setDriver(driver.get("name"));
        netInterface.setDriverVersion(driver.get("version"));
        netInterface.setFirmwareVersion(driver.get("firmware"));
        netInterface.setAutoConnect(LinuxNetworkUtil.isAutoConnect(interfaceName));
        netInterface.setHardwareAddress(ifconfig.getMacAddressBytes());
        netInterface.setMTU(ifconfig.getMtu());
        netInterface.setSupportsMulticast(ifconfig.isMulticast());
        netInterface.setLinkUp(LinuxNetworkUtil.isLinkUp(type, interfaceName));
        netInterface.setLoopback(false);
        netInterface.setPointToPoint(false);
        netInterface.setUp(isUp);
        netInterface.setVirtual(isVirtual());
        netInterface.setUsbDevice(getUsbDevice(interfaceName));
        netInterface.setState(getState(interfaceName, isUp));
        netInterface.setNetInterfaceAddresses(getNetInterfaceAddresses(interfaceName, type, isUp));
        return netInterface;
    } else if (type == NetInterfaceType.LOOPBACK) {
        LoopbackInterfaceImpl<NetInterfaceAddress> netInterface = new LoopbackInterfaceImpl<NetInterfaceAddress>(interfaceName);
        netInterface.setDriver(getDriver());
        netInterface.setDriverVersion(getDriverVersion());
        netInterface.setFirmwareVersion(getFirmwareVersion());
        netInterface.setAutoConnect(LinuxNetworkUtil.isAutoConnect(interfaceName));
        netInterface.setHardwareAddress(new byte[] { 0, 0, 0, 0, 0, 0 });
        netInterface.setLoopback(true);
        netInterface.setMTU(ifconfig.getMtu());
        netInterface.setSupportsMulticast(ifconfig.isMulticast());
        netInterface.setPointToPoint(false);
        netInterface.setUp(isUp);
        netInterface.setVirtual(false);
        netInterface.setUsbDevice(null);
        netInterface.setState(getState(interfaceName, isUp));
        netInterface.setNetInterfaceAddresses(getNetInterfaceAddresses(interfaceName, type, isUp));
        return netInterface;
    } else if (type == NetInterfaceType.WIFI) {
        WifiInterfaceImpl<WifiInterfaceAddress> wifiInterface = new WifiInterfaceImpl<WifiInterfaceAddress>(interfaceName);
        Map<String, String> driver = LinuxNetworkUtil.getEthernetDriver(interfaceName);
        wifiInterface.setDriver(driver.get("name"));
        wifiInterface.setDriverVersion(driver.get("version"));
        wifiInterface.setFirmwareVersion(driver.get("firmware"));
        wifiInterface.setAutoConnect(LinuxNetworkUtil.isAutoConnect(interfaceName));
        wifiInterface.setHardwareAddress(ifconfig.getMacAddressBytes());
        wifiInterface.setMTU(ifconfig.getMtu());
        wifiInterface.setSupportsMulticast(ifconfig.isMulticast());
        // FIXME:MS Add linkUp in the AbstractNetInterface and populate accordingly
        // wifiInterface.setLinkUp(LinuxNetworkUtil.isLinkUp(type, interfaceName));
        wifiInterface.setLoopback(false);
        wifiInterface.setPointToPoint(false);
        wifiInterface.setUp(isUp);
        wifiInterface.setVirtual(isVirtual());
        wifiInterface.setUsbDevice(getUsbDevice(interfaceName));
        wifiInterface.setState(getState(interfaceName, isUp));
        wifiInterface.setNetInterfaceAddresses(getWifiInterfaceAddresses(interfaceName, isUp));
        wifiInterface.setCapabilities(LinuxNetworkUtil.getWifiCapabilities(interfaceName));
        return wifiInterface;
    } else if (type == NetInterfaceType.MODEM) {
        ModemDevice modemDevice = null;
        if (interfaceName.startsWith("ppp")) {
            // already connected - find the corresponding usb device
            modemDevice = this.m_usbModems.get(getModemUsbPort(interfaceName));
            if (modemDevice == null && this.m_serialModem != null) {
                modemDevice = this.m_serialModem;
            }
        } else if (interfaceName.matches(UNCONFIGURED_MODEM_REGEX)) {
            // the interface name is in the form of a usb port i.e. "1-3.4"
            modemDevice = this.m_usbModems.get(interfaceName);
        } else if (this.m_serialModem != null && interfaceName.equals(this.m_serialModem.getProductName())) {
            modemDevice = this.m_serialModem;
        }
        return modemDevice != null ? getModemInterface(interfaceName, isUp, modemDevice) : null;
    } else {
        if (interfaceName.startsWith("can")) {
            s_logger.trace("Ignoring CAN interface: {}", interfaceName);
        } else if (interfaceName.startsWith("ppp")) {
            s_logger.debug("Ignoring unconfigured ppp interface: {}", interfaceName);
        } else {
            s_logger.debug("Unsupported network type - not adding to network devices: {} of type: ", interfaceName, type.toString());
        }
        return null;
    }
}

Example 2 with EthernetInterfaceImpl

use of org.eclipse.kura.core.net.EthernetInterfaceImpl in project kura by eclipse.

the class EmulatedNetworkServiceImpl method getActiveNetworkInterfaces.

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public List<NetInterface<? extends NetInterfaceAddress>> getActiveNetworkInterfaces() throws KuraException {
    IPAddress netAddress = null;
    NetInterfaceAddressImpl addressImpl = null;
    List<NetInterfaceAddress> addresses = null;
    List<NetInterface<? extends NetInterfaceAddress>> interfaces = new ArrayList<NetInterface<? extends NetInterfaceAddress>>();
    EthernetInterfaceImpl ethInterface = null;
    java.net.NetworkInterface jnInterface = null;
    List<java.net.InterfaceAddress> jnInterfaceAddresses = null;
    Enumeration<java.net.NetworkInterface> jnInterfaces = null;
    try {
        jnInterfaces = java.net.NetworkInterface.getNetworkInterfaces();
        while (jnInterfaces.hasMoreElements()) {
            try {
                jnInterface = jnInterfaces.nextElement();
                if (jnInterface.isUp() && !jnInterface.isVirtual() && !jnInterface.isLoopback() && !jnInterface.isPointToPoint() && jnInterface.getHardwareAddress() != null && !jnInterface.getInterfaceAddresses().isEmpty()) {
                    ethInterface = new EthernetInterfaceImpl(jnInterface.getName());
                    ethInterface.setVirtual(jnInterface.isVirtual());
                    ethInterface.setState(NetInterfaceState.ACTIVATED);
                    ethInterface.setAutoConnect(true);
                    byte[] hwAddr = null;
                    boolean isUp = false;
                    boolean isLoop = false;
                    int mtu = 0;
                    boolean isP2p = false;
                    boolean multi = false;
                    try {
                        hwAddr = jnInterface.getHardwareAddress();
                        isUp = jnInterface.isUp();
                        isLoop = jnInterface.isLoopback();
                        mtu = jnInterface.getMTU();
                        isP2p = jnInterface.isPointToPoint();
                        multi = jnInterface.supportsMulticast();
                    } catch (Exception e) {
                        s_logger.warn("Exception while getting information for interface " + jnInterface.getName(), e);
                    }
                    ethInterface.setHardwareAddress(hwAddr);
                    ethInterface.setLinkUp(isUp);
                    ethInterface.setLoopback(isLoop);
                    ethInterface.setMTU(mtu);
                    ethInterface.setPointToPoint(isP2p);
                    ethInterface.setSupportsMulticast(multi);
                    ethInterface.setUp(isUp);
                    addresses = new ArrayList<NetInterfaceAddress>();
                    jnInterfaceAddresses = jnInterface.getInterfaceAddresses();
                    for (java.net.InterfaceAddress jnInterfaceAddress : jnInterfaceAddresses) {
                        netAddress = IPAddress.getByAddress(jnInterfaceAddress.getAddress().getAddress());
                        addressImpl = new NetInterfaceAddressImpl();
                        addressImpl.setAddress(netAddress);
                        if (jnInterfaceAddress.getBroadcast() != null) {
                            addressImpl.setBroadcast(IPAddress.getByAddress(jnInterfaceAddress.getBroadcast().getAddress()));
                        }
                        addressImpl.setNetworkPrefixLength(jnInterfaceAddress.getNetworkPrefixLength());
                        addresses.add(addressImpl);
                    }
                    ethInterface.setNetInterfaceAddresses(addresses);
                    interfaces.add(ethInterface);
                }
            } catch (SocketException se) {
                s_logger.warn("Exception while getting information for interface " + jnInterface.getName(), se);
            }
        }
    } catch (Exception e) {
        throw new KuraException(KuraErrorCode.INTERNAL_ERROR, e);
    }
    return interfaces;
}

Example 3 with EthernetInterfaceImpl

use of org.eclipse.kura.core.net.EthernetInterfaceImpl in project kura by eclipse.

the class EmulatedNetworkServiceImpl method getNetworkInterfaces.

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public List<NetInterface<? extends NetInterfaceAddress>> getNetworkInterfaces() throws KuraException {
    IPAddress netAddress = null;
    NetInterfaceAddressImpl addressImpl = null;
    List<NetInterfaceAddress> addresses = null;
    List<NetInterface<? extends NetInterfaceAddress>> interfaces = new ArrayList<NetInterface<? extends NetInterfaceAddress>>();
    EthernetInterfaceImpl ethInterface = null;
    java.net.NetworkInterface jnInterface = null;
    List<java.net.InterfaceAddress> jnInterfaceAddresses = null;
    Enumeration<java.net.NetworkInterface> jnInterfaces = null;
    try {
        jnInterfaces = java.net.NetworkInterface.getNetworkInterfaces();
        while (jnInterfaces.hasMoreElements()) {
            jnInterface = jnInterfaces.nextElement();
            ethInterface = new EthernetInterfaceImpl(jnInterface.getName());
            ethInterface.setVirtual(jnInterface.isVirtual());
            ethInterface.setState(NetInterfaceState.ACTIVATED);
            ethInterface.setAutoConnect(true);
            byte[] hwAddr = null;
            boolean isUp = false;
            boolean isLoop = false;
            int mtu = 0;
            boolean isP2p = false;
            boolean multi = false;
            try {
                hwAddr = jnInterface.getHardwareAddress();
                isUp = jnInterface.isUp();
                isLoop = jnInterface.isLoopback();
                mtu = jnInterface.getMTU();
                isP2p = jnInterface.isPointToPoint();
                multi = jnInterface.supportsMulticast();
            } catch (Exception e) {
                s_logger.warn("Exception while getting information for interface " + jnInterface.getName() + ": " + e.getMessage());
            }
            ethInterface.setHardwareAddress(hwAddr);
            ethInterface.setLinkUp(isUp);
            ethInterface.setLoopback(isLoop);
            ethInterface.setMTU(mtu);
            ethInterface.setPointToPoint(isP2p);
            ethInterface.setSupportsMulticast(multi);
            ethInterface.setUp(isUp);
            addresses = new ArrayList<NetInterfaceAddress>();
            jnInterfaceAddresses = jnInterface.getInterfaceAddresses();
            for (java.net.InterfaceAddress jnInterfaceAddress : jnInterfaceAddresses) {
                netAddress = IPAddress.getByAddress(jnInterfaceAddress.getAddress().getAddress());
                addressImpl = new NetInterfaceAddressImpl();
                addressImpl.setAddress(netAddress);
                if (jnInterfaceAddress.getBroadcast() != null) {
                    addressImpl.setBroadcast(IPAddress.getByAddress(jnInterfaceAddress.getBroadcast().getAddress()));
                }
                addressImpl.setNetworkPrefixLength(jnInterfaceAddress.getNetworkPrefixLength());
                addresses.add(addressImpl);
            }
            ethInterface.setNetInterfaceAddresses(addresses);
            interfaces.add(ethInterface);
        }
    } catch (Exception e) {
        throw new KuraException(KuraErrorCode.INTERNAL_ERROR, e);
    }
    return interfaces;
}