commit e46782908e7026f27ef92de52e47ec3720116125

Author: Jan Synacek <jsynacek@redhat.com>

Date:   Tue Nov 7 08:26:54 2017 +0100

    implement rfc7440

diff --git a/common/Makefile b/common/Makefile

index a825213..d1e97b5 100644

--- a/common/Makefile

+++ b/common/Makefile

@@ -4,7 +4,7 @@ VERSION = $(shell cat ../version)

 -include ../MCONFIG

 include ../MRULES

-OBJS = tftpsubs.$(O)

+OBJS = tftpsubs.$(O) common.$(O)

 LIB  = libcommon.a

 all: $(LIB)

@@ -14,7 +14,7 @@ $(LIB): $(OBJS)

 	$(AR) $(LIB) $(OBJS)

 	$(RANLIB) $(LIB)

-$(OBJS): tftpsubs.h

+$(OBJS): tftpsubs.h common.h

 install:

diff --git a/common/common.c b/common/common.c

new file mode 100644

index 0000000..a4e2fef

--- /dev/null

+++ b/common/common.c

@@ -0,0 +1,433 @@

+/*

+ * Copyright (c) 2017 Jan Synáček

+ * All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ *    notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ *    notice, this list of conditions and the following disclaimer in the

+ *    documentation and/or other materials provided with the distribution.

+ * 3. All advertising materials mentioning features or use of this software

+ *    must display the following acknowledgement:

+ *	This product includes software developed by the University of

+ *	California, Berkeley and its contributors.

+ * 4. Neither the name of the University nor the names of its contributors

+ *    may be used to endorse or promote products derived from this software

+ *    without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

+ * SUCH DAMAGE.

+ */

+

+#include <poll.h>

+#include <stdarg.h>

+#include <syslog.h>

+#include "common.h"

+

+static char *pktbuf;

+static int verbose;

+

+const int SYNC_TIMEOUT = 50; /* ms */

+

+static void die(const char *fmt, ...)

+{

+    va_list ap;

+

+    va_start(ap, fmt);

+    fprintf(stderr, "fatal: ");

+    vfprintf(stderr, fmt, ap);

+    printf("\n");

+    va_end(ap);

+    exit(1);

+}

+

+int format_error(struct tftphdr *tp, char *error)

+{

+    int r = 0;

+

+    if (error)

+        r = snprintf(error, ERROR_MAXLEN, "Error code %d: %s", ntohs(tp->th_code), tp->th_msg);

+    return r;

+}

+

+void die_on_error(struct tftphdr *tp)

+{

+    char error[ERROR_MAXLEN];

+

+    snprintf(error, ERROR_MAXLEN, "Error code %d: %s", ntohs(tp->th_code), tp->th_msg);

+    fprintf(stderr, "%s\n", error);

+    exit(1);

+}

+

+void send_error(int sockfd, union sock_addr *to, const char *msg)

+{

+    char buf[516];

+    struct tftphdr *out = (struct tftphdr *)buf;

+    int len;

+

+    out->th_opcode = htons(ERROR);

+    out->th_code = htons(EUNDEF);

+

+    len = strlen(msg) + 1;

+    memset(buf, 0, 516);

+    memcpy(out->th_msg, msg, len > 511 ? 511 : len);

+    len += 4;

+

+    if (to) {

+        if (sendto(sockfd, out, len, 0, &to->sa, SOCKLEN(to)) != len)

+            die("send_error: sendto: %s", strerror(-errno));

+    } else {

+        if (send(sockfd, out, len, 0) != len)

+            die("send_error: send: %s", strerror(-errno));

+    }

+}

+

+static void _send_ack(int sockfd, union sock_addr *to, unsigned short block, int check_errors)

+{

+    struct tftphdr out;

+    out.th_opcode = htons(ACK);

+    out.th_block  = htons(block);

+

+    if (to) {

+        if (sendto(sockfd, &out, 4, 0, &to->sa, SOCKLEN(to)) != 4 && check_errors)

+            die("send_ack: sendto: %m");

+    } else {

+        if (send(sockfd, &out, 4, 0) != 4 && check_errors)

+            die("send_ack: send: %m");

+    }

+}

+

+void send_ack(int sockfd, union sock_addr *to, unsigned short block)

+{

+    _send_ack(sockfd, to, block, 1);

+}

+

+

+static size_t read_data(FILE *fp,

+                        int blocksize,

+                        unsigned short block,

+                        int seek,

+                        struct tftphdr *out)

+{

+    out->th_opcode = htons(DATA);

+    out->th_block  = htons(block);

+    if (seek)

+        (void) fseek(fp, seek, SEEK_CUR);

+    return fread(pktbuf + 4, 1, blocksize, fp);

+}

+

+static size_t write_data(FILE *fp, char *buf, size_t count, int convert)

+{

+    char wbuf[count];

+    size_t i = 0, cnt = 0;

+    static int was_cr = 0;

+

+    /* TODO: jsynacek: I don't think any conversion should take place...

+     * RFC 1350 says: "A host which receives netascii mode data must translate

+     * the data to its own format."

+     * That basically means nothing. What does "own format" even mean?

+     * The original implementation translated \r\n to \n and skipped \0 bytes,

+     * which aren't even legal in the netascii format.

+     * However, I believe that the file should remain as is before and after

+     * the transfer.

+     */

+    convert = 0;

+

+    if (convert == 0)

+        return fwrite(buf, 1, count, fp);

+

+    /* Working conversion. Leave it as dead code for now. */

+    if (was_cr && buf[0] == '\n') {

+        wbuf[cnt++] = '\n';

+        i = 1;

+        (void) fseek(fp, -1, SEEK_CUR);

+    }

+

+    while(i < count) {

+        if (buf[i] == '\r' && buf[i + 1] == '\n') {

+            wbuf[cnt++] = '\n';

+            ++i;

+        } else if (buf[i] == '\0') {

+            /* Skip it */

+        } else {

+            wbuf[cnt++] = buf[i];

+        }

+        ++i;

+    }

+    /* Preserve state between data chunks */

+    was_cr = buf[i - 1] == '\r';

+

+    if (fwrite(wbuf, 1, cnt, fp) == 0)

+        return 0;

+

+    return count;

+}

+

+void set_verbose(int v)

+{

+    verbose = v;

+}

+

+int recv_with_timeout(int s, void *in, int len, int timeout)

+{

+    return recvfrom_flags_with_timeout(s, in, len, NULL, timeout, 0);

+}

+

+int recvfrom_with_timeout(int s,

+                          void *in,

+                          size_t len,

+                          union sock_addr *from,

+                          int timeout)

+{

+    return recvfrom_flags_with_timeout(s, in, len, from, timeout, 0);

+}

+

+int recvfrom_flags_with_timeout(int s,

+                                void *in,

+                                size_t len,

+                                union sock_addr *from,

+                                int timeout,

+                                int flags)

+{

+    socklen_t fromlen = sizeof(from);

+    struct pollfd pfd;

+    int r;

+

+    pfd.fd = s;

+    pfd.events = POLLIN;

+    pfd.revents = 0;

+

+    r = poll(&pfd, 1, timeout);

+    if (r > 0) {

+        if (from) {

+            r = recvfrom(s, in, len, flags, &from->sa, &fromlen);

+            if (r < 0)

+                die("recvfrom_flags_with_timeout: recvfrom: %m");

+        } else {

+            r = recv(s, in, len, flags);

+            if (r < 0)

+                die("recvfrom_flags_with_timeout: recv: %m");

+        }

+    }

+

+    return r;

+}

+

+int receiver(int sockfd,

+             union sock_addr *server,

+             int blocksize,

+             int windowsize,

+             int timeout,

+             FILE *fp,

+             unsigned long *received,

+             char *error)

+{

+    struct tftphdr *tp;

+    unsigned short tp_opcode, tp_block;

+    unsigned short block = 1;

+    unsigned long amount = 0;

+    int pktsize = blocksize + 4;

+    int window = 1;

+    size_t size;

+    int retries;

+    int n, r = 0;

+

+    pktbuf = calloc(pktsize, 1);

+    if (!pktbuf)

+        die("Out of memory!");

+    tp = (struct tftphdr *)pktbuf;

+

+    retries = RETRIES;

+    do {

+        n = recvfrom_with_timeout(sockfd, tp, pktsize, server, timeout);

+        if (n == 0) {

+            if (--retries <= 0) {

+                r = E_TIMED_OUT;

+                goto abort;

+            }

+            continue;

+        }

+        retries = RETRIES;

+

+        tp_opcode = ntohs(tp->th_opcode);

+        tp_block  = ntohs(tp->th_block);

+

+        if (tp_opcode == DATA) {

+            if (tp_block == block) {

+                size = write_data(fp, tp->th_data, n - 4, 0);

+                if (size == 0 && ferror(fp)) {

+                    send_error(sockfd, server, "Failed to write data");

+                    r = E_FAILED_TO_WRITE;

+                    goto abort;

+                }

+                amount += size;

+

+                if (window++ >= windowsize || size != blocksize) {

+                    send_ack(sockfd, server, block);

+                    window = 1;

+                }

+

+                ++block;

+            } else {

+                do {

+                    n = recvfrom_with_timeout(sockfd, pktbuf, pktsize, server, SYNC_TIMEOUT);

+                } while (n > 0);

+                if (windowsize > 0) {

+                    send_ack(sockfd, server, block - 1);

+                }

+                window = 1;

+                n = 0;

+            }

+        } else if (tp_opcode == ERROR) {

+            format_error(tp, error);

+            r = E_RECEIVED_ERROR;

+            goto abort;

+        } else {

+            r = E_UNEXPECTED_PACKET;

+            goto abort;

+        }

+    } while (size == blocksize || n == 0);

+

+    /* Last ack can get lost, let's try and resend it twice

+     * to make it more likely that the ack gets to the sender.

+     */

+    --block;

+    for (n = 0; n < 2; ++n) {

+        usleep(SYNC_TIMEOUT * 1000);

+        _send_ack(sockfd, server, block, 0);

+    }

+

+    if (received)

+        *received = amount;

+abort:

+    free(pktbuf);

+    return r;

+}

+

+int sender(int sockfd,

+           union sock_addr *server,

+           int blocksize,

+           int windowsize,

+           int timeout,

+           int rollover,

+           FILE *fp,

+           unsigned long *sent)

+{

+    struct tftphdr *tp;

+    unsigned short tp_opcode, tp_block;

+    unsigned short block = 1;

+    unsigned long amount = 0;

+    int l_timeout = timeout;

+    int pktsize = blocksize + 4;

+    int window = 1;

+    int seek = 0;

+    int retries;

+    size_t size;

+    int done = 0;

+    int n, r = 0;

+

+    pktbuf = calloc(pktsize, 1);

+    if (!pktbuf)

+        die("Out of memory!");

+    tp = (struct tftphdr *)pktbuf;

+

+    retries = RETRIES;

+    do {

+        size = read_data(fp, blocksize, block, seek, tp);

+        if (size == 0 && ferror(fp)) {

+            send_error(sockfd, server, "Error while reading the file");

+            r = E_FAILED_TO_READ;

+            goto abort;

+        }

+        amount += size;

+        seek = 0;

+

+        if (server)

+            n = sendto(sockfd, tp, size + 4, 0, &server->sa, SOCKLEN(server));

+        else

+            n = send(sockfd, tp, size + 4, 0);

+        if (n != size + 4) {

+            syslog(LOG_WARNING, "tftpd: send: %m");

+            r = E_SYSTEM_ERROR;

+            goto abort;

+        }

+

+        if (window++ < windowsize) {

+            /* Even if the entire window is not sent, the server should check for incoming packets

+             * and react to out of order ACKs, or ERRORs.

+             */

+            l_timeout = 0;

+        } else {

+            l_timeout = timeout;

+            window = 1;

+        }

+        done = size != blocksize;

+        if (done) {

+            l_timeout = timeout;

+            window = 1;

+        }

+

+        n = recvfrom_with_timeout(sockfd, pktbuf, pktsize, server, l_timeout);

+        if (n < 0) {

+            syslog(LOG_WARNING, "tftpd: recv: %m");

+            r = E_SYSTEM_ERROR;

+            goto abort;

+        } else if (l_timeout > 0 && n == 0) {

+            seek = -size;

+            if (--retries <= 0) {

+                r = E_TIMED_OUT;

+                goto abort;

+            }

+            done = 0;

+            continue;

+        }

+

+        if (++block == 0)

+            block = rollover;

+

+        tp_opcode = ntohs(tp->th_opcode);

+        tp_block  = ntohs(tp->th_block);

+

+        if (tp_opcode == ACK) {

+            if (tp_block != (unsigned short)(block - 1)) {

+                int offset = tp_block;

+

+                done = 0;

+                do {

+                    n = recvfrom_with_timeout(sockfd, pktbuf, pktsize, server, SYNC_TIMEOUT);

+                } while (n > 0);

+                /* This is a bit of a hack. Mismatched packets that are "over the edge" of the unsigned short

+                 * have to be handled and a correct seek has to be issued. In theory, overflowing block number

+                 * should not even be supported, as it is impossible to distinguish correctly if more than 2^16

+                 * packets are sent, but the first ones are received later than the last ones.

+                 */

+                if (tp_block > 65000 && tp_block > (unsigned short)(block - 1))

+                    offset -= 65535;

+                seek = (offset - block + 2) * blocksize - size;

+            }

+            block = tp_block + 1;

+            retries = RETRIES;

+        } else if (tp_opcode == ERROR) {

+            r = E_RECEIVED_ERROR;

+            goto abort;

+        }

+    } while (!done);

+

+    if (sent)

+        *sent = amount;

+abort:

+    free(pktbuf);

+    return r;

+}

diff --git a/common/common.h b/common/common.h

new file mode 100644

index 0000000..31c1b7c

--- /dev/null

+++ b/common/common.h

@@ -0,0 +1,97 @@

+/*

+ * Copyright (c) 2017 Jan Synáček

+ * All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ *    notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ *    notice, this list of conditions and the following disclaimer in the

+ *    documentation and/or other materials provided with the distribution.

+ * 3. All advertising materials mentioning features or use of this software

+ *    must display the following acknowledgement:

+ *	This product includes software developed by the University of

+ *	California, Berkeley and its contributors.

+ * 4. Neither the name of the University nor the names of its contributors

+ *    may be used to endorse or promote products derived from this software

+ *    without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

+ * SUCH DAMAGE.

+ */

+

+#ifndef _COMMON_H

+#define _COMMON_H

+

+#include <netinet/in.h>

+#include "config.h"

+

+#define TIMEOUT 1000 /* ms */

+#define RETRIES 6

+

+#define E_TIMED_OUT -1

+#define E_RECEIVED_ERROR -2

+#define E_UNEXPECTED_PACKET -3

+#define E_FAILED_TO_READ -4

+#define E_FAILED_TO_WRITE -5

+#define E_SYSTEM_ERROR -6

+#define ERROR_MAXLEN 511

+

+union sock_addr {

+    struct sockaddr     sa;

+    struct sockaddr_in  si;

+#ifdef HAVE_IPV6

+    struct sockaddr_in6 s6;

+#endif

+};

+

+#define SOCKLEN(sock) \

+    (((union sock_addr*)sock)->sa.sa_family == AF_INET ? \

+    (sizeof(struct sockaddr_in)) : \

+    (sizeof(union sock_addr)))

+

+const char *opcode_to_str(unsigned short opcode);

+int str_equal(const char *s1, const char *s2);

+void set_verbose(int v);

+

+int format_error(struct tftphdr *tp, char *error);

+void die_on_error(struct tftphdr *tp);

+void send_error(int sockfd, union sock_addr *to, const char *msg);

+void send_ack(int sockfd, union sock_addr *to, unsigned short block);

+int recv_with_timeout(int s, void *in, int len, int timeout);

+int recvfrom_with_timeout(int s, void *in, size_t len, union sock_addr *from, int timeout);

+int recvfrom_flags_with_timeout(int s,

+                                void *in,

+                                size_t len,

+                                union sock_addr *from,

+                                int timeout,

+                                int flags);

+int receiver(int sockfd,

+             union sock_addr *server,

+             int blocksize,

+             int windowsize,

+             int timeout,

+             FILE *fp,

+             unsigned long *received,

+             char *error);

+

+int sender(int sockfd,

+           union sock_addr *server,

+           int blocksize,

+           int windowsize,

+           int timeout,

+           int rollover,

+           FILE *fp,

+           unsigned long *sent);

+#endif

diff --git a/common/tftpsubs.c b/common/tftpsubs.c

index 8c999f6..6033e9b 100644

--- a/common/tftpsubs.c

+++ b/common/tftpsubs.c

@@ -404,3 +404,23 @@ char *strip_address(char *addr)

     return addr;

 }

 #endif

+

+

+int str_equal(const char *s1, const char *s2)

+{

+    return !strcmp(s1, s2);

+}

+

+

+const char *opcode_to_str(unsigned short opcode)

+{

+    switch(opcode) {

+        case RRQ:   return "RRQ";

+        case WRQ:   return "WRQ";

+        case DATA:  return "DATA";

+        case ACK:   return "ACK";

+        case ERROR: return "ERROR";

+        case OACK:  return "OACK";

+    }

+    return "UNKNOWN";

+}

diff --git a/common/tftpsubs.h b/common/tftpsubs.h

index b3a3bf3..311b141 100644

--- a/common/tftpsubs.h

+++ b/common/tftpsubs.h

@@ -38,21 +38,9 @@

 #ifndef TFTPSUBS_H

 #define TFTPSUBS_H

+#include "common.h"

 #include "config.h"

-union sock_addr {

-    struct sockaddr     sa;

-    struct sockaddr_in  si;

-#ifdef HAVE_IPV6

-    struct sockaddr_in6 s6;

-#endif

-};

-

-#define SOCKLEN(sock) \

-    (((union sock_addr*)sock)->sa.sa_family == AF_INET ? \

-    (sizeof(struct sockaddr_in)) : \

-    (sizeof(union sock_addr)))

-

 #ifdef HAVE_IPV6

 #define SOCKPORT(sock) \

     (((union sock_addr*)sock)->sa.sa_family == AF_INET ? \

diff --git a/tftp/extern.h b/tftp/extern.h

index 78474fc..dd0523f 100644

--- a/tftp/extern.h

+++ b/tftp/extern.h

@@ -34,7 +34,7 @@

 #ifndef RECVFILE_H

 #define RECVFILE_H

-void tftp_recvfile(int, const char *, const char *);

-void tftp_sendfile(int, const char *, const char *);

+void tftp_recvfile(int, const char *, const char *, int);

+void tftp_sendfile(int, const char *, const char *, int);

 #endif

diff --git a/tftp/main.c b/tftp/main.c

index fcf5a25..5a7d3a6 100644

--- a/tftp/main.c

+++ b/tftp/main.c

@@ -49,7 +49,7 @@

 #include "extern.h"

-#define	TIMEOUT		5       /* secs between rexmt's */

+#define	RTIMEOUT	5       /* secs between rexmt's */

 #define	LBUFLEN		200     /* size of input buffer */

 struct modes {

@@ -82,7 +82,7 @@ int ai_fam_sock = AF_INET;

 union sock_addr peeraddr;

 int f = -1;

 u_short port;

-int trace;

+int trace_opt;

 int verbose;

 int literal;

 int connected;

@@ -104,6 +104,7 @@ struct servent *sp;

 int portrange = 0;

 unsigned int portrange_from = 0;

 unsigned int portrange_to = 0;

+int windowsize = -1;

 void get(int, char **);

 void help(int, char **);

@@ -191,14 +192,14 @@ char *xstrdup(const char *);

 const char *program;

-static inline void usage(int errcode)

+static void usage(int errcode)

 {

     fprintf(stderr,

 #ifdef HAVE_IPV6

-            "Usage: %s [-4][-6][-v][-V][-l][-m mode] [-R port:port] "

+            "Usage: %s [-4][-6][-v][-V][-l][-m mode][-w size] [-R port:port] "

 			"[host [port]] [-c command]\n",

 #else

-            "Usage: %s [-v][-V][-l][-m mode] [-R port:port] "

+            "Usage: %s [-v][-V][-l][-m mode][-w size] [-R port:port] "

 			"[host [port]] [-c command]\n",

 #endif

             program);

@@ -279,6 +280,15 @@ int main(int argc, char *argv[])

                     }

                     portrange = 1;

                     break;

+                case 'w':

+                    if (++arg >= argc)

+                        usage(EX_USAGE);

+                    windowsize = atoi(argv[arg]);

+                    if (windowsize <= 0 || windowsize > 64) {

+                        fprintf(stderr, "Bad window size: %s (1-64)\n", argv[arg]);

+                        exit(EX_USAGE);

+                    }

+                    break;

                 case 'h':

                 default:

                     usage(*optx == 'h' ? 0 : EX_USAGE);

@@ -593,7 +603,7 @@ void put(int argc, char *argv[])

             printf("putting %s to %s:%s [%s]\n",

                    cp, hostname, targ, mode->m_mode);

         sa_set_port(&peeraddr, port);

-        tftp_sendfile(fd, targ, mode->m_mode);

+        tftp_sendfile(fd, targ, mode->m_mode, windowsize);

         return;

     }

     /* this assumes the target is a directory */

@@ -625,7 +635,7 @@ void put(int argc, char *argv[])

             printf("putting %s to %s:%s [%s]\n",

                    argv[n], hostname, remote_pth, mode->m_mode);

         sa_set_port(&peeraddr, port);

-        tftp_sendfile(fd, remote_pth, mode->m_mode);

+        tftp_sendfile(fd, remote_pth, mode->m_mode, windowsize);

     }