Make sendResponsePending a free function

Author: christian-schilling

libs/bsw/uds/include/uds/connection/IncomingDiagConnection.h

@@ -81,7 +81,6 @@ class IncomingDiagConnection
                                         &IncomingDiagConnection::triggerNextNestedRequest>(*this))
     {
         _context = diagContext;
-        _pendingMessage.init(&_pendingMessageBuffer[0], PENDING_MESSAGE_BUFFER_LENGTH);
         for (uint8_t cnt = 0U; cnt < _identifiers.capacity(); cnt++)
         {
             _identifiers[cnt] = 0U;
@@ -237,8 +236,6 @@ class IncomingDiagConnection
 
     void restartPendingTimeout();
 
-    void sendResponsePending();
-
     void asyncTransportMessageProcessed(
         transport::TransportMessage* pTransportMessage, ProcessingResult status);
 

libs/bsw/uds/src/uds/connection/IncomingDiagConnection.cpp

@@ -28,6 +28,51 @@ using ::util::logger::UDS;
 namespace uds
 {
 
+void buildResponsePendingTransportMessage(
+    ::transport::TransportMessage& pendingMessage,
+    uint8_t* const pendingMessageBuffer,
+    uint16_t const sourceAddress,
+    uint16_t const responseSourceAddress,
+    uint8_t const serviceId)
+{
+    pendingMessage.init(
+        pendingMessageBuffer, IncomingDiagConnection::PENDING_MESSAGE_BUFFER_LENGTH);
+    pendingMessage.setTargetAddress(sourceAddress);
+    pendingMessage.setSourceAddress(responseSourceAddress);
+    pendingMessage.resetValidBytes();
+    (void)pendingMessage.append(DiagReturnCode::NEGATIVE_RESPONSE_IDENTIFIER);
+    (void)pendingMessage.append(serviceId);
+    (void)pendingMessage.append(static_cast<uint8_t>(DiagReturnCode::ISO_RESPONSE_PENDING));
+    pendingMessage.setPayloadLength(IncomingDiagConnection::PENDING_MESSAGE_PAYLOAD_LENGTH);
+}
+
+void sendResponsePending(
+    transport::AbstractTransportLayer& messageSender,
+    transport::TransportMessage& pendingMessage,
+    uint8_t& numPendingMessageProcessedCallbacks,
+    bool& responsePendingSent,
+    bool& responsePendingIsBeingSent,
+    transport::ITransportMessageProcessedListener& processedListener)
+{
+    ++numPendingMessageProcessedCallbacks;
+    bool const responsePendingSentBefore        = responsePendingSent;
+    bool const responsePendingIsBeingSentBefore = responsePendingIsBeingSent;
+    responsePendingSent                         = true;
+    responsePendingIsBeingSent                  = true;
+    AbstractTransportLayer::ErrorCode const result
+        = messageSender.send(pendingMessage, &processedListener);
+    if (result != AbstractTransportLayer::ErrorCode::TP_OK)
+    {
+        --numPendingMessageProcessedCallbacks;
+        responsePendingSent        = responsePendingSentBefore;
+        responsePendingIsBeingSent = responsePendingIsBeingSentBefore;
+        Logger::error(
+            UDS,
+            "IncomingDiagConnection: Unable to send ResponsePending: sendResult = %d!",
+            result);
+    }
+}
+
 void IncomingDiagConnection::addIdentifier()
 {
     ETL_ASSERT(!_isResponseActive, ETL_ERROR_GENERIC("response must not be active"));
@@ -291,7 +336,22 @@ void IncomingDiagConnection::asyncSendNegativeResponse(
 
             if (!_responsePendingIsPending)
             { // Only send ResponsePending while response is not being sent
-                sendResponsePending();
+                if (isOpen && (messageSender != nullptr))
+                {
+                    buildResponsePendingTransportMessage(
+                        _pendingMessage,
+                        _pendingMessageBuffer,
+                        sourceAddress,
+                        responseSourceAddress,
+                        serviceId);
+                    sendResponsePending( // send using persistent member instance
+                        *messageSender,
+                        _pendingMessage,
+                        _numPendingMessageProcessedCallbacks,
+                        _responsePendingSent,
+                        _responsePendingIsBeingSent,
+                        *this);
+                }
             }
             restartPendingTimeout();
         }
@@ -455,7 +515,22 @@ void IncomingDiagConnection::asyncTransportMessageProcessed(
         else if (_responsePendingIsPending)
         {
             _responsePendingIsPending = false;
-            sendResponsePending();
+            if (isOpen && (messageSender != nullptr))
+            {
+                buildResponsePendingTransportMessage(
+                    _pendingMessage,
+                    _pendingMessageBuffer,
+                    sourceAddress,
+                    responseSourceAddress,
+                    serviceId);
+                sendResponsePending(
+                    *messageSender,
+                    _pendingMessage,
+                    _numPendingMessageProcessedCallbacks,
+                    _responsePendingSent,
+                    _responsePendingIsBeingSent,
+                    *this);
+            }
         }
     }
     if (status != ITransportMessageProcessedListener::ProcessingResult::PROCESSED_NO_ERROR)
@@ -513,7 +588,22 @@ void IncomingDiagConnection::expired(::async::RunnableType const& timeout)
         if (!_responsePendingIsPending)
         {
             // Only send ResponsePending while response is not being sent
-            sendResponsePending();
+            if (isOpen && (messageSender != nullptr))
+            {
+                buildResponsePendingTransportMessage(
+                    _pendingMessage,
+                    _pendingMessageBuffer,
+                    sourceAddress,
+                    responseSourceAddress,
+                    serviceId);
+                sendResponsePending(
+                    *messageSender,
+                    _pendingMessage,
+                    _numPendingMessageProcessedCallbacks,
+                    _responsePendingSent,
+                    _responsePendingIsBeingSent,
+                    *this);
+            }
         }
         restartPendingTimeout();
     }
@@ -538,40 +628,6 @@ void IncomingDiagConnection::restartPendingTimeout()
     }
 }
 
-void IncomingDiagConnection::sendResponsePending()
-{
-    if ((!isOpen) || (nullptr == messageSender))
-    {
-        return;
-    }
-    _pendingMessage.setTargetAddress(sourceAddress);
-    _pendingMessage.setSourceAddress(responseSourceAddress);
-    _pendingMessage.resetValidBytes();
-    (void)_pendingMessage.append(DiagReturnCode::NEGATIVE_RESPONSE_IDENTIFIER);
-    (void)_pendingMessage.append(serviceId);
-    (void)_pendingMessage.append(static_cast<uint8_t>(DiagReturnCode::ISO_RESPONSE_PENDING));
-    _pendingMessage.setPayloadLength(PENDING_MESSAGE_PAYLOAD_LENGTH);
-    ++_numPendingMessageProcessedCallbacks;
-    // this flag indicates that pending has been sent --> a positive response must follow!
-    bool const responsePendingSent                     = _responsePendingSent;
-    bool const responsePendingIsBeingSent              = _responsePendingIsBeingSent;
-    _responsePendingSent                               = true;
-    _responsePendingIsBeingSent                        = true;
-    AbstractTransportLayer::ErrorCode const sendResult = messageSender->send(_pendingMessage, this);
-    if (sendResult != AbstractTransportLayer::ErrorCode::TP_OK)
-    {
-        --_numPendingMessageProcessedCallbacks;
-        // this flag indicates that pending has been sent --> a positive response must follow!
-        _responsePendingSent        = responsePendingSent;
-        _responsePendingIsBeingSent = responsePendingIsBeingSent;
-        Logger::error(
-            UDS,
-            "IncomingDiagConnection: Unable to send ResponsePending: "
-            "sendResult = %d!",
-            sendResult);
-    }
-}
-
 void IncomingDiagConnection::open(bool const activatePending)
 {
     if (isOpen)