Merge sf/master
[netatalk.git] / etc / afpd / fce_api.c
1 /*\r
2  * Copyright (c) 2010 Mark Williams\r
3  *\r
4  * File change event API for netatalk\r
5  *\r
6  * for every detected filesystem change a UDP packet is sent to an arbitrary list\r
7  * of listeners. Each packet contains unix path of modified filesystem element,\r
8  * event reason, and a consecutive event id (32 bit). Technically we are UDP client and are sending\r
9  * out packets synchronuosly as they are created by the afp functions. This should not affect\r
10  * performance measurably. The only delaying calls occur during initialization, if we have to\r
11  * resolve non-IP hostnames to IP. All numeric data inside the packet is network byte order, so use\r
12  * ntohs / ntohl to resolve length and event id. Ideally a listener receives every packet with\r
13  * no gaps in event ids, starting with event id 1 and mode FCE_CONN_START followed by\r
14  * data events from id 2 up to 0xFFFFFFFF, followed by 0 to 0xFFFFFFFF and so on.\r
15  *\r
16  * A gap or not starting with 1 mode FCE_CONN_START or receiving mode FCE_CONN_BROKEN means that\r
17  * the listener has lost at least one filesystem event\r
18  * \r
19  * All Rights Reserved.  See COPYRIGHT.\r
20  */\r
21 \r
22 #ifdef HAVE_CONFIG_H\r
23 #include "config.h"\r
24 #endif /* HAVE_CONFIG_H */\r
25 \r
26 #include <stdio.h>\r
27 \r
28 #include <string.h>\r
29 #include <stdlib.h>\r
30 #include <errno.h>\r
31 #include <time.h>\r
32 \r
33 \r
34 #include <sys/param.h>\r
35 #include <sys/socket.h>\r
36 #include <netinet/in.h>\r
37 #include <arpa/inet.h>\r
38 #include <netdb.h>\r
39 \r
40 #include <netatalk/at.h>\r
41 \r
42 #include <atalk/adouble.h>\r
43 #include <atalk/vfs.h>\r
44 #include <atalk/logger.h>\r
45 #include <atalk/afp.h>\r
46 #include <atalk/util.h>\r
47 #include <atalk/cnid.h>\r
48 #include <atalk/unix.h>\r
49 #include <atalk/fce_api.h>\r
50 \r
51 #include "fork.h"\r
52 #include "file.h"\r
53 #include "globals.h"\r
54 #include "directory.h"\r
55 #include "desktop.h"\r
56 #include "volume.h"\r
57 \r
58 // ONLY USED IN THIS FILE\r
59 #include "fce_api_internal.h"\r
60 \r
61 #define FCE_TRUE 1\r
62 #define FCE_FALSE 0\r
63 \r
64 /* We store our connection data here */\r
65 static struct udp_entry udp_socket_list[FCE_MAX_UDP_SOCKS];\r
66 static int udp_sockets = 0;\r
67 static int udp_initialized = FCE_FALSE;\r
68 static unsigned long fce_ev_enabled =\r
69     (1 << FCE_FILE_MODIFY) |\r
70     (1 << FCE_FILE_DELETE) |\r
71     (1 << FCE_DIR_DELETE) |\r
72     (1 << FCE_FILE_CREATE) |\r
73     (1 << FCE_DIR_CREATE);\r
74 \r
75 static uint64_t tm_used;          /* used for passing to event handler */\r
76 #define MAXIOBUF 1024\r
77 static char iobuf[MAXIOBUF];\r
78 static const char *skip_files[] = \r
79 {\r
80         ".DS_Store",\r
81         NULL\r
82 };\r
83 \r
84 /*\r
85  *\r
86  * Initialize network structs for any listeners\r
87  * We dont give return code because all errors are handled internally (I hope..)\r
88  *\r
89  * */\r
90 void fce_init_udp()\r
91 {\r
92     int rv;\r
93     struct addrinfo hints, *servinfo, *p;\r
94 \r
95     if (udp_initialized == FCE_TRUE)\r
96         return;\r
97 \r
98     memset(&hints, 0, sizeof hints);\r
99     hints.ai_family = AF_UNSPEC;\r
100     hints.ai_socktype = SOCK_DGRAM;\r
101 \r
102     for (int i = 0; i < udp_sockets; i++) {\r
103         struct udp_entry *udp_entry = udp_socket_list + i;\r
104 \r
105         /* Close any pending sockets */\r
106         if (udp_entry->sock != -1)\r
107             close(udp_entry->sock);\r
108 \r
109         if ((rv = getaddrinfo(udp_entry->addr, udp_entry->port, &hints, &servinfo)) != 0) {\r
110             LOG(log_error, logtype_afpd, "fce_init_udp: getaddrinfo(%s:%s): %s",\r
111                 udp_entry->addr, udp_entry->port, gai_strerror(rv));\r
112             continue;\r
113         }\r
114 \r
115         /* loop through all the results and make a socket */\r
116         for (p = servinfo; p != NULL; p = p->ai_next) {\r
117             if ((udp_entry->sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {\r
118                 LOG(log_error, logtype_afpd, "fce_init_udp: socket(%s:%s): %s",\r
119                     udp_entry->addr, udp_entry->port, strerror(errno));\r
120                 continue;\r
121             }\r
122             break;\r
123         }\r
124 \r
125         if (p == NULL) {\r
126             LOG(log_error, logtype_afpd, "fce_init_udp: no socket for %s:%s",\r
127                 udp_entry->addr, udp_entry->port);\r
128         }\r
129         udp_entry->addrinfo = *p;\r
130         memcpy(&udp_entry->addrinfo, p, sizeof(struct addrinfo));\r
131         memcpy(&udp_entry->sockaddr, p->ai_addr, sizeof(struct sockaddr_storage));\r
132         freeaddrinfo(servinfo);\r
133     }\r
134 \r
135     udp_initialized = FCE_TRUE;\r
136 }\r
137 \r
138 void fce_cleanup()\r
139 {\r
140     if (udp_initialized == FCE_FALSE )\r
141         return;\r
142 \r
143     for (int i = 0; i < udp_sockets; i++)\r
144     {\r
145         struct udp_entry *udp_entry = udp_socket_list + i;\r
146 \r
147         /* Close any pending sockets */\r
148         if (udp_entry->sock != -1)\r
149         {\r
150             close( udp_entry->sock );\r
151             udp_entry->sock = -1;\r
152         }\r
153     }\r
154     udp_initialized = FCE_FALSE;\r
155 }\r
156 \r
157 \r
158 /*\r
159  * Construct a UDP packet for our listeners and return packet size\r
160  * */\r
161 static ssize_t build_fce_packet( struct fce_packet *packet, char *path, int mode, uint32_t event_id )\r
162 {\r
163     size_t pathlen;\r
164     ssize_t data_len = 0;\r
165 \r
166     strncpy(packet->magic, FCE_PACKET_MAGIC, sizeof(packet->magic) );\r
167     packet->version = FCE_PACKET_VERSION;\r
168     packet->mode = mode;\r
169     packet->event_id = event_id;\r
170 \r
171     pathlen = strlen(path) + 1; /* include string terminator */\r
172 \r
173     /* This should never happen, but before we bust this server, we send nonsense, fce listener has to cope */\r
174     if (pathlen >= MAXPATHLEN)\r
175         pathlen = MAXPATHLEN - 1;\r
176 \r
177     /* This is the payload len. Means: the stream has len bytes more until packet is finished */\r
178     /* A server should read the first 16 byte, decode them and then fetch the rest */\r
179     data_len = FCE_PACKET_HEADER_SIZE + pathlen;\r
180     packet->datalen = pathlen;\r
181 \r
182     switch (mode) {\r
183     case FCE_TM_SIZE:\r
184         tm_used = hton64(tm_used);\r
185         memcpy(packet->data, &tm_used, sizeof(tm_used));\r
186         strncpy(packet->data + sizeof(tm_used), path, pathlen);\r
187 \r
188         packet->datalen += sizeof(tm_used);\r
189         data_len += sizeof(tm_used);\r
190         break;\r
191     default:\r
192         strncpy(packet->data, path, pathlen);\r
193         break;\r
194     }\r
195 \r
196     /* return the packet len */\r
197     return data_len;\r
198 }\r
199 \r
200 static int pack_fce_packet(struct fce_packet *packet, unsigned char *buf)\r
201 {\r
202     unsigned char *p = buf;\r
203 \r
204     memcpy(p, &packet->magic[0], sizeof(packet->magic));\r
205     p += sizeof(packet->magic);\r
206 \r
207     *p = packet->version;\r
208     p++;\r
209     \r
210     *p = packet->mode;\r
211     p++;\r
212     \r
213     uint32_t id = htonl(packet->event_id);\r
214     memcpy(p, &id, sizeof(id));\r
215     p += sizeof(packet->event_id);\r
216 \r
217     uint16_t l = htons(packet->datalen);\r
218     memcpy(p, &l, sizeof(l));\r
219     p += sizeof(l);\r
220 \r
221     memcpy(p, &packet->data[0], packet->datalen);\r
222     p += packet->datalen;\r
223 \r
224     return 0;\r
225 }\r
226 \r
227 /*\r
228  * Send the fce information to all (connected) listeners\r
229  * We dont give return code because all errors are handled internally (I hope..)\r
230  * */\r
231 static void send_fce_event( char *path, int mode )\r
232 {    \r
233     struct fce_packet packet;\r
234     void *data = &packet;\r
235     static uint32_t event_id = 0; /* the unique packet couter to detect packet/data loss. Going from 0xFFFFFFFF to 0x0 is a valid increment */\r
236 \r
237     LOG(log_debug, logtype_afpd, "send_fce_event: start");\r
238 \r
239     time_t now = time(NULL);\r
240 \r
241     /* build our data packet */\r
242     ssize_t data_len = build_fce_packet( &packet, path, mode, ++event_id );\r
243     pack_fce_packet(&packet, iobuf);\r
244 \r
245     for (int i = 0; i < udp_sockets; i++)\r
246     {\r
247         int sent_data = 0;\r
248         struct udp_entry *udp_entry = udp_socket_list + i;\r
249 \r
250         /* we had a problem earlier ? */\r
251         if (udp_entry->sock == -1)\r
252         {\r
253             /* We still have to wait ?*/\r
254             if (now < udp_entry->next_try_on_error)\r
255                 continue;\r
256 \r
257             /* Reopen socket */\r
258             udp_entry->sock = socket(udp_entry->addrinfo.ai_family,\r
259                                      udp_entry->addrinfo.ai_socktype,\r
260                                      udp_entry->addrinfo.ai_protocol);\r
261             \r
262             if (udp_entry->sock == -1) {\r
263                 /* failed again, so go to rest again */\r
264                 LOG(log_error, logtype_afpd, "Cannot recreate socket for fce UDP connection: errno %d", errno  );\r
265 \r
266                 udp_entry->next_try_on_error = now + FCE_SOCKET_RETRY_DELAY_S;\r
267                 continue;\r
268             }\r
269 \r
270             udp_entry->next_try_on_error = 0;\r
271 \r
272             /* Okay, we have a running socket again, send server that we had a problem on our side*/\r
273             data_len = build_fce_packet( &packet, "", FCE_CONN_BROKEN, 0 );\r
274             pack_fce_packet(&packet, iobuf);\r
275 \r
276             sendto(udp_entry->sock,\r
277                    iobuf,\r
278                    data_len,\r
279                    0,\r
280                    (struct sockaddr *)&udp_entry->sockaddr,\r
281                    udp_entry->addrinfo.ai_addrlen);\r
282 \r
283             /* Rebuild our original data packet */\r
284             data_len = build_fce_packet( &packet, path, mode, event_id );\r
285             pack_fce_packet(&packet, iobuf);\r
286         }\r
287 \r
288         sent_data = sendto(udp_entry->sock,\r
289                            iobuf,\r
290                            data_len,\r
291                            0,\r
292                            (struct sockaddr *)&udp_entry->sockaddr,\r
293                            udp_entry->addrinfo.ai_addrlen);\r
294 \r
295         /* Problems ? */\r
296         if (sent_data != data_len) {\r
297             /* Argh, socket broke, we close and retry later */\r
298             LOG(log_error, logtype_afpd, "send_fce_event: error sending packet to %s:%s, transfered %d of %d: %s",\r
299                 udp_entry->addr, udp_entry->port, sent_data, data_len, strerror(errno));\r
300 \r
301             close( udp_entry->sock );\r
302             udp_entry->sock = -1;\r
303             udp_entry->next_try_on_error = now + FCE_SOCKET_RETRY_DELAY_S;\r
304         }\r
305     }\r
306 }\r
307 \r
308 static int add_udp_socket(const char *target_ip, const char *target_port )\r
309 {\r
310     if (target_port == NULL)\r
311         target_port = FCE_DEFAULT_PORT_STRING;\r
312 \r
313     if (udp_sockets >= FCE_MAX_UDP_SOCKS) {\r
314         LOG(log_error, logtype_afpd, "Too many file change api UDP connections (max %d allowed)", FCE_MAX_UDP_SOCKS );\r
315         return AFPERR_PARAM;\r
316     }\r
317 \r
318     udp_socket_list[udp_sockets].addr = strdup(target_ip);\r
319     udp_socket_list[udp_sockets].port = strdup(target_port);\r
320     udp_socket_list[udp_sockets].sock = -1;\r
321     memset(&udp_socket_list[udp_sockets].addrinfo, 0, sizeof(struct addrinfo));\r
322     memset(&udp_socket_list[udp_sockets].sockaddr, 0, sizeof(struct sockaddr_storage));\r
323     udp_socket_list[udp_sockets].next_try_on_error = 0;\r
324 \r
325     udp_sockets++;\r
326 \r
327     return AFP_OK;\r
328 }\r
329 \r
330 /*\r
331  *\r
332  * Dispatcher for all incoming file change events\r
333  *\r
334  * */\r
335 static int register_fce(const char *u_name, int is_dir, int mode)\r
336 {\r
337     if (udp_sockets == 0)\r
338         /* No listeners configured */\r
339         return AFP_OK;\r
340 \r
341     if (u_name == NULL)\r
342         return AFPERR_PARAM;\r
343 \r
344     static int first_event = FCE_TRUE;\r
345 \r
346         /* do some initialization on the fly the first time */\r
347         if (first_event) {\r
348                 fce_initialize_history();\r
349         }\r
350 \r
351         /* handle files which should not cause events (.DS_Store atc. ) */\r
352         for (int i = 0; skip_files[i] != NULL; i++)\r
353         {\r
354                 if (!strcmp( u_name, skip_files[i]))\r
355                         return AFP_OK;\r
356         }\r
357 \r
358 \r
359         char full_path_buffer[MAXPATHLEN + 1] = {""};\r
360         const char *cwd = getcwdpath();\r
361 \r
362     if (mode == FCE_TM_SIZE) {\r
363         strlcpy(full_path_buffer, u_name, MAXPATHLEN);\r
364     } else if (!is_dir || mode == FCE_DIR_DELETE) {\r
365                 if (strlen( cwd ) + strlen( u_name) + 1 >= MAXPATHLEN) {\r
366                         LOG(log_error, logtype_afpd, "FCE file name too long: %s/%s", cwd, u_name );\r
367                         return AFPERR_PARAM;\r
368                 }\r
369                 sprintf( full_path_buffer, "%s/%s", cwd, u_name );\r
370         } else {\r
371                 if (strlen( cwd ) >= MAXPATHLEN) {\r
372                         LOG(log_error, logtype_afpd, "FCE directory name too long: %s", cwd);\r
373                         return AFPERR_PARAM;\r
374                 }\r
375                 strcpy( full_path_buffer, cwd);\r
376         }\r
377 \r
378         /* Can we ignore this event based on type or history? */\r
379         if (!(mode & FCE_TM_SIZE) && fce_handle_coalescation( full_path_buffer, is_dir, mode ))\r
380         {\r
381                 LOG(log_debug9, logtype_afpd, "Coalesced fc event <%d> for <%s>", mode, full_path_buffer );\r
382                 return AFP_OK;\r
383         }\r
384 \r
385         LOG(log_debug9, logtype_afpd, "Detected fc event <%d> for <%s>", mode, full_path_buffer );\r
386 \r
387 \r
388     /* we do initilization on the fly, no blocking calls in here \r
389      * (except when using FQDN in broken DNS environment)\r
390      */\r
391     if (first_event == FCE_TRUE)\r
392     {\r
393         fce_init_udp();\r
394         \r
395         /* Notify listeners the we start from the beginning */\r
396         send_fce_event( "", FCE_CONN_START );\r
397         \r
398         first_event = FCE_FALSE;\r
399     }\r
400 \r
401         /* Handle UDP transport */\r
402     send_fce_event( full_path_buffer, mode );\r
403 \r
404     return AFP_OK;\r
405 }\r
406 \r
407 \r
408 /******************** External calls start here **************************/\r
409 \r
410 /*\r
411  * API-Calls for file change api, called form outside (file.c directory.c ofork.c filedir.c)\r
412  * */\r
413 #ifndef FCE_TEST_MAIN\r
414 \r
415 int fce_register_delete_file( struct path *path )\r
416 {\r
417     int ret = AFP_OK;\r
418 \r
419     if (path == NULL)\r
420         return AFPERR_PARAM;\r
421 \r
422     if (!(fce_ev_enabled & (1 << FCE_FILE_DELETE)))\r
423         return ret;\r
424         \r
425     ret = register_fce( path->u_name, FALSE, FCE_FILE_DELETE );\r
426 \r
427     return ret;\r
428 }\r
429 int fce_register_delete_dir( char *name )\r
430 {\r
431     int ret = AFP_OK;\r
432 \r
433     if (name == NULL)\r
434         return AFPERR_PARAM;\r
435 \r
436     if (!(fce_ev_enabled & (1 << FCE_DIR_DELETE)))\r
437         return ret;\r
438         \r
439     ret = register_fce( name, TRUE, FCE_DIR_DELETE);\r
440 \r
441     return ret;\r
442 }\r
443 \r
444 int fce_register_new_dir( struct path *path )\r
445 {\r
446     int ret = AFP_OK;\r
447 \r
448     if (path == NULL)\r
449         return AFPERR_PARAM;\r
450 \r
451     if (!(fce_ev_enabled & (1 << FCE_DIR_CREATE)))\r
452         return ret;\r
453 \r
454     ret = register_fce( path->u_name, TRUE, FCE_DIR_CREATE );\r
455 \r
456     return ret;\r
457 }\r
458 \r
459 \r
460 int fce_register_new_file( struct path *path )\r
461 {\r
462     int ret = AFP_OK;\r
463 \r
464     if (path == NULL)\r
465         return AFPERR_PARAM;\r
466 \r
467     if (!(fce_ev_enabled & (1 << FCE_FILE_CREATE)))\r
468         return ret;\r
469 \r
470     ret = register_fce( path->u_name, FALSE, FCE_FILE_CREATE );\r
471 \r
472     return ret;\r
473 }\r
474 \r
475 int fce_register_file_modification( struct ofork *ofork )\r
476 {\r
477     char *u_name = NULL;\r
478     struct vol *vol;\r
479     int ret = AFP_OK;\r
480 \r
481     if (ofork == NULL || ofork->of_vol == NULL)\r
482         return AFPERR_PARAM;\r
483 \r
484     if (!(fce_ev_enabled & (1 << FCE_FILE_MODIFY)))\r
485         return ret;\r
486 \r
487     vol = ofork->of_vol;\r
488 \r
489     if (NULL == (u_name = mtoupath(vol, of_name(ofork), ofork->of_did, utf8_encoding()))) \r
490     {\r
491         return AFPERR_MISC;\r
492     }\r
493     \r
494     ret = register_fce( u_name, FALSE, FCE_FILE_MODIFY );\r
495     \r
496     return ret;    \r
497 }\r
498 \r
499 int fce_register_tm_size(const char *vol, size_t used)\r
500 {\r
501     int ret = AFP_OK;\r
502 \r
503     if (vol == NULL)\r
504         return AFPERR_PARAM;\r
505 \r
506     if (!(fce_ev_enabled & (1 << FCE_TM_SIZE)))\r
507         return ret;\r
508 \r
509     tm_used = used;             /* oh what a hack */\r
510     ret = register_fce(vol, FALSE, FCE_TM_SIZE);\r
511 \r
512     return ret;\r
513 }\r
514 #endif\r
515 \r
516 /*\r
517  *\r
518  * Extern connect to afpd parameter, can be called multiple times for multiple listeners (up to MAX_UDP_SOCKS times)\r
519  *\r
520  * */\r
521 int fce_add_udp_socket(const char *target)\r
522 {\r
523         const char *port = FCE_DEFAULT_PORT_STRING;\r
524         char target_ip[256] = {""};\r
525 \r
526         strncpy(target_ip, target, sizeof(target_ip) -1);\r
527 \r
528         char *port_delim = strchr( target_ip, ':' );\r
529         if (port_delim) {\r
530                 *port_delim = 0;\r
531                 port = port_delim + 1;\r
532         }\r
533         return add_udp_socket(target_ip, port);\r
534 }\r
535 \r
536 int fce_set_events(const char *events)\r
537 {\r
538     char *e;\r
539     char *p;\r
540     \r
541     if (events == NULL)\r
542         return AFPERR_PARAM;\r
543 \r
544     e = strdup(events);\r
545 \r
546     fce_ev_enabled = 0;\r
547 \r
548     for (p = strtok(e, ","); p; p = strtok(NULL, ",")) {\r
549         if (strcmp(p, "fmod") == 0) {\r
550             fce_ev_enabled |= (1 << FCE_FILE_MODIFY);\r
551         } else if (strcmp(p, "fdel") == 0) {\r
552             fce_ev_enabled |= (1 << FCE_FILE_DELETE);\r
553         } else if (strcmp(p, "ddel") == 0) {\r
554             fce_ev_enabled |= (1 << FCE_DIR_DELETE);\r
555         } else if (strcmp(p, "fcre") == 0) {\r
556             fce_ev_enabled |= (1 << FCE_FILE_CREATE);\r
557         } else if (strcmp(p, "dcre") == 0) {\r
558             fce_ev_enabled |= (1 << FCE_DIR_CREATE);\r
559         } else if (strcmp(p, "tmsz") == 0) {\r
560             fce_ev_enabled |= (1 << FCE_TM_SIZE);\r
561         }\r
562     }\r
563 \r
564     free(e);\r
565 }\r
566 \r
567 #ifdef FCE_TEST_MAIN\r
568 \r
569 \r
570 void shortsleep( unsigned int us )\r
571 {    \r
572     usleep( us );\r
573 }\r
574 int main( int argc, char*argv[] )\r
575 {\r
576     int c,ret;\r
577 \r
578     char *port = FCE_DEFAULT_PORT_STRING;\r
579     char *host = "localhost";\r
580     int delay_between_events = 1000;\r
581     int event_code = FCE_FILE_MODIFY;\r
582     char pathbuff[1024];\r
583     int duration_in_seconds = 0; // TILL ETERNITY\r
584     char target[256];\r
585     char *path = getcwd( pathbuff, sizeof(pathbuff) );\r
586 \r
587     // FULLSPEED TEST IS "-s 1001" -> delay is 0 -> send packets without pause\r
588 \r
589     while ((c = getopt(argc, argv, "d:e:h:p:P:s:")) != -1) {\r
590         switch(c) {\r
591         case '?':\r
592             fprintf(stdout, "%s: [ -p Port -h Listener1 [ -h Listener2 ...] -P path -s Delay_between_events_in_us -e event_code -d Duration ]\n", argv[0]);\r
593             exit(1);\r
594             break;\r
595         case 'd':\r
596             duration_in_seconds = atoi(optarg);\r
597             break;\r
598         case 'e':\r
599             event_code = atoi(optarg);\r
600             break;\r
601         case 'h':\r
602             host = strdup(optarg);\r
603             break;\r
604         case 'p':\r
605             port = strdup(optarg);\r
606             break;\r
607         case 'P':\r
608             path = strdup(optarg);\r
609             break;\r
610         case 's':\r
611             delay_between_events = atoi(optarg);\r
612             break;\r
613         }\r
614     }\r
615 \r
616     sprintf(target, "%s:%s", host, port);\r
617     if (fce_add_udp_socket(target) != 0)\r
618         return 1;\r
619 \r
620     int ev_cnt = 0;\r
621     time_t start_time = time(NULL);\r
622     time_t end_time = 0;\r
623 \r
624     if (duration_in_seconds)\r
625         end_time = start_time + duration_in_seconds;\r
626 \r
627     while (1)\r
628     {\r
629         time_t now = time(NULL);\r
630         if (now > start_time)\r
631         {\r
632             start_time = now;\r
633             fprintf( stdout, "%d events/s\n", ev_cnt );\r
634             ev_cnt = 0;\r
635         }\r
636         if (end_time && now >= end_time)\r
637             break;\r
638 \r
639         register_fce( path, 0, event_code );\r
640         ev_cnt++;\r
641 \r
642         \r
643         shortsleep( delay_between_events );\r
644     }\r
645 }\r
646 #endif /* TESTMAIN*/\r