diff --git a/lib/puppet/network/http/rack/rest.rb b/lib/puppet/network/http/rack/rest.rb
index f2ba39336..104751271 100644
--- a/lib/puppet/network/http/rack/rest.rb
+++ b/lib/puppet/network/http/rack/rest.rb
@@ -1,79 +1,79 @@
 require 'puppet/network/http/handler'
 require 'puppet/network/http/rack/httphandler'
 
 class Puppet::Network::HTTP::RackREST < Puppet::Network::HTTP::RackHttpHandler
 
     include Puppet::Network::HTTP::Handler
 
     HEADER_ACCEPT = 'HTTP_ACCEPT'.freeze
     ContentType = 'Content-Type'.freeze
 
     def initialize(args={})
         super()
         initialize_for_puppet(args)
     end
 
     def set_content_type(response, format)
         response[ContentType] = format_to_mime(format)
     end
 
     # produce the body of the response
     def set_response(response, result, status = 200)
         response.status = status
         response.write result
     end
 
     # Retrieve the accept header from the http request.
     def accept_header(request)
         request.env[HEADER_ACCEPT]
     end
 
     # Retrieve the accept header from the http request.
     def content_type_header(request)
-        request.env['HTTP_CONTENT_TYPE']
+        request.content_type
     end
 
     # Return which HTTP verb was used in this request.
     def http_method(request)
         request.request_method
     end
 
     # Return the query params for this request.
     def params(request)
         result = decode_params(request.params)
         result.merge(extract_client_info(request))
     end
 
     # what path was requested? (this is, without any query parameters)
     def path(request)
         request.path
     end
 
     # return the request body
     # request.body has some limitiations, so we need to concat it back
     # into a regular string, which is something puppet can use.
     def body(request)
         body = ''
         request.body.each { |part| body += part }
         body
     end
 
     def extract_client_info(request)
         result = {}
         result[:ip] = request.ip
 
         # if we find SSL info in the headers, use them to get a hostname.
         # try this with :ssl_client_header, which defaults should work for
         # Apache with StdEnvVars.
         if dn = request.env[Puppet[:ssl_client_header]] and dn_matchdata = dn.match(/^.*?CN\s*=\s*(.*)/)
             result[:node] = dn_matchdata[1].to_str
             result[:authenticated] = (request.env[Puppet[:ssl_client_verify_header]] == 'SUCCESS')
         else
             result[:node] = resolve_node(result)
             result[:authenticated] = false
         end
 
         result
     end
 
 end
diff --git a/spec/unit/network/http/rack/rest.rb b/spec/unit/network/http/rack/rest.rb
index 126b30152..e916712f3 100755
--- a/spec/unit/network/http/rack/rest.rb
+++ b/spec/unit/network/http/rack/rest.rb
@@ -1,199 +1,199 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
 require 'puppet/network/http/rack' if Puppet.features.rack?
 require 'puppet/network/http/rack/rest'
 
 describe "Puppet::Network::HTTP::RackREST" do
     confine "Rack is not available" => Puppet.features.rack?
 
     it "should include the Puppet::Network::HTTP::Handler module" do
         Puppet::Network::HTTP::RackREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
     end
 
     describe "when initializing" do
         it "should call the Handler's initialization hook with its provided arguments" do
             Puppet::Network::HTTP::RackREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
             Puppet::Network::HTTP::RackREST.new(:server => "my", :handler => "arguments")
         end
     end
 
     describe "when serving a request" do
         before :all do
             @model_class = stub('indirected model class')
             Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
             @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
         end
 
         before :each do
             @response = Rack::Response.new()
         end
 
         def mk_req(uri, opts = {})
             env = Rack::MockRequest.env_for(uri, opts)
             Rack::Request.new(env)
         end
 
         describe "and using the HTTP Handler interface" do
             it "should return the HTTP_ACCEPT parameter as the accept header" do
                 req = mk_req('/', 'HTTP_ACCEPT' => 'myaccept')
                 @handler.accept_header(req).should == "myaccept"
             end
 
-            it "should return the HTTP_CONTENT_TYPE parameter as the content type header" do
-                req = mk_req('/', 'HTTP_CONTENT_TYPE' => 'mycontent')
+            it "should return the CONTENT_TYPE parameter as the content type header" do
+                req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
                 @handler.content_type_header(req).should == "mycontent"
             end
 
             it "should use the REQUEST_METHOD as the http method" do
                 req = mk_req('/', :method => 'mymethod')
                 @handler.http_method(req).should == "mymethod"
             end
 
             it "should return the request path as the path" do
                 req = mk_req('/foo/bar')
                 @handler.path(req).should == "/foo/bar"
             end
 
             it "should return the request body as the body" do
                 req = mk_req('/foo/bar', :input => 'mybody')
                 @handler.body(req).should == "mybody"
             end
 
             it "should set the response's content-type header when setting the content type" do
                 @header = mock 'header'
                 @response.expects(:header).returns @header
                 @header.expects(:[]=).with('Content-Type', "mytype")
 
                 @handler.set_content_type(@response, "mytype")
             end
 
             it "should set the status and write the body when setting the response for a request" do
                 @response.expects(:status=).with(400)
                 @response.expects(:write).with("mybody")
 
                 @handler.set_response(@response, "mybody", 400)
             end
         end
 
         describe "and determining the request parameters" do
             it "should include the HTTP request parameters, with the keys as symbols" do
                 req = mk_req('/?foo=baz&bar=xyzzy')
                 result = @handler.params(req)
                 result[:foo].should == "baz"
                 result[:bar].should == "xyzzy"
             end
 
             it "should CGI-decode the HTTP parameters" do
                 encoding = CGI.escape("foo bar")
                 req = mk_req("/?foo=#{encoding}")
                 result = @handler.params(req)
                 result[:foo].should == "foo bar"
             end
 
             it "should convert the string 'true' to the boolean" do
                 req = mk_req("/?foo=true")
                 result = @handler.params(req)
                 result[:foo].should be_true
             end
 
             it "should convert the string 'false' to the boolean" do
                 req = mk_req("/?foo=false")
                 result = @handler.params(req)
                 result[:foo].should be_false
             end
 
             it "should convert integer arguments to Integers" do
                 req = mk_req("/?foo=15")
                 result = @handler.params(req)
                 result[:foo].should == 15
             end
 
             it "should convert floating point arguments to Floats" do
                 req = mk_req("/?foo=1.5")
                 result = @handler.params(req)
                 result[:foo].should == 1.5
             end
 
             it "should YAML-load and CGI-decode values that are YAML-encoded" do
                 escaping = CGI.escape(YAML.dump(%w{one two}))
                 req = mk_req("/?foo=#{escaping}")
                 result = @handler.params(req)
                 result[:foo].should == %w{one two}
             end
 
             it "should not allow the client to set the node via the query string" do
                 req = mk_req("/?node=foo")
                 @handler.params(req)[:node].should be_nil
             end
 
             it "should not allow the client to set the IP address via the query string" do
                 req = mk_req("/?ip=foo")
                 @handler.params(req)[:ip].should be_nil
             end
 
             it "should pass the client's ip address to model find" do
                 req = mk_req("/", 'REMOTE_ADDR' => 'ipaddress')
                 @handler.params(req)[:ip].should == "ipaddress"
             end
 
             it "should set 'authenticated' to false if no certificate is present" do
                 req = mk_req('/')
                 @handler.params(req)[:authenticated].should be_false
             end
         end
 
         describe "with pre-validated certificates" do
 
             it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
                 Puppet.settings.stubs(:value).returns "eh"
                 Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
                 req = mk_req('/', "myheader" => "/CN=host.domain.com")
                 @handler.params(req)
             end
 
             it "should retrieve the hostname by matching the certificate parameter" do
                 Puppet.settings.stubs(:value).returns "eh"
                 Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
                 req = mk_req('/', "myheader" => "/CN=host.domain.com")
                 @handler.params(req)[:node].should == "host.domain.com"
             end
 
             it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
                 req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
                 @handler.params(req)
             end
 
             it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
                 req = mk_req('/', "myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
                 @handler.params(req)[:authenticated].should be_true
             end
 
             it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
                 req = mk_req('/', "myheader" => "whatever", "certheader" => "/CN=host.domain.com")
                 @handler.params(req)[:authenticated].should be_false
             end
 
             it "should consider the host unauthenticated if no certificate information is present" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
                 req = mk_req('/', "myheader" => nil, "certheader" => "/CN=host.domain.com")
                 @handler.params(req)[:authenticated].should be_false
             end
 
             it "should resolve the node name with an ip address look-up if no certificate is present" do
                 Puppet.settings.stubs(:value).returns "eh"
                 Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
                 req = mk_req('/', "myheader" => nil)
                 @handler.expects(:resolve_node).returns("host.domain.com")
                 @handler.params(req)[:node].should == "host.domain.com"
             end
         end
     end
 end