From d5753ec513fa5a4bdcf59fa298642fd0d3a3c364 Mon Sep 17 00:00:00 2001

From: Yusuke Endoh <mame@ruby-lang.org>

Date: Fri, 12 Nov 2021 12:11:13 +0900

Subject: [PATCH 1/2] Add length limit option for methods that parses date

 strings

This patch fixes CVE-2021-41817 and created from the commit

<https://github.com/ruby/date/commit/4f9b8e946ba98f0a1774f8e677baa4a45637ebb3>.

We didn't merge the files included in the original commit below, as those are

for rebasing date gem version.

* ext/date/date.gemspec

* ext/date/lib/date.rb

== Original commit message ==

`Date.parse` now raises an ArgumentError when a given date string is

longer than 128. You can configure the limit by giving `limit` keyword

arguments like `Date.parse(str, limit: 1000)`. If you pass `limit: nil`,

the limit is disabled.

Not only `Date.parse` but also the following methods are changed.

* Date._parse

* Date.parse

* DateTime.parse

* Date._iso8601

* Date.iso8601

* DateTime.iso8601

* Date._rfc3339

* Date.rfc3339

* DateTime.rfc3339

* Date._xmlschema

* Date.xmlschema

* DateTime.xmlschema

* Date._rfc2822

* Date.rfc2822

* DateTime.rfc2822

* Date._rfc822

* Date.rfc822

* DateTime.rfc822

* Date._jisx0301

* Date.jisx0301

* DateTime.jisx0301

---

 ext/date/date_core.c         | 384 +++++++++++++++++++++++++++--------

 test/date/test_date_parse.rb |  29 +++

 2 files changed, 325 insertions(+), 88 deletions(-)

diff --git a/ext/date/date_core.c b/ext/date/date_core.c

index c250633426..177ea0f6c5 100644

--- a/ext/date/date_core.c

+++ b/ext/date/date_core.c

@@ -4290,12 +4290,37 @@ date_s_strptime(int argc, VALUE *argv, VALUE klass)

 VALUE date__parse(VALUE str, VALUE comp);

+static size_t

+get_limit(VALUE opt)

+{

+    if (!NIL_P(opt)) {

+        VALUE limit = rb_hash_aref(opt, ID2SYM(rb_intern("limit")));

+        if (NIL_P(limit)) return SIZE_MAX;

+        return NUM2SIZET(limit);

+    }

+    return 128;

+}

+

+static void

+check_limit(VALUE str, VALUE opt)

+{

+    StringValue(str);

+    size_t slen = RSTRING_LEN(str);

+    size_t limit = get_limit(opt);

+    if (slen > limit) {

+	rb_raise(rb_eArgError,

+		 "string length (%"PRI_SIZE_PREFIX"u) exceeds the limit %"PRI_SIZE_PREFIX"u", slen, limit);

+    }

+}

+

 static VALUE

 date_s__parse_internal(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE vstr, vcomp, hash;

+    VALUE vstr, vcomp, hash, opt;

-    rb_scan_args(argc, argv, "11", &vstr, &vcomp);

+    rb_scan_args(argc, argv, "11:", &vstr, &vcomp, &opt;;

+    if (!NIL_P(opt)) argc--;

+    check_limit(vstr, opt);

     StringValue(vstr);

     if (!rb_enc_str_asciicompat_p(vstr))

 	rb_raise(rb_eArgError,

@@ -4320,7 +4345,7 @@ date_s__parse_internal(int argc, VALUE *argv, VALUE klass)

 /*

  * call-seq:

- *    Date._parse(string[, comp=true])  ->  hash

+ *    Date._parse(string[, comp=true], limit: 128)  ->  hash

  *

  * Parses the given representation of date and time, and returns a

  * hash of parsed elements.  This method does not function as a

@@ -4331,6 +4356,10 @@ date_s__parse_internal(int argc, VALUE *argv, VALUE klass)

  * it full.

  *

  *    Date._parse('2001-02-03')	#=> {:year=>2001, :mon=>2, :mday=>3}

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s__parse(int argc, VALUE *argv, VALUE klass)

@@ -4340,7 +4369,7 @@ date_s__parse(int argc, VALUE *argv, VALUE klass)

 /*

  * call-seq:

- *    Date.parse(string='-4712-01-01'[, comp=true[, start=Date::ITALY]])  ->  date

+ *    Date.parse(string='-4712-01-01'[, comp=true[, start=Date::ITALY]], limit: 128)  ->  date

  *

  * Parses the given representation of date and time, and creates a

  * date object.  This method does not function as a validator.

@@ -4352,13 +4381,18 @@ date_s__parse(int argc, VALUE *argv, VALUE klass)

  *    Date.parse('2001-02-03')		#=> #<Date: 2001-02-03 ...>

  *    Date.parse('20010203')		#=> #<Date: 2001-02-03 ...>

  *    Date.parse('3rd Feb 2001')	#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_parse(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, comp, sg;

+    VALUE str, comp, sg, opt;

-    rb_scan_args(argc, argv, "03", &str, &comp, &sg;;

+    rb_scan_args(argc, argv, "03:", &str, &comp, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -4370,11 +4404,12 @@ date_s_parse(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE argv2[2], hash;

-

-	argv2[0] = str;

-	argv2[1] = comp;

-	hash = date_s__parse(2, argv2, klass);

+        int argc2 = 2;

+	VALUE argv2[3];

+        argv2[0] = str;

+        argv2[1] = comp;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__parse(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

@@ -4388,19 +4423,28 @@ VALUE date__jisx0301(VALUE);

 /*

  * call-seq:

- *    Date._iso8601(string)  ->  hash

+ *    Date._iso8601(string, limit: 128)  ->  hash

  *

  * Returns a hash of parsed elements.

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

-date_s__iso8601(VALUE klass, VALUE str)

+date_s__iso8601(int argc, VALUE *argv, VALUE klass)

 {

+    VALUE str, opt;

+

+    rb_scan_args(argc, argv, "1:", &str, &opt;;

+    check_limit(str, opt);

+

     return date__iso8601(str);

 }

 /*

  * call-seq:

- *    Date.iso8601(string='-4712-01-01'[, start=Date::ITALY])  ->  date

+ *    Date.iso8601(string='-4712-01-01'[, start=Date::ITALY], limit: 128)  ->  date

  *

  * Creates a new Date object by parsing from a string according to

  * some typical ISO 8601 formats.

@@ -4408,13 +4452,18 @@ date_s__iso8601(VALUE klass, VALUE str)

  *    Date.iso8601('2001-02-03')	#=> #<Date: 2001-02-03 ...>

  *    Date.iso8601('20010203')		#=> #<Date: 2001-02-03 ...>

  *    Date.iso8601('2001-W05-6')	#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_iso8601(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -4424,38 +4473,56 @@ date_s_iso8601(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__iso8601(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__iso8601(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    Date._rfc3339(string)  ->  hash

+ *    Date._rfc3339(string, limit: 128)  ->  hash

  *

  * Returns a hash of parsed elements.

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

-date_s__rfc3339(VALUE klass, VALUE str)

+date_s__rfc3339(int argc, VALUE *argv, VALUE klass)

 {

+    VALUE str, opt;

+

+    rb_scan_args(argc, argv, "1:", &str, &opt;;

+    check_limit(str, opt);

+

     return date__rfc3339(str);

 }

 /*

  * call-seq:

- *    Date.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY])  ->  date

+ *    Date.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128)  ->  date

  *

  * Creates a new Date object by parsing from a string according to

  * some typical RFC 3339 formats.

  *

  *    Date.rfc3339('2001-02-03T04:05:06+07:00')	#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_rfc3339(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -4465,38 +4532,56 @@ date_s_rfc3339(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__rfc3339(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__rfc3339(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    Date._xmlschema(string)  ->  hash

+ *    Date._xmlschema(string, limit: 128)  ->  hash

  *

  * Returns a hash of parsed elements.

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

-date_s__xmlschema(VALUE klass, VALUE str)

+date_s__xmlschema(int argc, VALUE *argv, VALUE klass)

 {

+    VALUE str, opt;

+

+    rb_scan_args(argc, argv, "1:", &str, &opt;;

+    check_limit(str, opt);

+

     return date__xmlschema(str);

 }

 /*

  * call-seq:

- *    Date.xmlschema(string='-4712-01-01'[, start=Date::ITALY])  ->  date

+ *    Date.xmlschema(string='-4712-01-01'[, start=Date::ITALY], limit: 128)  ->  date

  *

  * Creates a new Date object by parsing from a string according to

  * some typical XML Schema formats.

  *

  *    Date.xmlschema('2001-02-03')	#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_xmlschema(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -4506,41 +4591,58 @@ date_s_xmlschema(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__xmlschema(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__xmlschema(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    Date._rfc2822(string)  ->  hash

- *    Date._rfc822(string)   ->  hash

+ *    Date._rfc2822(string, limit: 128)  ->  hash

+ *    Date._rfc822(string, limit: 128)   ->  hash

  *

  * Returns a hash of parsed elements.

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

-date_s__rfc2822(VALUE klass, VALUE str)

+date_s__rfc2822(int argc, VALUE *argv, VALUE klass)

 {

+    VALUE str, opt;

+

+    rb_scan_args(argc, argv, "1:", &str, &opt;;

+    check_limit(str, opt);

+

     return date__rfc2822(str);

 }

 /*

  * call-seq:

- *    Date.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY])  ->  date

- *    Date.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY])   ->  date

+ *    Date.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128)  ->  date

+ *    Date.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128)   ->  date

  *

  * Creates a new Date object by parsing from a string according to

  * some typical RFC 2822 formats.

  *

  *    Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000')

  *						#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_rfc2822(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

     switch (argc) {

       case 0:

@@ -4550,39 +4652,56 @@ date_s_rfc2822(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__rfc2822(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__rfc2822(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    Date._httpdate(string)  ->  hash

+ *    Date._httpdate(string, limit: 128)  ->  hash

  *

  * Returns a hash of parsed elements.

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

-date_s__httpdate(VALUE klass, VALUE str)

+date_s__httpdate(int argc, VALUE *argv, VALUE klass)

 {

+    VALUE str, opt;

+

+    rb_scan_args(argc, argv, "1:", &str, &opt;;

+    check_limit(str, opt);

+

     return date__httpdate(str);

 }

 /*

  * call-seq:

- *    Date.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY])  ->  date

+ *    Date.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY], limit: 128)  ->  date

  *

  * Creates a new Date object by parsing from a string according to

  * some RFC 2616 format.

  *

  *    Date.httpdate('Sat, 03 Feb 2001 00:00:00 GMT')

  *						#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_httpdate(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

     switch (argc) {

       case 0:

@@ -4592,38 +4711,56 @@ date_s_httpdate(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__httpdate(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__httpdate(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    Date._jisx0301(string)  ->  hash

+ *    Date._jisx0301(string, limit: 128)  ->  hash

  *

  * Returns a hash of parsed elements.

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

-date_s__jisx0301(VALUE klass, VALUE str)

+date_s__jisx0301(int argc, VALUE *argv, VALUE klass)

 {

+    VALUE str, opt;

+

+    rb_scan_args(argc, argv, "1:", &str, &opt;;

+    check_limit(str, opt);

+

     return date__jisx0301(str);

 }

 /*

  * call-seq:

- *    Date.jisx0301(string='-4712-01-01'[, start=Date::ITALY])  ->  date

+ *    Date.jisx0301(string='-4712-01-01'[, start=Date::ITALY], limit: 128)  ->  date

  *

  * Creates a new Date object by parsing from a string according to

  * some typical JIS X 0301 formats.

  *

  *    Date.jisx0301('H13.02.03')		#=> #<Date: 2001-02-03 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 date_s_jisx0301(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -4633,7 +4770,11 @@ date_s_jisx0301(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__jisx0301(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        if (!NIL_P(opt)) argv2[argc2++] = opt;

+	VALUE hash = date_s__jisx0301(argc2, argv2, klass);

 	return d_new_by_frags(klass, hash, sg);

     }

 }

@@ -7925,7 +8066,7 @@ datetime_s_strptime(int argc, VALUE *argv, VALUE klass)

 /*

  * call-seq:

- *    DateTime.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]])  ->  datetime

+ *    DateTime.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]], limit: 128)  ->  datetime

  *

  * Parses the given representation of date and time, and creates a

  * DateTime object.  This method does not function as a validator.

@@ -7939,13 +8080,18 @@ datetime_s_strptime(int argc, VALUE *argv, VALUE klass)

  *				#=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

  *    DateTime.parse('3rd Feb 2001 04:05:06 PM')

  *				#=> #<DateTime: 2001-02-03T16:05:06+00:00 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 datetime_s_parse(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, comp, sg;

+    VALUE str, comp, sg, opt;

-    rb_scan_args(argc, argv, "03", &str, &comp, &sg;;

+    rb_scan_args(argc, argv, "03:", &str, &comp, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -7957,18 +8103,20 @@ datetime_s_parse(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE argv2[2], hash;

-

-	argv2[0] = str;

-	argv2[1] = comp;

-	hash = date_s__parse(2, argv2, klass);

+        int argc2 = 2;

+        VALUE argv2[3];

+        argv2[0] = str;

+        argv2[1] = comp;

+        argv2[2] = opt;

+        if (!NIL_P(opt)) argc2++;

+	VALUE hash = date_s__parse(argc2, argv2, klass);

 	return dt_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    DateTime.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY])  ->  datetime

+ *    DateTime.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128)  ->  datetime

  *

  * Creates a new DateTime object by parsing from a string according to

  * some typical ISO 8601 formats.

@@ -7979,13 +8127,18 @@ datetime_s_parse(int argc, VALUE *argv, VALUE klass)

  *				#=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

  *    DateTime.iso8601('2001-W05-6T04:05:06+07:00')

  *				#=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 datetime_s_iso8601(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -7995,27 +8148,37 @@ datetime_s_iso8601(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__iso8601(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        argv2[1] = opt;

+        if (!NIL_P(opt)) argc2--;

+	VALUE hash = date_s__iso8601(argc2, argv2, klass);

 	return dt_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    DateTime.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY])  ->  datetime

+ *    DateTime.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128)  ->  datetime

  *

  * Creates a new DateTime object by parsing from a string according to

  * some typical RFC 3339 formats.

  *

  *    DateTime.rfc3339('2001-02-03T04:05:06+07:00')

  *				#=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 datetime_s_rfc3339(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -8025,27 +8188,37 @@ datetime_s_rfc3339(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__rfc3339(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        argv2[1] = opt;

+        if (!NIL_P(opt)) argc2++;

+	VALUE hash = date_s__rfc3339(argc2, argv2, klass);

 	return dt_new_by_frags(klass, hash, sg);

     }

 }

 /*

  * call-seq:

- *    DateTime.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY])  ->  datetime

+ *    DateTime.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128)  ->  datetime

  *

  * Creates a new DateTime object by parsing from a string according to

  * some typical XML Schema formats.

  *

  *    DateTime.xmlschema('2001-02-03T04:05:06+07:00')

  *				#=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

+ *

+ * Raise an ArgumentError when the string length is longer than _limit_.

+ * You can stop this check by passing `limit: nil`, but note that

+ * it may take a long time to parse.

  */

 static VALUE

 datetime_s_xmlschema(int argc, VALUE *argv, VALUE klass)

 {

-    VALUE str, sg;

+    VALUE str, sg, opt;

-    rb_scan_args(argc, argv, "02", &str, &sg;;

+    rb_scan_args(argc, argv, "02:", &str, &sg, &opt;;

+    if (!NIL_P(opt)) argc--;

     switch (argc) {

       case 0:

@@ -8055,28 +8228,38 @@ datetime_s_xmlschema(int argc, VALUE *argv, VALUE klass)

     }

     {

-	VALUE hash = date_s__xmlschema(klass, str);

+        int argc2 = 1;

+        VALUE argv2[2];

+        argv2[0] = str;

+        argv2[1] = opt;

+        if (!NIL_P(opt)) argc2++;