static void
variables_variants(void) {
/* Set a scalar value */
UA_Variant v;
UA_Int32 i = 42;
UA_Variant_setScalar(&v, &i, &UA_TYPES[UA_TYPES_INT32]);
/* Make a copy */
UA_Variant v2;
UA_Variant_copy(&v, &v2);
UA_Variant_deleteMembers(&v2);
/* Set an array value */
UA_Variant v3;
UA_Double d[9] = {1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0};
UA_Variant_setArrayCopy(&v3, d, 9, &UA_TYPES[UA_TYPES_DOUBLE]);
/* Set array dimensions */
v3.arrayDimensions = (UA_UInt32 *)UA_Array_new(2, &UA_TYPES[UA_TYPES_UINT32]);
v3.arrayDimensionsSize = 2;
v3.arrayDimensions[0] = 3;
v3.arrayDimensions[1] = 3;
UA_Variant_deleteMembers(&v3);
}
UA_StatusCode
UA_Server_processServiceOperations(UA_Server *server, UA_Session *session,
UA_ServiceOperation operationCallback,
void *context, const size_t *requestOperations,
const UA_DataType *requestOperationsType,
size_t *responseOperations,
const UA_DataType *responseOperationsType) {
size_t ops = *requestOperations;
if(ops == 0)
return UA_STATUSCODE_BADNOTHINGTODO;
/* No padding after size_t */
void **respPos = (void**)((uintptr_t)responseOperations + sizeof(size_t));
*respPos = UA_Array_new(ops, responseOperationsType);
if(!(*respPos))
return UA_STATUSCODE_BADOUTOFMEMORY;
*responseOperations = ops;
uintptr_t respOp = (uintptr_t)*respPos;
/* No padding after size_t */
uintptr_t reqOp = *(uintptr_t*)((uintptr_t)requestOperations + sizeof(size_t));
for(size_t i = 0; i < ops; i++) {
operationCallback(server, session, context, (void*)reqOp, (void*)respOp);
reqOp += requestOperationsType->memSize;
respOp += responseOperationsType->memSize;
}
return UA_STATUSCODE_GOOD;
}
UA_Int32 UA_SecureConversationMessageFooter_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_SecureConversationMessageFooter* dst) {
UA_Int32 retval = UA_SUCCESS;
retval |= UA_Int32_decodeBinary(src,pos,&(dst->paddingSize)); // decode size
retval |= UA_Array_new((void***)&dst->padding,dst->paddingSize, UA_BYTE);
retval |= UA_Array_decodeBinary(src,dst->paddingSize, UA_BYTE,pos,(void *** const) &dst->padding);
retval |= UA_Byte_decodeBinary(src,pos,&(dst->signature));
return retval;
}
static UA_Int64 sendReadRequest(ConnectionInfo *connectionInfo, UA_Int32 nodeIds_size,UA_NodeId* nodeIds){
/*UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber, UA_UInt32 requestId,
UA_NodeId authenticationToken, UA_Int32 nodeIds_size,UA_NodeId* nodeIds) {
*/
UA_ByteString *message = UA_ByteString_new();
UA_ByteString_newMembers(message, 65536);
UA_UInt32 tmpChannelId = connectionInfo->channelId;
size_t offset = 0;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_NodeId type;
type.identifier.numeric = 631;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_ReadRequest rq;
UA_ReadRequest_init(&rq);
rq.maxAge = 0;
rq.nodesToRead = UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], nodeIds_size);
rq.nodesToReadSize = 1;
for(UA_Int32 i=0;i<nodeIds_size;i++) {
UA_ReadValueId_init(&(rq.nodesToRead[i]));
rq.nodesToRead[i].attributeId = 6; //WriteMask
UA_NodeId_init(&(rq.nodesToRead[i].nodeId));
rq.nodesToRead[i].nodeId = nodeIds[i];
UA_QualifiedName_init(&(rq.nodesToRead[0].dataEncoding));
}
rq.requestHeader.timeoutHint = 10000;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.authenticationToken = connectionInfo->authenticationToken;
rq.timestampsToReturn = 0x03;
rq.requestHeader.requestHandle = 1 + connectionInfo->sequenceHdr.requestId;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_ReadRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr,message,&offset);
UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->tokenId, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.sequenceNumber, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.requestId, message, &offset);
UA_NodeId_encodeBinary(&type,message,&offset);
UA_ReadRequest_encodeBinary(&rq, message, &offset);
UA_DateTime tic = UA_DateTime_now();
UA_Int32 sendret = send(connectionInfo->socket, message->data, offset, 0);
UA_Array_delete(rq.nodesToRead, &UA_TYPES[UA_TYPES_READVALUEID], nodeIds_size);
UA_ByteString_delete(message);
if (sendret < 0) {
printf("send readrequest failed");
return 1;
}
return tic;
}
void Service_Write(UA_Server *server, UA_Session *session,
const UA_WriteRequest *request, UA_WriteResponse *response) {
UA_assert(server != UA_NULL && session != UA_NULL && request != UA_NULL && response != UA_NULL);
UA_StatusCode retval = UA_Array_new((void**)&response->results, request->nodesToWriteSize, &UA_TYPES[UA_STATUSCODE]);
if(retval) {
response->responseHeader.serviceResult = retval;
return;
}
response->resultsSize = request->nodesToWriteSize;
for(UA_Int32 i = 0;i < request->nodesToWriteSize;i++)
response->results[i] = Service_Write_writeNode(server, &request->nodesToWrite[i]);
}
void Service_Write(UA_Server *server, UA_Session *session, const UA_WriteRequest *request,
UA_WriteResponse *response) {
UA_assert(server != UA_NULL && session != UA_NULL && request != UA_NULL && response != UA_NULL);
if(request->nodesToWriteSize <= 0){
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
response->results = UA_Array_new(&UA_TYPES[UA_TYPES_STATUSCODE], request->nodesToWriteSize);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
#ifdef UA_EXTERNAL_NAMESPACES
#ifdef NO_ALLOCA
UA_Boolean isExternal[request->nodesToWriteSize];
UA_UInt32 indices[request->nodesToWriteSize];
#else
UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * request->nodesToWriteSize);
UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * request->nodesToWriteSize);
#endif /*NO_ALLOCA */
UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean)*request->nodesToWriteSize);
for(size_t j = 0; j < server->externalNamespacesSize; j++) {
UA_UInt32 indexSize = 0;
for(UA_Int32 i = 0; i < request->nodesToWriteSize; i++) {
if(request->nodesToWrite[i].nodeId.namespaceIndex !=
server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indexSize] = i;
indexSize++;
}
if(indexSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->writeNodes(ens->ensHandle, &request->requestHeader, request->nodesToWrite,
indices, indexSize, response->results, response->diagnosticInfos);
}
#endif
response->resultsSize = request->nodesToWriteSize;
for(UA_Int32 i = 0;i < request->nodesToWriteSize;i++) {
#ifdef UA_EXTERNAL_NAMESPACES
if(!isExternal[i])
#endif
response->results[i] = writeValue(server, &request->nodesToWrite[i]);
}
}
void Service_AddNodes(UA_Server *server, UA_Session *session, const UA_AddNodesRequest *request,
UA_AddNodesResponse *response) {
if(request->nodesToAddSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
size_t size = request->nodesToAddSize;
response->results = UA_Array_new(size, &UA_TYPES[UA_TYPES_ADDNODESRESULT]);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
#ifdef UA_EXTERNAL_NAMESPACES
#ifdef _MSVC_VER
UA_Boolean *isExternal = UA_alloca(size);
UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32)*size);
#else
UA_Boolean isExternal[size];
UA_UInt32 indices[size];
#endif
memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
for(size_t j = 0; j <server->externalNamespacesSize; j++) {
size_t indexSize = 0;
for(size_t i = 0;i < size;i++) {
if(request->nodesToAdd[i].requestedNewNodeId.nodeId.namespaceIndex !=
server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indexSize] = i;
indexSize++;
}
if(indexSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->addNodes(ens->ensHandle, &request->requestHeader, request->nodesToAdd,
indices, indexSize, response->results, response->diagnosticInfos);
}
#endif
response->resultsSize = size;
for(size_t i = 0; i < size; i++) {
#ifdef UA_EXTERNAL_NAMESPACES
if(!isExternal[i])
#endif
Service_AddNodes_single(server, session, &request->nodesToAdd[i], &response->results[i]);
}
}
static void setupSelectClauses(void) {
// check for severity (set manually), message (set manually), eventType (automatic) and sourceNode (automatic)
selectClauses = (UA_SimpleAttributeOperand *)
UA_Array_new(nSelectClauses, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
if (!selectClauses)
return;
for (size_t i = 0; i < nSelectClauses; ++i) {
UA_SimpleAttributeOperand_init(&selectClauses[i]);
selectClauses[i].typeDefinitionId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE);
selectClauses[i].browsePathSize = 1;
selectClauses[i].attributeId = UA_ATTRIBUTEID_VALUE;
selectClauses[i].browsePath = (UA_QualifiedName *)
UA_Array_new(selectClauses[i].browsePathSize, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
if (!selectClauses[i].browsePathSize) {
UA_Array_delete(selectClauses, nSelectClauses, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
}
}
selectClauses[0].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "Severity");
selectClauses[1].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "Message");
selectClauses[2].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "EventType");
selectClauses[3].browsePath[0] = UA_QUALIFIEDNAME_ALLOC(0, "SourceNode");
}
END_TEST
START_TEST(Service_TranslateBrowsePathsToNodeIds) {
UA_Client *client = UA_Client_new(UA_ClientConfig_default);
UA_StatusCode retVal = UA_Client_connect(client, "opc.tcp://localhost:4840");
ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD);
// Just for testing we want to translate the following path to its corresponding node id
// /Objects/Server/ServerStatus/State
// Equals the following node IDs:
// /85/2253/2256/2259
#define BROWSE_PATHS_SIZE 3
char *paths[BROWSE_PATHS_SIZE] = {"Server", "ServerStatus", "State"};
UA_UInt32 ids[BROWSE_PATHS_SIZE] = {UA_NS0ID_ORGANIZES, UA_NS0ID_HASCOMPONENT, UA_NS0ID_HASCOMPONENT};
UA_BrowsePath browsePath;
UA_BrowsePath_init(&browsePath);
browsePath.startingNode = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
browsePath.relativePath.elements = (UA_RelativePathElement*)UA_Array_new(BROWSE_PATHS_SIZE, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]);
browsePath.relativePath.elementsSize = BROWSE_PATHS_SIZE;
for(size_t i = 0; i < BROWSE_PATHS_SIZE; i++) {
UA_RelativePathElement *elem = &browsePath.relativePath.elements[i];
elem->referenceTypeId = UA_NODEID_NUMERIC(0, ids[i]);
elem->targetName = UA_QUALIFIEDNAME_ALLOC(0, paths[i]);
}
UA_TranslateBrowsePathsToNodeIdsRequest request;
UA_TranslateBrowsePathsToNodeIdsRequest_init(&request);
request.browsePaths = &browsePath;
request.browsePathsSize = 1;
UA_TranslateBrowsePathsToNodeIdsResponse response = UA_Client_Service_translateBrowsePathsToNodeIds(client, request);
ck_assert_int_eq(response.responseHeader.serviceResult, UA_STATUSCODE_GOOD);
ck_assert_int_eq(response.resultsSize, 1);
ck_assert_int_eq(response.results[0].targetsSize, 1);
ck_assert_int_eq(response.results[0].targets[0].targetId.nodeId.identifierType, UA_NODEIDTYPE_NUMERIC);
ck_assert_int_eq(response.results[0].targets[0].targetId.nodeId.identifier.numeric, UA_NS0ID_SERVER_SERVERSTATUS_STATE);
UA_BrowsePath_deleteMembers(&browsePath);
UA_TranslateBrowsePathsToNodeIdsResponse_deleteMembers(&response);
retVal = UA_Client_disconnect(client);
ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD);
UA_Client_delete(client);
}
void Service_Write(UA_Server *server, UA_Session *session, const UA_WriteRequest *request,
UA_WriteResponse *response) {
UA_assert(server != NULL && session != NULL && request != NULL && response != NULL);
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SESSION,
"Processing WriteRequest for Session (ns=%i,i=%i)",
session->sessionId.namespaceIndex, session->sessionId.identifier.numeric);
if(request->nodesToWriteSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
response->results = UA_Array_new(request->nodesToWriteSize, &UA_TYPES[UA_TYPES_STATUSCODE]);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
#ifdef UA_ENABLE_EXTERNAL_NAMESPACES
UA_Boolean isExternal[request->nodesToWriteSize];
UA_UInt32 indices[request->nodesToWriteSize];
memset(isExternal, UA_FALSE, sizeof(UA_Boolean)*request->nodesToWriteSize);
for(size_t j = 0; j < server->externalNamespacesSize; j++) {
UA_UInt32 indexSize = 0;
for(UA_Int32 i = 0; i < request->nodesToWriteSize; i++) {
if(request->nodesToWrite[i].nodeId.namespaceIndex !=
server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indexSize] = i;
indexSize++;
}
if(indexSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->writeNodes(ens->ensHandle, &request->requestHeader, request->nodesToWrite,
indices, indexSize, response->results, response->diagnosticInfos);
}
#endif
response->resultsSize = request->nodesToWriteSize;
for(size_t i = 0;i < request->nodesToWriteSize;i++) {
#ifdef UA_ENABLE_EXTERNAL_NAMESPACES
if(!isExternal[i])
#endif
response->results[i] = Service_Write_single(server, session, &request->nodesToWrite[i]);
}
}
void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
UA_ReadResponse *response) {
if(request->nodesToReadSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
UA_StatusCode retval = UA_Array_new((void**)&response->results, request->nodesToReadSize, &UA_TYPES[UA_DATAVALUE]);
if(retval) {
response->responseHeader.serviceResult = retval;
return;
}
response->resultsSize = request->nodesToReadSize;
for(UA_Int32 i = 0;i < response->resultsSize;i++)
response->results[i] = service_read_node(server, &request->nodesToRead[i]);
}
void Service_Call(UA_Server *server, UA_Session *session, const UA_CallRequest *request,
UA_CallResponse *response) {
if(request->methodsToCallSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
response->results = UA_Array_new(&UA_TYPES[UA_TYPES_CALLMETHODRESULT],
request->methodsToCallSize);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = request->methodsToCallSize;
for(UA_Int32 i = 0; i < request->methodsToCallSize;i++)
callMethod(server, session, &request->methodsToCall[i], &response->results[i]);
}
void Service_Call(UA_Server *server, UA_Session *session, const UA_CallRequest *request,
UA_CallResponse *response) {
UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing CallRequest");
if(request->methodsToCallSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
response->results = UA_Array_new(request->methodsToCallSize, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = request->methodsToCallSize;
for(size_t i = 0; i < request->methodsToCallSize;i++)
Service_Call_single(server, session, &request->methodsToCall[i], &response->results[i]);
}
static void
variables_basic(void) {
/* Int32 */
UA_Int32 i = 5;
UA_Int32 j;
UA_Int32_copy(&i, &j);
UA_Int32 *ip = UA_Int32_new();
UA_Int32_copy(&i, ip);
UA_Int32_delete(ip);
/* String */
UA_String s;
UA_String_init(&s); /* _init zeroes out the entire memory of the datatype */
char *test = "test";
s.length = strlen(test);
s.data = (UA_Byte*)test;
UA_String s2;
UA_String_copy(&s, &s2);
UA_String_deleteMembers(&s2); /* Copying heap-allocated the dynamic content */
UA_String s3 = UA_STRING("test2");
UA_String s4 = UA_STRING_ALLOC("test2"); /* Copies the content to the heap */
UA_Boolean eq = UA_String_equal(&s3, &s4);
UA_String_deleteMembers(&s4);
if(!eq)
return;
/* Structured Type */
UA_ReadRequest rr;
UA_init(&rr, &UA_TYPES[UA_TYPES_READREQUEST]); /* Generic method */
UA_ReadRequest_init(&rr); /* Shorthand for the previous line */
rr.requestHeader.timestamp = UA_DateTime_now(); /* Members of a structure */
rr.nodesToRead = (UA_ReadValueId *)UA_Array_new(5, &UA_TYPES[UA_TYPES_READVALUEID]);
rr.nodesToReadSize = 5; /* Array size needs to be made known */
UA_ReadRequest *rr2 = UA_ReadRequest_new();
UA_copy(&rr, rr2, &UA_TYPES[UA_TYPES_READREQUEST]);
UA_ReadRequest_deleteMembers(&rr);
UA_ReadRequest_delete(rr2);
}
static UA_StatusCode
GetEndpoints(UA_Client *client, const UA_String* endpointUrl,
size_t* endpointDescriptionsSize,
UA_EndpointDescription** endpointDescriptions,
const char* filterTransportProfileUri) {
UA_GetEndpointsRequest request;
UA_GetEndpointsRequest_init(&request);
//request.requestHeader.authenticationToken = client->authenticationToken;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
request.endpointUrl = *endpointUrl; // assume the endpointurl outlives the service call
if (filterTransportProfileUri) {
request.profileUrisSize = 1;
request.profileUris = (UA_String*)UA_malloc(sizeof(UA_String));
request.profileUris[0] = UA_String_fromChars(filterTransportProfileUri);
}
UA_GetEndpointsResponse response;
UA_GetEndpointsResponse_init(&response);
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST],
&response, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
if (filterTransportProfileUri) {
UA_Array_delete(request.profileUris, request.profileUrisSize, &UA_TYPES[UA_TYPES_STRING]);
}
ck_assert_uint_eq(response.responseHeader.serviceResult, UA_STATUSCODE_GOOD);
*endpointDescriptionsSize = response.endpointsSize;
*endpointDescriptions =
(UA_EndpointDescription*)UA_Array_new(response.endpointsSize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
for(size_t i=0;i<response.endpointsSize;i++) {
UA_EndpointDescription_init(&(*endpointDescriptions)[i]);
UA_EndpointDescription_copy(&response.endpoints[i], &(*endpointDescriptions)[i]);
}
UA_GetEndpointsResponse_deleteMembers(&response);
return UA_STATUSCODE_GOOD;
}
void Service_CreateMonitoredItems(UA_Server *server, UA_Session *session,
const UA_CreateMonitoredItemsRequest *request,
UA_CreateMonitoredItemsResponse *response) {
if(request->itemsToCreateSize <= 0)
return;
//mock up
response->resultsSize = request->itemsToCreateSize;
UA_Array_new((void**)&response->results, response->resultsSize, &UA_[UA_MONITOREDITEMCREATERESULT]);
for(int i = 0;request->itemsToCreateSize > 0 && i < request->itemsToCreateSize;i++) {
//FIXME: search the object in the namespace
if(request->itemsToCreate[i].itemToMonitor.nodeId.identifier.numeric == 2253) { // server
response->results[i].statusCode = UA_STATUSCODE_GOOD;
response->results[i].monitoredItemId = 1;
response->results[i].revisedSamplingInterval = 4294967295;
response->results[i].revisedQueueSize = 0;
continue;
} else {
// response->results[i]->statusCode = UA_STATUSCODE_BAD_NODEIDUNKNOWN;
response->results[i].statusCode = -1;
}
}
}
void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
const UA_CreateSessionRequest *request,
UA_CreateSessionResponse *response) {
if(channel == NULL) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR;
return;
}
if(channel->connection == NULL) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR;
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel, "Trying to create session");
if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN ||
channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) {
if(!UA_ByteString_equal(&request->clientCertificate,
&channel->remoteCertificate)) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADCERTIFICATEINVALID;
return;
}
}
if(channel->securityToken.channelId == 0) {
response->responseHeader.serviceResult =
UA_STATUSCODE_BADSECURECHANNELIDINVALID;
return;
}
if(!UA_ByteString_equal(&channel->securityPolicy->policyUri,
&UA_SECURITY_POLICY_NONE_URI) &&
request->clientNonce.length < 32) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNONCEINVALID;
return;
}
////////////////////// TODO: Compare application URI with certificate uri (decode certificate)
/* Allocate the response */
response->serverEndpoints = (UA_EndpointDescription*)
UA_Array_new(server->config.endpointsSize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
if(!response->serverEndpoints) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->serverEndpointsSize = server->config.endpointsSize;
/* Copy the server's endpointdescriptions into the response */
for(size_t i = 0; i < server->config.endpointsSize; ++i)
response->responseHeader.serviceResult |=
UA_EndpointDescription_copy(&server->config.endpoints[0].endpointDescription,
&response->serverEndpoints[i]);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD)
return;
/* Mirror back the endpointUrl */
for(size_t i = 0; i < response->serverEndpointsSize; ++i) {
UA_String_deleteMembers(&response->serverEndpoints[i].endpointUrl);
UA_String_copy(&request->endpointUrl,
&response->serverEndpoints[i].endpointUrl);
}
UA_Session *newSession;
response->responseHeader.serviceResult =
UA_SessionManager_createSession(&server->sessionManager,
channel, request, &newSession);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Processing CreateSessionRequest failed");
return;
}
/* Fill the session with more information */
newSession->maxResponseMessageSize = request->maxResponseMessageSize;
newSession->maxRequestMessageSize =
channel->connection->localConf.maxMessageSize;
response->responseHeader.serviceResult |=
UA_ApplicationDescription_copy(&request->clientDescription,
&newSession->clientDescription);
/* Prepare the response */
response->sessionId = newSession->sessionId;
response->revisedSessionTimeout = (UA_Double)newSession->timeout;
response->authenticationToken = newSession->authenticationToken;
response->responseHeader.serviceResult =
UA_String_copy(&request->sessionName, &newSession->sessionName);
if(server->config.endpointsSize > 0)
response->responseHeader.serviceResult |=
UA_ByteString_copy(&channel->securityPolicy->localCertificate,
&response->serverCertificate);
/* Create a signed nonce */
response->responseHeader.serviceResult =
nonceAndSignCreateSessionResponse(server, channel, newSession, request, response);
/* Failure -> remove the session */
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager, &newSession->authenticationToken);
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Session " UA_PRINTF_GUID_FORMAT " created",
UA_PRINTF_GUID_DATA(newSession->sessionId.identifier.guid));
}
void
Service_Call_single(UA_Server *server, UA_Session *session, const UA_CallMethodRequest *request,
UA_CallMethodResult *result) {
/* Verify method/object relations. Object must have a hasComponent reference to the method node. */
UA_Boolean found = false;
UA_NodeId hasComponentNodeId = UA_NODEID_NUMERIC(0,UA_NS0ID_HASCOMPONENT);
result->statusCode = isNodeInTree(server->nodestore, &request->methodId, &request->objectId,
&hasComponentNodeId, 1, 1, &found);
if(!found)
result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
if(result->statusCode != UA_STATUSCODE_GOOD)
return;
/* Get/verify the method node */
const UA_MethodNode *methodCalled =
(const UA_MethodNode*)UA_NodeStore_get(server->nodestore, &request->methodId);
if(!methodCalled) {
result->statusCode = UA_STATUSCODE_BADMETHODINVALID;
return;
}
if(methodCalled->nodeClass != UA_NODECLASS_METHOD) {
result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
return;
}
if(!methodCalled->executable || !methodCalled->userExecutable || !methodCalled->attachedMethod) {
result->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
return;
}
/* Get/verify the object node */
const UA_ObjectNode *withObject =
(const UA_ObjectNode*)UA_NodeStore_get(server->nodestore, &request->objectId);
if(!withObject) {
result->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
return;
}
if(withObject->nodeClass != UA_NODECLASS_OBJECT && withObject->nodeClass != UA_NODECLASS_OBJECTTYPE) {
result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
return;
}
/* Verify Input Argument count, types and sizes */
const UA_VariableNode *inputArguments = getArgumentsVariableNode(server, methodCalled, UA_STRING("InputArguments"));
if(!inputArguments) {
result->statusCode = UA_STATUSCODE_BADINVALIDARGUMENT;
return;
}
result->statusCode = argConformsToDefinition(server, inputArguments, request->inputArgumentsSize,
request->inputArguments);
if(result->statusCode != UA_STATUSCODE_GOOD)
return;
/* Allocate the output arguments */
const UA_VariableNode *outputArguments = getArgumentsVariableNode(server, methodCalled, UA_STRING("OutputArguments"));
if(!outputArguments) {
result->statusCode = UA_STATUSCODE_BADINTERNALERROR;
return;
}
result->outputArguments = UA_Array_new(outputArguments->value.variant.value.arrayLength, &UA_TYPES[UA_TYPES_VARIANT]);
if(!result->outputArguments) {
result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
result->outputArgumentsSize = outputArguments->value.variant.value.arrayLength;
/* Call the method */
result->statusCode = methodCalled->attachedMethod(methodCalled->methodHandle, withObject->nodeId,
request->inputArgumentsSize, request->inputArguments,
result->outputArgumentsSize, result->outputArguments);
/* TODO: Verify Output Argument count, types and sizes */
}
void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
const UA_CreateSessionRequest *request,
UA_CreateSessionResponse *response) {
if(channel->securityToken.channelId == 0) {
response->responseHeader.serviceResult =
UA_STATUSCODE_BADSECURECHANNELIDINVALID;
return;
}
/* Allocate the response */
response->serverEndpoints = (UA_EndpointDescription*)
UA_Array_new(server->config.endpoints.count,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
if(!response->serverEndpoints) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->serverEndpointsSize = server->config.endpoints.count;
/* Copy the server's endpointdescriptions into the response */
for(size_t i = 0; i < server->config.endpoints.count; ++i)
response->responseHeader.serviceResult |=
UA_EndpointDescription_copy(&server->config.endpoints.endpoints[0].endpointDescription,
&response->serverEndpoints[i]);
/* Mirror back the endpointUrl */
for(size_t i = 0; i < response->serverEndpointsSize; ++i) {
UA_String_deleteMembers(&response->serverEndpoints[i].endpointUrl);
UA_String_copy(&request->endpointUrl,
&response->serverEndpoints[i].endpointUrl);
}
UA_Session *newSession;
response->responseHeader.serviceResult =
UA_SessionManager_createSession(&server->sessionManager,
channel, request, &newSession);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Processing CreateSessionRequest failed");
return;
}
/* Fill the session with more information */
newSession->maxResponseMessageSize = request->maxResponseMessageSize;
newSession->maxRequestMessageSize =
channel->connection->localConf.maxMessageSize;
response->responseHeader.serviceResult |=
UA_ApplicationDescription_copy(&request->clientDescription,
&newSession->clientDescription);
/* Prepare the response */
response->sessionId = newSession->sessionId;
response->revisedSessionTimeout = (UA_Double)newSession->timeout;
response->authenticationToken = newSession->authenticationToken;
response->responseHeader.serviceResult =
UA_String_copy(&request->sessionName, &newSession->sessionName);
if(server->config.endpoints.count > 0)
response->responseHeader.serviceResult |=
UA_ByteString_copy(&server->config.endpoints.endpoints[0].endpointDescription.serverCertificate,
&response->serverCertificate);
/* Failure -> remove the session */
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager,
&newSession->authenticationToken);
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Session " UA_PRINTF_GUID_FORMAT " created",
UA_PRINTF_GUID_DATA(newSession->sessionId.identifier.guid));
}
static UA_StatusCode
updateHistory(UA_PerformUpdateType updateType, UA_DateTime *updateData, UA_StatusCode ** operationResults, size_t *operationResultsSize)
{
UA_UpdateDataDetails *details = UA_UpdateDataDetails_new();
details->performInsertReplace = updateType;
UA_NodeId_copy(&outNodeId, &details->nodeId);
int updateDataSize = -1;
while(updateData[++updateDataSize]);
fprintf(stderr, "updateHistory for %d values.\n", updateDataSize);
details->updateValuesSize = (size_t)updateDataSize;
details->updateValues = (UA_DataValue*)UA_Array_new(details->updateValuesSize, &UA_TYPES[UA_TYPES_DATAVALUE]);
for (size_t i = 0; i < details->updateValuesSize; ++i) {
UA_DataValue_init(&details->updateValues[i]);
details->updateValues[i].hasValue = true;
UA_Int64 d = updateType;
UA_Variant_setScalarCopy(&details->updateValues[i].value, &d, &UA_TYPES[UA_TYPES_INT64]);
details->updateValues[i].hasSourceTimestamp = true;
details->updateValues[i].sourceTimestamp = updateData[i];
details->updateValues[i].hasServerTimestamp = true;
details->updateValues[i].serverTimestamp = updateData[i];
details->updateValues[i].hasStatus = true;
details->updateValues[i].status = UA_STATUSCODE_GOOD;
}
UA_HistoryUpdateRequest request;
UA_HistoryUpdateRequest_init(&request);
request.historyUpdateDetailsSize = 1;
request.historyUpdateDetails = UA_ExtensionObject_new();
UA_ExtensionObject_init(request.historyUpdateDetails);
request.historyUpdateDetails[0].encoding = UA_EXTENSIONOBJECT_DECODED;
request.historyUpdateDetails[0].content.decoded.type = &UA_TYPES[UA_TYPES_UPDATEDATADETAILS];
request.historyUpdateDetails[0].content.decoded.data = details;
UA_HistoryUpdateResponse response;
UA_HistoryUpdateResponse_init(&response);
Service_HistoryUpdate(server, &server->adminSession, &request, &response);
UA_HistoryUpdateRequest_deleteMembers(&request);
UA_StatusCode ret = UA_STATUSCODE_GOOD;
if (response.responseHeader.serviceResult != UA_STATUSCODE_GOOD)
ret = response.responseHeader.serviceResult;
else if (response.resultsSize != 1)
ret = UA_STATUSCODE_BADUNEXPECTEDERROR;
else if (response.results[0].statusCode != UA_STATUSCODE_GOOD)
ret = response.results[0].statusCode;
else if (response.results[0].operationResultsSize != (size_t)updateDataSize)
ret = UA_STATUSCODE_BADUNEXPECTEDERROR;
else {
if (operationResults) {
*operationResultsSize = response.results[0].operationResultsSize;
ret = UA_Array_copy(response.results[0].operationResults, *operationResultsSize, (void**)operationResults, &UA_TYPES[UA_TYPES_STATUSCODE]);
} else {
for (size_t i = 0; i < response.results[0].operationResultsSize; ++i) {
if (response.results[0].operationResults[i] != UA_STATUSCODE_GOOD) {
ret = response.results[0].operationResults[i];
break;
}
}
}
}
UA_HistoryUpdateResponse_deleteMembers(&response);
return ret;
}
void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
UA_ReadResponse *response) {
if(request->nodesToReadSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
if(request->timestampsToReturn > 3){
response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
return;
}
size_t size = request->nodesToReadSize;
response->results = UA_Array_new(&UA_TYPES[UA_TYPES_DATAVALUE], size);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = size;
if(request->maxAge < 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
return;
}
/* ### Begin External Namespaces */
UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
for(UA_Int32 j = 0;j<server->externalNamespacesSize;j++) {
size_t indexSize = 0;
for(size_t i = 0;i < size;i++) {
if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indexSize] = i;
indexSize++;
}
if(indexSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
indices, indexSize, response->results, UA_FALSE, response->diagnosticInfos);
}
/* ### End External Namespaces */
for(size_t i = 0;i < size;i++) {
if(!isExternal[i])
readValue(server, request->timestampsToReturn, &request->nodesToRead[i], &response->results[i]);
}
#ifdef EXTENSION_STATELESS
if(session==&anonymousSession){
/* expiry header */
UA_ExtensionObject additionalHeader;
UA_ExtensionObject_init(&additionalHeader);
additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
UA_Variant variant;
UA_Variant_init(&variant);
variant.type = &UA_TYPES[UA_TYPES_DATETIME];
variant.arrayLength = request->nodesToReadSize;
UA_DateTime* expireArray = UA_NULL;
expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
variant.data = expireArray;
UA_ByteString str;
UA_ByteString_init(&str);
/*expires in 20 seconds*/
for(UA_Int32 i = 0;i < response->resultsSize;i++) {
expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
}
size_t offset = 0;
str.data = UA_malloc(UA_Variant_calcSizeBinary(&variant));
str.length = UA_Variant_calcSizeBinary(&variant);
UA_Variant_encodeBinary(&variant, &str, &offset);
additionalHeader.body = str;
response->responseHeader.additionalHeader = additionalHeader;
}
#endif
}
static void
setInformationModel(UA_Server *server) {
/* add a static variable node to the server */
UA_VariableAttributes myVar = UA_VariableAttributes_default;
myVar.description = UA_LOCALIZEDTEXT("en-US", "the answer");
myVar.displayName = UA_LOCALIZEDTEXT("en-US", "the answer");
myVar.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
myVar.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
myVar.valueRank = UA_VALUERANK_SCALAR;
UA_Int32 myInteger = 42;
UA_Variant_setScalar(&myVar.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
const UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
const UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_Server_addVariableNode(server, myIntegerNodeId, parentNodeId, parentReferenceNodeId,
myIntegerName, baseDataVariableType, myVar, NULL, NULL);
/* add a static variable that is readable but not writable*/
myVar = UA_VariableAttributes_default;
myVar.description = UA_LOCALIZEDTEXT("en-US", "the answer - not readable");
myVar.displayName = UA_LOCALIZEDTEXT("en-US", "the answer - not readable");
myVar.accessLevel = UA_ACCESSLEVELMASK_WRITE;
myVar.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
myVar.valueRank = UA_VALUERANK_SCALAR;
UA_Variant_setScalar(&myVar.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
const UA_QualifiedName myInteger2Name = UA_QUALIFIEDNAME(1, "the answer - not readable");
const UA_NodeId myInteger2NodeId = UA_NODEID_STRING(1, "the.answer.no.read");
UA_Server_addVariableNode(server, myInteger2NodeId, parentNodeId, parentReferenceNodeId,
myInteger2Name, baseDataVariableType, myVar, NULL, NULL);
/* add a variable that is not readable or writable for the current user */
myVar = UA_VariableAttributes_default;
myVar.description = UA_LOCALIZEDTEXT("en-US", "the answer - not current user");
myVar.displayName = UA_LOCALIZEDTEXT("en-US", "the answer - not current user");
myVar.accessLevel = UA_ACCESSLEVELMASK_WRITE;
myVar.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
myVar.valueRank = UA_VALUERANK_SCALAR;
myVar.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
UA_Variant_setScalar(&myVar.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
const UA_QualifiedName accessDeniedName = UA_QUALIFIEDNAME(1, "the answer - not current user");
UA_Server_addVariableNode(server, accessDenied, parentNodeId, parentReferenceNodeId,
accessDeniedName, baseDataVariableType, myVar, NULL, NULL);
/* add a variable with the datetime data source */
UA_DataSource dateDataSource;
dateDataSource.read = readTimeData;
dateDataSource.write = NULL;
UA_VariableAttributes v_attr = UA_VariableAttributes_default;
v_attr.description = UA_LOCALIZEDTEXT("en-US", "current time");
v_attr.displayName = UA_LOCALIZEDTEXT("en-US", "current time");
v_attr.accessLevel = UA_ACCESSLEVELMASK_READ;
v_attr.dataType = UA_TYPES[UA_TYPES_DATETIME].typeId;
v_attr.valueRank = UA_VALUERANK_SCALAR;
const UA_QualifiedName dateName = UA_QUALIFIEDNAME(1, "current time");
UA_Server_addDataSourceVariableNode(server, UA_NODEID_NUMERIC(1, 2345),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), dateName,
baseDataVariableType, v_attr, dateDataSource, NULL, NULL);
/* add a bytestring variable with some content */
myVar = UA_VariableAttributes_default;
myVar.description = UA_LOCALIZEDTEXT("", "");
myVar.displayName = UA_LOCALIZEDTEXT("", "example bytestring");
myVar.dataType = UA_TYPES[UA_TYPES_BYTESTRING].typeId;
myVar.valueRank = UA_VALUERANK_SCALAR;
myVar.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
UA_ByteString myByteString = UA_BYTESTRING("test123\0test123");
UA_Variant_setScalar(&myVar.value, &myByteString, &UA_TYPES[UA_TYPES_BYTESTRING]);
const UA_QualifiedName byteStringName = UA_QUALIFIEDNAME(1, "example bytestring");
UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "myByteString"),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), byteStringName,
baseDataVariableType, myVar, NULL, NULL);
/* Add HelloWorld method to the server */
#ifdef UA_ENABLE_METHODCALLS
/* Method with IO Arguments */
UA_Argument inputArguments;
UA_Argument_init(&inputArguments);
inputArguments.dataType = UA_TYPES[UA_TYPES_STRING].typeId;
inputArguments.description = UA_LOCALIZEDTEXT("en-US", "Say your name");
inputArguments.name = UA_STRING("Name");
inputArguments.valueRank = UA_VALUERANK_SCALAR; /* scalar argument */
UA_Argument outputArguments;
UA_Argument_init(&outputArguments);
outputArguments.arrayDimensionsSize = 0;
outputArguments.arrayDimensions = NULL;
outputArguments.dataType = UA_TYPES[UA_TYPES_STRING].typeId;
outputArguments.description = UA_LOCALIZEDTEXT("en-US", "Receive a greeting");
outputArguments.name = UA_STRING("greeting");
outputArguments.valueRank = UA_VALUERANK_SCALAR;
UA_MethodAttributes addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "Hello World");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, 62541),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "hello_world"), addmethodattributes,
&helloWorld, /* callback of the method node */
1, &inputArguments, 1, &outputArguments, NULL, NULL);
#endif
/* Add folders for demo information model */
#define DEMOID 50000
#define SCALARID 50001
#define ARRAYID 50002
#define MATRIXID 50003
#define DEPTHID 50004
UA_ObjectAttributes object_attr = UA_ObjectAttributes_default;
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Demo");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Demo");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_QUALIFIEDNAME(1, "Demo"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Scalar");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Scalar");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, SCALARID),
UA_NODEID_NUMERIC(1, DEMOID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "Scalar"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Array");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Array");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, ARRAYID),
UA_NODEID_NUMERIC(1, DEMOID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "Array"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Matrix");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Matrix");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, MATRIXID), UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_QUALIFIEDNAME(1, "Matrix"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
/* Fill demo nodes for each type*/
UA_UInt32 matrixDims[2] = {3, 3};
UA_UInt32 id = 51000; // running id in namespace 0
for(UA_UInt32 type = 0; type < UA_TYPES_DIAGNOSTICINFO; type++) {
if(type == UA_TYPES_VARIANT || type == UA_TYPES_DIAGNOSTICINFO)
continue;
UA_VariableAttributes attr = UA_VariableAttributes_default;
attr.dataType = UA_TYPES[type].typeId;
#ifndef UA_ENABLE_TYPENAMES
char name[15];
UA_snprintf(name, 15, "%02d", type);
attr.displayName = UA_LOCALIZEDTEXT("en-US", name);
UA_QualifiedName qualifiedName = UA_QUALIFIEDNAME(1, name);
#else
attr.displayName = UA_LOCALIZEDTEXT_ALLOC("en-US", UA_TYPES[type].typeName);
UA_QualifiedName qualifiedName = UA_QUALIFIEDNAME_ALLOC(1, UA_TYPES[type].typeName);
#endif
attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
attr.writeMask = UA_WRITEMASK_DISPLAYNAME | UA_WRITEMASK_DESCRIPTION;
attr.userWriteMask = UA_WRITEMASK_DISPLAYNAME | UA_WRITEMASK_DESCRIPTION;
/* add a scalar node for every built-in type */
attr.valueRank = UA_VALUERANK_SCALAR;
void *value = UA_new(&UA_TYPES[type]);
UA_Variant_setScalar(&attr.value, value, &UA_TYPES[type]);
UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, ++id),
UA_NODEID_NUMERIC(1, SCALARID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
qualifiedName, baseDataVariableType, attr, NULL, NULL);
UA_Variant_clear(&attr.value);
/* add an array node for every built-in type */
UA_UInt32 arrayDims = 0;
attr.valueRank = UA_VALUERANK_ONE_DIMENSION;
attr.arrayDimensions = &arrayDims;
attr.arrayDimensionsSize = 1;
UA_Variant_setArray(&attr.value, UA_Array_new(10, &UA_TYPES[type]), 10, &UA_TYPES[type]);
UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, ++id), UA_NODEID_NUMERIC(1, ARRAYID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), qualifiedName,
baseDataVariableType, attr, NULL, NULL);
UA_Variant_clear(&attr.value);
/* add an matrix node for every built-in type */
attr.valueRank = UA_VALUERANK_TWO_DIMENSIONS;
attr.arrayDimensions = matrixDims;
attr.arrayDimensionsSize = 2;
void *myMultiArray = UA_Array_new(9, &UA_TYPES[type]);
attr.value.arrayDimensions = (UA_UInt32 *)UA_Array_new(2, &UA_TYPES[UA_TYPES_INT32]);
attr.value.arrayDimensions[0] = 3;
attr.value.arrayDimensions[1] = 3;
attr.value.arrayDimensionsSize = 2;
attr.value.arrayLength = 9;
attr.value.data = myMultiArray;
attr.value.type = &UA_TYPES[type];
UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, ++id), UA_NODEID_NUMERIC(1, MATRIXID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), qualifiedName,
baseDataVariableType, attr, NULL, NULL);
UA_Variant_clear(&attr.value);
#ifdef UA_ENABLE_TYPENAMES
UA_LocalizedText_clear(&attr.displayName);
UA_QualifiedName_clear(&qualifiedName);
#endif
}
/* Add Integer and UInteger variables */
UA_VariableAttributes iattr = UA_VariableAttributes_default;
iattr.dataType = UA_NODEID_NUMERIC(0, UA_NS0ID_INTEGER);
iattr.displayName = UA_LOCALIZEDTEXT("en-US", "Integer");
iattr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
iattr.writeMask = UA_WRITEMASK_DISPLAYNAME | UA_WRITEMASK_DESCRIPTION;
iattr.userWriteMask = UA_WRITEMASK_DISPLAYNAME | UA_WRITEMASK_DESCRIPTION;
iattr.valueRank = UA_VALUERANK_SCALAR;
UA_QualifiedName iQualifiedName = UA_QUALIFIEDNAME(1, "integer");
UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "integer"),
UA_NODEID_NUMERIC(1, SCALARID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
iQualifiedName, baseDataVariableType, iattr, NULL, NULL);
iattr.dataType = UA_NODEID_NUMERIC(0, UA_NS0ID_UINTEGER);
iattr.displayName = UA_LOCALIZEDTEXT("en-US", "UInteger");
UA_QualifiedName uQualifiedName = UA_QUALIFIEDNAME(1, "uinteger");
UA_Server_addVariableNode(server, UA_NODEID_STRING(1, "uinteger"),
UA_NODEID_NUMERIC(1, SCALARID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
uQualifiedName, baseDataVariableType, iattr, NULL, NULL);
UA_Variant_clear(&iattr.value);
/* Hierarchy of depth 10 for CTT testing with forward and inverse references */
/* Enter node "depth 9" in CTT configuration - Project->Settings->Server
Test->NodeIds->Paths->Starting Node 1 */
object_attr.description = UA_LOCALIZEDTEXT("en-US", "DepthDemo");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "DepthDemo");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, DEPTHID), UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_QUALIFIEDNAME(1, "DepthDemo"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
id = DEPTHID; // running id in namespace 0 - Start with Matrix NODE
for(UA_UInt32 i = 1; i <= 20; i++) {
char name[15];
UA_snprintf(name, 15, "depth%i", i);
object_attr.description = UA_LOCALIZEDTEXT("en-US", name);
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", name);
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, id + i),
UA_NODEID_NUMERIC(1, i == 1 ? DEPTHID : id + i - 1),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, name),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
}
/* Add the variable to some more places to get a node with three inverse references for the CTT */
UA_ExpandedNodeId answer_nodeid = UA_EXPANDEDNODEID_STRING(1, "the.answer");
UA_Server_addReference(server, UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), answer_nodeid, true);
UA_Server_addReference(server, UA_NODEID_NUMERIC(1, SCALARID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), answer_nodeid, true);
/* Example for manually setting an attribute within the server */
UA_LocalizedText objectsName = UA_LOCALIZEDTEXT("en-US", "Objects");
UA_Server_writeDisplayName(server, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), objectsName);
#define NOARGID 60000
#define INARGID 60001
#define OUTARGID 60002
#define INOUTARGID 60003
#ifdef UA_ENABLE_METHODCALLS
/* adding some more method nodes to pass CTT */
/* Method without arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "noarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, NOARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "noarg"), addmethodattributes,
&noargMethod, /* callback of the method node */
0, NULL, 0, NULL, NULL, NULL);
/* Method with in arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "inarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Argument_init(&inputArguments);
inputArguments.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
inputArguments.description = UA_LOCALIZEDTEXT("en-US", "Input");
inputArguments.name = UA_STRING("Input");
inputArguments.valueRank = UA_VALUERANK_SCALAR; //uaexpert will crash if set to 0 ;)
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, INARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "noarg"), addmethodattributes,
&noargMethod, /* callback of the method node */
1, &inputArguments, 0, NULL, NULL, NULL);
/* Method with out arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "outarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Argument_init(&outputArguments);
outputArguments.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
outputArguments.description = UA_LOCALIZEDTEXT("en-US", "Output");
outputArguments.name = UA_STRING("Output");
outputArguments.valueRank = UA_VALUERANK_SCALAR;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, OUTARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "outarg"), addmethodattributes,
&outargMethod, /* callback of the method node */
0, NULL, 1, &outputArguments, NULL, NULL);
/* Method with inout arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "inoutarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, INOUTARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "inoutarg"), addmethodattributes,
&outargMethod, /* callback of the method node */
1, &inputArguments, 1, &outputArguments, NULL, NULL);
#endif
}
void Service_Read(UA_Server *server, UA_Session *session, const UA_ReadRequest *request,
UA_ReadResponse *response) {
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SESSION,
"Processing ReadRequest for Session (ns=%i,i=%i)",
session->sessionId.namespaceIndex, session->sessionId.identifier.numeric);
if(request->nodesToReadSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
if(request->timestampsToReturn > 3){
response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID;
return;
}
size_t size = request->nodesToReadSize;
response->results = UA_Array_new(size, &UA_TYPES[UA_TYPES_DATAVALUE]);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = size;
if(request->maxAge < 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID;
return;
}
#ifdef UA_ENABLE_EXTERNAL_NAMESPACES
UA_Boolean isExternal[size];
UA_UInt32 indices[size];
memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
for(size_t j = 0;j<server->externalNamespacesSize;j++) {
size_t indexSize = 0;
for(size_t i = 0;i < size;i++) {
if(request->nodesToRead[i].nodeId.namespaceIndex != server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indexSize] = i;
indexSize++;
}
if(indexSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->readNodes(ens->ensHandle, &request->requestHeader, request->nodesToRead,
indices, indexSize, response->results, UA_FALSE, response->diagnosticInfos);
}
#endif
for(size_t i = 0;i < size;i++) {
#ifdef UA_ENABLE_EXTERNAL_NAMESPACES
if(!isExternal[i])
#endif
Service_Read_single(server, session, request->timestampsToReturn,
&request->nodesToRead[i], &response->results[i]);
}
#ifdef UA_ENABLE_NONSTANDARD_STATELESS
/* Add an expiry header for caching */
if(session==&anonymousSession){
UA_ExtensionObject additionalHeader;
UA_ExtensionObject_init(&additionalHeader);
additionalHeader.typeId = UA_TYPES[UA_TYPES_VARIANT].typeId;
additionalHeader.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
UA_Variant variant;
UA_Variant_init(&variant);
UA_DateTime* expireArray = NULL;
expireArray = UA_Array_new(&UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
variant.data = expireArray;
/*expires in 20 seconds*/
for(UA_Int32 i = 0;i < response->resultsSize;i++) {
expireArray[i] = UA_DateTime_now() + 20 * 100 * 1000 * 1000;
}
UA_Variant_setArray(&variant, expireArray, request->nodesToReadSize, &UA_TYPES[UA_TYPES_DATETIME]);
size_t offset = 0;
UA_ByteString str;
UA_ByteString_newMembers(&str, 65536);
UA_Variant_encodeBinary(&variant, &str, &offset);
UA_Array_delete(expireArray, &UA_TYPES[UA_TYPES_DATETIME], request->nodesToReadSize);
additionalHeader.body = str;
additionalHeader.body.length = offset;
response->responseHeader.additionalHeader = additionalHeader;
}
#endif
}
int main(int argc , char *argv[]) {
int sock;
struct sockaddr_in server;
UA_ByteString message;
message.data = (UA_Byte*)malloc(1000*sizeof(UA_Byte));
message.length = 1000;
//UA_UInt32 messageEncodedLength = 0;
UA_Byte server_reply[2000];
unsigned int messagepos = 0;
//Create socket
#ifdef UA_ENABLE_NONSTANDARD_UDP
sock = socket(AF_INET , SOCK_DGRAM , 0);
#else
sock = socket(AF_INET , SOCK_STREAM , 0);
#endif
if(sock == -1) {
printf("Could not create socket");
}
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 16664 );
//Connect to remote server
if(connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
perror("connect failed. Error");
return 1;
}
UA_TcpMessageHeader reqTcpHeader;
UA_UInt32 reqSecureChannelId = 0;
UA_UInt32 reqTokenId = 0;
UA_SequenceHeader reqSequenceHeader;
UA_NodeId reqRequestType;
UA_ReadRequest req;
UA_RequestHeader reqHeader;
UA_NodeId reqHeaderAuthToken;
UA_ExtensionObject reqHeaderAdditionalHeader;
UA_NodeId_init(&reqRequestType);
reqRequestType.identifierType = UA_NODEIDTYPE_NUMERIC;
reqRequestType.identifier.numeric = 631; //read request
UA_SequenceHeader_init(&reqSequenceHeader);
reqSequenceHeader.sequenceNumber = 42;
UA_ReadRequest_init(&req);
req.requestHeader = reqHeader;
UA_RequestHeader_init(&(req.requestHeader));
req.requestHeader.authenticationToken = reqHeaderAuthToken;
UA_NodeId_init(&(req.requestHeader.authenticationToken));
req.requestHeader.additionalHeader = reqHeaderAdditionalHeader;
UA_ExtensionObject_init(&(req.requestHeader.additionalHeader));
req.nodesToRead= UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], 1);
req.nodesToReadSize = 1;
UA_ReadValueId_init(&(req.nodesToRead[0]));
req.nodesToRead[0].attributeId = 13; //UA_ATTRIBUTEID_VALUE
UA_NodeId_init(&(req.nodesToRead[0].nodeId));
req.nodesToRead[0].nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
req.nodesToRead[0].nodeId.identifier.numeric = 2255;
UA_QualifiedName_init(&(req.nodesToRead[0].dataEncoding));
/**messageEncodedLength = UA_TcpMessageHeader_calcSizeBinary(&reqTcpHeader) +
UA_UInt32_calcSizeBinary(&reqSecureChannelId)+
UA_UInt32_calcSizeBinary(&reqTokenId)+
UA_SequenceHeader_calcSizeBinary(&reqSequenceHeader)+
UA_NodeId_calcSizeBinary(&reqRequestType) +
UA_ReadRequest_calcSizeBinary(&req);**/
UA_TcpMessageHeader_init(&reqTcpHeader);
reqTcpHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_TcpMessageHeader_encodeBinary(&reqTcpHeader, &message, &messagepos);
UA_UInt32_encodeBinary(&reqSecureChannelId, &message, &messagepos);
UA_UInt32_encodeBinary(&reqTokenId, &message, &messagepos);
UA_SequenceHeader_encodeBinary(&reqSequenceHeader, &message, &messagepos);
UA_NodeId_encodeBinary(&reqRequestType, &message, &messagepos);
UA_ReadRequest_encodeBinary(&req, &message, &messagepos);
reqTcpHeader.messageSize = messagepos;
messagepos=0;
UA_TcpMessageHeader_encodeBinary(&reqTcpHeader, &message, &messagepos);
UA_UInt32_encodeBinary(&reqSecureChannelId, &message, &messagepos);
UA_UInt32_encodeBinary(&reqTokenId, &message, &messagepos);
UA_SequenceHeader_encodeBinary(&reqSequenceHeader, &message, &messagepos);
UA_NodeId_encodeBinary(&reqRequestType, &message, &messagepos);
UA_ReadRequest_encodeBinary(&req, &message, &messagepos);
//Send some data
if(send(sock , message.data, messagepos , 0) < 0) {
puts("Send failed");
return 1;
}
//Receive a reply from the server
int received = recv(sock , server_reply , 2000 , 0);
if(received < 0) {
puts("recv failed");
return 1;
}
for(int i=0;i<received;i++) {
//show only printable ascii
if(server_reply[i] >= 32 && server_reply[i]<= 126)
printf("%c",server_reply[i]);
}
printf("\n");
close(sock);
return 0;
}
void Service_Call(UA_Server *server, UA_Session *session, const UA_CallRequest *request,
UA_CallResponse *response) {
if(request->methodsToCallSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
response->results = UA_Array_new(&UA_TYPES[UA_TYPES_CALLMETHODRESULT], request->methodsToCallSize);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = request->methodsToCallSize;
for(UA_Int32 i = 0; i < request->methodsToCallSize;i++) {
UA_CallMethodRequest *rq = &request->methodsToCall[i];
UA_CallMethodResult *rs = &response->results[i];
/* Get/Check Nodes */
const UA_MethodNode *methodCalled =
(const UA_MethodNode*) UA_NodeStore_get(server->nodestore, &rq->methodId);
if(methodCalled == UA_NULL) {
rs->statusCode = UA_STATUSCODE_BADMETHODINVALID;
continue;
}
const UA_ObjectNode *withObject =
(const UA_ObjectNode *) UA_NodeStore_get(server->nodestore, &rq->objectId);
if(withObject == UA_NULL) {
rs->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
printf("Obj not found\n");
continue;
}
if(methodCalled->nodeClass != UA_NODECLASS_METHOD) {
rs->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
continue;
}
if(withObject->nodeClass != UA_NODECLASS_OBJECT && withObject->nodeClass != UA_NODECLASS_OBJECTTYPE) {
rs->statusCode = UA_STATUSCODE_BADNODECLASSINVALID;
printf("Obj not found 1\n");
continue;
}
/* Verify method/object relations */
// Object must have a hasComponent reference (or any inherited referenceType from sayd reference)
// to be valid for a methodCall...
for(UA_Int32 i = 0; i < withObject->referencesSize; i++) {
if(withObject->references[i].referenceTypeId.identifier.numeric == UA_NS0ID_HASCOMPONENT) {
// FIXME: Not checking any subtypes of HasComponent at the moment
if(UA_NodeId_equal(&withObject->references[i].targetId.nodeId, &methodCalled->nodeId)) {
rs->statusCode = UA_STATUSCODE_GOOD;
break;
}
}
}
if(rs->statusCode != UA_STATUSCODE_GOOD)
continue;
/* Verify method executable */
if(((const UA_MethodNode *) methodCalled)->executable == UA_FALSE ||
((const UA_MethodNode *) methodCalled)->userExecutable == UA_FALSE ) {
rs->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
continue;
}
/* Verify Input Argument count, types and sizes */
const UA_VariableNode *inputArguments = getArgumentsVariableNode(server, methodCalled,
UA_STRING("InputArguments"));
if(inputArguments) {
// Expects arguments
rs->statusCode = argConformsToDefinition(rq, inputArguments);
UA_NodeStore_release((const UA_Node*)inputArguments);
if(rs->statusCode != UA_STATUSCODE_GOOD)
continue;
} else if(rq->inputArgumentsSize > 0) {
// Expects no arguments, but got some
rs->statusCode = UA_STATUSCODE_BADINVALIDARGUMENT;
UA_NodeStore_release((const UA_Node*)inputArguments);
continue;
}
const UA_VariableNode *outputArguments = getArgumentsVariableNode(server, methodCalled,
UA_STRING("OutputArguments"));
if(!outputArguments) {
// A MethodNode must have an OutputArguments variable (which may be empty)
rs->statusCode = UA_STATUSCODE_BADINTERNALERROR;
continue;
}
// Call method if available
if(methodCalled->attachedMethod) {
rs->outputArguments = UA_Array_new(&UA_TYPES[UA_TYPES_VARIANT],
outputArguments->value.variant.arrayLength);
rs->outputArgumentsSize = outputArguments->value.variant.arrayLength;
rs->statusCode = methodCalled->attachedMethod(withObject->nodeId, rq->inputArguments,
rs->outputArguments);
}
else
rs->statusCode = UA_STATUSCODE_BADNOTWRITABLE; // There is no NOTEXECUTABLE?
/* FIXME: Verify Output Argument count, types and sizes */
if(outputArguments) {
UA_NodeStore_release((const UA_Node*)outputArguments);
}
UA_NodeStore_release((const UA_Node *)withObject);
UA_NodeStore_release((const UA_Node *)methodCalled);
}
}
int main(void)
{
UA_Client *clt; //client
UA_StatusCode retval;
UA_ReadRequest req; //read request
UA_ReadResponse resp; //response
/*
* Step 1.
* create & init the client
*/
clt = UA_Client_new(UA_ClientConfig_standard);
retval = UA_Client_connect(clt, URL);
if(retval != UA_STATUSCODE_GOOD){
UA_Client_delete(clt);
return retval;
}
/*
* Step 2.
* Create read request
*/
UA_ReadRequest_init(&req); // memset 0 in req
req.nodesToRead = UA_Array_new(1, &UA_TYPES[UA_TYPES_READVALUEID]);
req.nodesToReadSize = 1;
/*
* Step 3.
* define which node and attribute to be read
*/
req.nodesToRead[0].nodeId = UA_NODEID_STRING_ALLOC(1, "the.f****r");
req.nodesToRead[0].attributeId = UA_ATTRIBUTEID_VALUE;
/*
* Step 4.
* call the `UA_Client_Service_read` to read
*/
UA_ReadResponse_init(&resp);
resp = UA_Client_Service_read(clt, req);
/* if(resp.responseHeader.serviceResult == UA_STATUSCODE_GOOD &&
resp.resultsSize > 0 &&
resp.results[0].hasValue &&
UA_Variant_isScalar(&resp.results[0].value) &&
resp.results[0].value.type == &UA_TYPES[UA_TYPES_INT32])
{*/
if(resp.responseHeader.serviceResult == UA_STATUSCODE_GOOD &&
resp.resultsSize > 0 &&
resp.results[0].hasValue &&
UA_Variant_isScalar(&resp.results[0].value) &&
resp.results[0].value.type == &UA_TYPES[UA_TYPES_STRING])
{
UA_String *str = (UA_String *)resp.results[0].value.data;
printf("The string : %s\n", str->data);
/*
UA_Int32 *val = (UA_Int32 *)resp.results[0].value.data;
printf("The value is: %d\n", *val);*/
}
/*
* Step 5.
* free resource
*/
UA_ReadRequest_deleteMembers(&req);
UA_ReadResponse_deleteMembers(&resp);
UA_Client_disconnect(clt);
UA_Client_delete(clt);
return UA_STATUSCODE_GOOD;
}
int main(int argc, char *argv[]) {
int defaultParams = argc < 8;
//start parameters
if(defaultParams) {
printf("1st parameter: number of nodes to read \n");
printf("2nd parameter: number of read-tries \n");
printf("3rd parameter: name of the file to save measurement data \n");
printf("4th parameter: 1 = read same node, 0 = read different nodes \n");
printf("5th parameter: ip adress \n");
printf("6th parameter: port \n");
printf("7th parameter: 0=stateful, 1=stateless\n");
printf("8th parameter: 0=tcp, 1=udp (only with stateless calls)\n");
printf("\nUsing default parameters. \n");
}
UA_UInt32 nodesToReadSize;
UA_UInt32 tries;
UA_Boolean alwaysSameNode;
UA_ByteString reply;
UA_ByteString_newMembers(&reply, 65536);
UA_Boolean stateless;
UA_Boolean udp;
if(defaultParams)
nodesToReadSize = 1;
else
nodesToReadSize = atoi(argv[1]);
if(defaultParams)
tries= 2;
else
tries = (UA_UInt32) atoi(argv[2]);
if(defaultParams){
alwaysSameNode = UA_TRUE;
}else{
if(atoi(argv[4]) != 0)
alwaysSameNode = UA_TRUE;
else
alwaysSameNode = UA_FALSE;
}
if(defaultParams){
stateless = UA_FALSE;
}else{
if(atoi(argv[7]) != 0)
stateless = UA_TRUE;
else
stateless = UA_FALSE;
}
if(defaultParams){
udp = UA_FALSE;
}else{
if(atoi(argv[8]) != 0)
udp = UA_TRUE;
else
udp = UA_FALSE;
}
//Connect to remote server
UA_String endpoint;
UA_String_copycstring("none",&endpoint);
ConnectionInfo connectionInfo;
/* REQUEST START*/
UA_NodeId *nodesToRead;
nodesToRead = UA_Array_new(&UA_TYPES[UA_TYPES_NODEID], 1);
for(UA_UInt32 i = 0; i<1; i++) {
if(alwaysSameNode)
nodesToRead[i].identifier.numeric = 2253; //ask always the same node
else
nodesToRead[i].identifier.numeric = 19000 +i;
nodesToRead[i].identifierType = UA_NODEIDTYPE_NUMERIC;
nodesToRead[i].namespaceIndex = 0;
}
UA_DateTime tic, toc;
UA_Double *timeDiffs;
UA_Int32 received;
timeDiffs = UA_Array_new(&UA_TYPES[UA_TYPES_DOUBLE], tries);
UA_Double sum = 0;
tic = UA_DateTime_now();
/**
UA_Double duration;
UA_UInt32 count = 0;
UA_Double start = 0, stop = 0;
UA_UInt32 timeToRun = 30;
UA_UInt32 timeToStart = 8;
UA_UInt32 timeToStop = 22;
do{
toc = UA_DateTime_now();
duration = ((UA_Double)toc-(UA_Double)tic)/(UA_Double)1e4;
if(duration>=timeToStart*1000 && duration <= timeToStop*1000){
if(start==0.0){
start=UA_DateTime_now();
}
}
//if(stateless || (!stateless && i==0)){
if(defaultParams){
if(ua_client_connectUA("127.0.0.1",atoi("16664"),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}else{
if(ua_client_connectUA(argv[5],atoi(argv[6]),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}
//}
sendReadRequest(&connectionInfo,1,nodesToRead);
received = recv(connectionInfo.socket, reply.data, 2000, 0);
if(duration>=timeToStart*1000 && duration <= timeToStop*1000){
count++;
}
if(!stateless){
closeSession(&connectionInfo);
recv(connectionInfo.socket, reply.data, 2000, 0);
closeSecureChannel(&connectionInfo);
}
//if(stateless || (!stateless && i==tries-1)){
close(connectionInfo.socket);
//}
if(duration >= timeToStop*1000 && stop==0){
stop=UA_DateTime_now();
printf("%i messages in %f secs, rate %f m/s\n", count, (stop-start)/(UA_Double)1e7, (UA_Double)count/((stop-start)/(UA_Double)1e7));
}
}while(duration<timeToRun*1000);
exit(0);
**/
for(UA_UInt32 i = 0; i < tries; i++) {
//if(stateless || (!stateless && i==0)){
tic = UA_DateTime_now();
if(defaultParams){
if(ua_client_connectUA("127.0.0.1",atoi("16664"),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}else{
if(ua_client_connectUA(argv[5],atoi(argv[6]),&endpoint,&connectionInfo,stateless,udp) != 0){
return 0;
}
}
//}
for(UA_UInt32 i = 0; i < nodesToReadSize; i++) {
sendReadRequest(&connectionInfo,1,nodesToRead);
received = recv(connectionInfo.socket, reply.data, 2000, 0);
}
if(!stateless){
closeSession(&connectionInfo);
recv(connectionInfo.socket, reply.data, 2000, 0);
closeSecureChannel(&connectionInfo);
}
//if(stateless || (!stateless && i==tries-1)){
close(connectionInfo.socket);
//}
toc = UA_DateTime_now() - tic;
timeDiffs[i] = (UA_Double)toc/(UA_Double)1e4;
sum = sum + timeDiffs[i];
}
/* REQUEST END*/
UA_Double mean = sum / tries;
printf("mean time for handling request: %16.10f ms \n",mean);
if(received>0)
printf("received: %i\n",received); // dummy
//save to file
char data[100];
const char flag = 'a';
FILE* fHandle = UA_NULL;
if (defaultParams) {
fHandle = fopen("client.log", &flag);
}else{
fHandle = fopen(argv[3], &flag);
}
//header
UA_Int32 bytesToWrite = sprintf(data, "measurement %s in ms, nodesToRead %d \n", argv[3], 1);
fwrite(data,1,bytesToWrite,fHandle);
for(UA_UInt32 i=0;i<tries;i++) {
bytesToWrite = sprintf(data,"%16.10f \n",timeDiffs[i]);
fwrite(data,1,bytesToWrite,fHandle);
}
fclose(fHandle);
UA_String_deleteMembers(&reply);
UA_Array_delete(nodesToRead,&UA_TYPES[UA_TYPES_NODEID], 1);
UA_free(timeDiffs);
return 0;
}
OV_DLLFNCEXPORT UA_StatusCode servicesOPCUAInterface_interface_ovServiceOutputArgumentsNodeToOPCUA(
void *handle, const UA_NodeId *nodeId, UA_Node** opcuaNode) {
UA_Node *newNode = NULL;
UA_StatusCode result = UA_STATUSCODE_GOOD;
OV_PATH path;
OV_INSTPTR_ov_object pobj = NULL;
OV_TICKET *pTicket = NULL;
OV_VTBLPTR_ov_object pVtblObj = NULL;
OV_ACCESS access;
UA_NodeClass nodeClass;
OV_ELEMENT element;
OV_STRING tmpString = NULL;
OV_UINT len = 0;
OV_STRING *plist = NULL;
copyOPCUAStringToOV(nodeId->identifier.string, &tmpString);
plist = ov_string_split(tmpString, "||", &len);
ov_string_setvalue(&tmpString, NULL);
UA_NodeId tmpNodeId;
UA_NodeId_init(&tmpNodeId);
tmpNodeId.namespaceIndex = nodeId->namespaceIndex;
tmpNodeId.identifierType = nodeId->identifierType;
tmpNodeId.identifier.string = UA_String_fromChars(plist[0]);
ov_string_freelist(plist);
ov_memstack_lock();
result = opcua_nodeStoreFunctions_resolveNodeIdToPath(tmpNodeId, &path);
UA_NodeId_deleteMembers(&tmpNodeId);
if(result != UA_STATUSCODE_GOOD){
ov_memstack_unlock();
return result;
}
element = path.elements[path.size-1];
ov_memstack_unlock();
result = opcua_nodeStoreFunctions_getVtblPointerAndCheckAccess(&(element), pTicket, &pobj, &pVtblObj, &access);
if(result != UA_STATUSCODE_GOOD){
return result;
}
nodeClass = UA_NODECLASS_VARIABLE;
newNode = (UA_Node*)UA_calloc(1, sizeof(UA_VariableNode));
// Basic Attribute
// BrowseName
UA_QualifiedName qName;
qName.name = UA_String_fromChars("OutputArguments");
qName.namespaceIndex = 0; //pinterface->v_interfacenamespace.index;
newNode->browseName = qName;
// Description
OV_STRING tempString = pVtblObj->m_getcomment(pobj, &element);
UA_LocalizedText lText;
UA_LocalizedText_init(&lText);
lText.locale = UA_String_fromChars("en");
if(tempString){
lText.text = UA_String_fromChars(tempString);
} else {
lText.text = UA_String_fromChars("");
}
UA_LocalizedText_copy(&lText,&newNode->description);
UA_LocalizedText_deleteMembers(&lText);
// DisplayName
UA_LocalizedText displayName;
UA_LocalizedText_init(&displayName);
displayName.locale = UA_String_fromChars("en");
displayName.text = UA_String_fromChars("OutputArguments");
UA_LocalizedText_copy(&displayName, &newNode->displayName);
UA_LocalizedText_deleteMembers(&displayName);
// NodeId
UA_NodeId_copy(nodeId, &newNode->nodeId);
// NodeClass
newNode->nodeClass = nodeClass;
// WriteMask
UA_UInt32 writeMask = 0;
if(element.elemtype != OV_ET_VARIABLE){
if(access & OV_AC_WRITE){
writeMask |= (1<<2); // BrowseName
writeMask |= (1<<6); // DisplayName
}
if(access & OV_AC_RENAMEABLE){
writeMask |= (1<<14); // NodeId
}
}
newNode->writeMask = writeMask;
// Variable specific attributes
// value
OV_ELEMENT tmpPart;
tmpPart.elemtype = OV_ET_NONE;
tmpPart.pobj = NULL;
OV_ELEMENT tmpParrent;
tmpParrent.pobj = pobj;
tmpParrent.elemtype = OV_ET_OBJECT;
OV_UINT sizeOutput = 0;
do {
ov_element_getnextpart(&tmpParrent, &tmpPart, OV_ET_VARIABLE);
if (tmpPart.elemtype == OV_ET_NONE)
break;
if (tmpPart.elemunion.pvar->v_flags == 16384){ // OutputFlag is set
sizeOutput++;
continue;
}
} while(TRUE);
// arrayDemensions
if (sizeOutput > 1){
((UA_VariableNode*)newNode)->arrayDimensionsSize = 1;
UA_UInt32 *pOutputDimension = UA_UInt32_new();
*pOutputDimension = sizeOutput;
((UA_VariableNode*)newNode)->arrayDimensions = pOutputDimension; //UA_Array_new(((UA_VariableNode*)newNode)->arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]); /* scalar or one dimension */
// valuerank
((UA_VariableNode*)newNode)->valueRank = 1; /* one dimension */
}else{
((UA_VariableNode*)newNode)->arrayDimensionsSize = 0;
((UA_VariableNode*)newNode)->arrayDimensions = NULL; //UA_Array_new(((UA_VariableNode*)newNode)->arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]); /* scalar or one dimension */
// valuerank
((UA_VariableNode*)newNode)->valueRank = -1; /* one dimension */
}
// value
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->type = &UA_TYPES[UA_TYPES_ARGUMENT];
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->arrayLength = sizeOutput;
if (sizeOutput > 1){
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data = UA_Array_new(sizeOutput, &UA_TYPES[UA_TYPES_ARGUMENT]);
}else{
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data = UA_Argument_new();
}
if (!((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data){
result = UA_STATUSCODE_BADOUTOFMEMORY;
return result;
}
((UA_VariableNode*)newNode)->value.data.value.hasValue = TRUE;
((UA_VariableNode*)newNode)->valueSource = UA_VALUESOURCE_DATA;
tmpPart.elemtype = OV_ET_NONE;
tmpPart.pobj = NULL;
OV_UINT count = 0;
do {
ov_element_getnextpart(&tmpParrent, &tmpPart, OV_ET_VARIABLE);
if (tmpPart.elemtype == OV_ET_NONE)
break;
if (tmpPart.elemunion.pvar->v_flags == 16384){ // OutputFlag is set
UA_Argument_init(&((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count]);
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].description = UA_LOCALIZEDTEXT_ALLOC("en_US","");
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].name = UA_STRING_ALLOC(tmpPart.elemunion.pvar->v_identifier);
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
switch(tmpPart.elemunion.pvar->v_vartype){
case OV_VT_BOOL:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_BOOLEAN].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_INT:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_INT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_UINT:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_SINGLE:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_FLOAT].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_DOUBLE:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_DOUBLE].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_ANY:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_VARIANT].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_STRING:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_STRING].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_BOOL_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_BOOLEAN].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_INT_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_INT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_UINT_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_SINGLE_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_FLOAT].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_DOUBLE_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_DOUBLE].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_STRING_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_STRING].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
default:
break;
}
count++;
if (count == sizeOutput){
break;
}else{
continue;
}
}
} while(TRUE);
ov_string_setvalue(&tmpString, NULL);
// accessLevel
UA_Byte accessLevel = 0;
if(access & OV_AC_READ){
accessLevel |= (1<<0);
}
if(access & OV_AC_WRITE){
accessLevel |= (1<<1);
}
((UA_VariableNode*)newNode)->accessLevel = accessLevel;
// minimumSamplingInterval
((UA_VariableNode*)newNode)->minimumSamplingInterval = -1;
// historizing
((UA_VariableNode*)newNode)->historizing = UA_FALSE;
// dataType
((UA_VariableNode*)newNode)->dataType = UA_NODEID_NUMERIC(0, 0);
// References have to do manual because it is an virtual node
size_t size_references = 0;
size_references = size_references + 2;// For Parent&TypeNode
newNode->references = UA_calloc(size_references, sizeof(UA_ReferenceNode));
if (!newNode->references){
result = ov_resultToUaStatusCode(OV_ERR_HEAPOUTOFMEMORY);
UA_free(newNode);
return result;
}
newNode->referencesSize = size_references;
// ParentNode
newNode->references[0].referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
newNode->references[0].isInverse = UA_TRUE;
len = 0;
plist = NULL;
tmpString = NULL;
copyOPCUAStringToOV(nodeId->identifier.string, &tmpString);
plist = ov_string_split(tmpString, "||", &len);
newNode->references[0].targetId = UA_EXPANDEDNODEID_STRING_ALLOC(pinterface->v_interfacenamespace.index, plist[0]);
ov_string_freelist(plist);
ov_string_setvalue(&tmpString, NULL);
// TypeNode
newNode->references[1].referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
newNode->references[1].isInverse = UA_FALSE;
newNode->references[1].targetId = UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE);
*opcuaNode = newNode;
return UA_STATUSCODE_GOOD;
}
int
main(int argc, char **argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
signal(SIGTERM, stopHandler);
#ifdef UA_ENABLE_ENCRYPTION
if(argc < 3) {
UA_LOG_FATAL(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Missing arguments for encryption support. "
"Arguments are <server-certificate.der> "
"<private-key.der> [<trustlist1.crl>, ...]");
return 1;
}
/* Load certificate and private key */
UA_ByteString certificate = loadFile(argv[1]);
UA_ByteString privateKey = loadFile(argv[2]);
/* Load the trustlist */
size_t trustListSize = 0;
if(argc > 3)
trustListSize = (size_t)argc-3;
UA_STACKARRAY(UA_ByteString, trustList, trustListSize);
for(size_t i = 0; i < trustListSize; i++)
trustList[i] = loadFile(argv[i+3]);
/* Loading of a revocation list currently unsupported */
UA_ByteString *revocationList = NULL;
size_t revocationListSize = 0;
UA_ServerConfig *config =
UA_ServerConfig_new_allSecurityPolicies(4840, &certificate, &privateKey,
trustList, trustListSize,
revocationList, revocationListSize);
UA_ByteString_deleteMembers(&certificate);
UA_ByteString_deleteMembers(&privateKey);
for(size_t i = 0; i < trustListSize; i++)
UA_ByteString_deleteMembers(&trustList[i]);
if(!config) {
UA_LOG_FATAL(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Could not create the server config");
return 1;
}
#else
if(argc < 2) {
UA_LOG_FATAL(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Missing argument for the server certificate");
return 1;
}
UA_ByteString certificate = loadFile(argv[1]);
UA_ServerConfig *config = UA_ServerConfig_new_minimal(4840, &certificate);
UA_ByteString_deleteMembers(&certificate);
#endif
/* uncomment next line to add a custom hostname */
// UA_ServerConfig_set_customHostname(config, UA_STRING("custom"));
UA_Server *server = UA_Server_new(config);
if(server == NULL)
return 1;
/* add a static variable node to the server */
UA_VariableAttributes myVar = UA_VariableAttributes_default;
myVar.description = UA_LOCALIZEDTEXT("en-US", "the answer");
myVar.displayName = UA_LOCALIZEDTEXT("en-US", "the answer");
myVar.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
myVar.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
myVar.valueRank = -1;
UA_Int32 myInteger = 42;
UA_Variant_setScalarCopy(&myVar.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
const UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
const UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_Server_addVariableNode(server, myIntegerNodeId, parentNodeId, parentReferenceNodeId,
myIntegerName, baseDataVariableType, myVar, NULL, NULL);
UA_Variant_deleteMembers(&myVar.value);
/* add a static variable that is readable but not writable*/
myVar = UA_VariableAttributes_default;
myVar.description = UA_LOCALIZEDTEXT("en-US", "the answer - not readable");
myVar.displayName = UA_LOCALIZEDTEXT("en-US", "the answer - not readable");
myVar.accessLevel = UA_ACCESSLEVELMASK_WRITE;
myVar.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
myVar.valueRank = -1;
UA_Variant_setScalarCopy(&myVar.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
const UA_QualifiedName myInteger2Name = UA_QUALIFIEDNAME(1, "the answer - not readable");
const UA_NodeId myInteger2NodeId = UA_NODEID_STRING(1, "the.answer.no.read");
UA_Server_addVariableNode(server, myInteger2NodeId, parentNodeId, parentReferenceNodeId,
myInteger2Name, baseDataVariableType, myVar, NULL, NULL);
UA_Variant_deleteMembers(&myVar.value);
/* add a variable with the datetime data source */
UA_DataSource dateDataSource;
dateDataSource.read = readTimeData;
dateDataSource.write = NULL;
UA_VariableAttributes v_attr = UA_VariableAttributes_default;
v_attr.description = UA_LOCALIZEDTEXT("en-US", "current time");
v_attr.displayName = UA_LOCALIZEDTEXT("en-US", "current time");
v_attr.accessLevel = UA_ACCESSLEVELMASK_READ;
v_attr.dataType = UA_TYPES[UA_TYPES_DATETIME].typeId;
v_attr.valueRank = -1;
const UA_QualifiedName dateName = UA_QUALIFIEDNAME(1, "current time");
UA_Server_addDataSourceVariableNode(server, UA_NODEID_NULL, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), dateName,
baseDataVariableType, v_attr, dateDataSource, NULL, NULL);
/* Add HelloWorld method to the server */
#ifdef UA_ENABLE_METHODCALLS
/* Method with IO Arguments */
UA_Argument inputArguments;
UA_Argument_init(&inputArguments);
inputArguments.dataType = UA_TYPES[UA_TYPES_STRING].typeId;
inputArguments.description = UA_LOCALIZEDTEXT("en-US", "Say your name");
inputArguments.name = UA_STRING("Name");
inputArguments.valueRank = -1; /* scalar argument */
UA_Argument outputArguments;
UA_Argument_init(&outputArguments);
outputArguments.arrayDimensionsSize = 0;
outputArguments.arrayDimensions = NULL;
outputArguments.dataType = UA_TYPES[UA_TYPES_STRING].typeId;
outputArguments.description = UA_LOCALIZEDTEXT("en-US", "Receive a greeting");
outputArguments.name = UA_STRING("greeting");
outputArguments.valueRank = -1;
UA_MethodAttributes addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "Hello World");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, 62541),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "hello_world"), addmethodattributes,
&helloWorld, /* callback of the method node */
1, &inputArguments, 1, &outputArguments, NULL, NULL);
#endif
/* Add folders for demo information model */
#define DEMOID 50000
#define SCALARID 50001
#define ARRAYID 50002
#define MATRIXID 50003
#define DEPTHID 50004
UA_ObjectAttributes object_attr = UA_ObjectAttributes_default;
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Demo");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Demo");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_QUALIFIEDNAME(1, "Demo"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Scalar");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Scalar");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, SCALARID),
UA_NODEID_NUMERIC(1, DEMOID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "Scalar"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Array");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Array");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, ARRAYID),
UA_NODEID_NUMERIC(1, DEMOID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "Array"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
object_attr.description = UA_LOCALIZEDTEXT("en-US", "Matrix");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "Matrix");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, MATRIXID), UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_QUALIFIEDNAME(1, "Matrix"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
/* Fill demo nodes for each type*/
UA_UInt32 id = 51000; // running id in namespace 0
for(UA_UInt32 type = 0; type < UA_TYPES_DIAGNOSTICINFO; type++) {
if(type == UA_TYPES_VARIANT || type == UA_TYPES_DIAGNOSTICINFO)
continue;
UA_VariableAttributes attr = UA_VariableAttributes_default;
attr.valueRank = -2;
attr.dataType = UA_TYPES[type].typeId;
#ifndef UA_ENABLE_TYPENAMES
char name[15];
#if defined(_WIN32) && !defined(__MINGW32__)
sprintf_s(name, 15, "%02d", type);
#else
sprintf(name, "%02d", type);
#endif
attr.displayName = UA_LOCALIZEDTEXT("en-US", name);
UA_QualifiedName qualifiedName = UA_QUALIFIEDNAME(1, name);
#else
attr.displayName = UA_LOCALIZEDTEXT_ALLOC("en-US", UA_TYPES[type].typeName);
UA_QualifiedName qualifiedName = UA_QUALIFIEDNAME_ALLOC(1, UA_TYPES[type].typeName);
#endif
attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
attr.writeMask = UA_WRITEMASK_DISPLAYNAME | UA_WRITEMASK_DESCRIPTION;
attr.userWriteMask = UA_WRITEMASK_DISPLAYNAME | UA_WRITEMASK_DESCRIPTION;
/* add a scalar node for every built-in type */
void *value = UA_new(&UA_TYPES[type]);
UA_Variant_setScalar(&attr.value, value, &UA_TYPES[type]);
UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, ++id),
UA_NODEID_NUMERIC(1, SCALARID), UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
qualifiedName, baseDataVariableType, attr, NULL, NULL);
UA_Variant_deleteMembers(&attr.value);
/* add an array node for every built-in type */
UA_Variant_setArray(&attr.value, UA_Array_new(10, &UA_TYPES[type]), 10, &UA_TYPES[type]);
UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, ++id), UA_NODEID_NUMERIC(1, ARRAYID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), qualifiedName,
baseDataVariableType, attr, NULL, NULL);
UA_Variant_deleteMembers(&attr.value);
/* add an matrix node for every built-in type */
void *myMultiArray = UA_Array_new(9, &UA_TYPES[type]);
attr.value.arrayDimensions = (UA_UInt32 *)UA_Array_new(2, &UA_TYPES[UA_TYPES_INT32]);
attr.value.arrayDimensions[0] = 3;
attr.value.arrayDimensions[1] = 3;
attr.value.arrayDimensionsSize = 2;
attr.value.arrayLength = 9;
attr.value.data = myMultiArray;
attr.value.type = &UA_TYPES[type];
UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(1, ++id), UA_NODEID_NUMERIC(1, MATRIXID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), qualifiedName,
baseDataVariableType, attr, NULL, NULL);
UA_Variant_deleteMembers(&attr.value);
#ifdef UA_ENABLE_TYPENAMES
UA_LocalizedText_deleteMembers(&attr.displayName);
UA_QualifiedName_deleteMembers(&qualifiedName);
#endif
}
/* Hierarchy of depth 10 for CTT testing with forward and inverse references */
/* Enter node "depth 9" in CTT configuration - Project->Settings->Server
Test->NodeIds->Paths->Starting Node 1 */
object_attr.description = UA_LOCALIZEDTEXT("en-US", "DepthDemo");
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", "DepthDemo");
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, DEPTHID), UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_QUALIFIEDNAME(1, "DepthDemo"),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
id = DEPTHID; // running id in namespace 0 - Start with Matrix NODE
for(UA_UInt32 i = 1; i <= 20; i++) {
char name[15];
#if defined(_WIN32) && !defined(__MINGW32__)
sprintf_s(name, 15, "depth%i", i);
#else
sprintf(name, "depth%i", i);
#endif
object_attr.description = UA_LOCALIZEDTEXT("en-US", name);
object_attr.displayName = UA_LOCALIZEDTEXT("en-US", name);
UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, id + i),
UA_NODEID_NUMERIC(1, i == 1 ? DEPTHID : id + i - 1),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, name),
UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), object_attr, NULL, NULL);
}
/* Add the variable to some more places to get a node with three inverse references for the CTT */
UA_ExpandedNodeId answer_nodeid = UA_EXPANDEDNODEID_STRING(1, "the.answer");
UA_Server_addReference(server, UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), answer_nodeid, true);
UA_Server_addReference(server, UA_NODEID_NUMERIC(1, SCALARID),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), answer_nodeid, true);
/* Example for manually setting an attribute within the server */
UA_LocalizedText objectsName = UA_LOCALIZEDTEXT("en-US", "Objects");
UA_Server_writeDisplayName(server, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), objectsName);
#define NOARGID 60000
#define INARGID 60001
#define OUTARGID 60002
#define INOUTARGID 60003
#ifdef UA_ENABLE_METHODCALLS
/* adding some more method nodes to pass CTT */
/* Method without arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "noarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, NOARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "noarg"), addmethodattributes,
&noargMethod, /* callback of the method node */
0, NULL, 0, NULL, NULL, NULL);
/* Method with in arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "inarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Argument_init(&inputArguments);
inputArguments.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
inputArguments.description = UA_LOCALIZEDTEXT("en-US", "Input");
inputArguments.name = UA_STRING("Input");
inputArguments.valueRank = -1; //uaexpert will crash if set to 0 ;)
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, INARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "noarg"), addmethodattributes,
&noargMethod, /* callback of the method node */
1, &inputArguments, 0, NULL, NULL, NULL);
/* Method with out arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "outarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Argument_init(&outputArguments);
outputArguments.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
outputArguments.description = UA_LOCALIZEDTEXT("en-US", "Output");
outputArguments.name = UA_STRING("Output");
outputArguments.valueRank = -1;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, OUTARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "outarg"), addmethodattributes,
&outargMethod, /* callback of the method node */
0, NULL, 1, &outputArguments, NULL, NULL);
/* Method with inout arguments */
addmethodattributes = UA_MethodAttributes_default;
addmethodattributes.displayName = UA_LOCALIZEDTEXT("en-US", "inoutarg");
addmethodattributes.executable = true;
addmethodattributes.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, INOUTARGID),
UA_NODEID_NUMERIC(1, DEMOID),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "inoutarg"), addmethodattributes,
&outargMethod, /* callback of the method node */
1, &inputArguments, 1, &outputArguments, NULL, NULL);
#endif
/* run server */
UA_StatusCode retval = UA_Server_run(server, &running);
UA_Server_delete(server);
UA_ServerConfig_delete(config);
return (int)retval;
}
int main(int argc, char *argv[]) {
UA_Client *client = UA_Client_new(UA_ClientConfig_standard);
//listing endpoints
UA_EndpointDescription* endpointArray = NULL;
size_t endpointArraySize = 0;
UA_StatusCode retval =
UA_Client_getEndpoints(client, "opc.tcp://localhost:16664",
&endpointArraySize, &endpointArray);
//freeing the endpointArray
if(retval != UA_STATUSCODE_GOOD) {
//cleanup array
UA_Array_delete(endpointArray,endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
UA_Client_delete(client);
return (int)retval;
}
printf("%i endpoints found\n", (int)endpointArraySize);
for(size_t i=0;i<endpointArraySize;i++){
printf("URL of endpoint %i is %.*s\n", (int)i, (int)endpointArray[i].endpointUrl.length, endpointArray[i].endpointUrl.data);
}
//cleanup array of enpoints
UA_Array_delete(endpointArray,endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
//connect to a server
//anonymous connect would be: retval = UA_Client_connect_username(client, UA_ClientConnectionTCP, "opc.tcp://localhost:16664");
retval = UA_Client_connect_username(client, "opc.tcp://localhost:16664", "user1", "password");
if(retval != UA_STATUSCODE_GOOD) {
UA_Client_delete(client);
return (int)retval;
}
// Browse some objects
printf("Browsing nodes in objects folder:\n");
UA_BrowseRequest bReq;
UA_BrowseRequest_init(&bReq);
bReq.requestedMaxReferencesPerNode = 0;
bReq.nodesToBrowse = UA_BrowseDescription_new();
bReq.nodesToBrowseSize = 1;
bReq.nodesToBrowse[0].nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER); //browse objects folder
bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL; //return everything
UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq);
printf("%-9s %-16s %-16s %-16s\n", "NAMESPACE", "NODEID", "BROWSE NAME", "DISPLAY NAME");
for (size_t i = 0; i < bResp.resultsSize; ++i) {
for (size_t j = 0; j < bResp.results[i].referencesSize; ++j) {
UA_ReferenceDescription *ref = &(bResp.results[i].references[j]);
if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_NUMERIC) {
printf("%-9d %-16d %-16.*s %-16.*s\n", ref->browseName.namespaceIndex,
ref->nodeId.nodeId.identifier.numeric, (int)ref->browseName.name.length,
ref->browseName.name.data, (int)ref->displayName.text.length,
ref->displayName.text.data);
} else if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_STRING) {
printf("%-9d %-16.*s %-16.*s %-16.*s\n", ref->browseName.namespaceIndex,
(int)ref->nodeId.nodeId.identifier.string.length, ref->nodeId.nodeId.identifier.string.data,
(int)ref->browseName.name.length, ref->browseName.name.data,
(int)ref->displayName.text.length, ref->displayName.text.data);
}
//TODO: distinguish further types
}
}
UA_BrowseRequest_deleteMembers(&bReq);
UA_BrowseResponse_deleteMembers(&bResp);
// Same thing, this time using the node iterator...
UA_NodeId *parent = UA_NodeId_new();
*parent = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_Client_forEachChildNodeCall(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), nodeIter, (void *) parent);
UA_NodeId_delete(parent);
#ifdef UA_ENABLE_SUBSCRIPTIONS
// Create a subscription with interval 0 (immediate)...
UA_UInt32 subId=0;
UA_Client_Subscriptions_new(client, UA_SubscriptionSettings_standard, &subId);
if(subId)
printf("Create subscription succeeded, id %u\n", subId);
// .. and monitor TheAnswer
UA_NodeId monitorThis = UA_NODEID_STRING(1, "the.answer");
UA_UInt32 monId=0;
UA_Client_Subscriptions_addMonitoredItem(client, subId, monitorThis,
UA_ATTRIBUTEID_VALUE, &handler_TheAnswerChanged, NULL, &monId);
if (monId)
printf("Monitoring 'the.answer', id %u\n", subId);
// First Publish always generates data (current value) and call out handler.
UA_Client_Subscriptions_manuallySendPublishRequest(client);
// This should not generate anything
UA_Client_Subscriptions_manuallySendPublishRequest(client);
#endif
UA_Int32 value = 0;
// Read node's value
printf("\nReading the value of node (1, \"the.answer\"):\n");
UA_ReadRequest rReq;
UA_ReadRequest_init(&rReq);
rReq.nodesToRead = UA_Array_new(1, &UA_TYPES[UA_TYPES_READVALUEID]);
rReq.nodesToReadSize = 1;
rReq.nodesToRead[0].nodeId = UA_NODEID_STRING_ALLOC(1, "the.answer"); /* assume this node exists */
rReq.nodesToRead[0].attributeId = UA_ATTRIBUTEID_VALUE;
UA_ReadResponse rResp = UA_Client_Service_read(client, rReq);
if(rResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD &&
rResp.resultsSize > 0 && rResp.results[0].hasValue &&
UA_Variant_isScalar(&rResp.results[0].value) &&
rResp.results[0].value.type == &UA_TYPES[UA_TYPES_INT32]) {
value = *(UA_Int32*)rResp.results[0].value.data;
printf("the value is: %i\n", value);
}
UA_ReadRequest_deleteMembers(&rReq);
UA_ReadResponse_deleteMembers(&rResp);
value++;
// Write node's value
printf("\nWriting a value of node (1, \"the.answer\"):\n");
UA_WriteRequest wReq;
UA_WriteRequest_init(&wReq);
wReq.nodesToWrite = UA_WriteValue_new();
wReq.nodesToWriteSize = 1;
wReq.nodesToWrite[0].nodeId = UA_NODEID_STRING_ALLOC(1, "the.answer"); /* assume this node exists */
wReq.nodesToWrite[0].attributeId = UA_ATTRIBUTEID_VALUE;
wReq.nodesToWrite[0].value.hasValue = true;
wReq.nodesToWrite[0].value.value.type = &UA_TYPES[UA_TYPES_INT32];
wReq.nodesToWrite[0].value.value.storageType = UA_VARIANT_DATA_NODELETE; //do not free the integer on deletion
wReq.nodesToWrite[0].value.value.data = &value;
UA_WriteResponse wResp = UA_Client_Service_write(client, wReq);
if(wResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD)
printf("the new value is: %i\n", value);
UA_WriteRequest_deleteMembers(&wReq);
UA_WriteResponse_deleteMembers(&wResp);
// Alternate Form, this time using the hl API
value++;
UA_Variant *myVariant = UA_Variant_new();
UA_Variant_setScalarCopy(myVariant, &value, &UA_TYPES[UA_TYPES_INT32]);
UA_Client_writeValueAttribute(client, UA_NODEID_STRING(1, "the.answer"), myVariant);
UA_Variant_delete(myVariant);
#ifdef UA_ENABLE_SUBSCRIPTIONS
// Take another look at the.answer... this should call the handler.
UA_Client_Subscriptions_manuallySendPublishRequest(client);
// Delete our subscription (which also unmonitors all items)
if(!UA_Client_Subscriptions_remove(client, subId))
printf("Subscription removed\n");
#endif
#ifdef UA_ENABLE_METHODCALLS
/* Note: This example requires Namespace 0 Node 11489 (ServerType -> GetMonitoredItems)
FIXME: Provide a namespace 0 independant example on the server side
*/
UA_Variant input;
UA_String argString = UA_STRING("Hello Server");
UA_Variant_init(&input);
UA_Variant_setScalarCopy(&input, &argString, &UA_TYPES[UA_TYPES_STRING]);
size_t outputSize;
UA_Variant *output;
retval = UA_Client_call(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(1, 62541), 1, &input, &outputSize, &output);
if(retval == UA_STATUSCODE_GOOD) {
printf("Method call was successfull, and %lu returned values available.\n",
(unsigned long)outputSize);
UA_Array_delete(output, outputSize, &UA_TYPES[UA_TYPES_VARIANT]);
} else {
printf("Method call was unsuccessfull, and %x returned values available.\n", retval);
}
UA_Variant_deleteMembers(&input);
#endif
#ifdef UA_ENABLE_NODEMANAGEMENT
/* New ReferenceType */
UA_NodeId ref_id;
UA_ReferenceTypeAttributes ref_attr;
UA_ReferenceTypeAttributes_init(&ref_attr);
ref_attr.displayName = UA_LOCALIZEDTEXT("en_US", "NewReference");
ref_attr.description = UA_LOCALIZEDTEXT("en_US", "References something that might or might not exist");
ref_attr.inverseName = UA_LOCALIZEDTEXT("en_US", "IsNewlyReferencedBy");
retval = UA_Client_addReferenceTypeNode(client,
UA_NODEID_NUMERIC(1, 12133),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
UA_QUALIFIEDNAME(1, "NewReference"),
ref_attr, &ref_id);
if(retval == UA_STATUSCODE_GOOD )
printf("Created 'NewReference' with numeric NodeID %u\n", ref_id.identifier.numeric);
/* New ObjectType */
UA_NodeId objt_id;
UA_ObjectTypeAttributes objt_attr;
UA_ObjectTypeAttributes_init(&objt_attr);
objt_attr.displayName = UA_LOCALIZEDTEXT("en_US", "TheNewObjectType");
objt_attr.description = UA_LOCALIZEDTEXT("en_US", "Put innovative description here");
retval = UA_Client_addObjectTypeNode(client,
UA_NODEID_NUMERIC(1, 12134),
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "NewObjectType"),
objt_attr, &objt_id);
if(retval == UA_STATUSCODE_GOOD)
printf("Created 'NewObjectType' with numeric NodeID %u\n", objt_id.identifier.numeric);
/* New Object */
UA_NodeId obj_id;
UA_ObjectAttributes obj_attr;
UA_ObjectAttributes_init(&obj_attr);
obj_attr.displayName = UA_LOCALIZEDTEXT("en_US", "TheNewGreatNode");
obj_attr.description = UA_LOCALIZEDTEXT("de_DE", "Hier koennte Ihre Webung stehen!");
retval = UA_Client_addObjectNode(client,
UA_NODEID_NUMERIC(1, 0),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "TheGreatNode"),
UA_NODEID_NUMERIC(1, 12134),
obj_attr, &obj_id);
if(retval == UA_STATUSCODE_GOOD )
printf("Created 'NewObject' with numeric NodeID %u\n", obj_id.identifier.numeric);
/* New Integer Variable */
UA_NodeId var_id;
UA_VariableAttributes var_attr;
UA_VariableAttributes_init(&var_attr);
var_attr.displayName = UA_LOCALIZEDTEXT("en_US", "TheNewVariableNode");
var_attr.description =
UA_LOCALIZEDTEXT("en_US", "This integer is just amazing - it has digits and everything.");
UA_Int32 int_value = 1234;
/* This does not copy the value */
UA_Variant_setScalar(&var_attr.value, &int_value, &UA_TYPES[UA_TYPES_INT32]);
var_attr.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
retval = UA_Client_addVariableNode(client,
UA_NODEID_NUMERIC(1, 0), // Assign new/random NodeID
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(0, "VariableNode"),
UA_NODEID_NULL, // no variable type
var_attr, &var_id);
if(retval == UA_STATUSCODE_GOOD )
printf("Created 'NewVariable' with numeric NodeID %u\n", var_id.identifier.numeric);
#endif
UA_Client_disconnect(client);
UA_Client_delete(client);
return (int) UA_STATUSCODE_GOOD;
}
