Apr 04 2019 UE4: How to set up LAN-Multiplayer for Windows and Android

Wifi Blocks Broad­cast Traf­fic

Many An­droid de­vices block UDP broad­cast traf­fic to save per­for­mance (see doc­u­men­ta­tion of an­droid.net.wifi.Wifi­Man­ag­er.Mul­ti­cas­t­Lock). As do Ocu­lus GO, Sam­sung Gal­axy S8 (and sim­i­lar), Sam­sung Gal­axy Tab A and the Google Pix­el (first gen) for ex­am­ple. There­fore broad­cast query pack­ets are not re­ceived on host­ing An­droid de­vices.

So­lu­tion is to ac­quire the af­fore­men­tioned Mul­ti­cas­t­Lock, telling the Wifi Stack to let through broad­cast/mul­ti­cast traf­fic.

Lo­cal Host Ad­dress is Wrong

Sock­et­Sub­sys­te­mAn­droid tries to get the ad­dress of the de­vices through the BSD sock­ets API. While this has been “fixed”, on UE 4.21 it cur­rent­ly just re­turns 127.0.0.1. That works fine for host­ing, but if this were to be sent as a broad­cast query re­sponse, the oth­er de­vices would try to con­nect to it­self rather than to the An­droid de­vice.

So­lu­tion is to re­trieve the ad­dress via the Ja­va An­droid APIs.

Broad­cast 255.255.255.255

Ap­par­ent­ly con­nect­ing to 255.255.255.255 (phys­i­cal lay­er broad­cast ad­dress) is not suf­fi­cient and we in­stead need to use the more ex­plic­it net­work lay­er broad­cast ad­dress, e.g. 192.168.172.255 (More in­fo here). While, yes, you can just change the last byte of your IP adress to 255, but that’s a very ug­ly hack and we should rather just ask the Ja­va APIs again.

So­lu­tion is to al­so re­trieve the broad­cast ad­dress via the Ja­va An­droid APIs.

But, ap­par­ent­ly, if you send to 255.255.255.255 from Win­dows, pack­ets still don’t reach An­droid, we there­fore need to use the more spe­cif­ic ad­dress there, too!

So­lu­tion is to re­trieve the more spe­cif­ic broad­cast ad­dress via WinSock APIs.

JNI

Thanks to the wrap­pers in UE4, call­ing these Ja­va func­tions is rather straight for­ward:

static jmethodID Sockets_GetIP = NULL;
static jmethodID Sockets_GetBroadcastIP = NULL;
static jmethodID Sockets_AcquireMulticastLock = NULL;
static jmethodID Sockets_ReleaseMulticastLock = NULL;

/* Init java functions */

 if (JNIEnv* Env = FAndroidApplication::GetJavaEnv(true)) {
     Sockets_GetIP = FJavaWrapper::FindMethod(Env,
             FJavaWrapper::GameActivityClassID,
             "Sockets_GetIP", "()I", false);
     check(Sockets_GetIP != NULL);

     Sockets_GetBroadcastIP = FJavaWrapper::FindMethod(Env,
             FJavaWrapper::GameActivityClassID,
             "Sockets_GetBroadcastIP", "()I", false);
     check(Sockets_GetBroadcastIP != NULL);

     Sockets_AcquireMulticastLock = FJavaWrapper::FindMethod(Env,
             FJavaWrapper::GameActivityClassID,
             "Sockets_AcquireMulticastLock", "()V", false);
     check(Sockets_AcquireMulticastLock != NULL);

     Sockets_AcquireMulticastLock = FJavaWrapper::FindMethod(Env,
             FJavaWrapper::GameActivityClassID,
             "Sockets_ReleaseMulticastLock", "()V", false);
     check(Sockets_AcquireMulticastLock != NULL);
 }

/* Call java functions */

void GetLocalHostAddrFixed(TSharedRef<FInternetAddr> localIp) {
   if (JNIEnv* Env = FAndroidApplication::GetJavaEnv(true)) {
      const int ip = FJavaWrapper::CallIntMethod(Env, FJavaWrapper::GameActivityThis,
               Sockets_GetIP);
      localIp->SetRawIp({
            uint8(ip & 0xff),
            uint8(ip >> 8 & 0xff),
            uint8(ip >> 16 & 0xff),
            uint8(ip >> 24 & 0xff)});
   }
}

void GetBroadcastAddrFixed(FInternetAddr& broadcastAddr) {
   if (JNIEnv* Env = FAndroidApplication::GetJavaEnv(true)) {
      const int ip = FJavaWrapper::CallIntMethod(Env, FJavaWrapper::GameActivityThis,
               Sockets_GetBroadcastIP);
      broadcastAddr.SetRawIp({
            uint8(ip & 0xff),
            uint8(ip >> 8 & 0xff),
            uint8(ip >> 16 & 0xff),
            uint8(ip >> 24 & 0xff)});
   }
}

void AcquireMulticastLock() {
   if (JNIEnv* Env = FAndroidApplication::GetJavaEnv(true)) {
      FJavaWrapper::CallVoidMethod(Env, FJavaWrapper::GameActivityThis,
               Sockets_AcquireMulticastLock);
   }
}

void ReleaseMulticastLock() {
   if (JNIEnv* Env = FAndroidApplication::GetJavaEnv(true)) {
      FJavaWrapper::CallVoidMethod(Env, FJavaWrapper::GameActivityThis,
               Sockets_ReleaseMulticastLock);
   }
}

Fi­nal­ly for An­droid, 3. make sure you have the fol­low­ing per­mis­sions:

android.permission.INTERNET
android.permission.ACCESS_WIFI_STATE
android.permission.ACCESS_NETWORK_STATE
android.permission.CHANGE_WIFI_MULTICAST_STATE

How do you in­ject the IP ad­dress­es in­to the On­li­ne­Sub­sys­tem­Null? You can ei­ther com­pile the en­gine your­self from source and change the source, or you try to wrap it some­how. For a while I had a FSocketSubsystemAndroidFixed class, which would use it’s orig­i­nal to “man­u­al­ly sub­class” it (since pri­vate sources of the en­gine, you can­not sub­class triv­ial­ly).

Win­dows

Now we have to mere­ly have to 4. fix the broad­cast ad­dress on Win­dows:

bool FSocketSubsystemWindows::GetLocalAdapterBroadcastAddresses( TArray<TSharedPtr<FInternetAddr> >& OutAdresses )
{
   ULONG Flags = GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
   ULONG Result;
   ULONG Size = 0;
   ULONG Family = (PLATFORM_HAS_BSD_IPV6_SOCKETS) ? AF_UNSPEC : AF_INET;

   Result = GetAdaptersAddresses(Family, Flags, NULL, NULL, &Size);
   if (Result != ERROR_BUFFER_OVERFLOW)
   {
      return false;
   }

   PIP_ADAPTER_ADDRESSES AdapterAddresses = (PIP_ADAPTER_ADDRESSES)FMemory::Malloc(Size);

   Result = GetAdaptersAddresses(Family, Flags, NULL, AdapterAddresses, &Size);
   if (Result != ERROR_SUCCESS)
   {
      FMemory::Free(AdapterAddresses);

      return false;
   }

   // extract the list of physical addresses from each adapter
   for (PIP_ADAPTER_ADDRESSES AdapterAddress = AdapterAddresses; AdapterAddress != NULL; AdapterAddress = AdapterAddress->Next)
   {
      if ((AdapterAddress->IfType == IF_TYPE_ETHERNET_CSMACD) ||
            (AdapterAddress->IfType == IF_TYPE_IEEE80211))
      {
         for (PIP_ADAPTER_UNICAST_ADDRESS UnicastAddress = AdapterAddress->FirstUnicastAddress; UnicastAddress != NULL; UnicastAddress = UnicastAddress->Next)
         {
            if ((UnicastAddress->Flags & IP_ADAPTER_ADDRESS_DNS_ELIGIBLE) != 0)
            {
               ULONG mask;
               ConvertLengthToIpv4Mask(UnicastAddress->OnLinkPrefixLength, &mask);

               const sockaddr_storage* RawAddress = (const sockaddr_storage*)(UnicastAddress->Address.lpSockaddr);
               TSharedRef<FInternetAddrBSD> NewAddress = MakeShareable(new FInternetAddrBSD(this));
               const int32 broadcastAddr = ~mask | ((sockaddr_in*)RawAddress)->sin_addr.s_addr;
               NewAddress->SetRawIp({
                     uint8(broadcastAddr & 0xff),
                     uint8(broadcastAddr >> 8 & 0xff),
                     uint8(broadcastAddr >> 16 & 0xff),
                     uint8(broadcastAddr >> 24 & 0xff)});
               OutAdresses.Add(NewAddress);
            }
         }
      }
   }

   FMemory::Free(AdapterAddresses);

   return true;
}