// 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.

#pragma once

#include <stddef.h>
#include <stdint.h>

#include "tftp/tftp.h"

#define OPCODE_RRQ 1
#define OPCODE_WRQ 2
#define OPCODE_DATA 3
#define OPCODE_ACK 4
#define OPCODE_ERROR 5
#define OPCODE_OACK 6

#ifdef __cplusplus
extern "C" {
#endif

typedef struct tftp_msg_t {
  uint16_t opcode;
  char data[0];
} tftp_msg;

typedef struct tftp_err_msg_t {
  uint16_t opcode;
  uint16_t err_code;
  char msg[0];
} tftp_err_msg;

typedef struct tftp_data_msg_t {
  uint16_t opcode;
  uint16_t block;
  uint8_t data[0];
} tftp_data_msg;

#define BLOCKSIZE_OPTION 0x01   // RFC 2348
#define TIMEOUT_OPTION 0x02     // RFC 2349
#define WINDOWSIZE_OPTION 0x04  // RFC 7440

#define DEFAULT_BLOCKSIZE 512
#define DEFAULT_TIMEOUT 1
#define DEFAULT_FILESIZE 0
#define DEFAULT_WINDOWSIZE 1
#define DEFAULT_MODE MODE_OCTET
#define DEFAULT_MAX_TIMEOUTS 5
#define DEFAULT_USE_OPCODE_PREFIX true

typedef struct tftp_options_t {
  // A bitmask of the options that have been set
  uint8_t mask;

  uint16_t block_size;
  uint8_t timeout;
  uint16_t window_size;
} tftp_options;

/**
  State transitions

  ***** READ FILE *****

    client                                                  server
    ~~~~~~                                                  ~~~~~~
    NONE                                                      NONE
        generate_request (rrq)
    REQ_SENT
                                ---- RRQ ----->
                                                 handle_rrq
                                                      REQ_RECEIVED
                               <---- OACK ----
                  handle_oack
    FIRST_DATA

+------+                                                      +-----+
|      |                                                      |     |
|      V                                                      V     |
|                               ---- ACK ----->                     |
|                                                handle_ack         |
|                                                     SENDING_DATA  |
|                              <---- DATA ----                |     |
|                 handle_data                                 |     |
|   RECEIVING_DATA                                            |     |
|                                    ...                      |     |
|                              <---- DATA ----                |     |
|                 handle_data                                 |     |
|      |                                                      |     |
+------+                                                      +-----+

         COMPLETED                                    COMPLETED


    ****** WRITE FILE *****

    client                                                  server
    ~~~~~~                                                  ~~~~~~
    NONE                                                      NONE
        generate_request (wrq)
    REQ_SENT
                                ---- WRQ ----->
                                                 handle_wrq
                                                      REQ_RECEIVED
                               <---- OACK ----
                  handle_oack
    FIRST_DATA

+------+                                                        +-----+
|      |                                                        |     |
|      V                                                        V     |
|                               ---- DATA ---->                       |
|                                                handle_data          |
|                                                     RECEIVING_DATA  |
|                              <----- ACK ----                  |     |
|                 handle_ack                                    |     |
|   SENDING_DATA                                                |     |
|      |                                                        |     |
+------+                                                        +-----+

         COMPLETED                                    COMPLETED

**/

typedef enum {
  NONE = 0,
  REQ_SENT,
  REQ_RECEIVED,
  FIRST_DATA,
  SENDING_DATA,
  RECEIVING_DATA,
  ERROR,
  COMPLETED,
} tftp_state;

typedef enum { SEND_FILE, RECV_FILE } tftp_file_direction;

struct tftp_session_t {
  // For a client, the options we will use on a new connection. For a server, the options we
  // will override, if possible, when we receive a write request.
  tftp_options options;

  // Tracks the options we used on the last request, so we can compare them to the options
  // we get back.
  tftp_options client_sent_opts;

  // Maximum filename really is 505 including \0
  // max request size (512) - opcode (2) - shortest mode (4) - null (1)
  char filename[512];
  tftp_mode mode;

  // General state values
  tftp_file_direction direction;  // Not valid when state is NONE, ERROR, or COMPLETED.
  tftp_state state;
  size_t offset;
  uint32_t consecutive_timeouts;
  uint8_t opcode_prefix;
  uint64_t block_number;
  uint32_t window_index;

  // Maximum number of times we will retransmit a single msg before aborting
  uint16_t max_timeouts;

  // Add an 8-bit prefix to the opcode so that retransmissions differ from the
  // original transmission. This fixes problems with checksums on asix 88179 USB
  // adapters (they send 0 checksums when they should send 0xffff, which is a
  // no-no in IPv6). This modification is not RFC-compatible.
  bool use_opcode_prefix;

  // "Negotiated" values
  size_t file_size;
  uint16_t window_size;
  uint16_t block_size;
  uint8_t timeout;

  // Callbacks
  tftp_file_interface file_interface;
  tftp_transport_interface transport_interface;

  // Metrics
  struct {
    uint32_t inorder_blocks;
    uint32_t outoforder_blocks;
    uint32_t acks_sent;
    uint32_t nacks_sent;
    uint32_t sas_events;  // Sorcerer's Apprentice Syndrome
    uint32_t timeouts;
    uint64_t inorder_bytes;
  } metrics;
};

// Generates a read or write request to send to a tftp server. |filename| is
// the name sent to the server. |datalen| is the size of the data (should be
// zero for read requests). If |block_size|, |timeout|, or |window_size| are
// set, those will be passed to the server in such a way that they cannot be
// negotiated (normal, negotiable settings can be set using
// tftp_set_options()). |outgoing| must point to a scratch buffer the library
// can use to assemble the request. |outlen| is the size of the outgoing
// scratch buffer, and will be set to the size of the request. |timeout_ms| is
// set to the next timeout value the user of the library should use when
// waiting for a response.
tftp_status tftp_generate_request(tftp_session* session, tftp_file_direction direction,
                                  const char* local_filename, const char* remote_filename,
                                  tftp_mode mode, size_t datalen, const uint16_t* block_size,
                                  const uint8_t* timeout, const uint16_t* window_size,
                                  void* outgoing, size_t* outlen, uint32_t* timeout_ms);

// Handle an incoming tftp packet. |incoming| must point to the packet of size
// |inlen|. |outgoing| must point to a scratch buffer the library can use to
// assemble the next packet to send. |outlen| is the size of the outgoing
// scratch buffer. |timeout_ms| is set to the next timeout value the user of the
// library should use when waiting for a response. |cookie| will be passed to
// the tftp callback functions.
tftp_status tftp_process_msg(tftp_session* session, void* incoming, size_t inlen, void* outgoing,
                             size_t* outlen, uint32_t* timeout_ms, void* cookie);

// Internal handlers
tftp_status tx_data(tftp_session* session, tftp_data_msg* resp, size_t* outlen, void* cookie);
tftp_status tftp_handle_rrq(tftp_session* session, tftp_msg* rrq, size_t rrq_len, tftp_msg* resp,
                            size_t* resp_len, uint32_t* timeout_ms, void* cookie);
tftp_status tftp_handle_wrq(tftp_session* session, tftp_msg* wrq, size_t wrq_len, tftp_msg* resp,
                            size_t* resp_len, uint32_t* timeout_ms, void* cookie);
tftp_status tftp_handle_data(tftp_session* session, tftp_msg* msg, size_t msg_len, tftp_msg* resp,
                             size_t* resp_len, uint32_t* timeout_ms, void* cookie);
tftp_status tftp_handle_ack(tftp_session* session, tftp_msg* ack, size_t ack_len, tftp_msg* resp,
                            size_t* resp_len, uint32_t* timeout_ms, void* cookie);
tftp_status tftp_handle_error(tftp_session* session, tftp_err_msg* err, size_t err_len,
                              tftp_msg* resp, size_t* resp_len, uint32_t* timeout_ms, void* cookie);
tftp_status tftp_handle_oack(tftp_session* session, tftp_msg* oack, size_t oack_len, tftp_msg* resp,
                             size_t* resp_len, uint32_t* timeout_ms, void* cookie);
tftp_status tftp_handle_oerror(tftp_session* session, tftp_msg* oerr, size_t oerr_len,
                               tftp_msg* resp, size_t* resp_len, uint32_t* timeout_ms,
                               void* cookie);

void print_hex(uint8_t* buf, size_t len);

#ifdef __cplusplus
}  // extern "C"
#endif