int main(int argc, char **argv)
{
signal(SIGINT, stopHandler);
signal(SIGTERM, stopHandler);
UA_Server *server = UA_Server_new();
UA_ServerConfig *config = UA_Server_getConfig(server);
UA_ServerConfig_setDefault(config);
config->customDataTypes = &customTypesArray;
UA_StatusCode retval;
/* create nodes from nodeset */
if(namespace_testnodeset_generated(server) != UA_STATUSCODE_GOOD) {
UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER,
"Could not add the example nodeset. "
"Check previous output for any error.");
retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
} else {
UA_Variant out;
UA_Variant_init(&out);
UA_Server_readValue(server, UA_NODEID_NUMERIC(2, 10002), &out);
UA_Point *p = (UA_Point *)out.data;
printf("point 2d x: %f y: %f \n", p->x, p->y);
retval = UA_Server_run(server, &running);
}
UA_Server_delete(server);
return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE;
}
} END_TEST
START_TEST(AddNodeTwiceGivesError) {
/* add a variable node to the address space */
UA_VariableAttributes attr = UA_VariableAttributes_default;
UA_Int32 myInteger = 42;
UA_Variant_setScalar(&attr.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
attr.description = UA_LOCALIZEDTEXT("en-US","the answer");
attr.displayName = UA_LOCALIZEDTEXT("en-US","the answer");
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_StatusCode res =
UA_Server_addVariableNode(server, myIntegerNodeId, parentNodeId,
parentReferenceNodeId, myIntegerName,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
attr, NULL, NULL);
ck_assert_int_eq(UA_STATUSCODE_GOOD, res);
res = UA_Server_addVariableNode(server, myIntegerNodeId, parentNodeId,
parentReferenceNodeId, myIntegerName,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
attr, NULL, NULL);
ck_assert_int_eq(res, UA_STATUSCODE_BADNODEIDEXISTS);
} END_TEST
int main(int argc, char** argv) {
signal(SIGINT, stopHandler);
signal(SIGTERM, stopHandler);
UA_ServerConfig config = UA_ServerConfig_standard;
UA_ServerNetworkLayer nl;
nl = UA_ServerNetworkLayerUDP(UA_ConnectionConfig_standard, 16664);
config.networkLayers = &nl;
config.networkLayersSize = 1;
UA_Server *server = UA_Server_new(config);
// add a variable node to the adresspace
UA_VariableAttributes attr;
UA_VariableAttributes_init(&attr);
UA_Int32 myInteger = 42;
UA_Variant_setScalar(&attr.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
attr.description = UA_LOCALIZEDTEXT("en_US","the answer");
attr.displayName = UA_LOCALIZEDTEXT("en_US","the answer");
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(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,
UA_NODEID_NULL, attr, NULL, NULL);
UA_StatusCode retval = UA_Server_run(server, &running);
UA_Server_delete(server);
return (int) retval;
}
static void
addVariable(size_t size) {
/* Define the attribute of the myInteger variable node */
UA_VariableAttributes attr = UA_VariableAttributes_default;
UA_Int32* array = (UA_Int32*)UA_malloc(size * sizeof(UA_Int32));
memset(array, 0, size * sizeof(UA_Int32));
UA_Variant_setArray(&attr.value, array, size, &UA_TYPES[UA_TYPES_INT32]);
char name[] = "my.variable";
attr.description = UA_LOCALIZEDTEXT("en-US", name);
attr.displayName = UA_LOCALIZEDTEXT("en-US", name);
attr.dataType = UA_TYPES[UA_TYPES_INT32].typeId;
/* Add the variable node to the information model */
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, name);
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, name);
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,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
attr, NULL, NULL);
UA_free(array);
}
int main(int argc, char** argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
UA_ServerConfig config = UA_ServerConfig_standard;
UA_ServerNetworkLayer nl = UA_ServerNetworkLayerTCP(UA_ConnectionConfig_standard, 16664);
config.networkLayers = &nl;
config.networkLayersSize = 1;
UA_Server *server = UA_Server_new(config);
/* add a variable node to the address space */
UA_Int32 myInteger = 42;
UA_NodeId myIntegerNodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName myIntegerName = UA_QUALIFIEDNAME(1, "the answer");
UA_DataSource dateDataSource = (UA_DataSource) {
.handle = &myInteger, .read = readInteger, .write = writeInteger};
UA_VariableAttributes attr;
UA_VariableAttributes_init(&attr);
attr.description = UA_LOCALIZEDTEXT("en_US","the answer");
attr.displayName = UA_LOCALIZEDTEXT("en_US","the answer");
UA_Server_addDataSourceVariableNode(server, myIntegerNodeId,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
myIntegerName, UA_NODEID_NULL, attr, dateDataSource, NULL);
UA_StatusCode retval = UA_Server_run(server, &running);
UA_Server_delete(server);
nl.deleteMembers(&nl);
return (int)retval;
}
static UA_StatusCode
instantiateObjectNode(UA_Server *server, UA_Session *session,
const UA_NodeId *nodeId, const UA_NodeId *typeId,
UA_InstantiationCallback *instantiationCallback) {
const UA_ObjectTypeNode *typenode = (const UA_ObjectTypeNode*)UA_NodeStore_get(server->nodestore, typeId);
if(!typenode)
return UA_STATUSCODE_BADNODEIDINVALID;
if(typenode->nodeClass != UA_NODECLASS_OBJECTTYPE)
return UA_STATUSCODE_BADNODECLASSINVALID;
/* Add all the child nodes */
UA_BrowseDescription browseChildren;
UA_BrowseDescription_init(&browseChildren);
browseChildren.nodeId = *typeId;
browseChildren.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES);
browseChildren.includeSubtypes = UA_TRUE;
browseChildren.browseDirection = UA_BROWSEDIRECTION_FORWARD;
browseChildren.nodeClassMask = UA_NODECLASS_OBJECT | UA_NODECLASS_VARIABLE | UA_NODECLASS_METHOD;
browseChildren.resultMask = UA_BROWSERESULTMASK_REFERENCETYPEID | UA_BROWSERESULTMASK_NODECLASS;
UA_BrowseResult browseResult;
UA_BrowseResult_init(&browseResult);
// todo: continuation points if there are too many results
Service_Browse_single(server, session, NULL, &browseChildren, 100, &browseResult);
for(size_t i = 0; i < browseResult.referencesSize; i++) {
UA_ReferenceDescription *rd = &browseResult.references[i];
if(rd->nodeClass == UA_NODECLASS_METHOD) {
/* add a reference to the method in the objecttype */
UA_AddReferencesItem item;
UA_AddReferencesItem_init(&item);
item.sourceNodeId = *nodeId;
item.referenceTypeId = rd->referenceTypeId;
item.isForward = UA_TRUE;
item.targetNodeId = rd->nodeId;
item.targetNodeClass = UA_NODECLASS_METHOD;
Service_AddReferences_single(server, session, &item);
} else if(rd->nodeClass == UA_NODECLASS_VARIABLE)
copyExistingVariable(server, session, &rd->nodeId.nodeId, &rd->referenceTypeId, nodeId, instantiationCallback);
else if(rd->nodeClass == UA_NODECLASS_OBJECT)
copyExistingObject(server, session, &rd->nodeId.nodeId, &rd->referenceTypeId, nodeId, instantiationCallback);
}
/* add a hastypedefinition reference */
UA_AddReferencesItem addref;
UA_AddReferencesItem_init(&addref);
addref.sourceNodeId = *nodeId;
addref.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
addref.isForward = UA_TRUE;
addref.targetNodeId.nodeId = *typeId;
addref.targetNodeClass = UA_NODECLASS_OBJECTTYPE;
Service_AddReferences_single(server, session, &addref);
/* call the constructor */
const UA_ObjectLifecycleManagement *olm = &typenode->lifecycleManagement;
if(olm->constructor)
UA_Server_editNode(server, session, nodeId,
(UA_EditNodeCallback)setObjectInstanceHandle, olm->constructor(*nodeId));
return UA_STATUSCODE_GOOD;
}
END_TEST
/* Send an async message and receive the response when the securechannel timed out */
START_TEST(SecureChannel_networkfail) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_ReadRequest rq;
UA_ReadRequest_init(&rq);
UA_ReadValueId rvi;
UA_ReadValueId_init(&rvi);
rvi.attributeId = UA_ATTRIBUTEID_VALUE;
rvi.nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE);
rq.nodesToRead = &rvi;
rq.nodesToReadSize = 1;
/* Forward the clock after recv in the client */
UA_ClientConfig *cconfig = UA_Client_getConfig(client);
UA_Client_recv = client->connection.recv;
client->connection.recv = UA_Client_recvTesting;
UA_Client_recvSleepDuration = cconfig->secureChannelLifeTime + 1;
UA_Variant val;
UA_Variant_init(&val);
UA_NodeId nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE);
retval = UA_Client_readValueAttribute(client, nodeId, &val);
ck_assert_msg(retval == UA_STATUSCODE_BADSECURECHANNELCLOSED);
UA_Client_disconnect(client);
UA_Client_delete(client);
}
static UA_NodeId addPubSubConnection(void){
UA_Variant publisherId;
UA_Variant_init(&publisherId);
UA_UInt32 publisherIdValue = 13245;
UA_Variant_setScalar(&publisherId, &publisherIdValue , &UA_TYPES[UA_TYPES_UINT32]);
UA_PubSubConnectionDataType pubSubConnection;
UA_PubSubConnectionDataType_init(&pubSubConnection);
pubSubConnection.name = UA_STRING("Model Connection 1");
pubSubConnection.enabled = UA_TRUE;
pubSubConnection.publisherId = publisherId;
pubSubConnection.transportProfileUri = UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-udp-uadp");
UA_ExtensionObject eo;
UA_NetworkAddressUrlDataType networkAddressDataType = {UA_STRING("eth0"), UA_STRING("opc.udp://224.0.0.22:4840/")};
UA_NetworkAddressUrlDataType* identityToken = UA_NetworkAddressUrlDataType_new();
UA_NetworkAddressUrlDataType_init(identityToken);
UA_NetworkAddressUrlDataType_copy(&networkAddressDataType, identityToken);
eo.encoding = UA_EXTENSIONOBJECT_DECODED;
eo.content.decoded.type = &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE];
eo.content.decoded.data = identityToken;
pubSubConnection.address = eo;
pubSubConnection.connectionPropertiesSize = 2;
UA_KeyValuePair connectionOptions[2];
memset(connectionOptions, 0, sizeof(UA_KeyValuePair)* 2);
connectionOptions[0].key = UA_QUALIFIEDNAME(0, "ttl");
UA_UInt32 ttl = 10;
UA_Variant_setScalar(&connectionOptions[0].value, &ttl, &UA_TYPES[UA_TYPES_UINT32]);
connectionOptions[1].key = UA_QUALIFIEDNAME(0, "loopback");
UA_Boolean loopback = UA_FALSE;
UA_Variant_setScalar(&connectionOptions[1].value, &loopback, &UA_TYPES[UA_TYPES_UINT32]);
pubSubConnection.connectionProperties = connectionOptions;
UA_Variant inputArguments;
UA_Variant_init(&inputArguments);
UA_Variant_setScalar(&inputArguments, &pubSubConnection, &UA_TYPES[UA_TYPES_PUBSUBCONNECTIONDATATYPE]);
UA_CallMethodRequest callMethodRequest;
UA_CallMethodRequest_init(&callMethodRequest);
callMethodRequest.inputArgumentsSize = 1;
callMethodRequest.inputArguments = &inputArguments;
callMethodRequest.objectId = UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE);
callMethodRequest.methodId = UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_ADDCONNECTION);
UA_NodeId connectionId = UA_NODEID_NULL;
UA_CallMethodResult result;
UA_CallMethodResult_init(&result);
result = UA_Server_call(server, &callMethodRequest);
ck_assert_int_eq(1, result.outputArgumentsSize);
ck_assert_int_eq(result.statusCode, UA_STATUSCODE_GOOD);
if(result.outputArguments->type == &UA_TYPES[UA_TYPES_NODEID])
connectionId = *((UA_NodeId *) result.outputArguments->data);
UA_ExtensionObject_deleteMembers(&eo);
callMethodRequest.inputArguments = NULL;
callMethodRequest.inputArgumentsSize = 0;
UA_CallMethodRequest_deleteMembers(&callMethodRequest);
UA_CallMethodResult_deleteMembers(&result);
return connectionId;
}
} END_TEST
START_TEST(AddAndRemovePublishedDataSetItems){
UA_StatusCode retVal;
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
retVal = UA_Client_connect(client, "opc.tcp://localhost:4840");
if(retVal != UA_STATUSCODE_GOOD) {
UA_Client_delete(client);
}
ck_assert_int_eq(retVal, UA_STATUSCODE_GOOD);
UA_Variant *inputArguments = (UA_Variant *) UA_calloc(4, (sizeof(UA_Variant)));
UA_String pdsName = UA_STRING("Test PDS");
UA_Variant_setScalar(&inputArguments[0], &pdsName, &UA_TYPES[UA_TYPES_STRING]);
UA_String *fieldNameAliases = (UA_String *) UA_calloc(2, sizeof(UA_String));
fieldNameAliases[0] = UA_STRING("field1");
fieldNameAliases[1] = UA_STRING("field2");
UA_Variant_setArray(&inputArguments[1], fieldNameAliases, 2, &UA_TYPES[UA_TYPES_STRING]);
UA_DataSetFieldFlags *dataSetFieldFlags = (UA_DataSetFieldFlags *) UA_calloc(2, sizeof(UA_DataSetFieldFlags));
dataSetFieldFlags[0] = UA_DATASETFIELDFLAGS_PROMOTEDFIELD;
dataSetFieldFlags[1] = UA_DATASETFIELDFLAGS_PROMOTEDFIELD;
UA_Variant_setArray(&inputArguments[2], dataSetFieldFlags, 2, &UA_TYPES[UA_TYPES_DATASETFIELDFLAGS]);
UA_PublishedVariableDataType *variablesToAdd = (UA_PublishedVariableDataType *) UA_calloc(2, sizeof(UA_PublishedVariableDataType));
variablesToAdd[0].publishedVariable = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_LOCALTIME);
variablesToAdd[0].attributeId = UA_ATTRIBUTEID_VALUE;
variablesToAdd[1].publishedVariable = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERREDUNDANCY_CURRENTSERVERID);
variablesToAdd[1].attributeId = UA_ATTRIBUTEID_VALUE;
UA_Variant_setArray(&inputArguments[3], variablesToAdd, 2, &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]);
UA_CallMethodRequest callMethodRequest;
UA_CallMethodRequest_init(&callMethodRequest);
callMethodRequest.inputArgumentsSize = 4;
callMethodRequest.inputArguments = inputArguments;
callMethodRequest.objectId = UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS);
callMethodRequest.methodId = UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS);
UA_CallMethodResult result;
UA_CallMethodResult_init(&result);
result = UA_Server_call(server, &callMethodRequest);
ck_assert_int_eq(3, result.outputArgumentsSize);
ck_assert_int_eq(result.statusCode, UA_STATUSCODE_GOOD);
//TODO checked correctness of created items
UA_CallMethodResult_deleteMembers(&result);
UA_free(inputArguments);
UA_free(fieldNameAliases);
UA_free(dataSetFieldFlags);
UA_free(variablesToAdd);
UA_Client_disconnect(client);
UA_Client_delete(client);
} END_TEST
//#######################################MAIN#######################################
int main(int argc, char** argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
if (gpioInitialise() < 0)
{
fprintf(stderr, "pigpio initialisation failed\n");
return 1;
}
gpioSetMode(17, PI_OUTPUT);
gpioSetMode(22, PI_INPUT);
gpioSetMode(24, PI_OUTPUT);
UA_ServerConfig config = UA_ServerConfig_standard;
UA_ServerNetworkLayer nl = UA_ServerNetworkLayerTCP(UA_ConnectionConfig_standard, 16664);
config.networkLayers = &nl;
config.networkLayersSize = 1;
UA_Server *server = UA_Server_new(config);
/* add a variable node to the address space */
UA_Int32 myIntegerB = 32;
UA_NodeId myIntegerBNodeId = UA_NODEID_STRING(1, "button");
UA_QualifiedName myIntegerBName = UA_QUALIFIEDNAME(1, "button");
UA_DataSource dateDataSource = (UA_DataSource) {
.handle = &myIntegerB, .read = readIntegerB, .write = writeIntegerB};
UA_VariableAttributes attr;
UA_VariableAttributes_init(&attr);
attr.description = UA_LOCALIZEDTEXT("en_US","button_on_off");
attr.displayName = UA_LOCALIZEDTEXT("en_US","button");
UA_Server_addDataSourceVariableNode(server, myIntegerBNodeId,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
myIntegerBName, UA_NODEID_NULL, attr, dateDataSource, NULL);
/* add a repeated job to the server */
UA_Job job = {.type = UA_JOBTYPE_METHODCALL,
.job.methodCall = {.method = testCallback, .data = NULL} };
UA_Server_addRepeatedJob(server, job, 2000, NULL); // call every 2 sec
UA_StatusCode retval = UA_Server_run(server, &running);
UA_Server_delete(server);
nl.deleteMembers(&nl);
return (int)retval;
}
static UA_StatusCode
addNewEventType(UA_Server *server) {
UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default;
attr.displayName = UA_LOCALIZEDTEXT("en-US", "SimpleEventType");
attr.description = UA_LOCALIZEDTEXT("en-US", "The simple event type we created");
return UA_Server_addObjectTypeNode(server, UA_NODEID_NULL,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
UA_QUALIFIEDNAME(0, "SimpleEventType"),
attr, NULL, &eventType);
}
static void
addPumpObjectInstance(UA_Server *server, char *name) {
UA_ObjectAttributes oAttr = UA_ObjectAttributes_default;
oAttr.displayName = UA_LOCALIZEDTEXT("en-US", name);
UA_Server_addObjectNode(server, UA_NODEID_NULL,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, name),
pumpTypeId, /* this refers to the object type
identifier */
oAttr, NULL, NULL);
}
static void addNewEventType(void) {
UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default;
attr.displayName = UA_LOCALIZEDTEXT_ALLOC("en-US", "SimpleEventType");
attr.description = UA_LOCALIZEDTEXT_ALLOC("en-US", "The simple event type we created");
UA_Server_addObjectTypeNode(server, UA_NODEID_NULL,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE),
UA_QUALIFIEDNAME(0, "SimpleEventType"),
attr, NULL, &eventType);
UA_LocalizedText_deleteMembers(&attr.displayName);
UA_LocalizedText_deleteMembers(&attr.description);
}
UA_Boolean
UA_Node_hasSubTypeOrInstances(const UA_Node *node) {
const UA_NodeId hasSubType = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
const UA_NodeId hasTypeDefinition = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
for(size_t i = 0; i < node->referencesSize; ++i) {
if(node->references[i].isInverse == false &&
UA_NodeId_equal(&node->references[i].referenceTypeId, &hasSubType))
return true;
if(node->references[i].isInverse == true &&
UA_NodeId_equal(&node->references[i].referenceTypeId, &hasTypeDefinition))
return true;
}
return false;
}
END_TEST
START_TEST(Client_methodcall) {
UA_Client *client = UA_Client_new(UA_ClientConfig_default);
UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_UInt32 subId;
retval = UA_Client_Subscriptions_new(client, UA_SubscriptionSettings_default, &subId);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
/* monitor the server state */
UA_UInt32 monId;
retval = UA_Client_Subscriptions_addMonitoredItem(client, subId, UA_NODEID_NUMERIC(0, 2259),
UA_ATTRIBUTEID_VALUE, NULL, NULL, &monId);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
/* call a method to get monitored item id */
UA_Variant input;
UA_Variant_init(&input);
UA_Variant_setScalarCopy(&input, &subId, &UA_TYPES[UA_TYPES_UINT32]);
size_t outputSize;
UA_Variant *output;
retval = UA_Client_call(client, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER),
UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_GETMONITOREDITEMS), 1, &input, &outputSize, &output);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
ck_assert_uint_eq(outputSize, 2);
ck_assert_uint_eq(output[0].arrayLength, 1);
ck_assert_uint_eq(*((UA_UInt32*)output[0].data), monId);
UA_Array_delete(output, outputSize, &UA_TYPES[UA_TYPES_VARIANT]);
UA_Variant_deleteMembers(&input);
/* call with invalid subscription id */
UA_Variant_init(&input);
subId = 0;
UA_Variant_setScalarCopy(&input, &subId, &UA_TYPES[UA_TYPES_UINT32]);
retval = UA_Client_call(client, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER),
UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_GETMONITOREDITEMS), 1, &input, &outputSize, &output);
ck_assert_uint_eq(retval, UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID);
UA_Variant_deleteMembers(&input);
UA_Client_disconnect(client);
UA_Client_delete(client);
}
static void
addGenerateEventMethod(UA_Server *server) {
UA_MethodAttributes generateAttr = UA_MethodAttributes_default;
generateAttr.description = UA_LOCALIZEDTEXT("en-US","Generate an event.");
generateAttr.displayName = UA_LOCALIZEDTEXT("en-US","Generate Event");
generateAttr.executable = true;
generateAttr.userExecutable = true;
UA_Server_addMethodNode(server, UA_NODEID_NUMERIC(1, 62541),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASORDEREDCOMPONENT),
UA_QUALIFIEDNAME(1, "Generate Event"),
generateAttr, &generateEventMethodCallback,
0, NULL, 0, NULL, NULL, NULL);
}
END_TEST
START_TEST(Nodes_createInheritedObject)
{
/* create an object/instance of the demo type */
UA_ObjectAttributes oAttr2 = UA_ObjectAttributes_default;
oAttr2.displayName = UA_LOCALIZEDTEXT("", "Demo");
oAttr2.description = UA_LOCALIZEDTEXT("", "");
UA_StatusCode retval = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 6020),
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "Demo"), UA_NODEID_NUMERIC(1, 6010),
oAttr2, NULL, NULL);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
}
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);
}
UA_StatusCode
UA_Server_addObjectNode(UA_Server *server, const UA_QualifiedName browseName,
UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId, const UA_NodeId typeDefinition)
{
UA_ObjectNode *node = UA_ObjectNode_new();
UA_NodeId_copy(&nodeId, &node->nodeId);
UA_QualifiedName_copy(&browseName, &node->browseName);
UA_String_copy(&browseName.name, &node->displayName.text);
UA_ExpandedNodeId parentId; // we need an expandednodeid
UA_ExpandedNodeId_init(&parentId);
UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
UA_AddNodesResult res =
UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, parentId, referenceTypeId);
if(res.statusCode != UA_STATUSCODE_GOOD) {
UA_ObjectNode_delete(node);
}
UA_AddNodesResult_deleteMembers(&res);
if(!(UA_NodeId_isNull(&typeDefinition))){
UA_ExpandedNodeId typeDefid; // we need an expandednodeid
UA_ExpandedNodeId_init(&typeDefid);
UA_NodeId_copy(&typeDefinition, &typeDefid.nodeId);
ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION), typeDefid);
}
return res.statusCode;
}
END_TEST
START_TEST(SecureChannel_cableunplugged) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant val;
UA_Variant_init(&val);
UA_NodeId nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE);
retval = UA_Client_readValueAttribute(client, nodeId, &val);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_Variant_deleteMembers(&val);
UA_Client_recv = client->connection.recv;
client->connection.recv = UA_Client_recvTesting;
/* Simulate network cable unplugged (no response from server) */
UA_Client_recvTesting_result = UA_STATUSCODE_GOODNONCRITICALTIMEOUT;
UA_Variant_init(&val);
retval = UA_Client_readValueAttribute(client, nodeId, &val);
ck_assert_uint_eq(retval, UA_STATUSCODE_BADCONNECTIONCLOSED);
ck_assert_msg(UA_Client_getState(client) == UA_CLIENTSTATE_DISCONNECTED);
UA_Client_recvTesting_result = UA_STATUSCODE_GOOD;
UA_Client_delete(client);
}
END_TEST
/* Send the next message after the securechannel timed out */
START_TEST(SecureChannel_timeout_fail) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
UA_ClientConfig *cconfig = UA_Client_getConfig(client);
UA_fakeSleep(cconfig->secureChannelLifeTime + 1);
UA_realSleep(50 + 1); // UA_MAXTIMEOUT+1 wait to be sure UA_Server_run_iterate can be completely executed
UA_Variant val;
UA_Variant_init(&val);
UA_NodeId nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE);
retval = UA_Client_readValueAttribute(client, nodeId, &val);
ck_assert(retval != UA_STATUSCODE_GOOD);
UA_Variant_deleteMembers(&val);
UA_Client_disconnect(client);
UA_Client_delete(client);
}
/**
* Triggering an event
* ^^^^^^^^^^^^^^^^^^^
* First a node representing an event is generated using ``setUpEvent``. Once our event is good to go, we specify
* a node which emits the event - in this case the server node. We can use ``UA_Server_triggerEvent`` to trigger our
* event onto said node. Passing ``NULL`` as the second-last argument means we will not receive the `EventId`.
* The last boolean argument states whether the node should be deleted. */
static UA_StatusCode
generateEventMethodCallback(UA_Server *server,
const UA_NodeId *sessionId, void *sessionHandle,
const UA_NodeId *methodId, void *methodContext,
const UA_NodeId *objectId, void *objectContext,
size_t inputSize, const UA_Variant *input,
size_t outputSize, UA_Variant *output) {
UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "Creating event");
/* set up event */
UA_NodeId eventNodeId;
UA_StatusCode retval = setUpEvent(server, &eventNodeId);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Creating event failed. StatusCode %s", UA_StatusCode_name(retval));
return retval;
}
retval = UA_Server_triggerEvent(server, eventNodeId,
UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER),
NULL, UA_TRUE);
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND,
"Triggering event failed. StatusCode %s", UA_StatusCode_name(retval));
return retval;
}
static UA_StatusCode argConformsToDefinition(UA_CallMethodRequest *rs, const UA_VariableNode *argDefinition) {
if(argDefinition->value.variant.type != &UA_TYPES[UA_TYPES_ARGUMENT] &&
argDefinition->value.variant.type != &UA_TYPES[UA_TYPES_EXTENSIONOBJECT])
return UA_STATUSCODE_BADINTERNALERROR;
if(rs->inputArgumentsSize < argDefinition->value.variant.arrayLength)
return UA_STATUSCODE_BADARGUMENTSMISSING;
if(rs->inputArgumentsSize > argDefinition->value.variant.arrayLength)
return UA_STATUSCODE_BADINVALIDARGUMENT;
const UA_ExtensionObject *thisArgDefExtObj;
UA_Variant *var;
UA_Argument arg;
size_t decodingOffset = 0;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
UA_NodeId ArgumentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ARGUMENT + UA_ENCODINGOFFSET_BINARY);
for(int i = 0; i<rs->inputArgumentsSize; i++) {
var = &rs->inputArguments[i];
if(argDefinition->value.variant.type == &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]) {
thisArgDefExtObj = &((const UA_ExtensionObject *) (argDefinition->value.variant.data))[i];
decodingOffset = 0;
if(!UA_NodeId_equal(&ArgumentNodeId, &thisArgDefExtObj->typeId))
return UA_STATUSCODE_BADINTERNALERROR;
UA_decodeBinary(&thisArgDefExtObj->body, &decodingOffset, &arg, &UA_TYPES[UA_TYPES_ARGUMENT]);
} else if(argDefinition->value.variant.type == &UA_TYPES[UA_TYPES_ARGUMENT])
arg = ((UA_Argument *) argDefinition->value.variant.data)[i];
retval |= statisfySignature(var, arg);
}
return retval;
}
static UA_StatusCode eventSetup(UA_NodeId *eventNodeId) {
UA_StatusCode retval;
retval = UA_Server_createEvent(server, eventType, eventNodeId);
ck_assert_uint_eq(retval, UA_STATUSCODE_GOOD);
// add a severity to the event
UA_Variant value;
UA_RelativePathElement rpe;
UA_RelativePathElement_init(&rpe);
rpe.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
rpe.isInverse = false;
rpe.includeSubtypes = false;
UA_BrowsePath bp;
UA_BrowsePath_init(&bp);
bp.startingNode = *eventNodeId;
bp.relativePath.elementsSize = 1;
bp.relativePath.elements = &rpe;
rpe.targetName = UA_QUALIFIEDNAME(0, "Severity");
UA_BrowsePathResult bpr = UA_Server_translateBrowsePathToNodeIds(server, &bp);
// number with no special meaning
UA_UInt16 eventSeverity = 1000;
UA_Variant_setScalar(&value, &eventSeverity, &UA_TYPES[UA_TYPES_UINT16]);
UA_Server_writeValue(server, bpr.targets[0].targetId.nodeId, value);
UA_BrowsePathResult_deleteMembers(&bpr);
//add a message to the event
rpe.targetName = UA_QUALIFIEDNAME(0, "Message");
bpr = UA_Server_translateBrowsePathToNodeIds(server, &bp);
UA_LocalizedText message = UA_LOCALIZEDTEXT("en-US", "Generated Event");
UA_Variant_setScalar(&value, &message, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
UA_Server_writeValue(server, bpr.targets[0].targetId.nodeId, value);
UA_BrowsePathResult_deleteMembers(&bpr);
return retval;
}
int main(int argc, char** argv) {
signal(SIGINT, stopHandler); /* catches ctrl-c */
#ifdef UA_ENABLE_MULTITHREADING
pthread_rwlock_init(&writeLock, 0);
#endif
UA_ServerNetworkLayer nl = UA_ServerNetworkLayerTCP(UA_ConnectionConfig_standard, 16664);
UA_ServerConfig config = UA_ServerConfig_standard;
config.serverCertificate = loadCertificate();
config.networkLayers = &nl;
config.networkLayersSize = 1;
UA_Server *server = UA_Server_new(config);
// add node with the datetime data source
UA_DataSource dateDataSource = (UA_DataSource) {.handle = NULL, .read = readTimeData, .write = NULL};
UA_VariableAttributes v_attr;
UA_VariableAttributes_init(&v_attr);
v_attr.description = UA_LOCALIZEDTEXT("en_US","current time");
v_attr.displayName = UA_LOCALIZEDTEXT("en_US","current time");
v_attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
const UA_QualifiedName dateName = UA_QUALIFIEDNAME(1, "current time");
UA_NodeId dataSourceId;
UA_Server_addDataSourceVariableNode(server, UA_NODEID_NULL,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), dateName,
UA_NODEID_NULL, v_attr, dateDataSource, &dataSourceId);
#ifndef _WIN32
/* cpu temperature monitoring for linux machines */
const char *temperatureFileName = "/sys/class/thermal/thermal_zone0/temp"; // RaspberryPi
// const char *temperatureFileName = "/sys/class/hwmon/hwmon0/device/temp1_input"; // Beaglebone
// const char *temperatureFileName = "/sys/class/thermal/thermal_zone3/temp"; // Intel Edison Alternative 1
// const char *temperatureFileName = "/sys/class/thermal/thermal_zone4/temp"; // Intel Edison Alternative 2
if((temperatureFile = fopen(temperatureFileName, "r"))) {
// add node with the data source
UA_DataSource temperatureDataSource = (UA_DataSource) {
.handle = NULL, .read = readTemperature, .write = NULL};
const UA_QualifiedName tempName = UA_QUALIFIEDNAME(1, "cpu temperature");
UA_VariableAttributes_init(&v_attr);
v_attr.description = UA_LOCALIZEDTEXT("en_US","temperature");
v_attr.displayName = UA_LOCALIZEDTEXT("en_US","temperature");
v_attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
UA_Server_addDataSourceVariableNode(server, UA_NODEID_NULL,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), tempName,
UA_NODEID_NULL, v_attr, temperatureDataSource, NULL);
}
const UA_Node *
getNodeType(UA_Server *server, const UA_Node *node) {
/* The reference to the parent is different for variable and variabletype */
UA_NodeId parentRef;
UA_Boolean inverse;
UA_NodeClass typeNodeClass;
switch(node->nodeClass) {
case UA_NODECLASS_OBJECT:
parentRef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
inverse = false;
typeNodeClass = UA_NODECLASS_OBJECTTYPE;
break;
case UA_NODECLASS_VARIABLE:
parentRef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
inverse = false;
typeNodeClass = UA_NODECLASS_VARIABLETYPE;
break;
case UA_NODECLASS_OBJECTTYPE:
case UA_NODECLASS_VARIABLETYPE:
case UA_NODECLASS_REFERENCETYPE:
case UA_NODECLASS_DATATYPE:
parentRef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE);
inverse = true;
typeNodeClass = node->nodeClass;
break;
default:
return NULL;
}
/* Return the first matching candidate */
for(size_t i = 0; i < node->referencesSize; ++i) {
if(node->references[i].isInverse != inverse)
continue;
if(!UA_NodeId_equal(&node->references[i].referenceTypeId, &parentRef))
continue;
UA_assert(node->references[i].targetIdsSize > 0);
const UA_NodeId *targetId = &node->references[i].targetIds[0].nodeId;
const UA_Node *type = UA_Nodestore_getNode(server->nsCtx, targetId);
if(!type)
continue;
if(type->nodeClass == typeNodeClass)
return type;
UA_Nodestore_releaseNode(server->nsCtx, type);
}
return NULL;
}
int main(void) {
UA_Client *client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
UA_StatusCode retval = UA_Client_connect_username(client, "opc.tcp://localhost:4840", "paula", "paula123");
if(retval != UA_STATUSCODE_GOOD) {
UA_Client_delete(client);
return EXIT_FAILURE;
}
UA_NodeId newVariableIdRequest = UA_NODEID_NUMERIC(1, 1001);
UA_NodeId newVariableId = UA_NODEID_NULL;
UA_VariableAttributes newVariableAttributes = UA_VariableAttributes_default;
newVariableAttributes.accessLevel = UA_ACCESSLEVELMASK_READ;
newVariableAttributes.description = UA_LOCALIZEDTEXT_ALLOC("en-US", "NewVariable desc");
newVariableAttributes.displayName = UA_LOCALIZEDTEXT_ALLOC("en-US", "NewVariable");
newVariableAttributes.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
UA_UInt32 value = 50;
UA_Variant_setScalarCopy(&newVariableAttributes.value, &value, &UA_TYPES[UA_TYPES_UINT32]);
UA_StatusCode retCode;
retCode = UA_Client_addVariableNode(client, newVariableIdRequest,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES),
UA_QUALIFIEDNAME(1, "newVariable"),
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
newVariableAttributes, &newVariableId);
printf("addVariable returned: %s\n", UA_StatusCode_name(retCode));
UA_ExpandedNodeId extNodeId = UA_EXPANDEDNODEID_NUMERIC(0, 0);
extNodeId.nodeId = newVariableId;
retCode = UA_Client_addReference(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), UA_TRUE,
UA_STRING_NULL, extNodeId, UA_NODECLASS_VARIABLE);
printf("addReference returned: %s\n", UA_StatusCode_name(retCode));
retCode = UA_Client_deleteReference(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), UA_TRUE, extNodeId,
UA_TRUE);
printf("deleteReference returned: %s\n", UA_StatusCode_name(retCode));
retCode = UA_Client_deleteNode(client, newVariableId, UA_TRUE);
printf("deleteNode returned: %s\n", UA_StatusCode_name(retCode));
/* Clean up */
UA_VariableAttributes_clear(&newVariableAttributes);
UA_Client_delete(client); /* Disconnects the client internally */
return EXIT_SUCCESS;
}
static void
addVariableFail(UA_Server *server) {
/* Prepare the node attributes */
UA_VariableAttributes vAttr = UA_VariableAttributes_default;
vAttr.dataType = UA_TYPES[UA_TYPES_DOUBLE].typeId;
vAttr.valueRank = -1; /* a scalar. this is not allowed per the variable type */
vAttr.displayName = UA_LOCALIZEDTEXT("en-US", "2DPoint Variable (fail)");
UA_String s = UA_STRING("2dpoint?");
UA_Variant_setScalar(&vAttr.value, &s, &UA_TYPES[UA_TYPES_STRING]);
/* Add the node */
UA_Server_addVariableNode(server, UA_NODEID_NULL,
UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER),
UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT),
UA_QUALIFIEDNAME(1, "2DPoint Type (fail)"), pointTypeId,
vAttr, NULL, NULL);
}
/* copy an existing variable under the given parent. then instantiate the
variable for all hastypedefinitions of the original version. */
static UA_StatusCode
copyExistingVariable(UA_Server *server, UA_Session *session, const UA_NodeId *variable,
const UA_NodeId *referenceType, const UA_NodeId *parent) {
const UA_VariableNode *node = (const UA_VariableNode*)UA_NodeStore_get(server->nodestore, variable);
if(!node)
return UA_STATUSCODE_BADNODEIDINVALID;
if(node->nodeClass != UA_NODECLASS_VARIABLE)
return UA_STATUSCODE_BADNODECLASSINVALID;
// copy the variable attributes
UA_VariableAttributes attr;
UA_VariableAttributes_init(&attr);
UA_LocalizedText_copy(&node->displayName, &attr.displayName);
UA_LocalizedText_copy(&node->description, &attr.description);
attr.writeMask = node->writeMask;
attr.userWriteMask = node->userWriteMask;
// todo: handle data sources!!!!
UA_Variant_copy(&node->value.variant.value, &attr.value);
// datatype is taken from the value
// valuerank is taken from the value
// array dimensions are taken from the value
attr.accessLevel = node->accessLevel;
attr.userAccessLevel = node->userAccessLevel;
attr.minimumSamplingInterval = node->minimumSamplingInterval;
attr.historizing = node->historizing;
UA_AddNodesItem item;
UA_AddNodesItem_init(&item);
UA_NodeId_copy(parent, &item.parentNodeId.nodeId);
UA_NodeId_copy(referenceType, &item.referenceTypeId);
UA_QualifiedName_copy(&node->browseName, &item.browseName);
item.nodeClass = UA_NODECLASS_VARIABLE;
item.nodeAttributes.encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE;
item.nodeAttributes.content.decoded.type = &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES];
item.nodeAttributes.content.decoded.data = &attr;
// don't add a typedefinition here.
// add the new variable
UA_AddNodesResult res;
UA_AddNodesResult_init(&res);
Service_AddNodes_single(server, session, &item, &res);
UA_VariableAttributes_deleteMembers(&attr);
UA_AddNodesItem_deleteMembers(&item);
// now instantiate the variable for all hastypedefinition references
for(size_t i = 0; i < node->referencesSize; i++) {
UA_ReferenceNode *rn = &node->references[i];
if(rn->isInverse)
continue;
const UA_NodeId hasTypeDef = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
if(!UA_NodeId_equal(&rn->referenceTypeId, &hasTypeDef))
continue;
instantiateVariableNode(server, session, &res.addedNodeId, &rn->targetId.nodeId);
}
UA_AddNodesResult_deleteMembers(&res);
return UA_STATUSCODE_GOOD;
}
END_TEST
START_TEST(failToFindNodeInOtherUA_NodeStore) {
UA_Node* n1 = createNode(0,2255);
ns.insertNode(ns.context, n1, NULL);
UA_NodeId in1 = UA_NODEID_NUMERIC(1, 2255);
const UA_Node* nr = ns.getNode(ns.context, &in1);
ck_assert_int_eq((uintptr_t)nr, 0);
}