c# - redes - puerta de enlace predeterminada no aparece

Obtener la puerta de enlace predeterminada

Question

Estoy escribiendo un programa que muestra al usuario su dirección IP, la máscara de subred y la puerta de enlace predeterminada. Puedo obtener los dos primeros, pero para el último, esto es lo que encontré:

GatewayIPAddressInformationCollection gwc = 
    System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()[0].GetIPProperties().GatewayAddresses;

Eso, por supuesto, devuelve una colección de GatewayIPAddressInformation . Entonces, si una computadora tiene múltiples puertas de enlace, ¿cómo puedo determinar cuál es la puerta de enlace predeterminada ?

En la práctica, solo he visto que esta colección contiene una sola entrada, pero como se implementa como una colección, es lógico que algunas computadoras contengan varias puertas de enlace, ninguna de las cuales está marcada como "Predeterminada". Entonces, ¿hay una manera de determinar el valor predeterminado o es todo solo conjeturas?

Answer 1

Acabo de encontrar esto y usaré el siguiente código: básicamente busca interfaces que no sean de bucle invertido y que estén instaladas y que tengan pasarelas y direcciones de unidifusión. Desde la interfaz obtengo una dirección IPV4 no transitoria.

public static class NetworkInterfaces
{
    public static NetworkInterface GetDefaultInterface()
    {
        var interfaces = System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces();
        foreach (var intf in interfaces)
        {
            if (intf.OperationalStatus != OperationalStatus.Up)
            {
                continue;
            }
            if (intf.NetworkInterfaceType == NetworkInterfaceType.Loopback)
            {
                continue;
            }

            var properties = intf.GetIPProperties();
            if (properties == null)
            {
                continue;
            }
            var gateways = properties.GatewayAddresses;
            if ((gateways == null) || (gateways.Count == 0))
            {
                continue;
            }
            var addresses = properties.UnicastAddresses;
            if ((addresses == null) || (addresses.Count == 0))
            {
                continue;
            }
            return intf;
        }
        return null;
    }

    public static IPAddress GetDefaultIPV4Address(NetworkInterface intf)
    {
        if (intf == null)
        {
            return null;
        }
        foreach (var address in intf.GetIPProperties().UnicastAddresses)
        {
            if (address.Address.AddressFamily != AddressFamily.InterNetwork)
            {
                continue;
            }
            if (address.IsTransient)
            {
                continue;
            }
            return address.Address;
        }
        return null;
    }
}

Answer 2

Creo que deberías recorrer esta colección y mostrar todas las Puertas de enlace, ya que si hay muchas puertas de enlace a un adaptador, todas se consideran Predeterminadas para ese adaptador

Answer 3

De acuerdo con el comentario de @Midspace sobre la respuesta de @ Caesay, esta es una mejor respuesta:

public static IPAddress GetDefaultGateway()
{
    var gateway_address = NetworkInterface.GetAllNetworkInterfaces()
        .Where(e => e.OperationalStatus == OperationalStatus.Up)
        .SelectMany(e => e.GetIPProperties().GatewayAddresses)
        .FirstOrDefault();
    if (gateway_address == null) return null;
    return gateway_address.Address;
}

Le advierto que no es una solución completa. Si está buscando la interfaz principal responsable del acceso a Internet, debe combinar otros enfoques, como el uso de la API GetBestInterface para encontrar la mejor interfaz para conectarse a una dirección de destino.

puede encontrar ejemplos de uso aquí: http://www.pinvoke.net/default.aspx/iphlpapi.getbestinterface

Answer 4

Debe ser la primera dirección de pasarela válida y habilitada de la primera interfaz de red habilitada:

public static IPAddress GetDefaultGateway()
{
    return NetworkInterface
        .GetAllNetworkInterfaces()
        .Where(n => n.OperationalStatus == OperationalStatus.Up)
        .Where(n => n.NetworkInterfaceType != NetworkInterfaceType.Loopback)
        .SelectMany(n => n.GetIPProperties()?.GatewayAddresses)
        .Select(g => g?.Address)
        .Where(a => a != null)
         // .Where(a => a.AddressFamily == AddressFamily.InterNetwork)
         // .Where(a => Array.FindIndex(a.GetAddressBytes(), b => b != 0) >= 0)
        .FirstOrDefault();
}

También agregué algunos controles adicionales comentados que otras personas han señalado como útiles aquí. Puede marcar AddressFamily one para distinguir entre IPv4 e IPv6. La última puede usarse si tienes problemas con una dirección 0.0.0.0 que se está devolviendo.

Dicho esto, la forma recomendada de hacer esto usa GetBestInterface para encontrar una interfaz para enrutar a una dirección IP específica. Si ya tiene en mente una dirección IP de destino, entonces es mejor usar esto, por lo que también incluí un ejemplo a continuación:

[DllImport("iphlpapi.dll", CharSet = CharSet.Auto)]
private static extern int GetBestInterface(UInt32 destAddr, out UInt32 bestIfIndex);

public static IPAddress GetGatewayForDestination(IPAddress destinationAddress)
{
    UInt32 destaddr = BitConverter.ToUInt32(destinationAddress.GetAddressBytes(), 0);

    uint interfaceIndex;
    int result = GetBestInterface(destaddr, out interfaceIndex);
    if (result != 0)
        throw new Win32Exception(result);

    foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
    {
        var niprops = ni.GetIPProperties();
        if (niprops == null)
            continue;

        var gateway = niprops.GatewayAddresses?.FirstOrDefault()?.Address;
        if (gateway == null)
            continue;

        if (ni.Supports(NetworkInterfaceComponent.IPv4))
        {
            var v4props = niprops.GetIPv4Properties();
            if (v4props == null)
                continue;

            if (v4props.Index == interfaceIndex)
                return gateway;
        }

        if (ni.Supports(NetworkInterfaceComponent.IPv6))
        {
            var v6props = niprops.GetIPv6Properties();
            if (v6props == null)
                continue;

            if (v6props.Index == interfaceIndex)
                return gateway;
        }
    }

    return null;
}

Answer 5

La primera dirección IP devuelta por el comando traceroute será la puerta de enlace. También puede usar este hecho para obtener la puerta de enlace. Puede encontrar una buena implementación de tracerout aquí: TraceRoute y Ping en C #

Answer 6

Sé que esta es una pregunta un poco más antigua, pero acabo de encontrar la necesidad de recuperar la dirección IPV4 de la puerta de enlace local. La respuesta aceptada no se ajusta a la medida cuando se trata de mi propio sistema, así que la modifiqué para que se adaptara y estoy seguro de que otros también podrán usar esta solución.

Como aún no tengo suficiente representante para comentar, me veo obligado a agregar esto como una "pregunta":

public static IPAddress GetDefaultGateway()
    {
        IPAddress result = null;
        var cards = NetworkInterface.GetAllNetworkInterfaces().ToList();
        if (cards.Any())
        {
            foreach (var card in cards)
            {
                var props = card.GetIPProperties();
                if (props == null)
                    continue;

                var gateways = props.GatewayAddresses;
                if (!gateways.Any())
                    continue;

                var gateway =
                    gateways.FirstOrDefault(g => g.Address.AddressFamily.ToString() == "InterNetwork");
                if (gateway == null)
                    continue;

                result = gateway.Address;
                break;
            };
        }

        return result;
    }

Answer 7

NetworkInterface[] allNICs = NetworkInterface.GetAllNetworkInterfaces();
foreach (var nic in allNICs)
{
    var ipProp = nic.GetIPProperties();
    var gwAddresses = ipProp.GatewayAddresses;
    if (gwAddresses.Count > 0 &&
        gwAddresses.FirstOrDefault(g => g.Address.AddressFamily == AddressFamily.InterNetwork) != null)
    {
        localIP = ipProp.UnicastAddresses.First(d => d.Address.AddressFamily == AddressFamily.InterNetwork).Address;
    }
}
Debug.Print(localIP.ToString());