custom_provider_historyread.c

/*****************************************************************************
 *                                                                           *
 * Copyright (c) 2006-2023 Unified Automation GmbH. All rights reserved.     *
 *                                                                           *
 * Software License Agreement ("SLA") Version 2.8                            *
 *                                                                           *
 * Unless explicitly acquired and licensed from Licensor under another       *
 * license, the contents of this file are subject to the Software License    *
 * Agreement ("SLA") Version 2.8, or subsequent versions as allowed by the   *
 * SLA, and You may not copy or use this file in either source code or       *
 * executable form, except in compliance with the terms and conditions of    *
 * the SLA.                                                                  *
 *                                                                           *
 * All software distributed under the SLA is provided strictly on an "AS     *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,       *
 * AND LICENSOR HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT      *
 * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR   *
 * PURPOSE, QUIET ENJOYMENT, OR NON-INFRINGEMENT. See the SLA for specific   *
 * language governing rights and limitations under the SLA.                  *
 *                                                                           *
 * The complete license agreement can be found here:                         *
 * http://unifiedautomation.com/License/SLA/2.8/                             *
 *                                                                           *
 * Project: Unified Automation ANSI C based OPC UA Server SDK                *
 *                                                                           *
 *****************************************************************************/

#include <uaserver_config.h>

#include <opcua_statuscodes.h>

#include <uaserver_historyread.h>
#include <uaserver_basenode.h>
#include <uaserver_utilities.h>
#include <uabase_p_atomic.h>

#include "custom_provider_helper.h"

#if HAVE_DATA_LOGGER
#include <uaserver_datalogger.h>
#endif /* HAVE_DATA_LOGGER */

OPCUA_BEGIN_EXTERN_C
OpcUa_Void CustomProvider_HistoryReadRawModifiedAsync_DeleteUserData(struct _UaServer_ContinuationPointHistoryInfo* pContinuationPointHistoryInfo)
{
    OpcUa_ByteString_Clear(pContinuationPointHistoryInfo->pUserData);
    OpcUa_Free(pContinuationPointHistoryInfo->pUserData);
    return;
}
IFMETHODIMP(CustomProvider_HistoryReadRawModifiedAsync)(UaServer_ProviderHistoryReadRawModifiedContext* a_pHistoryReadRawModifiedCtx)
{
    OpcUa_Int32                   i;
    OpcUa_BaseNode               *pNode         = OpcUa_Null;
    UaServer_AddressSpace        *pAddressSpace = &(g_pCustomProvider->AddressSpace);
    OpcUa_StatusCode              uStatus = OpcUa_Good;
    UaServer_Configuration       *pConfig = UaServer_GetConfiguration(((UaServer_HistoryReadContext*)a_pHistoryReadRawModifiedCtx)->pUaServer);

    OpcUa_ReturnErrorIfArgumentNull(a_pHistoryReadRawModifiedCtx);

    /* we will send exactly one callback */
    UaBase_Atomic_Increment(&a_pHistoryReadRawModifiedCtx->nOutstandingCbs);

    /* process nodes */
    for (i = 0; i < a_pHistoryReadRawModifiedCtx->NoOfNodesToRead; i++)
    {
        /* check if the node is from our provider's namespace */
        if (a_pHistoryReadRawModifiedCtx->pNodesToRead[i].NodeId.NamespaceIndex == g_uCustomProvider_NamespaceIndex)
        {
            /* get the node pointer from the NodeId */
            UaServer_GetNode(pAddressSpace, &a_pHistoryReadRawModifiedCtx->pNodesToRead[i].NodeId, &pNode);
            if (pNode)
            {
#if UASERVER_SUPPORT_AUTHORIZATION
                /* Check if the user has the necessary permission to read the history */
                if (!UaServer_UserMgt_IsHistoryReadable(OpcUa_BaseNode_GetINode(pNode), a_pHistoryReadRawModifiedCtx->pSession->UserIdentityData))
                {
                    a_pHistoryReadRawModifiedCtx->pResponse->Results[i].StatusCode = OpcUa_BadNotReadable;
                    continue;
                }
#endif
#if HAVE_DATA_LOGGER && UASERVER_DATALOGGER_SUPPORT_DATA

                if (OpcUa_BaseNode_GetId(pNode)->IdentifierType == OpcUa_IdentifierType_Numeric)
                {
                    OpcUa_HistoryReadResult *pHistoryResult = &a_pHistoryReadRawModifiedCtx->pResponse->Results[i];
                    UserDataCommon *pUserData = (UserDataCommon*)OpcUa_BaseNode_GetUserData(pNode);

                    if (pUserData && pUserData->Type == UserDataTemperature)
                    {
                        TemperatureSensor                          *pTemperatureSensorData = (TemperatureSensor*)pUserData;
                        OpcUa_Int32                                 noOfHistoryContinuationPoints;
                        OpcUa_Int32                                 iCount;
                        OpcUa_ReadRawModifiedDetails               *pHistoryReadRawModifiedDetails = a_pHistoryReadRawModifiedCtx->pHistoryReadRawModifiedDetails;
                        OpcUa_TimestampsToReturn                    TimestampsToReturn = a_pHistoryReadRawModifiedCtx->TimestampsToReturn;
                        UaServer_ContinuationPointHistoryInfo      *pContinuationPointHistoryInfo = OpcUa_Null;

                        if (a_pHistoryReadRawModifiedCtx->pNodesToRead[i].ContinuationPoint.Data != OpcUa_Null)
                        {
                            noOfHistoryContinuationPoints = UaBase_RingBuffer_Count(&a_pHistoryReadRawModifiedCtx->pSession->HistoryContinuationPoints);
                            for (iCount = 0; iCount < noOfHistoryContinuationPoints; iCount++)
                            {
                                UaServer_ContinuationPointHistoryInfo* pTmpInfo = UaBase_RingBuffer_Pop(&a_pHistoryReadRawModifiedCtx->pSession->HistoryContinuationPoints);
                                if (OpcUa_ByteString_Compare(&pTmpInfo->ContinuationPoint, &a_pHistoryReadRawModifiedCtx->pNodesToRead[i].ContinuationPoint) == 0)
                                {
                                    pContinuationPointHistoryInfo = pTmpInfo;
                                    OpcUa_ByteString_Clear(&a_pHistoryReadRawModifiedCtx->pNodesToRead[i].ContinuationPoint);
                                    OpcUa_ByteString_CopyTo(pContinuationPointHistoryInfo->pUserData, &a_pHistoryReadRawModifiedCtx->pNodesToRead[i].ContinuationPoint);
                                    pHistoryReadRawModifiedDetails = UaServer_GetHistoryReadRawModifiedDetails(&pContinuationPointHistoryInfo->HistoryReadDetails);
                                    TimestampsToReturn = pContinuationPointHistoryInfo->TimestampsToReturn;
                                    break;
                                }
                                UaBase_RingBuffer_Push(&a_pHistoryReadRawModifiedCtx->pSession->HistoryContinuationPoints, pTmpInfo);
                            }
                        }

                        if (pContinuationPointHistoryInfo != OpcUa_Null &&
                            OpcUa_NodeId_Compare(&a_pHistoryReadRawModifiedCtx->pNodesToRead[i].NodeId, &pContinuationPointHistoryInfo->NodeId) != 0)
                        {
                            a_pHistoryReadRawModifiedCtx->pResponse->Results[i].StatusCode = OpcUa_BadContinuationPointInvalid;
                            continue;
                        }

                        a_pHistoryReadRawModifiedCtx->pResponse->Results[i].StatusCode = UaServer_DataLogger_ReadValues(
                            g_hDataLogger,
                            pTemperatureSensorData->hDataLogItemTemperatureValue,
                            pHistoryReadRawModifiedDetails,
                            TimestampsToReturn,
                            a_pHistoryReadRawModifiedCtx->ReleaseContinuationPoints,
                            &a_pHistoryReadRawModifiedCtx->pNodesToRead[i],
                            pHistoryResult,
                            a_pHistoryReadRawModifiedCtx->RequestHeader.TimeoutHint);

                        if (pContinuationPointHistoryInfo == OpcUa_Null)
                        {
                            if (pHistoryResult->ContinuationPoint.Data != OpcUa_Null)
                            {
                               /* only emit error if more than MaxHistoryContinuationPoints are used in one single HistoryRead call */
                                if (a_pHistoryReadRawModifiedCtx->nCreatedContinuationPoints == pConfig->uMaxHistoryContinuationPointsPerSession)
                                {
                                    OpcUa_ByteString_Clear(&pHistoryResult->ContinuationPoint);
                                    pHistoryResult->StatusCode = OpcUa_BadNoContinuationPoints;
                                }
                                pContinuationPointHistoryInfo = UaServer_ContinuationPointHistoryInfo_Create();
                                UaServer_ContinuationPointHistoryInfo_InitCPData(pContinuationPointHistoryInfo);

                                OpcUa_NodeId_CopyTo(&a_pHistoryReadRawModifiedCtx->pNodesToRead[i].NodeId, &pContinuationPointHistoryInfo->NodeId);

                                pContinuationPointHistoryInfo->fctDeleteUserData = CustomProvider_HistoryReadRawModifiedAsync_DeleteUserData;
                                pContinuationPointHistoryInfo->pUserData = OpcUa_Alloc(sizeof(OpcUa_ByteString));
                                OpcUa_ByteString_Initialize(pContinuationPointHistoryInfo->pUserData);

                                OpcUa_ByteString_CopyTo(&pHistoryResult->ContinuationPoint, pContinuationPointHistoryInfo->pUserData);
                                OpcUa_ByteString_Clear(&pHistoryResult->ContinuationPoint);

                                pHistoryReadRawModifiedDetails = OpcUa_Null;
                                OpcUa_EncodeableObject_CreateExtension(&OpcUa_ReadRawModifiedDetails_EncodeableType,
                                                                       &pContinuationPointHistoryInfo->HistoryReadDetails,
                                                                       (OpcUa_Void**)&pHistoryReadRawModifiedDetails);

                                OpcUa_ReadRawModifiedDetails_CopyTo(a_pHistoryReadRawModifiedCtx->pHistoryReadRawModifiedDetails, pHistoryReadRawModifiedDetails);

                                pContinuationPointHistoryInfo->TimestampsToReturn = a_pHistoryReadRawModifiedCtx->TimestampsToReturn;

                                uStatus = UaServer_ContinuationPointHistoryInfo_AddToList(pContinuationPointHistoryInfo, (UaServer_PublicSession*)a_pHistoryReadRawModifiedCtx->pSession);
                                if (OpcUa_IsBad(uStatus))
                                {
                                    UaServer_ContinuationPointHistoryInfo_Delete(pContinuationPointHistoryInfo);
                                    pContinuationPointHistoryInfo = OpcUa_Null;
                                    pHistoryResult->StatusCode = uStatus;

                                }
                                else
                                {
                                    OpcUa_ByteString_CopyTo(&pContinuationPointHistoryInfo->ContinuationPoint, &pHistoryResult->ContinuationPoint);
                                    a_pHistoryReadRawModifiedCtx->nCreatedContinuationPoints++;
                                }
                            }
                        }
                        else
                        {
                            if (pHistoryResult->ContinuationPoint.Data != OpcUa_Null)
                            {
                                OpcUa_ByteString_Clear(pContinuationPointHistoryInfo->pUserData);
                                OpcUa_ByteString_CopyTo(&pHistoryResult->ContinuationPoint, pContinuationPointHistoryInfo->pUserData);
                                OpcUa_ByteString_Clear(&pHistoryResult->ContinuationPoint);

                                uStatus = UaServer_ContinuationPointHistoryInfo_AddToList(pContinuationPointHistoryInfo, (UaServer_PublicSession*)a_pHistoryReadRawModifiedCtx->pSession);
                                if (OpcUa_IsBad(uStatus))
                                {
                                    UaServer_ContinuationPointHistoryInfo_Delete(pContinuationPointHistoryInfo);
                                    pContinuationPointHistoryInfo = OpcUa_Null;
                                    pHistoryResult->StatusCode = uStatus;

                                }
                                else
                                {
                                    OpcUa_ByteString_CopyTo(&pContinuationPointHistoryInfo->ContinuationPoint, &pHistoryResult->ContinuationPoint);
                                }
                            }
                            else
                            {
                                UaServer_ContinuationPointHistoryInfo_Delete(pContinuationPointHistoryInfo);
                                pContinuationPointHistoryInfo = OpcUa_Null;
                            }
                        }
                    }
                    else
                    {
                        a_pHistoryReadRawModifiedCtx->pResponse->Results[i].StatusCode = OpcUa_BadNotReadable;
                    }
                }
#endif /* HAVE_DATA_LOGGER && UASERVER_DATALOGGER_SUPPORT_DATA */
            }
        }
    }

    /* send callback */
    UaServer_HistoryReadRawModifiedComplete(a_pHistoryReadRawModifiedCtx);

    return OpcUa_Good;
}

OPCUA_END_EXTERN_C