void Service_OpenSecureChannel(UA_Server *server, UA_Connection *connection,
const UA_OpenSecureChannelRequest *request,
UA_OpenSecureChannelResponse *response) {
// todo: if(request->clientProtocolVersion != protocolVersion)
if(request->requestType == UA_SECURITYTOKENREQUESTTYPE_ISSUE) {
response->responseHeader.serviceResult =
UA_SecureChannelManager_open(&server->secureChannelManager, connection, request, response);
if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD)
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Opened SecureChannel %i on Connection %i",
response->securityToken.channelId, connection->sockfd);
else
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Opening SecureChannel on Connection %i failed", connection->sockfd);
} else {
response->responseHeader.serviceResult =
UA_SecureChannelManager_renew(&server->secureChannelManager, connection, request, response);
if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD)
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Renewed SecureChannel %i on Connection %i",
response->securityToken.channelId, connection->sockfd);
else
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Renewing SecureChannel on Connection %i failed", connection->sockfd);
}
}
/*receives hello ack, opens secure channel*/
UA_StatusCode
processACKResponseAsync(void *application, UA_Connection *connection,
UA_ByteString *chunk) {
UA_Client *client = (UA_Client*)application;
/* Decode the message */
size_t offset = 0;
UA_TcpMessageHeader messageHeader;
UA_TcpAcknowledgeMessage ackMessage;
client->connectStatus = UA_TcpMessageHeader_decodeBinary (chunk, &offset,
&messageHeader);
client->connectStatus |= UA_TcpAcknowledgeMessage_decodeBinary(
chunk, &offset, &ackMessage);
if (client->connectStatus != UA_STATUSCODE_GOOD) {
UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_NETWORK,
"Decoding ACK message failed");
return client->connectStatus;
}
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Received ACK message");
client->connectStatus =
UA_Connection_processHELACK(connection, &client->config.localConnectionConfig,
(const UA_ConnectionConfig*)&ackMessage);
if(client->connectStatus != UA_STATUSCODE_GOOD)
return client->connectStatus;
client->state = UA_CLIENTSTATE_CONNECTED;
/* Open a SecureChannel. TODO: Select with endpoint */
client->channel.connection = &client->connection;
client->connectStatus = openSecureChannelAsync(client/*, false*/);
return client->connectStatus;
}
static void
serverOnNetworkCallback(const UA_ServerOnNetwork *serverOnNetwork, UA_Boolean isServerAnnounce,
UA_Boolean isTxtReceived, void *data) {
if(discovery_url != NULL || !isServerAnnounce) {
UA_LOG_DEBUG(logger, UA_LOGCATEGORY_SERVER,
"serverOnNetworkCallback called, but discovery URL "
"already initialized or is not announcing. Ignoring.");
return; // we already have everything we need or we only want server announces
}
if(self_discovery_url != NULL && UA_String_equal(&serverOnNetwork->discoveryUrl, self_discovery_url)) {
// skip self
return;
}
if(!isTxtReceived)
return; // we wait until the corresponding TXT record is announced.
// Problem: how to handle if a Server does not announce the
// optional TXT?
// here you can filter for a specific LDS server, e.g. call FindServers on
// the serverOnNetwork to make sure you are registering with the correct
// LDS. We will ignore this for now
UA_LOG_INFO(logger, UA_LOGCATEGORY_SERVER, "Another server announced itself on %.*s",
(int)serverOnNetwork->discoveryUrl.length, serverOnNetwork->discoveryUrl.data);
if(discovery_url != NULL)
UA_free(discovery_url);
discovery_url = (char*)UA_malloc(serverOnNetwork->discoveryUrl.length + 1);
memcpy(discovery_url, serverOnNetwork->discoveryUrl.data, serverOnNetwork->discoveryUrl.length);
discovery_url[serverOnNetwork->discoveryUrl.length] = 0;
}
/*
* Get the endpoint from the server, where we can call RegisterServer2 (or RegisterServer).
* This is normally the endpoint with highest supported encryption mode.
*
* @param discoveryServerUrl The discovery url from the remote server
* @return The endpoint description (which needs to be freed) or NULL
*/
static
UA_EndpointDescription *getRegisterEndpointFromServer(const char *discoveryServerUrl) {
UA_Client *client = UA_Client_new(UA_ClientConfig_default);
UA_EndpointDescription *endpointArray = NULL;
size_t endpointArraySize = 0;
UA_StatusCode retval = UA_Client_getEndpoints(client, discoveryServerUrl,
&endpointArraySize, &endpointArray);
if (retval != UA_STATUSCODE_GOOD) {
UA_Array_delete(endpointArray, endpointArraySize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
UA_LOG_ERROR(logger, UA_LOGCATEGORY_SERVER, "GetEndpoints failed with %s", UA_StatusCode_name(retval));
UA_Client_delete(client);
return NULL;
}
UA_LOG_DEBUG(logger, UA_LOGCATEGORY_SERVER, "Server has %ld endpoints", endpointArraySize);
UA_EndpointDescription *foundEndpoint = NULL;
for (size_t i = 0; i < endpointArraySize; i++) {
UA_LOG_DEBUG(logger, UA_LOGCATEGORY_SERVER, "\tURL = %.*s, SecurityMode = %s",
(int) endpointArray[i].endpointUrl.length,
endpointArray[i].endpointUrl.data,
endpointArray[i].securityMode == UA_MESSAGESECURITYMODE_NONE ? "None" :
endpointArray[i].securityMode == UA_MESSAGESECURITYMODE_SIGN ? "Sign" :
endpointArray[i].securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT ? "SignAndEncrypt" :
"Invalid"
);
// find the endpoint with highest supported security mode
if ((UA_String_equal(&endpointArray[i].securityPolicyUri, &UA_SECURITY_POLICY_NONE_URI) ||
UA_String_equal(&endpointArray[i].securityPolicyUri, &UA_SECURITY_POLICY_BASIC128_URI)) && (
foundEndpoint == NULL || foundEndpoint->securityMode < endpointArray[i].securityMode))
foundEndpoint = &endpointArray[i];
}
UA_EndpointDescription *returnEndpoint = NULL;
if (foundEndpoint != NULL) {
returnEndpoint = UA_EndpointDescription_new();
UA_EndpointDescription_copy(foundEndpoint, returnEndpoint);
}
UA_Array_delete(endpointArray, endpointArraySize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
return returnEndpoint;
}
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]);
}
}
static UA_StatusCode
writeDataTypeAttribute(UA_Server *server, UA_Session *session,
UA_VariableNode *node, const UA_VariableTypeNode *type,
const UA_NodeId *dataType) {
UA_assert(node != NULL);
UA_assert(type != NULL);
/* If this is a variabletype, there must be no instances or subtypes of it
when we do the change */
if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
UA_Node_hasSubTypeOrInstances((const UA_Node*)node))
return UA_STATUSCODE_BADINTERNALERROR;
/* Does the new type match the constraints of the variabletype? */
if(!compatibleDataType(server, dataType, &type->dataType))
return UA_STATUSCODE_BADTYPEMISMATCH;
/* Check if the current value would match the new type */
UA_DataValue value;
UA_DataValue_init(&value);
UA_StatusCode retval = readValueAttribute(server, session, node, &value);
if(retval != UA_STATUSCODE_GOOD)
return retval;
if(value.hasValue) {
if(!compatibleValue(server, dataType, node->valueRank,
node->arrayDimensionsSize, node->arrayDimensions,
&value.value, NULL))
retval = UA_STATUSCODE_BADTYPEMISMATCH;
UA_DataValue_deleteMembers(&value);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
"The current value does not match the new data type");
return retval;
}
}
/* Replace the datatype nodeid */
UA_NodeId dtCopy = node->dataType;
retval = UA_NodeId_copy(dataType, &node->dataType);
if(retval != UA_STATUSCODE_GOOD) {
node->dataType = dtCopy;
return retval;
}
UA_NodeId_deleteMembers(&dtCopy);
return UA_STATUSCODE_GOOD;
}
static UA_StatusCode
sendHELMessage(UA_Client *client) {
/* Get a buffer */
UA_ByteString message;
UA_Connection *conn = &client->connection;
UA_StatusCode retval = conn->getSendBuffer(conn, UA_MINMESSAGESIZE, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
/* Prepare the HEL message and encode at offset 8 */
UA_TcpHelloMessage hello;
UA_String_copy(&client->endpointUrl, &hello.endpointUrl); /* must be less than 4096 bytes */
memcpy(&hello, &client->config.localConnectionConfig,
sizeof(UA_ConnectionConfig)); /* same struct layout */
UA_Byte *bufPos = &message.data[8]; /* skip the header */
const UA_Byte *bufEnd = &message.data[message.length];
client->connectStatus = UA_TcpHelloMessage_encodeBinary(&hello, &bufPos, bufEnd);
UA_TcpHelloMessage_deleteMembers (&hello);
/* Encode the message header at offset 0 */
UA_TcpMessageHeader messageHeader;
messageHeader.messageTypeAndChunkType = UA_CHUNKTYPE_FINAL + UA_MESSAGETYPE_HEL;
messageHeader.messageSize = (UA_UInt32) ((uintptr_t)bufPos - (uintptr_t)message.data);
bufPos = message.data;
retval = UA_TcpMessageHeader_encodeBinary(&messageHeader, &bufPos, bufEnd);
if(retval != UA_STATUSCODE_GOOD) {
conn->releaseSendBuffer(conn, &message);
return retval;
}
/* Send the HEL message */
message.length = messageHeader.messageSize;
retval = conn->send (conn, &message);
if(retval == UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Sent HEL message");
} else {
UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Sending HEL failed");
}
return retval;
}
static UA_StatusCode HelAckHandshake(UA_Client *c) {
UA_TcpMessageHeader messageHeader;
messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
UA_TcpHelloMessage hello;
UA_String_copy(&c->endpointUrl, &hello.endpointUrl); /* must be less than 4096 bytes */
UA_Connection *conn = &c->connection;
hello.maxChunkCount = conn->localConf.maxChunkCount;
hello.maxMessageSize = conn->localConf.maxMessageSize;
hello.protocolVersion = conn->localConf.protocolVersion;
hello.receiveBufferSize = conn->localConf.recvBufferSize;
hello.sendBufferSize = conn->localConf.sendBufferSize;
UA_ByteString message;
UA_StatusCode retval;
retval = c->connection.getSendBuffer(&c->connection, c->connection.remoteConf.recvBufferSize, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
size_t offset = 8;
retval |= UA_TcpHelloMessage_encodeBinary(&hello, &message, &offset);
messageHeader.messageSize = offset;
offset = 0;
retval |= UA_TcpMessageHeader_encodeBinary(&messageHeader, &message, &offset);
UA_TcpHelloMessage_deleteMembers(&hello);
if(retval != UA_STATUSCODE_GOOD) {
c->connection.releaseSendBuffer(&c->connection, &message);
return retval;
}
message.length = messageHeader.messageSize;
retval = c->connection.send(&c->connection, &message);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Sending HEL failed");
return retval;
}
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Sent HEL message");
UA_ByteString reply;
UA_ByteString_init(&reply);
do {
retval = c->connection.recv(&c->connection, &reply, c->config.timeout);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Receiving ACK message failed");
return retval;
}
} while(!reply.data);
offset = 0;
UA_TcpMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
UA_TcpAcknowledgeMessage ackMessage;
retval = UA_TcpAcknowledgeMessage_decodeBinary(&reply, &offset, &ackMessage);
UA_ByteString_deleteMembers(&reply);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Decoding ACK message failed");
return retval;
}
UA_LOG_DEBUG(c->logger, UA_LOGCATEGORY_NETWORK, "Received ACK message");
conn->remoteConf.maxChunkCount = ackMessage.maxChunkCount;
conn->remoteConf.maxMessageSize = ackMessage.maxMessageSize;
conn->remoteConf.protocolVersion = ackMessage.protocolVersion;
conn->remoteConf.recvBufferSize = ackMessage.receiveBufferSize;
conn->remoteConf.sendBufferSize = ackMessage.sendBufferSize;
conn->state = UA_CONNECTION_ESTABLISHED;
return UA_STATUSCODE_GOOD;
}
void __UA_Client_Service(UA_Client *client, const void *r, const UA_DataType *requestType,
void *response, const UA_DataType *responseType) {
/* Requests always begin witih a RequestHeader, therefore we can cast. */
UA_RequestHeader *request = (void*)(uintptr_t)r;
UA_StatusCode retval = UA_STATUSCODE_GOOD;
UA_init(response, responseType);
UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response;
/* make sure we have a valid session */
retval = UA_Client_manuallyRenewSecureChannel(client);
if(retval != UA_STATUSCODE_GOOD) {
respHeader->serviceResult = retval;
client->state = UA_CLIENTSTATE_ERRORED;
return;
}
/* handling request parameters */
UA_NodeId_copy(&client->authenticationToken, &request->authenticationToken);
request->timestamp = UA_DateTime_now();
request->requestHandle = ++client->requestHandle;
/* Send the request */
UA_UInt32 requestId = ++client->requestId;
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_CLIENT,
"Sending a request of type %i", requestType->typeId.identifier.numeric);
retval = UA_SecureChannel_sendBinaryMessage(&client->channel, requestId, request, requestType);
if(retval) {
if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED)
respHeader->serviceResult = UA_STATUSCODE_BADREQUESTTOOLARGE;
else
respHeader->serviceResult = retval;
client->state = UA_CLIENTSTATE_ERRORED;
return;
}
/* Retrieve the response */
// Todo: push this into the generic securechannel implementation for client and server
UA_ByteString reply;
UA_ByteString_init(&reply);
do {
retval = client->connection.recv(&client->connection, &reply, client->config.timeout);
if(retval != UA_STATUSCODE_GOOD) {
respHeader->serviceResult = retval;
client->state = UA_CLIENTSTATE_ERRORED;
return;
}
} while(!reply.data);
size_t offset = 0;
UA_SecureConversationMessageHeader msgHeader;
retval |= UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &msgHeader);
UA_SymmetricAlgorithmSecurityHeader symHeader;
retval |= UA_SymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &symHeader);
UA_SequenceHeader seqHeader;
retval |= UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
UA_NodeId responseId;
retval |= UA_NodeId_decodeBinary(&reply, &offset, &responseId);
UA_NodeId expectedNodeId = UA_NODEID_NUMERIC(0, responseType->typeId.identifier.numeric +
UA_ENCODINGOFFSET_BINARY);
if(retval != UA_STATUSCODE_GOOD) {
goto finish;
}
/* Todo: we need to demux responses since a publish responses may come at any time */
if(!UA_NodeId_equal(&responseId, &expectedNodeId) || seqHeader.requestId != requestId) {
if(responseId.identifier.numeric != UA_NS0ID_SERVICEFAULT + UA_ENCODINGOFFSET_BINARY) {
UA_LOG_ERROR(client->logger, UA_LOGCATEGORY_CLIENT,
"Reply answers the wrong request. Expected ns=%i,i=%i. But retrieved ns=%i,i=%i",
expectedNodeId.namespaceIndex, expectedNodeId.identifier.numeric,
responseId.namespaceIndex, responseId.identifier.numeric);
respHeader->serviceResult = UA_STATUSCODE_BADINTERNALERROR;
} else
retval = UA_decodeBinary(&reply, &offset, respHeader, &UA_TYPES[UA_TYPES_SERVICEFAULT]);
goto finish;
}
retval = UA_decodeBinary(&reply, &offset, response, responseType);
if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED)
retval = UA_STATUSCODE_BADRESPONSETOOLARGE;
finish:
UA_SymmetricAlgorithmSecurityHeader_deleteMembers(&symHeader);
UA_ByteString_deleteMembers(&reply);
if(retval != UA_STATUSCODE_GOOD){
UA_LOG_INFO(client->logger, UA_LOGCATEGORY_CLIENT, "Error receiving the response");
client->state = UA_CLIENTSTATE_ERRORED;
respHeader->serviceResult = retval;
}
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_CLIENT,
"Received a response of type %i", responseId.identifier.numeric);
}
static UA_StatusCode SecureChannelHandshake(UA_Client *client, UA_Boolean renew) {
/* Check if sc is still valid */
if(renew && client->scExpiresAt - UA_DateTime_now() > client->config.timeToRenewSecureChannel * 10000)
return UA_STATUSCODE_GOOD;
UA_SecureConversationMessageHeader messageHeader;
messageHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
messageHeader.secureChannelId = 0;
UA_SequenceHeader seqHeader;
seqHeader.sequenceNumber = ++client->channel.sequenceNumber;
seqHeader.requestId = ++client->requestId;
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
UA_AsymmetricAlgorithmSecurityHeader_init(&asymHeader);
asymHeader.securityPolicyUri = UA_STRING_ALLOC("http://opcfoundation.org/UA/SecurityPolicy#None");
/* id of opensecurechannelrequest */
UA_NodeId requestType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELREQUEST + UA_ENCODINGOFFSET_BINARY);
UA_OpenSecureChannelRequest opnSecRq;
UA_OpenSecureChannelRequest_init(&opnSecRq);
opnSecRq.requestHeader.timestamp = UA_DateTime_now();
opnSecRq.requestHeader.authenticationToken = client->authenticationToken;
opnSecRq.requestedLifetime = client->config.secureChannelLifeTime;
if(renew) {
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_RENEW;
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "Requesting to renew the SecureChannel");
} else {
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
UA_ByteString_init(&client->channel.clientNonce);
UA_ByteString_copy(&client->channel.clientNonce, &opnSecRq.clientNonce);
opnSecRq.securityMode = UA_MESSAGESECURITYMODE_NONE;
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "Requesting to open a SecureChannel");
}
UA_ByteString message;
UA_Connection *c = &client->connection;
UA_StatusCode retval = c->getSendBuffer(c, c->remoteConf.recvBufferSize, &message);
if(retval != UA_STATUSCODE_GOOD) {
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
return retval;
}
size_t offset = 12;
retval = UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &message, &offset);
retval |= UA_SequenceHeader_encodeBinary(&seqHeader, &message, &offset);
retval |= UA_NodeId_encodeBinary(&requestType, &message, &offset);
retval |= UA_OpenSecureChannelRequest_encodeBinary(&opnSecRq, &message, &offset);
messageHeader.messageHeader.messageSize = offset;
offset = 0;
retval |= UA_SecureConversationMessageHeader_encodeBinary(&messageHeader, &message, &offset);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_OpenSecureChannelRequest_deleteMembers(&opnSecRq);
if(retval != UA_STATUSCODE_GOOD) {
client->connection.releaseSendBuffer(&client->connection, &message);
return retval;
}
message.length = messageHeader.messageHeader.messageSize;
retval = client->connection.send(&client->connection, &message);
if(retval != UA_STATUSCODE_GOOD)
return retval;
UA_ByteString reply;
UA_ByteString_init(&reply);
do {
retval = client->connection.recv(&client->connection, &reply, client->config.timeout);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Receiving OpenSecureChannelResponse failed");
return retval;
}
} while(!reply.data);
offset = 0;
UA_SecureConversationMessageHeader_decodeBinary(&reply, &offset, &messageHeader);
UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply, &offset, &asymHeader);
UA_SequenceHeader_decodeBinary(&reply, &offset, &seqHeader);
UA_NodeId_decodeBinary(&reply, &offset, &requestType);
UA_NodeId expectedRequest = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
UA_ENCODINGOFFSET_BINARY);
if(!UA_NodeId_equal(&requestType, &expectedRequest)) {
UA_ByteString_deleteMembers(&reply);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_NodeId_deleteMembers(&requestType);
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_CLIENT,
"Reply answers the wrong request. Expected OpenSecureChannelResponse.");
return UA_STATUSCODE_BADINTERNALERROR;
}
UA_OpenSecureChannelResponse response;
UA_OpenSecureChannelResponse_init(&response);
retval = UA_OpenSecureChannelResponse_decodeBinary(&reply, &offset, &response);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Decoding OpenSecureChannelResponse failed");
UA_ByteString_deleteMembers(&reply);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_OpenSecureChannelResponse_init(&response);
response.responseHeader.serviceResult = retval;
return retval;
}
client->scExpiresAt = UA_DateTime_now() + response.securityToken.revisedLifetime * 10000;
UA_ByteString_deleteMembers(&reply);
retval = response.responseHeader.serviceResult;
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL,
"SecureChannel could not be opened / renewed");
else if(!renew) {
UA_ChannelSecurityToken_copy(&response.securityToken, &client->channel.securityToken);
/* if the handshake is repeated, replace the old nonce */
UA_ByteString_deleteMembers(&client->channel.serverNonce);
UA_ByteString_copy(&response.serverNonce, &client->channel.serverNonce);
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "SecureChannel opened");
} else
UA_LOG_DEBUG(client->logger, UA_LOGCATEGORY_SECURECHANNEL, "SecureChannel renewed");
UA_OpenSecureChannelResponse_deleteMembers(&response);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return retval;
}
/* OPN messges to renew the channel are sent asynchronous */
static UA_StatusCode
openSecureChannelAsync(UA_Client *client/*, UA_Boolean renew*/) {
/* Check if sc is still valid */
/*if(renew && client->nextChannelRenewal - UA_DateTime_nowMonotonic () > 0)
return UA_STATUSCODE_GOOD;*/
UA_Connection *conn = &client->connection;
if(conn->state != UA_CONNECTION_ESTABLISHED)
return UA_STATUSCODE_BADSERVERNOTCONNECTED;
/* Prepare the OpenSecureChannelRequest */
UA_OpenSecureChannelRequest opnSecRq;
UA_OpenSecureChannelRequest_init(&opnSecRq);
opnSecRq.requestHeader.timestamp = UA_DateTime_now();
opnSecRq.requestHeader.authenticationToken = client->authenticationToken;
/*if(renew) {
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_RENEW;
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"Requesting to renew the SecureChannel");
} else {*/
opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE;
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"Requesting to open a SecureChannel");
//}
opnSecRq.securityMode = client->channel.securityMode;
opnSecRq.clientNonce = client->channel.localNonce;
opnSecRq.requestedLifetime = client->config.secureChannelLifeTime;
/* Prepare the entry for the linked list */
UA_UInt32 requestId = ++client->requestId;
/*AsyncServiceCall *ac = NULL;
if(renew) {
ac = (AsyncServiceCall*)UA_malloc(sizeof(AsyncServiceCall));
if (!ac)
return UA_STATUSCODE_BADOUTOFMEMORY;
ac->callback =
(UA_ClientAsyncServiceCallback) processDecodedOPNResponseAsync;
ac->responseType = &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE];
ac->requestId = requestId;
ac->userdata = NULL;
}*/
/* Send the OPN message */
UA_StatusCode retval = UA_SecureChannel_sendAsymmetricOPNMessage (
&client->channel, requestId, &opnSecRq,
&UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]);
client->connectStatus = retval;
if(retval != UA_STATUSCODE_GOOD) {
client->connectStatus = retval;
UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"Sending OPN message failed with error %s",
UA_StatusCode_name(retval));
UA_Client_disconnect(client);
//if(renew)
// UA_free(ac);
return retval;
}
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL,
"OPN message sent");
/* Store the entry for async processing and return */
/*if(renew) {
LIST_INSERT_HEAD(&client->asyncServiceCalls, ac, pointers);
return retval;
}*/
return retval;
}
static void
processDecodedOPNResponseAsync(void *application, UA_SecureChannel *channel,
UA_MessageType messageType,
UA_UInt32 requestId,
const UA_ByteString *message) {
/* Does the request id match? */
UA_Client *client = (UA_Client*)application;
if(requestId != client->requestId) {
UA_Client_disconnect(client);
return;
}
/* Is the content of the expected type? */
size_t offset = 0;
UA_NodeId responseId;
UA_NodeId expectedId = UA_NODEID_NUMERIC(
0, UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE].binaryEncodingId);
UA_StatusCode retval = UA_NodeId_decodeBinary(message, &offset,
&responseId);
if(retval != UA_STATUSCODE_GOOD) {
UA_Client_disconnect(client);
return;
}
if(!UA_NodeId_equal(&responseId, &expectedId)) {
UA_NodeId_deleteMembers(&responseId);
UA_Client_disconnect(client);
return;
}
UA_NodeId_deleteMembers (&responseId);
/* Decode the response */
UA_OpenSecureChannelResponse response;
retval = UA_OpenSecureChannelResponse_decodeBinary(message, &offset,
&response);
if(retval != UA_STATUSCODE_GOOD) {
UA_Client_disconnect(client);
return;
}
/* Response.securityToken.revisedLifetime is UInt32 we need to cast it to
* DateTime=Int64 we take 75% of lifetime to start renewing as described in
* standard */
client->nextChannelRenewal = UA_DateTime_nowMonotonic()
+ (UA_DateTime) (response.securityToken.revisedLifetime
* (UA_Double) UA_DATETIME_MSEC * 0.75);
/* Replace the token and nonce */
UA_ChannelSecurityToken_deleteMembers(&client->channel.securityToken);
UA_ByteString_deleteMembers(&client->channel.remoteNonce);
client->channel.securityToken = response.securityToken;
client->channel.remoteNonce = response.serverNonce;
UA_ResponseHeader_deleteMembers(&response.responseHeader); /* the other members were moved */
if(client->channel.state == UA_SECURECHANNELSTATE_OPEN)
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL, "SecureChannel renewed");
else
UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL, "SecureChannel opened");
client->channel.state = UA_SECURECHANNELSTATE_OPEN;
if(client->state < UA_CLIENTSTATE_SECURECHANNEL)
setClientState(client, UA_CLIENTSTATE_SECURECHANNEL);
}
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
}
/* The server does not send a CloseSecureChannel response */
void Service_CloseSecureChannel(UA_Server *server, UA_Int32 channelId) {
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Closing SecureChannel %i", channelId);
UA_SecureChannelManager_close(&server->secureChannelManager, channelId);
}
/* Stack layout: ... | node | type */
static UA_StatusCode
writeArrayDimensionsAttribute(UA_Server *server, UA_Session *session,
UA_VariableNode *node, const UA_VariableTypeNode *type,
size_t arrayDimensionsSize, UA_UInt32 *arrayDimensions) {
UA_assert(node != NULL);
UA_assert(type != NULL);
/* If this is a variabletype, there must be no instances or subtypes of it
* when we do the change */
if(node->nodeClass == UA_NODECLASS_VARIABLETYPE &&
UA_Node_hasSubTypeOrInstances((UA_Node*)node)) {
UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_SERVER,
"Cannot change a variable type with existing instances");
return UA_STATUSCODE_BADINTERNALERROR;
}
/* Check that the array dimensions match with the valuerank */
if(!compatibleValueRankArrayDimensions(node->valueRank, arrayDimensionsSize)) {
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
"The current value rank does not match the new array dimensions");
return UA_STATUSCODE_BADTYPEMISMATCH;
}
/* Check if the array dimensions match with the wildcards in the
* variabletype (dimension length 0) */
if(type->arrayDimensions &&
!compatibleArrayDimensions(type->arrayDimensionsSize, type->arrayDimensions,
arrayDimensionsSize, arrayDimensions)) {
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
"Array dimensions in the variable type do not match");
return UA_STATUSCODE_BADTYPEMISMATCH;
}
/* Check if the current value is compatible with the array dimensions */
UA_DataValue value;
UA_DataValue_init(&value);
UA_StatusCode retval = readValueAttribute(server, session, node, &value);
if(retval != UA_STATUSCODE_GOOD)
return retval;
if(value.hasValue) {
if(!compatibleValueArrayDimensions(&value.value, arrayDimensionsSize, arrayDimensions))
retval = UA_STATUSCODE_BADTYPEMISMATCH;
UA_DataValue_deleteMembers(&value);
if(retval != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG(server->config.logger, UA_LOGCATEGORY_SERVER,
"Array dimensions in the current value do not match");
return retval;
}
}
/* Ok, apply */
UA_UInt32 *oldArrayDimensions = node->arrayDimensions;
retval = UA_Array_copy(arrayDimensions, arrayDimensionsSize,
(void**)&node->arrayDimensions,
&UA_TYPES[UA_TYPES_UINT32]);
if(retval != UA_STATUSCODE_GOOD)
return retval;
UA_free(oldArrayDimensions);
node->arrayDimensionsSize = arrayDimensionsSize;
return UA_STATUSCODE_GOOD;
}
static void processMSG(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *pos) {
/* Read in the securechannel */
UA_UInt32 secureChannelId;
UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
if(retval != UA_STATUSCODE_GOOD)
return;
/* the anonymous channel is used e.g. to allow getEndpoints without a channel */
UA_SecureChannel *clientChannel = connection->channel;
UA_SecureChannel anonymousChannel;
if(!clientChannel) {
UA_SecureChannel_init(&anonymousChannel);
anonymousChannel.connection = connection;
clientChannel = &anonymousChannel;
}
/* Read the security header */
UA_UInt32 tokenId = 0;
UA_SequenceHeader sequenceHeader;
retval = UA_UInt32_decodeBinary(msg, pos, &tokenId);
retval |= UA_SequenceHeader_decodeBinary(msg, pos, &sequenceHeader);
#ifndef EXTENSION_STATELESS
if(retval != UA_STATUSCODE_GOOD || tokenId == 0) // 0 is invalid
return;
#else
if(retval != UA_STATUSCODE_GOOD)
return;
#endif
if(clientChannel != &anonymousChannel && tokenId != clientChannel->securityToken.tokenId) {
if(tokenId != clientChannel->nextSecurityToken.tokenId) {
/* close the securechannel but keep the connection open */
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_SECURECHANNEL,
"Request with a wrong security token. Closing the SecureChannel %i.",
clientChannel->securityToken.channelId);
Service_CloseSecureChannel(server, clientChannel->securityToken.channelId);
return;
}
UA_SecureChannel_revolveTokens(clientChannel);
}
/* Read the request type */
UA_NodeId requestType;
if(UA_NodeId_decodeBinary(msg, pos, &requestType) != UA_STATUSCODE_GOOD)
return;
if(requestType.identifierType != UA_NODEIDTYPE_NUMERIC) {
UA_NodeId_deleteMembers(&requestType);
return;
}
switch(requestType.identifier.numeric - UA_ENCODINGOFFSET_BINARY) {
case UA_NS0ID_GETENDPOINTSREQUEST: {
if(clientChannel == &anonymousChannel)
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_NETWORK, "Processing GetEndpointsRequest on Connection %i",
connection->sockfd);
else
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL, "Processing GetEndpointsRequest on SecureChannel %i",
clientChannel->securityToken.channelId);
UA_GetEndpointsRequest p;
UA_GetEndpointsResponse r;
if(UA_GetEndpointsRequest_decodeBinary(msg, pos, &p))
return;
UA_GetEndpointsResponse_init(&r);
init_response_header(&p.requestHeader, &r.responseHeader);
Service_GetEndpoints(server, &p, &r);
UA_GetEndpointsRequest_deleteMembers(&p);
UA_SecureChannel_sendBinaryMessage(clientChannel, sequenceHeader.requestId, &r,
&UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]);
UA_GetEndpointsResponse_deleteMembers(&r);
break;
}
case UA_NS0ID_FINDSERVERSREQUEST: {
if(clientChannel == &anonymousChannel)
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_NETWORK, "Processing FindServerRequest on Connection %i",
connection->sockfd);
else
UA_LOG_DEBUG(server->logger, UA_LOGCATEGORY_SECURECHANNEL, "Processing FindServerRequest on SecureChannel %i",
clientChannel->securityToken.channelId);
UA_FindServersRequest p;
UA_FindServersResponse r;
if(UA_FindServersRequest_decodeBinary(msg, pos, &p))
return;
UA_FindServersResponse_init(&r);
init_response_header(&p.requestHeader, &r.responseHeader);
Service_FindServers(server, &p, &r);
UA_FindServersRequest_deleteMembers(&p);
UA_SecureChannel_sendBinaryMessage(clientChannel, sequenceHeader.requestId, &r,
&UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]);
UA_FindServersResponse_deleteMembers(&r);
break;
}
case UA_NS0ID_CREATESESSIONREQUEST: {
UA_CreateSessionRequest p;
UA_CreateSessionResponse r;
if(UA_CreateSessionRequest_decodeBinary(msg, pos, &p))
return;
UA_CreateSessionResponse_init(&r);
init_response_header(&p.requestHeader, &r.responseHeader);
Service_CreateSession(server, clientChannel, &p, &r);
UA_CreateSessionRequest_deleteMembers(&p);
UA_SecureChannel_sendBinaryMessage(clientChannel, sequenceHeader.requestId, &r,
&UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]);
UA_CreateSessionResponse_deleteMembers(&r);
break;
}
case UA_NS0ID_ACTIVATESESSIONREQUEST: {
UA_ActivateSessionRequest p;
UA_ActivateSessionResponse r;
if(UA_ActivateSessionRequest_decodeBinary(msg, pos, &p))
return;
UA_ActivateSessionResponse_init(&r);
init_response_header(&p.requestHeader, &r.responseHeader);
Service_ActivateSession(server, clientChannel, &p, &r);
UA_ActivateSessionRequest_deleteMembers(&p);
UA_SecureChannel_sendBinaryMessage(clientChannel, sequenceHeader.requestId, &r,
&UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
UA_ActivateSessionResponse_deleteMembers(&r);
break;
}
case UA_NS0ID_CLOSESESSIONREQUEST:
INVOKE_SERVICE(CloseSession, UA_TYPES_CLOSESESSIONRESPONSE);
break;
case UA_NS0ID_READREQUEST:
INVOKE_SERVICE(Read, UA_TYPES_READRESPONSE);
break;
case UA_NS0ID_WRITEREQUEST:
INVOKE_SERVICE(Write, UA_TYPES_WRITERESPONSE);
break;
case UA_NS0ID_BROWSEREQUEST:
INVOKE_SERVICE(Browse, UA_TYPES_BROWSERESPONSE);
break;
case UA_NS0ID_BROWSENEXTREQUEST:
INVOKE_SERVICE(BrowseNext, UA_TYPES_BROWSENEXTRESPONSE);
break;
case UA_NS0ID_REGISTERNODESREQUEST:
INVOKE_SERVICE(RegisterNodes, UA_TYPES_REGISTERNODESRESPONSE);
break;
case UA_NS0ID_UNREGISTERNODESREQUEST:
INVOKE_SERVICE(UnregisterNodes, UA_TYPES_UNREGISTERNODESRESPONSE);
break;
case UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST:
INVOKE_SERVICE(TranslateBrowsePathsToNodeIds, UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE);
break;
#ifdef ENABLE_SUBSCRIPTIONS
case UA_NS0ID_CREATESUBSCRIPTIONREQUEST:
INVOKE_SERVICE(CreateSubscription, UA_TYPES_CREATESUBSCRIPTIONRESPONSE);
break;
case UA_NS0ID_PUBLISHREQUEST:
INVOKE_SERVICE(Publish, UA_TYPES_PUBLISHRESPONSE);
break;
case UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST:
INVOKE_SERVICE(ModifySubscription, UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE);
break;
case UA_NS0ID_DELETESUBSCRIPTIONSREQUEST:
INVOKE_SERVICE(DeleteSubscriptions, UA_TYPES_DELETESUBSCRIPTIONSRESPONSE);
break;
case UA_NS0ID_CREATEMONITOREDITEMSREQUEST:
INVOKE_SERVICE(CreateMonitoredItems, UA_TYPES_CREATEMONITOREDITEMSRESPONSE);
break;
case UA_NS0ID_DELETEMONITOREDITEMSREQUEST:
INVOKE_SERVICE(DeleteMonitoredItems, UA_TYPES_DELETEMONITOREDITEMSRESPONSE);
break;
#endif
#ifdef ENABLE_METHODCALLS
case UA_NS0ID_CALLREQUEST:
INVOKE_SERVICE(Call, UA_TYPES_CALLRESPONSE);
break;
#endif
#ifdef ENABLE_NODEMANAGEMENT
case UA_NS0ID_ADDNODESREQUEST:
INVOKE_SERVICE(AddNodes, UA_TYPES_ADDNODESRESPONSE);
break;
case UA_NS0ID_ADDREFERENCESREQUEST:
INVOKE_SERVICE(AddReferences, UA_TYPES_ADDREFERENCESRESPONSE);
break;
case UA_NS0ID_DELETENODESREQUEST:
INVOKE_SERVICE(DeleteNodes, UA_TYPES_DELETENODESRESPONSE);
break;
case UA_NS0ID_DELETEREFERENCESREQUEST:
INVOKE_SERVICE(DeleteReferences, UA_TYPES_DELETEREFERENCESRESPONSE);
break;
#endif
default: {
if(requestType.namespaceIndex == 0 && requestType.identifier.numeric==787)
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_NETWORK,
"Client requested a subscription that are not supported, the message will be skipped");
else
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_NETWORK, "Unknown request: NodeId(ns=%d, i=%d)",
requestType.namespaceIndex, requestType.identifier.numeric);
UA_RequestHeader p;
UA_ServiceFault r;
if(UA_RequestHeader_decodeBinary(msg, pos, &p) != UA_STATUSCODE_GOOD)
return;
UA_ServiceFault_init(&r);
init_response_header(&p, &r.responseHeader);
r.responseHeader.serviceResult = UA_STATUSCODE_BADSERVICEUNSUPPORTED;
UA_SecureChannel_sendBinaryMessage(clientChannel, sequenceHeader.requestId, &r,
&UA_TYPES[UA_TYPES_SERVICEFAULT]);
UA_RequestHeader_deleteMembers(&p);
UA_ServiceFault_deleteMembers(&r);
break;
}
}
}
