lh | 9ed821d | 2023-04-07 01:36:19 -0700 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
| 2 | /* |
| 3 | * Utility routines. |
| 4 | * |
| 5 | * Copyright (C) 2007 Denys Vlasenko |
| 6 | * |
| 7 | * Licensed under GPLv2, see file LICENSE in this source tree. |
| 8 | */ |
| 9 | #include "libbb.h" |
| 10 | |
| 11 | void FAST_FUNC parse_datestr(const char *date_str, struct tm *ptm) |
| 12 | { |
| 13 | char end = '\0'; |
| 14 | const char *last_colon = strrchr(date_str, ':'); |
| 15 | |
| 16 | if (last_colon != NULL) { |
| 17 | /* Parse input and assign appropriately to ptm */ |
| 18 | #if ENABLE_DESKTOP |
| 19 | const char *endp; |
| 20 | #endif |
| 21 | |
| 22 | /* HH:MM */ |
| 23 | if (sscanf(date_str, "%u:%u%c", |
| 24 | &ptm->tm_hour, |
| 25 | &ptm->tm_min, |
| 26 | &end) >= 2) { |
| 27 | /* no adjustments needed */ |
| 28 | } else |
| 29 | /* mm.dd-HH:MM */ |
| 30 | if (sscanf(date_str, "%u.%u-%u:%u%c", |
| 31 | &ptm->tm_mon, &ptm->tm_mday, |
| 32 | &ptm->tm_hour, &ptm->tm_min, |
| 33 | &end) >= 4) { |
| 34 | /* Adjust month from 1-12 to 0-11 */ |
| 35 | ptm->tm_mon -= 1; |
| 36 | } else |
| 37 | /* yyyy.mm.dd-HH:MM */ |
| 38 | if (sscanf(date_str, "%u.%u.%u-%u:%u%c", &ptm->tm_year, |
| 39 | &ptm->tm_mon, &ptm->tm_mday, |
| 40 | &ptm->tm_hour, &ptm->tm_min, |
| 41 | &end) >= 5) { |
| 42 | ptm->tm_year -= 1900; /* Adjust years */ |
| 43 | ptm->tm_mon -= 1; /* Adjust month from 1-12 to 0-11 */ |
| 44 | } else |
| 45 | /* yyyy-mm-dd HH:MM */ |
| 46 | if (sscanf(date_str, "%u-%u-%u %u:%u%c", &ptm->tm_year, |
| 47 | &ptm->tm_mon, &ptm->tm_mday, |
| 48 | &ptm->tm_hour, &ptm->tm_min, |
| 49 | &end) >= 5) { |
| 50 | ptm->tm_year -= 1900; /* Adjust years */ |
| 51 | ptm->tm_mon -= 1; /* Adjust month from 1-12 to 0-11 */ |
| 52 | } else |
| 53 | #if ENABLE_DESKTOP /* strptime is BIG: ~1k in uclibc, ~10k in glibc */ |
| 54 | /* month_name d HH:MM:SS YYYY. Supported by GNU date */ |
| 55 | if ((endp = strptime(date_str, "%b %d %T %Y", ptm)) != NULL |
| 56 | && *endp == '\0' |
| 57 | ) { |
| 58 | return; /* don't fall through to end == ":" check */ |
| 59 | } else |
| 60 | #endif |
| 61 | //TODO: coreutils 6.9 also accepts "yyyy-mm-dd HH" (no minutes) |
| 62 | { |
| 63 | bb_error_msg_and_die(bb_msg_invalid_date, date_str); |
| 64 | } |
| 65 | if (end == ':') { |
| 66 | /* xxx:SS */ |
| 67 | if (sscanf(last_colon + 1, "%u%c", &ptm->tm_sec, &end) == 1) |
| 68 | end = '\0'; |
| 69 | /* else end != NUL and we error out */ |
| 70 | } |
| 71 | } else if (date_str[0] == '@') { |
| 72 | time_t t = bb_strtol(date_str + 1, NULL, 10); |
| 73 | if (!errno) { |
| 74 | struct tm *lt = localtime(&t); |
| 75 | if (lt) { |
| 76 | *ptm = *lt; |
| 77 | return; |
| 78 | } |
| 79 | } |
| 80 | end = '1'; |
| 81 | } else { |
| 82 | /* Googled the following on an old date manpage: |
| 83 | * |
| 84 | * The canonical representation for setting the date/time is: |
| 85 | * cc Century (either 19 or 20) |
| 86 | * yy Year in abbreviated form (e.g. 89, 06) |
| 87 | * mm Numeric month, a number from 1 to 12 |
| 88 | * dd Day, a number from 1 to 31 |
| 89 | * HH Hour, a number from 0 to 23 |
| 90 | * MM Minutes, a number from 0 to 59 |
| 91 | * .SS Seconds, a number from 0 to 61 (with leap seconds) |
| 92 | * Everything but the minutes is optional |
| 93 | * |
| 94 | * "touch -t DATETIME" format: [[[[[YY]YY]MM]DD]hh]mm[.ss] |
| 95 | * Some, but not all, Unix "date DATETIME" commands |
| 96 | * move [[YY]YY] past minutes mm field (!). |
| 97 | * Coreutils date does it, and SUS mandates it. |
| 98 | * (date -s DATETIME does not support this format. lovely!) |
| 99 | * In bbox, this format is special-cased in date applet |
| 100 | * (IOW: this function assumes "touch -t" format). |
| 101 | */ |
| 102 | unsigned cur_year = ptm->tm_year; |
| 103 | int len = strchrnul(date_str, '.') - date_str; |
| 104 | |
| 105 | /* MM[.SS] */ |
| 106 | if (len == 2 && sscanf(date_str, "%2u%2u%2u%2u""%2u%c" + 12, |
| 107 | &ptm->tm_min, |
| 108 | &end) >= 1) { |
| 109 | } else |
| 110 | /* HHMM[.SS] */ |
| 111 | if (len == 4 && sscanf(date_str, "%2u%2u%2u""%2u%2u%c" + 9, |
| 112 | &ptm->tm_hour, |
| 113 | &ptm->tm_min, |
| 114 | &end) >= 2) { |
| 115 | } else |
| 116 | /* ddHHMM[.SS] */ |
| 117 | if (len == 6 && sscanf(date_str, "%2u%2u""%2u%2u%2u%c" + 6, |
| 118 | &ptm->tm_mday, |
| 119 | &ptm->tm_hour, |
| 120 | &ptm->tm_min, |
| 121 | &end) >= 3) { |
| 122 | } else |
| 123 | /* mmddHHMM[.SS] */ |
| 124 | if (len == 8 && sscanf(date_str, "%2u""%2u%2u%2u%2u%c" + 3, |
| 125 | &ptm->tm_mon, |
| 126 | &ptm->tm_mday, |
| 127 | &ptm->tm_hour, |
| 128 | &ptm->tm_min, |
| 129 | &end) >= 4) { |
| 130 | /* Adjust month from 1-12 to 0-11 */ |
| 131 | ptm->tm_mon -= 1; |
| 132 | } else |
| 133 | /* yymmddHHMM[.SS] */ |
| 134 | if (len == 10 && sscanf(date_str, "%2u%2u%2u%2u%2u%c", |
| 135 | &ptm->tm_year, |
| 136 | &ptm->tm_mon, |
| 137 | &ptm->tm_mday, |
| 138 | &ptm->tm_hour, |
| 139 | &ptm->tm_min, |
| 140 | &end) >= 5) { |
| 141 | /* Adjust month from 1-12 to 0-11 */ |
| 142 | ptm->tm_mon -= 1; |
| 143 | if ((int)cur_year >= 50) { /* >= 1950 */ |
| 144 | /* Adjust year: */ |
| 145 | /* 1. Put it in the current century */ |
| 146 | ptm->tm_year += (cur_year / 100) * 100; |
| 147 | /* 2. If too far in the past, +100 years */ |
| 148 | if (ptm->tm_year < cur_year - 50) |
| 149 | ptm->tm_year += 100; |
| 150 | /* 3. If too far in the future, -100 years */ |
| 151 | if (ptm->tm_year > cur_year + 50) |
| 152 | ptm->tm_year -= 100; |
| 153 | } |
| 154 | } else |
| 155 | /* ccyymmddHHMM[.SS] */ |
| 156 | if (len == 12 && sscanf(date_str, "%4u%2u%2u%2u%2u%c", |
| 157 | &ptm->tm_year, |
| 158 | &ptm->tm_mon, |
| 159 | &ptm->tm_mday, |
| 160 | &ptm->tm_hour, |
| 161 | &ptm->tm_min, |
| 162 | &end) >= 5) { |
| 163 | ptm->tm_year -= 1900; /* Adjust years */ |
| 164 | ptm->tm_mon -= 1; /* Adjust month from 1-12 to 0-11 */ |
| 165 | } else { |
| 166 | bb_error_msg_and_die(bb_msg_invalid_date, date_str); |
| 167 | } |
| 168 | if (end == '.') { |
| 169 | /* xxx.SS */ |
| 170 | if (sscanf(strchr(date_str, '.') + 1, "%u%c", |
| 171 | &ptm->tm_sec, &end) == 1) |
| 172 | end = '\0'; |
| 173 | /* else end != NUL and we error out */ |
| 174 | } |
| 175 | } |
| 176 | if (end != '\0') { |
| 177 | bb_error_msg_and_die(bb_msg_invalid_date, date_str); |
| 178 | } |
| 179 | } |
| 180 | |
| 181 | time_t FAST_FUNC validate_tm_time(const char *date_str, struct tm *ptm) |
| 182 | { |
| 183 | time_t t = mktime(ptm); |
| 184 | if (t == (time_t) -1L) { |
| 185 | bb_error_msg_and_die(bb_msg_invalid_date, date_str); |
| 186 | } |
| 187 | return t; |
| 188 | } |
| 189 | |
| 190 | #if ENABLE_MONOTONIC_SYSCALL |
| 191 | |
| 192 | #include <sys/syscall.h> |
| 193 | /* Old glibc (< 2.3.4) does not provide this constant. We use syscall |
| 194 | * directly so this definition is safe. */ |
| 195 | #ifndef CLOCK_MONOTONIC |
| 196 | #define CLOCK_MONOTONIC 1 |
| 197 | #endif |
| 198 | |
| 199 | /* libc has incredibly messy way of doing this, |
| 200 | * typically requiring -lrt. We just skip all this mess */ |
| 201 | static void get_mono(struct timespec *ts) |
| 202 | { |
| 203 | if (syscall(__NR_clock_gettime, CLOCK_MONOTONIC, ts)) |
| 204 | bb_error_msg_and_die("clock_gettime(MONOTONIC) failed"); |
| 205 | } |
| 206 | unsigned long long FAST_FUNC monotonic_ns(void) |
| 207 | { |
| 208 | struct timespec ts; |
| 209 | get_mono(&ts); |
| 210 | return ts.tv_sec * 1000000000ULL + ts.tv_nsec; |
| 211 | } |
| 212 | unsigned long long FAST_FUNC monotonic_us(void) |
| 213 | { |
| 214 | struct timespec ts; |
| 215 | get_mono(&ts); |
| 216 | return ts.tv_sec * 1000000ULL + ts.tv_nsec/1000; |
| 217 | } |
| 218 | unsigned long long FAST_FUNC monotonic_ms(void) |
| 219 | { |
| 220 | struct timespec ts; |
| 221 | get_mono(&ts); |
| 222 | return ts.tv_sec * 1000ULL + ts.tv_nsec/1000000; |
| 223 | } |
| 224 | unsigned FAST_FUNC monotonic_sec(void) |
| 225 | { |
| 226 | struct timespec ts; |
| 227 | get_mono(&ts); |
| 228 | return ts.tv_sec; |
| 229 | } |
| 230 | |
| 231 | #else |
| 232 | |
| 233 | unsigned long long FAST_FUNC monotonic_ns(void) |
| 234 | { |
| 235 | struct timeval tv; |
| 236 | gettimeofday(&tv, NULL); |
| 237 | return tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000; |
| 238 | } |
| 239 | unsigned long long FAST_FUNC monotonic_us(void) |
| 240 | { |
| 241 | struct timeval tv; |
| 242 | gettimeofday(&tv, NULL); |
| 243 | return tv.tv_sec * 1000000ULL + tv.tv_usec; |
| 244 | } |
| 245 | unsigned long long FAST_FUNC monotonic_ms(void) |
| 246 | { |
| 247 | struct timeval tv; |
| 248 | gettimeofday(&tv, NULL); |
| 249 | return tv.tv_sec * 1000ULL + tv.tv_usec / 1000; |
| 250 | } |
| 251 | unsigned FAST_FUNC monotonic_sec(void) |
| 252 | { |
| 253 | return time(NULL); |
| 254 | } |
| 255 | |
| 256 | #endif |