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