Release: 3.4.3 (#14)

* release: v3.4.3

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [3.4.3]
+- Added option to export NMEA sentences to a unix socket or a TCP connection. See `--nmea-export-*` command-line arguments. This requires the use of the NMEA receiver.
+- Fixed a bug where in cases of TCP connection failure, the addrinfo struct was not freed.
+
 ## [3.4.2]
 - Fixed a bug where GAD messages had TF009 set to 0. It will now be set to time specified in the STEC/Gridded IE.
 - Fixed a bug where parsing bitfields in UBX-NAV-PVT would not be incorrect.

CMakeLists.txt

@@ -28,7 +28,7 @@ find_package(OpenSSL REQUIRED)
 endif (USE_OPENSSL)
 
 add_definitions(-D_POSIX_C_SOURCE=200809L)
-add_definitions(-DCLIENT_VERSION="3.4.2")
+add_definitions(-DCLIENT_VERSION="3.4.3")
 
 if(${ASN_DEBUG})
  add_definitions(-DASN_EMIT_DEBUG=1)

README.md

@@ -1,6 +1,6 @@
 # SUPL 3GPP LPP client
 
-![version](https://img.shields.io/badge/version-3.4.2-green)
+![version](https://img.shields.io/badge/version-3.4.3-green)
 ![license](https://img.shields.io/badge/license-MXM-blue)
 
 This project is a set of libraries, examples and tools to facilitate the development of 3GPP LPP clients. 

examples/lpp/README.md

@@ -14,7 +14,7 @@ There are a few required arguments:
 ```
  ./example-lpp COMMAND {OPTIONS}
 
- 3GPP LPP Example (3.4.0) - This sample code is a simple client that asks for
+ 3GPP LPP Example (3.4.3) - This sample code is a simple client that asks for
  assistance data from a location server. It can handle OSR, SSR, and AGNSS
  requests. The assistance data can converted to RTCM or SPARTN before being
  sent to a GNSS receiver or other interface. The client also supports to 3GPP
@@ -96,6 +96,11 @@ There are a few required arguments:
  Parity Bits
  One of: none, odd, even
  Default: none
+ --nmea-export-un=[unix socket] Export NMEA to unix socket
+ --nmea-export-tcp=[ip] Export NMEA to TCP
+ --nmea-export-tcp-port=[port] Export NMEA to TCP Port
+ Other Receiver Options:
+ --print-receiver-messages, --prm Print Receiver Messages
  Output:
  File:
  --file=[file_path] Path

examples/lpp/options.cpp

@@ -190,6 +190,22 @@ args::ValueFlag<std::string> nmea_serial_parity_bits{nmea_receiver_group,
  "Parity Bits",
  {"nmea-serial-parity"},
  args::Options::Single};
+// export nmea to unix socket
+args::ValueFlag<std::string> nmea_export_un{nmea_receiver_group,
+ "unix socket",
+ "Export NMEA to unix socket",
+ {"nmea-export-un"},
+ args::Options::Single};
+args::ValueFlag<std::string> nmea_export_tcp{nmea_receiver_group,
+ "ip",
+ "Export NMEA to TCP",
+ {"nmea-export-tcp"},
+ args::Options::Single};
+args::ValueFlag<int> nmea_export_tcp_port{nmea_receiver_group,
+ "port",
+ "Export NMEA to TCP Port",
+ {"nmea-export-tcp-port"},
+ args::Options::Single};
 
 //
 // Output
@@ -691,10 +707,27 @@ static NmeaOptions nmea_parse_options() {
  }
  }
 
+ std::vector<std::unique_ptr<interface::Interface>> nmea_export_interfaces;
+ if (nmea_export_un) {
+ auto interface = interface::Interface::unix_socket_stream(nmea_export_un.Get(), true);
+ nmea_export_interfaces.emplace_back(interface);
+ }
+
+ if (nmea_export_tcp) {
+ if (!nmea_export_tcp_port) {
+ throw args::RequiredError("nmea-export-tcp-port");
+ }
+
+ auto interface =
+ interface::Interface::tcp(nmea_export_tcp.Get(), nmea_export_tcp_port.Get(), true);
+ nmea_export_interfaces.emplace_back(interface);
+ }
+
  auto interface = interface::Interface::serial(nmea_serial_device.Get(), baud_rate,
  data_bits, stop_bits, parity_bit);
  auto print_messages = print_receiver_options_parse();
- return NmeaOptions{std::unique_ptr<Interface>(interface), print_messages};
+ return NmeaOptions{std::unique_ptr<Interface>(interface), print_messages,
+ std::move(nmea_export_interfaces)};
  } else {
  return NmeaOptions{};
  }

examples/lpp/options.hpp

@@ -73,6 +73,8 @@ struct NmeaOptions {
  std::unique_ptr<interface::Interface> interface;
  /// Whether to print messages.
  bool print_messages;
+ /// Export messages to other interfaces.
+ std::vector<std::unique_ptr<interface::Interface>> export_interfaces;
 };
 
 /// Location information options.

examples/lpp/osr_example.cpp

@@ -131,8 +131,17 @@ void execute(Options options, osr_example::Format format, osr_example::MsmType m
  nmea_options.interface->open();
  nmea_options.interface->print_info();
 
+ if (!nmea_options.export_interfaces.empty()) {
+ printf("[nmea-export]\n");
+ for (auto& interface : nmea_options.export_interfaces) {
+ interface->open();
+ interface->print_info();
+ }
+ }
+
  gNmeaReceiver = std::unique_ptr<NReceiver>(
- new NReceiver(std::move(nmea_options.interface), nmea_options.print_messages));
+ new NReceiver(std::move(nmea_options.interface), nmea_options.print_messages,
+ std::move(nmea_options.export_interfaces)));
  gNmeaReceiver->start();
  }
 

examples/lpp/ssr_example.cpp

@@ -102,8 +102,17 @@ void execute(Options options, ssr_example::Format format, int ura_override,
  nmea_options.interface->open();
  nmea_options.interface->print_info();
 
+ if (!nmea_options.export_interfaces.empty()) {
+ printf("[nmea-export]\n");
+ for (auto& interface : nmea_options.export_interfaces) {
+ interface->open();
+ interface->print_info();
+ }
+ }
+
  gNmeaReceiver = std::unique_ptr<NReceiver>(
- new NReceiver(std::move(nmea_options.interface), nmea_options.print_messages));
+ new NReceiver(std::move(nmea_options.interface), nmea_options.print_messages,
+ std::move(nmea_options.export_interfaces)));
  gNmeaReceiver->start();
  }
 

interface/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(dependency_interface STATIC
  "reconnectable_socket.cpp"
  "tcp.cpp"
  "udp.cpp"
+ "unix_socket.cpp"
 )
 add_library(dependency::interface ALIAS dependency_interface)
 

interface/file.cpp

@@ -27,7 +27,7 @@ void FileInterface::open() {
  }
 
  if (fd < 0) {
- throw std::runtime_error("Failed to open file");
+ throw std::runtime_error("Failed to open file: " + mFilePath);
  }
 
  mFileDescriptor = FileDescriptor(fd);

interface/include/interface/interface.hpp

@@ -110,6 +110,11 @@ class Interface {
 
  /// Create a stdin interface.
  static Interface* stdin();
+
+ /// Create a unix socket interface. The socket type is SOCK_STREAM.
+ /// @param socket_path The path to the unix socket.
+ /// @param reconnect Whether to reconnect if the connection is lost.
+ static Interface* unix_socket_stream(std::string socket_path, bool reconnect);
 };
 
 } // namespace interface

interface/reconnectable_socket.cpp

@@ -96,6 +96,7 @@ void ReconnectableSocket::print_info() IF_NOEXCEPT {
  switch (mAddress.family()) {
  case AF_INET: printf(" family: AF_INET\n"); break;
  case AF_INET6: printf(" family: AF_INET6\n"); break;
+ case AF_UNIX: printf(" family: AF_UNIX\n"); break;
  default: printf(" family: AF_??? (%d)\n", mAddress.family()); break;
  }
  switch (mAddress.type()) {
@@ -106,6 +107,7 @@ void ReconnectableSocket::print_info() IF_NOEXCEPT {
  switch (mAddress.protocol()) {
  case IPPROTO_TCP: printf(" protocol: IPPROTO_TCP\n"); break;
  case IPPROTO_UDP: printf(" protocol: IPPROTO_UDP\n"); break;
+ case IPPROTO_IP: printf(" protocol: IPPROTO_IP\n"); break;
  default: printf(" protocol: IPPROTO_??? (%d)\n", mAddress.protocol()); break;
  }
  printf(" address: %s\n", mAddress.to_string().c_str());

interface/socket.hpp

@@ -7,6 +7,7 @@
 #include <stdexcept>
 #include <sys/socket.h>
 #include <sys/time.h>
+#include <sys/un.h>
 #include "types.hpp"
 
 namespace interface {
@@ -18,6 +19,7 @@ class NetworkAddress {
  switch (addr->ai_family) {
  case AF_INET: break;
  case AF_INET6: break;
+ case AF_UNIX: break;
  default: throw std::runtime_error("Unsupported network address");
  }
  NetworkAddress rtrn{};
@@ -31,12 +33,25 @@ class NetworkAddress {
  return rtrn;
  }
 
+ static NetworkAddress unix_socket_stream(const std::string& path) {
+ if (path.size() >= sizeof(sockaddr_un::sun_path)) throw std::runtime_error("Path too long");
+
+ NetworkAddress rtrn{};
+ rtrn.mFamily = AF_UNIX;
+ rtrn.mType = SOCK_STREAM;
+ rtrn.mProtocol = 0;
+ rtrn.mAddr.un.sun_family = AF_UNIX;
+ strncpy(rtrn.mAddr.un.sun_path, path.c_str(), sizeof(rtrn.mAddr.un.sun_path));
+ return rtrn;
+ }
+
  IF_NODISCARD struct sockaddr* ptr() IF_NOEXCEPT { return &mAddr.base; }
 
  IF_NODISCARD std::size_t length() const IF_NOEXCEPT {
  switch (mFamily) {
  case AF_INET: return sizeof(mAddr.in4);
  case AF_INET6: return sizeof(mAddr.in6);
+ case AF_UNIX: return sizeof(mAddr.un);
  default: return 0; /* fail safe in later call */
  }
  }
@@ -54,6 +69,7 @@ class NetworkAddress {
  case AF_INET6:
  inet_ntop(mFamily, &mAddr.in6.sin6_addr, buffer, INET6_ADDRSTRLEN);
  return std::string(buffer) + ":" + std::to_string(ntohs(mAddr.in6.sin6_port));
+ case AF_UNIX: return std::string(mAddr.un.sun_path);
  default: return "Unsupported network address";
  }
  }
@@ -67,6 +83,7 @@ class NetworkAddress {
  sockaddr base;
  sockaddr_in in4;
  sockaddr_in6 in6;
+ sockaddr_un un;
  } mAddr;
 };
 

interface/tcp.cpp

@@ -39,10 +39,12 @@ void TcpInterface::open() {
  auto address = NetworkAddress::from_addrinfo(rp);
  mSocket = ReconnectableSocket::connect(address, mReconnect);
  if (mSocket.is_open()) {
+ freeaddrinfo(result);
  return;
  }
  }
 
+ freeaddrinfo(result);
  throw std::runtime_error("Failed to connect to host");
 }
 

interface/unix_socket.cpp

@@ -0,0 +1,79 @@
+#include "unix_socket.hpp"
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <stdexcept>
+#include <sys/socket.h>
+#include <unistd.h>
+
+namespace interface {
+
+UnixSocketInterface::UnixSocketInterface(std::string path, bool reconnect) IF_NOEXCEPT
+ : mPath(std::move(path)),
+ mReconnect(reconnect) {}
+
+UnixSocketInterface::~UnixSocketInterface() IF_NOEXCEPT {
+ close();
+}
+
+void UnixSocketInterface::open() {
+ if (mSocket.is_open()) {
+ return;
+ }
+
+ auto address = NetworkAddress::unix_socket_stream(mPath);
+ mSocket = ReconnectableSocket::connect(address, mReconnect);
+ if (!mSocket.is_open()) {
+ throw std::runtime_error("Failed to connect to unix socket: '" + mPath + "'");
+ }
+}
+
+void UnixSocketInterface::close() {
+ mSocket.close();
+}
+
+size_t UnixSocketInterface::read(void* data, const size_t size) {
+ return mSocket.read(data, size);
+}
+
+size_t UnixSocketInterface::write(const void* data, const size_t size) {
+ return mSocket.write(data, size);
+}
+
+bool UnixSocketInterface::can_read() IF_NOEXCEPT {
+ return mSocket.can_read();
+}
+
+bool UnixSocketInterface::can_write() IF_NOEXCEPT {
+ return mSocket.can_write();
+}
+
+void UnixSocketInterface::wait_for_read() IF_NOEXCEPT {
+ mSocket.wait_for_read();
+}
+
+void UnixSocketInterface::wait_for_write() IF_NOEXCEPT {
+ mSocket.wait_for_write();
+}
+
+bool UnixSocketInterface::is_open() IF_NOEXCEPT {
+ return mSocket.is_open();
+}
+
+void UnixSocketInterface::print_info() IF_NOEXCEPT {
+ printf("[interface]\n");
+ printf(" type: unix-socket (stream)\n");
+ printf(" path: %s\n", mPath.c_str());
+ printf(" reconnect: %s\n", mReconnect ? "true" : "false");
+ mSocket.print_info();
+}
+
+//
+//
+//
+
+Interface* Interface::unix_socket_stream(std::string path, bool reconnect) {
+ return new UnixSocketInterface(std::move(path), reconnect);
+}
+
+} // namespace interface

interface/unix_socket.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include <cstddef>
+#include <string>
+#include "interface.hpp"
+#include "reconnectable_socket.hpp"
+
+namespace interface {
+
+class UnixSocketInterface final : public Interface {
+public:
+ explicit UnixSocketInterface(std::string path, bool reconnect) IF_NOEXCEPT;
+ ~UnixSocketInterface() IF_NOEXCEPT override;
+
+ void open() override;
+ void close() override;
+
+ size_t read(void* data, size_t length) override;
+ size_t write(const void* data, size_t length) override;
+
+ IF_NODISCARD bool can_read() IF_NOEXCEPT override;
+ IF_NODISCARD bool can_write() IF_NOEXCEPT override;
+
+ void wait_for_read() IF_NOEXCEPT override;
+ void wait_for_write() IF_NOEXCEPT override;
+
+ IF_NODISCARD bool is_open() IF_NOEXCEPT override;
+ void print_info() IF_NOEXCEPT override;
+
+private:
+ std::string mPath;
+ bool mReconnect;
+ ReconnectableSocket mSocket;
+};
+
+} // namespace interface