30#include <wx/msw/winundef.h>
36#include <netinet/tcp.h>
44#include <wx/datetime.h>
48#include <wx/chartype.h>
49#include <wx/sckaddr.h>
62using namespace std::literals::chrono_literals;
64#define N_DOG_TIMEOUT 8
67static bool IsBroadcastAddr(
unsigned addr,
unsigned netmask_bits) {
68 assert(netmask_bits <= 32);
69 uint32_t netmask = 0xffffffff << (32 - netmask_bits);
70 uint32_t host_mask = ~netmask;
71 return (addr & host_mask) == host_mask;
77 void SetMrqAddr(
unsigned int addr) {
78 m_mrq.imr_multiaddr.s_addr = addr;
79 m_mrq.imr_interface.s_addr = INADDR_ANY;
83static bool SetOutputSocketOptions(wxSocketBase* tsock) {
93 ret = tsock->SetOption(IPPROTO_TCP, TCP_NODELAY, &nagleDisable,
94 sizeof(nagleDisable));
100 unsigned long outbuf_size = 1024;
101 return (tsock->SetOption(SOL_SOCKET, SO_SNDBUF, &outbuf_size,
102 sizeof(outbuf_size)) &&
114 m_listener(listener),
117 m_socket_server(nullptr),
118 m_is_multicast(false),
119 m_stats_timer(*this, 2s),
122 m_rx_connect_event(false),
123 m_socket_timer(*this),
124 m_socketread_watchdog_timer(*this),
126 m_is_conn_err_reported(false) {
127 m_addr.Hostname(params->NetworkAddress);
128 m_addr.Service(params->NetworkPort);
129 this->attributes[
"netAddress"] = params->NetworkAddress.ToStdString();
130 this->attributes[
"netPort"] = std::to_string(params->NetworkPort);
131 this->attributes[
"userComment"] = params->UserComment.ToStdString();
133 m_driver_stats.driver_bus = NavAddr::Bus::N0183;
134 m_driver_stats.driver_iface = params->GetStrippedDSPort();
136 m_mrq_container = std::make_unique<MrqContainer>();
139 resume_listener.Init(SystemEvents::GetInstance().evt_resume,
141 Bind(wxEVT_SOCKET, &CommDriverN0183Net::OnSocketEvent,
this, DS_SOCKET_ID);
142 Bind(wxEVT_SOCKET, &CommDriverN0183Net::OnServerSocketEvent,
this,
148CommDriverN0183Net::~CommDriverN0183Net() { Close(); }
150void CommDriverN0183Net::HandleN0183Msg(
const std::string& sentence) {
152 m_driver_stats.
rx_count += sentence.size();
156void CommDriverN0183Net::Open() {
159 ((
struct sockaddr_in*)m_addr.GetAddressData())->sin_addr.s_addr;
161 unsigned int addr = inet_addr(m_addr.IPAddress().mb_str());
164 switch (m_params.NetProtocol) {
170 OpenNetworkTcp(addr);
174 OpenNetworkUdp(addr);
183void CommDriverN0183Net::OpenNetworkUdp(
unsigned int addr) {
184 if (m_params.IOSelect != DS_TYPE_OUTPUT) {
187 wxIPV4address conn_addr;
188 conn_addr.Service(std::to_string(m_params.NetworkPort));
189 conn_addr.AnyAddress();
190 conn_addr.AnyAddress();
192 new wxDatagramSocket(conn_addr, wxSOCKET_NOWAIT | wxSOCKET_REUSEADDR);
195 if ((ntohl(addr) & 0xf0000000) == 0xe0000000) {
196 m_is_multicast =
true;
197 m_mrq_container->SetMrqAddr(addr);
198 m_sock->SetOption(IPPROTO_IP, IP_ADD_MEMBERSHIP, &m_mrq_container->m_mrq,
199 sizeof(m_mrq_container->m_mrq));
202 m_sock->SetEventHandler(*
this, DS_SOCKET_ID);
204 m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_INPUT_FLAG |
206 m_sock->Notify(TRUE);
207 m_sock->SetTimeout(1);
208 m_driver_stats.available =
true;
212 if (m_params.IOSelect != DS_TYPE_INPUT) {
213 wxIPV4address tconn_addr;
214 tconn_addr.Service(0);
215 tconn_addr.AnyAddress();
217 new wxDatagramSocket(tconn_addr, wxSOCKET_NOWAIT | wxSOCKET_REUSEADDR);
222 if (!m_is_multicast && IsBroadcastAddr(addr, g_netmask_bits)) {
223 int broadcastEnable = 1;
224 m_tsock->SetOption(SOL_SOCKET, SO_BROADCAST, &broadcastEnable,
225 sizeof(broadcastEnable));
226 m_driver_stats.available =
true;
231 m_connect_time = std::chrono::steady_clock::now();
234void CommDriverN0183Net::OpenNetworkTcp(
unsigned int addr) {
235 if (addr == INADDR_ANY) {
236 MESSAGE_LOG <<
"Listening for TCP connections on " << INADDR_ANY;
237 m_socket_server =
new wxSocketServer(m_addr, wxSOCKET_REUSEADDR);
238 m_socket_server->SetEventHandler(*
this, DS_SERVERSOCKET_ID);
239 m_socket_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
240 m_socket_server->Notify(TRUE);
241 m_socket_server->SetTimeout(1);
243 MESSAGE_LOG <<
"Opening TCP connection to " << m_params.NetworkAddress
244 <<
":" << m_params.NetworkPort;
245 m_sock =
new wxSocketClient();
246 m_sock->SetEventHandler(*
this, DS_SOCKET_ID);
247 int notify_flags = (wxSOCKET_CONNECTION_FLAG | wxSOCKET_LOST_FLAG);
248 if (m_params.IOSelect != DS_TYPE_INPUT)
249 notify_flags |= wxSOCKET_OUTPUT_FLAG;
250 if (m_params.IOSelect != DS_TYPE_OUTPUT)
251 notify_flags |= wxSOCKET_INPUT_FLAG;
252 m_sock->SetNotify(notify_flags);
253 m_sock->Notify(
true);
254 m_sock->SetTimeout(1);
256 m_rx_connect_event =
false;
257 m_socket_timer.Start(100, wxTIMER_ONE_SHOT);
261 m_connect_time = std::chrono::steady_clock::now();
264void CommDriverN0183Net::OpenNetworkGpsd() {
265 m_sock =
new wxSocketClient();
266 m_sock->SetEventHandler(*
this, DS_SOCKET_ID);
267 m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_INPUT_FLAG |
269 m_sock->Notify(TRUE);
270 m_sock->SetTimeout(1);
272 auto* tcp_socket =
dynamic_cast<wxSocketClient*
>(m_sock);
273 tcp_socket->Connect(m_addr,
false);
274 m_rx_connect_event =
false;
277void CommDriverN0183Net::OnSocketReadWatchdogTimer() {
280 if (m_dog_value <= 0) {
281 if (GetParams().NoDataReconnect) {
283 if (m_params.NetProtocol == TCP) {
284 auto* tcp_socket =
dynamic_cast<wxSocketClient*
>(m_sock);
285 if (tcp_socket) tcp_socket->Close();
287 int n_reconnect_delay = wxMax(N_DOG_TIMEOUT - 2, 2);
288 wxLogMessage(
"Reconnection scheduled in %d seconds.",
290 m_socket_timer.Start(n_reconnect_delay * 1000, wxTIMER_ONE_SHOT);
293 m_socketread_watchdog_timer.Stop();
299void CommDriverN0183Net::OnTimerSocket() {
301 using namespace std::chrono;
302 auto* tcp_socket =
dynamic_cast<wxSocketClient*
>(m_sock);
304 if (tcp_socket->IsDisconnected()) {
305 m_driver_stats.available =
false;
306 wxLogDebug(
"Attempting reconnection...");
307 m_rx_connect_event =
false;
309 m_socketread_watchdog_timer.Stop();
310 tcp_socket->Connect(m_addr,
false);
313 int n_reconnect_delay = N_DOG_TIMEOUT;
314 m_socket_timer.Start(n_reconnect_delay * 1000, wxTIMER_ONE_SHOT);
317 if (m_connect_time == time_point<steady_clock>())
return;
318 auto since_connect = steady_clock::now() - m_connect_time;
319 if (since_connect > 10s && !m_is_conn_err_reported) {
320 std::stringstream ss;
321 ss << _(
"Cannot connect to remote server ") << m_params.NetworkAddress
322 <<
":" << m_params.NetworkPort;
324 m_is_conn_err_reported =
true;
331void CommDriverN0183Net::HandleResume() {
333 auto* tcp_socket =
dynamic_cast<wxSocketClient*
>(m_sock);
335 m_socketread_watchdog_timer.Stop();
340 int n_reconnect_delay = wxMax(N_DOG_TIMEOUT - 2, 2);
341 wxLogMessage(
"Reconnection scheduled in %d seconds.", n_reconnect_delay);
343 m_socket_timer.Start(n_reconnect_delay * 1000, wxTIMER_ONE_SHOT);
347bool CommDriverN0183Net::SendMessage(std::shared_ptr<const NavMsg> msg,
348 std::shared_ptr<const NavAddr> addr) {
349 auto msg_0183 = std::dynamic_pointer_cast<const Nmea0183Msg>(msg);
350 std::string payload(msg_0183->payload);
352 m_driver_stats.
tx_count += payload.size();
353 return SendSentenceNetwork(payload.c_str());
356void CommDriverN0183Net::OnSocketEvent(wxSocketEvent& event) {
357#define RD_BUF_SIZE 4096
361 switch (event.GetSocketEvent()) {
376 uint8_t buff[RD_BUF_SIZE + 1];
377 event.GetSocket()->Read(buff, RD_BUF_SIZE);
378 if (!event.GetSocket()->Error()) {
379 unsigned count =
event.GetSocket()->LastCount();
380 for (
unsigned i = 0; i < count; i += 1) n0183_buffer.
Put(buff[i]);
382 HandleN0183Msg(n0183_buffer.
GetSentence() +
"\r\n");
385 m_dog_value = N_DOG_TIMEOUT;
389 case wxSOCKET_LOST: {
390 m_driver_stats.available =
false;
391 using namespace std::chrono;
392 if (m_params.NetProtocol == TCP || m_params.NetProtocol == GPSD) {
393 if (m_rx_connect_event) {
394 MESSAGE_LOG <<
"NetworkDataStream connection lost: "
395 << m_params.GetDSPort();
397 if (m_socket_server) {
402 auto since_connect = 10s;
404 auto now = steady_clock::now();
405 if (m_connect_time != time_point<steady_clock>())
406 since_connect = duration_cast<seconds>(now - m_connect_time);
408 auto retry_time = 5s;
412 if (!m_rx_connect_event && (since_connect < 5s)) retry_time = 10s;
414 m_socketread_watchdog_timer.Stop();
417 m_socket_timer.Start(duration_cast<milliseconds>(retry_time).count(),
423 case wxSOCKET_CONNECTION: {
424 if (m_params.NetProtocol == GPSD) {
429 char cmd[] = R
"--(?WATCH={"class":"WATCH", "nmea":true})--";
430 m_sock->Write(cmd, strlen(cmd));
431 } else if (m_params.NetProtocol == TCP) {
432 MESSAGE_LOG <<
"TCP NetworkDataStream connection established: "
433 << m_params.GetDSPort();
435 m_dog_value = N_DOG_TIMEOUT;
436 if (m_params.IOSelect != DS_TYPE_OUTPUT) {
438 if (GetParams().NoDataReconnect)
439 m_socketread_watchdog_timer.Start(1000);
442 if (m_params.IOSelect != DS_TYPE_INPUT && GetSock()->IsOk())
443 (void)SetOutputSocketOptions(m_sock);
444 m_socket_timer.Stop();
445 m_rx_connect_event =
true;
448 m_driver_stats.available =
true;
449 m_connect_time = std::chrono::steady_clock::now();
458void CommDriverN0183Net::OnServerSocketEvent(wxSocketEvent& event) {
459 switch (event.GetSocketEvent()) {
460 case wxSOCKET_CONNECTION: {
461 m_sock = m_socket_server->Accept(
false);
464 m_sock->SetTimeout(2);
466 m_sock->SetEventHandler(*
this, DS_SOCKET_ID);
467 int notify_flags = (wxSOCKET_CONNECTION_FLAG | wxSOCKET_LOST_FLAG);
468 if (m_params.IOSelect != DS_TYPE_INPUT) {
469 notify_flags |= wxSOCKET_OUTPUT_FLAG;
470 (void)SetOutputSocketOptions(m_sock);
472 if (m_params.IOSelect != DS_TYPE_OUTPUT)
473 notify_flags |= wxSOCKET_INPUT_FLAG;
474 m_sock->SetNotify(notify_flags);
475 m_sock->Notify(
true);
484bool CommDriverN0183Net::SendSentenceNetwork(
const wxString& payload) {
491 wxDatagramSocket* udp_socket;
492 switch (m_params.NetProtocol) {
494 if (GetSock() && GetSock()->IsOk()) {
495 m_sock->Write(payload.mb_str(), strlen(payload.mb_str()));
496 m_dog_value = N_DOG_TIMEOUT;
497 if (GetSock()->Error()) {
498 if (m_socket_server) {
502 auto* tcp_socket =
dynamic_cast<wxSocketClient*
>(m_sock);
503 if (tcp_socket) tcp_socket->Close();
504 if (!m_socket_timer.IsRunning())
505 m_socket_timer.Start(5000, wxTIMER_ONE_SHOT);
507 m_socketread_watchdog_timer.Stop();
514 m_driver_stats.available = ret;
518 udp_socket =
dynamic_cast<wxDatagramSocket*
>(m_tsock);
519 if (udp_socket && udp_socket->IsOk()) {
520 udp_socket->SendTo(m_addr, payload.mb_str(), payload.size());
521 m_dog_value = N_DOG_TIMEOUT;
522 if (udp_socket->Error()) ret =
false;
526 m_driver_stats.available = ret;
538void CommDriverN0183Net::Close() {
539 MESSAGE_LOG <<
"Closing NMEA NetworkDataStream " << m_params.NetworkPort;
540 m_stats_timer.Stop();
544 m_sock->SetOption(IPPROTO_IP, IP_DROP_MEMBERSHIP, &m_mrq_container->m_mrq,
545 sizeof(m_mrq_container->m_mrq));
546 m_sock->Notify(FALSE);
551 m_tsock->Notify(FALSE);
555 if (m_socket_server) {
556 m_socket_server->Notify(FALSE);
557 m_socket_server->Destroy();
560 m_socket_timer.Stop();
561 m_socketread_watchdog_timer.Stop();
562 m_driver_stats.available =
false;
NMEA0183 basic parsing common parts:
void SendToListener(const std::string &payload, DriverListener &listener, const ConnectionParams ¶ms)
Wrap argument string in NavMsg pointer, forward to listener.
EventVar evt_driver_msg
Notified for messages from drivers.
Interface for handling incoming messages.
void Notify() override
Notify all listeners, no data supplied.
bool HasSentence() const
Return true if a sentence is available to be returned by GetSentence()
std::string GetSentence()
Retrieve a sentence from buffer.
void Put(uint8_t ch)
Add a single character, possibly making a sentence available.
Where messages are sent to or received from.
Custom event class for OpenCPN's notification system.
Driver registration container, a singleton.
Raw messages layer, supports sending and recieving navmsg messages.
Global variables stored in configuration file.
std::string DsPortTypeToString(dsPortType type)
Return textual representation for use in driver ioDirection attribute.
GUI constant definitions.
Enhanced logging interface on top of wx/log.h.
bool endswith(const std::string &str, const std::string &suffix)
Return true if s ends with given suffix.
General observable implementation with several specializations.
unsigned tx_count
Number of bytes sent since program start.
unsigned rx_count
Number of bytes received since program start.
unsigned error_count
Number of detected errors since program start.
Suspend/resume and new devices events exchange point.