utime: fix __32u sec time overflow

Signed-off-by: kungf <yang.wang@easystack.cn>

src/include/utime.h

@@ -32,6 +32,10 @@
 // --------
 // utime_t
 
+//from __u64 to __u32
+inline __u32 ut_safe_convert(__u64 t) {
+  return t < std::numeric_limits<uint32_t>::max() ? t : std::numeric_limits<uint32_t>::max();
+}
 /* WARNING: If add member in utime_t, please make sure the encode/decode funtion
  * work well. For little-endian machine, we should make sure there is no padding
  * in 32-bit machine and 64-bit machine.
@@ -47,9 +51,10 @@ class utime_t {
   bool is_zero() const {
     return (tv.tv_sec == 0) && (tv.tv_nsec == 0);
   }
+
   void normalize() {
     if (tv.tv_nsec > 1000000000ul) {
-      tv.tv_sec += tv.tv_nsec / (1000000000ul);
+      tv.tv_sec = ut_safe_convert(tv.tv_sec + tv.tv_nsec / (1000000000ul));
       tv.tv_nsec %= 1000000000ul;
     }
   }
@@ -433,23 +438,23 @@ class utime_t {
 WRITE_CLASS_ENCODER(utime_t)
 WRITE_CLASS_DENC(utime_t)
 
-
 // arithmetic operators
 inline utime_t operator+(const utime_t& l, const utime_t& r) {
-  return utime_t( l.sec() + r.sec() + (l.nsec()+r.nsec())/1000000000L,
-                  (l.nsec()+r.nsec())%1000000000L );
+  __u64 sec = (__u64)l.sec() + r.sec() + (l.nsec()+r.nsec())/1000000000ul;
+  __u64 nsec = (l.nsec()+r.nsec())%1000000000ul;
+  return utime_t( ut_safe_convert(sec), ut_safe_convert(nsec));
 }
 inline utime_t& operator+=(utime_t& l, const utime_t& r) {
-  l.sec_ref() += r.sec() + (l.nsec()+r.nsec())/1000000000L;
-  l.nsec_ref() += r.nsec();
-  l.nsec_ref() %= 1000000000L;
+  l.sec_ref() = ut_safe_convert((__u64)l.sec() + r.sec());
+  l.nsec_ref() = ut_safe_convert((__u64)l.nsec() + r.nsec());
+  l.normalize();
   return l;
 }
 inline utime_t& operator+=(utime_t& l, double f) {
   double fs = trunc(f);
   double ns = (f - fs) * 1000000000.0;
-  l.sec_ref() += (long)fs;
-  l.nsec_ref() += (long)ns;
+  l.sec_ref() = ut_safe_convert(l.sec() + (__u64)fs);
+  l.nsec_ref() = ut_safe_convert(l.nsec() + (__u64)ns);
   l.normalize();
   return l;
 }