1515 lines
47 KiB
Nim
1515 lines
47 KiB
Nim
#
|
|
# Chronos OS utilities
|
|
# (c) Copyright 2018-Present
|
|
# Status Research & Development GmbH
|
|
#
|
|
# Licensed under either of
|
|
# Apache License, version 2.0, (LICENSE-APACHEv2)
|
|
# MIT license (LICENSE-MIT)
|
|
|
|
## This module implements cross-platform network interfaces list.
|
|
## Currently supported OSes are Windows, Linux, MacOS, BSD(not tested).
|
|
import algorithm
|
|
from strutils import toHex
|
|
import ipnet
|
|
export ipnet
|
|
|
|
const
|
|
MaxAdapterAddressLength* = 8
|
|
|
|
type
|
|
InterfaceType* = enum
|
|
IfError = 0, # This is workaround element for ProoveInit warnings.
|
|
IfOther = 1,
|
|
IfRegular1822 = 2,
|
|
IfHdh1822 = 3,
|
|
IfDdnX25 = 4,
|
|
IfRfc877X25 = 5,
|
|
IfEthernetCsmacd = 6,
|
|
IfIso88023Csmacd = 7,
|
|
IfIso88024TokenBus = 8,
|
|
IfIso88025TokenRing = 9,
|
|
IfIso88026MAN = 10,
|
|
IfStarlan = 11,
|
|
IfProteon10Mbit = 12,
|
|
IfProteon80Mbit = 13,
|
|
IfHyperChannel = 14,
|
|
IfFddi = 15,
|
|
IfLapB = 16,
|
|
IfSdlc = 17,
|
|
IfDs1 = 18,
|
|
IfE1 = 19,
|
|
IfBasicIsdn = 20,
|
|
IfPrimaryIsdn = 21,
|
|
IfPropPoint2PointSerial = 22,
|
|
IfPpp = 23,
|
|
IfSoftwareLoopback = 24,
|
|
IfEon = 25,
|
|
IfEthernet3Mbit = 26,
|
|
IfNsip = 27,
|
|
IfSlip = 28,
|
|
IfUltra = 29,
|
|
IfDs3 = 30,
|
|
IfSip = 31,
|
|
IfFrameRelay = 32,
|
|
IfRs232 = 33,
|
|
IfPara = 34,
|
|
IfArcNet = 35,
|
|
IfArcNetPlus = 36,
|
|
IfAtm = 37,
|
|
IfMioX25 = 38,
|
|
IfSonet = 39,
|
|
IfX25Ple = 40,
|
|
IfIso88022Llc = 41,
|
|
IfLocalTalk = 42,
|
|
IfSmdsDxi = 43,
|
|
IfFrameRelayService = 44,
|
|
IfV35 = 45,
|
|
IfHssi = 46,
|
|
IfHippi = 47,
|
|
IfModem = 48,
|
|
IfAal5 = 49,
|
|
IfSonetPath = 50,
|
|
IfSonetVt = 51,
|
|
IfSmdsIcip = 52,
|
|
IfPropVirtual = 53,
|
|
IfPropMultiplexor = 54,
|
|
IfIeee80212 = 55,
|
|
IfFibreChannel = 56,
|
|
IfHippiInterface = 57,
|
|
IfFrameRelayInterconnect = 58,
|
|
IfAflane8023 = 59,
|
|
IfAflane8025 = 60,
|
|
IfCctemul = 61,
|
|
IfFastEther = 62,
|
|
IfIsdn = 63,
|
|
IfV11 = 64,
|
|
IfV36 = 65,
|
|
IfG70364K = 66,
|
|
IfG7032MB = 67,
|
|
IfQllc = 68,
|
|
IfFastEtherFx = 69,
|
|
IfChannel = 70,
|
|
IfIeee80211 = 71,
|
|
IfIbm370Parchan = 72,
|
|
IfEscon = 73,
|
|
IfDlsw = 74,
|
|
IfIsdnS = 75,
|
|
IfIsdnU = 76,
|
|
IfLapD = 77,
|
|
IfIpSwitch = 78,
|
|
IfRsrb = 79,
|
|
IfAtmLogical = 80,
|
|
IfDs0 = 81,
|
|
IfDs0Bundle = 82,
|
|
IfBsc = 83,
|
|
IfAsync = 84,
|
|
IfCnr = 85,
|
|
IfIso88025rDtr = 86,
|
|
IfEplrs = 87,
|
|
IfArap = 88,
|
|
IfPropCnls = 89,
|
|
IfHostPad = 90,
|
|
IfTermPad = 91,
|
|
IfFrameRelayMpi = 92,
|
|
IfX213 = 93,
|
|
IfAdsl = 94,
|
|
IfRadsl = 95,
|
|
IfSdsl = 96,
|
|
IfVdsl = 97,
|
|
IfIso88025Crfprint = 98,
|
|
IfMyrInet = 99,
|
|
IfVoiceEm = 100,
|
|
IfVoiceFxo = 101,
|
|
IfVoiceFxs = 102,
|
|
IfVoiceEncap = 103,
|
|
IfVoiceOverip = 104,
|
|
IfAtmDxi = 105,
|
|
IfAtmFuni = 106,
|
|
IfAtmIma = 107,
|
|
IfPppMultilinkBundle = 108,
|
|
IfIpoverCdlc = 109,
|
|
IfIpoverClaw = 110,
|
|
IfStackToStack = 111,
|
|
IfVirtualIpAddress = 112,
|
|
IfMpc = 113,
|
|
IfIpoverAtm = 114,
|
|
IfIso88025Fiber = 115,
|
|
IfTdlc = 116,
|
|
IfGigabitEthernet = 117,
|
|
IfHdlc = 118,
|
|
IfLapF = 119,
|
|
IfV37 = 120,
|
|
IfX25Mlp = 121,
|
|
IfX25HuntGroup = 122,
|
|
IfTransPhdlc = 123,
|
|
IfInterleave = 124,
|
|
IfFast = 125,
|
|
IfIp = 126,
|
|
IfDocScableMaclayer = 127,
|
|
IfDocScableDownstream = 128,
|
|
IfDocScableUpstream = 129,
|
|
IfA12MppSwitch = 130,
|
|
IfTunnel = 131,
|
|
IfCoffee = 132,
|
|
IfCes = 133,
|
|
IfAtmSubInterface = 134,
|
|
IfL2Vlan = 135,
|
|
IfL3IpVlan = 136,
|
|
IfL3IpxVlan = 137,
|
|
IfDigitalPowerline = 138,
|
|
IfMediaMailOverIp = 139,
|
|
IfDtm = 140,
|
|
IfDcn = 141,
|
|
IfIpForward = 142,
|
|
IfMsdsl = 143,
|
|
IfIeee1394 = 144,
|
|
IfIfGsn = 145,
|
|
IfDvbrccMaclayer = 146,
|
|
IfDvbrccDownstream = 147,
|
|
IfDvbrccUpstream = 148,
|
|
IfAtmVirtual = 149,
|
|
IfMplsTunnel = 150,
|
|
IfSrp = 151,
|
|
IfVoiceOverAtm = 152,
|
|
IfVoiceOverFrameRelay = 153,
|
|
IfIdsl = 154,
|
|
IfCompositeLink = 155,
|
|
IfSs7SigLink = 156,
|
|
IfPropWirelessP2p = 157,
|
|
IfFrForward = 158,
|
|
IfRfc1483 = 159,
|
|
IfUsb = 160,
|
|
IfIeee8023AdLag = 161,
|
|
IfBgpPolicyAccounting = 162,
|
|
IfFrf16MfrBundle = 163,
|
|
IfH323Gatekeeper = 164,
|
|
IfH323Proxy = 165,
|
|
IfMpls = 166,
|
|
IfMfSigLink = 167,
|
|
IfHdsl2 = 168,
|
|
IfShdsl = 169,
|
|
IfDs1Fdl = 170,
|
|
IfPos = 171,
|
|
IfDvbAsiIn = 172,
|
|
IfDvbAsiOut = 173,
|
|
IfPlc = 174,
|
|
IfNfas = 175,
|
|
IfTr008 = 176,
|
|
IfGr303Rdt = 177,
|
|
IfGr303Idt = 178,
|
|
IfIsup = 179,
|
|
IfPropDocsWirelessMaclayer = 180,
|
|
IfPropDocsWirelessDownstream = 181,
|
|
IfPropDocsWirelessUpstream = 182,
|
|
IfHiperLan2 = 183,
|
|
IfPropBwaP2mp = 184,
|
|
IfSonetOverheadChannel = 185,
|
|
IfDigitalWrapperOverheadChannel = 186,
|
|
IfAal2 = 187,
|
|
IfRadioMac = 188,
|
|
IfAtmRadio = 189,
|
|
IfImt = 190,
|
|
IfMvl = 191,
|
|
IfReachDsl = 192,
|
|
IfFrDlciEndpt = 193,
|
|
IfAtmVciEndpt = 194,
|
|
IfOpticalChannel = 195,
|
|
IfOpticalTransport = 196,
|
|
IfIeee80216Wman = 237,
|
|
IfWwanPp = 243,
|
|
IfWwanPp2 = 244,
|
|
IfIeee802154 = 259,
|
|
IfXboxWireless = 281
|
|
|
|
InterfaceState* = enum
|
|
StatusError = 0, # This is workaround element for ProoveInit warnings.
|
|
StatusUp,
|
|
StatusDown,
|
|
StatusTesting,
|
|
StatusUnknown,
|
|
StatusDormant,
|
|
StatusNotPresent,
|
|
StatusLowerLayerDown
|
|
|
|
InterfaceAddress* = object
|
|
host*: TransportAddress
|
|
net*: IpNet
|
|
|
|
NetworkInterface* = object
|
|
ifIndex*: int
|
|
ifType*: InterfaceType
|
|
name*: string
|
|
desc*: string
|
|
mtu*: int
|
|
flags*: uint64
|
|
state*: InterfaceState
|
|
mac*: array[MaxAdapterAddressLength, byte]
|
|
maclen*: int
|
|
addresses*: seq[InterfaceAddress]
|
|
|
|
Route* = object
|
|
ifIndex*: int
|
|
dest*: TransportAddress
|
|
source*: TransportAddress
|
|
gateway*: TransportAddress
|
|
metric*: int
|
|
|
|
proc broadcast*(ifa: InterfaceAddress): TransportAddress {.inline.} =
|
|
## Return broadcast address for ``ifa``.
|
|
result = ifa.net.broadcast()
|
|
|
|
proc network*(ifa: InterfaceAddress): TransportAddress {.inline.} =
|
|
## Return network address for ``ifa``.
|
|
result = ifa.net.network()
|
|
|
|
proc netmask*(ifa: InterfaceAddress): TransportAddress {.inline.} =
|
|
## Return network mask for ``ifa``.
|
|
result = ifa.net.subnetMask()
|
|
|
|
proc init*(ift: typedesc[InterfaceAddress], address: TransportAddress,
|
|
prefix: int): InterfaceAddress =
|
|
## Initialize ``InterfaceAddress`` using ``address`` and prefix length
|
|
## ``prefix``.
|
|
result.host = address
|
|
result.net = IpNet.init(address, prefix)
|
|
|
|
proc `$`*(ifa: InterfaceAddress): string {.inline.} =
|
|
## Return string representation of ``ifa``.
|
|
if ifa.host.family == AddressFamily.IPv4:
|
|
result = $ifa.net
|
|
elif ifa.host.family == AddressFamily.IPv6:
|
|
result = $ifa.net
|
|
|
|
proc `$`*(iface: NetworkInterface): string =
|
|
## Return string representation of network interface ``iface``.
|
|
result = $iface.ifIndex
|
|
if len(result) == 1:
|
|
result.add(". ")
|
|
else:
|
|
result.add(". ")
|
|
result.add(iface.name)
|
|
when defined(windows):
|
|
result.add(" [")
|
|
result.add(iface.desc)
|
|
result.add("]")
|
|
result.add(": flags = ")
|
|
result.add($iface.flags)
|
|
result.add(" mtu ")
|
|
result.add($iface.mtu)
|
|
result.add(" state ")
|
|
result.add($iface.state)
|
|
result.add("\n ")
|
|
result.add($iface.ifType)
|
|
result.add(" ")
|
|
if iface.maclen > 0:
|
|
for i in 0..<iface.maclen:
|
|
result.add(toHex(iface.mac[i]))
|
|
if i < iface.maclen - 1:
|
|
result.add(":")
|
|
for item in iface.addresses:
|
|
result.add("\n ")
|
|
if item.host.family == AddressFamily.IPv4:
|
|
result.add("inet ")
|
|
elif item.host.family == AddressFamily.IPv6:
|
|
result.add("inet6 ")
|
|
result.add($item)
|
|
result.add(" netmask ")
|
|
result.add($(item.netmask().address()))
|
|
result.add(" brd ")
|
|
result.add($(item.broadcast().address()))
|
|
|
|
proc `$`*(route: Route): string =
|
|
result = $route.dest.address()
|
|
result.add(" via ")
|
|
if route.gateway.family != AddressFamily.None:
|
|
result.add("gateway ")
|
|
result.add($route.gateway.address())
|
|
else:
|
|
result.add("link")
|
|
result.add(" src ")
|
|
result.add($route.source.address())
|
|
|
|
proc cmp*(a, b: NetworkInterface): int =
|
|
result = cmp(a.ifIndex, b.ifIndex)
|
|
|
|
when defined(linux):
|
|
import posix
|
|
|
|
const
|
|
AF_NETLINK = cint(16)
|
|
AF_PACKET = cint(17)
|
|
NETLINK_ROUTE = cint(0)
|
|
NLMSG_ALIGNTO = 4'u
|
|
RTA_ALIGNTO = 4'u
|
|
# RTA_UNSPEC = 0'u16
|
|
RTA_DST = 1'u16
|
|
# RTA_SRC = 2'u16
|
|
# RTA_IIF = 3'u16
|
|
RTA_OIF = 4'u16
|
|
RTA_GATEWAY = 5'u16
|
|
# RTA_PRIORITY = 6'u16
|
|
RTA_PREFSRC = 7'u16
|
|
# RTA_METRICS = 8'u16
|
|
|
|
RTM_F_LOOKUP_TABLE = 0x1000
|
|
|
|
RTM_GETLINK = 18
|
|
RTM_GETADDR = 22
|
|
RTM_GETROUTE = 26
|
|
NLM_F_REQUEST = 1
|
|
NLM_F_ROOT = 0x100
|
|
NLM_F_MATCH = 0x200
|
|
NLM_F_DUMP = NLM_F_ROOT or NLM_F_MATCH
|
|
IFLIST_REPLY_BUFFER = 8192
|
|
InvalidSocketHandle = SocketHandle(-1)
|
|
NLMSG_DONE = 0x03
|
|
# NLMSG_MIN_TYPE = 0x10
|
|
NLMSG_ERROR = 0x02
|
|
# MSG_TRUNC = 0x20
|
|
|
|
IFLA_ADDRESS = 1
|
|
IFLA_IFNAME = 3
|
|
IFLA_MTU = 4
|
|
IFLA_OPERSTATE = 16
|
|
|
|
IFA_ADDRESS = 1
|
|
IFA_LOCAL = 2
|
|
# IFA_BROADCAST = 4
|
|
|
|
# ARPHRD_NETROM = 0
|
|
ARPHRD_ETHER = 1
|
|
ARPHRD_EETHER = 2
|
|
# ARPHRD_AX25 = 3
|
|
# ARPHRD_PRONET = 4
|
|
# ARPHRD_CHAOS = 5
|
|
# ARPHRD_IEEE802 = 6
|
|
ARPHRD_ARCNET = 7
|
|
# ARPHRD_APPLETLK = 8
|
|
# ARPHRD_DLCI = 15
|
|
ARPHRD_ATM = 19
|
|
# ARPHRD_METRICOM = 23
|
|
ARPHRD_IEEE1394 = 24
|
|
# ARPHRD_EUI64 = 27
|
|
# ARPHRD_INFINIBAND = 32
|
|
ARPHRD_SLIP = 256
|
|
ARPHRD_CSLIP = 257
|
|
ARPHRD_SLIP6 = 258
|
|
ARPHRD_CSLIP6 = 259
|
|
# ARPHRD_RSRVD = 260
|
|
# ARPHRD_ADAPT = 264
|
|
# ARPHRD_ROSE = 270
|
|
# ARPHRD_X25 = 271
|
|
# ARPHRD_HWX25 = 272
|
|
# ARPHRD_CAN = 280
|
|
ARPHRD_PPP = 512
|
|
ARPHRD_CISCO = 513
|
|
ARPHRD_HDLC = ARPHRD_CISCO
|
|
ARPHRD_LAPB = 516
|
|
# ARPHRD_DDCMP = 517
|
|
# ARPHRD_RAWHDLC = 518
|
|
# ARPHRD_TUNNEL = 768
|
|
# ARPHRD_TUNNEL6 = 769
|
|
ARPHRD_FRAD = 770
|
|
# ARPHRD_SKIP = 771
|
|
ARPHRD_LOOPBACK = 772
|
|
# ARPHRD_LOCALTLK = 773
|
|
# ARPHRD_FDDI = 774
|
|
# ARPHRD_BIF = 775
|
|
# ARPHRD_SIT = 776
|
|
# ARPHRD_IPDDP = 777
|
|
# ARPHRD_IPGRE = 778
|
|
# ARPHRD_PIMREG = 779
|
|
ARPHRD_HIPPI = 780
|
|
# ARPHRD_ASH = 781
|
|
# ARPHRD_ECONET = 782
|
|
# ARPHRD_IRDA = 783
|
|
# ARPHRD_FCPP = 784
|
|
# ARPHRD_FCAL = 785
|
|
# ARPHRD_FCPL = 786
|
|
# ARPHRD_FCFABRIC = 787
|
|
# ARPHRD_IEEE802_TR = 800
|
|
ARPHRD_IEEE80211 = 801
|
|
ARPHRD_IEEE80211_PRISM = 802
|
|
ARPHRD_IEEE80211_RADIOTAP = 803
|
|
# ARPHRD_IEEE802154 = 804
|
|
# ARPHRD_IEEE802154_MONITOR = 805
|
|
# ARPHRD_PHONET = 820
|
|
# ARPHRD_PHONET_PIPE = 821
|
|
# ARPHRD_CAIF = 822
|
|
# ARPHRD_IP6GRE = 823
|
|
# ARPHRD_NETLINK = 824
|
|
# ARPHRD_6LOWPAN = 825
|
|
# ARPHRD_VOID = 0xFFFF
|
|
# ARPHRD_NONE = 0xFFFE
|
|
|
|
type
|
|
SockAddr_nl = object
|
|
family: cushort
|
|
pad: cushort
|
|
pid: uint32
|
|
groups: uint32
|
|
|
|
NlMsgHeader = object
|
|
nlmsg_len: uint32
|
|
nlmsg_type: uint16
|
|
nlmsg_flags: uint16
|
|
nlmsg_seq: uint32
|
|
nlmsg_pid: uint32
|
|
|
|
IfInfoMessage = object
|
|
ifi_family: cuchar
|
|
ifi_pad: cuchar
|
|
ifi_type: cushort
|
|
ifi_index: cint
|
|
ifi_flags: cuint
|
|
ifi_change: cuint
|
|
|
|
IfAddrMessage = object
|
|
ifa_family: cuchar
|
|
ifa_prefixlen: cuchar
|
|
ifa_flags: cuchar
|
|
ifa_scope: cuchar
|
|
ifa_index: uint32
|
|
|
|
RtMessage = object
|
|
rtm_family: byte
|
|
rtm_dst_len: byte
|
|
rtm_src_len: byte
|
|
rtm_tos: byte
|
|
rtm_table: byte
|
|
rtm_protocol: byte
|
|
rtm_scope: byte
|
|
rtm_type: byte
|
|
rtm_flags: cuint
|
|
|
|
RtAttr = object
|
|
rta_len: cushort
|
|
rta_type: cushort
|
|
|
|
RtGenMsg = object
|
|
rtgen_family: byte
|
|
|
|
NLReq = object
|
|
hdr: NlMsgHeader
|
|
msg: RtGenMsg
|
|
|
|
NLRouteReq = object
|
|
hdr: NlMsgHeader
|
|
msg: RtMessage
|
|
|
|
template NLMSG_ALIGN(length: uint): uint =
|
|
(length + NLMSG_ALIGNTO - 1) and not(NLMSG_ALIGNTO - 1)
|
|
|
|
template NLMSG_HDRLEN(): int =
|
|
int(NLMSG_ALIGN(uint(sizeof(NlMsgHeader))))
|
|
|
|
template NLMSG_LENGTH(length: int): uint32 =
|
|
uint32(NLMSG_HDRLEN() + length)
|
|
|
|
proc NLMSG_OK(nlh: ptr NlMsgHeader, length: int): bool {.inline.} =
|
|
result = (length >= int(sizeof(NlMsgHeader))) and
|
|
(nlh.nlmsg_len >= uint32(sizeof(NlMsgHeader))) and
|
|
(nlh.nlmsg_len <= uint32(length))
|
|
|
|
proc NLMSG_NEXT(nlh: ptr NlMsgHeader,
|
|
length: var int): ptr NlMsgHeader {.inline.} =
|
|
length = length - int(NLMSG_ALIGN(uint(nlh.nlmsg_len)))
|
|
result = cast[ptr NlMsgHeader](cast[uint](nlh) +
|
|
cast[uint](NLMSG_ALIGN(uint(nlh.nlmsg_len))))
|
|
|
|
proc NLMSG_DATA(nlh: ptr NlMsgHeader): ptr byte {.inline.} =
|
|
result = cast[ptr byte](cast[uint](nlh) + NLMSG_LENGTH(0))
|
|
|
|
proc NLMSG_TAIL(nlh: ptr NlMsgHeader): ptr byte {.inline.} =
|
|
cast[ptr byte](cast[uint](nlh) + NLMSG_ALIGN(uint(nlh.nlmsg_len)))
|
|
|
|
template RTA_ALIGN*(length: uint): uint =
|
|
(length + RTA_ALIGNTO - 1) and not(RTA_ALIGNTO - 1)
|
|
|
|
template RTA_HDRLEN(): int =
|
|
int(RTA_ALIGN(uint(sizeof(RtAttr))))
|
|
|
|
template RTA_LENGTH(length: int): uint =
|
|
uint(RTA_HDRLEN()) + uint(length)
|
|
|
|
template RTA_PAYLOAD*(length: uint): uint =
|
|
length - RTA_LENGTH(0)
|
|
|
|
proc IFLA_RTA(r: ptr byte): ptr RtAttr {.inline.} =
|
|
cast[ptr RtAttr](cast[uint](r) + NLMSG_ALIGN(uint(sizeof(IfInfoMessage))))
|
|
|
|
proc IFA_RTA(r: ptr byte): ptr RtAttr {.inline.} =
|
|
cast[ptr RtAttr](cast[uint](r) + NLMSG_ALIGN(uint(sizeof(IfAddrMessage))))
|
|
|
|
proc RT_RTA(r: ptr byte): ptr RtAttr {.inline.} =
|
|
cast[ptr RtAttr](cast[uint](r) + NLMSG_ALIGN(uint(sizeof(RtMessage))))
|
|
|
|
proc RTA_OK(rta: ptr RtAttr, length: int): bool {.inline.} =
|
|
result = length >= sizeof(RtAttr) and
|
|
rta.rta_len >= cushort(sizeof(RtAttr)) and
|
|
rta.rta_len <= cushort(length)
|
|
|
|
proc RTA_NEXT(rta: ptr RtAttr, length: var int): ptr RtAttr {.inline.} =
|
|
length = length - int(RTA_ALIGN(uint(rta.rta_len)))
|
|
result = cast[ptr RtAttr](cast[uint](rta) +
|
|
cast[uint](RTA_ALIGN(uint(rta.rta_len))))
|
|
|
|
proc RTA_DATA(rta: ptr RtAttr): ptr byte {.inline.} =
|
|
result = cast[ptr byte](cast[uint](rta) + RTA_LENGTH(0))
|
|
|
|
proc toInterfaceState(it: cint, flags: cuint): InterfaceState {.inline.} =
|
|
case it
|
|
of 1:
|
|
result = StatusNotPresent
|
|
of 2:
|
|
result = StatusDown
|
|
of 3:
|
|
result = StatusLowerLayerDown
|
|
of 4:
|
|
result = StatusTesting
|
|
of 5:
|
|
result = StatusDormant
|
|
of 6:
|
|
result = StatusUp
|
|
else:
|
|
result = StatusUnknown
|
|
|
|
proc toInterfaceType(ft: uint32): InterfaceType {.inline.} =
|
|
case ft
|
|
of ARPHRD_ETHER, ARPHRD_EETHER:
|
|
result = IfEthernetCsmacd
|
|
of ARPHRD_LOOPBACK:
|
|
result = IfSoftwareLoopback
|
|
of 787..799:
|
|
result = IfFibreChannel
|
|
of ARPHRD_PPP:
|
|
result = IfPpp
|
|
of ARPHRD_SLIP, ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6:
|
|
result = IfSlip
|
|
of ARPHRD_IEEE1394:
|
|
result = IfIeee1394
|
|
of ARPHRD_IEEE80211, ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP:
|
|
result = IfIeee80211
|
|
of ARPHRD_ATM:
|
|
result = IfAtm
|
|
of ARPHRD_HDLC:
|
|
result = IfHdlc
|
|
of ARPHRD_HIPPI:
|
|
result = IfHippiInterface
|
|
of ARPHRD_ARCNET:
|
|
result = IfArcNet
|
|
of ARPHRD_LAPB:
|
|
result = IfLapB
|
|
of ARPHRD_FRAD:
|
|
result = IfFrameRelay
|
|
else:
|
|
result = IfOther
|
|
|
|
proc createNetlinkSocket(pid: Pid): SocketHandle =
|
|
var address: SockAddr_nl
|
|
address.family = cushort(AF_NETLINK)
|
|
address.groups = 0
|
|
address.pid = cast[uint32](pid)
|
|
result = posix.socket(AF_NETLINK, posix.SOCK_DGRAM, NETLINK_ROUTE)
|
|
if result != SocketHandle(-1):
|
|
if posix.bindSocket(result, cast[ptr SockAddr](addr address),
|
|
Socklen(sizeof(SockAddr_nl))) != 0:
|
|
discard posix.close(result)
|
|
result = SocketHandle(-1)
|
|
|
|
proc sendLinkMessage(fd: SocketHandle, pid: Pid, seqno: uint32,
|
|
ntype: uint16, nflags: uint16): bool =
|
|
var
|
|
rmsg: Tmsghdr
|
|
iov: IOVec
|
|
req: NLReq
|
|
address: SockAddr_nl
|
|
|
|
type TIovLen = type iov.iov_len
|
|
|
|
address.family = cushort(AF_NETLINK)
|
|
req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(RtGenMsg))
|
|
req.hdr.nlmsg_type = ntype
|
|
req.hdr.nlmsg_flags = nflags
|
|
req.hdr.nlmsg_seq = seqno
|
|
req.hdr.nlmsg_pid = cast[uint32](pid)
|
|
req.msg.rtgen_family = byte(AF_PACKET)
|
|
iov.iov_base = cast[pointer](addr req)
|
|
iov.iov_len = cast[TIovLen](req.hdr.nlmsg_len)
|
|
rmsg.msg_iov = addr iov
|
|
rmsg.msg_iovlen = 1
|
|
rmsg.msg_name = cast[pointer](addr address)
|
|
rmsg.msg_namelen = Socklen(sizeof(SockAddr_nl))
|
|
let res = posix.sendmsg(fd, addr rmsg, 0).TIovLen
|
|
if res == iov.iov_len:
|
|
result = true
|
|
|
|
proc sendRouteMessage(fd: SocketHandle, pid: Pid, seqno: uint32,
|
|
ntype: uint16, nflags: uint16,
|
|
dest: TransportAddress): bool =
|
|
var
|
|
rmsg: Tmsghdr
|
|
iov: IOVec
|
|
address: SockAddr_nl
|
|
buffer: array[64, byte]
|
|
|
|
type TIovLen = type iov.iov_len
|
|
|
|
var req = cast[ptr NlRouteReq](addr buffer[0])
|
|
|
|
address.family = cushort(AF_NETLINK)
|
|
req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(RtMessage))
|
|
req.hdr.nlmsg_type = ntype
|
|
req.hdr.nlmsg_flags = nflags
|
|
req.hdr.nlmsg_seq = seqno
|
|
req.hdr.nlmsg_pid = cast[uint32](pid)
|
|
|
|
var attr = cast[ptr RtAttr](NLMSG_TAIL(addr req.hdr))
|
|
|
|
req.msg.rtm_flags = RTM_F_LOOKUP_TABLE
|
|
attr.rta_type = RTA_DST
|
|
if dest.family == AddressFamily.IPv4:
|
|
req.msg.rtm_family = byte(posix.AF_INET)
|
|
attr.rta_len = cast[cushort](RTA_LENGTH(4))
|
|
copyMem(RTA_DATA(attr), cast[ptr byte](unsafeAddr dest.address_v4[0]), 4)
|
|
req.hdr.nlmsg_len = uint32(NLMSG_ALIGN(uint(req.hdr.nlmsg_len)) +
|
|
RTA_ALIGN(uint(attr.rta_len)))
|
|
req.msg.rtm_dst_len = 4 * 8
|
|
elif dest.family == AddressFamily.IPv6:
|
|
req.msg.rtm_family = byte(posix.AF_INET6)
|
|
attr.rta_len = cast[cushort](RTA_LENGTH(16))
|
|
copyMem(RTA_DATA(attr), cast[ptr byte](unsafeAddr dest.address_v6[0]), 16)
|
|
req.hdr.nlmsg_len = uint32(NLMSG_ALIGN(uint(req.hdr.nlmsg_len)) +
|
|
RTA_ALIGN(uint(attr.rta_len)))
|
|
req.msg.rtm_dst_len = 16 * 8
|
|
|
|
iov.iov_base = cast[pointer](addr buffer[0])
|
|
iov.iov_len = cast[TIovLen](req.hdr.nlmsg_len)
|
|
rmsg.msg_iov = addr iov
|
|
rmsg.msg_iovlen = 1
|
|
rmsg.msg_name = cast[pointer](addr address)
|
|
rmsg.msg_namelen = Socklen(sizeof(SockAddr_nl))
|
|
let res = posix.sendmsg(fd, addr rmsg, 0).TIovLen
|
|
if res == iov.iov_len:
|
|
result = true
|
|
|
|
proc readNetlinkMessage(fd: SocketHandle, data: var seq[byte]): bool =
|
|
var
|
|
rmsg: Tmsghdr
|
|
iov: IOVec
|
|
address: SockAddr_nl
|
|
data.setLen(IFLIST_REPLY_BUFFER)
|
|
iov.iov_base = cast[pointer](addr data[0])
|
|
iov.iov_len = IFLIST_REPLY_BUFFER
|
|
rmsg.msg_iov = addr iov
|
|
rmsg.msg_iovlen = 1
|
|
rmsg.msg_name = cast[pointer](addr address)
|
|
rmsg.msg_namelen = SockLen(sizeof(SockAddr_nl))
|
|
var length = posix.recvmsg(fd, addr rmsg, 0)
|
|
if length >= 0:
|
|
data.setLen(length)
|
|
result = true
|
|
else:
|
|
data.setLen(0)
|
|
|
|
proc processLink(msg: ptr NlMsgHeader): NetworkInterface =
|
|
var iface: ptr IfInfoMessage
|
|
var attr: ptr RtAttr
|
|
var length: int
|
|
|
|
iface = cast[ptr IfInfoMessage](NLMSG_DATA(msg))
|
|
length = int(msg.nlmsg_len) - int(NLMSG_LENGTH(sizeof(IfInfoMessage)))
|
|
|
|
attr = IFLA_RTA(cast[ptr byte](iface))
|
|
result.ifType = toInterfaceType(iface.ifi_type)
|
|
result.ifIndex = iface.ifi_index
|
|
result.flags = cast[uint64](iface.ifi_flags)
|
|
|
|
while RTA_OK(attr, length):
|
|
if attr.rta_type == IFLA_IFNAME:
|
|
var p = cast[cstring](RTA_DATA(attr))
|
|
result.name = $p
|
|
elif attr.rta_type == IFLA_ADDRESS:
|
|
var p = cast[ptr byte](RTA_DATA(attr))
|
|
var plen = min(int(RTA_PAYLOAD(uint(attr.rta_len))), len(result.mac))
|
|
copyMem(addr result.mac[0], p, plen)
|
|
result.maclen = plen
|
|
elif attr.rta_type == IFLA_MTU:
|
|
var p = cast[ptr uint32](RTA_DATA(attr))
|
|
result.mtu = cast[int](p[])
|
|
elif attr.rta_type == IFLA_OPERSTATE:
|
|
var p = cast[ptr byte](RTA_DATA(attr))
|
|
result.state = toInterfaceState(cast[cint](p[]), iface.ifi_flags)
|
|
attr = RTA_NEXT(attr, length)
|
|
|
|
proc getAddress(f: int, p: pointer): TransportAddress {.inline.} =
|
|
if f == posix.AF_INET:
|
|
result = TransportAddress(family: AddressFamily.IPv4)
|
|
copyMem(addr result.address_v4[0], p, len(result.address_v4))
|
|
elif f == posix.AF_INET6:
|
|
result = TransportAddress(family: AddressFamily.IPv6)
|
|
copyMem(addr result.address_v6[0], p, len(result.address_v6))
|
|
|
|
proc processAddress(msg: ptr NlMsgHeader): NetworkInterface =
|
|
var iaddr: ptr IfAddrMessage
|
|
var attr: ptr RtAttr
|
|
var length: int
|
|
|
|
iaddr = cast[ptr IfAddrMessage](NLMSG_DATA(msg))
|
|
length = int(msg.nlmsg_len) - int(NLMSG_LENGTH(sizeof(IfAddrMessage)))
|
|
|
|
attr = IFA_RTA(cast[ptr byte](iaddr))
|
|
|
|
let family = cast[int](iaddr.ifa_family)
|
|
result.ifIndex = cast[int](iaddr.ifa_index)
|
|
|
|
var address, local: TransportAddress
|
|
|
|
while RTA_OK(attr, length):
|
|
if attr.rta_type == IFA_LOCAL:
|
|
local = getAddress(family, cast[pointer](RTA_DATA(attr)))
|
|
elif attr.rta_type == IFA_ADDRESS:
|
|
address = getAddress(family, cast[pointer](RTA_DATA(attr)))
|
|
attr = RTA_NEXT(attr, length)
|
|
|
|
if local.family != AddressFamily.None:
|
|
address = local
|
|
if len(result.addresses) == 0:
|
|
result.addresses = newSeq[InterfaceAddress]()
|
|
let prefixLength = cast[int](iaddr.ifa_prefixlen)
|
|
let ifaddr = InterfaceAddress.init(address, prefixLength)
|
|
result.addresses.add(ifaddr)
|
|
|
|
proc processRoute(msg: ptr NlMsgHeader): Route =
|
|
var rtmsg = cast[ptr RtMessage](NLMSG_DATA(msg))
|
|
var length = int(msg.nlmsg_len) - int(NLMSG_LENGTH(sizeof(RtMessage)))
|
|
var attr = RT_RTA(cast[ptr byte](rtmsg))
|
|
while RTA_OK(attr, length):
|
|
if attr.rta_type == RTA_DST:
|
|
result.dest = getAddress(int(rtmsg.rtm_family),
|
|
cast[pointer](RTA_DATA(attr)))
|
|
elif attr.rta_type == RTA_GATEWAY:
|
|
result.gateway = getAddress(int(rtmsg.rtm_family),
|
|
cast[pointer](RTA_DATA(attr)))
|
|
elif attr.rta_type == RTA_OIF:
|
|
var oid: uint32
|
|
copyMem(addr oid, RTA_DATA(attr), sizeof(uint32))
|
|
result.ifIndex = int(oid)
|
|
elif attr.rta_type == RTA_PREFSRC:
|
|
result.source = getAddress(int(rtmsg.rtm_family),
|
|
cast[pointer](RTA_DATA(attr)))
|
|
attr = RTA_NEXT(attr, length)
|
|
|
|
proc getRoute(netfd: SocketHandle, pid: Pid,
|
|
address: TransportAddress): Route =
|
|
if not sendRouteMessage(netfd, pid, 1, RTM_GETROUTE,
|
|
NLM_F_REQUEST, address):
|
|
return
|
|
var data = newSeq[byte]()
|
|
while true:
|
|
if not readNetlinkMessage(netfd, data):
|
|
break
|
|
var length = len(data)
|
|
var msg = cast[ptr NlMsgHeader](addr data[0])
|
|
var endflag = false
|
|
while NLMSG_OK(msg, length):
|
|
if msg.nlmsg_type == NLMSG_ERROR:
|
|
endflag = true
|
|
break
|
|
else:
|
|
result = processRoute(msg)
|
|
endflag = true
|
|
break
|
|
msg = NLMSG_NEXT(msg, length)
|
|
if endflag:
|
|
break
|
|
|
|
proc getLinks(netfd: SocketHandle, pid: Pid): seq[NetworkInterface] =
|
|
if not sendLinkMessage(netfd, pid, 1, RTM_GETLINK,
|
|
NLM_F_REQUEST or NLM_F_DUMP):
|
|
return
|
|
var data = newSeq[byte]()
|
|
result = newSeq[NetworkInterface]()
|
|
while true:
|
|
if not readNetlinkMessage(netfd, data):
|
|
break
|
|
var length = len(data)
|
|
if length == 0:
|
|
break
|
|
var msg = cast[ptr NlMsgHeader](addr data[0])
|
|
var endflag = false
|
|
while NLMSG_OK(msg, length):
|
|
if msg.nlmsg_type == NLMSG_DONE:
|
|
endflag = true
|
|
break
|
|
elif msg.nlmsg_type == NLMSG_ERROR:
|
|
endflag = true
|
|
break
|
|
else:
|
|
var iface = processLink(msg)
|
|
result.add(iface)
|
|
msg = NLMSG_NEXT(msg, length)
|
|
if endflag:
|
|
break
|
|
|
|
proc getAddresses(netfd: SocketHandle, pid: Pid,
|
|
ifaces: var seq[NetworkInterface]) =
|
|
if not sendLinkMessage(netfd, pid, 2, RTM_GETADDR,
|
|
NLM_F_REQUEST or NLM_F_DUMP):
|
|
return
|
|
var data = newSeq[byte]()
|
|
while true:
|
|
if not readNetlinkMessage(netfd, data):
|
|
break
|
|
var length = len(data)
|
|
if length == 0:
|
|
break
|
|
var msg = cast[ptr NlMsgHeader](addr data[0])
|
|
var endflag = false
|
|
while NLMSG_OK(msg, length):
|
|
if msg.nlmsg_type == NLMSG_DONE:
|
|
endflag = true
|
|
break
|
|
elif msg.nlmsg_type == NLMSG_ERROR:
|
|
endflag = true
|
|
break
|
|
else:
|
|
var iface = processAddress(msg)
|
|
for i in 0..<len(ifaces):
|
|
if ifaces[i].ifIndex == iface.ifIndex:
|
|
for item in iface.addresses:
|
|
ifaces[i].addresses.add(item)
|
|
msg = NLMSG_NEXT(msg, length)
|
|
if endflag:
|
|
break
|
|
|
|
proc getInterfaces*(): seq[NetworkInterface] =
|
|
## Return list of available interfaces.
|
|
var pid = posix.getpid()
|
|
var sock = createNetlinkSocket(pid)
|
|
if sock == InvalidSocketHandle:
|
|
return
|
|
result = getLinks(sock, pid)
|
|
getAddresses(sock, pid, result)
|
|
sort(result, cmp)
|
|
discard posix.close(sock)
|
|
|
|
proc getBestRoute*(address: TransportAddress): Route =
|
|
## Return best applicable OS route, which will be used for connecting to
|
|
## address ``address``.
|
|
var pid = posix.getpid()
|
|
var sock = createNetlinkSocket(pid)
|
|
if sock == InvalidSocketHandle:
|
|
return
|
|
result = getRoute(sock, pid, address)
|
|
discard posix.close(sock)
|
|
|
|
elif defined(macosx) or defined(bsd):
|
|
import posix
|
|
|
|
const
|
|
AF_LINK = 18
|
|
IFF_UP = 0x01
|
|
IFF_RUNNING = 0x40
|
|
|
|
PF_ROUTE = cint(17)
|
|
RTM_GET = 0x04'u8
|
|
RTF_UP = 0x01
|
|
RTF_GATEWAY = 0x02
|
|
RTM_VERSION = 5'u8
|
|
|
|
RTA_DST = 0x01
|
|
RTA_GATEWAY = 0x02
|
|
|
|
type
|
|
IfAddrs {.importc: "struct ifaddrs", header: "<ifaddrs.h>",
|
|
pure, final.} = object
|
|
ifa_next {.importc: "ifa_next".}: ptr IfAddrs
|
|
ifa_name {.importc: "ifa_name".}: ptr cchar
|
|
ifa_flags {.importc: "ifa_flags".}: cuint
|
|
ifa_addr {.importc: "ifa_addr".}: ptr SockAddr
|
|
ifa_netmask {.importc: "ifa_netmask".}: ptr SockAddr
|
|
ifa_dstaddr {.importc: "ifa_dstaddr".}: ptr SockAddr
|
|
ifa_data {.importc: "ifa_data".}: pointer
|
|
|
|
PIfAddrs = ptr IfAddrs
|
|
|
|
IfData {.importc: "struct if_data", header: "<net/if.h>",
|
|
pure, final.} = object
|
|
ifi_type {.importc: "ifi_type".}: byte
|
|
ifi_typelen {.importc: "ifi_typelen".}: byte
|
|
ifi_physical {.importc: "ifi_physical".}: byte
|
|
ifi_addrlen {.importc: "ifi_addrlen".}: byte
|
|
ifi_hdrlen {.importc: "ifi_hdrlen".}: byte
|
|
ifi_recvquota {.importc: "ifi_recvquota".}: byte
|
|
ifi_xmitquota {.importc: "ifi_xmitquota".}: byte
|
|
ifi_unused1 {.importc: "ifi_unused1".}: byte
|
|
ifi_mtu {.importc: "ifi_mtu".}: uint32
|
|
ifi_metric {.importc: "ifi_metric".}: uint32
|
|
ifi_baudrate {.importc: "ifi_baudrate".}: uint32
|
|
ifi_ipackets {.importc: "ifi_ipackets".}: uint32
|
|
ifi_ierrors {.importc: "ifi_ierrors".}: uint32
|
|
ifi_opackets {.importc: "ifi_opackets".}: uint32
|
|
ifi_oerrors {.importc: "ifi_oerrors".}: uint32
|
|
ifi_collisions {.importc: "ifi_collisions".}: uint32
|
|
ifi_ibytes {.importc: "ifi_ibytes".}: uint32
|
|
ifi_obytes {.importc: "ifi_obytes".}: uint32
|
|
ifi_imcasts {.importc: "ifi_imcasts".}: uint32
|
|
ifi_omcasts {.importc: "ifi_omcasts".}: uint32
|
|
ifi_iqdrops {.importc: "ifi_iqdrops".}: uint32
|
|
ifi_noproto {.importc: "ifi_noproto".}: uint32
|
|
ifi_recvtiming {.importc: "ifi_recvtiming".}: uint32
|
|
ifi_xmittiming {.importc: "ifi_xmittiming".}: uint32
|
|
ifi_lastchange {.importc: "ifi_lastchange".}: Timeval
|
|
ifi_unused2 {.importc: "ifi_unused2".}: uint32
|
|
ifi_hwassist {.importc: "ifi_hwassist".}: uint32
|
|
ifi_reserved1 {.importc: "ifi_reserved1".}: uint32
|
|
ifi_reserved2 {.importc: "ifi_reserved2".}: uint32
|
|
|
|
SockAddr_dl = object
|
|
sdl_len: byte
|
|
sdl_family: byte
|
|
sdl_index: uint16
|
|
sdl_type: byte
|
|
sdl_nlen: byte
|
|
sdl_alen: byte
|
|
sdl_slen: byte
|
|
sdl_data: array[12, byte]
|
|
|
|
RtMetrics = object
|
|
rmx_locks: uint32
|
|
rmx_mtu: uint32
|
|
rmx_hopcount: uint32
|
|
rmx_expire: int32
|
|
rmx_recvpipe: uint32
|
|
rmx_sendpipe: uint32
|
|
rmx_ssthresh: uint32
|
|
rmx_rtt: uint32
|
|
rmx_rttvar: uint32
|
|
rmx_pksent: uint32
|
|
rmx_state: uint32
|
|
rmx_filler: array[3, uint32]
|
|
|
|
RtMsgHeader = object
|
|
rtm_msglen: uint16
|
|
rtm_version: byte
|
|
rtm_type: byte
|
|
rtm_index: uint16
|
|
rtm_flags: cint
|
|
rtm_addrs: cint
|
|
rtm_pid: Pid
|
|
rtm_seq: cint
|
|
rtm_errno: cint
|
|
rtm_use: cint
|
|
rtm_inits: uint32
|
|
rtm_rmx: RtMetrics
|
|
|
|
RtMessage = object
|
|
rtm: RtMsgHeader
|
|
space: array[512, byte]
|
|
|
|
proc getIfAddrs(ifap: ptr PIfAddrs): cint {.importc: "getifaddrs",
|
|
header: """#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <ifaddrs.h>""".}
|
|
proc freeIfAddrs(ifap: ptr IfAddrs) {.importc: "freeifaddrs",
|
|
header: """#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <ifaddrs.h>""".}
|
|
|
|
proc toInterfaceType(f: byte): InterfaceType {.inline.} =
|
|
var ft = cast[int](f)
|
|
if (ft >= 1 and ft <= 196) or (ft == 237) or (ft == 243) or (ft == 244):
|
|
result = cast[InterfaceType](ft)
|
|
else:
|
|
result = IfOther
|
|
|
|
proc toInterfaceState(f: cuint): InterfaceState {.inline.} =
|
|
if (f and IFF_RUNNING) != 0 and (f and IFF_UP) != 0:
|
|
result = StatusUp
|
|
else:
|
|
result = StatusDown
|
|
|
|
proc getInterfaces*(): seq[NetworkInterface] =
|
|
## Return list of available interfaces.
|
|
var ifap: ptr IfAddrs
|
|
let res = getIfAddrs(addr ifap)
|
|
if res == 0:
|
|
result = newSeq[NetworkInterface]()
|
|
while not isNil(ifap):
|
|
var iface: NetworkInterface
|
|
var ifaddress: InterfaceAddress
|
|
|
|
iface.name = $ifap.ifa_name
|
|
iface.flags = cast[uint64](ifap.ifa_flags)
|
|
var i = 0
|
|
while i < len(result):
|
|
if result[i].name == iface.name:
|
|
break
|
|
inc(i)
|
|
if i == len(result):
|
|
result.add(iface)
|
|
|
|
if not isNil(ifap.ifa_addr):
|
|
let family = cast[int](ifap.ifa_addr.sa_family)
|
|
if family == AF_LINK:
|
|
var data = cast[ptr IfData](ifap.ifa_data)
|
|
var link = cast[ptr SockAddr_dl](ifap.ifa_addr)
|
|
result[i].ifIndex = cast[int](link.sdl_index)
|
|
let nlen = cast[int](link.sdl_nlen)
|
|
if nlen < len(link.sdl_data):
|
|
let minsize = min(cast[int](link.sdl_alen), len(result[i].mac))
|
|
copyMem(addr result[i].mac[0], addr link.sdl_data[nlen], minsize)
|
|
result[i].maclen = cast[int](link.sdl_alen)
|
|
result[i].ifType = toInterfaceType(data.ifi_type)
|
|
result[i].state = toInterfaceState(ifap.ifa_flags)
|
|
result[i].mtu = cast[int](data.ifi_mtu)
|
|
elif family == posix.AF_INET:
|
|
fromSAddr(cast[ptr Sockaddr_storage](ifap.ifa_addr),
|
|
Socklen(sizeof(SockAddr_in)), ifaddress.host)
|
|
elif family == posix.AF_INET6:
|
|
fromSAddr(cast[ptr Sockaddr_storage](ifap.ifa_addr),
|
|
Socklen(sizeof(SockAddr_in6)), ifaddress.host)
|
|
if not isNil(ifap.ifa_netmask):
|
|
var na: TransportAddress
|
|
var family = cast[cint](ifap.ifa_netmask.sa_family)
|
|
if family == posix.AF_INET:
|
|
fromSAddr(cast[ptr Sockaddr_storage](ifap.ifa_netmask),
|
|
Socklen(sizeof(SockAddr_in)), na)
|
|
elif family == posix.AF_INET6:
|
|
fromSAddr(cast[ptr Sockaddr_storage](ifap.ifa_netmask),
|
|
Socklen(sizeof(SockAddr_in6)), na)
|
|
ifaddress.net = IpNet.init(ifaddress.host, na)
|
|
|
|
if ifaddress.host.family != AddressFamily.None:
|
|
if len(result[i].addresses) == 0:
|
|
result[i].addresses = newSeq[InterfaceAddress]()
|
|
result[i].addresses.add(ifaddress)
|
|
ifap = ifap.ifa_next
|
|
|
|
sort(result, cmp)
|
|
freeIfAddrs(ifap)
|
|
|
|
proc sasize(data: openarray[byte]): int =
|
|
# SA_SIZE() template. Taken from FreeBSD net/route.h:1.63
|
|
if len(data) > 0:
|
|
if data[0] == 0x00'u8:
|
|
result = sizeof(uint32)
|
|
else:
|
|
result = 1 + (int(data[0] - 1) or (sizeof(uint32) - 1))
|
|
|
|
proc getBestRoute*(address: TransportAddress): Route =
|
|
## Return best applicable OS route, which will be used for connecting to
|
|
## address ``address``.
|
|
var sock: cint
|
|
var msg: RtMessage
|
|
var pid = posix.getpid()
|
|
|
|
if address.family notin {AddressFamily.IPv4, AddressFamily.IPv6}:
|
|
return
|
|
|
|
if address.family == AddressFamily.IPv4:
|
|
sock = cint(posix.socket(PF_ROUTE, posix.SOCK_RAW, posix.AF_INET))
|
|
elif address.family == AddressFamily.IPv6:
|
|
sock = cint(posix.socket(PF_ROUTE, posix.SOCK_RAW, posix.AF_INET6))
|
|
|
|
if sock != -1:
|
|
var sastore: Sockaddr_storage
|
|
var salen: Socklen
|
|
address.toSAddr(sastore, salen)
|
|
# We doing this trick because Nim's posix declaration of Sockaddr_storage
|
|
# is not compatible with BSD version. First byte in BSD version is length
|
|
# of Sockaddr structure, and second byte is family code.
|
|
copyMem(addr msg.space[0], addr sastore, int(salen))
|
|
msg.rtm.rtm_type = RTM_GET
|
|
msg.rtm.rtm_flags = RTF_UP or RTF_GATEWAY
|
|
msg.rtm.rtm_version = RTM_VERSION
|
|
msg.rtm.rtm_seq = 0xCAFE
|
|
msg.rtm.rtm_addrs = RTA_DST
|
|
msg.space[0] = cast[byte](salen)
|
|
msg.rtm.rtm_msglen = uint16(sizeof(RtMessage))
|
|
var res = posix.write(sock, addr msg, sizeof(RtMessage))
|
|
if res >= 0:
|
|
while true:
|
|
res = posix.read(sock, addr msg, sizeof(RtMessage))
|
|
if res >= 0 and msg.rtm.rtm_pid == pid and msg.rtm.rtm_seq == 0xCAFE:
|
|
break
|
|
if res >= 0 and msg.rtm.rtm_version == RTM_VERSION and
|
|
msg.rtm.rtm_errno == 0:
|
|
result.ifIndex = int(msg.rtm.rtm_index)
|
|
var so = 0
|
|
var eo = len(msg.space) - 1
|
|
for i in 0..<2:
|
|
let mask = 1 shl i
|
|
if (msg.rtm.rtm_addrs and mask) != 0:
|
|
var saddr = cast[ptr Sockaddr_storage](addr msg.space[so])
|
|
let size = sasize(msg.space.toOpenArray(so, eo))
|
|
if mask == RTA_DST:
|
|
fromSAddr(saddr, Socklen(size), result.dest)
|
|
elif mask == RTA_GATEWAY:
|
|
fromSAddr(saddr, Socklen(size), result.gateway)
|
|
so += size
|
|
|
|
if result.dest.isZero():
|
|
result.dest = address
|
|
var interfaces = getInterfaces()
|
|
for item in interfaces:
|
|
if result.ifIndex == item.ifIndex:
|
|
for a in item.addresses:
|
|
if a.host.family == address.family:
|
|
result.source = a.host
|
|
break
|
|
discard posix.close(sock)
|
|
|
|
elif defined(windows):
|
|
import winlean, dynlib
|
|
|
|
const
|
|
WorkBufferSize = 16384'u32
|
|
MaxTries = 3
|
|
|
|
AF_UNSPEC = 0x00'u32
|
|
|
|
GAA_FLAG_INCLUDE_PREFIX = 0x0010'u32
|
|
|
|
CP_UTF8 = 65001'u32
|
|
|
|
ERROR_BUFFER_OVERFLOW* = 111'u32
|
|
ERROR_SUCCESS* = 0'u32
|
|
|
|
type
|
|
WCHAR = distinct uint16
|
|
|
|
SocketAddress = object
|
|
lpSockaddr: ptr SockAddr
|
|
iSockaddrLength: cint
|
|
|
|
IpAdapterUnicastAddressXpLh = object
|
|
length: uint32
|
|
flags: uint32
|
|
next: ptr IpAdapterUnicastAddressXpLh
|
|
address: SocketAddress
|
|
prefixOrigin: cint
|
|
suffixOrigin: cint
|
|
dadState: cint
|
|
validLifetime: uint32
|
|
preferredLifetime: uint32
|
|
leaseLifetime: uint32
|
|
onLinkPrefixLength: byte # This field is available only from Vista
|
|
|
|
IpAdapterAnycastAddressXp = object
|
|
length: uint32
|
|
flags: uint32
|
|
next: ptr IpAdapterAnycastAddressXp
|
|
address: SocketAddress
|
|
|
|
IpAdapterMulticastAddressXp = object
|
|
length: uint32
|
|
flags: uint32
|
|
next: ptr IpAdapterMulticastAddressXp
|
|
address: SocketAddress
|
|
|
|
IpAdapterDnsServerAddressXp = object
|
|
length: uint32
|
|
flags: uint32
|
|
next: ptr IpAdapterDnsServerAddressXp
|
|
address: SocketAddress
|
|
|
|
IpAdapterPrefixXp = object
|
|
length: uint32
|
|
flags: uint32
|
|
next: ptr IpAdapterPrefixXp
|
|
address: SocketAddress
|
|
prefixLength: uint32
|
|
|
|
IpAdapterAddressesXp = object
|
|
length: uint32
|
|
ifIndex: uint32
|
|
next: ptr IpAdapterAddressesXp
|
|
adapterName: cstring
|
|
unicastAddress: ptr IpAdapterUnicastAddressXpLh
|
|
anycastAddress: ptr IpAdapterAnycastAddressXp
|
|
multicastAddress: ptr IpAdapterMulticastAddressXp
|
|
dnsServerAddress: ptr IpAdapterDnsServerAddressXp
|
|
dnsSuffix: ptr WCHAR
|
|
description: ptr WCHAR
|
|
friendlyName: ptr WCHAR
|
|
physicalAddress: array[MaxAdapterAddressLength, byte]
|
|
physicalAddressLength: uint32
|
|
flags: uint32
|
|
mtu: uint32
|
|
ifType: uint32
|
|
operStatus: cint
|
|
ipv6IfIndex: uint32
|
|
zoneIndices: array[16, uint32]
|
|
firstPrefix: ptr IpAdapterPrefixXp
|
|
|
|
MibIpForwardRow = object
|
|
dwForwardDest: uint32
|
|
dwForwardMask: uint32
|
|
dwForwardPolicy: uint32
|
|
dwForwardNextHop: uint32
|
|
dwForwardIfIndex: uint32
|
|
dwForwardType: uint32
|
|
dwForwardProto: uint32
|
|
dwForwardAge: uint32
|
|
dwForwardNextHopAS: uint32
|
|
dwForwardMetric1: uint32
|
|
dwForwardMetric2: uint32
|
|
dwForwardMetric3: uint32
|
|
dwForwardMetric4: uint32
|
|
dwForwardMetric5: uint32
|
|
|
|
SOCKADDR_INET {.union.} = object
|
|
ipv4: Sockaddr_in
|
|
ipv6: Sockaddr_in6
|
|
si_family: uint16
|
|
|
|
IPADDRESS_PREFIX = object
|
|
prefix: SOCKADDR_INET
|
|
prefixLength: uint8
|
|
|
|
MibIpForwardRow2 = object
|
|
interfaceLuid: uint64
|
|
interfaceIndex: uint32
|
|
destinationPrefix: IPADDRESS_PREFIX
|
|
nextHop: SOCKADDR_INET
|
|
sitePrefixLength: byte
|
|
validLifetime: uint32
|
|
preferredLifetime: uint32
|
|
metric: uint32
|
|
protocol: uint32
|
|
loopback: bool
|
|
autoconfigureAddress: bool
|
|
publish: bool
|
|
immortal: bool
|
|
age: uint32
|
|
origin: uint32
|
|
|
|
GETBESTROUTE2 = proc(InterfaceLuid: ptr uint64, InterfaceIndex: uint32,
|
|
SourceAddress: ptr SOCKADDR_INET,
|
|
DestinationAddress: ptr SOCKADDR_INET,
|
|
AddressSortOptions: uint32,
|
|
BestRoute: ptr MibIpForwardRow2,
|
|
BestSourceAddress: ptr SOCKADDR_INET): DWORD {.
|
|
gcsafe, stdcall.}
|
|
|
|
proc toInterfaceType(ft: uint32): InterfaceType {.inline.} =
|
|
if (ft >= 1'u32 and ft <= 196'u32) or
|
|
(ft == 237) or (ft == 243) or (ft == 244) or (ft == 259) or (ft == 281):
|
|
result = cast[InterfaceType](ft)
|
|
else:
|
|
result = IfOther
|
|
|
|
proc toInterfaceState(it: cint): InterfaceState {.inline.} =
|
|
if it >= 1 and it <= 7:
|
|
result = cast[InterfaceState](it)
|
|
else:
|
|
result = StatusUnknown
|
|
|
|
proc GetAdaptersAddresses(family: uint32, flags: uint32, reserved: pointer,
|
|
addresses: ptr IpAdapterAddressesXp,
|
|
sizeptr: ptr uint32): uint32 {.
|
|
stdcall, dynlib: "iphlpapi", importc: "GetAdaptersAddresses".}
|
|
|
|
proc WideCharToMultiByte(CodePage: uint32, dwFlags: uint32,
|
|
lpWideCharStr: ptr WCHAR, cchWideChar: cint,
|
|
lpMultiByteStr: ptr char, cbMultiByte: cint,
|
|
lpDefaultChar: ptr char,
|
|
lpUsedDefaultChar: ptr uint32): cint
|
|
{.stdcall, dynlib: "kernel32.dll", importc: "WideCharToMultiByte".}
|
|
|
|
proc getBestRouteXp(dwDestAddr: uint32, dwSourceAddr: uint32,
|
|
pBestRoute: ptr MibIpForwardRow): uint32 {.
|
|
stdcall, dynlib: "iphlpapi", importc: "GetBestRoute".}
|
|
|
|
proc `$`(bstr: ptr WCHAR): string =
|
|
var buffer: char
|
|
var count = WideCharToMultiByte(CP_UTF8, 0, bstr, -1, addr(buffer), 0,
|
|
nil, nil)
|
|
if count > 0:
|
|
result = newString(count + 8)
|
|
let res = WideCharToMultiByte(CP_UTF8, 0, bstr, -1, addr(result[0]),
|
|
count, nil, nil)
|
|
if res > 0:
|
|
result.setLen(res - 1)
|
|
else:
|
|
result.setLen(0)
|
|
|
|
proc isVista(): bool =
|
|
var ver: OSVERSIONINFO
|
|
ver.dwOSVersionInfoSize = DWORD(sizeof(ver))
|
|
let res = getVersionExW(addr(ver))
|
|
if res == 0:
|
|
result = false
|
|
else:
|
|
result = (ver.dwMajorVersion >= 6)
|
|
|
|
proc toIPv6(a: TransportAddress): TransportAddress =
|
|
## IPv4-mapped addresses are formed by:
|
|
## <80 bits of zeros> + <16 bits of ones> + <32-bit IPv4 address>.
|
|
if a.family == AddressFamily.IPv4:
|
|
result = TransportAddress(family: AddressFamily.IPv6)
|
|
result.address_v6[10] = 0xFF'u8
|
|
result.address_v6[11] = 0xFF'u8
|
|
copyMem(addr result.address_v6[12], unsafeAddr a.address_v4[0], 4)
|
|
elif a.family == AddressFamily.IPv6:
|
|
result = a
|
|
|
|
proc ipMatchPrefix(number, prefix: TransportAddress, nbits: int): bool =
|
|
var num6, prefix6: TransportAddress
|
|
if number.family == AddressFamily.IPv4:
|
|
num6 = toIPv6(number)
|
|
else:
|
|
num6 = number
|
|
if prefix.family == AddressFamily.IPv4:
|
|
prefix6 = toIPv6(number)
|
|
else:
|
|
prefix6 = prefix
|
|
var bytesCount = nbits div 8
|
|
var bitsCount = nbits mod 8
|
|
for i in 0..<bytesCount:
|
|
if num6.address_v6[i] != prefix6.address_v6[i]:
|
|
return false
|
|
if bitsCount != 0:
|
|
var mask = cast[byte](0xFF'u8 shl (8 - bitsCount))
|
|
let i = bytesCount
|
|
if (num6.address_v6[i] and mask) != (prefix6.address_v6[i] and mask):
|
|
return false
|
|
result = true
|
|
|
|
proc processAddress(ifitem: ptr IpAdapterAddressesXp,
|
|
ifunic: ptr IpAdapterUnicastAddressXpLh,
|
|
vista: bool): InterfaceAddress =
|
|
var netfamily = ifunic.address.lpSockaddr.sa_family
|
|
fromSAddr(cast[ptr Sockaddr_storage](ifunic.address.lpSockaddr),
|
|
SockLen(ifunic.address.iSockaddrLength), result.host)
|
|
if not vista:
|
|
var prefix = ifitem.firstPrefix
|
|
var prefixLength = -1
|
|
while not isNil(prefix):
|
|
var pa: TransportAddress
|
|
var prefamily = prefix.address.lpSockaddr.sa_family
|
|
fromSAddr(cast[ptr Sockaddr_storage](prefix.address.lpSockaddr),
|
|
SockLen(prefix.address.iSockaddrLength), pa)
|
|
if netfamily == prefamily:
|
|
if ipMatchPrefix(result.host, pa, cast[int](prefix.prefixLength)):
|
|
prefixLength = max(prefixLength, cast[int](prefix.prefixLength))
|
|
prefix = prefix.next
|
|
if prefixLength >= 0:
|
|
result.net = IpNet.init(result.host, prefixLength)
|
|
else:
|
|
let prefixLength = cast[int](ifunic.onLinkPrefixLength)
|
|
if prefixLength >= 0:
|
|
result.net = IpNet.init(result.host, prefixLength)
|
|
|
|
proc getInterfaces*(): seq[NetworkInterface] =
|
|
## Return list of network interfaces.
|
|
result = newSeq[NetworkInterface]()
|
|
var size = WorkBufferSize
|
|
var tries = 0
|
|
var buffer: seq[byte]
|
|
var res: uint32
|
|
var vista = isVista()
|
|
|
|
while true:
|
|
buffer = newSeq[byte](size)
|
|
var addresses = cast[ptr IpAdapterAddressesXp](addr buffer[0])
|
|
res = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, nil,
|
|
addresses, addr size)
|
|
if res == ERROR_SUCCESS:
|
|
buffer.setLen(size)
|
|
break
|
|
elif res == ERROR_BUFFER_OVERFLOW:
|
|
discard
|
|
else:
|
|
break
|
|
inc(tries)
|
|
if tries >= MaxTries:
|
|
break
|
|
|
|
if res == ERROR_SUCCESS:
|
|
var slider = cast[ptr IpAdapterAddressesXp](addr buffer[0])
|
|
while not isNil(slider):
|
|
var iface = NetworkInterface(
|
|
ifIndex: cast[int](slider.ifIndex),
|
|
ifType: toInterfaceType(slider.ifType),
|
|
state: toInterfaceState(slider.operStatus),
|
|
name: $slider.adapterName,
|
|
desc: $slider.description,
|
|
mtu: cast[int](slider.mtu),
|
|
maclen: cast[int](slider.physicalAddressLength),
|
|
flags: cast[uint64](slider.flags)
|
|
)
|
|
copyMem(addr iface.mac[0], addr slider.physicalAddress[0],
|
|
len(iface.mac))
|
|
var unicast = slider.unicastAddress
|
|
while not isNil(unicast):
|
|
var ifaddr = processAddress(slider, unicast, vista)
|
|
iface.addresses.add(ifaddr)
|
|
unicast = unicast.next
|
|
result.add(iface)
|
|
slider = slider.next
|
|
|
|
sort(result, cmp)
|
|
|
|
proc getBestRoute*(address: TransportAddress): Route =
|
|
## Return best applicable OS route, which will be used for connecting to
|
|
## address ``address``.
|
|
if isVista():
|
|
let iph = loadLib("iphlpapi.dll")
|
|
if iph != nil:
|
|
var bestRoute: MibIpForwardRow2
|
|
var empty: TransportAddress
|
|
var dest, src: Sockaddr_storage
|
|
var luid: uint64
|
|
var destlen: Socklen
|
|
address.toSAddr(dest, destlen)
|
|
var getBestRoute2 = cast[GETBESTROUTE2](symAddr(iph, "GetBestRoute2"))
|
|
var res = getBestRoute2(addr luid, 0'u32, nil,
|
|
cast[ptr SOCKADDR_INET](addr dest),
|
|
0'u32,
|
|
addr bestRoute,
|
|
cast[ptr SOCKADDR_INET](addr src))
|
|
if res == 0:
|
|
if src.ss_family == winlean.AF_INET:
|
|
fromSAddr(addr src, Socklen(sizeof(Sockaddr_in)), result.source)
|
|
elif src.ss_family == winlean.AF_INET6:
|
|
fromSAddr(addr src, Socklen(sizeof(Sockaddr_in6)), result.source)
|
|
if bestRoute.nextHop.si_family == winlean.AF_INET:
|
|
fromSAddr(cast[ptr Sockaddr_storage](addr bestRoute.nextHop),
|
|
Socklen(sizeof(Sockaddr_in)), result.gateway)
|
|
elif bestRoute.nextHop.si_family == winlean.AF_INET6:
|
|
fromSAddr(cast[ptr Sockaddr_storage](addr bestRoute.nextHop),
|
|
Socklen(sizeof(Sockaddr_in6)), result.gateway)
|
|
if result.gateway.isZero():
|
|
result.gateway = empty
|
|
result.dest = address
|
|
result.ifIndex = int(bestRoute.interfaceIndex)
|
|
result.metric = int(bestRoute.metric)
|
|
else:
|
|
if address.family == AddressFamily.IPv4:
|
|
var bestRoute: MibIpForwardRow
|
|
var dest: uint32
|
|
copyMem(addr dest, unsafeAddr address.address_v4[0], 4)
|
|
let res = getBestRouteXp(dest, 0'u32, addr bestRoute)
|
|
if res == 0:
|
|
var interfaces = getInterfaces()
|
|
result.dest = address
|
|
if bestRoute.dwForwardNextHop != 0'u32:
|
|
result.gateway = TransportAddress(family: AddressFamily.IPv4)
|
|
copyMem(addr result.gateway.address_v4[0],
|
|
addr bestRoute.dwForwardNextHop, 4)
|
|
result.metric = int(bestRoute.dwForwardMetric1)
|
|
result.ifIndex = int(bestRoute.dwForwardIfIndex)
|
|
for item in interfaces:
|
|
if item.ifIndex == int(bestRoute.dwForwardIfIndex):
|
|
for a in item.addresses:
|
|
if a.host.family == AddressFamily.IPv4:
|
|
result.source = a.host
|
|
break
|
|
|
|
else:
|
|
{.fatal: "Sorry, your OS is currently not supported!".}
|