#!/bin/sh
# =====================================================================
#  Projet  : DARKWALL
#  Fichier : lib/route6
#  Auteur  : Nicolas "DarkHack" Chapuis (c) 2026
# ================== DARKHACK ==================
#        [ darkweb.fr  -  system online ]
#   Powered by Perplexity, your AI assistant
#       https://www.perplexity.ai
# ==============================================
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
# =====================================================================
if ! type "shInclude" > /dev/null 2>&1; then racineSh="${racineSh:-/etc/darksh}"; . "$racineSh/lib/shTools"; shDebugEnable="1";fi
rootDarkWall="${rootDarkWall:-/etc/darkwall}"
[ ! -d "$rootDarkWall" ] && shDebug 0 "exit cause rootDarWall is not dir:$rootDarkWall" && exit 0

requiresCmd="printf cat rev tr cut grep echo head ping ping6 ip"
shWhichCmd $requiresCmd >/dev/null
shWarnOnMissing $( shWhichCmd $requiresCmd | $cmdTr '_' ' ' )

# local jsonEth="$( $cmdEcho {jsonEth} | route6AddEth )"
route6AddEth() {
 local log="route6AddEth:"
 local jsonEth="$( $cmdCat <&0 )"
 local eth="$( $cmdEcho ${jsonEth} | json64InObjectRead "eth" )"
 if [ -z "${jsonEth}" ] || [ -z "${eth}" ];then
  shDebugHidden 0 ""${log}" bad params empty eth:${eth} jsonEth:${jsonEth}" >&2
 else
  local log="route6AddEth[eth:${eth}]:"
  local masterEth="$( $cmdEcho ${jsonEth} | json64InObjectRead "masterEth" )"
  if [ -z "${masterEth}" ];then local masterEth="${eth}";fi
  local masterEth="$( $cmdEcho ${masterEth} | $cmdCut -d\: -f1 )"
  local log="route6AddEth[${eth}/${masterEth}]:"
  
  local jsonEthRoute="$( $cmdEcho ${jsonEth} | json64InObjectRead route6 )"
  if [ -n "${jsonEthRoute}" ];then
   local markEthIn="$( $cmdEcho ${jsonEthRoute} | json64InObjectRead "markIn" )"
   local markEthOut="$( $cmdEcho ${jsonEthRoute} | json64InObjectRead "markOut" )"
   shDebugHidden 1 ""${log}" jsonEthRoute ever registered markEthIn:${markEthIn} markEthOut:${markEthOut}" >&2
  else
#   local markEthIn=""$(ip6toolsGetMd5Rule "filter" "in${eth}" )""
#   local markEthOut=""$(ip6toolsGetMd5Rule "filter" "out${eth}" )""
   local jsonEthRoute="$( $cmdEcho {} | routeTableGetFromData "${eth}" )"
   local rtTbleMark="$( $cmdEcho $jsonEthRoute | jsonInObjectRead rtTableMark )"
   local markEthIn="$( $cmdEcho in${eth}${rtTbleMark} | $cmdTr ':' '_' )"
   local markEthOut="$( $cmdEcho out${eth}${rtTbleMark} | $cmdTr ':' '_' )"
   ip6toolsRuleCreate "filter" "${markEthIn}"
   ip6toolsRuleCreate "filter" "${markEthOut}"
   local jsonEthRoute="$( $cmdEcho ${jsonEthRoute} | json64InObjectWrite "markIn" ${markEthIn} )"
   local jsonEthRoute="$( $cmdEcho ${jsonEthRoute} | json64InObjectWrite "markOut" ${markEthOut} )"
   local jsonEth="$( $cmdEcho ${jsonEth} | json64InObjectWrite route6 ${jsonEthRoute} )"
  fi
#  if [ "|${eth}|" != "|${masterEth}|" ];then
#   shDebugHidden 0 ""${log}" on master for rule, cause ${eth} != ${masterEth}" >&2
#  else
  local rtTablePrio="$( $cmdEcho ${jsonEthRoute} | jsonInObjectRead "rtTablePrio" )"
  local rtTableMark="$( $cmdEcho ${jsonEthRoute} | jsonInObjectRead "rtTableMark" )"
  local rtTableName="$( $cmdEcho ${jsonEthRoute} | jsonInObjectRead "rtTableName" )"
  local rtTableCpt="$( $cmdEcho ${jsonEthRoute} | jsonInObjectRead "rtTableCpt" )"
  if [ -z "${rtTablePrio}" ] || [ -z "${rtTableMark}" ] || [ -z "${rtTableName}" ] || [ -z "${rtTableCpt}" ];then
   shDebugHidden 0 ""${log}"  bad params empty rtTablePrio:${rtTablePrio} rtTableMark:${rtTableMark} rtTableName:${rtTableName} rtTableCpt:${rtTableCpt}" >&2
  elif [ -z "${markEthIn}" ] || [ -z "${markEthOut}" ];then
   shDebugHidden 0 ""${log}"  bad params empty markEthIn:${markEthIn} markEthOut:${markEthOut}" >&2
  else
   #if ! iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} fwmark ${rtTableMark} iif ${eth} oif ${eth} lookup ${rtTableName}" ; then
   #iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} fwmark ${rtTableMark} lookup ${rtTableName}"
   iptoolsExecute "$cmdIp -6 rule add pri ${rtTableCpt} fwmark ${rtTableMark} lookup ${rtTableName}"
   iptoolsExecute "$cmdIp -6 rule add pri 30${rtTableCpt} oif ${eth} lookup ${rtTableName}"
   iptoolsExecute "$cmdIp -6 rule add pri 30${rtTableCpt} iif ${eth} lookup ${rtTableName}"
   ip6toolsRuleCreate "mangle" "${markEthIn}"
   ip6toolsRuleCreate "mangle" "${markEthOut}"
   
   ip6toolsRuleAdd "mangle" "markIn		-m mark --mark 0x0 -i "${eth}" -j ${markEthIn}"
   ip6toolsRuleAdd "mangle" "markOut		-m mark --mark 0x0 -o "${eth}" -j ${markEthOut}"
   
   # Add Filter Rule
   ip6toolsRuleAdd "filter" "INPUT  -i "${eth}" -j "${markEthIn}"" >&2
   ip6toolsRuleAdd "filter" "OUTPUT -o "${eth}" -j "${markEthOut}"" >&2
   shDebugHidden 1 ""${log}" added filter rule" >&2
   if [ "|${eth}|" != "|${masterEth}|" ];then
    ip6toolsRuleAdd "filter" "INPUT  -i "${masterEth}" -j "${markEthIn}"" >&2
    ip6toolsRuleAdd "filter" "OUTPUT -o "${masterEth}" -j "${markEthOut}"" >&2
#    local markEthIn=""$(iptoolsGetMd5Rule "filter" "in${eth}" )""
#    local markEthOut=""$(iptoolsGetMd5Rule "filter" "out${eth}" )""
#    local jsonMasterEthRoute="$( $cmdEcho {} | routeTableGetFromData "${masterEth}" )"
#    local masterRtTbleMark="$( $cmdEcho $jsonMasterEthRoute | jsonInObjectRead rtTableMark )"
#    local markMasterEthIn="$( $cmdEcho in${masterEth}${masterRtTbleMark} | $cmdTr ':' '_' )"
#    local markMasterEthOut="$( $cmdEcho out${masterEth}${masterRtTbleMark} | $cmdTr ':' '_' )"
#    ip6toolsRuleCreate "mangle" "${markMasterEthIn}"
#    ip6toolsRuleCreate "mangle" "${markMasterEthOut}"
#    ip6toolsRuleCreate "filter" "${markMasterEthIn}"
#    ip6toolsRuleCreate "filter" "${markMasterEthOut}"
##    local markMasterEthIn="$( $cmdEcho ${jsonMasterEthRoute} | json64InObjectRead "markIn" )"
##    local markMasterEthOut="$( $cmdEcho ${jsonMasterEthRoute} | json64InObjectRead "markOut" )"
#    # Add Filter Eth Rule
##    ip6toolsRuleInsert "filter" "INPUT  -i "${masterEth}" -j "${markEthIn}"" >&2
##    ip6toolsRuleInsert "filter" "OUTPUT -o "${masterEth}" -j "${markEthOut}"" >&2
#    ip6toolsRuleAdd "filter" "${markMasterEthIn} -j "${markEthIn}"" >&2
#    ip6toolsRuleAdd "filter" "${markMasterEthOut} -j "${markEthOut}"" >&2
#    ip6toolsRuleInsert "filter" "${markEthIn} -j "${markMasterEthIn}"" >&2
#    ip6toolsRuleInsert "filter" "${markEthOut} -j "${markMasterEthOut}"" >&2
##    ip6toolsRuleAdd "mangle" "markIn		-m mark --mark 0x0 -i "${masterEth}" -j ${markEthIn}"
##    ip6toolsRuleAdd "mangle" "markOut		-m mark --mark 0x0 -o "${masterEth}" -j ${markEthOut}"
#    ip6toolsRuleInsert "mangle" "${markMasterEthIn} -m mark --mark 0x0 -j "${markEthIn}""
#    ip6toolsRuleInsert "mangle" "${markMasterEthOut} -m mark --mark 0x0 -j "${markEthOut}""
#    shDebugHidden 1 ""${log}" added filter rule" >&2
#    shDebugHidden 0 ""$log" on master for rule, cause ${eth} != ${masterEth}" >&2
#   else
   fi
##   ip6toolsRuleAdd "mangle" "${markEthIn}	-m mark --mark 0x0 -j CONNMARK --set-mark "${rtTableMark}""
#   ip6toolsRuleAdd "mangle" "${markEthIn}	-m mark --mark 0x0 -j MARK --set-mark "${rtTableMark}""
   
##  ip6toolsRuleAdd "mangle" "${markEthOut}	-m mark --mark 0x0 -j CONNMARK --set-mark "${rtTableMark}""
#   ip6toolsRuleAdd "mangle" "${markEthOut}	-m mark --mark 0x0 -j MARK --set-mark "${rtTableMark}""
#   fi
   if [ "${eth}" != "lo" ];then
    iptoolsExecute "$cmdIp -6 route add ff00::/8 dev ${eth} metric 215 scope global  table ${rtTableName}"
    iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 214 dev ${eth} scope link table ${rtTableName}"
    iptoolsExecute "$cmdIp -6 route add fe80::/64 proto kernel metric 213 dev ${eth} scope link table ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 route del ff00::/8 dev ${eth} table local"
   fi
  fi
 fi
 $cmdEcho ${jsonEth}
}

# local jsonEth="$( $cmdEcho ${jsonEth} | route6AddIp "${ip6}" "${net6}" "${ll6}" )"
route6AddIp() {
 local log="route6AddIp"
 local jsonEth="$( $cmdCat <&0 )"
 
 local eth="$( $cmdEcho ${jsonEth} | json64InObjectRead "eth" )"
 local masterEth="$( $cmdEcho ${jsonEth} | json64InObjectRead "masterEth" )"
 local jsonEthRoute="$( $cmdEcho ${jsonEth} | json64InObjectRead "route6" )"
 local markEthIn="$( $cmdEcho ${jsonEthRoute} | json64InObjectRead "markIn" )"
 local markEthOut="$( $cmdEcho ${jsonEthRoute} | json64InObjectRead "markOut" )"
 local rtEthTableName="$( $cmdEcho "${jsonEthRoute}" | jsonInObjectRead "rtTableName" )"
 if [ -z "${masterEth}" ];then local masterEth="${eth}";fi
 if [ -z "${eth}" ] || [ -z "${masterEth}" ] || [ -z "${markEthIn}" ] || [ -z "${markEthOut}" ] || [ -z "${jsonEthRoute}" ];then
  shDebugHidden 0 "${log} param empty eth:${eth} masterEth:${masterEth} markEthIn:${markEthIn} markEthOut:${markEthOut} jsonEthRoute:${jsonEthRoute} jsonEth:${jsonEth}" >&2
 else
  local log="${log}[ ${eth}/${masterEth} ]"
  local ip6="${1}"
  local net6="${2}"
  local ll6="${3}"
#  if [ -z "${ip6}" ] || [ -z "${net6}" ] || ( [ -z "${ll6}" ] && [ "${eth}" != "lo" ] );then
#  if [ -z "${ip6}" ] || [ -z "${net6}" ] || ( [ -z "${ll6}" ] );then
  if [ -z "${ip6}" ];then
   shDebugHidden 0 "${log} ECHEC params ip6:${ip6} net6:${net6} ll6:${ll6} $*" >&2
  else
   local log="${log}[ ${ip6}/${net6} ]"
   local jsonIp6s="$( $cmdEcho ${jsonEth} | json64InObjectRead ip6s )"
   if [ -z "${jsonIp6s}" ];then local jsonIp6s="{}";fi
   local jsonIp6="$( $cmdEcho ${jsonIp6s} | json64InObjectRead "${ip6}" )"
   if [ -n "${jsonIp6}" ];then
    local jsonIp6Route="$( $cmdEcho ${jsonIp6} | json64InObjectRead route )"
    if [ -z "${jsonIp6Route}" ];then
     shDebugHidden 0 ""${log}" jsonIp6 haven't jsonIp6Route"
    fi
    shDebugHidden 1 ""${log}" jsonIp6 ever registered"
   else
    local jsonIp6Route="{}"
    local jsonIp6Route="$( $cmdEcho ${jsonIp6Route} | routeTableGetFromData "${ll6}" )"
#    local markNet6In="$( ip6toolsGetMd5Rule "filter" ${ll6}In )"
#    local markNet6Out="$( ip6toolsGetMd5Rule "filter" ${ll6}Out )"
    local markNet6In="$( $cmdEcho "${ll6}In" | tr -d ':' | tr -d '/' )"
    local markNet6Out="$( $cmdEcho "${ll6}Out" | tr -d ':' | tr -d '/' )"
    ip6toolsRuleCreate "filter" "${markNet6In}"
    ip6toolsRuleCreate "filter" "${markNet6Out}"
    local jsonIp6Route="$( $cmdEcho ${jsonIp6Route} | json64InObjectWrite "markIn" "$markNet6In" )"
    local jsonIp6Route="$( $cmdEcho ${jsonIp6Route} | json64InObjectWrite "markOut" "$markNet6Out" )"
    
    local jsonIp6="$( $cmdEcho {} | json64InObjectWrite route ${jsonIp6Route} )"
    local jsonIp6="$( $cmdEcho ${jsonIp6} | json64InObjectWrite "ip6" "${ip6}" )"
    local jsonIp6="$( $cmdEcho ${jsonIp6} | json64InObjectWrite "net6" "${net6}" )"
    local jsonIp6="$( $cmdEcho ${jsonIp6} | json64InObjectWrite "ll6" "${ll6}" )"
    shDebugHidden 1 ""${log}" jsonIp6 : ip6:"${ip6}" net6:"${net6}" ll6:"${ll6}"  registered"
   fi
   local markNet6In="$( $cmdEcho ${jsonIp6Route} | json64InObjectRead "markIn" )"
   local markNet6Out="$( $cmdEcho ${jsonIp6Route} | json64InObjectRead "markOut" )"
   
   local rtTablePrio="$( $cmdEcho ${jsonIp6Route} | jsonInObjectRead "rtTablePrio" )"
   local rtTableMark="$( $cmdEcho ${jsonIp6Route} | jsonInObjectRead "rtTableMark" )"
   local rtTableName="$( $cmdEcho ${jsonIp6Route} | jsonInObjectRead "rtTableName" )"
   local rtTableCpt="$( $cmdEcho ${jsonIp6Route} | jsonInObjectRead "rtTableCpt" )"
#   if [ -z "${markNet6In}" ] || [ -z "${markNet6Out}" ] || [ -z "${rtTablePrio}" ] || [ -z "${rtTableMark}" ] || [ -z "${rtTableName}" ] || [ -z "${rtTableCpt}" ] || [ -z "${rtTableCpt}" ];then
#    shDebugHidden 0 ""${log}" params empty markNet6In:${markNet6In} markNet6Out:${markNet6Out} rtTablePrio:${rtTablePrio} rtTableMark:${rtTableMark} rtTableName:${rtTableName} rtTableCpt:${rtTableCpt}" >&2
#   local ip6RoutePattern="$( $cmdIp -6 route show table local | awk -v addr="${ip6}" '$1 == "local" && $2 == addr {print $1, $2}' )"
#   local ll6RoutePattern="$( $cmdIp -6 route show table local | awk -v addr="${ll6}" '$1 == "local" && $2 == addr {print $1, $2}' )"
   local ip6RoutePattern="$($cmdIp -6 route show table local | $cmdGrep local\ ${ip6} | $cmdHead -n 1 | $cmdSed -E 's/[[:space:]]proto[[:space:]]+none//' | $cmdSed -E 's/[[:space:]]dev[[:space:]][a-zA-Z0-9]*//' | $cmdSed -E 's/[[:space:]]metric[[:space:]][0-9]*//' )"
   local ll6RoutePattern="$($cmdIp -6 route show table local | $cmdGrep local\ ${ll6} | $cmdHead -n 1 | $cmdSed -E 's/[[:space:]]proto[[:space:]]+none//' | $cmdSed -E 's/[[:space:]]dev[[:space:]][a-zA-Z0-9]*//' | $cmdSed -E 's/[[:space:]]metric[[:space:]][0-9]*//' )"
   if [ -z "${markNet6In}" ] || [ -z "${markNet6Out}" ];then
    shDebugHidden 0 ""${log}" params empty markNet6In:${markNet6In} markNet6Out:${markNet6Out}" >&2
   elif [ -z "${ip6RoutePattern}" ] || [ -z "${ll6RoutePattern}" ];then
    shDebugHidden 0 ""${log}" params empty ip6RoutePattern:${ip6RoutePattern} ll6RoutePattern:${ll6RoutePattern}" >&2
   else
#    iptoolsExecute "$cmdIp -6 route del $ip6RoutePattern table local"
#    iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev ${eth} metric 5${rtTableCpt} table main"
#    iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} metric 5${rtTableCpt} table main"
#    iptoolsExecute "$cmdIp -6 route del anycast ${net6} metric 0 table local"
#    iptoolsExecute "$cmdIp -6 route add anycast ${net6} dev ${eth} metric 1${rtTableCpt} table local"
#    iptoolsExecute "$cmdIp -6 route del ff00::/8 dev ${eth} table local"
#    iptoolsExecute "$cmdIp -6 route add ff00::/8 src ${ip6} dev ${eth} metric 2${rtTableCpt} table local"
#    iptoolsExecute "$cmdIp -6 route add ff00::/8 dev ${eth} metric 10${rtTableCpt} table local"
    
    iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev ${eth} metric 3${rtTableCpt} table ${rtTableName}"
    iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} metric 2${rtTableCpt} table ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev lo metric 1${rtTableCpt} table ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev lo metric 1${rtTableCpt} table ${rtTableName}"
    
#    iptoolsExecute "$cmdIp -6 route add ff00::/8 src ${ip6} proto kernel metric 1${rtTableCpt} dev ${eth} scope global table ${rtTableName}"
    iptoolsExecute "$cmdIp -6 route add ff00::/8 proto kernel metric 10${rtTableCpt} dev ${eth} scope global table ${rtTableName}"
    
#    iptoolsExecute "$cmdIp -6 route del fe80::/64 dev ${eth}"
    ip6toolsRuleCreate "mangle" "${markNet6In}"
    ip6toolsRuleCreate "mangle" "${markNet6Out}"
#    ip6toolsRuleAdd "mangle" "$markEthIn -d "${net6}" -j "${markNet6In}"" >&2
#    ip6toolsRuleAdd "mangle" "$markEthIn -s "${net6}" -j "${markNet6In}"" >&2
#    ip6toolsRuleAdd "mangle" "$markEthOut -s "${net6}" -j "${markNet6Out}"" >&2
#    ip6toolsRuleAdd "mangle" "$markEthOut -d "${net6}" -j "${markNet6Out}"" >&2
    # Add Filter Rule
    ip6toolsRuleInsert "filter" "$markEthIn -d "${ip6}" -j "${markNet6In}"" >&2
#    ip6toolsRuleInsert "filter" "$markEthIn -s "${net6}" -j "${markNet6In}"" >&2
    ip6toolsRuleInsert "filter" "$markEthOut -s "${ip6}" -j "${markNet6Out}"" >&2
#    ip6toolsRuleInsert "filter" "$markEthOut -d "${net6}" -j "${markNet6Out}"" >&2
    shDebugHidden 2 ""${log}" added filter rule" >&2
    
    #iptoolsExecute "$cmdIp -6 route del ${ip6} table local"
    #if ! iptoolsExecute "$cmdIp -6 route del ${net6} dev ${eth}" ; then
    # shDebugHidden 0 ""${log}" $eth ip route clean" >&2
    #else
    # shDebugHidden 2 ""${log}" $eth ip route clean" >&2
    #fi
    
    if [ "|${eth}|" != "|${masterEth}|" ];then
     local jsonMasterEthRoute="$( $cmdEcho {} | routeTableGetFromData "${masterEth}" )"
     local masterRtTableName="$( $cmdEcho $jsonMasterEthRoute | jsonInObjectRead "rtTableName" )"
    fi
#    iptoolsExecute "$cmdIp -6 route del fe80::/64 dev ${eth}"
#    iptoolsExecute "$cmdIp -6 route del ff00::/8 dev ${eth} table local"
    ip6toolsRuleInsert "mangle" "$markEthIn -m mark --mark 0x0 -d "${ip6}" -j "${markNet6In}"" >&2
#    ip6toolsRuleInsert "mangle" "$markEthIn -m mark --mark 0x0 -s "${ip6}" -j "${markNet6In}"" >&2
    ip6toolsRuleInsert "mangle" "$markEthOut -m mark --mark 0x0 -s "${ip6}" -j "${markNet6Out}"" >&2
#    ip6toolsRuleInsert "mangle" "$markEthOut -m mark --mark 0x0 -d "${ip6}" -j "${markNet6Out}"" >&2
    if [ "${ip6}" = "${ll6}" ];then
     for anRtTableName in ${rtTableName} ${rtEthTableName} ${masterRtTableName};do
#      iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev lo metric 111 table ${anRtTableName}"
      iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} metric 222 table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 5${rtTableCpt} dev ${eth} scope link src ${ll6} table ${anRtTableName}"
      iptoolsExecute "$cmdIp -6 route add fe80::/64 proto kernel metric ${rtTableCpt} dev ${eth} scope link table ${anRtTableName}"
      iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 10${rtTableCpt} dev ${eth} scope link table ${anRtTableName}"
      
#      iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 255 dev ${eth} scope link table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 254 dev ${eth} scope link src ${ll6} table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ff00::/8 proto kernel metric 2${rtTableCpt} dev ${eth} scope link src ${ll6} table ${anRtTableName}"
      iptoolsExecute "$cmdIp -6 route add ff00::/8 proto kernel metric 10${rtTableCpt} dev ${eth} scope link table ${anRtTableName}"
     done
     iptoolsExecute "$cmdIp -6 rule add pri 22${rtTableCpt} to ff00::/8 iif ${eth} lookup ${rtTableName}"
     iptoolsExecute "$cmdIp -6 rule add pri 23${rtTableCpt} to ff00::/8 oif ${eth} lookup ${rtTableName}"
    else
     local log="${log}[ ${ll6} ]"
     
#     for anRtTableName in ${rtTableName} $( $cmdEcho "${jsonEthRoute}" | jsonInObjectRead "rtTableName" );do
#     local jsonLl6Route="$( $cmdEcho {} | routeTableGetFromData "${eth}${ll6}" )"
#     local markLl6In="$( $cmdEcho ${jsonLl6Route} | json64InObjectRead "markIn" )"
#     local markLl6Out="$( $cmdEcho ${jsonLl6Route} | json64InObjectRead "markOut" )"
     
#     local ll6RtTablePrio="$( $cmdEcho ${jsonLl6Route} | jsonInObjectRead "rtTablePrio" )"
#     local ll6RtTableMark="$( $cmdEcho ${jsonLl6Route} | jsonInObjectRead "rtTableMark" )"
#     local ll6RtTableName="$( $cmdEcho ${jsonLl6Route} | jsonInObjectRead "rtTableName" )"
#     local ll6RtTableCpt="$( $cmdEcho ${jsonLl6Route} | jsonInObjectRead "rtTableCpt" )"
     
#     iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} table ${ll6RtTableName}"
#     iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 253 dev ${eth} scope link table ${ll6RtTableName}"
#     iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 252 dev ${eth} scope link src ${ll6} table ${ll6RtTableName}"
     
#     iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} table ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 251 dev ${eth} scope link table ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 route add ff00::/8 proto kernel metric 250 dev ${eth} scope link src ${ip6} table ${rtTableName}"
     shDebugHidden 0 "${log} route setup: rtTableName:${rtTableName} rtEthTableName:${rtEthTableName} masterRtTableName:${masterRtTableName} rtTableCpt:${rtTableCpt}" >&2
     for anRtTableName in ${rtTableName} ${rtEthTableName} ${masterRtTableName};do
      shDebugHidden 0 "${log} ADD-NET6: \
       net6=[${net6}] table=[${anRtTableName}] \
       cmd=ip -6 route add ${net6} proto kernel \
       metric 10${rtTableCpt} dev ${eth} scope link \
       table ${anRtTableName}" >&2
#      iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev lo metric 100 table ${anRtTableName}"
      iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev ${eth} metric 200 table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ${net6} src ${ip6} proto kernel metric 2${rtTableCpt} dev ${eth} scope link table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ${net6} src ${ll6} proto kernel metric 5${rtTableCpt} dev ${eth} scope link table ${anRtTableName}"
      shDebugHidden 0 "${log} route setup: ${net6} to ${anRtTableName}" >&2
      iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 10${rtTableCpt} dev ${eth} scope link table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 249 dev ${eth} scope link src ${ip6} table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 248 dev ${eth} scope link src ${ll6} table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 247 dev ${eth} scope link src ${ll6} table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 246 dev ${eth} scope link src ${ip6} table ${anRtTableName}"
#      iptoolsExecute "$cmdIp -6 route add ff00::/8 proto kernel metric 245 dev ${eth} scope link src ${ll6} table ${anRtTableName}"
     done
    fi
    iptoolsExecute ""
#    iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} fwmark ${rtTableMark} lookup ${rtTableName}"
    iptoolsExecute "$cmdIp -6 rule add pri ${rtTableCpt} fwmark ${rtTableMark} lookup ${rtTableName}"
    
    iptoolsExecute "$cmdIp -6 rule add pri 12${rtTableCpt} from ${net6} iif ${eth} lookup ${rtTableName}"
    iptoolsExecute "$cmdIp -6 rule add pri 13${rtTableCpt} from ${net6} oif ${eth} lookup ${rtTableName}"
    iptoolsExecute "$cmdIp -6 rule add pri 14${rtTableCpt} to ${net6} iif ${eth} lookup ${rtTableName}"
    iptoolsExecute "$cmdIp -6 rule add pri 15${rtTableCpt} to ${net6} oif ${eth} lookup ${rtTableName}"
    
    iptoolsExecute "$cmdIp -6 rule add pri 24${rtTableCpt} to $( ip6toolsGetNodeSollicite ${ip6} )/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 24${rtTableCpt} from $( ip6toolsGetNodeSollicite ${ip6} )/128 lookup ${rtTableName}"
    iptoolsExecute "$cmdIp -6 rule add pri 25${rtTableCpt} from ${ip6}/128 lookup ${rtTableName}"
    iptoolsExecute "$cmdIp -6 rule add pri 26${rtTableCpt} to ${ip6}/128 lookup ${rtTableName}"
    
    if [ "${ip6}" != "${ll6}" ];then
     iptoolsExecute "$cmdIp -6 rule add pri 34${rtTableCpt} from ${net6} lookup ${rtTableName}"
     iptoolsExecute "$cmdIp -6 rule add pri 35${rtTableCpt} to ${net6} lookup ${rtTableName}"
    fi
    
#    iptoolsExecute "$cmdIp -6 rule add pri 22${rtTableCpt} from ${ip6}/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 23${rtTableCpt} from ${ip6}/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 24${rtTableCpt} to ${ip6}/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 25${rtTableCpt} to ${ip6}/128 lookup ${rtTableName}"
    
#    iptoolsExecute "$cmdIp -6 rule add pri 2${rtTableCpt} from ${net6} iif ${eth} lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 3${rtTableCpt} from ${net6} oif ${eth} lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 4${rtTableCpt} to ${net6} iif ${eth} lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 5${rtTableCpt} to ${net6} oif ${eth} lookup ${rtTableName}"
    
#    iptoolsExecute "$cmdIp -6 rule add pri 21${rtTableCpt} from ${ip6}/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 22${rtTableCpt} to ${ip6}/128 lookup ${rtTableName}"
##    iptoolsExecute "$cmdIp -6 rule add pri 23${rtTableCpt} from ${ll6}/128 lookup ${rtTableName}"
##    iptoolsExecute "$cmdIp -6 rule add pri 24${rtTableCpt} to ${ll6}/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 25${rtTableCpt} from ${net6}/128 lookup ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 rule add pri 26${rtTableCpt} to ${net6}/128 lookup ${rtTableName}"
    
#    if [ "|${eth}|" != "|${masterEth}|" ];then
#     iptoolsExecute "$cmdIp -6 rule add pri 2${rtTableCpt} from ${ip6}/128 iif ${masterEth} lookup ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 rule add pri 3${rtTableCpt} from ${ip6}/128 oif ${masterEth} lookup ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 rule add pri 4${rtTableCpt} to ${ip6}/128 iif ${masterEth} lookup ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 rule add pri 5${rtTableCpt} to ${ip6}/128 oif ${masterEth} lookup ${rtTableName}"
##     
##     iptoolsExecute "$cmdIp -6 rule add pri 2${rtTableCpt} from ${net6} iif ${masterEth} lookup ${rtTableName}"
##     iptoolsExecute "$cmdIp -6 rule add pri 3${rtTableCpt} from ${net6} oif ${masterEth} lookup ${rtTableName}"
##     iptoolsExecute "$cmdIp -6 rule add pri 4${rtTableCpt} to ${net6} iif ${masterEth} lookup ${rtTableName}"
##     iptoolsExecute "$cmdIp -6 rule add pri 5${rtTableCpt} to ${net6} oif ${masterEth} lookup ${rtTableName}"
#    fi
    
##    if [ "${eth}" != "lo" ];then
##    iptoolsExecute "$cmdIp -6 route add ${net6} src ${ip6} dev ${eth} proto kernel metric 244 scope link src ${ip6} table ${rtTableName}"
#    iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev ${eth} table ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 route add ${net6} dev ${eth} proto kernel metric 243 scope link src ${ip6} table ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 route add local ${ll6}/128 dev ${eth} proto kernel metric 242 scope host table ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 route add ff00::/8 dev ${eth} metric 241 scope link src ${ip6} table ${rtTableName}"
##     if ip6IsInNetwork ${ip6} "fe80::/10" ; then
##      shDebugHidden 2 ""${log}" add ff00::/8 ${eth}${net6}|${ip6} " >&2
###      iptoolsExecute "$cmdIp -6 route del ${net6} dev ${eth} table main"
###     else
###      iptoolsExecute "$cmdIp -6 route add fe80::/64 dev ${eth} proto kernel metric 240 scope link src ${ip6} table ${rtTableName}"
###      iptoolsExecute "$cmdIp -6 route add fe80::/64 dev ${eth} proto kernel metric 239 scope link src ${ll6} table ${rtTableName}"
##     fi
#     if ! iptoolsExecute "${initIpRoute}" ; then
#      shDebugHidden 0 ""${log}" route add ${eth} ${net6} by ${ip6}" >&2
#     else
#      shDebugHidden 2 ""${log}" route add ${eth} ${net6} by ${ip6}" >&2
#     fi
##     ip6toolsRuleInsert "mangle" "$markEthIn	-d "${ip6}/128" -j MARK --set-mark "${rtTableMark}""
##     ip6toolsRuleInsert "mangle" "$markEthOut	-s "${ip6}/128" -j MARK --set-mark "${rtTableMark}""
##     if ip6IsInNetwork ${ip6} "fe80::/10" ; then
##      iptoolsExecute "$cmdIp -6 rule add pri 6${rtTableCpt} from ${ip6}/128 lookup ${rtTableName}"
###      iptoolsExecute "$cmdIp -6 rule add pri 6${rtTableCpt} to ${ip6}/128 lookup ${rtTableName}"
##     else
##      iptoolsExecute "$cmdIp -6 rule add pri 6${rtTableCpt} from ${ip6}/128 lookup ${rtTableName}"
###      iptoolsExecute "$cmdIp -6 rule add pri 6${rtTableCpt} to ${ip6}/128 lookup ${rtTableName}"
##     fi
#    fi
#    
#    iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} from ${ip6}/128 lookup ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} to ${ip6}/128 lookup ${rtTableName}"
#    if ip6IsInNetwork "${ip6}" "fe80::/10" ; then
#    fi
#     iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} iif ${eth} from ${net6} lookup ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} iif ${eth} to ${net6} lookup ${rtTableName}"
#     iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} oif ${eth} from ${net6} lookup ${rtTableName}"
#    else
#     iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} from ${ip6}/128 lookup ${rtTableName}"
##     iptoolsExecute "$cmdIp -6 rule add pri ${rtTablePrio} to ${net6} lookup ${rtTableName}"
#    
     ip6toolsRuleInsert "mangle" "${markNet6In}	-m mark --mark 0x0 -j MARK --set-mark "${rtTableMark}""
     ip6toolsRuleInsert "mangle" "${markNet6Out}	-m mark --mark 0x0 -j MARK --set-mark "${rtTableMark}""
#    if [ "${ip6}" != "${ll6}" ];then
#     ip6toolsRuleCreate "mangle" "${markNet6In}"
#     ip6toolsRuleCreate "mangle" "${markNet6Out}"
#     
#     ip6toolsRuleInsert "mangle" "${markEthIn}		-m mark --mark 0x0 -d "${ip6}/128" -j "${markNet6In}""
#     ip6toolsRuleInsert "mangle" "${markEthOut}		-m mark --mark 0x0 -s "${ip6}/128" -j "${markNet6Out}""
##     ip6toolsRuleInsert "mangle" "${markEthIn}		-m mark --mark 0x0 -s "${net6}" -j "${markNet6In}""
##     ip6toolsRuleInsert "mangle" "${markEthOut}	-m mark --mark 0x0 -d "${net6}" -j "${markNet6Out}""
#     ip6toolsRuleInsert "mangle" "${markEthIn}		-m mark --mark 0x0 -d "${ll6}/128" -j "${markNet6In}""
#     ip6toolsRuleInsert "mangle" "${markEthOut}		-m mark --mark 0x0 -s "${ll6}/128" -j "${markNet6Out}""
#     
##    ip6toolsRuleInsert "mangle" "${markEthOut}		-m mark --mark 0x0 -d "${net6}" -j MARK --set-mark "${rtTableMark}""
##    ip6toolsRuleInsert "mangle" "${markEthOut}		-m mark --mark 0x0 -s "${ip6}" -j MARK --set-mark "${rtTableMark}""
##    ip6toolsRuleInsert "mangle" "${markNet6In}		-m mark --mark 0x0 -d "${ip6}/128" -j CONNMARK --set-mark "${rtTableMark}""
##    ip6toolsRuleInsert "mangle" "${markNet6Out}	-m mark --mark 0x0 -s "${ip6}/128" -j CONNMARK --set-mark "${rtTableMark}""
#    fi
    
    local jsonIp6sN="$( $cmdEcho ${jsonIp6s} | json64InObjectWrite "${ip6}" "${jsonIp6}" )"
    if [ -z "${jsonIp6sN}" ];then
     shDebugHidden 0 ""${log}" jsonIp6sN empty echec write ${ip6}:${jsonIp6}" >&2
    else
     local jsonIp6s="${jsonIp6sN}"
     local jsonEthN="$( $cmdEcho $jsonEth | json64InObjectWrite ip6s "${jsonIp6s}" )"
     if [ -z "${jsonEthN}" ];then
      shDebugHidden 0 ""${log}" jsonEthN empty echec write ip6s:${jsonIp6s}" >&2
     else
      local jsonEth="${jsonEthN}"
      shDebugHidden 2 ""${log}" write jsonIp6 success" >&2
     fi
    fi
   fi
  fi
 fi
 $cmdEcho ${jsonEth}
}
#  local jsonGw6="$( $cmdEcho ${jsonGw6} | json64InObjectWrite state offlink )"
# $cmdEcho ${jsonGw6} | route6AddGw "${eth}" "${ip6}" "${markEthIn}" "${markEthOut}"
#        local refreshMangle=1
route6AddGw() {
 local log="route6AddGw:"
 local eth="${1}"
 local ip6="${2}"
 local ll6="${3}"
 local markEthIn="${4}"
 local markEthOut="${5}"
 [ "$ip6" = "$ll6" ] && shDebugHidden 0 ""${log}" no gateway for linklocal ll6:$ll6 ip6:$ip6" >&2
 
 local jsonGw6="$( $cmdCat <&0 )"
 if [ -z "${jsonGw6}" ];then
  shDebugHidden 0 ""${log}" no jsonGw6" >&2
  return ;
 fi
 
 local gw6="$( $cmdEcho ${jsonGw6} | json64InObjectRead ip )"
 local ethForGw="$( ip6ToolsGetEthForGw ${gw6} )"
 local ll6ForGw="$( ip6toolsGetLLForGw ${gw6} )"
 
# if [ "${ip6}" = "${ll6}" ] || [ -z "${eth}" ] || [ -z "${gw6}" ] || [ -z "${ip6}" ] || [ -z "${ll6}" ] || [ -z "${markEthIn}" ] || [ -z "${markEthOut}" ] || [ -z "${jsonGw6}" ];then
 if [ -z "${eth}" ] || [ -z "${gw6}" ] || [ -z "${ip6}" ] || [ -z "${ll6}" ] || [ -z "${markEthIn}" ] || [ -z "${markEthOut}" ] || [ -z "${jsonGw6}" ];then
   shDebugHidden 0 ""${log}" bad params eth:${eth} gw6:${gw6} ip6:${ip6} ll6:${ll6} markEthIn:${markEthIn} markEthOut:${markEthOut} jsonGw6:${jsonGw6}" >&2
 else
  local log="route6AddGw[${eth}/${ip6}/${gw6}][${markEthIn}/${markEthOut}]:"
  shDebugHidden 1 ""${log}" search mac route" >&2
  local jsonGw6Route="$( $cmdEcho ${jsonGw6} | json64InObjectRead route )"
  if [ -z "${jsonGw6Route}" ];then
   local mac="$( getMacForIp6InEth "${eth}" "${gw6}" )"
   if [ -z "${mac}" ];then
    shDebugHidden 0 ""${log}" no MAC for ${gw6}, have to try later" >&2
   else
    shDebugHidden 1 ""${log}" '"${gw6}"/"${mac}"' register mac route" >&2
    local jsonGw6="$( $cmdEcho ${jsonGw6} | json64InObjectWrite mac "${mac}" )"
   fi
#   local jsonGw6Route="$( $cmdEcho {} | routeTableGetFromData "${eth}${ip6}${gw6}" )"
#=============== ICI
   local jsonGw6Route="$( $cmdEcho {} | routeTableGetFromData "${ethForGw}${ll6ForGw}${gw6}" )"
   local rtTablePrio="$( $cmdEcho ${jsonGw6Route} | jsonInObjectRead "rtTablePrio" )"
   local rtTableMark="$( $cmdEcho ${jsonGw6Route} | jsonInObjectRead "rtTableMark" )"
   local rtTableName="$( $cmdEcho ${jsonGw6Route} | jsonInObjectRead "rtTableName" )"
   local rtTableCpt="$( $cmdEcho ${jsonGw6Route} | jsonInObjectRead "rtTableCpt" )"
   if [ -z "$rtTablePrio" ] || [ -z "$rtTableMark" ] || [ -z "$rtTableName" ] || [ -z "$rtTableCpt" ];then
    shDebugHidden 0 ""${log}" echec rtTablePrio:$rtTablePrio rtTableMark:$rtTableMark rtTableName:$rtTableName rtTableCpt:$rtTableCpt" >&2
   else
#    local jsonGw6="$( $cmdEcho ${jsonGw6} | json64InObjectWrite route "${jsonGw6Route}" )"
#    local initRouteGw="$cmdIp -6 rule add pri ${rtTablePrio} fwmark ${rtTableMark} iif ${eth} oif ${eth} lookup ${rtTableName}" ; then
#    local initRouteGw="$cmdIp -6 rule add pri ${rtTablePrio} fwmark ${rtTableMark} lookup ${rtTableName}"
    local initRouteGw="$cmdIp -6 rule add pri ${rtTableCpt} fwmark ${rtTableMark} lookup ${rtTableName}"
#    if ip6IsInNetwork ${gw6} "fe80::/10" ;then local initRouteGw="${initRouteGw};$cmdIp -6 route add ${gw6} dev ${eth}";fi
    if [ -z "${jsonGw6}" ] || ! iptoolsExecute "${initRouteGw}" >&2; then
     shDebugHidden 0 ""${log}" add mark for '${gw6}':'${mac}' mark:${rtTableMark} name:${rtTableName} prio:${rtTablePrio} jsonGw6:${jsonGw6}" >&2
    else
     shDebugHidden 2 ""${log}" ${markEthIn}/${markEthOut} add mark for '${gw6}':mac:'${mac}' mark:${rtTableMark} name:${rtTableName} prio:${rtTablePrio}" >&2
#     ip6toolsRuleInsert "mangle" "markIn	-d "${ip6}/128" -m mac --mac-source "${mac}" -j CONNMARK --set-mark "${rtTableMark}""
     ip6toolsRuleInsert "mangle" "${markEthIn}	-d "${net6}" -j MARK --set-mark "${rtTableMark}"" >&2
     [ -n "${mac}" ] && ip6toolsRuleInsert "mangle" "${markEthIn}	-m mac --mac-source "${mac}" -j MARK --set-mark "${rtTableMark}"" >&2
    fi
#    ip6toolsRuleInsert "mangle" "markOut	-s "${ip6}/128" -j CONNMARK --set-mark "${rtTableMark}"" >&2
#    ip6toolsRuleInsert "mangle" "markOut	-s "${ip6}/128" -j MARK --set-mark "${rtTableMark}"" >&2
    ip6toolsRuleInsert "mangle" "${markEthOut}	-s "${net6}" -j MARK --set-mark "${rtTableMark}"" >&2
    local jsonGw6="$( $cmdEcho ${jsonGw6} | json64InObjectWrite route ${jsonGw6Route} )"
    if [ "${ethForGw}" != "${eth}" ];then
     local jsonEthGw6Route="$( $cmdEcho {} | routeTableGetFromData "${ethForGw}" )"
#     local rtEthGwTablePrio="$( $cmdEcho ${jsonEthGw6Route} | jsonInObjectRead "rtTablePrio" )"
#     local rtEthGwTableMark="$( $cmdEcho ${jsonEthGw6Route} | jsonInObjectRead "rtTableMark" )"
     local rtEthGwTableName="$( $cmdEcho ${jsonEthGw6Route} | jsonInObjectRead "rtTableName" )"
#     local rtEthGwTableCpt="$( $cmdEcho ${jsonEthGw6Route} | jsonInObjectRead "rtTableCpt" )"
     iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 777 dev ${eth} scope link table ${rtEthGwTableName}"
#     local ll6OfEthForGw="$( ip6ToolsGetEthForGw ${gw6} )"
     shDebugHidden 2 ""${log}" ${eth}/${ethForGw} route add ${net6} proto kernel metric 777 dev ${eth} scope link table ${rtEthGwTableName}" >&2
     for ll6OfEthForGw in $( ip6toolsGetLls ${ethForGw} );do
      local anll6OfEthGw6Route="$( $cmdEcho {} | routeTableGetFromData "${ethForGw}${ll6OfEthForGw}${gw6}" )"
      local rtLl6EthGwTableName="$( $cmdEcho ${anll6OfEthGw6Route} | jsonInObjectRead "rtTableName" )"
      iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 777 dev ${eth} scope link table ${rtLl6EthGwTableName}"
      shDebugHidden 2 ""${log}" ${eth}/${ethForGw} route add ${net6} proto kernel metric 777 dev ${eth} scope link table ${rtLl6EthGwTableName}" >&2
     done
    fi
   fi
  fi
 fi
 $cmdEcho ${jsonGw6}
}

route6AddFwd() {
 local log="route6AddFwd:"
 
# local srcEth=""$( iptoolsGetHostEth ""${1}"" )""
 local srcEth="${1}"
 local srcEthClean="$( $cmdEcho ${srcEth} | $cmdTr ':' '_' )"
# local fwdEth=""$( iptoolsGetHostEth ""${2}"" )""
 local fwdEth="${2}"
 local fwdEthClean="$( $cmdEcho ${fwdEth} | $cmdTr ':' '_' )"
 
 local log="${log}[${srcEth}/${fwdEth}]"
 
# local ruleSrcIfaceIn="In"${srcEth}""
# local ruleSrcIfaceOut="Out"${srcEth}""
 local jsonEthRoute="$( $cmdEcho {} | routeTableGetFromData "${srcEth}" )"
 local rtTbleMark="$( $cmdEcho $jsonEthRoute | jsonInObjectRead rtTableMark )"
 local ruleSrcIfaceIn="$( $cmdEcho in${srcEth}${rtTbleMark} | $cmdTr ':' '_' )"
 local ruleSrcIfaceOut="$( $cmdEcho out${srcEth}${rtTbleMark} | $cmdTr ':' '_' )"
 
# local ruleFwdIfaceIn="In"${fwdEth}""
# local ruleFwdIfaceOut="Out"${fwdEth}""
 local jsonEthRoute="$( $cmdEcho {} | routeTableGetFromData "${fwdEth}" )"
 local rtTbleMark="$( $cmdEcho $jsonEthRoute | jsonInObjectRead rtTableMark )"
 local ruleFwdIfaceIn="$( $cmdEcho in${fwdEth}${rtTbleMark} | $cmdTr ':' '_' )"
 local ruleFwdIfaceOut="$( $cmdEcho out${fwdEth}${rtTbleMark} | $cmdTr ':' '_' )"
 
 #local ruleIfaceIn=""$(firewallCreateRule	"Gw"$eth"In")""
 #local ruleIfaceOut=""$(firewallCreateRule	"Gw"$eth"Out")""
 local ruleGwIn="Gw"${srcEthClean}"-"${fwdEthClean}"I"
 local ruleGwOut="Gw"${srcEthClean}"-"${fwdEthClean}"O"
 ip6toolsRuleCreate "filter" "$ruleGwIn"
 ip6toolsRuleCreate "filter" "$ruleGwOut"
 
 ip6toolsRuleAdd "filter" ""$ruleSrcIfaceIn"	-j "$ruleGwIn""
 ip6toolsRuleAdd "filter" "FORWARD	-i "${srcEthClean}"	-o "${fwdEthClean}"	-j "$ruleGwIn""
 ip6toolsRuleAdd "filter" ""$ruleFwdIfaceOut"	-j "$ruleGwIn""
 
 ip6toolsRuleAdd "filter" ""$ruleFwdIfaceIn"	-j "$ruleGwOut""
 ip6toolsRuleAdd "filter" "FORWARD	-i "${fwdEthClean}"	-o "${srcEthClean}"	-j "$ruleGwOut""
 ip6toolsRuleAdd "filter" ""$ruleSrcIfaceOut"	-j "$ruleGwOut""
}

# mangle6EnableGw "${eth}" "${ip6}" "${ll6}" "${net6}" "${gw6}" "${rtTableName}" >&2
mangle6EnableGw() {
 local log="mangle6EnableGw:"
# local eth=""$( iptoolsGetHostEth ""${1}"" | $cmdCut -f1 -d\: )""
 local eth=""$( $cmdEcho ""${1}"" | $cmdCut -f1 -d\: )""
 local ip6="${2}"
 local ll6="${3}"
 local net6="${4}"
 local gw6="${5}"
 local rtTableName="${6}"
 
 if [ "${ip6}" = "{ll6}" ] || [ -z "${eth}" ] || [ -z "${ip6}" ] || [ -z "${ll6}" ] || [ -z "${net6}" ] || [ -z "${gw6}" ] || [ -z "${rtTableName}" ];then
  shDebugHidden 0 ""$log" bad params [ eth:${eth} ip6:${ip6} net6:${net6} gw6:${gw6} rtTableName:${rtTableName} ]" >&2
 else
  local log="mangle6EnableGw[${eth}/${ip6}/${net6}/${gw6}/${rtTableName}]:"
#   local ip6RoutePattern="$( $cmdIp -6 route show table local | awk -v addr="${ip6}" '$1 == "local" && $2 == addr {print $1, $2}' )"
#   local ll6RoutePattern="$( $cmdIp -6 route show table local | awk -v addr="${ll6}" '$1 == "local" && $2 == addr {print $1, $2}' )"
  local ip6RoutePattern="$($cmdIp -6 route show table local | $cmdGrep local\ ${ip6} | $cmdHead -n 1 | $cmdSed -E 's/[[:space:]]proto[[:space:]]+none//' | $cmdSed -E 's/[[:space:]]dev[[:space:]][a-zA-Z0-9]*//' | $cmdSed -E 's/[[:space:]]metric[[:space:]][0-9]*//' )"
  local ll6RoutePattern="$($cmdIp -6 route show table local | $cmdGrep local\ ${ll6} | $cmdHead -n 1 | $cmdSed -E 's/[[:space:]]proto[[:space:]]+none//' | $cmdSed -E 's/[[:space:]]dev[[:space:]][a-zA-Z0-9]*//' | $cmdSed -E 's/[[:space:]]metric[[:space:]][0-9]*//' )"
  # Add Route Gw to Interface and confinement table
  local initMangle6Gw=""
  iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev ${eth} metric 238 table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} metric 237 table ${rtTableName}"
#  iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev lo metric 127 table ${rtTableName}"
#  iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev lo metric 126 table ${rtTableName}"
  
  iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 1124 dev ${eth} scope link table ${rtTableName}"
  
  iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 1224 dev ${eth} scope link table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add fe80::/64 proto kernel metric 1224 dev ${eth} scope link table ${rtTableName}"
  
  iptoolsExecute "$cmdIp -6 route add ff00::/8 dev ${eth} metric 1324 scope global table ${rtTableName}"
  
  local ethForGw="$( ip6ToolsGetEthForGw ${gw6} )"
  local soliciteForGw="$( ip6toolsGetNodeSollicite ${gw6} )"
#  iptoolsExecute "$cmdIp -6 route add default via ${gw6} src ${ip6} dev ${ethForGw} metric 4096 table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add default via ${gw6} dev ${ethForGw} metric 4225 table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add ${soliciteForGw}/128 proto kernel metric 5 dev ${ethForGw} scope link table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add ${gw6}/128 proto kernel metric 24 dev ${ethForGw} scope link table ${rtTableName}"
#  iptoolsExecute "$cmdIp -6 rule add pri 100 to ${soliciteForGw}/128 table ${rtTableName}"
  shDebugHidden 1 ""${log}" enabled route6 on gw" >&2
 fi
}
# mangle6EnableEthGw "${eth}" "${ip6}" "${net6}" "${gw6}" "${rtTableName}" >&2
mangle6EnableEthGw() {
 local log="mangle6EnableEthGw:"
# local eth=""$( iptoolsGetHostEth ""${1}"" | $cmdCut -f1 -d\: )""
 local eth=""$( $cmdEcho ""${1}"" | $cmdCut -f1 -d\: )""
 local ip6="${2}"
 local ll6="${3}"
 local net6="${4}"
 local gw6="${5}"
 local rtTableName="${6}"
 
 if [ "${ip6}" = "${ll6}" ] || [ -z "${eth}" ] || [ -z "${ip6}" ] || [ -z "${ll6}" ] || [ -z "${net6}" ] || [ -z "${gw6}" ] || [ -z "${rtTableName}" ];then
  shDebugHidden 0 ""$log" bad params [ eth:${eth} ip6:${ip6} ll6:${ll6} net6:${net6} gw6:${gw6} rtTableName:${rtTableName} ]" >&2
 else
  local log="mangle6EnableGw[${eth}/${ip6}/${ll6}/${net6}/${gw6}/${rtTableName}]:"
#   local ip6RoutePattern="$( $cmdIp -6 route show table local | awk -v addr="${ip6}" '$1 == "local" && $2 == addr {print $1, $2}' )"
#   local ll6RoutePattern="$( $cmdIp -6 route show table local | awk -v addr="${ll6}" '$1 == "local" && $2 == addr {print $1, $2}' )"
  local ip6RoutePattern="$($cmdIp -6 route show table local | $cmdGrep local\ ${ip6} | $cmdHead -n 1 | $cmdSed -E 's/[[:space:]]proto[[:space:]]+none//' | $cmdSed -E 's/[[:space:]]dev[[:space:]][a-zA-Z0-9]*//' | $cmdSed -E 's/[[:space:]]metric[[:space:]][0-9]*//' )"
  local ll6RoutePattern="$($cmdIp -6 route show table local | $cmdGrep local\ ${ll6} | $cmdHead -n 1 | $cmdSed -E 's/[[:space:]]proto[[:space:]]+none//' | $cmdSed -E 's/[[:space:]]dev[[:space:]][a-zA-Z0-9]*//' | $cmdSed -E 's/[[:space:]]metric[[:space:]][0-9]*//' )"
  
  # Add Route Gw to Interface and confinement table
  local initMangle6Gw=""
  iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev ${eth} metric 124 table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev ${eth} metric 123 table ${rtTableName}"
#  iptoolsExecute "$cmdIp -6 route add ${ip6RoutePattern} dev lo metric 121 table ${rtTableName}"
#  iptoolsExecute "$cmdIp -6 route add ${ll6RoutePattern} dev lo metric 120 table ${rtTableName}"
  
  iptoolsExecute "$cmdIp -6 route add fe80::/10 proto kernel metric 1524 dev ${eth} scope link table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add fe80::/64 proto kernel metric 512 dev ${eth} scope link table ${rtTableName}"
  
  local ethForGw="$( ip6ToolsGetEthForGw ${gw6} )"
  local soliciteForGw="$( ip6toolsGetNodeSollicite ${gw6} )"
  iptoolsExecute "$cmdIp -6 route add ${gw6}/128 proto kernel metric 24 dev ${ethForGw} scope link table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add ${soliciteForGw}/128 proto kernel metric 5 dev ${ethForGw} scope link table ${rtTableName}"
#  iptoolsExecute "$cmdIp -6 route add default via ${gw6} src ${ip6} dev ${ethForGw} metric 4096 table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 route add default via ${gw6} dev ${ethForGw} metric 4306 scope link table ${rtTableName}"
  iptoolsExecute "$cmdIp -6 rule add pri 102 to ${soliciteForGw}/128 table ${rtTableName}"
  
  iptoolsExecute "$cmdIp -6 route add ${net6} proto kernel metric 1624 dev ${eth} scope link table ${rtTableName}"
  
  iptoolsExecute "$cmdIp -6 route add ff00::/8 dev ${eth} metric 1724 scope link table ${rtTableName}"
  
  shDebugHidden 1 ""${log}" enabled route6 on gw" >&2
 fi
}

getMacForIp6InEth() {
# local log="getMacForIp6InEth:"
 local eth="${1}"
 local ip="${2}"
 local mac="$( tryGetMacForIp6InEth ${eth} ${ip} )"
 if [ -z "$mac" ];then tryPingIp6InEth ${eth} ${ip} ;local mac="$( tryGetMacForIp6InEth ${eth} ${ip} )";fi
 $cmdEcho ""$mac""
}

tryGetMacForIp6InEth() {
# local log="tryGetMacForIp6InEth:"
# local eth=""$(iptoolsGetHostEth ""${1}"" | $cmdCut -f1 -d\: )""
 local eth=""$( $cmdEcho ""${1}"" | $cmdCut -f1 -d\: )""
 local ip="${2}"
# $cmdEcho "$cmdIp -6 neigh | $cmdGrep " dev ${eth} " | $cmdGrep -v "FAILED" | $cmdTr -s ' ' '_'"
 local mac=""
 for arpLine in $( $cmdIp -6 neigh | $cmdGrep " dev ${eth} " | $cmdGrep -v "FAILED" | $cmdGrep -v "INCOMPLETE" | $cmdTr -s ' ' '_');do
  local arpIp="$( $cmdEcho ${arpLine} | $cmdCut -d'_' -f 1)"
  if [ "|${arpIp}|" = "|${ip}|" ];then
   local mac="$( $cmdEcho ${arpLine} | $cmdCut -d'_' -f 5)"
  fi
 done
 $cmdEcho ""${mac}""
}
# tryPingIp6InEth $eth $ip
tryPingIp6InEth() {
# local log="tryPingIp6InEth:"
# local eth=""$(iptoolsGetHostEth ""${1}"")""
 local eth=""$( $cmdEcho ""${1}"" | $cmdCut -f1 -d\: )""
 local ip="${2}%${eth}"
 if [ -z "$( $cmdPing6 -I ${eth} -c 1 ${ip} 2>/dev/null | grep time= )" ];then
  #local ruleInException="$(firewallCreateRule InStartException)"
  # icmp (echo-reply:129/0, echo-request:128/0)
  local ruleInException="Inpingexception"
  ip6toolsRuleCreate "filter" "$ruleInException" >&2 && ip6toolsRuleAdd "filter" ""$ruleInException"	-p icmpv6 --icmpv6-type 128/0	-j ACCEPT" >&2
  
  #local ruleOutException="$(firewallCreateRule OutStartException)"
  local ruleOutException="Outpingexception"
  ip6toolsRuleCreate "filter" "$ruleOutException" >&2 && ip6toolsRuleAdd "filter" ""$ruleOutException"	 -p icmpv6 --icmpv6-type 129/0	-j ACCEPT" >&2
  
  ip6toolsRuleAdd "filter" "INPUT	-i "$eth" -j "$ruleInException"" >&2
  ip6toolsRuleAdd "filter" "OUTPUT	-o "$eth" -j "$ruleOutException"" >&2
  
  $cmdPing6 -I ${eth} -c 1 ${ip} > /dev/null 2>&1
  
  ip6toolsRuleDelete "filter" "INPUT"	"-i "$eth" -j "$ruleInException"" >&2
  ip6toolsRuleDelete "filter" "OUTPUT"	"-o "$eth" -j "$ruleOutException"" >&2
 fi
}