OVMS3/OVMS.V3/main/ovms_netmanager.cpp

/*
;    Project:       Open Vehicle Monitor System
;    Date:          14th March 2017
;
;    Changes:
;    1.0  Initial release
;
;    (C) 2011       Michael Stegen / Stegen Electronics
;    (C) 2011-2017  Mark Webb-Johnson
;    (C) 2011        Sonny Chen @ EPRO/DX
;
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice shall be included in
; all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
; THE SOFTWARE.
*/

#include "ovms_log.h"
static const char *TAG = "netmanager";

#include <string.h>
#include <stdio.h>
#include <lwip/tcpip.h>
#include <lwip/ip_addr.h>
#include <lwip/netif.h>
#include <lwip/dns.h>
#include <netinet/in.h>
#include "metrics_standard.h"
#include "ovms_peripherals.h"
#include "ovms_netmanager.h"
#include "ovms_command.h"
#include "ovms_config.h"
#include "ovms_module.h"

#ifndef CONFIG_OVMS_NETMAN_TASK_PRIORITY
#define CONFIG_OVMS_NETMAN_TASK_PRIORITY 5
#endif

OvmsNetManager MyNetManager __attribute__ ((init_priority (8999)));

void network_status(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
  {
  struct netif *ni;
  for (ni = netif_list; ni; ni = ni->next)
    {
    if (ni->name[0]=='l' && ni->name[1]=='o')
      continue;
    writer->printf("Interface#%d: %c%c%d (ifup=%d linkup=%d)\n",
      ni->num,ni->name[0],ni->name[1],ni->num,
      ((ni->flags & NETIF_FLAG_UP) != 0),
      ((ni->flags & NETIF_FLAG_LINK_UP) != 0));
    writer->printf("  IPv4: " IPSTR "/" IPSTR " gateway " IPSTR "\n",
      IP2STR(&ni->ip_addr.u_addr.ip4), IP2STR(&ni->netmask.u_addr.ip4), IP2STR(&ni->gw.u_addr.ip4));
    writer->puts("");
    }

  writer->printf("DNS:");
  int dnsservers = 0;
  for (int k=0;k<DNS_MAX_SERVERS;k++)
    {
    const ip_addr_t* srv = dns_getserver(k);
    if (! ip_addr_isany(srv))
      {
      dnsservers++;
      if (srv->type == IPADDR_TYPE_V4)
        writer->printf(" " IPSTR, IP2STR(&srv->u_addr.ip4));
      else if (srv->type == IPADDR_TYPE_V6)
        writer->printf(" " IPSTR, IP2STR(&srv->u_addr.ip6));
      }
    }
  if (dnsservers == 0)
    writer->puts(" None");
  else
    writer->puts("");

  if (netif_default)
    {
    writer->printf("\nDefault Interface: %c%c%d (" IPSTR "/" IPSTR " gateway " IPSTR ")\n",
      netif_default->name[0], netif_default->name[1], netif_default->num,
      IP2STR(&netif_default->ip_addr.u_addr.ip4),
      IP2STR(&netif_default->netmask.u_addr.ip4),
      IP2STR(&netif_default->gw.u_addr.ip4));
    }
  else
    {
    writer->printf("\nDefault Interface: None\n");
    }
  }

void network_restart(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
  {
  writer->puts("Restarting network...");
  vTaskDelay(pdMS_TO_TICKS(100));
  MyNetManager.RestartNetwork();
  }

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

void network_connections(int verbosity, OvmsWriter* writer, OvmsCommand* cmd, int argc, const char* const* argv)
  {
  if (!MyNetManager.MongooseRunning())
    {
    writer->puts("ERROR: Mongoose task not running");
    return;
    }

  if (xTaskGetCurrentTaskHandle() == MyNetManager.GetMongooseTaskHandle())
    {
    // inline execution in mongoose context:
    if (strcmp(cmd->GetName(), "close") == 0)
      {
      uint32_t id = strtol(argv[0], NULL, 16);
      int cnt = MyNetManager.CloseConnection(id);
      if (cnt == 0)
        writer->printf("ERROR: connection ID %08x not found\n", id);
      else
        writer->printf("Close signal sent to %d connection(s)\n", cnt);
      }
    else if (strcmp(cmd->GetName(), "cleanup") == 0)
      {
      int cnt = MyNetManager.CleanupConnections();
      if (cnt == 0)
        writer->puts("All connections OK");
      else
        writer->printf("Close signal sent to %d connection(s)\n", cnt);
      }
    else
      {
      MyNetManager.ListConnections(verbosity, writer);
      }
    }
  else
    {
    // remote execution from non-mongoose context:
    static netman_job_t job;
    memset(&job, 0, sizeof(job));
    if (strcmp(cmd->GetName(), "close") == 0)
      {
      job.cmd = nmc_close;
      job.close.id = strtol(argv[0], NULL, 16);
      if (!MyNetManager.ExecuteJob(&job, pdMS_TO_TICKS(5000)))
        writer->puts("ERROR: job failed");
      else if (job.close.cnt == 0)
        writer->printf("ERROR: connection ID %08x not found\n", job.close.id);
      else
        writer->printf("Close signal sent to %d connection(s)\n", job.close.cnt);
      }
    else if (strcmp(cmd->GetName(), "cleanup") == 0)
      {
      job.cmd = nmc_cleanup;
      if (!MyNetManager.ExecuteJob(&job, pdMS_TO_TICKS(5000)))
        writer->puts("ERROR: job failed");
      else if (job.cleanup.cnt == 0)
        writer->puts("All connections OK");
      else
        writer->printf("Close signal sent to %d connection(s)\n", job.cleanup.cnt);
      }
    else
      {
      // Note: a timeout occurring after the job has begun processing will result in a crash
      //  here due to the StringWriter being deleted. This only applies to the list command.
      //  If this becomes a problem, we need to upgrade the job processing from send/notify
      //  to a full send/receive scheme.
      job.cmd = nmc_list;
      job.list.verbosity = verbosity;
      job.list.buf = new StringWriter();
      if (!MyNetManager.ExecuteJob(&job, pdMS_TO_TICKS(10000)))
        writer->puts("ERROR: job failed");
      else
        writer->write(job.list.buf->data(), job.list.buf->size());
      delete job.list.buf;
      job.list.buf = NULL;
      }
    }
  }

#endif // CONFIG_OVMS_SC_GPL_MONGOOSE

OvmsNetManager::OvmsNetManager()
  {
  ESP_LOGI(TAG, "Initialising NETMANAGER (8999)");
  m_connected_wifi = false;
  m_connected_modem = false;
  m_connected_any = false;
  m_wifi_sta = false;
  m_wifi_good = false;
  m_wifi_ap = false;
  m_network_any = false;
  m_cfg_wifi_sq_good = -87;
  m_cfg_wifi_sq_bad = -89;

  for (int i=0; i<DNS_MAX_SERVERS; i++)
    {
    m_dns_modem[i] = (ip_addr_t)ip_addr_any;
    m_dns_wifi[i] = (ip_addr_t)ip_addr_any;
    m_previous_dns[i] = (ip_addr_t)ip_addr_any;
    }
  m_previous_name[0] = m_previous_name[1] = 0;

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  m_mongoose_task = 0;
  m_mongoose_running = false;
  m_jobqueue = xQueueCreate(CONFIG_OVMS_HW_NETMANAGER_QUEUE_SIZE, sizeof(netman_job_t*));
#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

  // Register our commands
  OvmsCommand* cmd_network = MyCommandApp.RegisterCommand("network","NETWORK framework",network_status, "", 0, 0, false);
  cmd_network->RegisterCommand("status","Show network status",network_status, "", 0, 0, false);
  cmd_network->RegisterCommand("restart","Restart network",network_restart, "", 0, 0, false);
#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  cmd_network->RegisterCommand("list", "List network connections", network_connections);
  cmd_network->RegisterCommand("close", "Close network connection(s)", network_connections, "<id>\nUse ID from connection list / 0 to close all", 1, 1);
  cmd_network->RegisterCommand("cleanup", "Close orphaned network connections", network_connections);
#endif // CONFIG_OVMS_SC_GPL_MONGOOSE

  // Register our events
  #undef bind  // Kludgy, but works
  using std::placeholders::_1;
  using std::placeholders::_2;

#ifdef CONFIG_OVMS_COMP_WIFI
  MyEvents.RegisterEvent(TAG,"system.wifi.sta.gotip", std::bind(&OvmsNetManager::WifiStaGotIP, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.sta.lostip", std::bind(&OvmsNetManager::WifiStaLostIP, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"network.wifi.sta.good", std::bind(&OvmsNetManager::WifiStaGood, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"network.wifi.sta.bad", std::bind(&OvmsNetManager::WifiStaBad, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.sta.stop", std::bind(&OvmsNetManager::WifiStaStop, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.sta.connected", std::bind(&OvmsNetManager::WifiStaConnected, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.sta.disconnected", std::bind(&OvmsNetManager::WifiStaStop, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.down", std::bind(&OvmsNetManager::WifiStaStop, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.ap.start", std::bind(&OvmsNetManager::WifiUpAP, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.ap.stop", std::bind(&OvmsNetManager::WifiDownAP, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.wifi.ap.sta.disconnected", std::bind(&OvmsNetManager::WifiApStaDisconnect, this, _1, _2));
#endif // #ifdef CONFIG_OVMS_COMP_WIFI

  MyEvents.RegisterEvent(TAG,"system.modem.gotip", std::bind(&OvmsNetManager::ModemUp, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.modem.stop", std::bind(&OvmsNetManager::ModemDown, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.modem.down", std::bind(&OvmsNetManager::ModemDown, this, _1, _2));

  MyEvents.RegisterEvent(TAG,"config.mounted", std::bind(&OvmsNetManager::ConfigChanged, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"config.changed", std::bind(&OvmsNetManager::ConfigChanged, this, _1, _2));
  MyEvents.RegisterEvent(TAG,"system.shuttingdown", std::bind(&OvmsNetManager::EventSystemShuttingDown, this, _1, _2));

  MyConfig.RegisterParam("network", "Network Configuration", true, true);
  // Our instances:
  //   dns                Space-separated list of DNS servers
  //   wifi.sq.good       Threshold for usable wifi signal [dBm], default -87
  //   wifi.sq.bad        Threshold for unusable wifi signal [dBm], default -89

#ifdef CONFIG_OVMS_COMP_WIFI
  MyMetrics.RegisterListener(TAG, MS_N_WIFI_SQ, std::bind(&OvmsNetManager::WifiStaCheckSQ, this, _1));
#endif
  }

OvmsNetManager::~OvmsNetManager()
  {
  }

void OvmsNetManager::RestartNetwork()
  {
#ifdef CONFIG_OVMS_COMP_WIFI
  if (MyPeripherals && MyPeripherals->m_esp32wifi)
    MyPeripherals->m_esp32wifi->Restart();
#endif // #ifdef CONFIG_OVMS_COMP_WIFI

#ifdef CONFIG_OVMS_COMP_CELLULAR
  if (MyPeripherals && MyPeripherals->m_cellular_modem)
    MyPeripherals->m_cellular_modem->Restart();
#endif // CONFIG_OVMS_COMP_CELLULAR
  }

#ifdef CONFIG_OVMS_COMP_WIFI

void OvmsNetManager::WifiConnect()
  {
  if (m_wifi_sta && !m_connected_wifi)
    {
    m_connected_wifi = true;
    PrioritiseAndIndicate();

    MyEvents.SignalEvent("network.wifi.up",NULL);

    if (m_connected_modem)
      {
      ESP_LOGI(TAG, "WIFI client up (with MODEM up): reconfigured for WIFI client priority");
      MyEvents.SignalEvent("network.reconfigured",NULL);
      }
    else
      {
      ESP_LOGI(TAG, "WIFI client up (with MODEM down): starting network with WIFI client");
      MyEvents.SignalEvent("network.up",NULL);
      }

    #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
      StartMongooseTask();
    #endif

    MyEvents.SignalEvent("network.interface.change",NULL);
    }
  }

void OvmsNetManager::WifiDisconnect()
  {
  if (m_connected_wifi)
    {
    m_connected_wifi = false;
    PrioritiseAndIndicate();

    MyEvents.SignalEvent("network.wifi.down",NULL);

    if (m_connected_any)
      {
      ESP_LOGI(TAG, "WIFI client down (with MODEM up): reconfigured for MODEM priority");
      MyEvents.SignalEvent("network.reconfigured",NULL);
      #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
        ScheduleCleanup();
      #endif
      }
    else
      {
      ESP_LOGI(TAG, "WIFI client down (with MODEM down): network connectivity has been lost");
      MyEvents.SignalEvent("network.down",NULL);

      #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
        StopMongooseTask();
      #endif
      }

    MyEvents.SignalEvent("network.interface.change",NULL);
    }
  }

void OvmsNetManager::WifiStaGotIP(std::string event, void* data)
  {
  m_wifi_sta = true;
  ESP_LOGI(TAG, "WIFI client got IP");
  SaveDNSServer(m_dns_wifi);

  // Re-prioritise, just in case, as Wifi stack seems to mess with this
  // (in particular if an AP interface is up, and STA goes down, Wifi
  // stack seems to switch default interface to AP)
  PrioritiseAndIndicate();
  #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
    ScheduleCleanup();
  #endif

  WifiStaCheckSQ(StdMetrics.ms_m_net_wifi_sq);
  }

void OvmsNetManager::WifiStaLostIP(std::string event, void* data)
  {
  // Re-prioritise, just in case, as Wifi stack seems to mess with this
  // (in particular if an AP interface is up, and STA goes down, Wifi
  // stack seems to switch default interface to AP)
  PrioritiseAndIndicate();
  #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
    ScheduleCleanup();
  #endif
  }

void OvmsNetManager::WifiStaConnected(std::string event, void* data)
  {
  // Re-prioritise, just in case, as Wifi stack seems to mess with this
  // (in particular if an AP interface is up, and STA goes down, Wifi
  // stack seems to switch default interface to AP)
  PrioritiseAndIndicate();
  #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
    ScheduleCleanup();
  #endif
  }

void OvmsNetManager::WifiStaStop(std::string event, void* data)
  {
  WifiStaSetSQ(false);
  if (m_wifi_sta)
    {
    m_wifi_sta = false;
    ESP_LOGI(TAG, "WIFI client stop");
    if (m_connected_wifi)
      {
      WifiDisconnect();
      return;
      }
    }

  // Re-prioritise, just in case, as Wifi stack seems to mess with this
  // (in particular if an AP interface is up, and STA goes down, Wifi
  // stack seems to switch default interface to AP)
  PrioritiseAndIndicate();
  #ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
    ScheduleCleanup();
  #endif
  }

void OvmsNetManager::WifiStaGood(std::string event, void* data)
  {
  if (m_wifi_sta && !m_connected_wifi)
    {
    ESP_LOGI(TAG, "WIFI client has good signal quality (%.1f dBm); connect",
             StdMetrics.ms_m_net_wifi_sq->AsFloat());
    WifiConnect();
    }
  }

void OvmsNetManager::WifiStaBad(std::string event, void* data)
  {
  if (m_wifi_sta && m_connected_wifi)
    {
    ESP_LOGI(TAG, "WIFI client has bad signal quality (%.1f dBm); disconnect",
             StdMetrics.ms_m_net_wifi_sq->AsFloat());
    // Stop using the Wifi network:
    WifiDisconnect();
    // If enabled, start reconnecting immediately (for fast transition to next best
    //  AP instead of trying to reassociate to current AP):
    if (MyPeripherals && MyPeripherals->m_esp32wifi &&
        MyConfig.GetParamValueBool("network", "wifi.bad.reconnect") == true)
      {
      MyPeripherals->m_esp32wifi->Reconnect(NULL);
      }
    }
  }

void OvmsNetManager::WifiStaCheckSQ(OvmsMetric* metric)
  {
  if (m_wifi_sta)
    {
    float sq = StdMetrics.ms_m_net_wifi_sq->AsFloat();
    if ((!metric || !m_wifi_good) && sq >= m_cfg_wifi_sq_good)
      {
      m_wifi_good = true;
      MyEvents.SignalEvent("network.wifi.sta.good", NULL);
      }
    else if ((!metric || m_wifi_good) && sq <= m_cfg_wifi_sq_bad)
      {
      m_wifi_good = false;
      MyEvents.SignalEvent("network.wifi.sta.bad", NULL);
      }
    }
  }

void OvmsNetManager::WifiStaSetSQ(bool good)
  {
  if (m_wifi_sta && m_wifi_good != good)
    {
    m_wifi_good = good;
    MyEvents.SignalEvent(good ? "network.wifi.sta.good" : "network.wifi.sta.bad", NULL);
    }
  }

void OvmsNetManager::WifiUpAP(std::string event, void* data)
  {
  m_wifi_ap = true;
  PrioritiseAndIndicate();

  ESP_LOGI(TAG, "WIFI access point is up");

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  StartMongooseTask();
#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

  MyEvents.SignalEvent("network.interface.change",NULL);
  }

void OvmsNetManager::WifiDownAP(std::string event, void* data)
  {
  m_wifi_ap = false;
  PrioritiseAndIndicate();

  ESP_LOGI(TAG, "WIFI access point is down");

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  StopMongooseTask();
#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

  MyEvents.SignalEvent("network.interface.change",NULL);
  }

void OvmsNetManager::WifiApStaDisconnect(std::string event, void* data)
  {
  ESP_LOGI(TAG, "WIFI access point station disconnected");
#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  ScheduleCleanup();
#endif
  }

#endif // #ifdef CONFIG_OVMS_COMP_WIFI


void OvmsNetManager::ModemUp(std::string event, void* data)
  {
  m_connected_modem = true;
  SaveDNSServer(m_dns_modem);
  PrioritiseAndIndicate();

  MyEvents.SignalEvent("network.modem.up",NULL);

  if (!m_connected_wifi)
    {
    ESP_LOGI(TAG, "MODEM up (with WIFI client down): starting network with MODEM");
    MyEvents.SignalEvent("network.up",NULL);
    }
  else
    {
    ESP_LOGI(TAG, "MODEM up (with WIFI client up): staying with WIFI client priority");
    }

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  StartMongooseTask();
#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

  MyEvents.SignalEvent("network.interface.change",NULL);
  }

void OvmsNetManager::ModemDown(std::string event, void* data)
  {
  if (m_connected_modem)
    {
    m_connected_modem = false;
    PrioritiseAndIndicate();

    MyEvents.SignalEvent("network.modem.down",NULL);

    if (m_connected_any)
      {
      ESP_LOGI(TAG, "MODEM down (with WIFI client up): staying with WIFI client priority");
#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
      ScheduleCleanup();
#endif
      }
    else
      {
      ESP_LOGI(TAG, "MODEM down (with WIFI client down): network connectivity has been lost");
      MyEvents.SignalEvent("network.down",NULL);

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
      StopMongooseTask();
#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
      }

    MyEvents.SignalEvent("network.interface.change",NULL);
    }
  else
    {
    // Re-prioritise, just in case, as Wifi stack seems to mess with this
    // (in particular if an AP interface is up, and STA goes down, Wifi
    // stack seems to switch default interface to AP)
    PrioritiseAndIndicate();
#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
    ScheduleCleanup();
#endif
    }
  }

void OvmsNetManager::ConfigChanged(std::string event, void* data)
  {
  OvmsConfigParam* param = (OvmsConfigParam*)data;
  if (!param || param->GetName() == "network")
    {
    // Network config has been changed, apply:
    m_cfg_wifi_sq_good = MyConfig.GetParamValueFloat("network", "wifi.sq.good", -87);
    m_cfg_wifi_sq_bad  = MyConfig.GetParamValueFloat("network", "wifi.sq.bad",  -89);
    if (m_cfg_wifi_sq_good < m_cfg_wifi_sq_bad)
      {
      float x = m_cfg_wifi_sq_good;
      m_cfg_wifi_sq_good = m_cfg_wifi_sq_bad;
      m_cfg_wifi_sq_bad = x;
      }
    #ifdef CONFIG_OVMS_COMP_WIFI
      WifiStaCheckSQ(NULL);
    #endif
    if (param && m_network_any)
      PrioritiseAndIndicate();
    }
  }

void OvmsNetManager::EventSystemShuttingDown(std::string event, void* data)
  {
#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  StopMongooseTask();
#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE
  }

void OvmsNetManager::SaveDNSServer(ip_addr_t* dnsstore)
  {
  for (int i=0; i<DNS_MAX_SERVERS; i++)
    {
    dnsstore[i] = *dns_getserver(i);
    ESP_LOGD(TAG, "Saved DNS#%d %s", i, inet_ntoa(dnsstore[i]));
    }
  }

void OvmsNetManager::SetDNSServer(ip_addr_t* dnsstore)
  {
  // Read DNS configuration:
  std::string servers = MyConfig.GetParamValue("network", "dns");
  if (!servers.empty())
    {
    int spos = 0;
    size_t sep = 0;
    while ((spos<DNS_MAX_SERVERS)&&(sep != string::npos))
      {
      // Set the specified DNS servers
      size_t next = servers.find(' ',sep);
      std::string cserver;
      ip_addr_t serverip;
      if (next == std::string::npos)
        {
        // The last one
        cserver = std::string(servers,sep,string::npos);
        sep = string::npos;
        }
      else
        {
        // One of many
        cserver = std::string(servers,sep,next-sep);
        sep = next+1;
        }
      ip4_addr_set_u32(ip_2_ip4(&serverip), ipaddr_addr(cserver.c_str()));
      serverip.type = IPADDR_TYPE_V4;
      if (!ip_addr_cmp(&serverip, &m_previous_dns[spos]))
        {
        m_previous_dns[spos] = serverip;
        ESP_LOGI(TAG, "Set DNS#%d %s",spos,cserver.c_str());
        }
      dns_setserver(spos++, &serverip);
      }
    for (;spos<DNS_MAX_SERVERS;spos++)
      {
      dns_setserver(spos, IP_ADDR_ANY);
      }
    }
  else if (dnsstore)
    {
    // Set stored DNS servers:
    for (int i=0; i<DNS_MAX_SERVERS; i++)
      {
      if (ip_addr_cmp(&dnsstore[i], &m_previous_dns[i]))
        {
        m_previous_dns[i] = dnsstore[i];
        ESP_LOGI(TAG, "Set DNS#%d %s", i, inet_ntoa(dnsstore[i]));
        }
      dns_setserver(i, &dnsstore[i]);
      }
    }
  }

void OvmsNetManager::SetNetType(std::string type)
  {
  if (type == "wifi")
    {
    StdMetrics.ms_m_net_type->SetValue(type);
#ifdef CONFIG_OVMS_COMP_WIFI
    if (MyPeripherals && MyPeripherals->m_esp32wifi)
      MyPeripherals->m_esp32wifi->UpdateNetMetrics();
#endif // CONFIG_OVMS_COMP_WIFI
    }
  else if (type == "modem")
    {
    StdMetrics.ms_m_net_type->SetValue(type);
#ifdef CONFIG_OVMS_COMP_CELLULAR
    if (MyPeripherals && MyPeripherals->m_cellular_modem)
      MyPeripherals->m_cellular_modem->UpdateNetMetrics();
#endif // CONFIG_OVMS_COMP_CELLULAR
    }
  else
    {
      StdMetrics.ms_m_net_type->SetValue("none");
      StdMetrics.ms_m_net_provider->SetValue("");
      StdMetrics.ms_m_net_sq->SetValue(0, dbm);
    }
  }

void SafePrioritiseAndIndicate(void* ctx)
  {
  MyNetManager.DoSafePrioritiseAndIndicate();
  }

void OvmsNetManager::PrioritiseAndIndicate()
  {
  tcpip_callback_with_block(SafePrioritiseAndIndicate, NULL, 1);
  }

void OvmsNetManager::DoSafePrioritiseAndIndicate()
  {
  const char *search = NULL;
  ip_addr_t* dns = NULL;

  // A convenient place to keep track of connectivity in general
  m_connected_any = m_connected_wifi || m_connected_modem;
  m_network_any = m_connected_wifi || m_connected_modem || m_wifi_ap;

  // Priority order...
  if (m_connected_wifi)
    {
    // Wifi is up
    SetNetType("wifi");
    search = "st";
    dns = m_dns_wifi;
    }
  else if (m_connected_modem)
    {
    // Modem is up
    SetNetType("modem");
    search = "pp";
    dns = m_dns_modem;
    }

  if (search == NULL)
    {
    SetNetType("none");
    return;
    }

  for (struct netif *pri = netif_list; pri != NULL; pri=pri->next)
    {
    if ((pri->name[0]==search[0])&&
        (pri->name[1]==search[1]))
      {
      if (search[0] != m_previous_name[0] || search[1] != m_previous_name[1])
        {
        ESP_LOGI(TAG, "Interface priority is %c%c%d (" IPSTR "/" IPSTR " gateway " IPSTR ")",
          pri->name[0], pri->name[1], pri->num,
          IP2STR(&pri->ip_addr.u_addr.ip4), IP2STR(&pri->netmask.u_addr.ip4), IP2STR(&pri->gw.u_addr.ip4));
        m_previous_name[0] = search[0];
        m_previous_name[1] = search[1];
        for (int i=0; i<DNS_MAX_SERVERS; i++)
          m_previous_dns[i] = (ip_addr_t)ip_addr_any;
        }
      netif_set_default(pri);
      SetDNSServer(dns);
      return;
      }
    }
  ESP_LOGE(TAG, "Inconsistent state: no interface of type '%s' found", search);
  }

#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE

static void MongooseRawTask(void *pvParameters)
  {
  OvmsNetManager* me = (OvmsNetManager*)pvParameters;
  me->MongooseTask();
  }

void OvmsNetManager::MongooseTask()
  {
  int pri, lastpri = CONFIG_OVMS_NETMAN_TASK_PRIORITY;

  // Initialise the mongoose manager
  ESP_LOGD(TAG, "MongooseTask starting");
  mg_mgr_init(&m_mongoose_mgr, NULL);
  MyEvents.SignalEvent("network.mgr.init",NULL);

  m_mongoose_running = true;

  // Main event loop
  while (m_mongoose_running)
    {
    // poll interfaces:
    if (mg_mgr_poll(&m_mongoose_mgr, 250) == 0)
      {
      ESP_LOGD(TAG, "MongooseTask: no interfaces available => exit");
      break;
      }

    // check for netmanager control jobs:
    ProcessJobs();

    // Detect broken mutex priority inheritance:
    // (may be removed if solved by esp-idf commit 22d636b7b0d6006e06b5b3cfddfbf6e2cf69b4b8)
    if ((pri = uxTaskPriorityGet(NULL)) != lastpri)
      {
      ESP_LOGD(TAG, "MongooseTask: priority changed from %d to %d", lastpri, pri);
      lastpri = pri;
      }
    }

  m_mongoose_running = false;

  // Shutdown cleanly
  ESP_LOGD(TAG, "MongooseTask stopping");
  MyEvents.SignalEvent("network.mgr.stop",NULL);
  mg_mgr_free(&m_mongoose_mgr);
  m_mongoose_task = NULL;
  vTaskDelete(NULL);
  }

struct mg_mgr* OvmsNetManager::GetMongooseMgr()
  {
  return &m_mongoose_mgr;
  }

bool OvmsNetManager::MongooseRunning()
  {
  return m_mongoose_running;
  }

void OvmsNetManager::StartMongooseTask()
  {
  if (!m_mongoose_running)
    {
    if (m_network_any)
      {
      // wait for previous task to finish shutting down:
      while (m_mongoose_task)
        vTaskDelay(pdMS_TO_TICKS(50));
      // start new task:
      xTaskCreatePinnedToCore(MongooseRawTask, "OVMS NetMan",10*1024, (void*)this,
                              CONFIG_OVMS_NETMAN_TASK_PRIORITY, &m_mongoose_task, CORE(1));
      AddTaskToMap(m_mongoose_task);
      }
    }
  }

void OvmsNetManager::StopMongooseTask()
  {
  if (!m_network_any)
    m_mongoose_running = false;
  }

void OvmsNetManager::ProcessJobs()
  {
  netman_job_t* job;
  while (xQueueReceive(m_jobqueue, &job, 0) == pdTRUE)
    {
    ESP_LOGD(TAG, "MongooseTask: got cmd %d from %p", job->cmd, job->caller);
    switch (job->cmd)
      {
      case nmc_none:
        break;
      case nmc_list:
        job->list.cnt = ListConnections(job->list.verbosity, job->list.buf);
        break;
      case nmc_close:
        job->close.cnt = CloseConnection(job->close.id);
        break;
      case nmc_cleanup:
        job->cleanup.cnt = CleanupConnections();
        break;
      default:
        ESP_LOGW(TAG, "MongooseTask: got unknown cmd %d from %p", job->cmd, job->caller);
      }
    if (job->caller)
      xTaskNotifyGive(job->caller);
    ESP_LOGD(TAG, "MongooseTask: done cmd %d from %p", job->cmd, job->caller);
    }
  }

bool OvmsNetManager::ExecuteJob(netman_job_t* job, TickType_t timeout /*=portMAX_DELAY*/)
  {
  if (!m_mongoose_running)
    return false;
  if (timeout)
    {
    job->caller = xTaskGetCurrentTaskHandle();
    xTaskNotifyWait(ULONG_MAX, ULONG_MAX, NULL, 0); // clear state
    }
  else
    job->caller = 0;
  ESP_LOGD(TAG, "send cmd %d from %p", job->cmd, job->caller);
  if (xQueueSend(m_jobqueue, &job, timeout) != pdTRUE)
    {
    ESP_LOGW(TAG, "ExecuteJob: cmd %d: queue overflow", job->cmd);
    return false;
    }
  if (timeout && ulTaskNotifyTake(pdTRUE, timeout) == 0)
    {
    // try to prevent delayed processing (cannot stop if already started):
    netman_cmd_t cmd = job->cmd;
    job->cmd = nmc_none;
    job->caller = 0;
    ESP_LOGW(TAG, "ExecuteJob: cmd %d: timeout", cmd);
    return false;
    }
  ESP_LOGD(TAG, "done cmd %d from %p", job->cmd, job->caller);
  return true;
  }

void OvmsNetManager::ScheduleCleanup()
  {
  static netman_job_t job;
  memset(&job, 0, sizeof(job));
  job.cmd = nmc_cleanup;
  ExecuteJob(&job, 0);
  }

int OvmsNetManager::ListConnections(int verbosity, OvmsWriter* writer)
  {
  if (!m_mongoose_running)
    return 0;
  mg_connection *c;
  int cnt = 0;
  char local[48], remote[48];
  writer->printf("ID        Flags     Handler   Local                  Remote\n");
  for (c = mg_next(&m_mongoose_mgr, NULL); c; c = mg_next(&m_mongoose_mgr, c))
    {
    if (c->flags & MG_F_LISTENING)
      continue;
    mg_conn_addr_to_str(c, local, sizeof(local), MG_SOCK_STRINGIFY_IP|MG_SOCK_STRINGIFY_PORT);
    mg_conn_addr_to_str(c, remote, sizeof(remote), MG_SOCK_STRINGIFY_IP|MG_SOCK_STRINGIFY_PORT|MG_SOCK_STRINGIFY_REMOTE);
    writer->printf("%08x  %08x  %08x  %-21s  %s\n", (uint32_t)c, (uint32_t)c->flags, (uint32_t)c->user_data, local, remote);
    cnt++;
    }
  return cnt;
  }

int OvmsNetManager::CloseConnection(uint32_t id)
  {
  if (!m_mongoose_running)
    return 0;
  mg_connection *c;
  int cnt = 0;
  for (c = mg_next(&m_mongoose_mgr, NULL); c; c = mg_next(&m_mongoose_mgr, c))
    {
    if (c->flags & MG_F_LISTENING)
      continue;
    if (id == 0 || c == (mg_connection*)id)
      {
      c->flags |= MG_F_CLOSE_IMMEDIATELY;
      cnt++;
      }
    }
  return cnt;
  }

int OvmsNetManager::CleanupConnections()
  {
  if (!m_mongoose_running)
    return 0;

  struct netif *ni;
  mg_connection *c;
  tcpip_adapter_sta_list_t ap_ip_list;
  union socket_address sa;
  socklen_t slen = sizeof(sa);
  int cnt = 0;

  // get IP addresses of stations connected to our wifi AP:
  ap_ip_list.num = 0;
#ifdef CONFIG_OVMS_COMP_WIFI
  if (m_wifi_ap)
    {
    wifi_sta_list_t sta_list;
    if (esp_wifi_ap_get_sta_list(&sta_list) != ESP_OK)
      ESP_LOGW(TAG, "CleanupConnections: can't get AP station list");
    else if (tcpip_adapter_get_sta_list(&sta_list, &ap_ip_list) != ESP_OK)
      ESP_LOGW(TAG, "CleanupConnections: can't get AP station IP list");
    }
#endif // #ifdef CONFIG_OVMS_COMP_WIFI

  for (c = mg_next(&m_mongoose_mgr, NULL); c; c = mg_next(&m_mongoose_mgr, c))
    {
    if (c->flags & MG_F_LISTENING)
      continue;

    // get local address:
    memset(&sa, 0, sizeof(sa));
    if (getsockname(c->sock, &sa.sa, &slen) != 0)
      {
      ESP_LOGW(TAG, "CleanupConnections: conn %08x: getsockname failed", (uint32_t)c);
      continue;
      }

    if (sa.sa.sa_family != AF_INET || sa.sin.sin_addr.s_addr == IPADDR_ANY || sa.sin.sin_addr.s_addr == IPADDR_NONE)
      continue;

    // find interface:
    for (ni = netif_list; ni; ni = ni->next)
      {
      if (sa.sin.sin_addr.s_addr == ip4_addr_get_u32(netif_ip4_addr(ni)))
        break;
      }

    if (ni)
      ESP_LOGD(TAG, "CleanupConnections: conn %08x -> iface %c%c%d", (uint32_t)c, ni->name[0], ni->name[1], ni->num);
    else
      ESP_LOGD(TAG, "CleanupConnections: conn %08x -> no iface", (uint32_t)c);

    if (!ni || !(ni->flags & NETIF_FLAG_UP) || !(ni->flags & NETIF_FLAG_LINK_UP))
      {
      ESP_LOGI(TAG, "CleanupConnections: closing conn %08x: interface/link down", (uint32_t)c);
      c->flags |= MG_F_CLOSE_IMMEDIATELY;
      cnt++;
      continue;
      }

    // check remote address on wifi AP:
    if (ni->name[0] == 'a' && ni->name[1] == 'p')
      {
      memset(&sa, 0, sizeof(sa));
      if (getpeername(c->sock, &sa.sa, &slen) != 0)
        {
        ESP_LOGW(TAG, "CleanupConnections: conn %08x: getpeername failed", (uint32_t)c);
        continue;
        }
      int i;
      for (i = 0; i < ap_ip_list.num; i++)
        {
        if (sa.sin.sin_addr.s_addr == ap_ip_list.sta[i].ip.addr)
          break;
        }

      if (i < ap_ip_list.num)
        {
        ESP_LOGD(TAG, "CleanupConnections: conn %08x -> AP IP " IPSTR, (uint32_t)c, IP2STR(&ap_ip_list.sta[i].ip));
        }
      else
        {
        ESP_LOGI(TAG, "CleanupConnections: closing conn %08x: AP peer disconnected", (uint32_t)c);
        c->flags |= MG_F_CLOSE_IMMEDIATELY;
        cnt++;
        }
      } // AP remotes
    } // connection loop
  return cnt;
  }

bool OvmsNetManager::IsNetManagerTask()
  {
  // Return TRUE if the currently running task is the Net Manager task
  extern void *pxCurrentTCB[portNUM_PROCESSORS];

  return (m_mongoose_task == pxCurrentTCB[xPortGetCoreID()]);
  }

#endif //#ifdef CONFIG_OVMS_SC_GPL_MONGOOSE