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 #include <atalk/globals.h>\r
  51 \r
  52 #include "fork.h"\r
  53 #include "file.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