/* Used in inline functions exposing the Read service with more syntactic sugar
* for individual attributes */
UA_StatusCode
__UA_Server_read(UA_Server *server, const UA_NodeId *nodeId,
const UA_AttributeId attributeId, void *v) {
/* Call the read service */
UA_ReadValueId item;
UA_ReadValueId_init(&item);
item.nodeId = *nodeId;
item.attributeId = attributeId;
UA_DataValue dv = UA_Server_read(server, &item, UA_TIMESTAMPSTORETURN_NEITHER);
/* Check the return value */
UA_StatusCode retval = UA_STATUSCODE_GOOD;
if(dv.hasStatus)
retval = dv.status;
else if(!dv.hasValue)
retval = UA_STATUSCODE_BADUNEXPECTEDERROR;
if(retval != UA_STATUSCODE_GOOD) {
UA_DataValue_deleteMembers(&dv);
return retval;
}
/* Prepare the result */
if(attributeId == UA_ATTRIBUTEID_VALUE ||
attributeId == UA_ATTRIBUTEID_ARRAYDIMENSIONS) {
/* Return the entire variant */
if(dv.value.storageType == UA_VARIANT_DATA_NODELETE) {
retval = UA_Variant_copy(&dv.value,(UA_Variant *) v);
} else {
/* storageType is UA_VARIANT_DATA. Copy the entire variant
* (including pointers and all) */
memcpy(v, &dv.value, sizeof(UA_Variant));
}
} else {
/* Return the variant content only */
if(dv.value.storageType == UA_VARIANT_DATA_NODELETE) {
retval = UA_copy(dv.value.data, v, dv.value.type);
} else {
/* storageType is UA_VARIANT_DATA. Copy the content of the type
* (including pointers and all) */
memcpy(v, dv.value.data, dv.value.type->memSize);
/* Delete the "carrier" in the variant */
UA_free(dv.value.data);
}
}
return retval;
}
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
CopyAttributeIntoNode(UA_Server *server, UA_Session *session,
UA_Node *node, const UA_WriteValue *wvalue) {
if(!wvalue->value.hasValue)
return UA_STATUSCODE_BADNODATA;
void *value = wvalue->value.value.data;
void *target = NULL;
const UA_DataType *type = NULL;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
switch(wvalue->attributeId) {
case UA_ATTRIBUTEID_NODEID:
case UA_ATTRIBUTEID_NODECLASS:
case UA_ATTRIBUTEID_DATATYPE:
retval = UA_STATUSCODE_BADWRITENOTSUPPORTED;
break;
case UA_ATTRIBUTEID_BROWSENAME:
CHECK_DATATYPE(QUALIFIEDNAME);
target = &node->browseName;
type = &UA_TYPES[UA_TYPES_QUALIFIEDNAME];
break;
case UA_ATTRIBUTEID_DISPLAYNAME:
CHECK_DATATYPE(LOCALIZEDTEXT);
target = &node->displayName;
type = &UA_TYPES[UA_TYPES_LOCALIZEDTEXT];
break;
case UA_ATTRIBUTEID_DESCRIPTION:
CHECK_DATATYPE(LOCALIZEDTEXT);
target = &node->description;
type = &UA_TYPES[UA_TYPES_LOCALIZEDTEXT];
break;
case UA_ATTRIBUTEID_WRITEMASK:
CHECK_DATATYPE(UINT32);
node->writeMask = *(UA_UInt32*)value;
break;
case UA_ATTRIBUTEID_USERWRITEMASK:
CHECK_DATATYPE(UINT32);
node->userWriteMask = *(UA_UInt32*)value;
break;
case UA_ATTRIBUTEID_ISABSTRACT:
CHECK_NODECLASS_WRITE(UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_REFERENCETYPE |
UA_NODECLASS_VARIABLETYPE | UA_NODECLASS_DATATYPE);
CHECK_DATATYPE(BOOLEAN);
((UA_ObjectTypeNode*)node)->isAbstract = *(UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_SYMMETRIC:
CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
CHECK_DATATYPE(BOOLEAN);
((UA_ReferenceTypeNode*)node)->symmetric = *(UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_INVERSENAME:
CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE);
CHECK_DATATYPE(LOCALIZEDTEXT);
target = &((UA_ReferenceTypeNode*)node)->inverseName;
type = &UA_TYPES[UA_TYPES_LOCALIZEDTEXT];
break;
case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW);
CHECK_DATATYPE(BOOLEAN);
((UA_ViewNode*)node)->containsNoLoops = *(UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_EVENTNOTIFIER:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
CHECK_DATATYPE(BYTE);
((UA_ViewNode*)node)->eventNotifier = *(UA_Byte*)value;
break;
case UA_ATTRIBUTEID_VALUE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
if(((const UA_VariableNode*)node)->valueSource == UA_VALUESOURCE_VARIANT)
retval = CopyValueIntoNode((UA_VariableNode*)node, wvalue);
else
retval = Service_Write_single_ValueDataSource(server, session, (const UA_VariableNode*)node, wvalue);
break;
case UA_ATTRIBUTEID_ACCESSLEVEL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_DATATYPE(BYTE);
((UA_VariableNode*)node)->accessLevel = *(UA_Byte*)value;
break;
case UA_ATTRIBUTEID_USERACCESSLEVEL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_DATATYPE(BYTE);
((UA_VariableNode*)node)->userAccessLevel = *(UA_Byte*)value;
break;
case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_DATATYPE(DOUBLE);
((UA_VariableNode*)node)->minimumSamplingInterval = *(UA_Double*)value;
break;
case UA_ATTRIBUTEID_HISTORIZING:
CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE);
CHECK_DATATYPE(BOOLEAN);
((UA_VariableNode*)node)->historizing = *(UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_EXECUTABLE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
CHECK_DATATYPE(BOOLEAN);
((UA_MethodNode*)node)->executable = *(UA_Boolean*)value;
break;
case UA_ATTRIBUTEID_USEREXECUTABLE:
CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD);
CHECK_DATATYPE(BOOLEAN);
((UA_MethodNode*)node)->userExecutable = *(UA_Boolean*)value;
break;
default:
retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
break;
}
if(type) {
UA_deleteMembers(target, type);
retval = UA_copy(value, target, type);
}
return retval;
}
