riddl 0.99.218 → 0.99.219

data/lib/ruby/riddl/oauth2-helper.rb

@@ -0,0 +1,135 @@
+require 'openssl'
+require 'base64'
+require 'securerandom'
+require 'json'
+
+module Riddl
+  module Utils
+    module OAuth2
+
+      module Helper
+        class Tokens #{{{
+          def initialize(tfile)
+            @tfile = tfile
+            @changed = changed
+            read
+          end
+
+          def [](name)
+            read if changed != @changed
+            @tokens[name]
+          end
+
+          def method_missing(name,*opts)
+            @tokens.send(name,*opts)
+          end
+
+          def []=(name,value)
+            @tokens[name] = value
+            write
+            nil
+          end
+
+          def changed
+            if File.exists?(@tfile)
+              File.stat(@tfile).mtime
+            else
+              @tokens = {}
+              write
+            end
+          end
+          private :changed
+
+          def write
+            EM.defer {
+              File.write(@tfile, JSON::pretty_generate(@tokens)) rescue {}
+            }
+            @changed = changed
+          end
+          private :write
+
+          def read
+            @tokens = JSON::parse(File.read(@tfile)) rescue {}
+          end
+          private :read
+
+          def delete(token)
+            deleted = @tokens.delete(token)
+            write
+            deleted
+          end
+
+          def delete_by_value(user_id)
+            deleted = @tokens.delete_if { |_, v| v == user_id }
+            write
+            deleted
+          end
+        end #}}}
+
+        def self::header #{{{
+          {
+            :alg => 'HS256',
+            :typ => 'JWT'
+          }.to_json
+        end #}}}
+
+        def self::nonce
+          SecureRandom::hex(32)
+        end
+
+        def self::sign(secret, what) #{{{
+          Base64::urlsafe_encode64 OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), secret, what)
+        end #}}}
+
+        def self::generate_access_token(client_id, secret, dur=3600)# {{{
+          h = Base64::urlsafe_encode64 header
+          p = Base64::urlsafe_encode64( {
+            :iss => client_id,
+            :sub => nonce,
+            :aud => client_id,
+            :exp => Time.now.to_i + dur
+          }.to_json)
+          s = sign(secret, "#{h}.#{p}")
+          "#{h}.#{p}.#{s}"
+        end# }}}
+        def self::generate_refresh_token(client_id, secret, dur=7776000) # {{{
+          token = Base64::urlsafe_encode64({
+            :iss => client_id,
+            :sub => nonce,
+            :exp => Time.now.to_i + dur
+          }.to_json)
+          "#{token}.#{sign(secret,token)}"
+        end# }}}
+        def self::generate_optimistic_token(client_id, secret, adur=3600, rdur=7776000) #{{{
+          t = generate_access_token(client_id, secret, adur)
+          r = generate_refresh_token(client_id, secret, rdur)
+          [t, r]
+        end #}}}
+
+        def self::decrypt_with_shared_secret(data, secret) #{{{
+          # extract initialization vector from encrypted data for further shenanigans
+          iv, encr = data[0...16], data[16..-1]
+
+          decipher = OpenSSL::Cipher::Cipher.new 'aes-256-cbc'
+          decipher.decrypt
+
+          decipher.key = Digest::SHA256.hexdigest secret
+          decipher.iv = iv
+
+          decipher.update(encr) + decipher.final rescue nil
+        end #}}}
+        def self::encrypt_with_shared_secret(data, secret) #{{{
+          cipher = OpenSSL::Cipher::Cipher.new 'aes-256-cbc'
+          cipher.encrypt
+
+          key = Digest::SHA256.hexdigest secret
+          iv = cipher.random_iv
+          cipher.key = key
+          cipher.iv = iv
+
+           Base64::urlsafe_encode64(iv + cipher.update(data) + cipher.final) rescue nil
+        end #}}}
+      end
+    end
+  end
+end

data/lib/ruby/riddl/oauth2-univie.rb

@@ -0,0 +1,167 @@
+require File.expand_path(File.dirname(__FILE__) + '/oauth2-helper')
+
+module Riddl
+  module Utils
+    module OAuth2
+      
+      module UnivieBearer
+        def self::implementation(client_id, client_secret, access_tokens)
+          Proc.new do
+						run CheckAuth, client_id, client_secret, access_tokens if get
+          end
+        end  
+
+				class CheckAuth < Riddl::Implementation
+					def response
+						client_id = @a[0]
+						client_secret = @a[1]
+						access_tokens = @a[2]
+						if @h['AUTHORIZATION']
+							token = @h['AUTHORIZATION'].sub(/^Bearer /, '')
+
+							data, _, signature = token.rpartition '.'
+							expected_sign = Riddl::Utils::OAuth2::Helper::sign(client_id + ':' + client_secret, data)
+
+							if !access_tokens.key? token
+								@status = 403
+								return Riddl::Parameter::Complex.new('data', 'application/json', {
+									:error => 'Unknown token'
+								}.to_json)
+							elsif signature != expected_sign
+								@status = 403
+								return Riddl::Parameter::Complex.new('data', 'application/json', {
+									:error => 'Invalid token, you bad boy'
+								}.to_json)
+							end
+
+							header_claims, payload_claims = data.split('.').map { |v| Base64::urlsafe_decode64 v }
+							payload_claims = JSON::parse payload_claims
+
+							if header_claims != Riddl::Utils::OAuth2::Helper::header
+								@status = 401
+								return Riddl::Parameter::Complex.new('data', 'application/json', {
+									:error => 'Invalid header claims'
+								}.to_json)
+							elsif payload_claims['exp'] <= Time.now.to_i
+								@status = 403
+								return Riddl::Parameter::Complex.new('data', 'application/json', {
+									:error => 'Expired token'
+								}.to_json)
+							elsif !payload_claims['aud'].split(',').map(&:strip).include? client_id
+								# XXX: ein token für mehrere clients gültig? lookup?
+								@status = 403
+								return Riddl::Parameter::Complex.new('data', 'application/json', {
+									:error => 'Token is not valid for this application'
+								}.to_json)
+							end
+
+							@headers << Riddl::Header.new('AUTHORIZATION_BEARER', access_tokens[token])
+						end
+
+						@p
+					end
+				end
+			end
+
+      module UnivieApp
+        def self::implementation(client_id, client_secret, access_tokens, refresh_tokens)
+          Proc.new do
+            on resource 'verify' do
+              run VerifyIdentity, access_tokens, refresh_tokens, client_id, client_secret if post 'verify_in'
+            end
+            on resource 'token' do
+              run RefreshToken, access_tokens, refresh_tokens, client_id, client_secret if post 'refresh_token_in'
+            end
+            on resource 'revoke' do
+              run RevokeTokenFlow, access_tokens, refresh_tokens if get 'revoke_token_in'
+              run RevokeUserFlow, access_tokens, refresh_tokens if get 'revoke_user_in'
+            end
+          end
+        end  
+
+        class VerifyIdentity < Riddl::Implementation
+          def response
+            code = Base64::urlsafe_decode64 @p[0].value
+            access_tokens = @a[0]
+            refresh_tokens = @a[1]
+            client_id = @a[2]
+            client_secret = @a[3]
+
+            client_pass   = "#{client_id}:#{client_secret}"
+            user_id, decrypted            = Riddl::Utils::OAuth2::Helper::decrypt_with_shared_secret(code, client_pass).split(':', 2)
+            token, refresh_token          = Riddl::Utils::OAuth2::Helper::generate_optimistic_token(client_id, client_pass)
+            access_tokens[token]          = user_id
+            refresh_tokens[refresh_token] = token
+
+            json_response = {
+              :access_token => token,
+              :refresh_token => refresh_token,
+              :code => Base64.urlsafe_encode64(decrypted)
+            }.to_json
+
+            Riddl::Parameter::Complex.new('data', 'application/json', json_response)
+          end
+        end
+
+        class RevokeTokenFlow < Riddl::Implementation
+          def response
+            token = @p[0].value
+            access_tokens = @a[0]
+            refresh_tokens = @a[1]
+
+            access_tokens.delete(token)
+            refresh_tokens.delete_by_value(token)
+          end
+        end
+
+        class RevokeUserFlow < Riddl::Implementation
+          def response
+            user_id = @p[0].value
+            access_tokens = @a[0]
+            refresh_tokens = @a[1]
+
+            token = access_tokens.delete_by_value user_id
+            refresh_tokens.delete_by_value token
+          end
+        end
+
+        class RefreshToken < Riddl::Implementation
+          def response
+            refresh_token = @p[1].value
+            access_tokens = @a[0]
+            refresh_tokens = @a[1]
+            client_id = @a[2]
+            client_secret = @a[3]
+
+            token, _ = refresh_token.split '.'
+            token_data = JSON::parse(Base64::urlsafe_decode64 token)
+
+            if token_data['iss'] != client_id
+              @status = 401
+              return Riddl::Parameter::Complex.new('data', 'application/json', {
+                :error => 'Token must be refreshed by issuer.'
+              }.to_json)
+            elsif refresh_tokens[refresh_token].nil? || token_data['exp'] <= Time.now.to_i
+              @status = 403
+              puts "i dont know #{refresh_token}", "#{refresh_tokens[refresh_token]}"
+              return Riddl::Parameter::Complex.new('data', 'application/json', {
+                :error => 'Invalid refresh token.'
+              }.to_json)
+            end
+
+            old_token = refresh_tokens[refresh_token]
+            user = access_tokens.delete old_token
+
+            token = Riddl::Utils::OAuth2::Helper::generate_access_token(client_id, client_id + ':' + client_secret)
+
+            refresh_tokens[refresh_token] = token
+            access_tokens[token] = user
+
+            Riddl::Parameter::Complex.new('data', 'application/json', { :token => token }.to_json)
+          end
+        end
+      end
+
+    end  
+  end  
+end

data/lib/ruby/riddl/properties.rb

@@ -0,0 +1,479 @@
+module Riddl
+  module Utils
+    module Properties
+
+      VERSION_MAJOR = 1
+      VERSION_MINOR = 0
+      PROPERTIES_SCHEMA_XSL_RNG = "#{File.dirname(__FILE__)}/../ns/common-patterns/properties/#{VERSION_MAJOR}.#{VERSION_MINOR}/properties.schema.xsl"
+
+      def self::implementation(backend,handler=nil,details=:production)
+        unless handler.nil? || (handler.is_a? Riddl::Utils::Properties::HandlerBase)
+          raise "handler not a subclass of HandlerBase"
+        end
+        Proc.new do
+          run          Riddl::Utils::Properties::All,           backend, handler if get    '*'
+          run          Riddl::Utils::Properties::Query,         backend, handler if get    'query'
+          on resource 'schema' do
+            run        Riddl::Utils::Properties::Schema,        backend          if get
+            on resource 'rng' do
+              run      Riddl::Utils::Properties::RngSchema,     backend          if get
+            end  
+          end
+          on resource 'values' do
+            run        Riddl::Utils::Properties::Properties,    backend, handler if get
+            run        Riddl::Utils::Properties::AddProperty,   backend, handler if post   'property'
+            run        Riddl::Utils::Properties::AddProperties, backend, handler if put    'properties'
+            on resource do
+              run      Riddl::Utils::Properties::GetContent,    backend, handler if get
+              run      Riddl::Utils::Properties::DelContent,    backend, handler if delete
+              run      Riddl::Utils::Properties::AddContent,    backend, handler if post   'addcontent'
+              run      Riddl::Utils::Properties::UpdContent,    backend, handler if put    'updcontent'
+              on resource do
+                run    Riddl::Utils::Properties::GetContent,    backend, handler if get
+                run    Riddl::Utils::Properties::DelContent,    backend, handler if delete
+                run    Riddl::Utils::Properties::UpdContent,    backend, handler if put    'updcontent'
+                on resource do
+                  run  Riddl::Utils::Properties::GetContent,    backend, handler if get
+                end
+              end
+            end
+          end  
+        end
+      end  
+
+      # Overloadable and Backends
+      class HandlerBase #{{{
+        def initialize(data)
+          @data = data
+          @property = nil
+        end
+        def property(p)
+          @property = p
+          self
+        end  
+        def create; end
+        def read;   end
+        def update; end
+        def delete; end
+      end #}}}
+
+      class Backend #{{{
+        attr_reader :schema, :data, :rng 
+
+        def initialize(schema,target,init=nil)
+          @target = target.gsub(/^\/+/,'/')
+          @schemas = {}
+          @rngs = {}
+
+          if schema.is_a? Hash
+            schema.each { |k,v| add_schema k, v }
+          elsif schema.is_a? String  
+            add_schema 'default', schema
+          end
+          raise "no schemas provided" if @schemas.length == 0
+          @schema = @schemas.first[1]
+          @rng = @rngs.first[1]
+
+          FileUtils::mkdir_p(File::dirname(@target)) unless File.exists?(@target)
+          FileUtils::cp init, @target                if init and not File.exists?(@target)
+
+          raise "properties file not found" unless File.exists?(@target)
+          @data = XML::Smart.open_unprotected(@target)
+          @data.register_namespace 'p', 'http://riddl.org/ns/common-patterns/properties/1.0'
+          @mutex = Mutex.new
+        end
+
+        def activate_schema(name)
+          if @schemas[name]
+            @schema = @schemas[name]
+            @rng = @rngs[name]
+            true
+          else
+            false
+          end
+        end
+
+        def add_schema(key,name)
+          raise "schema file not found" unless File.exists?(name)
+          @schemas[key] = XML::Smart.open_unprotected(name.gsub(/^\/+/,'/'))
+          @schemas[key].register_namespace 'p', 'http://riddl.org/ns/common-patterns/properties/1.0'
+          if !File::exists?(Riddl::Utils::Properties::PROPERTIES_SCHEMA_XSL_RNG)
+            raise "properties schema transformation file not found"
+          end  
+          @rngs[key] = @schemas[key].transform_with(XML::Smart.open_unprotected(Riddl::Utils::Properties::PROPERTIES_SCHEMA_XSL_RNG))
+        end
+        private :add_schema
+
+        def modifiable?(property)
+          @schema.find("boolean(/p:properties/p:#{property}[@modifiable='true'])") || schema.find("boolean(/p:properties/p:optional/p:#{property}[@modifiable='true'])")
+        end
+        def valid_state?(property,current,new)
+          @schema.find("boolean(/p:properties/p:#{property}/p:#{current}/p:#{new}[@putable='true'])") || schema.find("boolean(/p:properties/p:optional/p:#{property}/p:#{current}/p:#{new}[@putable='true'])")
+        end
+        def is_state?(property)
+          @schema.find("boolean(/p:properties/p:#{property}[@type='state'])") || schema.find("boolean(/p:properties/p:optional/p:#{property}[@type='state'])")
+        end
+        def init_state?(property,new)
+          @schema.find("boolean(/p:properties/p:#{property}/p:#{new}[position()=1])") || schema.find("boolean(/p:properties/p:optional/p:#{property}/p:#{new}[position()=1])")
+        end
+        def property_type(property)
+          exis = @schema.find("/p:properties/*[name()='#{property}']|/p:properties/p:optional/*[name()='#{property}']")
+          exis.any? ? exis.first.attributes['type'].to_sym : nil
+        end
+
+        def modify(&block)
+          tdoc = @data.root.to_doc
+          tdoc.register_namespace 'p', 'http://riddl.org/ns/common-patterns/properties/1.0'
+          @mutex.synchronize do
+            block.call tdoc
+            if tdoc.validate_against(@rng){|err| puts err.message }
+              block.call @data
+              @data.save_as(@target)
+              true
+            else
+              false
+            end
+          end  
+        end
+       end #}}}
+
+      # Just reading
+      class All < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+          EM.defer{handler.read} unless handler.nil?
+          return Riddl::Parameter::Complex.new("document","text/xml",backend.data.to_s)
+        end
+      end #}}}
+
+      class Properties < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+          EM.defer{handler.read} unless handler.nil?
+
+          ret = XML::Smart.string("<properties xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>")
+          backend.schema.find("/p:properties/*[name()!='optional']|/p:properties/p:optional/*").each do |r|
+            ret.root.add("property",r.qname.to_s)
+          end
+          return Riddl::Parameter::Complex.new("keys","text/xml",ret.to_s)
+        end
+      end #}}} 
+
+      class Query < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+          EM.defer{handler.read} unless handler.nil?
+          query = (@p[0].value.to_s.strip.empty? ? '*' : @p[0].value)
+
+          begin
+            e = backend.data.find(query)
+          rescue => e
+            prop = XML::Smart::string("<not-existing xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>").to_s
+            return Riddl::Parameter::Complex.new("value","text/xml",prop.to_s)
+          end
+          if e.class == XML::Smart::Dom::NodeSet
+            if e.any?
+              prop = XML::Smart::string("<value xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>")
+              prop.root.add(e)
+            else
+              prop = XML::Smart::string("<not-existing xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>").to_s
+            end
+            return Riddl::Parameter::Complex.new("value","text/xml",prop.to_s)
+          else
+            return Riddl::Parameter::Simple.new("value",e.to_s)
+          end
+        end
+      end #}}}
+
+      class RngSchema < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          Riddl::Parameter::Complex.new("document-schema","text/xml",backend.rng.to_s)
+        end
+      end #}}}
+
+      class Schema < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          return Riddl::Parameter::Complex.new("document-schema","text/xml",backend.schema.to_s)
+        end
+      end #}}}
+
+      class GetContent < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+
+          EM.defer{handler.property(@r[1]).read} unless handler.nil?
+
+            if ret = extract_values(backend,@r[1],Riddl::Protocols::Utils::unescape(@r[2..-1].join('/')))
+            ret
+          else
+            @status = 404
+          end
+        end
+        
+        def extract_values(backend,property,minor=nil)
+          case backend.property_type(property)
+            when :complex
+              res = backend.data.find("/p:properties/*[name()=\"#{property}\"]#{minor == '' ? '' : "/p:#{minor}"}")
+              if res.any?
+                prop = XML::Smart::string("<value xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>")
+                if res.length == 1
+                  prop.root.add(res.first.children)
+                else  
+                  prop.root.add(res)
+                end  
+                return Riddl::Parameter::Complex.new("value","text/xml",prop.to_s)
+              else
+                prop = XML::Smart::string("<not-existing xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>")
+              end
+            when :simple, :state
+              res = backend.data.find("string(/p:properties/*[name()=\"#{property}\"]#{minor})")
+              return Riddl::Parameter::Simple.new("value",res.to_s)
+            when :arbitrary
+              res = backend.data.find("/p:properties/*[name()=\"#{property}\"]")
+              if res.any?
+                c = res.first.children
+                if c.length == 1 && c.first.class == XML::Smart::Dom::Element
+                  return Riddl::Parameter::Complex.new("content","text/xml",c.first.dump)
+                else
+                  return Riddl::Parameter::Complex.new("content","text/plain",c.first.to_s)
+                end
+              else
+                prop = XML::Smart::string("<not-existing xmlns=\"http://riddl.org/ns/common-patterns/properties/1.0\"/>")
+                return Riddl::Parameter::Complex.new("content","text/xml",prop.to_s)
+              end
+          end
+          nil
+        end
+        private :extract_values
+
+      end #}}}
+      
+      # Modifiable
+      class AddProperty < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+
+          property = @p[0].value
+          ct       = @p[1]
+          value    = ct.name == 'value' ? ct.value : nil
+          content  = ct.name == 'content' ? ct.value : nil
+
+          unless backend.modifiable?(property)
+            @status = 500
+            return # change properties.schema
+          end
+
+          path = "/p:properties/*[name()=\"#{property}\"]"
+          nodes = backend.data.find(path)
+          if nodes.any?
+            @status = 404
+            return # this property does not exist
+          end
+
+          if backend.is_state?(property)
+            unless backend.init_state?(property,value)
+              @status = 404
+              return # not a valid state from here on
+            end
+          end  
+
+          newstuff = value.nil? ? XML::Smart.string(content).root.children : value
+          backend.modify do |doc|
+            ele = doc.root.add property
+            if value.nil?
+              ele.add newstuff
+            else
+              ele.text = newstuff
+            end  
+          end || begin
+            @status = 400
+            return # bad request
+          end
+          
+          EM.defer{handler.property(property).create} unless handler.nil?
+          return
+        end
+      end #}}}
+      
+      class AddProperties < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+
+          0.upto(@p.length/2-1) do |i|
+            property = @p[i*2].value
+            ct       = @p[i*2+1]
+            value    = ct.name == 'value' ? ct.value : nil
+            content  = ct.name == 'content' ? ct.value : nil
+
+            unless backend.modifiable?(property)
+              @status = 500
+              return # change properties.schema
+            end
+
+            path = "/p:properties/*[name()=\"#{property}\"]"
+            nodes = backend.data.find(path)
+            if nodes.empty?
+              @status = 404
+              return # this property does not exist
+            end
+
+            if backend.is_state?(property)
+              unless backend.valid_state?(property,nodes.first.to_s,value)
+                @status = 404
+                return # not a valid state from here on
+              end
+            end  
+
+            newstuff = value.nil? ? XML::Smart.string(content).root.children : value
+            backend.modify do |doc|
+              nodes = doc.find(path)
+              nods = nodes.map{|ele| ele.children.delete_all!; ele}
+              nods.each do |ele| 
+                if value.nil?
+                  ele.add newstuff
+                else
+                  ele.text = newstuff
+                end  
+              end  
+            end || begin
+              @status = 400
+              return # bad request
+            end
+            
+          end
+          EM.defer do
+            0.upto(@p.length/2-1) do |i|
+              property = @p[i*2].value
+              handler.property(property).create
+            end
+          end unless handler.nil?
+          return
+        end
+      end #}}}
+
+      class AddContent < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+
+          property = @r[1]
+          value = @p.detect{|p| p.name == 'value'}.value
+
+          unless backend.modifiable?(property)
+            @status = 500
+            return # change properties.schema
+          end
+
+          path = "/p:properties/p:#{property}"
+          node = backend.data.find(path)
+          if node.empty?
+            @status = 404
+            return # this property does not exist
+          end  
+
+          newstuff = XML::Smart.string(value)
+          backend.modify do |doc|
+            node = doc.find(path)
+            node.first.add newstuff.root
+          end || begin
+            @status = 400
+            return # bad request
+          end
+
+          EM.defer{handler.property(property).create} unless handler.nil?
+        end
+      end #}}}
+
+      class DelContent < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+
+          property = @r[1]
+          minor    = Riddl::Protocols::Utils::unescape(@r[2])
+
+          unless backend.modifiable?(property)
+            @status = 500
+            return # change properties.schema
+          end
+
+          path = "/p:properties/*[name()=\"#{property}\"]#{minor.nil? ? '' : "/p:#{minor}"}"
+          nodes = backend.data.find(path)
+          if nodes.empty?
+            @status = 404
+            return # this property does not exist
+          end
+
+          backend.modify do |doc|
+            doc.find(path).delete_all!
+          end || begin
+            @status = 400
+            return # bad request
+          end
+
+          EM.defer{handler.property(property).delete} unless handler.nil?
+          return
+        end
+      end #}}} 
+
+      class UpdContent < Riddl::Implementation #{{{
+        def response
+          backend = @a[0]
+          handler = @a[1]
+
+          property = @r[1]
+          value    = @p.detect{|p| p.name == 'value'}; value = value.nil? ? value : value.value
+          content  = @p.detect{|p| p.name == 'content'}; content = content.nil? ? content : content.value
+          minor    = @r[2]
+
+          unless backend.modifiable?(property)
+            @status = 500
+            return # change properties.schema
+          end
+
+          path = "/p:properties/*[name()=\"#{property}\"]#{minor.nil? ? '' : "/p:#{minor}"}"
+          nodes = backend.data.find(path)
+          if nodes.empty?
+            @status = 404
+            return # this property does not exist
+          end
+
+          if backend.is_state?(property)
+            unless backend.valid_state?(property,nodes.first.to_s,value)
+              @status = 404
+              return # not a valid state from here on
+            end
+          end  
+
+          newstuff = value.nil? ? XML::Smart.string(content).root.children : value
+          backend.modify do |doc|
+            nodes = doc.root.find(path)
+            nods = nodes.map{|ele| ele.children.delete_all!; ele}
+            nods.each do |ele| 
+              if value.nil?
+                ele.add newstuff
+              else
+                ele.text = newstuff
+              end
+            end  
+          end || begin
+            @status = 400
+            return # bad request
+          end
+          
+          EM.defer{handler.property(property).update} unless handler.nil?
+          return
+        end
+      end #}}}
+
+    end
+  end
+end