]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/btime.c
ebl add Error status in update volume=xxx status=yyyy
[bacula/bacula] / bacula / src / lib / btime.c
1 /*
2  * Bacula floating point time and date routines -- John Walker
3  *
4  * Later double precision integer time/date routines -- Kern Sibbald
5  *
6  *   Version $Id$
7  */
8 /*
9    Bacula® - The Network Backup Solution
10
11    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
12
13    The main author of Bacula is Kern Sibbald, with contributions from
14    many others, a complete list can be found in the file AUTHORS.
15    This program is Free Software; you can redistribute it and/or
16    modify it under the terms of version two of the GNU General Public
17    License as published by the Free Software Foundation plus additions
18    that are listed in the file LICENSE.
19
20    This program is distributed in the hope that it will be useful, but
21    WITHOUT ANY WARRANTY; without even the implied warranty of
22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23    General Public License for more details.
24
25    You should have received a copy of the GNU General Public License
26    along with this program; if not, write to the Free Software
27    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
28    02110-1301, USA.
29
30    Bacula® is a registered trademark of John Walker.
31    The licensor of Bacula is the Free Software Foundation Europe
32    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
33    Switzerland, email:ftf@fsfeurope.org.
34 */
35
36
37 /* Concerning times. There are a number of differnt time standards
38  * in Bacula (fdate_t, ftime_t, time_t (Unix standard), btime_t, and
39  *  utime_t).  fdate_t and ftime_t are deprecated and should no longer
40  *  be used, and in general, Unix time time_t should no longer be used,
41  *  it is being phased out.
42  *
43  *  Epoch is the base of Unix time in seconds (time_t, ...)
44  *     and is 1 Jan 1970 at 0:0 UTC
45  *
46  *  The major two times that should be left are:
47  *     btime_t  (64 bit integer in microseconds base Epoch)
48  *     utime_t  (64 bit integer in seconds base Epoch)
49  */
50
51 #include "bacula.h"
52 #include <math.h>
53
54 /* Formatted time for user display: dd-Mon-yyyy hh:mm */
55 char *bstrftime(char *dt, int maxlen, utime_t tim)
56 {
57    time_t ttime = (time_t)tim;
58    struct tm tm;
59
60    /* ***FIXME**** the format and localtime_r() should be user configurable */
61    (void)localtime_r(&ttime, &tm);
62    strftime(dt, maxlen, "%d-%b-%Y %H:%M", &tm);
63    return dt;
64 }
65
66 /* Formatted time for user display: dd-Mon-yyyy hh:mm:ss */
67 char *bstrftimes(char *dt, int maxlen, utime_t tim)
68 {
69    time_t ttime = (time_t)tim;
70    struct tm tm;
71
72    /* ***FIXME**** the format and localtime_r() should be user configurable */
73    (void)localtime_r(&ttime, &tm);
74    strftime(dt, maxlen, "%d-%b-%Y %H:%M:%S", &tm);
75    return dt;
76 }
77
78
79 /* Formatted time for user display: dd-Mon hh:mm */
80 char *bstrftime_ny(char *dt, int maxlen, utime_t tim)
81 {
82    time_t ttime = (time_t)tim;
83    struct tm tm;
84
85    /* ***FIXME**** the format and localtime_r() should be user configurable */
86    (void)localtime_r(&ttime, &tm);
87    strftime(dt, maxlen, "%d-%b %H:%M", &tm);
88    return dt;
89 }
90
91
92 /* Formatted time for user display: dd-Mon-yy hh:mm  (no century) */
93 char *bstrftime_nc(char *dt, int maxlen, utime_t tim)
94 {
95    time_t ttime = (time_t)tim;
96    struct tm tm;
97
98    /* ***FIXME**** the format and localtime_r() should be user configurable */
99    (void)localtime_r(&ttime, &tm);
100    /* NOTE! since the compiler complains about %y, I use %y and cut the century */
101    strftime(dt, maxlen, "%d-%b-%Y %H:%M", &tm);
102    strcpy(dt+7, dt+9);
103    return dt;
104 }
105
106
107 /* Unix time to standard time string yyyy-mm-dd hh:mm:ss */
108 char *bstrutime(char *dt, int maxlen, utime_t tim)
109 {
110    time_t ttime = (time_t)tim;
111    struct tm tm;
112    (void)localtime_r(&ttime, &tm);
113    strftime(dt, maxlen, "%Y-%m-%d %H:%M:%S", &tm);
114    return dt;
115 }
116
117 /* Convert standard time string yyyy-mm-dd hh:mm:ss to Unix time */
118 utime_t str_to_utime(char *str)
119 {
120    struct tm tm;
121    time_t ttime;
122
123    /* Check for bad argument */
124    if (!str || *str == 0) {
125       return 0;
126    }
127
128    if (sscanf(str, "%d-%d-%d %d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
129                                         &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
130       return 0;
131    }
132    if (tm.tm_mon > 0) {
133       tm.tm_mon--;
134    } else {
135       return 0;
136    }
137    if (tm.tm_year >= 1900) {
138       tm.tm_year -= 1900;
139    } else {
140       return 0;
141    }
142    tm.tm_wday = tm.tm_yday = 0;
143    tm.tm_isdst = -1;
144    ttime = mktime(&tm);
145    if (ttime == -1) {
146       ttime = 0;
147    }
148    return (utime_t)ttime;
149 }
150
151
152 /*
153  * Bacula's time (btime_t) is an unsigned 64 bit integer that contains
154  *   the number of microseconds since Epoch Time (1 Jan 1970) UTC.
155  */
156
157 btime_t get_current_btime()
158 {
159    struct timeval tv;
160    if (gettimeofday(&tv, NULL) != 0) {
161       tv.tv_sec = (long)time(NULL);   /* fall back to old method */
162       tv.tv_usec = 0;
163    }
164    return ((btime_t)tv.tv_sec) * 1000000 + (btime_t)tv.tv_usec;
165 }
166
167 /* Convert btime to Unix time */
168 time_t btime_to_unix(btime_t bt)
169 {
170    return (time_t)(bt/1000000);
171 }
172
173 /* Convert btime to utime */
174 utime_t btime_to_utime(btime_t bt)
175 {
176    return (utime_t)(bt/1000000);
177 }
178
179 /*
180  * Return the week of the month, base 0 (wom)
181  *   given tm_mday and tm_wday. Value returned
182  *   can be from 0 to 4 => week1, ... week5
183  */
184 int tm_wom(int mday, int wday)
185 {
186    int fs;                       /* first sunday */
187    fs = (mday%7) - wday;
188    if (fs <= 0) {
189       fs += 7;
190    }
191    if (mday <= fs) {
192 //    Dmsg3(100, "mday=%d wom=0 wday=%d <= fs=%d\n", mday, wday, fs);
193       return 0;
194    }
195    int wom = 1 + (mday - fs - 1) / 7;
196 // Dmsg4(100, "mday=%d wom=%d wday=%d fs=%d\n", mday, wom, wday, fs);
197    return wom;
198 }
199
200 /*
201  * Given a Unix date return the week of the year.
202  * The returned value can be 0-53.  Officially
203  * the weeks are numbered from 1 to 53 where week1
204  * is the week in which the first Thursday of the
205  * year occurs (alternatively, the week which contains
206  * the 4th of January).  We return 0, if the week of the
207  * year does not fall in the current year.
208  */
209 int tm_woy(time_t stime)
210 {
211    int woy, fty, tm_yday;
212    time_t time4;
213    struct tm tm;
214    memset(&tm, 0, sizeof(struct tm));
215    (void)localtime_r(&stime, &tm);
216    tm_yday = tm.tm_yday;
217    tm.tm_mon = 0;
218    tm.tm_mday = 4;
219    time4 = mktime(&tm);
220    (void)localtime_r(&time4, &tm);
221    fty = 1 - tm.tm_wday;
222    if (fty <= 0) {
223       fty += 7;
224    }
225    woy = tm_yday - fty + 4;
226    if (woy < 0) {
227       return 0;
228    }
229    return 1 + woy / 7;
230 }
231
232 /* Deprecated. Do not use. */
233 void get_current_time(struct date_time *dt)
234 {
235    struct tm tm;
236    time_t now;
237
238    now = time(NULL);
239    (void)gmtime_r(&now, &tm);
240    Dmsg6(200, "m=%d d=%d y=%d h=%d m=%d s=%d\n", tm.tm_mon+1, tm.tm_mday, tm.tm_year+1900,
241       tm.tm_hour, tm.tm_min, tm.tm_sec);
242    tm_encode(dt, &tm);
243 #ifdef DEBUG
244    Dmsg2(200, "jday=%f jmin=%f\n", dt->julian_day_number, dt->julian_day_fraction);
245    tm_decode(dt, &tm);
246    Dmsg6(200, "m=%d d=%d y=%d h=%d m=%d s=%d\n", tm.tm_mon+1, tm.tm_mday, tm.tm_year+1900,
247       tm.tm_hour, tm.tm_min, tm.tm_sec);
248 #endif
249 }
250
251
252 /*  date_encode  --  Encode civil date as a Julian day number.  */
253
254 /* Deprecated. Do not use. */
255 fdate_t date_encode(uint32_t year, uint8_t month, uint8_t day)
256 {
257
258     /* Algorithm as given in Meeus, Astronomical Algorithms, Chapter 7, page 61 */
259
260     int32_t a, b, m;
261     uint32_t y;
262
263     ASSERT(month < 13);
264     ASSERT(day > 0 && day < 32);
265
266     m = month;
267     y = year;
268
269     if (m <= 2) {
270         y--;
271         m += 12;
272     }
273
274     /* Determine whether date is in Julian or Gregorian calendar based on
275        canonical date of calendar reform. */
276
277     if ((year < 1582) || ((year == 1582) && ((month < 9) || (month == 9 && day < 5)))) {
278         b = 0;
279     } else {
280         a = ((int) (y / 100));
281         b = 2 - a + (a / 4);
282     }
283
284     return (((int32_t) (365.25 * (y + 4716))) + ((int) (30.6001 * (m + 1))) +
285                 day + b - 1524.5);
286 }
287
288 /*  time_encode  --  Encode time from hours, minutes, and seconds
289                      into a fraction of a day.  */
290
291 /* Deprecated. Do not use. */
292 ftime_t time_encode(uint8_t hour, uint8_t minute, uint8_t second,
293                    float32_t second_fraction)
294 {
295     ASSERT((second_fraction >= 0.0) || (second_fraction < 1.0));
296     return (ftime_t) (((second + 60L * (minute + 60L * hour)) / 86400.0)) +
297                      second_fraction;
298 }
299
300 /*  date_time_encode  --  Set day number and fraction from date
301                           and time.  */
302
303 /* Deprecated. Do not use. */
304 void date_time_encode(struct date_time *dt,
305                       uint32_t year, uint8_t month, uint8_t day,
306                       uint8_t hour, uint8_t minute, uint8_t second,
307                       float32_t second_fraction)
308 {
309     dt->julian_day_number = date_encode(year, month, day);
310     dt->julian_day_fraction = time_encode(hour, minute, second, second_fraction);
311 }
312
313 /*  date_decode  --  Decode a Julian day number into civil date.  */
314
315 /* Deprecated. Do not use. */
316 void date_decode(fdate_t date, uint32_t *year, uint8_t *month,
317                  uint8_t *day)
318 {
319     fdate_t z, f, a, alpha, b, c, d, e;
320
321     date += 0.5;
322     z = floor(date);
323     f = date - z;
324
325     if (z < 2299161.0) {
326         a = z;
327     } else {
328         alpha = floor((z - 1867216.25) / 36524.25);
329         a = z + 1 + alpha - floor(alpha / 4);
330     }
331
332     b = a + 1524;
333     c = floor((b - 122.1) / 365.25);
334     d = floor(365.25 * c);
335     e = floor((b - d) / 30.6001);
336
337     *day = (uint8_t) (b - d - floor(30.6001 * e) + f);
338     *month = (uint8_t) ((e < 14) ? (e - 1) : (e - 13));
339     *year = (uint32_t) ((*month > 2) ? (c - 4716) : (c - 4715));
340 }
341
342 /*  time_decode  --  Decode a day fraction into civil time.  */
343
344 /* Deprecated. Do not use. */
345 void time_decode(ftime_t time, uint8_t *hour, uint8_t *minute,
346                  uint8_t *second, float32_t *second_fraction)
347 {
348     uint32_t ij;
349
350     ij = (uint32_t) ((time - floor(time)) * 86400.0);
351     *hour = (uint8_t) (ij / 3600L);
352     *minute = (uint8_t) ((ij / 60L) % 60L);
353     *second = (uint8_t) (ij % 60L);
354     if (second_fraction != NULL) {
355         *second_fraction = (float32_t)(time - floor(time));
356     }
357 }
358
359 /*  date_time_decode  --  Decode a Julian day and day fraction
360                           into civil date and time.  */
361
362 /* Deprecated. Do not use. */
363 void date_time_decode(struct date_time *dt,
364                       uint32_t *year, uint8_t *month, uint8_t *day,
365                       uint8_t *hour, uint8_t *minute, uint8_t *second,
366                       float32_t *second_fraction)
367 {
368     date_decode(dt->julian_day_number, year, month, day);
369     time_decode(dt->julian_day_fraction, hour, minute, second, second_fraction);
370 }
371
372 /*  tm_encode  --  Encode a civil date and time from a tm structure
373  *                 to a Julian day and day fraction.
374  */
375
376 /* Deprecated. Do not use. */
377 void tm_encode(struct date_time *dt,
378                       struct tm *tm)
379 {
380     uint32_t year;
381     uint8_t month, day, hour, minute, second;
382
383     year = tm->tm_year + 1900;
384     month = tm->tm_mon + 1;
385     day = tm->tm_mday;
386     hour = tm->tm_hour;
387     minute = tm->tm_min;
388     second = tm->tm_sec;
389     dt->julian_day_number = date_encode(year, month, day);
390     dt->julian_day_fraction = time_encode(hour, minute, second, 0.0);
391 }
392
393
394 /*  tm_decode  --  Decode a Julian day and day fraction
395                    into civil date and time in tm structure */
396
397 /* Deprecated. Do not use. */
398 void tm_decode(struct date_time *dt,
399                       struct tm *tm)
400 {
401     uint32_t year;
402     uint8_t month, day, hour, minute, second;
403
404     date_decode(dt->julian_day_number, &year, &month, &day);
405     time_decode(dt->julian_day_fraction, &hour, &minute, &second, NULL);
406     tm->tm_year = year - 1900;
407     tm->tm_mon = month - 1;
408     tm->tm_mday = day;
409     tm->tm_hour = hour;
410     tm->tm_min = minute;
411     tm->tm_sec = second;
412 }
413
414
415 /*  date_time_compare  --  Compare two dates and times and return
416                            the relationship as follows:
417
418                                     -1    dt1 < dt2
419                                      0    dt1 = dt2
420                                      1    dt1 > dt2
421 */
422
423 /* Deprecated. Do not use. */
424 int date_time_compare(struct date_time *dt1, struct date_time *dt2)
425 {
426     if (dt1->julian_day_number == dt2->julian_day_number) {
427         if (dt1->julian_day_fraction == dt2->julian_day_fraction) {
428             return 0;
429         }
430         return (dt1->julian_day_fraction < dt2->julian_day_fraction) ? -1 : 1;
431     }
432     return (dt1->julian_day_number - dt2->julian_day_number) ? -1 : 1;
433 }