Fix compilation errors in UDP network plugin (#820)

CMakeLists.txt

@@ -248,6 +248,10 @@ if(UA_ENABLE_GENERATE_NAMESPACE0)
   list(APPEND lib_sources ${PROJECT_BINARY_DIR}/src_generated/ua_namespaceinit_generated.c)
 endif()
 
+if(UA_ENABLE_NONSTANDARD_UDP)
+    list(APPEND exported_headers ${PROJECT_SOURCE_DIR}/plugins/ua_network_udp.h)
+endif()
+
 #########################
 # Generate source files #
 #########################

examples/CMakeLists.txt

@@ -28,7 +28,7 @@ add_executable(server server.c $<TARGET_OBJECTS:open62541-object>)
 target_link_libraries(server ${LIBS})
 
 if(UA_ENABLE_NONSTANDARD_UDP)
-  add_executable(server_udp server_udp.c $<TARGET_OBJECTS:open62541-object> ${PROJECT_SOURCE_DIR}/plugins/networklayer_udp.c)
+  add_executable(server_udp server_udp.c $<TARGET_OBJECTS:open62541-object> ${PROJECT_SOURCE_DIR}/plugins/ua_network_udp.c)
   target_link_libraries(server_udp ${LIBS})
 endif()
 

examples/server_udp.c

@@ -2,18 +2,21 @@
  * This work is licensed under a Creative Commons CCZero 1.0 Universal License.
  * See http://creativecommons.org/publicdomain/zero/1.0/ for more information.
  */
-#include <time.h>
 #include <stdio.h>
-#include <stdlib.h> 
 #include <signal.h>
 
-// provided by the open62541 lib
-# include "ua_types.h"
-# include "ua_server.h"
+#ifdef UA_NO_AMALGAMATION
+#include "ua_types.h"
+#include "ua_server.h"
+#include "ua_config_standard.h"
+#include "ua_log_stdout.h"
+#include "ua_network_udp.h"
+#else
+#include "open62541.h"
+#endif
 
-// provided by the user, implementations available in the /examples folder
-#include "logger_stdout.h"
-#include "networklayer_udp.h"
+
+UA_Logger logger = UA_Log_Stdout;
 
 UA_Boolean running = 1;
 
@@ -23,11 +26,15 @@ static void stopHandler(int sign) {
 }
 
 int main(int argc, char** argv) {
-    signal(SIGINT, stopHandler); /* catches ctrl-c */
+	signal(SIGINT,  stopHandler);
+	signal(SIGTERM, stopHandler);
 
-    UA_Server *server = UA_Server_new(UA_ServerConfig_standard);
-    UA_ServerNetworkLayer *nl = ServerNetworkLayerUDP_new(UA_ConnectionConfig_standard, 16664);
-    UA_Server_addNetworkLayer(server, nl);
+	UA_ServerConfig config = UA_ServerConfig_standard;
+	UA_ServerNetworkLayer nl;
+	nl = UA_ServerNetworkLayerUDP(UA_ConnectionConfig_standard, 16664);
+	config.networkLayers = &nl;
+	config.networkLayersSize = 1;
+	UA_Server *server = UA_Server_new(config);
 
     // add a variable node to the adresspace
     UA_VariableAttributes attr;
@@ -42,9 +49,9 @@ int main(int argc, char** argv) {
     UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
     UA_Server_addVariableNode(server, myIntegerNodeId, parentNodeId,
                               parentReferenceNodeId, myIntegerName,
-                              UA_NODEID_NULL, attr, NULL);
+                              UA_NODEID_NULL, attr, NULL, NULL);
 
-    UA_StatusCode retval = UA_Server_run(server, 1, &running);
+    UA_StatusCode retval = UA_Server_run(server, &running);
     UA_Server_delete(server);
 
     return (int) retval;

plugins/ua_network_udp.c

@@ -1,7 +1,7 @@
 /* This work is licensed under a Creative Commons CCZero 1.0 Universal License.
  * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. */
 
-#include "networklayer_udp.h"
+#include "ua_network_udp.h"
 #include <stdlib.h> // malloc, free
 #include <stdio.h>
 #include <string.h> // memset
@@ -45,7 +45,7 @@
 static UA_StatusCode GetMallocedBuffer(UA_Connection *connection, size_t length, UA_ByteString *buf) {
     if(length > connection->remoteConf.recvBufferSize)
         return UA_STATUSCODE_BADCOMMUNICATIONERROR;
-    return UA_ByteString_newMembers(buf, connection->remoteConf.recvBufferSize);
+    return UA_ByteString_allocBuffer(buf, connection->remoteConf.recvBufferSize);
 }
 
 static void ReleaseMallocedBuffer(UA_Connection *connection, UA_ByteString *buf) {
@@ -65,18 +65,19 @@ typedef struct {
 } UDPConnection;
 
 typedef struct {
-    UA_ServerNetworkLayer layer;
     UA_ConnectionConfig conf;
+	UA_UInt16 port;
     fd_set fdset;
     UA_Int32 serversockfd;
-    UA_UInt32 port;
+
+	UA_Logger logger; // Set during start
 } ServerNetworkLayerUDP;
 
 /** Accesses only the sockfd in the handle. Can be run from parallel threads. */
 static UA_StatusCode sendUDP(UA_Connection *connection, UA_ByteString *buf) {
     UDPConnection *udpc = (UDPConnection*)connection;
     ServerNetworkLayerUDP *layer = (ServerNetworkLayerUDP*)connection->handle;
-    size_t nWritten = 0;
+    long nWritten = 0;
     struct sockaddr_in *sin = NULL;
 
     if (udpc->from.sa_family == AF_INET) {
@@ -93,11 +94,11 @@ static UA_StatusCode sendUDP(UA_Connection *connection, UA_ByteString *buf) {
         return UA_STATUSCODE_BADINTERNALERROR;
     }
 
-    while (nWritten < (size_t)buf->length) {
-        UA_Int32 n = sendto(layer->serversockfd, buf->data, buf->length, 0,
+    while (nWritten < (long)buf->length) {
+        long n = sendto(layer->serversockfd, buf->data, buf->length, 0,
                             (struct sockaddr*)sin, sizeof(struct sockaddr_in));
         if(n == -1L) {
-            UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "UDP send error %i", errno);
+            UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "UDP send error %i", errno);
             UA_ByteString_deleteMembers(buf);
             return UA_STATUSCODE_BADINTERNALERROR;
         }
@@ -123,11 +124,12 @@ static void closeConnectionUDP(UA_Connection *handle) {
     free(handle);
 }
 
-static UA_StatusCode ServerNetworkLayerUDP_start(ServerNetworkLayerUDP *layer, UA_Logger logger) {
-    layer->layer.logger = logger;
+static UA_StatusCode ServerNetworkLayerUDP_start(UA_ServerNetworkLayer *nl, UA_Logger logger) {
+	ServerNetworkLayerUDP *layer = nl->handle;
+    layer->logger = logger;
     layer->serversockfd = socket(PF_INET, SOCK_DGRAM, 0);
     if(layer->serversockfd < 0) {
-        UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Error opening socket");
+        UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Error opening socket");
         return UA_STATUSCODE_BADINTERNALERROR;
     }
     const struct sockaddr_in serv_addr =
@@ -136,46 +138,47 @@ static UA_StatusCode ServerNetworkLayerUDP_start(ServerNetworkLayerUDP *layer, U
     int optval = 1;
     if(setsockopt(layer->serversockfd, SOL_SOCKET,
                   SO_REUSEADDR, (const char *)&optval, sizeof(optval)) == -1) {
-        UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Could not setsockopt");
+        UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Could not setsockopt");
         CLOSESOCKET(layer->serversockfd);
         return UA_STATUSCODE_BADINTERNALERROR;
     }
     if(bind(layer->serversockfd, (const struct sockaddr *)&serv_addr,
             sizeof(serv_addr)) < 0) {
-        UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Could not bind the socket");
+        UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Could not bind the socket");
         CLOSESOCKET(layer->serversockfd);
         return UA_STATUSCODE_BADINTERNALERROR;
     }
     socket_set_nonblocking(layer->serversockfd);
-    UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Listening for UDP connections on %s:%d",
+    UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "Listening for UDP connections on %s:%d",
                    inet_ntoa(serv_addr.sin_addr), ntohs(serv_addr.sin_port));
     return UA_STATUSCODE_GOOD;
 }
 
-static size_t ServerNetworkLayerUDP_getJobs(ServerNetworkLayerUDP *layer, UA_Job **jobs, UA_UInt16 timeout) {
+static size_t ServerNetworkLayerUDP_getJobs(UA_ServerNetworkLayer *nl, UA_Job **jobs, UA_UInt16 timeout) {
+	ServerNetworkLayerUDP *layer = nl->handle;
     UA_Job *items = NULL;
     setFDSet(layer);
     struct timeval tmptv = {0, timeout};
-    UA_Int32 resultsize = select(layer->serversockfd+1, &layer->fdset, NULL, NULL, &tmptv);
+    int resultsize = select(layer->serversockfd+1, &layer->fdset, NULL, NULL, &tmptv);
     if(resultsize <= 0 || !FD_ISSET(layer->serversockfd, &layer->fdset)) {
         *jobs = items;
         return 0;
     }
-    items = malloc(sizeof(UA_Job)*resultsize);
+    items = malloc(sizeof(UA_Job)*(unsigned long)resultsize);
     // read from established sockets
-    UA_Int32 j = 0;
-    UA_ByteString buf = {-1, NULL};
+	size_t j = 0;
+    UA_ByteString buf = {0, NULL};
     if(!buf.data) {
         buf.data = malloc(sizeof(UA_Byte) * layer->conf.recvBufferSize);
         if(!buf.data)
-            UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "malloc failed");
+            UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, "malloc failed");
     }
     struct sockaddr sender;
     socklen_t sendsize = sizeof(sender);
     bzero(&sender, sizeof(sender));
     ssize_t rec_result = recvfrom(layer->serversockfd, buf.data, layer->conf.recvBufferSize, 0, &sender, &sendsize);
     if (rec_result > 0) {
-        buf.length = rec_result;
+        buf.length = (size_t)rec_result;
         UDPConnection *c = malloc(sizeof(UDPConnection));
         if(!c){
                 free(items);
@@ -209,25 +212,37 @@ static size_t ServerNetworkLayerUDP_getJobs(ServerNetworkLayerUDP *layer, UA_Job
     return j;
 }
 
-static UA_Int32 ServerNetworkLayerUDP_stop(ServerNetworkLayerUDP * layer, UA_Job **jobs) {
+static size_t ServerNetworkLayerUDP_stop(UA_ServerNetworkLayer *nl, UA_Job **jobs) {
+	ServerNetworkLayerUDP *layer = nl->handle;
+	UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK,
+				"Shutting down the UDP network layer");
     CLOSESOCKET(layer->serversockfd);
     return 0;
 }
 
-static void ServerNetworkLayerUDP_deleteMembers(ServerNetworkLayerUDP *layer) {
+static void ServerNetworkLayerUDP_deleteMembers(UA_ServerNetworkLayer *nl) {
+	ServerNetworkLayerUDP *layer = nl->handle;
+	free(layer);
+	UA_String_deleteMembers(&nl->discoveryUrl);
 }
 
-UA_ServerNetworkLayer * ServerNetworkLayerUDP_new(UA_ConnectionConfig conf, UA_UInt32 port) {
+UA_ServerNetworkLayer
+UA_ServerNetworkLayerUDP(UA_ConnectionConfig conf, UA_UInt16 port) {
+	UA_ServerNetworkLayer nl;
+	memset(&nl, 0, sizeof(UA_ServerNetworkLayer));
+
     ServerNetworkLayerUDP *layer = malloc(sizeof(ServerNetworkLayerUDP));
     if(!layer)
-        return NULL;
+        return nl;
     memset(layer, 0, sizeof(ServerNetworkLayerUDP));
 
     layer->conf = conf;
     layer->port = port;
-    layer->layer.start = (UA_StatusCode(*)(UA_ServerNetworkLayer*,UA_Logger))ServerNetworkLayerUDP_start;
-    layer->layer.getJobs = (size_t(*)(UA_ServerNetworkLayer*,UA_Job**,UA_UInt16))ServerNetworkLayerUDP_getJobs;
-    layer->layer.stop = (size_t(*)(UA_ServerNetworkLayer*, UA_Job**))ServerNetworkLayerUDP_stop;
-    layer->layer.deleteMembers = (void(*)(UA_ServerNetworkLayer*))ServerNetworkLayerUDP_deleteMembers;
-    return &layer->layer;
+
+	nl.handle = layer;
+	nl.start = ServerNetworkLayerUDP_start;
+	nl.getJobs = ServerNetworkLayerUDP_getJobs;
+	nl.stop = ServerNetworkLayerUDP_stop;
+	nl.deleteMembers = ServerNetworkLayerUDP_deleteMembers;
+	return nl;
 }

plugins/ua_network_udp.h

@@ -1,8 +1,8 @@
 /* This work is licensed under a Creative Commons CCZero 1.0 Universal License.
  * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. */
 
-#ifndef UA_NETWORKLAYER_UDP_H_
-#define UA_NETWORKLAYER_UDP_H_
+#ifndef UA_NETWORK_UDP_H_
+#define UA_NETWORK_UDP_H_
 
 #ifdef __cplusplus
 extern "C" {
@@ -12,13 +12,14 @@ extern "C" {
 #include "ua_client.h"
 
 /* Create the UDP networklayer and listen to the specified port */
-UA_ServerNetworkLayer UA_EXPORT * ServerNetworkLayerUDP_new(UA_ConnectionConfig conf, UA_UInt32 port);
+UA_ServerNetworkLayer UA_EXPORT
+UA_ServerNetworkLayerUDP(UA_ConnectionConfig conf, UA_UInt16 port);
 
 UA_Connection UA_EXPORT
-ClientNetworkLayerUDP_connect(UA_ConnectionConfig conf, char endpointUrl[], UA_Logger logger);
+UA_ClientConnectionUDP(UA_ConnectionConfig conf, const char *endpointUrl, UA_Logger logger);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
-#endif /* UA_NETWORKLAYER_UDP_H_ */
+#endif /* UA_NETWORK_UDP_H_ */

src/server/ua_services_attribute.c

@@ -1,6 +1,8 @@
 #include "ua_server_internal.h"
 #include "ua_services.h"
-
+#ifdef UA_ENABLE_NONSTANDARD_STATELESS
+#include "ua_types_encoding_binary.h"
+#endif
 /******************/
 /* Read Attribute */
 /******************/