0005-add-pkg-gluon-hoodselector.patch

From bfb90653c70a1f9c9573b4d0b4efc48702320f62 Mon Sep 17 00:00:00 2001
From: Jan-Tarek Butt <tarek@ring0.de>
Date: Mon, 18 Sep 2017 18:20:28 +0200
Subject: [PATCH 5/5] add pkg gluon-hoodselector

 * add pkg Makefile
 * add respondd c file
 * add respondd Makefile
 * add etc config
 * add micron.d file
 * add upgrade script 540-hoodselector
 * add hoodselector lua script
 * rm gluon-hoods and gluon-mesh-vpn-fastd from DEPENDS
 * config rm static option
 * backport tested comunity version:
   - Hoodselector: is now able to handle Polygon hoods. !60
   - Hoodselector: does not use `scan dump` anymore which
                   saved airtime
   - Hoodselector: L2TP tunneldigger support #47
   - Hoodselector: the upgrade script got a refactoring.
                   Dead code is removed. desing failuer is
                   fixed, the script use the hood BSSID
                   instead the possible redundant hood name
                   for hood identification. #107
   - Hoodselector: New state, a router from hood A which is
                   connected to an another router from hood B
                   is now able to switch back in its own hood
                   if a router from hood A viseble. #108
   - Hoodselector: in state "radio less" is now ensured that
                   mesh on LAN / WAN is enabled befor entering
                   mode. #109
   - Hoodselector: A bug in the function get_mesh_if() is
                   fixed now. This function returns now a list
                   of all mesh interfaces exzept the VPN
                   interface #116
   - Hoodselector: Old VPN configurations will be deleted now.
                   If a hood without VPN peers got configured
                   the old peers from the old hood was still
                   presend. #117
   - Hoodselector: many functions of the hoodselector are now
                   placed in a lua libary. #118
---
 package/gluon-hoodselector/Makefile                |  43 +
 .../files/etc/config/hoodselector                  |   3 +
 .../files/usr/lib/micron.d/hoodselector            |   1 +
 .../luasrc/lib/gluon/upgrade/540-hoodselector      |  88 ++
 .../luasrc/usr/lib/lua/hoodselector/util.lua       | 898 +++++++++++++++++++++
 .../luasrc/usr/sbin/hoodselector                   | 622 ++++++++++++++
 package/gluon-hoodselector/src/Makefile            |   6 +
 package/gluon-hoodselector/src/respondd.c          | 139 ++++
 8 files changed, 1800 insertions(+)
 create mode 100644 package/gluon-hoodselector/Makefile
 create mode 100644 package/gluon-hoodselector/files/etc/config/hoodselector
 create mode 100644 package/gluon-hoodselector/files/usr/lib/micron.d/hoodselector
 create mode 100755 package/gluon-hoodselector/luasrc/lib/gluon/upgrade/540-hoodselector
 create mode 100644 package/gluon-hoodselector/luasrc/usr/lib/lua/hoodselector/util.lua
 create mode 100755 package/gluon-hoodselector/luasrc/usr/sbin/hoodselector
 create mode 100644 package/gluon-hoodselector/src/Makefile
 create mode 100644 package/gluon-hoodselector/src/respondd.c

diff --git a/package/gluon-hoodselector/Makefile b/package/gluon-hoodselector/Makefile
new file mode 100644
index 00000000..210e5200
--- /dev/null
+++ b/package/gluon-hoodselector/Makefile
@@ -0,0 +1,43 @@
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=gluon-hoodselector
+PKG_VERSION:=1
+PKG_RELEASE:=1
+
+PKG_BUILD_DIR := $(BUILD_DIR)/$(PKG_NAME)
+PKG_BUILD_DEPENDS := respondd
+
+include ../gluon.mk
+
+define Package/gluon-hoodselector
+  SECTION:=network
+  CATEGORY:=Gluon
+  TITLE:=Automatic layer2 networksecmentation depending on geo coordinates
+  DEPENDS:=+luci-lib-jsonc +gluon-mesh-batman-adv-15 +respondd +iwinfo
+endef
+
+define Package/gluon-hoodselector/description
+	Automatic layer2 networksecmentation depending on geo coordinates
+endef
+
+define Build/Prepare
+	mkdir -p $(PKG_BUILD_DIR)
+	$(CP) ./src/* $(PKG_BUILD_DIR)/
+endef
+
+define Build/Configure
+endef
+
+define Build/Compile
+	$(call Build/Compile/Default)
+	$(call GluonSrcDiet,./luasrc,$(PKG_BUILD_DIR)/luadest/)
+endef
+
+define Package/gluon-hoodselector/install
+	$(CP) ./files/* $(1)/
+	$(CP) $(PKG_BUILD_DIR)/luadest/* $(1)/
+	$(INSTALL_DIR) $(1)/lib/gluon/respondd
+	$(CP) $(PKG_BUILD_DIR)/respondd.so $(1)/lib/gluon/respondd/hoodselector.so
+endef
+
+$(eval $(call BuildPackage,gluon-hoodselector))
diff --git a/package/gluon-hoodselector/files/etc/config/hoodselector b/package/gluon-hoodselector/files/etc/config/hoodselector
new file mode 100644
index 00000000..24b2800c
--- /dev/null
+++ b/package/gluon-hoodselector/files/etc/config/hoodselector
@@ -0,0 +1,3 @@
+config settings 'hoodselector'
+    option hoodfile '/lib/gluon/hoods.json'
+    option enabled '1'
diff --git a/package/gluon-hoodselector/files/usr/lib/micron.d/hoodselector b/package/gluon-hoodselector/files/usr/lib/micron.d/hoodselector
new file mode 100644
index 00000000..a4c9916d
--- /dev/null
+++ b/package/gluon-hoodselector/files/usr/lib/micron.d/hoodselector
@@ -0,0 +1 @@
+*/2 * * * * /usr/sbin/hoodselector 2>> /tmp/hoodselector_error
diff --git a/package/gluon-hoodselector/luasrc/lib/gluon/upgrade/540-hoodselector b/package/gluon-hoodselector/luasrc/lib/gluon/upgrade/540-hoodselector
new file mode 100755
index 00000000..a0fe8d65
--- /dev/null
+++ b/package/gluon-hoodselector/luasrc/lib/gluon/upgrade/540-hoodselector
@@ -0,0 +1,88 @@
+#!/usr/bin/lua
+
+local uci = require('simple-uci').cursor()
+local hoodutil = require("hoodselector.util")
+
+-- Retun a table of current peers from /etc/config/fastd
+local function getCurrentPeers()
+  local configPeers = {}
+  local err = uci:foreach('fastd', 'peer',
+    function(s)
+      hoodutil.extrac_fastd_peer(s,configPeers)
+    end
+  )
+  if not err then
+    os.exit(1)
+  end
+  return configPeers
+end
+
+-- START HERE
+local hoodfile = uci:get('hoodselector', 'hoodselector', 'hoodfile')
+local hoodbssid = uci:get('hoodselector', 'hoodselector', 'hood')
+
+if hoodfile == nil then
+  os.exit(1)
+end
+
+local jhood = hoodutil.readHoodfile(hoodfile)
+if jhood == nil then
+  uci:set('hoodselector', 'hoodselector', 'enabled', false)
+  uci:save('hoodselector')
+  os.exit(1)
+end
+
+if hoodbssid == nil then
+  local defaulthood = hoodutil.getDefaultHood(jhood)
+  if defaulthood == nil then
+    os.exit(1)
+  end
+  if defaulthood.bssid == nil then
+    os.exit(1)
+  end
+  hoodbssid = defaulthood.bssid
+end
+
+local hood = hoodutil.gethoodByBssid(jhood,hoodbssid)
+if hood == nil then
+  os.exit(1)
+end
+
+uci:section('hoodselector', 'settings', 'hoodselector', {
+  hood = hoodbssid,
+  hoodfile = hoodfile,
+  enabled = true
+})
+uci:save('hoodselector')
+
+local radios = hoodutil.getWifiDevices()
+-- pre check if fastd conf exsist
+if uci:get('fastd', 'mesh_vpn_backbone', 'net') ~= nil then
+  hoodutil.fastd_reconfigure(hood["servers"],getCurrentPeers())
+end
+-- per check if tunneldigger conf exsist
+if uci:get('tunneldigger', 'mesh_vpn', 'interface') ~= nil then
+  hoodutil.tunneldigger_reconfigure(hood["servers"])
+end
+
+if next(radios) then
+  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, hood["bssid"])
+  end
+  if mesh_exists then
+    local mesh_prefix = hoodutil.get_mesh_prefix(radios)
+    hoodutil.mesh_reconfigure(radios, mesh_prefix..hood["bssid"]:lower())
+  end
+end
diff --git a/package/gluon-hoodselector/luasrc/usr/lib/lua/hoodselector/util.lua b/package/gluon-hoodselector/luasrc/usr/lib/lua/hoodselector/util.lua
new file mode 100644
index 00000000..05678809
--- /dev/null
+++ b/package/gluon-hoodselector/luasrc/usr/lib/lua/hoodselector/util.lua
@@ -0,0 +1,898 @@
+local json = require ("luci.jsonc")
+local uci = require('simple-uci').cursor()
+
+local M = {}
+
+function M.split(s, delimiter)
+  local result = {};
+  for match in (s..delimiter):gmatch("(.-)"..delimiter) do
+    table.insert(result, match);
+  end
+  return result;
+end
+
+local PID = M.split(io.open("/proc/self/stat", 'r'):read('*a'), " ")[1]
+
+function M.log(msg)
+  if msg then
+    io.stdout:write(msg.."\n")
+    os.execute("logger hoodselector["..PID.."]: "..msg)
+  end
+end
+
+-- Read the full hoodfile. Return nil for wrong format or no such file
+function M.readHoodfile(file)
+  local jhood = io.open(file, 'r')
+  if not jhood then return nil end
+  local obj, _, err = json.parse (jhood:read('*a'), 1, nil)
+  if err then
+    return nil
+  else
+    return obj
+  end
+end
+
+function M.mesh_on_wan_disable()
+  os.execute('ifdown mesh_wan')
+  io.stdout:write('Interface mesh_wan disabled.\n')
+end
+
+function M.mesh_on_wan_enable()
+  os.execute('ifup mesh_wan')
+  io.stdout:write('Interface mesh_wan enabled.\n')
+end
+
+function M.mesh_on_lan_disable()
+  os.execute('ifdown mesh_lan')
+  io.stdout:write('Interface mesh_lan disabled.\n')
+end
+
+function M.mesh_on_lan_enable()
+  os.execute('ifup mesh_lan')
+  io.stdout:write('Interface mesh_lan enabled.\n')
+end
+
+function M.fastd_installed()
+  if io.open("/usr/bin/fastd", 'r') ~= nil then
+    return true
+  end
+  return false
+end
+
+function M.tunneldigger_installed()
+  if io.open("/usr/bin/tunneldigger", 'r') ~= nil then
+    return true
+  end
+  return false
+end
+
+function M.filt_if(filt,str)
+  for _, c in ipairs(filt) do
+    -- check if - is contains because it is a magic character thus it musst be replace)
+    if c:gsub("%-", "0"):match(str:gsub("%-", "0")) then
+      return true
+    end
+  end
+  return false
+end
+
+function M.filter_redundancy(list)
+  local flag = {}
+  local ret = {}
+  for _,element in ipairs(list) do
+    if not flag[element] then
+      ret[#ret+1] = element
+      flag[element] = true
+    end
+  end
+  return ret
+end
+
+function M.trim(s)
+  -- from PiL2 19.4
+  return (s:gsub("^%s*(.-)%s*$", "%1"))
+end
+
+function M.sleep(n)
+  os.execute("sleep " .. tonumber(n))
+end
+
+function M.brclient_restart()
+  os.execute('ifconfig br-client down')
+  os.execute('ifconfig br-client up')
+  io.stdout:write('Interface br-client restarted.\n')
+end
+
+function M.vpn_stop()
+  -- check if fastd installed
+  if M.fastd_installed() then
+    if uci:get_bool('fastd','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/fastd stop')
+      io.stdout:write('Fastd stoped.\n')
+    end
+  end
+  -- check if tunneldigger installed
+  if M.tunneldigger_installed() then
+    if uci:get_bool('tunneldigger','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/tunneldigger stop')
+      io.stdout:write('Tunneldigger stoped.\n')
+    end
+  end
+end
+
+function M.vpn_start()
+  if M.fastd_installed() then
+    if uci:get_bool('fastd','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/fastd start')
+      io.stdout:write('Fastd started.\n')
+    end
+  end
+  if M.tunneldigger_installed() then
+    if uci:get_bool('tunneldigger','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/tunneldigger start')
+      io.stdout:write('Tunneldigger started.\n')
+    end
+  end
+  M.brclient_restart()
+end
+
+function M.vpn_disable()
+  if M.fastd_installed() then
+    if uci:get_bool('fastd','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/fastd disable')
+      io.stdout:write('Fastd disabled.\n')
+    end
+  end
+  if M.tunneldigger_installed() then
+    if uci:get_bool('tunneldigger','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/tunneldigger disable')
+      io.stdout:write('Tunneldigger disabled.\n')
+    end
+  end
+end
+
+function M.vpn_enable()
+  if M.fastd_installed() then
+    if not uci:get_bool('fastd','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/fastd enable')
+      io.stdout:write('Fastd enabled.\n')
+    end
+  end
+  if M.tunneldigger_installed() then
+    if not uci:get_bool('tunneldigger','mesh_vpn','enabled') then
+      os.execute('/etc/init.d/tunneldigger enable')
+      io.stdout:write('Tunneldigger enabled.\n')
+    end
+  end
+end
+
+function M.wireless_restart()
+  os.execute('wifi')
+  io.stdout:write('Wireless restarted.\n')
+end
+
+-- Get a list of wifi devices return an emty table for no divices
+function M.getWifiDevices()
+  local radios = {}
+  uci:foreach('wireless', 'wifi-device',
+    function(s)
+      table.insert(radios, s['.name'])
+    end
+  )
+  return radios
+end
+
+-- get signal strength
+function M.scan_filter_quality(scan_str, redirect)
+  local tmp_quality = redirect
+  if scan_str:match("signal:") then
+    tmp_quality = M.split(scan_str, " ")
+    tmp_quality = M.split(tmp_quality[2], "%.")
+    if tmp_quality[1]:match("-") then
+      tmp_quality = M.split(tmp_quality[1], "-")
+    end
+    tmp_quality = tonumber(tmp_quality[2]:match("(%d%d)"))
+  end
+  return tmp_quality
+end
+
+-- get frequency
+function M.scan_filter_frequency(scan_str, redirect)
+  local tmp_frequency = redirect
+  if scan_str:match("freq") then
+    tmp_frequency = M.split(scan_str, ":")
+    tmp_frequency = tmp_frequency[2]
+    if tmp_frequency ~= nil then
+      tmp_frequency = M.trim(tmp_frequency)
+    end
+  end
+  return tmp_frequency
+end
+
+function M.ibss_scan(radio,ifname,ssid,networks)
+  local wireless_scan = string.format( "iw %s scan", ifname)
+  local row = {}
+  row["radio"] = radio
+  -- loop through each line in the output of iw
+  for wifiscan in io.popen(wireless_scan, 'r'):lines() do
+    -- the following line matches a new network in the output of iw
+    if(row["bssid"] ~= nil and row["quality"] ~= nil and row["ssid"] == ssid) then
+      table.insert(networks, row)
+      row = {}
+      row["radio"] = radio
+    end
+
+    -- get ssid
+    if wifiscan:match("SSID:") then
+      row["ssid"] = M.split(wifiscan, ":")
+      row["ssid"] = row["ssid"][2]
+      if(row["ssid"] ~= nil) then
+        row["ssid"] = M.trim(row["ssid"])
+      end
+    end
+    row["frequency"] = M.scan_filter_frequency(wifiscan, row["frequency"])
+
+    -- get bssid
+    if wifiscan:match("(%w+:%w+:%w+:%w+:%w+:%w+)") then
+      row["bssid"] = wifiscan:match("(%w+:%w+:%w+:%w+:%w+:%w+)")
+    end
+    row["quality"] = M.scan_filter_quality(wifiscan, row["quality"])
+  end
+  return networks
+end
+
+function M.mesh_scan(radio,ifname,meshid,networks)
+  local wireless_scan = string.format( "iw %s scan", ifname)
+  local row = {}
+  row["radio"] = radio
+  -- loop through each line in the output of iw
+  for wifiscan in io.popen(wireless_scan, 'r'):lines() do
+    -- the following line matches a new network in the output of iw
+    if(row["bssid"] ~= nil and row["quality"] ~= nil and row["ssid"] == meshid) then
+      table.insert(networks, row)
+      row = {}
+      row["radio"] = radio
+    end
+    row["frequency"] = M.scan_filter_frequency(wifiscan, row["frequency"])
+    row["quality"] = M.scan_filter_quality(wifiscan, row["quality"])
+
+    -- get mesh-ID(ssid) and hoodbssid
+    if wifiscan:match("MESH ID:") then
+      local meshID = M.split(wifiscan, " ")[3]
+      if meshID ~= nil then
+        meshID = M.split(meshID, "_")
+        if meshID[1] ~= nil then
+          row["ssid"] = meshID[1].."_"
+        end
+        if meshID[2] ~= nil then
+          if meshID[2]:match("(%w+:%w+:%w+:%w+:%w+:%w+)") then
+            row["bssid"] = meshID[2]:match("(%w+:%w+:%w+:%w+:%w+:%w+)")
+          end
+        end
+      end
+    end
+  end
+  return networks
+end
+
+-- Scans for wireless networks and returns a two dimensional array containing
+-- wireless mesh neighbour networks and their properties.
+-- The array is sorted descending by signal strength (strongest signal
+-- first, usually the local signal of the wireless chip of the router)
+function M.wlan_list_sorted(radios, mesh_prefix)
+  local networks = {}
+  for _, radio in ipairs(radios) do
+    local ifname = uci:get('wireless', 'ibss_' .. radio, 'ifname')
+    local ssid = uci:get('wireless', 'ibss_' .. radio, 'ssid')
+    if (ifname ~= nil and ssid ~= nil) then
+      --do ibss scan
+      networks = M.ibss_scan(radio,ifname,ssid,networks)
+    end
+    ifname = uci:get('wireless', 'mesh_' .. radio, 'ifname')
+    if (ifname ~= nil and mesh_prefix ~= nil) then
+      --do mesh scan
+      networks = M.mesh_scan(radio,ifname,mesh_prefix,networks)
+    end
+  end
+  table.sort(networks, function(a,b) return a["quality"] < b["quality"] end)
+  return networks
+end
+
+-- this method removes the wireless network of the router itself
+-- from the wlan_list
+function M.filter_my_wlan_network(wlan_list)
+  for i=#wlan_list,1,-1 do
+    local bssid = uci:get('wireless', 'ibss_' .. wlan_list[i].radio, 'bssid')
+    if bssid ~= nil then
+      if string.lower(wlan_list[i].bssid) == string.lower(bssid) then
+        table.remove(wlan_list, i)
+      end
+    else
+      local mesh = uci:get('wireless', 'mesh_' .. wlan_list[i].radio, 'mesh_id')
+      if mesh ~= nil then
+        if string.lower(wlan_list[i].ssid..wlan_list[i].bssid) == string.lower(mesh) then
+          table.remove(wlan_list, i)
+        end
+      end
+    end
+  end
+  return wlan_list
+end
+
+function M.filter_default_hood_wlan_networks(default_hood, wlan_list)
+  for i=#wlan_list,1,-1 do
+    if(string.lower(default_hood.bssid) == string.lower(wlan_list[i].bssid)) then
+      table.remove(wlan_list, i)
+    end
+  end
+  return wlan_list
+end
+
+-- Get Geoposition. Return nil for no position
+function M.getGeolocation()
+  return {["lat"] = tonumber(uci:get('gluon-node-info', uci:get_first('gluon-node-info', 'location'), 'latitude')),
+  ["lon"] =  tonumber(uci:get('gluon-node-info', uci:get_first('gluon-node-info', 'location'), 'longitude')) }
+end
+
+-- Source with pseudocode: https://de.wikipedia.org/wiki/Punkt-in-Polygon-Test_nach_Jordan
+-- see also https://en.wikipedia.org/wiki/Point_in_polygon
+-- parameters: points A = (x_A,y_A), B = (x_B,y_B), C = (x_C,y_C)
+-- return value: −1 if the ray from A to the right bisects the edge [BC] (the lower vortex of [BC]
+-- is not seen as part of [BC]);
+--                0 if A is on [BC];
+--               +1 else
+function M.crossProdTest(x_A,y_A,x_B,y_B,x_C,y_C)
+  if y_A == y_B and y_B == y_C then
+    if (x_B <= x_A and x_A <= x_C) or (x_C <= x_A and x_A <= x_B) then
+      return 0
+    end
+    return 1
+  end
+  if not ((y_A == y_B) and (x_A == x_B)) then
+    if y_B > y_C then
+      -- swap B and C
+      local h = x_B
+      x_B = x_C
+      x_C = h
+      h = y_B
+      y_B = y_C
+      y_C = h
+    end
+    if (y_A <= y_B) or (y_A > y_C) then
+      return 1
+    end
+    local Delta = (x_B-x_A) * (y_C-y_A) - (y_B-y_A) * (x_C-x_A)
+    if Delta > 0 then
+      return 1
+    elseif Delta < 0 then
+      return -1
+    end
+  end
+  return 0
+end
+
+-- Source with pseudocode: https://de.wikipedia.org/wiki/Punkt-in-Polygon-Test_nach_Jordan
+-- see also: https://en.wikipedia.org/wiki/Point_in_polygon
+-- let P be a 2D Polygon and Q a 2D Point
+-- return value:  +1 if Q within P;
+--               −1 if Q outside of P;
+--                0 if Q on an edge of P
+function M.pointInPolygon(poly, point)
+  local t = -1
+  for i=1,#poly-1 do
+    t = t * M.crossProdTest(point.lon,point.lat,poly[i][2],poly[i][1],poly[i+1][2],poly[i+1][1])
+    if t == 0 then break end
+  end
+  return t
+end
+
+-- Return hood from the hood file based on geo position or nil if no real hood could be determined
+-- First check if an area has > 2 points and is hence a polygon. Else assume it is a rectangular
+-- box defined by two points (south-west and north-east)
+function M.getHoodByGeo(jhood,geo)
+  for _, h in pairs(jhood) do
+    for _, area in pairs(h.boxes) do
+      if #area > 2 then
+        if (M.pointInPolygon(area,geo) == 1) then
+          return h
+        end
+      else
+        if ( geo.lat >= area[1][1] and geo.lat < area[2][1] and geo.lon >= area[1][2] and geo.lon < area[2][2] ) then
+          return h
+        end
+      end
+    end
+  end
+  return nil
+end
+
+-- This method checks if the fastd configuration needs to be rewritten from the
+-- hoodfile. Therefore the method performs 3 checks and returns false if all
+-- checks fail. If one of the checks results to true the method returns true:
+--   1. Check if the local fastd configuration has a server that does not exist
+--      in the hoodfile.
+--   2. Check if a server that does exist in the local fastd configuration AND
+--      in the hoodfile has a configuration change.
+--   3. Check if the hoodfile contains a server that does not exist in the
+--      local fastd configuration.
+function M.fastd_reconfiguration_needed(hood_serverlist,local_serverlist)
+
+  local tmp_hood_serverlist = {}
+  for _,hood_server in pairs(hood_serverlist) do
+    if (hood_server["type"] == "fastd") then
+      table.insert(tmp_hood_serverlist,hood_server)
+    end
+  end
+
+  -- Checks 1. and 2.
+  for local_server_config_name, local_server in pairs(local_serverlist) do
+    local local_server_exists_in_hoodfile = false
+    for _,hood_server in pairs(tmp_hood_serverlist) do
+      if (local_server_config_name == 'mesh_vpn_backbone_peer_'..
+        M.split(hood_server["host"], '.')[1]:gsub("%-", "%_") .. "_" .. hood_server['port']) then
+        local_server_exists_in_hoodfile = true
+        if ( local_server.key ~= hood_server['publickey'] ) then return true end
+        if ( local_server.remote.host ~= '\"'..hood_server["host"]..'\"' ) then return true end
+        if ( local_server.remote.port ~= hood_server['port'] ) then return true end
+      end
+    end
+    if not local_server_exists_in_hoodfile then return true end
+  end
+
+  -- Check 3.
+  for _,hood_server in pairs(tmp_hood_serverlist) do
+    local hood_server_exists_locally = false
+    for local_server_config_name, _ in pairs(local_serverlist) do
+      if (local_server_config_name == 'mesh_vpn_backbone_peer_'..
+        M.split(hood_server["host"], '.')[1]:gsub("%-", "%_") .. "_" .. hood_server['port']) then
+        hood_server_exists_locally = true
+      end
+    end
+    if not hood_server_exists_locally then return true end
+  end
+  return false
+end
+
+function M.tunneldigger_reconfiguration_needed(hood_serverlist,local_serverlist)
+
+  local tmp_hood_serverlist = {}
+  for _,hood_server in pairs(hood_serverlist) do
+    if (hood_server["type"] == "l2tp") then
+      table.insert(tmp_hood_serverlist,hood_server)
+    end
+  end
+
+  -- Checks 1. and 2.
+  for _,local_peer in pairs(local_serverlist) do
+    local local_server_exists_in_hoodfile = false
+    for _,hood_server in pairs(tmp_hood_serverlist) do
+      if (local_peer == hood_server["host"] .. ":" .. hood_server["port"]) then
+        local_server_exists_in_hoodfile = true
+      end
+    end
+    if not local_server_exists_in_hoodfile then return true end
+  end
+
+  -- Check 3.
+  for _,hood_server in pairs(tmp_hood_serverlist) do
+    local hood_server_exists_locally = false
+    for _,local_peer in pairs(local_serverlist) do
+      if (local_peer == hood_server["host"] .. ":" .. hood_server["port"]) then
+        hood_server_exists_locally = true
+      end
+    end
+    if not(hood_server_exists_locally) then return true end
+  end
+  return false
+end
+
+-- Reconfigure fastd
+function M.fastd_reconfigure(hood_serverlist,local_serverlist)
+  -- remove all servers
+  for config_index, _ in pairs(local_serverlist) do
+    uci:delete('fastd',config_index)
+  end
+
+  -- add servers from hoodfile
+  local group = 'mesh_vpn_backbone'
+  for _,hood_server in pairs(hood_serverlist) do
+    if (hood_server["type"] == "fastd") then
+      uci:section('fastd', 'peer', group .. '_peer_' ..
+      M.split(hood_server.host, '.')[1]:gsub("%-", "%_") .. "_" .. hood_server.port,
+        {
+          enabled = 1,
+          net = 'mesh_vpn',
+          group = group,
+          key = hood_server.publickey,
+          remote = {'\"'..hood_server.host..'\"'..' port '..hood_server.port}
+        }
+      )
+    end
+  end
+
+  uci:save('fastd')
+  uci:commit('fastd')
+  io.stdout:write('Fastd needed reconfiguration. Stopped and applied new settings.\n')
+end
+
+function M.tunneldigger_reconfigure(hood_serverlist)
+  -- remove all servers
+  uci:delete('tunneldigger', 'mesh_vpn', 'address')
+
+  -- add servers from hoodfile
+  local addresslist = {}
+  for _,hood_server in pairs(hood_serverlist) do
+    if (hood_server["type"] == "l2tp") then
+      local tmpAdrr =hood_server["host"] .. ":" .. hood_server["port"]
+      table.insert(addresslist, tmpAdrr)
+    end
+  end
+  if next(addresslist) then
+    uci:set('tunneldigger', 'mesh_vpn', 'address', addresslist)
+  end
+  uci:save('tunneldigger')
+  uci:commit('tunneldigger')
+  io.stdout:write('tunneldigger needed reconfiguration. Stopped and applied new settings.\n')
+end
+
+-- Checks if wireless needs a reconfiguration. Returns true if any of the checks
+-- passes. Otherwise the method returns false.
+function M.wireless_reconfiguration_needed(radios, prefix, hood_bssid)
+  local configure_ibss = false
+  local configure_mesh = false
+  for _, radio in ipairs(radios) do
+    if uci:get('wireless', 'ibss_' .. radio, 'ifname') ~= nil then
+      if ( uci:get('wireless', 'ibss_' .. radio, 'bssid') ~= hood_bssid ) then
+        configure_ibss = true
+      end
+    end
+    if uci:get('wireless', 'mesh_' .. radio, 'ifname') ~= nil then
+      if ( uci:get('wireless', 'mesh_' .. radio, 'mesh_id') ~= prefix..hood_bssid:lower() ) then
+        configure_mesh = true
+      end
+    end
+  end
+  if not configure_ibss and not configure_mesh then return 0 end --no changes
+  if configure_ibss and not configure_mesh then return 1 end --ibss changes
+  if not configure_ibss and configure_mesh then return 2 end --mesh changes
+  return 3 --bouth changes
+end
+
+-- Reconfigure wireless
+function M.ibss_reconfigure(radios, hood_bssid)
+  for _, radio in ipairs(radios) do
+    if not ( uci:get('wireless', 'ibss_' .. radio, 'bssid') == hood_bssid ) then
+      uci:section('wireless', 'wifi-iface', 'ibss_' .. radio, {bssid = hood_bssid})
+    end
+  end
+  uci:save('wireless')
+  uci:commit('wireless')
+end
+
+function M.mesh_reconfigure(radios, meshid)
+  for _, radio in ipairs(radios) do
+    if not ( uci:get('wireless', 'mesh_' .. radio, 'mesh_id') == meshid ) then
+      uci:section('wireless', 'wifi-iface', 'mesh_' .. radio, {mesh_id = meshid})
+    end
+  end
+  uci:save('wireless')
+  uci:commit('wireless')
+end
+
+-- Save selected hood to config to make a restore after a sysupgrade possible
+function M.saveHoodToConfig(hoodbssid)
+  uci:set('hoodselector', 'hoodselector', 'hood', hoodbssid)
+  uci:save('hoodselector')
+  uci:commit('hoodselector')
+end
+
+-- Return the default hood in the hood list.
+-- This method can return the following data:
+-- * default hood
+-- * nil if no default hood has been defined
+function M.getDefaultHood(jhood)
+  for _, h in pairs(jhood) do
+    if h.defaulthood then
+      return h
+    end
+  end
+  return nil
+end
+
+-- boolean check if batman-adv has gateways
+function M.batmanHasGateway()
+  local file = io.open("/sys/kernel/debug/batman_adv/bat0/gateways", 'r')
+  if file ~= nil then
+    for gw in file:lines() do
+      if gw:match("Bit") then
+        return true
+      end
+    end
+  end
+  return false
+end
+
+-- Return hood from the hood file based on a given BSSID. nil if no matching hood could be found
+function M.gethoodByBssid(jhood, scan_bssid)
+  for _, h in pairs(jhood) do
+    if scan_bssid:lower():match(h.bssid:lower()) then
+      return h
+    end
+  end
+  return nil
+end
+
+-- Return hood from hood file based on a bssid address. nil if no matching hood could be found
+function M.getCurrentHood(jhood)
+  local hoodbssid = uci:get('hoodselector', 'hoodselector', 'hood')
+  for _, h in pairs(jhood) do
+    if h.bssid == hoodbssid then
+      return h
+    end
+  end
+  return nil
+end
+
+function M.test_batman_mesh_networks(sorted_wlan_list, meshprefix)
+  -- remove the ap network because we cannot change
+  -- the settings of the adhoc network if the ap network is still operating
+  for iface in io.popen(string.format("iw dev"),'r'):lines() do
+    if iface:match("Interface") then
+      iface = M.trim(M.split(iface, "Interface")[2])
+      if not ( iface:match("ibss") or iface:match("mesh")) then
+        os.execute("iw dev "..iface.." del")
+      end
+    end
+  end
+  for _, wireless in pairs(sorted_wlan_list) do
+    local ibss = uci:get('wireless', 'ibss_' .. wireless["radio"], 'ifname')
+    local mesh = uci:get('wireless', 'mesh_' .. wireless["radio"], 'ifname')
+    if wireless["ssid"] == uci:get('wireless', 'ibss_' .. wireless["radio"], 'ssid') then
+      io.stdout:write("Testing IBSS "..wireless["bssid"].."...\n")
+      -- leave the current adhoc network
+      os.execute("iw dev "..ibss.." ibss leave 2> /dev/null")
+      if mesh ~= nil then
+        os.execute("iw dev "..mesh.." mesh leave 2> /dev/null")
+      end
+      -- setup the adhoc network we want to test
+      os.execute("iw dev "..ibss.." ibss join "..wireless["ssid"].." "..wireless["frequency"].." "..wireless["bssid"])
+    end
+    if wireless["ssid"] == meshprefix then
+      io.stdout:write("Testing MESH "..wireless["bssid"].."...\n")
+      -- leave the current mesh network
+      os.execute("iw dev "..mesh.." mesh leave 2> /dev/null")
+      if ibss ~= nil then
+        os.execute("iw dev "..ibss.." ibss leave 2> /dev/null")
+      end
+      -- setup the mesh network we want to test
+      os.execute("iw dev "..mesh.." mesh join "..meshprefix..wireless["bssid"].." freq "..wireless["frequency"])
+    end
+    -- sleep 30 seconds till the connection is fully setup
+    local c = 0;
+    while(not M.batmanHasGateway()) do
+      if(c >= 30) then break end
+      M.sleep(1)
+      c = c +1;
+    end
+    if c < 30 then
+      return wireless["bssid"]
+    end
+  end
+  return nil
+end
+
+function M.get_batman_mesh_network(sorted_wlan_list, defaultHood, meshprefix)
+  io.stdout:write('Testing neighbouring adhoc networks for batman advanced gw connection.\n')
+  io.stdout:write('The following wireless networks have been found:\n')
+  for _, network in pairs(sorted_wlan_list) do
+    print(network["quality"].."\t"..network["frequency"].."\t"..network["bssid"].."\t"..network["ssid"])
+  end
+
+  -- we dont want to test the default hood because if there is no other
+  -- hood present we will connect to the default hood anyway
+  sorted_wlan_list = M.filter_default_hood_wlan_networks(defaultHood, sorted_wlan_list)
+
+  -- we dont want to test duplicated networks
+  sorted_wlan_list = M.filter_redundancy(sorted_wlan_list)
+
+  -- we dont want to get tricked by our signal
+  sorted_wlan_list = M.filter_my_wlan_network(sorted_wlan_list)
+
+  io.stdout:write('After filtering we will test the following wireless networks:\n')
+  for _, network in pairs(sorted_wlan_list) do
+    print(network["quality"].."\t"..network["frequency"].."\t"..network["bssid"].."\t"..network["ssid"])
+  end
+
+  local bssid = nil
+  if(next(sorted_wlan_list)) then
+    io.stdout:write("Prepare configuration for testing wireless networks...\n")
+    -- Notice:
+    -- we will use iw for testing the wireless networks because using iw does
+    -- not need any changes inside the uci config. This approach allows the
+    -- router to automatically reset to previous configuration in case
+    -- someone disconnects the router from power during test.
+
+    -- stop vpn to prevent two hoods from beeing connected in case
+    -- the router gets internet unexpectedly during test.
+    M.vpn_stop()
+    bssid = M.test_batman_mesh_networks(sorted_wlan_list, meshprefix)
+    M.vpn_start()
+    M.wireless_restart()
+    io.stdout:write("Finished testing wireless networks, restored previous configuration\n")
+  end
+
+  return bssid
+end
+
+function M.get_batman_GW_interface()
+  for gw in io.open("/sys/kernel/debug/batman_adv/bat0/gateways", 'r'):lines() do
+    if gw:match("=>") then
+      return M.trim(gw:match("%[.-%]"):gsub("%[", ""):gsub("%]", ""))
+    end
+  end
+  return nil
+end
+
+function M.get_radio_to_bssid(radios,iface,jhood)
+  for _, radio in ipairs(radios) do
+    local ifname = uci:get('wireless', 'ibss_' .. radio, 'ifname')
+    if ifname == iface then
+      return M.gethoodByBssid(jhood, uci:get('wireless', 'ibss_' .. radio, 'bssid'))
+    end
+    ifname = uci:get('wireless', 'mesh_' .. radio, 'ifname')
+    if ifname == iface then
+      local meshid = uci:get('wireless', 'mesh_' .. radio, 'mesh_id')
+      meshid = M.split(meshid, '_')
+      if meshid[2] ~= nil then
+        if meshid[2]:match("(%w+:%w+:%w+:%w+:%w+:%w+)") then
+          return M.gethoodByBssid(jhood, meshid[2]:match("(%w+:%w+:%w+:%w+:%w+:%w+)"))
+        end
+      end
+    end
+  end
+  return nil
+end
+
+function M.mesh_lan_wan(iface)
+  if uci:get('network', 'mesh_wan') then
+    local if_wan = io.popen(string.format("ifstatus mesh_wan"), 'r'):read('*a')
+    if if_wan ~= nil then
+      local wan, _, _ = json.parse(if_wan, 1, nil)
+      if wan["device"] == iface then
+        io.stdout:write("gw source is wan\n")
+        return true
+      end
+    end
+  end
+  if uci:get('network', 'mesh_lan') then
+    local if_lan = io.popen(string.format("ifstatus mesh_lan"), 'r'):read('*a')
+    if if_lan ~= nil then
+      local lan, _, _ = json.parse(if_lan, 1, nil)
+      if lan["device"] == iface then
+        io.stdout:write("gw source is lan\n")
+        return true
+      end
+    end
+  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