Use higher packet size for remote streaming over end-to-end IPv6 conn…

…ection

The IPv6 spec guarantees a minimum of 1280 byte MTUs

src/Connection.c

@@ -386,18 +386,28 @@ int LiStartConnection(PSERVER_INFORMATION serverInfo, PSTREAM_CONFIGURATION stre
  // now that we have resolved the target address and impose the video packet
  // size cap if required.
  if (StreamConfig.streamingRemotely == STREAM_CFG_AUTO) {
- if (isPrivateNetworkAddress(&RemoteAddr)) {
+ bool isNat64 = isNat64SynthesizedAddress(&RemoteAddr);
+
+ // It's possible to have a NAT64 prefix on a ULA or other private range,
+ // so we must exclude NAT64 addresses from our local address checks.
+ if (!isNat64 && isPrivateNetworkAddress(&RemoteAddr)) {
  StreamConfig.streamingRemotely = STREAM_CFG_LOCAL;
  }
  else {
  StreamConfig.streamingRemotely = STREAM_CFG_REMOTE;
 
- if (StreamConfig.packetSize > 1024) {
- // Cap packet size at 1024 for remote streaming to avoid
- // MTU problems and fragmentation.
- Limelog("Packet size capped at 1KB for remote streaming\n");
+ if (RemoteAddr.ss_family == AF_INET || isNat64) {
+ // Cap packet size at 1024 for remote IPv4 streaming to avoid fragmentation.
+ Limelog("Packet size capped at 1024 bytes for remote IPv4 streaming\n");
  StreamConfig.packetSize = 1024;
  }
+ else {
+ // IPv6 guarantees a minimum MTU of 1280 before fragmentation, so use a higher
+ // packet size cap for remote IPv6 streaming (when not using NAT64 which isn't
+ // end-to-end IPv6 traffic).
+ Limelog("Packet size capped at 1184 bytes for remote IPv6 streaming\n");
+ StreamConfig.packetSize = 1184;
+ }
  }
  }
 

src/PlatformSockets.c

@@ -716,6 +716,119 @@ bool isPrivateNetworkAddress(struct sockaddr_storage* address) {
  return false;
 }
 
+bool isNat64SynthesizedAddress(struct sockaddr_storage* address) {
+#ifdef AF_INET6
+ if (address->ss_family == AF_INET6) {
+ struct sockaddr_in6* sin6 = (struct sockaddr_in6*)address;
+ struct addrinfo hints, *res, *currentAddr;
+ int err;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_INET6;
+ hints.ai_flags = AI_ADDRCONFIG;
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_protocol = IPPROTO_TCP;
+ err = getaddrinfo("ipv4only.arpa.", NULL, &hints, &res);
+ if (err != 0) {
+ Limelog("Client is not running in NAT64 environment (%d)\n", err);
+ return false;
+ }
+ else if (res == NULL) {
+ Limelog("getaddrinfo(ipv4only.arpa.) returned success without addresses\n");
+ return false;
+ }
+
+ for (currentAddr = res; currentAddr != NULL; currentAddr = currentAddr->ai_next) {
+ struct sockaddr_in6* candidate6 = (struct sockaddr_in6*)currentAddr->ai_addr;
+ static const unsigned char wellKnownAddresses[2][4] = {
+ { 0xC0, 0x00, 0x00, 0xAA }, // 192.0.0.170
+ { 0xC0, 0x00, 0x00, 0xAB }, // 192.0.0.171
+ };
+
+ if (candidate6->sin6_family != AF_INET6) {
+ // This shouldn't be possible but check anyway
+ continue;
+ }
+
+ for (int i = 0; i < 2; i++) {
+ int foundCount = 0;
+ int prefixLen = 0;
+ int suffixStart = 0;
+
+ // Search for each well-known IPv4 address at all locations specified by
+ // https://datatracker.ietf.org/doc/html/rfc6052#section-2.2
+ if (memcmp(&candidate6->sin6_addr.s6_addr[4], wellKnownAddresses[i], 4) == 0) {
+ foundCount++;
+
+ prefixLen = 4;
+ suffixStart = 9;
+ }
+ if (memcmp(&candidate6->sin6_addr.s6_addr[5], &wellKnownAddresses[i][0], 3) == 0 &&
+ memcmp(&candidate6->sin6_addr.s6_addr[9], &wellKnownAddresses[i][3], 1) == 0) {
+ foundCount++;
+
+ prefixLen = 5;
+ suffixStart = 10;
+ }
+ if (memcmp(&candidate6->sin6_addr.s6_addr[6], &wellKnownAddresses[i][0], 2) == 0 &&
+ memcmp(&candidate6->sin6_addr.s6_addr[9], &wellKnownAddresses[i][2], 2) == 0) {
+ foundCount++;
+
+ prefixLen = 6;
+ suffixStart = 11;
+ }
+ if (memcmp(&candidate6->sin6_addr.s6_addr[7], &wellKnownAddresses[i][0], 1) == 0 &&
+ memcmp(&candidate6->sin6_addr.s6_addr[9], &wellKnownAddresses[i][1], 3) == 0) {
+ foundCount++;
+
+ prefixLen = 7;
+ suffixStart = 12;
+ }
+ if (memcmp(&candidate6->sin6_addr.s6_addr[9], &wellKnownAddresses[i], 4) == 0) {
+ foundCount++;
+
+ prefixLen = 8;
+ suffixStart = 13;
+ }
+ if (memcmp(&candidate6->sin6_addr.s6_addr[12], &wellKnownAddresses[i], 4) == 0) {
+ foundCount++;
+
+ prefixLen = 12;
+ suffixStart = 16;
+ }
+
+ // We must find the well-known address exactly once. If we find it zero or multiple
+ // times, we must try the second well-known address or other AAAA records.
+ if (foundCount != 1) {
+ continue;
+ }
+
+ // We have a valid NAT64 address identified, so we know we're running in an NAT64 environment.
+ //
+ // Now we must check to see if the address we resolved for the remote host actually falls
+ // within the NAT64 range to see if we must restrict ourselves to the IPv4 MTU.
+ if (memcmp(&sin6->sin6_addr.s6_addr[0], &candidate6->sin6_addr.s6_addr[0], prefixLen) == 0 &&
+ (suffixStart == 16 || memcmp(&sin6->sin6_addr.s6_addr[suffixStart],
+ &candidate6->sin6_addr.s6_addr[suffixStart],
+ 16 - suffixStart) == 0)) {
+ freeaddrinfo(res);
+ return true;
+ }
+ else {
+ // This one didn't match, so let's break out of the loop and try the next AAAA record.
+ break;
+ }
+ }
+ }
+
+ freeaddrinfo(res);
+ return false;
+ }
+#endif
+
+ return false;
+}
+
 // Enable platform-specific low latency options (best-effort)
 void enterLowLatencyMode(void) {
 #if defined(LC_WINDOWS_DESKTOP)

src/PlatformSockets.h

@@ -110,6 +110,7 @@ void shutdownTcpSocket(SOCKET s);
 int setNonFatalRecvTimeoutMs(SOCKET s, int timeoutMs);
 void closeSocket(SOCKET s);
 bool isPrivateNetworkAddress(struct sockaddr_storage* address);
+bool isNat64SynthesizedAddress(struct sockaddr_storage* address);
 int pollSockets(struct pollfd* pollFds, int pollFdsCount, int timeoutMs);
 bool isSocketReadable(SOCKET s);