etc/afpd/fce_util.c

   1 /*
   2  * Copyright (c) 2010 Mark Williams
   3  *
   4  * File change event API for netatalk
   5  *
   6  * for every detected filesystem change a UDP packet is sent to an arbitrary list
   7  * of listeners. Each packet contains unix path of modified filesystem element,
   8  * event reason, and a consecutive event id (32 bit). Technically we are UDP client and are sending
   9  * out packets synchronuosly as they are created by the afp functions. This should not affect
  10  * performance measurably. The only delaying calls occur during initialization, if we have to
  11  * resolve non-IP hostnames to IP. All numeric data inside the packet is network byte order, so use
  12  * ntohs / ntohl to resolve length and event id. Ideally a listener receives every packet with
  13  * no gaps in event ids, starting with event id 1 and mode FCE_CONN_START followed by
  14  * data events from id 2 up to 0xFFFFFFFF, followed by 0 to 0xFFFFFFFF and so on.
  15  *
  16  * A gap or not starting with 1 mode FCE_CONN_START or receiving mode FCE_CONN_BROKEN means that
  17  * the listener has lost at least one filesystem event
  18  *
  19  * All Rights Reserved.  See COPYRIGHT.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif /* HAVE_CONFIG_H */
  25
  26 #include <stdio.h>
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <time.h>
  32
  33
  34 #include <sys/param.h>
  35 #include <sys/socket.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <netdb.h>
  39
  40 #include <netatalk/at.h>
  41
  42 #include <atalk/adouble.h>
  43 #include <atalk/vfs.h>
  44 #include <atalk/logger.h>
  45 #include <atalk/afp.h>
  46 #include <atalk/util.h>
  47 #include <atalk/cnid.h>
  48 #include <atalk/unix.h>
  49 #include <atalk/fce_api.h>
  50 #include <atalk/globals.h>
  51
  52 #include "fork.h"
  53 #include "file.h"
  54 #include "directory.h"
  55 #include "desktop.h"
  56 #include "volume.h"
  57
  58 // ONLY USED IN THIS FILE
  59 #include "fce_api_internal.h"
  60
  61 #define FCE_TRUE 1
  62 #define FCE_FALSE 0
  63
  64 /* We store our connection data here */
  65 static uint32_t coalesce = 0;
  66 static struct fce_history fce_history_list[FCE_HISTORY_LEN];
  67
  68 /****
  69 * With coalesce we try to reduce the events over UDP, the eventlistener would throw these
  70 * events away anyway.
  71 * This works only, if the connected listener uses the events on a "per directory" base
  72 * It is a very simple aproach, but saves a lot of events sent to listeners.
  73 * Every "child element" event is ignored as long as its parent event is not older
  74 * than MAX_COALESCE_TIME_MS ms. If large directory trees or large files are created or deleted,
  75 * this probably will not work recursive, because the time to copy data will exceed this
  76 * event timeout.
  77 *
  78 ****/
  79
  80 static long get_ms_difftime (  struct timeval *tv1, struct timeval *tv2 )
  81 {
  82         unsigned long s = tv2->tv_sec - tv1->tv_sec;
  83         long us = tv2->tv_usec - tv1->tv_usec;
  84
  85         return s * 1000 + us/1000;
  86 }
  87
  88 /******************************************************************************
  89  * Public functions follow
  90  ******************************************************************************/
  91
  92 void fce_initialize_history()
  93 {
  94         for (int i = 0; i < FCE_HISTORY_LEN; i++) {
  95                 memset( &fce_history_list[i], 0, sizeof(fce_history_list[i]) );
  96         }
  97 }
  98
  99 int fce_handle_coalescation( char *path, int is_dir, int mode )
 100 {
 101         /* These two are used to eval our next index in history */
 102         /* the history is unsorted, speed should not be a problem, length is 10 */
 103         unsigned long oldest_entry = (unsigned long )((long)-1);
 104         int oldest_entry_idx = -1;
 105         struct timeval tv;
 106
 107         if (coalesce == 0)
 108                 return FALSE;
 109
 110         /* After a file creation *ALWAYS* a file modification is produced */
 111         if ((mode == FCE_FILE_CREATE) && (coalesce & FCE_COALESCE_CREATE))
 112         return TRUE;
 113
 114         /* get timestamp */
 115         gettimeofday(&tv, 0);
 116
 117         /* Now detect events in the very near history */
 118         for (int i = 0; i < FCE_HISTORY_LEN; i++) {
 119                 struct fce_history *fh = &fce_history_list[i];
 120
 121                 /* Not inited ? */
 122                 if (fh->tv.tv_sec == 0) {
 123                         /* we can use it for new elements */
 124                         oldest_entry = 0;
 125                         oldest_entry_idx = i;
 126                         continue;
 127                 }
 128
 129                 /* Too old ? */
 130                 if (get_ms_difftime( &fh->tv, &tv ) > MAX_COALESCE_TIME_MS) {
 131                         /* Invalidate entry */
 132                         fh->tv.tv_sec = 0;
 133                         oldest_entry = 0;
 134                         oldest_entry_idx = i;
 135                         continue;
 136                 }
 137
 138
 139                 /* If we find a parent dir wich was created we are done */
 140                 if ((coalesce & FCE_COALESCE_CREATE) && (fh->mode == FCE_DIR_CREATE)) {
 141                         /* Parent dir ? */
 142                         if (!strncmp(fh->path, path, strlen(fh->path)))
 143                                 return TRUE;
 144                 }
 145
 146                 /* If we find a parent dir we should be DELETED we are done */
 147                 if ((coalesce & FCE_COALESCE_DELETE)
 148             && fh->is_dir
 149             && (mode == FCE_FILE_DELETE || mode == FCE_DIR_DELETE)) {
 150                         /* Parent dir ? */
 151                         if (!strncmp(fh->path, path, strlen(fh->path)))
 152                                 return TRUE;
 153                 }
 154
 155                 /* Detect oldest entry for next new entry */
 156                 if (oldest_entry_idx == -1 || fh->tv.tv_sec < oldest_entry) {
 157                         oldest_entry = fh->tv.tv_sec;
 158                         oldest_entry_idx = i;
 159                 }
 160         }
 161
 162         /* We have a new entry for the history, register it */
 163         fce_history_list[oldest_entry_idx].tv = tv;
 164         fce_history_list[oldest_entry_idx].mode = mode;
 165         fce_history_list[oldest_entry_idx].is_dir = is_dir;
 166         strncpy( fce_history_list[oldest_entry_idx].path, path, MAXPATHLEN);
 167
 168         /* we have to handle this event */
 169         return FALSE;
 170 }
 171
 172 /*
 173  * Set event coalescation to reduce number of events sent over UDP
 174  * all|delete|create
 175  */
 176
 177 int fce_set_coalesce(char *opt)
 178 {
 179     char *e;
 180     char *p;
 181
 182     if (opt == NULL)
 183         return AFPERR_PARAM;
 184
 185     e = strdup(opt);
 186
 187     for (p = strtok(e, ","); p; p = strtok(NULL, ",")) {
 188         if (strcmp(p, "all") == 0) {
 189             coalesce = FCE_COALESCE_ALL;
 190         } else if (strcmp(p, "delete") == 0) {
 191             coalesce = FCE_COALESCE_DELETE;
 192         } else if (strcmp(p, "create") == 0) {
 193             coalesce = FCE_COALESCE_CREATE;
 194         }
 195     }
 196
 197     free(e);
 198 }
 199
 200
 201
 202