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_note, 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         LOG(log_note, logtype_afpd, "send_fce_event: sending...");\r
 289         sent_data = sendto(udp_entry->sock,\r
 290                            iobuf,\r
 291                            data_len,\r
 292                            0,\r
 293                            (struct sockaddr *)&udp_entry->sockaddr,\r
 294                            udp_entry->addrinfo.ai_addrlen);\r
 295 \r
 296         /* Problems ? */\r
 297         if (sent_data != data_len) {\r
 298             /* Argh, socket broke, we close and retry later */\r
 299             LOG(log_error, logtype_afpd, "send_fce_event: error sending packet to %s:%s, transfered %d of %d: %s",\r
 300                 udp_entry->addr, udp_entry->port, sent_data, data_len, strerror(errno));\r
 301 \r
 302             close( udp_entry->sock );\r
 303             udp_entry->sock = -1;\r
 304             udp_entry->next_try_on_error = now + FCE_SOCKET_RETRY_DELAY_S;\r
 305         }\r
 306     }\r
 307 }\r
 308 \r
 309 static int add_udp_socket(const char *target_ip, const char *target_port )\r
 310 {\r
 311     if (target_port == NULL)\r
 312         target_port = FCE_DEFAULT_PORT_STRING;\r
 313 \r
 314     if (udp_sockets >= FCE_MAX_UDP_SOCKS) {\r
 315         LOG(log_error, logtype_afpd, "Too many file change api UDP connections (max %d allowed)", FCE_MAX_UDP_SOCKS );\r
 316         return AFPERR_PARAM;\r
 317     }\r
 318 \r
 319     udp_socket_list[udp_sockets].addr = strdup(target_ip);\r
 320     udp_socket_list[udp_sockets].port = strdup(target_port);\r
 321     udp_socket_list[udp_sockets].sock = -1;\r
 322     memset(&udp_socket_list[udp_sockets].addrinfo, 0, sizeof(struct addrinfo));\r
 323     memset(&udp_socket_list[udp_sockets].sockaddr, 0, sizeof(struct sockaddr_storage));\r
 324     udp_socket_list[udp_sockets].next_try_on_error = 0;\r
 325 \r
 326     udp_sockets++;\r
 327 \r
 328     return AFP_OK;\r
 329 }\r
 330 \r
 331 /*\r
 332  *\r
 333  * Dispatcher for all incoming file change events\r
 334  *\r
 335  * */\r
 336 static int register_fce(const char *u_name, int is_dir, int mode)\r
 337 {\r
 338     if (udp_sockets == 0)\r
 339         /* No listeners configured */\r
 340         return AFP_OK;\r
 341 \r
 342     if (u_name == NULL)\r
 343         return AFPERR_PARAM;\r
 344 \r
 345     static int first_event = FCE_TRUE;\r
 346 \r
 347         /* do some initialization on the fly the first time */\r
 348         if (first_event) {\r
 349                 fce_initialize_history();\r
 350         }\r
 351 \r
 352         /* handle files which should not cause events (.DS_Store atc. ) */\r
 353         for (int i = 0; skip_files[i] != NULL; i++)\r
 354         {\r
 355                 if (!strcmp( u_name, skip_files[i]))\r
 356                         return AFP_OK;\r
 357         }\r
 358 \r
 359 \r
 360         char full_path_buffer[MAXPATHLEN + 1] = {""};\r
 361         const char *cwd = getcwdpath();\r
 362 \r
 363     if (mode == FCE_TM_SIZE) {\r
 364         strlcpy(full_path_buffer, u_name, MAXPATHLEN);\r
 365     } else if (!is_dir || mode == FCE_DIR_DELETE) {\r
 366                 if (strlen( cwd ) + strlen( u_name) + 1 >= MAXPATHLEN) {\r
 367                         LOG(log_error, logtype_afpd, "FCE file name too long: %s/%s", cwd, u_name );\r
 368                         return AFPERR_PARAM;\r
 369                 }\r
 370                 sprintf( full_path_buffer, "%s/%s", cwd, u_name );\r
 371         } else {\r
 372                 if (strlen( cwd ) >= MAXPATHLEN) {\r
 373                         LOG(log_error, logtype_afpd, "FCE directory name too long: %s", cwd);\r
 374                         return AFPERR_PARAM;\r
 375                 }\r
 376                 strcpy( full_path_buffer, cwd);\r
 377         }\r
 378 \r
 379         /* Can we ignore this event based on type or history? */\r
 380         if (!(mode & FCE_TM_SIZE) && fce_handle_coalescation( full_path_buffer, is_dir, mode ))\r
 381         {\r
 382                 LOG(log_debug9, logtype_afpd, "Coalesced fc event <%d> for <%s>", mode, full_path_buffer );\r
 383                 return AFP_OK;\r
 384         }\r
 385 \r
 386         LOG(log_debug9, logtype_afpd, "Detected fc event <%d> for <%s>", mode, full_path_buffer );\r
 387 \r
 388 \r
 389     /* we do initilization on the fly, no blocking calls in here \r
 390      * (except when using FQDN in broken DNS environment)\r
 391      */\r
 392     if (first_event == FCE_TRUE)\r
 393     {\r
 394         fce_init_udp();\r
 395         \r
 396         /* Notify listeners the we start from the beginning */\r
 397         send_fce_event( "", FCE_CONN_START );\r
 398         \r
 399         first_event = FCE_FALSE;\r
 400     }\r
 401 \r
 402         /* Handle UDP transport */\r
 403     send_fce_event( full_path_buffer, mode );\r
 404 \r
 405     return AFP_OK;\r
 406 }\r
 407 \r
 408 \r
 409 /******************** External calls start here **************************/\r
 410 \r
 411 /*\r
 412  * API-Calls for file change api, called form outside (file.c directory.c ofork.c filedir.c)\r
 413  * */\r
 414 #ifndef FCE_TEST_MAIN\r
 415 \r
 416 int fce_register_delete_file( struct path *path )\r
 417 {\r
 418     int ret = AFP_OK;\r
 419 \r
 420     if (path == NULL)\r
 421         return AFPERR_PARAM;\r
 422 \r
 423     if (!(fce_ev_enabled & (1 << FCE_FILE_DELETE)))\r
 424         return ret;\r
 425         \r
 426     ret = register_fce( path->u_name, FALSE, FCE_FILE_DELETE );\r
 427 \r
 428     return ret;\r
 429 }\r
 430 int fce_register_delete_dir( char *name )\r
 431 {\r
 432     int ret = AFP_OK;\r
 433 \r
 434     if (name == NULL)\r
 435         return AFPERR_PARAM;\r
 436 \r
 437     if (!(fce_ev_enabled & (1 << FCE_DIR_DELETE)))\r
 438         return ret;\r
 439         \r
 440     ret = register_fce( name, TRUE, FCE_DIR_DELETE);\r
 441 \r
 442     return ret;\r
 443 }\r
 444 \r
 445 int fce_register_new_dir( struct path *path )\r
 446 {\r
 447     int ret = AFP_OK;\r
 448 \r
 449     if (path == NULL)\r
 450         return AFPERR_PARAM;\r
 451 \r
 452     if (!(fce_ev_enabled & (1 << FCE_DIR_CREATE)))\r
 453         return ret;\r
 454 \r
 455     ret = register_fce( path->u_name, TRUE, FCE_DIR_CREATE );\r
 456 \r
 457     return ret;\r
 458 }\r
 459 \r
 460 \r
 461 int fce_register_new_file( struct path *path )\r
 462 {\r
 463     int ret = AFP_OK;\r
 464 \r
 465     if (path == NULL)\r
 466         return AFPERR_PARAM;\r
 467 \r
 468     if (!(fce_ev_enabled & (1 << FCE_FILE_CREATE)))\r
 469         return ret;\r
 470 \r
 471     ret = register_fce( path->u_name, FALSE, FCE_FILE_CREATE );\r
 472 \r
 473     return ret;\r
 474 }\r
 475 \r
 476 int fce_register_file_modification( struct ofork *ofork )\r
 477 {\r
 478     char *u_name = NULL;\r
 479     struct vol *vol;\r
 480     int ret = AFP_OK;\r
 481 \r
 482     if (ofork == NULL || ofork->of_vol == NULL)\r
 483         return AFPERR_PARAM;\r
 484 \r
 485     if (!(fce_ev_enabled & (1 << FCE_FILE_MODIFY)))\r
 486         return ret;\r
 487 \r
 488     vol = ofork->of_vol;\r
 489 \r
 490     if (NULL == (u_name = mtoupath(vol, of_name(ofork), ofork->of_did, utf8_encoding()))) \r
 491     {\r
 492         return AFPERR_MISC;\r
 493     }\r
 494     \r
 495     ret = register_fce( u_name, FALSE, FCE_FILE_MODIFY );\r
 496     \r
 497     return ret;    \r
 498 }\r
 499 \r
 500 int fce_register_tm_size(const char *vol, size_t used)\r
 501 {\r
 502     int ret = AFP_OK;\r
 503 \r
 504     LOG(log_note, logtype_afpd, "fce_register_tm_size");\r
 505 \r
 506     if (vol == NULL)\r
 507         return AFPERR_PARAM;\r
 508 \r
 509     if (!(fce_ev_enabled & (1 << FCE_TM_SIZE)))\r
 510         return ret;\r
 511 \r
 512     tm_used = used;             /* oh what a hack */\r
 513     ret = register_fce(vol, FALSE, FCE_TM_SIZE);\r
 514 \r
 515     return ret;\r
 516 }\r
 517 #endif\r
 518 \r
 519 /*\r
 520  *\r
 521  * Extern connect to afpd parameter, can be called multiple times for multiple listeners (up to MAX_UDP_SOCKS times)\r
 522  *\r
 523  * */\r
 524 int fce_add_udp_socket(const char *target)\r
 525 {\r
 526         const char *port = FCE_DEFAULT_PORT_STRING;\r
 527         char target_ip[256] = {""};\r
 528 \r
 529         strncpy(target_ip, target, sizeof(target_ip) -1);\r
 530 \r
 531         char *port_delim = strchr( target_ip, ':' );\r
 532         if (port_delim) {\r
 533                 *port_delim = 0;\r
 534                 port = port_delim + 1;\r
 535         }\r
 536         return add_udp_socket(target_ip, port);\r
 537 }\r
 538 \r
 539 int fce_set_events(const char *events)\r
 540 {\r
 541     char *e;\r
 542     char *p;\r
 543     \r
 544     if (events == NULL)\r
 545         return AFPERR_PARAM;\r
 546 \r
 547     e = strdup(events);\r
 548 \r
 549     fce_ev_enabled = 0;\r
 550 \r
 551     for (p = strtok(e, ","); p; p = strtok(NULL, ",")) {\r
 552         if (strcmp(p, "fmod") == 0) {\r
 553             fce_ev_enabled |= (1 << FCE_FILE_MODIFY);\r
 554         } else if (strcmp(p, "fdel") == 0) {\r
 555             fce_ev_enabled |= (1 << FCE_FILE_DELETE);\r
 556         } else if (strcmp(p, "ddel") == 0) {\r
 557             fce_ev_enabled |= (1 << FCE_DIR_DELETE);\r
 558         } else if (strcmp(p, "fcre") == 0) {\r
 559             fce_ev_enabled |= (1 << FCE_FILE_CREATE);\r
 560         } else if (strcmp(p, "dcre") == 0) {\r
 561             fce_ev_enabled |= (1 << FCE_DIR_CREATE);\r
 562         } else if (strcmp(p, "tmsz") == 0) {\r
 563             fce_ev_enabled |= (1 << FCE_TM_SIZE);\r
 564         }\r
 565     }\r
 566 \r
 567     free(e);\r
 568 }\r
 569 \r
 570 #ifdef FCE_TEST_MAIN\r
 571 \r
 572 \r
 573 void shortsleep( unsigned int us )\r
 574 {    \r
 575     usleep( us );\r
 576 }\r
 577 int main( int argc, char*argv[] )\r
 578 {\r
 579     int c,ret;\r
 580 \r
 581     char *port = FCE_DEFAULT_PORT_STRING;\r
 582     char *host = "localhost";\r
 583     int delay_between_events = 1000;\r
 584     int event_code = FCE_FILE_MODIFY;\r
 585     char pathbuff[1024];\r
 586     int duration_in_seconds = 0; // TILL ETERNITY\r
 587     char target[256];\r
 588     char *path = getcwd( pathbuff, sizeof(pathbuff) );\r
 589 \r
 590     // FULLSPEED TEST IS "-s 1001" -> delay is 0 -> send packets without pause\r
 591 \r
 592     while ((c = getopt(argc, argv, "d:e:h:p:P:s:")) != -1) {\r
 593         switch(c) {\r
 594         case '?':\r
 595             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
 596             exit(1);\r
 597             break;\r
 598         case 'd':\r
 599             duration_in_seconds = atoi(optarg);\r
 600             break;\r
 601         case 'e':\r
 602             event_code = atoi(optarg);\r
 603             break;\r
 604         case 'h':\r
 605             host = strdup(optarg);\r
 606             break;\r
 607         case 'p':\r
 608             port = strdup(optarg);\r
 609             break;\r
 610         case 'P':\r
 611             path = strdup(optarg);\r
 612             break;\r
 613         case 's':\r
 614             delay_between_events = atoi(optarg);\r
 615             break;\r
 616         }\r
 617     }\r
 618 \r
 619     sprintf(target, "%s:%s", host, port);\r
 620     if (fce_add_udp_socket(target) != 0)\r
 621         return 1;\r
 622 \r
 623     int ev_cnt = 0;\r
 624     time_t start_time = time(NULL);\r
 625     time_t end_time = 0;\r
 626 \r
 627     if (duration_in_seconds)\r
 628         end_time = start_time + duration_in_seconds;\r
 629 \r
 630     while (1)\r
 631     {\r
 632         time_t now = time(NULL);\r
 633         if (now > start_time)\r
 634         {\r
 635             start_time = now;\r
 636             fprintf( stdout, "%d events/s\n", ev_cnt );\r
 637             ev_cnt = 0;\r
 638         }\r
 639         if (end_time && now >= end_time)\r
 640             break;\r
 641 \r
 642         register_fce( path, 0, event_code );\r
 643         ev_cnt++;\r
 644 \r
 645         \r
 646         shortsleep( delay_between_events );\r
 647     }\r
 648 }\r
 649 #endif /* TESTMAIN*/\r