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