opcua 0.15 → 0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b88e1080f821f09f3d4fd61010839ab8f55aa93079443bcc06690e51a241ae7e
-  data.tar.gz: 6d61c4f16cf5f9165338aefee2cee562c676b8e32916791c9358e2de5356041c
+  metadata.gz: b563025f5af4ab20c27a4f6ff05e5e442dab0d44462c346bd7d32ac3ff58ad49
+  data.tar.gz: '059f6ae8d6a8ed02d7577e8c7fc55154f5574549cdb47628bb4e1ace0675a3eb'
 SHA512:
-  metadata.gz: 486f8eb376b8531bc11f448f6d649725a28a823e4eb7feccb667141a5365f4155089296887b7bb4e8dc11e20cf16db2fc4f4bbed6737ee160631f584e5491b95
-  data.tar.gz: 37969a55340a2ced0f2f31ca9922c39c9d4df266e98e9c06f27846ddc390c965704c8f4f3473567a3c9f52a95d45e2a02a84cb1f190f4731a6832d89c041829b
+  metadata.gz: b4bcf7661e9be89ac2a6be22404e07274ee829b23ee1afde5647d7f7bd0cd6987d396542e802ae5e2303895888abcc8b6a68244f97b2010b677375a01e04835b
+  data.tar.gz: 1fe326883189de7b5395009677b0241f23bd539a7c31e2001e63ff6bcb4c1b1c8f8d4371eb3e8e48578dcc6e9fdac215145659673da335a2b173aa02a83a3bc2

data/README.md

@@ -1,6 +1,6 @@
 # OPC-UA Ruby Bindings (open62541)
 
-The development of OPC UA applications takes currently a lot of effort. This is caused by the large possibilities of the OPC UA specification. With this implemtation we want to define some conventions, which shoud make the technology more useable.
+The development of OPC UA applications takes currently a lot of effort. This is caused by the large possibilities of the OPC UA specification. With this implementation we want to define some conventions, which shoud make the technology more useable.
 
 ## Table of Contents
 
@@ -30,27 +30,31 @@ Copyright (C) 2019-* Jürgen "eTM" Mangler . opcua-sm
 
 ## Installation
 
-Dependency: https://github.com/open62541/open62541 > 0.4 (master branch as of 2019-04-26)
+
+```sh
+# Debian/Ubuntu
+apt install build-essential cmake-curses-gui libmbedtls-dev libxml2-dev libxslt-dev libz-dev libssl-dev libicu-dev
+# Fedora/Redhat
+dnf install @buildsys-build @development-tools cmake libxml2-devel libxslt-devel zlib-devel libicu-devel mbedtls-devel
+```
+
+Dependency: https://github.com/open62541/open62541 > 1.1 (master branch as of 2020-06-04)
 
 ```sh
 git clone https://github.com/open62541/open62541.git
 cd open62541
-mkdir build
-cd build
-cmake ..
-ccmake ..
-# Configuration, see picture below
+mkdir build && cd build
+cmake -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUA_ENABLE_AMALGAMATION=ON -DUA_ENABLE_ENCRYPTION=ON -DUA_ENABLE_ENCRYPTION_MBEDTLS=ON ..
 make
 sudo make install
 gem install opcua
 ```
 
-![ccmake Config](config.png)
-
 If the installation works correctly, but examples are still complaining about missing lib62541.so, try this:
 
 ```sh
-sudo echo "/usr/local/lib" > /etc/ld.so.conf.d/local.conf # add to libs path
+sudo echo "/usr/local/lib" >> /etc/ld.so.conf.d/local.conf # add to libs path
+sudo echo "/usr/local/lib64" >> /etc/ld.so.conf.d/local.conf # add to libs path
 sudo ldconfig # update libs
 sudo ldconfig -p | grep libopen62541 # check if its there
 ```
@@ -67,7 +71,7 @@ The server has following functions:
 * Find nodes in the adress space
 * Loop for getting real life data
 
-Every server application uses the Demonite gem, which allows to run the server as service.
+Every server application uses the Daemonite gem, which allows to run the server as service.
 ```ruby
 Daemonite.new do
   on startup do |opts|
@@ -93,7 +97,7 @@ server.add_namespace "https://yourdomain/testserver"
 ```
 
 
-#### Create ObjectTypes 
+#### Create ObjectTypes
 
 Basically all new created types are subtypes of the _BaseObjectType_. With ```server.types.add_object_type(:TestObjectType)``` a new type is defined in the information model. All nodes of the new created type are defined in the ```tap{}``` region.
 
@@ -129,7 +133,7 @@ With ```.add_object(:TestObject)``` a new object named _TestObject_ is added. Th
 
 ##### Add Method
 
-Methods are added with the ```.add_method(:TestMethod)``` function. Per default the method has no input and output arguments. By adding additional arguments you can define input arguments. The code for defining a method with input arguments looks like 
+Methods are added with the ```.add_method(:TestMethod)``` function. Per default the method has no input and output arguments. By adding additional arguments you can define input arguments. The code for defining a method with input arguments looks like
 ```ruby
  t.add_method :TestMethod, inputarg1: OPCUA::TYPES::STRING, inputarg2: OPCUA::TYPES::DATETIME do |node, inputarg1, inputarg2|
     #do some stuff here
@@ -140,7 +144,7 @@ in the ```do...end```section you write the code which should be executed by call
 
 #### Manifest Objects
 
-ObjectTypes can be instiantiated with the ```.manifest``` method. 
+ObjectTypes can be instiantiated with the ```.manifest``` method.
 
 ```ruby
 testobject =server.objects.manifest(:TestObjectType, to)
@@ -156,7 +160,7 @@ testobject.delete!
 
 #### Find Nodes in the Addressspace
 
-To get a specific node you should use the ```.find``` method. 
+To get a specific node you should use the ```.find``` method.
 ```ruby
 tv = to.find :TestVariable
 ```
@@ -187,7 +191,7 @@ You can assign vlaues without definig a datatype. The correct _DataType_ will be
 #### Loop for getting Real Life Data
 The server loop looks like follows:
 ```ruby
- run do 
+ run do
     sleep server.run
     to.value = 'Testvariable1'
     p to.value
@@ -196,7 +200,7 @@ The server loop looks like follows:
  end
 ```
 
-The loop starts with ```sleep server.run```. This is recommended by the open62541 developer. With the ```.value``` function you can write or get the value of a node. 
+The loop starts with ```sleep server.run```. This is recommended by the open62541 developer. With the ```.value``` function you can write or get the value of a node.
 
 ### Client
 TBD. See examples subdirectory.

data/Rakefile

@@ -1,24 +1,26 @@
 require 'rubygems/package_task'
-require 'rake/extensiontask'
 require 'fileutils'
 
 spec = eval(File.read('opcua.gemspec'))
 
-puts `cert/generate_certificate.sh`
+task :compile do
+  require 'rake/extensiontask'
 
-spec.extensions.each do |f|
-  Rake.application.clear
+  puts `cert/generate_certificate.sh`
+  spec.extensions.each do |f|
+    Rake.application.clear
 
-  task :default => [:compile]
+    task :default => [:compile]
 
-  t = Rake::ExtensionTask.new "opcua/" + File.basename(File.dirname(f)), spec
-  Rake::Task[:default].invoke
+    t = Rake::ExtensionTask.new "opcua/" + File.basename(File.dirname(f)), spec
+    Rake::Task[:default].invoke
+  end
+  Rake.application.clear
 end
-Rake.application.clear
 
-task :default => [:gem]
+task :default => [:compile]
 
-pkg = Gem::PackageTask.new(spec) do |pkg|
+Gem::PackageTask.new(spec) do |pkg|
   pkg.need_zip = true
   pkg.need_tar = true
   FileUtils.mkdir 'pkg' rescue nil
@@ -26,10 +28,16 @@ pkg = Gem::PackageTask.new(spec) do |pkg|
   FileUtils.ln_sf "#{pkg.name}.gem", "pkg/#{spec.name}.gem"
 end
 
-task :push => :gem do |r|
+task :push => :gem do
   `gem push pkg/opcua.gem`
 end
 
-task :install => :gem do |r|
+task :install => :gem do
   `gem install pkg/opcua.gem`
 end
+
+task :clean do
+  FileUtils.rm_rf(File.join(__dir__,'tmp'))
+  FileUtils.rm_rf(File.join(__dir__,'lib','opcua','client.so'))
+  FileUtils.rm_rf(File.join(__dir__,'lib','opcua','server.so'))
+end

data/cert/cert.h

@@ -1,70 +1,70 @@
 unsigned char cert_der[] = {
   0x30, 0x82, 0x03, 0x18, 0x30, 0x82, 0x02, 0x00, 0xa0, 0x03, 0x02, 0x01,
-  0x02, 0x02, 0x14, 0x34, 0x2f, 0x44, 0xf3, 0xa4, 0x03, 0xc5, 0x6d, 0xea,
-  0x21, 0x16, 0xa3, 0x64, 0xa9, 0x82, 0x24, 0xda, 0xa3, 0xba, 0x61, 0x30,
+  0x02, 0x02, 0x14, 0x7e, 0x53, 0x21, 0xef, 0xe9, 0x0b, 0x90, 0x45, 0x91,
+  0x50, 0x71, 0x15, 0x0a, 0xcb, 0x99, 0x5a, 0xe3, 0x98, 0xc0, 0xdd, 0x30,
   0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
   0x05, 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04,
   0x03, 0x0c, 0x0a, 0x72, 0x75, 0x62, 0x79, 0x2d, 0x6f, 0x70, 0x63, 0x75,
-  0x61, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x39, 0x30, 0x38, 0x32, 0x39, 0x31,
-  0x34, 0x34, 0x39, 0x33, 0x32, 0x5a, 0x17, 0x0d, 0x32, 0x30, 0x30, 0x38,
-  0x31, 0x38, 0x31, 0x34, 0x34, 0x39, 0x33, 0x32, 0x5a, 0x30, 0x15, 0x31,
+  0x61, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x30, 0x30, 0x37, 0x31, 0x30, 0x31,
+  0x34, 0x30, 0x36, 0x30, 0x32, 0x5a, 0x17, 0x0d, 0x32, 0x31, 0x30, 0x36,
+  0x33, 0x30, 0x31, 0x34, 0x30, 0x36, 0x30, 0x32, 0x5a, 0x30, 0x15, 0x31,
   0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0a, 0x72, 0x75,
   0x62, 0x79, 0x2d, 0x6f, 0x70, 0x63, 0x75, 0x61, 0x30, 0x82, 0x01, 0x22,
   0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
   0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a,
-  0x02, 0x82, 0x01, 0x01, 0x00, 0xe0, 0x7b, 0x3a, 0x29, 0x39, 0xbf, 0x5e,
-  0x05, 0xd2, 0xed, 0x67, 0xb8, 0x2d, 0xba, 0xb2, 0x3c, 0xc9, 0xdb, 0x01,
-  0xc9, 0x20, 0x89, 0x80, 0x5e, 0x1c, 0xe1, 0x7c, 0x6e, 0x8e, 0xb5, 0x5a,
-  0x27, 0xf2, 0x39, 0x76, 0x1b, 0x4a, 0xb0, 0x4d, 0xed, 0xf0, 0xfa, 0xda,
-  0xc8, 0x0a, 0x0e, 0x9f, 0xff, 0xd9, 0x56, 0x74, 0xa1, 0x53, 0x15, 0x12,
-  0x5c, 0x8a, 0xb2, 0x48, 0x22, 0x60, 0xfb, 0x84, 0x6d, 0xf3, 0x2b, 0xcf,
-  0x2b, 0x2a, 0x4b, 0xa6, 0xcb, 0x8c, 0x87, 0x48, 0x99, 0xc1, 0x54, 0x1e,
-  0x6a, 0xd0, 0x2e, 0xb9, 0xfb, 0x5b, 0xf1, 0xd8, 0x4b, 0x4f, 0x17, 0xda,
-  0xd3, 0x08, 0x84, 0x7c, 0xa3, 0xe4, 0x78, 0xa5, 0x58, 0xe0, 0x71, 0xd7,
-  0x4b, 0x5a, 0x9a, 0x8e, 0x42, 0x15, 0x81, 0xf3, 0x1a, 0xd7, 0x23, 0x61,
-  0x9b, 0xb6, 0x0a, 0xe4, 0xec, 0xd7, 0xb6, 0xd5, 0x0c, 0xf6, 0x06, 0xf5,
-  0x31, 0xbb, 0xa9, 0xa6, 0x2b, 0x4c, 0xbf, 0xab, 0x3b, 0x28, 0x94, 0x65,
-  0x0e, 0x78, 0xcf, 0xad, 0x42, 0x91, 0x24, 0xea, 0xa6, 0x8a, 0x9d, 0xdc,
-  0xac, 0x3f, 0x58, 0xb0, 0x72, 0xbe, 0xe5, 0xb8, 0x9c, 0x1b, 0x2a, 0xa1,
-  0xee, 0x82, 0x5e, 0xe1, 0xde, 0x0d, 0x7f, 0x1a, 0x6a, 0x91, 0x7c, 0xd1,
-  0x62, 0x50, 0x2d, 0xad, 0x78, 0x6a, 0x05, 0xae, 0xb7, 0xf2, 0xbe, 0xe5,
-  0xfa, 0x06, 0x0e, 0x62, 0x2e, 0xd9, 0xaf, 0xa4, 0xa5, 0x26, 0xb3, 0x78,
-  0xdf, 0x58, 0x39, 0x80, 0xa3, 0x77, 0x4d, 0xd7, 0x4c, 0x80, 0xe6, 0xb6,
-  0x67, 0x1f, 0x59, 0xee, 0xe3, 0xc1, 0xc1, 0x69, 0xf0, 0xfb, 0x3a, 0xd8,
-  0xff, 0x6c, 0xbc, 0x22, 0x80, 0x94, 0xc4, 0x40, 0xfa, 0x06, 0x32, 0xa8,
-  0xe2, 0x71, 0x4f, 0x4c, 0x72, 0xa6, 0x39, 0xba, 0xe5, 0xb9, 0x2a, 0xd0,
-  0x25, 0x95, 0x54, 0x0d, 0x51, 0x9a, 0xc6, 0xd6, 0x37, 0x02, 0x03, 0x01,
+  0x02, 0x82, 0x01, 0x01, 0x00, 0xbf, 0xcd, 0xca, 0x15, 0x60, 0x85, 0x47,
+  0xb7, 0x3d, 0x38, 0x00, 0xe2, 0x1f, 0xcc, 0xc9, 0x15, 0x7f, 0xb1, 0x58,
+  0xc8, 0x33, 0x8e, 0x74, 0x52, 0x1e, 0xcc, 0x5f, 0xe0, 0xa4, 0x11, 0x92,
+  0x47, 0x66, 0xb6, 0x33, 0x0c, 0xd0, 0xde, 0x39, 0xf6, 0xd0, 0x7b, 0x78,
+  0x6c, 0x13, 0xf8, 0xfd, 0x2b, 0xf0, 0x67, 0xbf, 0xd4, 0x54, 0xb9, 0x10,
+  0xf3, 0x1c, 0xa5, 0xe5, 0x10, 0x4f, 0x14, 0x63, 0x5e, 0x62, 0x19, 0x4b,
+  0xf8, 0x6e, 0x38, 0xfd, 0x31, 0xb9, 0x64, 0xb3, 0xb1, 0xe1, 0xe5, 0x80,
+  0x59, 0xef, 0x85, 0x21, 0x02, 0x73, 0x95, 0x3a, 0xe0, 0xc5, 0x4c, 0xbb,
+  0xc8, 0x72, 0x96, 0x0d, 0x17, 0xae, 0x89, 0xa8, 0x6a, 0xf9, 0xb0, 0xf0,
+  0xaf, 0xf7, 0xda, 0xbe, 0x13, 0x43, 0xb2, 0xce, 0xa5, 0x52, 0x3d, 0x16,
+  0xf1, 0x1a, 0x19, 0xad, 0xb1, 0x9f, 0xfb, 0x06, 0x00, 0x91, 0xff, 0xf5,
+  0x06, 0x38, 0x63, 0x6f, 0x09, 0x52, 0x97, 0x98, 0x86, 0xfe, 0xab, 0xb8,
+  0xe4, 0x27, 0x03, 0xdb, 0x8b, 0x5a, 0x2d, 0xcd, 0x65, 0x5f, 0x48, 0x09,
+  0xb8, 0xa7, 0xba, 0xf3, 0xf3, 0xa2, 0xe9, 0xbc, 0x35, 0x6f, 0x34, 0xf0,
+  0x38, 0xc8, 0x14, 0x28, 0x8c, 0x98, 0x28, 0x9f, 0xb4, 0x50, 0xfd, 0xb4,
+  0x9c, 0xf0, 0xb6, 0x5f, 0x4e, 0x4c, 0xdb, 0x84, 0x98, 0xce, 0xb1, 0x54,
+  0xb3, 0x57, 0xbd, 0x12, 0x0c, 0x09, 0x21, 0x7f, 0x44, 0x37, 0xbf, 0xb3,
+  0x44, 0xc2, 0x30, 0x61, 0x99, 0x2f, 0x67, 0x1a, 0x19, 0xc0, 0x67, 0xa5,
+  0x82, 0xe7, 0xd6, 0x08, 0x6f, 0x26, 0x64, 0x8f, 0x56, 0x66, 0xd5, 0x8a,
+  0x08, 0x54, 0x6c, 0xad, 0xf8, 0x7c, 0x1a, 0x18, 0xdb, 0xc0, 0xf1, 0x5d,
+  0x4f, 0x68, 0xe5, 0x93, 0x52, 0x4a, 0x58, 0x67, 0x7d, 0x7c, 0x2c, 0xb7,
+  0x59, 0x16, 0x6e, 0x67, 0xab, 0x10, 0xe2, 0xab, 0x11, 0x02, 0x03, 0x01,
   0x00, 0x01, 0xa3, 0x60, 0x30, 0x5e, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d,
-  0x0e, 0x04, 0x16, 0x04, 0x14, 0x22, 0x23, 0x55, 0x4f, 0x8f, 0xd3, 0x96,
-  0x92, 0x13, 0x7f, 0x4c, 0x3b, 0x68, 0x03, 0x39, 0x0d, 0x84, 0x5d, 0x9b,
-  0xc8, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04,
+  0x0e, 0x04, 0x16, 0x04, 0x14, 0x23, 0x5a, 0xee, 0xbe, 0x0a, 0x8d, 0x60,
+  0xac, 0x7e, 0x6b, 0xaa, 0xc2, 0xd7, 0x15, 0x4d, 0x8d, 0xac, 0x48, 0x2a,
+  0x59, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04,
   0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x1c, 0x06, 0x03, 0x55, 0x1d,
   0x11, 0x04, 0x15, 0x30, 0x13, 0x86, 0x11, 0x72, 0x75, 0x62, 0x79, 0x2d,
   0x6f, 0x70, 0x63, 0x75, 0x61, 0x3a, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74,
   0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d, 0x0f, 0x01, 0x01, 0xff, 0x04, 0x04,
   0x03, 0x02, 0x05, 0xa0, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
   0xf7, 0x0d, 0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01, 0x01, 0x00,
-  0x67, 0x88, 0x14, 0x27, 0xe4, 0xd6, 0xb7, 0x31, 0xa6, 0xb3, 0x7e, 0xc7,
-  0x56, 0x0a, 0x6e, 0xda, 0x91, 0xb0, 0x47, 0x90, 0x6f, 0x41, 0x7b, 0x89,
-  0xf5, 0x71, 0x3a, 0x86, 0x0f, 0xc1, 0x97, 0x34, 0x96, 0x7b, 0x3d, 0x49,
-  0xc6, 0x49, 0xd1, 0x52, 0xb1, 0xb5, 0xf3, 0x05, 0x71, 0x8d, 0x69, 0xf4,
-  0xe3, 0x66, 0x51, 0xdd, 0xa1, 0x3b, 0x1c, 0x01, 0xdd, 0x43, 0xc4, 0xe7,
-  0x84, 0x0f, 0xf8, 0x7c, 0xe8, 0xae, 0xdc, 0xb7, 0x5c, 0xe0, 0xc5, 0x4c,
-  0x98, 0x0d, 0xdd, 0xcc, 0x77, 0x0d, 0x66, 0x4e, 0x19, 0xf6, 0x03, 0x02,
-  0x5c, 0xc1, 0x9f, 0x45, 0x4d, 0x45, 0xd4, 0xe8, 0xc3, 0xb1, 0xef, 0x9e,
-  0x61, 0x79, 0xaf, 0xfc, 0xc7, 0x6a, 0xca, 0x97, 0xb1, 0xf0, 0xf1, 0x5c,
-  0xa3, 0xc2, 0xee, 0x02, 0x26, 0x04, 0xe7, 0x8e, 0xff, 0x5f, 0x6f, 0x70,
-  0x72, 0x30, 0x6d, 0x5b, 0x6c, 0x55, 0xf8, 0x57, 0x67, 0xf7, 0x77, 0x81,
-  0xad, 0xb0, 0x29, 0x04, 0x6a, 0x17, 0x13, 0x5b, 0xdb, 0x68, 0x46, 0x46,
-  0x31, 0xd7, 0x25, 0xdb, 0xfb, 0x04, 0x3a, 0x35, 0x9a, 0x0b, 0x77, 0x0e,
-  0xb3, 0x56, 0xb1, 0xa6, 0x56, 0x75, 0xe4, 0x51, 0x4e, 0x51, 0x4e, 0xb0,
-  0xd2, 0xbf, 0x0d, 0xf3, 0x43, 0x1c, 0x21, 0xd9, 0x54, 0x97, 0x64, 0xdf,
-  0xee, 0xa7, 0xc9, 0xfa, 0xdc, 0xca, 0xa3, 0x27, 0xd7, 0xe1, 0x65, 0xac,
-  0x57, 0xfb, 0x0d, 0x4d, 0x07, 0x81, 0x88, 0x35, 0xdf, 0x5e, 0x1a, 0xf3,
-  0x5e, 0x1b, 0xc9, 0xe9, 0x2e, 0xec, 0x97, 0xbc, 0x38, 0x8b, 0x65, 0xd4,
-  0x92, 0xce, 0xbb, 0xfd, 0x87, 0x1e, 0x96, 0xce, 0xc1, 0x18, 0x01, 0xbb,
-  0xc8, 0x96, 0xf4, 0xf0, 0x3b, 0x7e, 0xc0, 0x1f, 0x42, 0x0f, 0xfb, 0x92,
-  0xc6, 0xf5, 0x57, 0xdf, 0xfb, 0xa1, 0x99, 0xe8, 0x43, 0x29, 0x11, 0xec,
-  0x21, 0x1d, 0x61, 0x85
+  0x9e, 0x76, 0xfa, 0x53, 0xcd, 0x42, 0xf6, 0x59, 0x5f, 0xab, 0x4a, 0x68,
+  0x8c, 0xad, 0x60, 0xc1, 0x70, 0xeb, 0xf0, 0x64, 0x79, 0x2e, 0x12, 0x5c,
+  0xf4, 0x62, 0x7c, 0x8d, 0x88, 0x2b, 0xe2, 0x8f, 0x4c, 0xca, 0x46, 0xfb,
+  0xc0, 0x4b, 0xad, 0x8c, 0xbb, 0x6f, 0xf8, 0x43, 0x4c, 0x07, 0x99, 0xe0,
+  0xdd, 0x91, 0x07, 0x46, 0x21, 0x3f, 0xe0, 0xc1, 0x3c, 0xa5, 0x59, 0x3c,
+  0x61, 0xde, 0xea, 0xf4, 0x37, 0x1c, 0xe6, 0x11, 0x64, 0x83, 0x1b, 0x53,
+  0x5e, 0xb5, 0xc0, 0x4c, 0x78, 0x5c, 0xbc, 0xaa, 0xb1, 0xe6, 0x23, 0x75,
+  0xe1, 0x1d, 0x80, 0x4f, 0xe3, 0x6b, 0x37, 0xb2, 0x08, 0xf9, 0x86, 0xf8,
+  0x95, 0xa2, 0x71, 0x08, 0xe7, 0x3d, 0xe1, 0x5b, 0x7b, 0x46, 0x6c, 0x05,
+  0x71, 0xa1, 0xf6, 0x5e, 0x24, 0x3b, 0x30, 0x59, 0x53, 0x25, 0x5c, 0xf0,
+  0xe7, 0x6f, 0xb1, 0x2e, 0xdf, 0x29, 0x60, 0xb5, 0xe9, 0x9e, 0xda, 0x26,
+  0xa2, 0x35, 0xff, 0x05, 0x6b, 0x12, 0xec, 0x45, 0xd2, 0x65, 0x12, 0x72,
+  0xf2, 0x27, 0xeb, 0x19, 0xcf, 0x1e, 0xa4, 0x5b, 0xdb, 0x48, 0x5d, 0x73,
+  0xc9, 0xd1, 0x38, 0x98, 0xc2, 0xb4, 0x57, 0x12, 0xb8, 0xc4, 0x9c, 0x8d,
+  0xad, 0xd9, 0x03, 0x01, 0x39, 0xa3, 0x90, 0x3c, 0xce, 0xcc, 0xc8, 0x38,
+  0x82, 0x20, 0x6a, 0x74, 0x25, 0xe5, 0x38, 0x8c, 0x70, 0xf0, 0xe4, 0x03,
+  0x54, 0x42, 0x12, 0xee, 0xc4, 0x9b, 0xc2, 0x7c, 0xd1, 0x70, 0xf0, 0x7f,
+  0xda, 0xb5, 0xa9, 0x1d, 0x4d, 0xc9, 0x7b, 0x0f, 0x94, 0xf6, 0x8a, 0xbe,
+  0xe1, 0xe8, 0x1b, 0xaa, 0x46, 0x84, 0x65, 0xfa, 0xd4, 0xef, 0x66, 0x4b,
+  0xdd, 0xb6, 0xa1, 0x17, 0xe0, 0x33, 0xd9, 0x87, 0xa1, 0xe3, 0xd0, 0x7a,
+  0x15, 0x44, 0xee, 0xb8, 0xab, 0x15, 0x1a, 0xd3, 0x84, 0x79, 0xaf, 0x15,
+  0xdd, 0x64, 0x13, 0x17
 };
 unsigned int cert_der_len = 796;

data/cert/cert_key.h

@@ -1,103 +1,103 @@
 unsigned char cert_key_der[] = {
-  0x30, 0x82, 0x04, 0xa5, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
-  0xe0, 0x7b, 0x3a, 0x29, 0x39, 0xbf, 0x5e, 0x05, 0xd2, 0xed, 0x67, 0xb8,
-  0x2d, 0xba, 0xb2, 0x3c, 0xc9, 0xdb, 0x01, 0xc9, 0x20, 0x89, 0x80, 0x5e,
-  0x1c, 0xe1, 0x7c, 0x6e, 0x8e, 0xb5, 0x5a, 0x27, 0xf2, 0x39, 0x76, 0x1b,
-  0x4a, 0xb0, 0x4d, 0xed, 0xf0, 0xfa, 0xda, 0xc8, 0x0a, 0x0e, 0x9f, 0xff,
-  0xd9, 0x56, 0x74, 0xa1, 0x53, 0x15, 0x12, 0x5c, 0x8a, 0xb2, 0x48, 0x22,
-  0x60, 0xfb, 0x84, 0x6d, 0xf3, 0x2b, 0xcf, 0x2b, 0x2a, 0x4b, 0xa6, 0xcb,
-  0x8c, 0x87, 0x48, 0x99, 0xc1, 0x54, 0x1e, 0x6a, 0xd0, 0x2e, 0xb9, 0xfb,
-  0x5b, 0xf1, 0xd8, 0x4b, 0x4f, 0x17, 0xda, 0xd3, 0x08, 0x84, 0x7c, 0xa3,
-  0xe4, 0x78, 0xa5, 0x58, 0xe0, 0x71, 0xd7, 0x4b, 0x5a, 0x9a, 0x8e, 0x42,
-  0x15, 0x81, 0xf3, 0x1a, 0xd7, 0x23, 0x61, 0x9b, 0xb6, 0x0a, 0xe4, 0xec,
-  0xd7, 0xb6, 0xd5, 0x0c, 0xf6, 0x06, 0xf5, 0x31, 0xbb, 0xa9, 0xa6, 0x2b,
-  0x4c, 0xbf, 0xab, 0x3b, 0x28, 0x94, 0x65, 0x0e, 0x78, 0xcf, 0xad, 0x42,
-  0x91, 0x24, 0xea, 0xa6, 0x8a, 0x9d, 0xdc, 0xac, 0x3f, 0x58, 0xb0, 0x72,
-  0xbe, 0xe5, 0xb8, 0x9c, 0x1b, 0x2a, 0xa1, 0xee, 0x82, 0x5e, 0xe1, 0xde,
-  0x0d, 0x7f, 0x1a, 0x6a, 0x91, 0x7c, 0xd1, 0x62, 0x50, 0x2d, 0xad, 0x78,
-  0x6a, 0x05, 0xae, 0xb7, 0xf2, 0xbe, 0xe5, 0xfa, 0x06, 0x0e, 0x62, 0x2e,
-  0xd9, 0xaf, 0xa4, 0xa5, 0x26, 0xb3, 0x78, 0xdf, 0x58, 0x39, 0x80, 0xa3,
-  0x77, 0x4d, 0xd7, 0x4c, 0x80, 0xe6, 0xb6, 0x67, 0x1f, 0x59, 0xee, 0xe3,
-  0xc1, 0xc1, 0x69, 0xf0, 0xfb, 0x3a, 0xd8, 0xff, 0x6c, 0xbc, 0x22, 0x80,
-  0x94, 0xc4, 0x40, 0xfa, 0x06, 0x32, 0xa8, 0xe2, 0x71, 0x4f, 0x4c, 0x72,
-  0xa6, 0x39, 0xba, 0xe5, 0xb9, 0x2a, 0xd0, 0x25, 0x95, 0x54, 0x0d, 0x51,
-  0x9a, 0xc6, 0xd6, 0x37, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
-  0x00, 0x03, 0xe9, 0x61, 0xcc, 0x12, 0x1b, 0x89, 0x91, 0xe4, 0x69, 0x0a,
-  0xa3, 0xa4, 0xf8, 0x59, 0xde, 0xc1, 0x4d, 0xb5, 0xac, 0x41, 0x8a, 0xe3,
-  0xd7, 0xbf, 0xfd, 0x15, 0xe3, 0xff, 0x4c, 0x9d, 0xb3, 0x90, 0x7e, 0xfb,
-  0xd5, 0xe1, 0xe9, 0x4c, 0x92, 0x56, 0xde, 0xa8, 0x2d, 0x50, 0x2f, 0x8d,
-  0x0e, 0x32, 0x45, 0x55, 0x66, 0xf2, 0x41, 0xad, 0xbe, 0x3b, 0x14, 0x7c,
-  0x39, 0x4d, 0x23, 0x54, 0xdd, 0x6d, 0x9d, 0x57, 0xd0, 0xd2, 0xbd, 0xda,
-  0xbc, 0x35, 0x48, 0xae, 0x35, 0x2f, 0xaf, 0x3d, 0x90, 0x72, 0xec, 0x3d,
-  0x85, 0x69, 0xc6, 0xbf, 0x14, 0x20, 0xde, 0xb3, 0x8b, 0x75, 0xdc, 0x89,
-  0x27, 0x79, 0xf5, 0xb8, 0x3b, 0xe2, 0x3d, 0x59, 0x99, 0x10, 0x8d, 0x1c,
-  0xe9, 0x7d, 0xe2, 0x73, 0xd0, 0x05, 0xeb, 0xb1, 0xe9, 0xba, 0xb4, 0x59,
-  0xe4, 0xde, 0xa5, 0x6a, 0xf4, 0xfc, 0xdc, 0x86, 0x2d, 0x3d, 0x53, 0x21,
-  0x11, 0xee, 0x62, 0xd9, 0x61, 0xf7, 0x69, 0x5b, 0x9b, 0x1f, 0xd0, 0xae,
-  0xc0, 0xb3, 0x21, 0xed, 0x0d, 0xe6, 0xb5, 0xf6, 0xd9, 0x99, 0x69, 0x73,
-  0xeb, 0xf8, 0x90, 0x7a, 0xcf, 0x65, 0xac, 0xe2, 0x0a, 0x1a, 0x23, 0x31,
-  0x0c, 0xf8, 0xf0, 0x81, 0xf1, 0x82, 0xbf, 0xbb, 0x7c, 0x99, 0xdc, 0x59,
-  0x49, 0x1b, 0x60, 0x4e, 0xa4, 0x23, 0x43, 0x1a, 0x9f, 0x96, 0xea, 0x9e,
-  0x03, 0x8c, 0x54, 0x81, 0x80, 0x3b, 0xd0, 0x03, 0x61, 0x97, 0x34, 0xea,
-  0x3b, 0xc9, 0x52, 0x83, 0xaf, 0x6d, 0xfe, 0xfd, 0x69, 0x72, 0x5f, 0x90,
-  0x6d, 0xc7, 0x5e, 0x1d, 0x79, 0xad, 0x6c, 0xbf, 0xe0, 0xa4, 0x3f, 0xcb,
-  0x9b, 0x68, 0x51, 0x44, 0x63, 0xcb, 0xc9, 0xb4, 0x60, 0xe9, 0xde, 0xae,
-  0xe9, 0xdb, 0x86, 0xdd, 0x48, 0x8e, 0x67, 0x60, 0xea, 0x4c, 0x57, 0x05,
-  0x84, 0x02, 0x5a, 0x4b, 0x41, 0x02, 0x81, 0x81, 0x00, 0xf0, 0x0f, 0x7a,
-  0xf9, 0x85, 0xad, 0xa1, 0xab, 0xdb, 0x76, 0x59, 0x80, 0xd7, 0xbb, 0xb6,
-  0x72, 0x64, 0x0b, 0xe4, 0x83, 0xe9, 0x4c, 0x3a, 0x09, 0xe0, 0x75, 0xd7,
-  0x23, 0xc1, 0xef, 0x0a, 0xf3, 0xc1, 0xe9, 0xe8, 0x54, 0x7c, 0xd4, 0x96,
-  0xf2, 0x25, 0x79, 0x0f, 0xce, 0xf0, 0x79, 0x91, 0x4c, 0x12, 0x7e, 0x2e,
-  0x42, 0x13, 0xb0, 0x24, 0x09, 0xf7, 0x8c, 0x39, 0x90, 0x75, 0x57, 0xe1,
-  0x32, 0x9b, 0xa9, 0x0c, 0xf6, 0x4b, 0x79, 0x6f, 0x47, 0xe5, 0xe2, 0x55,
-  0xc1, 0xdf, 0x3d, 0xa5, 0x11, 0x38, 0x7d, 0x95, 0x63, 0x57, 0xca, 0x7d,
-  0x27, 0x81, 0xd8, 0xe4, 0xc8, 0xfa, 0x4c, 0x94, 0x7e, 0x6b, 0xf0, 0xe3,
-  0x41, 0xb7, 0x65, 0xbe, 0x2a, 0xb9, 0x48, 0x9b, 0xa0, 0xcd, 0x50, 0x2d,
-  0x1a, 0x7a, 0x48, 0x16, 0xa8, 0x8e, 0x50, 0x06, 0x4e, 0xdb, 0xab, 0x94,
-  0xc4, 0xf3, 0x7e, 0x0f, 0x87, 0x02, 0x81, 0x81, 0x00, 0xef, 0x62, 0xef,
-  0x53, 0xf9, 0x1b, 0xf3, 0xdb, 0x57, 0x21, 0xda, 0x20, 0xd0, 0x32, 0x52,
-  0xdc, 0x4e, 0x95, 0x2b, 0xd5, 0x91, 0xa8, 0x43, 0x3c, 0x8a, 0x23, 0x8f,
-  0x03, 0x8f, 0x05, 0x2a, 0x52, 0x9b, 0x8b, 0x36, 0x77, 0x75, 0xc8, 0x58,
-  0x55, 0xb7, 0x45, 0x81, 0xdc, 0x7b, 0x85, 0xa9, 0xd1, 0xca, 0xb2, 0xd3,
-  0x9f, 0x19, 0x7d, 0xe3, 0x59, 0xb7, 0x38, 0x87, 0x0b, 0x84, 0x8f, 0xbd,
-  0x06, 0x7a, 0x17, 0x38, 0x05, 0x8a, 0x05, 0xc3, 0x4a, 0xa6, 0x3b, 0xf1,
-  0xc9, 0x08, 0xfa, 0x00, 0x7a, 0x91, 0xd8, 0x00, 0x30, 0x36, 0x85, 0x66,
-  0xac, 0x9a, 0x7e, 0xf8, 0xdf, 0x9e, 0xa6, 0x3d, 0xea, 0x55, 0x6e, 0x79,
-  0x42, 0x77, 0xe4, 0xda, 0x72, 0x01, 0xb4, 0xa9, 0x96, 0x52, 0x0a, 0x9a,
-  0x84, 0x02, 0x88, 0xff, 0x61, 0x8d, 0x80, 0xd3, 0x53, 0x87, 0x98, 0xcf,
-  0xbe, 0x72, 0xc2, 0xcf, 0xd1, 0x02, 0x81, 0x81, 0x00, 0xe5, 0x2f, 0x62,
-  0x50, 0x66, 0x77, 0x66, 0x2a, 0x14, 0xd3, 0xe0, 0x8f, 0x49, 0x67, 0x44,
-  0xbf, 0xe1, 0x14, 0x19, 0x8e, 0x76, 0x64, 0xf7, 0xe4, 0x06, 0x0f, 0x7a,
-  0xde, 0x00, 0x80, 0x9f, 0x0c, 0x28, 0xcd, 0x8f, 0xa9, 0x59, 0xa3, 0xfc,
-  0x98, 0x21, 0x7e, 0x7a, 0xc1, 0x2e, 0x84, 0x61, 0x5b, 0x27, 0x2c, 0xa0,
-  0x2d, 0x25, 0x6e, 0xbc, 0x79, 0x67, 0x84, 0xd0, 0x50, 0x42, 0x37, 0x2c,
-  0x20, 0x8c, 0xcb, 0xd0, 0x3c, 0x33, 0xc2, 0x33, 0xa3, 0x88, 0xad, 0x95,
-  0x02, 0x0a, 0x87, 0x67, 0xd8, 0x10, 0xfe, 0x94, 0x68, 0xcb, 0x9f, 0xdd,
-  0xec, 0xa1, 0xe2, 0xd8, 0x49, 0xa7, 0xed, 0x04, 0xb7, 0xcd, 0x85, 0xa4,
-  0xf1, 0x50, 0x8e, 0x2a, 0x07, 0xcf, 0xec, 0xa9, 0xe7, 0xd3, 0x1c, 0x00,
-  0x73, 0x8e, 0xda, 0xd4, 0x07, 0x08, 0x17, 0x0e, 0x6e, 0xaa, 0xfa, 0x1c,
-  0x86, 0x0b, 0x91, 0x06, 0x71, 0x02, 0x81, 0x81, 0x00, 0xe9, 0x80, 0x81,
-  0x9e, 0x51, 0x60, 0xf8, 0xae, 0xbd, 0x01, 0x22, 0x39, 0xdb, 0x9b, 0x1a,
-  0xc4, 0x16, 0x4a, 0xdf, 0x65, 0x05, 0x1d, 0x31, 0xe8, 0x7d, 0x7e, 0x4d,
-  0xe3, 0xd4, 0xbf, 0xdf, 0x16, 0x90, 0xee, 0x6c, 0x04, 0x7e, 0x79, 0x1b,
-  0xe1, 0x10, 0x51, 0xd6, 0x67, 0xf0, 0x7c, 0xe2, 0xb6, 0xe6, 0x97, 0x24,
-  0x61, 0x0e, 0x86, 0x83, 0x1b, 0x61, 0xe2, 0xdb, 0xa7, 0x5a, 0x78, 0xb2,
-  0x92, 0xfc, 0xc8, 0x65, 0x36, 0xd1, 0xf8, 0xe9, 0x13, 0x89, 0xae, 0xf3,
-  0x1b, 0x7b, 0x8c, 0x10, 0xa7, 0x7e, 0x57, 0x49, 0x67, 0xbd, 0xe6, 0xc5,
-  0xce, 0x1b, 0x2d, 0x3b, 0x29, 0x35, 0x21, 0x47, 0x47, 0xaa, 0x69, 0x86,
-  0x12, 0x55, 0xcc, 0x7f, 0x5f, 0xb1, 0x56, 0x3e, 0x0d, 0x88, 0x9d, 0x1b,
-  0x37, 0x25, 0x19, 0xe8, 0xb1, 0x89, 0x4b, 0x5d, 0xd7, 0x1e, 0x6e, 0xea,
-  0x45, 0x04, 0xc0, 0x0d, 0xe1, 0x02, 0x81, 0x81, 0x00, 0xb6, 0x69, 0x8f,
-  0x9f, 0xf7, 0x1e, 0x3c, 0xbe, 0x7e, 0x02, 0x0d, 0xd4, 0x60, 0x0f, 0x9b,
-  0x84, 0xd2, 0x20, 0x73, 0x89, 0x9a, 0xf0, 0x31, 0x0e, 0xa2, 0xe9, 0x83,
-  0xa7, 0x63, 0x41, 0xd4, 0x49, 0x6e, 0x3e, 0x14, 0xb2, 0xd6, 0xe0, 0x6d,
-  0xd4, 0xaa, 0x0d, 0xed, 0x4b, 0xc2, 0xa3, 0x92, 0xde, 0x3b, 0x4e, 0xbc,
-  0x39, 0x78, 0xd6, 0x6f, 0xd6, 0x5d, 0x6e, 0x14, 0xbe, 0x01, 0x7f, 0x8d,
-  0x31, 0xf5, 0xd0, 0x0d, 0x0f, 0x4f, 0xb6, 0xf4, 0x52, 0x10, 0xe5, 0x61,
-  0xc4, 0xc9, 0xc3, 0x80, 0x18, 0x4f, 0x25, 0x84, 0xc5, 0x85, 0x69, 0xd1,
-  0x6b, 0x46, 0x37, 0x61, 0x01, 0xf0, 0xfd, 0x26, 0x07, 0x6a, 0x22, 0xc9,
-  0x90, 0x75, 0x4f, 0x72, 0x10, 0xc2, 0x8a, 0xae, 0xe1, 0x9b, 0xfb, 0x2d,
-  0xce, 0xc8, 0x22, 0x03, 0x86, 0x7d, 0x42, 0xc5, 0xf8, 0x67, 0x25, 0xb2,
-  0x2a, 0x18, 0x17, 0x48, 0x9b
+  0x30, 0x82, 0x04, 0xa3, 0x02, 0x01, 0x00, 0x02, 0x82, 0x01, 0x01, 0x00,
+  0xbf, 0xcd, 0xca, 0x15, 0x60, 0x85, 0x47, 0xb7, 0x3d, 0x38, 0x00, 0xe2,
+  0x1f, 0xcc, 0xc9, 0x15, 0x7f, 0xb1, 0x58, 0xc8, 0x33, 0x8e, 0x74, 0x52,
+  0x1e, 0xcc, 0x5f, 0xe0, 0xa4, 0x11, 0x92, 0x47, 0x66, 0xb6, 0x33, 0x0c,
+  0xd0, 0xde, 0x39, 0xf6, 0xd0, 0x7b, 0x78, 0x6c, 0x13, 0xf8, 0xfd, 0x2b,
+  0xf0, 0x67, 0xbf, 0xd4, 0x54, 0xb9, 0x10, 0xf3, 0x1c, 0xa5, 0xe5, 0x10,
+  0x4f, 0x14, 0x63, 0x5e, 0x62, 0x19, 0x4b, 0xf8, 0x6e, 0x38, 0xfd, 0x31,
+  0xb9, 0x64, 0xb3, 0xb1, 0xe1, 0xe5, 0x80, 0x59, 0xef, 0x85, 0x21, 0x02,
+  0x73, 0x95, 0x3a, 0xe0, 0xc5, 0x4c, 0xbb, 0xc8, 0x72, 0x96, 0x0d, 0x17,
+  0xae, 0x89, 0xa8, 0x6a, 0xf9, 0xb0, 0xf0, 0xaf, 0xf7, 0xda, 0xbe, 0x13,
+  0x43, 0xb2, 0xce, 0xa5, 0x52, 0x3d, 0x16, 0xf1, 0x1a, 0x19, 0xad, 0xb1,
+  0x9f, 0xfb, 0x06, 0x00, 0x91, 0xff, 0xf5, 0x06, 0x38, 0x63, 0x6f, 0x09,
+  0x52, 0x97, 0x98, 0x86, 0xfe, 0xab, 0xb8, 0xe4, 0x27, 0x03, 0xdb, 0x8b,
+  0x5a, 0x2d, 0xcd, 0x65, 0x5f, 0x48, 0x09, 0xb8, 0xa7, 0xba, 0xf3, 0xf3,
+  0xa2, 0xe9, 0xbc, 0x35, 0x6f, 0x34, 0xf0, 0x38, 0xc8, 0x14, 0x28, 0x8c,
+  0x98, 0x28, 0x9f, 0xb4, 0x50, 0xfd, 0xb4, 0x9c, 0xf0, 0xb6, 0x5f, 0x4e,
+  0x4c, 0xdb, 0x84, 0x98, 0xce, 0xb1, 0x54, 0xb3, 0x57, 0xbd, 0x12, 0x0c,
+  0x09, 0x21, 0x7f, 0x44, 0x37, 0xbf, 0xb3, 0x44, 0xc2, 0x30, 0x61, 0x99,
+  0x2f, 0x67, 0x1a, 0x19, 0xc0, 0x67, 0xa5, 0x82, 0xe7, 0xd6, 0x08, 0x6f,
+  0x26, 0x64, 0x8f, 0x56, 0x66, 0xd5, 0x8a, 0x08, 0x54, 0x6c, 0xad, 0xf8,
+  0x7c, 0x1a, 0x18, 0xdb, 0xc0, 0xf1, 0x5d, 0x4f, 0x68, 0xe5, 0x93, 0x52,
+  0x4a, 0x58, 0x67, 0x7d, 0x7c, 0x2c, 0xb7, 0x59, 0x16, 0x6e, 0x67, 0xab,
+  0x10, 0xe2, 0xab, 0x11, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x82, 0x01,
+  0x00, 0x15, 0x12, 0x66, 0xc1, 0x32, 0x79, 0x72, 0x07, 0x8f, 0x92, 0x37,
+  0x86, 0xa0, 0x37, 0xbf, 0x5f, 0xbd, 0x47, 0x9e, 0x99, 0x60, 0x10, 0xa6,
+  0x76, 0xdf, 0x2b, 0x54, 0xdd, 0x39, 0x29, 0x35, 0x08, 0xe3, 0x1f, 0xe1,
+  0x3b, 0xe7, 0x36, 0x82, 0xe7, 0xba, 0xbf, 0xd5, 0xdb, 0x09, 0xd6, 0xb0,
+  0xf9, 0xc2, 0xcf, 0xa3, 0x23, 0x90, 0xab, 0x44, 0x51, 0x71, 0x34, 0x48,
+  0x96, 0x22, 0x19, 0xfb, 0x50, 0xc3, 0x36, 0x44, 0x42, 0x66, 0xd9, 0x9b,
+  0xf7, 0x7a, 0x86, 0xb5, 0xb7, 0x35, 0x3a, 0x21, 0x7f, 0xbf, 0xf0, 0xc0,
+  0x4f, 0xa4, 0xa3, 0x20, 0x74, 0xd1, 0x38, 0x3c, 0xe9, 0x28, 0xad, 0x93,
+  0x82, 0xa6, 0x8a, 0x39, 0x16, 0x87, 0x98, 0x08, 0xd9, 0x4c, 0x41, 0x9b,
+  0xe0, 0x41, 0xef, 0xc3, 0x04, 0x26, 0xa4, 0xcf, 0x80, 0x6d, 0x7d, 0xa4,
+  0xb7, 0x7e, 0xfb, 0xf5, 0x0c, 0xda, 0xfd, 0x63, 0xcd, 0xba, 0x67, 0x0e,
+  0xaa, 0xf7, 0x80, 0x6d, 0x99, 0x28, 0x7d, 0xca, 0x64, 0x34, 0x87, 0xbc,
+  0x8f, 0x90, 0xed, 0x26, 0x38, 0x20, 0x29, 0x65, 0xfa, 0xa7, 0x36, 0x18,
+  0xf8, 0xf3, 0x32, 0xd9, 0xcc, 0x04, 0x71, 0xc1, 0x60, 0xdf, 0xdc, 0xb7,
+  0xf7, 0x40, 0xed, 0xac, 0x4b, 0x3a, 0x3a, 0x06, 0xb0, 0xde, 0xbd, 0x77,
+  0xb5, 0xde, 0x3d, 0x7c, 0x6b, 0x04, 0x81, 0x3b, 0xe1, 0x62, 0xeb, 0x64,
+  0x4b, 0x90, 0xe7, 0x79, 0x4c, 0xb2, 0x3f, 0x55, 0x31, 0x3d, 0xff, 0xf4,
+  0x68, 0x44, 0xf0, 0xff, 0xe1, 0x46, 0x31, 0x8e, 0x08, 0x6f, 0x3c, 0x2b,
+  0x05, 0xb4, 0x6d, 0x06, 0x44, 0x23, 0x32, 0x08, 0x43, 0xb8, 0x57, 0x49,
+  0x55, 0xfd, 0x34, 0xe2, 0x5a, 0x53, 0x54, 0x5d, 0xe4, 0x5b, 0xae, 0x48,
+  0xfd, 0xeb, 0x6a, 0x31, 0xdb, 0xe0, 0x7b, 0x81, 0x7a, 0xd7, 0x06, 0x16,
+  0x33, 0x81, 0xda, 0x46, 0x81, 0x02, 0x81, 0x81, 0x00, 0xe7, 0xd6, 0xb7,
+  0x46, 0x5f, 0x23, 0x66, 0x18, 0xc7, 0xd9, 0x4b, 0x39, 0xe8, 0x0b, 0x61,
+  0xdb, 0x4c, 0xa5, 0x7f, 0x19, 0xe9, 0xd1, 0xbd, 0x8b, 0x14, 0xde, 0x42,
+  0xee, 0x66, 0x08, 0x4e, 0x25, 0x5d, 0x7c, 0x9c, 0x0c, 0x3f, 0x00, 0xcf,
+  0x98, 0x36, 0x70, 0x82, 0x45, 0x8d, 0x6e, 0x7a, 0xdd, 0xf4, 0x40, 0xa0,
+  0x7f, 0x80, 0x5e, 0xc7, 0x07, 0x87, 0x17, 0xa5, 0xa9, 0xc1, 0x54, 0x7a,
+  0xfb, 0xfc, 0xe2, 0x53, 0xb6, 0x8d, 0xd1, 0xe9, 0x4b, 0x2e, 0xc8, 0x14,
+  0xe0, 0xb8, 0xa9, 0x7c, 0x2c, 0x70, 0xf9, 0x18, 0x6a, 0xaf, 0x9e, 0x76,
+  0xd5, 0x3d, 0x55, 0x11, 0x5f, 0xb5, 0x13, 0x6f, 0x66, 0x20, 0x9a, 0x76,
+  0x58, 0x6a, 0x14, 0xb4, 0x00, 0x2f, 0xe3, 0x41, 0x9b, 0x8b, 0xf9, 0xdf,
+  0x64, 0xec, 0x53, 0xc5, 0x95, 0xc3, 0x82, 0x9d, 0x11, 0x82, 0xb5, 0xc9,
+  0xfd, 0x7c, 0x62, 0xfa, 0x5b, 0x02, 0x81, 0x81, 0x00, 0xd3, 0xca, 0xf9,
+  0x1c, 0x9d, 0xb7, 0x25, 0x01, 0x57, 0x00, 0x67, 0xe7, 0xb9, 0x6d, 0x0f,
+  0x0b, 0xbb, 0xba, 0xae, 0xd1, 0x7d, 0x5f, 0x52, 0xdc, 0x52, 0x8d, 0x0a,
+  0x5e, 0xb0, 0x83, 0xab, 0x8b, 0x03, 0x02, 0x13, 0xcb, 0xc7, 0xbd, 0x2a,
+  0xbb, 0xbe, 0xd7, 0x80, 0xab, 0xf8, 0xd9, 0x26, 0x04, 0x32, 0x90, 0x40,
+  0xf6, 0xfa, 0x72, 0xb0, 0xbf, 0xe5, 0x50, 0xda, 0x2e, 0x0a, 0x01, 0xee,
+  0xfe, 0x3a, 0x37, 0xfb, 0x0c, 0xaf, 0x30, 0xa7, 0x40, 0x92, 0xcb, 0xc5,
+  0x08, 0x58, 0x42, 0x90, 0xc2, 0xff, 0x1e, 0x30, 0x02, 0xb2, 0xee, 0xf4,
+  0x85, 0x73, 0x34, 0x16, 0xf4, 0x15, 0x18, 0x2a, 0xed, 0x46, 0x34, 0x01,
+  0xad, 0x7d, 0xb9, 0x2d, 0xb4, 0x1c, 0x7a, 0xb8, 0xf9, 0x7e, 0xf5, 0xc6,
+  0xd5, 0xe2, 0xd9, 0x7e, 0x6b, 0x0d, 0x2a, 0x9a, 0x0d, 0xd1, 0x20, 0xd2,
+  0x3e, 0x5c, 0x41, 0xf4, 0x03, 0x02, 0x81, 0x81, 0x00, 0x99, 0x35, 0xce,
+  0x5c, 0x95, 0x16, 0xe1, 0xab, 0xd2, 0xb6, 0x88, 0xfe, 0x35, 0x99, 0x00,
+  0x0c, 0x5a, 0xf4, 0xab, 0xb0, 0x46, 0x53, 0x33, 0x7d, 0xac, 0x46, 0xcd,
+  0xd8, 0x9a, 0x59, 0x36, 0xbb, 0x7e, 0xb2, 0x90, 0xb5, 0x8f, 0x15, 0x4c,
+  0x1b, 0x7d, 0x2e, 0x91, 0x08, 0xc1, 0xd4, 0x97, 0x22, 0x02, 0xfe, 0x8a,
+  0x92, 0x78, 0x15, 0x2a, 0x56, 0x91, 0x32, 0x51, 0x6a, 0x83, 0xb6, 0xfe,
+  0xa7, 0x74, 0x91, 0x65, 0x5d, 0x29, 0x0f, 0xe5, 0xaa, 0xa7, 0xb9, 0xd6,
+  0x02, 0x44, 0x46, 0xcd, 0x26, 0xd9, 0x69, 0xe4, 0x76, 0xec, 0xa4, 0x3e,
+  0x47, 0xe1, 0x86, 0x4c, 0x3b, 0x01, 0x81, 0x5c, 0x87, 0x13, 0x58, 0xc0,
+  0x88, 0xe1, 0x61, 0xd9, 0x2a, 0x9e, 0x7b, 0x02, 0xaa, 0x76, 0xb0, 0xa4,
+  0xaf, 0x1f, 0x76, 0xa5, 0x06, 0xb9, 0xf3, 0xa1, 0x35, 0x27, 0x3a, 0x57,
+  0xc8, 0x4a, 0xe1, 0x66, 0x2d, 0x02, 0x81, 0x80, 0x28, 0x0c, 0xc4, 0xe8,
+  0xc5, 0x66, 0x41, 0xa8, 0x2c, 0x34, 0x96, 0x71, 0x7a, 0x5e, 0x06, 0x2f,
+  0x58, 0xd3, 0xa7, 0x85, 0x53, 0xe8, 0xf7, 0xb9, 0x54, 0x1e, 0xf9, 0xac,
+  0x08, 0x43, 0x0d, 0xe8, 0x5e, 0xac, 0x40, 0xe4, 0x13, 0x24, 0x51, 0x75,
+  0x69, 0x54, 0x45, 0x2f, 0xc0, 0x02, 0x08, 0x2f, 0x59, 0x04, 0x70, 0x54,
+  0x83, 0xed, 0xb6, 0x40, 0xc3, 0x73, 0x73, 0x9e, 0xab, 0x23, 0xcc, 0x76,
+  0xe4, 0xb9, 0x7b, 0x4e, 0xdd, 0xbe, 0x1c, 0x92, 0x98, 0x6f, 0xd2, 0x15,
+  0x8e, 0xe3, 0x1f, 0x8e, 0xd0, 0x41, 0x7c, 0x20, 0xb6, 0x87, 0x7b, 0x53,
+  0xd5, 0x02, 0x2f, 0xa8, 0xfe, 0x68, 0x30, 0x8d, 0xe7, 0xed, 0xa3, 0xb7,
+  0x94, 0x03, 0xb5, 0x81, 0xce, 0xb4, 0xe2, 0x4f, 0xc3, 0xd3, 0x64, 0x43,
+  0x43, 0xff, 0x8e, 0xe9, 0x5d, 0x77, 0x05, 0xe4, 0xc0, 0xfc, 0x2c, 0xe5,
+  0xbf, 0xfa, 0x74, 0xd3, 0x02, 0x81, 0x80, 0x7b, 0xb4, 0xa2, 0x42, 0x72,
+  0xec, 0x25, 0x6a, 0x80, 0xdc, 0xbd, 0x45, 0x57, 0x6c, 0x28, 0xb9, 0x7b,
+  0x22, 0x70, 0x17, 0x04, 0x2d, 0x50, 0xf4, 0x74, 0x52, 0xd7, 0xc6, 0x90,
+  0x8a, 0x04, 0x5b, 0x0a, 0xf0, 0x21, 0x8d, 0x14, 0xe6, 0x06, 0x65, 0x1d,
+  0x65, 0xab, 0xee, 0xd2, 0x5a, 0x85, 0x2b, 0xde, 0xc7, 0x4a, 0x79, 0x77,
+  0x18, 0x1b, 0xd6, 0xe7, 0x64, 0xdb, 0xea, 0xfc, 0xc1, 0x34, 0xcc, 0xdc,
+  0xfa, 0xf1, 0x79, 0x95, 0xc3, 0x53, 0x40, 0x1f, 0xfe, 0x48, 0xf8, 0x13,
+  0x81, 0x41, 0xf2, 0x77, 0xcb, 0x0c, 0x88, 0xb4, 0xc1, 0xa8, 0xcf, 0x59,
+  0x1b, 0xba, 0xf3, 0x1a, 0x1d, 0xa2, 0xfc, 0x02, 0x00, 0xa2, 0xf7, 0x2a,
+  0x90, 0x3a, 0x02, 0xf0, 0x23, 0x13, 0xb8, 0xe7, 0xde, 0x58, 0x5d, 0xe1,
+  0x74, 0xbf, 0xdc, 0x62, 0xcf, 0xf4, 0x18, 0x78, 0x15, 0xbd, 0xd5, 0x4d,
+  0x6e, 0xfd, 0xbb
 };
-unsigned int cert_key_der_len = 1193;
+unsigned int cert_key_der_len = 1191;

data/example/bug5.rb

@@ -14,7 +14,7 @@ Daemonite.new do
     t.add_object :M, mt, OPCUA::MANDATORY
   }
 
-  tools = server.objects.instantiate(:KalimatC34, tt)
+  tools = server.objects.manifest(:KalimatC34, tt)
 
   run do
     sleep server.run

data/example/client_get_float.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby
+require_relative '../lib/opcua/client'
+
+client = OPCUA::Client.new("opc.tcp://128.130.57.76:4840")
+client.subscription_interval = 100 # default 500
+
+if (node = client.get 1, 'DISPLAY_VOLTAGE')  # get node from nodeid
+  p node
+  p node.value
+else
+  p 'invalid nodeid'
+end

data/example/client_method.rb

@@ -13,6 +13,9 @@ client.default_ns = 2
 # p node.call 'abcde', Time.now
 # client.disconnect
 
-node = client.get 0, 11492
-p node
-p node.call 2
+# node = client.get 1, 62541
+# p node.to_s
+# p node.call 'a'
+
+node = client.get '/KalimatC34/Tools/Tool3/testRetMethod'
+p node.call 'abcde'

data/example/server.rb

@@ -27,6 +27,14 @@ Daemonite.new do
         p test2
         puts '-' * 10
       end
+      t.add_method :testRetMethod, test1: OPCUA::TYPES::STRING, return: OPCUA::TYPES::STRING do |node, test1|
+        ns, nid = node.id
+        puts '-' * 10
+        p nid
+        p test1
+        puts '-' * 10
+        "hello world"
+      end
       t.add_object(:Measurements, opts['server'].types.folder).tap{ |u|
         u.add_object :M, mt, OPCUA::OPTIONAL
       }

data/example/server_xml.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/ruby
+require_relative '../lib/opcua/server'
+
+Daemonite.new do
+  on startup do |opts|
+    srv = opts['server'] = OPCUA::Server.new
+    srv.import_UA # FIX
+    srv.import_nodeset File::read('nodeset1.xml')
+    srv.import_nodeset File::read('nodeset1.xml')
+    srv.import_nodeset File::read('nodeset1.xml')
+    DI  = srv.imports['http://xxxxx/DI']
+    AID = srv.imports['http://xxxxx/AutoID']
+
+    srv.objects
+
+    # ab 106 im nodesets.rb
+    x = srv.data_types.add(qualifiedname,referencetype=UA::HasSubtype,nodeid=rand())
+    x.displayname['en-US'] = 'rrr'
+    x.displayname['de'] = 'rrr'
+    x.displayname.delete('de')
+
+    srv.data_types.bla.blurg.add(wieheissts')
+    srv.data_types.bla.blurg.push(wieheissts')
+    srv.data_types.bla.blurg.<<('wieheissts')
+    x = srv.data_types.bla.find name: 'bla', type: SUBXXXX
+    [x] = srv.data_types.bla.find_all name: 'bla', type: SUBXXXX
+    [x] = srv.data_types.bla.select name: 'bla', type: SUBXXXX
+    srv.data_types.bla.parent
+
+    # srv.event_types
+    # srv.interfaces_types
+
+    srv.reference_types.add(qualifiedname,symmetric,referencetype,nodeid)
+    srv.reference_types.add_symmetric(qualifiedname,referencetype,nodeid)
+
+    srv.variable_types
+    srv.object_types
+
+    p server.add_namespace "https://centurio.work/kelch"
+    p server.active_namespace
+    server.active_namespace = 0
+    p server.active_namespace
+    p server.namespaces
+
+
+    tools = opts['server'].objects.manifest(:KalimatC34, pt).find(:Tools)
+
+    t1 = tools.manifest(:Tool1,tt)
+    t2 = tools.manifest(:Tool2,tt)
+    t3 = tools.manifest(:Tool3,tt)
+
+    opts[:tn] = t1.find(:ToolNumber)
+    opts[:tn].description = 'test test'
+    opts[:tn].value = [0,1]
+    p opts[:tn].description
+    p opts[:tn].to_s
+    p opts[:tn].name
+
+    measurments_t1 = t1.find(:Measurements)
+    measurments_t1.manifest(:M1,mt)
+    m2 = measurments_t1.manifest(:M2,mt)
+  rescue => e
+    puts e.message
+  end
+
+
+  counter = 0
+  run do |opts|
+    GC.start
+    sleep opts['server'].run
+    # if counter % 100 == 0
+    #   opts[:tn].value = [counter, counter]
+    #   # opts[:tn].value = 1
+    #   p opts[:tn].value
+    # end
+    # counter += 1
+  rescue => e
+    puts e.message
+  end
+
+  on exit do
+    # we could disconnect here, but OPCUA::Server does not have an explicit disconnect
+    puts 'bye.'
+  end
+end.loop!

data/ext/opcua/client/client.c

@@ -320,7 +320,7 @@ static VALUE client_init(VALUE self,VALUE url,VALUE user,VALUE pass) { //{{{
     }
     char *pstr = (char *)StringValuePtr(vpstr);
 
-    retval = UA_Client_connect_username(pss->master, nstr, ustr, pstr);
+    retval = UA_Client_connectUsername(pss->master, nstr, ustr, pstr);
   }
   if (retval != UA_STATUSCODE_GOOD) {
     pss->started = false;
@@ -502,7 +502,11 @@ static VALUE node_call(int argc, VALUE* argv, VALUE self) { //{{{
   Data_Get_Struct(self, node_struct, ns);
 
   UA_NodeId parent;
-  client_node_get_reference_by_type(ns->master->master, ns->id, UA_NODEID_NUMERIC(0,UA_NS0ID_HASCOMPONENT), &parent, true);
+  if (!client_node_get_reference_by_type(ns->master->master, ns->id, UA_NODEID_NUMERIC(0,UA_NS0ID_HASCOMPONENT), &parent, true)) {
+    if (!client_node_get_reference_by_type(ns->master->master, ns->id, UA_NODEID_NUMERIC(0,UA_NS0ID_HASORDEREDCOMPONENT), &parent, true)) {
+      rb_raise(rb_eRuntimeError, "Cant find parent node, neither hascomponent nor hasorderedcomponent is there!");
+    }
+  }
 
   UA_NodeId ia;
   client_node_get_reference_by_name(ns->master->master, ns->id, UA_QUALIFIEDNAME(0,"InputArguments"), &ia, false);
@@ -525,21 +529,27 @@ static VALUE node_call(int argc, VALUE* argv, VALUE self) { //{{{
     value_to_variant(RARRAY_AREF(splat, i),&inputArguments[i],proposal[i]);
   }
 
+  size_t outputSize;
+  UA_Variant *output;
+
   retval = UA_Client_call(
     ns->master->master,
     parent,
     ns->id,
     RARRAY_LEN(splat),
     (UA_Variant *)&inputArguments,
-    0,
-    NULL
+    &outputSize,
+    &output
   );
 
-
-  if(retval == UA_STATUSCODE_GOOD) {
-    return Qtrue;
+  if (retval == UA_STATUSCODE_GOOD && outputSize > 0) {
+    VALUE ret = rb_ary_new2(outputSize);
+    for (int i=0; i<outputSize; i++) {
+      rb_ary_store(ret,i,rb_ary_entry(extract_value(output[i]),0));
+    }
+    return rb_ary_entry(ret,0);
   } else {
-    return Qfalse;
+    return Qnil;
   }
 } //}}}
 
@@ -621,7 +631,7 @@ void Init_client(void) {
   cMethodNode = rb_define_class_under(cClient, "cMethodNode", cNode);
   cVarNode    = rb_define_class_under(cClient, "cVarNode", cNode);
 
-  Init_types();
+  Init_types(mOPCUA);
 
   rb_define_alloc_func(cClient, client_alloc);
   rb_define_method(cClient, "initialize", client_init, 3);

data/ext/opcua/helpers/finders.c

@@ -46,6 +46,34 @@ bool server_node_get_reference(UA_Server *server, UA_NodeId parent, UA_NodeId *r
   return false;
 }
 
+bool server_node_get_reference_by_name(UA_Server *server, UA_NodeId parent, UA_QualifiedName name, UA_NodeId *result, bool inverse) {
+	UA_BrowseDescription bDes;
+  UA_BrowseDescription_init(&bDes);
+  bDes.nodeId = parent;
+  bDes.resultMask = UA_BROWSERESULTMASK_ALL;
+  bDes.browseDirection = inverse ? 1 : 0;
+  UA_BrowseResult bRes = UA_Server_browse(server, 999, &bDes);
+
+  for (int i=0; i < bRes.referencesSize; i++) {
+    UA_ReferenceDescription *ref = &(bRes.references[i]);
+
+    UA_QualifiedName qn;  UA_QualifiedName_init(&qn);
+    UA_Server_readBrowseName(server, ref->nodeId.nodeId, &qn);
+
+    if (UA_QualifiedName_equal(&qn,&name)) {
+      UA_NodeId_copy(&ref->nodeId.nodeId,result);
+
+      UA_BrowseResult_deleteMembers(&bRes);
+      UA_BrowseResult_clear(&bRes);
+      return true;
+    }
+  }
+
+  UA_BrowseResult_deleteMembers(&bRes);
+  UA_BrowseResult_clear(&bRes);
+  return false;
+}
+
 bool client_node_get_reference_by_name(UA_Client *client, UA_NodeId parent, UA_QualifiedName name, UA_NodeId *result, bool inverse) {
   UA_BrowseRequest bReq;
   UA_BrowseRequest_init(&bReq);

data/ext/opcua/helpers/finders.h

@@ -6,6 +6,7 @@
 
 RUBY_EXTERN UA_BrowsePathResult node_browse_path(UA_Server *server, UA_NodeId relative, UA_NodeId ref, UA_QualifiedName mqn, bool inverse);
 RUBY_EXTERN bool server_node_get_reference(UA_Server *server, UA_NodeId parent, UA_NodeId *result, bool inverse);
+RUBY_EXTERN bool server_node_get_reference_by_name(UA_Server *server, UA_NodeId parent, UA_QualifiedName name, UA_NodeId *result, bool inverse);
 RUBY_EXTERN bool client_node_get_reference_by_name(UA_Client *client, UA_NodeId parent, UA_QualifiedName name, UA_NodeId *result, bool inverse);
 RUBY_EXTERN bool client_node_get_reference_by_type(UA_Client *client, UA_NodeId parent, UA_NodeId type, UA_NodeId *result, bool inverse);
 RUBY_EXTERN bool client_node_list_references(UA_Client *client, UA_NodeId parent, bool inverse);

data/ext/opcua/helpers/values.c

@@ -1,6 +1,6 @@
 #include "values.h"
 
-VALUE mOPCUA;
+VALUE mTYPES;
 
 /* -- */
 static void variant_set_one_dimension(UA_Variant *variant,UA_UInt32 len) { //{{{
@@ -154,8 +154,16 @@ bool value_to_variant(VALUE value, UA_Variant *variant, UA_UInt32 proposal) { //
       case T_SYMBOL:
         {
           VALUE str = rb_obj_as_string(value);
-          UA_String tmp = UA_STRING(StringValuePtr(str));
-          UA_Variant_setScalarCopy(variant, &tmp, &UA_TYPES[UA_TYPES_STRING]);
+          if (proposal == UA_TYPES_STRING) {
+            UA_String tmp = UA_STRING(StringValuePtr(str));
+            UA_Variant_setScalarCopy(variant, &tmp, &UA_TYPES[UA_TYPES_STRING]);
+          } else if (proposal == UA_TYPES_NODEID) {
+            UA_NodeId tmp = UA_NODEID(StringValuePtr(str));
+            UA_Variant_setScalarCopy(variant, &tmp, &UA_TYPES[UA_TYPES_NODEID]);
+          } else if (proposal == UA_TYPES_BYTESTRING) {
+            UA_ByteString tmp = UA_BYTESTRING(StringValuePtr(str));
+            UA_Variant_setScalarCopy(variant, &tmp, &UA_TYPES[UA_TYPES_BYTESTRING]);
+          }
           done = true;
           break;
         }
@@ -171,10 +179,11 @@ bool value_to_variant(VALUE value, UA_Variant *variant, UA_UInt32 proposal) { //
   return done;
 } //}}}
 
-void Init_types() {/*{{{*/
+void Init_types(VALUE mOPCUA) {/*{{{*/
   mTYPES = rb_define_module_under(mOPCUA,"TYPES");
   rb_define_const(mTYPES, "DATETIME",            INT2NUM(UA_TYPES_DATETIME           ));
   rb_define_const(mTYPES, "BOOLEAN",             INT2NUM(UA_TYPES_BOOLEAN            ));
+  rb_define_const(mTYPES, "FLOAT",               INT2NUM(UA_TYPES_FLOAT              ));
   rb_define_const(mTYPES, "DOUBLE",              INT2NUM(UA_TYPES_DOUBLE             ));
   rb_define_const(mTYPES, "INT32",               INT2NUM(UA_TYPES_INT32              ));
   rb_define_const(mTYPES, "INT16",               INT2NUM(UA_TYPES_INT16              ));
@@ -189,6 +198,9 @@ static VALUE UA_TYPES_DATETIME_to_value(UA_DateTime data) { //{{{
 static VALUE UA_TYPES_BOOLEAN_to_value(UA_Boolean data) { //{{{
   return data ? Qtrue : Qfalse;
 } //}}}
+static VALUE UA_TYPES_FLOAT_to_value(UA_Float data) { //{{{
+  return DBL2NUM((double)data);
+} //}}}
 static VALUE UA_TYPES_DOUBLE_to_value(UA_Double data) { //{{{
   return DBL2NUM(data);
 } //}}}
@@ -213,6 +225,9 @@ static VALUE UA_TYPES_UINT16_to_value(UA_UInt16 data) { //{{{
 static VALUE UA_TYPES_STRING_to_value(UA_String data) { //{{{
   return rb_str_export_locale(rb_str_new((char *)(data.data),data.length));
 } //}}}
+static VALUE UA_TYPES_BYTESTRING_to_value(UA_ByteString data) { //{{{
+  return rb_str_export_locale(rb_str_new((char *)(data.data),data.length));
+} //}}}
 
 VALUE extract_value(UA_Variant value) { //{{{
   VALUE ret = rb_ary_new2(2);
@@ -228,6 +243,9 @@ VALUE extract_value(UA_Variant value) { //{{{
     } else if (UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_BOOLEAN])) {
       rb_ary_store(ret,0,UA_TYPES_BOOLEAN_to_value(*(UA_Boolean *)value.data));
       rb_ary_store(ret,1,ID2SYM(rb_intern("VariantType.Boolean")));
+    } else if (UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_FLOAT])) {
+      rb_ary_store(ret,0,UA_TYPES_FLOAT_to_value(*(UA_Float *)value.data));
+      rb_ary_store(ret,1,ID2SYM(rb_intern("VariantType.Float")));
     } else if (UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_DOUBLE])) {
       rb_ary_store(ret,0,UA_TYPES_DOUBLE_to_value(*(UA_Double *)value.data));
       rb_ary_store(ret,1,ID2SYM(rb_intern("VariantType.Double")));
@@ -252,6 +270,11 @@ VALUE extract_value(UA_Variant value) { //{{{
     } else if (UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_STRING])) {
       rb_ary_store(ret,0,UA_TYPES_STRING_to_value(*(UA_String *)value.data));
       rb_ary_store(ret,1,ID2SYM(rb_intern("VariantType.String")));
+    } else if (UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_BYTESTRING])) {
+      rb_ary_store(ret,0,UA_TYPES_BYTESTRING_to_value(*(UA_ByteString *)value.data));
+      rb_ary_store(ret,1,ID2SYM(rb_intern("VariantType.String")));
+    } else {
+      //printf("Unknown Datatype\n");
     }
   } else if (value.arrayDimensionsSize == 1 || (value.arrayDimensionsSize == 0 && value.arrayLength > 0)) {
     if (UA_Variant_hasArrayType(&value, &UA_TYPES[UA_TYPES_DATETIME])) {
@@ -268,6 +291,13 @@ VALUE extract_value(UA_Variant value) { //{{{
       for (int i=0; i < value.arrayLength; i++) {
         rb_ary_push(res,UA_TYPES_BOOLEAN_to_value(((UA_Boolean *)value.data)[i]));
       }
+    } else if (UA_Variant_hasArrayType(&value, &UA_TYPES[UA_TYPES_FLOAT])) {
+      VALUE res = rb_ary_new();
+      rb_ary_store(ret,0,res);
+      rb_ary_store(ret,1,ID2SYM(rb_intern("VariantType.Float")));
+      for (int i=0; i < value.arrayLength; i++) {
+        rb_ary_push(res,UA_TYPES_FLOAT_to_value(((UA_Float *)value.data)[i]));
+      }
     } else if (UA_Variant_hasArrayType(&value, &UA_TYPES[UA_TYPES_DOUBLE])) {
       VALUE res = rb_ary_new();
       rb_ary_store(ret,0,res);

data/ext/opcua/helpers/values.h

@@ -4,9 +4,8 @@
 #include <open62541.h>
 #include <ruby.h>
 
-VALUE mTYPES;
 RUBY_EXTERN bool value_to_variant(VALUE value, UA_Variant *variant, UA_UInt32 proposal);
-RUBY_EXTERN void Init_types();
+RUBY_EXTERN void Init_types(VALUE mOPCUA);
 RUBY_EXTERN VALUE extract_value(UA_Variant value);
 
 #endif

data/ext/opcua/server/server.c

@@ -224,11 +224,15 @@ static UA_StatusCode node_add_method_callback( //{{{
     rb_ary_push(args,rb_ary_entry(ret,0));
   }
 
-  rb_proc_call(me->method,args);
+  VALUE ret = rb_proc_call(me->method,args);
+
+  if (outputSize == 1) {
+    value_to_variant(ret,output,-1);
+  }
 
   return UA_STATUSCODE_GOOD;
 } //}}}
-static UA_NodeId node_add_method_ua(UA_NodeId n, UA_LocalizedText dn, UA_QualifiedName qn, node_struct *parent,size_t inputArgumentsSize,const UA_Argument *inputArguments, VALUE blk) { //{{{
+static UA_NodeId node_add_method_ua(UA_NodeId n, UA_LocalizedText dn, UA_QualifiedName qn, node_struct *parent,size_t inputArgumentsSize,const UA_Argument *inputArguments,size_t outputArgumentsSize,const UA_Argument *outputArguments, VALUE blk) { //{{{
   UA_MethodAttributes mnAttr = UA_MethodAttributes_default;
   mnAttr.displayName = dn;
   mnAttr.executable = true;
@@ -248,8 +252,8 @@ static UA_NodeId node_add_method_ua(UA_NodeId n, UA_LocalizedText dn, UA_Qualifi
                          &node_add_method_callback,
                          inputArgumentsSize,
                          inputArguments,
-                         0,
-                         NULL,
+                         outputArgumentsSize,
+                         outputArguments,
                          (void *)me,
                          NULL);
 
@@ -264,6 +268,8 @@ static UA_NodeId node_add_method_ua(UA_NodeId n, UA_LocalizedText dn, UA_Qualifi
 } //}}}
 static UA_NodeId node_add_method_ua_simple(char* nstr, node_struct *parent, VALUE opts, VALUE blk) { //{{{
   UA_Argument inputArguments[RHASH_SIZE(opts)];
+  UA_Argument outputArguments[1];
+  int counter = 0;
 
   VALUE ary = rb_funcall(opts, rb_intern("to_a"), 0);
   for (long i=0; i<RARRAY_LEN(ary); i++) {
@@ -272,11 +278,20 @@ static UA_NodeId node_add_method_ua_simple(char* nstr, node_struct *parent, VALU
     if (NIL_P(str) || TYPE(str) != T_STRING)
       rb_raise(rb_eTypeError, "cannot convert obj to string");
     char *nstr = (char *)StringValuePtr(str);
-    UA_Argument_init(&inputArguments[i]);
-    inputArguments[i].description = UA_LOCALIZEDTEXT("en-US", nstr);
-    inputArguments[i].name = UA_STRING(nstr);
-    inputArguments[i].dataType = UA_TYPES[NUM2INT(RARRAY_AREF(item, 1))].typeId;
-    inputArguments[i].valueRank = UA_VALUERANK_SCALAR;
+    if (rb_str_cmp(str,rb_str_new2("return"))) {
+      UA_Argument_init(&inputArguments[counter]);
+      inputArguments[counter].description = UA_LOCALIZEDTEXT("en-US", nstr);
+      inputArguments[counter].name = UA_STRING(nstr);
+      inputArguments[counter].dataType = UA_TYPES[NUM2INT(RARRAY_AREF(item, 1))].typeId;
+      inputArguments[counter].valueRank = UA_VALUERANK_SCALAR;
+      counter++;
+    } else {
+      UA_Argument_init(&outputArguments[0]);
+      outputArguments[0].description = UA_LOCALIZEDTEXT("en-US", nstr);
+      outputArguments[0].name = UA_STRING(nstr);
+      outputArguments[0].dataType = UA_TYPES[NUM2INT(RARRAY_AREF(item, 1))].typeId;
+      outputArguments[0].valueRank = UA_VALUERANK_SCALAR;
+    }
   }
   int nodeid = nodecounter++;
 
@@ -288,8 +303,10 @@ static UA_NodeId node_add_method_ua_simple(char* nstr, node_struct *parent, VALU
     UA_LOCALIZEDTEXT("en-US", nstr),
     UA_QUALIFIEDNAME(parent->master->default_ns, nstr),
     parent,
-    RHASH_SIZE(opts),
+    counter,
     inputArguments,
+    RHASH_SIZE(opts)-counter,
+    outputArguments,
     blk
   );
 } //}}}
@@ -556,16 +573,38 @@ static UA_StatusCode node_manifest_iter(UA_NodeId child_id, UA_Boolean is_invers
             UA_BrowsePathResult_clear(&property);
           }
           if(nc == UA_NODECLASS_METHOD) {
-            UA_NodeId ttt;
+            UA_NodeId ia;
+            UA_NodeId oa;
             VALUE blk = rb_hash_aref(parent->master->methods,INT2NUM(child_id.identifier.numeric));
-            if (server_node_get_reference(parent->master->master, child_id, &ttt, false)) {
+
+            bool iacheck = server_node_get_reference_by_name(parent->master->master, child_id, UA_QUALIFIEDNAME(0,"InputArguments"), &ia, false);
+            bool oacheck = server_node_get_reference_by_name(parent->master->master, child_id, UA_QUALIFIEDNAME(0,"OutputArguments"), &oa, false);
+            if (iacheck && oacheck) {
+              UA_Variant arv1; UA_Variant_init(&arv1);
+              UA_Variant arv2; UA_Variant_init(&arv2);
+              UA_Server_readValue(parent->master->master, ia, &arv1);
+              UA_Server_readValue(parent->master->master, oa, &arv2);
+
+              // todo differentiate between input and output reference
+              node_add_method_ua(UA_NODEID_STRING(parent->master->default_ns,buffer),dn,qn,newnode,arv1.arrayLength,(UA_Argument *)arv1.data,arv2.arrayLength,(UA_Argument *)arv2.data,blk);
+              UA_Variant_clear(&arv1);
+              UA_Variant_clear(&arv2);
+            } else if (iacheck) {
               UA_Variant arv; UA_Variant_init(&arv);
-              UA_Server_readValue(parent->master->master, ttt, &arv);
+              UA_Server_readValue(parent->master->master, ia, &arv);
 
-              node_add_method_ua(UA_NODEID_STRING(parent->master->default_ns,buffer),dn,qn,newnode,arv.arrayLength,(UA_Argument *)arv.data,blk);
+              // todo differentiate between input and output reference
+              node_add_method_ua(UA_NODEID_STRING(parent->master->default_ns,buffer),dn,qn,newnode,arv.arrayLength,(UA_Argument *)arv.data,0,NULL,blk);
+              UA_Variant_clear(&arv);
+            } else if (oacheck) {
+              UA_Variant arv; UA_Variant_init(&arv);
+              UA_Server_readValue(parent->master->master, oa, &arv);
+
+              // todo differentiate between input and output reference
+              node_add_method_ua(UA_NODEID_STRING(parent->master->default_ns,buffer),dn,qn,newnode,0,NULL,arv.arrayLength,(UA_Argument *)arv.data,blk);
               UA_Variant_clear(&arv);
             } else {
-              node_add_method_ua(UA_NODEID_STRING(parent->master->default_ns,buffer),dn,qn,newnode,0,NULL,blk);
+              node_add_method_ua(UA_NODEID_STRING(parent->master->default_ns,buffer),dn,qn,newnode,0,NULL,0,NULL,blk);
             }
           }
         }
@@ -861,7 +900,7 @@ static VALUE server_add_namespace(VALUE self, VALUE name) { //{{{
   char *nstr = (char *)StringValuePtr(str);
 
   pss->default_ns = UA_Server_addNamespace(pss->master, nstr);
-  return self;
+  return INT2NUM(pss->default_ns);
 } //}}}
 static VALUE server_types(VALUE self) { //{{{
   server_struct *pss;
@@ -914,6 +953,21 @@ static VALUE server_namespaces(VALUE self) { //{{{
   RB_OBJ_FREEZE(ret);
   return rb_ary_entry(ret,0);
 } //}}}
+static VALUE server_active_namespace(VALUE self) { //{{{
+  server_struct *pss;
+  Data_Get_Struct(self, server_struct, pss);
+  return UINT2NUM(pss->default_ns);
+} //}}}
+static VALUE server_active_namespace_set(VALUE self, VALUE val) { //{{{
+  server_struct *pss;
+  Data_Get_Struct(self, server_struct, pss);
+
+  if (NIL_P(val) || TYPE(val) != T_FIXNUM)
+    rb_raise(rb_eTypeError, "namespace is not an integer");
+
+  pss->default_ns = NUM2UINT(val);
+  return self;
+} //}}}
 
 void Init_server(void) {
   mOPCUA = rb_define_module("OPCUA");
@@ -924,7 +978,7 @@ void Init_server(void) {
   rb_define_const(mOPCUA, "BASEDATAVARIABLETYPE", INT2NUM(UA_NS0ID_BASEDATAVARIABLETYPE));
   rb_define_const(mOPCUA, "PROPERTYTYPE", INT2NUM(UA_NS0ID_PROPERTYTYPE));
 
-  Init_types();
+  Init_types(mOPCUA);
 
   cServer            = rb_define_class_under(mOPCUA, "Server", rb_cObject);
   cNode              = rb_define_class_under(cServer, "Node", rb_cObject);
@@ -941,6 +995,8 @@ void Init_server(void) {
   rb_define_method(cServer, "initialize", server_init, 0);
   rb_define_method(cServer, "run", server_run, 0);
   rb_define_method(cServer, "add_namespace", server_add_namespace, 1);
+  rb_define_method(cServer, "active_namespace", server_active_namespace, 0);
+  rb_define_method(cServer, "active_namespace=", server_active_namespace_set, 1);
   rb_define_method(cServer, "types", server_types, 0);
   rb_define_method(cServer, "references", server_references, 0);
   rb_define_method(cServer, "objects", server_objects, 0);
@@ -957,7 +1013,7 @@ void Init_server(void) {
   rb_define_method(cNode, "exists?", node_exists, 0);
 
   rb_define_method(cTypeTopNode, "add_object_type", node_add_object_type, 1);
-  rb_define_method(cTypeTopNode, "add_reference_type", node_add_reference_type, 1);
+  rb_define_method(cTypeTopNode, "add_reference_type", node_add_reference_type, 2);
   rb_define_method(cTypeTopNode, "folder", node_type_folder, 0);
 
   rb_define_method(cTypeSubNode, "add_object_type", node_add_object_type, 1);

data/opcua.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name             = "opcua"
-  s.version          = "0.15"
+  s.version          = "0.20"
   s.platform         = Gem::Platform::RUBY
   s.license          = "LGPL-3.0"
   s.summary          = "Preliminary release of opcua (open62541) ruby bindings. C performance, Ruby elegance, simplicity, and productivity."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opcua
 version: !ruby/object:Gem::Version
-  version: '0.15'
+  version: '0.20'
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: tools
 cert_chain: []
-date: 2019-08-29 00:00:00.000000000 Z
+date: 2020-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daemonite
@@ -74,6 +74,7 @@ files:
 - cert/cert.h
 - cert/cert_key.h
 - example/bug5.rb
+- example/client_get_float.rb
 - example/client_get_sync.rb
 - example/client_get_value.rb
 - example/client_method.rb
@@ -83,6 +84,7 @@ files:
 - example/server.rb
 - example/server_deep.rb
 - example/server_values.rb
+- example/server_xml.rb
 - example/test.rb
 - ext/opcua/client/client.c
 - ext/opcua/client/client.h
@@ -136,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Preliminary release of opcua (open62541) ruby bindings. C performance, Ruby