Ensuring there will be a means for clients to disconnect themselves if they haven't been approved in a reasonable amount of time.

Assets/Scripts/Game/GameManager.cs

             LobbyAsyncRequests.Instance.BeginTracking(m_localLobby.LobbyID);
             m_lobbyContentHeartbeat.BeginTracking(m_localLobby, m_localUser);
             SetUserLobbyState();
-            StartRelayConnection();
-            StartVivoxJoin();
+
+            // The host has the opportunity to reject incoming players, but to do so the player needs to connect to Relay without having game logic available.
+            // In particular, we should prevent players from joining voice chat until they are approved.
+            OnReceiveMessage(MessageType.LobbyUserStatus, UserStatus.Connecting);
+            if (m_localUser.IsHost)
+            {
+                StartRelayConnection();
+                StartVivoxJoin();
+            }
+            else
+            {
+                // TODO: Implement
+            }
         }
 
         private void OnLeftLobby()
                 m_relaySetup = gameObject.AddComponent<RelayUtpSetupHost>();
             else
                 m_relaySetup = gameObject.AddComponent<RelayUtpSetupClient>();
-            OnReceiveMessage(MessageType.LobbyUserStatus, UserStatus.Connecting);
             m_relaySetup.BeginRelayJoin(m_localLobby, m_localUser, OnRelayConnected);
 
             void OnRelayConnected(bool didSucceed, RelayUtpClient client)

Assets/Scripts/Game/LobbyUser.cs

     [Serializable]
     public class LobbyUser : Observed<LobbyUser>
     {
-        public LobbyUser(bool isHost = false, string displayName = null, string id = null, EmoteType emote = EmoteType.None, UserStatus userStatus = UserStatus.Menu)
+        public LobbyUser(bool isHost = false, string displayName = null, string id = null, EmoteType emote = EmoteType.None, UserStatus userStatus = UserStatus.Menu, bool isApproved = false)
-            m_data = new UserData(isHost, displayName, id, emote, userStatus);
+            m_data = new UserData(isHost, displayName, id, emote, userStatus, isApproved);
         }
 
         #region Local UserData
             public string ID { get; set; }
             public EmoteType Emote { get; set; }
             public UserStatus UserStatus { get; set; }
+            public bool IsApproved { get; set; }
-            public UserData(bool isHost, string displayName, string id, EmoteType emote, UserStatus userStatus)
+            public UserData(bool isHost, string displayName, string id, EmoteType emote, UserStatus userStatus, bool isApproved)
             {
                 IsHost = isHost;
                 DisplayName = displayName;
+                IsApproved = isApproved;
             }
         }
 
         {
-            m_data = new UserData(false, m_data.DisplayName, m_data.ID, EmoteType.None, UserStatus.Menu); // ID and DisplayName should persist since this might be the local user.
+            m_data = new UserData(false, m_data.DisplayName, m_data.ID, EmoteType.None, UserStatus.Menu, false); // ID and DisplayName should persist since this might be the local user.
         }
 
         #endregion
             DisplayName = 2,
             Emote = 4,
             ID = 8,
-            UserStatus = 16
-		}
+            UserStatus = 16,
+            IsApproved = 32
+        }
 
         private UserMembers m_lastChanged;
         public UserMembers LastChanged => m_lastChanged;
                     m_data.IsHost = value;
                     m_lastChanged = UserMembers.IsHost;
                     OnChanged(this);
+                    if (value)
+                        IsApproved = true;
                 }
             }
         }
                 {
                     m_userStatus = value;
                     m_lastChanged = UserMembers.UserStatus;
+                    OnChanged(this);
+                }
+            }
+        }
+
+        public bool IsApproved // Clients joining the lobby should be approved by the host before they can interact.
+        {
+            get => m_data.IsApproved;
+            set
+            {
+                if (!m_data.IsApproved && value) // Don't be un-approved except by a call to ResetState.
+                {
+                    m_data.IsApproved = value;
+                    m_lastChanged = UserMembers.IsApproved;
                     OnChanged(this);
                 }
             }

Assets/Scripts/Lobby/LobbyContentHeartbeat.cs

         private bool m_isAwaitingQuery = false;
         private bool m_shouldPushData = false;
 
+        private const float k_approvalMaxTime = 10; // Used for determining if a user should timeout if they are unable to connect.
+        private float m_lifetime = 0;
+
         public void BeginTracking(LocalLobby lobby, LobbyUser localUser)
         {
             m_localLobby = lobby;
             m_shouldPushData = true; // Ensure the initial presence of a new player is pushed to the lobby; otherwise, when a non-host joins, the LocalLobby never receives their data until they push something new.
+            m_lifetime = 0;
         }
 
         public void EndTracking()
         /// </summary>
         private void OnUpdate(float dt)
         {
+            m_lifetime += dt;
+
+            if (!m_localUser.IsApproved && m_lifetime > k_approvalMaxTime)
+            {
+                Locator.Get.Messenger.OnReceiveMessage(MessageType.DisplayErrorPopup, "Connection attempt timed out!");
+                Locator.Get.Messenger.OnReceiveMessage(MessageType.ChangeGameState, GameState.JoinMenu);
+            }
+
             m_isAwaitingQuery = true; // Note that because we make async calls, if one of them fails and doesn't call our callback, this will never be reset to false.
             if (m_shouldPushData)
                 PushDataToLobby();