fixed merge error within connection_secureChannel branch

examples/src/networklayer.c

@@ -28,11 +28,9 @@ NL_Description NL_Description_TcpBinary  = {
 _Bool NL_ConnectionComparer(void *p1, void* p2) {
 	NL_Connection* c1 = (NL_Connection*) p1;
 	NL_Connection* c2 = (NL_Connection*) p2;
-	UA_UInt32 h1,h2;
-	UA_TL_Connection_getHandle(c1->connection,&h1);
-	UA_TL_Connection_getHandle(c2->connection,&h2);
 
-	return (h1 == h2);
+	return (c1->connectionHandle == c2->connectionHandle)
+
 }
 int NL_TCP_SetNonBlocking(int sock) {
 	int opts = fcntl(sock,F_GETFL);
@@ -135,15 +133,27 @@ void* NL_TCP_reader(NL_Connection *c) {
 
 
 	if (c->state  != CONNECTIONSTATE_CLOSE) {
-		DBG_VERBOSE(printf("NL_TCP_reader - enter read\n"));
+	//	DBG_VERBOSE(printf("NL_TCP_reader - enter read\n"));
 		readBuffer.length = read(connectionHandle, readBuffer.data, localBuffers.recvBufferSize);
-		DBG_VERBOSE(printf("NL_TCP_reader - leave read\n"));
+	//	DBG_VERBOSE(printf("NL_TCP_reader - leave read\n"));
 
-		DBG_VERBOSE(printf("NL_TCP_reader - src={%*.s}, ",c->connection.remoteEndpointUrl.length,c->connection.remoteEndpointUrl.data));
-		DBG(UA_ByteString_printx("NL_TCP_reader - received=",&readBuffer));
+	//	DBG_VERBOSE(printf("NL_TCP_reader - src={%*.s}, ",c->connection.remoteEndpointUrl.length,c->connection.remoteEndpointUrl.data));
+	//	DBG(UA_ByteString_printx("NL_TCP_reader - received=",&readBuffer));
 
 		if (readBuffer.length  > 0) {
-
+#ifdef DEBUG
+#include "ua_transport_binary_secure.h"
+			UA_UInt32 pos = 0;
+			UA_OPCUATcpMessageHeader header;
+			UA_OPCUATcpMessageHeader_decodeBinary(&readBuffer, &pos, &header);
+			pos = 24;
+			if(header.messageType == UA_MESSAGETYPE_MSG)
+			{
+				UA_NodeId serviceRequestType;
+				UA_NodeId_decodeBinary(&readBuffer, &pos,&serviceRequestType);
+				UA_NodeId_printf("Service Type\n",&serviceRequestType);
+			}
+#endif
 			TL_Process((c->connection),&readBuffer);
 		} else {
 //TODO close connection - what does close do?
@@ -154,12 +164,7 @@ void* NL_TCP_reader(NL_Connection *c) {
 	}
 	UA_TL_Connection_getState(c->connection, &connectionState);
 	if (connectionState == CONNECTIONSTATE_CLOSE) {
-		DBG_VERBOSE(printf("NL_TCP_reader - enter shutdown\n"));
-		shutdown(connectionHandle,2);
-		DBG_VERBOSE(printf("NL_TCP_reader - enter close\n"));
-		close(connectionHandle);
-		DBG_VERBOSE(printf("NL_TCP_reader - leave close\n"));
-		UA_TL_Connection_setState(c->connection,CONNECTIONSTATE_CLOSED);
+		UA_TL_Connection_close(c->connection);
 
 		//c->state  = CONNECTIONSTATE_CLOSED;
 
@@ -204,8 +209,8 @@ UA_Int32 NL_TCP_writer(UA_Int32 connectionHandle, UA_ByteString const * const *
 		iov[i].iov_base = gather_buf[i]->data;
 		iov[i].iov_len = gather_buf[i]->length;
 		total_len += gather_buf[i]->length;
-		DBG(printf("NL_TCP_writer - gather_buf[%i]",i));
-		DBG(UA_ByteString_printx("=", gather_buf[i]));
+//		DBG(printf("NL_TCP_writer - gather_buf[%i]",i));
+//		DBG(UA_ByteString_printx("=", gather_buf[i]));
 	}
 
 	struct msghdr message;
@@ -236,18 +241,33 @@ UA_Int32 NL_TCP_writer(UA_Int32 connectionHandle, UA_ByteString const * const *
 	}
 	return UA_SUCCESS;
 }
-
+//callback function which is called when the UA_TL_Connection_close() function is initiated
+UA_Int32 NL_Connection_close(UA_TL_Connection1 connection)
+{
+	NL_Connection *networkLayerData = UA_NULL;
+	UA_TL_Connection_getNetworkLayerData(connection, (void**)&networkLayerData);
+	if(networkLayerData != UA_NULL){
+		DBG_VERBOSE(printf("NL_Connection_close - enter shutdown\n"));
+		shutdown(networkLayerData->connectionHandle,2);
+		DBG_VERBOSE(printf("NL_Connection_close - enter close\n"));
+		close(networkLayerData->connectionHandle);
+		DBG_VERBOSE(printf("NL_Connection_close - leave close\n"));
+		return UA_SUCCESS;
+	}
+    DBG_VERBOSE(printf("NL_Connection_close - ERROR: connection object invalid \n"));
+	return UA_ERROR;
+}
 void* NL_Connection_init(NL_Connection* c, NL_data* tld, UA_Int32 connectionHandle, NL_Reader reader, TL_Writer writer)
 {
 
 
 	UA_TL_Connection1 connection = UA_NULL;
 	//create new connection object
-	UA_TL_Connection_new(&connection, tld->tld->localConf,writer);
+	UA_TL_Connection_new(&connection, tld->tld->localConf, writer, NL_Connection_close,c);
 	//add connection object to list, so stack is aware of its connections
 	UA_TL_Connection_setConnectionHandle(connection,connectionHandle);
 
-	UA_TL_ConnectionManager_addConnection(&connection);
+//	UA_TL_ConnectionManager_addConnection(&connection);
 
 	// connection layer of UA stackwriteLock
 	c->connection = connection;
@@ -322,7 +342,6 @@ void* NL_TCP_listenThread(NL_Connection* c) {
 }
 #endif
 
-
 UA_Int32 NL_TCP_init(NL_data* tld, UA_Int32 port) {
 	UA_Int32 retval = UA_SUCCESS;
 	// socket variables
@@ -385,3 +404,4 @@ NL_data* NL_init(NL_Description* tlDesc, UA_Int32 port) {
 	}
 	return nl;
 }
+

examples/src/networklayer.h

@@ -56,6 +56,7 @@ typedef struct NL_Connection {
 } NL_Connection;
 
 NL_data* NL_init(NL_Description* tlDesc, UA_Int32 port);
+UA_Int32 NL_Connection_close(UA_TL_Connection1 connection);
 UA_Int32 NL_msgLoop(NL_data* nl, struct timeval* tv,UA_Int32 (*timeoutCallBack)(void*),void *arg);
 UA_Int32 NL_TCP_writer(UA_Int32 connectionHandle, UA_ByteString const * const * gather_buf, UA_UInt32 gather_len);
 

examples/src/opcuaServerACPLT.c

@@ -112,7 +112,7 @@ void server_run() {
 		UA_TL_ConnectionManager_getConnectionByHandle(newsockfd, &tmpConnection);
 		if(tmpConnection == UA_NULL)
 		{
-			UA_TL_Connection_new(&connection, localBuffers, (TL_Writer)NL_TCP_writer);
+			UA_TL_Connection_new(&connection, localBuffers, (TL_Writer)NL_TCP_writer,NL_Connection_close,UA_NULL);
 		}
 		UA_TL_Connection_getState(connection, &connectionState);
 

src/ua_application.c

@@ -527,8 +527,6 @@ void appMockup_init() {
 	Namespace_insert(ns0,(UA_Node*)serverstatus);
 
 	// State (Component of ServerStatus)
-	UA_Int32 *stateVal;
-	UA_Int32_new(&stateVal);
 	UA_VariableNode *state;
 	UA_VariableNode_new(&state);
 	state->nodeId = ObjId_State.nodeId;

src/ua_services.h

@@ -241,6 +241,9 @@ UA_Int32 Service_CreateSubscription(UA_Session session, const UA_CreateSubscript
                                    UA_CreateSubscriptionResponse *response);
 // Service_ModifySubscription
 // Service_SetPublishingMode
+UA_Int32 Service_SetPublishingMode(UA_Session session, const UA_SetPublishingModeRequest *request,
+                                   UA_SetPublishingModeResponse *response);
+
 UA_Int32 Service_Publish(UA_Session session, const UA_PublishRequest *request,
                                    UA_PublishResponse *response);
 

src/ua_services_subscription.c

@@ -28,3 +28,11 @@ UA_Int32 Service_Publish(UA_Session session, const UA_PublishRequest *request,
 	return UA_SUCCESS;
 }
 
+UA_Int32 Service_SetPublishingMode(UA_Session session, const UA_SetPublishingModeRequest *request,
+                                   UA_SetPublishingModeResponse *response)
+{
+	response->diagnosticInfos = UA_NULL;
+	response->results = UA_NULL;
+	response->resultsSize = 0;
+	return UA_SUCCESS;
+}

src/ua_stack_channel.c

@@ -437,6 +437,9 @@ UA_Int32 SL_Channel_processCloseRequest(SL_secureChannel channel,
 		const UA_CloseSecureChannelRequest* request)
 {
 	SL_Channel_setState(channel,UA_SL_CHANNEL_CLOSED);
+	UA_TL_Connection1 connection;
+	SL_Channel_getConnection(channel, &connection);
+	UA_TL_Connection_close(connection);
 	return UA_SUCCESS;
 }
 

src/ua_transport.c

@@ -480,6 +480,7 @@ UA_Int32 UA_SecureConversationMessageFooter_copy(const UA_SecureConversationMess
     	if(src == UA_NULL || dst == UA_NULL) return UA_ERROR;
     	UA_Int32 retval = UA_SUCCESS;
 	memcpy(dst, src, sizeof(UA_SecureConversationMessageFooter));
+
 	dst->padding = src->padding;
 	retval |= UA_Array_copy(&src->padding, src->paddingSize,&UA_.types[UA_BYTE],(void**)&dst->padding);
 	return retval;

src/ua_transport_binary.c

@@ -5,7 +5,7 @@
 #include "ua_transport_connection.h"
 
 
-static UA_Int32 TL_handleHello1(UA_TL_Connection1 connection, const UA_ByteString* msg, UA_UInt32* pos){
+static UA_Int32 TL_handleHello(UA_TL_Connection1 connection, const UA_ByteString* msg, UA_UInt32* pos){
 	UA_Int32 retval = UA_SUCCESS;
 	UA_UInt32 tmpPos = 0;
 	UA_Int32 connectionState;
@@ -57,66 +57,7 @@ static UA_Int32 TL_handleHello1(UA_TL_Connection1 connection, const UA_ByteStrin
 	}
 	return retval;
 }
-/*
-static UA_Int32 TL_handleHello(TL_Connection* connection, const UA_ByteString* msg, UA_Int32* pos) {
-	UA_Int32 retval = UA_SUCCESS;
-	UA_Int32 tmpPos = 0;
-	UA_OPCUATcpHelloMessage helloMessage;
-
-
-	if (connection->connectionState == CONNECTIONSTATE_CLOSED) {
-		DBG_VERBOSE(printf("TL_handleHello - extracting header information \n"));
-		UA_OPCUATcpHelloMessage_decodeBinary(msg,pos,&helloMessage);
-
-		// memorize buffer info and change mode to established
-		connection->remoteConf.protocolVersion = helloMessage.protocolVersion;
-		connection->remoteConf.recvBufferSize = helloMessage.receiveBufferSize;
-		connection->remoteConf.sendBufferSize = helloMessage.sendBufferSize;
-		connection->remoteConf.maxMessageSize = helloMessage.maxMessageSize;
-		connection->remoteConf.maxChunkCount = helloMessage.maxChunkCount;
-		UA_String_copy(&(helloMessage.endpointUrl), &(connection->remoteEndpointUrl));
-		UA_OPCUATcpHelloMessage_deleteMembers(&helloMessage);
-
-		DBG_VERBOSE(printf("TL_handleHello - protocolVersion = %d \n",connection->remoteConf.protocolVersion));
-		DBG_VERBOSE(printf("TL_handleHello - recvBufferSize = %d \n",connection->remoteConf.recvBufferSize));
-		DBG_VERBOSE(printf("TL_handleHello - sendBufferSize = %d \n",connection->remoteConf.sendBufferSize));
-		DBG_VERBOSE(printf("TL_handleHello - maxMessageSize = %d \n",connection->remoteConf.maxMessageSize));
-		DBG_VERBOSE(printf("TL_handleHello - maxChunkCount = %d \n",connection->remoteConf.maxChunkCount));
-		connection->connectionState = CONNECTIONSTATE_ESTABLISHED;
-
-		// build acknowledge response
-		UA_OPCUATcpAcknowledgeMessage ackMessage;
-		ackMessage.protocolVersion = connection->localConf.protocolVersion;
-		ackMessage.receiveBufferSize = connection->localConf.recvBufferSize;
-		ackMessage.sendBufferSize = connection->localConf.sendBufferSize;
-		ackMessage.maxMessageSize = connection->localConf.maxMessageSize;
-		ackMessage.maxChunkCount = connection->localConf.maxChunkCount;
-
-		UA_OPCUATcpMessageHeader ackHeader;
-		ackHeader.messageType = UA_MESSAGETYPE_ACK;
-		ackHeader.isFinal = 'F';
 
-		// encode header and message to buffer
-		tmpPos = 0;
-		ackHeader.messageSize = UA_OPCUATcpAcknowledgeMessage_calcSize(&ackMessage) + UA_OPCUATcpMessageHeader_calcSize(&ackHeader);
-		UA_ByteString *ack_msg;
-		UA_alloc((void **)&ack_msg, sizeof(UA_ByteString));
-		UA_ByteString_newMembers(ack_msg, ackHeader.messageSize);
-		UA_OPCUATcpMessageHeader_encodeBinary(&ackHeader,&tmpPos,ack_msg);
-		UA_OPCUATcpAcknowledgeMessage_encodeBinary(&ackMessage,&tmpPos,ack_msg);
-
-		DBG_VERBOSE(printf("TL_handleHello - Size messageToSend = %d, pos=%d\n",ackHeader.messageSize, tmpPos));
-		DBG_VERBOSE(UA_ByteString_printx("_handleHello - ack=", ack_msg));
-		TL_Send(connection, (const UA_ByteString **) &ack_msg, 1);
-		DBG_VERBOSE(printf("TL_handleHello - finished writing\n"));
-		UA_ByteString_delete(ack_msg);
-	} else {
-		DBG_ERR(printf("TL_handleHello - wrong connection state \n"));
-		retval = UA_ERROR_MULTIPLE_HEL;
-	}
-	return retval;
-}
-*/
 
 static UA_Int32 TL_securitySettingsMockup_get(UA_ByteString *receiverCertificateThumbprint,UA_ByteString *securityPolicyUri, UA_ByteString *senderCertificate)
 {
@@ -199,28 +140,28 @@ UA_Int32 TL_Process(UA_TL_Connection1 connection, const UA_ByteString* msg) {
 
 	DBG_VERBOSE(printf("TL_Process - entered \n"));
 
-	if ((retval = UA_OPCUATcpMessageHeader_decodeBinary(msg, &pos, &tcpMessageHeader)) == UA_SUCCESS) {
-		printf("TL_Process - messageType=%.*s\n",3,msg->data);
-		switch(tcpMessageHeader.messageType) {
-		case UA_MESSAGETYPE_HEL:
-			retval = TL_handleHello1(connection, msg, &pos);
-			//retval = TL_handleHello(connection, msg, &pos);
-
-			break;
-		case UA_MESSAGETYPE_OPN:
-			retval = TL_handleOpen(connection, msg, &pos);
-			break;
-		case UA_MESSAGETYPE_MSG:
-			retval = TL_handleMsg(connection, msg, &pos);
-			break;
-		case UA_MESSAGETYPE_CLO:
-			retval = TL_handleClo(connection, msg, &pos);
-			break;
-		default: // dispatch processing to secureLayer
-			retval = UA_ERR_INVALID_VALUE;
-			break;
+	do{
+		if ((retval = UA_OPCUATcpMessageHeader_decodeBinary(msg,&pos,&tcpMessageHeader)) == UA_SUCCESS) {
+			printf("TL_Process - messageType=%.*s\n",3,msg->data);
+			switch(tcpMessageHeader.messageType) {
+			case UA_MESSAGETYPE_HEL:
+				retval = TL_handleHello(connection, msg, &pos);
+				break;
+			case UA_MESSAGETYPE_OPN:
+				retval = TL_handleOpen(connection, msg, &pos);
+				break;
+			case UA_MESSAGETYPE_MSG:
+				retval = TL_handleMsg(connection, msg, &pos);
+				break;
+			case UA_MESSAGETYPE_CLO:
+				retval = TL_handleClo(connection, msg, &pos);
+				break;
+			default: // dispatch processing to secureLayer
+				retval = UA_ERR_INVALID_VALUE;
+				break;
+			}
 		}
-	}
+	}while(msg->length > (UA_Int32)pos);
 	/* if (retval != UA_SUCCESS) { */
 	/* 	// FIXME: compose real error message */
 	/* 	UA_ByteString errorMsg; */

src/ua_transport_binary_secure.c

@@ -345,6 +345,23 @@ UA_Int32 SL_handleRequest(SL_secureChannel channel, const UA_ByteString* msg,
 
 		responsetype = UA_CREATEMONITOREDITEMSRESPONSE_NS0;
 	}
+	else if (serviceid == UA_SETPUBLISHINGMODEREQUEST_NS0)
+	{
+		RESPONSE_PREPARE(SetPublishingMode);
+		DBG_VERBOSE(printf("Finished Service: %s\n",SetPublishingMode));
+		if (UA_Session_verifyChannel(session,channel)){
+			Service_SetPublishingMode(session, &p, &r);
+		}
+		else
+		{
+			DBG_VERBOSE(printf("session does not match secure channel"));
+		}
+		DBG_VERBOSE(printf("Finished Service: %s\n", SetPublishingMode));
+		RESPONSE_CLEANUP(SetPublishingMode);
+		//TODO prepare userdefined implementation
+
+		responsetype = UA_SETPUBLISHINGMODERESPONSE_NS0;
+	}
 	else
 	{
 		printf(

src/ua_transport_connection.c

@@ -15,10 +15,12 @@ typedef struct TL_Connection{
 	TL_Writer writer;
 	UA_String localEndpointUrl;
 	UA_String remoteEndpointUrl;
+	TL_Closer closeCallback;
+	void *networkLayerData;
 } TL_Connection;
 
 
-UA_Int32 UA_TL_Connection_new(UA_TL_Connection1 *connection, TL_Buffer localBuffers,TL_Writer writer)
+UA_Int32 UA_TL_Connection_new(UA_TL_Connection1 *connection, TL_Buffer localBuffers,TL_Writer writer, TL_Closer closeCallback, void* networkLayerData)
 {
 	UA_Int32 retval = UA_SUCCESS;
 	retval |= UA_alloc((void**)connection,sizeof(TL_Connection));
@@ -26,7 +28,9 @@ UA_Int32 UA_TL_Connection_new(UA_TL_Connection1 *connection, TL_Buffer localBuff
 	{
 		(*((TL_Connection**)connection))->localConf = localBuffers;
 		(*((TL_Connection**)connection))->writer = writer;
+		(*((TL_Connection**)connection))->closeCallback = closeCallback;
 		(*((TL_Connection**)connection))->state = CONNECTIONSTATE_CLOSED;
+		(*((TL_Connection**)connection))->networkLayerData = networkLayerData;
 	}
 	return retval;
 }
@@ -41,6 +45,7 @@ UA_Int32 UA_TL_Connection_delete(UA_TL_Connection1 connection)
 UA_Int32 UA_TL_Connection_close(UA_TL_Connection1 connection)
 {
 	((TL_Connection*)connection)->state = CONNECTIONSTATE_CLOSE;
+	((TL_Connection*)connection)->closeCallback(connection);
 	return UA_SUCCESS;
 }
 
@@ -110,6 +115,18 @@ UA_Int32 UA_TL_Connection_getState(UA_TL_Connection1 connection, UA_Int32 *conne
 	}
 }
 
+UA_Int32 UA_TL_Connection_getNetworkLayerData(UA_TL_Connection1 connection,void** networkLayerData)
+{
+	if(connection)
+	{
+		*networkLayerData = ((TL_Connection*)connection)->networkLayerData;
+		return UA_SUCCESS;
+	}else{
+		*networkLayerData = UA_NULL;
+		return UA_ERROR;
+	}
+}
+
 UA_Int32 UA_TL_Connection_getProtocolVersion(UA_TL_Connection1 connection, UA_UInt32 *protocolVersion)
 {
 	if(connection)
@@ -148,7 +165,6 @@ UA_Int32 UA_TL_Connection_bind(UA_TL_Connection1 connection, UA_Int32 handle)
 {
 	if(connection)
 	{
-
 		((TL_Connection*)connection)->connectionHandle = handle;
 		return UA_SUCCESS;
 	}else{

src/ua_transport_connection.h

@@ -21,7 +21,7 @@ typedef struct TL_Buffer{
 
 typedef struct TL_Connection *UA_TL_Connection1;
 
-
+typedef UA_Int32 (*TL_Closer)(UA_TL_Connection1);
 typedef UA_Int32 (*TL_Writer)(UA_Int32 connectionHandle, const UA_ByteString** gather_bufs, UA_Int32 gather_len); // send mutiple buffer concatenated into one msg (zero copy)
 
 
@@ -31,8 +31,7 @@ UA_Int32 UA_TL_Connection_delete(UA_TL_Connection1 connection);
 UA_Int32 UA_TL_Connection_callWriter(UA_TL_Connection1 connection, const UA_ByteString** gather_bufs, UA_Int32 gather_len);
 
 UA_Int32 UA_TL_Connection_close(UA_TL_Connection1 connection);
-UA_Int32 UA_TL_Connection_new(UA_TL_Connection1 *connection,
-		TL_Buffer localBuffers,TL_Writer writer);
+UA_Int32 UA_TL_Connection_new(UA_TL_Connection1 *connection, TL_Buffer localBuffers,TL_Writer writer, TL_Closer closeCallback, void* networkLayerData);
 UA_Int32 UA_TL_Connection_bind(UA_TL_Connection1 connection, UA_Int32 handle);
 UA_Boolean UA_TL_Connection_compare(UA_TL_Connection1 *connection1, UA_TL_Connection1 *connection2);
 
@@ -46,6 +45,7 @@ UA_Int32 UA_TL_Connection_getHandle(UA_TL_Connection1 connection, UA_UInt32 *con
 UA_Int32 UA_TL_Connection_getProtocolVersion(UA_TL_Connection1 connection, UA_UInt32 *protocolVersion);
 UA_Int32 UA_TL_Connection_getState(UA_TL_Connection1 connection, UA_Int32 *connectionState);
 UA_Int32 UA_TL_Connection_getLocalConfiguration(UA_TL_Connection1 connection, TL_Buffer *localConfiguration);
+UA_Int32 UA_TL_Connection_getNetworkLayerData(UA_TL_Connection1 connection,void** networkLayerData);
 
 
 #endif /* UA_TRANSPORT_CONNECTION_H_ */

src/ua_transport_connection_manager.h

@@ -11,7 +11,7 @@
 #include "ua_transport_connection.h"
 
 
-
+UA_Int32 UA_TL_ConnectionManager_init(UA_UInt32 maxConnectionCount);
 UA_Int32 UA_TL_ConnectionManager_addConnection(UA_TL_Connection1 *connection);
 UA_Int32 UA_TL_ConnectionManager_removeConnection(UA_TL_Connection1 connection);
 //getter

src/util/ua_list.c

@@ -105,12 +105,18 @@ UA_Int32 UA_list_removeLast(UA_list_List* list, UA_list_PayloadVisitor visitor){
 	UA_list_Element* temp = UA_NULL;
 	if(list->last){
 		temp = list->last->prev;
+		if(temp == UA_NULL)
+		{
+			return UA_ERROR;
+		}
+
 		if(visitor){
 			(*visitor)(list->last->payload);
 		}
 		UA_free(list->last);
 		temp->next = UA_NULL;
 		list->last = temp;
+		list->last->next = UA_NULL;
 		list->size--;
 		if(list->size == 1){
 			list->first = temp;