[FEATURE] Add a timeout to `TransportArbitrator` for `clientReceive`

[adadaadadade]

Is your feature request related to a problem? Please describe.
If for some reason, transmission is failed. Therefore, client will not able to receive any response from server. But TransportArbitrator will stuck forever because it is waiting for semaphore.

erpc/erpc_c/infra/erpc_transport_arbitrator.cpp

Lines 165 to 178 in 781fb03

	erpc_status_t TransportArbitrator::clientReceive(client_token_t token)
	{
	erpc_assert((token != 0) && ("invalid client token" != NULL));
	// Convert token to pointer to info struct for this client receive request.
	PendingClientInfo *info = reinterpret_cast<PendingClientInfo *>(token);
	// Wait on the semaphore until we're signaled.
	info->m_sem.get(Semaphore::kWaitForever);
	removePendingClient(info);
	return kErpcStatus_Success;
	}

ClientManager do not have this porblem because it doesn't wait for semaphore.

Describe the solution you'd like
I know unreliable transport causes this problem. but it is inefficient to implement a reliable transport for serial and spi. It will need a ack from the other side.

• Maybe add a timeout option for TransportArbitrator and ArbitratedClientManager
• do nothing

Describe alternatives you've considered

Steps you didn't forgot to do

• I checked if there is no related issue opened/closed.
  Arbitrated client stucks -> dead lock #171
• I checked that there doesn't exist opened PR which is solving this issue.
  deadlock fix proposals #121

Additional context

[github-actions]

Hi eRPC user. Thank you for your interest and welcome. We hope you will enjoy this framework well.

[djmuhlestein]

Related to this request, Serial Transport doesn't actually ever return a timeout error code when the read times out. Is the following a good change to erpc_serial_transport.cpp?

 erpc_status_t SerialTransport::underlyingReceive(uint8_t *data, uint32_t size)
 {
     uint32_t bytesRead = serial_read(m_serialHandle, reinterpret_cast<char *>(data), size);
-
-    return (size != bytesRead) ? kErpcStatus_ReceiveFailed : kErpcStatus_Success;
+    return (size != bytesRead) ? 
+           ((bytesRead == 0 && m_vtime > 0) ? kErpcStatus_Timeout : kErpcStatus_ReceiveFailed) :
+           kErpcStatus_Success;
 }

I added m_vtime to capture the vtime parameter from init. The idea being if vtime is > 0, the read can return with less bytes than were requested if it times out.

Part of the issue is that code in the Transport Arbitrator checks the return code for timeout to to unblock the other client requests. So maybe a better fix is to just patch that to check anything other than success to run the clean up code.