static uint32_t prvAzureIoTHubClientPropertiesProcess()

in source/azure_iot_hub_client.c [307:380]
65 lines of code
7 McCabe index (conditional complexity)

static uint32_t prvAzureIoTHubClientPropertiesProcess( AzureIoTHubClientReceiveContext_t * pxContext,
                                                       AzureIoTHubClient_t * pxAzureIoTHubClient,
                                                       void * pvPublishInfo )
{
    AzureIoTResult_t xResult;
    AzureIoTHubClientPropertiesResponse_t xPropertiesResponse = { 0 };
    AzureIoTMQTTPublishInfo_t * xMQTTPublishInfo = ( AzureIoTMQTTPublishInfo_t * ) pvPublishInfo;
    az_result xCoreResult;
    az_iot_hub_client_properties_message xOutMessage;
    az_span xTopicSpan = az_span_create( ( uint8_t * ) xMQTTPublishInfo->pcTopicName, xMQTTPublishInfo->usTopicNameLength );
    uint32_t ulRequestID = 0;

    /* Failed means no topic match. This means the message is not for properties messaging. */
    xCoreResult = az_iot_hub_client_properties_parse_received_topic( &pxAzureIoTHubClient->_internal.xAzureIoTHubClientCore,
                                                                     xTopicSpan, &xOutMessage );

    if( az_result_failed( xCoreResult ) )
    {
        xResult = AzureIoT_TranslateCoreError( xCoreResult );
    }
    else
    {
        AZLogDebug( ( "Properties topic: %.*s. with payload : %.*s",
                      xMQTTPublishInfo->usTopicNameLength,
                      xMQTTPublishInfo->pcTopicName,
                      xMQTTPublishInfo->xPayloadLength,
                      ( const char * ) xMQTTPublishInfo->pvPayload ) );

        xResult = eAzureIoTSuccess;

        if( pxContext->_internal.callbacks.xPropertiesCallback )
        {
            if( az_span_size( xOutMessage.request_id ) == 0 )
            {
                xPropertiesResponse.xMessageType = eAzureIoTHubPropertiesWritablePropertyMessage;
            }
            else
            {
                if( az_result_succeeded( xCoreResult = az_span_atou32( xOutMessage.request_id, &ulRequestID ) ) )
                {
                    if( ulRequestID & 0x01 )
                    {
                        xPropertiesResponse.xMessageType = eAzureIoTHubPropertiesReportedResponseMessage;
                    }
                    else
                    {
                        xPropertiesResponse.xMessageType = eAzureIoTHubPropertiesRequestedMessage;
                    }
                }
                else
                {
                    /* Failed to parse the message */
                    AZLogError( ( "Request ID parsing failed: core error=0x%08x", ( uint16_t ) xCoreResult ) );
                    xResult = AzureIoT_TranslateCoreError( xCoreResult );
                }
            }

            if( xResult == eAzureIoTSuccess )
            {
                xPropertiesResponse.pvMessagePayload = xMQTTPublishInfo->pvPayload;
                xPropertiesResponse.ulPayloadLength = ( uint32_t ) xMQTTPublishInfo->xPayloadLength;
                xPropertiesResponse.xMessageStatus = ( AzureIoTHubMessageStatus_t ) xOutMessage.status;
                xPropertiesResponse.ulRequestID = ulRequestID;

                AZLogDebug( ( "Invoking property callback" ) );
                pxContext->_internal.callbacks.xPropertiesCallback( &xPropertiesResponse,
                                                                    pxContext->_internal.pvCallbackContext );
                AZLogDebug( ( "Returning from property callback" ) );
            }
        }
    }

    return ( uint32_t ) xResult;
}