#!/usr/bin/env ruby
# File:       06-11-14-mongrel_xmlrpc.rb
# Author:     Manuel Holtgrewe <purestorm at ggnore.net>
#
# Copyright (c) 2006 Manuel Holtgrewe, 2007 Luke Kanies
#
# 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.

# This file is based heavily on a file retrieved from
# http://ttt.ggnore.net/2006/11/15/xmlrpc-with-mongrel-and-ruby-off-rails/

require 'rubygems'
require 'mongrel'
require 'xmlrpc/server'
require 'puppet/network/xmlrpc/server'
require 'puppet/network/http_server'
require 'puppet/network/client_request'
require 'puppet/network/handler'

require 'resolv'

# This handler can be hooked into Mongrel to accept HTTP requests. After
# checking whether the request itself is sane, the handler forwards it
# to an internal instance of XMLRPC::BasicServer to process it.
#
# You can access the server by calling the Handler's "xmlrpc_server"
# attribute accessor method and add XMLRPC handlers there. For example:
#
# <pre>
# handler = XmlRpcHandler.new
# handler.xmlrpc_server.add_handler("my.add") { |a, b| a.to_i + b.to_i }
# </pre>
module Puppet::Network
    class HTTPServer::Mongrel < ::Mongrel::HttpHandler
        attr_reader :xmlrpc_server

        def initialize(handlers)
            if Puppet[:debug]
                $mongrel_debug_client = true
                Puppet.debug 'Mongrel client debugging enabled. [$mongrel_debug_client = true].'
            end
            # Create a new instance of BasicServer. We are supposed to subclass it
            # but that does not make sense since we would not introduce any new
            # behaviour and we have to subclass Mongrel::HttpHandler so our handler
            # works for Mongrel.
            @xmlrpc_server = Puppet::Network::XMLRPCServer.new
            handlers.each do |name|
                unless handler = Puppet::Network::Handler.handler(name)
                    raise ArgumentError, "Invalid handler #{name}"
                end
                @xmlrpc_server.add_handler(handler.interface, handler.new({}))
            end
        end

        # This method produces the same results as XMLRPC::CGIServer.serve
        # from Ruby's stdlib XMLRPC implementation.
        def process(request, response)
            # Make sure this has been a POST as required for XMLRPC.
            request_method = request.params[Mongrel::Const::REQUEST_METHOD] || Mongrel::Const::GET
            if request_method != "POST"
                response.start(405) { |head, out| out.write("Method Not Allowed") }
                return
            end

            # Make sure the user has sent text/xml data.
            request_mime = request.params["CONTENT_TYPE"] || "text/plain"
            if parse_content_type(request_mime).first != "text/xml"
                response.start(400) { |head, out| out.write("Bad Request") }
                return
            end

            # Make sure there is data in the body at all.
            length = request.params[Mongrel::Const::CONTENT_LENGTH].to_i
            if length <= 0
                response.start(411) { |head, out| out.write("Length Required") }
                return
            end

            # Check the body to be valid.
            if request.body.nil? or request.body.size != length
                response.start(400) { |head, out| out.write("Bad Request") }
                return
            end

            info = client_info(request)

            # All checks above passed through
            response.start(200) do |head, out|
                head["Content-Type"] = "text/xml; charset=utf-8"
                begin
                    out.write(@xmlrpc_server.process(request.body, info))
                rescue => detail
                    puts detail.backtrace
                    raise
                end
            end
        end

        private

        def client_info(request)
            params = request.params
            ip = params["HTTP_X_FORWARDED_FOR"] ? params["HTTP_X_FORWARDED_FOR"].split(',').last.strip : params["REMOTE_ADDR"]
            # JJM #906 The following dn.match regular expression is forgiving
            # enough to match the two Distinguished Name string contents
            # coming from Apache, Pound or other reverse SSL proxies.
            if dn = params[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
                client = dn_matchdata[1].to_str
                valid = (params[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
            else
                begin
                    client = Resolv.getname(ip)
                rescue => detail
                    Puppet.err "Could not resolve #{ip}: #{detail}"
                    client = "unknown"
                end
                valid = false
            end

            info = Puppet::Network::ClientRequest.new(client, ip, valid)

            info
        end

        # Taken from XMLRPC::ParseContentType
        def parse_content_type(str)
            a, *b = str.split(";")
            return a.strip, *b
        end
    end
end