0005-add-pkg-gluon-hoodselector.patch

+  end
+  return false
+end
+
+function M.conditional_increment(table,index)
+  if index["bssid"] ~= nil then
+    if not table[index["bssid"]] then
+      table[index["bssid"]] = 1
+    else
+      table[index["bssid"]] = table[index["bssid"]] + 1
+    end
+  end
+end
+
+-- Get BSSID from neighbour hoods over respondd
+function M.molw_get_bssid(iface)
+  -- differentiate between VPN and mesh only routers
+  local vpn_router_neighbour_bssids = {}
+  local mesh_router_neighbour_bssids = {}
+  local own_mac = uci:get('network', 'client', 'macaddr')
+  for _,respondd_if in ipairs(iface) do
+    local respondd = string.format("gluon-neighbour-info -i " ..
+    respondd_if .. " -p 1001 -d ff02::2 -r hoodselector -t 0.5")
+    print(respondd)
+    for line in io.popen(respondd, 'r'):lines() do
+      local obj, _, err = json.parse (line, 1, nil)
+      if err then
+        io.stdout:write("json parse error!\n")
+      else
+        if obj["mac"] ~= own_mac then
+          if obj["hoodinfo"] ~= nil then
+            if obj["hoodinfo"]["vpnrouter"] ~= nil then
+              if obj["hoodinfo"]["vpnrouter"]:match("true") then
+                if obj["mesh"] ~= nil then
+                  M.conditional_increment(vpn_router_neighbour_bssids, obj["mesh"])
+                end
+              else
+                if obj["mesh"] ~= nil then
+                  M.conditional_increment(mesh_router_neighbour_bssids, obj["mesh"])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  local neighbour_bssids
+  if next(vpn_router_neighbour_bssids) then
+    -- molwm VPN router founds.
+    print("Found VPN routers over mesh on lan or wan")
+    neighbour_bssids = vpn_router_neighbour_bssids
+  else
+    -- molwm VPN router not founds. Get most presented bssid
+    print("No VPN routers over mesh on lan or wan")
+    neighbour_bssids = mesh_router_neighbour_bssids
+  end
+
+  local bssid = nil
+  local value = 0
+  for b,c in pairs(neighbour_bssids) do
+    io.stdout:write(b.."\t"..c.."\n")
+    if value < c then
+      bssid = b
+      value = c
+    end
+  end
+  local eq_cost_entrys = {}
+  for b,c in pairs(neighbour_bssids) do
+    if b == bssid then
+      table.insert(eq_cost_entrys,b)
+    end
+    if c == value and b ~= bssid then
+      table.insert(eq_cost_entrys,b)
+    end
+  end
+  if #eq_cost_entrys ~= 0 then
+    bssid = eq_cost_entrys[math.random(#eq_cost_entrys)]
+  end
+  return bssid
+end
+
+function M.get_mesh_prefix(radios)
+  local mesh_prefix = nil
+  for _,radio in ipairs(radios) do
+    local mesh_id = uci:get('wireless', 'mesh_' .. radio, 'mesh_id')
+    if mesh_id ~= nil then
+      mesh_id = M.split(mesh_id, '_')
+      if mesh_id[1] ~= "" then
+        mesh_prefix = mesh_id[1].."_"
+      else
+        if mesh_id[2] ~= "" then
+          mesh_prefix = mesh_id[2].."_"
+        end
+      end
+    end
+  end
+  return mesh_prefix
+end
+
+function M.extrac_fastd_peer(s,configPeers)
+  if s['.name'] then
+    for prefix,peer in pairs(s) do
+      local tmpPeer = {}
+      if prefix:match(".name") then
+        if peer:match("mesh_vpn_backbone_peer_") then
+          -- val tmpRemote does not need uci exception check because its already include by "uci:foreach"
+          local tmpRemote = uci:get('fastd', peer, 'remote')
+          tmpRemote = M.split(tmpRemote[1], " ")
+          local remote = {}
+          remote['host'] = tmpRemote[1]
+          remote[tmpRemote[2]] = tmpRemote[3]
+          -- uci:get does not need uci exception check because its already include by "uci:foreach"
+          tmpPeer['key'] = tostring(uci:get('fastd', peer, 'key'))
+          tmpPeer['remote'] = remote
+          configPeers[peer] = tmpPeer
+        end
+      end
+    end
+  end
+end
+
+return M
diff --git a/package/gluon-hoodselector/luasrc/usr/sbin/hoodselector b/package/gluon-hoodselector/luasrc/usr/sbin/hoodselector
new file mode 100755
index 00000000..b74f0362
--- /dev/null
+++ b/package/gluon-hoodselector/luasrc/usr/sbin/hoodselector
@@ -0,0 +1,622 @@
+#!/usr/bin/lua
+
+-- This is the hoodselector. The hoodselector is one of the main components for
+-- splitting a layer 2 mesh network into seperated network segments (hoods).
+-- The job of the hoodselector is to automatically detect in which hood
+-- the router is located based on geo settings or by scanning its environment.
+-- Based on these informations the hoodselector should select a hood from a
+-- list of known hoods (hoodlist) and adjust vpn, wireless and mesh on lan
+-- configuration based on the settings given for the selected hood.
+--
+-- The hoodlist containing all hood settings is located in a seperate hoodfile
+-- in the hoods package.
+--
+-- The hoodselector works with the folowing additional software:
+--  * fastd (vpn configuration) see getCurrentFastdPeers()
+--  * tunneldigger (vpn configuration) see getCurrentTunneldiggerPeers()
+--  * iw (wireless network scanning) see get_batman_mesh_network()
+--  * batman-adv (mesh protocol) see directVPN(), get_batman_GW_interface()
+--  * respondd (mesh on LAN or WAN) see molwm()
+--
+--  To detect the current hood the hoodselector knows 5 modes containing
+--  * 1. VPN mode (VPN Router)
+--    - set hood dependent on geo position.
+--  * 2. Gateway mode
+--    - set hood dependent on gateway source
+--  * 3. Scan mode
+--    - Set wifi conf on scanned BSSID
+--    - Set vpn conf getting by BSSID (if no VPN conf exsist disable vpn)
+--  * 4. Radio less mode
+--    - Set hood via mesh on lan wan managemand
+--  * 5. Default mode
+--    - Set default hood if no other hood matchs
+
+-- When selecting a hood, the hoodselector has the following priorities:
+--   1. Selecting a hood by geo position depending on direct VPN connection.
+--   2. force creating one mesh cloud with neighbour mesh routers
+--   3. if routers had only mesh setting vpn config depends on the BSSID
+--
+-- Resources
+--  * https://wireless.wiki.kernel.org/en/users/documentation/iw
+
+-- MOLWM respondd file
+local molwmFile="/tmp/.hoodselector"
+
+local molwmtable = {}
+molwmtable["md5hash"] = ""
+molwmtable["vpnrouter"] = ""
+molwmtable["hoodname"] = ""
+molwmtable["bssid"] = ""
+
+-- PID file to ensure the hoodselector isn't running parallel
+local pidPath="/var/run/hoodselector.pid"
+
+local json = require ("luci.jsonc")
+local uci = require('simple-uci').cursor()
+local hash = require("hash")
+local hoodutil = require("hoodselector.util")
+
+if not uci:get_bool('hoodselector', 'hoodselector', 'enabled') then
+  io.stdout:write("Hoodselector is disabled by UCI\n")
+  os.exit(0)
+end
+
+if io.open(pidPath, "r") ~=nil then
+  hoodutil.log("The hoodselector is still running.")
+  os.exit(1)
+else
+  if io.open(pidPath, "w") ==nil then
+    hoodutil.log("Can`t create pid file on "..pidPath)
+    os.exit(1)
+  end
+end
+
+-- Program terminating function including removing of PID file
+local function exit(exc)
+  if io.open(pidPath, "r") ~=nil then
+    os.remove(pidPath)
+  end
+  os.exit(tonumber(exc))
+end
+
+local FILE = uci:get('hoodselector', 'hoodselector', 'hoodfile')
+if FILE == nil then
+  hoodutil.log("No hood file in config")
+  exit(1)
+end
+
+-- initialization done
+
+local function get_mesh_vpn_interface()
+  local ret = {}
+  if hoodutil.fastd_installed() then
+    local vpnifac = uci:get('fastd', 'mesh_vpn_backbone', 'net')
+    if vpnifac  ~= nil then
+      vpnifac = vpnifac:gsub("%_",'-')
+      table.insert(ret,vpnifac)
+    else
+      hoodutil.log("fastd uci config broken! abort...")
+      exit(1)
+    end
+  end
+  if hoodutil.tunneldigger_installed() then
+    local vpnifac = uci:get('tunneldigger', 'mesh_vpn', 'interface')
+    if vpnifac  ~= nil then
+      table.insert(ret,vpnifac)
+    else
+      hoodutil.log("tunneldigger uci config broken! abort...")
+      exit(1)
+    end
+  end
+  return ret
+end
+
+-- Give a list of interfaces where respondd is listening
+local function get_mesh_if(radios)
+  -- get VPN interfaces
+  local filtert_if = get_mesh_vpn_interface()
+
+  -- get Wifi interfaces
+  for _, radio in ipairs(radios) do
+    local ifname = uci:get('wireless', 'ibss_' .. radio, 'ifname')
+    if ifname ~= nil then
+      table.insert(filtert_if,ifname)
+    end
+    ifname = uci:get('wireless', 'mesh_' .. radio, 'ifname')
+    if ifname ~= nil then
+      table.insert(filtert_if,ifname)
+    end
+  end
+
+  local respondd_if = {}
+  for line in io.popen(string.format("ubus call network.interface dump | jsonfilter -e \"@.interface[@.proto='gluon_mesh' && @.up=true].device\" -e \"@.interface[@.interface='$(cat /lib/gluon/respondd/client.dev 2>/dev/null)' && @.up=true].device\""), "r"):lines() do
+    -- filter vpn and wifi interfaces
+    if not hoodutil.filt_if(filtert_if,line) then
+      table.insert(respondd_if,line)
+    end
+  end
+
+  return hoodutil.filter_redundancy(respondd_if)
+end
+
+local function molwm(radios)
+  if uci:get_bool("network", "mesh_lan", "auto") or uci:get_bool("network", "mesh_wan", "auto") then
+    local mesh_en = true
+    for _,respondd_if in ipairs(get_mesh_if(radios)) do
+      local respondd = string.format("gluon-neighbour-info -i " .. respondd_if .. " -p 1001 -d ff02::2 -r hoodselector -t 0.5")
+      for line in io.popen(respondd, 'r'):lines() do
+        local obj, _, err = json.parse (line, 1, nil)
+        if err then
+          io.stdout:write("json parse error!\n")
+          mesh_en = false
+          break
+        else
+          if obj["hoodinfo"] ~= nil then
+            if obj["mesh"] ~= nil then
+              if ( obj["mesh"]["lan"] or obj["mesh"]["wan"] ) then
+                if not ( obj["hoodinfo"]["md5hash"] == molwmtable["md5hash"]:gsub('\"', '') ) then
+                  io.stdout:write("hashes are not equal! Souce " .. respondd .. "\n")
+                  mesh_en = false
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    if uci:get('network', 'mesh_wan') then
+      local ifstatus_wan = io.popen(string.format("ifstatus mesh_wan"), 'r'):read('*a')
+      if ifstatus_wan ~= nil then
+        local wan, _, _ = json.parse (ifstatus_wan, 1, nil)
+        if wan["up"] and not mesh_en then
+          hoodutil.mesh_on_wan_disable()
+        end
+        if not wan["up"] and mesh_en then
+          hoodutil.mesh_on_wan_enable()
+        end
+      end
+    end
+    if uci:get('network', 'mesh_lan') then
+      local ifstatus_lan = io.popen(string.format("ifstatus mesh_lan"), 'r'):read('*a')
+      if ifstatus_lan ~= nil then
+        local lan, _, _ = json.parse (ifstatus_lan, 1, nil)
+        if lan["up"] and not mesh_en then
+          hoodutil.mesh_on_lan_disable()
+        end
+        if not lan["up"] and mesh_en then
+          hoodutil.mesh_on_lan_enable()
+        end
+      end
+    end
+  end
+end
+
+function table.val_to_str ( v )
+  if "string" == type( v ) then
+    v = string.gsub( v, "\n", "\\n" )
+    if string.match( string.gsub(v,"[^'\"]",""), '^"+$' ) then
+      return "'" .. v .. "'"
+    end
+    return '"' .. string.gsub(v,'"', '\\"' ) .. '"'
+  else
+    return "table" == type( v ) and table.tostring( v ) or tostring( v )
+  end
+end
+
+function table.key_to_str ( k )
+  if "string" == type( k ) and string.match( k, "^[_%a][_%a%d]*$" ) then
+    return k
+  else
+    return "[" .. table.val_to_str( k ) .. "]"
+  end
+end
+
+function table.tostring( tbl )
+  local result, done = {}, {}
+  for k, v in ipairs( tbl ) do
+    table.insert( result, table.val_to_str( v ) )
+    done[ k ] = true
+  end
+  for k, v in pairs( tbl ) do
+    if not done[ k ] then
+      table.insert( result, table.key_to_str( k ) .. "=" .. table.val_to_str( v ) )
+    end
+  end
+  return "{" .. table.concat( result, "," ) .. "}"
+end
+
+local function molwm_to_file()
+  local file = io.open(molwmFile, "w")
+  if not file then
+    hoodutil.log(molwmFile ..' not found or not createble!')
+  else
+    file:write("\"md5hash\": " .. molwmtable["md5hash"] .. "\n")
+    file:write("\"vpnrouter\": " .. molwmtable["vpnrouter"] .. "\n")
+    file:write("\"hoodname\": " .. molwmtable["hoodname"] .. "\n")
+    file:write("\"bssid\": " .. molwmtable["bssid"] .. "\n")
+    file:close()
+  end
+end
+
+-- Write MOLWM content into file
+local function write_molwm(hood,radios)
+  if hood ~= nil then
+    molwmtable["md5hash"] = "\"" .. string.format(hash.md5(table.tostring(hood))) .. "\""
+    molwmtable["hoodname"] = "\"" .. hood["name"] .. "\""
+    molwmtable["bssid"] = "\"" .. hood["bssid"] .. "\""
+  end
+  molwm(radios)
+  molwm_to_file()
+end
+
+-- bool if direct VPN. The detection is realaise by searching the fastd network interface inside the originator table
+local function directVPN()
+  local vpnIfaceList = get_mesh_vpn_interface()
+  for _,vpnIface in ipairs(vpnIfaceList) do
+    local file = io.open("/sys/kernel/debug/batman_adv/bat0/originators", 'r')
+    if file ~= nil then
+      for outgoingIF in file:lines() do
+        -- escape special chars "[]-"
+        if outgoingIF:match(string.gsub("%[  " .. vpnIface .. "%]","%-", "%%-")) then
+          molwmtable["vpnrouter"] = "\"true\""
+          return true
+        end
+      end
+    end
+  end
+  molwmtable["vpnrouter"] = "\"false\""
+  return false
+end
+
+-- Retun a table of current peers from /etc/config/fastd
+local function getFastdCurrentPeers()
+  local configPeers = {}
+  local err = uci:foreach('fastd', 'peer',
+    function(s)
+      hoodutil.extrac_fastd_peer(s,configPeers)
+    end
+  )
+  if not err then
+    hoodutil.log("fastd uci config broken! abort...")
+    exit(1)
+  end
+  return configPeers
+end
+
+-- Retun a table of current peers from /etc/config/tunneldigger
+local function getTunneldiggerCurrentPeers()
+  local configPeers = {}
+  local err = uci:foreach('tunneldigger', 'broker',
+    function(s)
+      if s["address"] then
+        for _, peer in pairs(s["address"]) do
+          table.insert(configPeers, peer)
+        end
+      end
+    end
+  )
+  if not err then
+    hoodutil.log("tunneldigger uci config broken! abort...")
+    exit(1)
+  end
+  return configPeers
+end
+
+-- This method sets a new hoodconfig and takes care that services are only
+-- stopped or restarted if reconfiguration is needed.
+-- Process:
+--   * Check if wireless needs reconfiguration and prepare reconfiguration
+--   * Check if vpn needs reconfiguration and prepare reconfiguration
+--   * If vpn needs reconfiguration, stop vpn and apply new settings but
+--     dont restart it before wireless has been reconfigured
+--   * If wireless needs reconfiguration apply new settings and restart wireless
+--   * If vpn needed reconfiguration start fastd now
+local function set_hoodconfig(hood, prefix, radios)
+  local fastd_serverlist = {}
+  local fastd_reconf_needed = false
+  local tunneldigger_reconf_needed = false
+
+  -- pre check if fastd conf exsist
+  if uci:get('fastd', 'mesh_vpn_backbone', 'net') ~= nil then
+    fastd_serverlist = getFastdCurrentPeers()
+    -- Check if fastd needs reconfiguration because in case of reconfiguration we
+    -- need to stop fastd before we can reconfigure any other connection.
+    fastd_reconf_needed = hoodutil.fastd_reconfiguration_needed(hood["servers"], fastd_serverlist);
+  else
+    -- check if fastd uci conf broken
+    if hoodutil.fastd_installed() then
+      hoodutil.log("fastd uci config broken! abort...")
+      exit(1)
+    end
+  end
+
+  -- per check if tunneldigger conf exsist
+  if uci:get('tunneldigger', 'mesh_vpn', 'interface') ~= nil then
+    local tunneldigger_serverlist = getTunneldiggerCurrentPeers()
+    tunneldigger_reconf_needed = hoodutil.tunneldigger_reconfiguration_needed(hood["servers"], tunneldigger_serverlist)
+  else
+    -- check if tunneldigger uci conf broken
+    if hoodutil.tunneldigger_installed() then
+      hoodutil.log("tunneldigger uci config broken! abort...")
+      exit(1)
+    end
+  end
+
+  if fastd_reconf_needed or tunneldigger_reconf_needed then
+    hoodutil.vpn_stop()
+  end
+
+  -- reconfigure wireless
+  local wifi_reconf = hoodutil.wireless_reconfiguration_needed(radios, prefix, hood["bssid"])
+  if(wifi_reconf == 1 or wifi_reconf == 3) then
+    hoodutil.ibss_reconfigure(radios, hood["bssid"])
+    hoodutil.wireless_restart()
+    io.stdout:write('IBSS needed reconfiguration. Applied new settings and restarted.\n')
+  end
+  if(wifi_reconf == 2 or wifi_reconf == 3) then
+    hoodutil.mesh_reconfigure(radios, prefix..hood["bssid"]:lower())
+    hoodutil.wireless_restart()
+    io.stdout:write('MESH needed reconfiguration. Applied new settings and restarted.\n')
+  end
+
+  -- reconfigure fastd
+  if fastd_reconf_needed then
+    hoodutil.fastd_reconfigure(hood["servers"],fastd_serverlist)
+    io.stdout:write('fastd needed reconfiguration. Applied new settings and restarted.\n')
+  end
+
+  if tunneldigger_reconf_needed then
+    hoodutil.tunneldigger_reconfigure(hood["servers"])
+    io.stdout:write('tunneldigger needed reconfiguration. Applied new settings and restarted.\n')
+  end
+
+  if fastd_reconf_needed or tunneldigger_reconf_needed then
+    -- scan mode can disable VPN so we need to make shure that VPN is enabled
+    -- if the router selects a hood
+    hoodutil.vpn_enable()
+    hoodutil.vpn_start()
+  end
+
+  io.stdout:write("Set hood \""..hood["name"].."\"\n")
+  molwmtable["hoodname"] = "\"" .. hood["name"] .. "\""
+
+  if(uci:get('hoodselector', 'hoodselector' , 'hood') ~= hood["bssid"]) then
+    hoodutil.saveHoodToConfig(hood["bssid"])
+  end
+  return true
+end
+
+-- INITIALIZE AND PREPARE DATA --
+-- read hoodfile, exit if reading the hoodfile fails
+local jhood = hoodutil.readHoodfile(FILE)
+if jhood == nil then
+  hoodutil.log('There seems to have gone something wrong while reading hoodfile from ' .. FILE)
+  exit(1)
+end
+
+-- check if a default hood has been defined and exit if none has been defined
+local defaultHood = hoodutil.getDefaultHood(jhood)
+if defaultHood == nil then
+  hoodutil.log('No defaulthood defined.')
+  exit(1)
+end
+
+-- Get list of wifi devices
+local radios = hoodutil.getWifiDevices()
+
+local mesh_prefix = hoodutil.get_mesh_prefix(radios)
+
+-- VPN MODE
+-- If we have a VPN connection then we will try to get the routers location and
+-- select the hood coresponding to our location.
+-- If no hood for the location has been defined, we will select
+-- the default hood.
+-- If we can not get our routers location, we will fallback to scan mode.
+if directVPN() then
+  io.stdout:write('VPN connection found.\n')
+  local geo = hoodutil.getGeolocation()
+  if geo.lat ~= nil and geo.lon ~= nil then
+    io.stdout:write('Position found.\n')
+    local geoHood = hoodutil.getHoodByGeo(jhood, geo)
+    if geoHood ~= nil then
+      set_hoodconfig(geoHood, mesh_prefix, radios)
+      io.stdout:write('Hood set by VPN mode.\n')
+      write_molwm(geoHood,radios)
+      exit(0)
+    end
+    io.stdout:write('No hood has been defined for current position.\n')
+  else
+    io.stdout:write('No position found\n')
+  end
+  set_hoodconfig(defaultHood, mesh_prefix, radios)
+  io.stdout:write('Set defaulthood.\n')
+  write_molwm(defaultHood,radios)
+  exit(0)
+else
+  io.stdout:write('No VPN connection found\n')
+end
+
+if hoodutil.batmanHasGateway() then
+  io.stdout:write('Batman gateways found\n')
+  local gw_intf = {}
+  table.insert(gw_intf,hoodutil.get_batman_GW_interface())
+
+  if next(gw_intf) then
+    -- wifi interface
+    local bssidHood = hoodutil.get_radio_to_bssid(radios,gw_intf[1], jhood)
+    if bssidHood ~= nil then
+      --check if hood inside geo pos
+      local geo = hoodutil.getGeolocation()
+      if geo.lat ~= nil and geo.lon ~= nil then
+       io.stdout:write('Position found.\n')
+       local geoHood = hoodutil.getHoodByGeo(jhood, geo)
+       if geoHood ~= nil then
+         if string.format(hash.md5(table.tostring(bssidHood))) ~= string.format(hash.md5(table.tostring(geoHood))) then
+           io.stdout:write('Geo hood and bssid hood are not equal, do wifi scan...\n')
+           local sortedWlanList = hoodutil.wlan_list_sorted(radios, mesh_prefix)
+           for i=#sortedWlanList,1,-1 do
+             if(string.lower(geoHood.bssid) ~= string.lower(sortedWlanList[i].bssid)) then
+              table.remove(sortedWlanList, i)
+             end
+           end
+           if next(sortedWlanList) then
+             io.stdout:write('Try to switch back in our real hood!\n')
+             io.stdout:write('After filtering we will test the following wireless networks:\n')
+             for _, network in pairs(sortedWlanList) do
+              print(network["quality"].."\t"..network["frequency"].."\t"..network["bssid"].."\t"..network["ssid"])
+             end
+             io.stdout:write("Prepare configuration for testing wireless networks...\n")
+             local bssid = hoodutil.test_batman_mesh_networks(sortedWlanList, mesh_prefix)
+             hoodutil.wireless_restart()
+             io.stdout:write("Finished testing wireless networks, restored previous configuration\n")
+             if bssid ~= nil then
+              set_hoodconfig(geoHood, mesh_prefix, radios)
+              hoodutil.vpn_enable()
+              hoodutil.vpn_start()
+              io.stdout:write('Set Geo Hood by Gateway mode\n')
+              write_molwm(geoHood, radios)
+              exit(0)
+             else
+              io.stdout:write('No neighboring freifunk batman advanced mesh found.\n')
+             end
+           else
+             io.stdout:write('No networks left after filtering!\n')
+           end --end next(sortedWlanList)
+         else
+           io.stdout:write('Geo hood are equal to bssid hood no wifi scan necessary.\n')
+         end --end bssidHood ~= geoHood
+       else
+         io.stdout:write('No hood has been defined for current position.\n')
+       end --end geoHood ~= nil
+      else
+       io.stdout:write('No position found.\n')
+      end --end geo.lat ~= nil and geo.lon ~= nil
+      set_hoodconfig(bssidHood, mesh_prefix, radios)
+      io.stdout:write('Hood set by batmanHasGateway mode, GW source is wifi\n')
+      write_molwm(bssidHood,radios)
+      exit(0)
+    end --end bssidHood ~= nil
+
+    -- mesh lan or wan interface
+    if hoodutil.mesh_lan_wan(gw_intf[1]) then
+      -- if mesh_lan/wan try to get hood by selected bssid of neightbour vpnRouters
+      local neighbourBssid = hoodutil.molw_get_bssid(gw_intf)
+      if neighbourBssid ~= nil then
+        bssidHood = hoodutil.gethoodByBssid(jhood, neighbourBssid)
+        if bssidHood ~= nil then
+          set_hoodconfig(bssidHood, mesh_prefix, radios)
+          io.stdout:write('Hood set by batmanHasGateway mode, GW source is mesh on lan/wan\n')
+          molwmtable["md5hash"] = "\"" .. string.format(hash.md5(table.tostring(bssidHood))) .. "\""
+          molwmtable["hoodname"] = "\"" .. bssidHood["name"] .. "\""
+          molwmtable["bssid"] = "\"" .. bssidHood["bssid"] .. "\""
+          molwm_to_file()
+          exit(0)
+        end
+      end
+    end
+  end --end next(gw_intf)
+  local currendHood = hoodutil.getCurrentHood(jhood)
+  if currendHood ~= nil then
+    write_molwm(currendHood,radios)
+  end
+end
+
+-- SCAN MODE
+if next(radios) then
+  -- check if there exist a neighbouring freifunk batman advanced mesh
+  -- network with an active connection to a batman advanced gateway
+  local sortedWlanList = hoodutil.wlan_list_sorted(radios, mesh_prefix)
+  local meshBSSID = hoodutil.get_batman_mesh_network(sortedWlanList, defaultHood, mesh_prefix)
+  if meshBSSID ~= nil then
+    io.stdout:write("Neighoring freifunk batman advanced mesh with BSSID "..meshBSSID.." found\n")
+    local bssidHood = hoodutil.gethoodByBssid(jhood, meshBSSID)
+    if bssidHood ~= nil then
+      set_hoodconfig(bssidHood, mesh_prefix, radios)
+      io.stdout:write('Hood set by scan mode\n')
+      write_molwm(bssidHood,radios)
+      exit(0)
+    end
+
+    -- if the bssid does not corespond to any hood, we disable vpn and
+    -- just establish a wireless connection to the mesh without any vpn or
+    hoodutil.vpn_stop()
+    hoodutil.vpn_disable()
+    local ibss_exists = false
+    local mesh_exists = false
+    for _,radio in ipairs(radios) do
+      local ifname = uci:get('wireless', 'ibss_' .. radio, 'ifname')
+      if (ifname ~= nil) then
+        ibss_exists = true
+      end
+      ifname = uci:get('wireless', 'mesh_' .. radio, 'ifname')
+      if (ifname ~= nil) then
+        mesh_exists = true
+      end
+    end
+    if ibss_exists then
+      hoodutil.ibss_reconfigure(radios, meshBSSID)
+    end
+    if mesh_exists then
+      hoodutil.mesh_reconfigure(radios, mesh_prefix..meshBSSID:lower())
+    end
+    hoodutil.wireless_restart()
+    io.stdout:write('Could not select a hood but established a connection via wireless mesh.\n')
+    io.stdout:write('Disabled all connections except connections via wireless mesh.\n')
+    exit(0)
+  end
+  io.stdout:write('No neighbouring freifunk batman advanced mesh found.\n')
+end
+
+--Radio less router have mesh lan/wan neighbours
+local mesh_inf = get_mesh_if(radios);
+if next(mesh_inf) then
+  local wait_for_mesh_lan_wan = false
+  if uci:get('network', 'mesh_wan') then
+    local ifstatus_wan = io.popen(string.format("ifstatus mesh_wan"), 'r'):read('*a')
+    if ifstatus_wan ~= nil then
+      local wan, _, _ = json.parse (ifstatus_wan, 1, nil)
+      if not wan["up"] and uci:get_bool("network", "mesh_wan", "auto") then
+        hoodutil.mesh_on_wan_enable()
+        wait_for_mesh_lan_wan = true
+      end
+    end
+  end
+  if uci:get('network', 'mesh_lan') then
+    local ifstatus_lan = io.popen(string.format("ifstatus mesh_lan"), 'r'):read('*a')
+    if ifstatus_lan ~= nil then
+      local lan, _, _ = json.parse (ifstatus_lan, 1, nil)
+      if not lan["up"] and uci:get_bool("network", "mesh_lan", "auto") then
+        hoodutil.mesh_on_lan_enable()
+        wait_for_mesh_lan_wan = true
+      end
+    end
+  end
+  -- wait for network delay
+  if wait_for_mesh_lan_wan then
+    hoodutil.sleep(5)
+  end
+  local neighbourBssid = hoodutil.molw_get_bssid(mesh_inf)
+  if neighbourBssid ~= nil then
+    local bssidHood = hoodutil.gethoodByBssid(jhood, neighbourBssid)
+    if bssidHood ~= nil then
+      set_hoodconfig(bssidHood, mesh_prefix, radios)
+      io.stdout:write('Hood set by "Radio less router have mesh lan/wan neighbours"\n')
+      molwmtable["md5hash"] = "\"" .. string.format(hash.md5(table.tostring(bssidHood)    )) .. "\""
+      molwmtable["hoodname"] = "\"" .. bssidHood["name"] .. "\""
+      molwmtable["bssid"] = "\"" .. bssidHood["bssid"] .. "\""
+      molwm_to_file()
+      exit(0)
+    end
+  end
+  io.stdout:write('No molwm neighbours found\n')
+end
+
+-- DEFAULT-HOOD MODE
+-- If we do NOT have a VPN connection AND found no freifunk mesh network while
+-- scanning then we set the default hood if no current hood set.
+io.stdout:write("ENV does not give enough information set default hood\n")
+set_hoodconfig(defaultHood, mesh_prefix, radios)
+io.stdout:write('Set defaulthood.\n')
+write_molwm(defaultHood,radios)
+exit(0)
diff --git a/package/gluon-hoodselector/src/Makefile b/package/gluon-hoodselector/src/Makefile
new file mode 100644
index 00000000..3ddc8a58
--- /dev/null
+++ b/package/gluon-hoodselector/src/Makefile
@@ -0,0 +1,6 @@
+all: respondd.so
+
+CFLAGS += -Wall
+
+respondd.so: respondd.c
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -shared -fPIC -D_GNU_SOURCE -o $@ $^ $(LDLIBS) -lgluonutil -luci
diff --git a/package/gluon-hoodselector/src/respondd.c b/package/gluon-hoodselector/src/respondd.c
new file mode 100644
index 00000000..cc864a1c
--- /dev/null
+++ b/package/gluon-hoodselector/src/respondd.c
@@ -0,0 +1,139 @@
+#include <respondd.h>
+#include <json-c/json.h>
+#include <libgluonutil.h>
+#include <uci.h>
+#include <string.h>
+#include <net/if.h>
+
+#define _STRINGIFY(s) #s
+#define STRINGIFY(s) _STRINGIFY(s)
+
+bool strstw(const char *pre, const char *str) {
+	size_t lenpre = strlen(pre);
+	return strlen(str) < lenpre ? false : strncmp(pre, str, lenpre) == 0;
+}
+
+bool strrmbs(char *line, int begin, int end) { // <- ist es hier sinvoller pointer auf die ints zu setzen??
+	size_t len = strlen(line);
+	if (len < begin)
+		return false;
+
+	memmove(line, line+begin, len - begin + 1);
+	if (len < end)
+		return false;
+
+	line[len-end] = 0; //remove val of end characters on the end
+	return true;
+}
+
+// extract hood informations
+static struct json_object * get_hoodselector(void) {
+	FILE *f = fopen("/tmp/.hoodselector", "r");
+	if (!f)
+		return NULL;
+
+	struct json_object *ret = json_object_new_object();
+	char *line = NULL;
+	size_t len = 0;
+	while (getline(&line, &len, f) >= 0) {
+		//1. Get md5 hash from current selected hood.
+		if (strstw("\"md5hash\": ",line)) {
+			if (!strrmbs(line, 12, 14))
+				continue;
+
+			json_object_object_add(ret, "md5hash", gluonutil_wrap_string(line));
+		}
+		//2. Get true or false string for VPN Router.
+		if (strstw("\"vpnrouter\": ",line)) {
+			if (!strrmbs(line, 14, 16))
+				continue;
+
+			json_object_object_add(ret, "vpnrouter", gluonutil_wrap_string(line));
+		}
+		//3. Get hoodname
+		if (strstw("\"hoodname\": ",line)) {
+			if (!strrmbs(line, 13, 15))
+				continue;
+
+			json_object_object_add(ret, "hoodname", gluonutil_wrap_string(line));
+		}
+	}
+	free(line);
+	fclose(f);
+	return ret;
+}
+
+//Get uci mesh on lan wan
+static struct json_object * get_mesh_on_lan_wan(void){
+	struct uci_context *ctx = uci_alloc_context();
+	ctx->flags &= ~UCI_FLAG_STRICT;
+	struct uci_package *p;
+
+	if (!uci_load(ctx, "wireless", &p)) {
+		struct uci_element *e;
+		uci_foreach_element(&p->sections, e) {
+			struct uci_section *s = uci_to_section(e);
+			if (strcmp(s->type, "wifi-iface"))
+				continue;
+
+			if (strncmp(e->name, "ibss_", 5))
+				continue;
+
+			const char *bssid = uci_lookup_option_string(ctx, s, "bssid");
+			if (!bssid)
+				continue;
+
+			struct json_object *ret = json_object_new_object();
+			json_object_object_add(ret, "bssid", gluonutil_wrap_string(bssid));
+			free((char*)bssid);
+			if(ret) {
+				uci_free_context(ctx);
+				return ret;
+			}
+		}
+	}
+	uci_free_context(ctx);
+	FILE *f = fopen("/tmp/.hoodselector", "r");
+	if (!f)
+		return NULL;
+
+	struct json_object *ret = json_object_new_object();
+	char *line = NULL;
+	size_t len = 0;
+	while (getline(&line, &len, f) >= 0) {
+		//Get bssid from current selected hood.
+		if (strstw("\"bssid\": ",line)) {
+			if (!strrmbs(line, 10, 12))
+				continue;
+			json_object_object_add(ret, "bssid", gluonutil_wrap_string(line));
+			free(line);
+			fclose(f);
+			return ret;
+		}
+	}
+	free(line);
+	fclose(f);
+	return NULL;
+}
+
+// create final obj with logical structure
+static struct json_object * respondd_provider_hoodselector(void) {
+	struct json_object *ret = json_object_new_object();
+
+	struct json_object *hoodinfo = get_hoodselector();
+	if(hoodinfo)
+		json_object_object_add(ret, "hoodinfo", hoodinfo);
+
+	struct json_object *mesh_on_lan_wan = get_mesh_on_lan_wan();
+	if(mesh_on_lan_wan)
+		 json_object_object_add(ret, "mesh", mesh_on_lan_wan);
+
+	json_object_object_add(ret, "mac", gluonutil_wrap_and_free_string(gluonutil_get_sysconfig("primary_mac")));
+	return ret;
+}
+
+// related to respondd_provider_hoodselector
+const struct respondd_provider_info respondd_providers[] = {
+	{"hoodselector", respondd_provider_hoodselector},
+	{}
+};
-- 
2.15.1