void Service_AddReferences(UA_Server *server, UA_Session *session, const UA_AddReferencesRequest *request,
UA_AddReferencesResponse *response) {
if(request->referencesToAddSize <= 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO;
return;
}
size_t size = request->referencesToAddSize;
if(!(response->results = UA_malloc(sizeof(UA_StatusCode) * size))) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->resultsSize = size;
UA_memset(response->results, UA_STATUSCODE_GOOD, sizeof(UA_StatusCode) * size);
#ifdef UA_EXTERNAL_NAMESPACES
#ifdef NO_ALLOCA
UA_Boolean isExternal[size];
UA_UInt32 indices[size];
#else
UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
#endif /*NO_ALLOCA */
UA_memset(isExternal, UA_FALSE, sizeof(UA_Boolean) * size);
for(size_t j = 0; j < server->externalNamespacesSize; j++) {
size_t indicesSize = 0;
for(size_t i = 0;i < size;i++) {
if(request->referencesToAdd[i].sourceNodeId.namespaceIndex
!= server->externalNamespaces[j].index)
continue;
isExternal[i] = UA_TRUE;
indices[indicesSize] = i;
indicesSize++;
}
if (indicesSize == 0)
continue;
UA_ExternalNodeStore *ens = &server->externalNamespaces[j].externalNodeStore;
ens->addReferences(ens->ensHandle, &request->requestHeader, request->referencesToAdd,
indices, indicesSize, response->results, response->diagnosticInfos);
}
#endif
response->resultsSize = size;
for(UA_Int32 i = 0; i < response->resultsSize; i++) {
#ifdef UA_EXTERNAL_NAMESPACES
if(!isExternal[i])
#endif
UA_Server_addReferenceWithSession(server, session, &request->referencesToAdd[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(&UA_TYPES[UA_TYPES_ADDNODESRESULT], size);
if(!response->results) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
#ifdef UA_EXTERNAL_NAMESPACES
#ifdef NO_ALLOCA
UA_Boolean isExternal[size];
UA_UInt32 indices[size];
#else
UA_Boolean *isExternal = UA_alloca(sizeof(UA_Boolean) * size);
UA_UInt32 *indices = UA_alloca(sizeof(UA_UInt32) * size);
#endif /*NO_ALLOCA */
UA_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
addNodeFromAttributes(server, session, &request->nodesToAdd[i], &response->results[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;
}
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
}
