ServeWebdav 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 / 2006-11-13
+
+* Initial release
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/serve_webdav.rb
+lib/serve_webdav/errors.rb
+lib/serve_webdav/raw_data_patch.rb
+lib/serve_webdav/resource.rb
+lib/serve_webdav/serve_webdav.rb
+test/test_serve_webdav.rb

data/README.txt

@@ -0,0 +1,49 @@
+ServeWebdav
+    by Stuart Eccles and Adocca AB
+    http://www.adocca.com
+
+== DESCRIPTION:
+  
+Based on the RailsDav plugin by Stuart Eccles, but somewhat altered. Provides a webdav interface
+for rails applications.
+
+== FEATURES/PROBLEMS:
+  
+TODO write better docs
+
+== SYNOPSYS:
+
+TODO write better docs...
+
+== REQUIREMENTS:
+
+* Rails 1.1.6
+
+== INSTALL:
+
+* gem install serve_webdav
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006 Stuart Eccles & Adocca AB
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+require './lib/serve_webdav.rb'
+
+
+Hoe.new('ServeWebdav', ServeWebdav::VERSION) do |p|
+  p.rubyforge_name = 'adocca_plugins'
+  p.summary = 'Webdav protocol abstraction for rails controllers'
+  # p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  # p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/serve_webdav/errors.rb

@@ -0,0 +1,68 @@
+require 'active_support'
+
+module WebDavErrors
+  
+  class BaseError < Exception
+  end
+  
+  class LockedError < WebDavErrors::BaseError
+    @@http_status = 423
+    cattr_accessor :http_status
+  end
+
+  class InsufficientStorageError < WebDavErrors::BaseError
+    @@http_status = 507
+    cattr_accessor :http_status
+  end
+  
+  class ConflictError < WebDavErrors::BaseError
+    @@http_status = 405
+    cattr_accessor :http_status
+  end
+  
+  class ForbiddenError < WebDavErrors::BaseError
+    @@http_status = 403
+    cattr_accessor :http_status
+  end
+  
+  class BadGatewayError < WebDavErrors::BaseError
+    @@http_status = 502
+    cattr_accessor :http_status
+  end
+  
+  class PreconditionFailsError < WebDavErrors::BaseError
+    @@http_status = 412
+    cattr_accessor :http_status
+  end
+  
+  class NotFoundError < WebDavErrors::BaseError
+    @@http_status = 404
+    cattr_accessor :http_status
+  end
+  
+  class UnSupportedTypeError < WebDavErrors::BaseError
+    @@http_status = 415
+    cattr_accessor :http_status
+  end
+  
+  class UnknownWebDavMethodError < WebDavErrors::BaseError
+    @@http_status = 405
+    cattr_accessor :http_status
+  end
+
+  class ConflictWebDavError < WebDavErrors::BaseError
+    @@http_status = 409
+    cattr_accessor :http_status
+  end
+  
+  class BadRequestBodyError < WebDavErrors::BaseError
+    @@http_status = 400
+    cattr_accessor :http_status
+  end
+  
+  class EmptyPutError < WebDavErrors::BaseError
+    @@http_status = 200
+    cattr_accessor :http_status
+  end
+end
+

data/lib/serve_webdav/raw_data_patch.rb

@@ -0,0 +1,77 @@
+class CGI #:nodoc:
+  # Add @request.env['RAW_POST_DATA'] for the vegans.
+  module QueryExtension 
+    
+  private 
+    
+    def read_query_params(method)
+      case method
+        when :get
+          read_params_from_query
+        when :post, :proppatch, :propfind
+          read_params_from_post
+        when :put
+          read_params_from_post
+          ""
+        when :cmd
+          read_from_cmdline
+        else # when :head, :delete, :options
+          read_params_from_query
+      end
+    end
+end # module QueryExtension
+end
+
+class CGIMethods
+    def self.typecast_xml_value(value)
+      case value
+      when Hash
+        if value.has_key?("__content__")
+          content = translate_xml_entities(value["__content__"])
+          case value["type"]
+          when "integer"  then content.to_i
+          when "boolean"  then content == "true"
+          when "datetime" then Time.parse(content)
+          when "date"     then Date.parse(content)
+          else                 content
+          end
+        else
+          value.empty? ? nil : value.inject({}) do |h,(k,v)|
+            h[k] = typecast_xml_value(v)
+            h
+          end
+        end
+      when Array
+        value.map! { |i| typecast_xml_value(i) }
+        case value.length
+        when 0 then nil
+        when 1 then value.first
+        else value
+        end
+      when String
+        value
+      else
+        raise "can't typecast #{value.inspect}"
+      end
+    end
+end
+
+class CGIMethods
+  def CGIMethods.parse_request_parameters(params)
+      parsed_params = {}
+
+      for key, value in params
+        value = [value] if key =~ /.*\[\]$/
+        next if key.nil?
+        if !key.nil? && !key.include?('[')
+          # much faster to test for the most common case first (GET)
+          # and avoid the call to build_deep_hash
+          parsed_params[key] = get_typed_value(value[0])
+        else
+          build_deep_hash(get_typed_value(value[0]), parsed_params, get_levels(key))
+        end
+      end
+    
+      parsed_params
+    end
+end

data/lib/serve_webdav/resource.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2006 Stuart Eccles
+# Released under the MIT License.  See the LICENSE file for more details.
+class WebDavResource
+  
+  def properties
+    Array.new
+  end
+  
+  def delete!
+    
+  end
+  
+  def move! (dest_path, depth)
+    
+  end
+    
+  def copy! (dest_path, depth)
+    
+  end
+  
+  def status
+    gen_status(200, "OK").to_s
+  end
+  
+  def collection?
+    return false
+  end
+  
+  def children
+    return []
+  end
+
+  def get_displayname
+    CGI::escape(self.displayname).gsub(/\+/, '%20')
+  end
+
+  def get_href
+    self.href.gsub(/\+/, '%20')
+  end
+
+  def get_properties
+    hsh = {}
+    self.properties.each do|meth|
+      if self.respond_to?('get_'+meth.to_s)
+        hsh[meth] = self.send(('get_'+meth.to_s).to_sym)
+      else
+        hsh[meth] = self.send(meth)
+      end
+    end
+    hsh
+  end
+
+  protected
+   def gen_element(elem, text = nil, attrib = {})
+     e = REXML::Element.new elem
+     text and e.text = text
+     attrib.each {|k, v| e.attributes[k] = v }
+     e
+   end
+   
+   def gen_status(status_code, reason_phrase)
+       "HTTP/1.1 #{status_code} #{reason_phrase}"
+   end
+   
+end
+

data/lib/serve_webdav/serve_webdav.rb

@@ -0,0 +1,419 @@
+require 'action_controller'
+module ServeWebdav
+
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end 
+
+  module ClassMethods
+    def serve_webdav
+      class_eval do 
+        extend ServeWebdav::SingletonMethods
+      end
+      include ServeWebdav::InstanceMethods
+    end
+  end
+
+  module SingletonMethods 
+     
+    def set_max_propfind_depth( value=nil)
+      @@max_propfind_depth = value
+    end
+
+    def get_max_propfind_depth
+      @@max_propfind_depth
+    end
+
+    def get_propfind_xml
+    <<EOPROPFIND_XML 
+     xml.D(:multistatus, {"xmlns:D" => "DAV:"}) do
+        @resources.each do |resource|
+           xml.D :response do
+               xml.D :href, resource.get_href
+               xml.D :propstat do
+                  xml.D :prop do
+      			         resource.get_properties.each do |property, value|
+                      xml.D(property, value)
+      			         end
+      			         xml.D :resourcetype do
+         				     xml.D :collection if resource.collection?
+         			     end
+                  end
+      			       xml.D :status, resource.status
+               end
+            end
+        end
+     end  
+EOPROPFIND_XML
+    end
+    def get_proppatch_xml
+      <<EOPROPPATCH_XML 
+      xml.D(:multistatus, {"xmlns:D" => "DAV:"}) do
+         xml.D :response do
+            xml.D :href, @resource.get_href
+            for remove_property in @remove_properties
+                xml.D :propstat do
+                  xml.D :prop do
+                    xml.tag! remove_property.name.to_sym, remove_property.attributes
+                  end
+                  if @resource.respond_to?(("remove_" + remove_property.name).to_sym)
+                    xml.D(:status, @resource.__send__(("remove_" + remove_property.name).to_sym))
+                  else
+                    xml.D :status, "HTTP/1.1 200 OK"
+                  end
+                end
+            end
+            for set_property in @set_properties
+                xml.D :propstat do
+                  xml.D :prop do
+                    xml.D set_property.name.to_sym, set_property.attributes
+                  end
+                  if @resource.respond_to?(("set_" + set_property.name).to_sym)
+                    xml.D(:status, @resource.__send__(("set_" + set_property.name).to_sym))
+                  else
+                    xml.D :status, "HTTP/1.1 200 OK"
+                  end
+                end
+            end
+   			    xml.D :responsedescription
+         end
+      end
+EOPROPPATCH_XML
+    end
+     
+    private
+    def define_attr_method(name, value=nil, &block)
+      sing = class << self; self; end
+      #sing.send :alias_method, "original_#{name}", name
+      if block_given?
+        sing.send :define_method, name, &block
+      else
+        # use eval instead of a block to work around a memory leak in dev
+        # mode in fcgi
+        sing.class_eval "def #{name}; #{value.to_s.inspect}; end"
+      end
+    end
+  end # SingletonMethods 
+  
+  module InstanceMethods
+    def index
+      webdav
+    end
+     
+    def webdav
+      #we can get the method (as webdav has a lot of new methods) from the request
+      webdav_method = request.method.to_s
+      @path_info = convert_path_info(@request, params[:path_info].to_s) 
+     
+      begin
+       #going to call the method for this webdav method 
+       if respond_to?("webdav_#{webdav_method}", true)
+         __send__("webdav_#{webdav_method}")
+       else
+         raise WebDavErrors::UnknownWebDavMethodError
+       end
+       
+      rescue WebDavErrors::BaseError => webdav_error
+        logger.debug("ERROR : #{webdav_error.to_s}")
+        logger.debug("STATUS : #{webdav_error.http_status}")
+        render :nothing => true, :status => webdav_error.http_status and return
+      end
+    end
+
+    def webdav_options()
+      @response.headers['DAV'] = "1,2"
+      @response.headers['MS-Author-Via'] = "DAV"
+      @response.headers["Allow"] = "COPY,DELETE,GET,HEAD,MKCOL,MOVE,OPTIONS,POST,PROPFIND,PROPPATCH,PUT"
+      render  :nothing => true, :status => 200 and return
+    end
+     
+    def webdav_lock()
+      #TODO implementation for now return a 200 OK
+      render :nothing => true, :status => 200 and return
+    end
+     
+    def webdav_unlock()
+      #TODO implementation for now return a 200 OK
+      render :nothing => true, :status => 200 and return
+    end
+     
+    def webdav_propfind() 
+      logger.info("PATH INFO: " + @path_info)
+      @depth = get_depth
+      
+      #default a big depth if infinity
+      @depth = 500 if @depth.nil?
+      
+      
+      unless request.raw_post.blank?
+        begin
+          req_doc = REXML::Document.new @request.raw_post
+        rescue REXML::ParseException
+          raise WebDavErrors::BadRequestBodyError 
+        end
+      end
+      
+      @resources = get_dav_resource_props(@path_info)
+      
+      raise WebDavErrors::NotFoundError if @resources.blank?
+      
+      response.headers["Content-Type"] = 'text/xml; charset="utf-8"'
+      #render the Multistatus XML
+      render :inline => self.class.get_propfind_xml, :type => :rxml, :status => 207  and return
+    end
+  
+    def webdav_proppatch()
+      
+      @resource = get_resource_for_path(@path_info)
+      
+      ns = {""=>"DAV:"}
+      begin
+        req_doc = REXML::Document.new request.raw_post
+      rescue REXML::ParseException
+        raise WebDavErrors::BadRequestBodyError
+      end
+      
+      @remove_properties = []
+      @set_properties = []
+      REXML::XPath.each(req_doc, "/propertyupdate/remove/prop/*", ns){|e|
+        @remove_properties << e
+      }
+      REXML::XPath.each(req_doc, "/propertyupdate/set/prop/*", ns){|e|
+        @set_properties << e
+      }
+      
+       response.headers["Content-Type"] = 'text/xml; charset="utf-8"'
+       
+       #render the Multistatus XML
+       render :inline => self.class.get_proppatch_xml, :type => :rxml, :status => 207 # and return
+    end
+  
+    def webdav_mkcol
+        # need to check the content-type header to not allow invalid content types
+        mkcol_ct = request.env['CONTENT_TYPE']
+
+        logger.info(request.inspect)
+
+        if (!mkcol_ct.blank? && (mkcol_ct != "httpd/unix-directory")) || !request.raw_post.nil?
+          raise WebDavErrors::UnSupportedTypeError
+        end
+
+        
+        raise WebDavErrors::UnknownWebDavMethodError if file_exist?(@path_info)
+        
+        mkcol_for_path(@path_info)
+        
+        render :nothing => true, :status => 201
+    end
+  
+    def webdav_delete()
+      resource = get_resource_for_path(@path_info)
+      unless resource.nil?
+        logger.debug('RESOURCE IS' + resource.inspect)
+        resource.delete!
+      else
+        # Delete on a non-existant resource
+        raise WebDavErrors::NotFoundError
+      end
+
+      render :nothing => true, :status => 204
+    end
+  
+    def webdav_put()
+      write_content_to_path(@path_info, request.raw_post)
+
+      render :nothing => true, :status => 201 and return
+    end
+  
+    def webdav_copy()
+      @depth = get_depth
+
+      #Check the destination URI
+      begin
+        dest_uri = get_destination_uri
+        dest_path = convert_path_info(@request, get_dest_path)
+        # Bad Gateway it if the servers arnt the same
+        raise WebDavErrors::BadGatewayError unless request.host_with_port == "#{dest_uri.host}:#{dest_uri.port}"
+      rescue URI::InvalidURIError
+        raise WebDavErrors::BadGatewayError
+      end
+
+      resource = get_resource_for_path(@path_info)
+
+      # Not found if the source doesnt exist
+      raise WebDavErrors::NotFoundError if resource.nil?
+
+      file_exist = file_exist?(dest_path)
+      
+      raise WebDavErrors::PreconditionFailsError if file_exist && !get_overwrite
+      
+      copy_to_path(resource, dest_path, @depth)
+
+      file_exist ? render(:nothing => true, :status => 204) : render(:nothing => true, :status => 201)
+    end
+  
+    def webdav_move()
+      @depth = get_depth
+
+      #Check the destination URI
+      begin
+        dest_uri = get_destination_uri
+        dest_path = convert_path_info(@request, get_dest_path)
+        #Bad Gateway it if the servers arnt the same
+        raise WebDavErrors::BadGatewayError unless request.host_with_port == "#{dest_uri.host}:#{dest_uri.port}"
+      rescue URI::InvalidURIError => e
+        logger.debug("INVALID URI: " + e.to_s)
+        logger.debug(request.env['HTTP_DESTINATION'])
+        raise WebDavErrors::BadGatewayError
+      end
+
+      resource = get_resource_for_path(@path_info)
+
+      #Not found if the source doesnt exist
+      raise WebDavErrors::NotFoundError if resource.nil?
+
+      file_exist = file_exist?(dest_path)
+      
+      raise WebDavErrors::PreconditionFailsError if file_exist && !get_overwrite
+
+      move_to_path(resource, dest_path, @depth)
+      file_exist ? render(:nothing => true, :status => 204) : render(:nothing => true, :status => 201)
+    end
+      
+    def webdav_get
+      resource = get_resource_for_path(@path_info)
+      send_data resource.data, :filename => resource.get_displayname
+    end
+
+    def webdav_head
+      resource = get_resource_for_path(@path_info)
+      raise WebDavErrors::NotFoundError if resource.blank?
+      @response.headers["Last-Modified"] = resource.getlastmodified
+      render(:nothing => true, :status => 200) and return  
+    end
+
+    protected
+    ##############################################################################################################
+    #To be overidden by implementing controller
+    def mkcol_for_path(path)
+      raise "implement me"
+    end
+
+    def write_content_to_path(path, content)
+      raise "implement me"
+    end
+
+    def file_exist?(dest_path)
+       raise "implement me"
+    end
+
+    def copy_to_path(resource, dest_path, depth)
+      raise "implement me"
+    end
+
+    def move_to_path(resource, dest_path, depth)
+      raise "implement me"
+    end
+
+    def get_resource_for_path(file_path)
+      raise "implement me" # WebDavResource.new
+    end
+    ##############################################################################################################
+      
+    def get_depth
+      depth_head = request.env['HTTP_DEPTH'] 
+
+      if (depth_head.nil?)
+        depth = 1
+      else
+        depth = (depth_head == "infinity") ? nil : depth_head.to_i
+      end
+      return depth
+    end
+           
+    def get_destination_uri
+      URI.parse(request.env['HTTP_DESTINATION'])
+    end
+           
+    def get_dest_path
+      if /^#{Regexp.escape(url_for(:only_path => true, :path_info => ""))}/ =~  get_destination_uri.path
+         return $'
+      else
+         raise WebDavErrors::ForbiddenError
+      end
+    end
+           
+    def get_overwrite
+      ov = request.env['HTTP_OVERWRITE']
+      return (!ov.blank? and ov == 'T')
+    end
+  
+    def get_dav_resource_props(path)
+      ret_set = Array.new
+      @depth = self.class.get_max_propfind_depth if @depth > self.class.get_max_propfind_depth
+      @depth -= 1
+      resource = get_resource_for_path(path)
+      ret_set << resource
+      ret_set.concat resource.children unless @depth < 0
+      
+      return ret_set
+    end
+           
+    def href_for_path(path)
+      unless path.nil?
+        new_path = path.clone
+        new_path = new_path[1..-1] if (new_path.first == "/")
+        url_for(:only_path => true, :path_info => new_path)
+      else 
+        url_for(:only_path => true)
+      end
+    end
+            
+    def basic_auth_required(realm='Web Password', error_message="Could not authenticate you") 
+      username, passwd = get_auth_data
+      # check if authorized
+      # try to get user
+      unless yield username, passwd
+        # the user does not exist or the password was wrong
+        headers["Status"] = "Unauthorized" 
+        headers["WWW-Authenticate"] = "Basic realm=\"#{realm}\"" 
+        render :nothing => true, :status => 401
+      end 
+    end 
+           
+    def get_auth_data 
+      user, pass = '', '' 
+      # extract authorisation credentials 
+      if request.env.has_key? 'X-HTTP_AUTHORIZATION' 
+        # try to get it where mod_rewrite might have put it 
+        authdata = request.env['X-HTTP_AUTHORIZATION'].to_s.split 
+      elsif request.env.has_key? 'HTTP_AUTHORIZATION' 
+        # this is the regular location 
+        authdata = request.env['HTTP_AUTHORIZATION'].to_s.split  
+      end 
+
+      # at the moment we only support basic authentication 
+      if authdata and authdata[0] == 'Basic' 
+        user, pass = Base64.decode64(authdata[1]).split(':')[0..1] 
+      end 
+      return [user, pass]
+    end
+
+    def convert_path_info(req, path)
+      logger.info("PATH; " + path)
+      if req.env["HTTP_USER_AGENT"].match(/Microsoft|Windows/)
+        logger.info("CONVERTED: " + Iconv.iconv('UTF-8', 'latin1', CGI::unescape(path)).first)
+        Iconv.iconv('UTF-8', 'latin1', CGI::unescape(path)).first
+      elsif req.env["HTTP_USER_AGENT"].match(/cadaver/)
+        CGI::unescape(CGI::unescape(path))
+      elsif req.env["HTTP_USER_AGENT"].match(/Darwin|Macintosh/)
+        Unicode::normalize_KC(CGI::unescape(path))
+      else
+        CGI::unescape(path)
+      end
+    end
+  end
+end
+
+ActionController::Base.send(:include, ServeWebdav)

data/lib/serve_webdav.rb

@@ -0,0 +1,14 @@
+# = About lib/serve_webdav.rb
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+# Blah blah
+
+module ServeWebdav
+  VERSION = '0.0.1'
+end
+
+require 'serve_webdav/errors'
+require 'serve_webdav/resource'
+require 'serve_webdav/raw_data_patch'
+require 'serve_webdav/serve_webdav'
+

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ServeWebdav
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-11-13 00:00:00 +01:00
+summary: Webdav protocol abstraction for rails controllers
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: http://www.zenspider.com/ZSS/Products/ServeWebdav/
+rubyforge_project: adocca_plugins
+description: Ryan Davis is too lazy to write a description
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/serve_webdav.rb
+- lib/serve_webdav/errors.rb
+- lib/serve_webdav/raw_data_patch.rb
+- lib/serve_webdav/resource.rb
+- lib/serve_webdav/serve_webdav.rb
+- test/test_serve_webdav.rb
+test_files: 
+- test/test_serve_webdav.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.4
+    version: