| /* |
| * |
| * Copyright (c) 2025 Project CHIP Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * This file implements a WiFiPAF endpoint abstraction for CHIP over WiFiPAF (CHIPoPAF) |
| * Public Action Frame Transport Protocol (PAFTP). |
| * |
| */ |
| |
| #include "WiFiPAFEndPoint.h" |
| |
| #include <cstdint> |
| #include <cstring> |
| #include <utility> |
| |
| #include <lib/support/BitFlags.h> |
| #include <lib/support/BufferReader.h> |
| #include <lib/support/CodeUtils.h> |
| #include <lib/support/logging/CHIPLogging.h> |
| #include <system/SystemClock.h> |
| #include <system/SystemLayer.h> |
| #include <system/SystemPacketBuffer.h> |
| |
| #include "WiFiPAFConfig.h" |
| #include "WiFiPAFError.h" |
| #include "WiFiPAFLayer.h" |
| #include "WiFiPAFTP.h" |
| |
| // Define below to enable extremely verbose, WiFiPAF end point-specific debug logging. |
| #undef CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_ENABLED |
| #define CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_LEVEL 0 |
| |
| #ifdef CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_ENABLED |
| #define ChipLogDebugWiFiPAFEndPoint_L0(MOD, MSG, ...) ChipLogDetail(MOD, MSG, ##__VA_ARGS__) |
| #if (CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_LEVEL == 0) |
| #define ChipLogDebugWiFiPAFEndPoint(MOD, MSG, ...) |
| #else |
| #define ChipLogDebugWiFiPAFEndPoint(MOD, MSG, ...) ChipLogDetail(MOD, MSG, ##__VA_ARGS__) |
| #endif // CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_LEVEL |
| #define ChipLogDebugBufferWiFiPAFEndPoint(MOD, BUF) \ |
| ChipLogByteSpan(MOD, ByteSpan((BUF)->Start(), ((BUF)->DataLength() < 8 ? (BUF)->DataLength() : 8u))) |
| #else |
| #define ChipLogDebugWiFiPAFEndPoint(MOD, MSG, ...) |
| #define ChipLogDebugBufferWiFiPAFEndPoint(MOD, BUF) |
| #endif |
| |
| /** |
| * @def WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD |
| * |
| * @brief |
| * If an end point's receive window drops equal to or below this value, it will send an immediate acknowledgement |
| * packet to re-open its window instead of waiting for the send-ack timer to expire. |
| * |
| */ |
| #define WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD 1 |
| |
| #define WIFIPAF_ACK_SEND_TIMEOUT_MS 2500 |
| #define WIFIPAF_WAIT_RES_TIMEOUT_MS 1000 |
| // Drop the connection if network resources remain unavailable for the period. |
| #define WIFIPAF_MAX_RESOURCE_BLOCK_COUNT (PAFTP_CONN_IDLE_TIMEOUT_MS / WIFIPAF_WAIT_RES_TIMEOUT_MS) |
| |
| /** |
| * @def WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD |
| * |
| * @brief |
| * Data fragments may only be sent without piggybacked acks if receiver's window size is above this threshold. |
| * |
| */ |
| #define WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD 1 |
| |
| namespace chip { |
| namespace WiFiPAF { |
| |
| CHIP_ERROR WiFiPAFEndPoint::StartConnect() |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| PAFTransportCapabilitiesRequestMessage req; |
| PacketBufferHandle buf; |
| constexpr uint8_t numVersions = |
| CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION - CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION + 1; |
| static_assert(numVersions <= NUM_PAFTP_SUPPORTED_PROTOCOL_VERSIONS, "Incompatibly protocol versions"); |
| |
| // Ensure we're in the correct state. |
| VerifyOrExit(mState == kState_Ready, err = CHIP_ERROR_INCORRECT_STATE); |
| mState = kState_Connecting; |
| |
| // Build PAF transport protocol capabilities request. |
| buf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); |
| VerifyOrExit(!buf.IsNull(), err = CHIP_ERROR_NO_MEMORY); |
| |
| // Zero-initialize PAF transport capabilities request. |
| memset(&req, 0, sizeof(req)); |
| req.mMtu = CHIP_PAF_DEFAULT_MTU; |
| req.mWindowSize = PAF_MAX_RECEIVE_WINDOW_SIZE; |
| |
| // Populate request with highest supported protocol versions |
| for (uint8_t i = 0; i < numVersions; i++) |
| { |
| req.SetSupportedProtocolVersion(i, static_cast<uint8_t>(CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION - i)); |
| } |
| |
| err = req.Encode(buf); |
| SuccessOrExit(err); |
| |
| // Start connect timer. Canceled when end point freed or connection established. |
| err = StartConnectTimer(); |
| SuccessOrExit(err); |
| |
| // Send PAF transport capabilities request to peripheral. |
| // Add reference to message fragment. CHIP retains partial ownership of message fragment's packet buffer, |
| // since this is the same buffer as that of the whole message, just with a fragmenter-modified payload offset |
| // and data length, by a Retain() on the handle when calling this function. |
| err = SendWrite(buf.Retain()); |
| SuccessOrExit(err); |
| // Free request buffer on write confirmation. Stash a reference to it in mSendQueue, which we don't use anyway |
| // until the connection has been set up. |
| QueueTx(std::move(buf), kType_Data); |
| |
| exit: |
| // If we failed to initiate the connection, close the end point. |
| if (err != CHIP_NO_ERROR) |
| { |
| StopConnectTimer(); |
| DoClose(kWiFiPAFCloseFlag_AbortTransmission, err); |
| } |
| |
| return err; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::HandleConnectComplete() |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| mState = kState_Connected; |
| // Cancel the connect timer. |
| StopConnectTimer(); |
| |
| // We've successfully completed the PAF transport protocol handshake, so let the application know we're open for business. |
| if (mWiFiPafLayer != nullptr) |
| { |
| // Indicate connect complete to next-higher layer. |
| mWiFiPafLayer->OnEndPointConnectComplete(this, CHIP_NO_ERROR); |
| } |
| else |
| { |
| // If no connect complete callback has been set up, close the end point. |
| err = WIFIPAF_ERROR_NO_CONNECT_COMPLETE_CALLBACK; |
| } |
| return err; |
| } |
| |
| bool WiFiPAFEndPoint::IsConnected(uint8_t state) const |
| { |
| return (state == kState_Connected || state == kState_Closing); |
| } |
| |
| void WiFiPAFEndPoint::DoClose(uint8_t flags, CHIP_ERROR err) |
| { |
| uint8_t oldState = mState; |
| |
| // If end point is not closed or closing, OR end point was closing gracefully, but tx abort has been specified... |
| if ((mState != kState_Closed && mState != kState_Closing) || |
| (mState == kState_Closing && (flags & kWiFiPAFCloseFlag_AbortTransmission))) |
| { |
| // Cancel Connect and ReceiveConnect timers if they are running. |
| // Check role first to avoid needless iteration over timer pool. |
| if (mRole == kWiFiPafRole_Subscriber) |
| { |
| StopConnectTimer(); |
| } |
| |
| // Free the packets in re-order queue if ones exist |
| for (uint8_t qidx = 0; qidx < PAFTP_REORDER_QUEUE_SIZE; qidx++) |
| { |
| if (ReorderQueue[qidx] != nullptr) |
| { |
| ReorderQueue[qidx] = nullptr; |
| ItemsInReorderQueue--; |
| } |
| } |
| |
| // If transmit buffer is empty or a transmission abort was specified... |
| if (mPafTP.TxState() == WiFiPAFTP::kState_Idle || (flags & kWiFiPAFCloseFlag_AbortTransmission)) |
| { |
| FinalizeClose(oldState, flags, err); |
| } |
| else |
| { |
| // Wait for send queue and fragmenter's tx buffer to become empty, to ensure all pending messages have been |
| // sent. Only free end point and tell platform it can throw away the underlying connection once all |
| // pending messages have been sent and acknowledged by the remote CHIPoPAF stack, or once the remote stack |
| // closes the CHIPoPAF connection. |
| // |
| // In so doing, WiFiPAFEndPoint attempts to emulate the level of reliability afforded by TCPEndPoint and TCP |
| // sockets in general with a typical default SO_LINGER option. That said, there is no hard guarantee that |
| // pending messages will be sent once (Do)Close() is called, so developers should use application-level |
| // messages to confirm the receipt of all data sent prior to a Close() call. |
| mState = kState_Closing; |
| |
| if ((flags & kWiFiPAFCloseFlag_SuppressCallback) == 0) |
| { |
| DoCloseCallback(oldState, flags, err); |
| } |
| } |
| } |
| } |
| |
| void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR err) |
| { |
| mState = kState_Closed; |
| |
| // Ensure transmit queue is empty and set to NULL. |
| mSendQueue = nullptr; |
| // Clear the session information |
| ChipLogProgress(WiFiPAF, "Shutdown PAF session (%u, %u)", mSessionInfo.id, mSessionInfo.role); |
| mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFCloseSession(mSessionInfo); |
| memset(&mSessionInfo, 0, sizeof(mSessionInfo)); |
| // Fire application's close callback if we haven't already, and it's not suppressed. |
| if (oldState != kState_Closing && (flags & kWiFiPAFCloseFlag_SuppressCallback) == 0) |
| { |
| DoCloseCallback(oldState, flags, err); |
| } |
| |
| // If underlying WiFiPAF connection has closed, connection object is invalid, so just free the end point and return. |
| if (err == WIFIPAF_ERROR_REMOTE_DEVICE_DISCONNECTED || err == WIFIPAF_ERROR_APP_CLOSED_CONNECTION) |
| { |
| Free(); |
| } |
| else // Otherwise, try to signal close to remote device before end point releases WiFiPAF connection and frees itself. |
| { |
| if (mRole == kWiFiPafRole_Subscriber) |
| { |
| // Cancel send and receive-ack timers, if running. |
| StopAckReceivedTimer(); |
| StopSendAckTimer(); |
| StopWaitResourceTimer(); |
| mConnStateFlags.Set(ConnectionStateFlag::kOperationInFlight); |
| } |
| else |
| { |
| Free(); |
| } |
| } |
| ClearAll(); |
| } |
| |
| void WiFiPAFEndPoint::DoCloseCallback(uint8_t state, uint8_t flags, CHIP_ERROR err) |
| { |
| // Callback fires once per end point lifetime. |
| mOnPafSubscribeComplete = nullptr; |
| mOnPafSubscribeError = nullptr; |
| OnConnectionClosed = nullptr; |
| } |
| |
| void WiFiPAFEndPoint::Free() |
| { |
| // Clear fragmentation and reassembly engine's Tx and Rx buffers. Counters will be reset by next engine init. |
| FreePAFtpEngine(); |
| |
| // Clear pending ack buffer, if any. |
| mAckToSend = nullptr; |
| |
| // Cancel all timers. |
| StopConnectTimer(); |
| StopAckReceivedTimer(); |
| StopSendAckTimer(); |
| StopWaitResourceTimer(); |
| |
| // Clear callbacks. |
| mOnPafSubscribeComplete = nullptr; |
| mOnPafSubscribeError = nullptr; |
| OnMessageReceived = nullptr; |
| OnConnectionClosed = nullptr; |
| } |
| |
| void WiFiPAFEndPoint::FreePAFtpEngine() |
| { |
| // Free transmit disassembly buffer |
| mPafTP.ClearTxPacket(); |
| |
| // Free receive reassembly buffer |
| mPafTP.ClearRxPacket(); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::Init(WiFiPAFLayer * WiFiPafLayer, WiFiPAFSession & SessionInfo) |
| { |
| // Fail if already initialized. |
| VerifyOrReturnError(mWiFiPafLayer == nullptr, CHIP_ERROR_INCORRECT_STATE); |
| |
| // Validate args. |
| VerifyOrReturnError(WiFiPafLayer != nullptr, CHIP_ERROR_INVALID_ARGUMENT); |
| |
| // If end point plays subscriber role, expect ack as last step of PAFTP handshake. |
| // If being publisher, subscriber's handshake indication 'ack's write sent by publisher to kick off the PAFTP handshake. |
| bool expectInitialAck = (SessionInfo.role == kWiFiPafRole_Publisher); |
| |
| CHIP_ERROR err = mPafTP.Init(this, expectInitialAck); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(WiFiPAF, "WiFiPAFTP init failed"); |
| return err; |
| } |
| |
| mWiFiPafLayer = WiFiPafLayer; |
| |
| // WiFiPAF EndPoint data members: |
| memcpy(&mSessionInfo, &SessionInfo, sizeof(mSessionInfo)); |
| mRole = SessionInfo.role; |
| mTimerStateFlags.ClearAll(); |
| mLocalReceiveWindowSize = 0; |
| mRemoteReceiveWindowSize = 0; |
| mReceiveWindowMaxSize = 0; |
| mSendQueue = nullptr; |
| mAckToSend = nullptr; |
| |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "initialized local rx window, size = %u", mLocalReceiveWindowSize); |
| |
| // End point is ready. |
| mState = kState_Ready; |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::SendCharacteristic(PacketBufferHandle && buf) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| SuccessOrExit(err = SendWrite(std::move(buf))); |
| // Write succeeded, so shrink remote receive window counter by 1. |
| mRemoteReceiveWindowSize = static_cast<SequenceNumber_t>(mRemoteReceiveWindowSize - 1); |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "decremented remote rx window, new size = %u", mRemoteReceiveWindowSize); |
| exit: |
| return err; |
| } |
| |
| /* |
| * Routine to queue the Tx packet with a packet type |
| * kType_Data(0) - data packet |
| * kType_Control(1) - control packet |
| */ |
| void WiFiPAFEndPoint::QueueTx(PacketBufferHandle && data, PacketType_t type) |
| { |
| if (mSendQueue.IsNull()) |
| { |
| mSendQueue = std::move(data); |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "%s: Set data as new mSendQueue %p, type %d", __FUNCTION__, mSendQueue->Start(), type); |
| } |
| else |
| { |
| mSendQueue->AddToEnd(std::move(data)); |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "%s: Append data to mSendQueue %p, type %d", __FUNCTION__, mSendQueue->Start(), type); |
| } |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::Send(PacketBufferHandle && data) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| VerifyOrExit(!data.IsNull(), err = CHIP_ERROR_INVALID_ARGUMENT); |
| VerifyOrExit(IsConnected(mState), err = CHIP_ERROR_INCORRECT_STATE); |
| |
| // Ensure outgoing message fits in a single contiguous packet buffer, as currently required by the |
| // message fragmentation and reassembly engine. |
| if (data->HasChainedBuffer()) |
| { |
| data->CompactHead(); |
| |
| if (data->HasChainedBuffer()) |
| { |
| err = CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG; |
| ExitNow(); |
| } |
| } |
| |
| // Add new message to send queue. |
| QueueTx(std::move(data), kType_Data); |
| |
| // Send first fragment of new message, if we can. |
| err = DriveSending(); |
| SuccessOrExit(err); |
| exit: |
| if (err != CHIP_NO_ERROR) |
| { |
| DoClose(kWiFiPAFCloseFlag_AbortTransmission, err); |
| } |
| |
| return err; |
| } |
| |
| bool WiFiPAFEndPoint::PrepareNextFragment(PacketBufferHandle && data, bool & sentAck) |
| { |
| // If we have a pending fragment acknowledgement to send, piggyback it on the fragment we're about to transmit. |
| if (mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning)) |
| { |
| // Reset local receive window counter. |
| mLocalReceiveWindowSize = mReceiveWindowMaxSize; |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "reset local rx window on piggyback ack tx, size = %u", mLocalReceiveWindowSize); |
| |
| // Tell caller AND fragmenter we have an ack to piggyback. |
| sentAck = true; |
| } |
| else |
| { |
| // No ack to piggyback. |
| sentAck = false; |
| } |
| |
| return mPafTP.HandleCharacteristicSend(std::move(data), sentAck); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::SendNextMessage() |
| { |
| // Get the first queued packet to send |
| PacketBufferHandle data = mSendQueue.PopHead(); |
| |
| // Hand whole message payload to the fragmenter. |
| bool sentAck; |
| VerifyOrReturnError(PrepareNextFragment(std::move(data), sentAck), WIFIPAF_ERROR_CHIPPAF_PROTOCOL_ABORT); |
| |
| ReturnErrorOnFailure(SendCharacteristic(mPafTP.BorrowTxPacket())); |
| |
| if (sentAck) |
| { |
| // If sent piggybacked ack, stop send-ack timer. |
| StopSendAckTimer(); |
| } |
| |
| // Start ack received timer, if it's not already running. |
| return StartAckReceivedTimer(); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::ContinueMessageSend() |
| { |
| bool sentAck; |
| |
| if (!PrepareNextFragment(nullptr, sentAck)) |
| { |
| // Log PAFTP error |
| ChipLogError(WiFiPAF, "paftp fragmenter error on send!"); |
| mPafTP.LogState(); |
| |
| return WIFIPAF_ERROR_CHIPPAF_PROTOCOL_ABORT; |
| } |
| |
| ReturnErrorOnFailure(SendCharacteristic(mPafTP.BorrowTxPacket())); |
| |
| if (sentAck) |
| { |
| // If sent piggybacked ack, stop send-ack timer. |
| StopSendAckTimer(); |
| } |
| |
| // Start ack received timer, if it's not already running. |
| return StartAckReceivedTimer(); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::HandleHandshakeConfirmationReceived() |
| { |
| // Free capabilities request/response payload. |
| mSendQueue.FreeHead(); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::HandleFragmentConfirmationReceived(bool result) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| // Ensure we're in correct state to receive confirmation of non-handshake GATT send. |
| VerifyOrExit(IsConnected(mState), err = CHIP_ERROR_INCORRECT_STATE); |
| |
| if (mConnStateFlags.Has(ConnectionStateFlag::kStandAloneAckInFlight)) |
| { |
| // If confirmation was received for stand-alone ack, free its tx buffer. |
| mAckToSend = nullptr; |
| mConnStateFlags.Clear(ConnectionStateFlag::kStandAloneAckInFlight); |
| } |
| |
| if (result != true) |
| { |
| // Something wrong in writing packets |
| ChipLogError(WiFiPAF, "Failed to send PAF packet"); |
| err = CHIP_ERROR_SENDING_BLOCKED; |
| StopAckReceivedTimer(); |
| SuccessOrExit(err); |
| } |
| |
| // If local receive window size has shrunk to or below immediate ack threshold, AND a message fragment is not |
| // pending on which to piggyback an ack, send immediate stand-alone ack. |
| // |
| // This check covers the case where the local receive window has shrunk between transmission and confirmation of |
| // the stand-alone ack, and also the case where a window size < the immediate ack threshold was detected in |
| // Receive(), but the stand-alone ack was deferred due to a pending outbound message fragment. |
| if (mLocalReceiveWindowSize <= WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD && mSendQueue.IsNull() && |
| mPafTP.TxState() != WiFiPAFTP::kState_InProgress) |
| { |
| err = DriveStandAloneAck(); // Encode stand-alone ack and drive sending. |
| SuccessOrExit(err); |
| } |
| else |
| { |
| err = DriveSending(); |
| SuccessOrExit(err); |
| } |
| |
| exit: |
| if (err != CHIP_NO_ERROR) |
| { |
| DoClose(kWiFiPAFCloseFlag_AbortTransmission, err); |
| } |
| |
| return err; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::HandleSendConfirmationReceived(bool result) |
| { |
| // Mark outstanding operation as finished. |
| mConnStateFlags.Clear(ConnectionStateFlag::kOperationInFlight); |
| |
| // If confirmation was for outbound portion of PAFTP connect handshake... |
| if (!mConnStateFlags.Has(ConnectionStateFlag::kCapabilitiesConfReceived)) |
| { |
| mConnStateFlags.Set(ConnectionStateFlag::kCapabilitiesConfReceived); |
| return HandleHandshakeConfirmationReceived(); |
| } |
| |
| return HandleFragmentConfirmationReceived(result); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::DriveStandAloneAck() |
| { |
| // Stop send-ack timer if running. |
| StopSendAckTimer(); |
| |
| // If stand-alone ack not already pending, allocate new payload buffer here. |
| if (mAckToSend.IsNull()) |
| { |
| mAckToSend = System::PacketBufferHandle::New(kTransferProtocolStandaloneAckHeaderSize); |
| VerifyOrReturnError(!mAckToSend.IsNull(), CHIP_ERROR_NO_MEMORY); |
| } |
| |
| // Attempt to send stand-alone ack. |
| return DriveSending(); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::DoSendStandAloneAck() |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "sending stand-alone ack"); |
| |
| // Encode and transmit stand-alone ack. |
| mPafTP.EncodeStandAloneAck(mAckToSend); |
| ReturnErrorOnFailure(SendCharacteristic(mAckToSend.Retain())); |
| |
| // Reset local receive window counter. |
| mLocalReceiveWindowSize = mReceiveWindowMaxSize; |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "reset local rx window on stand-alone ack tx, size = %u", mLocalReceiveWindowSize); |
| |
| mConnStateFlags.Set(ConnectionStateFlag::kStandAloneAckInFlight); |
| |
| // Start ack received timer, if it's not already running. |
| return StartAckReceivedTimer(); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::DriveSending() |
| { |
| // If receiver's window is almost closed and we don't have an ack to send, OR we do have an ack to send but |
| // receiver's window is completely empty, OR another operation is in flight, awaiting confirmation... |
| if ((mRemoteReceiveWindowSize <= WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD && |
| !mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning) && mAckToSend.IsNull()) || |
| (mRemoteReceiveWindowSize == 0) || (mConnStateFlags.Has(ConnectionStateFlag::kOperationInFlight))) |
| { |
| if (mRemoteReceiveWindowSize <= WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD && |
| !mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning) && mAckToSend.IsNull()) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "NO SEND: receive window almost closed, and no ack to send"); |
| } |
| |
| if (mRemoteReceiveWindowSize == 0) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "NO SEND: remote receive window closed"); |
| } |
| |
| if (mConnStateFlags.Has(ConnectionStateFlag::kOperationInFlight)) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "NO SEND: Operation in flight"); |
| } |
| // Can't send anything. |
| return CHIP_NO_ERROR; |
| } |
| |
| if (!mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFResourceAvailable() && (!mAckToSend.IsNull() || !mSendQueue.IsNull())) |
| { |
| // Resource is currently unavailable, send packets later |
| StartWaitResourceTimer(); |
| return CHIP_NO_ERROR; |
| } |
| mResourceWaitCount = 0; |
| |
| // Otherwise, let's see what we can send. |
| if ((!mAckToSend.IsNull()) && !mConnStateFlags.Has(ConnectionStateFlag::kStandAloneAckInFlight)) |
| { |
| // If immediate, stand-alone ack is pending, send it. |
| ChipLogProgress(WiFiPAF, "Send the pending stand-alone ack"); |
| ReturnErrorOnFailure(DoSendStandAloneAck()); |
| } |
| else if (mPafTP.TxState() == WiFiPAFTP::kState_Idle) // Else send next message fragment, if any. |
| { |
| // Fragmenter's idle, let's see what's in the send queue... |
| if (!mSendQueue.IsNull()) |
| { |
| // Transmit first fragment of next whole message in send queue. |
| ReturnErrorOnFailure(SendNextMessage()); |
| } |
| else |
| { |
| // Nothing to send! |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "=> No pending packets, nothing to send!"); |
| } |
| } |
| else if (mPafTP.TxState() == WiFiPAFTP::kState_InProgress) |
| { |
| // Send next fragment of message currently held by fragmenter. |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Send the next fragment"); |
| ReturnErrorOnFailure(ContinueMessageSend()); |
| } |
| else if (mPafTP.TxState() == WiFiPAFTP::kState_Complete) |
| { |
| // Clear fragmenter's pointer to sent message buffer and reset its Tx state. |
| // Buffer will be freed at scope exit. |
| PacketBufferHandle sentBuf = mPafTP.TakeTxPacket(); |
| |
| if (!mSendQueue.IsNull()) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Send the next pkt"); |
| // Transmit first fragment of next whole message in send queue. |
| ReturnErrorOnFailure(SendNextMessage()); |
| } |
| else if (mState == kState_Closing && !mPafTP.ExpectingAck()) // and mSendQueue is NULL, per above... |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Closing and no expect ack!"); |
| // If end point closing, got last ack, and got out-of-order confirmation for last send, finalize close. |
| FinalizeClose(mState, kWiFiPAFCloseFlag_SuppressCallback, CHIP_NO_ERROR); |
| } |
| else |
| { |
| // Nothing to send! |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "No more packets to send"); |
| } |
| } |
| else |
| { |
| ChipLogError(WiFiPAF, "Unknown TxState: %u", mPafTP.TxState()); |
| } |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::HandleCapabilitiesRequestReceived(PacketBufferHandle && data) |
| { |
| PAFTransportCapabilitiesRequestMessage req; |
| PAFTransportCapabilitiesResponseMessage resp; |
| uint16_t mtu; |
| |
| VerifyOrReturnError(!data.IsNull(), CHIP_ERROR_INVALID_ARGUMENT); |
| |
| mState = kState_Connecting; |
| |
| // Decode PAFTP capabilities request. |
| ReturnErrorOnFailure(PAFTransportCapabilitiesRequestMessage::Decode(data, req)); |
| |
| PacketBufferHandle responseBuf = System::PacketBufferHandle::New(kCapabilitiesResponseLength); |
| VerifyOrReturnError(!responseBuf.IsNull(), CHIP_ERROR_NO_MEMORY); |
| |
| if (req.mMtu > 0) // If MTU was observed and provided by central... |
| { |
| mtu = req.mMtu; // Accept central's observation of the MTU. |
| } |
| else |
| { |
| mtu = CHIP_PAF_DEFAULT_MTU; |
| } |
| |
| // Select fragment size for connection based on MTU. |
| resp.mFragmentSize = std::min(static_cast<uint16_t>(mtu), WiFiPAFTP::sMaxFragmentSize); |
| |
| // Select local and remote max receive window size based on local resources available for both incoming writes |
| mRemoteReceiveWindowSize = mLocalReceiveWindowSize = mReceiveWindowMaxSize = |
| std::min(req.mWindowSize, static_cast<uint8_t>(PAF_MAX_RECEIVE_WINDOW_SIZE)); |
| resp.mWindowSize = mReceiveWindowMaxSize; |
| ChipLogProgress(WiFiPAF, "local and remote recv window sizes = %u", resp.mWindowSize); |
| |
| // Select PAF transport protocol version from those supported by central, or none if no supported version found. |
| resp.mSelectedProtocolVersion = WiFiPAFLayer::GetHighestSupportedProtocolVersion(req); |
| ChipLogProgress(WiFiPAF, "selected PAFTP version %d", resp.mSelectedProtocolVersion); |
| |
| if (resp.mSelectedProtocolVersion == kWiFiPAFTransportProtocolVersion_None) |
| { |
| // If WiFiPAF transport protocol versions incompatible, prepare to close connection after capabilities response |
| // has been sent. |
| ChipLogError(WiFiPAF, "incompatible PAFTP versions; peripheral expected between %d and %d", |
| CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION, CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION); |
| mState = kState_Aborting; |
| } |
| else |
| { |
| // Set Rx and Tx fragment sizes to the same value |
| mPafTP.SetRxFragmentSize(resp.mFragmentSize); |
| mPafTP.SetTxFragmentSize(resp.mFragmentSize); |
| } |
| |
| ChipLogProgress(WiFiPAF, "using PAFTP fragment sizes rx %d / tx %d.", mPafTP.GetRxFragmentSize(), mPafTP.GetTxFragmentSize()); |
| ReturnErrorOnFailure(resp.Encode(responseBuf)); |
| |
| CHIP_ERROR err; |
| err = SendWrite(responseBuf.Retain()); |
| SuccessOrExit(err); |
| |
| // Stash capabilities response payload |
| QueueTx(std::move(responseBuf), kType_Data); |
| |
| // Response has been sent |
| return HandleConnectComplete(); |
| exit: |
| return err; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::HandleCapabilitiesResponseReceived(PacketBufferHandle && data) |
| { |
| PAFTransportCapabilitiesResponseMessage resp; |
| |
| VerifyOrReturnError(!data.IsNull(), CHIP_ERROR_INVALID_ARGUMENT); |
| |
| // Decode PAFTP capabilities response. |
| ReturnErrorOnFailure(PAFTransportCapabilitiesResponseMessage::Decode(data, resp)); |
| |
| VerifyOrReturnError(resp.mFragmentSize > 0, WIFIPAF_ERROR_INVALID_FRAGMENT_SIZE); |
| |
| ChipLogProgress(WiFiPAF, "Publisher chose PAFTP version %d; subscriber expected between %d and %d", |
| resp.mSelectedProtocolVersion, CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION, |
| CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION); |
| |
| if ((resp.mSelectedProtocolVersion < CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION) || |
| (resp.mSelectedProtocolVersion > CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION)) |
| { |
| return WIFIPAF_ERROR_INCOMPATIBLE_PROTOCOL_VERSIONS; |
| } |
| |
| // Set fragment size as minimum of (reported ATT MTU, BTP characteristic size) |
| resp.mFragmentSize = std::min(resp.mFragmentSize, WiFiPAFTP::sMaxFragmentSize); |
| |
| mPafTP.SetRxFragmentSize(resp.mFragmentSize); |
| mPafTP.SetTxFragmentSize(resp.mFragmentSize); |
| |
| ChipLogProgress(WiFiPAF, "using PAFTP fragment sizes rx %d / tx %d.", mPafTP.GetRxFragmentSize(), mPafTP.GetTxFragmentSize()); |
| |
| // Select local and remote max receive window size based on local resources available for both incoming indications |
| mRemoteReceiveWindowSize = mLocalReceiveWindowSize = mReceiveWindowMaxSize = resp.mWindowSize; |
| |
| ChipLogProgress(WiFiPAF, "local and remote recv window size = %u", resp.mWindowSize); |
| |
| // Shrink local receive window counter by 1, since connect handshake indication requires acknowledgement. |
| mLocalReceiveWindowSize = static_cast<SequenceNumber_t>(mLocalReceiveWindowSize - 1); |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "decremented local rx window, new size = %u", mLocalReceiveWindowSize); |
| |
| // Send ack for connection handshake indication when timer expires. Sequence numbers always start at 0, |
| // and the reassembler's "last received seq num" is initialized to 0 and updated when new fragments are |
| // received from the peripheral, so we don't need to explicitly mark the ack num to send here. |
| ReturnErrorOnFailure(StartSendAckTimer()); |
| |
| // We've sent a capabilities request write and received a compatible response, so the connect |
| // operation has completed successfully. |
| return HandleConnectComplete(); |
| } |
| |
| // Returns number of open slots in remote receive window given the input values. |
| SequenceNumber_t WiFiPAFEndPoint::AdjustRemoteReceiveWindow(SequenceNumber_t lastReceivedAck, SequenceNumber_t maxRemoteWindowSize, |
| SequenceNumber_t newestUnackedSentSeqNum) |
| { |
| // Assumption: SequenceNumber_t is uint8_t. |
| // Assumption: Maximum possible sequence number value is UINT8_MAX. |
| // Assumption: Sequence numbers incremented past maximum value wrap to 0. |
| // Assumption: newest unacked sent sequence number never exceeds current (and by extension, new and un-wrapped) |
| // window boundary, so it never wraps relative to last received ack, if new window boundary would not |
| // also wrap. |
| |
| // Define new window boundary (inclusive) as uint16_t, so its value can temporarily exceed UINT8_MAX. |
| uint16_t newRemoteWindowBoundary = static_cast<uint16_t>(lastReceivedAck + maxRemoteWindowSize); |
| |
| if (newRemoteWindowBoundary > UINT8_MAX && newestUnackedSentSeqNum < lastReceivedAck) |
| { |
| // New window boundary WOULD wrap, and latest unacked seq num already HAS wrapped, so add offset to difference. |
| return static_cast<uint8_t>(newRemoteWindowBoundary - (newestUnackedSentSeqNum + UINT8_MAX)); |
| } |
| |
| // Neither values would or have wrapped, OR new boundary WOULD wrap but latest unacked seq num does not, so no |
| // offset required. |
| return static_cast<uint8_t>(newRemoteWindowBoundary - newestUnackedSentSeqNum); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::GetPktSn(Encoding::LittleEndian::Reader & reader, uint8_t * pHead, SequenceNumber_t & seqNum) |
| { |
| CHIP_ERROR err; |
| BitFlags<WiFiPAFTP::HeaderFlags> rx_flags; |
| size_t SnOffset = 0; |
| SequenceNumber_t * pSn; |
| err = reader.Read8(rx_flags.RawStorage()).StatusCode(); |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kHankshake)) |
| { |
| // Handkshake message => No ack/sn |
| return CHIP_ERROR_INTERNAL; |
| } |
| // Always has header flag |
| SnOffset += kTransferProtocolHeaderFlagsSize; |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kManagementOpcode)) // Has Mgmt_Op |
| { |
| SnOffset += kTransferProtocolMgmtOpSize; |
| } |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kFragmentAck)) // Has ack |
| { |
| SnOffset += kTransferProtocolAckSize; |
| } |
| pSn = pHead + SnOffset; |
| seqNum = *pSn; |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::DebugPktAckSn(const PktDirect_t PktDirect, Encoding::LittleEndian::Reader & reader, uint8_t * pHead) |
| { |
| #ifdef CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_ENABLED |
| BitFlags<WiFiPAFTP::HeaderFlags> rx_flags; |
| CHIP_ERROR err; |
| uint8_t * pAct = nullptr; |
| char AckBuff[4]; |
| uint8_t * pSn; |
| size_t SnOffset = 0; |
| |
| err = reader.Read8(rx_flags.RawStorage()).StatusCode(); |
| SuccessOrExit(err); |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kHankshake)) |
| { |
| // Handkshake message => No ack/sn |
| return CHIP_NO_ERROR; |
| } |
| // Always has header flag |
| SnOffset += kTransferProtocolHeaderFlagsSize; |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kManagementOpcode)) // Has Mgmt_Op |
| { |
| SnOffset += kTransferProtocolMgmtOpSize; |
| } |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kFragmentAck)) // Has ack |
| { |
| pAct = pHead + kTransferProtocolHeaderFlagsSize; |
| SnOffset += kTransferProtocolAckSize; |
| } |
| pSn = pHead + SnOffset; |
| if (pAct == nullptr) |
| { |
| strcpy(AckBuff, " "); |
| } |
| else |
| { |
| snprintf(AckBuff, sizeof(AckBuff), "%02hhu", *pAct); |
| } |
| if (PktDirect == PktDirect_t::kTx) |
| { |
| ChipLogDebugWiFiPAFEndPoint_L0(WiFiPAF, "==>[tx] [Sn, Ack] = [ %02u, -- %s]", *pSn, AckBuff); |
| } |
| else if (PktDirect == PktDirect_t::kRx) |
| { |
| ChipLogDebugWiFiPAFEndPoint_L0(WiFiPAF, "<==[rx] [Ack, Sn] = [-- %s, %02u]", AckBuff, *pSn); |
| } |
| exit: |
| return err; |
| #else |
| return CHIP_NO_ERROR; |
| #endif |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::Receive(PacketBufferHandle && data) |
| { |
| SequenceNumber_t ExpRxNextSeqNum = mPafTP.GetRxNextSeqNum(); |
| SequenceNumber_t seqNum; |
| Encoding::LittleEndian::Reader reader(data->Start(), data->DataLength()); |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| err = GetPktSn(reader, data->Start(), seqNum); |
| if (err != CHIP_NO_ERROR) |
| { |
| // Failed to get SeqNum. => Pass down to PAFTP engine directly |
| return RxPacketProcess(std::move(data)); |
| } |
| /* |
| If reorder-queue is not empty => Need to queue the packet whose SeqNum is the next one at |
| offset 0 to fill the hole. |
| */ |
| if ((ExpRxNextSeqNum == seqNum) && (ItemsInReorderQueue == 0)) |
| return RxPacketProcess(std::move(data)); |
| |
| ChipLogError(WiFiPAF, "Reorder the packet: [%u, %u]", ExpRxNextSeqNum, seqNum); |
| // Start reordering packets |
| SequenceNumber_t offset = OffsetSeqNum(seqNum, ExpRxNextSeqNum); |
| if (offset >= PAFTP_REORDER_QUEUE_SIZE) |
| { |
| // Offset is too big |
| // => It may be the unexpected packet or duplicate packet => drop it |
| ChipLogError(WiFiPAF, "Offset (%u) is too big => drop the packet", offset); |
| ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, data); |
| return CHIP_NO_ERROR; |
| } |
| |
| // Save the packet to the reorder-queue |
| if (ReorderQueue[offset] == nullptr) |
| { |
| ReorderQueue[offset] = std::move(data).UnsafeRelease(); |
| ItemsInReorderQueue++; |
| } |
| |
| // Consume the packets in the reorder queue if no hole exists |
| if (ReorderQueue[0] == nullptr) |
| { |
| // The hole still exists => Can't continue |
| ChipLogError(WiFiPAF, "The hole still exists. Packets in reorder-queue: %u", ItemsInReorderQueue); |
| return CHIP_NO_ERROR; |
| } |
| uint8_t qidx; |
| for (qidx = 0; qidx < PAFTP_REORDER_QUEUE_SIZE; qidx++) |
| { |
| // The head slots should have been filled. => Do rx processing |
| if (ReorderQueue[qidx] == nullptr) |
| { |
| // Stop consuming packets until the hole or no packets |
| break; |
| } |
| // Consume the saved packets |
| ChipLogProgress(WiFiPAF, "Rx processing from the re-order queue [%u]", qidx); |
| err = RxPacketProcess(System::PacketBufferHandle::Adopt(ReorderQueue[qidx])); |
| ReorderQueue[qidx] = nullptr; |
| ItemsInReorderQueue--; |
| } |
| // Has reached the 1st hole in the queue => move the rest items forward |
| // Note: It's to continue => No need to reinit "i" |
| for (uint8_t newId = 0; qidx < PAFTP_REORDER_QUEUE_SIZE; qidx++, newId++) |
| { |
| if (ReorderQueue[qidx] != nullptr) |
| { |
| ReorderQueue[newId] = ReorderQueue[qidx]; |
| ReorderQueue[qidx] = nullptr; |
| } |
| } |
| return err; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::RxPacketProcess(PacketBufferHandle && data) |
| { |
| ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, data); |
| |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| SequenceNumber_t receivedAck = 0; |
| uint8_t closeFlags = kWiFiPAFCloseFlag_AbortTransmission; |
| bool didReceiveAck = false; |
| BitFlags<WiFiPAFTP::HeaderFlags> rx_flags; |
| Encoding::LittleEndian::Reader reader(data->Start(), data->DataLength()); |
| DebugPktAckSn(PktDirect_t::kRx, reader, data->Start()); |
| |
| { // This is a special handling on the first CHIPoPAF data packet, the CapabilitiesRequest. |
| // If we're receiving the first inbound packet of a PAF transport connection handshake... |
| if (!mConnStateFlags.Has(ConnectionStateFlag::kCapabilitiesMsgReceived)) |
| { |
| if (mRole == kWiFiPafRole_Subscriber) // If we're a central receiving a capabilities response indication... |
| { |
| // Ensure end point's in the right state before continuing. |
| VerifyOrExit(mState == kState_Connecting, err = CHIP_ERROR_INCORRECT_STATE); |
| mConnStateFlags.Set(ConnectionStateFlag::kCapabilitiesMsgReceived); |
| err = HandleCapabilitiesResponseReceived(std::move(data)); |
| SuccessOrExit(err); |
| } |
| else // Or, a peripheral receiving a capabilities request write... |
| { |
| // Ensure end point's in the right state before continuing. |
| VerifyOrExit(mState == kState_Ready, err = CHIP_ERROR_INCORRECT_STATE); |
| mConnStateFlags.Set(ConnectionStateFlag::kCapabilitiesMsgReceived); |
| err = HandleCapabilitiesRequestReceived(std::move(data)); |
| if (err != CHIP_NO_ERROR) |
| { |
| // If an error occurred decoding and handling the capabilities request, release the BLE connection. |
| // Central's connect attempt will time out if peripheral's application decides to keep the BLE |
| // connection open, or fail immediately if the application closes the connection. |
| closeFlags = closeFlags | kWiFiPAFCloseFlag_SuppressCallback; |
| ExitNow(); |
| } |
| } |
| // If received data was handshake packet, don't feed it to message reassembler. |
| ExitNow(); |
| } |
| } // End handling the CapabilitiesRequest |
| |
| err = reader.Read8(rx_flags.RawStorage()).StatusCode(); |
| SuccessOrExit(err); |
| if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kHankshake)) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Unexpected handshake packet => drop"); |
| ExitNow(); |
| } |
| |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "PAFTP about to rx characteristic, state before:"); |
| mPafTP.LogStateDebug(); |
| |
| // Pass received packet into PAFTP protocol engine. |
| err = mPafTP.HandleCharacteristicReceived(std::move(data), receivedAck, didReceiveAck); |
| |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "PAFTP rx'd characteristic, state after:"); |
| mPafTP.LogStateDebug(); |
| SuccessOrExit(err); |
| |
| // Protocol engine accepted the fragment, so shrink local receive window counter by 1. |
| mLocalReceiveWindowSize = static_cast<SequenceNumber_t>(mLocalReceiveWindowSize - 1); |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "decremented local rx window, new size = %u", mLocalReceiveWindowSize); |
| |
| // Respond to received ack, if any. |
| if (didReceiveAck) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "got paftp ack = %u", receivedAck); |
| |
| // If ack was rx'd for newest unacked sent fragment, stop ack received timer. |
| if (!mPafTP.ExpectingAck()) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "got ack for last outstanding fragment"); |
| StopAckReceivedTimer(); |
| |
| if (mState == kState_Closing && mSendQueue.IsNull() && mPafTP.TxState() == WiFiPAFTP::kState_Idle) |
| { |
| // If end point closing, got confirmation for last send, and waiting for last ack, finalize close. |
| FinalizeClose(mState, kWiFiPAFCloseFlag_SuppressCallback, CHIP_NO_ERROR); |
| ExitNow(); |
| } |
| } |
| else // Else there are still sent fragments for which acks are expected, so restart ack received timer. |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "still expecting ack(s), restarting timer..."); |
| err = RestartAckReceivedTimer(); |
| SuccessOrExit(err); |
| } |
| |
| ChipLogDebugWiFiPAFEndPoint( |
| WiFiPAF, "about to adjust remote rx window; got ack num = %u, newest unacked sent seq num = %u, \ |
| old window size = %u, max window size = %u", |
| receivedAck, mPafTP.GetNewestUnackedSentSequenceNumber(), mRemoteReceiveWindowSize, mReceiveWindowMaxSize); |
| |
| // Open remote device's receive window according to sequence number it just acknowledged. |
| mRemoteReceiveWindowSize = |
| AdjustRemoteReceiveWindow(receivedAck, mReceiveWindowMaxSize, mPafTP.GetNewestUnackedSentSequenceNumber()); |
| |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "adjusted remote rx window, new size = %u", mRemoteReceiveWindowSize); |
| |
| // Restart message transmission if it was previously paused due to window exhaustion. |
| err = DriveSending(); |
| SuccessOrExit(err); |
| } |
| |
| // The previous DriveSending() might have generated a piggyback acknowledgement if there was |
| // previously un-acked data. Otherwise, prepare to send acknowledgement for newly received fragment. |
| // |
| // If local receive window is below immediate ack threshold, AND there is no previous stand-alone ack in |
| // flight, AND there is no pending outbound message fragment on which the ack can and will be piggybacked, |
| // send immediate stand-alone ack to reopen window for sender. |
| // |
| // The "operation in flight" check below covers "pending outbound message fragment" by extension, as when |
| // a message has been passed to the end point via Send(), its next outbound fragment must either be in flight |
| // itself, or awaiting the completion of another in-flight operation. |
| // |
| // If any operation is in flight that is NOT a stand-alone ack, the window size will be checked against |
| // this threshold again when the operation is confirmed. |
| if (mPafTP.HasUnackedData()) |
| { |
| if (mLocalReceiveWindowSize <= WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD && |
| !mConnStateFlags.Has(ConnectionStateFlag::kOperationInFlight)) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "sending immediate ack"); |
| err = DriveStandAloneAck(); |
| SuccessOrExit(err); |
| } |
| else |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "starting send-ack timer"); |
| // Send ack when timer expires. |
| err = StartSendAckTimer(); |
| SuccessOrExit(err); |
| } |
| } |
| |
| // If we've reassembled a whole message... |
| if (mPafTP.RxState() == WiFiPAFTP::kState_Complete) |
| { |
| // Take ownership of message buffer |
| System::PacketBufferHandle full_packet = mPafTP.TakeRxPacket(); |
| |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "reassembled whole msg, len = %u", static_cast<unsigned>(full_packet->DataLength())); |
| |
| // If we have a message received callback, and end point is not closing... |
| if (mWiFiPafLayer != nullptr && mState != kState_Closing) |
| { |
| // Pass received message up the stack. |
| err = mWiFiPafLayer->OnWiFiPAFMsgRxComplete(mSessionInfo, std::move(full_packet)); |
| } |
| } |
| |
| exit: |
| if (err != CHIP_NO_ERROR) |
| { |
| DoClose(closeFlags, err); |
| } |
| |
| return err; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::SendWrite(PacketBufferHandle && buf) |
| { |
| mConnStateFlags.Set(ConnectionStateFlag::kOperationInFlight); |
| |
| ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, buf); |
| Encoding::LittleEndian::Reader reader(buf->Start(), buf->DataLength()); |
| DebugPktAckSn(PktDirect_t::kTx, reader, buf->Start()); |
| mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFMessageSend(mSessionInfo, std::move(buf)); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::StartConnectTimer() |
| { |
| const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer(System::Clock::Milliseconds32(PAFTP_CONN_RSP_TIMEOUT_MS), |
| HandleConnectTimeout, this); |
| ReturnErrorOnFailure(timerErr); |
| mTimerStateFlags.Set(TimerStateFlag::kConnectTimerRunning); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::StartAckReceivedTimer() |
| { |
| if (!mTimerStateFlags.Has(TimerStateFlag::kAckReceivedTimerRunning)) |
| { |
| const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer(System::Clock::Milliseconds32(PAFTP_ACK_TIMEOUT_MS), |
| HandleAckReceivedTimeout, this); |
| ReturnErrorOnFailure(timerErr); |
| |
| mTimerStateFlags.Set(TimerStateFlag::kAckReceivedTimerRunning); |
| } |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::RestartAckReceivedTimer() |
| { |
| VerifyOrReturnError(mTimerStateFlags.Has(TimerStateFlag::kAckReceivedTimerRunning), CHIP_ERROR_INCORRECT_STATE); |
| |
| StopAckReceivedTimer(); |
| |
| return StartAckReceivedTimer(); |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::StartSendAckTimer() |
| { |
| if (!mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning)) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "starting new SendAckTimer"); |
| const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer( |
| System::Clock::Milliseconds32(WIFIPAF_ACK_SEND_TIMEOUT_MS), HandleSendAckTimeout, this); |
| ReturnErrorOnFailure(timerErr); |
| |
| mTimerStateFlags.Set(TimerStateFlag::kSendAckTimerRunning); |
| } |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR WiFiPAFEndPoint::StartWaitResourceTimer() |
| { |
| mResourceWaitCount++; |
| if (mResourceWaitCount >= WIFIPAF_MAX_RESOURCE_BLOCK_COUNT) |
| { |
| ChipLogError(WiFiPAF, "Network resource has been unavailable for a long time"); |
| mResourceWaitCount = 0; |
| DoClose(kWiFiPAFCloseFlag_AbortTransmission, CHIP_ERROR_NOT_CONNECTED); |
| return CHIP_NO_ERROR; |
| } |
| if (!mTimerStateFlags.Has(TimerStateFlag::kWaitResTimerRunning)) |
| { |
| ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "starting new WaitResTimer"); |
| const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer( |
| System::Clock::Milliseconds32(WIFIPAF_WAIT_RES_TIMEOUT_MS), HandleWaitResourceTimeout, this); |
| ReturnErrorOnFailure(timerErr); |
| mTimerStateFlags.Set(TimerStateFlag::kWaitResTimerRunning); |
| } |
| return CHIP_NO_ERROR; |
| } |
| |
| void WiFiPAFEndPoint::StopConnectTimer() |
| { |
| // Cancel any existing connect timer. |
| mWiFiPafLayer->mSystemLayer->CancelTimer(HandleConnectTimeout, this); |
| mTimerStateFlags.Clear(TimerStateFlag::kConnectTimerRunning); |
| } |
| |
| void WiFiPAFEndPoint::StopAckReceivedTimer() |
| { |
| // Cancel any existing ack-received timer. |
| mWiFiPafLayer->mSystemLayer->CancelTimer(HandleAckReceivedTimeout, this); |
| mTimerStateFlags.Clear(TimerStateFlag::kAckReceivedTimerRunning); |
| } |
| |
| void WiFiPAFEndPoint::StopSendAckTimer() |
| { |
| // Cancel any existing send-ack timer. |
| mWiFiPafLayer->mSystemLayer->CancelTimer(HandleSendAckTimeout, this); |
| mTimerStateFlags.Clear(TimerStateFlag::kSendAckTimerRunning); |
| } |
| |
| void WiFiPAFEndPoint::StopWaitResourceTimer() |
| { |
| // Cancel any existing wait-resource timer. |
| mWiFiPafLayer->mSystemLayer->CancelTimer(HandleWaitResourceTimeout, this); |
| mTimerStateFlags.Clear(TimerStateFlag::kWaitResTimerRunning); |
| } |
| |
| void WiFiPAFEndPoint::HandleConnectTimeout(chip::System::Layer * systemLayer, void * appState) |
| { |
| WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState); |
| |
| // Check for event-based timer race condition. |
| if (ep->mTimerStateFlags.Has(TimerStateFlag::kConnectTimerRunning)) |
| { |
| ChipLogError(WiFiPAF, "connect handshake timed out, closing ep %p", ep); |
| ep->mTimerStateFlags.Clear(TimerStateFlag::kConnectTimerRunning); |
| ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_CONNECT_TIMED_OUT); |
| } |
| } |
| |
| void WiFiPAFEndPoint::HandleAckReceivedTimeout(chip::System::Layer * systemLayer, void * appState) |
| { |
| WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState); |
| |
| // Check for event-based timer race condition. |
| if (ep->mTimerStateFlags.Has(TimerStateFlag::kAckReceivedTimerRunning)) |
| { |
| ChipLogError(WiFiPAF, "ack recv timeout, closing ep %p", ep); |
| ep->mPafTP.LogStateDebug(); |
| ep->mTimerStateFlags.Clear(TimerStateFlag::kAckReceivedTimerRunning); |
| ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_FRAGMENT_ACK_TIMED_OUT); |
| } |
| } |
| |
| void WiFiPAFEndPoint::HandleSendAckTimeout(chip::System::Layer * systemLayer, void * appState) |
| { |
| WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState); |
| |
| // Check for event-based timer race condition. |
| if (ep->mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning)) |
| { |
| ep->mTimerStateFlags.Clear(TimerStateFlag::kSendAckTimerRunning); |
| |
| // If previous stand-alone ack isn't still in flight... |
| if (!ep->mConnStateFlags.Has(ConnectionStateFlag::kStandAloneAckInFlight)) |
| { |
| CHIP_ERROR sendErr = ep->DriveStandAloneAck(); |
| |
| if (sendErr != CHIP_NO_ERROR) |
| { |
| ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, sendErr); |
| } |
| } |
| } |
| } |
| |
| void WiFiPAFEndPoint::HandleWaitResourceTimeout(chip::System::Layer * systemLayer, void * appState) |
| { |
| WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState); |
| |
| // Check for event-based timer race condition. |
| if (ep->mTimerStateFlags.Has(TimerStateFlag::kWaitResTimerRunning)) |
| { |
| ep->mTimerStateFlags.Clear(TimerStateFlag::kWaitResTimerRunning); |
| CHIP_ERROR sendErr = ep->DriveSending(); |
| if (sendErr != CHIP_NO_ERROR) |
| { |
| ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, sendErr); |
| } |
| } |
| } |
| |
| void WiFiPAFEndPoint::ClearAll() |
| { |
| memset(reinterpret_cast<uint8_t *>(this), 0, sizeof(WiFiPAFEndPoint)); |
| return; |
| } |
| |
| } /* namespace WiFiPAF */ |
| } /* namespace chip */ |
