This patch is an update of Data-Dumper to version 2.154 that comes from:

http://search.cpan.org/~smueller/Data-Dumper-2.154/Dumper.pm

diff -ur --new-file perl-5.16.3/dist/Data-Dumper/Changes perl-5.16.3/dist/Data-Dumper/Changes

--- perl-5.16.3/dist/Data-Dumper/Changes	2014-09-29 13:45:01.142205831 -0400

+++ perl-5.16.3/dist/Data-Dumper/Changes	2014-09-29 13:47:39.521852778 -0400

@@ -1,11 +1,104 @@

 =head1 NAME

-HISTORY - public release history for Data::Dumper

+Changes - public release history for Data::Dumper

 =head1 DESCRIPTION

 =over 8

+=item 2.154 (Sep 18 2014)

+

+Most notably, this release fixes CVE-2014-4330:

+

+  Don't recurse infinitely in Data::Dumper

+

+  Add a configuration variable/option to limit recursion when

+  dumpng deep data structures.

+  [...]

+  This patch addresses CVE-2014-4330.  This bug was found and

+  reported by: LSE Leading Security Experts GmbH employee Markus

+  Vervier.

+

+On top of that, there are several minor big fixes and improvements,

+see "git log" if the core perl distribution for details.

+

+=item 2.151 (Mar 7 2014)

+

+A "useqq" implementation for the XS version of Data::Dumper.

+

+Better compatibility wrt. hash key quoting between PP and XS

+versions of Data::Dumper.

+

+EBCDIC fixes.

+

+64bit safety fixes (for very large arrays).

+

+Build fixes for threaded perls.

+

+clang warning fixes.

+

+Warning fixes in tests on older perls.

+

+Typo fixes in documentation.

+

+=item 2.145 (Mar 15 2013)

+

+Test refactoring and fixing wide and far.

+

+Various old-perl compat fixes.

+

+=item 2.143 (Feb 26 2013)

+

+Address vstring related test failures on 5.8: Skip tests for

+obscure case.

+

+Major improvements to test coverage and significant refactoring.

+

+Make Data::Dumper XS ignore Freezer return value. Fixes RT #116364.

+

+Change call of isALNUM to equivalent but more clearly named isWORDCHAR

+

+=item 2.139 (Dec 12 2012)

+

+Supply an explicit dynamic_config => 0 in META

+

+Properly list BUILD_REQUIRES prereqs (P5-RT#116028)

+

+Some optimizations. Removed useless "register" declarations.

+

+=item 2.136 (Oct 04 2012)

+

+Promote to stable release.

+

+Drop some "register" declarations.

+

+=item 2.135_07 (Aug 06 2012)

+

+Use the new utf8 to code point functions - fixing a potential

+reading buffer overrun.

+

+Data::Dumper: Sparseseen option to avoid building much of the seen

+hash: This has been measured to, in some cases, provide a 50% speed-up

+

+Dumper.xs: Avoid scan_vstring on 5.17.3 and up

+

+Avoid a warning from clang when compiling Data::Dumper

+

+Fix DD's dumping of qr|\/|

+

+Data::Dumper's Perl implementation was not working with overloaded

+blessed globs, which it thought were strings.

+

+Allow Data::Dumper to load on miniperl

+

+=item 2.135_02 (Dec 29 2011)

+

+Makes DD dump *{''} properly.

+

+[perl #101162] DD support for vstrings:

+Support for vstrings to Data::Dumper, in both Perl and XS

+implementations.

+

 =item 2.135_01 (Dec 19 2011)

 Make Data::Dumper UTF8- and null-clean with GVs.

diff -ur --new-file perl-5.16.3/dist/Data-Dumper/Dumper.pm perl-5.16.3/dist/Data-Dumper/Dumper.pm

--- perl-5.16.3/dist/Data-Dumper/Dumper.pm	2014-09-29 13:45:01.132167061 -0400

+++ perl-5.16.3/dist/Data-Dumper/Dumper.pm	2014-09-29 13:47:39.522908324 -0400

@@ -10,8 +10,8 @@

 package Data::Dumper;

 BEGIN {

-    $VERSION = '2.135_06'; # Don't forget to set version and release

-}			   # date in POD!

+    $VERSION = '2.154'; # Don't forget to set version and release

+}               # date in POD below!

 #$| = 1;

@@ -30,9 +30,9 @@

     # XSLoader should be attempted to load, or the pure perl flag

     # toggled on load failure.

     eval {

-	require XSLoader;

-	XSLoader::load( 'Data::Dumper' );

-	1

+        require XSLoader;

+        XSLoader::load( 'Data::Dumper' );

+        1

     }

     or $Useperl = 1;

 }

@@ -55,6 +55,8 @@

 $Useperl    = 0         unless defined $Useperl;

 $Sortkeys   = 0         unless defined $Sortkeys;

 $Deparse    = 0         unless defined $Deparse;

+$Sparseseen = 0         unless defined $Sparseseen;

+$Maxrecurse = 1000      unless defined $Maxrecurse;

 #

 # expects an arrayref of values to be dumped.

@@ -65,36 +67,38 @@

 sub new {

   my($c, $v, $n) = @_;

-  croak "Usage:  PACKAGE->new(ARRAYREF, [ARRAYREF])" 

+  croak "Usage:  PACKAGE->new(ARRAYREF, [ARRAYREF])"

     unless (defined($v) && (ref($v) eq 'ARRAY'));

   $n = [] unless (defined($n) && (ref($n) eq 'ARRAY'));

-  my($s) = { 

-             level      => 0,           # current recursive depth

-	     indent     => $Indent,     # various styles of indenting

-	     pad	=> $Pad,        # all lines prefixed by this string

-	     xpad       => "",          # padding-per-level

-	     apad       => "",          # added padding for hash keys n such

-	     sep        => "",          # list separator

-	     pair	=> $Pair,	# hash key/value separator: defaults to ' => '

-	     seen       => {},          # local (nested) refs (id => [name, val])

-	     todump     => $v,          # values to dump []

-	     names      => $n,          # optional names for values []

-	     varname    => $Varname,    # prefix to use for tagging nameless ones

-             purity     => $Purity,     # degree to which output is evalable

-             useqq 	=> $Useqq,      # use "" for strings (backslashitis ensues)

-             terse 	=> $Terse,      # avoid name output (where feasible)

-             freezer	=> $Freezer,    # name of Freezer method for objects

-             toaster	=> $Toaster,    # name of method to revive objects

-             deepcopy	=> $Deepcopy,   # dont cross-ref, except to stop recursion

-             quotekeys	=> $Quotekeys,  # quote hash keys

-             'bless'	=> $Bless,	# keyword to use for "bless"

-#	     expdepth   => $Expdepth,   # cutoff depth for explicit dumping

-	     maxdepth	=> $Maxdepth,   # depth beyond which we give up

-	     useperl    => $Useperl,    # use the pure Perl implementation

-	     sortkeys   => $Sortkeys,   # flag or filter for sorting hash keys

-	     deparse	=> $Deparse,	# use B::Deparse for coderefs

-	   };

+  my($s) = {

+        level      => 0,           # current recursive depth

+        indent     => $Indent,     # various styles of indenting

+        pad        => $Pad,        # all lines prefixed by this string

+        xpad       => "",          # padding-per-level

+        apad       => "",          # added padding for hash keys n such

+        sep        => "",          # list separator

+        pair       => $Pair,    # hash key/value separator: defaults to ' => '

+        seen       => {},          # local (nested) refs (id => [name, val])

+        todump     => $v,          # values to dump []

+        names      => $n,          # optional names for values []

+        varname    => $Varname,    # prefix to use for tagging nameless ones

+        purity     => $Purity,     # degree to which output is evalable

+        useqq      => $Useqq,      # use "" for strings (backslashitis ensues)

+        terse      => $Terse,      # avoid name output (where feasible)

+        freezer    => $Freezer,    # name of Freezer method for objects

+        toaster    => $Toaster,    # name of method to revive objects

+        deepcopy   => $Deepcopy,   # do not cross-ref, except to stop recursion

+        quotekeys  => $Quotekeys,  # quote hash keys

+        'bless'    => $Bless,    # keyword to use for "bless"

+#        expdepth   => $Expdepth,   # cutoff depth for explicit dumping

+        maxdepth   => $Maxdepth,   # depth beyond which we give up

+	maxrecurse => $Maxrecurse, # depth beyond which we abort

+        useperl    => $Useperl,    # use the pure Perl implementation

+        sortkeys   => $Sortkeys,   # flag or filter for sorting hash keys

+        deparse    => $Deparse,    # use B::Deparse for coderefs

+        noseen     => $Sparseseen, # do not populate the seen hash unless necessary

+       };

   if ($Indent > 0) {

     $s->{xpad} = "  ";

@@ -147,21 +151,26 @@

     init_refaddr_format();

     my($k, $v, $id);

     while (($k, $v) = each %$g) {

-      if (defined $v and ref $v) {

-	$id = format_refaddr($v);

-	if ($k =~ /^[*](.*)$/) {

-	  $k = (ref $v eq 'ARRAY') ? ( "\\\@" . $1 ) :

-	       (ref $v eq 'HASH')  ? ( "\\\%" . $1 ) :

-	       (ref $v eq 'CODE')  ? ( "\\\&" . $1 ) :

-				     (   "\$" . $1 ) ;

-	}

-	elsif ($k !~ /^\$/) {

-	  $k = "\$" . $k;

-	}

-	$s->{seen}{$id} = [$k, $v];

+      if (defined $v) {

+        if (ref $v) {

+          $id = format_refaddr($v);

+          if ($k =~ /^[*](.*)$/) {

+            $k = (ref $v eq 'ARRAY') ? ( "\\\@" . $1 ) :

+                 (ref $v eq 'HASH')  ? ( "\\\%" . $1 ) :

+                 (ref $v eq 'CODE')  ? ( "\\\&" . $1 ) :

+                 (   "\$" . $1 ) ;

+          }

+          elsif ($k !~ /^\$/) {

+            $k = "\$" . $k;

+          }

+          $s->{seen}{$id} = [$k, $v];

+        }

+        else {

+          carp "Only refs supported, ignoring non-ref item \$$k";

+        }

       }

       else {

-	carp "Only refs supported, ignoring non-ref item \$$k";

+        carp "Value of ref must be defined; ignoring undefined item \$$k";

       }

     }

     return $s;

@@ -176,9 +185,14 @@

 #

 sub Values {

   my($s, $v) = @_;

-  if (defined($v) && (ref($v) eq 'ARRAY'))  {

-    $s->{todump} = [@$v];        # make a copy

-    return $s;

+  if (defined($v)) {

+    if (ref($v) eq 'ARRAY')  {

+      $s->{todump} = [@$v];        # make a copy

+      return $s;

+    }

+    else {

+      croak "Argument to Values, if provided, must be array ref";

+    }

   }

   else {

     return @{$s->{todump}};

@@ -190,9 +204,14 @@

 #

 sub Names {

   my($s, $n) = @_;

-  if (defined($n) && (ref($n) eq 'ARRAY'))  {

-    $s->{names} = [@$n];         # make a copy

-    return $s;

+  if (defined($n)) {

+    if (ref($n) eq 'ARRAY') {

+      $s->{names} = [@$n];         # make a copy

+      return $s;

+    }

+    else {

+      croak "Argument to Names, if provided, must be array ref";

+    }

   }

   else {

     return @{$s->{names}};

@@ -203,9 +222,8 @@

 sub Dump {

     return &Dumpxs

-	unless $Data::Dumper::Useperl || (ref($_[0]) && $_[0]->{useperl}) ||

-	       $Data::Dumper::Useqq   || (ref($_[0]) && $_[0]->{useqq}) ||

-	       $Data::Dumper::Deparse || (ref($_[0]) && $_[0]->{deparse});

+    unless $Data::Dumper::Useperl || (ref($_[0]) && $_[0]->{useperl}) ||

+           $Data::Dumper::Deparse || (ref($_[0]) && $_[0]->{deparse});

     return &Dumpperl;

 }

@@ -223,28 +241,9 @@

   $s = $s->new(@_) unless ref $s;

   for $val (@{$s->{todump}}) {

-    my $out = "";

     @post = ();

     $name = $s->{names}[$i++];

-    if (defined $name) {

-      if ($name =~ /^[*](.*)$/) {

-	if (defined $val) {

-	  $name = (ref $val eq 'ARRAY') ? ( "\@" . $1 ) :

-		  (ref $val eq 'HASH')  ? ( "\%" . $1 ) :

-		  (ref $val eq 'CODE')  ? ( "\*" . $1 ) :

-					  ( "\$" . $1 ) ;

-	}

-	else {

-	  $name = "\$" . $1;

-	}

-      }

-      elsif ($name !~ /^\$/) {

-	$name = "\$" . $name;

-      }

-    }

-    else {

-      $name = "\$" . $s->{varname} . $i;

-    }

+    $name = $s->_refine_name($name, $val, $i);

     my $valstr;

     {

@@ -254,9 +253,7 @@

     }

     $valstr = "$name = " . $valstr . ';' if @post or !$s->{terse};

-    $out .= $s->{pad} . $valstr . $s->{sep};

-    $out .= $s->{pad} . join(';' . $s->{sep} . $s->{pad}, @post) 

-      . ';' . $s->{sep} if @post;

+    my $out = $s->_compose_out($valstr, \@post);

     push @out, $out;

   }

@@ -282,8 +279,7 @@

 #

 sub _dump {

   my($s, $val, $name) = @_;

-  my($sname);

-  my($out, $realpack, $realtype, $type, $ipad, $id, $blesspad);

+  my($out, $type, $id, $sname);

   $type = ref $val;

   $out = "";

@@ -300,65 +296,70 @@

     }

     require Scalar::Util;

-    $realpack = Scalar::Util::blessed($val);

-    $realtype = $realpack ? Scalar::Util::reftype($val) : ref $val;

+    my $realpack = Scalar::Util::blessed($val);

+    my $realtype = $realpack ? Scalar::Util::reftype($val) : ref $val;

     $id = format_refaddr($val);

-    # if it has a name, we need to either look it up, or keep a tab

-    # on it so we know when we hit it later

-    if (defined($name) and length($name)) {

-      # keep a tab on it so that we dont fall into recursive pit

-      if (exists $s->{seen}{$id}) {

-#	if ($s->{expdepth} < $s->{level}) {

-	  if ($s->{purity} and $s->{level} > 0) {

-	    $out = ($realtype eq 'HASH')  ? '{}' :

-	      ($realtype eq 'ARRAY') ? '[]' :

-		'do{my $o}' ;

-	    push @post, $name . " = " . $s->{seen}{$id}[0];

-	  }

-	  else {

-	    $out = $s->{seen}{$id}[0];

-	    if ($name =~ /^([\@\%])/) {

-	      my $start = $1;

-	      if ($out =~ /^\\$start/) {

-		$out = substr($out, 1);

-	      }

-	      else {

-		$out = $start . '{' . $out . '}';

-	      }

-	    }

-          }

-	  return $out;

-#        }

+    # Note: By this point $name is always defined and of non-zero length.

+    # Keep a tab on it so that we do not fall into recursive pit.

+    if (exists $s->{seen}{$id}) {

+      if ($s->{purity} and $s->{level} > 0) {

+        $out = ($realtype eq 'HASH')  ? '{}' :

+               ($realtype eq 'ARRAY') ? '[]' :

+               'do{my $o}' ;

+        push @post, $name . " = " . $s->{seen}{$id}[0];

       }

       else {

-        # store our name

-        $s->{seen}{$id} = [ (($name =~ /^[@%]/)     ? ('\\' . $name ) :

-			     ($realtype eq 'CODE' and

-			      $name =~ /^[*](.*)$/) ? ('\\&' . $1 )   :

-			     $name          ),

-			    $val ];

+        $out = $s->{seen}{$id}[0];

+        if ($name =~ /^([\@\%])/) {

+          my $start = $1;

+          if ($out =~ /^\\$start/) {

+            $out = substr($out, 1);

+          }

+          else {

+            $out = $start . '{' . $out . '}';

+          }

+        }

       }

+      return $out;

+    }

+    else {

+      # store our name

+      $s->{seen}{$id} = [ (

+          ($name =~ /^[@%]/)

+            ? ('\\' . $name )

+            : ($realtype eq 'CODE' and $name =~ /^[*](.*)$/)

+              ? ('\\&' . $1 )

+              : $name

+        ), $val ];

     }

-    my $no_bless = 0; 

+    my $no_bless = 0;

     my $is_regex = 0;

     if ( $realpack and ($] >= 5.009005 ? re::is_regexp($val) : $realpack eq 'Regexp') ) {

         $is_regex = 1;

         $no_bless = $realpack eq 'Regexp';

     }

-    # If purity is not set and maxdepth is set, then check depth: 

+    # If purity is not set and maxdepth is set, then check depth:

     # if we have reached maximum depth, return the string

     # representation of the thing we are currently examining

-    # at this depth (i.e., 'Foo=ARRAY(0xdeadbeef)'). 

+    # at this depth (i.e., 'Foo=ARRAY(0xdeadbeef)').

     if (!$s->{purity}

-	and $s->{maxdepth} > 0

-	and $s->{level} >= $s->{maxdepth})

+      and defined($s->{maxdepth})

+      and $s->{maxdepth} > 0

+      and $s->{level} >= $s->{maxdepth})

     {

       return qq['$val'];

     }

+    # avoid recursing infinitely [perl #122111]

+    if ($s->{maxrecurse} > 0

+        and $s->{level} >= $s->{maxrecurse}) {

+        die "Recursion limit of $s->{maxrecurse} exceeded";

+    }

+

     # we have a blessed ref

+    my ($blesspad);

     if ($realpack and !$no_bless) {

       $out = $s->{'bless'} . '( ';

       $blesspad = $s->{apad};

@@ -366,131 +367,136 @@

     }

     $s->{level}++;

-    $ipad = $s->{xpad} x $s->{level};

+    my $ipad = $s->{xpad} x $s->{level};

     if ($is_regex) {

         my $pat;

-        # This really sucks, re:regexp_pattern is in ext/re/re.xs and not in 

-        # universal.c, and even worse we cant just require that re to be loaded

-        # we *have* to use() it. 

-        # We should probably move it to universal.c for 5.10.1 and fix this.

-        # Currently we only use re::regexp_pattern when the re is blessed into another

-        # package. This has the disadvantage of meaning that a DD dump won't round trip

-        # as the pattern will be repeatedly wrapped with the same modifiers.

-        # This is an aesthetic issue so we will leave it for now, but we could use

-        # regexp_pattern() in list context to get the modifiers separately.

-        # But since this means loading the full debugging engine in process we wont

-        # bother unless its necessary for accuracy.

-        if (($realpack ne 'Regexp') && defined(*re::regexp_pattern{CODE})) {

-            $pat = re::regexp_pattern($val);

-        } else {

-            $pat = "$val";

+        my $flags = "";

+        if (defined(*re::regexp_pattern{CODE})) {

+          ($pat, $flags) = re::regexp_pattern($val);

+        }

+        else {

+          $pat = "$val";

         }

         $pat =~ s <(\\.)|/> { $1 || '\\/' }ge;

-        $out .= "qr/$pat/";

+        $out .= "qr/$pat/$flags";

     }

     elsif ($realtype eq 'SCALAR' || $realtype eq 'REF'

-	|| $realtype eq 'VSTRING') {

+    || $realtype eq 'VSTRING') {

       if ($realpack) {

-	$out .= 'do{\\(my $o = ' . $s->_dump($$val, "\${$name}") . ')}';

+        $out .= 'do{\\(my $o = ' . $s->_dump($$val, "\${$name}") . ')}';

       }

       else {

-	$out .= '\\' . $s->_dump($$val, "\${$name}");

+        $out .= '\\' . $s->_dump($$val, "\${$name}");

       }

     }

     elsif ($realtype eq 'GLOB') {

-	$out .= '\\' . $s->_dump($$val, "*{$name}");

+      $out .= '\\' . $s->_dump($$val, "*{$name}");

     }

     elsif ($realtype eq 'ARRAY') {

       my($pad, $mname);

       my($i) = 0;

       $out .= ($name =~ /^\@/) ? '(' : '[';

       $pad = $s->{sep} . $s->{pad} . $s->{apad};

-      ($name =~ /^\@(.*)$/) ? ($mname = "\$" . $1) : 

-	# omit -> if $foo->[0]->{bar}, but not ${$foo->[0]}->{bar}

-	($name =~ /^\\?[\%\@\*\$][^{].*[]}]$/) ? ($mname = $name) :

-	  ($mname = $name . '->');

+      ($name =~ /^\@(.*)$/) ? ($mname = "\$" . $1) :

+    # omit -> if $foo->[0]->{bar}, but not ${$foo->[0]}->{bar}

+        ($name =~ /^\\?[\%\@\*\$][^{].*[]}]$/) ? ($mname = $name) :

+        ($mname = $name . '->');

       $mname .= '->' if $mname =~ /^\*.+\{[A-Z]+\}$/;

       for my $v (@$val) {