zircon/system/ulib/tftp/tftp-example.c

// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This is an example binary to exercise ulib/tftp. It runs on Linux or macOS.

#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

#include "tftp/tftp.h"

#define BLOCKSZ 1024
#define WINSZ   64

#define DROPRATE 100

#define SCRATCHSZ 2048
static char scratch[SCRATCHSZ];
static char out_scratch[SCRATCHSZ];
static char in_scratch[SCRATCHSZ];

typedef struct connection connection_t;

struct tftp_file {
    int fd;
    size_t size;
};

struct connection {
    int socket;
    struct sockaddr_in out_addr;
    struct sockaddr_in in_addr;
    uint32_t previous_timeout_ms;
};

tftp_status connection_send(void* data, size_t len, void* transport_cookie) {
    connection_t* connection = (connection_t*)transport_cookie;
#if DROPRATE != 0
    if (rand() % DROPRATE == 0) {
        fprintf(stderr, "DROP\n");
        return len;
    }
#endif
    uint8_t* msg = data;
    uint16_t opcode = ntohs(*(uint16_t*)msg);
    fprintf(stderr, "sending opcode=%u\n", opcode);
    ssize_t send_result = sendto(connection->socket, data, len, 0, (struct sockaddr*)&connection->out_addr,
                                 sizeof(struct sockaddr_in));
    if (send_result != len) {
        return TFTP_ERR_IO;
    }
    return TFTP_NO_ERROR;
}

int connection_receive(void* data, size_t len, bool block, void* transport_cookie) {
    connection_t* connection = (connection_t*)transport_cookie;
    socklen_t server_len;
    int fl = fcntl(connection->socket, F_GETFL, 0);
    if (fl < 0) {
        int e = errno;
        fprintf(stderr, "could not get socket flags: %d\n", errno);
        errno = e;
        return -1;
    }
    if (block) {
        fl &= ~O_NONBLOCK;
    } else {
        fl |= O_NONBLOCK;
    }
    int ret = fcntl(connection->socket, F_SETFL, fl);
    if (ret < 0) {
        int e = errno;
        fprintf(stderr, "could not set socket flags: %d\n", errno);
        errno = e;
        return -1;
    }
    ssize_t recv_result = recvfrom(connection->socket, data, len, 0,
                                   (struct sockaddr*)&connection->in_addr,
                                   &server_len);
    if (recv_result < 0) {
        if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
            return TFTP_ERR_TIMED_OUT;
        fprintf(stderr, "failed during recvfrom: errno=%d\n", (int) errno);
        return TFTP_ERR_INTERNAL;
    }
    return recv_result;
}

int connection_set_timeout(uint32_t timeout_ms, void* transport_cookie) {
    connection_t* connection = (connection_t*)transport_cookie;
    if (connection->previous_timeout_ms != timeout_ms && timeout_ms > 0) {
        fprintf(stdout, "Setting timeout to %dms\n", timeout_ms);
        connection->previous_timeout_ms = timeout_ms;
        struct timeval tv;
        tv.tv_sec = timeout_ms / 1000;
        tv.tv_usec = 1000 * (timeout_ms - 1000 * tv.tv_sec);
        return setsockopt(connection->socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    }
    return 0;
}

connection_t* create_connection(const char* hostname, int incoming_port, int outgoing_port) {
    connection_t* connection = (connection_t*)malloc(sizeof(connection_t));
    memset(connection, 0, sizeof(connection_t));

    struct hostent* server;

    if ((connection->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        fprintf(stderr, "Cannot create socket\n");
        goto err;
    }

    if (!(server = gethostbyname(hostname))) {
        fprintf(stderr, "Could not resolve host '%s'\n", hostname);
        goto err;
    }

    memset(&connection->out_addr, 0, sizeof(struct sockaddr_in));
    connection->out_addr.sin_family = AF_INET;
    connection->out_addr.sin_port = htons(outgoing_port);
    void* server_addr = server->h_addr_list[0];
    memcpy(&connection->out_addr.sin_addr.s_addr, server_addr, server->h_length);

    memset(&connection->in_addr, 0, sizeof(struct sockaddr_in));
    connection->in_addr.sin_family = AF_INET;
    connection->in_addr.sin_port = htons(incoming_port);
    memcpy(&connection->in_addr.sin_addr.s_addr, server_addr, server->h_length);
    if (bind(connection->socket, (struct sockaddr*)&connection->in_addr, sizeof(struct sockaddr_in)) == -1) {
        fprintf(stderr, "Could not bind\n");
        goto err;
    }

    connection->previous_timeout_ms = 0;
    return connection;

err:
    if (connection->socket) close(connection->socket);
    free(connection);
    return NULL;
}

void print_usage(void) {
    fprintf(stdout, "tftp (-s filename|-r)\n");
    fprintf(stdout, "\t -s filename to send the provided file\n");
    fprintf(stdout, "\t -r to receive a file\n");
}

ssize_t open_read_file(const char* filename, void* file_cookie) {
    fprintf(stdout, "Opening %s for reading\n", filename);
    int fd = open(filename, O_RDONLY);
    if (fd < 0) {
        fprintf(stderr, "could not open file: err=%d\n", errno);
        return TFTP_ERR_IO;
    }
    struct tftp_file* f = (struct tftp_file*)file_cookie;
    f->fd = fd;
    struct stat st;
    if (fstat(f->fd, &st) < 0) {
        fprintf(stderr, "could not get file size: err=%d\n", errno);
        return TFTP_ERR_IO;
    }
    return st.st_size;
}

tftp_status open_write_file(const char* filename, size_t size, void* file_cookie) {
    fprintf(stdout, "Opening %s for writing\n", filename);
    int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC,
                            S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (fd < 0) {
        fprintf(stderr, "could not open file: err=%d\n", errno);
        return TFTP_ERR_IO;
    }
    struct tftp_file* f = (struct tftp_file*)file_cookie;
    f->fd = fd;
    return TFTP_NO_ERROR;
}

tftp_status read_file(void* data, size_t* length, off_t offset, void* file_cookie) {
    int fd = ((struct tftp_file*)file_cookie)->fd;
    ssize_t n = pread(fd, data, *length, offset);
    if (n < 0) {
        fprintf(stderr, "could not read file: offset %jd, err=%d\n", (intmax_t)offset, errno);
        return n;
    }
    *length = n;
    return TFTP_NO_ERROR;
}

tftp_status write_file(const void* data, size_t* length, off_t offset, void* file_cookie) {
    struct tftp_file* f = file_cookie;
    int fd = f->fd;
    ssize_t n = pwrite(fd, data, *length, offset);
    if (n < 0) {
        fprintf(stderr, "could not write file: offset %jd, err=%d\n", (intmax_t)offset, errno);
        return n;
    }
    *length = n;
    f->size = offset + *length;
    return TFTP_NO_ERROR;
}

void close_file(void* file_cookie) {
    struct tftp_file* f = file_cookie;
    close(f->fd);
}

int tftp_send_file_wrapper(tftp_session* session,
                           connection_t* connection,
                           const char* filename) {
    uint16_t block_size = BLOCKSZ;
    uint16_t window_size = WINSZ;
    tftp_set_options(session, &block_size, NULL, &window_size);

    struct tftp_file file_cookie;
    char err_msg[128];
    tftp_request_opts options = { 0 };
    options.inbuf = in_scratch;
    options.inbuf_sz = sizeof(in_scratch);
    options.outbuf = out_scratch;
    options.outbuf_sz = sizeof(out_scratch);
    options.err_msg = err_msg;
    options.err_msg_sz = sizeof(err_msg);
    tftp_status send_result =
        tftp_push_file(session, connection, &file_cookie, filename,
                       "zircon.bin", &options);
    if (send_result == TFTP_NO_ERROR) {
        return 0;
    }
    fprintf(stderr, "%s\n", err_msg);
    return -1;
}

int tftp_receive_file_wrapper(tftp_session* session,
                              connection_t* connection) {
    struct tftp_file file_cookie;
    char err_msg[128];
    tftp_handler_opts options = { 0 };
    options.inbuf = in_scratch;
    options.inbuf_sz = sizeof(in_scratch);
    options.outbuf = out_scratch;
    size_t outbuf_sz = sizeof(out_scratch);
    options.outbuf_sz = &outbuf_sz;
    options.err_msg = err_msg;
    options.err_msg_sz = sizeof(err_msg);

    tftp_status status;
    do {
        status = tftp_service_request(session, connection, &file_cookie,
                                     &options);
    } while (status == TFTP_NO_ERROR || status == TFTP_ERR_TIMED_OUT);
    if (status == TFTP_TRANSFER_COMPLETED)
        return 0;
    fprintf(stderr, "%s\n", err_msg);
    return 1;
}

int main(int argc, char* argv[]) {
    const char* hostname = "127.0.0.1";
    int port = 2343;

    srand(time(NULL));

    if (argc < 2) {
        print_usage();
        return 1;
    }

    tftp_session* session = NULL;
    if (SCRATCHSZ < tftp_sizeof_session()) {
        fprintf(stderr, "Need more space for tftp session: %d < %zu\n",
                SCRATCHSZ, tftp_sizeof_session());
        return -1;
    }
    if (tftp_init(&session, scratch, SCRATCHSZ)) {
        fprintf(stderr, "Failed to initialize TFTP Session\n");
        return -1;
    }

    tftp_file_interface file_interface = {open_read_file,
                                          open_write_file,
                                          read_file,
                                          write_file,
                                          close_file};
    tftp_session_set_file_interface(session, &file_interface);
    tftp_transport_interface transport_interface = {connection_send,
                                                    connection_receive,
                                                    connection_set_timeout};
    tftp_session_set_transport_interface(session, &transport_interface);

    connection_t* connection;
    if (!strncmp(argv[1], "-s", 2)) {
        if (argc < 3) {
            print_usage();
            return 1;
        }
        connection = create_connection(hostname, port, port + 1);
        if (!connection) {
            return -1;
        }
        return tftp_send_file_wrapper(session, connection, argv[2]);
    } else if (!strncmp(argv[1], "-r", 2)) {
        connection = create_connection(hostname, port + 1, port);
        if (!connection) {
            return -1;
        }
        return tftp_receive_file_wrapper(session, connection);
    } else {
        print_usage();
        return 2;
    }
    return 0;
}