Prevent Time::Span overflow

src/time/span.cr

@@ -60,13 +60,24 @@ struct Time::Span
   def self.new(days : Int, hours : Int, minutes : Int, seconds : Int, nanoseconds : Int = 0)
     new(
       seconds: compute_seconds!(days, hours, minutes, seconds),
-      nanoseconds: nanoseconds.to_i64,
+      nanoseconds: nanoseconds,
     )
   end
 
   def initialize(*, seconds : Int, nanoseconds : Int)
+    # check for possible overflow
+    # seconds could be too big
+    unless Int64::MIN <= seconds <= Int64::MAX
+      raise ArgumentError.new "Time::Span too big or too small"
+    end
+    seconds = seconds.to_i64
     # Normalize nanoseconds in the range 0...1_000_000_000
-    seconds += nanoseconds.tdiv(NANOSECONDS_PER_SECOND)
+    sec = nanoseconds.tdiv(NANOSECONDS_PER_SECOND)
+    if ((seconds > Int64::MAX - sec) && (sec > 0)) || ((sec < 0) && (seconds < Int64::MIN - sec))
+      raise ArgumentError.new "Time::Span too big or too small"
+    else
+      seconds += sec
+    end
     nanoseconds = nanoseconds.remainder(NANOSECONDS_PER_SECOND)
 
     # Make sure that if seconds is positive, nanoseconds is
@@ -86,8 +97,8 @@ struct Time::Span
 
   def self.new(*, nanoseconds : Int)
     new(
-      seconds: nanoseconds.to_i64.tdiv(NANOSECONDS_PER_SECOND),
-      nanoseconds: nanoseconds.to_i64.remainder(NANOSECONDS_PER_SECOND),
+      seconds: 0,
+      nanoseconds: nanoseconds,
     )
   end
 
@@ -279,7 +290,10 @@ struct Time::Span
   end
 
   def +(other : self) : Time::Span
-    # TODO check overflow
+    # check seconds for possible integer overflow
+    if ((other.to_i > 0) && (to_i > Int64::MAX - other.to_i)) || ((other.to_i < 0) && (to_i < Int64::MIN - other.to_i))
+      raise ArgumentError.new "Overflow: Time::Span too big or too small"
+    end
     Span.new(
       seconds: to_i + other.to_i,
       nanoseconds: nanoseconds + other.nanoseconds,
@@ -293,24 +307,13 @@ struct Time::Span
   # Returns a `Time::Span` that is *number* times longer.
   def *(number : Number) : Time::Span
     # TODO check overflow
-    Span.new(
-      seconds: to_i.to_i64 * number,
-      nanoseconds: nanoseconds.to_i64 * number,
-    )
+    (total_nanoseconds * number).nanoseconds
   end
 
+  # Return a `Time::Span` that is divided by *number*.
   def /(number : Number) : Time::Span
-    seconds = to_i.tdiv(number)
-    nanoseconds = self.nanoseconds.tdiv(number)
-
-    remainder = to_i.remainder(number)
-    nanoseconds += (remainder * NANOSECONDS_PER_SECOND) / number
-
     # TODO check overflow
-    Span.new(
-      seconds: seconds,
-      nanoseconds: nanoseconds,
-    )
+    (total_nanoseconds / number).nanoseconds
   end
 
   def /(other : self) : Float64