• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  * 3. The name of the author may not be used to endorse or promote products
13  *    derived from this software without specific prior written permission.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include "event2/event-config.h"
28 #include "evconfig-private.h"
29 
30 #ifdef _WIN32
31 #include <winsock2.h>
32 #define WIN32_LEAN_AND_MEAN
33 #include <windows.h>
34 #undef WIN32_LEAN_AND_MEAN
35 #endif
36 
37 #include <sys/types.h>
38 #ifdef EVENT__HAVE_STDLIB_H
39 #include <stdlib.h>
40 #endif
41 #include <errno.h>
42 #include <limits.h>
43 #ifndef EVENT__HAVE_GETTIMEOFDAY
44 #include <sys/timeb.h>
45 #endif
46 #if !defined(EVENT__HAVE_NANOSLEEP) && !defined(EVENT_HAVE_USLEEP) && \
47 	!defined(_WIN32)
48 #include <sys/select.h>
49 #endif
50 #include <time.h>
51 #include <sys/stat.h>
52 #include <string.h>
53 
54 /** evutil_usleep_() */
55 #if defined(_WIN32)
56 #elif defined(EVENT__HAVE_NANOSLEEP)
57 #elif defined(EVENT__HAVE_USLEEP)
58 #include <unistd.h>
59 #endif
60 
61 #include "event2/util.h"
62 #include "util-internal.h"
63 #include "log-internal.h"
64 #include "mm-internal.h"
65 
66 #ifndef EVENT__HAVE_GETTIMEOFDAY
67 /* No gettimeofday; this must be windows. */
68 int
evutil_gettimeofday(struct timeval * tv,struct timezone * tz)69 evutil_gettimeofday(struct timeval *tv, struct timezone *tz)
70 {
71 #ifdef _MSC_VER
72 #define U64_LITERAL(n) n##ui64
73 #else
74 #define U64_LITERAL(n) n##llu
75 #endif
76 
77 	/* Conversion logic taken from Tor, which in turn took it
78 	 * from Perl.  GetSystemTimeAsFileTime returns its value as
79 	 * an unaligned (!) 64-bit value containing the number of
80 	 * 100-nanosecond intervals since 1 January 1601 UTC. */
81 #define EPOCH_BIAS U64_LITERAL(116444736000000000)
82 #define UNITS_PER_SEC U64_LITERAL(10000000)
83 #define USEC_PER_SEC U64_LITERAL(1000000)
84 #define UNITS_PER_USEC U64_LITERAL(10)
85 	union {
86 		FILETIME ft_ft;
87 		ev_uint64_t ft_64;
88 	} ft;
89 
90 	if (tv == NULL)
91 		return -1;
92 
93 	GetSystemTimeAsFileTime(&ft.ft_ft);
94 
95 	if (EVUTIL_UNLIKELY(ft.ft_64 < EPOCH_BIAS)) {
96 		/* Time before the unix epoch. */
97 		return -1;
98 	}
99 	ft.ft_64 -= EPOCH_BIAS;
100 	tv->tv_sec = (long) (ft.ft_64 / UNITS_PER_SEC);
101 	tv->tv_usec = (long) ((ft.ft_64 / UNITS_PER_USEC) % USEC_PER_SEC);
102 	return 0;
103 }
104 #endif
105 
106 #define MAX_SECONDS_IN_MSEC_LONG \
107 	(((LONG_MAX) - 999) / 1000)
108 
109 long
evutil_tv_to_msec_(const struct timeval * tv)110 evutil_tv_to_msec_(const struct timeval *tv)
111 {
112 	if (tv->tv_usec > 1000000 || tv->tv_sec > MAX_SECONDS_IN_MSEC_LONG)
113 		return -1;
114 
115 	return (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000);
116 }
117 
118 /*
119   Replacement for usleep on platforms that don't have one.  Not guaranteed to
120   be any more finegrained than 1 msec.
121  */
122 void
evutil_usleep_(const struct timeval * tv)123 evutil_usleep_(const struct timeval *tv)
124 {
125 	if (!tv)
126 		return;
127 #if defined(_WIN32)
128 	{
129 		long msec = evutil_tv_to_msec_(tv);
130 		Sleep((DWORD)msec);
131 	}
132 #elif defined(EVENT__HAVE_NANOSLEEP)
133 	{
134 		struct timespec ts;
135 		ts.tv_sec = tv->tv_sec;
136 		ts.tv_nsec = tv->tv_usec*1000;
137 		nanosleep(&ts, NULL);
138 	}
139 #elif defined(EVENT__HAVE_USLEEP)
140 	/* Some systems don't like to usleep more than 999999 usec */
141 	sleep(tv->tv_sec);
142 	usleep(tv->tv_usec);
143 #else
144 	select(0, NULL, NULL, NULL, tv);
145 #endif
146 }
147 
148 int
evutil_date_rfc1123(char * date,const size_t datelen,const struct tm * tm)149 evutil_date_rfc1123(char *date, const size_t datelen, const struct tm *tm)
150 {
151 	static const char *DAYS[] =
152 		{ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
153 	static const char *MONTHS[] =
154 		{ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
155 
156 	time_t t = time(NULL);
157 
158 #ifndef _WIN32
159 	struct tm sys;
160 #endif
161 
162 	/* If `tm` is null, set system's current time. */
163 	if (tm == NULL) {
164 #ifdef _WIN32
165 		/** TODO: detect _gmtime64()/_gmtime64_s() */
166 		tm = gmtime(&t);
167 #else
168 		gmtime_r(&t, &sys);
169 		tm = &sys;
170 #endif
171 	}
172 
173 	return evutil_snprintf(
174 		date, datelen, "%s, %02d %s %4d %02d:%02d:%02d GMT",
175 		DAYS[tm->tm_wday], tm->tm_mday, MONTHS[tm->tm_mon],
176 		1900 + tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec);
177 }
178 
179 /*
180    This function assumes it's called repeatedly with a
181    not-actually-so-monotonic time source whose outputs are in 'tv'. It
182    implements a trivial ratcheting mechanism so that the values never go
183    backwards.
184  */
185 static void
adjust_monotonic_time(struct evutil_monotonic_timer * base,struct timeval * tv)186 adjust_monotonic_time(struct evutil_monotonic_timer *base,
187     struct timeval *tv)
188 {
189 	evutil_timeradd(tv, &base->adjust_monotonic_clock, tv);
190 
191 	if (evutil_timercmp(tv, &base->last_time, <)) {
192 		/* Guess it wasn't monotonic after all. */
193 		struct timeval adjust;
194 		evutil_timersub(&base->last_time, tv, &adjust);
195 		evutil_timeradd(&adjust, &base->adjust_monotonic_clock,
196 		    &base->adjust_monotonic_clock);
197 		*tv = base->last_time;
198 	}
199 	base->last_time = *tv;
200 }
201 
202 /*
203    Allocate a new struct evutil_monotonic_timer
204  */
205 struct evutil_monotonic_timer *
evutil_monotonic_timer_new(void)206 evutil_monotonic_timer_new(void)
207 {
208   struct evutil_monotonic_timer *p = NULL;
209 
210   p = mm_malloc(sizeof(*p));
211   if (!p) goto done;
212 
213   memset(p, 0, sizeof(*p));
214 
215  done:
216   return p;
217 }
218 
219 /*
220    Free a struct evutil_monotonic_timer
221  */
222 void
evutil_monotonic_timer_free(struct evutil_monotonic_timer * timer)223 evutil_monotonic_timer_free(struct evutil_monotonic_timer *timer)
224 {
225   if (timer) {
226     mm_free(timer);
227   }
228 }
229 
230 /*
231    Set up a struct evutil_monotonic_timer for initial use
232  */
233 int
evutil_configure_monotonic_time(struct evutil_monotonic_timer * timer,int flags)234 evutil_configure_monotonic_time(struct evutil_monotonic_timer *timer,
235                                 int flags)
236 {
237   return evutil_configure_monotonic_time_(timer, flags);
238 }
239 
240 /*
241    Query the current monotonic time
242  */
243 int
evutil_gettime_monotonic(struct evutil_monotonic_timer * timer,struct timeval * tp)244 evutil_gettime_monotonic(struct evutil_monotonic_timer *timer,
245                          struct timeval *tp)
246 {
247   return evutil_gettime_monotonic_(timer, tp);
248 }
249 
250 
251 #if defined(HAVE_POSIX_MONOTONIC)
252 /* =====
253    The POSIX clock_gettime() interface provides a few ways to get at a
254    monotonic clock.  CLOCK_MONOTONIC is most widely supported.  Linux also
255    provides a CLOCK_MONOTONIC_COARSE with accuracy of about 1-4 msec.
256 
257    On all platforms I'm aware of, CLOCK_MONOTONIC really is monotonic.
258    Platforms don't agree about whether it should jump on a sleep/resume.
259  */
260 
261 int
evutil_configure_monotonic_time_(struct evutil_monotonic_timer * base,int flags)262 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
263     int flags)
264 {
265 	/* CLOCK_MONOTONIC exists on FreeBSD, Linux, and Solaris.  You need to
266 	 * check for it at runtime, because some older kernel versions won't
267 	 * have it working. */
268 #ifdef CLOCK_MONOTONIC_COARSE
269 	const int precise = flags & EV_MONOT_PRECISE;
270 #endif
271 	const int fallback = flags & EV_MONOT_FALLBACK;
272 	struct timespec	ts;
273 
274 #ifdef CLOCK_MONOTONIC_COARSE
275 	if (CLOCK_MONOTONIC_COARSE < 0) {
276 		/* Technically speaking, nothing keeps CLOCK_* from being
277 		 * negative (as far as I know). This check and the one below
278 		 * make sure that it's safe for us to use -1 as an "unset"
279 		 * value. */
280 		event_errx(1,"I didn't expect CLOCK_MONOTONIC_COARSE to be < 0");
281 	}
282 	if (! precise && ! fallback) {
283 		if (clock_gettime(CLOCK_MONOTONIC_COARSE, &ts) == 0) {
284 			base->monotonic_clock = CLOCK_MONOTONIC_COARSE;
285 			return 0;
286 		}
287 	}
288 #endif
289 	if (!fallback && clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
290 		base->monotonic_clock = CLOCK_MONOTONIC;
291 		return 0;
292 	}
293 
294 	if (CLOCK_MONOTONIC < 0) {
295 		event_errx(1,"I didn't expect CLOCK_MONOTONIC to be < 0");
296 	}
297 
298 	base->monotonic_clock = -1;
299 	return 0;
300 }
301 
302 int
evutil_gettime_monotonic_(struct evutil_monotonic_timer * base,struct timeval * tp)303 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
304     struct timeval *tp)
305 {
306 	struct timespec ts;
307 
308 	if (base->monotonic_clock < 0) {
309 		if (evutil_gettimeofday(tp, NULL) < 0)
310 			return -1;
311 		adjust_monotonic_time(base, tp);
312 		return 0;
313 	}
314 
315 	if (clock_gettime(base->monotonic_clock, &ts) == -1)
316 		return -1;
317 	tp->tv_sec = ts.tv_sec;
318 	tp->tv_usec = ts.tv_nsec / 1000;
319 
320 	return 0;
321 }
322 #endif
323 
324 #if defined(HAVE_MACH_MONOTONIC)
325 /* ======
326    Apple is a little late to the POSIX party.  And why not?  Instead of
327    clock_gettime(), they provide mach_absolute_time().  Its units are not
328    fixed; we need to use mach_timebase_info() to get the right functions to
329    convert its units into nanoseconds.
330 
331    To all appearances, mach_absolute_time() seems to be honest-to-goodness
332    monotonic.  Whether it stops during sleep or not is unspecified in
333    principle, and dependent on CPU architecture in practice.
334  */
335 
336 int
evutil_configure_monotonic_time_(struct evutil_monotonic_timer * base,int flags)337 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
338     int flags)
339 {
340 	const int fallback = flags & EV_MONOT_FALLBACK;
341 	struct mach_timebase_info mi;
342 	memset(base, 0, sizeof(*base));
343 	/* OSX has mach_absolute_time() */
344 	if (!fallback &&
345 	    mach_timebase_info(&mi) == 0 &&
346 	    mach_absolute_time() != 0) {
347 		/* mach_timebase_info tells us how to convert
348 		 * mach_absolute_time() into nanoseconds, but we
349 		 * want to use microseconds instead. */
350 		mi.denom *= 1000;
351 		memcpy(&base->mach_timebase_units, &mi, sizeof(mi));
352 	} else {
353 		base->mach_timebase_units.numer = 0;
354 	}
355 	return 0;
356 }
357 
358 int
evutil_gettime_monotonic_(struct evutil_monotonic_timer * base,struct timeval * tp)359 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
360     struct timeval *tp)
361 {
362 	ev_uint64_t abstime, usec;
363 	if (base->mach_timebase_units.numer == 0) {
364 		if (evutil_gettimeofday(tp, NULL) < 0)
365 			return -1;
366 		adjust_monotonic_time(base, tp);
367 		return 0;
368 	}
369 
370 	abstime = mach_absolute_time();
371 	usec = (abstime * base->mach_timebase_units.numer)
372 	    / (base->mach_timebase_units.denom);
373 	tp->tv_sec = usec / 1000000;
374 	tp->tv_usec = usec % 1000000;
375 
376 	return 0;
377 }
378 #endif
379 
380 #if defined(HAVE_WIN32_MONOTONIC)
381 /* =====
382    Turn we now to Windows.  Want monontonic time on Windows?
383 
384    Windows has QueryPerformanceCounter(), which gives time most high-
385    resolution time.  It's a pity it's not so monotonic in practice; it's
386    also got some fun bugs, especially: with older Windowses, under
387    virtualizations, with funny hardware, on multiprocessor systems, and so
388    on.  PEP418 [1] has a nice roundup of the issues here.
389 
390    There's GetTickCount64() on Vista and later, which gives a number of 1-msec
391    ticks since startup.  The accuracy here might be as bad as 10-20 msec, I
392    hear.  There's an undocumented function (NtSetTimerResolution) that
393    allegedly increases the accuracy. Good luck!
394 
395    There's also GetTickCount(), which is only 32 bits, but seems to be
396    supported on pre-Vista versions of Windows.  Apparently, you can coax
397    another 14 bits out of it, giving you 2231 years before rollover.
398 
399    The less said about timeGetTime() the better.
400 
401    "We don't care.  We don't have to.  We're the Phone Company."
402             -- Lily Tomlin, SNL
403 
404    Our strategy, if precise timers are turned off, is to just use the best
405    GetTickCount equivalent available.  If we've been asked for precise timing,
406    then we mostly[2] assume that GetTickCount is monotonic, and correct
407    GetPerformanceCounter to approximate it.
408 
409    [1] http://www.python.org/dev/peps/pep-0418
410    [2] Of course, we feed the Windows stuff into adjust_monotonic_time()
411        anyway, just in case it isn't.
412 
413  */
414 /*
415     Parts of our logic in the win32 timer code here are closely based on
416     BitTorrent's libUTP library.  That code is subject to the following
417     license:
418 
419       Copyright (c) 2010 BitTorrent, Inc.
420 
421       Permission is hereby granted, free of charge, to any person obtaining a
422       copy of this software and associated documentation files (the
423       "Software"), to deal in the Software without restriction, including
424       without limitation the rights to use, copy, modify, merge, publish,
425       distribute, sublicense, and/or sell copies of the Software, and to
426       permit persons to whom the Software is furnished to do so, subject to
427       the following conditions:
428 
429       The above copyright notice and this permission notice shall be included
430       in all copies or substantial portions of the Software.
431 
432       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
433       OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
434       MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
435       NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
436       LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
437       OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
438       WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
439 */
440 
441 static ev_uint64_t
evutil_GetTickCount_(struct evutil_monotonic_timer * base)442 evutil_GetTickCount_(struct evutil_monotonic_timer *base)
443 {
444 	if (base->GetTickCount64_fn) {
445 		/* Let's just use GetTickCount64 if we can. */
446 		return base->GetTickCount64_fn();
447 	} else if (base->GetTickCount_fn) {
448 		/* Greg Hazel assures me that this works, that BitTorrent has
449 		 * done it for years, and this it won't turn around and
450 		 * bite us.  He says they found it on some game programmers'
451 		 * forum some time around 2007.
452 		 */
453 		ev_uint64_t v = base->GetTickCount_fn();
454 		return (DWORD)v | ((v >> 18) & 0xFFFFFFFF00000000);
455 	} else {
456 		/* Here's the fallback implementation. We have to use
457 		 * GetTickCount() with its given signature, so we only get
458 		 * 32 bits worth of milliseconds, which will roll ove every
459 		 * 49 days or so.  */
460 		DWORD ticks = GetTickCount();
461 		if (ticks < base->last_tick_count) {
462 			base->adjust_tick_count += ((ev_uint64_t)1) << 32;
463 		}
464 		base->last_tick_count = ticks;
465 		return ticks + base->adjust_tick_count;
466 	}
467 }
468 
469 int
evutil_configure_monotonic_time_(struct evutil_monotonic_timer * base,int flags)470 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
471     int flags)
472 {
473 	const int precise = flags & EV_MONOT_PRECISE;
474 	const int fallback = flags & EV_MONOT_FALLBACK;
475 	HANDLE h;
476 	memset(base, 0, sizeof(*base));
477 
478 	h = evutil_load_windows_system_library_(TEXT("kernel32.dll"));
479 	if (h != NULL && !fallback) {
480 		base->GetTickCount64_fn = (ev_GetTickCount_func)GetProcAddress(h, "GetTickCount64");
481 		base->GetTickCount_fn = (ev_GetTickCount_func)GetProcAddress(h, "GetTickCount");
482 	}
483 
484 	base->first_tick = base->last_tick_count = evutil_GetTickCount_(base);
485 	if (precise && !fallback) {
486 		LARGE_INTEGER freq;
487 		if (QueryPerformanceFrequency(&freq)) {
488 			LARGE_INTEGER counter;
489 			QueryPerformanceCounter(&counter);
490 			base->first_counter = counter.QuadPart;
491 			base->usec_per_count = 1.0e6 / freq.QuadPart;
492 			base->use_performance_counter = 1;
493 		}
494 	}
495 
496 	return 0;
497 }
498 
499 static inline ev_int64_t
abs64(ev_int64_t i)500 abs64(ev_int64_t i)
501 {
502 	return i < 0 ? -i : i;
503 }
504 
505 
506 int
evutil_gettime_monotonic_(struct evutil_monotonic_timer * base,struct timeval * tp)507 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
508     struct timeval *tp)
509 {
510 	ev_uint64_t ticks = evutil_GetTickCount_(base);
511 	if (base->use_performance_counter) {
512 		/* Here's a trick we took from BitTorrent's libutp, at Greg
513 		 * Hazel's recommendation.  We use QueryPerformanceCounter for
514 		 * our high-resolution timer, but use GetTickCount*() to keep
515 		 * it sane, and adjust_monotonic_time() to keep it monotonic.
516 		 */
517 		LARGE_INTEGER counter;
518 		ev_int64_t counter_elapsed, counter_usec_elapsed, ticks_elapsed;
519 		QueryPerformanceCounter(&counter);
520 		counter_elapsed = (ev_int64_t)
521 		    (counter.QuadPart - base->first_counter);
522 		ticks_elapsed = ticks - base->first_tick;
523 		/* TODO: This may upset VC6. If you need this to work with
524 		 * VC6, please supply an appropriate patch. */
525 		counter_usec_elapsed = (ev_int64_t)
526 		    (counter_elapsed * base->usec_per_count);
527 
528 		if (abs64(ticks_elapsed*1000 - counter_usec_elapsed) > 1000000) {
529 			/* It appears that the QueryPerformanceCounter()
530 			 * result is more than 1 second away from
531 			 * GetTickCount() result. Let's adjust it to be as
532 			 * accurate as we can; adjust_monotnonic_time() below
533 			 * will keep it monotonic. */
534 			counter_usec_elapsed = ticks_elapsed * 1000;
535 			base->first_counter = (ev_uint64_t) (counter.QuadPart - counter_usec_elapsed / base->usec_per_count);
536 		}
537 		tp->tv_sec = (time_t) (counter_usec_elapsed / 1000000);
538 		tp->tv_usec = counter_usec_elapsed % 1000000;
539 
540 	} else {
541 		/* We're just using GetTickCount(). */
542 		tp->tv_sec = (time_t) (ticks / 1000);
543 		tp->tv_usec = (ticks % 1000) * 1000;
544 	}
545 	adjust_monotonic_time(base, tp);
546 
547 	return 0;
548 }
549 #endif
550 
551 #if defined(HAVE_FALLBACK_MONOTONIC)
552 /* =====
553    And if none of the other options work, let's just use gettimeofday(), and
554    ratchet it forward so that it acts like a monotonic timer, whether it
555    wants to or not.
556  */
557 
558 int
evutil_configure_monotonic_time_(struct evutil_monotonic_timer * base,int precise)559 evutil_configure_monotonic_time_(struct evutil_monotonic_timer *base,
560     int precise)
561 {
562 	memset(base, 0, sizeof(*base));
563 	return 0;
564 }
565 
566 int
evutil_gettime_monotonic_(struct evutil_monotonic_timer * base,struct timeval * tp)567 evutil_gettime_monotonic_(struct evutil_monotonic_timer *base,
568     struct timeval *tp)
569 {
570 	if (evutil_gettimeofday(tp, NULL) < 0)
571 		return -1;
572 	adjust_monotonic_time(base, tp);
573 	return 0;
574 
575 }
576 #endif
577