#!/usr/bin/sh
#------------------------------------------------------------------------------
# /usr/libexec/netconfig/nm-get-bridge - bridge start script
#
# Creation:     2005-01-18  nico
# Last Update:  $Id$
#
# Copyright (c) 2005-@@YEAR@@ the eisfair team, team(at)eisfair(dot)net
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#------------------------------------------------------------------------------

IP=/usr/sbin/ip

. /etc/config.d/base
. /etc/config.d/bridge

# ---------------------------------------------------------------------------
# check status of bonding
# ---------------------------------------------------------------------------
check_bridge_status()
{
    /usr/bin/grep -q '^bridge ' /proc/modules
    return ${?}
}

# ---------------------------------------------------------------------------
# start
# ---------------------------------------------------------------------------
bridge_start()
{
    # load kernelmodul
    /usr/sbin/modprobe bridge

    bridge_idx=1
    while [ ${bridge_idx} -le ${BRIDGE_N:-0} ]
    do
        eval  active='${BRIDGE_'${bridge_idx}'_ACTIVE}'

        if [ "${active}" != "yes" ]
        then
            bridge_idx=$((${bridge_idx} - 1))
            continue
        fi

        bridx=$((${bridge_idx} - 1))

        ${IP} addr flush dev br${bridx} 2>/dev/null

        # set br${bridx}.nmconnection
        {
            # set interface parameter
            echo '[connection]'
            echo "id=br${bridx}"
            echo 'type=bridge'
            echo "interface-name=br${bridx}"

            echo
            echo '[ethernet]'

            echo
            echo '[bridge]'

            eval STP='${BRIDGE_'${bridge_idx}'_STP}'

            if [ "${STP}" = "yes" ]
            then
                eval    BRIDGE_PRIO='${BRIDGE_'${bridge_idx}'_PRIO}'
                eval   BRIDGE_HELLO='${BRIDGE_'${bridge_idx}'_HELLO}'
                eval BRIDGE_MESSAGE='${BRIDGE_'${bridge_idx}'_MAX_MESSAGE_AGE}'
                eval  BRIDGE_FDELAY='${BRIDGE_'${bridge_idx}'_FORWARD_DELAY}'

                if [ -n "${BRIDGE_FDELAY}" ] &&
                   [ ${BRIDGE_FDELAY} -ne 15 ]
                then
                    echo "forward_delay=${BRIDGE_FDELAY}"
                fi

                if [ -n "${BRIDGE_HELLO}" ] &&
                   [ ${BRIDGE_HELLO} -ne 2 ]
                then
                    echo "hello_time=${BRIDGE_HELLO}"
                fi

                if [ -n "${BRIDGE_MESSAGE}" ] &&
                   [ ${BRIDGE_MESSAGE} -ne 20 ]
                then
                    echo "max_age=${BRIDGE_MESSAGE}"
                fi

                if [ -n "${BRIDGE_PRIO}" ] &&
                   [ ${BRIDGE_PRIO} -ne 327680 ]
                then
                    echo "priority=${BRIDGE_PRIO}"
                fi
            else
                echo 'stp=false'
            fi

                # optional, setting default
                #  IGMP snooping  ->  multicast-snooping=false  default true
                #  ageing-time=600  -> 300 default

            idx=''
            eval idx='${BRIDGE_'${bridge_idx}'_BIND_1_ETH}'


            # ipv4 settings
            ipv4_dns=''
            ipv4_dhcp=''
            ipv4_dhcp_host=''
            ipv4_dhcp_peer=''
            ipv4_method=''
            ipv4_gateway_m=''
            ipv4_gateway=''
            ipv4_metric=''

            eval      ipv4_dhcp='${IP_ETH_'${idx}'_V4_DHCP}'
            eval ipv4_dhcp_host='${IP_ETH_'${idx}'_v4_DHCP_HOSTNAME}'
            eval ipv4_dhcp_peer='${IP_ETH_'${idx}'_V4_DHCP_PEERDNS}'
            eval    ipv4_method='${IP_ETH_'${idx}'_V4_METHOD}'
            eval ipv4_gateway_m='${IP_ETH_'${idx}'_V4_GATEWAY}'

            # split gateway and metric
            ipv4_gateway=$(echo "${ipv4_gateway_m}" | cut -d ' ' -f1)
            ipv4_metric=$(echo "${ipv4_gateway_m}" | cut -s -d ' ' -f2)

            if [ -z "${ipv4_method}" ]
            then
                eval      ipv4_dhcp='${IP_ETH_'${idx}'_DHCP}'
                eval ipv4_dhcp_host='${IP_ETH_'${idx}'_DHCP_HOSTNAME}'
                eval ipv4_dhcp_peer='${IP_ETH_'${idx}'_DHCP_PEERDNS}'
                eval    ipv4_method='${IP_ETH_'${idx}'_METHOD}'
                eval   ipv4_gateway='${IP_DEFAULT_GATEWAY}'
            fi

            if [ -z "${ipv4_method}" ]
            then
                ipv4_method='manual'
            fi

            if [ "${ipv4_dhcp:-no}" = "yes" ]
            then
                ipv4_method='auto'
            fi
            echo
            echo '[ipv4]'

            case "${ipv4_method}" in
            manual)
                ipv4_n=''
                eval ipv4_n='${IP_ETH_'${idx}'_IP_N}'

                if [ -z "${ipv4_n}" ]
                then
                    eval ipv4_n='${IP_ETH_'${idx}'_IP_N}'
                fi

                idxa=1
                idy=1
                while [ ${idy} -le ${ipv4_n:-0} ]
                do
                    ipv4_addr=''
                    ipv4_netmask=''
                    eval    ipv4_addr='${IP_ETH_'${idx}'_IP_'${idy}'_IPADDR}'
                    eval ipv4_netmask='${IP_ETH_'${idx}'_IP_'${idy}'_NETMASK}'

                    if [ -z "${ipv4_addr}" ]
                    then
                        eval    ipv4_addr='${IP_ETH_'${idx}'_IP_'${idy}'_IPADDR}'
                        eval ipv4_netmask='${IP_ETH_'${idx}'_IP_'${idy}'_NETMASK}'
                    fi

                    netmaskbits=$(/usr/bin/netcalc netmaskbits ${ipv4_netmask})

                    echo "address${idxa}=${ipv4_addr}/${netmaskbits}"

                    idxa=$((${idxa} +1))
                    idy=$((${idy} + 1))
                done

                if [ -n "${ipv4_gateway}" ]
                then
                    echo "gateway=${ipv4_gateway}"
                    if [ -n "${ipv4_metric}" ]
                    then
                        echo "route-metric=${ipv4_metric}"
                    fi
                fi

                # include to set gateway and route
                . /var/install/include/nm-get-route
                get_route ipv4

                if ! "${ipv4_dns:-false}"
                then
                    # include to set dns responder
                    . /var/install/include/nm-get-dns
                    get_dns ipv4

                    ipv4_dns=true
                fi
                ;;
            disabled)
                : #
                ;;
            link-local)
                : #
                ;;
            auto)
                : #
                ;;
            esac

            echo "method=${ipv4_method}"

            # ipv6 settings
            ipv6_dns=''
            ipv6_dhcp=''
            ipv6_dhcp_host=''
            ipv6_dhcp_peer=''
            ipv6_method=''
            ipv6_gateway_m=''
            ipv6_gateway=''
            ipv6_metric=''
            ipv6_addr_mode=''
            eval      ipv6_dhcp='${IP_ETH_'${idx}'_V6_DHCP}'
            eval ipv6_dhcp_host='${IP_ETH_'${idx}'_V6_DHCP_HOSTNAME}'
            eval ipv6_dhcp_peer='${IP_ETH_'${idx}'_V6_DHCP_PEERDNS}'
            eval    ipv6_method='${IP_ETH_'${idx}'_V6_METHOD}'
            eval ipv6_addr_mode='${IP_ETH_'${idx}'_V6_ADDR_GEN_MODE}'
            eval ipv6_gateway_m='${IP_ETH_'${idx}'_V6_GATEWAY}'

            # split gateway and metric
            ipv6_gateway=$(echo "${ipv6_gateway_m}" | cut -d ' ' -f1)
            ipv6_metric=$(echo "${ipv6_gateway_m}" | cut -s -d ' ' -f2)

            if [ "${ipv6_dhcp:-no}" = "yes" ]
            then
                ipv6_method='auto'
            fi

            echo
            echo '[ipv6]'

            case "${ipv6_method}" in
            manual)
                ipv6_n=''
                eval ipv6_n='${IP_ETH_'${idx}'_V6_IP_N}'
                idxa=1
                id6=1
                while [ ${id6} -le ${ipv6_n:-0} ]
                do
                    ipv6_addr=''
                    ipv6_prefix=''
                    eval   ipv6_addr='${IP_ETH_'${idx}'_V6_IP_'${id6}'_IPADDR}'
                    eval ipv6_prefix='${IP_ETH_'${idx}'_V6_IP_'${id6}'_PREFIXLENGHT}'

                    echo "address${idxa}=${ipv6_addr}/${ipv6_prefix}"

                    idxa=$((${idxa} +1))
                    id6=$((${id6} +1))
                done

                if [ -n "${ipv6_gateway}" ]
                then
                    echo "gateway=${ipv6_gateway}"
                    if [ -n "${ipv6_metric}" ]
                    then
                        echo "route-metric=${ipv6_metric}"
                    fi
                fi
                # include to set route
                . /var/install/include/nm-get-route
                get_route ipv6

                if ! "${ipv6_dns:-false}"
                then
                    # include to set dns rsponder
                    . /var/install/include/nm-get-dns
                    get_dns ipv6

                    ipv6_dns=true
                fi
                ;;
            disabled)
                : #
                ;;
            link-local)
                echo "addr-gen-mode=${ipv6_addr_mode}"
                ;;
            ignore)
                : #
                ;;
            auto)
                : #
                ;;
            esac

            echo "method=${ipv6_method}"

            echo
            echo '[proxy]'
            echo
        } > /etc/NetworkManager/system-connections/br${bridx}.nmconnection

        /usr/bin/chmod 0600 /etc/NetworkManager/system-connections/br${bridx}.nmconnection
        >/run/netconfig/br${bridx}.nmconnection

        unset BRIDGE_PRIO
        unset BRIDGE_HELLO
        unset BRIDGE_MESSAGE
        unset BRIDGE_FDELAY

        idx2=1
        eval dev='${BRIDGE_'${bridge_idx}'_BIND_N}'
        while [ ${idx2} -le ${dev} ]
        do
            eval idxb='${BRIDGE_'${bridge_idx}'_BIND_'${idx2}'_ETH}'
            eval PRIO='${BRIDGE_'${bridge_idx}'_BIND_'${idx2}'_PRIO}'
            eval COST='${BRIDGE_'${bridge_idx}'_BIND_'${idx2}'_COST}'

            eval bridge_iface='${IP_ETH_'${idxb}'_NAME}'
            # putting down the network interface
            ${IP} addr flush dev ${bridge_iface} 2>/dev/null

            # set interface to bridge
            {
                echo '[connection]'
                echo "id=${bridge_iface}"
                echo 'type=ethernet'
                echo "controller=br${bridx}"
                echo "interface-name=${bridge_iface}"
                echo 'port-type=bridge'
                echo
                echo '[ethernet]'
                echo
                echo '[bridge-port]'

                if [ -n "${COST}" ] &&
                   [ ${COST} -ne 100 ]
                then
                    echo "path-cost=${COST}"
                fi

                if [ -n "${PRIO}" ] &&
                   [ ${PRIO} -ne 32 ]
                then
                    echo "priority=${PRIO}"
                fi

                echo
            } > /etc/NetworkManager/system-connections/${bridge_iface}.nmconnection

            /usr/bin/chmod 0600 /etc/NetworkManager/system-connections/${bridge_iface}.nmconnection
            >/run/netconfig/${bridge_iface}.nmconnection

            idx2=$((${idx2} + 1))
            unset PRIO
            unset COST
        done

        bridge_idx=$((${bridge_idx} + 1))
    done
}

# ---------------------------------------------------------------------------
# stop
# ---------------------------------------------------------------------------
bridge_stop()
{
    if check_bridge_status
    then
        idx=1
        while [ ${idx} -le ${BRIDGE_N:-0} ]
        do
            eval dev='${BRIDGE_'${idx}'_BIND_N}'

            idx2=1
            while [ ${idx2} -le ${dev} ]
            do
                eval idxb='${BRIDGE_'${idx}'_BIND_'${idx2}'_ETH}'
                eval bridge_iface='${IP_ETH_'${idxb}'_NAME}'

                ${IP} link set dev ${bridge_iface} nomaster
                ${IP} link set ${bridge_iface} down
                idx2=$((${idx2} + 1))
            done

            bridx=$((${idx} - 1))
            ${IP} link del br${bridx}

            idx=$((${idx} + 1))
        done

        # remove kernelmodul
        /usr/sbin/modprobe -r bridge
    fi
}

# ---------------------------------------------------------------------------
# main
# ---------------------------------------------------------------------------
main()
{
    while [ "${#}" -gt 0 ]
    do
        case "${1}" in
        --quiet)
            _quiet=true
            shift
            ;;
        *)
            _action="${1}"
            shift
            ;;
        esac
    done


    case "${_action}" in
        start)
            bridge_start
        ;;
        stop)
            bridge_stop
        ;;
    esac

    exit 0
}

# ---------------------------------------------------------------------------
# exec main
# ---------------------------------------------------------------------------
main "${@}"

# ---------------------------------------------------------------------------
# end
# ---------------------------------------------------------------------------