Commit | Line | Data |
---|---|---|
89c4ed63 A |
1 | /** strptime workaround (for oa macos leopard) |
2 | * This strptime follows the man strptime (2001-11-12) | |
3 | * conforming to SUSv2, POSIX.1-2001 | |
4 | * | |
5 | * This very simple version of strptime has no: | |
6 | * - E alternatives | |
7 | * - O alternatives | |
8 | * - Glibc additions | |
9 | * - Does not process week numbers | |
10 | * - Does not properly processes year day | |
11 | * | |
12 | * LICENSE | |
13 | * Copyright (c) 2008, NLnet Labs, Matthijs Mekking | |
14 | * All rights reserved. | |
15 | * | |
16 | * Redistribution and use in source and binary forms, with or without | |
17 | * modification, are permitted provided that the following conditions are met: | |
18 | * * Redistributions of source code must retain the above copyright notice, | |
19 | * this list of conditions and the following disclaimer. | |
20 | * * Redistributions in binary form must reproduce the above copyright | |
21 | * notice, this list of conditions and the following disclaimer in the | |
22 | * documentation and/or other materials provided with the distribution. | |
23 | * * Neither the name of NLnetLabs nor the names of its | |
24 | * contributors may be used to endorse or promote products derived from this | |
25 | * software without specific prior written permission. | |
26 | * | |
27 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
28 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
29 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
30 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
31 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
32 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
33 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
34 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
35 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
36 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
37 | * POSSIBILITY OF SUCH DAMAGE. | |
38 | **/ | |
39 | ||
40 | #include "config.h" | |
41 | ||
42 | #ifndef HAVE_CONFIG_H | |
43 | #include <time.h> | |
44 | #endif | |
45 | ||
46 | #ifndef STRPTIME_WORKS | |
47 | ||
48 | #define TM_YEAR_BASE 1900 | |
49 | ||
50 | #include <ctype.h> | |
51 | #include <string.h> | |
52 | ||
53 | static const char *abb_weekdays[] = { | |
54 | "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL | |
55 | }; | |
56 | static const char *full_weekdays[] = { | |
57 | "Sunday", "Monday", "Tuesday", "Wednesday", | |
58 | "Thursday", "Friday", "Saturday", NULL | |
59 | }; | |
60 | static const char *abb_months[] = { | |
61 | "Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
62 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL | |
63 | }; | |
64 | static const char *full_months[] = { | |
65 | "January", "February", "March", "April", "May", "June", | |
66 | "July", "August", "September", "October", "November", "December", NULL | |
67 | }; | |
68 | static const char *ampm[] = { | |
69 | "am", "pm", NULL | |
70 | }; | |
71 | ||
72 | static int | |
73 | match_string(const char **buf, const char **strs) | |
74 | { | |
75 | int i = 0; | |
76 | ||
77 | for (i = 0; strs[i] != NULL; i++) { | |
78 | int len = strlen(strs[i]); | |
79 | if (strncasecmp (*buf, strs[i], len) == 0) { | |
80 | *buf += len; | |
81 | return i; | |
82 | } | |
83 | } | |
84 | return -1; | |
85 | } | |
86 | ||
87 | static int | |
88 | str2int(const char **buf, int max) | |
89 | { | |
90 | int ret=0, count=0; | |
91 | ||
92 | while (*buf[0] != '\0' && isdigit((unsigned char)*buf[0]) && count<max) { | |
93 | ret = ret*10 + (*buf[0] - '0'); | |
94 | (*buf)++; | |
95 | count++; | |
96 | } | |
97 | ||
98 | if (!count) | |
99 | return -1; | |
100 | return ret; | |
101 | } | |
102 | ||
103 | /** Converts the character string s to values which are stored in tm | |
104 | * using the format specified by format | |
105 | **/ | |
106 | char * | |
107 | unbound_strptime(const char *s, const char *format, struct tm *tm) | |
108 | { | |
109 | int c, ret; | |
110 | int split_year = 0; | |
111 | ||
112 | while ((c = *format) != '\0') { | |
113 | /* whitespace, literal or format */ | |
114 | if (isspace((unsigned char)c)) { /* whitespace */ | |
115 | /** whitespace matches zero or more whitespace characters in the | |
116 | * input string. | |
117 | **/ | |
118 | while (isspace((unsigned char)*s)) | |
119 | s++; | |
120 | } | |
121 | else if (c == '%') { /* format */ | |
122 | format++; | |
123 | c = *format; | |
124 | switch (c) { | |
125 | case '%': /* %% is converted to % */ | |
126 | if (*s != c) { | |
127 | return NULL; | |
128 | } | |
129 | s++; | |
130 | break; | |
131 | case 'a': /* weekday name, abbreviated or full */ | |
132 | case 'A': | |
133 | ret = match_string(&s, full_weekdays); | |
134 | if (ret < 0) | |
135 | ret = match_string(&s, abb_weekdays); | |
136 | if (ret < 0) { | |
137 | return NULL; | |
138 | } | |
139 | tm->tm_wday = ret; | |
140 | break; | |
141 | case 'b': /* month name, abbreviated or full */ | |
142 | case 'B': | |
143 | case 'h': | |
144 | ret = match_string(&s, full_months); | |
145 | if (ret < 0) | |
146 | ret = match_string(&s, abb_months); | |
147 | if (ret < 0) { | |
148 | return NULL; | |
149 | } | |
150 | tm->tm_mon = ret; | |
151 | break; | |
152 | case 'c': /* date and time representation */ | |
153 | if (!(s = unbound_strptime(s, "%x %X", tm))) { | |
154 | return NULL; | |
155 | } | |
156 | break; | |
157 | case 'C': /* century number */ | |
158 | ret = str2int(&s, 2); | |
159 | if (ret < 0 || ret > 99) { /* must be in [00,99] */ | |
160 | return NULL; | |
161 | } | |
162 | ||
163 | if (split_year) { | |
164 | tm->tm_year = ret*100 + (tm->tm_year%100); | |
165 | } | |
166 | else { | |
167 | tm->tm_year = ret*100 - TM_YEAR_BASE; | |
168 | split_year = 1; | |
169 | } | |
170 | break; | |
171 | case 'd': /* day of month */ | |
172 | case 'e': | |
173 | ret = str2int(&s, 2); | |
174 | if (ret < 1 || ret > 31) { /* must be in [01,31] */ | |
175 | return NULL; | |
176 | } | |
177 | tm->tm_mday = ret; | |
178 | break; | |
179 | case 'D': /* equivalent to %m/%d/%y */ | |
180 | if (!(s = unbound_strptime(s, "%m/%d/%y", tm))) { | |
181 | return NULL; | |
182 | } | |
183 | break; | |
184 | case 'H': /* hour */ | |
185 | ret = str2int(&s, 2); | |
186 | if (ret < 0 || ret > 23) { /* must be in [00,23] */ | |
187 | return NULL; | |
188 | } | |
189 | tm->tm_hour = ret; | |
190 | break; | |
191 | case 'I': /* 12hr clock hour */ | |
192 | ret = str2int(&s, 2); | |
193 | if (ret < 1 || ret > 12) { /* must be in [01,12] */ | |
194 | return NULL; | |
195 | } | |
196 | if (ret == 12) /* actually [0,11] */ | |
197 | ret = 0; | |
198 | tm->tm_hour = ret; | |
199 | break; | |
200 | case 'j': /* day of year */ | |
201 | ret = str2int(&s, 2); | |
202 | if (ret < 1 || ret > 366) { /* must be in [001,366] */ | |
203 | return NULL; | |
204 | } | |
205 | tm->tm_yday = ret; | |
206 | break; | |
207 | case 'm': /* month */ | |
208 | ret = str2int(&s, 2); | |
209 | if (ret < 1 || ret > 12) { /* must be in [01,12] */ | |
210 | return NULL; | |
211 | } | |
212 | /* months go from 0-11 */ | |
213 | tm->tm_mon = (ret-1); | |
214 | break; | |
215 | case 'M': /* minute */ | |
216 | ret = str2int(&s, 2); | |
217 | if (ret < 0 || ret > 59) { /* must be in [00,59] */ | |
218 | return NULL; | |
219 | } | |
220 | tm->tm_min = ret; | |
221 | break; | |
222 | case 'n': /* arbitrary whitespace */ | |
223 | case 't': | |
224 | while (isspace((unsigned char)*s)) | |
225 | s++; | |
226 | break; | |
227 | case 'p': /* am pm */ | |
228 | ret = match_string(&s, ampm); | |
229 | if (ret < 0) { | |
230 | return NULL; | |
231 | } | |
232 | if (tm->tm_hour < 0 || tm->tm_hour > 11) { /* %I */ | |
233 | return NULL; | |
234 | } | |
235 | ||
236 | if (ret == 1) /* pm */ | |
237 | tm->tm_hour += 12; | |
238 | break; | |
239 | case 'r': /* equivalent of %I:%M:%S %p */ | |
240 | if (!(s = unbound_strptime(s, "%I:%M:%S %p", tm))) { | |
241 | return NULL; | |
242 | } | |
243 | break; | |
244 | case 'R': /* equivalent of %H:%M */ | |
245 | if (!(s = unbound_strptime(s, "%H:%M", tm))) { | |
246 | return NULL; | |
247 | } | |
248 | break; | |
249 | case 'S': /* seconds */ | |
250 | ret = str2int(&s, 2); | |
251 | /* 60 may occur for leap seconds */ | |
252 | /* earlier 61 was also allowed */ | |
253 | if (ret < 0 || ret > 60) { /* must be in [00,60] */ | |
254 | return NULL; | |
255 | } | |
256 | tm->tm_sec = ret; | |
257 | break; | |
258 | case 'T': /* equivalent of %H:%M:%S */ | |
259 | if (!(s = unbound_strptime(s, "%H:%M:%S", tm))) { | |
260 | return NULL; | |
261 | } | |
262 | break; | |
263 | case 'U': /* week number, with the first Sun of Jan being w1 */ | |
264 | ret = str2int(&s, 2); | |
265 | if (ret < 0 || ret > 53) { /* must be in [00,53] */ | |
266 | return NULL; | |
267 | } | |
268 | /** it is hard (and not necessary for nsd) to determine time | |
269 | * data from week number. | |
270 | **/ | |
271 | break; | |
272 | case 'w': /* day of week */ | |
273 | ret = str2int(&s, 1); | |
274 | if (ret < 0 || ret > 6) { /* must be in [0,6] */ | |
275 | return NULL; | |
276 | } | |
277 | tm->tm_wday = ret; | |
278 | break; | |
279 | case 'W': /* week number, with the first Mon of Jan being w1 */ | |
280 | ret = str2int(&s, 2); | |
281 | if (ret < 0 || ret > 53) { /* must be in [00,53] */ | |
282 | return NULL; | |
283 | } | |
284 | /** it is hard (and not necessary for nsd) to determine time | |
285 | * data from week number. | |
286 | **/ | |
287 | break; | |
288 | case 'x': /* date format */ | |
289 | if (!(s = unbound_strptime(s, "%m/%d/%y", tm))) { | |
290 | return NULL; | |
291 | } | |
292 | break; | |
293 | case 'X': /* time format */ | |
294 | if (!(s = unbound_strptime(s, "%H:%M:%S", tm))) { | |
295 | return NULL; | |
296 | } | |
297 | break; | |
298 | case 'y': /* last two digits of a year */ | |
299 | ret = str2int(&s, 2); | |
300 | if (ret < 0 || ret > 99) { /* must be in [00,99] */ | |
301 | return NULL; | |
302 | } | |
303 | if (split_year) { | |
304 | tm->tm_year = ((tm->tm_year/100) * 100) + ret; | |
305 | } | |
306 | else { | |
307 | split_year = 1; | |
308 | ||
309 | /** currently: | |
310 | * if in [0,68] we are in 21th century, | |
311 | * if in [69,99] we are in 20th century. | |
312 | **/ | |
313 | if (ret < 69) /* 2000 */ | |
314 | ret += 100; | |
315 | tm->tm_year = ret; | |
316 | } | |
317 | break; | |
318 | case 'Y': /* year */ | |
319 | ret = str2int(&s, 4); | |
320 | if (ret < 0 || ret > 9999) { | |
321 | return NULL; | |
322 | } | |
323 | tm->tm_year = ret - TM_YEAR_BASE; | |
324 | break; | |
325 | case '\0': | |
326 | default: /* unsupported, cannot match format */ | |
327 | return NULL; | |
328 | break; | |
329 | } | |
330 | } | |
331 | else { /* literal */ | |
332 | /* if input cannot match format, return NULL */ | |
333 | if (*s != c) | |
334 | return NULL; | |
335 | s++; | |
336 | } | |
337 | ||
338 | format++; | |
339 | } | |
340 | ||
341 | /* return pointer to remainder of s */ | |
342 | return (char*) s; | |
343 | } | |
344 | ||
345 | #endif /* STRPTIME_WORKS */ |