libs2opc_client_cmds.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 LIBS2OPC_CLIENT_CMDS_H_
#define LIBS2OPC_CLIENT_CMDS_H_
 
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
 
#include "sopc_builtintypes.h"
#include "sopc_crypto_profiles.h"
#include "sopc_enum_types.h"
#include "sopc_log_manager.h"
#include "sopc_user_app_itf.h"
 
typedef void SOPC_ClientHelper_DataChangeCbk(const int32_t connectionId,
                                             const char* nodeId,
                                             const SOPC_DataValue* value);
 
typedef void SOPC_ClientHelper_DisconnectCbk(const uint32_t connectionId);
 
typedef struct
{
    const char* security_policy;
    OpcUa_MessageSecurityMode security_mode;
    const char* path_cert_auth;
    const char* path_crl;
    const char* path_cert_srv;
    const char* path_cert_cli;
    const char* path_key_cli;
    const char* policyId;
    const char* username;
    const char* password;
    const char* path_cert_x509_token;
    const char* path_key_x509_token;
} SOPC_ClientHelper_Security;
 
typedef struct
{
    const char* endpointUrl;
    const char* serverUri;
    uint32_t reverseConnectionConfigId;
} SOPC_ClientHelper_EndpointConnection;
 
typedef struct
{
    const char* nodeId;
    const char* indexRange;
    SOPC_DataValue* value;
} SOPC_ClientHelper_WriteValue;
 
typedef struct
{
    const char* nodeId;
    uint32_t attributeId;
    const char* indexRange;
} SOPC_ClientHelper_ReadValue;
 
typedef struct
{
    const char* nodeId;
    OpcUa_BrowseDirection direction;
    const char* referenceTypeId;
    bool includeSubtypes;
} SOPC_ClientHelper_BrowseRequest;
 
typedef struct
{
    char* referenceTypeId;
    bool isForward;
    char* nodeId;
    char* browseName;
    char* displayName;
    OpcUa_NodeClass nodeClass;
} SOPC_ClientHelper_BrowseResultReference;
 
typedef struct
{
    SOPC_ReturnStatus statusCode;
    int32_t nbOfReferences;
    SOPC_ClientHelper_BrowseResultReference* references;
} SOPC_ClientHelper_BrowseResult;
 
void SOPC_ClientHelper_BrowseResultReference_Move(SOPC_ClientHelper_BrowseResultReference* dest,
                                                  SOPC_ClientHelper_BrowseResultReference* src);
void SOPC_ClientHelper_BrowseResultReference_Clear(SOPC_ClientHelper_BrowseResultReference* brr);
 
void SOPC_ClientHelper_BrowseResults_Clear(size_t nbElements, SOPC_ClientHelper_BrowseResult* results);
 
typedef struct
{
    char* objectNodeId;
    char* methodNodeId;
    int32_t nbOfInputParams;
    SOPC_Variant* inputParams;
} SOPC_ClientHelper_CallMethodRequest;
 
typedef struct
{
    SOPC_StatusCode status;
    int32_t nbOfOutputParams;
    SOPC_Variant* outputParams;
} SOPC_ClientHelper_CallMethodResult;
 
typedef struct
{
    char* policyId;
    OpcUa_UserTokenType tokenType;
    char* issuedTokenType;
    char* issuerEndpointUrl;
    char* securityPolicyUri;
} SOPC_ClientHelper_UserIdentityToken;
 
typedef struct
{
    char* endpointUrl;
    int32_t security_mode;
    char* security_policyUri;
    int32_t nbOfUserIdentityTokens;
    SOPC_ClientHelper_UserIdentityToken* userIdentityTokens;
    char* transportProfileUri;
    int32_t securityLevel;
    int32_t serverCertificateNbBytes;
    uint8_t* serverCertificate;
} SOPC_ClientHelper_EndpointDescription;
 
typedef struct
{
    int32_t nbOfEndpoints;
    SOPC_ClientHelper_EndpointDescription* endpoints;
} SOPC_ClientHelper_GetEndpointsResult;
 
int32_t SOPC_ClientHelper_Initialize(SOPC_ClientHelper_DisconnectCbk* const disconnect_callback);
 
void SOPC_ClientHelper_Finalize(void);
 
int32_t SOPC_ClientHelper_GetEndpoints(SOPC_ClientHelper_EndpointConnection* connection,
                                       SOPC_ClientHelper_GetEndpointsResult** result);
 
void SOPC_ClientHelper_GetEndpointsResult_Free(SOPC_ClientHelper_GetEndpointsResult** getEpResult);
 
int32_t SOPC_ClientHelper_CreateReverseEndpoint(const char* reverseEndpointURL);
 
int32_t SOPC_ClientHelper_CreateConfiguration(SOPC_ClientHelper_EndpointConnection* connection,
                                              SOPC_ClientHelper_Security* security,
                                              OpcUa_GetEndpointsResponse* expectedEndpoints);
 
int32_t SOPC_ClientHelper_CreateConnection(int32_t cfg_id);
 
int32_t SOPC_ClientHelper_CreateSubscription(int32_t connectionId, SOPC_ClientHelper_DataChangeCbk* callback);
 
int32_t SOPC_ClientHelper_AddMonitoredItems(int32_t connectionId,
                                            char** nodeIds,
                                            size_t nbNodeIds,
                                            SOPC_StatusCode* results);
 
int32_t SOPC_ClientHelper_Unsubscribe(int32_t connectionId);
 
int32_t SOPC_ClientHelper_Disconnect(int32_t connectionId);
 
int32_t SOPC_ClientHelper_Write(int32_t connectionId,
                                SOPC_ClientHelper_WriteValue* writeValues,
                                size_t nbElements,
                                SOPC_StatusCode* writeResults);
 
int32_t SOPC_ClientHelper_Read(int32_t connectionId,
                               SOPC_ClientHelper_ReadValue* readValues,
                               size_t nbElements,
                               SOPC_DataValue* values);
void SOPC_ClientHelper_ReadResults_Free(size_t nbElements, SOPC_DataValue* values);
 
int32_t SOPC_ClientHelper_Browse(int32_t connectionId,
                                 SOPC_ClientHelper_BrowseRequest* browseRequests,
                                 size_t nbElements,
                                 SOPC_ClientHelper_BrowseResult* browseResults);
 
int32_t SOPC_ClientHelper_CallMethod(int32_t connectionId,
                                     SOPC_ClientHelper_CallMethodRequest* callRequests,
                                     size_t nbOfElements,
                                     SOPC_ClientHelper_CallMethodResult* callResults);
 
SOPC_ReturnStatus SOPC_ClientHelper_GenericService(int32_t connectionId, void* requestMsg, void** responseMsg);
 
void SOPC_ClientHelper_CallMethodResults_Clear(size_t nbElements, SOPC_ClientHelper_CallMethodResult* results);
 
SOPC_ReturnStatus SOPC_ClientHelper_SetLocaleIds(size_t nbLocales, const char** localeIds);
 
SOPC_ReturnStatus SOPC_ClientHelper_SetApplicationDescription(const char* applicationUri,
                                                              const char* productUri,
                                                              const char* defaultAppName,
                                                              const char* defaultAppNameLocale,
                                                              OpcUa_ApplicationType applicationType);
#endif /* LIBS2OPC_CLIENT_CMDS_H_ */