ALT Linux Sisyphus - Package alterator-net-functions

alterator-net-functions-1.3.0/000075500000000000000000000000001206262351600163035ustar00rootroot00000000000000alterator-net-functions-1.3.0/Makefile000064400000000000000000000003761206262351600177510ustar00rootroot00000000000000INSTALL=/usr/bin/install

install:
	$(INSTALL) -Dpm 644 alterator-net-functions $(bindir)/alterator-net-functions
	$(INSTALL) -d $(libexecdir)/alterator-net-functions/
	$(INSTALL) -pm755 tools/* $(libexecdir)/alterator-net-functions/

check:
	./runtests
alterator-net-functions-1.3.0/alterator-net-functions000064400000000000000000000277531206262351600230330ustar00rootroot00000000000000#!/bin/sh

PATH="/usr/lib/alterator-net-functions:$PATH"

etcnet_iface_dir=/etc/net/ifaces
etcnet_default_iface_dir="$etcnet_iface_dir/default"
resolvconf_rdelim='[[:space:]]\+'
resolvconf_wdelim=' '

. alterator-hw-functions
. shell-config
. shell-var
. shell-ip-address

### IPv4 helpers
valid_ipv4prefix()
{
	[ "$1" -ge 1 -a "$1" -le 32 ] 2>/dev/null
}

# Heavy based on valid_ipv4() from libshell.
# We can't use valid_ipv4() because it
# don't treat 127.* and 224.* addresses as valid addresses.
valid_ipv4addr()
{
	local ipaddr="$1"
	local i=0 byte

	byte="${ipaddr##*.}"
	ipaddr="${ipaddr%.$byte}"

	[ "$byte" -gt 0 -a "$byte" -lt 255 ] 2>/dev/null ||
		return 1

	while [ $i -lt 3 ]; do
		byte="${ipaddr##*.}"

		[ "$byte" != "$ipaddr" ] ||
			break

		ipaddr="${ipaddr%.$byte}"

		[ "$byte" -ge 0 -a "$byte" -lt 255 ] 2>/dev/null ||
			return 1

		i=$(($i+1))
	done

	[ $i -eq 2 ] 2>/dev/null ||
		return 1
}

### IPv6 helpers
valid_ipv6addr()
{
	local c=0 s=

	# Check that there is no single ':' in the beginning and the end
	# of the string
	case "$1" in
		:[0-9a-fA-F]*|*[0-9a-fA-F]:) return 1;;
		*);;
	esac

	local IFS=':'

	for a in $1; do
		c=$(($c + 1))
		[ "$c" -le 8 ] || return 1
		case "$a" in
			[0-9a-fA-F]) ;;
			[0-9a-fA-F][0-9a-fA-F]) ;;
			[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]) ;;
			[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]) ;;
			'') if [ $c -gt 1 ]; then
					[ -z "$s" ] && s=1 || return 1
				fi
				;;
			*) return 1;;
		esac
	done

	if [ "$c" -lt 8 ]; then
		if [ -n "$s" ]; then
			return 0
		else
			return 1
		fi
	else
		return 0
	fi
}

valid_ipv6prefix()
{
	[ "$1" -ge 1 -a "$1" -le 128 ] 2>/dev/null
}

# FIXME: Should replace longest zeros sequence
ipv6addr_terse()
{
	case "$1" in
		*::) echo "$1" | sed -r 's/:[0:]+::$/::/' ;;
		::*) echo "$1" | sed -r 's/^::[0:]+:/::/' ;;
		*::*) echo "$1" ;;
		*) echo "$1" | sed -r 's/(:[0:]+:|^[0:]+:|:[0:]+$)/::/' ;;
	esac | sed -r 's/(^|:)(0+)([[:xdigit:]])/\1\3/g'
}

ipv6addr_expand()
{
	local in="$1"; shift
	local c= tmp= out= z=

	valid_ipv6addr "$in" || return 1
	c=$(echo "$in" | grep -o ":" | wc -l)

	# Replace :: with zero segmets
	case "$in" in
		*::*)
			if [ $c -eq 8 ]; then
				if [ -z "${in%%::*}" ]; then
					# ::a:a:a:a:a:a:a expanded to 0:a:a:a:a:a:a:a
					tmp="0${in#:}"
				elif [ -z "${in##*::}" ]; then
					# a:a:a:a:a:a:a:: expanded to a:a:a:a:a:a:a:0
					tmp="${in%:}0"
				else
					return 1
				fi
			elif [ $c -gt 0 -a $c -le 7 ]; then
				while [ "$c" -le 7 ]; do
					c=$((c + 1))
					z="$z${z:+:}0"
				done

				if [ -z "${in%%::*}" ]; then
					z="0:$z:"
				elif [ -z "${in##*::}" ]; then
					z=":$z:0"
				else
					z=":$z:"
				fi
				tmp="$(echo "$in" | sed s/::/$z/)"
			else
				return 1
			fi
			;;
		*) [ $c -eq 7 ] && tmp="$in" || return 1
			;;
	esac

	# Expand each segment to four hex digits
	local i= s=
	local IFS=:
	for i in $tmp; do
		case $i in
			[0-9a-fA-F]) s=000$i;;
			[0-9a-fA-F][0-9a-fA-F]) s=00$i;;
			[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]) s=0$i;;
			[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]) s=$i;;
		esac
		out="$out${out:+:}$s"
	done

	echo "$out"
}

ipv6_network()
{
	local network= n= r= c= tmp=
	local ip="$(ipv6addr_expand "${1%%/*}")"
	local prefix="${1##*/}"

	if [ -z "$ip" ] || ! valid_ipv6prefix "$prefix"; then
		return 1
	fi

	local IFS=":"
	set -- $ip

	n=$(($prefix / 16))
	r=$(($prefix % 16))
	c=0

	for i; do
		if [ $c -eq $n ]; then
			tmp=$(( ~(0xffff >> $r) & 0xffff & 0x$i))
			if [ $tmp -gt 0 ]; then
				network="$network${network:+:}$(printf "%x" "$tmp")"
			fi
			[ $c -eq 7 -a $tmp -gt 0 ] || network="$network::"
			break
		fi

		network="$network${network:+:}$i"
		c=$(($c + 1))
	done

	echo "$(ipv6addr_terse "$network")/$prefix"
}

ipv6addr_is_in_subnet()
{
	local ip="${1-}"; shift
	local net="${1-}"; shift
	local prefix="${net##*/}"
	local p=$((0xFFFF))
	local pos seg ip_seg net_seg n hex_mask

	valid_ipv6prefix "$prefix" ||
		return 2

	n=$(($prefix % 16))
	hex_mask="$(($p - ($p >> $n)))"

	pos=$(($prefix / 16))
	seg="$(($pos * 4 + $pos))"

	net="$(ipv6addr_expand ${net%%/*})"
	[ -n "$net" ] || return 2
	net_head="${net:0:$seg}"
	# get IPv6 network segment
	net_seg="${net:$seg:4}"

	ip="$(ipv6addr_expand $ip)"
	[ -n "$ip" ] || return 2
	ip_head="${ip:0:$seg}"
	# get IPv6 address segment
	ip_seg="${ip:$seg:4}"

	[ "$net_head" = "$ip_head" ] &&
	[ "$((0x$net_seg & $hex_mask))" -eq "$((0x$ip_seg & $hex_mask))" ] ||
		return 1
}

### common helpers

get_ip_version()
{
	local ip="$1"
	if valid_ipv4addr "$ip"; then
		echo 4
	elif valid_ipv6addr "$ip"; then
		echo 6
	else
		return 1
	fi

	return 0
}

next_iface()
{
	local name="$1";shift
	local i="${1:-0}"
	local path="$etcnet_iface_dir/$name"
	while true; do
		[ -d "$path$i" ] || { echo "$name$i" && break; }
		i=$(($i + 1))
	done
}

### common iface options

write_iface_option()
{
    shell_config_set "$1/options" "$2" "$3"
}

# write_iface_addr <iface_path> <address> [ ip_version ]
write_iface_addr()
{
	local p="${3:-4}"
    echo "$2" >"$1/ipv${p}address"
}

# write_iface_addresses <iface_path> <address_list> [ ip_version ]
write_iface_addresses()
{
	local p="${3:-4}"
	local addresses_file="$1/ipv${p}address"
	>"$addresses_file"
	for i in $2;do
	    echo "$i" >>"$addresses_file"
	done
}

read_iface_option()
{
    # shell_config_get always returns 0,
    # so we can't merge commands with || :(

    local ret="$(shell_config_get "$1/options" "$2")"
    if [ -z "$ret" ]; then
      local type="$(shell_config_get "$1/options" "TYPE")"
      [ -z "$type" ] ||
        ret="$(shell_config_get "$etcnet_default_iface_dir/options-$type" "$2")"
    fi
    if [ -z "$ret" ]; then
      ret="$(shell_config_get "$etcnet_default_iface_dir/options" "$2")"
    fi
    echo "$ret"
}

__ipv4_addr_start_re='^[0-9]'
__ipv6_addr_start_re='^[[:xdigit:]:]'

__ipv4_network_re="[[:space:]]+inet[[:space:]]+([.0-9/]+).*"
__ipv6_network_re="[[:space:]]+inet6[[:space:]]+([[:xdigit:]:/]+).*"

# read_iface_addr <iface_path> [ ip_version ]
read_iface_addr()
{
	local p="${2:-4}" r=
	eval "r=\$__ipv${p}_addr_start_re"
    [ ! -s "$1/ipv${p}address" ] || grep -m 1 "$r" "$1/ipv${p}address"
}

# read_iface_addresses <iface_path> [ ip_version ]
read_iface_addresses()
{
    local retval
    local v=
	local p="${2:-4}" r=

	eval "r=\$__ipv${p}_addr_start_re"
    [ ! -s "$1/ipv${p}address" ] || v=$(grep "$r" "$1"/ipv${p}address| tr '\n' ' ')
    shell_var_trim retval "$v"
    echo "$retval"
}

# read_iface_current_addr <iface_path> [ ip_version ]
read_iface_current_addr()
{
	local name="${1##*/}"
	local p="${2:-4}" r=
	eval "r=\$__ipv${p}_network_re"
	/sbin/ip -$p a s "$name" 2>/dev/null|sed -r -n "s,$r,\1,p" | head -n1
}

# read_iface_current_addr <iface_path> [ ip_version ]
read_iface_current_addresses()
{
	local name="${1##*/}"
	local p="${2:-4}" r=
	local p="${2:-4}" r=
	eval "r=\$__ipv${p}_network_re"
	/sbin/ip -$p a s "$name" 2>/dev/null|sed -r -n "s,$r,\1,p"
}

__default_ipv4_gw_re='^[[:space:]]*default[[:space:]]\+via[[:space:]]\([0-9.]\+\).*'
__default_ipv6_gw_re='^[[:space:]]*default[[:space:]]\+via[[:space:]]\([[:xdigit:]:]\+\).*'

# read_iface_default_gw <iface_path> [ ip_version ]
read_iface_default_gw()
{
	local p="${2:-4}" r=

	eval "r=\$__default_ipv${p}_gw_re"
    [ ! -s "$1/ipv${p}route" ] ||
	sed -n -e "s/$r/\1/p" \
	       -e 't l1' \
	       -e 'b' \
	       -e ': l1' \
	       -e 'q' \
	       "$1/ipv${p}route"
}

# write_iface_default_gw <iface_path> <address> [ ip_version ]
write_iface_default_gw()
{
	local p="${3:-4}" r=

	eval "r=\$__default_ipv${p}_gw_re"
    [ ! -s "$1/ipv${p}route" ] ||
	sed "/$r/ d" -i "$1/ipv${p}route"
    [ -z "$2" ] ||
	printf 'default via %s\n' "$2" >>"$1/ipv${p}route"
}

read_iface_search()
{
    local retval
    local v="$(shell_config_get "$1/resolv.conf" search "$resolvconf_rdelim"| tr '\n' ' ')"
    shell_var_trim retval "$v"
    echo "$retval"
}

write_iface_search()
{
	local resolvconf_file="$1/resolv.conf"

	shell_config_del "$resolvconf_file" search "$resolvconf_rdelim"
	[ -z "$2" ] || shell_config_set "$resolvconf_file" search "$2" "$resolvconf_rdelim" "$resolvconf_wdelim"

	[ -s "$resolvconf_file" ] || rm -f -- "$resolvconf_file"
}

read_iface_dns()
{
    local retval
    local v="$(shell_config_get "$1/resolv.conf" nameserver "$resolvconf_rdelim"| tr '\n' ' ')"
    shell_var_trim retval "$v"
    echo "$retval"
}

write_iface_dns()
{
	local resolvconf_file="$1/resolv.conf"

	shell_config_del "$resolvconf_file" nameserver "$resolvconf_rdelim"

	local IFS=' '
	for i in $2;do
	    printf 'nameserver %s\n' "$i" >>"$resolvconf_file"
	done

	[ -s "$resolvconf_file" ] || rm -f -- "$resolvconf_file"
}

### string ppp options

write_ppp_option()
{
    shell_config_set "$1/pppoptions" "$2" "$3" '[[:space:]]\+' ' '
    chmod o-rw "$name/pppoptions"
}

read_ppp_option()
{
    shell_config_get "$1/pppoptions" "$2" '[[:space:]]\+'
}

### boolean ppp options

read_ppp_option1()
{
    local file="$1";shift
    local name1="$1";shift
    local name2="$1";shift
    local defvalue="${1:-no}";shift ||:

    if grep -qs "^$name1\$" "$file/pppoptions";then
	echo 'yes'
    elif grep -qs "^$name2\$" "$file/pppoptions"; then
	echo 'no'
    else
	echo "$defvalue"
    fi
}

write_ppp_option1()
{
    local file="$1";shift
    local name1="$1";shift
    local name2="$1";shift
    local value="$1";shift

    [ -f "$file/pppoptions" ] || touch "$file/pppoptions"

    sed \
	-e "/^$name1/d" \
	-e "/^$name2/d " \
	-i "$file/pppoptions"

    if [ "$value" -eq 0 ]; then
	echo "$name1" >> "$file/pppoptions"
    else
	echo "$name2" >> "$file/pppoptions"
    fi
}

next_ppp()
{
    # not to interfere with dialup ppp0
    next_iface ppp 1
}

### list various interface types

list_ppp()
{
    local t="${1:-}"
    for i in `find "$etcnet_iface_dir" -type d`; do
	[ "$(read_iface_option "$i" TYPE)" != "ppp" ] ||
	[ -n "$t" -a "$(read_iface_option "$i" PPPTYPE)" != "$t" ] ||
	    echo "${i##*/}" 2>/dev/null
    done
}

list_eth()
{
    netdev_list|
	while read iface; do
	    netdev_is_eth "$iface" || continue
	    netdev_is_real "$iface" || continue

	    local b="$(netdev_find_bridge "$iface")"
	    echo "${b:-$iface}" 2>/dev/null
	done
}

list_iface()
{
    netdev_list|
	while read iface; do
	    [ "$iface" != "lo" ] || continue
	    [ -z "$(netdev_find_bridge "$iface")" ] || continue
	    local tf="/sys/class/net/$iface/type"
	    [ ! -f "$tf" ] || [ "$(cat "$tf")" != 801 ] || continue
	    echo "$iface" 2>/dev/null
	done
}

# list_static_iface [ ip_version ]
list_static_iface()
{
	local p="${1:-4}"

    for i in `find "$etcnet_iface_dir" -type d`; do
	local name="${i##*/}"
	[ "$name" != "lo" -a "$name" != "default" -a "$name" != "unknown" ] || continue
	[ "$(read_iface_option $i BOOTPROTO)" = "static" -a -s "$i/ipv${p}address" ] || continue
	echo "${i##*/}"
    done
}

# list_network [ ip_version ]
list_network()
{
	local p="${1:-4}" r=

	eval "r=\$__ipv${p}_network_re"
    for i in `find "$etcnet_iface_dir" -type d`; do
	local name="${i##*/}"
	[ "$name" != "lo" -a "$name" != "default" -a "$name" != "unknown" ] || continue

	local proto="$(read_iface_option $i BOOTPROTO)"
	local addr=
	if [ "$proto" = "static" ];then
	    addr="$(read_iface_addresses $i "$p")"
	else
	    addr="$(read_iface_current_addresses $i "$p")"
	fi
	if [ "$p" = 4 ]; then
		[ -z "$addr" ] || netname "$addr" | cut -f1
	else
		[ -z "$addr" ] || ipv6_network "$addr"
	fi
    done
}

### start/stop interfaces

iface_up()
{
    local iface="$1";shift
    local n="${1:-0}";shift

    env -i PATH="$PATH" HOME="$HOME" TMPDIR="$TMPDIR" /sbin/ifup "$iface" >/dev/null
    for i in $(seq 0 "$n"); do
	netdev_is_up "$iface" && return 0
	[ "$i" != "$n" ] || sleep 1
    done
    return 1
}

iface_down()
{
    local iface="$1";shift
    local n="${1:-0}";shift

    env -i PATH="$PATH" HOME="$HOME" TMPDIR="$TMPDIR" /sbin/ifdown "$iface" >/dev/null
    for i in $(seq 0 "$n"); do
	netdev_is_up "$iface" || return 0
	[ "$i" != "$n" ] || sleep 1
    done
    return 1
}

### ipv4address calculations
# For backward compatibility only.
# In new code use functions from shell-ip-address directly.
ipv4addr_is_in_subnet()
{
	ipv4_ip_subnet "$@"
}

ipv4addr_mask_to_prefix()
{
	ipv4_mask2prefix "$@"
}

ipv4addr_prefix_to_mask()
{
	ipv4_prefix2mask "$@"
}
alterator-net-functions-1.3.0/runtests000075500000000000000000000004061206262351600201200ustar00rootroot00000000000000#!/bin/sh -e

. shell-unittest
. ./alterator-net-functions

WORKDIR=
setUp() {
	WORKDIR="$(mktemp -td "alterator-net-functions.XXXXXXXXX")"
	cd "$WORKDIR"
}

tearDown() {
	rm -rf -- "$WORKDIR"
}

### common testcases

for i in test/*; do . $i;done

runUnitTests
alterator-net-functions-1.3.0/test/000075500000000000000000000000001206262351600172625ustar00rootroot00000000000000alterator-net-functions-1.3.0/test/ipv4addr000064400000000000000000000022211206262351600207170ustar00rootroot00000000000000#!/bin/sh

appendTests \
    test_ipv4addr_is_in_subnet \
    test_ipv4addr_mask_to_prefix \
    test_ipv4addr_prefix_to_mask \
#

test_ipv4addr_is_in_subnet()
{
     assertTrue "10.1.1.187" "ipv4addr_is_in_subnet 10.1.1.187 10.1.0.0/23"
     assertTrue "10.1.1.187" "ipv4addr_is_in_subnet 10.1.1.187 10.1.1.187/23"
     assertTrue "10.1.1.187" "ipv4addr_is_in_subnet 10.1.0.1 10.1.0.0/23"
     assertFalse "10.1.1.187" "ipv4addr_is_in_subnet 10.1.3.1 10.1.0.0/23"
}

test_ipv4addr_mask_to_prefix()
{
    assertEquals "0.0.0.0" "$(ipv4addr_mask_to_prefix 0.0.0.0)" "0"
    assertEquals "255.255.255.255" "$(ipv4addr_mask_to_prefix 255.255.255.255)" "32"
    assertEquals "255.255.255.0" "$(ipv4addr_mask_to_prefix 255.255.255.0)" "24"
    assertEquals "255.255.254.0" "$(ipv4addr_mask_to_prefix 255.255.254.0)" "23"
}

test_ipv4addr_prefix_to_mask()
{
    assertEquals "0.0.0.0" "$(ipv4addr_prefix_to_mask 0)" "0.0.0.0"
    assertEquals "255.255.255.255" "$(ipv4addr_prefix_to_mask 32)" "255.255.255.255"
    assertEquals "255.255.255.0" "$(ipv4addr_prefix_to_mask 24)" "255.255.255.0"
    assertEquals "255.255.254.0" "$(ipv4addr_prefix_to_mask 23)" "255.255.254.0"
}
alterator-net-functions-1.3.0/test/ipv6addr000064400000000000000000000045611206262351600207320ustar00rootroot00000000000000#!/bin/sh

appendTests \
	test_valid_ipv6addr \
	test_ipv6addr_terse \
	test_ipv6addr_expand \
	test_ipv6_network \
	test_ipv6addr_is_in_subnet
#

test_valid_ipv6addr()
{
	assertTrue "2001:db8:1::5" "valid_ipv6addr 2001:db8:1::5"
	assertTrue "::1" "valid_ipv6addr ::1"
	assertTrue "2001:ffff:1234:1:2:a:adc:ef" "valid_ipv6addr 2001:ffff:1234:1:2:a:adc:ef"
	assertFalse "2001:ffff:1234:1:2:z:adc:ef" "valid_ipv6addr 2001:ffff:1234:1:2:z:adc:ef"
	assertFalse "2001::1234::2:da:adc:ef" "valid_ipv6addr 2001::1234::2:da:adc:ef"
	assertFalse "10.1.1.187" "valid_ipv6addr 10.1.1.187"
	assertFalse "2001:db822:1::5" "valid_ipv6addr 2001:db822:1::5"
}

test_ipv6addr_terse()
{
	assertEquals "2001:ffff:1234:1:0:0:0:ef" "2001:ffff:1234:1::ef" "$(ipv6addr_terse 2001:ffff:1234:1:0:0:0:ef)"
	assertEquals "2001:ffff:1234:1:0:0:0::" "2001:ffff:1234:1::" "$(ipv6addr_terse 2001:ffff:1234:1:0:0:0::)"
	assertEquals "::0:0:0:2001:ffff:1234:1" "::2001:ffff:1234:1" "$(ipv6addr_terse ::0:0:0:2001:ffff:1234:1)"
	assertEquals "0201:0fff:1234:0001:0:0:0:00ef" "201:fff:1234:1::ef" "$(ipv6addr_terse 0201:0fff:1234:0001:0:0:0:00ef)"
}

test_ipv6addr_expand()
{
	assertEquals "2001:ffff:1234:1::ef" "2001:ffff:1234:0001:0000:0000:0000:00ef" "$(ipv6addr_expand 2001:ffff:1234:1::ef)"
	assertEquals "2001:ffff:1234:1::" "2001:ffff:1234:0001:0000:0000:0000:0000"  "$(ipv6addr_expand "2001:ffff:1234:1::")"
	assertEquals "::2001:ffff:1234:1" "0000:0000:0000:0000:2001:ffff:1234:0001" "$(ipv6addr_expand "::2001:ffff:1234:1")"
}

test_ipv6_network()
{
	assertEquals "2001:db8:1::5/64" "2001:db8:1::/64" "$(ipv6_network 2001:db8:1::5/64)"
	assertEquals "2001:db8:1:2:fff:45:abcd:5/128" "2001:db8:1:2:fff:45:abcd:5/128" "$(ipv6_network 2001:db8:1:2:fff:45:abcd:5/128)"
	assertEquals "2001:db8:1:2:fff:45:abcd:5/104" "2001:db8:1:2:fff:45:ab00::/104" "$(ipv6_network 2001:db8:1:2:fff:45:abcd:5/104)"
}

test_ipv6addr_is_in_subnet()
{
	assertTrue "2001:db8:1:1::1 2001:db8:1::/63" "ipv6addr_is_in_subnet 2001:db8:1:1::1 2001:db8:1::/63"
	assertTrue "2001:db8:1:0:1::1 2001:db8:1::/64" "ipv6addr_is_in_subnet 2001:db8:1:0:1::1 2001:db8:1::/64"
	assertTrue "2001:db8:1::ffff 2001:db8:1::/64" "ipv6addr_is_in_subnet 2001:db8:1::ffff 2001:db8:1::/64"
	assertFalse "2001:db8:1:2::1 2001:db8:1::/63" "ipv6addr_is_in_subnet 2001:db8:1:2::1 2001:db8:1::/63"
	assertFalse "2001:db9::1 2001:db8:1::/64" "ipv6addr_is_in_subnet 2001:db9::1 2001:db8:1::/64"
}
alterator-net-functions-1.3.0/test/read_iface_default_gw000064400000000000000000000065651206262351600234640ustar00rootroot00000000000000#!/bin/sh

appendTests \
    test_read_iface_default_gw \
    test_write_iface_default_gw \
    test_read_iface_default_gw_ipv6 \
    test_write_iface_default_gw_ipv6 \
#

### IPv4
test_read_iface_default_gw()
{
    local iface_dir="$WORKDIR/eth1"
    mkdir -p -- "$iface_dir"

    assertEquals "empty config" "$(read_iface_default_gw "$iface_dir")" ""

    cat >"$iface_dir/ipv4route"<<EOF
	some
EOF

    assertEquals "no gw" "$(read_iface_default_gw "$iface_dir")" ""

    cat >"$iface_dir/ipv4route"<<EOF
	default via 10.1.0.1
EOF

    assertEquals "one gw" "$(read_iface_default_gw "$iface_dir")" "10.1.0.1"

    cat >"$iface_dir/ipv4route"<<EOF
	default via 10.1.0.1
	some
	default via 10.1.0.2
EOF

    assertEquals "two gw" "$(read_iface_default_gw "$iface_dir")" "10.1.0.1"
}

test_write_iface_default_gw()
{
    local iface_dir="$WORKDIR/eth2"
    mkdir -p -- "$iface_dir"

    write_iface_default_gw "$iface_dir" "10.1.0.1"
    assertEquals "write gw" "$(cat "$iface_dir/ipv4route")" "default via 10.1.0.1"

    write_iface_default_gw "$iface_dir" "10.1.0.2"
    assertEquals "replace gw - 1" "$(cat "$iface_dir/ipv4route")" "default via 10.1.0.2"

    cat >"$iface_dir/ipv4route"<<EOF
    default via 10.1.0.1
default via 10.1.0.2
EOF
    write_iface_default_gw "$iface_dir" "10.1.0.3"
    assertEquals "replace gw - 2" "$(cat "$iface_dir/ipv4route")" "default via 10.1.0.3"

    cat >"$iface_dir/ipv4route"<<EOF
zzz
default via 10.1.0.2
EOF
    write_iface_default_gw "$iface_dir" "10.1.0.3"
    assertTrue "replace gw - 3" 'grep -qs "zzz" "$iface_dir/ipv4route"'

    cat >"$iface_dir/ipv4route"<<EOF
default via 10.1.0.2
EOF
    write_iface_default_gw "$iface_dir" ""

    assertEquals "no gw" "$(cat "$iface_dir/ipv4route")" ""
}

### IPv6
test_read_iface_default_gw_ipv6()
{
    local iface_dir="$WORKDIR/eth1"
    mkdir -p -- "$iface_dir"

    assertEquals "empty config" "$(read_iface_default_gw "$iface_dir" 6)" ""

    cat >"$iface_dir/ipv6route"<<EOF
	some
EOF

    assertEquals "no gw" "$(read_iface_default_gw "$iface_dir" 6)" ""

    cat >"$iface_dir/ipv6route"<<EOF
	default via 2001:db8:1::1
EOF

    assertEquals "one gw" "$(read_iface_default_gw "$iface_dir" 6)" "2001:db8:1::1"

    cat >"$iface_dir/ipv6route"<<EOF
	default via 2001:db8:1::1
	some
	default via 2001:db8:1::2
EOF

    assertEquals "two gw" "$(read_iface_default_gw "$iface_dir" 6)" "2001:db8:1::1"
}

test_write_iface_default_gw_ipv6()
{
    local iface_dir="$WORKDIR/eth2"
    mkdir -p -- "$iface_dir"

    write_iface_default_gw "$iface_dir" "2001:db8:1::1" 6
    assertEquals "write gw" "$(cat "$iface_dir/ipv6route")" "default via 2001:db8:1::1"

    write_iface_default_gw "$iface_dir" "2001:db8:1::1" 6
    assertEquals "replace gw - 1" "$(cat "$iface_dir/ipv6route")" "default via 2001:db8:1::1"

    cat >"$iface_dir/ipv6route"<<EOF
    default via 2001:db8:1::1
default via 2001:db8:1::2
EOF
    write_iface_default_gw "$iface_dir" "2001:db8:1::3" 6
    assertEquals "replace gw - 2" "$(cat "$iface_dir/ipv6route")" "default via 2001:db8:1::3"

    cat >"$iface_dir/ipv6route"<<EOF
zzz
default via 10.1.0.2
default via 2001:db8:1::2
EOF
    write_iface_default_gw "$iface_dir" "10.1.0.3" 6
    assertTrue "replace gw - 3" 'grep -qs "zzz" "$iface_dir/ipv6route"'

    cat >"$iface_dir/ipv6route"<<EOF
default via 2001:db8:1::2
EOF
    write_iface_default_gw "$iface_dir" "" 6

    assertEquals "no gw" "$(cat "$iface_dir/ipv6route")" ""
}
alterator-net-functions-1.3.0/test/read_iface_dns000064400000000000000000000020161206262351600221120ustar00rootroot00000000000000#!/bin/sh

appendTests \
    test_read_iface_dns \
    test_write_iface_dns \
#

test_read_iface_dns()
{
    local iface_dir="$WORKDIR/eth1"
    mkdir -p -- "$iface_dir"

    assertEquals "empty config" "$(read_iface_dns "$iface_dir")" ""

    cat >"$iface_dir/resolv.conf"<<EOF
	nameserver a
EOF

    assertEquals "one dns" "$(read_iface_dns "$iface_dir")" "a"

    cat >"$iface_dir/resolv.conf"<<EOF
	nameserver a
	nameserver b
EOF

    assertEquals "two dns" "$(read_iface_dns "$iface_dir")" "a b"
}

test_write_iface_dns()
{
    local iface_dir="$WORKDIR/eth2"
    mkdir -p -- "$iface_dir"

    write_iface_dns "$iface_dir" "a"

    assertEquals "one dns" "$(cat "$iface_dir/resolv.conf")" "nameserver a"

    write_iface_dns "$iface_dir" "a b"

    assertEquals "two dns" "$(cat "$iface_dir/resolv.conf")" \
"nameserver a
nameserver b"

    cat >"$iface_dir/resolv.conf"<<EOF
	nameserver a
EOF
    write_iface_dns "$iface_dir" ""

    assertEquals "no dns" "$([ ! -s "$iface_dir/resolv.conf" ] || cat "$iface_dir/resolv.conf")" ""
}
alterator-net-functions-1.3.0/test/read_iface_option000064400000000000000000000061341206262351600226430ustar00rootroot00000000000000#!/bin/sh

appendTests \
    test_read_iface_option1 \
    test_read_iface_option2 \
    test_read_iface_option3 \
    test_read_iface_option4 \
    test_read_iface_option5 \
    test_read_iface_option6 \
    test_read_iface_option7 \
#

test_read_iface_option1()
{
    local iface_dir="$WORKDIR/eth"
    local etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    assertEquals "no option, no default" "$(read_iface_option "$iface_dir" PARAM)" ""
}

test_read_iface_option2()
{
    local iface_dir="$WORKDIR/eth"
    local etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    printf 'PARAM=value\n' >"$iface_dir/options"

    assertEquals "has option, no default" "$(read_iface_option "$iface_dir" PARAM)" "value"
}

test_read_iface_option3()
{
    local iface_dir="$WORKDIR/eth"
    local etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    printf 'PARAM=value1\n' >"$iface_dir/options"
    printf 'PARAM=value2\n' >"$etcnet_default_iface_dir/options"

    assertEquals "has option, has global default" "$(read_iface_option "$iface_dir" PARAM)" "value1"
}

test_read_iface_option4()
{
    local iface_dir="$WORKDIR/eth"
    local etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    printf 'PARAM=value1\nTYPE=b' >"$iface_dir/options"
    printf 'PARAM=defa\n' >"$etcnet_default_iface_dir/options-a"
    printf 'PARAM=defb\n' >"$etcnet_default_iface_dir/options-b"

    assertEquals "has option, has type default" "$(read_iface_option "$iface_dir" PARAM)" "value1"
}

test_read_iface_option5()
{
    iface_dir="$WORKDIR/eth"
    etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    printf 'PARAM=def-\n' >"$etcnet_default_iface_dir/options-"

    read_iface_option "$iface_dir" PARAM

    assertEquals "no option, no type, has type default" "$(read_iface_option "$iface_dir" PARAM)" ""
}

test_read_iface_option6()
{
    iface_dir="$WORKDIR/eth"
    etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    printf 'TYPE=a\n' >"$iface_dir/options"
    printf 'PARAM=def\n' >"$etcnet_default_iface_dir/options"
    printf 'PARAM=def-\n' >"$etcnet_default_iface_dir/options-"
    printf 'PARAM=def-a\n' >"$etcnet_default_iface_dir/options-a"
    printf 'PARAM=def-b\n' >"$etcnet_default_iface_dir/options-b"

    assertEquals "no option, no type, has type default" "$(read_iface_option "$iface_dir" PARAM)" "def-a"
}

test_read_iface_option7()
{
    iface_dir="$WORKDIR/eth"
    etcnet_default_iface_dir="$WORKDIR/eth-default"

    mkdir -p -- "$iface_dir"
    mkdir -p -- "$etcnet_default_iface_dir"

    printf 'TYPE=a\n' >"$iface_dir/options"
    printf 'PARAM=def\n' >"$etcnet_default_iface_dir/options"

    assertEquals "no option, no type default, has global default" "$(read_iface_option "$iface_dir" PARAM)" "def"
}
alterator-net-functions-1.3.0/test/read_iface_search000064400000000000000000000024551206262351600226020ustar00rootroot00000000000000#!/bin/sh

appendTests \
    test_read_iface_search \
    test_write_iface_search \
#

test_read_iface_search()
{
    local iface_dir="$WORKDIR/eth1"
    mkdir -p -- "$iface_dir"

    assertEquals "empty config" "$(read_iface_search "$iface_dir")" ""

    cat >"$iface_dir/resolv.conf"<<EOF
	search a
EOF

    assertEquals "one search 1" "$(read_iface_search "$iface_dir")" "a"

    cat >"$iface_dir/resolv.conf"<<EOF
	search a b
EOF

    assertEquals "one search 1" "$(read_iface_search "$iface_dir")" "a b"

    cat >"$iface_dir/resolv.conf"<<EOF
	search a
	search b
EOF

    assertEquals "two search 1" "$(read_iface_search "$iface_dir")" "a b"
    cat >"$iface_dir/resolv.conf"<<EOF
	search a b
	search c
EOF

    assertEquals "two search 1" "$(read_iface_search "$iface_dir")" "a b c"
}

test_write_iface_search()
{
    local iface_dir="$WORKDIR/eth2"
    mkdir -p -- "$iface_dir"

    write_iface_search "$iface_dir" "a"

    assertEquals "one search" "$(cat "$iface_dir/resolv.conf")" "search a"

    write_iface_search "$iface_dir" "a b"

    assertEquals "two search" "$(cat "$iface_dir/resolv.conf")" "search a b"

    cat >"$iface_dir/resolv.conf"<<EOF
	search a b
EOF
    write_iface_search "$iface_dir" ""

    assertEquals "no search" "$([ ! -s "$iface_dir/resolv.conf" ] || cat "$iface_dir/resolv.conf")" ""
}
alterator-net-functions-1.3.0/tools/000075500000000000000000000000001206262351600174435ustar00rootroot00000000000000alterator-net-functions-1.3.0/tools/ifdown000075500000000000000000000001321206262351600206530ustar00rootroot00000000000000#!/bin/sh

env -i PATH="$PATH" HOME="$HOME" TMPDIR="$TMPDIR" /sbin/ifdown "$1" >/dev/null
alterator-net-functions-1.3.0/tools/ifup000075500000000000000000000001301206262351600203260ustar00rootroot00000000000000#!/bin/sh

env -i PATH="$PATH" HOME="$HOME" TMPDIR="$TMPDIR" /sbin/ifup "$1" >/dev/null
alterator-net-functions-1.3.0/tools/ifvar000075500000000000000000000006671206262351600205110ustar00rootroot00000000000000#!/bin/bash

NAME="$1" && shift
VAR="$1" && shift

unset $VAR

. "${SCRIPTDIR:=/etc/net/scripts}/functions"
pickup_defaults
if [ -d "$IFACEDIR/$NAME@$NETHOST" ]; then
	MYIFACEDIR="$IFACEDIR/$NAME@$NETHOST"
else
	MYIFACEDIR="$IFACEDIR/$NAME"
fi

[ -d "$MYIFACEDIR" ] || {
	print_error "interface configuration directory '$MYIFACEDIR' not found"
	exit 1
}
export MYIFACEDIR NETPROFILE

init_netprofile
pickup_options

eval "echo \"\$$VAR\""
alterator-net-functions-1.3.0/tools/maskname000075500000000000000000000004401206262351600211630ustar00rootroot00000000000000#!/bin/sh -e

len=$1;shift
position=$((0xFFFFFFFF))

[ "$len" -ge 0 -a "$len" -le 32 ] 2>/dev/null
mask=$(( $position - ($position >> $len) ))

printf '%s.%s.%s.%s\n' \
    "$(($mask >> 24 & 0xff))" \
    "$(($mask >> 16 & 0xff))" \
    "$(($mask >> 8 & 0xff))" \
    "$(($mask & 0xff))"
alterator-net-functions-1.3.0/tools/netcheck000075500000000000000000000013301206262351600211520ustar00rootroot00000000000000#!/bin/sh -efu

net_ip="${1%%/*}"
net_len="${1##*/}"
ext_ip1="$2"
ext_ip2="$3"

position=$((0xffffffff))
[ "$net_len" -ge 1 -a "$net_len" -le 32 ] 2>/dev/null
mask="$(( $position - ($position >> $net_len) ))"
wildcard="$(( ~mask & $position))"

OLD_IFS="$IFS"
IFS=.
set ${ext_ip1} ${ext_ip2}
IFS="$OLD_IFS"

#network
n1="$(($mask >> 24 & $1 & 0xff))"
n2="$(($mask >> 16 & $2 & 0xff))"
n3="$(($mask >> 8 & $3 & 0xff))"
n4="$(($mask & $4 & 0xff))"

n5="$(($mask >> 24 & $5 & 0xff))"
n6="$(($mask >> 16 & $6 & 0xff))"
n7="$(($mask >> 8 & $7 & 0xff))"
n8="$(($mask & $8 & 0xff))"

[ "$n1.$n2.$n3.$n4" = "$net_ip" ] &&
    [ "$n5.$n6.$n7.$n8" = "$net_ip" ] &&
    [ "$1" -le "$5" -a "$2" -le "$6" -a "$3" -le "$7" -a "$4" -le "$8" ]
alterator-net-functions-1.3.0/tools/netname000075500000000000000000000015661206262351600210300ustar00rootroot00000000000000#!/bin/sh -efu

ip="${1%%/*}"
len="${1##*/}"

position=$((0xffffffff))
[ "$len" -ge 1 -a "$len" -le 32 ] 2>/dev/null
mask="$(( $position - ($position >> $len) ))"
wildcard="$(( ~mask & $position))"

IFS="."
set  $ip

#network
n1="$(($mask >> 24 & $1 & 0xff))"
n2="$(($mask >> 16 & $2 & 0xff))"
n3="$(($mask >> 8 & $3 & 0xff))"
n4="$(($mask & $4 & 0xff))"

#broadcast
b1="$(($wildcard >> 24 & 0xff | $1))"
b2="$(($wildcard >> 16 & 0xff | $2))"
b3="$(($wildcard >> 8 & 0xff | $3))"
b4="$(($wildcard & 0xff | $4))"

printf '%s.%s.%s.%s/%s' \
    "$n1" "$n2" "$n3" "$n4" "$len"

if [ "$len" -lt 31 ] ;then
    printf '	%s.%s.%s.%s	%s.%s.%s.%s\n' \
	"$n1" "$n2" "$n3" "$(( $n4 | 1 ))" \
	"$b1" "$b2" "$b3" "$(( $b4 & 0xfe ))"
elif [ "$len" -eq 31 ] ;then
    printf '	%s.%s.%s.%s	%s.%s.%s.%s\n' \
	"$n1" "$n2" "$n3" "$n4" \
	"$b1" "$b2" "$b3" "$b4"
else
    printf '	%s	%s\n' "$ip" "$ip"
fi
alterator-net-functions-1.3.0/tools/revdns000075500000000000000000000034321206262351600206740ustar00rootroot00000000000000#!/bin/sh -efu
. alterator-net-functions

ipv4_rdns_net()
{
	local net="$1";shift
	local pos="$1";shift
	local inc="$1";shift

	local IFS='.'
	set -- $net
	case "$pos" in
	1)
	    printf "%s\n" "$(( $1 + $inc ))"
	;;
	2)
	    printf "%s.%s\n"  "$(( $2 + $inc ))" "$1"
	;;
	3)
	    printf "%s.%s.%s\n"   "$(( $3 + $inc ))" "$2" "$1"
	;;
    esac
}

ipv4_revdns()
{
	local nprefix pos i num
	local net="$(netname "$ip/$prefix"|cut -f1)"
	net="${net%%/$prefix}"

	if [ "$prefix" -gt 0 -a "$prefix" -le 8 ];then
		nprefix=8
		pos=1

	elif [ "$prefix" -gt 8 -a "$prefix" -le 16 ];then
		nprefix=16
		pos=2
	elif [ "$prefix" -gt 16 -a "$prefix" -le 24 ];then
		nprefix=24
		pos=3
	else
		prefix=24
		nprefix=24
		pos=3
	fi

	num="$(( 2**($nprefix - $prefix) - 1 ))"

	for i in `seq 0 $num` ;do
		ipv4_rdns_net "$net" "$pos" "$i"
	done
}

ipv6_rdns_net()
{
	local net="$1";shift
	local pos="$1";shift
	local inc="$1";shift
	local c=0
	local out tmp i p

	net="$(ipv6addr_expand "${net%%/$prefix}")"

	local IFS=':'
	for i in $net; do
		[ $c -lt $pos ] || break
		tmp="$tmp$i"
		c=$(($c + 1))
	done

	tmp="$tmp$(printf '%04x' $((0x$i + 0x$inc)))"
	for p in $(echo $tmp | sed -r 's;([[:xdigit:]]);\1:;g'); do
		out="$p${out:+.}$out"
	done
	echo "$out"
}

ipv6_revdns()
{
	local nprefix pos i num
	local net="$(ipv6_network "$ip/$prefix")"

	pos=$(($prefix / 16))
	nprefix=$((16 - $prefix % 16))
	if [ $nprefix -eq 16 ]; then
		nprefix=0
		pos=$(($pos - 1))
	fi

	num="$(( 2**$nprefix - 1 ))"

	for i in $(printf "%x " $(seq 0 $num)) ;do
		ipv6_rdns_net "$net" "$pos" "$i"
	done
}

ip="${1%%/*}"
prefix="${1##*/}"
ipv="${2:-4}"

case "$ipv" in
	4) valid_ipv4addr "$ip" &&
	   valid_ipv4prefix "$prefix" &&
	   ipv4_revdns
	;;
	6) valid_ipv6addr "$ip" &&
	   valid_ipv6prefix "$prefix" &&
	   ipv6_revdns
	;;
	*) exit 1 ;;
esac

S:	2.1.1-alt1
5.0:	0.9-alt3