UA_Int32 UA_OPCUATcpAcknowledgeMessage_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_OPCUATcpAcknowledgeMessage* dst) {
UA_Int32 retval = UA_SUCCESS;
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->protocolVersion));
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->receiveBufferSize));
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->sendBufferSize));
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->maxMessageSize));
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->maxChunkCount));
return retval;
}
UA_Int32 UA_OPCUATcpMessageHeader_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_OPCUATcpMessageHeader* dst) {
UA_Int32 retval = UA_SUCCESS;
retval |= UA_MessageType_decodeBinary(src,pos,&(dst->messageType));
retval |= UA_Byte_decodeBinary(src,pos,&(dst->isFinal));
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->messageSize));
return retval;
}
UA_Int32 UA_SecureConversationMessageHeader_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_SecureConversationMessageHeader* dst) {
UA_Int32 retval = UA_SUCCESS;
//retval |= UA_alloc((void**)&(dst->tcpMessageHeader),UA_OPCUATcpMessageHeader_calcSize(UA_NULL));
//retval |= UA_OPCUATcpMessageHeader_decode(src,pos,dst->tcpMessageHeader);
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->secureChannelId));
return retval;
}
/* Takes the raw message from the network layer */
void
UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection,
const UA_ByteString *message) {
UA_SecureChannel *channel = connection->channel;
if(channel) {
/* Assemble chunks in the securechannel and process complete messages */
UA_StatusCode retval =
UA_SecureChannel_processChunks(channel, message,
(UA_ProcessMessageCallback*)UA_Server_processSecureChannelMessage, server);
if(retval != UA_STATUSCODE_GOOD)
UA_LOG_TRACE_CHANNEL(server->config.logger, channel,
"Procesing chunkgs resulted in error code 0x%08x", retval);
} else {
/* Process messages without a channel and no chunking */
size_t offset = 0;
UA_TcpMessageHeader tcpMessageHeader;
UA_StatusCode retval = UA_TcpMessageHeader_decodeBinary(message, &offset, &tcpMessageHeader);
if(retval != UA_STATUSCODE_GOOD) {
connection->close(connection);
return;
}
/* Dispatch according to the message type */
switch(tcpMessageHeader.messageTypeAndChunkType & 0x00ffffff) {
case UA_MESSAGETYPE_HEL:
UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK,
"Connection %i | Process HEL message", connection->sockfd);
processHEL(connection, message, &offset);
break;
case UA_MESSAGETYPE_OPN: {
UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK,
"Connection %i | Process OPN message", connection->sockfd);
UA_UInt32 channelId = 0;
retval = UA_UInt32_decodeBinary(message, &offset, &channelId);
if(retval != UA_STATUSCODE_GOOD)
connection->close(connection);
UA_ByteString offsetMessage = (UA_ByteString){
.data = message->data + 12, .length = message->length - 12};
processOPN(server, connection, channelId, &offsetMessage);
break; }
case UA_MESSAGETYPE_MSG:
UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK,
"Connection %i | Processing a MSG message not possible "
"without a SecureChannel", connection->sockfd);
connection->close(connection);
break;
case UA_MESSAGETYPE_CLO:
UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK,
"Connection %i | Processing a CLO message not possible "
"without a SecureChannel", connection->sockfd);
connection->close(connection);
break;
default:
UA_LOG_TRACE(server->config.logger, UA_LOGCATEGORY_NETWORK,
"Connection %i | Unknown message type", connection->sockfd);
connection->close(connection);
}
}
}
static void processCLO(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *pos) {
UA_UInt32 secureChannelId;
UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
if(retval != UA_STATUSCODE_GOOD || !connection->channel ||
connection->channel->securityToken.channelId != secureChannelId)
return;
Service_CloseSecureChannel(server, secureChannelId);
}
static void processOPN(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg,
size_t *pos) {
if(connection->state != UA_CONNECTION_ESTABLISHED) {
connection->close(connection);
return;
}
UA_UInt32 secureChannelId;
UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
retval |= UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, pos, &asymHeader);
UA_SequenceHeader seqHeader;
retval |= UA_SequenceHeader_decodeBinary(msg, pos, &seqHeader);
UA_NodeId requestType;
retval |= UA_NodeId_decodeBinary(msg, pos, &requestType);
UA_OpenSecureChannelRequest r;
retval |= UA_OpenSecureChannelRequest_decodeBinary(msg, pos, &r);
if(retval != UA_STATUSCODE_GOOD || requestType.identifier.numeric != 446) {
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_SequenceHeader_deleteMembers(&seqHeader);
UA_NodeId_deleteMembers(&requestType);
UA_OpenSecureChannelRequest_deleteMembers(&r);
connection->close(connection);
return;
}
UA_OpenSecureChannelResponse p;
UA_OpenSecureChannelResponse_init(&p);
Service_OpenSecureChannel(server, connection, &r, &p);
UA_OpenSecureChannelRequest_deleteMembers(&r);
UA_SecureChannel *channel = connection->channel;
if(!channel) {
connection->close(connection);
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return;
}
/* send the response with an asymmetric security header */
seqHeader.sequenceNumber = channel->sequenceNumber;
UA_SecureConversationMessageHeader respHeader;
respHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
respHeader.messageHeader.messageSize = 0;
respHeader.secureChannelId = p.securityToken.channelId;
UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
UA_ENCODINGOFFSET_BINARY);
respHeader.messageHeader.messageSize =
UA_SecureConversationMessageHeader_calcSizeBinary(&respHeader)
+ UA_AsymmetricAlgorithmSecurityHeader_calcSizeBinary(&asymHeader)
+ UA_SequenceHeader_calcSizeBinary(&seqHeader)
+ UA_NodeId_calcSizeBinary(&responseType)
+ UA_OpenSecureChannelResponse_calcSizeBinary(&p);
UA_ByteString resp_msg;
retval = connection->getBuffer(connection, &resp_msg, respHeader.messageHeader.messageSize);
if(retval != UA_STATUSCODE_GOOD) {
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return;
}
size_t tmpPos = 0;
UA_SecureConversationMessageHeader_encodeBinary(&respHeader, &resp_msg, &tmpPos);
UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &resp_msg, &tmpPos); // just mirror back
UA_SequenceHeader_encodeBinary(&seqHeader, &resp_msg, &tmpPos); // just mirror back
UA_NodeId_encodeBinary(&responseType, &resp_msg, &tmpPos);
UA_OpenSecureChannelResponse_encodeBinary(&p, &resp_msg, &tmpPos);
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
connection->write(connection, &resp_msg);
connection->releaseBuffer(connection, &resp_msg);
}
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;
#ifdef EXTENSION_STATELESS
anonymousChannel.session = &anonymousSession;
#endif
}
/* Read the security header */
UA_UInt32 tokenId;
UA_SequenceHeader sequenceHeader;
retval = UA_UInt32_decodeBinary(msg, pos, &tokenId);
retval |= UA_SequenceHeader_decodeBinary(msg, pos, &sequenceHeader);
if(retval != UA_STATUSCODE_GOOD)
return;
/* 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: {
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: {
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_ADDREFERENCESREQUEST:
INVOKE_SERVICE(AddReferences, UA_TYPES_ADDREFERENCESRESPONSE);
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;
default: {
if(requestType.namespaceIndex == 0 && requestType.identifier.numeric==787)
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_COMMUNICATION,
"Client requested a subscription that are not supported, the message will be skipped");
else
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_COMMUNICATION, "Unknown request: NodeId(ns=%d, i=%d)",
requestType.namespaceIndex, requestType.identifier.numeric);
UA_RequestHeader p;
UA_ResponseHeader r;
if(UA_RequestHeader_decodeBinary(msg, pos, &p) != UA_STATUSCODE_GOOD)
return;
UA_ResponseHeader_init(&r);
init_response_header(&p, &r);
r.serviceResult = UA_STATUSCODE_BADSERVICEUNSUPPORTED;
#ifdef EXTENSION_STATELESS
if(retval != UA_STATUSCODE_GOOD)
r.serviceResult = retval;
#endif
UA_RequestHeader_deleteMembers(&p);
UA_SecureChannel_sendBinaryMessage(clientChannel, sequenceHeader.requestId,
&r, &UA_TYPES[UA_TYPES_RESPONSEHEADER]);
break;
}
}
}
static int ua_client_connectUA(char* ipaddress,int port, UA_String *endpointUrl, ConnectionInfo *connectionInfo,
UA_Boolean stateless, UA_Boolean udp) {
UA_ByteString reply;
UA_ByteString_newMembers(&reply, 65536);
int sock;
struct sockaddr_in server;
//Create socket
if(udp==UA_TRUE){
sock = socket(AF_INET, SOCK_DGRAM, 0);
}else{
sock = socket(AF_INET, SOCK_STREAM, 0);
}
if(sock == -1) {
printf("Could not create socket");
return 1;
}
server.sin_addr.s_addr = inet_addr(ipaddress);
server.sin_family = AF_INET;
server.sin_port = htons(port);
if(connect(sock, (struct sockaddr *) &server, sizeof(server)) < 0) {
perror("connect failed. Error");
return 1;
}
connectionInfo->socket = sock;
if(stateless){
UA_NodeId_init(&connectionInfo->authenticationToken);
connectionInfo->channelId=0;
UA_SequenceHeader_init(&connectionInfo->sequenceHdr);
connectionInfo->tokenId=0;
return 0;
}else{
sendHello(sock, endpointUrl);
recv(sock, reply.data, reply.length, 0);
sendOpenSecureChannel(sock);
recv(sock, reply.data, reply.length, 0);
size_t recvOffset = 0;
UA_TcpMessageHeader msghdr;
UA_TcpMessageHeader_decodeBinary(&reply, &recvOffset, &msghdr);
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
UA_NodeId rspType;
UA_OpenSecureChannelResponse openSecChannelRsp;
UA_UInt32_decodeBinary(&reply, &recvOffset, &connectionInfo->channelId);
UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(&reply,&recvOffset,&asymHeader);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_SequenceHeader_decodeBinary(&reply,&recvOffset,&connectionInfo->sequenceHdr);
UA_NodeId_decodeBinary(&reply,&recvOffset,&rspType);
UA_OpenSecureChannelResponse_decodeBinary(&reply,&recvOffset,&openSecChannelRsp);
connectionInfo->tokenId = openSecChannelRsp.securityToken.tokenId;
sendCreateSession(sock, connectionInfo->channelId, openSecChannelRsp.securityToken.tokenId, 52, 2, endpointUrl);
recv(sock, reply.data, reply.length, 0);
UA_NodeId messageType;
recvOffset = 24;
UA_NodeId_decodeBinary(&reply,&recvOffset,&messageType);
UA_CreateSessionResponse createSessionResponse;
UA_CreateSessionResponse_decodeBinary(&reply,&recvOffset,&createSessionResponse);
connectionInfo->authenticationToken = createSessionResponse.authenticationToken;
sendActivateSession(sock, connectionInfo->channelId, connectionInfo->tokenId, 53, 3,
connectionInfo->authenticationToken);
recv(sock, reply.data, reply.length, 0);
UA_OpenSecureChannelResponse_deleteMembers(&openSecChannelRsp);
UA_String_deleteMembers(&reply);
UA_CreateSessionResponse_deleteMembers(&createSessionResponse);
return 0;
}
}
UA_Int32 UA_SecureConversationMessageAbortBody_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_SecureConversationMessageAbortBody* dst) {
UA_Int32 retval = UA_SUCCESS;
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->error));
retval |= UA_String_decodeBinary(src,pos,&(dst->reason));
return retval;
}
UA_Int32 UA_SequenceHeader_decodeBinary(UA_ByteString const * src, UA_Int32* pos, UA_SequenceHeader* dst) {
UA_Int32 retval = UA_SUCCESS;
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->sequenceNumber));
retval |= UA_UInt32_decodeBinary(src,pos,&(dst->requestId));
return retval;
}
static void processOPN(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *pos) {
if(connection->state != UA_CONNECTION_ESTABLISHED) {
connection->close(connection);
return;
}
UA_UInt32 secureChannelId;
UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
UA_AsymmetricAlgorithmSecurityHeader asymHeader;
retval |= UA_AsymmetricAlgorithmSecurityHeader_decodeBinary(msg, pos, &asymHeader);
UA_SequenceHeader seqHeader;
retval |= UA_SequenceHeader_decodeBinary(msg, pos, &seqHeader);
UA_NodeId requestType;
retval |= UA_NodeId_decodeBinary(msg, pos, &requestType);
UA_OpenSecureChannelRequest r;
retval |= UA_OpenSecureChannelRequest_decodeBinary(msg, pos, &r);
if(retval != UA_STATUSCODE_GOOD || requestType.identifier.numeric != 446) {
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
UA_SequenceHeader_deleteMembers(&seqHeader);
UA_NodeId_deleteMembers(&requestType);
UA_OpenSecureChannelRequest_deleteMembers(&r);
connection->close(connection);
return;
}
UA_OpenSecureChannelResponse p;
UA_OpenSecureChannelResponse_init(&p);
Service_OpenSecureChannel(server, connection, &r, &p);
UA_OpenSecureChannelRequest_deleteMembers(&r);
UA_SecureChannel *channel = connection->channel;
if(!channel) {
connection->close(connection);
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return;
}
/* send the response with an asymmetric security header */
#ifndef UA_MULTITHREADING
seqHeader.sequenceNumber = ++channel->sequenceNumber;
#else
seqHeader.sequenceNumber = uatomic_add_return(&channel->sequenceNumber, 1);
#endif
UA_SecureConversationMessageHeader respHeader;
respHeader.messageHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_OPNF;
respHeader.messageHeader.messageSize = 0;
respHeader.secureChannelId = p.securityToken.channelId;
UA_NodeId responseType = UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE +
UA_ENCODINGOFFSET_BINARY);
UA_ByteString resp_msg;
retval = connection->getSendBuffer(connection, connection->remoteConf.recvBufferSize, &resp_msg);
if(retval != UA_STATUSCODE_GOOD) {
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
return;
}
size_t tmpPos = 12; /* skip the secureconversationmessageheader for now */
retval |= UA_AsymmetricAlgorithmSecurityHeader_encodeBinary(&asymHeader, &resp_msg, &tmpPos); // just mirror back
retval |= UA_SequenceHeader_encodeBinary(&seqHeader, &resp_msg, &tmpPos); // just mirror back
retval |= UA_NodeId_encodeBinary(&responseType, &resp_msg, &tmpPos);
retval |= UA_OpenSecureChannelResponse_encodeBinary(&p, &resp_msg, &tmpPos);
if(retval != UA_STATUSCODE_GOOD) {
connection->releaseSendBuffer(connection, &resp_msg);
connection->close(connection);
} else {
respHeader.messageHeader.messageSize = tmpPos;
tmpPos = 0;
UA_SecureConversationMessageHeader_encodeBinary(&respHeader, &resp_msg, &tmpPos);
resp_msg.length = respHeader.messageHeader.messageSize;
connection->send(connection, &resp_msg);
}
UA_OpenSecureChannelResponse_deleteMembers(&p);
UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(&asymHeader);
}
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;
}
}
}
static void
processMSG(UA_Connection *connection, UA_Server *server, const UA_ByteString *msg, size_t *pos) {
/* If we cannot decode these, don't respond */
UA_UInt32 secureChannelId = 0;
UA_UInt32 tokenId = 0;
UA_SequenceHeader sequenceHeader;
UA_NodeId requestTypeId;
UA_StatusCode retval = UA_UInt32_decodeBinary(msg, pos, &secureChannelId);
retval |= UA_UInt32_decodeBinary(msg, pos, &tokenId);
retval |= UA_SequenceHeader_decodeBinary(msg, pos, &sequenceHeader);
retval = UA_NodeId_decodeBinary(msg, pos, &requestTypeId);
if(retval != UA_STATUSCODE_GOOD)
return;
UA_SecureChannel *channel = connection->channel;
UA_SecureChannel anonymousChannel;
if(!channel) {
UA_SecureChannel_init(&anonymousChannel);
anonymousChannel.connection = connection;
channel = &anonymousChannel;
}
/* Test if the secure channel is ok */
if(secureChannelId != channel->securityToken.channelId)
return;
if(tokenId != channel->securityToken.tokenId) {
if(tokenId != channel->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.",
channel->securityToken.channelId);
Service_CloseSecureChannel(server, channel->securityToken.channelId);
return;
}
UA_SecureChannel_revolveTokens(channel);
}
/* Test if the service type nodeid has the right format */
if(requestTypeId.identifierType != UA_NODEIDTYPE_NUMERIC ||
requestTypeId.namespaceIndex != 0) {
UA_NodeId_deleteMembers(&requestTypeId);
sendError(channel, msg, *pos, sequenceHeader.requestId, UA_STATUSCODE_BADSERVICEUNSUPPORTED);
return;
}
/* Get the service pointers */
UA_Service service = NULL;
const UA_DataType *requestType = NULL;
const UA_DataType *responseType = NULL;
getServicePointers(requestTypeId.identifier.numeric, &requestType, &responseType, &service);
if(!service) {
/* The service is not supported */
if(requestTypeId.identifier.numeric==787)
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_SERVER,
"Client requested a subscription that are not supported, "
"the message will be skipped");
else
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_SERVER, "Unknown request: NodeId(ns=%d, i=%d)",
requestTypeId.namespaceIndex, requestTypeId.identifier.numeric);
sendError(channel, msg, *pos, sequenceHeader.requestId, UA_STATUSCODE_BADSERVICEUNSUPPORTED);
return;
}
/* Most services can only be called with a valid securechannel */
#ifndef EXTENSION_STATELESS
if(channel == &anonymousChannel &&
requestType->typeIndex > UA_TYPES_OPENSECURECHANNELREQUEST) {
sendError(channel, msg, *pos, sequenceHeader.requestId, UA_STATUSCODE_BADSECURECHANNELIDINVALID);
return;
}
#endif
/* Decode the request */
void *request = UA_alloca(requestType->memSize);
size_t oldpos = *pos;
retval = UA_decodeBinary(msg, pos, request, requestType);
if(retval != UA_STATUSCODE_GOOD) {
sendError(channel, msg, oldpos, sequenceHeader.requestId, retval);
return;
}
/* Find the matching session */
UA_Session *session =
UA_SecureChannel_getSession(channel, &((UA_RequestHeader*)request)->authenticationToken);
UA_Session anonymousSession;
if(!session) {
UA_Session_init(&anonymousSession);
anonymousSession.channel = channel;
anonymousSession.activated = UA_TRUE;
session = &anonymousSession;
}
/* Test if the session is valid */
if(!session->activated && requestType->typeIndex != UA_TYPES_ACTIVATESESSIONREQUEST) {
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_SERVER, "Client tries to call a service with a non-activated session");
sendError(channel, msg, *pos, sequenceHeader.requestId, UA_STATUSCODE_BADSESSIONNOTACTIVATED);
return;
}
#ifndef EXTENSION_STATELESS
if(session == &anonymousSession &&
requestType->typeIndex > UA_TYPES_ACTIVATESESSIONREQUEST) {
UA_LOG_INFO(server->logger, UA_LOGCATEGORY_SERVER, "Client tries to call a service without a session");
sendError(channel, msg, *pos, sequenceHeader.requestId, UA_STATUSCODE_BADSESSIONIDINVALID);
return;
}
#endif
/* Call the service */
UA_Session_updateLifetime(session);
void *response = UA_alloca(responseType->memSize);
UA_init(response, responseType);
init_response_header(request, response);
service(server, session, request, response);
/* Send the response */
retval = UA_SecureChannel_sendBinaryMessage(channel, sequenceHeader.requestId,
response, responseType);
if(retval != UA_STATUSCODE_GOOD) {
/* e.g. UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED */
sendError(channel, msg, oldpos, sequenceHeader.requestId, retval);
}
/* Clean up */
UA_deleteMembers(request, requestType);
UA_deleteMembers(response, responseType);
return;
}