Code works outside of Unity, but inside of it something gets lost...

Unity Engine
1

I have made a framework .dll that encapsulates a lot of networking stuff. I use it outside of Unity without any issues at all. However, adding it to Unity (inside a Plugins folder) works, but only until I try sending messages back/forth.

The gist of it is that the Login script runs, handling events from the ServerManager that it needs (connections/messages). The messages are a custom class from my framework. Now, the connections work great, as I am connected. I also get the first message from the server that it will now accept messages, so it correctly turns the login button on. However, after clicking the login button (which calls the LoginClick), I do not get anything back from the server. No message is returned, and no message from the server can come through anymore (including the previous working “accepting messages”).

The login function correctly works, as verified by debugging the received message on the server side. It correctly finds the information in our database, and writes back the correct message.

The odd thing about this, it all works when I made a test Windows Form application. Using the same ServerManager approach, I made a WinForm with the same design and textboxes, and even the login call on a button click. It works, and I even get the message back (“AccountLogin”) from the server properly.

So, it can’t really be an issue with my framework/dll, could it be? I mean the whole thing works, then just breaks after calling the login function on a Unity button click. The exact same scenario works in WinForms. Unity even gets all messages I send from the server until I click that button to try logging in.

ServerManager.cs:

using UnityEngine;
using System.Collections;
using RiptideShared;
using RiptideShared.Messaging;
using System.Collections.Generic;

public static class ServerManager
{

   private static RiptideClient _client = null;

  public delegate void OnConnectionChangedEventHandler(RiptideClient Sender, eConnectionStatus ConnectionStatus);
  public static event OnConnectionChangedEventHandler OnConnectionChanged;
  public delegate void OnMessageReceivedEventHandler(RiptideClient Sender, Message Message);
  public static event OnMessageReceivedEventHandler OnMessageReceived;

   public static bool ClientConnected
   {
     get
     {
       if(_client.ConnectionStatus == RiptideShared.eConnectionStatus.Connected)
         return true;
       else
         return false;
     }
   }

  public static RiptideClient Client { get { return _client; } }

   public static void Start()
   {
  if (_client == null)
  {
  _client = new RiptideShared.RiptideClient();
  _client.OnConnectionChanged += HandleOnConnectionChanged;
  _client.OnMessageReceived += HandleOnMessageReceived;
  }
     _client.Connect ();
   }

   static void HandleOnConnectionChanged (RiptideClient Sender, eConnectionStatus ConnectionStatus)
   {
  Debug.Log(ConnectionStatus.ToString());
  if (OnConnectionChanged != null)
  OnConnectionChanged(Sender, ConnectionStatus);
   }

   static void HandleOnMessageReceived (RiptideClient Sender, Message Message)
   {
  Debug.Log(Message.MessageType);
  if (OnMessageReceived != null)
  OnMessageReceived(Sender, Message);
   }

  public static void Login(string Username, string Password)
  {
  _client.WriteTo(new Message(null, Message.MessageTypes.AccountLogin, new List<object>() { Username, Password }));
  }

}

Login.cs

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using RiptideShared.Messaging;
using RiptideShared;
using System.Collections.Generic;

public class Login : MonoBehaviour {

  Text _connectionStatusLabel;
  InputField _emailInputField;
  InputField _passwordInputField;
  Button _loginButton;

  bool _serverAcceptingMessages = false;
  RiptideShared.eConnectionStatus connectionStatus = eConnectionStatus.NotConnected;

   // Use this for initialization
   void Start () {

  //get the variables filled up
  _connectionStatusLabel = (Text)GameObject.Find("ConnectionStatusLabel").GetComponent(typeof(Text));
  _emailInputField = (InputField)GameObject.Find("EmailInput").GetComponent(typeof(InputField));
  _passwordInputField = (InputField)GameObject.Find("PasswordInput").GetComponent(typeof(InputField));
  _loginButton = (Button)GameObject.Find("LoginButton").GetComponent(typeof(Button));

  //start the server manager
  ServerManager.OnConnectionChanged += ServerManager_OnConnectionChanged;
  ServerManager.OnMessageReceived += ServerManager_OnMessageReceived;
  ServerManager.Start();
   }

  void ServerManager_OnMessageReceived(RiptideClient Sender, Message Message)
  {
  switch(Message.MessageType)
  {
  case Message.MessageTypes.ServerAcceptingMessages:
  _serverAcceptingMessages = true;
  break;
  case Message.MessageTypes.AccountLogin:
  break;
  }
  }

  void ServerManager_OnConnectionChanged(RiptideClient Sender, eConnectionStatus ConnectionStatus)
  {
  connectionStatus = ConnectionStatus;
  }
   
   // Update is called once per frame
   void Update () {
  _connectionStatusLabel.text = "Connection Status: " + connectionStatus.ToString();
  if ((!_loginButton.interactable) && (connectionStatus == eConnectionStatus.Connected) && (_serverAcceptingMessages))
  _loginButton.interactable = true;
  else if (connectionStatus != eConnectionStatus.Connected)
  _loginButton.interactable = false;
   }

  public void LoginClick()
  {
  ServerManager.Login(_emailInputField.text, _passwordInputField.text);
  }

}
2

Just a random thought is if you are running this in the browser: the browser has a sandbox model that prohibits Unity’s code from contacting third party servers, unless there is an appropriate cross-site XML policy file in place.

3

Browser as in the web? No, this happens in the editor when “playing” and also on a build of the .exe (through Unity) running standalone.

4

Yeah, I meant in the webplayer build just because that’s a common pitfall, forgetting about XSS.

Other than that you’ll probably have to wireshark it or otherwise sniff the traffic in a way that can reveal where you’re going astray… double check your target URIs, etc.

5

Bringing this thread up to the top again.

I finally had some time to download wireshark. Ugh, I can barely understand the things going on. But, I did run the server and client through Unity while it was capturing the packets. Looking through what was displayed, I could not find any entry at all related to the port I use for the server/client.

This leads me to believe that wireshark is useless (for the time being) as the server/client run on the same machine. The server has been tested, and connected to successfully, from outside the local network, so hopefully I can get someone to test the Unity program for me while I have the server and wireshark running on my machine.

As another test, I added a button into the Unity program to send a message to the server. Verified it correctly sends the message to the server, and the server sends a response back. Unity receives this message, as verified through my receiving message event and showing a Debug.Log(***).

Now, this really confuses me since I now know that I can send a message and get one back.

So, I dug a little deeper. It turns out that in my Login procedure on the server, I do some things that apparently causes issues. I found 1 lines which if I comment them out, Unity gets the Login message back correctly. However, by not running the “issue” line, the server doesn’t think that an account is logged in.

So, why is it that the WinForms application works correctly (with the “issue” line) and the Unity one doesn’t? I don’t know, and probably no one else knows either. It’s such a weird issue.

Here is my login procedure (on the server):

private void AccountLogin(ref RiptideClient Client, Message Message)
  {
  int id = -1;
  id = AccountLoginID(Message);

  if (id > 0)
  {
  //successful login
  AccountInformation(id);
  Player player = PlayerInformation(id);
  Client.Player = player;

  Server.Log("Login: " + _username);
  RiptideShared.Messaging.Message message = new RiptideShared.Messaging.Message(Client.Player, RiptideShared.Messaging.Message.MessageTypes.AccountLogin,
  new List<object>() { id, Client.Player });
  Client.WriteTo(message);
  ClientManager.SendToAccountType("Developer", message);
  }
  else
  {
  //can't login

  }
  }

The “Client.Player = player” is the 1 line that doesn’t let Unity get the message back. Commenting it out, Unity receives the message back. Remember, it works “as is” in a WinForms application.

I think my head hurts now :frowning:

6

I know this is a long post, so please bare with it if you decide to read it.

It turns out the “Client.Player = player” isn’t exactly the issue, it just looked like it.

If I replace

RiptideShared.Messaging.Message message = new RiptideShared.Messaging.Message(Client.Player, RiptideShared.Messaging.Message.MessageTypes.AccountLogin,
  new List<object>() { id, Client.Player });

with this

RiptideShared.Messaging.Message message = new RiptideShared.Messaging.Message(null, RiptideShared.Messaging.Message.MessageTypes.AccountLogin,
  new List<object>() { id, null });

Unity can receive the message back.

However, if I try 1 of the “Client.Player” variables instead of null, Unity doesn’t receive the message back. It’s important that I send the Client.Player back to the client that is logging in.

Here is my Message class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using RiptideShared.Player;

namespace RiptideShared.Messaging
{
  [Serializable]
  public class Message
  {

  public enum MessageTypes
  {
  *** enums removed, have about 50 of them so far... ***
  }

  private MessageTypes messageType;
  private List<object> messageParameters = new List<object>();
  private Player.Player _player;

  public MessageTypes MessageType { get { return messageType; } }
  public List<object> MessageParameters { get { return messageParameters; } }
  public Player.Player Player { get { return _player; } }

  public Message(Player.Player Player, MessageTypes MessageType)
  {
  _player = Player;
  messageType = MessageType;
  messageParameters = new List<object>() { };
  }


  public Message(Player.Player Player, MessageTypes MessageType, List<object> MessageParameters)
  {
  _player = Player;
  messageType = MessageType;
  messageParameters = MessageParameters;
  }

  }
}

Every class used inside of Player (and sub classes) are all correctly marked [Serializable] so they can be passed via network. I won’t put all of those in here unless absolutely necessary.

Here is my DataWriter:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;


namespace RiptideShared
{
  class DataWriter
  {

  //declarations
  private NetworkStream stream;

  public DataWriter(RiptideClient Client)
  {
  stream = Client.Stream;
  }

  private byte[] Combine(byte[] one, byte[] two)
  {
  byte[] ret = new byte[one.Length + two.Length];
  Buffer.BlockCopy(one, 0, ret, 0, one.Length);
  Buffer.BlockCopy(two, 0, ret, one.Length, two.Length);
  return ret;
  }

  public void WriteTo(RiptideShared.Messaging.Message Message)
  {
  BinaryFormatter bf = new BinaryFormatter();
  MemoryStream ms = new MemoryStream();
  bf.Serialize(ms, Message);

  byte[] buffer = ms.ToArray();
  //prepend the length of the buffer
  byte[] toPrepend = Encoding.ASCII.GetBytes("[" + buffer.Length.ToString() + "]");
  byte[] combined = Combine(toPrepend, buffer);

  stream.Write(combined, 0, combined.Length);
  }

  }
}

And my DataReader:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Net.Sockets;
using System.Diagnostics;

namespace RiptideShared
{
  class DataReader
  {

  //events
  public delegate void OnMessageReceivedEventHandler(Messaging.Message Message);
  public event OnMessageReceivedEventHandler OnMessageReceived;

  //declarations
  RiptideClient client; //this is the exact copy of the client passed in (on server = from _sharedClients, on client = from client)
  NetworkStream stream;
  byte[] constantBuffer = new byte[0];

  //methods
  public DataReader(RiptideClient Client)
  {
  client = Client;
  stream = Client.Stream;
  }

  public void StartReading()
  {
  WaitForData();
  }

  private void WaitForData()
  {
  byte[] buffer = new byte[client.GetBufferSize];
  stream.BeginRead(buffer, 0, buffer.Length, ReadData, buffer);
  }

  private void ReadData(IAsyncResult ar)
  {
  //try
  //{
  int read = -1;
  try
  {
  read = stream.EndRead(ar);
  }
  catch(Exception ex)
  {
  //ungraceful disconnect???
  //RiptideShared.Messaging.Message message = new Messaging.Message(client.Player, Messaging.Message.MessageTypes.AccountDisconnect);
  //if (OnMessageReceived != null)
  //  OnMessageReceived(message);
  //return;
  }
   
  if (read == 0)
  {
  //client disconnected

  }
  else
  {
  byte[] buffer = ar.AsyncState as byte[];
  constantBuffer = Combine(constantBuffer, buffer, read);
  string checkLength = Encoding.Default.GetString(constantBuffer, 0, constantBuffer.Length);
  while (true)
  {
  if ((checkLength.Contains("[")) && (checkLength.Contains("]")))
  {
  string toCheck = checkLength.Substring(1, checkLength.IndexOf("]") - 1);
  int lengthOfBytes = Convert.ToInt32(checkLength.Substring(1, checkLength.IndexOf("]") - 1));
  if (constantBuffer.Length >= lengthOfBytes)
  {
  //have an instance of our class here
  byte[] toPrepend = Encoding.ASCII.GetBytes("[" + lengthOfBytes.ToString() + "]");
  byte[] messageClass = new byte[lengthOfBytes];
  Buffer.BlockCopy(constantBuffer, toPrepend.Length, messageClass, 0, lengthOfBytes);

  RiptideShared.Messaging.Message Message = null;
  using (MemoryStream memStream = new MemoryStream())
  {
  BinaryFormatter binForm = new BinaryFormatter();
  //memStream.Write(buffer, 0, buffer.Length);
  memStream.Write(messageClass, 0, messageClass.Length);
  memStream.Seek(0, SeekOrigin.Begin);
  Message = (RiptideShared.Messaging.Message)binForm.Deserialize(memStream);
  if (OnMessageReceived != null)
  OnMessageReceived(Message);
  }

  //reset the constantBuffer to everything minus the just used message class
  int constantLength = constantBuffer.Length;
  int prependLength = toPrepend.Length;
  int messageLength = messageClass.Length;
  int togetherLength = prependLength + messageLength;
  int newLength = constantLength - togetherLength;
  byte[] newByte = new byte[newLength];
  Buffer.BlockCopy(constantBuffer, togetherLength, newByte, 0, newLength);
  constantBuffer = newByte;

  checkLength = Encoding.Default.GetString(constantBuffer, 0, constantBuffer.Length);
  }
  else
  break;
  }
  else
  break;
  }
  }
  WaitForData();
  //}
  //catch(Exception ex)
  //{
  //ungraceful disconnect
   
  //}
  }

  private byte[] Combine(byte[] one, byte[] two, int twoRead)
  {
  byte[] ret = new byte[one.Length + twoRead];
  Buffer.BlockCopy(one, 0, ret, 0, one.Length);
  Buffer.BlockCopy(two, 0, ret, one.Length, twoRead);
  return ret;
  }

  }
}