X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=netatalk.git;a=blobdiff_plain;f=etc%2Fafpd%2Ffce_api.c;h=b2dead294445229bb3984c6018fd22a62744879d;hp=6443bf302c6c9484b0dbde85e8c2be1a12081f1d;hb=e22bbf78a53bf739dd38383de42a23c95d43c15d;hpb=33f44ea7f93b30678659d7e50b23c5056991dfd0

diff --git a/etc/afpd/fce_api.c b/etc/afpd/fce_api.c
index 6443bf30..b2dead29 100755
--- a/etc/afpd/fce_api.c
+++ b/etc/afpd/fce_api.c
@@ -1,6 +1,4 @@
 /*
- * $Id: fce_api.c,v 0.01 2010-10-01 00:00:0 mw Exp $
- *
  * Copyright (c) 2010 Mark Williams
  *
  * File change event API for netatalk
@@ -48,16 +46,15 @@
 #include <atalk/util.h>
 #include <atalk/cnid.h>
 #include <atalk/unix.h>
+#include <atalk/fce_api.h>
+#include <atalk/globals.h>
 
 #include "fork.h"
 #include "file.h"
-#include "globals.h"
 #include "directory.h"
 #include "desktop.h"
 #include "volume.h"
 
-#include "fce_api.h"
-
 // ONLY USED IN THIS FILE
 #include "fce_api_internal.h"
 
@@ -68,8 +65,16 @@
 static struct udp_entry udp_socket_list[FCE_MAX_UDP_SOCKS];
 static int udp_sockets = 0;
 static int udp_initialized = FCE_FALSE;
-
-
+static unsigned long fce_ev_enabled =
+    (1 << FCE_FILE_MODIFY) |
+    (1 << FCE_FILE_DELETE) |
+    (1 << FCE_DIR_DELETE) |
+    (1 << FCE_FILE_CREATE) |
+    (1 << FCE_DIR_CREATE);
+
+static uint64_t tm_used;          /* used for passing to event handler */
+#define MAXIOBUF 1024
+static char iobuf[MAXIOBUF];
 static const char *skip_files[] = 
 {
 	".DS_Store",
@@ -84,48 +89,52 @@ static const char *skip_files[] =
  * */
 void fce_init_udp()
 {
+    int rv;
+    struct addrinfo hints, *servinfo, *p;
+
     if (udp_initialized == FCE_TRUE)
         return;
 
+    memset(&hints, 0, sizeof hints);
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = SOCK_DGRAM;
 
-    for (int i = 0; i < udp_sockets; i++)
-    {
+    for (int i = 0; i < udp_sockets; i++) {
         struct udp_entry *udp_entry = udp_socket_list + i;
 
         /* Close any pending sockets */
         if (udp_entry->sock != -1)
-        {
-            close( udp_entry->sock );
+            close(udp_entry->sock);
+
+        if ((rv = getaddrinfo(udp_entry->addr, udp_entry->port, &hints, &servinfo)) != 0) {
+            LOG(log_error, logtype_afpd, "fce_init_udp: getaddrinfo(%s:%s): %s",
+                udp_entry->addr, udp_entry->port, gai_strerror(rv));
+            continue;
         }
 
-        /* resolve IP to network address */
-        if (inet_aton( udp_entry->ip, &udp_entry->addr.sin_addr ) ==0 )
-        {
-            /* Hmm, failed try to resolve host */
-            struct hostent *hp = gethostbyname( udp_entry->ip );
-            if (hp == NULL)
-            {
-                LOG(log_error, logtype_afpd, "Cannot resolve host name for fce UDP connection: %s (errno %d)", udp_entry->ip, errno  );
+        /* loop through all the results and make a socket */
+        for (p = servinfo; p != NULL; p = p->ai_next) {
+            if ((udp_entry->sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
+                LOG(log_error, logtype_afpd, "fce_init_udp: socket(%s:%s): %s",
+                    udp_entry->addr, udp_entry->port, strerror(errno));
                 continue;
             }
-            memcpy( &udp_entry->addr.sin_addr, &hp->h_addr, sizeof(udp_entry->addr.sin_addr) );
+            break;
         }
 
-        /* Create UDP socket */
-        udp_entry->sock = socket( AF_INET, SOCK_DGRAM, 0 );
-        if (udp_entry->sock == -1)
-        {
-            LOG(log_error, logtype_afpd, "Cannot create socket for fce UDP connection: errno %d", errno  );
-            continue;
+        if (p == NULL) {
+            LOG(log_error, logtype_afpd, "fce_init_udp: no socket for %s:%s",
+                udp_entry->addr, udp_entry->port);
         }
-
-        /* Set socket address params */
-        udp_entry->addr.sin_family = AF_INET;
-        udp_entry->addr.sin_port = htons(udp_entry->port);
+        udp_entry->addrinfo = *p;
+        memcpy(&udp_entry->addrinfo, p, sizeof(struct addrinfo));
+        memcpy(&udp_entry->sockaddr, p->ai_addr, sizeof(struct sockaddr_storage));
+        freeaddrinfo(servinfo);
     }
-    udp_initialized = FCE_TRUE;
 
+    udp_initialized = FCE_TRUE;
 }
+
 void fce_cleanup()
 {
     if (udp_initialized == FCE_FALSE )
@@ -149,31 +158,70 @@ void fce_cleanup()
 /*
  * Construct a UDP packet for our listeners and return packet size
  * */
-static unsigned short build_fce_packet( struct fce_packet *packet, char *path, int mode, uint32_t event_id )
+static ssize_t build_fce_packet( struct fce_packet *packet, char *path, int mode, uint32_t event_id )
 {
-    unsigned short data_len = 0;
+    size_t pathlen;
+    ssize_t data_len = 0;
 
     strncpy(packet->magic, FCE_PACKET_MAGIC, sizeof(packet->magic) );
     packet->version = FCE_PACKET_VERSION;
     packet->mode = mode;
+    packet->event_id = event_id;
 
-    data_len = strlen( path );
+    pathlen = strlen(path) + 1; /* include string terminator */
 
     /* This should never happen, but before we bust this server, we send nonsense, fce listener has to cope */
-    if (data_len >= FCE_MAX_PATH_LEN)
-    {
-        data_len = FCE_MAX_PATH_LEN - 1;
-    }
+    if (pathlen >= MAXPATHLEN)
+        pathlen = MAXPATHLEN - 1;
 
     /* This is the payload len. Means: the stream has len bytes more until packet is finished */
     /* A server should read the first 16 byte, decode them and then fetch the rest */
-    packet->len = htons( data_len);
-    packet->event_id = htonl( event_id );
-
-    strncpy( packet->data, path, data_len );
+    data_len = FCE_PACKET_HEADER_SIZE + pathlen;
+    packet->datalen = pathlen;
+
+    switch (mode) {
+    case FCE_TM_SIZE:
+        tm_used = hton64(tm_used);
+        memcpy(packet->data, &tm_used, sizeof(tm_used));
+        strncpy(packet->data + sizeof(tm_used), path, pathlen);
+
+        packet->datalen += sizeof(tm_used);
+        data_len += sizeof(tm_used);
+        break;
+    default:
+        strncpy(packet->data, path, pathlen);
+        break;
+    }
 
     /* return the packet len */
-    return sizeof(struct fce_packet) - FCE_MAX_PATH_LEN + data_len;
+    return data_len;
+}
+
+static int pack_fce_packet(struct fce_packet *packet, unsigned char *buf)
+{
+    unsigned char *p = buf;
+
+    memcpy(p, &packet->magic[0], sizeof(packet->magic));
+    p += sizeof(packet->magic);
+
+    *p = packet->version;
+    p++;
+    
+    *p = packet->mode;
+    p++;
+    
+    uint32_t id = htonl(packet->event_id);
+    memcpy(p, &id, sizeof(id));
+    p += sizeof(packet->event_id);
+
+    uint16_t l = htons(packet->datalen);
+    memcpy(p, &l, sizeof(l));
+    p += sizeof(l);
+
+    memcpy(p, &packet->data[0], packet->datalen);
+    p += packet->datalen;
+
+    return 0;
 }
 
 /*
@@ -186,11 +234,13 @@ static void send_fce_event( char *path, int mode )
     void *data = &packet;
     static uint32_t event_id = 0; /* the unique packet couter to detect packet/data loss. Going from 0xFFFFFFFF to 0x0 is a valid increment */
 
+    LOG(log_debug, logtype_afpd, "send_fce_event: start");
+
     time_t now = time(NULL);
 
     /* build our data packet */
-    int data_len = build_fce_packet( &packet, path, mode, ++event_id );
-
+    ssize_t data_len = build_fce_packet( &packet, path, mode, ++event_id );
+    pack_fce_packet(&packet, iobuf);
 
     for (int i = 0; i < udp_sockets; i++)
     {
@@ -205,10 +255,11 @@ static void send_fce_event( char *path, int mode )
                 continue;
 
             /* Reopen socket */
-            udp_entry->sock = socket( AF_INET, SOCK_DGRAM, 0 );
-
-            if (udp_entry->sock == -1)
-            {
+            udp_entry->sock = socket(udp_entry->addrinfo.ai_family,
+                                     udp_entry->addrinfo.ai_socktype,
+                                     udp_entry->addrinfo.ai_protocol);
+            
+            if (udp_entry->sock == -1) {
                 /* failed again, so go to rest again */
                 LOG(log_error, logtype_afpd, "Cannot recreate socket for fce UDP connection: errno %d", errno  );
 
@@ -220,21 +271,32 @@ static void send_fce_event( char *path, int mode )
 
             /* Okay, we have a running socket again, send server that we had a problem on our side*/
             data_len = build_fce_packet( &packet, "", FCE_CONN_BROKEN, 0 );
+            pack_fce_packet(&packet, iobuf);
 
-            sendto( udp_entry->sock, data, data_len, 0, &udp_entry->addr, sizeof(udp_entry->addr) );
+            sendto(udp_entry->sock,
+                   iobuf,
+                   data_len,
+                   0,
+                   (struct sockaddr *)&udp_entry->sockaddr,
+                   udp_entry->addrinfo.ai_addrlen);
 
             /* Rebuild our original data packet */
             data_len = build_fce_packet( &packet, path, mode, event_id );
+            pack_fce_packet(&packet, iobuf);
         }
 
-        sent_data =  sendto( udp_entry->sock, data, data_len, 0, &udp_entry->addr, sizeof(udp_entry->addr) );
+        sent_data = sendto(udp_entry->sock,
+                           iobuf,
+                           data_len,
+                           0,
+                           (struct sockaddr *)&udp_entry->sockaddr,
+                           udp_entry->addrinfo.ai_addrlen);
 
         /* Problems ? */
-        if (sent_data != data_len)
-        {
+        if (sent_data != data_len) {
             /* Argh, socket broke, we close and retry later */
-            LOG(log_error, logtype_afpd, "Error while sending packet to %s for fce UDP connection: transfered: %d of %d errno %d",
-                    udp_entry->port, sent_data, data_len, errno  );
+            LOG(log_error, logtype_afpd, "send_fce_event: error sending packet to %s:%s, transfered %d of %d: %s",
+                udp_entry->addr, udp_entry->port, sent_data, data_len, strerror(errno));
 
             close( udp_entry->sock );
             udp_entry->sock = -1;
@@ -243,21 +305,21 @@ static void send_fce_event( char *path, int mode )
     }
 }
 
-static int add_udp_socket( char *target_ip, int target_port )
+static int add_udp_socket(const char *target_ip, const char *target_port )
 {
-    if (target_port == 0)
-        target_port = FCE_DEFAULT_PORT;
+    if (target_port == NULL)
+        target_port = FCE_DEFAULT_PORT_STRING;
 
-    if (udp_sockets >= FCE_MAX_UDP_SOCKS)
-    {
+    if (udp_sockets >= FCE_MAX_UDP_SOCKS) {
         LOG(log_error, logtype_afpd, "Too many file change api UDP connections (max %d allowed)", FCE_MAX_UDP_SOCKS );
         return AFPERR_PARAM;
     }
 
-    strncpy( udp_socket_list[udp_sockets].ip, target_ip, FCE_MAX_IP_LEN - 1);
-    udp_socket_list[udp_sockets].port = target_port;
+    udp_socket_list[udp_sockets].addr = strdup(target_ip);
+    udp_socket_list[udp_sockets].port = strdup(target_port);
     udp_socket_list[udp_sockets].sock = -1;
-    memset( &udp_socket_list[udp_sockets].addr, 0, sizeof(struct sockaddr_in) );
+    memset(&udp_socket_list[udp_sockets].addrinfo, 0, sizeof(struct addrinfo));
+    memset(&udp_socket_list[udp_sockets].sockaddr, 0, sizeof(struct sockaddr_storage));
     udp_socket_list[udp_sockets].next_try_on_error = 0;
 
     udp_sockets++;
@@ -270,20 +332,22 @@ static int add_udp_socket( char *target_ip, int target_port )
  * Dispatcher for all incoming file change events
  *
  * */
-static int register_fce( char *u_name, int is_dir, int mode )
+static int register_fce(const char *u_name, int is_dir, int mode)
 {
+    if (udp_sockets == 0)
+        /* No listeners configured */
+        return AFP_OK;
+
     if (u_name == NULL)
         return AFPERR_PARAM;
 
     static int first_event = FCE_TRUE;
 
 	/* do some initialization on the fly the first time */
-	if (first_event)
-	{
+	if (first_event) {
 		fce_initialize_history();
 	}
 
-
 	/* handle files which should not cause events (.DS_Store atc. ) */
 	for (int i = 0; skip_files[i] != NULL; i++)
 	{
@@ -292,22 +356,19 @@ static int register_fce( char *u_name, int is_dir, int mode )
 	}
 
 
-	char full_path_buffer[FCE_MAX_PATH_LEN + 1] = {""};
+	char full_path_buffer[MAXPATHLEN + 1] = {""};
 	const char *cwd = getcwdpath();
 
-	if (!is_dir || mode == FCE_DIR_DELETE)
-	{
-		if (strlen( cwd ) + strlen( u_name) + 1 >= FCE_MAX_PATH_LEN)
-		{
+    if (mode == FCE_TM_SIZE) {
+        strlcpy(full_path_buffer, u_name, MAXPATHLEN);
+    } else if (!is_dir || mode == FCE_DIR_DELETE) {
+		if (strlen( cwd ) + strlen( u_name) + 1 >= MAXPATHLEN) {
 			LOG(log_error, logtype_afpd, "FCE file name too long: %s/%s", cwd, u_name );
 			return AFPERR_PARAM;
 		}
 		sprintf( full_path_buffer, "%s/%s", cwd, u_name );
-	}
-	else
-	{
-		if (strlen( cwd ) >= FCE_MAX_PATH_LEN)
-		{
+	} else {
+		if (strlen( cwd ) >= MAXPATHLEN) {
 			LOG(log_error, logtype_afpd, "FCE directory name too long: %s", cwd);
 			return AFPERR_PARAM;
 		}
@@ -315,7 +376,7 @@ static int register_fce( char *u_name, int is_dir, int mode )
 	}
 
 	/* Can we ignore this event based on type or history? */
-	if (fce_handle_coalescation( full_path_buffer, is_dir, mode ))
+	if (!(mode & FCE_TM_SIZE) && fce_handle_coalescation( full_path_buffer, is_dir, mode ))
 	{
 		LOG(log_debug9, logtype_afpd, "Coalesced fc event <%d> for <%s>", mode, full_path_buffer );
 		return AFP_OK;
@@ -351,7 +412,6 @@ static int register_fce( char *u_name, int is_dir, int mode )
  * */
 #ifndef FCE_TEST_MAIN
 
-
 int fce_register_delete_file( struct path *path )
 {
     int ret = AFP_OK;
@@ -359,6 +419,8 @@ int fce_register_delete_file( struct path *path )
     if (path == NULL)
         return AFPERR_PARAM;
 
+    if (!(fce_ev_enabled & (1 << FCE_FILE_DELETE)))
+        return ret;
 	
     ret = register_fce( path->u_name, FALSE, FCE_FILE_DELETE );
 
@@ -371,6 +433,8 @@ int fce_register_delete_dir( char *name )
     if (name == NULL)
         return AFPERR_PARAM;
 
+    if (!(fce_ev_enabled & (1 << FCE_DIR_DELETE)))
+        return ret;
 	
     ret = register_fce( name, TRUE, FCE_DIR_DELETE);
 
@@ -384,6 +448,9 @@ int fce_register_new_dir( struct path *path )
     if (path == NULL)
         return AFPERR_PARAM;
 
+    if (!(fce_ev_enabled & (1 << FCE_DIR_CREATE)))
+        return ret;
+
     ret = register_fce( path->u_name, TRUE, FCE_DIR_CREATE );
 
     return ret;
@@ -397,26 +464,29 @@ int fce_register_new_file( struct path *path )
     if (path == NULL)
         return AFPERR_PARAM;
 
+    if (!(fce_ev_enabled & (1 << FCE_FILE_CREATE)))
+        return ret;
+
     ret = register_fce( path->u_name, FALSE, FCE_FILE_CREATE );
 
     return ret;
 }
 
-
 int fce_register_file_modification( struct ofork *ofork )
 {
     char *u_name = NULL;
-    struct dir *dir;
     struct vol *vol;
     int ret = AFP_OK;
 
-    if (ofork == NULL || ofork->of_vol == NULL || ofork->of_dir == NULL)
+    if (ofork == NULL || ofork->of_vol == NULL)
         return AFPERR_PARAM;
 
+    if (!(fce_ev_enabled & (1 << FCE_FILE_MODIFY)))
+        return ret;
+
     vol = ofork->of_vol;
-    dir = ofork->of_dir;
 
-    if (NULL == (u_name = mtoupath(vol, of_name(ofork), dir->d_did, utf8_encoding()))) 
+    if (NULL == (u_name = mtoupath(vol, of_name(ofork), ofork->of_did, utf8_encoding()))) 
     {
         return AFPERR_MISC;
     }
@@ -425,6 +495,22 @@ int fce_register_file_modification( struct ofork *ofork )
     
     return ret;    
 }
+
+int fce_register_tm_size(const char *vol, size_t used)
+{
+    int ret = AFP_OK;
+
+    if (vol == NULL)
+        return AFPERR_PARAM;
+
+    if (!(fce_ev_enabled & (1 << FCE_TM_SIZE)))
+        return ret;
+
+    tm_used = used;             /* oh what a hack */
+    ret = register_fce(vol, FALSE, FCE_TM_SIZE);
+
+    return ret;
+}
 #endif
 
 /*
@@ -432,22 +518,51 @@ int fce_register_file_modification( struct ofork *ofork )
  * Extern connect to afpd parameter, can be called multiple times for multiple listeners (up to MAX_UDP_SOCKS times)
  *
  * */
-int fce_add_udp_socket( char *target )
+int fce_add_udp_socket(const char *target)
 {
-	int port = FCE_DEFAULT_PORT;
+	const char *port = FCE_DEFAULT_PORT_STRING;
 	char target_ip[256] = {""};
 
-	strncpy( target_ip, target, sizeof(target_ip) -1);
+	strncpy(target_ip, target, sizeof(target_ip) -1);
+
 	char *port_delim = strchr( target_ip, ':' );
-	if (port_delim)
-	{
+	if (port_delim) {
 		*port_delim = 0;
-		port = atoi( port_delim + 1);
+		port = port_delim + 1;
 	}
-	return add_udp_socket( target_ip, port );
+	return add_udp_socket(target_ip, port);
 }
 
+int fce_set_events(const char *events)
+{
+    char *e;
+    char *p;
+    
+    if (events == NULL)
+        return AFPERR_PARAM;
+
+    e = strdup(events);
+
+    fce_ev_enabled = 0;
+
+    for (p = strtok(e, ","); p; p = strtok(NULL, ",")) {
+        if (strcmp(p, "fmod") == 0) {
+            fce_ev_enabled |= (1 << FCE_FILE_MODIFY);
+        } else if (strcmp(p, "fdel") == 0) {
+            fce_ev_enabled |= (1 << FCE_FILE_DELETE);
+        } else if (strcmp(p, "ddel") == 0) {
+            fce_ev_enabled |= (1 << FCE_DIR_DELETE);
+        } else if (strcmp(p, "fcre") == 0) {
+            fce_ev_enabled |= (1 << FCE_FILE_CREATE);
+        } else if (strcmp(p, "dcre") == 0) {
+            fce_ev_enabled |= (1 << FCE_DIR_CREATE);
+        } else if (strcmp(p, "tmsz") == 0) {
+            fce_ev_enabled |= (1 << FCE_TM_SIZE);
+        }
+    }
 
+    free(e);
+}
 
 #ifdef FCE_TEST_MAIN
 
@@ -458,64 +573,49 @@ void shortsleep( unsigned int us )
 }
 int main( int argc, char*argv[] )
 {
-    int port  = 11250;
-    char *host = NULL;
+    int c,ret;
+
+    char *port = FCE_DEFAULT_PORT_STRING;
+    char *host = "localhost";
     int delay_between_events = 1000;
     int event_code = FCE_FILE_MODIFY;
     char pathbuff[1024];
     int duration_in_seconds = 0; // TILL ETERNITY
-
+    char target[256];
     char *path = getcwd( pathbuff, sizeof(pathbuff) );
 
     // FULLSPEED TEST IS "-s 1001" -> delay is 0 -> send packets without pause
 
-    if (argc == 1)
-    {
-        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]);
-        exit( 1 );
-    }
-    int ret = AFP_OK;
-
-    for (int i = 1; i < argc; i++)
-    {
-        char *p = argv[i];
-        if (*p == '-' && p[1])
-        {
-            char *arg = argv[i + 1];
-            switch (p[1])
-            {
-                case 'p': if (arg) port = atoi( arg ), i++; break;
-                case 'P': if (arg) path =  arg, i++; break;
-                case 's': if (arg) delay_between_events = atoi( arg ), i++; break;
-                case 'e': if (arg) event_code = atoi( arg ), i++; break;
-                case 'd': if (arg) duration_in_seconds = atoi( arg ), i++; break;
-                case 'h':
-                {
-                    if (arg)
-                    {
-                        host = arg;
-						char target[256];
-						sprintf( target, "%s:%d", host, port );
-                        ret += fce_add_udp_socket( target );
-                        i++;
-                    }
-                    break;
-                }               
-            }
+    while ((c = getopt(argc, argv, "d:e:h:p:P:s:")) != -1) {
+        switch(c) {
+        case '?':
+            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]);
+            exit(1);
+            break;
+        case 'd':
+            duration_in_seconds = atoi(optarg);
+            break;
+        case 'e':
+            event_code = atoi(optarg);
+            break;
+        case 'h':
+            host = strdup(optarg);
+            break;
+        case 'p':
+            port = strdup(optarg);
+            break;
+        case 'P':
+            path = strdup(optarg);
+            break;
+        case 's':
+            delay_between_events = atoi(optarg);
+            break;
         }
     }
-	
-
-    if (host == NULL)
-	{
-		char target[256];
-		sprintf( target, "127.0.0.1:%d", port );
-		ret += fce_add_udp_socket( target );
-	}
-
-    if (ret)
-        return ret;
 
+    sprintf(target, "%s:%s", host, port);
+    if (fce_add_udp_socket(target) != 0)
+        return 1;
 
     int ev_cnt = 0;
     time_t start_time = time(NULL);
@@ -536,7 +636,7 @@ int main( int argc, char*argv[] )
         if (end_time && now >= end_time)
             break;
 
-        register_fce( path, event_code );
+        register_fce( path, 0, event_code );
         ev_cnt++;