claunia/86Box
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Network Switch support

Browse Source 
Co-Authored-By: Alexander Babikov <2708460+lemondrops@users.noreply.github.com>
Co-Authored-By: cold-brewed <47337035+cold-brewed@users.noreply.github.com>
This commit is contained in:
Jasmine Iwanek
2025-06-26 20:53:17 -04:00
parent be8dc5f488
commit 2dc28d39b1
20 changed files with 6846 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/config.c
View File

@@ -681,6 +681,10 @@ load_network(void)
nc->net_type = NET_TYPE_VDE;
else if (!strcmp(p, "tap") || !strcmp(p, "4"))
nc->net_type = NET_TYPE_TAP;
else if (!strcmp(p, "nmswitch") || !strcmp(p, "5"))
nc->net_type = NET_TYPE_NMSWITCH;
else if (!strcmp(p, "nrswitch") || !strcmp(p, "6"))
nc->net_type = NET_TYPE_NRSWITCH;
else
nc->net_type = NET_TYPE_NONE;
} else
@@ -729,6 +733,10 @@ load_network(void)
nc->net_type = NET_TYPE_VDE;
else if (!strcmp(p, "tap") || !strcmp(p, "4"))
nc->net_type = NET_TYPE_TAP;
else if (!strcmp(p, "nmswitch") || !strcmp(p, "5"))
nc->net_type = NET_TYPE_NMSWITCH;
else if (!strcmp(p, "nrswitch") || !strcmp(p, "6"))
nc->net_type = NET_TYPE_NRSWITCH;
else
nc->net_type = NET_TYPE_NONE;
} else
@@ -750,6 +758,19 @@ load_network(void)
} else
strcpy(nc->host_dev_name, "none");
sprintf(temp, "net_%02i_switch_group", c + 1);
net_cards_conf[c].switch_group = ini_section_get_int(cat, temp, 0);
sprintf(temp, "net_%02i_promisc", c + 1);
net_cards_conf[c].promisc_mode = ini_section_get_int(cat, temp, 0);
sprintf(temp, "net_%02i_nrs_host", c + 1);
p = ini_section_get_string(cat, temp, NULL);
if (p != NULL)
strncpy(net_cards_conf[c].nrs_hostname, p, sizeof(net_cards_conf[c].nrs_hostname) - 1);
else
strncpy(net_cards_conf[c].nrs_hostname, "", sizeof(net_cards_conf[c].nrs_hostname) - 1);
sprintf(temp, "net_%02i_link", c + 1);
nc->link_state = ini_section_get_int(cat, temp,
(NET_LINK_10_HD | NET_LINK_10_FD |
@@ -2601,6 +2622,12 @@ save_network(void)
case NET_TYPE_TAP:
ini_section_set_string(cat, temp, "tap");
break;
case NET_TYPE_NMSWITCH:
ini_section_set_string(cat, temp, "nmswitch");
break;
case NET_TYPE_NRSWITCH:
ini_section_set_string(cat, temp, "nrswitch");
break;
default:
break;
}
@@ -2621,6 +2648,28 @@ save_network(void)
ini_section_delete_var(cat, temp);
else
ini_section_set_int(cat, temp, nc->link_state);
sprintf(temp, "net_%02i_switch_group", c + 1);
if (nc->device_num == 0)
ini_section_delete_var(cat, temp);
else
ini_section_set_int(cat, temp, net_cards_conf[c].switch_group);
sprintf(temp, "net_%02i_promisc", c + 1);
if (nc->device_num == 0)
ini_section_delete_var(cat, temp);
else
ini_section_set_int(cat, temp, net_cards_conf[c].promisc_mode);
sprintf(temp, "net_%02i_nrs_host", c + 1);
if (nc->device_num == 0)
ini_section_delete_var(cat, temp);
else {
if (nc->nrs_hostname[0] != '\0')
ini_section_set_string(cat, temp, net_cards_conf[c].nrs_hostname);
else
ini_section_delete_var(cat, temp);
}
}
ini_delete_section_if_empty(config, cat);

17
src/include/86box/network.h
View File

@@ -48,11 +48,13 @@
#include <stdint.h>
/* Network provider types. */
#define NET_TYPE_NONE 0 /* use the null network driver */
#define NET_TYPE_SLIRP 1 /* use the SLiRP port forwarder */
#define NET_TYPE_PCAP 2 /* use the (Win)Pcap API */
#define NET_TYPE_VDE 3 /* use the VDE plug API */
#define NET_TYPE_TAP 4 /* use a linux TAP device */
#define NET_TYPE_NONE 0 /* use the null network driver */
#define NET_TYPE_SLIRP 1 /* use the SLiRP port forwarder */
#define NET_TYPE_PCAP 2 /* use the (Win)Pcap API */
#define NET_TYPE_VDE 3 /* use the VDE plug API */
#define NET_TYPE_TAP 4 /* use a linux TAP device */
#define NET_TYPE_NMSWITCH 5 /* use the network multicast switch provider */
#define NET_TYPE_NRSWITCH 6 /* use the network remote switch provider */
#define NET_MAX_FRAME 1518
/* Queue size must be a power of 2 */
@@ -96,6 +98,9 @@ typedef struct netcard_conf_t {
int net_type;
char host_dev_name[128];
uint32_t link_state;
uint8_t switch_group;
uint8_t promisc_mode;
char nrs_hostname[128];
} netcard_conf_t;
extern netcard_conf_t net_cards_conf[NET_CARD_MAX];
@@ -129,6 +134,7 @@ extern const netdrv_t net_slirp_drv;
extern const netdrv_t net_vde_drv;
extern const netdrv_t net_tap_drv;
extern const netdrv_t net_null_drv;
extern const netdrv_t net_netswitch_drv;
struct _netcard_t {
const device_t *device;
@@ -194,6 +200,7 @@ extern int network_dev_available(int);
extern int network_dev_to_id(char *);
extern int network_card_available(int);
extern int network_card_has_config(int);
extern int network_type_has_config(int);
extern const char *network_card_get_internal_name(int);
extern int network_card_get_from_internal_name(char *);
#ifdef EMU_DEVICE_H

7
src/network/CMakeLists.txt
View File

@@ -34,6 +34,13 @@ list(APPEND net_sources
net_l80225.c
net_modem.c
utils/getline.c
net_netswitch.c
netswitch.c
pb_common.c
pb_encode.c
pb_decode.c
networkmessage.pb.c
)
find_package(PkgConfig REQUIRED)

498
src/network/net_netswitch.c Normal file
View File

@@ -0,0 +1,498 @@
/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
*
* This file is part of the 86Box distribution.
*
* Network Switch network driver
*
*
*
* Authors: cold-brewed
*
* Copyright 2024 cold-brewed
*/
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <winsock2.h>
#else
# include <poll.h>
#endif
#define HAVE_STDARG_H
#include <86box/86box.h>
#include <86box/device.h>
#include <86box/thread.h>
#include <86box/timer.h>
#include <86box/network.h>
#include <86box/net_event.h>
#include "netswitch.h"
#include "networkmessage.pb.h"
enum {
NET_EVENT_STOP = 0,
NET_EVENT_TX,
NET_EVENT_RX,
NET_EVENT_SWITCH,
NET_EVENT_MAX
};
/* Special define for the windows portion. We only need to poll up to
* NET_EVENT_SWITCH. NET_EVENT_SWITCH gives us a different NET_EVENT_MAX
* excluding the others, and windows does not like polling events that
* do not exist. */
#define NET_EVENT_WIN_MAX NET_EVENT_SWITCH
#define SWITCH_PKT_BATCH NET_QUEUE_LEN
/* In µs, how often to send a keepalive and perform connection maintenance */
#define SWITCH_KEEPALIVE_INTERVAL 5000000
/* In ms, how long until we consider a connection gone? */
#define SWITCH_MAX_INTERVAL 10000
typedef struct {
void *nsconn;
uint8_t mac_addr[6];
netcard_t *card;
thread_t *poll_tid;
net_evt_t tx_event;
net_evt_t stop_event;
netpkt_t pktv[SWITCH_PKT_BATCH];
pc_timer_t stats_timer;
pc_timer_t maintenance_timer;
ns_rx_packet_t rx_packet;
char switch_type[16];
#ifdef _WIN32
HANDLE sock_event;
#endif
} net_netswitch_t;
// Used for debugging, needs to be moved to an official location
void print_packet(const netpkt_t netpkt) {
if(netpkt.len == 0) {
net_switch_log("Something is wrong, len is %d\n", netpkt.len);
return;
}
/* Temporarily disable log suppression for packet dumping to allow specific formatting */
pclog_toggle_suppr();
uint8_t linebuff[17] = "\0";
char src_mac_buf[32] = "";
char dst_mac_buf[32] = "";
for(int m_i=0; m_i < 6; m_i++) {
char src_octet[4];
char dst_octet[4];
snprintf(src_octet, sizeof(src_octet), "%02X%s", netpkt.data[m_i+6], m_i < 5 ? ":" : "");
strncat(src_mac_buf, src_octet, sizeof (src_mac_buf) - 1);
snprintf(dst_octet, sizeof(dst_octet), "%02X%s", netpkt.data[m_i], m_i < 5 ? ":" : "");
strncat(dst_mac_buf, dst_octet, sizeof (dst_mac_buf) - 1);
}
net_switch_log("%s -> %s\n\n", src_mac_buf, dst_mac_buf);
// Payload length (bytes 12-13 with zero index)
uint16_t payload_length = (netpkt.data[12] & 0xFF) << 8;
payload_length |= (netpkt.data[13] & 0xFF);
const uint16_t actual_length = netpkt.len - 14;
if(payload_length <= 1500) {
// 802.3 / 802.2
net_switch_log("Payload length according to frame: %i\n", payload_length);
// remaining length of packet (len - 14) to calculate padding
net_switch_log("Actual payload length: %i\n", actual_length);
if(payload_length <=46 ) {
net_switch_log("Likely has %d bytes padding\n", actual_length - payload_length);
}
} else {
// Type II
net_switch_log("EtherType: 0x%04X\n", payload_length);
}
// actual packet size
net_switch_log("Full frame size: %i\n", netpkt.len);
net_switch_log("\n");
for(int i=0; i< netpkt.len; i++) {
net_switch_log("%02x ", netpkt.data[i]);
if ((netpkt.data[i] < 0x20) || (netpkt.data[i] > 0x7e)) {
linebuff[i % 16] = '.';
} else {
linebuff[i % 16] = netpkt.data[i];
}
if( (i+1) % 8 == 0) {
net_switch_log(" ");
}
if( (i+1) % 16 == 0) {
net_switch_log("| %s |\n", (char *)linebuff);
linebuff[0] = '\0';
}
// last char?
if(i+1 == netpkt.len) {
const int togo = 16 - (i % 16);
for(int remaining = 0; remaining < togo-1; remaining++) {
// This would represent the byte display and the space
net_switch_log(" ");
}
// spacing between byte groupings
if(togo > 8) {
net_switch_log(" ");
}
linebuff[(i % 16) +1] = '\0';
net_switch_log(" | %s", (char *)linebuff);
for(int remaining = 0; remaining < togo-1; remaining++) {
// This would represent the remaining bytes on the right
net_switch_log(" ");
}
net_switch_log(" |\n");
}
}
net_switch_log("\n");
pclog_toggle_suppr();
}
#ifdef ENABLE_NET_SWITCH_STATS
static void
stats_timer(void *priv)
{
/* Get the device state structure. */
net_netswitch_t *netswitch = priv;
const NSCONN *nsconn = netswitch->nsconn;
net_switch_log("Max (frame / packet) TX (%zu/%zu) RX (%zu/%zu)\n",
nsconn->stats.max_tx_frame, nsconn->stats.max_tx_packet,
nsconn->stats.max_rx_frame, nsconn->stats.max_rx_packet);
net_switch_log("Last ethertype (TX/RX) (%02x%02x/%02x%02x)\n", nsconn->stats.last_tx_ethertype[0], nsconn->stats.last_tx_ethertype[1],
nsconn->stats.last_rx_ethertype[0], nsconn->stats.last_rx_ethertype[1]);
net_switch_log("Packet totals (all/tx/rx/would fragment/max vec) (%zu/%zu/%zu/%zu/%i)\n", nsconn->stats.total_tx_packets + nsconn->stats.total_rx_packets,
nsconn->stats.total_tx_packets, nsconn->stats.total_rx_packets, nsconn->stats.total_fragments, nsconn->stats.max_vec);
net_switch_log("---\n");
/* Restart the timer */
timer_on_auto(&netswitch->stats_timer, 60000000);
}
#endif
static void
maintenance_timer(void *priv)
{
/* Get the device state structure. */
net_netswitch_t *netswitch = (net_netswitch_t *) priv;
NSCONN *nsconn = (NSCONN *) netswitch->nsconn;
if (!ns_send_control(nsconn, MessageType_MESSAGE_TYPE_KEEPALIVE)) {
net_switch_log("Failed to send keepalive packet\n");
}
const int64_t interval = ns_get_current_millis() - nsconn->last_packet_stamp;
// net_switch_log("Last packet time: %lld ago\n", interval);
// net_switch_log("Last packet time: %lld ago\n", interval);
/* A timeout has likely occurred, try to fix the connection if type is REMOTE */
if((interval > SWITCH_MAX_INTERVAL) && nsconn->switch_type == SWITCH_TYPE_REMOTE) {
/* FIXME: This is really rough, needs moar logic */
nsconn->client_state = CONNECTING;
net_switch_log("We appear to be disconnected, attempting to reconnect\n");
/* TODO: Proper connect function! This is duplicated code */
if(!ns_send_control(nsconn, MessageType_MESSAGE_TYPE_CONNECT_REQUEST)) {
/* TODO: Failure */
}
}
/* Restart the timer */
timer_on_auto(&netswitch->maintenance_timer, SWITCH_KEEPALIVE_INTERVAL);
}
/* Lots of #ifdef madness here thanks to the polling differences on windows */
static void
net_netswitch_thread(void *priv)
{
net_netswitch_t *net_netswitch = (net_netswitch_t *) priv;
NSCONN *nsconn = (NSCONN *) net_netswitch->nsconn;
bool status;
char switch_type[32];
snprintf(switch_type, sizeof(switch_type), "%s", nsconn->switch_type == SWITCH_TYPE_REMOTE ? "Remote" : "Local");
net_switch_log("%s Net Switch: polling started.\n", switch_type);
#ifdef _WIN32
WSAEventSelect(ns_pollfd(net_netswitch->nsconn), net_netswitch->sock_event, FD_READ);
HANDLE events[NET_EVENT_MAX];
events[NET_EVENT_STOP] = net_event_get_handle(&net_netswitch->stop_event);
events[NET_EVENT_TX] = net_event_get_handle(&net_netswitch->tx_event);
events[NET_EVENT_RX] = net_netswitch->sock_event;
bool run = true;
#else
struct pollfd pfd[NET_EVENT_MAX];
pfd[NET_EVENT_STOP].fd = net_event_get_fd(&net_netswitch->stop_event);
pfd[NET_EVENT_STOP].events = POLLIN | POLLPRI;
pfd[NET_EVENT_TX].fd = net_event_get_fd(&net_netswitch->tx_event);
pfd[NET_EVENT_TX].events = POLLIN | POLLPRI;
pfd[NET_EVENT_RX].fd = ns_pollfd(net_netswitch->nsconn);
pfd[NET_EVENT_RX].events = POLLIN | POLLPRI;
#endif
#ifdef _WIN32
while (run) {
int ret = WaitForMultipleObjects(NET_EVENT_WIN_MAX, events, FALSE, INFINITE);
switch (ret - WAIT_OBJECT_0) {
#else
while (1) {
poll(pfd, NET_EVENT_MAX, -1);
#endif
#ifdef _WIN32
case NET_EVENT_STOP:
net_event_clear(&net_netswitch->stop_event);
run = false;
break;
case NET_EVENT_TX:
#else
if (pfd[NET_EVENT_STOP].revents & POLLIN) {
net_event_clear(&net_netswitch->stop_event);
break;
}
if (pfd[NET_EVENT_TX].revents & POLLIN) {
#endif
net_event_clear(&net_netswitch->tx_event);
const int packets = network_tx_popv(net_netswitch->card, net_netswitch->pktv, SWITCH_PKT_BATCH);
if (packets > nsconn->stats.max_vec) {
nsconn->stats.max_vec = packets;
}
for (int i = 0; i < packets; i++) {
// net_switch_log("%d packet(s) to send\n", packets);
data_packet_info_t packet_info = get_data_packet_info(&net_netswitch->pktv[i], net_netswitch->mac_addr);
/* Temporarily disable log suppression for packet logging */
pclog_toggle_suppr();
net_switch_log("%s Net Switch: TX: %s\n", switch_type, packet_info.printable);
pclog_toggle_suppr();
#if defined(NET_PRINT_PACKET_TX) || defined(NET_PRINT_PACKET_ALL)
print_packet(net_netswitch->pktv[i]);
#endif
/* Only send if we're in a connected state (always true for local) */
if(ns_connected(net_netswitch->nsconn)) {
const ssize_t nc = ns_send_pb(net_netswitch->nsconn, &net_netswitch->pktv[i], 0);
if (nc < 1) {
perror("Got");
net_switch_log("%s Net Switch: Problem, no bytes sent. Got back %i\n", switch_type, nc);
}
}
}
#ifdef _WIN32
break;
case NET_EVENT_RX:
#else
}
if (pfd[NET_EVENT_RX].revents & POLLIN) {
#endif
/* Packets are available for reading */
status = ns_recv_pb(net_netswitch->nsconn, &net_netswitch->rx_packet, NET_MAX_FRAME, 0);
if (!status) {
net_switch_log("Receive packet failed. Skipping.\n");
continue;
}
/* These types are handled in the backend and don't need to be considered */
if (is_control_packet(&net_netswitch->rx_packet) || is_fragment_packet(&net_netswitch->rx_packet)) {
continue;
}
data_packet_info_t packet_info = get_data_packet_info(&net_netswitch->rx_packet.pkt, net_netswitch->mac_addr);
#if defined(NET_PRINT_PACKET_RX) || defined(NET_PRINT_PACKET_ALL)
print_packet(net_netswitch->rx_packet.pkt);
#endif
/*
* Accept packets that are
* Unicast for us
* Broadcasts that are not from us
* All other packets *if* promiscuous mode is enabled (excluding our own)
*/
if (packet_info.is_packet_for_me || (packet_info.is_broadcast && !packet_info.is_packet_from_me)) {
/* Temporarily disable log suppression for packet logging */
pclog_toggle_suppr();
net_switch_log("%s Net Switch: RX: %s\n", switch_type, packet_info.printable);
pclog_toggle_suppr();
network_rx_put_pkt(net_netswitch->card, &net_netswitch->rx_packet.pkt);
} else if (packet_info.is_packet_from_me) {
net_switch_log("%s Net Switch: Got my own packet... ignoring\n", switch_type);
} else {
/* Not our packet. Pass it along if promiscuous mode is enabled. */
if (ns_flags(net_netswitch->nsconn) & FLAGS_PROMISC) {
net_switch_log("%s Net Switch: Got packet from %s (not mine, promiscuous is set, getting)\n", switch_type, packet_info.src_mac_h);
network_rx_put_pkt(net_netswitch->card, &net_netswitch->rx_packet.pkt);
} else {
net_switch_log("%s Net Switch: RX: %s (not mine, dest %s != %s, promiscuous not set, ignoring)\n", switch_type, packet_info.printable, packet_info.dest_mac_h, packet_info.my_mac_h);
}
}
#ifdef _WIN32
break;
}
#else
}
#endif
}
net_switch_log("%s Net Switch: polling stopped.\n", switch_type);
}
void
net_netswitch_error(char *errbuf, const char *message) {
strncpy(errbuf, message, NET_DRV_ERRBUF_SIZE);
net_switch_log("Net Switch: %s\n", message);
}
void *
net_netswitch_init(const netcard_t *card, const uint8_t *mac_addr, void *priv, char *netdrv_errbuf)
{
net_switch_log("Net Switch: Init\n");
netcard_conf_t *netcard = (netcard_conf_t *) priv;
ns_flags_t flags = FLAGS_NONE;
ns_type_t switch_type;
const int net_type = netcard->net_type;
if(net_type == NET_TYPE_NRSWITCH) {
net_switch_log("Switch type: Remote\n");
switch_type = SWITCH_TYPE_REMOTE;
} else if (net_type == NET_TYPE_NMSWITCH) {
net_switch_log("Switch type: Local Multicast\n");
switch_type = SWITCH_TYPE_LOCAL;
if(netcard->promisc_mode) {
flags |= FLAGS_PROMISC;
}
} else {
net_switch_log("Failed: Unknown net switch type %d\n", net_type);
return NULL;
}
// FIXME: Only here during dev. This would be an error otherwise (hostname not specified)
if(strlen(netcard->nrs_hostname) == 0) {
strncpy(netcard->nrs_hostname, "127.0.0.1", 128 - 1);
}
net_netswitch_t *net_netswitch = calloc(1, sizeof(net_netswitch_t));
net_netswitch->card = (netcard_t *) card;
memcpy(net_netswitch->mac_addr, mac_addr, sizeof(net_netswitch->mac_addr));
snprintf(net_netswitch->switch_type, sizeof(net_netswitch->switch_type), "%s", net_type == NET_TYPE_NRSWITCH ? "Remote" : "Local");
// net_switch_log("%s Net Switch: mode: %d, group %d, hostname %s len %lu\n", net_netswitch->switch_type, netcard->promisc_mode, netcard->switch_group, netcard->nrs_hostname, strlen(netcard->nrs_hostname));
struct ns_open_args ns_args;
ns_args.type = switch_type;
/* Setting FLAGS_PROMISC here lets all packets through except the ones from us */
ns_args.flags = flags;
/* This option sets which switch group you want to be a part of.
* Functionally equivalent to being plugged into a different switch */
ns_args.group = netcard->switch_group;
/* You could also set the client_id here. If 0, it will be generated. */
ns_args.client_id = 0;
memcpy(ns_args.mac_addr, net_netswitch->mac_addr, 6);
/* The remote switch hostname */
strncpy(ns_args.nrs_hostname, netcard->nrs_hostname, sizeof(ns_args.nrs_hostname) - 1);
net_switch_log("%s Net Switch: Starting up virtual switch with group %d, flags %d\n", net_netswitch->switch_type, ns_args.group, ns_args.flags);
if ((net_netswitch->nsconn = ns_open(&ns_args)) == NULL) {
char buf[NET_DRV_ERRBUF_SIZE];
/* We're using some errnos for our own purposes */
switch (errno) {
case EFAULT:
snprintf(buf, NET_DRV_ERRBUF_SIZE, "Unable to open switch group %d: Cannot resolve remote switch hostname %s", ns_args.group, ns_args.nrs_hostname);
break;
default:
snprintf(buf, NET_DRV_ERRBUF_SIZE, "Unable to open switch group %d (%s)", ns_args.group, strerror(errno));
break;
}
net_netswitch_error(netdrv_errbuf, buf);
free(net_netswitch);
return NULL;
}
for (int i = 0; i < SWITCH_PKT_BATCH; i++) {
net_netswitch->pktv[i].data = calloc(1, NET_MAX_FRAME);
}
net_netswitch->rx_packet.pkt.data = calloc(1, NET_MAX_FRAME);
net_event_init(&net_netswitch->tx_event);
net_event_init(&net_netswitch->stop_event);
#ifdef _WIN32
net_netswitch->sock_event = CreateEvent(NULL, FALSE, FALSE, NULL);
#endif
net_netswitch->poll_tid = thread_create(net_netswitch_thread, net_netswitch);
/* Add the timers */
#ifdef ENABLE_NET_SWITCH_STATS
timer_add(&net_netswitch->stats_timer, stats_timer, net_netswitch, 0);
timer_on_auto(&net_netswitch->stats_timer, 5000000);
#endif
timer_add(&net_netswitch->maintenance_timer, maintenance_timer, net_netswitch, 0);
timer_on_auto(&net_netswitch->maintenance_timer, SWITCH_KEEPALIVE_INTERVAL);
/* Send join message. Return status not checked here. */
ns_send_control(net_netswitch->nsconn, MessageType_MESSAGE_TYPE_JOIN);
return net_netswitch;
}
void
net_netswitch_in_available(void *priv)
{
net_netswitch_t *net_netswitch = (net_netswitch_t *) priv;
net_event_set(&net_netswitch->tx_event);
}
void
net_netswitch_close(void *priv)
{
if (priv == NULL)
return;
net_netswitch_t *net_netswitch = (net_netswitch_t *) priv;
net_switch_log("%s Net Switch: closing.\n", net_netswitch->switch_type);
/* Tell the thread to terminate. */
net_event_set(&net_netswitch->stop_event);
/* Wait for the thread to finish. */
net_switch_log("%s Net Switch: waiting for thread to end...\n", net_netswitch->switch_type);
thread_wait(net_netswitch->poll_tid);
net_switch_log("%s Net Switch: thread ended\n", net_netswitch->switch_type);
for (int i = 0; i < SWITCH_PKT_BATCH; i++) {
free(net_netswitch->pktv[i].data);
}
free(net_netswitch->rx_packet.pkt.data);
net_event_close(&net_netswitch->tx_event);
net_event_close(&net_netswitch->stop_event);
#ifdef _WIN32
WSACleanup();
#endif
ns_close(net_netswitch->nsconn);
free(net_netswitch);
}
const netdrv_t net_netswitch_drv = {
.notify_in = &net_netswitch_in_available,
.init = &net_netswitch_init,
.close = &net_netswitch_close,
.priv = NULL,
};

973
src/network/netswitch.c Normal file
View File

@@ -0,0 +1,973 @@
/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
*
* This file is part of the 86Box distribution.
*
* Network Switch backend
*
*
*
* Authors: cold-brewed
*
* Copyright 2024 cold-brewed
*/
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <wchar.h>
#include <stdbool.h>
#include <errno.h>
#include <fcntl.h>
#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <winsock2.h>
#else
# include <poll.h>
# include <netdb.h>
#endif
#define HAVE_STDARG_H
#include <86box/86box.h>
#include <86box/device.h>
#include <86box/thread.h>
#include <86box/timer.h>
#include <86box/network.h>
#include <86box/net_event.h>
#include <86box/random.h>
#include <sys/time.h>
#include "netswitch.h"
#include "pb_encode.h"
#include "pb_decode.h"
#include "networkmessage.pb.h"
bool ns_socket_setup(NSCONN *conn) {
if(conn == NULL) {
errno=EINVAL;
return false;
}
#ifdef _WIN32
// Initialize Windows Socket API with the given version.
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 0), &wsaData)) {
perror("WSAStartup");
return false;
}
#endif
/* Create the "main" socket
* Local mode: the listener socket for multicast packets
* Remote mode: the "main" socket for send and receive */
conn->fddata = socket(AF_INET, SOCK_DGRAM, 0);
if (conn->fddata < 0) {
perror("socket");
return false;
}
/* Here things diverge depending on local or remote type */
if(conn->switch_type == SWITCH_TYPE_LOCAL) {
/* Set socket options - allow multiple sockets to use the same address */
u_int on = 1;
if (setsockopt(conn->fddata, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on)) < 0) {
perror("Reusing ADDR failed");
return false;
}
#ifndef _WIN32
/* ... and same port number
* Not needed on windows because SO_REUSEPORT doesn't exist there. However, the same
* functionality comes along with SO_REUSEADDR. */
if (setsockopt(conn->fddata, SOL_SOCKET, SO_REUSEPORT, (char *) &on, sizeof(on)) < 0) {
perror("Reusing PORT failed");
return false;
}
#endif
memset(&conn->addr, 0, sizeof(conn->addr));
conn->addr.sin_family = AF_INET;
conn->addr.sin_addr.s_addr = htonl(INADDR_ANY);
conn->addr.sin_port = htons(conn->local_multicast_port);
/* Bind to receive address */
if (bind(conn->fddata, (struct sockaddr *) &conn->addr, sizeof(conn->addr)) < 0) {
perror("bind");
return false;
}
/* Request to join multicast group */
/*** NOTE: intermittent airplane (non-connected wifi) failures with 239.255.86.86 - needs more investigation */
struct ip_mreq mreq;
mreq.imr_multiaddr.s_addr = inet_addr(conn->mcast_group);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(conn->fddata, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, sizeof(mreq)) < 0) {
perror("setsockopt");
return false;
}
/* Now create the outgoing data socket */
conn->fdout = socket(AF_INET, SOCK_DGRAM, 0);
if (conn->fdout < 0) {
perror("out socket");
return false;
}
/* Set up destination address */
memset(&conn->outaddr, 0, sizeof(conn->outaddr));
conn->outaddr.sin_family = AF_INET;
conn->outaddr.sin_addr.s_addr = inet_addr(conn->mcast_group);
conn->outaddr.sin_port = htons(conn->local_multicast_port);
} else if (conn->switch_type == SWITCH_TYPE_REMOTE) {
/* Remote switch path */
int status;
struct addrinfo hints;
struct addrinfo *servinfo;
char connect_ip[128] = "\0";
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE; // not sure?
if((status = getaddrinfo(conn->nrs_hostname, NULL, &hints, &servinfo)) != 0) {
net_switch_log("getaddrinfo error: %s\n", gai_strerror(status));
errno=EFAULT;
return false;
}
for(const struct addrinfo *p = servinfo; p != NULL; p = p->ai_next) { // NOLINT (only want the first result)
/* Take the first result, ipv4 since AF_INET was set in the hints */
const struct sockaddr_in *ipv4 = (struct sockaddr_in *) p->ai_addr;
const void *addr = &(ipv4->sin_addr);
inet_ntop(p->ai_family, addr, connect_ip, sizeof connect_ip);
break;
}
freeaddrinfo(servinfo);
if(strlen(connect_ip) == 0) {
/* Couldn't look up the hostname */
net_switch_log("Hostname lookup failure?\n");
errno=EFAULT;
return false;
}
/* Set up local socket address and port */
memset(&conn->addr, 0, sizeof(conn->addr));
conn->addr.sin_family = AF_INET;
conn->addr.sin_addr.s_addr = htonl(INADDR_ANY);
conn->addr.sin_port = htons(conn->remote_source_port);
/* Bind to receive address. Try the first 100 ports to allow the use of multiple systems simultaneously */
for(int i=0; i<100; i++) {
if(i==99) {
net_switch_log("Unable to find an available port to bind\n");
return false;
}
if (bind(conn->fddata, (struct sockaddr *) &conn->addr, sizeof(conn->addr)) < 0) {
net_switch_log("local port %d unavailable, trying next..\n", conn->remote_source_port);
conn->remote_source_port += 1;
conn->addr.sin_port = htons(conn->remote_source_port);
continue ;
} else {
net_switch_log("** Local port for net remote switch is %d\n", conn->remote_source_port);
break;
}
}
/* Set up remote address and port */
memset(&conn->outaddr, 0, sizeof(conn->outaddr));
conn->outaddr.sin_family = AF_INET;
conn->outaddr.sin_addr.s_addr = inet_addr(connect_ip);
conn->outaddr.sin_port = htons(conn->remote_network_port);
/* In remote mode the file descriptor for send (fdout) is the same as receive */
conn->fdout = conn->fddata;
} else {
errno=EINVAL;
return false;
}
return true;
}
NSCONN *
ns_open(struct ns_open_args *open_args) {
struct nsconn *conn=NULL;
/* Each "group" is really just the base port + group number
* A different group effectively gets you a different switch
* Clamp the group at MAX_SWITCH_GROUP */
if(open_args->group > MAX_SWITCH_GROUP) {
open_args->group = MAX_SWITCH_GROUP;
}
// FIXME: hardcoded for testing
char *mcast_group = "239.255.86.86"; // Admin scope
// char *mcast_group = "224.0.0.86"; // Local scope
if ( (conn=calloc(1,sizeof(struct nsconn)))==NULL) {
errno=ENOMEM;
return NULL;
}
/* Type */
conn->switch_type = open_args->type;
/* Allocate the fragment buffer */
for (int i = 0; i < FRAGMENT_BUFFER_LENGTH; i++) {
conn->fragment_buffer[i] = calloc(1, sizeof(ns_fragment_t));
/* Set the default size to 0 and null data buffer to indicate it is unused.
* The data buffer will be allocated as needed. */
conn->fragment_buffer[i]->size = 0;
conn->fragment_buffer[i]->data = NULL;
}
// net_switch_log("Fragment buffers: %d total, %d each\n", FRAGMENT_BUFFER_LENGTH, MAX_FRAME_SEND_SIZE);
snprintf(conn->mcast_group, MAX_MCAST_GROUP_LEN, "%s", mcast_group);
conn->flags = open_args->flags;
/* Increment the multicast port by the switch group number. Each group is
* just a different port. */
conn->local_multicast_port = open_args->group + NET_SWITCH_MULTICAST_PORT;
conn->remote_network_port = NET_SWITCH_REMOTE_PORT;
/* Source ports for remote switch will start here and be incremented until an available port is found */
conn->remote_source_port = NET_SWITCH_REMOTE_PORT + NET_SWITCH_RECV_PORT_OFFSET;
/* Remote switch hostname */
strncpy(conn->nrs_hostname, open_args->nrs_hostname, sizeof(conn->nrs_hostname) - 1);
/* Switch type */
if(conn->switch_type == SWITCH_TYPE_REMOTE) {
net_switch_log("Connecting to remote %s:%d, initial local port %d, group %d\n", conn->nrs_hostname, conn->remote_network_port, conn->remote_source_port, open_args->group);
} else {
net_switch_log("Opening IP %s, port %d, group %d\n", mcast_group, conn->local_multicast_port, open_args->group);
}
/* Client state, disconnected by default.
* Primarily used in remote mode */
conn->client_state = DISCONNECTED;
/* Client ID. Generate the ID if set to zero. */
if(open_args->client_id == 0) {
conn->client_id = ns_gen_client_id();
}
/* MAC address is set from the emulated card */
memcpy(conn->mac_addr, open_args->mac_addr, PB_MAC_ADDR_SIZE);
/* Protocol version */
conn->version = NS_PROTOCOL_VERSION;
if(!ns_socket_setup(conn)) {
goto fail;
}
if (conn->switch_type == SWITCH_TYPE_REMOTE) {
/* Perhaps one day do the entire handshake process here */
if(!ns_send_control(conn, MessageType_MESSAGE_TYPE_CONNECT_REQUEST)) {
goto fail;
}
conn->client_state = CONNECTING;
net_switch_log("Client state is now CONNECTING\n");
} else {
conn->client_state = LOCAL;
}
/* Initialize sequence numbers */
conn->sequence = 1;
conn->remote_sequence = 1;
/* Initialize stats */
conn->stats.max_tx_frame = 0;
conn->stats.max_tx_packet = 0;
conn->stats.max_rx_frame = 0;
conn->stats.max_rx_packet = 0;
conn->stats.total_rx_packets = 0;
conn->stats.total_tx_packets = 0;
conn->stats.total_fragments = 0;
conn->stats.max_vec = 0;
memcpy(conn->stats.last_tx_ethertype, (uint8_t []) { 0, 0}, sizeof(conn->stats.last_tx_ethertype));
memcpy(conn->stats.last_rx_ethertype, (uint8_t []) { 0, 0}, sizeof(conn->stats.last_rx_ethertype));
/* Assuming all went well we have our sockets */
return conn;
/* Cleanup */
fail:
for (int i = 0; i < FRAGMENT_BUFFER_LENGTH; i++) {
free(conn->fragment_buffer[i]);
}
return NULL;
}
int
ns_pollfd(const NSCONN *conn) {
if (conn->fddata != 0)
return conn->fddata;
else {
errno=EBADF;
return -1;
}
}
ssize_t
ns_sock_recv(const NSCONN *conn,void *buf, const size_t len, const int flags) {
if (fd_valid(conn->fddata))
return recv(conn->fddata,buf,len,0);
else {
errno=EBADF;
return -1;
}
}
ssize_t
ns_sock_send(NSCONN *conn,const void *buf, const size_t len, const int flags) {
if (fd_valid(conn->fddata)) {
/* Use the outgoing socket for sending, set elsewhere:
* Remote mode: same as sending
* Local mode: different from sending */
return sendto(conn->fdout, buf, len, 0, (struct sockaddr *) &conn->outaddr, sizeof(conn->outaddr));
} else {
errno=EBADF;
return -1;
}
}
ssize_t
ns_send_pb(NSCONN *conn, const netpkt_t *packet,int flags) {
NetworkMessage network_message = NetworkMessage_init_zero;
uint8_t fragment_count;
/* Do we need to fragment? First, determine how many packets we will be sending */
if(packet->len <= MAX_FRAME_SEND_SIZE) {
fragment_count = 1;
// net_switch_log("No Fragmentation. Frame size %d is less than max size %d\n", packet->len, MAX_FRAME_SEND_SIZE);
} else {
/* Since we're using integer math and the remainder is
* discarded we'll add one to the result *unless* the result can be evenly divided. */
const uint8_t extra = (packet->len % MAX_FRAME_SEND_SIZE) == 0 ? 0 : 1;
fragment_count = (packet->len / MAX_FRAME_SEND_SIZE) + extra;
// net_switch_log("Fragmentation required, frame size %d exceeds max size %d\n", packet->len, MAX_FRAME_SEND_SIZE);
}
/* Loop here for each fragment. Send each fragment. In the even that the packet is *not* a fragment (regular data packet)
* this will only execute once. */
const uint32_t fragment_sequence = conn->sequence;
const int64_t packet_timestamp = ns_get_current_millis();
for (uint8_t fragment_index = 0; fragment_index < fragment_count; fragment_index++) {
uint8_t buffer[NET_SWITCH_BUFFER_LENGTH];
pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
#ifdef ENABLE_NET_SWITCH_PB_FILE_DEBUG
uint8_t file_buffer[NET_SWITCH_BUFFER_LENGTH];
/* file_stream used for debugging and writing the message to a file */
pb_ostream_t file_stream = pb_ostream_from_buffer(file_buffer, sizeof(file_buffer));
#endif
/* Single frame is type DATA, fragments are FRAGMENT */
network_message.message_type = fragment_count > 1 ? MessageType_MESSAGE_TYPE_FRAGMENT : MessageType_MESSAGE_TYPE_DATA;
network_message.client_id = conn->client_id;
network_message.timestamp = packet_timestamp;
network_message.version = conn->version;
/* Need some additional data if we're a fragment */
if(fragment_count > 1) {
network_message.fragment.total = fragment_count;
network_message.fragment.id = fragment_sequence;
network_message.fragment.sequence = fragment_index + 1;
network_message.has_fragment = true;
}
/* TODO: Better / real ack logic. Needs its own function. Currently just putting in dummy data. */
network_message.ack.id = 1;
network_message.ack.history = 1;
network_message.has_ack = true;
network_message.sequence = conn->sequence;
/* Frame data must be allocated */
network_message.frame = calloc(1, PB_BYTES_ARRAY_T_ALLOCSIZE(packet->len));
/* Calculate offsets based on our position in the fragment.
* For anything other than the *last* packet, we'll have a max frame size */
uint16_t copy_length;
const uint16_t copy_offset = fragment_index * MAX_FRAME_SEND_SIZE;
if(fragment_index == (fragment_count - 1)) {
copy_length = packet->len % MAX_FRAME_SEND_SIZE == 0 ? MAX_FRAME_SEND_SIZE : packet->len % MAX_FRAME_SEND_SIZE;
} else {
copy_length = MAX_FRAME_SEND_SIZE;
}
if(fragment_count > 1) {
// net_switch_log("Fragment %d/%d, %d bytes\n", fragment_index + 1, fragment_count, copy_length);
}
network_message.frame->size = copy_length;
memcpy(network_message.frame->bytes, packet->data + copy_offset, copy_length);
/* mac address must be allocated */
network_message.mac = calloc(1, PB_BYTES_ARRAY_T_ALLOCSIZE(PB_MAC_ADDR_SIZE));
network_message.mac->size = PB_MAC_ADDR_SIZE;
memcpy(network_message.mac->bytes, conn->mac_addr, PB_MAC_ADDR_SIZE);
/* Encode the protobuf message */
if (!pb_encode_ex(&stream, NetworkMessage_fields, &network_message,PB_ENCODE_DELIMITED)) {
net_switch_log("Encoding failed: %s\n", PB_GET_ERROR(&stream));
errno = EBADF;
return -1;
}
/* Send on the socket */
const ssize_t nc = ns_sock_send(conn, buffer, stream.bytes_written, 0);
if(!nc) {
net_switch_log("Error sending data on the socket\n");
errno=EBADF;
pb_release(NetworkMessage_fields, &network_message);
return -1;
}
#ifdef ENABLE_NET_SWITCH_PB_FILE_DEBUG
/* File writing for troubleshooting when needed */
FILE *f = fopen("/var/tmp/pbuf", "wb");
if (f) {
if (!pb_encode(&file_stream, NetworkMessage_fields, &network_message)) {
net_switch_log("File encoding failed: %s\n", PB_GET_ERROR(&file_stream));
}
fwrite(file_buffer, file_stream.bytes_written, 1, f);
fclose(f);
} else {
net_switch_log("file open failed\n");
}
#endif
/* Stats */
if(network_message.frame->size > conn->stats.max_tx_frame) {
conn->stats.max_tx_frame = network_message.frame->size;
}
if(nc > conn->stats.max_tx_packet) {
conn->stats.max_tx_packet = nc;
}
if(nc > MAX_FRAME_SEND_SIZE) {
conn->stats.total_fragments = fragment_count > 1 ? conn->stats.total_fragments += fragment_count : conn->stats.total_fragments;
}
conn->stats.total_tx_packets++;
memcpy(conn->stats.last_tx_ethertype, &packet->data[12], 2);
/* Increment the sequence number */
seq_increment(conn);
/* nanopb will free all the allocated entries for us */
pb_release(NetworkMessage_fields, &network_message);
}
return packet->len;
}
bool store_fragment(const NSCONN *conn, const NetworkMessage *network_message) {
if(conn == NULL || network_message == NULL) {
return false;
}
/* The fragment sequence indicates which fragment this is in the overall fragment
* collection. This is used to index the fragments while being stored for reassembly
* (zero indexed locally) */
const uint32_t fragment_index = network_message->fragment.sequence - 1;
const uint32_t fragment_size = network_message->frame->size;
/* Make sure the fragments aren't too small
* (see header notes about size requirements for MIN_FRAG_RECV_SIZE and FRAGMENT_BUFFER_LENGTH)
* NOTE: The last packet is exempt from this rule because it can have a smaller amount.
* This is primarily to ensure there's enough space to fit all the fragments. */
if(network_message->fragment.sequence != network_message->fragment.total) {
if (network_message->frame->size < MIN_FRAG_RECV_SIZE) {
net_switch_log("size: %d < %d\n", network_message->frame->size, MIN_FRAG_RECV_SIZE);
return false;
}
}
/* Make sure we can handle the amount of incoming fragments */
if (network_message->fragment.total > FRAGMENT_BUFFER_LENGTH) {
net_switch_log("buflen: %d > %d\n", network_message->fragment.total, FRAGMENT_BUFFER_LENGTH);
return false;
}
/* Allocate or reallocate as needed.
* size > 0 indicates this buffer has already been allocated. */
if(conn->fragment_buffer[fragment_index]->size > 0) {
conn->fragment_buffer[fragment_index]->data = realloc(conn->fragment_buffer[fragment_index]->data, sizeof(char) * fragment_size);
} else {
conn->fragment_buffer[fragment_index]->data = calloc(1, sizeof(char) * fragment_size);
}
if (conn->fragment_buffer[fragment_index]->data == NULL) {
net_switch_log("Failed to allocate / reallocate fragment buffer space\n");
return false;
}
/* Each fragment will belong to a particular ID. All members will have the same ID,
* which is generally set to the sequence number of the first fragment */
conn->fragment_buffer[fragment_index]->id = network_message->fragment.id;
/* The sequence here is set to the index of the packet in the total fragment collection
* (network_message->fragment.sequence) */
conn->fragment_buffer[fragment_index]->sequence = fragment_index;
/* Total number of fragments in this set */
conn->fragment_buffer[fragment_index]->total = network_message->fragment.total;
/* The sequence number from the packet that contained the fragment */
conn->fragment_buffer[fragment_index]->packet_sequence = network_message->sequence;
/* Copy the fragment data and size */
/* The size of fragment_buffer[fragment_index]->data is checked against MAX_FRAME_SEND_SIZE above */
memcpy(conn->fragment_buffer[fragment_index]->data, network_message->frame->bytes, fragment_size);
conn->fragment_buffer[fragment_index]->size = fragment_size;
/* 10 seconds for a TTL */
conn->fragment_buffer[fragment_index]->ttl = ns_get_current_millis() + 10000;
return true;
}
bool
reassemble_fragment(const NSCONN *conn, netpkt_t *pkt, const uint32_t packet_count)
{
uint32_t total = 0;
/* Make sure the reassembled packet doesn't exceed NET_MAX_FRAME */
// if (packet_count * MAX_FRAME_SEND_SIZE > NET_MAX_FRAME) {
// return false;
// }
/* Too many packets! */
if (packet_count > FRAGMENT_BUFFER_LENGTH) {
return false;
}
// TODO: Check fragment ID
// TODO: Check TTL
/* Get the fragment size from the first entry. All fragments in a particular
* set must be of the same size except the last fragment, which may be smaller.
* The fragment size will be used to determine the offset. */
const uint16_t fragment_size = conn->fragment_buffer[0]->size;
// net_switch_log("Reassembling %d fragments\n", packet_count);
for(int i = 0; i < packet_count; i++) {
/* Size of zero means we're trying to assemble from a bad fragment */
if(conn->fragment_buffer[i]->size == 0) {
net_switch_log("Fragment size 0 when trying to reassemble (id %i/index %i/seq %i/ total %i)\n",conn->fragment_buffer[i]->id, i, conn->fragment_buffer[i]->sequence, conn->fragment_buffer[i]->total);
return false;
}
if(conn->fragment_buffer[i]->data == NULL) {
net_switch_log("Missing fragment data when trying to reassemble\n");
return false;
}
memcpy(pkt->data + (fragment_size * i), conn->fragment_buffer[i]->data, conn->fragment_buffer[i]->size);
total += conn->fragment_buffer[i]->size;
/* Zero out the size to indicate the slot is unused */
conn->fragment_buffer[i]->size = 0;
free(conn->fragment_buffer[i]->data);
conn->fragment_buffer[i]->data = NULL;
}
/* Set the size, must cast due to netpkt_t (len is int) */
pkt->len = (int) total;
// net_switch_log("%d bytes reassembled and converted to data packet.\n", pkt->len);
return true;
}
bool
ns_recv_pb(NSCONN *conn, ns_rx_packet_t *packet,size_t len,int flags) {
NetworkMessage network_message = NetworkMessage_init_zero;
ns_rx_packet_t *ns_packet = packet;
uint8_t buffer[NET_SWITCH_BUFFER_LENGTH];
/* TODO: Use the passed len? Most likely not needed */
const ssize_t nc = ns_sock_recv(conn, buffer, NET_SWITCH_BUFFER_LENGTH, 0);
if(!nc) {
net_switch_log("Error receiving data on the socket\n");
errno=EBADF;
return false;
}
pb_istream_t stream = pb_istream_from_buffer(buffer, sizeof(buffer));
if (!pb_decode_delimited(&stream, NetworkMessage_fields, &network_message)) {
/* Decode failed */
net_switch_log("PB decoding failed: %s\n", PB_GET_ERROR(&stream));
/* Allocated fields are automatically released upon failure */
return false;
}
/* Basic checks for validity */
if(network_message.mac == NULL || network_message.message_type == MessageType_MESSAGE_TYPE_UNSPECIFIED ||
network_message.client_id == 0) {
net_switch_log("Invalid packet received! Skipping..\n");
goto fail;
}
/* These fields should always be set. Start copying into our packet structure. */
ns_packet->client_id = network_message.client_id;
ns_packet->type = network_message.message_type;
memcpy(ns_packet->mac, network_message.mac->bytes, PB_MAC_ADDR_SIZE);
ns_packet->timestamp = network_message.timestamp;
ns_packet->version = network_message.version;
conn->remote_sequence = network_message.sequence;
conn->last_packet_stamp = network_message.timestamp;
/* Control messages take a different path */
if(network_message.message_type != MessageType_MESSAGE_TYPE_DATA &&
network_message.message_type != MessageType_MESSAGE_TYPE_FRAGMENT) {
process_control_packet(conn, ns_packet);
pb_release(NetworkMessage_fields, &network_message);
return true;
}
/* All packets should be DATA or FRAGMENT at this point and have a frame */
if(network_message.frame == NULL) {
net_switch_log("Invalid data packet received! Frame is null. Skipping..\n");
goto fail;
}
/* Fragment path first */
if(network_message.message_type == MessageType_MESSAGE_TYPE_FRAGMENT) {
/* Store fragment */
if(!store_fragment(conn, &network_message)) {
net_switch_log("Failed to store fragment\n");
goto fail;
}
/* Is this the last fragment? If not, return */
if(network_message.fragment.sequence != network_message.fragment.total) {
// FIXME: Really dumb, needs to be smarter
pb_release(NetworkMessage_fields, &network_message);
return true;
}
/* This is the last fragment. Attempt to reassemble */
if(!reassemble_fragment(conn, &ns_packet->pkt, network_message.fragment.total)) {
net_switch_log("Failed to reassemble fragment\n");
goto fail;
}
/* Change the type to DATA */
ns_packet->type = MessageType_MESSAGE_TYPE_DATA;
} else {
/* Standard DATA packet path. Copy frame from the message */
memcpy(ns_packet->pkt.data, network_message.frame->bytes, network_message.frame->size);
ns_packet->pkt.len = network_message.frame->size;
}
/* Stats */
if(network_message.frame->size > conn->stats.max_rx_frame) {
conn->stats.max_rx_frame = network_message.frame->size;
}
if(nc > conn->stats.max_rx_packet) {
conn->stats.max_rx_packet = nc;
}
memcpy(conn->stats.last_rx_ethertype, &packet->pkt.data[12], 2);
conn->stats.total_rx_packets++;
/* End Stats */
/* nanopb allocates the necessary fields while serializing.
They need to be manually released once you are done with the message */
pb_release(NetworkMessage_fields, &network_message);
return true;
fail:
pb_release(NetworkMessage_fields, &network_message);
return false;
}
bool process_control_packet(NSCONN *conn, const ns_rx_packet_t *packet) {
control_packet_info_t packet_info = get_control_packet_info(*packet, conn->mac_addr);
// net_switch_log("Last timestamp: %lld\n", ns_get_current_millis());
// net_switch_log("(%lld ms) [%03d] ", ns_get_current_millis() - packet_info.timestamp, conn->sequence);
/* I probably want to eventually differentiate between local and remote here, kind of basic now */
if(!packet_info.is_packet_from_me) { /* in case of local mode */
switch (packet_info.type) {
case MessageType_MESSAGE_TYPE_JOIN:
net_switch_log("Client ID 0x%08llx (MAC %s) has joined the chat\n", packet_info.client_id, packet_info.src_mac_h);
break;
case MessageType_MESSAGE_TYPE_LEAVE:
net_switch_log("Client ID 0x%08llx (MAC %s) has left us\n", packet_info.client_id, packet_info.src_mac_h);
break;
case MessageType_MESSAGE_TYPE_KEEPALIVE:
// net_switch_log("Client ID 0x%08llx (MAC %s) is still alive\n", packet_info.client_id, packet_info.src_mac_h);
break;
case MessageType_MESSAGE_TYPE_ACK:
// net_switch_log("Client ID 0x%08llx (MAC %s) has sent an ACK\n", packet_info.client_id, packet_info.src_mac_h);
break;
case MessageType_MESSAGE_TYPE_CONNECT_REPLY:
conn->client_state = CONNECTED;
net_switch_log("Client ID 0x%08llx (MAC %s) has sent a connection reply\n", packet_info.client_id, packet_info.src_mac_h);
net_switch_log("Client state is now CONNECTED\n");
break;
case MessageType_MESSAGE_TYPE_FRAGMENT:
net_switch_log("Client ID 0x%08llx (MAC %s) has sent a fragment\n", packet_info.client_id, packet_info.src_mac_h);
break;
default:
net_switch_log("Client ID 0x%08llx (MAC %s) has sent a message that we don't understand (type %d)\n", packet_info.client_id, packet_info.src_mac_h, packet_info.type);
break;
}
}
return true;
}
bool
ns_send_control(NSCONN *conn, const MessageType type) {
NetworkMessage network_message = NetworkMessage_init_zero;
uint8_t buffer[NET_SWITCH_BUFFER_LENGTH];
pb_ostream_t stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
network_message.message_type = type;
network_message.client_id = conn->client_id;
/* No frame data so we only need to allocate mac address */
network_message.mac = calloc(1, PB_BYTES_ARRAY_T_ALLOCSIZE(PB_MAC_ADDR_SIZE));
network_message.mac->size = PB_MAC_ADDR_SIZE;
memcpy(network_message.mac->bytes, conn->mac_addr, PB_MAC_ADDR_SIZE);
network_message.timestamp = ns_get_current_millis();
network_message.version = conn->version;
network_message.sequence = conn->sequence;
if (!pb_encode_ex(&stream, NetworkMessage_fields, &network_message, PB_ENCODE_DELIMITED)) {
net_switch_log("Encoding failed: %s\n", PB_GET_ERROR(&stream));
errno = EBADF;
return false;
}
const ssize_t nc = ns_sock_send(conn, buffer, stream.bytes_written, 0);
if(!nc) {
net_switch_log("Error sending control message on the socket\n");
errno=EBADF;
pb_release(NetworkMessage_fields, &network_message);
return -1;
}
/* Increment the sequence number */
seq_increment(conn);
/* Stats */
conn->stats.total_tx_packets++;
/* Must release allocated data */
pb_release(NetworkMessage_fields, &network_message);
return true;
}
uint32_t
ns_gen_client_id(void) {
uint32_t msb;
do {
msb = random_generate();
} while (msb < 0x10);
return ( random_generate() | (random_generate() << 8) | (random_generate() << 16) | (msb << 24));
}
const char *
ns_printable_message_type(const MessageType type)
{
switch (type) {
case MessageType_MESSAGE_TYPE_DATA:
return "Data";
case MessageType_MESSAGE_TYPE_JOIN:
return "Join";
case MessageType_MESSAGE_TYPE_LEAVE:
return "Leave";
case MessageType_MESSAGE_TYPE_KEEPALIVE:
return "Keepalive";
case MessageType_MESSAGE_TYPE_FRAGMENT:
return "Fragment";
case MessageType_MESSAGE_TYPE_ACK:
return "Ack";
case MessageType_MESSAGE_TYPE_UNSPECIFIED:
return "Unspecified (shouldn't get this)";
default:
return "Unknown message type - probably hasn't been added yet!";
}
}
int64_t
ns_get_current_millis(void) {
struct timeval time;
gettimeofday(&time, NULL);
/* Windows won't properly promote integers so this is necessary */
const int64_t seconds = (int64_t) time.tv_sec * 1000;
return seconds + (time.tv_usec / 1000);
}
int
ns_flags(const NSCONN *conn) {
return conn->flags;
}
int
ns_close(NSCONN *conn) {
if(conn->switch_type == SWITCH_TYPE_REMOTE) {
/* TBD */
}
/* No need to check the return here as we're closing out */
ns_send_control(conn, MessageType_MESSAGE_TYPE_LEAVE);
for (int i = 0; i < FRAGMENT_BUFFER_LENGTH; i++) {
if (conn->fragment_buffer[i]->size > 0) {
free(conn->fragment_buffer[i]->data);
conn->fragment_buffer[i]->data = NULL;
}
free(conn->fragment_buffer[i]);
}
close(conn->fddata);
close(conn->fdout);
return 0;
}
bool is_control_packet(const ns_rx_packet_t *packet) {
return packet->type != MessageType_MESSAGE_TYPE_DATA;
}
bool is_fragment_packet(const ns_rx_packet_t *packet) {
return packet->type == MessageType_MESSAGE_TYPE_FRAGMENT;
}
bool ns_connected(const NSCONN *conn) {
if(conn->switch_type == SWITCH_TYPE_LOCAL) {
return true;
}
if(conn->switch_type == SWITCH_TYPE_REMOTE) {
if(conn->client_state == CONNECTED) {
return true;
}
}
return false;
}
char* formatted_mac(uint8_t mac_addr[6])
{
char *mac_h = calloc(1, sizeof(char)* 32);
for(int i=0; i < 6; i++) {
char octet[4];
snprintf(octet, sizeof(octet), "%02X%s", mac_addr[i], i < 5 ? ":" : "");
strncat(mac_h, octet, sizeof(mac_h) - 1);
}
return mac_h;
}
control_packet_info_t get_control_packet_info(const ns_rx_packet_t packet, const uint8_t *my_mac)
{
control_packet_info_t packet_info;
packet_info.src_mac_h[0] = '\0';
packet_info.printable[0] = '\0';
packet_info.client_id = packet.client_id;
memcpy(packet_info.src_mac, &packet.mac, 6);
packet_info.type = packet.type;
packet_info.is_packet_from_me = (memcmp(my_mac, packet_info.src_mac, sizeof(uint8_t) * 6) == 0);
char *formatted_mac_h = formatted_mac(packet_info.src_mac);
strncpy(packet_info.src_mac_h, formatted_mac_h, MAX_PRINTABLE_MAC);
free(formatted_mac_h);
snprintf(packet_info.printable, sizeof(packet_info.printable), "%s", ns_printable_message_type(packet_info.type));
packet_info.timestamp = packet.timestamp;
return packet_info;
}
data_packet_info_t
get_data_packet_info(const netpkt_t *packet, const uint8_t *my_mac) {
data_packet_info_t packet_info;
packet_info.src_mac_h[0] = '\0';
packet_info.dest_mac_h[0] = '\0';
packet_info.my_mac_h[0] = '\0';
packet_info.printable[0] = '\0';
memcpy(packet_info.dest_mac,&packet->data[0], 6);
memcpy(packet_info.src_mac, &packet->data[6], 6);
/* Broadcast and multicast are treated the same at L2 and both will have the
* least significant bit of 1 in the first transmitted byte.
* The below test matches 0xFF for standard broadcast along with 0x01 and 0x33 for multicast */
packet_info.is_broadcast = ((packet->data[0] & 1) == 1);
packet_info.is_packet_for_me = (memcmp(my_mac, packet_info.dest_mac, sizeof(uint8_t) * 6) == 0);
packet_info.is_packet_from_me = (memcmp(my_mac, packet_info.src_mac, sizeof(uint8_t) * 6) == 0);
packet_info.is_data_packet = packet->len > 0;
packet_info.size = packet->len;
/* Since this function is applied to every packet, only enable the pretty formatting below
* if logging is specifically enabled. */
#ifdef ENABLE_NET_SWITCH_LOG
/* Pretty formatting for hardware addresses */
for(int i=0; i < 6; i++) {
char octet[4];
snprintf(octet, sizeof(octet), "%02X%s", packet_info.src_mac[i], i < 5 ? ":" : "");
strncat(packet_info.src_mac_h, octet, sizeof (packet_info.src_mac_h) - 1);
snprintf(octet, sizeof(octet), "%02X%s", packet_info.dest_mac[i], i < 5 ? ":" : "");
strncat(packet_info.dest_mac_h, octet, sizeof (packet_info.dest_mac_h) - 1);
snprintf(octet, sizeof(octet), "%02X%s", my_mac[i], i < 5 ? ":" : "");
strncat(packet_info.my_mac_h, octet, sizeof (packet_info.my_mac_h) - 1);
}
/* Printable output formatting */
if(packet_info.is_broadcast) {
if(packet_info.is_packet_from_me) {
snprintf(packet_info.printable, sizeof(packet_info.printable), "(broadcast)");
} else {
snprintf(packet_info.printable, sizeof(packet_info.printable), "%s (broadcast)", packet_info.src_mac_h);
}
} else {
snprintf(packet_info.printable, sizeof(packet_info.printable), "%s%s -> %s%s", packet_info.src_mac_h, packet_info.is_packet_from_me ? " (me)" : " ",
packet_info.dest_mac_h, packet_info.is_packet_for_me ? " (me)" : "");
}
#endif
return packet_info;
}
bool
fd_valid(const int fd)
{
#ifdef _WIN32
int error_code;
int error_code_size = sizeof(error_code);
getsockopt(fd, SOL_SOCKET, SO_ERROR, (char *) &error_code, &error_code_size);
if (error_code == WSAENOTSOCK) {
return false;
}
return true;
#else
if (fcntl(fd, F_GETFD) == -1) {
return false;
}
/* All other values will be a valid fd */
return true;
#endif
}
bool
seq_increment(NSCONN *conn)
{
if(conn == NULL) {
return false;
}
conn->sequence++;
if (conn->sequence == 0) {
conn->sequence = 1;
}
return true;
}

298
src/network/netswitch.h Normal file
View File

@@ -0,0 +1,298 @@
/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
*
* This file is part of the 86Box distribution.
*
* Network Switch backend
*
*
*
* Authors: cold-brewed
*
* Copyright 2024 cold-brewed
*/
#ifndef NET_SWITCH_H
#define NET_SWITCH_H
#ifdef _WIN32
#include <Winsock2.h> // before Windows.h, else Winsock 1 conflict
#include <Ws2tcpip.h> // needed for ip_mreq definition for multicast
#include <Windows.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#endif
#include <unistd.h>
#include "pb.h"
#include "networkmessage.pb.h"
/* Local switch multicast port */
#define NET_SWITCH_MULTICAST_PORT 8086
/* Remote switch connect port */
#define NET_SWITCH_REMOTE_PORT 8088
/* Remove switch. This offset is where the local source ports will begin. */
#define NET_SWITCH_RECV_PORT_OFFSET 198
/* Multicast group (IP Address) maximum length. String representation. */
#define MAX_MCAST_GROUP_LEN 32
/* The buffer length used for both receiving on sockets and protobuf serialize / deserialize */
#define NET_SWITCH_BUFFER_LENGTH 2048
/* Any frame above this size gets fragmented */
#define MAX_FRAME_SEND_SIZE 1200
/* Minimum fragment size we'll accept */
#define MIN_FRAG_RECV_SIZE 12
/*
Size of the fragment buffer - how many can we hold?
Note: FRAGMENT_BUFFER_LENGTH * MIN_FRAG_RECV_SIZE *must* be greater
than NET_MAX_FRAME or bad things will happen with large packets!
*/
#define FRAGMENT_BUFFER_LENGTH 128
/* Maximum number of switch groups */
#define MAX_SWITCH_GROUP 31
/* Size of a mac address in bytes. Used for the protobuf serializing / deserializing */
#define PB_MAC_ADDR_SIZE 6
/* This will define the version in use and the minimum required for communication */
#define NS_PROTOCOL_VERSION 1
/* Maximum string size for a printable (formatted) mac address */
#define MAX_PRINTABLE_MAC 32
/* Maximum hostname length for a remote switch host */
#define MAX_HOSTNAME 128
typedef enum {
FLAGS_NONE = 0,
FLAGS_PROMISC = 1 << 0,
} ns_flags_t;
typedef enum {
SWITCH_TYPE_LOCAL = 0,
SWITCH_TYPE_REMOTE,
} ns_type_t;
typedef enum {
DISCONNECTED,
CONNECTING,
CONNECTED,
LOCAL,
} ns_client_state_t;
struct ns_open_args {
uint8_t group;
ns_flags_t flags;
ns_type_t type;
char *client_id;
uint8_t mac_addr[6];
char nrs_hostname[MAX_HOSTNAME];
};
struct nsconn;
typedef struct nsconn NSCONN;
struct ns_stats {
size_t max_tx_frame;
size_t max_tx_packet;
size_t max_rx_frame;
size_t max_rx_packet;
uint8_t last_tx_ethertype[2];
uint8_t last_rx_ethertype[2];
u_long total_rx_packets;
u_long total_tx_packets;
u_long total_fragments;
uint8_t max_vec;
};
typedef struct {
/* The ID of the fragment. All fragments in a set should have the same ID. */
uint32_t id;
/* The fragment index in the sequence of fragments. NOTE: one indexed, not zero!
* Example: the first fragment of three would be 1 in the sequence */
uint32_t sequence;
/* Total number of fragments for the collection */
uint32_t total;
/* The sequence number of the packet that delivered the fragment. Not the same as fragment sequence above! */
uint32_t packet_sequence;
/* Frame data */
char *data;
/* Frame size. A size of zero indicates an unused fragment slot and unallocated data field. */
uint32_t size;
/* Epoch time (in ms) that the fragment is valid until */
uint64_t ttl;
} ns_fragment_t;
struct nsconn {
uint16_t flags;
int fdctl;
int fddata;
int fdout;
char mcast_group[MAX_MCAST_GROUP_LEN];
struct sockaddr_in addr;
struct sockaddr_in outaddr;
size_t outlen;
struct sockaddr *sock;
struct sockaddr *outsock;
struct ns_stats stats;
uint32_t client_id;
uint8_t mac_addr[6];
uint16_t sequence;
uint16_t remote_sequence;
uint8_t version;
uint8_t switch_type;
ns_client_state_t client_state;
int64_t last_packet_stamp;
/* Remote switch hostname */
char nrs_hostname[MAX_HOSTNAME];
/* Remote connect port for remote network switch */
uint16_t remote_network_port;
/* Local multicast port for the local network switch */
uint16_t local_multicast_port;
/*
* The source port to receive packets. Only applies to remote mode.
* This will also be the source port for sent packets in order to aid
* NAT
*/
uint16_t remote_source_port;
ns_fragment_t *fragment_buffer[FRAGMENT_BUFFER_LENGTH];
};
typedef struct {
uint32_t id;
uint32_t history;
} ns_ack_t;
typedef struct {
uint32_t id;
uint32_t sequence;
uint32_t total;
} ns_fragment_info_t;
typedef struct {
netpkt_t pkt;
MessageType type;
uint32_t client_id;
uint8_t mac[6];
uint32_t flags;
int64_t timestamp;
ns_ack_t ack;
ns_fragment_info_t fragment;
uint32_t version;
} ns_rx_packet_t;
typedef struct {
size_t size;
char src_mac_h[MAX_PRINTABLE_MAC];
char dest_mac_h[MAX_PRINTABLE_MAC];
char my_mac_h[MAX_PRINTABLE_MAC];
uint8_t src_mac[6];
uint8_t dest_mac[6];
bool is_packet_from_me;
bool is_broadcast;
bool is_packet_for_me;
bool is_data_packet;
char printable[128];
} data_packet_info_t;
typedef struct {
uint8_t src_mac[6];
char src_mac_h[MAX_PRINTABLE_MAC];
bool is_packet_from_me;
MessageType type;
char printable[128];
uint64_t client_id;
int64_t timestamp;
} control_packet_info_t;
/* Initializes and opens the Net Multicast Switch */
NSCONN *ns_open(struct ns_open_args *open_args);
/* Returns the flags */
int ns_flags(const NSCONN *conn);
/* Returns the file descriptor for polling */
int ns_pollfd(const NSCONN *conn);
/* This should be used to receive serialized protobuf packets
* and have the output placed in the packet struct */
bool ns_recv_pb(NSCONN *conn, ns_rx_packet_t *packet,size_t len,int flags);
/* Do not call directly! Used internally */
ssize_t ns_sock_recv(const NSCONN *conn,void *buf,size_t len,int flags);
/* This should be used to send serialized protobuf packets
* and have the output placed in the packet struct */
ssize_t ns_send_pb(NSCONN *conn, const netpkt_t *packet,int flags);
/* Send control messages */
bool ns_send_control(NSCONN *conn, MessageType type);
const char* ns_printable_message_type(MessageType type);
/* Do not call directly! Used internally */
ssize_t ns_sock_send(NSCONN *conn,const void *buf,size_t len,int flags);
uint32_t ns_gen_client_id(void);
/* Closes and cleans up */
int ns_close(NSCONN *conn);
/* Return current time in milliseconds */
int64_t ns_get_current_millis(void);
/* Is the packet a control packet?
* Any type other than DATA is a control packet, including fragments */
bool is_control_packet(const ns_rx_packet_t *packet);
/* Logic for handling control packets */
bool process_control_packet(NSCONN *conn, const ns_rx_packet_t *packet);
/* Is the packet a fragment packet? */
bool is_fragment_packet(const ns_rx_packet_t *packet);
/* Store a fragment in the fragment buffer */
bool store_fragment(const NSCONN *conn, const NetworkMessage *network_message);
/* Reassemble a fragment from the fragment buffer */
bool reassemble_fragment(const NSCONN *conn, netpkt_t *pkt, uint32_t packet_count);
/* Set up the socket. Accounts for the differences between local and remote modes */
bool ns_socket_setup(NSCONN *conn);
/* Is the switch in a connected state? Always returns true in local mode */
bool ns_connected(const NSCONN *conn);
/* Return a string with a properly formatted mac address.
* Note: Caller must free! */
char* formatted_mac(uint8_t mac_addr[6]);
/* Used for control packet info and logic */
control_packet_info_t get_control_packet_info(ns_rx_packet_t packet, const uint8_t *my_mac);
/* Used for data packet info and logic */
data_packet_info_t get_data_packet_info(const netpkt_t *packet, const uint8_t *my_mac);
/* Checks for a valid file descriptor */
bool fd_valid(int fd);
/* Wrapping increment for the sequence number */
bool seq_increment(NSCONN *conn);
#ifdef ENABLE_NET_SWITCH_LOG
static void
net_switch_log(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
pclog_ex(fmt, ap);
va_end(ap);
}
#else
# define net_switch_log(fmt, ...)
#endif
#endif

11
src/network/network.c
View File

@@ -503,6 +503,11 @@ network_attach(void *card_drv, uint8_t *mac, NETRXCB rx, NETSETLINKSTATE set_lin
card->host_drv.priv = card->host_drv.init(card, mac, net_cards_conf[net_card_current].host_dev_name, net_drv_error);
break;
#endif
case NET_TYPE_NMSWITCH:
case NET_TYPE_NRSWITCH:
card->host_drv = net_netswitch_drv;
card->host_drv.priv = card->host_drv.init(card, mac, &net_cards_conf[net_card_current], net_drv_error);
break;
default:
card->host_drv.priv = NULL;
break;
@@ -514,6 +519,12 @@ network_attach(void *card_drv, uint8_t *mac, NETRXCB rx, NETSETLINKSTATE set_lin
if (!card->host_drv.priv) {
if(net_cards_conf[net_card_current].net_type != NET_TYPE_NONE) {
// FIXME: Hardcoded during dev
// FIXME: Remove when done!
if((net_cards_conf[net_card_current].net_type == NET_TYPE_NMSWITCH) ||
(net_cards_conf[net_card_current].net_type == NET_TYPE_NRSWITCH))
fatal("%s", net_drv_error);
// We're here because of a failure
swprintf(tempmsg, sizeof_w(tempmsg), L"%ls:\n\n%s\n\n%ls", plat_get_string(STRING_NET_ERROR), net_drv_error, plat_get_string(STRING_NET_ERROR_DESC));
ui_msgbox(MBX_ERROR, tempmsg);

19
src/network/networkmessage.pb.c Normal file
View File

@@ -0,0 +1,19 @@
/* Automatically generated nanopb constant definitions */
/* Generated by nanopb-0.4.8-dev */
#include "networkmessage.pb.h"
#if PB_PROTO_HEADER_VERSION != 40
#error Regenerate this file with the current version of nanopb generator.
#endif
PB_BIND(Fragment, Fragment, AUTO)
PB_BIND(Ack, Ack, AUTO)
PB_BIND(NetworkMessage, NetworkMessage, AUTO)

140
src/network/networkmessage.pb.h Normal file
View File

@@ -0,0 +1,140 @@
/* Automatically generated nanopb header */
/* Generated by nanopb-0.4.8-dev */
#ifndef PB_NETWORKMESSAGE_PB_H_INCLUDED
#define PB_NETWORKMESSAGE_PB_H_INCLUDED
#include "pb.h"
#if PB_PROTO_HEADER_VERSION != 40
#error Regenerate this file with the current version of nanopb generator.
#endif
/* Enum definitions */
typedef enum _MessageType {
MessageType_MESSAGE_TYPE_UNSPECIFIED = 0,
MessageType_MESSAGE_TYPE_DATA = 1,
MessageType_MESSAGE_TYPE_JOIN = 2,
MessageType_MESSAGE_TYPE_LEAVE = 3,
MessageType_MESSAGE_TYPE_KEEPALIVE = 4,
MessageType_MESSAGE_TYPE_FRAGMENT = 5,
MessageType_MESSAGE_TYPE_ACK = 6,
MessageType_MESSAGE_TYPE_CONNECT_REQUEST = 7,
MessageType_MESSAGE_TYPE_CONNECT_REPLY = 8
} MessageType;
/* Struct definitions */
typedef struct _Fragment {
uint32_t id;
uint32_t sequence;
uint32_t total;
} Fragment;
typedef struct _Ack {
uint32_t id;
uint32_t history;
} Ack;
typedef struct _NetworkMessage {
MessageType message_type;
uint32_t client_id;
pb_bytes_array_t *mac;
pb_bytes_array_t *frame;
uint32_t flags;
uint32_t version;
bool has_ack;
Ack ack;
bool has_fragment;
Fragment fragment;
int64_t timestamp;
uint32_t sequence;
} NetworkMessage;
#ifdef __cplusplus
extern "C" {
#endif
/* Helper constants for enums */
#define _MessageType_MIN MessageType_MESSAGE_TYPE_UNSPECIFIED
#define _MessageType_MAX MessageType_MESSAGE_TYPE_CONNECT_REPLY
#define _MessageType_ARRAYSIZE ((MessageType)(MessageType_MESSAGE_TYPE_CONNECT_REPLY+1))
#define NetworkMessage_message_type_ENUMTYPE MessageType
/* Initializer values for message structs */
#define Fragment_init_default {0, 0, 0}
#define Ack_init_default {0, 0}
#define NetworkMessage_init_default {_MessageType_MIN, 0, NULL, NULL, 0, 0, false, Ack_init_default, false, Fragment_init_default, 0, 0}
#define Fragment_init_zero {0, 0, 0}
#define Ack_init_zero {0, 0}
#define NetworkMessage_init_zero {_MessageType_MIN, 0, NULL, NULL, 0, 0, false, Ack_init_zero, false, Fragment_init_zero, 0, 0}
/* Field tags (for use in manual encoding/decoding) */
#define Fragment_id_tag 1
#define Fragment_sequence_tag 2
#define Fragment_total_tag 3
#define Ack_id_tag 1
#define Ack_history_tag 2
#define NetworkMessage_message_type_tag 1
#define NetworkMessage_client_id_tag 2
#define NetworkMessage_mac_tag 3
#define NetworkMessage_frame_tag 4
#define NetworkMessage_flags_tag 5
#define NetworkMessage_version_tag 6
#define NetworkMessage_ack_tag 7
#define NetworkMessage_fragment_tag 8
#define NetworkMessage_timestamp_tag 9
#define NetworkMessage_sequence_tag 10
/* Struct field encoding specification for nanopb */
#define Fragment_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UINT32, id, 1) \
X(a, STATIC, SINGULAR, UINT32, sequence, 2) \
X(a, STATIC, SINGULAR, UINT32, total, 3)
#define Fragment_CALLBACK NULL
#define Fragment_DEFAULT NULL
#define Ack_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UINT32, id, 1) \
X(a, STATIC, SINGULAR, UINT32, history, 2)
#define Ack_CALLBACK NULL
#define Ack_DEFAULT NULL
#define NetworkMessage_FIELDLIST(X, a) \
X(a, STATIC, SINGULAR, UENUM, message_type, 1) \
X(a, STATIC, SINGULAR, UINT32, client_id, 2) \
X(a, POINTER, SINGULAR, BYTES, mac, 3) \
X(a, POINTER, SINGULAR, BYTES, frame, 4) \
X(a, STATIC, SINGULAR, UINT32, flags, 5) \
X(a, STATIC, SINGULAR, UINT32, version, 6) \
X(a, STATIC, OPTIONAL, MESSAGE, ack, 7) \
X(a, STATIC, OPTIONAL, MESSAGE, fragment, 8) \
X(a, STATIC, SINGULAR, INT64, timestamp, 9) \
X(a, STATIC, SINGULAR, UINT32, sequence, 10)
#define NetworkMessage_CALLBACK NULL
#define NetworkMessage_DEFAULT NULL
#define NetworkMessage_ack_MSGTYPE Ack
#define NetworkMessage_fragment_MSGTYPE Fragment
extern const pb_msgdesc_t Fragment_msg;
extern const pb_msgdesc_t Ack_msg;
extern const pb_msgdesc_t NetworkMessage_msg;
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
#define Fragment_fields &Fragment_msg
#define Ack_fields &Ack_msg
#define NetworkMessage_fields &NetworkMessage_msg
/* Maximum encoded size of messages (where known) */
/* NetworkMessage_size depends on runtime parameters */
#define Ack_size 12
#define Fragment_size 18
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif

38
src/network/networkmessage.proto.txt Normal file
View File

@@ -0,0 +1,38 @@
syntax = "proto3";
import "nanopb.proto";
enum MessageType {
MESSAGE_TYPE_UNSPECIFIED = 0;
MESSAGE_TYPE_DATA = 1;
MESSAGE_TYPE_JOIN = 2;
MESSAGE_TYPE_LEAVE = 3;
MESSAGE_TYPE_KEEPALIVE = 4;
MESSAGE_TYPE_FRAGMENT = 5;
MESSAGE_TYPE_ACK = 6;
MESSAGE_TYPE_CONNECT_REQUEST = 7;
MESSAGE_TYPE_CONNECT_REPLY = 8;
}
message Fragment {
uint32 id = 1;
uint32 sequence = 2;
uint32 total = 3;
}
message Ack {
uint32 id = 1;
uint32 history = 2;
}
message NetworkMessage {
MessageType message_type = 1;
uint32 client_id = 2;
bytes mac = 3 [(nanopb).type = FT_POINTER];
bytes frame = 4 [(nanopb).type = FT_POINTER];
uint32 flags = 5;
uint32 version = 6;
Ack ack = 7;
Fragment fragment = 8;
int64 timestamp = 9;
uint32 sequence = 10;
}

917
src/network/pb.h Normal file
View File

@@ -0,0 +1,917 @@
/* Common parts of the nanopb library. Most of these are quite low-level
* stuff. For the high-level interface, see pb_encode.h and pb_decode.h.
*/
#ifndef PB_H_INCLUDED
#define PB_H_INCLUDED
/*****************************************************************
* Nanopb compilation time options. You can change these here by *
* uncommenting the lines, or on the compiler command line. *
*****************************************************************/
/* Enable support for dynamically allocated fields */
#define PB_ENABLE_MALLOC 1
/* Define this if your CPU / compiler combination does not support
* unaligned memory access to packed structures. Note that packed
* structures are only used when requested in .proto options. */
/* #define PB_NO_PACKED_STRUCTS 1 */
/* Increase the number of required fields that are tracked.
* A compiler warning will tell if you need this. */
/* #define PB_MAX_REQUIRED_FIELDS 256 */
/* Add support for tag numbers > 65536 and fields larger than 65536 bytes. */
/* #define PB_FIELD_32BIT 1 */
/* Disable support for error messages in order to save some code space. */
/* #define PB_NO_ERRMSG 1 */
/* Disable support for custom streams (support only memory buffers). */
#define PB_BUFFER_ONLY 1
/* Disable support for 64-bit datatypes, for compilers without int64_t
or to save some code space. */
/* #define PB_WITHOUT_64BIT 1 */
/* Don't encode scalar arrays as packed. This is only to be used when
* the decoder on the receiving side cannot process packed scalar arrays.
* Such example is older protobuf.js. */
/* #define PB_ENCODE_ARRAYS_UNPACKED 1 */
/* Enable conversion of doubles to floats for platforms that do not
* support 64-bit doubles. Most commonly AVR. */
/* #define PB_CONVERT_DOUBLE_FLOAT 1 */
/* Check whether incoming strings are valid UTF-8 sequences. Slows down
* the string processing slightly and slightly increases code size. */
/* #define PB_VALIDATE_UTF8 1 */
/* This can be defined if the platform is little-endian and has 8-bit bytes.
* Normally it is automatically detected based on __BYTE_ORDER__ macro. */
/* #define PB_LITTLE_ENDIAN_8BIT 1 */
/* Configure static assert mechanism. Instead of changing these, set your
* compiler to C11 standard mode if possible. */
/* #define PB_C99_STATIC_ASSERT 1 */
/* #define PB_NO_STATIC_ASSERT 1 */
/******************************************************************
* You usually don't need to change anything below this line. *
* Feel free to look around and use the defined macros, though. *
******************************************************************/
/* Version of the nanopb library. Just in case you want to check it in
* your own program. */
#define NANOPB_VERSION "nanopb-0.4.8-dev"
/* Include all the system headers needed by nanopb. You will need the
* definitions of the following:
* - strlen, memcpy, memset functions
* - [u]int_least8_t, uint_fast8_t, [u]int_least16_t, [u]int32_t, [u]int64_t
* - size_t
* - bool
*
* If you don't have the standard header files, you can instead provide
* a custom header that defines or includes all this. In that case,
* define PB_SYSTEM_HEADER to the path of this file.
*/
#ifdef PB_SYSTEM_HEADER
#include PB_SYSTEM_HEADER
#else
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <string.h>
#include <limits.h>
#ifdef PB_ENABLE_MALLOC
#include <stdlib.h>
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Macro for defining packed structures (compiler dependent).
* This just reduces memory requirements, but is not required.
*/
#if defined(PB_NO_PACKED_STRUCTS)
/* Disable struct packing */
# define PB_PACKED_STRUCT_START
# define PB_PACKED_STRUCT_END
# define pb_packed
#elif defined(__GNUC__) || defined(__clang__)
/* For GCC and clang */
# define PB_PACKED_STRUCT_START
# define PB_PACKED_STRUCT_END
# define pb_packed __attribute__((packed))
#elif defined(__ICCARM__) || defined(__CC_ARM)
/* For IAR ARM and Keil MDK-ARM compilers */
# define PB_PACKED_STRUCT_START _Pragma("pack(push, 1)")
# define PB_PACKED_STRUCT_END _Pragma("pack(pop)")
# define pb_packed
#elif defined(_MSC_VER) && (_MSC_VER >= 1500)
/* For Microsoft Visual C++ */
# define PB_PACKED_STRUCT_START __pragma(pack(push, 1))
# define PB_PACKED_STRUCT_END __pragma(pack(pop))
# define pb_packed
#else
/* Unknown compiler */
# define PB_PACKED_STRUCT_START
# define PB_PACKED_STRUCT_END
# define pb_packed
#endif
/* Detect endianness */
#ifndef PB_LITTLE_ENDIAN_8BIT
#if ((defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
(defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || \
defined(__THUMBEL__) || defined(__AARCH64EL__) || defined(_MIPSEL) || \
defined(_M_IX86) || defined(_M_X64) || defined(_M_ARM)) \
&& CHAR_BIT == 8
#define PB_LITTLE_ENDIAN_8BIT 1
#endif
#endif
/* Handly macro for suppressing unreferenced-parameter compiler warnings. */
#ifndef PB_UNUSED
#define PB_UNUSED(x) (void)(x)
#endif
/* Harvard-architecture processors may need special attributes for storing
* field information in program memory. */
#ifndef PB_PROGMEM
#ifdef __AVR__
#include <avr/pgmspace.h>
#define PB_PROGMEM PROGMEM
#define PB_PROGMEM_READU32(x) pgm_read_dword(&x)
#else
#define PB_PROGMEM
#define PB_PROGMEM_READU32(x) (x)
#endif
#endif
/* Compile-time assertion, used for checking compatible compilation options.
* If this does not work properly on your compiler, use
* #define PB_NO_STATIC_ASSERT to disable it.
*
* But before doing that, check carefully the error message / place where it
* comes from to see if the error has a real cause. Unfortunately the error
* message is not always very clear to read, but you can see the reason better
* in the place where the PB_STATIC_ASSERT macro was called.
*/
#ifndef PB_NO_STATIC_ASSERT
# ifndef PB_STATIC_ASSERT
# if defined(__ICCARM__)
/* IAR has static_assert keyword but no _Static_assert */
# define PB_STATIC_ASSERT(COND,MSG) static_assert(COND,#MSG);
# elif defined(_MSC_VER) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112)
/* MSVC in C89 mode supports static_assert() keyword anyway */
# define PB_STATIC_ASSERT(COND,MSG) static_assert(COND,#MSG);
# elif defined(PB_C99_STATIC_ASSERT)
/* Classic negative-size-array static assert mechanism */
# define PB_STATIC_ASSERT(COND,MSG) typedef char PB_STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
# define PB_STATIC_ASSERT_MSG(MSG, LINE, COUNTER) PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
# define PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) pb_static_assertion_##MSG##_##LINE##_##COUNTER
# elif defined(__cplusplus)
/* C++11 standard static_assert mechanism */
# define PB_STATIC_ASSERT(COND,MSG) static_assert(COND,#MSG);
# else
/* C11 standard _Static_assert mechanism */
# define PB_STATIC_ASSERT(COND,MSG) _Static_assert(COND,#MSG);
# endif
# endif
#else
/* Static asserts disabled by PB_NO_STATIC_ASSERT */
# define PB_STATIC_ASSERT(COND,MSG)
#endif
/* Test that PB_STATIC_ASSERT works
* If you get errors here, you may need to do one of these:
* - Enable C11 standard support in your compiler
* - Define PB_C99_STATIC_ASSERT to enable C99 standard support
* - Define PB_NO_STATIC_ASSERT to disable static asserts altogether
*/
PB_STATIC_ASSERT(1, STATIC_ASSERT_IS_NOT_WORKING)
/* Number of required fields to keep track of. */
#ifndef PB_MAX_REQUIRED_FIELDS
#define PB_MAX_REQUIRED_FIELDS 64
#endif
#if PB_MAX_REQUIRED_FIELDS < 64
#error You should not lower PB_MAX_REQUIRED_FIELDS from the default value (64).
#endif
#ifdef PB_WITHOUT_64BIT
#ifdef PB_CONVERT_DOUBLE_FLOAT
/* Cannot use doubles without 64-bit types */
#undef PB_CONVERT_DOUBLE_FLOAT
#endif
#endif
/* List of possible field types. These are used in the autogenerated code.
* Least-significant 4 bits tell the scalar type
* Most-significant 4 bits specify repeated/required/packed etc.
*/
typedef uint_least8_t pb_type_t;
/**** Field data types ****/
/* Numeric types */
#define PB_LTYPE_BOOL 0x00U /* bool */
#define PB_LTYPE_VARINT 0x01U /* int32, int64, enum, bool */
#define PB_LTYPE_UVARINT 0x02U /* uint32, uint64 */
#define PB_LTYPE_SVARINT 0x03U /* sint32, sint64 */
#define PB_LTYPE_FIXED32 0x04U /* fixed32, sfixed32, float */
#define PB_LTYPE_FIXED64 0x05U /* fixed64, sfixed64, double */
/* Marker for last packable field type. */
#define PB_LTYPE_LAST_PACKABLE 0x05U
/* Byte array with pre-allocated buffer.
* data_size is the length of the allocated PB_BYTES_ARRAY structure. */
#define PB_LTYPE_BYTES 0x06U
/* String with pre-allocated buffer.
* data_size is the maximum length. */
#define PB_LTYPE_STRING 0x07U
/* Submessage
* submsg_fields is pointer to field descriptions */
#define PB_LTYPE_SUBMESSAGE 0x08U
/* Submessage with pre-decoding callback
* The pre-decoding callback is stored as pb_callback_t right before pSize.
* submsg_fields is pointer to field descriptions */
#define PB_LTYPE_SUBMSG_W_CB 0x09U
/* Extension pseudo-field
* The field contains a pointer to pb_extension_t */
#define PB_LTYPE_EXTENSION 0x0AU
/* Byte array with inline, pre-allocated byffer.
* data_size is the length of the inline, allocated buffer.
* This differs from PB_LTYPE_BYTES by defining the element as
* pb_byte_t[data_size] rather than pb_bytes_array_t. */
#define PB_LTYPE_FIXED_LENGTH_BYTES 0x0BU
/* Number of declared LTYPES */
#define PB_LTYPES_COUNT 0x0CU
#define PB_LTYPE_MASK 0x0FU
/**** Field repetition rules ****/
#define PB_HTYPE_REQUIRED 0x00U
#define PB_HTYPE_OPTIONAL 0x10U
#define PB_HTYPE_SINGULAR 0x10U
#define PB_HTYPE_REPEATED 0x20U
#define PB_HTYPE_FIXARRAY 0x20U
#define PB_HTYPE_ONEOF 0x30U
#define PB_HTYPE_MASK 0x30U
/**** Field allocation types ****/
#define PB_ATYPE_STATIC 0x00U
#define PB_ATYPE_POINTER 0x80U
#define PB_ATYPE_CALLBACK 0x40U
#define PB_ATYPE_MASK 0xC0U
#define PB_ATYPE(x) ((x) & PB_ATYPE_MASK)
#define PB_HTYPE(x) ((x) & PB_HTYPE_MASK)
#define PB_LTYPE(x) ((x) & PB_LTYPE_MASK)
#define PB_LTYPE_IS_SUBMSG(x) (PB_LTYPE(x) == PB_LTYPE_SUBMESSAGE || \
PB_LTYPE(x) == PB_LTYPE_SUBMSG_W_CB)
/* Data type used for storing sizes of struct fields
* and array counts.
*/
#if defined(PB_FIELD_32BIT)
typedef uint32_t pb_size_t;
typedef int32_t pb_ssize_t;
#else
typedef uint_least16_t pb_size_t;
typedef int_least16_t pb_ssize_t;
#endif
#define PB_SIZE_MAX ((pb_size_t)-1)
/* Data type for storing encoded data and other byte streams.
* This typedef exists to support platforms where uint8_t does not exist.
* You can regard it as equivalent on uint8_t on other platforms.
*/
typedef uint_least8_t pb_byte_t;
/* Forward declaration of struct types */
typedef struct pb_istream_s pb_istream_t;
typedef struct pb_ostream_s pb_ostream_t;
typedef struct pb_field_iter_s pb_field_iter_t;
/* This structure is used in auto-generated constants
* to specify struct fields.
*/
typedef struct pb_msgdesc_s pb_msgdesc_t;
struct pb_msgdesc_s {
const uint32_t *field_info;
const pb_msgdesc_t * const * submsg_info;
const pb_byte_t *default_value;
bool (*field_callback)(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field);
pb_size_t field_count;
pb_size_t required_field_count;
pb_size_t largest_tag;
};
/* Iterator for message descriptor */
struct pb_field_iter_s {
const pb_msgdesc_t *descriptor; /* Pointer to message descriptor constant */
void *message; /* Pointer to start of the structure */
pb_size_t index; /* Index of the field */
pb_size_t field_info_index; /* Index to descriptor->field_info array */
pb_size_t required_field_index; /* Index that counts only the required fields */
pb_size_t submessage_index; /* Index that counts only submessages */
pb_size_t tag; /* Tag of current field */
pb_size_t data_size; /* sizeof() of a single item */
pb_size_t array_size; /* Number of array entries */
pb_type_t type; /* Type of current field */
void *pField; /* Pointer to current field in struct */
void *pData; /* Pointer to current data contents. Different than pField for arrays and pointers. */
void *pSize; /* Pointer to count/has field */
const pb_msgdesc_t *submsg_desc; /* For submessage fields, pointer to field descriptor for the submessage. */
};
/* For compatibility with legacy code */
typedef pb_field_iter_t pb_field_t;
/* Make sure that the standard integer types are of the expected sizes.
* Otherwise fixed32/fixed64 fields can break.
*
* If you get errors here, it probably means that your stdint.h is not
* correct for your platform.
*/
#ifndef PB_WITHOUT_64BIT
PB_STATIC_ASSERT(sizeof(int64_t) == 2 * sizeof(int32_t), INT64_T_WRONG_SIZE)
PB_STATIC_ASSERT(sizeof(uint64_t) == 2 * sizeof(uint32_t), UINT64_T_WRONG_SIZE)
#endif
/* This structure is used for 'bytes' arrays.
* It has the number of bytes in the beginning, and after that an array.
* Note that actual structs used will have a different length of bytes array.
*/
#define PB_BYTES_ARRAY_T(n) struct { pb_size_t size; pb_byte_t bytes[n]; }
#define PB_BYTES_ARRAY_T_ALLOCSIZE(n) ((size_t)n + offsetof(pb_bytes_array_t, bytes))
struct pb_bytes_array_s {
pb_size_t size;
pb_byte_t bytes[1];
};
typedef struct pb_bytes_array_s pb_bytes_array_t;
/* This structure is used for giving the callback function.
* It is stored in the message structure and filled in by the method that
* calls pb_decode.
*
* The decoding callback will be given a limited-length stream
* If the wire type was string, the length is the length of the string.
* If the wire type was a varint/fixed32/fixed64, the length is the length
* of the actual value.
* The function may be called multiple times (especially for repeated types,
* but also otherwise if the message happens to contain the field multiple
* times.)
*
* The encoding callback will receive the actual output stream.
* It should write all the data in one call, including the field tag and
* wire type. It can write multiple fields.
*
* The callback can be null if you want to skip a field.
*/
typedef struct pb_callback_s pb_callback_t;
struct pb_callback_s {
/* Callback functions receive a pointer to the arg field.
* You can access the value of the field as *arg, and modify it if needed.
*/
union {
bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void **arg);
bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
} funcs;
/* Free arg for use by callback */
void *arg;
};
extern bool pb_default_field_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
/* Wire types. Library user needs these only in encoder callbacks. */
typedef enum {
PB_WT_VARINT = 0,
PB_WT_64BIT = 1,
PB_WT_STRING = 2,
PB_WT_32BIT = 5,
PB_WT_PACKED = 255 /* PB_WT_PACKED is internal marker for packed arrays. */
} pb_wire_type_t;
/* Structure for defining the handling of unknown/extension fields.
* Usually the pb_extension_type_t structure is automatically generated,
* while the pb_extension_t structure is created by the user. However,
* if you want to catch all unknown fields, you can also create a custom
* pb_extension_type_t with your own callback.
*/
typedef struct pb_extension_type_s pb_extension_type_t;
typedef struct pb_extension_s pb_extension_t;
struct pb_extension_type_s {
/* Called for each unknown field in the message.
* If you handle the field, read off all of its data and return true.
* If you do not handle the field, do not read anything and return true.
* If you run into an error, return false.
* Set to NULL for default handler.
*/
bool (*decode)(pb_istream_t *stream, pb_extension_t *extension,
uint32_t tag, pb_wire_type_t wire_type);
/* Called once after all regular fields have been encoded.
* If you have something to write, do so and return true.
* If you do not have anything to write, just return true.
* If you run into an error, return false.
* Set to NULL for default handler.
*/
bool (*encode)(pb_ostream_t *stream, const pb_extension_t *extension);
/* Free field for use by the callback. */
const void *arg;
};
struct pb_extension_s {
/* Type describing the extension field. Usually you'll initialize
* this to a pointer to the automatically generated structure. */
const pb_extension_type_t *type;
/* Destination for the decoded data. This must match the datatype
* of the extension field. */
void *dest;
/* Pointer to the next extension handler, or NULL.
* If this extension does not match a field, the next handler is
* automatically called. */
pb_extension_t *next;
/* The decoder sets this to true if the extension was found.
* Ignored for encoding. */
bool found;
};
#define pb_extension_init_zero {NULL,NULL,NULL,false}
/* Memory allocation functions to use. You can define pb_realloc and
* pb_free to custom functions if you want. */
#ifdef PB_ENABLE_MALLOC
# ifndef pb_realloc
# define pb_realloc(ptr, size) realloc(ptr, size)
# endif
# ifndef pb_free
# define pb_free(ptr) free(ptr)
# endif
#endif
/* This is used to inform about need to regenerate .pb.h/.pb.c files. */
#define PB_PROTO_HEADER_VERSION 40
/* These macros are used to declare pb_field_t's in the constant array. */
/* Size of a structure member, in bytes. */
#define pb_membersize(st, m) (sizeof ((st*)0)->m)
/* Number of entries in an array. */
#define pb_arraysize(st, m) (pb_membersize(st, m) / pb_membersize(st, m[0]))
/* Delta from start of one member to the start of another member. */
#define pb_delta(st, m1, m2) ((int)offsetof(st, m1) - (int)offsetof(st, m2))
/* Force expansion of macro value */
#define PB_EXPAND(x) x
/* Binding of a message field set into a specific structure */
#define PB_BIND(msgname, structname, width) \
const uint32_t structname ## _field_info[] PB_PROGMEM = \
{ \
msgname ## _FIELDLIST(PB_GEN_FIELD_INFO_ ## width, structname) \
0 \
}; \
const pb_msgdesc_t* const structname ## _submsg_info[] = \
{ \
msgname ## _FIELDLIST(PB_GEN_SUBMSG_INFO, structname) \
NULL \
}; \
const pb_msgdesc_t structname ## _msg = \
{ \
structname ## _field_info, \
structname ## _submsg_info, \
msgname ## _DEFAULT, \
msgname ## _CALLBACK, \
0 msgname ## _FIELDLIST(PB_GEN_FIELD_COUNT, structname), \
0 msgname ## _FIELDLIST(PB_GEN_REQ_FIELD_COUNT, structname), \
0 msgname ## _FIELDLIST(PB_GEN_LARGEST_TAG, structname), \
}; \
msgname ## _FIELDLIST(PB_GEN_FIELD_INFO_ASSERT_ ## width, structname)
#define PB_GEN_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) +1
#define PB_GEN_REQ_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) \
+ (PB_HTYPE_ ## htype == PB_HTYPE_REQUIRED)
#define PB_GEN_LARGEST_TAG(structname, atype, htype, ltype, fieldname, tag) \
* 0 + tag
/* X-macro for generating the entries in struct_field_info[] array. */
#define PB_GEN_FIELD_INFO_1(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_1(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_2(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_2(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_4(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_4(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_8(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_8(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_AUTO(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_ ## atype, _PB_HTYPE_ ## htype, _PB_LTYPE_ ## ltype), \
tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_FIELDINFO_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size) \
PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size)
#define PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) \
PB_FIELDINFO_ ## width(tag, type, data_offset, data_size, size_offset, array_size)
/* X-macro for generating asserts that entries fit in struct_field_info[] array.
* The structure of macros here must match the structure above in PB_GEN_FIELD_INFO_x(),
* but it is not easily reused because of how macro substitutions work. */
#define PB_GEN_FIELD_INFO_ASSERT_1(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_ASSERT_1(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_ASSERT_2(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_ASSERT_2(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_ASSERT_4(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_ASSERT_4(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_ASSERT_8(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_ASSERT_8(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_GEN_FIELD_INFO_ASSERT_AUTO(structname, atype, htype, ltype, fieldname, tag) \
PB_FIELDINFO_ASSERT_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_ ## atype, _PB_HTYPE_ ## htype, _PB_LTYPE_ ## ltype), \
tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
#define PB_FIELDINFO_ASSERT_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size) \
PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size)
#define PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) \
PB_FIELDINFO_ASSERT_ ## width(tag, type, data_offset, data_size, size_offset, array_size)
#define PB_DATA_OFFSET_STATIC(htype, structname, fieldname) PB_DO ## htype(structname, fieldname)
#define PB_DATA_OFFSET_POINTER(htype, structname, fieldname) PB_DO ## htype(structname, fieldname)
#define PB_DATA_OFFSET_CALLBACK(htype, structname, fieldname) PB_DO ## htype(structname, fieldname)
#define PB_DO_PB_HTYPE_REQUIRED(structname, fieldname) offsetof(structname, fieldname)
#define PB_DO_PB_HTYPE_SINGULAR(structname, fieldname) offsetof(structname, fieldname)
#define PB_DO_PB_HTYPE_ONEOF(structname, fieldname) offsetof(structname, PB_ONEOF_NAME(FULL, fieldname))
#define PB_DO_PB_HTYPE_OPTIONAL(structname, fieldname) offsetof(structname, fieldname)
#define PB_DO_PB_HTYPE_REPEATED(structname, fieldname) offsetof(structname, fieldname)
#define PB_DO_PB_HTYPE_FIXARRAY(structname, fieldname) offsetof(structname, fieldname)
#define PB_SIZE_OFFSET_STATIC(htype, structname, fieldname) PB_SO ## htype(structname, fieldname)
#define PB_SIZE_OFFSET_POINTER(htype, structname, fieldname) PB_SO_PTR ## htype(structname, fieldname)
#define PB_SIZE_OFFSET_CALLBACK(htype, structname, fieldname) PB_SO_CB ## htype(structname, fieldname)
#define PB_SO_PB_HTYPE_REQUIRED(structname, fieldname) 0
#define PB_SO_PB_HTYPE_SINGULAR(structname, fieldname) 0
#define PB_SO_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF2(structname, PB_ONEOF_NAME(FULL, fieldname), PB_ONEOF_NAME(UNION, fieldname))
#define PB_SO_PB_HTYPE_ONEOF2(structname, fullname, unionname) PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname)
#define PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname) pb_delta(structname, fullname, which_ ## unionname)
#define PB_SO_PB_HTYPE_OPTIONAL(structname, fieldname) pb_delta(structname, fieldname, has_ ## fieldname)
#define PB_SO_PB_HTYPE_REPEATED(structname, fieldname) pb_delta(structname, fieldname, fieldname ## _count)
#define PB_SO_PB_HTYPE_FIXARRAY(structname, fieldname) 0
#define PB_SO_PTR_PB_HTYPE_REQUIRED(structname, fieldname) 0
#define PB_SO_PTR_PB_HTYPE_SINGULAR(structname, fieldname) 0
#define PB_SO_PTR_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF(structname, fieldname)
#define PB_SO_PTR_PB_HTYPE_OPTIONAL(structname, fieldname) 0
#define PB_SO_PTR_PB_HTYPE_REPEATED(structname, fieldname) PB_SO_PB_HTYPE_REPEATED(structname, fieldname)
#define PB_SO_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) 0
#define PB_SO_CB_PB_HTYPE_REQUIRED(structname, fieldname) 0
#define PB_SO_CB_PB_HTYPE_SINGULAR(structname, fieldname) 0
#define PB_SO_CB_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF(structname, fieldname)
#define PB_SO_CB_PB_HTYPE_OPTIONAL(structname, fieldname) 0
#define PB_SO_CB_PB_HTYPE_REPEATED(structname, fieldname) 0
#define PB_SO_CB_PB_HTYPE_FIXARRAY(structname, fieldname) 0
#define PB_ARRAY_SIZE_STATIC(htype, structname, fieldname) PB_AS ## htype(structname, fieldname)
#define PB_ARRAY_SIZE_POINTER(htype, structname, fieldname) PB_AS_PTR ## htype(structname, fieldname)
#define PB_ARRAY_SIZE_CALLBACK(htype, structname, fieldname) 1
#define PB_AS_PB_HTYPE_REQUIRED(structname, fieldname) 1
#define PB_AS_PB_HTYPE_SINGULAR(structname, fieldname) 1
#define PB_AS_PB_HTYPE_OPTIONAL(structname, fieldname) 1
#define PB_AS_PB_HTYPE_ONEOF(structname, fieldname) 1
#define PB_AS_PB_HTYPE_REPEATED(structname, fieldname) pb_arraysize(structname, fieldname)
#define PB_AS_PB_HTYPE_FIXARRAY(structname, fieldname) pb_arraysize(structname, fieldname)
#define PB_AS_PTR_PB_HTYPE_REQUIRED(structname, fieldname) 1
#define PB_AS_PTR_PB_HTYPE_SINGULAR(structname, fieldname) 1
#define PB_AS_PTR_PB_HTYPE_OPTIONAL(structname, fieldname) 1
#define PB_AS_PTR_PB_HTYPE_ONEOF(structname, fieldname) 1
#define PB_AS_PTR_PB_HTYPE_REPEATED(structname, fieldname) 1
#define PB_AS_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) pb_arraysize(structname, fieldname[0])
#define PB_DATA_SIZE_STATIC(htype, structname, fieldname) PB_DS ## htype(structname, fieldname)
#define PB_DATA_SIZE_POINTER(htype, structname, fieldname) PB_DS_PTR ## htype(structname, fieldname)
#define PB_DATA_SIZE_CALLBACK(htype, structname, fieldname) PB_DS_CB ## htype(structname, fieldname)
#define PB_DS_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_PB_HTYPE_ONEOF(structname, fieldname) pb_membersize(structname, PB_ONEOF_NAME(FULL, fieldname))
#define PB_DS_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname[0])
#define PB_DS_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname[0])
#define PB_DS_PTR_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname[0])
#define PB_DS_PTR_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname[0])
#define PB_DS_PTR_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname[0])
#define PB_DS_PTR_PB_HTYPE_ONEOF(structname, fieldname) pb_membersize(structname, PB_ONEOF_NAME(FULL, fieldname)[0])
#define PB_DS_PTR_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname[0])
#define PB_DS_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname[0][0])
#define PB_DS_CB_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_CB_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_CB_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_CB_PB_HTYPE_ONEOF(structname, fieldname) pb_membersize(structname, PB_ONEOF_NAME(FULL, fieldname))
#define PB_DS_CB_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_DS_CB_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname)
#define PB_ONEOF_NAME(type, tuple) PB_EXPAND(PB_ONEOF_NAME_ ## type tuple)
#define PB_ONEOF_NAME_UNION(unionname,membername,fullname) unionname
#define PB_ONEOF_NAME_MEMBER(unionname,membername,fullname) membername
#define PB_ONEOF_NAME_FULL(unionname,membername,fullname) fullname
#define PB_GEN_SUBMSG_INFO(structname, atype, htype, ltype, fieldname, tag) \
PB_SUBMSG_INFO_ ## htype(_PB_LTYPE_ ## ltype, structname, fieldname)
#define PB_SUBMSG_INFO_REQUIRED(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
#define PB_SUBMSG_INFO_SINGULAR(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
#define PB_SUBMSG_INFO_OPTIONAL(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
#define PB_SUBMSG_INFO_ONEOF(ltype, structname, fieldname) PB_SUBMSG_INFO_ONEOF2(ltype, structname, PB_ONEOF_NAME(UNION, fieldname), PB_ONEOF_NAME(MEMBER, fieldname))
#define PB_SUBMSG_INFO_ONEOF2(ltype, structname, unionname, membername) PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername)
#define PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername) PB_SI ## ltype(structname ## _ ## unionname ## _ ## membername ## _MSGTYPE)
#define PB_SUBMSG_INFO_REPEATED(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
#define PB_SUBMSG_INFO_FIXARRAY(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
#define PB_SI_PB_LTYPE_BOOL(t)
#define PB_SI_PB_LTYPE_BYTES(t)
#define PB_SI_PB_LTYPE_DOUBLE(t)
#define PB_SI_PB_LTYPE_ENUM(t)
#define PB_SI_PB_LTYPE_UENUM(t)
#define PB_SI_PB_LTYPE_FIXED32(t)
#define PB_SI_PB_LTYPE_FIXED64(t)
#define PB_SI_PB_LTYPE_FLOAT(t)
#define PB_SI_PB_LTYPE_INT32(t)
#define PB_SI_PB_LTYPE_INT64(t)
#define PB_SI_PB_LTYPE_MESSAGE(t) PB_SUBMSG_DESCRIPTOR(t)
#define PB_SI_PB_LTYPE_MSG_W_CB(t) PB_SUBMSG_DESCRIPTOR(t)
#define PB_SI_PB_LTYPE_SFIXED32(t)
#define PB_SI_PB_LTYPE_SFIXED64(t)
#define PB_SI_PB_LTYPE_SINT32(t)
#define PB_SI_PB_LTYPE_SINT64(t)
#define PB_SI_PB_LTYPE_STRING(t)
#define PB_SI_PB_LTYPE_UINT32(t)
#define PB_SI_PB_LTYPE_UINT64(t)
#define PB_SI_PB_LTYPE_EXTENSION(t)
#define PB_SI_PB_LTYPE_FIXED_LENGTH_BYTES(t)
#define PB_SUBMSG_DESCRIPTOR(t) &(t ## _msg),
/* The field descriptors use a variable width format, with width of either
* 1, 2, 4 or 8 of 32-bit words. The two lowest bytes of the first byte always
* encode the descriptor size, 6 lowest bits of field tag number, and 8 bits
* of the field type.
*
* Descriptor size is encoded as 0 = 1 word, 1 = 2 words, 2 = 4 words, 3 = 8 words.
*
* Formats, listed starting with the least significant bit of the first word.
* 1 word: [2-bit len] [6-bit tag] [8-bit type] [8-bit data_offset] [4-bit size_offset] [4-bit data_size]
*
* 2 words: [2-bit len] [6-bit tag] [8-bit type] [12-bit array_size] [4-bit size_offset]
* [16-bit data_offset] [12-bit data_size] [4-bit tag>>6]
*
* 4 words: [2-bit len] [6-bit tag] [8-bit type] [16-bit array_size]
* [8-bit size_offset] [24-bit tag>>6]
* [32-bit data_offset]
* [32-bit data_size]
*
* 8 words: [2-bit len] [6-bit tag] [8-bit type] [16-bit reserved]
* [8-bit size_offset] [24-bit tag>>6]
* [32-bit data_offset]
* [32-bit data_size]
* [32-bit array_size]
* [32-bit reserved]
* [32-bit reserved]
* [32-bit reserved]
*/
#define PB_FIELDINFO_1(tag, type, data_offset, data_size, size_offset, array_size) \
(0 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(data_offset) & 0xFF) << 16) | \
(((uint32_t)(size_offset) & 0x0F) << 24) | (((uint32_t)(data_size) & 0x0F) << 28)),
#define PB_FIELDINFO_2(tag, type, data_offset, data_size, size_offset, array_size) \
(1 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size) & 0xFFF) << 16) | (((uint32_t)(size_offset) & 0x0F) << 28)), \
(((uint32_t)(data_offset) & 0xFFFF) | (((uint32_t)(data_size) & 0xFFF) << 16) | (((uint32_t)(tag) & 0x3c0) << 22)),
#define PB_FIELDINFO_4(tag, type, data_offset, data_size, size_offset, array_size) \
(2 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size) & 0xFFFF) << 16)), \
((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), \
(data_offset), (data_size),
#define PB_FIELDINFO_8(tag, type, data_offset, data_size, size_offset, array_size) \
(3 | (((tag) << 2) & 0xFF) | ((type) << 8)), \
((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), \
(data_offset), (data_size), (array_size), 0, 0, 0,
/* These assertions verify that the field information fits in the allocated space.
* The generator tries to automatically determine the correct width that can fit all
* data associated with a message. These asserts will fail only if there has been a
* problem in the automatic logic - this may be worth reporting as a bug. As a workaround,
* you can increase the descriptor width by defining PB_FIELDINFO_WIDTH or by setting
* descriptorsize option in .options file.
*/
#define PB_FITS(value,bits) ((uint32_t)(value) < ((uint32_t)1<<bits))
#define PB_FIELDINFO_ASSERT_1(tag, type, data_offset, data_size, size_offset, array_size) \
PB_STATIC_ASSERT(PB_FITS(tag,6) && PB_FITS(data_offset,8) && PB_FITS(size_offset,4) && PB_FITS(data_size,4) && PB_FITS(array_size,1), FIELDINFO_DOES_NOT_FIT_width1_field ## tag)
#define PB_FIELDINFO_ASSERT_2(tag, type, data_offset, data_size, size_offset, array_size) \
PB_STATIC_ASSERT(PB_FITS(tag,10) && PB_FITS(data_offset,16) && PB_FITS(size_offset,4) && PB_FITS(data_size,12) && PB_FITS(array_size,12), FIELDINFO_DOES_NOT_FIT_width2_field ## tag)
#ifndef PB_FIELD_32BIT
/* Maximum field sizes are still 16-bit if pb_size_t is 16-bit */
#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size) \
PB_STATIC_ASSERT(PB_FITS(tag,16) && PB_FITS(data_offset,16) && PB_FITS((int_least8_t)size_offset,8) && PB_FITS(data_size,16) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width4_field ## tag)
#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size) \
PB_STATIC_ASSERT(PB_FITS(tag,16) && PB_FITS(data_offset,16) && PB_FITS((int_least8_t)size_offset,8) && PB_FITS(data_size,16) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width8_field ## tag)
#else
/* Up to 32-bit fields supported.
* Note that the checks are against 31 bits to avoid compiler warnings about shift wider than type in the test.
* I expect that there is no reasonable use for >2GB messages with nanopb anyway.
*/
#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size) \
PB_STATIC_ASSERT(PB_FITS(tag,30) && PB_FITS(data_offset,31) && PB_FITS(size_offset,8) && PB_FITS(data_size,31) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width4_field ## tag)
#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size) \
PB_STATIC_ASSERT(PB_FITS(tag,30) && PB_FITS(data_offset,31) && PB_FITS(size_offset,8) && PB_FITS(data_size,31) && PB_FITS(array_size,31), FIELDINFO_DOES_NOT_FIT_width8_field ## tag)
#endif
/* Automatic picking of FIELDINFO width:
* Uses width 1 when possible, otherwise resorts to width 2.
* This is used when PB_BIND() is called with "AUTO" as the argument.
* The generator will give explicit size argument when it knows that a message
* structure grows beyond 1-word format limits.
*/
#define PB_FIELDINFO_WIDTH_AUTO(atype, htype, ltype) PB_FI_WIDTH ## atype(htype, ltype)
#define PB_FI_WIDTH_PB_ATYPE_STATIC(htype, ltype) PB_FI_WIDTH ## htype(ltype)
#define PB_FI_WIDTH_PB_ATYPE_POINTER(htype, ltype) PB_FI_WIDTH ## htype(ltype)
#define PB_FI_WIDTH_PB_ATYPE_CALLBACK(htype, ltype) 2
#define PB_FI_WIDTH_PB_HTYPE_REQUIRED(ltype) PB_FI_WIDTH ## ltype
#define PB_FI_WIDTH_PB_HTYPE_SINGULAR(ltype) PB_FI_WIDTH ## ltype
#define PB_FI_WIDTH_PB_HTYPE_OPTIONAL(ltype) PB_FI_WIDTH ## ltype
#define PB_FI_WIDTH_PB_HTYPE_ONEOF(ltype) PB_FI_WIDTH ## ltype
#define PB_FI_WIDTH_PB_HTYPE_REPEATED(ltype) 2
#define PB_FI_WIDTH_PB_HTYPE_FIXARRAY(ltype) 2
#define PB_FI_WIDTH_PB_LTYPE_BOOL 1
#define PB_FI_WIDTH_PB_LTYPE_BYTES 2
#define PB_FI_WIDTH_PB_LTYPE_DOUBLE 1
#define PB_FI_WIDTH_PB_LTYPE_ENUM 1
#define PB_FI_WIDTH_PB_LTYPE_UENUM 1
#define PB_FI_WIDTH_PB_LTYPE_FIXED32 1
#define PB_FI_WIDTH_PB_LTYPE_FIXED64 1
#define PB_FI_WIDTH_PB_LTYPE_FLOAT 1
#define PB_FI_WIDTH_PB_LTYPE_INT32 1
#define PB_FI_WIDTH_PB_LTYPE_INT64 1
#define PB_FI_WIDTH_PB_LTYPE_MESSAGE 2
#define PB_FI_WIDTH_PB_LTYPE_MSG_W_CB 2
#define PB_FI_WIDTH_PB_LTYPE_SFIXED32 1
#define PB_FI_WIDTH_PB_LTYPE_SFIXED64 1
#define PB_FI_WIDTH_PB_LTYPE_SINT32 1
#define PB_FI_WIDTH_PB_LTYPE_SINT64 1
#define PB_FI_WIDTH_PB_LTYPE_STRING 2
#define PB_FI_WIDTH_PB_LTYPE_UINT32 1
#define PB_FI_WIDTH_PB_LTYPE_UINT64 1
#define PB_FI_WIDTH_PB_LTYPE_EXTENSION 1
#define PB_FI_WIDTH_PB_LTYPE_FIXED_LENGTH_BYTES 2
/* The mapping from protobuf types to LTYPEs is done using these macros. */
#define PB_LTYPE_MAP_BOOL PB_LTYPE_BOOL
#define PB_LTYPE_MAP_BYTES PB_LTYPE_BYTES
#define PB_LTYPE_MAP_DOUBLE PB_LTYPE_FIXED64
#define PB_LTYPE_MAP_ENUM PB_LTYPE_VARINT
#define PB_LTYPE_MAP_UENUM PB_LTYPE_UVARINT
#define PB_LTYPE_MAP_FIXED32 PB_LTYPE_FIXED32
#define PB_LTYPE_MAP_FIXED64 PB_LTYPE_FIXED64
#define PB_LTYPE_MAP_FLOAT PB_LTYPE_FIXED32
#define PB_LTYPE_MAP_INT32 PB_LTYPE_VARINT
#define PB_LTYPE_MAP_INT64 PB_LTYPE_VARINT
#define PB_LTYPE_MAP_MESSAGE PB_LTYPE_SUBMESSAGE
#define PB_LTYPE_MAP_MSG_W_CB PB_LTYPE_SUBMSG_W_CB
#define PB_LTYPE_MAP_SFIXED32 PB_LTYPE_FIXED32
#define PB_LTYPE_MAP_SFIXED64 PB_LTYPE_FIXED64
#define PB_LTYPE_MAP_SINT32 PB_LTYPE_SVARINT
#define PB_LTYPE_MAP_SINT64 PB_LTYPE_SVARINT
#define PB_LTYPE_MAP_STRING PB_LTYPE_STRING
#define PB_LTYPE_MAP_UINT32 PB_LTYPE_UVARINT
#define PB_LTYPE_MAP_UINT64 PB_LTYPE_UVARINT
#define PB_LTYPE_MAP_EXTENSION PB_LTYPE_EXTENSION
#define PB_LTYPE_MAP_FIXED_LENGTH_BYTES PB_LTYPE_FIXED_LENGTH_BYTES
/* These macros are used for giving out error messages.
* They are mostly a debugging aid; the main error information
* is the true/false return value from functions.
* Some code space can be saved by disabling the error
* messages if not used.
*
* PB_SET_ERROR() sets the error message if none has been set yet.
* msg must be a constant string literal.
* PB_GET_ERROR() always returns a pointer to a string.
* PB_RETURN_ERROR() sets the error and returns false from current
* function.
*/
#ifdef PB_NO_ERRMSG
#define PB_SET_ERROR(stream, msg) PB_UNUSED(stream)
#define PB_GET_ERROR(stream) "(errmsg disabled)"
#else
#define PB_SET_ERROR(stream, msg) (stream->errmsg = (stream)->errmsg ? (stream)->errmsg : (msg))
#define PB_GET_ERROR(stream) ((stream)->errmsg ? (stream)->errmsg : "(none)")
#endif
#define PB_RETURN_ERROR(stream, msg) return PB_SET_ERROR(stream, msg), false
#ifdef __cplusplus
} /* extern "C" */
#endif
#ifdef __cplusplus
#if __cplusplus >= 201103L
#define PB_CONSTEXPR constexpr
#else // __cplusplus >= 201103L
#define PB_CONSTEXPR
#endif // __cplusplus >= 201103L
#if __cplusplus >= 201703L
#define PB_INLINE_CONSTEXPR inline constexpr
#else // __cplusplus >= 201703L
#define PB_INLINE_CONSTEXPR PB_CONSTEXPR
#endif // __cplusplus >= 201703L
extern "C++"
{
namespace nanopb {
// Each type will be partially specialized by the generator.
template <typename GenMessageT> struct MessageDescriptor;
} // namespace nanopb
}
#endif /* __cplusplus */
#endif

388
src/network/pb_common.c Normal file
View File

@@ -0,0 +1,388 @@
/* pb_common.c: Common support functions for pb_encode.c and pb_decode.c.
*
* 2014 Petteri Aimonen <jpa@kapsi.fi>
*/
#include "pb_common.h"
static bool load_descriptor_values(pb_field_iter_t *iter)
{
uint32_t word0;
uint32_t data_offset;
int_least8_t size_offset;
if (iter->index >= iter->descriptor->field_count)
return false;
word0 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
iter->type = (pb_type_t)((word0 >> 8) & 0xFF);
switch(word0 & 3)
{
case 0: {
/* 1-word format */
iter->array_size = 1;
iter->tag = (pb_size_t)((word0 >> 2) & 0x3F);
size_offset = (int_least8_t)((word0 >> 24) & 0x0F);
data_offset = (word0 >> 16) & 0xFF;
iter->data_size = (pb_size_t)((word0 >> 28) & 0x0F);
break;
}
case 1: {
/* 2-word format */
uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]);
iter->array_size = (pb_size_t)((word0 >> 16) & 0x0FFF);
iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 28) << 6));
size_offset = (int_least8_t)((word0 >> 28) & 0x0F);
data_offset = word1 & 0xFFFF;
iter->data_size = (pb_size_t)((word1 >> 16) & 0x0FFF);
break;
}
case 2: {
/* 4-word format */
uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]);
uint32_t word2 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 2]);
uint32_t word3 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 3]);
iter->array_size = (pb_size_t)(word0 >> 16);
iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 8) << 6));
size_offset = (int_least8_t)(word1 & 0xFF);
data_offset = word2;
iter->data_size = (pb_size_t)word3;
break;
}
default: {
/* 8-word format */
uint32_t word1 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 1]);
uint32_t word2 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 2]);
uint32_t word3 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 3]);
uint32_t word4 = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index + 4]);
iter->array_size = (pb_size_t)word4;
iter->tag = (pb_size_t)(((word0 >> 2) & 0x3F) | ((word1 >> 8) << 6));
size_offset = (int_least8_t)(word1 & 0xFF);
data_offset = word2;
iter->data_size = (pb_size_t)word3;
break;
}
}
if (!iter->message)
{
/* Avoid doing arithmetic on null pointers, it is undefined */
iter->pField = NULL;
iter->pSize = NULL;
}
else
{
iter->pField = (char*)iter->message + data_offset;
if (size_offset)
{
iter->pSize = (char*)iter->pField - size_offset;
}
else if (PB_HTYPE(iter->type) == PB_HTYPE_REPEATED &&
(PB_ATYPE(iter->type) == PB_ATYPE_STATIC ||
PB_ATYPE(iter->type) == PB_ATYPE_POINTER))
{
/* Fixed count array */
iter->pSize = &iter->array_size;
}
else
{
iter->pSize = NULL;
}
if (PB_ATYPE(iter->type) == PB_ATYPE_POINTER && iter->pField != NULL)
{
iter->pData = *(void**)iter->pField;
}
else
{
iter->pData = iter->pField;
}
}
if (PB_LTYPE_IS_SUBMSG(iter->type))
{
iter->submsg_desc = iter->descriptor->submsg_info[iter->submessage_index];
}
else
{
iter->submsg_desc = NULL;
}
return true;
}
static void advance_iterator(pb_field_iter_t *iter)
{
iter->index++;
if (iter->index >= iter->descriptor->field_count)
{
/* Restart */
iter->index = 0;
iter->field_info_index = 0;
iter->submessage_index = 0;
iter->required_field_index = 0;
}
else
{
/* Increment indexes based on previous field type.
* All field info formats have the following fields:
* - lowest 2 bits tell the amount of words in the descriptor (2^n words)
* - bits 2..7 give the lowest bits of tag number.
* - bits 8..15 give the field type.
*/
uint32_t prev_descriptor = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
pb_type_t prev_type = (prev_descriptor >> 8) & 0xFF;
pb_size_t descriptor_len = (pb_size_t)(1 << (prev_descriptor & 3));
/* Add to fields.
* The cast to pb_size_t is needed to avoid -Wconversion warning.
* Because the data is is constants from generator, there is no danger of overflow.
*/
iter->field_info_index = (pb_size_t)(iter->field_info_index + descriptor_len);
iter->required_field_index = (pb_size_t)(iter->required_field_index + (PB_HTYPE(prev_type) == PB_HTYPE_REQUIRED));
iter->submessage_index = (pb_size_t)(iter->submessage_index + PB_LTYPE_IS_SUBMSG(prev_type));
}
}
bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_msgdesc_t *desc, void *message)
{
memset(iter, 0, sizeof(*iter));
iter->descriptor = desc;
iter->message = message;
return load_descriptor_values(iter);
}
bool pb_field_iter_begin_extension(pb_field_iter_t *iter, pb_extension_t *extension)
{
const pb_msgdesc_t *msg = (const pb_msgdesc_t*)extension->type->arg;
bool status;
uint32_t word0 = PB_PROGMEM_READU32(msg->field_info[0]);
if (PB_ATYPE(word0 >> 8) == PB_ATYPE_POINTER)
{
/* For pointer extensions, the pointer is stored directly
* in the extension structure. This avoids having an extra
* indirection. */
status = pb_field_iter_begin(iter, msg, &extension->dest);
}
else
{
status = pb_field_iter_begin(iter, msg, extension->dest);
}
iter->pSize = &extension->found;
return status;
}
bool pb_field_iter_next(pb_field_iter_t *iter)
{
advance_iterator(iter);
(void)load_descriptor_values(iter);
return iter->index != 0;
}
bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag)
{
if (iter->tag == tag)
{
return true; /* Nothing to do, correct field already. */
}
else if (tag > iter->descriptor->largest_tag)
{
return false;
}
else
{
pb_size_t start = iter->index;
uint32_t fieldinfo;
if (tag < iter->tag)
{
/* Fields are in tag number order, so we know that tag is between
* 0 and our start position. Setting index to end forces
* advance_iterator() call below to restart from beginning. */
iter->index = iter->descriptor->field_count;
}
do
{
/* Advance iterator but don't load values yet */
advance_iterator(iter);
/* Do fast check for tag number match */
fieldinfo = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
if (((fieldinfo >> 2) & 0x3F) == (tag & 0x3F))
{
/* Good candidate, check further */
(void)load_descriptor_values(iter);
if (iter->tag == tag &&
PB_LTYPE(iter->type) != PB_LTYPE_EXTENSION)
{
/* Found it */
return true;
}
}
} while (iter->index != start);
/* Searched all the way back to start, and found nothing. */
(void)load_descriptor_values(iter);
return false;
}
}
bool pb_field_iter_find_extension(pb_field_iter_t *iter)
{
if (PB_LTYPE(iter->type) == PB_LTYPE_EXTENSION)
{
return true;
}
else
{
pb_size_t start = iter->index;
uint32_t fieldinfo;
do
{
/* Advance iterator but don't load values yet */
advance_iterator(iter);
/* Do fast check for field type */
fieldinfo = PB_PROGMEM_READU32(iter->descriptor->field_info[iter->field_info_index]);
if (PB_LTYPE((fieldinfo >> 8) & 0xFF) == PB_LTYPE_EXTENSION)
{
return load_descriptor_values(iter);
}
} while (iter->index != start);
/* Searched all the way back to start, and found nothing. */
(void)load_descriptor_values(iter);
return false;
}
}
static void *pb_const_cast(const void *p)
{
/* Note: this casts away const, in order to use the common field iterator
* logic for both encoding and decoding. The cast is done using union
* to avoid spurious compiler warnings. */
union {
void *p1;
const void *p2;
} t;
t.p2 = p;
return t.p1;
}
bool pb_field_iter_begin_const(pb_field_iter_t *iter, const pb_msgdesc_t *desc, const void *message)
{
return pb_field_iter_begin(iter, desc, pb_const_cast(message));
}
bool pb_field_iter_begin_extension_const(pb_field_iter_t *iter, const pb_extension_t *extension)
{
return pb_field_iter_begin_extension(iter, (pb_extension_t*)pb_const_cast(extension));
}
bool pb_default_field_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field)
{
if (field->data_size == sizeof(pb_callback_t))
{
pb_callback_t *pCallback = (pb_callback_t*)field->pData;
if (pCallback != NULL)
{
if (istream != NULL && pCallback->funcs.decode != NULL)
{
return pCallback->funcs.decode(istream, field, &pCallback->arg);
}
if (ostream != NULL && pCallback->funcs.encode != NULL)
{
return pCallback->funcs.encode(ostream, field, &pCallback->arg);
}
}
}
return true; /* Success, but didn't do anything */
}
#ifdef PB_VALIDATE_UTF8
/* This function checks whether a string is valid UTF-8 text.
*
* Algorithm is adapted from https://www.cl.cam.ac.uk/~mgk25/ucs/utf8_check.c
* Original copyright: Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> 2005-03-30
* Licensed under "Short code license", which allows use under MIT license or
* any compatible with it.
*/
bool pb_validate_utf8(const char *str)
{
const pb_byte_t *s = (const pb_byte_t*)str;
while (*s)
{
if (*s < 0x80)
{
/* 0xxxxxxx */
s++;
}
else if ((s[0] & 0xe0) == 0xc0)
{
/* 110XXXXx 10xxxxxx */
if ((s[1] & 0xc0) != 0x80 ||
(s[0] & 0xfe) == 0xc0) /* overlong? */
return false;
else
s += 2;
}
else if ((s[0] & 0xf0) == 0xe0)
{
/* 1110XXXX 10Xxxxxx 10xxxxxx */
if ((s[1] & 0xc0) != 0x80 ||
(s[2] & 0xc0) != 0x80 ||
(s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) || /* overlong? */
(s[0] == 0xed && (s[1] & 0xe0) == 0xa0) || /* surrogate? */
(s[0] == 0xef && s[1] == 0xbf &&
(s[2] & 0xfe) == 0xbe)) /* U+FFFE or U+FFFF? */
return false;
else
s += 3;
}
else if ((s[0] & 0xf8) == 0xf0)
{
/* 11110XXX 10XXxxxx 10xxxxxx 10xxxxxx */
if ((s[1] & 0xc0) != 0x80 ||
(s[2] & 0xc0) != 0x80 ||
(s[3] & 0xc0) != 0x80 ||
(s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) || /* overlong? */
(s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4) /* > U+10FFFF? */
return false;
else
s += 4;
}
else
{
return false;
}
}
return true;
}
#endif

49
src/network/pb_common.h Normal file
View File

@@ -0,0 +1,49 @@
/* pb_common.h: Common support functions for pb_encode.c and pb_decode.c.
* These functions are rarely needed by applications directly.
*/
#ifndef PB_COMMON_H_INCLUDED
#define PB_COMMON_H_INCLUDED
#include "pb.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Initialize the field iterator structure to beginning.
* Returns false if the message type is empty. */
bool pb_field_iter_begin(pb_field_iter_t *iter, const pb_msgdesc_t *desc, void *message);
/* Get a field iterator for extension field. */
bool pb_field_iter_begin_extension(pb_field_iter_t *iter, pb_extension_t *extension);
/* Same as pb_field_iter_begin(), but for const message pointer.
* Note that the pointers in pb_field_iter_t will be non-const but shouldn't
* be written to when using these functions. */
bool pb_field_iter_begin_const(pb_field_iter_t *iter, const pb_msgdesc_t *desc, const void *message);
bool pb_field_iter_begin_extension_const(pb_field_iter_t *iter, const pb_extension_t *extension);
/* Advance the iterator to the next field.
* Returns false when the iterator wraps back to the first field. */
bool pb_field_iter_next(pb_field_iter_t *iter);
/* Advance the iterator until it points at a field with the given tag.
* Returns false if no such field exists. */
bool pb_field_iter_find(pb_field_iter_t *iter, uint32_t tag);
/* Find a field with type PB_LTYPE_EXTENSION, or return false if not found.
* There can be only one extension range field per message. */
bool pb_field_iter_find_extension(pb_field_iter_t *iter);
#ifdef PB_VALIDATE_UTF8
/* Validate UTF-8 text string */
bool pb_validate_utf8(const char *s);
#endif
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif

1727
src/network/pb_decode.c Normal file
View File

File diff suppressed because it is too large Load Diff

193
src/network/pb_decode.h Normal file
View File

@@ -0,0 +1,193 @@
/* pb_decode.h: Functions to decode protocol buffers. Depends on pb_decode.c.
* The main function is pb_decode. You also need an input stream, and the
* field descriptions created by nanopb_generator.py.
*/
#ifndef PB_DECODE_H_INCLUDED
#define PB_DECODE_H_INCLUDED
#include "pb.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Structure for defining custom input streams. You will need to provide
* a callback function to read the bytes from your storage, which can be
* for example a file or a network socket.
*
* The callback must conform to these rules:
*
* 1) Return false on IO errors. This will cause decoding to abort.
* 2) You can use state to store your own data (e.g. buffer pointer),
* and rely on pb_read to verify that no-body reads past bytes_left.
* 3) Your callback may be used with substreams, in which case bytes_left
* is different than from the main stream. Don't use bytes_left to compute
* any pointers.
*/
struct pb_istream_s
{
#ifdef PB_BUFFER_ONLY
/* Callback pointer is not used in buffer-only configuration.
* Having an int pointer here allows binary compatibility but
* gives an error if someone tries to assign callback function.
*/
int *callback;
#else
bool (*callback)(pb_istream_t *stream, pb_byte_t *buf, size_t count);
#endif
void *state; /* Free field for use by callback implementation */
size_t bytes_left;
#ifndef PB_NO_ERRMSG
const char *errmsg;
#endif
};
#ifndef PB_NO_ERRMSG
#define PB_ISTREAM_EMPTY {0,0,0,0}
#else
#define PB_ISTREAM_EMPTY {0,0,0}
#endif
/***************************
* Main decoding functions *
***************************/
/* Decode a single protocol buffers message from input stream into a C structure.
* Returns true on success, false on any failure.
* The actual struct pointed to by dest must match the description in fields.
* Callback fields of the destination structure must be initialized by caller.
* All other fields will be initialized by this function.
*
* Example usage:
* MyMessage msg = {};
* uint8_t buffer[64];
* pb_istream_t stream;
*
* // ... read some data into buffer ...
*
* stream = pb_istream_from_buffer(buffer, count);
* pb_decode(&stream, MyMessage_fields, &msg);
*/
bool pb_decode(pb_istream_t *stream, const pb_msgdesc_t *fields, void *dest_struct);
/* Extended version of pb_decode, with several options to control
* the decoding process:
*
* PB_DECODE_NOINIT: Do not initialize the fields to default values.
* This is slightly faster if you do not need the default
* values and instead initialize the structure to 0 using
* e.g. memset(). This can also be used for merging two
* messages, i.e. combine already existing data with new
* values.
*
* PB_DECODE_DELIMITED: Input message starts with the message size as varint.
* Corresponds to parseDelimitedFrom() in Google's
* protobuf API.
*
* PB_DECODE_NULLTERMINATED: Stop reading when field tag is read as 0. This allows
* reading null terminated messages.
* NOTE: Until nanopb-0.4.0, pb_decode() also allows
* null-termination. This behaviour is not supported in
* most other protobuf implementations, so PB_DECODE_DELIMITED
* is a better option for compatibility.
*
* Multiple flags can be combined with bitwise or (| operator)
*/
#define PB_DECODE_NOINIT 0x01U
#define PB_DECODE_DELIMITED 0x02U
#define PB_DECODE_NULLTERMINATED 0x04U
bool pb_decode_ex(pb_istream_t *stream, const pb_msgdesc_t *fields, void *dest_struct, unsigned int flags);
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
#define pb_decode_noinit(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_NOINIT)
#define pb_decode_delimited(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_DELIMITED)
#define pb_decode_delimited_noinit(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_DELIMITED | PB_DECODE_NOINIT)
#define pb_decode_nullterminated(s,f,d) pb_decode_ex(s,f,d, PB_DECODE_NULLTERMINATED)
/* Release any allocated pointer fields. If you use dynamic allocation, you should
* call this for any successfully decoded message when you are done with it. If
* pb_decode() returns with an error, the message is already released.
*/
void pb_release(const pb_msgdesc_t *fields, void *dest_struct);
/**************************************
* Functions for manipulating streams *
**************************************/
/* Create an input stream for reading from a memory buffer.
*
* msglen should be the actual length of the message, not the full size of
* allocated buffer.
*
* Alternatively, you can use a custom stream that reads directly from e.g.
* a file or a network socket.
*/
pb_istream_t pb_istream_from_buffer(const pb_byte_t *buf, size_t msglen);
/* Function to read from a pb_istream_t. You can use this if you need to
* read some custom header data, or to read data in field callbacks.
*/
bool pb_read(pb_istream_t *stream, pb_byte_t *buf, size_t count);
/************************************************
* Helper functions for writing field callbacks *
************************************************/
/* Decode the tag for the next field in the stream. Gives the wire type and
* field tag. At end of the message, returns false and sets eof to true. */
bool pb_decode_tag(pb_istream_t *stream, pb_wire_type_t *wire_type, uint32_t *tag, bool *eof);
/* Skip the field payload data, given the wire type. */
bool pb_skip_field(pb_istream_t *stream, pb_wire_type_t wire_type);
/* Decode an integer in the varint format. This works for enum, int32,
* int64, uint32 and uint64 field types. */
#ifndef PB_WITHOUT_64BIT
bool pb_decode_varint(pb_istream_t *stream, uint64_t *dest);
#else
#define pb_decode_varint pb_decode_varint32
#endif
/* Decode an integer in the varint format. This works for enum, int32,
* and uint32 field types. */
bool pb_decode_varint32(pb_istream_t *stream, uint32_t *dest);
/* Decode a bool value in varint format. */
bool pb_decode_bool(pb_istream_t *stream, bool *dest);
/* Decode an integer in the zig-zagged svarint format. This works for sint32
* and sint64. */
#ifndef PB_WITHOUT_64BIT
bool pb_decode_svarint(pb_istream_t *stream, int64_t *dest);
#else
bool pb_decode_svarint(pb_istream_t *stream, int32_t *dest);
#endif
/* Decode a fixed32, sfixed32 or float value. You need to pass a pointer to
* a 4-byte wide C variable. */
bool pb_decode_fixed32(pb_istream_t *stream, void *dest);
#ifndef PB_WITHOUT_64BIT
/* Decode a fixed64, sfixed64 or double value. You need to pass a pointer to
* a 8-byte wide C variable. */
bool pb_decode_fixed64(pb_istream_t *stream, void *dest);
#endif
#ifdef PB_CONVERT_DOUBLE_FLOAT
/* Decode a double value into float variable. */
bool pb_decode_double_as_float(pb_istream_t *stream, float *dest);
#endif
/* Make a limited-length substream for reading a PB_WT_STRING field. */
bool pb_make_string_substream(pb_istream_t *stream, pb_istream_t *substream);
bool pb_close_string_substream(pb_istream_t *stream, pb_istream_t *substream);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif

1000
src/network/pb_encode.c Normal file
View File

File diff suppressed because it is too large Load Diff

185
src/network/pb_encode.h Normal file
View File

@@ -0,0 +1,185 @@
/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
* The main function is pb_encode. You also need an output stream, and the
* field descriptions created by nanopb_generator.py.
*/
#ifndef PB_ENCODE_H_INCLUDED
#define PB_ENCODE_H_INCLUDED
#include "pb.h"
#ifdef __cplusplus
extern "C" {
#endif
/* Structure for defining custom output streams. You will need to provide
* a callback function to write the bytes to your storage, which can be
* for example a file or a network socket.
*
* The callback must conform to these rules:
*
* 1) Return false on IO errors. This will cause encoding to abort.
* 2) You can use state to store your own data (e.g. buffer pointer).
* 3) pb_write will update bytes_written after your callback runs.
* 4) Substreams will modify max_size and bytes_written. Don't use them
* to calculate any pointers.
*/
struct pb_ostream_s
{
#ifdef PB_BUFFER_ONLY
/* Callback pointer is not used in buffer-only configuration.
* Having an int pointer here allows binary compatibility but
* gives an error if someone tries to assign callback function.
* Also, NULL pointer marks a 'sizing stream' that does not
* write anything.
*/
const int *callback;
#else
bool (*callback)(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
#endif
void *state; /* Free field for use by callback implementation. */
size_t max_size; /* Limit number of output bytes written (or use SIZE_MAX). */
size_t bytes_written; /* Number of bytes written so far. */
#ifndef PB_NO_ERRMSG
const char *errmsg;
#endif
};
/***************************
* Main encoding functions *
***************************/
/* Encode a single protocol buffers message from C structure into a stream.
* Returns true on success, false on any failure.
* The actual struct pointed to by src_struct must match the description in fields.
* All required fields in the struct are assumed to have been filled in.
*
* Example usage:
* MyMessage msg = {};
* uint8_t buffer[64];
* pb_ostream_t stream;
*
* msg.field1 = 42;
* stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
* pb_encode(&stream, MyMessage_fields, &msg);
*/
bool pb_encode(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct);
/* Extended version of pb_encode, with several options to control the
* encoding process:
*
* PB_ENCODE_DELIMITED: Prepend the length of message as a varint.
* Corresponds to writeDelimitedTo() in Google's
* protobuf API.
*
* PB_ENCODE_NULLTERMINATED: Append a null byte to the message for termination.
* NOTE: This behaviour is not supported in most other
* protobuf implementations, so PB_ENCODE_DELIMITED
* is a better option for compatibility.
*/
#define PB_ENCODE_DELIMITED 0x02U
#define PB_ENCODE_NULLTERMINATED 0x04U
bool pb_encode_ex(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct, unsigned int flags);
/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
#define pb_encode_delimited(s,f,d) pb_encode_ex(s,f,d, PB_ENCODE_DELIMITED)
#define pb_encode_nullterminated(s,f,d) pb_encode_ex(s,f,d, PB_ENCODE_NULLTERMINATED)
/* Encode the message to get the size of the encoded data, but do not store
* the data. */
bool pb_get_encoded_size(size_t *size, const pb_msgdesc_t *fields, const void *src_struct);
/**************************************
* Functions for manipulating streams *
**************************************/
/* Create an output stream for writing into a memory buffer.
* The number of bytes written can be found in stream.bytes_written after
* encoding the message.
*
* Alternatively, you can use a custom stream that writes directly to e.g.
* a file or a network socket.
*/
pb_ostream_t pb_ostream_from_buffer(pb_byte_t *buf, size_t bufsize);
/* Pseudo-stream for measuring the size of a message without actually storing
* the encoded data.
*
* Example usage:
* MyMessage msg = {};
* pb_ostream_t stream = PB_OSTREAM_SIZING;
* pb_encode(&stream, MyMessage_fields, &msg);
* printf("Message size is %d\n", stream.bytes_written);
*/
#ifndef PB_NO_ERRMSG
#define PB_OSTREAM_SIZING {0,0,0,0,0}
#else
#define PB_OSTREAM_SIZING {0,0,0,0}
#endif
/* Function to write into a pb_ostream_t stream. You can use this if you need
* to append or prepend some custom headers to the message.
*/
bool pb_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
/************************************************
* Helper functions for writing field callbacks *
************************************************/
/* Encode field header based on type and field number defined in the field
* structure. Call this from the callback before writing out field contents. */
bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_iter_t *field);
/* Encode field header by manually specifying wire type. You need to use this
* if you want to write out packed arrays from a callback field. */
bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
/* Encode an integer in the varint format.
* This works for bool, enum, int32, int64, uint32 and uint64 field types. */
#ifndef PB_WITHOUT_64BIT
bool pb_encode_varint(pb_ostream_t *stream, uint64_t value);
#else
bool pb_encode_varint(pb_ostream_t *stream, uint32_t value);
#endif
/* Encode an integer in the zig-zagged svarint format.
* This works for sint32 and sint64. */
#ifndef PB_WITHOUT_64BIT
bool pb_encode_svarint(pb_ostream_t *stream, int64_t value);
#else
bool pb_encode_svarint(pb_ostream_t *stream, int32_t value);
#endif
/* Encode a string or bytes type field. For strings, pass strlen(s) as size. */
bool pb_encode_string(pb_ostream_t *stream, const pb_byte_t *buffer, size_t size);
/* Encode a fixed32, sfixed32 or float value.
* You need to pass a pointer to a 4-byte wide C variable. */
bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
#ifndef PB_WITHOUT_64BIT
/* Encode a fixed64, sfixed64 or double value.
* You need to pass a pointer to a 8-byte wide C variable. */
bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
#endif
#ifdef PB_CONVERT_DOUBLE_FLOAT
/* Encode a float value so that it appears like a double in the encoded
* message. */
bool pb_encode_float_as_double(pb_ostream_t *stream, float value);
#endif
/* Encode a submessage field.
* You need to pass the pb_field_t array and pointer to struct, just like
* with pb_encode(). This internally encodes the submessage twice, first to
* calculate message size and then to actually write it out.
*/
bool pb_encode_submessage(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif

6
src/qt/qt_mediamenu.cpp
View File

@@ -1181,6 +1181,12 @@ MediaMenu::nicUpdateMenu(int i)
case NET_TYPE_TAP:
netType = "TAP";
break;
case NET_TYPE_NMSWITCH:
netType = "Local Switch";
break;
case NET_TYPE_NRSWITCH:
netType = "Remote Switch";
break;
}
QString devName = DeviceConfig::DeviceName(network_card_getdevice(net_cards_conf[i].device_num), network_card_get_internal_name(net_cards_conf[i].device_num), 1);

88
src/qt/qt_settingsnetwork.cpp
View File

@@ -51,11 +51,43 @@ SettingsNetwork::enableElements(Ui::SettingsNetwork *ui)
auto *option_list_label = findChild<QLabel *>(QString("labelOptionList%1").arg(i + 1));
auto *option_list_line = findChild<QWidget *>(QString("lineOptionList%1").arg(i + 1));
// Switch group
auto *switch_group_label = findChild<QLabel *>(QString("labelSwitch%1").arg(i + 1));
// auto *switch_group_hlayout = findChild<QHBoxLayout *>(QString("HLayoutSwitch%1").arg(i + 1));
// auto *switch_group_hspacer = findChild<QWidget *>(QString("horizontalSpacerSwitch%1").arg(i + 1));
auto *switch_group_value = findChild<QSpinBox *>(QString("spinnerSwitch%1").arg(i + 1));
switch_group_value->setMinimum(1);
switch_group_value->setMaximum(10);
// Promiscuous option
auto *promisc_label = findChild<QLabel *>(QString("labelPromisc%1").arg(i + 1));
auto *promisc_value = findChild<QCheckBox *>(QString("boxPromisc%1").arg(i + 1));
// Remote switch hostname
auto *hostname_label = findChild<QLabel *>(QString("labelHostname%1").arg(i + 1));
auto *hostname_value = findChild<QLineEdit *>(QString("hostnameSwitch%1").arg(i + 1));
bridge_line->setEnabled(net_type_cbox->currentData().toInt() == NET_TYPE_TAP);
intf_cbox->setEnabled(net_type_cbox->currentData().toInt() == NET_TYPE_PCAP);
conf_btn->setEnabled(network_card_has_config(nic_cbox->currentData().toInt()));
// net_type_conf_btn->setEnabled(network_type_has_config(netType));
// NEW STUFF
// Make all options invisible by default
// Switch group
switch_group_label->setVisible(false);
switch_group_value->setVisible(false);
// switch_group_hspacer->setVisible(false);
// Promiscuous options
promisc_label->setVisible(false);
promisc_value->setVisible(false);
// Hostname
hostname_label->setVisible(false);
hostname_value->setVisible(false);
// Option list label and line
option_list_label->setVisible(false);
option_list_line->setVisible(false);
@@ -107,6 +139,36 @@ SettingsNetwork::enableElements(Ui::SettingsNetwork *ui)
break;
#endif
case NET_TYPE_NMSWITCH:
// option_list_label->setText("Local Switch Options");
option_list_label->setVisible(true);
option_list_line->setVisible(true);
// Switch group
switch_group_label->setVisible(true);
switch_group_value->setVisible(true);
// switch_group_hspacer->setVisible(false);
// Promiscuous options
promisc_label->setVisible(true);
promisc_value->setVisible(true);
break;
case NET_TYPE_NRSWITCH:
// option_list_label->setText("Remote Switch Options");
option_list_label->setVisible(true);
option_list_line->setVisible(true);
// Switch group
switch_group_label->setVisible(true);
switch_group_value->setVisible(true);
// switch_group_hspacer->setVisible(false);
// Hostname
hostname_label->setVisible(true);
hostname_value->setVisible(true);
break;
case NET_TYPE_SLIRP:
default:
break;
@@ -151,6 +213,9 @@ SettingsNetwork::save()
cbox = findChild<QComboBox *>(QString("comboBoxNet%1").arg(i + 1));
net_cards_conf[i].net_type = cbox->currentData().toInt();
cbox = findChild<QComboBox *>(QString("comboBoxIntf%1").arg(i + 1));
auto *hostname_value = findChild<QLineEdit *>(QString("hostnameSwitch%1").arg(i + 1));
auto *promisc_value = findChild<QCheckBox *>(QString("boxPromisc%1").arg(i + 1));
auto *switch_group_value = findChild<QSpinBox *>(QString("spinnerSwitch%1").arg(i + 1));
memset(net_cards_conf[i].host_dev_name, '\0', sizeof(net_cards_conf[i].host_dev_name));
if (net_cards_conf[i].net_type == NET_TYPE_PCAP)
strncpy(net_cards_conf[i].host_dev_name, network_devs[cbox->currentData().toInt()].device, sizeof(net_cards_conf[i].host_dev_name) - 1);
@@ -162,6 +227,14 @@ SettingsNetwork::save()
else if (net_cards_conf[i].net_type == NET_TYPE_TAP)
strncpy(net_cards_conf[i].host_dev_name, bridge_line->text().toUtf8().constData(), sizeof(net_cards_conf[i].host_dev_name));
#endif
else if (net_cards_conf[i].net_type == NET_TYPE_NRSWITCH) {
memset(net_cards_conf[i].nrs_hostname, '\0', sizeof(net_cards_conf[i].nrs_hostname));
strncpy(net_cards_conf[i].nrs_hostname, hostname_value->text().toUtf8().constData(), sizeof(net_cards_conf[i].nrs_hostname) - 1);
net_cards_conf[i].switch_group = switch_group_value->value() - 1;
} else if (net_cards_conf[i].net_type == NET_TYPE_NMSWITCH) {
net_cards_conf[i].promisc_mode = promisc_value->isChecked();
net_cards_conf[i].switch_group = switch_group_value->value() - 1;
}
}
}
@@ -234,6 +307,11 @@ SettingsNetwork::onCurrentMachineChanged(int machineId)
Models::AddEntry(model, "TAP", NET_TYPE_TAP);
#endif
Models::AddEntry(model, "Local Switch", NET_TYPE_NMSWITCH);
#ifdef ENABLE_NET_NRSWITCH
Models::AddEntry(model, "Remote Switch", NET_TYPE_NRSWITCH);
#endif
model->removeRows(0, removeRows);
cbox->setCurrentIndex(cbox->findData(net_cards_conf[i].net_type));
@@ -268,6 +346,16 @@ SettingsNetwork::onCurrentMachineChanged(int machineId)
auto editline = findChild<QLineEdit *>(QString("bridgeTAPNIC%1").arg(i+1));
editline->setText(currentTapDevice);
#endif
} else if (net_cards_conf[i].net_type == NET_TYPE_NMSWITCH) {
auto *promisc_value = findChild<QCheckBox *>(QString("promiscBox%1").arg(i + 1));
promisc_value->setCheckState(net_cards_conf[i].promisc_mode == 1 ? Qt::CheckState::Checked : Qt::CheckState::Unchecked);
auto *switch_group_value = findChild<QSpinBox *>(QString("switchSpinner%1").arg(i + 1));
switch_group_value->setValue(net_cards_conf[i].switch_group + 1);
} else if (net_cards_conf[i].net_type == NET_TYPE_NRSWITCH) {
auto *hostname_value = findChild<QLineEdit *>(QString("switchHostname%1").arg(i + 1));
hostname_value->setText(net_cards_conf[i].nrs_hostname);
auto *switch_group_value = findChild<QSpinBox *>(QString("switchSpinner%1").arg(i + 1));
switch_group_value->setValue(net_cards_conf[i].switch_group + 1);
}
}
}

248
src/qt/qt_settingsnetwork.ui
View File

@@ -169,7 +169,69 @@
</property>
</widget>
</item>
<item row="7" column="0">
<widget class="QLabel" name="labelSwitch1">
<property name="text">
<string>Switch:</string>
</property>
</widget>
</item>
<item row="7" column="1">
<layout class="QHBoxLayout" name="HLayoutSwitch1">
<item>
<widget class="QSpinBox" name="spinnerSwitch1">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>10</number>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacerSwitch1">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item row="8" column="0">
<widget class="QLabel" name="labelPromisc1">
<property name="text">
<string>Hub Mode</string>
</property>
</widget>
</item>
<item row="8" column="1">
<widget class="QCheckBox" name="boxPromisc1">
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="9" column="0">
<widget class="QLabel" name="labelHostname1">
<property name="text">
<string>Hostname:</string>
</property>
</widget>
</item>
<item row="9" column="1">
<widget class="QLineEdit" name="hostnameSwitch1">
<property name="maxLength">
<number>128</number>
</property>
</widget>
</item>
<item row="10" column="1">
<spacer name="verticalSpacerNIC1">
<property name="orientation">
<enum>Qt::Vertical</enum>
@@ -322,7 +384,69 @@
</property>
</widget>
</item>
<item row="7" column="0">
<widget class="QLabel" name="labelSwitch2">
<property name="text">
<string>Switch:</string>
</property>
</widget>
</item>
<item row="7" column="1">
<layout class="QHBoxLayout" name="HLayoutSwitch2">
<item>
<widget class="QSpinBox" name="spinnerSwitch2">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>10</number>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacerSwitch2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item row="8" column="0">
<widget class="QLabel" name="labelPromisc2">
<property name="text">
<string>Hub Mode</string>
</property>
</widget>
</item>
<item row="8" column="1">
<widget class="QCheckBox" name="boxPromisc2">
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="9" column="0">
<widget class="QLabel" name="labelHostname2">
<property name="text">
<string>Hostname:</string>
</property>
</widget>
</item>
<item row="9" column="1">
<widget class="QLineEdit" name="hostnameSwitch2">
<property name="maxLength">
<number>128</number>
</property>
</widget>
</item>
<item row="10" column="1">
<spacer name="verticalSpacerNIC2">
<property name="orientation">
<enum>Qt::Vertical</enum>
@@ -475,7 +599,69 @@
</property>
</widget>
</item>
<item row="7" column="0">
<widget class="QLabel" name="labelSwitch3">
<property name="text">
<string>Switch:</string>
</property>
</widget>
</item>
<item row="7" column="1">
<layout class="QHBoxLayout" name="HLayoutSwitch3">
<item>
<widget class="QSpinBox" name="spinnerSwitch3">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>10</number>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacerSwitch3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item row="8" column="0">
<widget class="QLabel" name="labelPromisc3">
<property name="text">
<string>Hub Mode</string>
</property>
</widget>
</item>
<item row="8" column="1">
<widget class="QCheckBox" name="boxPromisc3">
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="9" column="0">
<widget class="QLabel" name="labelHostname3">
<property name="text">
<string>Hostname:</string>
</property>
</widget>
</item>
<item row="9" column="1">
<widget class="QLineEdit" name="hostnameSwitch3">
<property name="maxLength">
<number>128</number>
</property>
</widget>
</item>
<item row="10" column="1">
<spacer name="verticalSpacerNIC3">
<property name="orientation">
<enum>Qt::Vertical</enum>
@@ -628,7 +814,69 @@
</property>
</widget>
</item>
<item row="7" column="0">
<widget class="QLabel" name="labelSwitch4">
<property name="text">
<string>Switch:</string>
</property>
</widget>
</item>
<item row="7" column="1">
<layout class="QHBoxLayout" name="HLayoutSwitch4">
<item>
<widget class="QSpinBox" name="spinnerSwitch4">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>10</number>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacerSwitch4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item row="8" column="0">
<widget class="QLabel" name="labelPromisc4">
<property name="text">
<string>Hub Mode</string>
</property>
</widget>
</item>
<item row="8" column="1">
<widget class="QCheckBox" name="boxPromisc4">
<property name="text">
<string/>
</property>
</widget>
</item>
<item row="9" column="0">
<widget class="QLabel" name="labelHostname4">
<property name="text">
<string>Hostname:</string>
</property>
</widget>
</item>
<item row="9" column="1">
<widget class="QLineEdit" name="hostnameSwitch4">
<property name="maxLength">
<number>128</number>
</property>
</widget>
</item>
<item row="10" column="1">
<spacer name="verticalSpacerNIC4">
<property name="orientation">
<enum>Qt::Vertical</enum>