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;
}
static UA_Int32 sendHello(UA_Int32 sock, UA_String *endpointURL) {
UA_TcpMessageHeader messageHeader;
messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_HELF;
UA_TcpHelloMessage hello;
UA_String_copy(endpointURL, &hello.endpointUrl);
hello.maxChunkCount = 1;
hello.maxMessageSize = 16777216;
hello.protocolVersion = 0;
hello.receiveBufferSize = 65536;
hello.sendBufferSize = 65536;
messageHeader.messageSize = UA_TcpHelloMessage_calcSizeBinary((UA_TcpHelloMessage const*) &hello) +
UA_TcpMessageHeader_calcSizeBinary((UA_TcpMessageHeader const*) &messageHeader);
UA_ByteString message;
UA_ByteString_newMembers(&message, messageHeader.messageSize);
size_t offset = 0;
UA_TcpMessageHeader_encodeBinary((UA_TcpMessageHeader const*) &messageHeader, &message, &offset);
UA_TcpHelloMessage_encodeBinary((UA_TcpHelloMessage const*) &hello, &message, &offset);
UA_Int32 sendret = send(sock, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
free(hello.endpointUrl.data);
if (sendret < 0)
return 1;
return 0;
}
UA_ServerNetworkLayer * ServerNetworkLayerTCP_new(UA_ConnectionConfig conf, UA_UInt32 port) {
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
#endif
ServerNetworkLayerTCP *layer = malloc(sizeof(ServerNetworkLayerTCP));
if(!layer)
return NULL;
memset(layer, 0, sizeof(ServerNetworkLayerTCP));
layer->conf = conf;
layer->mappingsSize = 0;
layer->mappings = NULL;
layer->port = port;
char hostname[256];
if(gethostname(hostname, 255) == 0) {
char discoveryUrl[256];
UA_String str;
#ifndef _MSC_VER
str.length = snprintf(discoveryUrl, 255, "opc.tcp://%s:%d", hostname, port);
#else
str.length = _snprintf_s(discoveryUrl, 255, _TRUNCATE, "opc.tcp://%s:%d", hostname, port);
#endif
str.data = (UA_Byte*)discoveryUrl;
UA_String_copy(&str, &layer->layer.discoveryUrl);
}
layer->layer.start = (UA_StatusCode(*)(UA_ServerNetworkLayer*,UA_Logger))ServerNetworkLayerTCP_start;
layer->layer.getJobs = (size_t(*)(UA_ServerNetworkLayer*,UA_Job**,UA_UInt16))ServerNetworkLayerTCP_getJobs;
layer->layer.stop = (size_t(*)(UA_ServerNetworkLayer*, UA_Job**))ServerNetworkLayerTCP_stop;
layer->layer.deleteMembers = (void(*)(UA_ServerNetworkLayer*))ServerNetworkLayerTCP_deleteMembers;
return &layer->layer;
}
void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
const UA_CreateSessionRequest *request,
UA_CreateSessionResponse *response) {
response->responseHeader.serviceResult =
UA_Array_copy(server->endpointDescriptions, (void**)&response->serverEndpoints,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION], server->endpointDescriptionsSize);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD)
return;
response->serverEndpointsSize = server->endpointDescriptionsSize;
UA_Session *newSession;
response->responseHeader.serviceResult = UA_SessionManager_createSession(&server->sessionManager,
channel, request, &newSession);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD)
return;
//TODO get maxResponseMessageSize internally
newSession->maxResponseMessageSize = request->maxResponseMessageSize;
response->sessionId = newSession->sessionId;
response->revisedSessionTimeout = newSession->timeout;
response->authenticationToken = newSession->authenticationToken;
response->responseHeader.serviceResult = UA_String_copy(&request->sessionName, &newSession->sessionName);
if(server->endpointDescriptions)
response->responseHeader.serviceResult |=
UA_ByteString_copy(&server->endpointDescriptions->serverCertificate, &response->serverCertificate);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager, server, &newSession->authenticationToken);
return;
}
}
/* Create a signed nonce */
static UA_StatusCode
nonceAndSignCreateSessionResponse(UA_Server *server, UA_SecureChannel *channel,
UA_Session *session,
const UA_CreateSessionRequest *request,
UA_CreateSessionResponse *response) {
if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGN &&
channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT)
return UA_STATUSCODE_GOOD;
const UA_SecurityPolicy *const securityPolicy = channel->securityPolicy;
UA_SignatureData *signatureData = &response->serverSignature;
/* Generate Nonce
* FIXME: remove magic number??? */
UA_StatusCode retval = UA_SecureChannel_generateNonce(channel, 32, &response->serverNonce);
retval |= UA_ByteString_copy(&response->serverNonce, &session->serverNonce);
if(retval != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager, &session->authenticationToken);
return retval;
}
size_t signatureSize = securityPolicy->asymmetricModule.cryptoModule.
getLocalSignatureSize(securityPolicy, channel->channelContext);
retval |= UA_ByteString_allocBuffer(&signatureData->signature, signatureSize);
if(retval != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager, &session->authenticationToken);
return retval;
}
UA_ByteString dataToSign;
retval |= UA_ByteString_allocBuffer(&dataToSign,
request->clientCertificate.length +
request->clientNonce.length);
if(retval != UA_STATUSCODE_GOOD) {
UA_SignatureData_deleteMembers(signatureData);
UA_SessionManager_removeSession(&server->sessionManager, &session->authenticationToken);
return retval;
}
memcpy(dataToSign.data, request->clientCertificate.data, request->clientCertificate.length);
memcpy(dataToSign.data + request->clientCertificate.length,
request->clientNonce.data, request->clientNonce.length);
retval |= UA_String_copy(&securityPolicy->asymmetricModule.cryptoModule.
signatureAlgorithmUri, &signatureData->algorithm);
retval |= securityPolicy->asymmetricModule.cryptoModule.
sign(securityPolicy, channel->channelContext, &dataToSign, &signatureData->signature);
UA_ByteString_deleteMembers(&dataToSign);
if(retval != UA_STATUSCODE_GOOD) {
UA_SignatureData_deleteMembers(signatureData);
UA_SessionManager_removeSession(&server->sessionManager, &session->authenticationToken);
}
return retval;
}
UaNodeId::UaNodeId ( const UaString& stringAddress, int ns)
{
// TODO: not implemented yet in open62541
// UA_NodeId_fromInteger( 2, 2);
m_impl.namespaceIndex = ns;
m_impl.identifierType = UA_NODEIDTYPE_STRING;
UA_StatusCode status = UA_String_copy( stringAddress.impl(), &m_impl.identifier.string );
if (status != UA_STATUSCODE_GOOD)
throw alloc_error();
}
static UA_StatusCode
requestActivateSession (UA_Client *client, UA_UInt32 *requestId) {
UA_ActivateSessionRequest request;
UA_ActivateSessionRequest_init(&request);
request.requestHeader.requestHandle = ++client->requestHandle;
request.requestHeader.timestamp = UA_DateTime_now ();
request.requestHeader.timeoutHint = 600000;
UA_StatusCode retval =
UA_ExtensionObject_copy(&client->config.userIdentityToken, &request.userIdentityToken);
if(retval != UA_STATUSCODE_GOOD)
return retval;
/* If not token is set, use anonymous */
if(request.userIdentityToken.encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY) {
UA_AnonymousIdentityToken *t = UA_AnonymousIdentityToken_new();
if(!t) {
UA_ActivateSessionRequest_deleteMembers(&request);
return UA_STATUSCODE_BADOUTOFMEMORY;
}
request.userIdentityToken.content.decoded.data = t;
request.userIdentityToken.content.decoded.type = &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN];
request.userIdentityToken.encoding = UA_EXTENSIONOBJECT_DECODED;
}
/* Set the policy-Id from the endpoint. Every IdentityToken starts with a
* string. */
retval = UA_String_copy(&client->config.userTokenPolicy.policyId,
(UA_String*)request.userIdentityToken.content.decoded.data);
#ifdef UA_ENABLE_ENCRYPTION
/* Encrypt the UserIdentityToken */
const UA_String *userTokenPolicy = &client->channel.securityPolicy->policyUri;
if(client->config.userTokenPolicy.securityPolicyUri.length > 0)
userTokenPolicy = &client->config.userTokenPolicy.securityPolicyUri;
retval |= encryptUserIdentityToken(client, userTokenPolicy, &request.userIdentityToken);
/* This function call is to prepare a client signature */
retval |= signActivateSessionRequest(&client->channel, &request);
#endif
if(retval != UA_STATUSCODE_GOOD) {
UA_ActivateSessionRequest_deleteMembers(&request);
client->connectStatus = retval;
return retval;
}
retval = UA_Client_sendAsyncRequest (
client, &request, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST],
(UA_ClientAsyncServiceCallback) responseActivateSession,
&UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE], NULL, requestId);
UA_ActivateSessionRequest_deleteMembers(&request);
client->connectStatus = retval;
return retval;
}
static UA_Int32 sendCreateSession(UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber,
UA_UInt32 requestId, UA_String *endpointUrl) {
UA_ByteString message;
UA_ByteString_newMembers(&message, 65536);
UA_UInt32 tmpChannelId = channelId;
size_t offset = 0;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_NodeId type;
type.identifier.numeric = 461;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_CreateSessionRequest rq;
UA_CreateSessionRequest_init(&rq);
rq.requestHeader.requestHandle = 1;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.timeoutHint = 10000;
rq.requestHeader.authenticationToken.identifier.numeric = 10;
rq.requestHeader.authenticationToken.identifierType = UA_NODEIDTYPE_NUMERIC;
rq.requestHeader.authenticationToken.namespaceIndex = 10;
UA_String_copy(endpointUrl, &rq.endpointUrl);
UA_String_copycstring("mysession", &rq.sessionName);
UA_String_copycstring("abcd", &rq.clientCertificate);
UA_ByteString_newMembers(&rq.clientNonce, 1);
rq.clientNonce.data[0] = 0;
rq.requestedSessionTimeout = 1200000;
rq.maxResponseMessageSize = UA_INT32_MAX;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_CreateSessionRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr, &message, &offset);
UA_UInt32_encodeBinary(&tmpChannelId, &message, &offset);
UA_UInt32_encodeBinary(&tokenId, &message, &offset);
UA_UInt32_encodeBinary(&sequenceNumber, &message, &offset);
UA_UInt32_encodeBinary(&requestId, &message, &offset);
UA_NodeId_encodeBinary(&type, &message, &offset);
UA_CreateSessionRequest_encodeBinary(&rq, &message, &offset);
UA_Int32 sendret = send(sock, message.data, offset, 0);
UA_ByteString_deleteMembers(&message);
UA_CreateSessionRequest_deleteMembers(&rq);
if (sendret < 0) {
printf("send opensecurechannel failed");
return 1;
}
return 0;
}
static UA_StatusCode
requestGetEndpoints(UA_Client *client, UA_UInt32 *requestId) {
UA_GetEndpointsRequest request;
UA_GetEndpointsRequest_init(&request);
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
/* assume the endpointurl outlives the service call */
UA_String_copy(&client->endpointUrl, &request.endpointUrl);
client->connectStatus = UA_Client_sendAsyncRequest(
client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST],
(UA_ClientAsyncServiceCallback) responseGetEndpoints,
&UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE], NULL, requestId);
UA_GetEndpointsRequest_deleteMembers(&request);
return client->connectStatus;
}
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);
}
UA_ServerNetworkLayer
UA_ServerNetworkLayerTCP(UA_ConnectionConfig conf, UA_UInt32 port, UA_Logger logger) {
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
#endif
UA_ServerNetworkLayer nl;
memset(&nl, 0, sizeof(UA_ServerNetworkLayer));
ServerNetworkLayerTCP *layer = malloc(sizeof(ServerNetworkLayerTCP));
if(!layer)
return nl;
layer->conf = conf;
layer->port = port;
layer->logger = logger;
layer->mappingsSize = 0;
layer->mappings = NULL;
/* get the discovery url from the hostname */
UA_String du = UA_STRING_NULL;
char hostname[256];
if(gethostname(hostname, 255) == 0) {
char discoveryUrl[256];
#ifndef _MSC_VER
du.length = snprintf(discoveryUrl, 255, "opc.tcp://%s:%d", hostname, port);
#else
du.length = _snprintf_s(discoveryUrl, 255, _TRUNCATE, "opc.tcp://%s:%d", hostname, port);
#endif
du.data = (UA_Byte*)discoveryUrl;
}
nl.handle = layer;
UA_String_copy(&du, &nl.discoveryUrl);
nl.start = ServerNetworkLayerTCP_start;
nl.getJobs = ServerNetworkLayerTCP_getJobs;
nl.stop = ServerNetworkLayerTCP_stop;
nl.deleteMembers = ServerNetworkLayerTCP_deleteMembers;
return nl;
}
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
requestSession(UA_Client *client, UA_UInt32 *requestId) {
UA_CreateSessionRequest request;
UA_CreateSessionRequest_init(&request);
UA_StatusCode retval = UA_STATUSCODE_GOOD;
if(client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGN ||
client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) {
if(client->channel.localNonce.length != UA_SESSION_LOCALNONCELENGTH) {
UA_ByteString_deleteMembers(&client->channel.localNonce);
retval = UA_ByteString_allocBuffer(&client->channel.localNonce,
UA_SESSION_LOCALNONCELENGTH);
if(retval != UA_STATUSCODE_GOOD)
return retval;
}
retval = client->channel.securityPolicy->symmetricModule.
generateNonce(client->channel.securityPolicy, &client->channel.localNonce);
if(retval != UA_STATUSCODE_GOOD)
return retval;
}
request.requestHeader.requestHandle = ++client->requestHandle;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
UA_ByteString_copy(&client->channel.localNonce, &request.clientNonce);
request.requestedSessionTimeout = client->config.requestedSessionTimeout;
request.maxResponseMessageSize = UA_INT32_MAX;
UA_String_copy(&client->config.endpoint.endpointUrl, &request.endpointUrl);
UA_ApplicationDescription_copy(&client->config.clientDescription,
&request.clientDescription);
retval = UA_Client_sendAsyncRequest (
client, &request, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST],
(UA_ClientAsyncServiceCallback) responseSessionCallback,
&UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE], NULL, requestId);
UA_CreateSessionRequest_deleteMembers(&request);
client->connectStatus = retval;
return client->connectStatus;
}
UA_StatusCode
UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
const UA_QualifiedName browseName, UA_NodeId nodeId,
const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId)
{
UA_VariableNode *node = UA_VariableNode_new();
node->valueSource = UA_VALUESOURCE_DATASOURCE;
node->value.dataSource = dataSource;
UA_NodeId_copy(&nodeId, &node->nodeId);
UA_QualifiedName_copy(&browseName, &node->browseName);
UA_String_copy(&browseName.name, &node->displayName.text);
UA_ExpandedNodeId parentId; // dummy exapndednodeid
UA_ExpandedNodeId_init(&parentId);
UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
UA_AddNodesResult res =
UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, parentId, referenceTypeId);
ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE));
if(res.statusCode != UA_STATUSCODE_GOOD)
UA_VariableNode_delete(node);
UA_AddNodesResult_deleteMembers(&res);
return res.statusCode;
}
static UA_StatusCode ActivateSession(UA_Client *client) {
UA_ActivateSessionRequest request;
UA_ActivateSessionRequest_init(&request);
request.requestHeader.requestHandle = 2; //TODO: is it a magic number?
request.requestHeader.authenticationToken = client->authenticationToken;
request.requestHeader.timestamp = UA_DateTime_now();
request.requestHeader.timeoutHint = 10000;
UA_AnonymousIdentityToken identityToken;
UA_AnonymousIdentityToken_init(&identityToken);
UA_String_copy(&client->token.policyId, &identityToken.policyId);
//manual ExtensionObject encoding of the identityToken
request.userIdentityToken.encoding = UA_EXTENSIONOBJECT_ENCODINGMASK_BODYISBYTESTRING;
request.userIdentityToken.typeId = UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN].typeId;
request.userIdentityToken.typeId.identifier.numeric+=UA_ENCODINGOFFSET_BINARY;
if (identityToken.policyId.length >= 0)
UA_ByteString_newMembers(&request.userIdentityToken.body, identityToken.policyId.length+4);
else {
identityToken.policyId.length = -1;
UA_ByteString_newMembers(&request.userIdentityToken.body, 4);
}
size_t offset = 0;
UA_ByteString_encodeBinary(&identityToken.policyId,&request.userIdentityToken.body,&offset);
UA_ActivateSessionResponse response;
__UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST],
&response, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]);
UA_AnonymousIdentityToken_deleteMembers(&identityToken);
UA_ActivateSessionRequest_deleteMembers(&request);
UA_ActivateSessionResponse_deleteMembers(&response);
return response.responseHeader.serviceResult; // not deleted
}
void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
const UA_CreateSessionRequest *request, UA_CreateSessionResponse *response) {
if(channel->securityToken.channelId == 0) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADSECURECHANNELIDINVALID;
return;
}
response->responseHeader.serviceResult =
UA_Array_copy(server->endpointDescriptions, server->endpointDescriptionsSize,
(void**)&response->serverEndpoints, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD)
return;
response->serverEndpointsSize = server->endpointDescriptionsSize;
UA_Session *newSession;
response->responseHeader.serviceResult =
UA_SessionManager_createSession(&server->sessionManager, channel, request, &newSession);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel, "Processing CreateSessionRequest failed");
return;
}
newSession->maxResponseMessageSize = request->maxResponseMessageSize;
newSession->maxRequestMessageSize = channel->connection->localConf.maxMessageSize;
response->sessionId = newSession->sessionId;
response->revisedSessionTimeout = (UA_Double)newSession->timeout;
response->authenticationToken = newSession->authenticationToken;
response->responseHeader.serviceResult = UA_String_copy(&request->sessionName, &newSession->sessionName);
if(server->endpointDescriptionsSize > 0)
response->responseHeader.serviceResult |= UA_ByteString_copy(&server->endpointDescriptions->serverCertificate,
&response->serverCertificate);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager, &newSession->authenticationToken);
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel, "Session " PRINTF_GUID_FORMAT " created",
PRINTF_GUID_DATA(newSession->sessionId));
}
UA_StatusCode
UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, const UA_QualifiedName browseName,
UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId)
{
UA_VariableNode *node = UA_VariableNode_new();
node->value.variant = *value; // copy content
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);
ADDREFERENCE(res.addedNodeId, UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION),
UA_EXPANDEDNODEID_NUMERIC(0, value->type->typeId.identifier.numeric));
if(res.statusCode != UA_STATUSCODE_GOOD) {
UA_Variant_init(&node->value.variant);
UA_VariableNode_delete(node);
} else
UA_free(value);
UA_AddNodesResult_deleteMembers(&res);
return res.statusCode;
}
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 Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
const UA_CreateSessionRequest *request,
UA_CreateSessionResponse *response) {
if(channel == NULL) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR;
return;
}
if(channel->connection == NULL) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR;
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel, "Trying to create session");
if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN ||
channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) {
if(!UA_ByteString_equal(&request->clientCertificate,
&channel->remoteCertificate)) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADCERTIFICATEINVALID;
return;
}
}
if(channel->securityToken.channelId == 0) {
response->responseHeader.serviceResult =
UA_STATUSCODE_BADSECURECHANNELIDINVALID;
return;
}
if(!UA_ByteString_equal(&channel->securityPolicy->policyUri,
&UA_SECURITY_POLICY_NONE_URI) &&
request->clientNonce.length < 32) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADNONCEINVALID;
return;
}
////////////////////// TODO: Compare application URI with certificate uri (decode certificate)
/* Allocate the response */
response->serverEndpoints = (UA_EndpointDescription*)
UA_Array_new(server->config.endpointsSize,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
if(!response->serverEndpoints) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->serverEndpointsSize = server->config.endpointsSize;
/* Copy the server's endpointdescriptions into the response */
for(size_t i = 0; i < server->config.endpointsSize; ++i)
response->responseHeader.serviceResult |=
UA_EndpointDescription_copy(&server->config.endpoints[0].endpointDescription,
&response->serverEndpoints[i]);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD)
return;
/* Mirror back the endpointUrl */
for(size_t i = 0; i < response->serverEndpointsSize; ++i) {
UA_String_deleteMembers(&response->serverEndpoints[i].endpointUrl);
UA_String_copy(&request->endpointUrl,
&response->serverEndpoints[i].endpointUrl);
}
UA_Session *newSession;
response->responseHeader.serviceResult =
UA_SessionManager_createSession(&server->sessionManager,
channel, request, &newSession);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Processing CreateSessionRequest failed");
return;
}
/* Fill the session with more information */
newSession->maxResponseMessageSize = request->maxResponseMessageSize;
newSession->maxRequestMessageSize =
channel->connection->localConf.maxMessageSize;
response->responseHeader.serviceResult |=
UA_ApplicationDescription_copy(&request->clientDescription,
&newSession->clientDescription);
/* Prepare the response */
response->sessionId = newSession->sessionId;
response->revisedSessionTimeout = (UA_Double)newSession->timeout;
response->authenticationToken = newSession->authenticationToken;
response->responseHeader.serviceResult =
UA_String_copy(&request->sessionName, &newSession->sessionName);
if(server->config.endpointsSize > 0)
response->responseHeader.serviceResult |=
UA_ByteString_copy(&channel->securityPolicy->localCertificate,
&response->serverCertificate);
/* Create a signed nonce */
response->responseHeader.serviceResult =
nonceAndSignCreateSessionResponse(server, channel, newSession, request, response);
/* Failure -> remove the session */
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager, &newSession->authenticationToken);
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Session " UA_PRINTF_GUID_FORMAT " created",
UA_PRINTF_GUID_DATA(newSession->sessionId.identifier.guid));
}
void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel,
const UA_CreateSessionRequest *request,
UA_CreateSessionResponse *response) {
if(channel->securityToken.channelId == 0) {
response->responseHeader.serviceResult =
UA_STATUSCODE_BADSECURECHANNELIDINVALID;
return;
}
/* Allocate the response */
response->serverEndpoints = (UA_EndpointDescription*)
UA_Array_new(server->config.endpoints.count,
&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
if(!response->serverEndpoints) {
response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
return;
}
response->serverEndpointsSize = server->config.endpoints.count;
/* Copy the server's endpointdescriptions into the response */
for(size_t i = 0; i < server->config.endpoints.count; ++i)
response->responseHeader.serviceResult |=
UA_EndpointDescription_copy(&server->config.endpoints.endpoints[0].endpointDescription,
&response->serverEndpoints[i]);
/* Mirror back the endpointUrl */
for(size_t i = 0; i < response->serverEndpointsSize; ++i) {
UA_String_deleteMembers(&response->serverEndpoints[i].endpointUrl);
UA_String_copy(&request->endpointUrl,
&response->serverEndpoints[i].endpointUrl);
}
UA_Session *newSession;
response->responseHeader.serviceResult =
UA_SessionManager_createSession(&server->sessionManager,
channel, request, &newSession);
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Processing CreateSessionRequest failed");
return;
}
/* Fill the session with more information */
newSession->maxResponseMessageSize = request->maxResponseMessageSize;
newSession->maxRequestMessageSize =
channel->connection->localConf.maxMessageSize;
response->responseHeader.serviceResult |=
UA_ApplicationDescription_copy(&request->clientDescription,
&newSession->clientDescription);
/* Prepare the response */
response->sessionId = newSession->sessionId;
response->revisedSessionTimeout = (UA_Double)newSession->timeout;
response->authenticationToken = newSession->authenticationToken;
response->responseHeader.serviceResult =
UA_String_copy(&request->sessionName, &newSession->sessionName);
if(server->config.endpoints.count > 0)
response->responseHeader.serviceResult |=
UA_ByteString_copy(&server->config.endpoints.endpoints[0].endpointDescription.serverCertificate,
&response->serverCertificate);
/* Failure -> remove the session */
if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
UA_SessionManager_removeSession(&server->sessionManager,
&newSession->authenticationToken);
return;
}
UA_LOG_DEBUG_CHANNEL(server->config.logger, channel,
"Session " UA_PRINTF_GUID_FORMAT " created",
UA_PRINTF_GUID_DATA(newSession->sessionId.identifier.guid));
}
