Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2025 Project CHIP Authors
4 : *
5 : * Licensed under the Apache License, Version 2.0 (the "License");
6 : * you may not use this file except in compliance with the License.
7 : * You may obtain a copy of the License at
8 : *
9 : * http://www.apache.org/licenses/LICENSE-2.0
10 : *
11 : * Unless required by applicable law or agreed to in writing, software
12 : * distributed under the License is distributed on an "AS IS" BASIS,
13 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 : * See the License for the specific language governing permissions and
15 : * limitations under the License.
16 : */
17 :
18 : /**
19 : * @file
20 : * This file implements a WiFiPAF endpoint abstraction for CHIP over WiFiPAF (CHIPoPAF)
21 : * Public Action Frame Transport Protocol (PAFTP).
22 : *
23 : */
24 :
25 : #include "WiFiPAFEndPoint.h"
26 :
27 : #include <cstdint>
28 : #include <cstring>
29 : #include <utility>
30 :
31 : #include <lib/support/BitFlags.h>
32 : #include <lib/support/BufferReader.h>
33 : #include <lib/support/CodeUtils.h>
34 : #include <lib/support/logging/CHIPLogging.h>
35 : #include <system/SystemClock.h>
36 : #include <system/SystemLayer.h>
37 : #include <system/SystemPacketBuffer.h>
38 :
39 : #include "WiFiPAFConfig.h"
40 : #include "WiFiPAFError.h"
41 : #include "WiFiPAFLayer.h"
42 : #include "WiFiPAFTP.h"
43 :
44 : // Define below to enable extremely verbose, WiFiPAF end point-specific debug logging.
45 : #undef CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_ENABLED
46 : #define CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_LEVEL 0
47 :
48 : #ifdef CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_ENABLED
49 : #define ChipLogDebugWiFiPAFEndPoint_L0(MOD, MSG, ...) ChipLogDetail(MOD, MSG, ##__VA_ARGS__)
50 : #if (CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_LEVEL == 0)
51 : #define ChipLogDebugWiFiPAFEndPoint(MOD, MSG, ...)
52 : #else
53 : #define ChipLogDebugWiFiPAFEndPoint(MOD, MSG, ...) ChipLogDetail(MOD, MSG, ##__VA_ARGS__)
54 : #endif // CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_LEVEL
55 : #define ChipLogDebugBufferWiFiPAFEndPoint(MOD, BUF) \
56 : ChipLogByteSpan(MOD, ByteSpan((BUF)->Start(), ((BUF)->DataLength() < 8 ? (BUF)->DataLength() : 8u)))
57 : #else
58 : #define ChipLogDebugWiFiPAFEndPoint(MOD, MSG, ...)
59 : #define ChipLogDebugBufferWiFiPAFEndPoint(MOD, BUF)
60 : #endif
61 :
62 : /**
63 : * @def WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD
64 : *
65 : * @brief
66 : * If an end point's receive window drops equal to or below this value, it will send an immediate acknowledgement
67 : * packet to re-open its window instead of waiting for the send-ack timer to expire.
68 : *
69 : */
70 : #define WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD 1
71 :
72 : #define WIFIPAF_ACK_SEND_TIMEOUT_MS 2500
73 :
74 : /**
75 : * @def WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD
76 : *
77 : * @brief
78 : * Data fragments may only be sent without piggybacked acks if receiver's window size is above this threshold.
79 : *
80 : */
81 : #define WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD 1
82 :
83 : namespace chip {
84 : namespace WiFiPAF {
85 :
86 1 : CHIP_ERROR WiFiPAFEndPoint::StartConnect()
87 : {
88 1 : CHIP_ERROR err = CHIP_NO_ERROR;
89 : PAFTransportCapabilitiesRequestMessage req;
90 1 : PacketBufferHandle buf;
91 1 : constexpr uint8_t numVersions =
92 : CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION - CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION + 1;
93 : static_assert(numVersions <= NUM_PAFTP_SUPPORTED_PROTOCOL_VERSIONS, "Incompatibly protocol versions");
94 :
95 : // Ensure we're in the correct state.
96 1 : VerifyOrExit(mState == kState_Ready, err = CHIP_ERROR_INCORRECT_STATE);
97 1 : mState = kState_Connecting;
98 :
99 : // Build PAF transport protocol capabilities request.
100 1 : buf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize);
101 1 : VerifyOrExit(!buf.IsNull(), err = CHIP_ERROR_NO_MEMORY);
102 :
103 : // Zero-initialize PAF transport capabilities request.
104 1 : memset(&req, 0, sizeof(req));
105 1 : req.mMtu = CHIP_PAF_DEFAULT_MTU;
106 1 : req.mWindowSize = PAF_MAX_RECEIVE_WINDOW_SIZE;
107 :
108 : // Populate request with highest supported protocol versions
109 2 : for (uint8_t i = 0; i < numVersions; i++)
110 : {
111 1 : req.SetSupportedProtocolVersion(i, static_cast<uint8_t>(CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION - i));
112 : }
113 :
114 1 : err = req.Encode(buf);
115 1 : SuccessOrExit(err);
116 :
117 : // Start connect timer. Canceled when end point freed or connection established.
118 1 : err = StartConnectTimer();
119 1 : SuccessOrExit(err);
120 :
121 : // Send PAF transport capabilities request to peripheral.
122 : // Add reference to message fragment. CHIP retains partial ownership of message fragment's packet buffer,
123 : // since this is the same buffer as that of the whole message, just with a fragmenter-modified payload offset
124 : // and data length, by a Retain() on the handle when calling this function.
125 1 : err = SendWrite(buf.Retain());
126 1 : SuccessOrExit(err);
127 : // Free request buffer on write confirmation. Stash a reference to it in mSendQueue, which we don't use anyway
128 : // until the connection has been set up.
129 1 : QueueTx(std::move(buf), kType_Data);
130 :
131 1 : exit:
132 : // If we failed to initiate the connection, close the end point.
133 1 : if (err != CHIP_NO_ERROR)
134 : {
135 0 : StopConnectTimer();
136 0 : DoClose(kWiFiPAFCloseFlag_AbortTransmission, err);
137 : }
138 :
139 1 : return err;
140 1 : }
141 :
142 2 : CHIP_ERROR WiFiPAFEndPoint::HandleConnectComplete()
143 : {
144 2 : CHIP_ERROR err = CHIP_NO_ERROR;
145 :
146 2 : mState = kState_Connected;
147 : // Cancel the connect timer.
148 2 : StopConnectTimer();
149 :
150 : // We've successfully completed the PAF transport protocol handshake, so let the application know we're open for business.
151 2 : if (mWiFiPafLayer != nullptr)
152 : {
153 : // Indicate connect complete to next-higher layer.
154 2 : mWiFiPafLayer->OnEndPointConnectComplete(this, CHIP_NO_ERROR);
155 : }
156 : else
157 : {
158 : // If no connect complete callback has been set up, close the end point.
159 0 : err = WIFIPAF_ERROR_NO_CONNECT_COMPLETE_CALLBACK;
160 : }
161 2 : return err;
162 : }
163 :
164 11 : bool WiFiPAFEndPoint::IsConnected(uint8_t state) const
165 : {
166 11 : return (state == kState_Connected || state == kState_Closing);
167 : }
168 :
169 2 : void WiFiPAFEndPoint::DoClose(uint8_t flags, CHIP_ERROR err)
170 : {
171 2 : uint8_t oldState = mState;
172 :
173 : // If end point is not closed or closing, OR end point was closing gracefully, but tx abort has been specified...
174 2 : if ((mState != kState_Closed && mState != kState_Closing) ||
175 0 : (mState == kState_Closing && (flags & kWiFiPAFCloseFlag_AbortTransmission)))
176 : {
177 : // Cancel Connect and ReceiveConnect timers if they are running.
178 : // Check role first to avoid needless iteration over timer pool.
179 2 : if (mRole == kWiFiPafRole_Subscriber)
180 : {
181 1 : StopConnectTimer();
182 : }
183 :
184 : // Free the packets in re-order queue if ones exist
185 14 : for (uint8_t qidx = 0; qidx < PAFTP_REORDER_QUEUE_SIZE; qidx++)
186 : {
187 12 : if (ReorderQueue[qidx] != nullptr)
188 : {
189 0 : ReorderQueue[qidx] = nullptr;
190 0 : ItemsInReorderQueue--;
191 : }
192 : }
193 :
194 : // If transmit buffer is empty or a transmission abort was specified...
195 2 : if (mPafTP.TxState() == WiFiPAFTP::kState_Idle || (flags & kWiFiPAFCloseFlag_AbortTransmission))
196 : {
197 2 : FinalizeClose(oldState, flags, err);
198 : }
199 : else
200 : {
201 : // Wait for send queue and fragmenter's tx buffer to become empty, to ensure all pending messages have been
202 : // sent. Only free end point and tell platform it can throw away the underlying connection once all
203 : // pending messages have been sent and acknowledged by the remote CHIPoPAF stack, or once the remote stack
204 : // closes the CHIPoPAF connection.
205 : //
206 : // In so doing, WiFiPAFEndPoint attempts to emulate the level of reliability afforded by TCPEndPoint and TCP
207 : // sockets in general with a typical default SO_LINGER option. That said, there is no hard guarantee that
208 : // pending messages will be sent once (Do)Close() is called, so developers should use application-level
209 : // messages to confirm the receipt of all data sent prior to a Close() call.
210 0 : mState = kState_Closing;
211 :
212 0 : if ((flags & kWiFiPAFCloseFlag_SuppressCallback) == 0)
213 : {
214 0 : DoCloseCallback(oldState, flags, err);
215 : }
216 : }
217 : }
218 2 : }
219 :
220 2 : void WiFiPAFEndPoint::FinalizeClose(uint8_t oldState, uint8_t flags, CHIP_ERROR err)
221 : {
222 2 : mState = kState_Closed;
223 :
224 : // Ensure transmit queue is empty and set to NULL.
225 2 : mSendQueue = nullptr;
226 : // Clear the session information
227 2 : ChipLogProgress(WiFiPAF, "Shutdown PAF session (%u, %u)", mSessionInfo.id, mSessionInfo.role);
228 2 : mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFCloseSession(mSessionInfo);
229 2 : memset(&mSessionInfo, 0, sizeof(mSessionInfo));
230 : // Fire application's close callback if we haven't already, and it's not suppressed.
231 2 : if (oldState != kState_Closing && (flags & kWiFiPAFCloseFlag_SuppressCallback) == 0)
232 : {
233 2 : DoCloseCallback(oldState, flags, err);
234 : }
235 :
236 : // If underlying WiFiPAF connection has closed, connection object is invalid, so just free the end point and return.
237 2 : if (err == WIFIPAF_ERROR_REMOTE_DEVICE_DISCONNECTED || err == WIFIPAF_ERROR_APP_CLOSED_CONNECTION)
238 : {
239 2 : Free();
240 : }
241 : else // Otherwise, try to signal close to remote device before end point releases WiFiPAF connection and frees itself.
242 : {
243 0 : if (mRole == kWiFiPafRole_Subscriber)
244 : {
245 : // Cancel send and receive-ack timers, if running.
246 0 : StopAckReceivedTimer();
247 0 : StopSendAckTimer();
248 0 : mConnStateFlags.Set(ConnectionStateFlag::kOperationInFlight);
249 : }
250 : else
251 : {
252 0 : Free();
253 : }
254 : }
255 2 : ClearAll();
256 2 : }
257 :
258 2 : void WiFiPAFEndPoint::DoCloseCallback(uint8_t state, uint8_t flags, CHIP_ERROR err)
259 : {
260 : // Callback fires once per end point lifetime.
261 2 : mOnPafSubscribeComplete = nullptr;
262 2 : mOnPafSubscribeError = nullptr;
263 2 : OnConnectionClosed = nullptr;
264 2 : }
265 :
266 2 : void WiFiPAFEndPoint::Free()
267 : {
268 : // Clear fragmentation and reassembly engine's Tx and Rx buffers. Counters will be reset by next engine init.
269 2 : FreePAFtpEngine();
270 :
271 : // Clear pending ack buffer, if any.
272 2 : mAckToSend = nullptr;
273 :
274 : // Cancel all timers.
275 2 : StopConnectTimer();
276 2 : StopAckReceivedTimer();
277 2 : StopSendAckTimer();
278 :
279 : // Clear callbacks.
280 2 : mOnPafSubscribeComplete = nullptr;
281 2 : mOnPafSubscribeError = nullptr;
282 2 : OnMessageReceived = nullptr;
283 2 : OnConnectionClosed = nullptr;
284 2 : }
285 :
286 2 : void WiFiPAFEndPoint::FreePAFtpEngine()
287 : {
288 : // Free transmit disassembly buffer
289 2 : mPafTP.ClearTxPacket();
290 :
291 : // Free receive reassembly buffer
292 2 : mPafTP.ClearRxPacket();
293 2 : }
294 :
295 2 : CHIP_ERROR WiFiPAFEndPoint::Init(WiFiPAFLayer * WiFiPafLayer, WiFiPAFSession & SessionInfo)
296 : {
297 : // Fail if already initialized.
298 2 : VerifyOrReturnError(mWiFiPafLayer == nullptr, CHIP_ERROR_INCORRECT_STATE);
299 :
300 : // Validate args.
301 2 : VerifyOrReturnError(WiFiPafLayer != nullptr, CHIP_ERROR_INVALID_ARGUMENT);
302 :
303 : // If end point plays subscriber role, expect ack as last step of PAFTP handshake.
304 : // If being publisher, subscriber's handshake indication 'ack's write sent by publisher to kick off the PAFTP handshake.
305 2 : bool expectInitialAck = (SessionInfo.role == kWiFiPafRole_Publisher);
306 :
307 2 : CHIP_ERROR err = mPafTP.Init(this, expectInitialAck);
308 2 : if (err != CHIP_NO_ERROR)
309 : {
310 0 : ChipLogError(WiFiPAF, "WiFiPAFTP init failed");
311 0 : return err;
312 : }
313 :
314 2 : mWiFiPafLayer = WiFiPafLayer;
315 :
316 : // WiFiPAF EndPoint data members:
317 2 : memcpy(&mSessionInfo, &SessionInfo, sizeof(mSessionInfo));
318 2 : mRole = SessionInfo.role;
319 2 : mTimerStateFlags.ClearAll();
320 2 : mLocalReceiveWindowSize = 0;
321 2 : mRemoteReceiveWindowSize = 0;
322 2 : mReceiveWindowMaxSize = 0;
323 2 : mSendQueue = nullptr;
324 2 : mAckToSend = nullptr;
325 :
326 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "initialized local rx window, size = %u", mLocalReceiveWindowSize);
327 :
328 : // End point is ready.
329 2 : mState = kState_Ready;
330 :
331 2 : return CHIP_NO_ERROR;
332 : }
333 :
334 8 : CHIP_ERROR WiFiPAFEndPoint::SendCharacteristic(PacketBufferHandle && buf)
335 : {
336 8 : CHIP_ERROR err = CHIP_NO_ERROR;
337 :
338 8 : SuccessOrExit(err = SendWrite(std::move(buf)));
339 : // Write succeeded, so shrink remote receive window counter by 1.
340 8 : mRemoteReceiveWindowSize = static_cast<SequenceNumber_t>(mRemoteReceiveWindowSize - 1);
341 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "decremented remote rx window, new size = %u", mRemoteReceiveWindowSize);
342 8 : exit:
343 8 : return err;
344 : }
345 :
346 : /*
347 : * Routine to queue the Tx packet with a packet type
348 : * kType_Data(0) - data packet
349 : * kType_Control(1) - control packet
350 : */
351 8 : void WiFiPAFEndPoint::QueueTx(PacketBufferHandle && data, PacketType_t type)
352 : {
353 8 : if (mSendQueue.IsNull())
354 : {
355 6 : mSendQueue = std::move(data);
356 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "%s: Set data as new mSendQueue %p, type %d", __FUNCTION__, mSendQueue->Start(), type);
357 : }
358 : else
359 : {
360 2 : mSendQueue->AddToEnd(std::move(data));
361 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "%s: Append data to mSendQueue %p, type %d", __FUNCTION__, mSendQueue->Start(), type);
362 : }
363 8 : }
364 :
365 6 : CHIP_ERROR WiFiPAFEndPoint::Send(PacketBufferHandle && data)
366 : {
367 6 : CHIP_ERROR err = CHIP_NO_ERROR;
368 :
369 6 : VerifyOrExit(!data.IsNull(), err = CHIP_ERROR_INVALID_ARGUMENT);
370 6 : VerifyOrExit(IsConnected(mState), err = CHIP_ERROR_INCORRECT_STATE);
371 :
372 : // Ensure outgoing message fits in a single contiguous packet buffer, as currently required by the
373 : // message fragmentation and reassembly engine.
374 6 : if (data->HasChainedBuffer())
375 : {
376 1 : data->CompactHead();
377 :
378 1 : if (data->HasChainedBuffer())
379 : {
380 0 : err = CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG;
381 0 : ExitNow();
382 : }
383 : }
384 :
385 : // Add new message to send queue.
386 6 : QueueTx(std::move(data), kType_Data);
387 :
388 : // Send first fragment of new message, if we can.
389 6 : err = DriveSending();
390 6 : SuccessOrExit(err);
391 6 : exit:
392 6 : if (err != CHIP_NO_ERROR)
393 : {
394 0 : DoClose(kWiFiPAFCloseFlag_AbortTransmission, err);
395 : }
396 :
397 6 : return err;
398 : }
399 :
400 7 : bool WiFiPAFEndPoint::PrepareNextFragment(PacketBufferHandle && data, bool & sentAck)
401 : {
402 : // If we have a pending fragment acknowledgement to send, piggyback it on the fragment we're about to transmit.
403 7 : if (mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning))
404 : {
405 : // Reset local receive window counter.
406 2 : mLocalReceiveWindowSize = mReceiveWindowMaxSize;
407 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "reset local rx window on piggyback ack tx, size = %u", mLocalReceiveWindowSize);
408 :
409 : // Tell caller AND fragmenter we have an ack to piggyback.
410 2 : sentAck = true;
411 : }
412 : else
413 : {
414 : // No ack to piggyback.
415 5 : sentAck = false;
416 : }
417 :
418 7 : return mPafTP.HandleCharacteristicSend(std::move(data), sentAck);
419 : }
420 :
421 6 : CHIP_ERROR WiFiPAFEndPoint::SendNextMessage()
422 : {
423 : // Get the first queued packet to send
424 6 : PacketBufferHandle data = mSendQueue.PopHead();
425 :
426 : // Hand whole message payload to the fragmenter.
427 : bool sentAck;
428 6 : VerifyOrReturnError(PrepareNextFragment(std::move(data), sentAck), WIFIPAF_ERROR_CHIPPAF_PROTOCOL_ABORT);
429 :
430 6 : ReturnErrorOnFailure(SendCharacteristic(mPafTP.BorrowTxPacket()));
431 :
432 6 : if (sentAck)
433 : {
434 : // If sent piggybacked ack, stop send-ack timer.
435 2 : StopSendAckTimer();
436 : }
437 :
438 : // Start ack received timer, if it's not already running.
439 6 : return StartAckReceivedTimer();
440 6 : }
441 :
442 1 : CHIP_ERROR WiFiPAFEndPoint::ContinueMessageSend()
443 : {
444 : bool sentAck;
445 :
446 1 : if (!PrepareNextFragment(nullptr, sentAck))
447 : {
448 : // Log PAFTP error
449 0 : ChipLogError(WiFiPAF, "paftp fragmenter error on send!");
450 0 : mPafTP.LogState();
451 :
452 0 : return WIFIPAF_ERROR_CHIPPAF_PROTOCOL_ABORT;
453 : }
454 :
455 1 : ReturnErrorOnFailure(SendCharacteristic(mPafTP.BorrowTxPacket()));
456 :
457 1 : if (sentAck)
458 : {
459 : // If sent piggybacked ack, stop send-ack timer.
460 0 : StopSendAckTimer();
461 : }
462 :
463 : // Start ack received timer, if it's not already running.
464 1 : return StartAckReceivedTimer();
465 : }
466 :
467 2 : CHIP_ERROR WiFiPAFEndPoint::HandleHandshakeConfirmationReceived()
468 : {
469 : // Free capabilities request/response payload.
470 2 : mSendQueue.FreeHead();
471 :
472 2 : return CHIP_NO_ERROR;
473 : }
474 :
475 5 : CHIP_ERROR WiFiPAFEndPoint::HandleFragmentConfirmationReceived(bool result)
476 : {
477 5 : CHIP_ERROR err = CHIP_NO_ERROR;
478 : // Ensure we're in correct state to receive confirmation of non-handshake GATT send.
479 5 : VerifyOrExit(IsConnected(mState), err = CHIP_ERROR_INCORRECT_STATE);
480 :
481 5 : if (mConnStateFlags.Has(ConnectionStateFlag::kStandAloneAckInFlight))
482 : {
483 : // If confirmation was received for stand-alone ack, free its tx buffer.
484 0 : mAckToSend = nullptr;
485 0 : mConnStateFlags.Clear(ConnectionStateFlag::kStandAloneAckInFlight);
486 : }
487 :
488 5 : if (result != true)
489 : {
490 : // Something wrong in writing packets
491 0 : ChipLogError(WiFiPAF, "Failed to send PAF packet");
492 0 : err = CHIP_ERROR_SENDING_BLOCKED;
493 0 : StopAckReceivedTimer();
494 0 : SuccessOrExit(err);
495 : }
496 :
497 : // If local receive window size has shrunk to or below immediate ack threshold, AND a message fragment is not
498 : // pending on which to piggyback an ack, send immediate stand-alone ack.
499 : //
500 : // This check covers the case where the local receive window has shrunk between transmission and confirmation of
501 : // the stand-alone ack, and also the case where a window size < the immediate ack threshold was detected in
502 : // Receive(), but the stand-alone ack was deferred due to a pending outbound message fragment.
503 5 : if (mLocalReceiveWindowSize <= WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD && mSendQueue.IsNull() &&
504 0 : mPafTP.TxState() != WiFiPAFTP::kState_InProgress)
505 : {
506 0 : err = DriveStandAloneAck(); // Encode stand-alone ack and drive sending.
507 0 : SuccessOrExit(err);
508 : }
509 : else
510 : {
511 5 : err = DriveSending();
512 5 : SuccessOrExit(err);
513 : }
514 :
515 5 : exit:
516 5 : if (err != CHIP_NO_ERROR)
517 : {
518 0 : DoClose(kWiFiPAFCloseFlag_AbortTransmission, err);
519 : }
520 :
521 5 : return err;
522 : }
523 :
524 7 : CHIP_ERROR WiFiPAFEndPoint::HandleSendConfirmationReceived(bool result)
525 : {
526 : // Mark outstanding operation as finished.
527 7 : mConnStateFlags.Clear(ConnectionStateFlag::kOperationInFlight);
528 :
529 : // If confirmation was for outbound portion of PAFTP connect handshake...
530 7 : if (!mConnStateFlags.Has(ConnectionStateFlag::kCapabilitiesConfReceived))
531 : {
532 2 : mConnStateFlags.Set(ConnectionStateFlag::kCapabilitiesConfReceived);
533 2 : return HandleHandshakeConfirmationReceived();
534 : }
535 :
536 5 : return HandleFragmentConfirmationReceived(result);
537 : }
538 :
539 1 : CHIP_ERROR WiFiPAFEndPoint::DriveStandAloneAck()
540 : {
541 : // Stop send-ack timer if running.
542 1 : StopSendAckTimer();
543 :
544 : // If stand-alone ack not already pending, allocate new payload buffer here.
545 1 : if (mAckToSend.IsNull())
546 : {
547 1 : mAckToSend = System::PacketBufferHandle::New(kTransferProtocolStandaloneAckHeaderSize);
548 1 : VerifyOrReturnError(!mAckToSend.IsNull(), CHIP_ERROR_NO_MEMORY);
549 : }
550 :
551 : // Attempt to send stand-alone ack.
552 1 : return DriveSending();
553 : }
554 :
555 1 : CHIP_ERROR WiFiPAFEndPoint::DoSendStandAloneAck()
556 : {
557 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "sending stand-alone ack");
558 :
559 : // Encode and transmit stand-alone ack.
560 1 : mPafTP.EncodeStandAloneAck(mAckToSend);
561 1 : ReturnErrorOnFailure(SendCharacteristic(mAckToSend.Retain()));
562 :
563 : // Reset local receive window counter.
564 1 : mLocalReceiveWindowSize = mReceiveWindowMaxSize;
565 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "reset local rx window on stand-alone ack tx, size = %u", mLocalReceiveWindowSize);
566 :
567 1 : mConnStateFlags.Set(ConnectionStateFlag::kStandAloneAckInFlight);
568 :
569 : // Start ack received timer, if it's not already running.
570 1 : return StartAckReceivedTimer();
571 : }
572 :
573 16 : CHIP_ERROR WiFiPAFEndPoint::DriveSending()
574 : {
575 : // 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
576 : // receiver's window is completely empty, OR another operation is in flight, awaiting confirmation...
577 33 : if ((mRemoteReceiveWindowSize <= WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD &&
578 1 : !mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning) && mAckToSend.IsNull()) ||
579 17 : (mRemoteReceiveWindowSize == 0) || (mConnStateFlags.Has(ConnectionStateFlag::kOperationInFlight)))
580 : {
581 4 : if (mRemoteReceiveWindowSize <= WIFIPAF_WINDOW_NO_ACK_SEND_THRESHOLD &&
582 3 : !mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning) && mAckToSend.IsNull())
583 : {
584 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "NO SEND: receive window almost closed, and no ack to send");
585 : }
586 :
587 3 : if (mRemoteReceiveWindowSize == 0)
588 : {
589 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "NO SEND: remote receive window closed");
590 : }
591 :
592 3 : if (mConnStateFlags.Has(ConnectionStateFlag::kOperationInFlight))
593 : {
594 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "NO SEND: Operation in flight");
595 : }
596 : // Can't send anything.
597 3 : return CHIP_NO_ERROR;
598 : }
599 :
600 : // Otherwise, let's see what we can send.
601 13 : if ((!mAckToSend.IsNull()) && !mConnStateFlags.Has(ConnectionStateFlag::kStandAloneAckInFlight))
602 : {
603 : // If immediate, stand-alone ack is pending, send it.
604 0 : ChipLogProgress(WiFiPAF, "Send the pending stand-alone ack");
605 0 : ReturnErrorOnFailure(DoSendStandAloneAck());
606 : }
607 13 : else if (mPafTP.TxState() == WiFiPAFTP::kState_Idle) // Else send next message fragment, if any.
608 : {
609 : // Fragmenter's idle, let's see what's in the send queue...
610 8 : if (!mSendQueue.IsNull())
611 : {
612 : // Transmit first fragment of next whole message in send queue.
613 5 : ReturnErrorOnFailure(SendNextMessage());
614 : }
615 : else
616 : {
617 : // Nothing to send!
618 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "=> No pending packets, nothing to send!");
619 : }
620 : }
621 5 : else if (mPafTP.TxState() == WiFiPAFTP::kState_InProgress)
622 : {
623 : // Send next fragment of message currently held by fragmenter.
624 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Send the next fragment");
625 1 : ReturnErrorOnFailure(ContinueMessageSend());
626 : }
627 4 : else if (mPafTP.TxState() == WiFiPAFTP::kState_Complete)
628 : {
629 : // Clear fragmenter's pointer to sent message buffer and reset its Tx state.
630 : // Buffer will be freed at scope exit.
631 4 : PacketBufferHandle sentBuf = mPafTP.TakeTxPacket();
632 :
633 4 : if (!mSendQueue.IsNull())
634 : {
635 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Send the next pkt");
636 : // Transmit first fragment of next whole message in send queue.
637 1 : ReturnErrorOnFailure(SendNextMessage());
638 : }
639 3 : else if (mState == kState_Closing && !mPafTP.ExpectingAck()) // and mSendQueue is NULL, per above...
640 : {
641 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Closing and no expect ack!");
642 : // If end point closing, got last ack, and got out-of-order confirmation for last send, finalize close.
643 0 : FinalizeClose(mState, kWiFiPAFCloseFlag_SuppressCallback, CHIP_NO_ERROR);
644 : }
645 : else
646 : {
647 : // Nothing to send!
648 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "No more packets to send");
649 : }
650 4 : }
651 : else
652 : {
653 0 : ChipLogError(WiFiPAF, "Unknown TxState: %u", mPafTP.TxState());
654 : }
655 13 : return CHIP_NO_ERROR;
656 : }
657 :
658 1 : CHIP_ERROR WiFiPAFEndPoint::HandleCapabilitiesRequestReceived(PacketBufferHandle && data)
659 : {
660 : PAFTransportCapabilitiesRequestMessage req;
661 : PAFTransportCapabilitiesResponseMessage resp;
662 : uint16_t mtu;
663 :
664 1 : VerifyOrReturnError(!data.IsNull(), CHIP_ERROR_INVALID_ARGUMENT);
665 :
666 1 : mState = kState_Connecting;
667 :
668 : // Decode PAFTP capabilities request.
669 1 : ReturnErrorOnFailure(PAFTransportCapabilitiesRequestMessage::Decode(data, req));
670 :
671 1 : PacketBufferHandle responseBuf = System::PacketBufferHandle::New(kCapabilitiesResponseLength);
672 1 : VerifyOrReturnError(!responseBuf.IsNull(), CHIP_ERROR_NO_MEMORY);
673 :
674 1 : if (req.mMtu > 0) // If MTU was observed and provided by central...
675 : {
676 1 : mtu = req.mMtu; // Accept central's observation of the MTU.
677 : }
678 : else
679 : {
680 0 : mtu = CHIP_PAF_DEFAULT_MTU;
681 : }
682 :
683 : // Select fragment size for connection based on MTU.
684 1 : resp.mFragmentSize = std::min(static_cast<uint16_t>(mtu), WiFiPAFTP::sMaxFragmentSize);
685 :
686 : // Select local and remote max receive window size based on local resources available for both incoming writes
687 1 : mRemoteReceiveWindowSize = mLocalReceiveWindowSize = mReceiveWindowMaxSize =
688 1 : std::min(req.mWindowSize, static_cast<uint8_t>(PAF_MAX_RECEIVE_WINDOW_SIZE));
689 1 : resp.mWindowSize = mReceiveWindowMaxSize;
690 1 : ChipLogProgress(WiFiPAF, "local and remote recv window sizes = %u", resp.mWindowSize);
691 :
692 : // Select PAF transport protocol version from those supported by central, or none if no supported version found.
693 1 : resp.mSelectedProtocolVersion = WiFiPAFLayer::GetHighestSupportedProtocolVersion(req);
694 1 : ChipLogProgress(WiFiPAF, "selected PAFTP version %d", resp.mSelectedProtocolVersion);
695 :
696 1 : if (resp.mSelectedProtocolVersion == kWiFiPAFTransportProtocolVersion_None)
697 : {
698 : // If WiFiPAF transport protocol versions incompatible, prepare to close connection after capabilities response
699 : // has been sent.
700 0 : ChipLogError(WiFiPAF, "incompatible PAFTP versions; peripheral expected between %d and %d",
701 : CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION, CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION);
702 0 : mState = kState_Aborting;
703 : }
704 : else
705 : {
706 : // Set Rx and Tx fragment sizes to the same value
707 1 : mPafTP.SetRxFragmentSize(resp.mFragmentSize);
708 1 : mPafTP.SetTxFragmentSize(resp.mFragmentSize);
709 : }
710 :
711 1 : ChipLogProgress(WiFiPAF, "using PAFTP fragment sizes rx %d / tx %d.", mPafTP.GetRxFragmentSize(), mPafTP.GetTxFragmentSize());
712 1 : ReturnErrorOnFailure(resp.Encode(responseBuf));
713 :
714 : CHIP_ERROR err;
715 1 : err = SendWrite(responseBuf.Retain());
716 1 : SuccessOrExit(err);
717 :
718 : // Stash capabilities response payload
719 1 : QueueTx(std::move(responseBuf), kType_Data);
720 :
721 : // Response has been sent
722 1 : return HandleConnectComplete();
723 0 : exit:
724 0 : return err;
725 1 : }
726 :
727 1 : CHIP_ERROR WiFiPAFEndPoint::HandleCapabilitiesResponseReceived(PacketBufferHandle && data)
728 : {
729 : PAFTransportCapabilitiesResponseMessage resp;
730 :
731 1 : VerifyOrReturnError(!data.IsNull(), CHIP_ERROR_INVALID_ARGUMENT);
732 :
733 : // Decode PAFTP capabilities response.
734 1 : ReturnErrorOnFailure(PAFTransportCapabilitiesResponseMessage::Decode(data, resp));
735 :
736 1 : VerifyOrReturnError(resp.mFragmentSize > 0, WIFIPAF_ERROR_INVALID_FRAGMENT_SIZE);
737 :
738 1 : ChipLogProgress(WiFiPAF, "Publisher chose PAFTP version %d; subscriber expected between %d and %d",
739 : resp.mSelectedProtocolVersion, CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION,
740 : CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION);
741 :
742 1 : if ((resp.mSelectedProtocolVersion < CHIP_PAF_TRANSPORT_PROTOCOL_MIN_SUPPORTED_VERSION) ||
743 1 : (resp.mSelectedProtocolVersion > CHIP_PAF_TRANSPORT_PROTOCOL_MAX_SUPPORTED_VERSION))
744 : {
745 0 : return WIFIPAF_ERROR_INCOMPATIBLE_PROTOCOL_VERSIONS;
746 : }
747 :
748 : // Set fragment size as minimum of (reported ATT MTU, BTP characteristic size)
749 1 : resp.mFragmentSize = std::min(resp.mFragmentSize, WiFiPAFTP::sMaxFragmentSize);
750 :
751 1 : mPafTP.SetRxFragmentSize(resp.mFragmentSize);
752 1 : mPafTP.SetTxFragmentSize(resp.mFragmentSize);
753 :
754 1 : ChipLogProgress(WiFiPAF, "using PAFTP fragment sizes rx %d / tx %d.", mPafTP.GetRxFragmentSize(), mPafTP.GetTxFragmentSize());
755 :
756 : // Select local and remote max receive window size based on local resources available for both incoming indications
757 1 : mRemoteReceiveWindowSize = mLocalReceiveWindowSize = mReceiveWindowMaxSize = resp.mWindowSize;
758 :
759 1 : ChipLogProgress(WiFiPAF, "local and remote recv window size = %u", resp.mWindowSize);
760 :
761 : // Shrink local receive window counter by 1, since connect handshake indication requires acknowledgement.
762 1 : mLocalReceiveWindowSize = static_cast<SequenceNumber_t>(mLocalReceiveWindowSize - 1);
763 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "decremented local rx window, new size = %u", mLocalReceiveWindowSize);
764 :
765 : // Send ack for connection handshake indication when timer expires. Sequence numbers always start at 0,
766 : // and the reassembler's "last received seq num" is initialized to 0 and updated when new fragments are
767 : // received from the peripheral, so we don't need to explicitly mark the ack num to send here.
768 1 : ReturnErrorOnFailure(StartSendAckTimer());
769 :
770 : // We've sent a capabilities request write and received a compatible response, so the connect
771 : // operation has completed successfully.
772 1 : return HandleConnectComplete();
773 : }
774 :
775 : // Returns number of open slots in remote receive window given the input values.
776 4 : SequenceNumber_t WiFiPAFEndPoint::AdjustRemoteReceiveWindow(SequenceNumber_t lastReceivedAck, SequenceNumber_t maxRemoteWindowSize,
777 : SequenceNumber_t newestUnackedSentSeqNum)
778 : {
779 : // Assumption: SequenceNumber_t is uint8_t.
780 : // Assumption: Maximum possible sequence number value is UINT8_MAX.
781 : // Assumption: Sequence numbers incremented past maximum value wrap to 0.
782 : // Assumption: newest unacked sent sequence number never exceeds current (and by extension, new and un-wrapped)
783 : // window boundary, so it never wraps relative to last received ack, if new window boundary would not
784 : // also wrap.
785 :
786 : // Define new window boundary (inclusive) as uint16_t, so its value can temporarily exceed UINT8_MAX.
787 4 : uint16_t newRemoteWindowBoundary = static_cast<uint16_t>(lastReceivedAck + maxRemoteWindowSize);
788 :
789 4 : if (newRemoteWindowBoundary > UINT8_MAX && newestUnackedSentSeqNum < lastReceivedAck)
790 : {
791 : // New window boundary WOULD wrap, and latest unacked seq num already HAS wrapped, so add offset to difference.
792 0 : return static_cast<uint8_t>(newRemoteWindowBoundary - (newestUnackedSentSeqNum + UINT8_MAX));
793 : }
794 :
795 : // Neither values would or have wrapped, OR new boundary WOULD wrap but latest unacked seq num does not, so no
796 : // offset required.
797 4 : return static_cast<uint8_t>(newRemoteWindowBoundary - newestUnackedSentSeqNum);
798 : }
799 :
800 7 : CHIP_ERROR WiFiPAFEndPoint::GetPktSn(Encoding::LittleEndian::Reader & reader, uint8_t * pHead, SequenceNumber_t & seqNum)
801 : {
802 : CHIP_ERROR err;
803 7 : BitFlags<WiFiPAFTP::HeaderFlags> rx_flags;
804 7 : size_t SnOffset = 0;
805 : SequenceNumber_t * pSn;
806 7 : err = reader.Read8(rx_flags.RawStorage()).StatusCode();
807 7 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kHankshake))
808 : {
809 : // Handkshake message => No ack/sn
810 2 : return CHIP_ERROR_INTERNAL;
811 : }
812 : // Always has header flag
813 5 : SnOffset += kTransferProtocolHeaderFlagsSize;
814 5 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kManagementOpcode)) // Has Mgmt_Op
815 : {
816 0 : SnOffset += kTransferProtocolMgmtOpSize;
817 : }
818 5 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kFragmentAck)) // Has ack
819 : {
820 5 : SnOffset += kTransferProtocolAckSize;
821 : }
822 5 : pSn = pHead + SnOffset;
823 5 : seqNum = *pSn;
824 :
825 5 : return CHIP_NO_ERROR;
826 : }
827 :
828 16 : CHIP_ERROR WiFiPAFEndPoint::DebugPktAckSn(const PktDirect_t PktDirect, Encoding::LittleEndian::Reader & reader, uint8_t * pHead)
829 : {
830 : #ifdef CHIP_WIFIPAF_END_POINT_DEBUG_LOGGING_ENABLED
831 : BitFlags<WiFiPAFTP::HeaderFlags> rx_flags;
832 : CHIP_ERROR err;
833 : uint8_t * pAct = nullptr;
834 : char AckBuff[4];
835 : uint8_t * pSn;
836 : size_t SnOffset = 0;
837 :
838 : err = reader.Read8(rx_flags.RawStorage()).StatusCode();
839 : SuccessOrExit(err);
840 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kHankshake))
841 : {
842 : // Handkshake message => No ack/sn
843 : return CHIP_NO_ERROR;
844 : }
845 : // Always has header flag
846 : SnOffset += kTransferProtocolHeaderFlagsSize;
847 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kManagementOpcode)) // Has Mgmt_Op
848 : {
849 : SnOffset += kTransferProtocolMgmtOpSize;
850 : }
851 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kFragmentAck)) // Has ack
852 : {
853 : pAct = pHead + kTransferProtocolHeaderFlagsSize;
854 : SnOffset += kTransferProtocolAckSize;
855 : }
856 : pSn = pHead + SnOffset;
857 : if (pAct == nullptr)
858 : {
859 : strcpy(AckBuff, " ");
860 : }
861 : else
862 : {
863 : snprintf(AckBuff, sizeof(AckBuff), "%02hhu", *pAct);
864 : }
865 : if (PktDirect == PktDirect_t::kTx)
866 : {
867 : ChipLogDebugWiFiPAFEndPoint_L0(WiFiPAF, "==>[tx] [Sn, Ack] = [ %02u, -- %s]", *pSn, AckBuff);
868 : }
869 : else if (PktDirect == PktDirect_t::kRx)
870 : {
871 : ChipLogDebugWiFiPAFEndPoint_L0(WiFiPAF, "<==[rx] [Ack, Sn] = [-- %s, %02u]", AckBuff, *pSn);
872 : }
873 : exit:
874 : return err;
875 : #else
876 16 : return CHIP_NO_ERROR;
877 : #endif
878 : }
879 :
880 7 : CHIP_ERROR WiFiPAFEndPoint::Receive(PacketBufferHandle && data)
881 : {
882 7 : SequenceNumber_t ExpRxNextSeqNum = mPafTP.GetRxNextSeqNum();
883 : SequenceNumber_t seqNum;
884 7 : Encoding::LittleEndian::Reader reader(data->Start(), data->DataLength());
885 7 : CHIP_ERROR err = CHIP_NO_ERROR;
886 :
887 7 : err = GetPktSn(reader, data->Start(), seqNum);
888 7 : if (err != CHIP_NO_ERROR)
889 : {
890 : // Failed to get SeqNum. => Pass down to PAFTP engine directly
891 2 : return RxPacketProcess(std::move(data));
892 : }
893 : /*
894 : If reorder-queue is not empty => Need to queue the packet whose SeqNum is the next one at
895 : offset 0 to fill the hole.
896 : */
897 5 : if ((ExpRxNextSeqNum == seqNum) && (ItemsInReorderQueue == 0))
898 2 : return RxPacketProcess(std::move(data));
899 :
900 3 : ChipLogError(WiFiPAF, "Reorder the packet: [%u, %u]", ExpRxNextSeqNum, seqNum);
901 : // Start reordering packets
902 3 : SequenceNumber_t offset = OffsetSeqNum(seqNum, ExpRxNextSeqNum);
903 3 : if (offset >= PAFTP_REORDER_QUEUE_SIZE)
904 : {
905 : // Offset is too big
906 : // => It may be the unexpected packet or duplicate packet => drop it
907 1 : ChipLogError(WiFiPAF, "Offset (%u) is too big => drop the packet", offset);
908 : ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, data);
909 1 : return CHIP_NO_ERROR;
910 : }
911 :
912 : // Save the packet to the reorder-queue
913 2 : if (ReorderQueue[offset] == nullptr)
914 : {
915 2 : ReorderQueue[offset] = std::move(data).UnsafeRelease();
916 2 : ItemsInReorderQueue++;
917 : }
918 :
919 : // Consume the packets in the reorder queue if no hole exists
920 2 : if (ReorderQueue[0] == nullptr)
921 : {
922 : // The hole still exists => Can't continue
923 1 : ChipLogError(WiFiPAF, "The hole still exists. Packets in reorder-queue: %u", ItemsInReorderQueue);
924 1 : return CHIP_NO_ERROR;
925 : }
926 : uint8_t qidx;
927 3 : for (qidx = 0; qidx < PAFTP_REORDER_QUEUE_SIZE; qidx++)
928 : {
929 : // The head slots should have been filled. => Do rx processing
930 3 : if (ReorderQueue[qidx] == nullptr)
931 : {
932 : // Stop consuming packets until the hole or no packets
933 1 : break;
934 : }
935 : // Consume the saved packets
936 2 : ChipLogProgress(WiFiPAF, "Rx processing from the re-order queue [%u]", qidx);
937 2 : err = RxPacketProcess(System::PacketBufferHandle::Adopt(ReorderQueue[qidx]));
938 2 : ReorderQueue[qidx] = nullptr;
939 2 : ItemsInReorderQueue--;
940 : }
941 : // Has reached the 1st hole in the queue => move the rest items forward
942 : // Note: It's to continue => No need to reinit "i"
943 5 : for (uint8_t newId = 0; qidx < PAFTP_REORDER_QUEUE_SIZE; qidx++, newId++)
944 : {
945 4 : if (ReorderQueue[qidx] != nullptr)
946 : {
947 0 : ReorderQueue[newId] = ReorderQueue[qidx];
948 0 : ReorderQueue[qidx] = nullptr;
949 : }
950 : }
951 1 : return err;
952 : }
953 :
954 6 : CHIP_ERROR WiFiPAFEndPoint::RxPacketProcess(PacketBufferHandle && data)
955 : {
956 : ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, data);
957 :
958 6 : CHIP_ERROR err = CHIP_NO_ERROR;
959 6 : SequenceNumber_t receivedAck = 0;
960 6 : uint8_t closeFlags = kWiFiPAFCloseFlag_AbortTransmission;
961 6 : bool didReceiveAck = false;
962 6 : BitFlags<WiFiPAFTP::HeaderFlags> rx_flags;
963 6 : Encoding::LittleEndian::Reader reader(data->Start(), data->DataLength());
964 6 : DebugPktAckSn(PktDirect_t::kRx, reader, data->Start());
965 :
966 : { // This is a special handling on the first CHIPoPAF data packet, the CapabilitiesRequest.
967 : // If we're receiving the first inbound packet of a PAF transport connection handshake...
968 6 : if (!mConnStateFlags.Has(ConnectionStateFlag::kCapabilitiesMsgReceived))
969 : {
970 2 : if (mRole == kWiFiPafRole_Subscriber) // If we're a central receiving a capabilities response indication...
971 : {
972 : // Ensure end point's in the right state before continuing.
973 1 : VerifyOrExit(mState == kState_Connecting, err = CHIP_ERROR_INCORRECT_STATE);
974 1 : mConnStateFlags.Set(ConnectionStateFlag::kCapabilitiesMsgReceived);
975 1 : err = HandleCapabilitiesResponseReceived(std::move(data));
976 1 : SuccessOrExit(err);
977 : }
978 : else // Or, a peripheral receiving a capabilities request write...
979 : {
980 : // Ensure end point's in the right state before continuing.
981 1 : VerifyOrExit(mState == kState_Ready, err = CHIP_ERROR_INCORRECT_STATE);
982 1 : mConnStateFlags.Set(ConnectionStateFlag::kCapabilitiesMsgReceived);
983 1 : err = HandleCapabilitiesRequestReceived(std::move(data));
984 1 : if (err != CHIP_NO_ERROR)
985 : {
986 : // If an error occurred decoding and handling the capabilities request, release the BLE connection.
987 : // Central's connect attempt will time out if peripheral's application decides to keep the BLE
988 : // connection open, or fail immediately if the application closes the connection.
989 0 : closeFlags = closeFlags | kWiFiPAFCloseFlag_SuppressCallback;
990 0 : ExitNow();
991 : }
992 : }
993 : // If received data was handshake packet, don't feed it to message reassembler.
994 2 : ExitNow();
995 : }
996 : } // End handling the CapabilitiesRequest
997 :
998 4 : err = reader.Read8(rx_flags.RawStorage()).StatusCode();
999 4 : SuccessOrExit(err);
1000 4 : if (rx_flags.Has(WiFiPAFTP::HeaderFlags::kHankshake))
1001 : {
1002 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "Unexpected handshake packet => drop");
1003 0 : ExitNow();
1004 : }
1005 :
1006 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "PAFTP about to rx characteristic, state before:");
1007 4 : mPafTP.LogStateDebug();
1008 :
1009 : // Pass received packet into PAFTP protocol engine.
1010 4 : err = mPafTP.HandleCharacteristicReceived(std::move(data), receivedAck, didReceiveAck);
1011 :
1012 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "PAFTP rx'd characteristic, state after:");
1013 4 : mPafTP.LogStateDebug();
1014 4 : SuccessOrExit(err);
1015 :
1016 : // Protocol engine accepted the fragment, so shrink local receive window counter by 1.
1017 4 : mLocalReceiveWindowSize = static_cast<SequenceNumber_t>(mLocalReceiveWindowSize - 1);
1018 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "decremented local rx window, new size = %u", mLocalReceiveWindowSize);
1019 :
1020 : // Respond to received ack, if any.
1021 4 : if (didReceiveAck)
1022 : {
1023 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "got paftp ack = %u", receivedAck);
1024 :
1025 : // If ack was rx'd for newest unacked sent fragment, stop ack received timer.
1026 4 : if (!mPafTP.ExpectingAck())
1027 : {
1028 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "got ack for last outstanding fragment");
1029 1 : StopAckReceivedTimer();
1030 :
1031 1 : if (mState == kState_Closing && mSendQueue.IsNull() && mPafTP.TxState() == WiFiPAFTP::kState_Idle)
1032 : {
1033 : // If end point closing, got confirmation for last send, and waiting for last ack, finalize close.
1034 0 : FinalizeClose(mState, kWiFiPAFCloseFlag_SuppressCallback, CHIP_NO_ERROR);
1035 0 : ExitNow();
1036 : }
1037 : }
1038 : else // Else there are still sent fragments for which acks are expected, so restart ack received timer.
1039 : {
1040 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "still expecting ack(s), restarting timer...");
1041 3 : err = RestartAckReceivedTimer();
1042 3 : SuccessOrExit(err);
1043 : }
1044 :
1045 : ChipLogDebugWiFiPAFEndPoint(
1046 : WiFiPAF, "about to adjust remote rx window; got ack num = %u, newest unacked sent seq num = %u, \
1047 : old window size = %u, max window size = %u",
1048 : receivedAck, mPafTP.GetNewestUnackedSentSequenceNumber(), mRemoteReceiveWindowSize, mReceiveWindowMaxSize);
1049 :
1050 : // Open remote device's receive window according to sequence number it just acknowledged.
1051 4 : mRemoteReceiveWindowSize =
1052 4 : AdjustRemoteReceiveWindow(receivedAck, mReceiveWindowMaxSize, mPafTP.GetNewestUnackedSentSequenceNumber());
1053 :
1054 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "adjusted remote rx window, new size = %u", mRemoteReceiveWindowSize);
1055 :
1056 : // Restart message transmission if it was previously paused due to window exhaustion.
1057 4 : err = DriveSending();
1058 4 : SuccessOrExit(err);
1059 : }
1060 :
1061 : // The previous DriveSending() might have generated a piggyback acknowledgement if there was
1062 : // previously un-acked data. Otherwise, prepare to send acknowledgement for newly received fragment.
1063 : //
1064 : // If local receive window is below immediate ack threshold, AND there is no previous stand-alone ack in
1065 : // flight, AND there is no pending outbound message fragment on which the ack can and will be piggybacked,
1066 : // send immediate stand-alone ack to reopen window for sender.
1067 : //
1068 : // The "operation in flight" check below covers "pending outbound message fragment" by extension, as when
1069 : // a message has been passed to the end point via Send(), its next outbound fragment must either be in flight
1070 : // itself, or awaiting the completion of another in-flight operation.
1071 : //
1072 : // If any operation is in flight that is NOT a stand-alone ack, the window size will be checked against
1073 : // this threshold again when the operation is confirmed.
1074 4 : if (mPafTP.HasUnackedData())
1075 : {
1076 4 : if (mLocalReceiveWindowSize <= WIFIPAF_CONFIG_IMMEDIATE_ACK_WINDOW_THRESHOLD &&
1077 0 : !mConnStateFlags.Has(ConnectionStateFlag::kOperationInFlight))
1078 : {
1079 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "sending immediate ack");
1080 0 : err = DriveStandAloneAck();
1081 0 : SuccessOrExit(err);
1082 : }
1083 : else
1084 : {
1085 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "starting send-ack timer");
1086 :
1087 : // Send ack when timer expires.
1088 4 : err = StartSendAckTimer();
1089 4 : SuccessOrExit(err);
1090 : }
1091 : }
1092 :
1093 : // If we've reassembled a whole message...
1094 4 : if (mPafTP.RxState() == WiFiPAFTP::kState_Complete)
1095 : {
1096 : // Take ownership of message buffer
1097 2 : System::PacketBufferHandle full_packet = mPafTP.TakeRxPacket();
1098 :
1099 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "reassembled whole msg, len = %u", static_cast<unsigned>(full_packet->DataLength()));
1100 :
1101 : // If we have a message received callback, and end point is not closing...
1102 2 : if (mWiFiPafLayer != nullptr && mState != kState_Closing)
1103 : {
1104 : // Pass received message up the stack.
1105 2 : err = mWiFiPafLayer->OnWiFiPAFMsgRxComplete(mSessionInfo, std::move(full_packet));
1106 : }
1107 2 : }
1108 :
1109 2 : exit:
1110 6 : if (err != CHIP_NO_ERROR)
1111 : {
1112 0 : DoClose(closeFlags, err);
1113 : }
1114 :
1115 6 : return err;
1116 : }
1117 :
1118 10 : CHIP_ERROR WiFiPAFEndPoint::SendWrite(PacketBufferHandle && buf)
1119 : {
1120 10 : mConnStateFlags.Set(ConnectionStateFlag::kOperationInFlight);
1121 :
1122 : ChipLogDebugBufferWiFiPAFEndPoint(WiFiPAF, buf);
1123 10 : Encoding::LittleEndian::Reader reader(buf->Start(), buf->DataLength());
1124 10 : DebugPktAckSn(PktDirect_t::kTx, reader, buf->Start());
1125 10 : mWiFiPafLayer->mWiFiPAFTransport->WiFiPAFMessageSend(mSessionInfo, std::move(buf));
1126 :
1127 10 : return CHIP_NO_ERROR;
1128 : }
1129 :
1130 1 : CHIP_ERROR WiFiPAFEndPoint::StartConnectTimer()
1131 : {
1132 1 : const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer(System::Clock::Milliseconds32(PAFTP_CONN_RSP_TIMEOUT_MS),
1133 : HandleConnectTimeout, this);
1134 1 : ReturnErrorOnFailure(timerErr);
1135 1 : mTimerStateFlags.Set(TimerStateFlag::kConnectTimerRunning);
1136 :
1137 1 : return CHIP_NO_ERROR;
1138 : }
1139 :
1140 11 : CHIP_ERROR WiFiPAFEndPoint::StartAckReceivedTimer()
1141 : {
1142 11 : if (!mTimerStateFlags.Has(TimerStateFlag::kAckReceivedTimerRunning))
1143 : {
1144 6 : const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer(System::Clock::Milliseconds32(PAFTP_ACK_TIMEOUT_MS),
1145 : HandleAckReceivedTimeout, this);
1146 6 : ReturnErrorOnFailure(timerErr);
1147 :
1148 6 : mTimerStateFlags.Set(TimerStateFlag::kAckReceivedTimerRunning);
1149 : }
1150 :
1151 11 : return CHIP_NO_ERROR;
1152 : }
1153 :
1154 3 : CHIP_ERROR WiFiPAFEndPoint::RestartAckReceivedTimer()
1155 : {
1156 3 : VerifyOrReturnError(mTimerStateFlags.Has(TimerStateFlag::kAckReceivedTimerRunning), CHIP_ERROR_INCORRECT_STATE);
1157 :
1158 3 : StopAckReceivedTimer();
1159 :
1160 3 : return StartAckReceivedTimer();
1161 : }
1162 :
1163 5 : CHIP_ERROR WiFiPAFEndPoint::StartSendAckTimer()
1164 : {
1165 5 : if (!mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning))
1166 : {
1167 : ChipLogDebugWiFiPAFEndPoint(WiFiPAF, "starting new SendAckTimer");
1168 3 : const CHIP_ERROR timerErr = mWiFiPafLayer->mSystemLayer->StartTimer(
1169 3 : System::Clock::Milliseconds32(WIFIPAF_ACK_SEND_TIMEOUT_MS), HandleSendAckTimeout, this);
1170 3 : ReturnErrorOnFailure(timerErr);
1171 :
1172 3 : mTimerStateFlags.Set(TimerStateFlag::kSendAckTimerRunning);
1173 : }
1174 :
1175 5 : return CHIP_NO_ERROR;
1176 : }
1177 :
1178 5 : void WiFiPAFEndPoint::StopConnectTimer()
1179 : {
1180 : // Cancel any existing connect timer.
1181 5 : mWiFiPafLayer->mSystemLayer->CancelTimer(HandleConnectTimeout, this);
1182 5 : mTimerStateFlags.Clear(TimerStateFlag::kConnectTimerRunning);
1183 5 : }
1184 :
1185 6 : void WiFiPAFEndPoint::StopAckReceivedTimer()
1186 : {
1187 : // Cancel any existing ack-received timer.
1188 6 : mWiFiPafLayer->mSystemLayer->CancelTimer(HandleAckReceivedTimeout, this);
1189 6 : mTimerStateFlags.Clear(TimerStateFlag::kAckReceivedTimerRunning);
1190 6 : }
1191 :
1192 5 : void WiFiPAFEndPoint::StopSendAckTimer()
1193 : {
1194 : // Cancel any existing send-ack timer.
1195 5 : mWiFiPafLayer->mSystemLayer->CancelTimer(HandleSendAckTimeout, this);
1196 5 : mTimerStateFlags.Clear(TimerStateFlag::kSendAckTimerRunning);
1197 5 : }
1198 :
1199 0 : void WiFiPAFEndPoint::HandleConnectTimeout(chip::System::Layer * systemLayer, void * appState)
1200 : {
1201 0 : WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState);
1202 :
1203 : // Check for event-based timer race condition.
1204 0 : if (ep->mTimerStateFlags.Has(TimerStateFlag::kConnectTimerRunning))
1205 : {
1206 0 : ChipLogError(WiFiPAF, "connect handshake timed out, closing ep %p", ep);
1207 0 : ep->mTimerStateFlags.Clear(TimerStateFlag::kConnectTimerRunning);
1208 0 : ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_CONNECT_TIMED_OUT);
1209 : }
1210 0 : }
1211 :
1212 0 : void WiFiPAFEndPoint::HandleAckReceivedTimeout(chip::System::Layer * systemLayer, void * appState)
1213 : {
1214 0 : WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState);
1215 :
1216 : // Check for event-based timer race condition.
1217 0 : if (ep->mTimerStateFlags.Has(TimerStateFlag::kAckReceivedTimerRunning))
1218 : {
1219 0 : ChipLogError(WiFiPAF, "ack recv timeout, closing ep %p", ep);
1220 0 : ep->mPafTP.LogStateDebug();
1221 0 : ep->mTimerStateFlags.Clear(TimerStateFlag::kAckReceivedTimerRunning);
1222 0 : ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_FRAGMENT_ACK_TIMED_OUT);
1223 : }
1224 0 : }
1225 :
1226 0 : void WiFiPAFEndPoint::HandleSendAckTimeout(chip::System::Layer * systemLayer, void * appState)
1227 : {
1228 0 : WiFiPAFEndPoint * ep = static_cast<WiFiPAFEndPoint *>(appState);
1229 :
1230 : // Check for event-based timer race condition.
1231 0 : if (ep->mTimerStateFlags.Has(TimerStateFlag::kSendAckTimerRunning))
1232 : {
1233 0 : ep->mTimerStateFlags.Clear(TimerStateFlag::kSendAckTimerRunning);
1234 :
1235 : // If previous stand-alone ack isn't still in flight...
1236 0 : if (!ep->mConnStateFlags.Has(ConnectionStateFlag::kStandAloneAckInFlight))
1237 : {
1238 0 : CHIP_ERROR sendErr = ep->DriveStandAloneAck();
1239 :
1240 0 : if (sendErr != CHIP_NO_ERROR)
1241 : {
1242 0 : ep->DoClose(kWiFiPAFCloseFlag_AbortTransmission, sendErr);
1243 : }
1244 : }
1245 : }
1246 0 : }
1247 :
1248 2 : void WiFiPAFEndPoint::ClearAll()
1249 : {
1250 2 : memset(reinterpret_cast<uint8_t *>(this), 0, sizeof(WiFiPAFEndPoint));
1251 2 : return;
1252 : }
1253 :
1254 : } /* namespace WiFiPAF */
1255 : } /* namespace chip */
|
