[ViewVC] Diff of: cvs/libev/ev.pod

Comparing libev/ev.pod (file contents):
Revision 1.46 by root, Mon Nov 26 10:20:43 2007 UTC vs.
Revision 1.52 by root, Tue Nov 27 19:41:52 2007 UTC

…		…
48	the beginning of 1970, details are complicated, don't ask). This type is	48	the beginning of 1970, details are complicated, don't ask). This type is
49	called C<ev_tstamp>, which is what you should use too. It usually aliases	49	called C<ev_tstamp>, which is what you should use too. It usually aliases
50	to the C<double> type in C, and when you need to do any calculations on	50	to the C<double> type in C, and when you need to do any calculations on
51	it, you should treat it as such.	51	it, you should treat it as such.
52		52
53
54	=head1 GLOBAL FUNCTIONS	53	=head1 GLOBAL FUNCTIONS
55		54
56	These functions can be called anytime, even before initialising the	55	These functions can be called anytime, even before initialising the
57	library in any way.	56	library in any way.
58		57
…		…
116	C<ev_embeddable_backends () & ev_supported_backends ()>, likewise for	115	C<ev_embeddable_backends () & ev_supported_backends ()>, likewise for
117	recommended ones.	116	recommended ones.
118		117
119	See the description of C<ev_embed> watchers for more info.	118	See the description of C<ev_embed> watchers for more info.
120		119
121	=item ev_set_allocator (void (cb)(void *ptr, long size))	120	=item ev_set_allocator (void (cb)(void *ptr, size_t size))
122		121
123	Sets the allocation function to use (the prototype is similar to the	122	Sets the allocation function to use (the prototype and semantics are
124	realloc C function, the semantics are identical). It is used to allocate	123	identical to the realloc C function). It is used to allocate and free
125	and free memory (no surprises here). If it returns zero when memory	124	memory (no surprises here). If it returns zero when memory needs to be
126	needs to be allocated, the library might abort or take some potentially	125	allocated, the library might abort or take some potentially destructive
127	destructive action. The default is your system realloc function.	126	action. The default is your system realloc function.
128		127
129	You could override this function in high-availability programs to, say,	128	You could override this function in high-availability programs to, say,
130	free some memory if it cannot allocate memory, to use a special allocator,	129	free some memory if it cannot allocate memory, to use a special allocator,
131	or even to sleep a while and retry until some memory is available.	130	or even to sleep a while and retry until some memory is available.
132		131
133	Example: replace the libev allocator with one that waits a bit and then	132	Example: replace the libev allocator with one that waits a bit and then
134	retries: better than mine).	133	retries: better than mine).
135		134
136	static void *	135	static void *
137	persistent_realloc (void *ptr, long size)	136	persistent_realloc (void *ptr, size_t size)
138	{	137	{
139	for (;;)	138	for (;;)
140	{	139	{
141	void *newptr = realloc (ptr, size);	140	void *newptr = realloc (ptr, size);
142		141
…		…
545		544
546	=item C<EV_CHILD>	545	=item C<EV_CHILD>
547		546
548	The pid specified in the C<ev_child> watcher has received a status change.	547	The pid specified in the C<ev_child> watcher has received a status change.
549		548
		549	=item C<EV_STAT>
		550
		551	The path specified in the C<ev_stat> watcher changed its attributes somehow.
		552
550	=item C<EV_IDLE>	553	=item C<EV_IDLE>
551		554
552	The C<ev_idle> watcher has determined that you have nothing better to do.	555	The C<ev_idle> watcher has determined that you have nothing better to do.
553		556
554	=item C<EV_PREPARE>	557	=item C<EV_PREPARE>
…		…
561	received events. Callbacks of both watcher types can start and stop as	564	received events. Callbacks of both watcher types can start and stop as
562	many watchers as they want, and all of them will be taken into account	565	many watchers as they want, and all of them will be taken into account
563	(for example, a C<ev_prepare> watcher might start an idle watcher to keep	566	(for example, a C<ev_prepare> watcher might start an idle watcher to keep
564	C<ev_loop> from blocking).	567	C<ev_loop> from blocking).
565		568
		569	=item C<EV_EMBED>
		570
		571	The embedded event loop specified in the C<ev_embed> watcher needs attention.
		572
		573	=item C<EV_FORK>
		574
		575	The event loop has been resumed in the child process after fork (see
		576	C<ev_fork>).
		577
566	=item C<EV_ERROR>	578	=item C<EV_ERROR>
567		579
568	An unspecified error has occured, the watcher has been stopped. This might	580	An unspecified error has occured, the watcher has been stopped. This might
569	happen because the watcher could not be properly started because libev	581	happen because the watcher could not be properly started because libev
570	ran out of memory, a file descriptor was found to be closed or any other	582	ran out of memory, a file descriptor was found to be closed or any other
…		…
689		701
690		702
691	=head1 WATCHER TYPES	703	=head1 WATCHER TYPES
692		704
693	This section describes each watcher in detail, but will not repeat	705	This section describes each watcher in detail, but will not repeat
694	information given in the last section.	706	information given in the last section. Any initialisation/set macros,
		707	functions and members specific to the watcher type are explained.
		708
		709	Members are additionally marked with either I<[read-only]>, meaning that,
		710	while the watcher is active, you can look at the member and expect some
		711	sensible content, but you must not modify it (you can modify it while the
		712	watcher is stopped to your hearts content), or I<[read-write]>, which
		713	means you can expect it to have some sensible content while the watcher
		714	is active, but you can also modify it. Modifying it may not do something
		715	sensible or take immediate effect (or do anything at all), but libev will
		716	not crash or malfunction in any way.
695		717
696		718
697	=head2 C<ev_io> - is this file descriptor readable or writable?	719	=head2 C<ev_io> - is this file descriptor readable or writable?
698		720
699	I/O watchers check whether a file descriptor is readable or writable	721	I/O watchers check whether a file descriptor is readable or writable
…		…
742		764
743	Configures an C<ev_io> watcher. The C<fd> is the file descriptor to	765	Configures an C<ev_io> watcher. The C<fd> is the file descriptor to
744	rceeive events for and events is either C<EV_READ>, C<EV_WRITE> or	766	rceeive events for and events is either C<EV_READ>, C<EV_WRITE> or
745	C<EV_READ \| EV_WRITE> to receive the given events.	767	C<EV_READ \| EV_WRITE> to receive the given events.
746		768
		769	=item int fd [read-only]
		770
		771	The file descriptor being watched.
		772
		773	=item int events [read-only]
		774
		775	The events being watched.
		776
747	=back	777	=back
748		778
749	Example: call C<stdin_readable_cb> when STDIN_FILENO has become, well	779	Example: call C<stdin_readable_cb> when STDIN_FILENO has become, well
750	readable, but only once. Since it is likely line-buffered, you could	780	readable, but only once. Since it is likely line-buffered, you could
751	attempt to read a whole line in the callback:	781	attempt to read a whole line in the callback:
…		…
814		844
815	If the timer is repeating, either start it if necessary (with the repeat	845	If the timer is repeating, either start it if necessary (with the repeat
816	value), or reset the running timer to the repeat value.	846	value), or reset the running timer to the repeat value.
817		847
818	This sounds a bit complicated, but here is a useful and typical	848	This sounds a bit complicated, but here is a useful and typical
819	example: Imagine you have a tcp connection and you want a so-called idle	849	example: Imagine you have a tcp connection and you want a so-called
820	timeout, that is, you want to be called when there have been, say, 60	850	idle timeout, that is, you want to be called when there have been,
821	seconds of inactivity on the socket. The easiest way to do this is to	851	say, 60 seconds of inactivity on the socket. The easiest way to do
822	configure an C<ev_timer> with after=repeat=60 and calling ev_timer_again each	852	this is to configure an C<ev_timer> with C<after>=C<repeat>=C<60> and calling
823	time you successfully read or write some data. If you go into an idle	853	C<ev_timer_again> each time you successfully read or write some data. If
824	state where you do not expect data to travel on the socket, you can stop	854	you go into an idle state where you do not expect data to travel on the
825	the timer, and again will automatically restart it if need be.	855	socket, you can stop the timer, and again will automatically restart it if
		856	need be.
		857
		858	You can also ignore the C<after> value and C<ev_timer_start> altogether
		859	and only ever use the C<repeat> value:
		860
		861	ev_timer_init (timer, callback, 0., 5.);
		862	ev_timer_again (loop, timer);
		863	...
		864	timer->again = 17.;
		865	ev_timer_again (loop, timer);
		866	...
		867	timer->again = 10.;
		868	ev_timer_again (loop, timer);
		869
		870	This is more efficient then stopping/starting the timer eahc time you want
		871	to modify its timeout value.
		872
		873	=item ev_tstamp repeat [read-write]
		874
		875	The current C<repeat> value. Will be used each time the watcher times out
		876	or C<ev_timer_again> is called and determines the next timeout (if any),
		877	which is also when any modifications are taken into account.
826		878
827	=back	879	=back
828		880
829	Example: create a timer that fires after 60 seconds.	881	Example: create a timer that fires after 60 seconds.
830		882
…		…
957	Simply stops and restarts the periodic watcher again. This is only useful	1009	Simply stops and restarts the periodic watcher again. This is only useful
958	when you changed some parameters or the reschedule callback would return	1010	when you changed some parameters or the reschedule callback would return
959	a different time than the last time it was called (e.g. in a crond like	1011	a different time than the last time it was called (e.g. in a crond like
960	program when the crontabs have changed).	1012	program when the crontabs have changed).
961		1013
		1014	=item ev_tstamp interval [read-write]
		1015
		1016	The current interval value. Can be modified any time, but changes only
		1017	take effect when the periodic timer fires or C<ev_periodic_again> is being
		1018	called.
		1019
		1020	=item ev_tstamp (reschedule_cb)(struct ev_periodic w, ev_tstamp now) [read-write]
		1021
		1022	The current reschedule callback, or C<0>, if this functionality is
		1023	switched off. Can be changed any time, but changes only take effect when
		1024	the periodic timer fires or C<ev_periodic_again> is being called.
		1025
962	=back	1026	=back
963		1027
964	Example: call a callback every hour, or, more precisely, whenever the	1028	Example: call a callback every hour, or, more precisely, whenever the
965	system clock is divisible by 3600. The callback invocation times have	1029	system clock is divisible by 3600. The callback invocation times have
966	potentially a lot of jittering, but good long-term stability.	1030	potentially a lot of jittering, but good long-term stability.
…		…
1016	=item ev_signal_set (ev_signal *, int signum)	1080	=item ev_signal_set (ev_signal *, int signum)
1017		1081
1018	Configures the watcher to trigger on the given signal number (usually one	1082	Configures the watcher to trigger on the given signal number (usually one
1019	of the C<SIGxxx> constants).	1083	of the C<SIGxxx> constants).
1020		1084
		1085	=item int signum [read-only]
		1086
		1087	The signal the watcher watches out for.
		1088
1021	=back	1089	=back
1022		1090
1023		1091
1024	=head2 C<ev_child> - watch out for process status changes	1092	=head2 C<ev_child> - watch out for process status changes
1025		1093
…		…
1037	at the C<rstatus> member of the C<ev_child> watcher structure to see	1105	at the C<rstatus> member of the C<ev_child> watcher structure to see
1038	the status word (use the macros from C<sys/wait.h> and see your systems	1106	the status word (use the macros from C<sys/wait.h> and see your systems
1039	C<waitpid> documentation). The C<rpid> member contains the pid of the	1107	C<waitpid> documentation). The C<rpid> member contains the pid of the
1040	process causing the status change.	1108	process causing the status change.
1041		1109
		1110	=item int pid [read-only]
		1111
		1112	The process id this watcher watches out for, or C<0>, meaning any process id.
		1113
		1114	=item int rpid [read-write]
		1115
		1116	The process id that detected a status change.
		1117
		1118	=item int rstatus [read-write]
		1119
		1120	The process exit/trace status caused by C<rpid> (see your systems
		1121	C<waitpid> and C<sys/wait.h> documentation for details).
		1122
1042	=back	1123	=back
1043		1124
1044	Example: try to exit cleanly on SIGINT and SIGTERM.	1125	Example: try to exit cleanly on SIGINT and SIGTERM.
1045		1126
1046	static void	1127	static void
…		…
1050	}	1131	}
1051		1132
1052	struct ev_signal signal_watcher;	1133	struct ev_signal signal_watcher;
1053	ev_signal_init (&signal_watcher, sigint_cb, SIGINT);	1134	ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
1054	ev_signal_start (loop, &sigint_cb);	1135	ev_signal_start (loop, &sigint_cb);
		1136
		1137
		1138	=head2 C<ev_stat> - did the file attributes just change?
		1139
		1140	This watches a filesystem path for attribute changes. That is, it calls
		1141	C<stat> regularly (or when the OS says it changed) and sees if it changed
		1142	compared to the last time, invoking the callback if it did.
		1143
		1144	The path does not need to exist: changing from "path exists" to "path does
		1145	not exist" is a status change like any other. The condition "path does
		1146	not exist" is signified by the C<st_nlink> field being zero (which is
		1147	otherwise always forced to be at least one) and all the other fields of
		1148	the stat buffer having unspecified contents.
		1149
		1150	Since there is no standard to do this, the portable implementation simply
		1151	calls C<stat (2)> regulalry on the path to see if it changed somehow. You
		1152	can specify a recommended polling interval for this case. If you specify
		1153	a polling interval of C<0> (highly recommended!) then a I<suitable,
		1154	unspecified default> value will be used (which you can expect to be around
		1155	five seconds, although this might change dynamically). Libev will also
		1156	impose a minimum interval which is currently around C<0.1>, but thats
		1157	usually overkill.
		1158
		1159	This watcher type is not meant for massive numbers of stat watchers,
		1160	as even with OS-supported change notifications, this can be
		1161	resource-intensive.
		1162
		1163	At the time of this writing, no specific OS backends are implemented, but
		1164	if demand increases, at least a kqueue and inotify backend will be added.
		1165
		1166	=over 4
		1167
		1168	=item ev_stat_init (ev_stat , callback, const char path, ev_tstamp interval)
		1169
		1170	=item ev_stat_set (ev_stat , const char path, ev_tstamp interval)
		1171
		1172	Configures the watcher to wait for status changes of the given
		1173	C<path>. The C<interval> is a hint on how quickly a change is expected to
		1174	be detected and should normally be specified as C<0> to let libev choose
		1175	a suitable value. The memory pointed to by C<path> must point to the same
		1176	path for as long as the watcher is active.
		1177
		1178	The callback will be receive C<EV_STAT> when a change was detected,
		1179	relative to the attributes at the time the watcher was started (or the
		1180	last change was detected).
		1181
		1182	=item ev_stat_stat (ev_stat *)
		1183
		1184	Updates the stat buffer immediately with new values. If you change the
		1185	watched path in your callback, you could call this fucntion to avoid
		1186	detecting this change (while introducing a race condition). Can also be
		1187	useful simply to find out the new values.
		1188
		1189	=item ev_statdata attr [read-only]
		1190
		1191	The most-recently detected attributes of the file. Although the type is of
		1192	C<ev_statdata>, this is usually the (or one of the) C<struct stat> types
		1193	suitable for your system. If the C<st_nlink> member is C<0>, then there
		1194	was some error while C<stat>ing the file.
		1195
		1196	=item ev_statdata prev [read-only]
		1197
		1198	The previous attributes of the file. The callback gets invoked whenever
		1199	C<prev> != C<attr>.
		1200
		1201	=item ev_tstamp interval [read-only]
		1202
		1203	The specified interval.
		1204
		1205	=item const char *path [read-only]
		1206
		1207	The filesystem path that is being watched.
		1208
		1209	=back
		1210
		1211	Example: Watch C</etc/passwd> for attribute changes.
		1212
		1213	static void
		1214	passwd_cb (struct ev_loop loop, ev_stat w, int revents)
		1215	{
		1216	/* /etc/passwd changed in some way */
		1217	if (w->attr.st_nlink)
		1218	{
		1219	printf ("passwd current size %ld\n", (long)w->attr.st_size);
		1220	printf ("passwd current atime %ld\n", (long)w->attr.st_mtime);
		1221	printf ("passwd current mtime %ld\n", (long)w->attr.st_mtime);
		1222	}
		1223	else
		1224	/* you shalt not abuse printf for puts */
		1225	puts ("wow, /etc/passwd is not there, expect problems. "
		1226	"if this is windows, they already arrived\n");
		1227	}
		1228
		1229	...
		1230	ev_stat passwd;
		1231
		1232	ev_stat_init (&passwd, passwd_cb, "/etc/passwd");
		1233	ev_stat_start (loop, &passwd);
1055		1234
1056		1235
1057	=head2 C<ev_idle> - when you've got nothing better to do...	1236	=head2 C<ev_idle> - when you've got nothing better to do...
1058		1237
1059	Idle watchers trigger events when there are no other events are pending	1238	Idle watchers trigger events when there are no other events are pending
…		…
1292		1471
1293	Make a single, non-blocking sweep over the embedded loop. This works	1472	Make a single, non-blocking sweep over the embedded loop. This works
1294	similarly to C<ev_loop (embedded_loop, EVLOOP_NONBLOCK)>, but in the most	1473	similarly to C<ev_loop (embedded_loop, EVLOOP_NONBLOCK)>, but in the most
1295	apropriate way for embedded loops.	1474	apropriate way for embedded loops.
1296		1475
		1476	=item struct ev_loop *loop [read-only]
		1477
		1478	The embedded event loop.
		1479
		1480	=back
		1481
		1482
		1483	=head2 C<ev_fork> - the audacity to resume the event loop after a fork
		1484
		1485	Fork watchers are called when a C<fork ()> was detected (usually because
		1486	whoever is a good citizen cared to tell libev about it by calling
		1487	C<ev_default_fork> or C<ev_loop_fork>). The invocation is done before the
		1488	event loop blocks next and before C<ev_check> watchers are being called,
		1489	and only in the child after the fork. If whoever good citizen calling
		1490	C<ev_default_fork> cheats and calls it in the wrong process, the fork
		1491	handlers will be invoked, too, of course.
		1492
		1493	=over 4
		1494
		1495	=item ev_fork_init (ev_signal *, callback)
		1496
		1497	Initialises and configures the fork watcher - it has no parameters of any
		1498	kind. There is a C<ev_fork_set> macro, but using it is utterly pointless,
		1499	believe me.
		1500
1297	=back	1501	=back
1298		1502
1299		1503
1300	=head1 OTHER FUNCTIONS	1504	=head1 OTHER FUNCTIONS
1301		1505
…		…
1463		1667
1464	=item w->sweep () C<ev::embed> only	1668	=item w->sweep () C<ev::embed> only
1465		1669
1466	Invokes C<ev_embed_sweep>.	1670	Invokes C<ev_embed_sweep>.
1467		1671
		1672	=item w->update () C<ev::stat> only
		1673
		1674	Invokes C<ev_stat_stat>.
		1675
1468	=back	1676	=back
1469		1677
1470	=back	1678	=back
1471		1679
1472	Example: Define a class with an IO and idle watcher, start one of them in	1680	Example: Define a class with an IO and idle watcher, start one of them in
…		…
1484	: io (this, &myclass::io_cb),	1692	: io (this, &myclass::io_cb),
1485	idle (this, &myclass::idle_cb)	1693	idle (this, &myclass::idle_cb)
1486	{	1694	{
1487	io.start (fd, ev::READ);	1695	io.start (fd, ev::READ);
1488	}	1696	}
		1697
		1698
		1699	=head1 MACRO MAGIC
		1700
		1701	Libev can be compiled with a variety of options, the most fundemantal is
		1702	C<EV_MULTIPLICITY>. This option determines wether (most) functions and
		1703	callbacks have an initial C<struct ev_loop *> argument.
		1704
		1705	To make it easier to write programs that cope with either variant, the
		1706	following macros are defined:
		1707
		1708	=over 4
		1709
		1710	=item C<EV_A>, C<EV_A_>
		1711
		1712	This provides the loop I<argument> for functions, if one is required ("ev
		1713	loop argument"). The C<EV_A> form is used when this is the sole argument,
		1714	C<EV_A_> is used when other arguments are following. Example:
		1715
		1716	ev_unref (EV_A);
		1717	ev_timer_add (EV_A_ watcher);
		1718	ev_loop (EV_A_ 0);
		1719
		1720	It assumes the variable C<loop> of type C<struct ev_loop *> is in scope,
		1721	which is often provided by the following macro.
		1722
		1723	=item C<EV_P>, C<EV_P_>
		1724
		1725	This provides the loop I<parameter> for functions, if one is required ("ev
		1726	loop parameter"). The C<EV_P> form is used when this is the sole parameter,
		1727	C<EV_P_> is used when other parameters are following. Example:
		1728
		1729	// this is how ev_unref is being declared
		1730	static void ev_unref (EV_P);
		1731
		1732	// this is how you can declare your typical callback
		1733	static void cb (EV_P_ ev_timer *w, int revents)
		1734
		1735	It declares a parameter C<loop> of type C<struct ev_loop *>, quite
		1736	suitable for use with C<EV_A>.
		1737
		1738	=item C<EV_DEFAULT>, C<EV_DEFAULT_>
		1739
		1740	Similar to the other two macros, this gives you the value of the default
		1741	loop, if multiple loops are supported ("ev loop default").
		1742
		1743	=back
		1744
		1745	Example: Declare and initialise a check watcher, working regardless of
		1746	wether multiple loops are supported or not.
		1747
		1748	static void
		1749	check_cb (EV_P_ ev_timer *w, int revents)
		1750	{
		1751	ev_check_stop (EV_A_ w);
		1752	}
		1753
		1754	ev_check check;
		1755	ev_check_init (&check, check_cb);
		1756	ev_check_start (EV_DEFAULT_ &check);
		1757	ev_loop (EV_DEFAULT_ 0);
		1758
1489		1759
1490	=head1 EMBEDDING	1760	=head1 EMBEDDING
1491		1761
1492	Libev can (and often is) directly embedded into host	1762	Libev can (and often is) directly embedded into host
1493	applications. Examples of applications that embed it include the Deliantra	1763	applications. Examples of applications that embed it include the Deliantra
…		…
1700	will have the C<struct ev_loop *> as first argument, and you can create	1970	will have the C<struct ev_loop *> as first argument, and you can create
1701	additional independent event loops. Otherwise there will be no support	1971	additional independent event loops. Otherwise there will be no support
1702	for multiple event loops and there is no first event loop pointer	1972	for multiple event loops and there is no first event loop pointer
1703	argument. Instead, all functions act on the single default loop.	1973	argument. Instead, all functions act on the single default loop.
1704		1974
1705	=item EV_PERIODICS	1975	=item EV_PERIODIC_ENABLE
1706		1976
1707	If undefined or defined to be C<1>, then periodic timers are supported,	1977	If undefined or defined to be C<1>, then periodic timers are supported. If
1708	otherwise not. This saves a few kb of code.	1978	defined to be C<0>, then they are not. Disabling them saves a few kB of
		1979	code.
		1980
		1981	=item EV_EMBED_ENABLE
		1982
		1983	If undefined or defined to be C<1>, then embed watchers are supported. If
		1984	defined to be C<0>, then they are not.
		1985
		1986	=item EV_STAT_ENABLE
		1987
		1988	If undefined or defined to be C<1>, then stat watchers are supported. If
		1989	defined to be C<0>, then they are not.
		1990
		1991	=item EV_FORK_ENABLE
		1992
		1993	If undefined or defined to be C<1>, then fork watchers are supported. If
		1994	defined to be C<0>, then they are not.
		1995
		1996	=item EV_MINIMAL
		1997
		1998	If you need to shave off some kilobytes of code at the expense of some
		1999	speed, define this symbol to C<1>. Currently only used for gcc to override
		2000	some inlining decisions, saves roughly 30% codesize of amd64.
		2001
		2002	=item EV_PID_HASHSIZE
		2003
		2004	C<ev_child> watchers use a small hash table to distribute workload by
		2005	pid. The default size is C<16> (or C<1> with C<EV_MINIMAL>), usually more
		2006	than enough. If you need to manage thousands of children you might want to
		2007	increase this value.
1709		2008
1710	=item EV_COMMON	2009	=item EV_COMMON
1711		2010
1712	By default, all watchers have a C<void *data> member. By redefining	2011	By default, all watchers have a C<void *data> member. By redefining
1713	this macro to a something else you can include more and other types of	2012	this macro to a something else you can include more and other types of

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.pod (file contents): Revision 1.46 by root, Mon Nov 26 10:20:43 2007 UTC vs. Revision 1.52 by root, Tue Nov 27 19:41:52 2007 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.46 by root, Mon Nov 26 10:20:43 2007 UTC vs.
Revision 1.52 by root, Tue Nov 27 19:41:52 2007 UTC