Merge branch 'egil/file-info-opt-utc/OTP-7687'

* egil/file-info-opt-utc/OTP-7687: (39 commits)
  Remove time_t specific test in prim_file_SUITE
  Update prim_file.beam and prim_zip.beam
  Add types for posixtime_to_universaltime and the reverse
  Set BASEYEAR to 1902
  Set lower limit of years handled to 1601
  Emulate localtime, gmtime and mktime to enable negative time_t
  Document file:*_file_info/2
  Fix compiler warning in unix_efile.c
  Change name of bif universaltime_to_seconds/1
  Change options to prim_file:*_file_info/*
  Remove dead code
  Catch errors from prim_file:*_file_info
  Testcase for utc <-> seconds conversion
  Fix negative time in seconds_to_universaltime/1
  Remove OS taint from datetime conversion
  Add utc <-> seconds conversions bifs
  Let prim_file validate ctime in file_info
  Teach #file_info spec unix epochs for file times
  Add file_info_opt tests in prim_file_SUITE
  unix_efile: Zero is a valid number in utime
  ...

Conflicts:
	erts/emulator/beam/erl_time_sup.c
	erts/emulator/sys/win32/erl_win_sys.h
	erts/emulator/sys/win32/sys_time.c

11 files changed, 675 insertions, 199 deletions

diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 26f1b4facb..55f4798892 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -3385,6 +3385,61 @@ BIF_RETTYPE universaltime_to_localtime_1(BIF_ALIST_1)
     BIF_RET(TUPLE2(hp, res1, res2));
 }
 
+/* convert calendar:universaltime_to_seconds/1 */
+
+BIF_RETTYPE universaltime_to_posixtime_1(BIF_ALIST_1)
+{
+    Sint year, month, day;
+    Sint hour, minute, second;
+
+    Sint64 seconds = 0;
+    Eterm *hp;
+    Uint hsz = 0;
+
+    if (!time_to_parts(BIF_ARG_1, &year, &month, &day, 
+		       &hour, &minute, &second))
+	BIF_ERROR(BIF_P, BADARG);
+
+    if (!univ_to_seconds(year, month, day, hour, minute, second, &seconds)) {
+	BIF_ERROR(BIF_P, BADARG);
+    }
+
+    erts_bld_sint64(NULL, &hsz, seconds);
+    hp = HAlloc(BIF_P, hsz);
+    BIF_RET(erts_bld_sint64(&hp, NULL, seconds));
+}
+
+/* convert calendar:seconds_to_universaltime/1 */
+
+BIF_RETTYPE posixtime_to_universaltime_1(BIF_ALIST_1)
+{
+    Sint year, month, day;
+    Sint hour, minute, second;
+    Eterm res1, res2;
+    Eterm* hp;
+
+    Sint64 time = 0;
+
+    if (!term_to_Sint64(BIF_ARG_1, &time)) {
+	BIF_ERROR(BIF_P, BADARG);
+    }
+
+    if (!seconds_to_univ(time, &year, &month, &day,
+		&hour, &minute, &second)) {
+	BIF_ERROR(BIF_P, BADARG);
+    }
+
+    hp = HAlloc(BIF_P, 4+4+3);
+    res1 = TUPLE3(hp,make_small(year),make_small(month),
+		  make_small(day));
+    hp += 4;
+    res2 = TUPLE3(hp,make_small(hour),make_small(minute),
+		  make_small(second));
+    hp += 4;
+    BIF_RET(TUPLE2(hp, res1, res2));
+}
+
+
 /**********************************************************************/
 
 
diff --git a/erts/emulator/beam/bif.tab b/erts/emulator/beam/bif.tab
index 987008c937..8cc568b16c 100644
--- a/erts/emulator/beam/bif.tab
+++ b/erts/emulator/beam/bif.tab
@@ -806,6 +806,12 @@ bif file:native_name_encoding/0
 #
 bif erlang:check_old_code/1
 
+
+#
+# New in R15B
+#
+bif erlang:universaltime_to_posixtime/1
+bif erlang:posixtime_to_universaltime/1
 #
 # Obsolete
 #
diff --git a/erts/emulator/beam/erl_time_sup.c b/erts/emulator/beam/erl_time_sup.c
index b319288f7d..f782e2f0b1 100644
--- a/erts/emulator/beam/erl_time_sup.c
+++ b/erts/emulator/beam/erl_time_sup.c
@@ -494,7 +494,7 @@ get_time(int *hour, int *minute, int *second)
     
     the_clock = time((time_t *)0);
 #ifdef HAVE_LOCALTIME_R
-    localtime_r(&the_clock, (tm = &tmbuf));
+    tm = localtime_r(&the_clock, &tmbuf);
 #else
     tm = localtime(&the_clock);
 #endif
@@ -516,7 +516,7 @@ get_date(int *year, int *month, int *day)
 
     the_clock = time((time_t *)0);
 #ifdef HAVE_LOCALTIME_R
-    localtime_r(&the_clock, (tm = &tmbuf));
+    tm = localtime_r(&the_clock, &tmbuf);
 #else
     tm = localtime(&the_clock);
 #endif
@@ -586,7 +586,44 @@ static const int mdays[14] = {0, 31, 28, 31, 30, 31, 30,
                             (((y) % 100) != 0)) || \
                            (((y) % 400) == 0))
 
-#define  BASEYEAR       1970
+/* This is the earliest year we are sure to be able to handle
+   on all platforms w/o problems */
+#define  BASEYEAR       1902 
+
+/* A more "clever" mktime
+ * return  1, if successful
+ * return -1, if not successful
+ */
+
+static int erl_mktime(time_t *c, struct tm *tm) {
+    time_t clock;
+
+    clock = mktime(tm);
+
+    if (clock != -1) {
+	*c = clock;
+	return 1;
+    }
+
+    /* in rare occasions mktime returns -1
+     * when a correct value has been entered
+     *
+     * decrease seconds with one second
+     * if the result is -2, epochs should be -1
+     */
+
+    tm->tm_sec = tm->tm_sec - 1;
+    clock = mktime(tm);
+    tm->tm_sec = tm->tm_sec + 1;
+
+    *c = -1;
+
+    if (clock == -2) {
+	return 1;
+    }
+
+    return -1;
+}
 
 /*
  * gregday
@@ -597,8 +634,8 @@ static const int mdays[14] = {0, 31, 28, 31, 30, 31, 30,
  */
 static time_t gregday(int year, int month, int day)
 {
-  time_t ndays = 0;
-  time_t gyear, pyear, m;
+  Sint ndays = 0;
+  Sint gyear, pyear, m;
   
   /* number of days in previous years */
   gyear = year - 1600;
@@ -613,10 +650,72 @@ static time_t gregday(int year, int month, int day)
   if (is_leap_year(year) && (month > 2))
     ndays++;
   ndays += day - 1;
-  return ndays - 135140;        /* 135140 = Jan 1, 1970 */
+  return (time_t) (ndays - 135140);        /* 135140 = Jan 1, 1970 */
+}
+
+#define SECONDS_PER_MINUTE  (60)
+#define SECONDS_PER_HOUR    (60 * SECONDS_PER_MINUTE)
+#define SECONDS_PER_DAY     (24 * SECONDS_PER_HOUR)
+
+int seconds_to_univ(Sint64 time, Sint *year, Sint *month, Sint *day, 
+	Sint *hour, Sint *minute, Sint *second) {
+
+    Sint y,mi;
+    Sint days = time / SECONDS_PER_DAY;
+    Sint secs = time % SECONDS_PER_DAY;
+    Sint tmp;
+
+    if (secs < 0) {
+	days--;
+	secs += SECONDS_PER_DAY;
+    }
+    
+    tmp     = secs % SECONDS_PER_HOUR;
+
+    *hour   = secs / SECONDS_PER_HOUR;
+    *minute = tmp  / SECONDS_PER_MINUTE;
+    *second = tmp  % SECONDS_PER_MINUTE;
+
+    days   += 719468;
+    y       = (10000*((Sint64)days) + 14780) / 3652425; 
+    tmp     = days - (365 * y + y/4 - y/100 + y/400);
+
+    if (tmp < 0) {
+	y--;
+	tmp = days - (365*y + y/4 - y/100 + y/400);
+    }
+    mi = (100 * tmp + 52)/3060;
+    *month = (mi + 2) % 12 + 1;
+    *year  = y + (mi + 2) / 12;
+    *day   = tmp - (mi * 306 + 5)/10 + 1;
+
+    return 1;
 }
 
+int univ_to_seconds(Sint year, Sint month, Sint day, Sint hour, Sint minute, Sint second, Sint64 *time) {
+    Sint days;
+
+    if (!(IN_RANGE(1600, year, INT_MAX - 1) &&
+          IN_RANGE(1, month, 12) &&
+          IN_RANGE(1, day, (mdays[month] + 
+                             (month == 2 
+                              && (year % 4 == 0) 
+                              && (year % 100 != 0 || year % 400 == 0)))) &&
+          IN_RANGE(0, hour, 23) &&
+          IN_RANGE(0, minute, 59) &&
+          IN_RANGE(0, second, 59))) {
+      return 0;
+    }
+ 
+    days   = gregday(year, month, day);
+    *time  = SECONDS_PER_DAY;
+    *time *= days;             /* don't try overflow it, it hurts */
+    *time += SECONDS_PER_HOUR * hour;
+    *time += SECONDS_PER_MINUTE * minute;
+    *time += second;
 
+    return 1;
+}
 
 int 
 local_to_univ(Sint *year, Sint *month, Sint *day, 
@@ -647,15 +746,18 @@ local_to_univ(Sint *year, Sint *month, Sint *day,
     t.tm_min = *minute;
     t.tm_sec = *second;
     t.tm_isdst = isdst;
-    the_clock = mktime(&t);
-    if (the_clock == -1) {
+
+    /* the nature of mktime makes this a bit interesting,
+     * up to four mktime calls could happen here
+     */
+
+    if (erl_mktime(&the_clock, &t) < 0) {
 	if (isdst) {
 	    /* If this is a timezone without DST and the OS (correctly)
 	       refuses to give us a DST time, we simulate the Linux/Solaris
 	       behaviour of giving the same data as if is_dst was not set. */
 	    t.tm_isdst = 0;
-	    the_clock = mktime(&t);
-	    if (the_clock == -1) {
+	    if (erl_mktime(&the_clock, &t)) {
 		/* Failed anyway, something else is bad - will be a badarg */
 		return 0;
 	    }
@@ -665,10 +767,13 @@ local_to_univ(Sint *year, Sint *month, Sint *day,
 	}
     }
 #ifdef HAVE_GMTIME_R
-    gmtime_r(&the_clock, (tm = &tmbuf));
+    tm = gmtime_r(&the_clock, &tmbuf);
 #else
     tm = gmtime(&the_clock);
 #endif
+    if (!tm) {
+      return 0;
+    }
     *year = tm->tm_year + 1900;
     *month = tm->tm_mon +1;
     *day = tm->tm_mday;
@@ -722,17 +827,20 @@ univ_to_local(Sint *year, Sint *month, Sint *day,
 #endif
 
 #ifdef HAVE_LOCALTIME_R
-    localtime_r(&the_clock, (tm = &tmbuf));
+    tm = localtime_r(&the_clock, &tmbuf);
 #else
     tm = localtime(&the_clock);
 #endif
-    *year = tm->tm_year + 1900;
-    *month = tm->tm_mon +1;
-    *day = tm->tm_mday;
-    *hour = tm->tm_hour;
-    *minute = tm->tm_min;
-    *second = tm->tm_sec;
-    return 1;
+    if (tm) {
+	*year   = tm->tm_year + 1900;
+	*month  = tm->tm_mon +1;
+	*day    = tm->tm_mday;
+	*hour   = tm->tm_hour;
+	*minute = tm->tm_min;
+	*second = tm->tm_sec;
+	return 1;
+    }
+    return 0;
 }
 
 
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index efc6dd2c6b..6b4b382caa 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -667,7 +667,14 @@ void get_localtime(int *year, int *month, int *day,
 		   int *hour, int *minute, int *second);
 void get_universaltime(int *year, int *month, int *day, 
 		       int *hour, int *minute, int *second);
-int univ_to_local(Sint *year, Sint *month, Sint *day, 
+int seconds_to_univ(Sint64 seconds, 
+		    Sint *year, Sint *month, Sint *day, 
+		    Sint *hour, Sint *minute, Sint *second);
+int univ_to_seconds(Sint year, Sint month, Sint day, 
+		    Sint hour, Sint minute, Sint second,
+		    Sint64* seconds);
+int univ_to_local(
+    Sint *year, Sint *month, Sint *day, 
 		  Sint *hour, Sint *minute, Sint *second);
 int local_to_univ(Sint *year, Sint *month, Sint *day, 
 		  Sint *hour, Sint *minute, Sint *second, int isdst);
diff --git a/erts/emulator/drivers/common/efile_drv.c b/erts/emulator/drivers/common/efile_drv.c
index 5c52b99348..e7235c30f7 100644
--- a/erts/emulator/drivers/common/efile_drv.c
+++ b/erts/emulator/drivers/common/efile_drv.c
@@ -2120,24 +2120,25 @@ file_async_ready(ErlDrvData e, ErlDrvThreadData data)
 	    if (d->result_ok) {
 		resbuf[0] = FILE_RESP_INFO;
 
-		put_int32(d->info.size_high,         &resbuf[1 + (0 * 4)]);
-		put_int32(d->info.size_low,          &resbuf[1 + (1 * 4)]);
-		put_int32(d->info.type,              &resbuf[1 + (2 * 4)]);
-
-		PUT_TIME(d->info.accessTime, resbuf + 1 + 3*4);
-		PUT_TIME(d->info.modifyTime, resbuf + 1 + 9*4);
-		PUT_TIME(d->info.cTime, resbuf + 1 + 15*4);
-
-		put_int32(d->info.mode,              &resbuf[1 + (21 * 4)]);
-		put_int32(d->info.links,             &resbuf[1 + (22 * 4)]);
-		put_int32(d->info.major_device,      &resbuf[1 + (23 * 4)]);
-		put_int32(d->info.minor_device,      &resbuf[1 + (24 * 4)]);
-		put_int32(d->info.inode,             &resbuf[1 + (25 * 4)]);
-		put_int32(d->info.uid,               &resbuf[1 + (26 * 4)]);
-		put_int32(d->info.gid,               &resbuf[1 + (27 * 4)]);
-		put_int32(d->info.access,            &resbuf[1 + (28 * 4)]);
-
-#define RESULT_SIZE (1 + (29 * 4))
+		put_int32(d->info.size_high,         &resbuf[1 + ( 0 * 4)]);
+		put_int32(d->info.size_low,          &resbuf[1 + ( 1 * 4)]);
+		put_int32(d->info.type,              &resbuf[1 + ( 2 * 4)]);
+
+		/* Note 64 bit indexing in resbuf here */
+		put_int64(d->info.accessTime,        &resbuf[1 + ( 3 * 4)]);
+		put_int64(d->info.modifyTime,        &resbuf[1 + ( 5 * 4)]);
+		put_int64(d->info.cTime,             &resbuf[1 + ( 7 * 4)]);
+
+		put_int32(d->info.mode,              &resbuf[1 + ( 9 * 4)]);
+		put_int32(d->info.links,             &resbuf[1 + (10 * 4)]);
+		put_int32(d->info.major_device,      &resbuf[1 + (11 * 4)]);
+		put_int32(d->info.minor_device,      &resbuf[1 + (12 * 4)]);
+		put_int32(d->info.inode,             &resbuf[1 + (13 * 4)]);
+		put_int32(d->info.uid,               &resbuf[1 + (14 * 4)]);
+		put_int32(d->info.gid,               &resbuf[1 + (15 * 4)]);
+		put_int32(d->info.access,            &resbuf[1 + (16 * 4)]);
+
+#define RESULT_SIZE (1 + (17 * 4))
 		TRACE_C('R');
 		driver_output2(desc->port, resbuf, RESULT_SIZE, NULL, 0);
 #undef RESULT_SIZE
@@ -2485,15 +2486,16 @@ file_output(ErlDrvData e, char* buf, int count)
     case FILE_WRITE_INFO:
 	{
 	    d = EF_SAFE_ALLOC(sizeof(struct t_data) - 1
-			      + FILENAME_BYTELEN(buf+21*4) + FILENAME_CHARSIZE);
+			      + FILENAME_BYTELEN(buf + 9*4) + FILENAME_CHARSIZE);
 	    
-	    d->info.mode = get_int32(buf + 0 * 4);
-	    d->info.uid = get_int32(buf + 1 * 4);
-	    d->info.gid = get_int32(buf + 2 * 4);
-	    GET_TIME(d->info.accessTime, buf + 3 * 4);
-	    GET_TIME(d->info.modifyTime, buf + 9 * 4);
-	    GET_TIME(d->info.cTime, buf + 15 * 4);
-	    FILENAME_COPY(d->b, buf+21*4);
+	    d->info.mode       = get_int32(buf +  0 * 4);
+	    d->info.uid        = get_int32(buf +  1 * 4);
+	    d->info.gid        = get_int32(buf +  2 * 4);
+	    d->info.accessTime = (time_t)((Sint64)get_int64(buf +  3 * 4));
+	    d->info.modifyTime = (time_t)((Sint64)get_int64(buf +  5 * 4));
+	    d->info.cTime      = (time_t)((Sint64)get_int64(buf +  7 * 4));
+
+	    FILENAME_COPY(d->b, buf + 9*4);
 	    d->command = command;
 	    d->invoke = invoke_write_info;
 	    d->free = free_data;
diff --git a/erts/emulator/drivers/common/erl_efile.h b/erts/emulator/drivers/common/erl_efile.h
index 349ab0e17b..5c0b89e850 100644
--- a/erts/emulator/drivers/common/erl_efile.h
+++ b/erts/emulator/drivers/common/erl_efile.h
@@ -85,14 +85,15 @@ typedef struct _Efile_error {
 /*
  * This structure contains date and time.
  */
-typedef struct _Efile_time {
-    unsigned year;		/* (4 digits). */
-    unsigned month;		/* (1..12). */
-    unsigned day;		/* (1..31). */
-    unsigned hour;		/* (0..23). */
-    unsigned minute;		/* (0..59). */
-    unsigned second;		/* (0..59). */
-} Efile_time;
+
+//typedef struct _Efile_time {
+//    unsigned year;		/* (4 digits). */
+//    unsigned month;		/* (1..12). */
+//    unsigned day;		/* (1..31). */
+//    unsigned hour;		/* (0..23). */
+//    unsigned minute;		/* (0..59). */
+//    unsigned second;		/* (0..59). */
+//} Efile_time;
 
 
 /*
@@ -111,9 +112,9 @@ typedef struct _Efile_info {
     Uint32 inode;		/* Inode number. */
     Uint32 uid;			/* User id of owner. */
     Uint32 gid;			/* Group id of owner. */
-    Efile_time accessTime;	/* Last time the file was accessed. */
-    Efile_time modifyTime;	/* Last time the file was modified. */
-    Efile_time cTime;		/* Creation time (Windows) or last
+    time_t accessTime;		/* Last time the file was accessed. */
+    time_t modifyTime;		/* Last time the file was modified. */
+    time_t cTime;		/* Creation time (Windows) or last
 				 * inode change (Unix).
 				 */
 } Efile_info;
diff --git a/erts/emulator/drivers/unix/unix_efile.c b/erts/emulator/drivers/unix/unix_efile.c
index 72911641d3..d2d8713c1e 100644
--- a/erts/emulator/drivers/unix/unix_efile.c
+++ b/erts/emulator/drivers/unix/unix_efile.c
@@ -816,7 +816,6 @@ efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
 	       char* name, int info_for_link)
 {
     struct stat statbuf;	/* Information about the file */
-    struct tm *timep;		/* Broken-apart filetime. */
     int result;
 
 #ifdef VXWORKS
@@ -883,40 +882,17 @@ efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
     else
 	pInfo->type = FT_OTHER;
 
-#if defined(HAVE_LOCALTIME_R) || defined(VXWORKS)
-    {
-	/* Use the reentrant version of localtime() */
-	static struct tm local_tm;
-#define localtime(a) (localtime_r((a), &local_tm), &local_tm)
-#endif
-
-
-#define GET_TIME(dst, src) \
-    timep = localtime(&statbuf.src); \
-    (dst).year = timep->tm_year+1900; \
-    (dst).month = timep->tm_mon+1; \
-    (dst).day = timep->tm_mday; \
-    (dst).hour = timep->tm_hour; \
-    (dst).minute = timep->tm_min; \
-    (dst).second = timep->tm_sec
-
-    GET_TIME(pInfo->accessTime, st_atime);
-    GET_TIME(pInfo->modifyTime, st_mtime);
-    GET_TIME(pInfo->cTime, st_ctime);
-
-#undef GET_TIME
-
-#if defined(HAVE_LOCALTIME_R) || defined(VXWORKS)
-    }
-#endif
+    pInfo->accessTime   = statbuf.st_atime;
+    pInfo->modifyTime   = statbuf.st_mtime;
+    pInfo->cTime        = statbuf.st_ctime;
 
-    pInfo->mode = statbuf.st_mode;
-    pInfo->links = statbuf.st_nlink;
+    pInfo->mode         = statbuf.st_mode;
+    pInfo->links        = statbuf.st_nlink;
     pInfo->major_device = statbuf.st_dev;
     pInfo->minor_device = statbuf.st_rdev;
-    pInfo->inode = statbuf.st_ino;
-    pInfo->uid = statbuf.st_uid;
-    pInfo->gid = statbuf.st_gid;
+    pInfo->inode        = statbuf.st_ino;
+    pInfo->uid          = statbuf.st_uid;
+    pInfo->gid          = statbuf.st_gid;
 
     return 1;
 }
@@ -924,6 +900,8 @@ efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
 int
 efile_write_info(Efile_error *errInfo, Efile_info *pInfo, char *name)
 {
+    struct utimbuf tval;
+
     CHECK_PATHLEN(name, errInfo);
 
 #ifdef VXWORKS
@@ -976,38 +954,18 @@ efile_write_info(Efile_error *errInfo, Efile_info *pInfo, char *name)
 
 #endif /* !VXWORKS */
 
-    if (pInfo->accessTime.year != -1 && pInfo->modifyTime.year != -1) {
-	struct utimbuf tval;
-	struct tm timebuf;
-
-#define MKTIME(tb, ts) \
-    timebuf.tm_year = ts.year-1900; \
-    timebuf.tm_mon = ts.month-1; \
-    timebuf.tm_mday = ts.day; \
-    timebuf.tm_hour = ts.hour; \
-    timebuf.tm_min = ts.minute; \
-    timebuf.tm_sec = ts.second; \
-    timebuf.tm_isdst = -1; \
-    if ((tb = mktime(&timebuf)) == (time_t) -1) { \
-       errno = EINVAL; \
-       return check_error(-1, errInfo); \
-    }
+    tval.actime  = pInfo->accessTime;
+    tval.modtime = pInfo->modifyTime;
 
-        MKTIME(tval.actime, pInfo->accessTime);
-	MKTIME(tval.modtime, pInfo->modifyTime);
-#undef MKTIME
-	
 #ifdef VXWORKS
-	/* VxWorks' utime doesn't work when the file is a nfs mounted
-	 * one, don't report error if utime fails.
-	 */
-	utime(name, &tval);
-	return 1;
+    /* VxWorks' utime doesn't work when the file is a nfs mounted
+     * one, don't report error if utime fails.
+     */
+    utime(name, &tval);
+    return 1;
 #else
-	return check_error(utime(name, &tval), errInfo);
+    return check_error(utime(name, &tval), errInfo);
 #endif
-    }
-    return 1;
 }
 
 
diff --git a/erts/emulator/drivers/win32/win_efile.c b/erts/emulator/drivers/win32/win_efile.c
index 0bc701c4cb..0d3d334154 100644
--- a/erts/emulator/drivers/win32/win_efile.c
+++ b/erts/emulator/drivers/win32/win_efile.c
@@ -45,6 +45,26 @@
 #define INVALID_FILE_ATTRIBUTES ((DWORD) 0xFFFFFFFF)
 #endif
 
+#define TICKS_PER_SECOND (10000000ULL)
+#define EPOCH_DIFFERENCE (11644473600LL)
+
+#define FILETIME_TO_EPOCH(epoch, ft) \
+    do { \
+	ULARGE_INTEGER ull; \
+	ull.LowPart  = (ft).dwLowDateTime; \
+	ull.HighPart = (ft).dwHighDateTime; \
+	(epoch) = ((ull.QuadPart / TICKS_PER_SECOND) - EPOCH_DIFFERENCE); \
+    } while(0)
+
+#define EPOCH_TO_FILETIME(ft, epoch) \
+    do { \
+	ULARGE_INTEGER ull; \
+	ull.QuadPart = (((epoch) + EPOCH_DIFFERENCE) * TICKS_PER_SECOND); \
+	(ft).dwLowDateTime = ull.LowPart; \
+	(ft).dwHighDateTime = ull.HighPart; \
+    } while(0)
+
+
 static int check_error(int result, Efile_error* errInfo);
 static int set_error(Efile_error* errInfo);
 static int is_root_unc_name(const WCHAR *path);
@@ -864,14 +884,7 @@ efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
         findbuf.cFileName[0] = L'\0';
 
 	pInfo->links = 1;
-	pInfo->modifyTime.year = 1980;
-	pInfo->modifyTime.month = 1;
-	pInfo->modifyTime.day = 1;
-	pInfo->modifyTime.hour = 0;
-	pInfo->modifyTime.minute = 0;
-	pInfo->modifyTime.second = 0;
-
-	pInfo->accessTime = pInfo->modifyTime;
+	pInfo->cTime = pInfo->accessTime = pInfo->modifyTime = 0;
     } else {
 	SYSTEMTIME SystemTime;
         FILETIME LocalFTime;
@@ -905,34 +918,21 @@ efile_fileinfo(Efile_error* errInfo, Efile_info* pInfo,
 	    }	
 	}
 
-#define GET_TIME(dst, src) \
-if (!FileTimeToLocalFileTime(&findbuf.src, &LocalFTime) || \
-    !FileTimeToSystemTime(&LocalFTime, &SystemTime)) { \
-    return set_error(errInfo); \
-} \
-(dst).year = SystemTime.wYear; \
-(dst).month = SystemTime.wMonth; \
-(dst).day = SystemTime.wDay; \
-(dst).hour = SystemTime.wHour; \
-(dst).minute = SystemTime.wMinute; \
-(dst).second = SystemTime.wSecond;
-
-        GET_TIME(pInfo->modifyTime, ftLastWriteTime);
+        FILETIME_TO_EPOCH(pInfo->modifyTime, findbuf.ftLastWriteTime);
 
         if (findbuf.ftLastAccessTime.dwLowDateTime == 0 &&
 	    findbuf.ftLastAccessTime.dwHighDateTime == 0) {
 	    pInfo->accessTime = pInfo->modifyTime;
 	} else {
-	    GET_TIME(pInfo->accessTime, ftLastAccessTime);
+	    FILETIME_TO_EPOCH(pInfo->accessTime, findbuf.ftLastAccessTime);
 	}
 
         if (findbuf.ftCreationTime.dwLowDateTime == 0 &&
 	    findbuf.ftCreationTime.dwHighDateTime == 0) {
 	    pInfo->cTime = pInfo->modifyTime;
 	} else {
-	    GET_TIME(pInfo->cTime, ftCreationTime);
+	    FILETIME_TO_EPOCH(pInfo->cTime ,findbuf.ftCreationTime);
 	}
-#undef GET_TIME
         FindClose(findhandle);
     }
 
@@ -968,17 +968,12 @@ efile_write_info(Efile_error* errInfo,
 		 char* name)
 {
     SYSTEMTIME timebuf;
-    FILETIME LocalFileTime;
     FILETIME ModifyFileTime;
     FILETIME AccessFileTime;
     FILETIME CreationFileTime;
     HANDLE fd;
-    FILETIME* mtime = NULL;
-    FILETIME* atime = NULL;
-    FILETIME* ctime = NULL;
     DWORD attr;
     DWORD tempAttr;
-    BOOL modifyTime = FALSE;
     WCHAR *wname = (WCHAR *) name;
 
     /*
@@ -1003,57 +998,36 @@ efile_write_info(Efile_error* errInfo,
      * Construct all file times.
      */
 
-#define MKTIME(tb, ts, ptr) \
-    timebuf.wYear = ts.year; \
-    timebuf.wMonth = ts.month; \
-    timebuf.wDay = ts.day; \
-    timebuf.wHour = ts.hour; \
-    timebuf.wMinute = ts.minute; \
-    timebuf.wSecond = ts.second; \
-    timebuf.wMilliseconds = 0; \
-    if (ts.year != -1) { \
-      modifyTime = TRUE; \
-      ptr = &tb; \
-      if (!SystemTimeToFileTime(&timebuf, &LocalFileTime ) || \
-	!LocalFileTimeToFileTime(&LocalFileTime, &tb)) { \
-        errno = EINVAL; \
-	return check_error(-1, errInfo); \
-     } \
-    }
-
-    MKTIME(ModifyFileTime, pInfo->modifyTime, mtime);
-    MKTIME(AccessFileTime, pInfo->accessTime, atime);
-    MKTIME(CreationFileTime, pInfo->cTime, ctime);
-#undef MKTIME
+    EPOCH_TO_FILETIME(ModifyFileTime,   pInfo->modifyTime);
+    EPOCH_TO_FILETIME(AccessFileTime,   pInfo->accessTime);
+    EPOCH_TO_FILETIME(CreationFileTime, pInfo->cTime);
 
     /*
      * If necessary, set the file times.
      */
 
-    if (modifyTime) {
-	/*
-	 * If the has read only access, we must temporarily turn on
-	 * write access (this is necessary for native filesystems,
-	 * but not for NFS filesystems).
-	 */
+    /*
+     * If the has read only access, we must temporarily turn on
+     * write access (this is necessary for native filesystems,
+     * but not for NFS filesystems).
+     */
 
-	if (tempAttr & FILE_ATTRIBUTE_READONLY) {
-	    tempAttr &= ~FILE_ATTRIBUTE_READONLY;
-	    if (!SetFileAttributesW(wname, tempAttr)) {
-		return set_error(errInfo);
-	    }
+    if (tempAttr & FILE_ATTRIBUTE_READONLY) {
+	tempAttr &= ~FILE_ATTRIBUTE_READONLY;
+	if (!SetFileAttributesW(wname, tempAttr)) {
+	    return set_error(errInfo);
 	}
+    }
 
-	fd = CreateFileW(wname, GENERIC_READ|GENERIC_WRITE,
-			FILE_SHARE_READ | FILE_SHARE_WRITE,
-			NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-	if (fd != INVALID_HANDLE_VALUE) {
-	    BOOL result = SetFileTime(fd, ctime, atime, mtime);
-	    if (!result) {
-		return set_error(errInfo);
-	    }
-	    CloseHandle(fd);
+    fd = CreateFileW(wname, GENERIC_READ|GENERIC_WRITE,
+	    FILE_SHARE_READ | FILE_SHARE_WRITE,
+	    NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (fd != INVALID_HANDLE_VALUE) {
+	BOOL result = SetFileTime(fd, &CreationFileTime, &AccessFileTime, &ModifyFileTime);
+	if (!result) {
+	    return set_error(errInfo);
 	}
+	CloseHandle(fd);
     }
 
     /*
diff --git a/erts/emulator/sys/win32/erl_win_sys.h b/erts/emulator/sys/win32/erl_win_sys.h
index cf3fb4446f..e8453205ea 100644
--- a/erts/emulator/sys/win32/erl_win_sys.h
+++ b/erts/emulator/sys/win32/erl_win_sys.h
@@ -128,6 +128,16 @@ int erts_check_io_debug(void);
  */
 typedef __int64 erts_time_t;
 
+struct tm *sys_localtime_r(time_t *epochs, struct tm *ptm);
+struct tm *sys_gmtime_r(time_t *epochs, struct tm *ptm);
+time_t sys_mktime( struct tm *ptm);
+
+#define localtime_r sys_localtime_r
+#define HAVE_LOCALTIME_R 1
+#define gmtime_r sys_gmtime_r
+#define HAVE_GMTIME_R
+#define mktime sys_mktime
+
 typedef struct {
     erts_time_t tv_sec;
     erts_time_t tv_usec;
diff --git a/erts/emulator/sys/win32/sys_time.c b/erts/emulator/sys/win32/sys_time.c
index e5b9513edc..6362c1a06d 100644
--- a/erts/emulator/sys/win32/sys_time.c
+++ b/erts/emulator/sys/win32/sys_time.c
@@ -35,28 +35,336 @@
 /******************* Routines for time measurement *********************/
 
 #define EPOCH_JULIAN_DIFF LL_LITERAL(11644473600)
+#define TICKS_PER_SECOND LL_LITERAL(10000000)
+#define SECONDS_PER_DAY LL_LITERAL(86400)
 
+#define ULI_TO_FILETIME(ft,ull)			\
+ do {						\
+     (ft).dwLowDateTime = (ull).LowPart;	\
+     (ft).dwHighDateTime = (ull).HighPart;	\
+ } while (0)
+
+#define FILETIME_TO_ULI(ull,ft)			\
+ do {						\
+     (ull).LowPart = (ft).dwLowDateTime;	\
+     (ull).HighPart = (ft).dwHighDateTime;	\
+ } while (0)
+
+
+#define EPOCH_TO_FILETIME(ft, epoch) \
+    do { \
+	ULARGE_INTEGER ull; \
+	ull.QuadPart = (((epoch) + EPOCH_JULIAN_DIFF) * TICKS_PER_SECOND); \
+	ULI_TO_FILETIME(ft,ull); \
+    } while(0)
+
+#define FILETIME_TO_EPOCH(epoch, ft) \
+    do { \
+	ULARGE_INTEGER ull; \
+	FILETIME_TO_ULI(ull,ft); \
+	(epoch) = ((ull.QuadPart / TICKS_PER_SECOND) - EPOCH_JULIAN_DIFF); \
+    } while(0)
+ 
 static SysHrTime wrap = 0;
 static DWORD last_tick_count = 0;
 
+/* Getting timezone information is a heavy operation, so we want to do this 
+   only once */
+
+static TIME_ZONE_INFORMATION static_tzi;
+static int have_static_tzi = 0;
+
+static int days_in_month[2][13] = {
+    {0,31,28,31,30,31,30,31,31,30,31,30,31},
+    {0,31,29,31,30,31,30,31,31,30,31,30,31}};
+
 int 
 sys_init_time(void)
 {
+    if(GetTimeZoneInformation(&static_tzi) && 
+       static_tzi.StandardDate.wMonth != 0 &&
+       static_tzi.DaylightDate.wMonth != 0) {
+	have_static_tzi = 1;
+    }
     return 1;
 }
 
+/* Returns a switchtimes for DST as UTC filetimes given data from a 
+   TIME_ZONE_INFORMATION, see sys_localtime_r for usage. */ 
+static void 
+get_dst_switchtime(DWORD year, 
+		   SYSTEMTIME dstinfo, LONG bias,
+		   FILETIME *utc_switchtime) 
+{
+    DWORD occu;
+    DWORD weekday,wday_1st;
+    DWORD day, days_in;
+    FILETIME tmp,tmp2;
+    ULARGE_INTEGER ull;
+    int leap_year = 0;
+    if (dstinfo.wYear != 0) {
+	/* A year specific transition, in which case the data in the structure
+	   is already properly set for a specific year. Compare year
+	   with parameter and see if they correspond, in that case generate a 
+	   filetime directly, otherwise set the filetime to 0 */
+	if (year != dstinfo.wYear) {
+	    utc_switchtime->dwLowDateTime = utc_switchtime->dwHighDateTime = 0;
+	    return;
+	} 
+    } else {
+	occu = dstinfo.wDay;
+	weekday = dstinfo.wDayOfWeek;
+
+	dstinfo.wDayOfWeek = 0;
+	dstinfo.wDay = 1;
+	dstinfo.wYear = year;
+	
+	SystemTimeToFileTime(&dstinfo,&tmp);
+	ull.LowPart = tmp.dwLowDateTime;
+	ull.HighPart = tmp.dwHighDateTime;
+    
+	ull.QuadPart /= (TICKS_PER_SECOND*SECONDS_PER_DAY); /* Julian Day */
+	wday_1st = (DWORD) ((ull.QuadPart + LL_LITERAL(1)) % LL_LITERAL(7));
+	day = (weekday >= wday_1st) ? 
+	    weekday - wday_1st + 1 :
+	    weekday - wday_1st + 8;
+	--occu;
+	if (((dstinfo.wYear % 4) == 0 && (dstinfo.wYear % 100) > 0) ||
+	    ((dstinfo.wYear % 400) == 0)) {
+	    leap_year = 1;
+	}
+	days_in = days_in_month[leap_year][dstinfo.wMonth];
+	while (occu > 0 && (day + 7 <= days_in)) {
+	    --occu;
+	    day += 7;
+	}
+	dstinfo.wDay = day;
+    }
+    SystemTimeToFileTime(&dstinfo,&tmp);
+    /* correct for bias */
+    ull.LowPart = tmp.dwLowDateTime;
+    ull.HighPart = tmp.dwHighDateTime;
+    ull.QuadPart += (((LONGLONG) bias) * LL_LITERAL(60) * TICKS_PER_SECOND);
+    utc_switchtime->dwLowDateTime = ull.LowPart;
+    utc_switchtime->dwHighDateTime = ull.HighPart;
+    return;
+}
+
+/* This function gives approximately the correct year from a FILETIME
+   Around the actual new year, it may return the wrong value, but that's OK
+   as DST never switches around new year. */
+static DWORD 
+approx_year(FILETIME ft)
+{
+    ULARGE_INTEGER ull;
+    FILETIME_TO_ULI(ull,ft);
+    ull.QuadPart /= LL_LITERAL(1000);
+    ull.QuadPart /= SECONDS_PER_DAY;
+    ull.QuadPart /= LL_LITERAL(3652425);
+    ull.QuadPart += 1601;
+    return (DWORD) ull.QuadPart;
+}
+
+struct tm *
+sys_localtime_r(time_t *epochs, struct tm *ptm)
+{
+    FILETIME ft,lft;
+    SYSTEMTIME st;
+    
+    if ((((*epochs) + EPOCH_JULIAN_DIFF) * TICKS_PER_SECOND) < 0LL) {
+	fprintf(stderr,"1\r\n"); fflush(stderr);
+	return NULL;
+    }
+    
+    EPOCH_TO_FILETIME(ft,*epochs);
+    ptm->tm_isdst = 0;
+    if (have_static_tzi) {
+	FILETIME dst_start, dst_stop;
+	ULARGE_INTEGER ull;
+	DWORD year = approx_year(ft);
+	get_dst_switchtime(year,static_tzi.DaylightDate,
+			   static_tzi.Bias+static_tzi.StandardBias,&dst_start);
+	get_dst_switchtime(year,static_tzi.StandardDate,
+			   static_tzi.Bias+static_tzi.StandardBias+
+			   static_tzi.DaylightBias,
+			   &dst_stop);
+	FILETIME_TO_ULI(ull,ft);
+
+	if (CompareFileTime(&ft,&dst_start) >= 0 && 
+	    CompareFileTime(&ft,&dst_stop) < 0) {
+	    ull.QuadPart -= 
+		((LONGLONG) static_tzi.Bias+static_tzi.StandardBias+
+		 static_tzi.DaylightBias) * 
+		LL_LITERAL(60) * TICKS_PER_SECOND;
+	    ptm->tm_isdst = 1;
+	} else {
+	    ull.QuadPart -= 
+		((LONGLONG) static_tzi.Bias+static_tzi.StandardBias) 
+		* LL_LITERAL(60) * TICKS_PER_SECOND;
+	}
+	ULI_TO_FILETIME(ft,ull);
+    } else {
+	if (!FileTimeToLocalFileTime(&ft,&lft)) {
+	    return NULL;
+	}
+	ft = lft;
+    }
+    
+    if (!FileTimeToSystemTime(&ft,&st)) {
+	return NULL;
+    }
+    
+    ptm->tm_year = (int) st.wYear - 1900;
+    ptm->tm_mon  = (int) st.wMonth - 1;
+    ptm->tm_mday = (int) st.wDay;
+    ptm->tm_hour = (int) st.wHour;
+    ptm->tm_min  = (int) st.wMinute;
+    ptm->tm_sec  = (int) st.wSecond;
+    ptm->tm_wday  = (int) st.wDayOfWeek;
+    {
+	int yday = ptm->tm_mday - 1;
+	int m =  ptm->tm_mon;
+	int leap_year = 0;
+	if (((st.wYear % 4) == 0 && (st.wYear % 100) > 0) ||
+	    ((st.wYear % 400) == 0)) {
+	    leap_year = 1;
+	}
+	while (m > 0) {
+	    yday +=days_in_month[leap_year][m];
+	    --m;
+	}
+	ptm->tm_yday = yday;
+    }
+    return ptm;
+}
+
+struct tm * 
+sys_gmtime_r(time_t *epochs, struct tm *ptm)
+{
+    FILETIME ft;
+    SYSTEMTIME st;
+    
+    if ((((*epochs) + EPOCH_JULIAN_DIFF) * TICKS_PER_SECOND) < 0LL) {
+	return NULL;
+    }
+    
+    EPOCH_TO_FILETIME(ft,*epochs);
+    
+    if (!FileTimeToSystemTime(&ft,&st)) {
+	return NULL;
+    }
+    
+    ptm->tm_year = (int) st.wYear - 1900;
+    ptm->tm_mon  = (int) st.wMonth - 1;
+    ptm->tm_mday = (int) st.wDay;
+    ptm->tm_hour = (int) st.wHour;
+    ptm->tm_min  = (int) st.wMinute;
+    ptm->tm_sec  = (int) st.wSecond;
+    ptm->tm_wday  = (int) st.wDayOfWeek;
+    ptm->tm_isdst  = 0;
+    {
+	int yday = ptm->tm_mday - 1;
+	int m =  ptm->tm_mon;
+	int leap_year = 0;
+	if (((st.wYear % 4) == 0 && (st.wYear % 100) > 0) ||
+	    ((st.wYear % 400) == 0)) {
+	    leap_year = 1;
+	}
+	while (m > 0) {
+	    yday +=days_in_month[leap_year][m];
+	    --m;
+	}
+	ptm->tm_yday = yday;
+    }
+
+    return ptm;
+}
+
+time_t 
+sys_mktime(struct tm *ptm) 
+{
+    FILETIME ft;
+    SYSTEMTIME st;
+    int dst = 0;
+    time_t epochs;
+
+    memset(&st,0,sizeof(st));
+    /* Convert relevant parts of truct tm to SYSTEMTIME */
+    st.wYear =  (USHORT) (ptm->tm_year + 1900);
+    st.wMonth =  (USHORT) (ptm->tm_mon + 1);
+    st.wDay =  (USHORT) ptm->tm_mday;
+    st.wHour =  (USHORT) ptm->tm_hour;
+    st.wMinute =  (USHORT) ptm->tm_min;
+    st.wSecond = (USHORT) ptm->tm_sec;
+
+    SystemTimeToFileTime(&st,&ft);
+    
+    /* ft is now some kind of local file time, but it may be wrong depending 
+       on what is in the tm_dst field. We need to manually convert it to
+       UTC before turning it into epochs */
+
+    if (have_static_tzi) {
+	FILETIME dst_start, dst_stop;
+	ULARGE_INTEGER ull_start,ull_stop,ull_ft;
+
+	FILETIME_TO_ULI(ull_ft,ft);
+
+	/* Correct everything except DST */
+	ull_ft.QuadPart += (static_tzi.Bias+static_tzi.StandardBias) 
+	    * LL_LITERAL(60) * TICKS_PER_SECOND;
+
+	/* Determine if DST is active */
+	if (ptm->tm_isdst >= 0) {
+	    dst = ptm->tm_isdst;
+	} else if (static_tzi.DaylightDate.wMonth != 0){
+	    /* This is how windows mktime does it, meaning it does not
+	       take nonexisting local times into account */
+	    get_dst_switchtime(st.wYear,static_tzi.DaylightDate,
+			       static_tzi.Bias+static_tzi.StandardBias,
+			       &dst_start);
+	    get_dst_switchtime(st.wYear,static_tzi.StandardDate,
+			       static_tzi.Bias+static_tzi.StandardBias+
+			       static_tzi.DaylightBias,
+			       &dst_stop);
+	    FILETIME_TO_ULI(ull_start,dst_start);
+	    FILETIME_TO_ULI(ull_stop,dst_stop);
+	    if ((ull_ft.QuadPart >= ull_start.QuadPart) &&
+		(ull_ft.QuadPart < ull_stop.QuadPart)) {
+		/* We are in DST */
+		dst = 1;
+	    }
+	}
+	/* Correct for DST */
+	if (dst) {
+	    ull_ft.QuadPart += static_tzi.DaylightBias * 
+		LL_LITERAL(60) * TICKS_PER_SECOND;
+	}
+	epochs = ((ull_ft.QuadPart / TICKS_PER_SECOND) - EPOCH_JULIAN_DIFF);
+    } else {
+	/* No DST, life is easy... */
+	FILETIME lft;
+	LocalFileTimeToFileTime(&ft,&lft);
+	FILETIME_TO_EPOCH(epochs,lft);
+    }
+    /* Normalize the struct tm */
+    sys_localtime_r(&epochs,ptm);
+    return epochs;
+}
+
 void 
 sys_gettimeofday(SysTimeval *tv)
 {
     SYSTEMTIME t;
     FILETIME ft;
-    LONGLONG lft;
+    ULARGE_INTEGER ull;
 
     GetSystemTime(&t);
     SystemTimeToFileTime(&t, &ft);
-    memcpy(&lft, &ft, sizeof(lft));
-    tv->tv_usec = (erts_time_t) ((lft / LL_LITERAL(10)) % LL_LITERAL(1000000));
-    tv->tv_sec = (erts_time_t) ((lft / LL_LITERAL(10000000)) - EPOCH_JULIAN_DIFF);
+    FILETIME_TO_ULI(ull,ft);
+    tv->tv_usec = (long) ((ull.QuadPart / LL_LITERAL(10)) % 
+			  LL_LITERAL(1000000));
+    tv->tv_sec = (long) ((ull.QuadPart / LL_LITERAL(10000000)) - 
+			 EPOCH_JULIAN_DIFF);
 }
 
 SysHrTime 
@@ -91,9 +399,3 @@ sys_times(SysTimes *buffer) {
     buffer->tms_stime = (clock_t) (system & LL_LITERAL(0x7FFFFFFF));
     return kernel_ticks;
 }
-
-
-
-
-
-
diff --git a/erts/emulator/test/time_SUITE.erl b/erts/emulator/test/time_SUITE.erl
index bd48a0a7db..4d12e3449c 100644
--- a/erts/emulator/test/time_SUITE.erl
+++ b/erts/emulator/test/time_SUITE.erl
@@ -32,6 +32,7 @@
 -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
 	 init_per_group/2,end_per_group/2, univ_to_local/1, local_to_univ/1,
 	 bad_univ_to_local/1, bad_local_to_univ/1,
+	 univ_to_seconds/1, seconds_to_univ/1,
 	 consistency/1,
 	 now_unique/1, now_update/1, timestamp/1]).
 
@@ -59,7 +60,9 @@ suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
     [univ_to_local, local_to_univ, local_to_univ_utc,
-     bad_univ_to_local, bad_local_to_univ, consistency,
+     bad_univ_to_local, bad_local_to_univ, 
+     univ_to_seconds, seconds_to_univ,
+     consistency,
      {group, now}, timestamp].
 
 groups() -> 
@@ -162,6 +165,30 @@ bad_test_local_to_univ([Local|Rest]) ->
 bad_test_local_to_univ([]) ->
     ok.
 
+
+%% Test universaltime to seconds conversions
+univ_to_seconds(Config) when is_list(Config) ->
+    test_univ_to_seconds(ok_utc_seconds()).
+
+test_univ_to_seconds([{Datetime, Seconds}|DSs]) ->
+    io:format("universaltime = ~p -> seconds = ~p", [Datetime, Seconds]),
+    Seconds = erlang:universaltime_to_posixtime(Datetime),
+    test_univ_to_seconds(DSs);
+test_univ_to_seconds([]) -> 
+    ok.
+
+%% Test seconds to universaltime conversions
+seconds_to_univ(Config) when is_list(Config) ->
+    test_seconds_to_univ(ok_utc_seconds()).
+
+test_seconds_to_univ([{Datetime, Seconds}|DSs]) ->
+    io:format("universaltime = ~p <- seconds = ~p", [Datetime, Seconds]),
+    Datetime = erlang:posixtime_to_universaltime(Seconds),
+    test_seconds_to_univ(DSs);
+test_seconds_to_univ([]) -> 
+    ok.
+
+
 %% Test that the the different time functions return
 %% consistent results. (See the test case for assumptions
 %% and limitations.)
@@ -453,6 +480,32 @@ dst_dates() ->
      {1998, 06, 3},
      {1999, 06, 4}].
 
+%% exakt utc {date(), time()} which corresponds to the same seconds since 1 jan 1970 
+%% negative seconds are ok
+%% generated with date --date='1979-05-28 12:30:35 UTC' +%s
+ok_utc_seconds() -> [
+	{ {{1970, 1, 1},{ 0, 0, 0}},            0 },
+	{ {{1970, 1, 1},{ 0, 0, 1}},            1 },
+	{ {{1969,12,31},{23,59,59}},           -1 },
+	{ {{1920,12,31},{23,59,59}},  -1546300801 },
+	{ {{1600,02,19},{15,14,08}}, -11671807552 },
+	{ {{1979,05,28},{12,30,35}},    296742635 },
+	{ {{1999,12,31},{23,59,59}},    946684799 },
+	{ {{2000, 1, 1},{ 0, 0, 0}},    946684800 },
+	{ {{2000, 1, 1},{ 0, 0, 1}},    946684801 },
+
+	{ {{2038, 1,19},{03,14,07}},   2147483647 }, % Sint32 full - 1
+	{ {{2038, 1,19},{03,14,08}},   2147483648 }, % Sint32 full
+	{ {{2038, 1,19},{03,14,09}},   2147483649 }, % Sint32 full + 1
+
+	{ {{2106, 2, 7},{ 6,28,14}},   4294967294 }, % Uint32 full  0xFFFFFFFF - 1
+	{ {{2106, 2, 7},{ 6,28,15}},   4294967295 }, % Uint32 full  0xFFFFFFFF
+	{ {{2106, 2, 7},{ 6,28,16}},   4294967296 }, % Uint32 full  0xFFFFFFFF + 1
+	{ {{2012,12, 6},{16,28,08}},   1354811288 },
+	{ {{2412,12, 6},{16,28,08}},  13977592088 }
+    ].
+
+
 %% The following dates should not be near the end or beginning of
 %% a month, because they will be used to test when the dates are
 %% different in UTC and local time.