board/main/net_gateway_monitor.c

#include <lwip/netdb.h>
#include <string.h>
#include <sys/param.h>

#include "esp_err.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "gui.c"
#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"

#define NET_GATEWAY_MONITOR_UDP_PORT 23043
#define NET_GATEWAY_MONITOR_SERVER_ADDR 0xC0A81F05  // 192.168.31.5
#define NET_GATEWAY_MONITOR_SERVER_PORT 17890

static const char *NET_GATEWAY_MONITOR_TAG = "NET_GATE_MONITOR";
static int net_gateway_monitor_socket = -1;

static void net_gateway_monitor_request_task(void *pvParameters) {
  int sock = net_gateway_monitor_socket;
  struct sockaddr_in server_addr;
  server_addr.sin_addr.s_addr = htonl(NET_GATEWAY_MONITOR_SERVER_ADDR);
  server_addr.sin_family = AF_INET;
  server_addr.sin_port = htons(NET_GATEWAY_MONITOR_SERVER_PORT);
  while (sock == net_gateway_monitor_socket) {
    int err = sendto(net_gateway_monitor_socket, "ping", 4, 0, &server_addr,
                     sizeof(server_addr));
    if (err < 0) {
      ESP_LOGE(NET_GATEWAY_MONITOR_TAG,
               "Error occurred during sending: errno %d. sock: %d", errno,
               net_gateway_monitor_socket);
    }
    vTaskDelay(5000 / portTICK_PERIOD_MS);
  }
  vTaskDelete(NULL);
}

static void net_gateway_monitor_run_task(void *pvParameters) {
  char rx_buffer[1024];
  char addr_str[128];
  int addr_family = (int)pvParameters;
  int ip_protocol = 0;
  struct sockaddr_in dest_addr;
  struct sockaddr_in server_addr;

  while (1) {
    dest_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(NET_GATEWAY_MONITOR_UDP_PORT);
    ip_protocol = IPPROTO_IP;

    server_addr.sin_addr.s_addr = htonl(NET_GATEWAY_MONITOR_SERVER_ADDR);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(NET_GATEWAY_MONITOR_SERVER_PORT);

    net_gateway_monitor_socket = socket(addr_family, SOCK_DGRAM, ip_protocol);
    if (net_gateway_monitor_socket < 0) {
      ESP_LOGE(NET_GATEWAY_MONITOR_TAG,
               "Unable to create socket: errno %d. sock: %d", errno,
               net_gateway_monitor_socket);
      break;
    }
    ESP_LOGI(NET_GATEWAY_MONITOR_TAG, "Socket created");

    // Set timeout
    struct timeval timeout;
    timeout.tv_sec = 10;
    timeout.tv_usec = 0;
    setsockopt(net_gateway_monitor_socket, SOL_SOCKET, SO_RCVTIMEO, &timeout,
               sizeof timeout);

    int err = bind(net_gateway_monitor_socket, (struct sockaddr *)&dest_addr,
                   sizeof(dest_addr));
    if (err < 0) {
      ESP_LOGE(NET_GATEWAY_MONITOR_TAG,
               "Socket unable to bind: errno %d. sock: %d", errno,
               net_gateway_monitor_socket);
      net_gateway_monitor_socket = -1;
      vTaskDelay(1000 / portTICK_PERIOD_MS);
      continue;
    }
    // err = connect(net_gateway_monitor_socket, (struct sockaddr
    // *)&server_addr,
    //               sizeof(server_addr));
    if (err < 0) {
      ESP_LOGE(NET_GATEWAY_MONITOR_TAG,
               "Socket unable to connect: errno %d. sock: %d", errno,
               net_gateway_monitor_socket);
      net_gateway_monitor_socket = -1;
      vTaskDelay(1000 / portTICK_PERIOD_MS);
      continue;
    }

    ESP_LOGI(NET_GATEWAY_MONITOR_TAG, "Socket bound, port %d",
             NET_GATEWAY_MONITOR_UDP_PORT);

    xTaskCreate(net_gateway_monitor_request_task, "net_gateway_monitor_request",
                1024, NULL, 5, NULL);

    while (1) {
      uint8_t from_len = sizeof(server_addr);
      // ESP_LOGI(NET_GATEWAY_MONITOR_TAG, "Waiting for data");
      int len =
          recv(net_gateway_monitor_socket, rx_buffer, sizeof(rx_buffer) - 1, 0);
      // Error occurred during receiving
      if (len < 0) {
        if (errno == EAGAIN) {
          continue;
        }
        ESP_LOGE(NET_GATEWAY_MONITOR_TAG, "recvfrom failed: errno %d. len: %d",
                 errno, len);
      }
      // Data received
      else {
        // Get the sender's ip address as string
        inet_ntoa_r(server_addr.sin_addr, addr_str, sizeof(addr_str) - 1);

        rx_buffer[len] = 0;  // Null-terminate whatever we received and treat
                             // like a string...
        gui_change_network_speed(
            (uint64_t *)&rx_buffer[0], (uint64_t *)&rx_buffer[8],
            (uint64_t *)&rx_buffer[16], (uint64_t *)&rx_buffer[24]);
      }

      if (net_gateway_monitor_socket != -1 && len < 0) {
        ESP_LOGE(NET_GATEWAY_MONITOR_TAG,
                 "Shutting down socket and restarting...");
        shutdown(net_gateway_monitor_socket, 0);
        close(net_gateway_monitor_socket);
        break;
      }
    }
  }
  vTaskDelete(NULL);
}

static void net_gateway_monitor_init() {
  ESP_LOGI(NET_GATEWAY_MONITOR_TAG, "Start net gateway monitor");
  xTaskCreate(net_gateway_monitor_run_task, "net_gateway_monitor_run", 4096,
              (void *)AF_INET, 5, NULL);
}