diff --git a/lib/puppet/util/monkey_patches.rb b/lib/puppet/util/monkey_patches.rb
index a59332504..93d266f8f 100644
--- a/lib/puppet/util/monkey_patches.rb
+++ b/lib/puppet/util/monkey_patches.rb
@@ -1,207 +1,224 @@
 require 'puppet/util'
 module Puppet::Util::MonkeyPatches
 end
 
 unless defined? JRUBY_VERSION
   Process.maxgroups = 1024
 end
 
 module RDoc
   def self.caller(skip=nil)
     in_gem_wrapper = false
     Kernel.caller.reject { |call|
       in_gem_wrapper ||= call =~ /#{Regexp.escape $0}:\d+:in `load'/
     }
   end
 end
 
 
 require "yaml"
 require "puppet/util/zaml.rb"
 
 class Symbol
   def to_zaml(z)
     z.emit("!ruby/sym ")
     to_s.to_zaml(z)
   end
   def <=> (other)
     self.to_s <=> other.to_s
   end unless method_defined? "<=>"
 end
 
 [Object, Exception, Integer, Struct, Date, Time, Range, Regexp, Hash, Array, Float, String, FalseClass, TrueClass, Symbol, NilClass, Class].each { |cls|
   cls.class_eval do
     def to_yaml(ignored=nil)
       ZAML.dump(self)
     end
   end
 }
 
 def YAML.dump(*args)
   ZAML.dump(*args)
 end
 
 #
 # Workaround for bug in MRI 1.8.7, see
 #     http://redmine.ruby-lang.org/issues/show/2708
 # for details
 #
 if RUBY_VERSION == '1.8.7'
   class NilClass
     def closed?
       true
     end
   end
 end
 
 class Object
   # ActiveSupport 2.3.x mixes in a dangerous method
   # that can cause rspec to fork bomb
   # and other strange things like that.
   def daemonize
     raise NotImplementedError, "Kernel.daemonize is too dangerous, please don't try to use it."
   end
 end
 
 # Workaround for yaml_initialize, which isn't supported before Ruby
 # 1.8.3.
 if RUBY_VERSION == '1.8.1' || RUBY_VERSION == '1.8.2'
   YAML.add_ruby_type( /^object/ ) { |tag, val|
     type, obj_class = YAML.read_type_class( tag, Object )
     r = YAML.object_maker( obj_class, val )
     if r.respond_to? :yaml_initialize
       r.instance_eval { instance_variables.each { |name| remove_instance_variable name } }
       r.yaml_initialize(tag, val)
     end
     r
   }
 end
 
 class Array
   # Ruby < 1.8.7 doesn't have this method but we use it in tests
   def combination(num)
     return [] if num < 0 || num > size
     return [[]] if num == 0
     return map{|e| [e] } if num == 1
     tmp = self.dup
     self[0, size - (num - 1)].inject([]) do |ret, e|
       tmp.shift
       ret += tmp.combination(num - 1).map{|a| a.unshift(e) }
     end
   end unless method_defined? :combination
 
   alias :count :length unless method_defined? :count
 end
 
 
 class Symbol
   def to_proc
     Proc.new { |*args| args.shift.__send__(self, *args) }
   end unless method_defined? :to_proc
 end
 
 class String
   unless method_defined? :lines
     require 'puppet/util/monkey_patches/lines'
     include Puppet::Util::MonkeyPatches::Lines
   end
 end
 
+require 'fcntl'
 class IO
   unless method_defined? :lines
     require 'puppet/util/monkey_patches/lines'
     include Puppet::Util::MonkeyPatches::Lines
   end
 
   def self.binread(name, length = nil, offset = 0)
     File.open(name, 'rb') do |f|
       f.seek(offset) if offset > 0
       f.read(length)
     end
   end unless singleton_methods.include?(:binread)
 
-  def self.binwrite(name, string, offset = 0)
-    File.open(name, 'wb') do |f|
-      f.write(offset > 0 ? string[offset..-1] : string)
+  def self.binwrite(name, string, offset = nil)
+    # Determine if we should truncate or not.  Since the truncate method on a
+    # file handle isn't implemented on all platforms, safer to do this in what
+    # looks like the libc interface - which is usually pretty robust.
+    # --daniel 2012-03-11
+    mode = Fcntl::O_CREAT | Fcntl::O_WRONLY | (offset.nil? ? Fcntl::O_TRUNC : 0)
+    IO.open(IO::sysopen(name, mode)) do |f|
+      # ...seek to our desired offset, then write the bytes.  Don't try to
+      # seek past the start of the file, eh, because who knows what platform
+      # would legitimately blow up if we did that.
+      #
+      # Double-check the positioning, too, since destroying data isn't my idea
+      # of a good time. --daniel 2012-03-11
+      target = [0, offset.to_i].max
+      unless (landed = f.sysseek(target, IO::SEEK_SET)) == target
+        raise "unable to seek to target offset #{target} in #{name}: got to #{landed}"
+      end
+
+      f.syswrite(string)
     end
   end unless singleton_methods.include?(:binwrite)
 end
 
 class Range
   def intersection(other)
     raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
     return unless other === self.first || self === other.first
 
     start = [self.first, other.first].max
     if self.exclude_end? && self.last <= other.last
       start ... self.last
     elsif other.exclude_end? && self.last >= other.last
       start ... other.last
     else
       start .. [ self.last, other.last ].min
     end
   end unless method_defined? :intersection
 
   alias_method :&, :intersection unless method_defined? :&
 end
 
 # Ruby 1.8.5 doesn't have tap
 module Kernel
   def tap
     yield(self)
     self
   end unless method_defined?(:tap)
 end
 
 
 ########################################################################
 # The return type of `instance_variables` changes between Ruby 1.8 and 1.9
 # releases; it used to return an array of strings in the form "@foo", but
 # now returns an array of symbols in the form :@foo.
 #
 # Nothing else in the stack cares which form you get - you can pass the
 # string or symbol to things like `instance_variable_set` and they will work
 # transparently.
 #
 # Having the same form in all releases of Puppet is a win, though, so we
 # pick a unification and enforce than on all releases.  That way developers
 # who do set math on them (eg: for YAML rendering) don't have to handle the
 # distinction themselves.
 #
 # In the sane tradition, we bring older releases into conformance with newer
 # releases, so we return symbols rather than strings, to be more like the
 # future versions of Ruby are.
 #
 # We also carefully support reloading, by only wrapping when we don't
 # already have the original version of the method aliased away somewhere.
 if RUBY_VERSION[0,3] == '1.8'
   unless Object.respond_to?(:puppet_original_instance_variables)
 
     # Add our wrapper to the method.
     class Object
       alias :puppet_original_instance_variables :instance_variables
 
       def instance_variables
         puppet_original_instance_variables.map(&:to_sym)
       end
     end
 
     # The one place that Ruby 1.8 assumes something about the return format of
     # the `instance_variables` method is actually kind of odd, because it uses
     # eval to get at instance variables of another object.
     #
     # This takes the original code and applies replaces instance_eval with
     # instance_variable_get through it.  All other bugs in the original (such
     # as equality depending on the instance variables having the same order
     # without any promise from the runtime) are preserved. --daniel 2012-03-11
     require 'resolv'
     class Resolv::DNS::Resource
       def ==(other) # :nodoc:
         return self.class == other.class &&
           self.instance_variables == other.instance_variables &&
           self.instance_variables.collect {|name| self.instance_variable_get name} ==
           other.instance_variables.collect {|name| other.instance_variable_get name}
       end
     end
   end
 end
diff --git a/spec/unit/util/monkey_patches_spec.rb b/spec/unit/util/monkey_patches_spec.rb
index b3ff331b7..9757a4a7d 100755
--- a/spec/unit/util/monkey_patches_spec.rb
+++ b/spec/unit/util/monkey_patches_spec.rb
@@ -1,187 +1,214 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/monkey_patches'
 
 
 
 describe "yaml deserialization" do
   it "should call yaml_initialize when deserializing objects that have that method defined" do
     class Puppet::TestYamlInitializeClass
       attr_reader :foo
 
       def yaml_initialize(tag, var)
         var.should == {'foo' => 100}
         instance_variables.should == []
         @foo = 200
       end
     end
 
     obj = YAML.load("--- !ruby/object:Puppet::TestYamlInitializeClass\n  foo: 100")
     obj.foo.should == 200
   end
 
   it "should not call yaml_initialize if not defined" do
     class Puppet::TestYamlNonInitializeClass
       attr_reader :foo
     end
 
     obj = YAML.load("--- !ruby/object:Puppet::TestYamlNonInitializeClass\n  foo: 100")
     obj.foo.should == 100
   end
 end
 
 # In Ruby > 1.8.7 this is a builtin, otherwise we monkey patch the method in
 describe "Array#combination" do
   it "should fail if wrong number of arguments given" do
     lambda { [1,2,3].combination() }.should raise_error(ArgumentError, /wrong number/)
     lambda { [1,2,3].combination(1,2) }.should raise_error(ArgumentError, /wrong number/)
   end
 
   it "should return an empty array if combo size than array size or negative" do
     [1,2,3].combination(4).to_a.should == []
     [1,2,3].combination(-1).to_a.should == []
   end
 
   it "should return an empty array with an empty array if combo size == 0" do
     [1,2,3].combination(0).to_a.should == [[]]
   end
 
   it "should all provide all combinations of size passed in" do
     [1,2,3,4].combination(1).to_a.should == [[1], [2], [3], [4]]
     [1,2,3,4].combination(2).to_a.should == [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
     [1,2,3,4].combination(3).to_a.should == [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
   end
 end
 
 describe IO do
   include PuppetSpec::Files
 
   let(:file) { tmpfile('io-binary') }
   let(:content) { "\x01\x02\x03\x04" }
 
   describe "::binread" do
     it "should read in binary mode" do
       File.open(file, 'wb') {|f| f.write(content) }
       IO.binread(file).should == content
     end
 
     it "should read with a length and offset" do
       offset = 1
       length = 2
       File.open(file, 'wb') {|f| f.write(content) }
       IO.binread(file, length, offset).should == content[offset..length]
     end
 
     it "should raise an error if the file doesn't exist" do
       expect { IO.binread('/path/does/not/exist') }.to raise_error(Errno::ENOENT)
     end
   end
 
   describe "::binwrite" do
     it "should write in binary mode" do
       IO.binwrite(file, content).should == content.length
       File.open(file, 'rb') {|f| f.read.should == content }
     end
 
-    it "should write using an offset" do
-      offset = 1
-      IO.binwrite(file, content, offset).should == content.length - offset
-      File.open(file, 'rb') {|f| f.read.should == content[offset..-1] }
+    (0..10).each do |offset|
+      it "should write correctly using an offset of #{offset}" do
+        IO.binwrite(file, content, offset).should == content.length
+        File.open(file, 'rb') {|f| f.read.should == ("\x00" * offset) + content }
+      end
     end
 
-    it "should raise an error if the file doesn't exist" do
+    context "truncation" do
+      let :input do "welcome to paradise, population ... YOU!" end
+      before :each do IO.binwrite(file, input) end
+
+      it "should truncate if no offset is given" do
+        IO.binwrite(file, "boo").should == 3
+        File.read(file).should == "boo"
+      end
+
+      (0..10).each do |offset|
+        it "should not truncate if an offset of #{offset} is given" do
+          expect = input.dup
+          expect[offset, 3] = "BAM"
+
+          IO.binwrite(file, "BAM", offset).should == 3
+          File.read(file).should == expect
+        end
+      end
+
+      it "should pad with NULL bytes if writing past EOF without truncate" do
+        expect = input + ("\x00" * 4) + "BAM"
+        IO.binwrite(file, "BAM", input.length + 4).should == 3
+        File.read(file).should == expect
+      end
+    end
+
+    it "should raise an error if the directory containing the file doesn't exist" do
       expect { IO.binwrite('/path/does/not/exist', 'foo') }.to raise_error(Errno::ENOENT)
     end
   end
 end
 
 describe Range do
   def do_test( range, other, expected )
     result = range.intersection(other)
     result.should == expected
   end
 
   it "should return expected ranges for iterable things" do
     iterable_tests = {
       1  .. 4   => nil,          # before
       11 .. 15  => nil,          # after
       1  .. 6   => 5  ..  6,     # overlap_begin
       9  .. 15  => 9  ..  10,    # overlap_end
       1  .. 5   => 5  ..  5,     # overlap_begin_edge
       10 .. 15  => 10 ..  10,    # overlap_end_edge
       5  .. 10  => 5  ..  10,    # overlap_all
       6  .. 9   => 6  ..  9,     # overlap_inner
 
       1 ... 5   => nil,          # before             (exclusive range)
       1 ... 7   => 5  ... 7,     # overlap_begin      (exclusive range)
       1 ... 6   => 5  ... 6,     # overlap_begin_edge (exclusive range)
       5 ... 11  => 5  ..  10,    # overlap_all        (exclusive range)
       6 ... 10  => 6  ... 10,    # overlap_inner      (exclusive range)
     }
 
     iterable_tests.each do |other, expected|
       do_test( 5..10, other, expected )
       do_test( other, 5..10, expected )
     end
   end
 
   it "should return expected ranges for noniterable things" do
     inclusive_base_case = {
       1.to_f  .. 4.to_f   => nil,                   # before
       11.to_f .. 15.to_f  => nil,                   # after
       1.to_f  .. 6.to_f   => 5.to_f  ..  6.to_f,    # overlap_begin
       9.to_f  .. 15.to_f  => 9.to_f  ..  10.to_f,   # overlap_end
       1.to_f  .. 5.to_f   => 5.to_f  ..  5.to_f,    # overlap_begin_edge
       10.to_f .. 15.to_f  => 10.to_f ..  10.to_f,   # overlap_end_edge
       5.to_f  .. 10.to_f  => 5.to_f  ..  10.to_f,   # overlap_all
       6.to_f  .. 9.to_f   => 6.to_f  ..  9.to_f,    # overlap_inner
 
       1.to_f ... 5.to_f   => nil,                   # before             (exclusive range)
       1.to_f ... 7.to_f   => 5.to_f  ... 7.to_f,    # overlap_begin      (exclusive range)
       1.to_f ... 6.to_f   => 5.to_f  ... 6.to_f,    # overlap_begin_edge (exclusive range)
       5.to_f ... 11.to_f  => 5.to_f  ..  10.to_f,   # overlap_all        (exclusive range)
       6.to_f ... 10.to_f  => 6.to_f  ... 10.to_f,   # overlap_inner      (exclusive range)
     }
 
     inclusive_base_case.each do |other, expected|
       do_test( 5.to_f..10.to_f, other, expected )
       do_test( other, 5.to_f..10.to_f, expected )
     end
 
     exclusive_base_case = {
       1.to_f  .. 4.to_f   => nil,                   # before
       11.to_f .. 15.to_f  => nil,                   # after
       1.to_f  .. 6.to_f   => 5.to_f  ..  6.to_f,    # overlap_begin
       9.to_f  .. 15.to_f  => 9.to_f  ... 10.to_f,   # overlap_end
       1.to_f  .. 5.to_f   => 5.to_f  ..  5.to_f,    # overlap_begin_edge
       10.to_f .. 15.to_f  => nil,                   # overlap_end_edge
       5.to_f  .. 10.to_f  => 5.to_f  ... 10.to_f,   # overlap_all
       6.to_f  .. 9.to_f   => 6.to_f  ..  9.to_f,    # overlap_inner
 
       1.to_f ... 5.to_f   => nil,                   # before             (exclusive range)
       1.to_f ... 7.to_f   => 5.to_f  ... 7.to_f,    # overlap_begin      (exclusive range)
       1.to_f ... 6.to_f   => 5.to_f  ... 6.to_f,    # overlap_begin_edge (exclusive range)
       5.to_f ... 11.to_f  => 5.to_f  ... 10.to_f,   # overlap_all        (exclusive range)
       6.to_f ... 10.to_f  => 6.to_f  ... 10.to_f,   # overlap_inner      (exclusive range)
     }
 
     exclusive_base_case.each do |other, expected|
       do_test( 5.to_f...10.to_f, other, expected )
       do_test( other, 5.to_f...10.to_f, expected )
     end
   end
 end
 
 
 describe Object, "#instance_variables" do
   it "should work with no instance variables" do
     Object.new.instance_variables.should == []
   end
 
   it "should return symbols, not strings" do
     o = Object.new
     ["@foo", "@bar", "@baz"].map {|x| o.instance_variable_set(x, x) }
     o.instance_variables.should =~ [:@foo, :@bar, :@baz]
   end
 end