UaNodeId::UaNodeId ( const UaNodeId & other)
{
UA_NodeId_init( &m_impl );
UA_StatusCode status = UA_NodeId_copy( other.pimpl(), &this->m_impl );
if (status != UA_STATUSCODE_GOOD)
throw alloc_error();
}
static UA_Int64 sendReadRequest(ConnectionInfo *connectionInfo, UA_Int32 nodeIds_size,UA_NodeId* nodeIds){
/*UA_Int32 sock, UA_UInt32 channelId, UA_UInt32 tokenId, UA_UInt32 sequenceNumber, UA_UInt32 requestId,
UA_NodeId authenticationToken, UA_Int32 nodeIds_size,UA_NodeId* nodeIds) {
*/
UA_ByteString *message = UA_ByteString_new();
UA_ByteString_newMembers(message, 65536);
UA_UInt32 tmpChannelId = connectionInfo->channelId;
size_t offset = 0;
UA_TcpMessageHeader msghdr;
msghdr.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_NodeId type;
type.identifier.numeric = 631;
type.identifierType = UA_NODEIDTYPE_NUMERIC;
type.namespaceIndex = 0;
UA_ReadRequest rq;
UA_ReadRequest_init(&rq);
rq.maxAge = 0;
rq.nodesToRead = UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], nodeIds_size);
rq.nodesToReadSize = 1;
for(UA_Int32 i=0;i<nodeIds_size;i++) {
UA_ReadValueId_init(&(rq.nodesToRead[i]));
rq.nodesToRead[i].attributeId = 6; //WriteMask
UA_NodeId_init(&(rq.nodesToRead[i].nodeId));
rq.nodesToRead[i].nodeId = nodeIds[i];
UA_QualifiedName_init(&(rq.nodesToRead[0].dataEncoding));
}
rq.requestHeader.timeoutHint = 10000;
rq.requestHeader.timestamp = UA_DateTime_now();
rq.requestHeader.authenticationToken = connectionInfo->authenticationToken;
rq.timestampsToReturn = 0x03;
rq.requestHeader.requestHandle = 1 + connectionInfo->sequenceHdr.requestId;
msghdr.messageSize = 16 + UA_TcpMessageHeader_calcSizeBinary(&msghdr) + UA_NodeId_calcSizeBinary(&type) +
UA_ReadRequest_calcSizeBinary(&rq);
UA_TcpMessageHeader_encodeBinary(&msghdr,message,&offset);
UA_UInt32_encodeBinary(&tmpChannelId, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->tokenId, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.sequenceNumber, message, &offset);
UA_UInt32_encodeBinary(&connectionInfo->sequenceHdr.requestId, message, &offset);
UA_NodeId_encodeBinary(&type,message,&offset);
UA_ReadRequest_encodeBinary(&rq, message, &offset);
UA_DateTime tic = UA_DateTime_now();
UA_Int32 sendret = send(connectionInfo->socket, message->data, offset, 0);
UA_Array_delete(rq.nodesToRead, &UA_TYPES[UA_TYPES_READVALUEID], nodeIds_size);
UA_ByteString_delete(message);
if (sendret < 0) {
printf("send readrequest failed");
return 1;
}
return tic;
}
const UaNodeId& UaNodeId::operator=(const UaNodeId & other)
{
UA_NodeId_deleteMembers( &m_impl );
UA_NodeId_init( &m_impl );
UA_StatusCode status = UA_NodeId_copy( other.pimpl(), &this->m_impl );
if (status != UA_STATUSCODE_GOOD)
throw alloc_error();
return *this;
}
/* UA_Node */
static void UA_Node_init(UA_Node *p) {
UA_NodeId_init(&p->nodeId);
UA_NodeClass_init(&p->nodeClass);
UA_QualifiedName_init(&p->browseName);
UA_LocalizedText_init(&p->displayName);
UA_LocalizedText_init(&p->description);
UA_UInt32_init(&p->writeMask);
UA_UInt32_init(&p->userWriteMask);
p->referencesSize = -1;
p->references = UA_NULL;
}
static void *profileGetThread(void *arg) {
struct UA_NodeStoreProfileTest *test = (struct UA_NodeStoreProfileTest*) arg;
UA_NodeId id;
UA_NodeId_init(&id);
UA_Int32 max_val = test->max_val;
for(UA_Int32 x = 0; x<test->rounds; x++) {
for(UA_Int32 i=test->min_val; i<max_val; i++) {
id.identifier.numeric = i+1;
const UA_Node *n = ns.getNode(ns.context, &id);
ns.releaseNode(ns.context, n);
}
}
return NULL;
}
UA_Client * UA_Client_new(void) {
UA_Client *client = UA_malloc(sizeof(UA_Client));
if(!client)
return UA_NULL;
UA_String_init(&client->endpointUrl);
client->connection.state = UA_CONNECTION_OPENING;
client->sequenceNumber = 0;
client->requestId = 0;
/* Secure Channel */
UA_ChannelSecurityToken_deleteMembers(&client->securityToken);
UA_ByteString_init(&client->clientNonce);
UA_ByteString_init(&client->serverNonce);
UA_NodeId_init(&client->authenticationToken);
return client;
}
static void UA_Client_init(UA_Client* client, UA_ClientConfig config,
UA_Logger logger) {
client->state = UA_CLIENTSTATE_READY;
UA_Connection_init(&client->connection);
UA_SecureChannel_init(&client->channel);
client->channel.connection = &client->connection;
UA_String_init(&client->endpointUrl);
client->requestId = 0;
UA_NodeId_init(&client->authenticationToken);
client->requestHandle = 0;
client->logger = logger;
client->config = config;
client->scExpiresAt = 0;
#ifdef ENABLE_SUBSCRIPTIONS
client->monitoredItemHandles = 0;
LIST_INIT(&client->pendingNotificationsAcks);
LIST_INIT(&client->subscriptions);
#endif
}
UA_StatusCode
__UA_Client_addNode(UA_Client *client, const UA_NodeClass nodeClass, const UA_NodeId requestedNewNodeId,
const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
const UA_QualifiedName browseName, const UA_NodeId typeDefinition,
const UA_NodeAttributes *attr, const UA_DataType *attributeType, UA_NodeId *outNewNodeId) {
UA_StatusCode retval = UA_STATUSCODE_GOOD;
UA_AddNodesRequest request;
UA_AddNodesRequest_init(&request);
UA_AddNodesItem item;
UA_AddNodesItem_init(&item);
item.parentNodeId.nodeId = parentNodeId;
item.referenceTypeId = referenceTypeId;
item.requestedNewNodeId.nodeId = requestedNewNodeId;
item.browseName = browseName;
item.nodeClass = nodeClass;
item.typeDefinition.nodeId = typeDefinition;
item.nodeAttributes.encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE;
item.nodeAttributes.content.decoded.type = attributeType;
item.nodeAttributes.content.decoded.data = (void*)(uintptr_t)attr; // hack. is not written into.
request.nodesToAdd = &item;
request.nodesToAddSize = 1;
UA_AddNodesResponse response = UA_Client_Service_addNodes(client, request);
if(response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
retval = response.responseHeader.serviceResult;
UA_AddNodesResponse_deleteMembers(&response);
return retval;
}
if(response.resultsSize != 1) {
UA_AddNodesResponse_deleteMembers(&response);
return UA_STATUSCODE_BADUNEXPECTEDERROR;
}
if(outNewNodeId && response.results[0].statusCode == UA_STATUSCODE_GOOD) {
*outNewNodeId = response.results[0].addedNodeId;
UA_NodeId_init(&response.results[0].addedNodeId);
}
retval = response.results[0].statusCode;
UA_AddNodesResponse_deleteMembers(&response);
return retval;
}
OV_DLLFNCEXPORT UA_StatusCode servicesOPCUAInterface_interface_ovServiceOutputArgumentsNodeToOPCUA(
void *handle, const UA_NodeId *nodeId, UA_Node** opcuaNode) {
UA_Node *newNode = NULL;
UA_StatusCode result = UA_STATUSCODE_GOOD;
OV_PATH path;
OV_INSTPTR_ov_object pobj = NULL;
OV_TICKET *pTicket = NULL;
OV_VTBLPTR_ov_object pVtblObj = NULL;
OV_ACCESS access;
UA_NodeClass nodeClass;
OV_ELEMENT element;
OV_STRING tmpString = NULL;
OV_UINT len = 0;
OV_STRING *plist = NULL;
copyOPCUAStringToOV(nodeId->identifier.string, &tmpString);
plist = ov_string_split(tmpString, "||", &len);
ov_string_setvalue(&tmpString, NULL);
UA_NodeId tmpNodeId;
UA_NodeId_init(&tmpNodeId);
tmpNodeId.namespaceIndex = nodeId->namespaceIndex;
tmpNodeId.identifierType = nodeId->identifierType;
tmpNodeId.identifier.string = UA_String_fromChars(plist[0]);
ov_string_freelist(plist);
ov_memstack_lock();
result = opcua_nodeStoreFunctions_resolveNodeIdToPath(tmpNodeId, &path);
UA_NodeId_deleteMembers(&tmpNodeId);
if(result != UA_STATUSCODE_GOOD){
ov_memstack_unlock();
return result;
}
element = path.elements[path.size-1];
ov_memstack_unlock();
result = opcua_nodeStoreFunctions_getVtblPointerAndCheckAccess(&(element), pTicket, &pobj, &pVtblObj, &access);
if(result != UA_STATUSCODE_GOOD){
return result;
}
nodeClass = UA_NODECLASS_VARIABLE;
newNode = (UA_Node*)UA_calloc(1, sizeof(UA_VariableNode));
// Basic Attribute
// BrowseName
UA_QualifiedName qName;
qName.name = UA_String_fromChars("OutputArguments");
qName.namespaceIndex = 0; //pinterface->v_interfacenamespace.index;
newNode->browseName = qName;
// Description
OV_STRING tempString = pVtblObj->m_getcomment(pobj, &element);
UA_LocalizedText lText;
UA_LocalizedText_init(&lText);
lText.locale = UA_String_fromChars("en");
if(tempString){
lText.text = UA_String_fromChars(tempString);
} else {
lText.text = UA_String_fromChars("");
}
UA_LocalizedText_copy(&lText,&newNode->description);
UA_LocalizedText_deleteMembers(&lText);
// DisplayName
UA_LocalizedText displayName;
UA_LocalizedText_init(&displayName);
displayName.locale = UA_String_fromChars("en");
displayName.text = UA_String_fromChars("OutputArguments");
UA_LocalizedText_copy(&displayName, &newNode->displayName);
UA_LocalizedText_deleteMembers(&displayName);
// NodeId
UA_NodeId_copy(nodeId, &newNode->nodeId);
// NodeClass
newNode->nodeClass = nodeClass;
// WriteMask
UA_UInt32 writeMask = 0;
if(element.elemtype != OV_ET_VARIABLE){
if(access & OV_AC_WRITE){
writeMask |= (1<<2); // BrowseName
writeMask |= (1<<6); // DisplayName
}
if(access & OV_AC_RENAMEABLE){
writeMask |= (1<<14); // NodeId
}
}
newNode->writeMask = writeMask;
// Variable specific attributes
// value
OV_ELEMENT tmpPart;
tmpPart.elemtype = OV_ET_NONE;
tmpPart.pobj = NULL;
OV_ELEMENT tmpParrent;
tmpParrent.pobj = pobj;
tmpParrent.elemtype = OV_ET_OBJECT;
OV_UINT sizeOutput = 0;
do {
ov_element_getnextpart(&tmpParrent, &tmpPart, OV_ET_VARIABLE);
if (tmpPart.elemtype == OV_ET_NONE)
break;
if (tmpPart.elemunion.pvar->v_flags == 16384){ // OutputFlag is set
sizeOutput++;
continue;
}
} while(TRUE);
// arrayDemensions
if (sizeOutput > 1){
((UA_VariableNode*)newNode)->arrayDimensionsSize = 1;
UA_UInt32 *pOutputDimension = UA_UInt32_new();
*pOutputDimension = sizeOutput;
((UA_VariableNode*)newNode)->arrayDimensions = pOutputDimension; //UA_Array_new(((UA_VariableNode*)newNode)->arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]); /* scalar or one dimension */
// valuerank
((UA_VariableNode*)newNode)->valueRank = 1; /* one dimension */
}else{
((UA_VariableNode*)newNode)->arrayDimensionsSize = 0;
((UA_VariableNode*)newNode)->arrayDimensions = NULL; //UA_Array_new(((UA_VariableNode*)newNode)->arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]); /* scalar or one dimension */
// valuerank
((UA_VariableNode*)newNode)->valueRank = -1; /* one dimension */
}
// value
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->type = &UA_TYPES[UA_TYPES_ARGUMENT];
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->arrayLength = sizeOutput;
if (sizeOutput > 1){
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data = UA_Array_new(sizeOutput, &UA_TYPES[UA_TYPES_ARGUMENT]);
}else{
((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data = UA_Argument_new();
}
if (!((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data){
result = UA_STATUSCODE_BADOUTOFMEMORY;
return result;
}
((UA_VariableNode*)newNode)->value.data.value.hasValue = TRUE;
((UA_VariableNode*)newNode)->valueSource = UA_VALUESOURCE_DATA;
tmpPart.elemtype = OV_ET_NONE;
tmpPart.pobj = NULL;
OV_UINT count = 0;
do {
ov_element_getnextpart(&tmpParrent, &tmpPart, OV_ET_VARIABLE);
if (tmpPart.elemtype == OV_ET_NONE)
break;
if (tmpPart.elemunion.pvar->v_flags == 16384){ // OutputFlag is set
UA_Argument_init(&((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count]);
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].description = UA_LOCALIZEDTEXT_ALLOC("en_US","");
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].name = UA_STRING_ALLOC(tmpPart.elemunion.pvar->v_identifier);
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
switch(tmpPart.elemunion.pvar->v_vartype){
case OV_VT_BOOL:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_BOOLEAN].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_INT:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_INT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_UINT:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_SINGLE:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_FLOAT].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_DOUBLE:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_DOUBLE].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_ANY:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_VARIANT].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_STRING:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_STRING].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = -1;
break;
case OV_VT_BOOL_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_BOOLEAN].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_INT_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_INT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_UINT_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_SINGLE_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_FLOAT].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_DOUBLE_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_DOUBLE].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
case OV_VT_STRING_VEC:
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].dataType = UA_TYPES[UA_TYPES_STRING].typeId;
((UA_Argument*)((UA_Variant*)&((UA_VariableNode*)newNode)->value.data.value.value)->data)[count].valueRank = 1;
break;
default:
break;
}
count++;
if (count == sizeOutput){
break;
}else{
continue;
}
}
} while(TRUE);
ov_string_setvalue(&tmpString, NULL);
// accessLevel
UA_Byte accessLevel = 0;
if(access & OV_AC_READ){
accessLevel |= (1<<0);
}
if(access & OV_AC_WRITE){
accessLevel |= (1<<1);
}
((UA_VariableNode*)newNode)->accessLevel = accessLevel;
// minimumSamplingInterval
((UA_VariableNode*)newNode)->minimumSamplingInterval = -1;
// historizing
((UA_VariableNode*)newNode)->historizing = UA_FALSE;
// dataType
((UA_VariableNode*)newNode)->dataType = UA_NODEID_NUMERIC(0, 0);
// References have to do manual because it is an virtual node
size_t size_references = 0;
size_references = size_references + 2;// For Parent&TypeNode
newNode->references = UA_calloc(size_references, sizeof(UA_ReferenceNode));
if (!newNode->references){
result = ov_resultToUaStatusCode(OV_ERR_HEAPOUTOFMEMORY);
UA_free(newNode);
return result;
}
newNode->referencesSize = size_references;
// ParentNode
newNode->references[0].referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY);
newNode->references[0].isInverse = UA_TRUE;
len = 0;
plist = NULL;
tmpString = NULL;
copyOPCUAStringToOV(nodeId->identifier.string, &tmpString);
plist = ov_string_split(tmpString, "||", &len);
newNode->references[0].targetId = UA_EXPANDEDNODEID_STRING_ALLOC(pinterface->v_interfacenamespace.index, plist[0]);
ov_string_freelist(plist);
ov_string_setvalue(&tmpString, NULL);
// TypeNode
newNode->references[1].referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASTYPEDEFINITION);
newNode->references[1].isInverse = UA_FALSE;
newNode->references[1].targetId = UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE);
*opcuaNode = newNode;
return UA_STATUSCODE_GOOD;
}
static void setup(void) {
if (!(MUTEX_INIT(serverMutex))) {
fprintf(stderr, "Server mutex was not created correctly.\n");
exit(1);
}
running = true;
server = UA_Server_new();
UA_ServerConfig *config = UA_Server_getConfig(server);
UA_ServerConfig_setDefault(config);
#ifdef UA_ENABLE_HISTORIZING
gathering = (UA_HistoryDataGathering*)UA_calloc(1, sizeof(UA_HistoryDataGathering));
*gathering = UA_HistoryDataGathering_Default(1);
config->historyDatabase = UA_HistoryDatabase_default(*gathering);
#endif
UA_StatusCode retval = UA_Server_run_startup(server);
if(retval != UA_STATUSCODE_GOOD) {
fprintf(stderr, "Error while calling Server_run_startup. %s\n", UA_StatusCode_name(retval));
UA_Server_delete(server);
exit(1);
}
THREAD_CREATE(server_thread, serverloop);
/* Define the attribute of the uint32 variable node */
UA_VariableAttributes attr = UA_VariableAttributes_default;
UA_UInt32 myUint32 = 40;
UA_Variant_setScalar(&attr.value, &myUint32, &UA_TYPES[UA_TYPES_UINT32]);
attr.description = UA_LOCALIZEDTEXT("en-US","the answer");
attr.displayName = UA_LOCALIZEDTEXT("en-US","the answer");
attr.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE | UA_ACCESSLEVELMASK_HISTORYREAD | UA_ACCESSLEVELMASK_HISTORYWRITE;
attr.historizing = true;
/* Add the variable node to the information model */
UA_NodeId uint32NodeId = UA_NODEID_STRING(1, "the.answer");
UA_QualifiedName uint32Name = UA_QUALIFIEDNAME(1, "the answer");
parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
UA_NodeId_init(&outNodeId);
retval = UA_Server_addVariableNode(server, uint32NodeId, parentNodeId,
parentReferenceNodeId, uint32Name,
UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
attr, NULL, &outNodeId);
if (retval != UA_STATUSCODE_GOOD) {
fprintf(stderr, "Error adding variable node. %s\n", UA_StatusCode_name(retval));
UA_Server_delete(server);
exit(1);
}
client = UA_Client_new();
UA_ClientConfig_setDefault(UA_Client_getConfig(client));
retval = UA_Client_connect(client, "opc.tcp://localhost:4840");
if (retval != UA_STATUSCODE_GOOD) {
fprintf(stderr, "Client can not connect to opc.tcp://localhost:4840. %s\n", UA_StatusCode_name(retval));
UA_Client_delete(client);
UA_Server_delete(server);
exit(1);
}
UA_Client_recv = client->connection.recv;
client->connection.recv = UA_Client_recvTesting;
}
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;
}
}
int main(int argc , char *argv[]) {
int sock;
struct sockaddr_in server;
UA_ByteString message;
message.data = (UA_Byte*)malloc(1000*sizeof(UA_Byte));
message.length = 1000;
//UA_UInt32 messageEncodedLength = 0;
UA_Byte server_reply[2000];
unsigned int messagepos = 0;
//Create socket
#ifdef UA_ENABLE_NONSTANDARD_UDP
sock = socket(AF_INET , SOCK_DGRAM , 0);
#else
sock = socket(AF_INET , SOCK_STREAM , 0);
#endif
if(sock == -1) {
printf("Could not create socket");
}
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_family = AF_INET;
server.sin_port = htons( 16664 );
//Connect to remote server
if(connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
perror("connect failed. Error");
return 1;
}
UA_TcpMessageHeader reqTcpHeader;
UA_UInt32 reqSecureChannelId = 0;
UA_UInt32 reqTokenId = 0;
UA_SequenceHeader reqSequenceHeader;
UA_NodeId reqRequestType;
UA_ReadRequest req;
UA_RequestHeader reqHeader;
UA_NodeId reqHeaderAuthToken;
UA_ExtensionObject reqHeaderAdditionalHeader;
UA_NodeId_init(&reqRequestType);
reqRequestType.identifierType = UA_NODEIDTYPE_NUMERIC;
reqRequestType.identifier.numeric = 631; //read request
UA_SequenceHeader_init(&reqSequenceHeader);
reqSequenceHeader.sequenceNumber = 42;
UA_ReadRequest_init(&req);
req.requestHeader = reqHeader;
UA_RequestHeader_init(&(req.requestHeader));
req.requestHeader.authenticationToken = reqHeaderAuthToken;
UA_NodeId_init(&(req.requestHeader.authenticationToken));
req.requestHeader.additionalHeader = reqHeaderAdditionalHeader;
UA_ExtensionObject_init(&(req.requestHeader.additionalHeader));
req.nodesToRead= UA_Array_new(&UA_TYPES[UA_TYPES_READVALUEID], 1);
req.nodesToReadSize = 1;
UA_ReadValueId_init(&(req.nodesToRead[0]));
req.nodesToRead[0].attributeId = 13; //UA_ATTRIBUTEID_VALUE
UA_NodeId_init(&(req.nodesToRead[0].nodeId));
req.nodesToRead[0].nodeId.identifierType = UA_NODEIDTYPE_NUMERIC;
req.nodesToRead[0].nodeId.identifier.numeric = 2255;
UA_QualifiedName_init(&(req.nodesToRead[0].dataEncoding));
/**messageEncodedLength = UA_TcpMessageHeader_calcSizeBinary(&reqTcpHeader) +
UA_UInt32_calcSizeBinary(&reqSecureChannelId)+
UA_UInt32_calcSizeBinary(&reqTokenId)+
UA_SequenceHeader_calcSizeBinary(&reqSequenceHeader)+
UA_NodeId_calcSizeBinary(&reqRequestType) +
UA_ReadRequest_calcSizeBinary(&req);**/
UA_TcpMessageHeader_init(&reqTcpHeader);
reqTcpHeader.messageTypeAndFinal = UA_MESSAGETYPEANDFINAL_MSGF;
UA_TcpMessageHeader_encodeBinary(&reqTcpHeader, &message, &messagepos);
UA_UInt32_encodeBinary(&reqSecureChannelId, &message, &messagepos);
UA_UInt32_encodeBinary(&reqTokenId, &message, &messagepos);
UA_SequenceHeader_encodeBinary(&reqSequenceHeader, &message, &messagepos);
UA_NodeId_encodeBinary(&reqRequestType, &message, &messagepos);
UA_ReadRequest_encodeBinary(&req, &message, &messagepos);
reqTcpHeader.messageSize = messagepos;
messagepos=0;
UA_TcpMessageHeader_encodeBinary(&reqTcpHeader, &message, &messagepos);
UA_UInt32_encodeBinary(&reqSecureChannelId, &message, &messagepos);
UA_UInt32_encodeBinary(&reqTokenId, &message, &messagepos);
UA_SequenceHeader_encodeBinary(&reqSequenceHeader, &message, &messagepos);
UA_NodeId_encodeBinary(&reqRequestType, &message, &messagepos);
UA_ReadRequest_encodeBinary(&req, &message, &messagepos);
//Send some data
if(send(sock , message.data, messagepos , 0) < 0) {
puts("Send failed");
return 1;
}
//Receive a reply from the server
int received = recv(sock , server_reply , 2000 , 0);
if(received < 0) {
puts("recv failed");
return 1;
}
for(int i=0;i<received;i++) {
//show only printable ascii
if(server_reply[i] >= 32 && server_reply[i]<= 126)
printf("%c",server_reply[i]);
}
printf("\n");
close(sock);
return 0;
}
