Various fixes

diff --git a/bin/misc/fce.c b/bin/misc/fce.c
index 863665b408c4187e0820cd799e45b6a5064fc718..76ca0a8e6a63505b41d736245b768ae1682345d3 100644 (file)
--- a/bin/misc/fce.c
+++ b/bin/misc/fce.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -8,13 +12,29 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <netdb.h>
+#include <inttypes.h>
+#include <sys/types.h>
+
+#include <sys/param.h>
+#include <sys/cdefs.h>
 
 #include <atalk/fce_api.h>
+#include <atalk/util.h>
+
+#define MAXBUFLEN 1024
 
-#define MAXBUFLEN 100
+static char *fce_ev_names[] = {
+    "",
+    "FCE_FILE_MODIFY",
+    "FCE_FILE_DELETE",
+    "FCE_DIR_DELETE",
+    "FCE_FILE_CREATE",
+    "FCE_DIR_CREATE",
+    "FCE_TM_SIZE"
+};
 
 // get sockaddr, IPv4 or IPv6:
-void *get_in_addr(struct sockaddr *sa)
+static void *get_in_addr(struct sockaddr *sa)
 {
     if (sa->sa_family == AF_INET) {
         return &(((struct sockaddr_in*)sa)->sin_addr);
@@ -23,6 +43,33 @@ void *get_in_addr(struct sockaddr *sa)
     return &(((struct sockaddr_in6*)sa)->sin6_addr);
 }
 
+static int unpack_fce_packet(unsigned char *buf, struct fce_packet *packet)
+{
+    unsigned char *p = buf;
+
+    memcpy(&packet->magic[0], p, sizeof(packet->magic));
+    p += sizeof(packet->magic);
+
+    packet->version = *p;
+    p++;
+
+    packet->mode = *p;
+    p++;
+
+    memcpy(&packet->event_id, p, sizeof(packet->event_id));
+    p += sizeof(packet->event_id);
+    packet->event_id = ntohl(packet->event_id);
+
+    memcpy(&packet->datalen, p, sizeof(packet->datalen));
+    p += sizeof(packet->datalen);
+    packet->datalen = ntohs(packet->datalen);
+
+    memcpy(&packet->data[0], p, packet->datalen);
+    p += packet->datalen;
+
+    return 0;
+}
+
 int main(void)
 {
     int sockfd;
@@ -33,11 +80,11 @@ int main(void)
     char buf[MAXBUFLEN];
     socklen_t addr_len;
     char s[INET6_ADDRSTRLEN];
+    uint64_t tmsize;
 
     memset(&hints, 0, sizeof hints);
     hints.ai_family = AF_UNSPEC; // set to AF_INET to force IPv4
     hints.ai_socktype = SOCK_DGRAM;
-//    hints.ai_flags = AI_PASSIVE; // use my IP
 
     if ((rv = getaddrinfo(NULL, FCE_DEFAULT_PORT_STRING, &hints, &servinfo)) != 0) {
         fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
@@ -71,21 +118,47 @@ int main(void)
     printf("listener: waiting to recvfrom...\n");
 
     addr_len = sizeof their_addr;
-    if ((numbytes = recvfrom(sockfd, buf, MAXBUFLEN-1 , 0,
-                             (struct sockaddr *)&their_addr, &addr_len)) == -1) {
-        perror("recvfrom");
-        exit(1);
-    }
 
-    printf("listener: got packet from %s\n",
-           inet_ntop(their_addr.ss_family,
-                     get_in_addr((struct sockaddr *)&their_addr),
-                     s, sizeof s));
-    printf("listener: packet is %d bytes long\n", numbytes);
-    buf[numbytes] = '\0';
-    printf("listener: packet contains \"%s\"\n", buf);
+    struct fce_packet packet;
+    while (1) {
+        if ((numbytes = recvfrom(sockfd,
+                                 buf,
+                                 MAXBUFLEN - 1,
+                                 0,
+                                 (struct sockaddr *)&their_addr,
+                                 &addr_len)) == -1) {
+            perror("recvfrom");
+            exit(1);
+        }
 
-    close(sockfd);
+        unpack_fce_packet(buf, &packet);
+
+        if (memcmp(packet.magic, FCE_PACKET_MAGIC, sizeof(packet.magic)) == 0) {
+
+            switch (packet.mode) {
+            case FCE_TM_SIZE:
+                memcpy(&tmsize, packet.data, sizeof(uint64_t));
+                tmsize = ntoh64(tmsize);
+                printf("ID: %" PRIu32 ", Event: %s, Volume: %s, TM used size: %" PRIu64 " \n",
+                       packet.event_id, fce_ev_names[packet.mode], packet.data + sizeof(uint64_t), tmsize);
+                break;
 
+            case FCE_CONN_START:
+                printf("FCE Start\n");
+                break;
+
+            case FCE_CONN_BROKEN:
+                printf("Broken FCE connection\n");
+                break;
+
+            default:
+                printf("ID: %" PRIu32 ", Event: %s, Path: %s\n",
+                       packet.event_id, fce_ev_names[packet.mode], packet.data);
+                break;
+            }
+        }
+    }
+
+    close(sockfd);
     return 0;
 }

diff --git a/etc/afpd/fce_api.c b/etc/afpd/fce_api.c
index 6c6bf4edda02c4d71f38e220523ffe670e075607..012dedde22feb18c8d7891beeebbfa5ffe215f61 100755 (executable)
--- a/etc/afpd/fce_api.c
+++ b/etc/afpd/fce_api.c
@@ -65,8 +65,16 @@
 static struct udp_entry udp_socket_list[FCE_MAX_UDP_SOCKS];\r
 static int udp_sockets = 0;\r
 static int udp_initialized = FCE_FALSE;\r
-static unsigned long fce_ev_enabled = 0;\r
+static unsigned long fce_ev_enabled =\r
+    (1 << FCE_FILE_MODIFY) |\r
+    (1 << FCE_FILE_DELETE) |\r
+    (1 << FCE_DIR_DELETE) |\r
+    (1 << FCE_FILE_CREATE) |\r
+    (1 << FCE_DIR_CREATE);\r
+\r
 static uint64_t tm_used;          /* used for passing to event handler */\r
+#define MAXIOBUF 1024\r
+static char iobuf[MAXIOBUF];\r
 static const char *skip_files[] = \r
 {\r
        ".DS_Store",\r
@@ -118,7 +126,9 @@ void fce_init_udp()
             LOG(log_error, logtype_afpd, "fce_init_udp: no socket for %s:%s",\r
                 udp_entry->addr, udp_entry->port);\r
         }\r
+        udp_entry->addrinfo = *p;\r
         memcpy(&udp_entry->addrinfo, p, sizeof(struct addrinfo));\r
+        memcpy(&udp_entry->sockaddr, p->ai_addr, sizeof(struct sockaddr_storage));\r
         freeaddrinfo(servinfo);\r
     }\r
 \r
@@ -156,7 +166,7 @@ static ssize_t build_fce_packet( struct fce_packet *packet, char *path, int mode
     strncpy(packet->magic, FCE_PACKET_MAGIC, sizeof(packet->magic) );\r
     packet->version = FCE_PACKET_VERSION;\r
     packet->mode = mode;\r
-    packet->event_id = htonl( event_id );\r
+    packet->event_id = event_id;\r
 \r
     pathlen = strlen(path) + 1; /* include string terminator */\r
 \r
@@ -166,20 +176,20 @@ static ssize_t build_fce_packet( struct fce_packet *packet, char *path, int mode
 \r
     /* This is the payload len. Means: the stream has len bytes more until packet is finished */\r
     /* A server should read the first 16 byte, decode them and then fetch the rest */\r
+    data_len = FCE_PACKET_HEADER_SIZE + pathlen;\r
+    packet->datalen = pathlen;\r
 \r
     switch (mode) {\r
     case FCE_TM_SIZE:\r
-        packet->len = htons(pathlen) + sizeof(tm_used);\r
         tm_used = hton64(tm_used);\r
         memcpy(packet->data, &tm_used, sizeof(tm_used));\r
-\r
         strncpy(packet->data + sizeof(tm_used), path, pathlen);\r
-        data_len = sizeof(struct fce_packet) + pathlen + sizeof(tm_used);\r
+\r
+        packet->datalen += sizeof(tm_used);\r
+        data_len += sizeof(tm_used);\r
         break;\r
     default:\r
-        packet->len = htons(pathlen);\r
         strncpy(packet->data, path, pathlen);\r
-        data_len = sizeof(struct fce_packet) + pathlen;\r
         break;\r
     }\r
 \r
@@ -187,6 +197,33 @@ static ssize_t build_fce_packet( struct fce_packet *packet, char *path, int mode
     return data_len;\r
 }\r
 \r
+static int pack_fce_packet(struct fce_packet *packet, unsigned char *buf)\r
+{\r
+    unsigned char *p = buf;\r
+\r
+    memcpy(p, &packet->magic[0], sizeof(packet->magic));\r
+    p += sizeof(packet->magic);\r
+\r
+    *p = packet->version;\r
+    p++;\r
+    \r
+    *p = packet->mode;\r
+    p++;\r
+    \r
+    uint32_t id = htonl(packet->event_id);\r
+    memcpy(p, &id, sizeof(id));\r
+    p += sizeof(packet->event_id);\r
+\r
+    uint16_t l = htons(packet->datalen);\r
+    memcpy(p, &l, sizeof(l));\r
+    p += sizeof(l);\r
+\r
+    memcpy(p, &packet->data[0], packet->datalen);\r
+    p += packet->datalen;\r
+\r
+    return 0;\r
+}\r
+\r
 /*\r
  * Send the fce information to all (connected) listeners\r
  * We dont give return code because all errors are handled internally (I hope..)\r
@@ -197,11 +234,13 @@ static void send_fce_event( char *path, int mode )
     void *data = &packet;\r
     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
 \r
+    LOG(log_note, logtype_afpd, "send_fce_event: start");\r
+\r
     time_t now = time(NULL);\r
 \r
     /* build our data packet */\r
     ssize_t data_len = build_fce_packet( &packet, path, mode, ++event_id );\r
-\r
+    pack_fce_packet(&packet, iobuf);\r
 \r
     for (int i = 0; i < udp_sockets; i++)\r
     {\r
@@ -232,31 +271,33 @@ static void send_fce_event( char *path, int mode )
 \r
             /* Okay, we have a running socket again, send server that we had a problem on our side*/\r
             data_len = build_fce_packet( &packet, "", FCE_CONN_BROKEN, 0 );\r
+            pack_fce_packet(&packet, iobuf);\r
 \r
             sendto(udp_entry->sock,\r
-                   data,\r
+                   iobuf,\r
                    data_len,\r
                    0,\r
-                   udp_entry->addrinfo.ai_addr,\r
+                   (struct sockaddr *)&udp_entry->sockaddr,\r
                    udp_entry->addrinfo.ai_addrlen);\r
 \r
             /* Rebuild our original data packet */\r
             data_len = build_fce_packet( &packet, path, mode, event_id );\r
+            pack_fce_packet(&packet, iobuf);\r
         }\r
 \r
+        LOG(log_note, logtype_afpd, "send_fce_event: sending...");\r
         sent_data = sendto(udp_entry->sock,\r
-                           data,\r
+                           iobuf,\r
                            data_len,\r
                            0,\r
-                           udp_entry->addrinfo.ai_addr,\r
+                           (struct sockaddr *)&udp_entry->sockaddr,\r
                            udp_entry->addrinfo.ai_addrlen);\r
 \r
         /* Problems ? */\r
-        if (sent_data != data_len)\r
-        {\r
+        if (sent_data != data_len) {\r
             /* Argh, socket broke, we close and retry later */\r
-            LOG(log_error, logtype_afpd, "Error while sending packet to %s for fce UDP connection: transfered: %d of %d errno %d",\r
-                    udp_entry->port, sent_data, data_len, errno  );\r
+            LOG(log_error, logtype_afpd, "send_fce_event: error sending packet to %s:%s, transfered %d of %d: %s",\r
+                udp_entry->addr, udp_entry->port, sent_data, data_len, strerror(errno));\r
 \r
             close( udp_entry->sock );\r
             udp_entry->sock = -1;\r
@@ -278,7 +319,8 @@ static int add_udp_socket(const char *target_ip, const char *target_port )
     udp_socket_list[udp_sockets].addr = strdup(target_ip);\r
     udp_socket_list[udp_sockets].port = strdup(target_port);\r
     udp_socket_list[udp_sockets].sock = -1;\r
-    memset( &udp_socket_list[udp_sockets].addrinfo, 0, sizeof(struct sockaddr_in) );\r
+    memset(&udp_socket_list[udp_sockets].addrinfo, 0, sizeof(struct addrinfo));\r
+    memset(&udp_socket_list[udp_sockets].sockaddr, 0, sizeof(struct sockaddr_storage));\r
     udp_socket_list[udp_sockets].next_try_on_error = 0;\r
 \r
     udp_sockets++;\r
@@ -303,18 +345,10 @@ static int register_fce(const char *u_name, int is_dir, int mode)
     static int first_event = FCE_TRUE;\r
 \r
        /* do some initialization on the fly the first time */\r
-       if (first_event)\r
-       {\r
+       if (first_event) {\r
                fce_initialize_history();\r
-        fce_ev_enabled =\r
-            (1 << FCE_FILE_MODIFY) |\r
-            (1 << FCE_FILE_DELETE) |\r
-            (1 << FCE_DIR_DELETE) |\r
-            (1 << FCE_FILE_CREATE) |\r
-            (1 << FCE_DIR_CREATE);\r
        }\r
 \r
-\r
        /* handle files which should not cause events (.DS_Store atc. ) */\r
        for (int i = 0; skip_files[i] != NULL; i++)\r
        {\r
@@ -326,8 +360,8 @@ static int register_fce(const char *u_name, int is_dir, int mode)
        char full_path_buffer[MAXPATHLEN + 1] = {""};\r
        const char *cwd = getcwdpath();\r
 \r
-    if (mode & FCE_TM_SIZE) {\r
-        strncpy(full_path_buffer, u_name, MAXPATHLEN);\r
+    if (mode == FCE_TM_SIZE) {\r
+        strlcpy(full_path_buffer, u_name, MAXPATHLEN);\r
     } else if (!is_dir || mode == FCE_DIR_DELETE) {\r
                if (strlen( cwd ) + strlen( u_name) + 1 >= MAXPATHLEN) {\r
                        LOG(log_error, logtype_afpd, "FCE file name too long: %s/%s", cwd, u_name );\r
@@ -467,6 +501,8 @@ int fce_register_tm_size(const char *vol, size_t used)
 {\r
     int ret = AFP_OK;\r
 \r
+    LOG(log_note, logtype_afpd, "fce_register_tm_size");\r
+\r
     if (vol == NULL)\r
         return AFPERR_PARAM;\r
 \r
@@ -509,21 +545,22 @@ int fce_set_events(const char *events)
         return AFPERR_PARAM;\r
 \r
     e = strdup(events);\r
+\r
     fce_ev_enabled = 0;\r
 \r
     for (p = strtok(e, ","); p; p = strtok(NULL, ",")) {\r
-        if (strcmp(e, "fmod") == 0) {\r
-            fce_ev_enabled |= FCE_FILE_MODIFY;\r
-        } else if (strcmp(e, "fdel") == 0) {\r
-            fce_ev_enabled |= FCE_FILE_DELETE;\r
-        } else if (strcmp(e, "ddel") == 0) {\r
-            fce_ev_enabled |= FCE_DIR_DELETE;\r
-        } else if (strcmp(e, "fcre") == 0) {\r
-            fce_ev_enabled |= FCE_FILE_CREATE;\r
-        } else if (strcmp(e, "dcre") == 0) {\r
-            fce_ev_enabled |= FCE_DIR_CREATE;\r
-        } else if (strcmp(e, "tmsz") == 0) {\r
-            fce_ev_enabled |= FCE_TM_SIZE;\r
+        if (strcmp(p, "fmod") == 0) {\r
+            fce_ev_enabled |= (1 << FCE_FILE_MODIFY);\r
+        } else if (strcmp(p, "fdel") == 0) {\r
+            fce_ev_enabled |= (1 << FCE_FILE_DELETE);\r
+        } else if (strcmp(p, "ddel") == 0) {\r
+            fce_ev_enabled |= (1 << FCE_DIR_DELETE);\r
+        } else if (strcmp(p, "fcre") == 0) {\r
+            fce_ev_enabled |= (1 << FCE_FILE_CREATE);\r
+        } else if (strcmp(p, "dcre") == 0) {\r
+            fce_ev_enabled |= (1 << FCE_DIR_CREATE);\r
+        } else if (strcmp(p, "tmsz") == 0) {\r
+            fce_ev_enabled |= (1 << FCE_TM_SIZE);\r
         }\r
     }\r
 \r

diff --git a/etc/afpd/fce_api_internal.h b/etc/afpd/fce_api_internal.h
index f405cabfa08faab959ee9eb9fbe973b0ffda269f..d73b775a56e19619027df5d431948759ce33db52 100755 (executable)
--- a/etc/afpd/fce_api_internal.h
+++ b/etc/afpd/fce_api_internal.h
@@ -20,6 +20,7 @@ struct udp_entry
     char *addr;\r
     char *port;\r
     struct addrinfo addrinfo;\r
+    struct sockaddr_storage sockaddr;\r
     time_t next_try_on_error;      /* In case of error set next timestamp to retry */\r
 };\r
 \r

diff --git a/include/atalk/fce_api.h b/include/atalk/fce_api.h
index 2e23a81d2005723cdc61f53e5951305b2652cbf3..b6111e4c6c660f889cccad484dd07270cc510a56 100755 (executable)
--- a/include/atalk/fce_api.h
+++ b/include/atalk/fce_api.h
@@ -28,13 +28,14 @@
  * be shure about datastructs and type sizes between platforms.
  * Format is network byte order.
  */
+#define FCE_PACKET_HEADER_SIZE 8+1+1+4+2
 struct fce_packet
 {
     char magic[8];
     unsigned char version;
     unsigned char mode;
-    uint32_t event_id; /* network byte order */
-    uint16_t len;  /* network byte order */
+    uint32_t event_id;
+    uint16_t datalen;
     char data[MAXPATHLEN];
 };
 
@@ -50,7 +51,7 @@ int fce_register_tm_size(const char *vol, size_t used);
 
 int fce_add_udp_socket(const char *target );  // IP or IP:Port
 int fce_set_coalesce( char *coalesce_opt ); // all|delete|create
-int fce_set_events(const char *events);     /* fmod,fdel,ddel,fcre,dcre,tmsz (default is all) */
+int fce_set_events(const char *events);     /* fmod,fdel,ddel,fcre,dcre,tmsz (default is all except tmsz) */
 
 #define FCE_DEFAULT_PORT 12250
 #define FCE_DEFAULT_PORT_STRING "12250"

diff --git a/include/atalk/util.h b/include/atalk/util.h
index 79f6db2b50805e7e45724c4852d130158ea674a1..811c0ee661a6af7316b51a045034fd654b464447 100644 (file)
--- a/include/atalk/util.h
+++ b/include/atalk/util.h
@@ -52,8 +52,8 @@
 #define hton64(x)       (x)
 #define ntoh64(x)       (x)
 #else /* BYTE_ORDER == BIG_ENDIAN */
-#define hton64(x)       ((u_int64_t) (htonl(((x) >> 32) & 0xffffffffLL)) | \
-                         (u_int64_t) ((htonl(x) & 0xffffffffLL) << 32))
+#define hton64(x)       ((uint64_t) (htonl(((x) >> 32) & 0xffffffffLL)) | \
+                         (uint64_t) ((htonl(x) & 0xffffffffLL) << 32))
 #define ntoh64(x)       (hton64(x))
 #endif /* BYTE_ORDER == BIG_ENDIAN */