libraries/AP_Networking/AP_Networking.cpp

   1
   2 #include "AP_Networking_Config.h"
   3
   4 #if AP_NETWORKING_ENABLED
   5
   6 #include "AP_Networking.h"
   7 #include "AP_Networking_Backend.h"
   8 #include <GCS_MAVLink/GCS.h>
   9 #include <AP_Math/crc.h>
  10 #include <AP_InternalError/AP_InternalError.h>
  11 #include <AP_Filesystem/AP_Filesystem.h>
  12 #include <AP_HAL/CANIface.h>
  13
  14 extern const AP_HAL::HAL& hal;
  15
  16 #if AP_NETWORKING_BACKEND_CHIBIOS
  17 #include "AP_Networking_ChibiOS.h"
  18 #include <hal_mii.h>
  19 #endif
  20
  21 #include <lwipopts.h>
  22 #include <errno.h>
  23
  24
  25 #include <AP_HAL/utility/Socket.h>
  26
  27 #if AP_NETWORKING_BACKEND_PPP
  28 #include "AP_Networking_PPP.h"
  29 #endif
  30
  31 #if AP_NETWORKING_BACKEND_SITL
  32 #include "AP_Networking_SITL.h"
  33 #endif
  34
  35 const AP_Param::GroupInfo AP_Networking::var_info[] = {
  36     // @Param: ENABLE
  37     // @DisplayName: Networking Enable
  38     // @Description: Networking Enable
  39     // @Values: 0:Disable,1:Enable
  40     // @RebootRequired: True
  41     // @User: Advanced
  42     AP_GROUPINFO_FLAGS("ENABLE",  1, AP_Networking, param.enabled, 0, AP_PARAM_FLAG_ENABLE),
  43
  44 #if AP_NETWORKING_CONTROLS_HOST_IP_SETTINGS_ENABLED
  45     // @Group: IPADDR
  46     // @Path: AP_Networking_address.cpp
  47     AP_SUBGROUPINFO(param.ipaddr, "IPADDR", 2,  AP_Networking, AP_Networking_IPV4),
  48
  49     // @Param: NETMASK
  50     // @DisplayName: IP Subnet mask
  51     // @Description: Allows setting static subnet mask. The value is a count of consecutive bits. Examples: 24 = 255.255.255.0, 16 = 255.255.0.0
  52     // @Range: 0 32
  53     // @RebootRequired: True
  54     // @User: Advanced
  55     AP_GROUPINFO("NETMASK", 3,  AP_Networking,    param.netmask,   AP_NETWORKING_DEFAULT_NETMASK),
  56
  57 #if AP_NETWORKING_DHCP_AVAILABLE
  58     // @Param: DHCP
  59     // @DisplayName: DHCP client
  60     // @Description: Enable/Disable DHCP client
  61     // @Values: 0:Disable, 1:Enable
  62     // @RebootRequired: True
  63     // @User: Advanced
  64     AP_GROUPINFO("DHCP", 4,  AP_Networking,    param.dhcp,   AP_NETWORKING_DEFAULT_DHCP_ENABLE),
  65 #endif
  66
  67     // @Group: GWADDR
  68     // @Path: AP_Networking_address.cpp
  69     AP_SUBGROUPINFO(param.gwaddr, "GWADDR", 5,  AP_Networking, AP_Networking_IPV4),
  70
  71     // @Group: MACADDR
  72     // @Path: AP_Networking_macaddr.cpp
  73     AP_SUBGROUPINFO(param.macaddr, "MACADDR", 6,  AP_Networking, AP_Networking_MAC),
  74 #endif // AP_NETWORKING_CONTROLS_HOST_IP_SETTINGS_ENABLED
  75
  76 #if AP_NETWORKING_TESTS_ENABLED
  77     // @Param: TESTS
  78     // @DisplayName: Test enable flags
  79     // @Description: Enable/Disable networking tests
  80     // @Bitmask: 0:UDP echo test,1:TCP echo test, 2:TCP discard test, 3:TCP reflect test
  81     // @RebootRequired: True
  82     // @User: Advanced
  83     AP_GROUPINFO("TESTS", 7,  AP_Networking,    param.tests,   0),
  84
  85     // @Group: TEST_IP
  86     // @Path: AP_Networking_address.cpp
  87     AP_SUBGROUPINFO(param.test_ipaddr, "TEST_IP", 8,  AP_Networking, AP_Networking_IPV4),
  88 #endif
  89
  90     // @Param: OPTIONS
  91     // @DisplayName: Networking options
  92     // @Description: Networking options
  93     // @Bitmask: 0:EnablePPP Ethernet gateway, 1:Enable CAN1 multicast endpoint, 2:Enable CAN2 multicast endpoint, 3:Enable CAN1 multicast bridged, 4:Enable CAN2 multicast bridged
  94     // @RebootRequired: True
  95     // @User: Advanced
  96     AP_GROUPINFO("OPTIONS", 9,  AP_Networking,    param.options, 0),
  97
  98 #if AP_NETWORKING_PPP_GATEWAY_ENABLED
  99     // @Group: REMPPP_IP
 100     // @Path: AP_Networking_address.cpp
 101     AP_SUBGROUPINFO(param.remote_ppp_ip, "REMPPP_IP", 10,  AP_Networking, AP_Networking_IPV4),
 102 #endif
 103
 104     AP_GROUPEND
 105 };
 106
 107 /*
 108   constructor
 109  */
 110 AP_Networking::AP_Networking(void)
 111 {
 112 #if CONFIG_HAL_BOARD == HAL_BOARD_SITL
 113     if (singleton != nullptr) {
 114         AP_HAL::panic("AP_Networking must be singleton");
 115     }
 116 #endif
 117     singleton = this;
 118     AP_Param::setup_object_defaults(this, var_info);
 119 }
 120
 121 /*
 122   initialise networking subsystem
 123  */
 124 void AP_Networking::init()
 125 {
 126     if (!param.enabled || backend != nullptr) {
 127         return;
 128     }
 129
 130 #if AP_NETWORKING_CONTROLS_HOST_IP_SETTINGS_ENABLED
 131     // set default MAC Address as lower 3 bytes of the CRC of the UID
 132     uint8_t uid[50];
 133     uint8_t uid_len = sizeof(uid);
 134     if (hal.util->get_system_id_unformatted(uid, uid_len)) {
 135         union {
 136             uint8_t bytes[4];
 137             uint32_t value32;
 138         } crc;
 139         crc.value32 = crc_crc32(0, uid, uid_len);
 140
 141         param.macaddr.set_default_address_byte(3, crc.bytes[0]);
 142         param.macaddr.set_default_address_byte(4, crc.bytes[1]);
 143         param.macaddr.set_default_address_byte(5, crc.bytes[2]);
 144     }
 145 #endif
 146
 147 #if AP_NETWORKING_PPP_GATEWAY_ENABLED
 148     if (option_is_set(OPTION::PPP_ETHERNET_GATEWAY)) {
 149         /*
 150           when we are a PPP/Ethernet gateway we bring up the ethernet first
 151          */
 152         backend = NEW_NOTHROW AP_Networking_ChibiOS(*this);
 153         backend_PPP = NEW_NOTHROW AP_Networking_PPP(*this);
 154     }
 155 #endif
 156
 157
 158 #if AP_NETWORKING_BACKEND_PPP
 159     if (backend == nullptr && AP::serialmanager().have_serial(AP_SerialManager::SerialProtocol_PPP, 0)) {
 160         backend = NEW_NOTHROW AP_Networking_PPP(*this);
 161     }
 162 #endif
 163
 164 #if AP_NETWORKING_BACKEND_CHIBIOS
 165     if (backend == nullptr) {
 166         backend = NEW_NOTHROW AP_Networking_ChibiOS(*this);
 167     }
 168 #endif
 169 #if AP_NETWORKING_BACKEND_SITL
 170     if (backend == nullptr) {
 171         backend = NEW_NOTHROW AP_Networking_SITL(*this);
 172     }
 173 #endif
 174
 175     if (backend == nullptr) {
 176         GCS_SEND_TEXT(MAV_SEVERITY_INFO, "NET: backend failed");
 177         return;
 178     }
 179
 180     if (!backend->init()) {
 181         GCS_SEND_TEXT(MAV_SEVERITY_INFO, "NET: backend init failed");
 182         // the backend init function creates a thread which references the backend pointer; that thread may be running so don't remove the backend allocation.
 183         backend = nullptr;
 184         return;
 185     }
 186
 187 #if AP_NETWORKING_PPP_GATEWAY_ENABLED
 188     if (backend_PPP != nullptr && !backend_PPP->init()) {
 189         GCS_SEND_TEXT(MAV_SEVERITY_INFO, "NET: backend_PPP init failed");
 190         backend_PPP = nullptr;
 191     }
 192 #endif
 193
 194     announce_address_changes();
 195
 196     GCS_SEND_TEXT(MAV_SEVERITY_INFO,"NET: Initialized");
 197
 198 #if AP_NETWORKING_TESTS_ENABLED
 199     start_tests();
 200 #endif
 201
 202 #if AP_NETWORKING_CAN_MCAST_BRIDGING_ENABLED
 203     if (option_is_set(OPTION::CAN1_MCAST_ENDPOINT) || option_is_set(OPTION::CAN1_MCAST_ENDPOINT)) {
 204         // get mask of enabled buses
 205         uint8_t bus_mask = 0;
 206         if (option_is_set(OPTION::CAN1_MCAST_ENDPOINT)) {
 207             bus_mask |= (1U<<0);
 208         }
 209         if (option_is_set(OPTION::CAN1_MCAST_ENDPOINT)) {
 210             bus_mask |= (1U<<1);
 211         }
 212         mcast_server.start(bus_mask);
 213     }
 214 #endif
 215
 216 #if AP_NETWORKING_REGISTER_PORT_ENABLED
 217     // init network mapped serialmanager ports
 218     ports_init();
 219 #endif
 220 }
 221
 222 /*
 223   check if we should announce changes to IP addresses
 224  */
 225 void AP_Networking::announce_address_changes()
 226 {
 227     const auto &as = backend->activeSettings;
 228
 229     if (as.last_change_ms == 0 || as.last_change_ms == announce_ms) {
 230         // nothing changed and we've already printed it at least once. Nothing to do.
 231         return;
 232     }
 233
 234 #if AP_HAVE_GCS_SEND_TEXT
 235     char ipstr[16];
 236     GCS_SEND_TEXT(MAV_SEVERITY_INFO, "NET: IP      %s", SocketAPM::inet_addr_to_str(get_ip_active(), ipstr, sizeof(ipstr)));
 237     GCS_SEND_TEXT(MAV_SEVERITY_INFO, "NET: Mask    %s", SocketAPM::inet_addr_to_str(get_netmask_active(), ipstr, sizeof(ipstr)));
 238     GCS_SEND_TEXT(MAV_SEVERITY_INFO, "NET: Gateway %s", SocketAPM::inet_addr_to_str(get_gateway_active(), ipstr, sizeof(ipstr)));
 239 #endif
 240
 241     announce_ms = as.last_change_ms;
 242 }
 243
 244 /*
 245   update called at 10Hz
 246  */
 247 void AP_Networking::update()
 248 {
 249     if (!is_healthy()) {
 250         return;
 251     }
 252     backend->update();
 253     announce_address_changes();
 254 }
 255
 256 uint32_t AP_Networking::convert_netmask_bitcount_to_ip(const uint32_t netmask_bitcount)
 257 {
 258     if (netmask_bitcount >= 32) {
 259         return 0xFFFFFFFFU;
 260     }
 261     return ~((1U<<(32U-netmask_bitcount))-1U);
 262 }
 263
 264 uint8_t AP_Networking::convert_netmask_ip_to_bitcount(const uint32_t netmask_ip)
 265 {
 266     uint32_t netmask_bitcount = 0;
 267     for (uint32_t i=0; i<32; i++) {
 268         // note, netmask LSB is IP MSB
 269         if ((netmask_ip & (1UL<<i)) == 0) {
 270             break;
 271         }
 272         netmask_bitcount++;
 273     }
 274     return netmask_bitcount;
 275 }
 276
 277 /*
 278   convert a string to an ethernet MAC address
 279  */
 280 bool AP_Networking::convert_str_to_macaddr(const char *mac_str, uint8_t addr[6])
 281 {
 282     if (strlen(mac_str) != 17) {
 283         return false;
 284     }
 285     char s2[18];
 286     strncpy(s2, mac_str, sizeof(s2)-1);
 287     s2[17] = 0;
 288     char *ptr = nullptr;
 289     const char *s = strtok_r(s2, ":", &ptr);
 290     for (uint8_t i=0; i<6; i++) {
 291         if (s == nullptr) {
 292             return false;
 293         }
 294         auto v = strtoul(s, nullptr, 16);
 295         if (v > 255) {
 296             return false;
 297         }
 298         addr[i] = v;
 299         s = strtok_r(nullptr, ":", &ptr);
 300     }
 301     return true;
 302 }
 303
 304 // returns the 32bit value of the active IP address that is currently in use
 305 uint32_t AP_Networking::get_ip_active() const
 306 {
 307     return backend?backend->activeSettings.ip:0;
 308 }
 309
 310 // returns the 32bit value of the active Netmask that is currently in use
 311 uint32_t AP_Networking::get_netmask_active() const
 312 {
 313     return backend?backend->activeSettings.nm:0;
 314 }
 315
 316 uint32_t AP_Networking::get_gateway_active() const
 317 {
 318     return backend?backend->activeSettings.gw:0;
 319 }
 320
 321 /*
 322   wait for networking to be active
 323  */
 324 void AP_Networking::startup_wait(void) const
 325 {
 326     if (hal.scheduler->in_main_thread()) {
 327         INTERNAL_ERROR(AP_InternalError::error_t::flow_of_control);
 328         return;
 329     }
 330     while (!hal.scheduler->is_system_initialized()) {
 331         hal.scheduler->delay(100);
 332     }
 333 #if AP_NETWORKING_BACKEND_CHIBIOS
 334     do {
 335         hal.scheduler->delay(250);
 336     } while (get_ip_active() == 0);
 337 #endif
 338 }
 339
 340 /*
 341   send the rest of a file to a socket
 342  */
 343 bool AP_Networking::sendfile(SocketAPM *sock, int fd)
 344 {
 345     WITH_SEMAPHORE(sem);
 346     if (sendfile_buf == nullptr) {
 347         uint32_t bufsize = AP_NETWORKING_SENDFILE_BUFSIZE;
 348         do {
 349             sendfile_buf = (uint8_t *)hal.util->malloc_type(bufsize, AP_HAL::Util::MEM_FILESYSTEM);
 350             if (sendfile_buf != nullptr) {
 351                 sendfile_bufsize = bufsize;
 352                 break;
 353             }
 354             bufsize /= 2;
 355         } while (bufsize >= 4096);
 356         if (sendfile_buf == nullptr) {
 357             return false;
 358         }
 359     }
 360     if (!sendfile_thread_started) {
 361         if (!hal.scheduler->thread_create(FUNCTOR_BIND_MEMBER(&AP_Networking::sendfile_check, void),
 362                                           "sendfile",
 363                                           2048, AP_HAL::Scheduler::PRIORITY_UART, 0)) {
 364             return false;
 365         }
 366         sendfile_thread_started = true;
 367     }
 368     for (auto &s : sendfiles) {
 369         if (s.sock == nullptr) {
 370             s.sock = sock->duplicate();
 371             if (s.sock == nullptr) {
 372                 return false;
 373             }
 374             s.fd = fd;
 375             return true;
 376         }
 377     }
 378     return false;
 379 }
 380
 381 void AP_Networking::SendFile::close(void)
 382 {
 383     AP::FS().close(fd);
 384     delete sock;
 385     sock = nullptr;
 386 }
 387
 388 #include <stdio.h>
 389 /*
 390   check for sendfile updates
 391  */
 392 void AP_Networking::sendfile_check(void)
 393 {
 394     while (true) {
 395         hal.scheduler->delay(1);
 396         WITH_SEMAPHORE(sem);
 397         bool none_active = true;
 398         for (auto &s : sendfiles) {
 399             if (s.sock == nullptr) {
 400                 continue;
 401             }
 402             none_active = false;
 403             if (!s.sock->pollout(0)) {
 404                 continue;
 405             }
 406             const auto nread = AP::FS().read(s.fd, sendfile_buf, sendfile_bufsize);
 407             if (nread <= 0) {
 408                 s.close();
 409                 continue;
 410             }
 411             const auto nsent = s.sock->send(sendfile_buf, nread);
 412             if (nsent <= 0) {
 413                 s.close();
 414                 continue;
 415             }
 416             if (nsent < nread) {
 417                 AP::FS().lseek(s.fd, nsent - nread, SEEK_CUR);
 418             }
 419         }
 420         if (none_active) {
 421             free(sendfile_buf);
 422             sendfile_buf = nullptr;
 423         }
 424     }
 425 }
 426
 427 AP_Networking *AP_Networking::singleton;
 428
 429 namespace AP
 430 {
 431 AP_Networking &network()
 432 {
 433     return *AP_Networking::get_singleton();
 434 }
 435 }
 436
 437 /*
 438   debug printfs from LWIP
 439  */
 440 int ap_networking_printf(const char *fmt, ...)
 441 {
 442     WITH_SEMAPHORE(AP::network().get_semaphore());
 443 #ifdef AP_NETWORKING_LWIP_DEBUG_FILE
 444     static int fd = -1;
 445     if (fd == -1) {
 446         fd = AP::FS().open(AP_NETWORKING_LWIP_DEBUG_FILE, O_WRONLY|O_CREAT|O_TRUNC, 0644);
 447         if (fd == -1) {
 448             return -1;
 449         }
 450     }
 451     va_list ap;
 452     va_start(ap, fmt);
 453     vdprintf(fd, fmt, ap);
 454     va_end(ap);
 455 #else
 456     va_list ap;
 457     va_start(ap, fmt);
 458     hal.console->vprintf(fmt, ap);
 459     va_end(ap);
 460 #endif
 461     return 0;
 462 }
 463
 464 // address to string using a static return buffer
 465 const char *AP_Networking::address_to_str(uint32_t addr)
 466 {
 467     static char buf[16]; // 16 for aaa.bbb.ccc.ddd
 468     return SocketAPM::inet_addr_to_str(addr, buf, sizeof(buf));
 469 }
 470
 471 #ifdef LWIP_PLATFORM_ASSERT
 472 void ap_networking_platform_assert(const char *msg, int line, const char *file)
 473 {
 474     AP_HAL::panic("LWIP: %s: %s:%u", msg, file, line);
 475 }
 476 #endif
 477
 478 #endif // AP_NETWORKING_ENABLED