package/base-files/files/lib/functions/network.sh

   1 . /usr/share/libubox/jshn.sh
   2
   3 __network_set_cache()
   4 {
   5         if [ -n "$3" ]; then
   6                 eval "export -- __NETWORK_CV_$1='$3'"
   7                 __NETWORK_CACHE="${__NETWORK_CACHE:+$__NETWORK_CACHE }__NETWORK_CV_$1"
   8         elif json_get_var "__NETWORK_CV_$1" "$2"; then
   9                 __NETWORK_CACHE="${__NETWORK_CACHE:+$__NETWORK_CACHE }__NETWORK_CV_$1"
  10         fi
  11 }
  12
  13 __network_export()
  14 {
  15         local __v="__NETWORK_CV_$2"
  16         eval "export -- \"$1=\${$__v:+\$$__v$3}\"; [ -n \"\${$__v+x}\" ]"
  17 }
  18
  19 __network_parse_ifstatus()
  20 {
  21         local __iface="$1"
  22         local __key="${__iface}"
  23         local __tmp
  24         local __old_ns
  25
  26         __network_export __tmp "${__key}__parsed" && return 0
  27         __tmp="$(ubus call network.interface."$__iface" status 2>/dev/null)"
  28         [ -n "$__tmp" ] || return 1
  29
  30         json_set_namespace "network" __old_ns
  31         json_load "$__tmp"
  32
  33         __network_set_cache "${__key}__parsed" "" "1"
  34
  35         for __tmp in "" "_inactive"; do
  36
  37                 __key="${__key}${__tmp}"
  38
  39                 # parse addresses
  40                 local __family
  41                 for __family in 4 6; do
  42                         if json_is_a "ipv${__family}_address" array; then
  43
  44                                 json_select "ipv${__family}_address"
  45
  46                                 if json_is_a 1 object; then
  47
  48                                         json_select 1
  49                                         __network_set_cache "${__key}_address${__family}" address
  50                                         __network_set_cache "${__key}_mask${__family}"    mask
  51                                         json_select ".."
  52
  53                                 fi
  54
  55                                 json_select ".."
  56
  57                         fi
  58                 done
  59
  60                 # parse prefixes
  61                 if json_is_a "ipv6_prefix" array; then
  62                         json_select "ipv6_prefix"
  63
  64                         if json_is_a 1 object; then
  65                                 json_select 1
  66                                 __network_set_cache "${__key}_prefix6_address"  address
  67                                 __network_set_cache "${__key}_prefix6_mask"     mask
  68                                 json_select ".."
  69                         fi
  70
  71                         json_select ".."
  72                 fi
  73
  74                 # parse routes
  75                 if json_is_a route array; then
  76
  77                         json_select "route"
  78
  79                         local __idx=1
  80                         while json_is_a "$__idx" object; do
  81
  82                                 json_select "$((__idx++))"
  83                                 json_get_var __tmp target
  84
  85                                 case "${__tmp}" in
  86                                         0.0.0.0)
  87                                                 __network_set_cache "${__key}_gateway4" nexthop
  88                                         ;;
  89                                         ::)
  90                                                 __network_set_cache "${__key}_gateway6" nexthop
  91                                         ;;
  92                                 esac
  93
  94                                 json_select ".."
  95
  96                         done
  97
  98                         json_select ".."
  99
 100                 fi
 101
 102                 # parse dns info
 103                 local __field
 104                 for __field in "dns_server" "dns_search"; do
 105                         if json_is_a "$__field" array; then
 106
 107                                 json_select "$__field"
 108
 109                                 local __idx=1
 110                                 local __dns=""
 111
 112                                 while json_is_a "$__idx" string; do
 113
 114                                         json_get_var __tmp "$((__idx++))"
 115                                         __dns="${__dns:+$__dns }$__tmp"
 116
 117                                 done
 118
 119                                 json_select ".."
 120
 121                                 if [ -n "$__dns" ]; then
 122                                         __network_set_cache "${__key}_${__field}" "" "$__dns"
 123                                 fi
 124                         fi
 125                 done
 126
 127                 # parse up state, device and physdev
 128                 for __field in "up" "l3_device" "device"; do
 129                         if json_get_type __tmp "$__field"; then
 130                                 __network_set_cache "${__key}_${__field}" "$__field"
 131                         fi
 132                 done
 133
 134                 # descend into inactive table
 135                 json_is_a "inactive" object && json_select "inactive"
 136
 137         done
 138
 139         json_cleanup
 140         json_set_namespace "$__old_ns"
 141
 142         return 0
 143 }
 144
 145
 146 __network_ipaddr()
 147 {
 148         local __var="$1"
 149         local __iface="$2"
 150         local __family="$3"
 151         local __prefix="$4"
 152         local __tmp
 153
 154         __network_parse_ifstatus "$__iface" || return 1
 155
 156         if [ $__prefix -eq 1 ]; then
 157                 __network_export __tmp "${__iface}_mask${__family}" && \
 158                         __network_export "$__var" "${__iface}_address${__family}" "/$__tmp"
 159                 return $?
 160         fi
 161
 162         __network_export "$__var" "${__iface}_address${__family}"
 163         return $?
 164
 165 }
 166
 167 # determine IPv4 address of given logical interface
 168 # 1: destination variable
 169 # 2: interface
 170 network_get_ipaddr()  { __network_ipaddr "$1" "$2" 4 0; }
 171
 172 # determine IPv6 address of given logical interface
 173 # 1: destination variable
 174 # 2: interface
 175 network_get_ipaddr6() { __network_ipaddr "$1" "$2" 6 0; }
 176
 177 # determine IPv4 subnet of given logical interface
 178 # 1: destination variable
 179 # 2: interface
 180 network_get_subnet()  { __network_ipaddr "$1" "$2" 4 1; }
 181
 182 # determine IPv6 subnet of given logical interface
 183 # 1: destination variable
 184 # 2: interface
 185 network_get_subnet6() { __network_ipaddr "$1" "$2" 6 1; }
 186
 187 # determine IPv6 prefix
 188 network_get_prefix6() {
 189         local __var="$1"
 190         local __iface="$2"
 191         local __address
 192         local __mask
 193
 194         __network_parse_ifstatus "$__iface" || return 1
 195         __network_export __mask "${__iface}_prefix6_mask" || return 1
 196         __network_export __var "${__iface}_prefix6_address" "/$__mask"
 197         return $?
 198 }
 199
 200
 201 __network_gateway()
 202 {
 203         local __var="$1"
 204         local __iface="$2"
 205         local __family="$3"
 206         local __inactive="$4"
 207
 208         __network_parse_ifstatus "$__iface" || return 1
 209
 210         if [ "$__inactive" = 1 -o "$__inactive" = "true" ]; then
 211                 __network_export "$__var" "${__iface}_inactive_gateway${__family}" && \
 212                         return 0
 213         fi
 214
 215         __network_export "$__var" "${__iface}_gateway${__family}"
 216         return $?
 217 }
 218
 219 # determine IPv4 gateway of given logical interface
 220 # 1: destination variable
 221 # 2: interface
 222 # 3: consider inactive gateway if "true" (optional)
 223 network_get_gateway()  { __network_gateway "$1" "$2" 4 "${3:-0}"; }
 224
 225 # determine  IPv6 gateway of given logical interface
 226 # 1: destination variable
 227 # 2: interface
 228 # 3: consider inactive gateway if "true" (optional)
 229 network_get_gateway6() { __network_gateway "$1" "$2" 6 "${3:-0}"; }
 230
 231
 232 __network_dns() {
 233         local __var="$1"
 234         local __iface="$2"
 235         local __field="$3"
 236         local __inactive="$4"
 237
 238         __network_parse_ifstatus "$__iface" || return 1
 239
 240         if [ "$__inactive" = 1 -o "$__inactive" = "true" ]; then
 241                 __network_export "$__var" "${__iface}_inactive_${__field}" && \
 242                         return 0
 243         fi
 244
 245         __network_export "$__var" "${__iface}_${__field}"
 246         return $?
 247 }
 248
 249 # determine the DNS servers of the given logical interface
 250 # 1: destination variable
 251 # 2: interface
 252 # 3: consider inactive servers if "true" (optional)
 253 network_get_dnsserver() { __network_dns "$1" "$2" dns_server "${3:-0}"; }
 254
 255 # determine the domains of the given logical interface
 256 # 1: destination variable
 257 # 2: interface
 258 # 3: consider inactive domains if "true" (optional)
 259 network_get_dnssearch() { __network_dns "$1" "$2" dns_search "${3:-0}"; }
 260
 261
 262 __network_wan()
 263 {
 264         local __var="$1"
 265         local __family="$2"
 266         local __inactive="$3"
 267         local __iface
 268
 269         for __iface in $(ubus list | sed -ne 's/^network\.interface\.//p'); do
 270                 if [ "$__iface" != loopback ]; then
 271                         if __network_gateway "$__var" "$__iface" "$__family" "$__inactive"; then
 272                                 eval "export -- \"$__var=$__iface\""
 273                                 return 0
 274                         fi
 275                 fi
 276         done
 277
 278         eval "export -- \"$__var=\""
 279         return 1
 280 }
 281
 282 # find the logical interface which holds the current IPv4 default route
 283 # 1: destination variable
 284 # 2: consider inactive default routes if "true" (optional)
 285 network_find_wan()  { __network_wan "$1" 4 "${2:-0}"; }
 286
 287 # find the logical interface which holds the current IPv6 default route
 288 # 1: destination variable
 289 # 2: consider inactive dafault routes if "true" (optional)
 290 network_find_wan6() { __network_wan "$1" 6 "${2:-0}"; }
 291
 292
 293 __network_device()
 294 {
 295         local __var="$1"
 296         local __iface="$2"
 297         local __field="$3"
 298
 299         __network_parse_ifstatus "$__iface" || return 1
 300         __network_export "$__var" "${__iface}_${__field}"
 301         return $?
 302 }
 303
 304 # test whether the given logical interface is running
 305 # 1: interface
 306 network_is_up()
 307 {
 308         local __up
 309         __network_device __up "$1" up && [ $__up -eq 1 ]
 310 }
 311
 312 # determine the layer 3 linux network device of the given logical interface
 313 # 1: destination variable
 314 # 2: interface
 315 network_get_device()  { __network_device "$1" "$2" l3_device; }
 316
 317 # determine the layer 2 linux network device of the given logical interface
 318 # 1: destination variable
 319 # 2: interface
 320 network_get_physdev() { __network_device "$1" "$2" device;    }
 321
 322
 323 __network_defer()
 324 {
 325         local __device="$1"
 326         local __defer="$2"
 327
 328         json_init
 329         json_add_string name "$__device"
 330         json_add_boolean defer "$__defer"
 331
 332         ubus call network.device set_state "$(json_dump)" 2>/dev/null
 333 }
 334
 335 # defer netifd actions on the given linux network device
 336 # 1: device name
 337 network_defer_device() { __network_defer "$1" 1; }
 338
 339 # continue netifd actions on the given linux network device
 340 # 1: device name
 341 network_ready_device() { __network_defer "$1" 0; }
 342
 343 # flush the internal value cache to force re-reading values from ubus
 344 network_flush_cache()
 345 {
 346         local __tmp
 347         for __tmp in $__NETWORK_CACHE __NETWORK_CACHE; do
 348                 unset "$__tmp"
 349         done
 350 }