#include <stdio.h>
#include <stdlib.h>
#if defined(WIN32)
#include <windows.h>
#endif
#if defined(__VXWORKS__)
#include <hostLib.h>
#endif
#include <uabase_settings.h>
#include <uabase_utilities.h>
#include <uabase_trace.h>
#include <uabase_module.h>
#include <opcua_memory.h>
#include <opcua_datetime.h>
#include <opcua_string.h>
#include <opcua_proxystub.h>
#include <opcua_trace.h>
#include <opcua_pkifactory.h>
#include <uaclient_module.h>
#include <uaclient_discovery.h>
#include <uaclient_session.h>
#include <uaclient_subscription.h>
#include <uaclient_config.h>
#if OPCUA_SUPPORT_PKI && UABASE_USE_FILESYSTEM
# include <uabase_p_filesystem.h>
# include <uabase_pki.h>
#endif
#define UACLIENT_APPLICATION_NAME "UaSdkC - Client - Lesson04@[gethostname]"
#define UACLIENT_APPLICATION_URI "urn:[gethostname]:UnifiedAutomation:UaSdkC:Client:Lesson04"
#define UACLIENT_PRODUCT_NAME "UA ANSI C SDK based Sample Client"
#define UACLIENT_PRODUCT_URI "urn:UnifiedAutomation:UaSdkC:Client:Lesson04"
#define SERVER_ENDPOINT_URL "opc.tcp://localhost:48020"
typedef enum _SampleStateMachine
{
State_Idle,
State_FindServers,
State_FindServersDone,
State_GetEndpoints,
State_GetEndpointsDone,
State_Connect,
State_Connected,
State_Disconnect,
State_Disconnected,
State_Error
} SampleStateMachine;
typedef struct _SampleClientContext
{
SampleStateMachine State;
} SampleClientContext;
typedef struct _Sample_Discovery
{
OpcUa_List lstDiscoveryUrls;
OpcUa_List lstEndpoints;
OpcUa_Void *pUserData;
} Sample_Discovery;
#if defined(WIN32) && !defined(_WIN32_WCE)
#include <conio.h>
#elif !defined(EUROS_VERSION) && !defined(_WIN32_WCE) && !defined(__VXWORKS__)
#include <unistd.h>
#include <netdb.h>
static int peek_character = -1;
int _getch(void)
{
char ch = 0;
ssize_t ret;
if (peek_character != -1)
{
ch = peek_character;
peek_character = -1;
return ch;
}
ret = read(0, &ch, 1);
OpcUa_ReferenceParameter(ret);
return ch;
}
#else
int _getch(void)
{
return 0;
}
#endif
int GetFQHostname(char *a_szHostname, int a_len)
{
struct hostent* pEnt = 0;
int ret = gethostname(a_szHostname, a_len);
if (ret != 0) return ret;
pEnt = gethostbyname(a_szHostname);
if (pEnt == 0) return -1;
OpcUa_StrlCpyA(a_szHostname, pEnt->h_name, a_len);
a_szHostname[a_len - 1] = 0;
return 0;
}
OpcUa_ProxyStubConfiguration *a_pProxyStubConfiguration)
{
OpcUa_InitializeStatus(OpcUa_Module_Client, "InitializeOpcUaStack");
printf("UA Client: Initializing Stack...\n");
a_pProxyStubConfiguration->bProxyStub_Trace_Enabled = OpcUa_True;
a_pProxyStubConfiguration->uProxyStub_Trace_Level = OPCUA_TRACE_OUTPUT_LEVEL_WARNING;
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
{
OpcUa_InitializeStatus(OpcUa_Module_Client, "CleanupOpcUaStack");
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
#if OPCUA_SUPPORT_PKI && UABASE_USE_FILESYSTEM
const char* a_szHostname,
const char* a_szApplicationUri,
const char* a_szApplicationName,
OpcUa_Boolean a_bIsClient)
{
OpcUa_Boolean bGenerateCertificate = OpcUa_False;
OpcUa_CharA szString[UABASE_PATH_MAX];
OpcUa_CharA szCertificateFile[UABASE_PATH_MAX];
OpcUa_CharA szCertificateKeyFile[UABASE_PATH_MAX];
UaBase_File *pFile = OpcUa_Null;
OpcUa_Boolean bCertAvailable = OpcUa_True;
OpcUa_Int iRet;
OpcUa_InitializeStatus(OpcUa_Module_Utilities, "SetupPKIStore");
if (iRet !=
UABASE_SUCCESS) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR,
"Could not create trust list path (ret=%i)\n", iRet); OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError); }
if (iRet !=
UABASE_SUCCESS) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR,
"Could not create CRL path (ret=%i)\n", iRet); OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError); }
if (iRet !=
UABASE_SUCCESS) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR,
"Could not create issuer trust list path (ret=%i)\n", iRet); OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError); }
if (iRet !=
UABASE_SUCCESS) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR,
"Could not create issuer CRL path (ret=%i)\n", iRet); OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError); }
if (bGenerateCertificate == OpcUa_False)
{
OpcUa_ReturnStatusCode;
}
pFile = UaBase_Fopen(szCertificateFile, "r");
if (pFile != NULL)
{
UaBase_Fclose(pFile);
}
else
{
bCertAvailable = OpcUa_False;
}
pFile = UaBase_Fopen(szCertificateKeyFile, "r");
if (pFile != NULL)
{
UaBase_Fclose(pFile);
}
else
{
bCertAvailable = OpcUa_False;
}
pFile = NULL;
if (bCertAvailable == OpcUa_False)
{
OpcUa_CharA szCommonName[64];
OpcUa_CharA szOrganization[64];
OpcUa_CharA szOrganizationUnit[64];
OpcUa_CharA szLocality[64];
OpcUa_CharA szState[64];
OpcUa_CharA szCountry[3];
OpcUa_CharA szDNSNames[64];
OpcUa_CharA szIPAddresses[64];
OpcUa_CharA szApplicationUri[128];
OpcUa_UInt iYearsValidFor = 0;
OpcUa_UInt iKeyLength = 0;
OpcUa_CharA szSignatureAlgorithm[8] = "";
OpcUa_X509SignatureAlgorithm signatureAlgorithm = OpcUa_X509SignatureAlgorithm_Sha256;
OpcUa_StringA_snprintf(szString, sizeof(szString), "%s", a_szApplicationName);
UaBase_Settings_ReplaceString(szString, sizeof(szString), "[gethostname]", a_szHostname);
UaBase_Settings_ReplaceString(szCommonName, sizeof(szCommonName), "[ApplicationName]", szString);
subject.sCommonName = szCommonName;
subject.sOrganization = szOrganization;
subject.sOrganizationUnit = szOrganizationUnit;
subject.sLocality = szLocality;
subject.sState = szState;
subject.sCountry = szCountry;
subject.sDomainComponent = "";
OpcUa_StrlCpyA(szApplicationUri, a_szApplicationUri, sizeof(szApplicationUri));
UaBase_Settings_ReplaceString(szApplicationUri, sizeof(szApplicationUri), "[gethostname]", a_szHostname);
certificateInfo.sURI = szApplicationUri;
certificateInfo.
sIP = szIPAddresses;
UaBase_Settings_ReplaceString(szDNSNames, sizeof(szDNSNames), "[gethostname]", a_szHostname);
certificateInfo.
sDNS = OpcUa_StrLenA(szDNSNames) > 0 ? szDNSNames : a_szHostname;
certificateInfo.sEMail = "";
certificateInfo.validTime = 3600 * 24 * 365 * iYearsValidFor;
certificateInfo.extendedKeyUsage = a_bIsClient == OpcUa_False ? OpcUa_ExtendedKeyUsage_ServerAuth : OpcUa_ExtendedKeyUsage_ClientAuth;
if (OpcUa_IsNotGood(uStatus)) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR, "UaBase_PkiRsaKeyPair_Create failed (ret=0x%08x)\n", uStatus); OpcUa_GotoError; }
if (szSignatureAlgorithm[0] != '\0')
{
if (OpcUa_StrCmpA(szSignatureAlgorithm, "Sha1") == 0) signatureAlgorithm = OpcUa_X509SignatureAlgorithm_Sha1;
else if (OpcUa_StrCmpA(szSignatureAlgorithm, "Sha224") == 0) signatureAlgorithm = OpcUa_X509SignatureAlgorithm_Sha224;
else if (OpcUa_StrCmpA(szSignatureAlgorithm, "Sha256") == 0) signatureAlgorithm = OpcUa_X509SignatureAlgorithm_Sha256;
else if (OpcUa_StrCmpA(szSignatureAlgorithm, "Sha384") == 0) signatureAlgorithm = OpcUa_X509SignatureAlgorithm_Sha384;
else if (OpcUa_StrCmpA(szSignatureAlgorithm, "Sha512") == 0) signatureAlgorithm = OpcUa_X509SignatureAlgorithm_Sha512;
}
&pCertificate,
certificateInfo,
subject,
*pSubjectKeyPair,
subject,
*pSubjectKeyPair,
signatureAlgorithm);
if (OpcUa_IsNotGood(uStatus)) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR, "UaBase_PkiCertificate_Create failed (ret=0x%08x)\n", uStatus); OpcUa_GotoError; }
OpcUa_StrlCpyA(szString, szCertificateFile, sizeof(szString));
if (iRet !=
UABASE_SUCCESS) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR,
"Could not create certificate path (ret=%i)\n", iRet); OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError);; }
if (OpcUa_IsNotGood(uStatus)) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR, "UaBase_PkiCertificate_ToDERFile failed (ret=0x%08x)\n", uStatus); OpcUa_GotoError; }
OpcUa_StrlCpyA(szString, szCertificateKeyFile, sizeof(szString));
if (iRet !=
UABASE_SUCCESS) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR,
"Could not create private key path (ret=%i)\n", iRet); OpcUa_GotoErrorWithStatus(OpcUa_BadInternalError);; }
if (OpcUa_IsNotGood(uStatus)) { OpcUa_Trace(OPCUA_TRACE_LEVEL_ERROR, "UaBase_PkiRsaKeyPair_ToPEMFile failed (ret=0x%08x)\n", uStatus); OpcUa_GotoError; }
}
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
const char *a_szHostname,
const char *a_szApplicationUri,
const char *a_szApplicationName)
{
OpcUa_InitializeStatus(OpcUa_Module_Client, "SetupClientPKIInfrastructure");
uStatus = SetupPKIStore(a_pSettings,
a_szHostname,
a_szApplicationUri,
a_szApplicationName,
OpcUa_True);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
OpcUa_FinishErrorHandling;
}
#endif
{
SampleClientContext *pClientContext = a_pSession->
pUserData;
const char *pStatus = "INVALID";
switch (a_status)
{
pStatus = "Disconnected";
if (pClientContext->State == State_Connect)
{
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "UA Client: failed to connect to server!\n");
}
if (pClientContext->State == State_Disconnect)
{
pClientContext->State = State_Disconnected;
}
else
{
pClientContext->State = State_Error;
}
break;
pStatus = "Connected";
if (pClientContext->State == State_Connect)
{
pClientContext->State = State_Connected;
}
else
{
pClientContext->State = State_Error;
}
break;
pStatus = "Connecting";
break;
pStatus = "ConnectionWarningWatchdogTimeout";
break;
pStatus = "ConnectionErrorClientReconnect";
break;
pStatus = "SessionAutomaticallyRecreated";
break;
default: break;
}
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "\n--> Sample_ConnectionStatusChanged_CB: %s\n\n", pStatus);
}
OpcUa_Boolean a_overridable)
{
SampleClientContext *pClientContext = a_pSession->
pUserData;
const char *pServiceType = "INVALID";
switch (a_serviceType)
{
default: break;
}
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "Sample_ConnectError_CB:\n");
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, " ServiceType: %s\n", pServiceType);
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, " Error: 0x%08x\n", a_error);
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, " Overridable: %s\n", a_overridable == OpcUa_False ? "false" : "true");
pClientContext->State = State_Error;
return OpcUa_False;
}
OpcUa_Int32 a_NoOfServers,
OpcUa_Void *a_pUserData)
{
Sample_Discovery *pSampleDiscovery = (Sample_Discovery*)a_pUserData;
SampleClientContext *pClientContext = pSampleDiscovery->pUserData;
OpcUa_ReferenceParameter(a_pDiscovery);
{
OpcUa_Int32 i, j;
printf(
"Sample_FindServers_CB result (0x%08x):\n", a_pResponseHeader->
ServiceResult);
for (i = 0; i < a_NoOfServers; i++)
{
printf("[%i] %s:\n", i, OpcUa_String_GetRawString(&a_pServers[i].ApplicationName.Text));
for (j = 0; j < a_pServers[i].NoOfDiscoveryUrls; j++)
{
if (!pCopy)
{
printf(" OUT OF MEMORY\n");
break;
}
OpcUa_String_Initialize(&a_pServers[i].DiscoveryUrls[j]);
OpcUa_List_AddElementToEnd(&pSampleDiscovery->lstDiscoveryUrls, pCopy);
printf(" %s\n", OpcUa_String_GetRawString(pCopy));
}
}
}
else
{
printf(
"Sample_FindServers_CB: bad status (0x%08x)\n", a_pResponseHeader->
ServiceResult);
}
if (pClientContext->State == State_FindServers)
{
pClientContext->State = State_FindServersDone;
}
else
{
pClientContext->State = State_Error;
}
}
OpcUa_Int32 a_NoOfEndpoints,
OpcUa_Void *a_pUserData)
{
Sample_Discovery *pSampleDiscovery = (Sample_Discovery*)a_pUserData;
SampleClientContext *pClientContext = pSampleDiscovery->pUserData;
OpcUa_ReferenceParameter(a_pDiscovery);
{
OpcUa_Int32 i;
printf(
"Sample_GetEndpoints_CB result (0x%08x):\n", a_pResponseHeader->
ServiceResult);
for (i = 0; i < a_NoOfEndpoints; i++)
{
if (!pCopy)
{
printf(" OUT OF MEMORY\n");
break;
}
*pCopy = a_pEndpoints[i];
OpcUa_EndpointDescription_Initialize(&a_pEndpoints[i]);
OpcUa_List_AddElementToEnd(&pSampleDiscovery->lstEndpoints, pCopy);
printf(
"[%i]: %s\n", i, OpcUa_String_GetRawString(&pCopy->
EndpointUrl));
}
if (pClientContext->State == State_GetEndpoints)
{
pClientContext->State = State_GetEndpointsDone;
}
else
{
pClientContext->State = State_Error;
}
}
else
{
printf(
"Sample_GetEndpoints_CB: bad status (0x%08x)\n", a_pResponseHeader->
ServiceResult);
pClientContext->State = State_Error;
}
}
{
OpcUa_Boolean bClientInitialized = OpcUa_False;
OpcUa_Boolean bComplete = OpcUa_False;
SampleClientContext clientContext;
Sample_Discovery sampleDiscovery;
char szValue[UABASE_PATH_MAX] = { 0 };
OpcUa_UInt32 uNoOfDiscoveryUrls = 0, uNoOfEndpoints = 0;
OpcUa_InitializeStatus(OpcUa_Module_Client, "ClientMain");
OpcUa_DeclareErrorTraceModule(OpcUa_Module_Client);
clientContext.State = State_Idle;
#if OPCUA_SUPPORT_PKI && UABASE_USE_FILESYSTEM
uStatus = SetupClientPKIInfrastructure(a_pSettings,
a_szHostname,
UACLIENT_APPLICATION_URI,
UACLIENT_APPLICATION_NAME);
OpcUa_GotoErrorIfBad(uStatus);
#endif
OpcUa_String_Initialize(&sampleDiscovery.InitialDiscoveryUrl);
OpcUa_String_Initialize(&sampleDiscovery.DiscoveryUrl);
sampleDiscovery.pDiscovery = OpcUa_Null;
OpcUa_List_Initialize(&sampleDiscovery.lstDiscoveryUrls);
OpcUa_List_Initialize(&sampleDiscovery.lstEndpoints);
OpcUa_GotoErrorIfBad(uStatus);
bClientInitialized = OpcUa_True;
#if OPCUA_TRACE_ENABLE && UABASE_USE_FILESYSTEM
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
#endif
OpcUa_GotoErrorIfBad(uStatus);
uStatus = UaClient_Discovery_Create(&sampleDiscovery.pDiscovery);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_MemSet(&sessionCallback, 0, sizeof(sessionCallback));
sessionCallback.pfConnectionStatusChanged_CB = Sample_ConnectionStatusChanged_CB;
sessionCallback.pfConnectError_CB = Sample_ConnectError_CB;
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
if (a_szUrl == OpcUa_Null || OpcUa_StrLenA(a_szUrl) <= 0)
{
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
if (uStatus == OpcUa_UncertainSubstituteValue)
{
OpcUa_GotoErrorIfBad(uStatus);
}
}
else
{
uStatus = OpcUa_String_AttachCopy(&sampleDiscovery.InitialDiscoveryUrl, a_szUrl);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
}
uStatus = OpcUa_String_CopyTo(&sampleDiscovery.InitialDiscoveryUrl, &sampleDiscovery.DiscoveryUrl);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
if (OpcUa_StrCmpA(szValue, "Anonymous") == 0)
{
}
else if (OpcUa_StrCmpA(szValue, "UserName") == 0)
{
OpcUa_String_Initialize(&pSession->UserToken.Token.UserName.User);
OpcUa_String_Initialize(&pSession->UserToken.Token.UserName.Password);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
}
else if (OpcUa_StrCmpA(szValue, "Certificate") == 0)
{
#if defined(OPCUA_P_PKI_TYPE_OPENSSL)
OpcUa_PKIProvider PKIProvider;
OpcUa_CertificateStoreConfiguration PKIConfig;
OpcUa_Handle hCertificateStore = OpcUa_Null;
OpcUa_MemSet(&PKIProvider, 0, sizeof(PKIProvider));
OpcUa_CertificateStoreConfiguration_Initialize(&PKIConfig);
OpcUa_ByteString_Initialize(&pSession->UserToken.Token.X509.UserCertificate);
OpcUa_Key_Initialize(&pSession->UserToken.Token.X509.UserPrivateKey);
PKIConfig.strPkiType = (char*)OPCUA_P_PKI_TYPE_OPENSSL;
OpcUa_GotoErrorIfBad(uStatus);
PKIConfig.strTrustedCertificateListLocation = szValue;
uStatus = OpcUa_PKIProvider_Create(&PKIConfig, &PKIProvider);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = PKIProvider.OpenCertificateStore(&PKIProvider,
&hCertificateStore);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = PKIProvider.LoadCertificate(&PKIProvider,
szValue,
hCertificateStore,
&pSession->UserToken.Token.X509.UserCertificate);
OpcUa_GotoErrorIfBad(uStatus);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = PKIProvider.LoadPrivateKey(szValue,
OpcUa_Crypto_Encoding_PEM,
OpcUa_Null,
&pSession->UserToken.Token.X509.UserPrivateKey);
OpcUa_GotoErrorIfBad(uStatus);
uStatus = PKIProvider.CloseCertificateStore(&PKIProvider, &hCertificateStore);
OpcUa_GotoErrorIfBad(uStatus);
#else
printf("Cannot use certificate tokens without OpenSSL\n");
OpcUa_GotoErrorWithStatus(OpcUa_BadConfigurationError);
#endif
}
OpcUa_GotoErrorIfBad(uStatus);
{
switch (clientContext.State)
{
case State_Idle:
sampleDiscovery.pUserData = &clientContext;
OpcUa_Null,
&sampleDiscovery.DiscoveryUrl,
0,
OpcUa_Null,
0,
OpcUa_Null,
Sample_FindServers_CB,
&sampleDiscovery);
OpcUa_GotoErrorIfBad(uStatus);
clientContext.State = State_FindServers;
break;
case State_FindServersDone:
uNoOfDiscoveryUrls = 0;
uNoOfEndpoints = 0;
OpcUa_List_GetNumberOfElements(&sampleDiscovery.lstDiscoveryUrls, &uNoOfDiscoveryUrls);
OpcUa_List_GetNumberOfElements(&sampleDiscovery.lstEndpoints, &uNoOfEndpoints);
if (uNoOfDiscoveryUrls > 0 && sampleDiscovery.pDiscovery->Connected == OpcUa_False)
{
pDiscoveryUrl = OpcUa_List_RemoveFirstElement(&sampleDiscovery.lstDiscoveryUrls);
OpcUa_String_Clear(&sampleDiscovery.DiscoveryUrl);
sampleDiscovery.DiscoveryUrl = *pDiscoveryUrl;
OpcUa_Free(pDiscoveryUrl);
OpcUa_Null,
&sampleDiscovery.DiscoveryUrl,
0,
OpcUa_Null,
0,
OpcUa_Null,
Sample_GetEndpoints_CB,
&sampleDiscovery);
OpcUa_GotoErrorIfBad(uStatus);
}
OpcUa_GotoErrorIfBad(uStatus);
clientContext.State = State_GetEndpoints;
break;
case State_GetEndpointsDone:
uNoOfDiscoveryUrls = 0;
uNoOfEndpoints = 0;
OpcUa_List_GetNumberOfElements(&sampleDiscovery.lstDiscoveryUrls, &uNoOfDiscoveryUrls);
OpcUa_List_GetNumberOfElements(&sampleDiscovery.lstEndpoints, &uNoOfEndpoints);
if (uNoOfDiscoveryUrls == 0 && uNoOfEndpoints > 0 && sampleDiscovery.pDiscovery->Connected == OpcUa_False)
{
OpcUa_UInt32 i = 0;
int iChosen = -1;
OpcUa_String_CopyTo(&sampleDiscovery.InitialDiscoveryUrl, &sampleDiscovery.DiscoveryUrl);
printf("Select one of the following endpoints by pressing the according key:\n");
OpcUa_List_ResetCurrent(&sampleDiscovery.lstEndpoints);
pEndpoint = OpcUa_List_GetCurrentElement(&sampleDiscovery.lstEndpoints);
while (pEndpoint)
{
printf("[%u]:\n", i);
printf(
" EndpointUrl: %s\n", OpcUa_String_GetRawString(&pEndpoint->
EndpointUrl));
printf(" SecurityMode: %s\n", szSecurityMode);
printf(
" SecurityMode: %s\n", OpcUa_String_GetRawString(&pEndpoint->
SecurityPolicyUri));
pEndpoint = OpcUa_List_GetNextElement(&sampleDiscovery.lstEndpoints);
i++;
}
while (iChosen == -1)
{
iChosen = _getch() - '0';
if (iChosen >= 0 && iChosen < (int)uNoOfEndpoints)
{
i = 0;
OpcUa_List_ResetCurrent(&sampleDiscovery.lstEndpoints);
pEndpoint = OpcUa_List_GetCurrentElement(&sampleDiscovery.lstEndpoints);
while (pEndpoint)
{
if (i == (OpcUa_UInt32)iChosen)
{
printf("Using endpoint #%i\n", i);
OpcUa_EndpointDescription_Initialize(pEndpoint);
#if OPCUA_SUPPORT_PKI
OpcUa_String_FromCString(OpcUa_SecurityPolicy_None),
OPCUA_STRING_LENDONTCARE,
OpcUa_False) != 0)
{
if (OpcUa_IsBad(uStatus))
{
UaClient_TrustCertificate(&pClientConfiguration->
PkiConfig,
printf("\n");
printf("Stored server certificate in the client trust list\n");
printf("Make sure the client certificate is in server trust list\n\n");
}
}
#endif
if (a_szUrl != OpcUa_Null && OpcUa_StrLenA(a_szUrl) > 0)
{
OpcUa_GotoErrorIfBad(uStatus);
}
}
else
{
OpcUa_EndpointDescription_Clear(pEndpoint);
}
OpcUa_Free(pEndpoint);
pEndpoint = OpcUa_List_GetNextElement(&sampleDiscovery.lstEndpoints);
i++;
}
OpcUa_List_Clear(&sampleDiscovery.lstEndpoints);
}
else
{
printf("Invalid choice, please try again\n");
iChosen = -1;
}
}
}
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "UA Client: Connecting to %s ...\n", SERVER_ENDPOINT_URL);
OpcUa_GotoErrorIfBad(uStatus);
clientContext.State = State_Connect;
break;
case State_Connected:
OpcUa_GotoErrorIfBad(uStatus);
clientContext.State = State_Disconnect;
break;
case State_Disconnected:
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "Sample successfully completed. Terminating now.\n");
bComplete = OpcUa_True;
break;
case State_Error:
if (OpcUa_IsBad(uStatus) && uStatus != OpcUa_BadInvalidState) { OpcUa_GotoError; }
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "An error occured. Terminating now.\n");
bComplete = OpcUa_True;
break;
default:
break;
}
if (OpcUa_IsBad(uStatus))
{
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "UaBase_DoCom failed (0x%08x)\n", uStatus);
bComplete = OpcUa_True;
}
}
UaClient_Discovery_Delete(&sampleDiscovery.pDiscovery);
OpcUa_List_Clear(&sampleDiscovery.lstDiscoveryUrls);
OpcUa_List_Clear(&sampleDiscovery.lstEndpoints);
OpcUa_String_Clear(&sampleDiscovery.InitialDiscoveryUrl);
OpcUa_String_Clear(&sampleDiscovery.DiscoveryUrl);
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "UA Client: Main stopped\n");
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if (pSession)
if (bClientInitialized != OpcUa_False)
{
UaClient_Discovery_Delete(&sampleDiscovery.pDiscovery);
OpcUa_List_Clear(&sampleDiscovery.lstDiscoveryUrls);
OpcUa_List_Clear(&sampleDiscovery.lstEndpoints);
OpcUa_String_Clear(&sampleDiscovery.InitialDiscoveryUrl);
OpcUa_String_Clear(&sampleDiscovery.DiscoveryUrl);
}
OpcUa_Trace(OPCUA_TRACE_LEVEL_WARNING, "UA Client: Main stopped due ERROR! (0x%08x)\n", uStatus);
OpcUa_FinishErrorHandling;
}
int main(void)
{
int ret = EXIT_SUCCESS;
OpcUa_Handle hProxyStubPlatformLayer = OpcUa_Null;
OpcUa_ProxyStubConfiguration proxyStubConfiguration;
#if defined(WIN32)
char szConfigurationFile[UABASE_PATH_MAX] = "client_settings.ini";
#else
char szConfigurationFile[UABASE_PATH_MAX] = "client_settings.conf";
#endif
char szHostname[256] = "";
char szUrl[256] = "";
uStatus = InitializeOpcUaStack(&hProxyStubPlatformLayer, &proxyStubConfiguration);
if ( OpcUa_IsNotGood(uStatus) )
{
return EXIT_FAILURE;
}
if (OpcUa_IsNotGood(uStatus))
{
printf("Could not open configuration file '%s'\n", szConfigurationFile);
CleanupOpcUaStack(&hProxyStubPlatformLayer);
exit(EXIT_FAILURE);
}
GetFQHostname(szHostname, sizeof(szHostname));
uStatus = ClientMain(&g_settings, szHostname, szUrl);
if (OpcUa_IsNotGood(uStatus))
{
ret = EXIT_FAILURE;
}
uStatus = CleanupOpcUaStack(&hProxyStubPlatformLayer);
if ( OpcUa_IsNotGood(uStatus) )
{
ret = EXIT_FAILURE;
}
return ret;
}