sopc_user_app_itf.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 SOPC_USER_APP_ITF_H_
#define SOPC_USER_APP_ITF_H_
 
#include <stdbool.h>
 
#include "sopc_call_method_manager.h"
#include "sopc_common_build_info.h"
#include "sopc_crypto_profiles.h"
#include "sopc_key_cert_pair.h"
#include "sopc_key_manager.h"
#include "sopc_service_call_context.h"
#include "sopc_toolkit_config_constants.h"
#include "sopc_types.h"
#include "sopc_user_manager.h"
 
typedef struct SOPC_Client_Config SOPC_Client_Config;
 
typedef struct SOPC_SecureChannel_Config
{
    uint8_t isClientSc; 
    const SOPC_Client_Config* clientConfigPtr; 
    const OpcUa_GetEndpointsResponse* expectedEndpoints; 
    const char* serverUri; 
    const char* url;       
    const SOPC_SerializedCertificate* peerAppCert; /*< Peer application certificate:
                                                       isClientSc => serverCertificate (configuration data)
                                                       !isClientSc => clientCertificate (runtime data) */
    const char* reqSecuPolicyUri;                  
    uint32_t requestedLifetime;                    
    OpcUa_MessageSecurityMode msgSecurityMode;     
    uintptr_t internalProtocolData; 
} SOPC_SecureChannel_Config;
 
#define SOPC_SECURITY_MODE_NONE_MASK 0x01
#define SOPC_SECURITY_MODE_SIGN_MASK 0x02
#define SOPC_SECURITY_MODE_SIGNANDENCRYPT_MASK 0x04
#define SOPC_SECURITY_MODE_ANY_MASK 0x07
 
#ifndef SOPC_MAX_SECU_POLICIES_CFG
#define SOPC_MAX_SECU_POLICIES_CFG 5 /* Maximum number of security policies in a configuration array */
#endif
 
/* Maximum number of client secure connections */
#ifndef SOPC_MAX_CLIENT_SECURE_CONNECTIONS_CONFIG
#define SOPC_MAX_CLIENT_SECURE_CONNECTIONS_CONFIG SOPC_MAX_SECURE_CONNECTIONS
#else
#if SOPC_MAX_CLIENT_SECURE_CONNECTIONS_CONFIG > UINT16_MAX
#error "Maximum number of secure connections configuration cannot be > UINT16_MAX"
#endif
#endif
 
typedef struct SOPC_SecurityPolicy
{
    SOPC_String securityPolicy; 
    uint16_t securityModes;     
    uint8_t nbOfUserTokenPolicies; 
    OpcUa_UserTokenPolicy
        userTokenPolicies[SOPC_MAX_SECU_POLICIES_CFG]; 
} SOPC_SecurityPolicy;
 
typedef struct SOPC_Server_Config SOPC_Server_Config;
 
typedef struct SOPC_Server_ClientToConnect
{
    char* clientApplicationURI; 
    char* clientEndpointURL;    
} SOPC_Server_ClientToConnect;
 
typedef struct SOPC_Endpoint_Config
{
    SOPC_Server_Config* serverConfigPtr; 
    char* endpointURL;                   
    bool hasDiscoveryEndpoint; 
    uint8_t nbSecuConfigs;     
    SOPC_SecurityPolicy
        secuConfigurations[SOPC_MAX_SECU_POLICIES_CFG]; 
    /* To be instantiated by applicative code: */
    SOPC_UserAuthentication_Manager*
        authenticationManager; 
    SOPC_UserAuthorization_Manager*
        authorizationManager; 
    /* Configure reverse connection mechanism */
    bool noListening;            
    uint16_t nbClientsToConnect; 
    SOPC_Server_ClientToConnect
        clientsToConnect[SOPC_MAX_REVERSE_CLIENT_CONNECTIONS]; 
} SOPC_Endpoint_Config;
 
typedef struct SOPC_Session_UserX509_ConfigFromPaths
{
    char* userCertPath; 
    char* userKeyPath;  
    bool userKeyEncrypted; 
} SOPC_Session_UserX509_ConfigFromPaths;
 
typedef struct SOPC_Session_UserX509
{
    SOPC_SerializedCertificate* certX509;
    SOPC_SerializedAsymmetricKey* keyX509;
 
    bool isConfigFromPathNeeded; 
    SOPC_Session_UserX509_ConfigFromPaths* configFromPaths; 
} SOPC_Session_UserX509;
 
typedef struct SOPC_Session_UserName
{
    char* userName;
    char* userPwd;
} SOPC_Session_UserName;
 
typedef struct SOPC_Session_Config
{
    const char* userPolicyId;
    OpcUa_UserTokenType userTokenType;
    union
    {
        SOPC_Session_UserName userName;
        SOPC_Session_UserX509 userX509;
    } userToken;
 
} SOPC_Session_Config;
 
typedef struct SOPC_SecureConnection_Config
{
    const char* userDefinedId; // Optional user defined id
 
    SOPC_SecureChannel_Config scConfig;
    const char* reverseURL;
 
    bool isServerCertFromPathNeeded; 
    char* serverCertPath; 
    SOPC_Session_Config sessionConfig; 
    uint16_t secureConnectionIdx; 
    bool finalized; 
} SOPC_SecureConnection_Config;
 
typedef struct SOPC_Client_ConfigFromPaths
{
    char* clientCertPath;    
    char* clientKeyPath;     
    bool clientKeyEncrypted; 
    char* clientPkiPath;     
} SOPC_Client_ConfigFromPaths;
 
struct SOPC_Client_Config
{
    OpcUa_ApplicationDescription
        clientDescription; 
    bool freeCstringsFlag;  
    char** clientLocaleIds; 
    bool isConfigFromPathsNeeded; 
    SOPC_Client_ConfigFromPaths* configFromPaths; 
    SOPC_KeyCertPair* clientKeyCertPair; 
    SOPC_PKIProvider* clientPKI;         
    uint16_t nbSecureConnections; 
    SOPC_SecureConnection_Config*
        secureConnections[SOPC_MAX_CLIENT_SECURE_CONNECTIONS_CONFIG]; 
    uint16_t nbReverseEndpointURLs;
    char* reverseEndpointURLs[SOPC_MAX_CLIENT_SECURE_CONNECTIONS_CONFIG]; 
};
 
typedef bool SOPC_CreateMI_NodeAvailFunc(const SOPC_NodeId* nodeId,
                                         OpcUa_NodeClass* outNodeClass,
                                         SOPC_StatusCode* outUnavailabilityStatus);
 
struct SOPC_Server_Config
{
    bool freeCstringsFlag; 
    char** namespaces;     
    char** localeIds; 
    OpcUa_ApplicationDescription serverDescription; 
    char* serverCertPath; 
    char* serverKeyPath;  
    bool serverKeyEncrypted;         
    char* serverPkiPath;             
    uint8_t nbEndpoints;             
    SOPC_Endpoint_Config* endpoints; 
    /* To be instantiated by applicative code: */
    SOPC_KeyCertPair* serverKeyCertPair;        
    SOPC_PKIProvider* pki;                      
    SOPC_MethodCallManager* mcm;                
    SOPC_CreateMI_NodeAvailFunc* nodeAvailFunc; 
};
 
typedef struct SOPC_S2OPC_Config
{
    SOPC_Server_Config serverConfig; 
    SOPC_Client_Config clientConfig; 
} SOPC_S2OPC_Config;
 
typedef uint32_t SOPC_SessionId;
 
typedef enum SOPC_App_Com_Event
{
    /* Client application events */
    SE_REVERSE_ENDPOINT_CLOSED = 0x700, 
    SE_SESSION_ACTIVATION_FAILURE,      
    SE_ACTIVATED_SESSION,               
    SE_SESSION_REACTIVATING,            
    SE_RCV_SESSION_RESPONSE,            
    SE_CLOSED_SESSION,                  
    SE_RCV_DISCOVERY_RESPONSE,          
    SE_SND_REQUEST_FAILED,              
    /* Server application events */
    SE_CLOSED_ENDPOINT,       
    SE_LOCAL_SERVICE_RESPONSE 
} SOPC_App_Com_Event;
 
/* Server only interfaces */
 
typedef enum SOPC_App_AddSpace_Event
{
    /* Server application events */
    AS_WRITE_EVENT = 0x800, 
} SOPC_App_AddSpace_Event;
 
typedef void SOPC_ComEvent_Fct(SOPC_App_Com_Event event, uint32_t IdOrStatus, void* param, uintptr_t appContext);
 
typedef void SOPC_AddressSpaceNotif_Fct(const SOPC_CallContext* callCtxPtr,
                                        SOPC_App_AddSpace_Event event,
                                        void* opParam,
                                        SOPC_StatusCode opStatus);
 
typedef struct
{
    SOPC_Build_Info commonBuildInfo;
    SOPC_Build_Info clientServerBuildInfo;
} SOPC_Toolkit_Build_Info;
 
void SOPC_S2OPC_Config_Initialize(SOPC_S2OPC_Config* config);
 
void SOPC_S2OPC_Config_Clear(SOPC_S2OPC_Config* config);
 
void SOPC_ServerConfig_Initialize(SOPC_Server_Config* config);
 
void SOPC_ServerConfig_Clear(SOPC_Server_Config* config);
 
void SOPC_ClientConfig_Initialize(SOPC_Client_Config* config);
 
void SOPC_ClientConfig_Clear(SOPC_Client_Config* config);
 
#endif // SOPC_USER_APP_ITF_H_