diff --git a/acceptance/tests/allow_symlinks_as_config_directories.rb b/acceptance/tests/allow_symlinks_as_config_directories.rb
new file mode 100644
index 000000000..66c6ccca0
--- /dev/null
+++ b/acceptance/tests/allow_symlinks_as_config_directories.rb
@@ -0,0 +1,27 @@
+test_name "Should allow symlinks to directories as configuration directories"
+
+step "Create the test confdir with a link to it"
+confdir = "/tmp/puppet_conf-directory-#{$$}"
+conflink = "/tmp/puppet_conf-symlink-#{$$}"
+
+on agents, "rm -rf #{conflink} #{confdir}"
+
+on agents, "mkdir #{confdir}"
+on agents, "ln -s #{confdir} #{conflink}"
+
+create_remote_file agents, "#{confdir}/puppet.conf", <<CONFFILE
+[main]
+certname = "awesome_certname"
+CONFFILE
+
+manifest = 'notify{"My certname is $clientcert": }'
+
+step "Run Puppet and ensure it used the conf file in the confdir"
+on agents, puppet_apply("--confdir #{conflink}"), :stdin => manifest do
+  assert_match("My certname is awesome_certname", stdout)
+end
+
+step "Check that the symlink and confdir are unchanged"
+on agents, "[ -L #{conflink} ]"
+on agents, "[ -d #{confdir} ]"
+on agents, "[ $(readlink #{conflink}) = #{confdir} ]"
diff --git a/lib/puppet/util/settings/file_setting.rb b/lib/puppet/util/settings/file_setting.rb
index edbab1d0c..776398ef4 100644
--- a/lib/puppet/util/settings/file_setting.rb
+++ b/lib/puppet/util/settings/file_setting.rb
@@ -1,123 +1,124 @@
 require 'puppet/util/settings/setting'
 
 # A file.
 class Puppet::Util::Settings::FileSetting < Puppet::Util::Settings::Setting
   AllowedOwners = %w{root service}
   AllowedGroups = %w{root service}
 
   class SettingError < StandardError; end
 
   attr_accessor :mode, :create
 
   # Should we create files, rather than just directories?
   def create_files?
     create
   end
 
   def group=(value)
     unless AllowedGroups.include?(value)
       identifying_fields = [desc,name,default].compact.join(': ')
       raise SettingError, "Internal error: The :group setting for #{identifying_fields} must be 'service', not '#{value}'"
     end
     @group = value
   end
 
   def group
     return unless @group
     @settings[:group]
   end
 
   def owner=(value)
     unless AllowedOwners.include?(value)
       identifying_fields = [desc,name,default].compact.join(': ')
       raise SettingError, "Internal error: The :owner setting for #{identifying_fields} must be either 'root' or 'service', not '#{value}'"
     end
     @owner = value
   end
 
   def owner
     return unless @owner
     return "root" if @owner == "root" or ! use_service_user?
     @settings[:user]
   end
 
   def use_service_user?
     @settings[:mkusers] or @settings.service_user_available?
   end
 
   # Set the type appropriately.  Yep, a hack.  This supports either naming
   # the variable 'dir', or adding a slash at the end.
   def munge(value)
     # If it's not a fully qualified path...
     if value.is_a?(String) and value !~ /^\$/ and value != 'false'
       # Make it one
       value = File.expand_path(value)
     end
     if value.to_s =~ /\/$/
       @type = :directory
       return value.sub(/\/$/, '')
     end
     value
   end
 
   # Return the appropriate type.
   def type
     value = @settings.value(self.name)
     if @name.to_s =~ /dir/
       return :directory
     elsif value.to_s =~ /\/$/
       return :directory
     elsif value.is_a? String
       return :file
     else
       return nil
     end
   end
 
   # Turn our setting thing into a Puppet::Resource instance.
   def to_resource
     return nil unless type = self.type
 
     path = self.value
 
     return nil unless path.is_a?(String)
 
     # Make sure the paths are fully qualified.
     path = File.expand_path(path)
 
     return nil unless type == :directory or create_files? or File.exist?(path)
     return nil if path =~ /^\/dev/
 
     resource = Puppet::Resource.new(:file, path)
 
     if Puppet[:manage_internal_file_permissions]
       resource[:mode] = self.mode if self.mode
 
       if Puppet.features.root?
         resource[:owner] = self.owner if self.owner
         resource[:group] = self.group if self.group
       end
     end
 
     resource[:ensure] = type
     resource[:loglevel] = :debug
+    resource[:links] = :follow
     resource[:backup] = false
 
     resource.tag(self.section, self.name, "settings")
 
     resource
   end
 
   # Make sure any provided variables look up to something.
   def validate(value)
     return true unless value.is_a? String
     value.scan(/\$(\w+)/) { |name|
       name = $1
       unless @settings.include?(name)
         raise ArgumentError,
           "Settings parameter '#{name}' is undefined"
       end
     }
   end
 end
 
diff --git a/spec/unit/util/settings/file_setting_spec.rb b/spec/unit/util/settings/file_setting_spec.rb
index dcfb6e3b1..1167e971d 100755
--- a/spec/unit/util/settings/file_setting_spec.rb
+++ b/spec/unit/util/settings/file_setting_spec.rb
@@ -1,254 +1,258 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 require 'puppet/util/settings'
 require 'puppet/util/settings/file_setting'
 
 describe Puppet::Util::Settings::FileSetting do
   FileSetting = Puppet::Util::Settings::FileSetting
 
   before do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
   end
 
   describe "when determining whether the service user should be used" do
     before do
       @settings = mock 'settings'
       @settings.stubs(:[]).with(:mkusers).returns false
       @settings.stubs(:service_user_available?).returns true
     end
 
     it "should be true if the service user is available" do
       @settings.expects(:service_user_available?).returns true
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
 
     it "should be true if 'mkusers' is set" do
       @settings.expects(:[]).with(:mkusers).returns true
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
 
     it "should be false if the service user is not available and 'mkusers' is unset" do
       setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
       setting.should be_use_service_user
     end
   end
 
   describe "when setting the owner" do
     it "should allow the file to be owned by root" do
       root_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") }
       root_owner.should_not raise_error
     end
 
     it "should allow the file to be owned by the service user" do
       service_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "service", :desc => "a setting") }
       service_owner.should_not raise_error
     end
 
     it "should allow the ownership of the file to be unspecified" do
       no_owner = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
       no_owner.should_not raise_error
     end
 
     it "should not allow other owners" do
       invalid_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "invalid", :desc => "a setting") }
       invalid_owner.should raise_error(FileSetting::SettingError)
     end
   end
 
   describe "when reading the owner" do
     it "should be root when the setting specifies root" do
       setting = FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting")
       setting.owner.should == "root"
     end
 
     it "should be the owner of the service when the setting specifies service and the service user should be used" do
       settings = mock("settings")
       settings.stubs(:[]).returns "the_service"
 
       setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
       setting.expects(:use_service_user?).returns true
       setting.owner.should == "the_service"
     end
 
     it "should be the root when the setting specifies service and the service user should not be used" do
       settings = mock("settings")
       settings.stubs(:[]).returns "the_service"
 
       setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
       setting.expects(:use_service_user?).returns false
       setting.owner.should == "root"
     end
 
     it "should be nil when the owner is unspecified" do
       FileSetting.new(:settings => mock("settings"), :desc => "a setting").owner.should be_nil
     end
   end
 
   describe "when setting the group" do
     it "should allow the group to be service" do
       service_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "service", :desc => "a setting") }
       service_group.should_not raise_error
     end
 
     it "should allow the group to be unspecified" do
       no_group = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
       no_group.should_not raise_error
     end
 
     it "should not allow invalid groups" do
       invalid_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "invalid", :desc => "a setting") }
       invalid_group.should raise_error(FileSetting::SettingError)
     end
   end
 
   describe "when reading the group" do
     it "should be service when the setting specifies service" do
       setting = FileSetting.new(:settings => mock("settings", :[] => "the_service"), :group => "service", :desc => "a setting")
       setting.group.should == "the_service"
     end
 
     it "should be nil when the group is unspecified" do
       FileSetting.new(:settings => mock("settings"), :desc => "a setting").group.should be_nil
     end
   end
 
   it "should be able to be converted into a resource" do
     FileSetting.new(:settings => mock("settings"), :desc => "eh").should respond_to(:to_resource)
   end
 
   describe "when being converted to a resource" do
     before do
       @settings = mock 'settings'
       @file = Puppet::Util::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :mydir, :section => "mysect")
       @settings.stubs(:value).with(:mydir).returns @basepath
     end
 
     it "should skip files that cannot determine their types" do
       @file.expects(:type).returns nil
       @file.to_resource.should be_nil
     end
 
     it "should skip non-existent files if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
       File.expects(:exist?).with(@basepath).returns false
       @file.to_resource.should be_nil
     end
 
     it "should manage existent files even if 'create_files' is not enabled" do
       @file.expects(:create_files?).returns false
       @file.expects(:type).returns :file
       File.expects(:exist?).with(@basepath).returns true
       @file.to_resource.should be_instance_of(Puppet::Resource)
     end
 
     describe "on POSIX systems", :if => Puppet.features.posix? do
       it "should skip files in /dev" do
         @settings.stubs(:value).with(:mydir).returns "/dev/file"
         @file.to_resource.should be_nil
       end
     end
 
     it "should skip files whose paths are not strings" do
       @settings.stubs(:value).with(:mydir).returns :foo
       @file.to_resource.should be_nil
     end
 
     it "should return a file resource with the path set appropriately" do
       resource = @file.to_resource
       resource.type.should == "File"
       resource.title.should == @basepath
     end
 
     it "should fully qualified returned files if necessary (#795)" do
       @settings.stubs(:value).with(:mydir).returns "myfile"
       @file.to_resource.title.should == File.join(Dir.getwd, "myfile")
     end
 
     it "should set the mode on the file if a mode is provided" do
       @file.mode = 0755
 
       @file.to_resource[:mode].should == 0755
     end
 
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
 
       @file.stubs(:mode).returns(0755)
 
       @file.to_resource[:mode].should == nil
     end
 
     it "should set the owner if running as root and the owner is provided" do
       Puppet.features.expects(:root?).returns true
       @file.stubs(:owner).returns "foo"
       @file.to_resource[:owner].should == "foo"
     end
 
     it "should not set the owner if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
       Puppet.features.stubs(:root?).returns true
       @file.stubs(:owner).returns "foo"
 
       @file.to_resource[:owner].should == nil
     end
 
     it "should set the group if running as root and the group is provided" do
       Puppet.features.expects(:root?).returns true
       @file.stubs(:group).returns "foo"
       @file.to_resource[:group].should == "foo"
     end
 
     it "should not set the group if manage_internal_file_permissions is disabled" do
       Puppet[:manage_internal_file_permissions] = false
       Puppet.features.stubs(:root?).returns true
       @file.stubs(:group).returns "foo"
 
       @file.to_resource[:group].should == nil
     end
 
 
     it "should not set owner if not running as root" do
       Puppet.features.expects(:root?).returns false
       @file.stubs(:owner).returns "foo"
       @file.to_resource[:owner].should be_nil
     end
 
     it "should not set group if not running as root" do
       Puppet.features.expects(:root?).returns false
       @file.stubs(:group).returns "foo"
       @file.to_resource[:group].should be_nil
     end
 
     it "should set :ensure to the file type" do
       @file.expects(:type).returns :directory
       @file.to_resource[:ensure].should == :directory
     end
 
     it "should set the loglevel to :debug" do
       @file.to_resource[:loglevel].should == :debug
     end
 
     it "should set the backup to false" do
       @file.to_resource[:backup].should be_false
     end
 
     it "should tag the resource with the settings section" do
       @file.expects(:section).returns "mysect"
       @file.to_resource.should be_tagged("mysect")
     end
 
     it "should tag the resource with the setting name" do
       @file.to_resource.should be_tagged("mydir")
     end
 
     it "should tag the resource with 'settings'" do
       @file.to_resource.should be_tagged("settings")
     end
+
+    it "should set links to 'follow'" do
+      @file.to_resource[:links].should == :follow
+    end
   end
 end