#!/bin/sh

cachedir="/var/cache/alterator/net-eth"
precommit_hooks_dir=/usr/lib/alterator/hooks/net-eth-precommit.d
postcommit_hooks_dir=/usr/lib/alterator/hooks/net-eth.d

rdelim='[[:space:]]\+'
wdelim=' '

alterator_api_version=1

. alterator-sh-functions
. alterator-net-functions
. alterator-hw-functions
. shell-config

###

is_defined()
{
    set|grep -qs "^$(quote_sed_regexp "$1")="
}

real_iface()
{
    if netdev_is_bridge "$1";then
	netdev_list_brif "$1"|head -n1
    else
	echo "$1"
    fi
}

### cache
init_cache()
{
    local ifacedir="/etc/net/ifaces/$1"

    if [ ! -d "$cachedir/$1" ] ;then
	[ -d "$ifacedir" ] && cp -a "$ifacedir" "$cachedir"
	mkdir -p -- "$cachedir/$1"
    fi

    [ ! -f /etc/iftab -o -f "$cachedir/iftab" ] || cp /etc/iftab "$cachedir/iftab"
    [ ! -f /etc/sysconfig/network -o -f "$cachedir/network" ] || cp /etc/sysconfig/network "$cachedir/network"
}

clear_cache()
{
    rm -rf "$cachedir"
    mkdir "$cachedir"
}

commit_hostname()
{
    [ -f "$cachedir/network" ] || return
    ! cmp -s /etc/sysconfig/network "$cachedir/network" || return

    local old_value="$(shell_config_get /etc/sysconfig/network HOSTNAME)"
    local new_value="$(shell_config_get "$cachedir/network"    HOSTNAME)"

    mv -f "$cachedir/network" /etc/sysconfig/network
    hostname "$new_value"
    run-parts /etc/hooks/hostname.d "$old_value" "$new_value"
}

commit_cache()
{
    #little run-parts: check configuration before apply it
    set_locale
    local answer=
    for f in "$precommit_hooks_dir"/*; do
	[ -f "$f" -a -x "$f" ] || continue
	[ "${f%.rpm*}" = "$f" -a "${f%\~}" = "$f" ] || continue

	if ! answer="$("$f")";then
	    [ -n "$answer" ] || answer="$f failed"
	    write_error "$answer"
	    return 1
	fi
    done

    [ -f "$cachedir/iftab" ] && mv -f "$cachedir/iftab" /etc/iftab
    commit_hostname

    find $cachedir -maxdepth 1 -mindepth 1 -type d|
	while read iface; do

	    [ -n "$iface" ] || exit

	    local ifname="${iface##*/}"

	    [ -n "$DURING_INSTALL" ] || iface_down "$ifname"

	    local old_ip="$(read_iface_addr "/etc/net/ifaces/$ifname")"
	    local new_ip="$(read_iface_addr "$iface")"

	    local old_configuration="$(read_configuration "/etc/net/ifaces/$ifname")"
	    local new_configuration="$(read_configuration "$iface")"

	    #update configs
	    rm -rf -- "/etc/net/ifaces/$ifname"
	    mv -f -- "$cachedir/$ifname" "/etc/net/ifaces/$ifname"

	    #add config for bridge members
	    if netdev_is_bridge "$ifname";then
		local real_fname="$(real_iface "$ifname")"
		rm -rf -- "/etc/net/ifaces/$real_fname"
		mkdir -p -- "/etc/net/ifaces/$real_fname"
		printf 'TYPE=eth' >"/etc/net/ifaces/$real_fname/options"
	    fi

	    #try to restart
	    [ -n "$DURING_INSTALL" ] && netdev_is_up "$ifname" || iface_up "$ifname"

	    if [ "$old_ip" != "$new_ip" -o "$old_configuration" != "$new_configuration" ];then
		export old_ip new_ip old_configuration new_configuration
		run-parts  "$postcommit_hooks_dir"  "$ifname"
	    fi
	done

    clear_cache
    /sbin/update_chrooted conf >&2 || :
}

### hostname
read_hostname()
{
	local netconfig="/etc/sysconfig/network"
	[ -f "$cachedir/network" ] && netconfig="$cachedir/network"
	
	local value="$(shell_config_get "$netconfig" HOSTNAME)"

	[ -n "$value" ] || value="localhost.localdomain"
	echo "$value"
}

write_hostname()
{
	local netconfig="$cachedir/network"

	shell_config_set "$netconfig" HOSTNAME "$1"
	shell_config_del "$netconfig" DOMAINNAME
}

### computer name

read_computer_name()
{
	local value="$(read_hostname)"
	echo "${value%%.*}"
}

read_computer_domain()
{
	local value="$(read_hostname)"
	local domain="${value#*.}"
	[ "$value" != "$domain" ] || domain="localdomain"
	echo "$domain"
}

write_computer_name()
{
    write_hostname "$1.$(read_computer_domain)"
}

### interface work

list_mask()
{
    for i in `seq 32 -1 0`; do 
	write_enum_item "$i" "/$i ($(maskname "$i"))"
    done
}

list_hw_binding()
{
    write_enum_item "missing" "`_ "missing"`"
    write_enum_item "mac" "`_ "by MAC address"`"
    write_enum_item "businfo" "`_ "by bus location"`"
}

list_controlled()
{
    write_enum_item "etcnet" "Etcnet"
    [ ! -f "/usr/sbin/NetworkManager" ] || write_enum_item "NetworkManager" "NetworkManager"
    write_enum_item "nothing" "`_ "not under control"`"
}

list_configuration()
{
    write_enum_item "dhcp" "`_ "Use DHCP"`"
    write_enum_item "ipv4ll" "`_ "Use Zeroconf"`"
    write_enum_item "static" "`_ "Manually"`"
}

read_hw_binding()
{
    local name="$(real_iface "$1")";shift
    local config=

    if [ -f "$cachedir/iftab" ];then
	config="$cachedir/iftab"
    else
	config="/etc/iftab"
    fi

    local line="$(grep "^[[:space:]]*$name[[:space:]]" "$config")"

    if [ -z "$line" ]; then
	echo "missing"
    else
	if echo "$line" | fgrep -qsw mac; then
	    echo "mac"
	elif echo "$line" | fgrep -qsw businfo; then
	    echo "businfo"
	else
	    echo "missing"
	fi
    fi
}

read_info()
{
    local name="$(real_iface "$1")";shift
    [ -n "$name" ] || return 0

    local info="`_ "Network adaptor:"`"
    info="$info $(netdev_read_info "$name")"

    if ! netdev_is_wireless "$name"; then
	if netdev_is_plugged "$name";then
	    info="$info
`_ "plugged"`"
	else
	    info="$info
`_ "unplugged"`"
	fi
    fi
    echo "$info"
}

read_controlled()
{
	local nm_controlled="$(read_iface_option "$1" NM_CONTROLLED)"
	local disabled="$(read_iface_option "$1" DISABLED)"

	if [ $(write_bool "$nm_controlled") = "#t" ];then
		echo 'NetworkManager'
	elif [ $(write_bool "$disabled") = "#f" ];then
		echo 'etcnet'
	else
		echo "nothing"
	fi
}

read_configuration()
{
    local disabled="$(read_iface_option "$1" DISABLED)"
    local bootproto="$(read_iface_option "$1" BOOTPROTO)"

    if [ "$bootproto" = "static" ];then
	echo 'static'
    elif [ "$bootproto" = "ipv4ll" ];then
	echo 'ipv4ll'
    else #dhcp by default
	echo 'dhcp'
    fi
}

read_iface()
{
	local name="$1"; shift
	local ifacedir=

	if [ -d "$cachedir/$name" ];then
	    ifacedir="$cachedir/$name"
	else
	    ifacedir="/etc/net/ifaces/$name"
	fi

	#collect general information

	write_string_param adaptor "$(read_info "$name")"
	write_string_param hw_binding "$(read_hw_binding "$name")"
	write_string_param configuration "$(read_configuration "$ifacedir")"
	write_string_param controlled "$(read_controlled "$ifacedir")"
	write_bool_param wireless "$(netdev_is_wireless "$name" && echo "yes" || echo "no")"

	write_string_param dns "$(read_iface_dns "$ifacedir")"
	write_string_param search "$(read_iface_search "$ifacedir")"

	local addr="$(read_iface_addr "$ifacedir")"
	local ip= mask=
	if [ -n "$addr" ]; then
		ip="${addr%%/*}"
		mask="${addr#$ip}"; mask="${mask#/}"
	fi

	write_string_param ip "$ip"
	write_string_param mask "${mask:-24}"
	write_string_param default "$(read_iface_default_gw "$ifacedir")"
}

write_controlled()
{
	local ifacedir="$1";shift
	local controlled="$1";shift

	case "$controlled" in
	    NetworkManager)
		write_iface_option "$ifacedir" DISABLED yes
		write_iface_option "$ifacedir" NM_CONTROLLED yes
		;;
	    etcnet)
		write_iface_option "$ifacedir" DISABLED no
		write_iface_option "$ifacedir" NM_CONTROLLED no
		;;
	    nothing)
		write_iface_option "$ifacedir" DISABLED yes
		write_iface_option "$ifacedir" NM_CONTROLLED no
		;;
	esac
}

write_configuration()
{
	local ifacedir="$1";shift
	local configuration="$1";shift

	 case "$configuration" in
	    static)
		write_iface_option "$ifacedir" BOOTPROTO static
		;;
	    dhcp)
		write_iface_option "$ifacedir" BOOTPROTO dhcp
		;;
	    ipv4ll)
		write_iface_option "$ifacedir" BOOTPROTO ipv4ll
		;;
	esac
}

write_hw_binding()
{
    local name="$(real_iface "$1")";shift
    local value="$1";shift
    local config="$cachedir/iftab"

    local mac="$(netdev_read_mac "$name")"
    local businfo="$(netdev_read_businfo "$name")"

    if [ -s "$config" ]; then
	sed -r \
	    -e "/^$name[[:space:]]/ d" \
	    -i "$config"

	[ -z "$mac" ] ||
	[ "$mac" = "00:00:00:00:00:00" ] ||
	    sed -r \
		-e "/[[:space:]]mac[[:space:]]+$mac([[:space:]]|\$)/ d" \
	        -i "$config"

	[ -z "$businfo" ] ||
	    sed -r \
		-e "/[[:space:]]businfo[[:space:]]+$businfo([[:space:]]|\$)/ d" \
	    	-i "$config"
    fi

    case "$value" in
	none) ;;
	mac)
	    [ -z "$mac" ] ||
	    [ "$mac" = "00:00:00:00:00:00" ] ||
	    printf "%s\tmac %s\n" "$name" "$mac" >>"$config"
	    ;;
	businfo)
	    [ -z "$businfo" ] ||
	    printf "%s\tbusinfo %s\n" "$name" "$businfo" >>"$config"
	    ;;
    esac
}

write_iface()
{
	local name="$1" && shift
	local ifacedir="$cachedir/$name"

	if netdev_is_bridge "$name";then
	    write_iface_option "$ifacedir" TYPE bri
	    write_iface_option "$ifacedir" HOST "$(real_iface "$name")"
	else
	    write_iface_option "$ifacedir" TYPE eth
	fi

	[ -n "$in_mask" ] && [ -n "$in_ip" ] &&
		write_iface_addr "$ifacedir" "$in_ip/$in_mask"

	is_defined "in_default" &&
		write_iface_default_gw "$ifacedir" "$in_default"

	[ -n "$in_controlled" ] &&
	    write_controlled "$ifacedir" "$in_controlled"

	[ -n "$in_configuration" ] &&
	    write_configuration "$ifacedir" "$in_configuration"

	[ -n "$in_hw_binding" ] &&
	    write_hw_binding "$name" "$in_hw_binding"

	is_defined "in_dns" &&
	    write_iface_dns "$ifacedir" "$in_dns"

	is_defined "in_search" &&
	    write_iface_search "$ifacedir" "$in_search"
}

#initial actions
iface_up lo
clear_cache

on_message()
{
	case "$in_action" in
		type)
		    write_type_item computer_name system-computer-name
		    write_type_item ip ipv4-address
		    write_type_item default ipv4-address

		    write_type_item search hostname-list
		    write_type_item dns ipv4-address-list
		    ;;
		list)
			case "${in__objects##*/}" in
			    avail_masks) list_mask ;;
			    avail_hw_bindings) list_hw_binding ;;
			    avail_configurations) list_configuration ;;
			    avail_controlled) list_controlled ;;
			    *) list_eth|write_enum ;;
			esac
			;;
		read)
			local name="${in_name}"
			[ -n "$name" ] || name="$(list_eth|head -n1)"
			[ -n "$name" ] && read_iface "$name"

			write_string_param name "$name"

			write_string_param computer_name "$(read_computer_name)"
			write_string_param computer_domain "$(read_computer_domain)"
			;;
		write)
			local name="${in_name}"
			[ -n "$name" ] || name="$(list_eth|head -n1)"

			init_cache "$name"

			[ -n "$name" ] && write_iface "$name"

			[ -n "$in_computer_name" ] && write_computer_name "$in_computer_name"
			[ -n "$in_hostname" ] && write_hostname "$in_hostname"

			if [ -n "$in_commit" ]; then
			    commit_cache || return
			elif [ -n "$in_reset" ]; then
			    clear_cache || return
			fi
			;;
	esac
}

message_loop
