Send DETACH when ATTACHED is received on a detaching or detached channel (RTL5k)

src/Ably.PubSub.Shared/Realtime/ChannelMessageProcessor.cs

@@ -39,6 +39,17 @@ public Task<bool> MessageReceived(ProtocolMessage protocolMessage, RealtimeState
                 return Task.FromResult(false);
             }
 
+            // RTL5k - an ATTACHED received while the channel is DETACHING or DETACHED must not
+            // re-attach a channel the application has detached. It is answered with a new DETACH and
+            // leaves the channel untouched otherwise: in particular the RTL15b channelSerial below,
+            // which RTL15b2 cleared on entering DETACHED and the next ATTACH would carry (RTL4c1).
+            if (protocolMessage.Action == ProtocolMessage.MessageAction.Attached &&
+                (channel.State == ChannelState.Detaching || channel.State == ChannelState.Detached))
+            {
+                channel.DetachForUnexpectedAttached();
+                return TaskConstants.BooleanTrue;
+            }
+
             // RTL15b
             if (protocolMessage.ChannelSerial.IsNotEmpty() &&
                 (protocolMessage.Action == ProtocolMessage.MessageAction.Message ||

src/Ably.PubSub.Shared/Realtime/RealtimeChannel.cs

@@ -496,6 +496,61 @@ private void Detach(Action<bool, ErrorInfo> callback, bool force, bool emitUpdat
             }
         }
 
+        /// <summary>
+        /// RTL5k - "If the channel receives an ATTACHED message while in the DETACHING or DETACHED
+        /// state, it should send a new DETACH message and remain in (or transition to) the DETACHING
+        /// state".
+        /// </summary>
+        internal void DetachForUnexpectedAttached()
+        {
+            // State is read once: a concurrent Attach() on the caller's thread may already have moved
+            // the channel on, in which case the ATTACHED is no longer unexpected.
+            var state = State;
+            if (state != ChannelState.Detaching && state != ChannelState.Detached)
+            {
+                return;
+            }
+
+            switch (ConnectionState)
+            {
+                case ConnectionState.Connected:
+                    Logger.Debug($"#{Name}: ATTACHED received in {state} state; sending DETACH (RTL5k)");
+
+                    if (state == ChannelState.Detaching && DetachedAwaiter.Waiting)
+                    {
+                        // The detach in progress already owns the RTL5f timer, so only the DETACH
+                        // is resent.
+                        SendMessage(new ProtocolMessage(ProtocolMessage.MessageAction.Detach, Name));
+                    }
+                    else
+                    {
+                        // The ordinary detach path transitions to DETACHING, starts the RTL5f timer,
+                        // which returns the channel to its previous state if no DETACHED arrives, and
+                        // sends the DETACH.
+                        Detach(null, force: true, emitUpdate: false);
+                    }
+
+                    break;
+
+                case ConnectionState.Connecting:
+                case ConnectionState.Disconnected:
+                    // A DETACHING channel has its DETACH sent, and its RTL5f timer started, once the
+                    // connection becomes CONNECTED (RTN19b).
+                    Logger.Debug($"#{Name}: ATTACHED received in {state} state while connection is {ConnectionState}; DETACH will be sent once connected (RTL5k)");
+
+                    if (state == ChannelState.Detached)
+                    {
+                        SetChannelState(ChannelState.Detaching);
+                    }
+
+                    break;
+
+                default:
+                    Logger.Debug($"#{Name}: ATTACHED received in {state} state while connection is {ConnectionState}; not sending DETACH");
+                    break;
+            }
+        }
+
         public async Task<Result> DetachAsync()
         {
             return await TaskWrapper.Wrap(Detach);