state_machine.h

Go to the documentation of this file.

/*
 * Licensed to Systerel under one or more contributor license
 * agreements. See the NOTICE file distributed with this work
 * for additional information regarding copyright ownership.
 * Systerel licenses this file to you under the Apache
 * License, Version 2.0 (the "License"); you may not use this
 * file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
 
#ifndef STATE_MACHINE_H_
#define STATE_MACHINE_H_
 
/* Machine static parameters, MonitoredItem parameters */
#define MONIT_TIMESTAMPS_TO_RETURN OpcUa_TimestampsToReturn_Both
#define MONIT_QSIZE 10
 
#include <stdbool.h>
 
#include "sopc_builtintypes.h"
#include "sopc_types.h"
 
typedef enum _SOPC_StaMac_ApplicativeEvent
{
    SOPC_StaMac_ApplicativeEvent_SendFailed,
    SOPC_StaMac_ApplicativeEvent_Response
} SOPC_StaMac_ApplicativeEvent;
 
typedef void SOPC_StaMac_EventCbk(uint32_t c_id,
                                  SOPC_StaMac_ApplicativeEvent event,
                                  SOPC_StatusCode status,
                                  const void* response,
                                  uintptr_t responseContext);
 
/* Machine states */
typedef enum
{
    stError, /* stError is both error and closed state */
    stInit,
    stActivating,
    stActivated,
    stCreatingSubscr,
    stCreatingMonIt,
    stDeletingMonIt,
    stDeletingSubscr,
    stClosing
} SOPC_StaMac_State;
 
/* Request types */
typedef enum
{
    SOPC_REQUEST_TYPE_UNKNOWN = 0,  /* Unknown Request */
    SOPC_REQUEST_TYPE_USER,         /* User Crafted Request */
    SOPC_REQUEST_TYPE_PUBLISH,      /* PublishRequest */
    SOPC_REQUEST_TYPE_SUBSCRIPTION, /* Other internally managed Subscription related request */
    SOPC_REQUEST_TYPE_GET_ENDPOINTS /* GetEndpointsRequest */
} SOPC_StaMac_RequestType;
 
/* Request scopes */
typedef enum
{
    SOPC_REQUEST_SCOPE_STATE_MACHINE, 
    SOPC_REQUEST_SCOPE_APPLICATION,   
    SOPC_REQUEST_SCOPE_DISCOVERY      
} SOPC_StaMac_RequestScope;
 
/* Machine content is private to the implementation */
typedef struct SOPC_StaMac_Machine SOPC_StaMac_Machine;
 
typedef struct
{
    SOPC_StaMac_Machine* pSM;              /* The state machine that issued the request */
    uintptr_t appCtx;                      /* Application context, chosen outside of the state machine */
    SOPC_StaMac_RequestScope requestScope; /* Whether the request is started by the state machine or the applicative */
    SOPC_StaMac_RequestType requestType;   /* the type of request */
} SOPC_StaMac_ReqCtx;
 
/* Machine lifecycle */
 
SOPC_ReturnStatus SOPC_StaMac_Create(uint32_t iscConfig,
                                     SOPC_ReverseEndpointConfigIdx reverseConfigIdx,
                                     uint32_t iCliId,
                                     const char* szPolicyId,
                                     const char* szUsername,
                                     const char* szPassword,
                                     const SOPC_SerializedCertificate* pUserCertX509,
                                     const SOPC_SerializedAsymmetricKey* pUserKey,
                                     uint32_t iTokenTarget,
                                     SOPC_StaMac_EventCbk* cbkGenericEvent,
                                     uintptr_t userContext,
                                     SOPC_StaMac_Machine** ppSM);
 
void SOPC_StaMac_Delete(SOPC_StaMac_Machine** ppSM);
 
SOPC_ReturnStatus SOPC_StaMac_StartSession(SOPC_StaMac_Machine* pSM);
 
SOPC_ReturnStatus SOPC_StaMac_StopSession(SOPC_StaMac_Machine* pSM);
 
SOPC_ReturnStatus SOPC_StaMac_SendRequest(SOPC_StaMac_Machine* pSM,
                                          void* requestStruct,
                                          uintptr_t appCtx,
                                          SOPC_StaMac_RequestScope requestScope,
                                          SOPC_StaMac_RequestType requestType);
 
/*
 * \brief Create subscription associated to the given state machine using the subscription request (new API)
 */
SOPC_ReturnStatus SOPC_StaMac_NewCreateSubscription(SOPC_StaMac_Machine* pSM,
                                                    OpcUa_CreateSubscriptionRequest* req,
                                                    uintptr_t userAppContext);
 
uintptr_t SOPC_StaMac_GetSubscriptionCtx(SOPC_StaMac_Machine* pSM);
 
/*
 * \brief Retrieve the subscription parameters revised by the server (for non-NULL params only)
 */
SOPC_ReturnStatus SOPC_StaMac_GetSubscriptionRevisedParams(SOPC_StaMac_Machine* pSM,
                                                           double* revisedPublishingInterval,
                                                           uint32_t* revisedLifetimeCount,
                                                           uint32_t* revisedMaxKeepAliveCount);
 
/*
 * \brief Set the number of tokens for the subscription associated to the given state machine
 */
SOPC_ReturnStatus SOPC_StaMac_SetSubscriptionNbTokens(SOPC_StaMac_Machine* pSM, uint32_t nbTokens);
 
SOPC_ReturnStatus SOPC_StaMac_DeleteSubscription(SOPC_StaMac_Machine* pSM);
 
typedef struct SOPC_CreateMonitoredItems_Ctx
{
    OpcUa_CreateMonitoredItemsResponse* Results; /* It shall be allocated if response expected
                                                    or might be NULL if not necessary for application. */
    uintptr_t outCtxId; /* Contains unique identifier filled by ::SOPC_StaMac_NewCreateMonitoredItems*/
    OpcUa_CreateMonitoredItemsRequest*
        req; /* Contains the request sent to the server (internal use only, freed during treatment)*/
} SOPC_CreateMonitoredItems_Ctx;
 
typedef void SOPC_StaMacNotification_Fct(uintptr_t subscriptionAppCtx,
                                         SOPC_StatusCode status,
                                         SOPC_EncodeableType* notificationType,
                                         uint32_t nbNotifElts,
                                         const void* notification,
                                         uintptr_t* monitoredItemCtxArray);
/*
 * \brief Changes the callback for data change notifications on subscription
 *
 * \param pSM             The state machine with a subscription used to create monitored items
 * \param pNotificationCb The callback to be called on data change notifications on created monitored items
 *
 * \return SOPC_STATUS_OK if the callback was successfully set,
 *         otherwise SOPC_STATUS_INVALID_PARAMETER if one of the parameters is NULL or
 *         SOPC_STATUS_INVALID_STATE if a data change notification callback is already set.
 */
SOPC_ReturnStatus SOPC_StaMac_NewConfigureNotificationCallback(SOPC_StaMac_Machine* pSM,
                                                               SOPC_StaMacNotification_Fct* pNotificationCb);
 
SOPC_ReturnStatus SOPC_StaMac_NewCreateMonitoredItems(SOPC_StaMac_Machine* pSM,
                                                      OpcUa_CreateMonitoredItemsRequest* req,
                                                      const uintptr_t* userAppCtxArray,
                                                      SOPC_CreateMonitoredItems_Ctx* pAppCtx);
 
typedef struct SOPC_DeleteMonitoredItems_Ctx
{
    OpcUa_DeleteMonitoredItemsResponse* Results; /* It shall be allocated if response expected
                                                    or might be NULL if not necessary for application. */
    uintptr_t outCtxId; /* Contains unique identifier filled by ::SOPC_StaMac_NewDeleteMonitoredItems */
    OpcUa_DeleteMonitoredItemsRequest*
        req; /* Contains the request sent to the server (internal use only, freed during treatment)*/
} SOPC_DeleteMonitoredItems_Ctx;
 
SOPC_ReturnStatus SOPC_StaMac_NewDeleteMonitoredItems(SOPC_StaMac_Machine* pSM,
                                                      OpcUa_DeleteMonitoredItemsRequest* req,
                                                      SOPC_DeleteMonitoredItems_Ctx* outAppCtx);
 
bool SOPC_StaMac_IsConnectable(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_IsConnected(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_IsError(SOPC_StaMac_Machine* pSM);
 
void SOPC_StaMac_SetError(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_HasSubscription(SOPC_StaMac_Machine* pSM);
 
uint32_t SOPC_StaMac_HasSubscriptionId(SOPC_StaMac_Machine* pSM);
 
bool SOPC_StaMac_PopMonItByAppCtx(SOPC_StaMac_Machine* pSM, SOPC_CreateMonitoredItems_Ctx* pAppCtx);
 
bool SOPC_StaMac_PopDeleteMonItByAppCtx(SOPC_StaMac_Machine* pSM, SOPC_DeleteMonitoredItems_Ctx* pAppCtx);
 
uintptr_t SOPC_StaMac_GetUserContext(SOPC_StaMac_Machine* pSM);
 
void SOPC_StaMac_SetUserContext(SOPC_StaMac_Machine* pSM, uintptr_t userContext);
 
bool SOPC_StaMac_EventDispatcher(SOPC_StaMac_Machine* pSM,
                                 uintptr_t* pAppCtx,
                                 SOPC_App_Com_Event event,
                                 uint32_t arg,
                                 void* pParam,
                                 uintptr_t appCtx);
 
#endif /* STATE_MACHINE_H_ */