; minimal tftp implementation (client only)
; supports file upload and download

TFTP_MAX_RESENDS = 10
TFTP_TIMER_MASK  = $F8          ; mask lower two bits, means we wait for 8 x1/4 seconds

.include "zeropage.inc"
.include "../inc/common.i"

.ifndef KPR_API_VERSION_NUMBER
  .define EQU =
  .include "../inc/kipper_constants.i"
.endif

.export tftp_load_address
.export tftp_ip
.export tftp_download
.export tftp_upload
.export tftp_data_block_length
.export tftp_set_callback_vector
.export tftp_callback_vector
.export tftp_clear_callbacks
.export tftp_filename
.export tftp_filesize
.export tftp_upload_from_memory
.import ip65_process
.import ip65_error

.import udp_add_listener
.import udp_remove_listener
.import output_buffer
.import udp_callback
.import udp_send
.import check_for_abort_key
.import udp_inp
.import ip_inp
.importzp ip_src
.importzp udp_src_port

.importzp udp_data

.import udp_send_dest
.import udp_send_src_port
.import udp_send_dest_port
.import udp_send_len

.import copymem
.importzp copy_src
.importzp copy_dest

.import timer_read


.bss

; packet offsets
tftp_inp  = udp_inp + udp_data
tftp_outp = output_buffer

; everything after filename in a request at a relative address, not fixed, so don't bother defining offset constants

tftp_server_port = 69
tftp_client_port_low_byte: .res 1

tftp_load_address:      .res 2  ; address file will be (or was) downloaded to
tftp_ip:                .res 4  ; ip address of tftp server - set to 255.255.255.255 (broadcast) to send request to all tftp servers on local lan

tftp_data_block_length: .res 2
tftp_send_len:          .res 2
tftp_current_memloc:    .res 2

; tftp state machine
tftp_initializing             = 1       ; initial state
tftp_initial_request_sent     = 2       ; sent the RRQ or WRQ, waiting for some data
tftp_transmission_in_progress = 3       ; we have sent/received the first packet of file data
tftp_complete                 = 4       ; we have sent/received the final packet of file data
tftp_error                    = 5       ; we got an error

tftp_state:                     .res 1  ; current activity
tftp_timer:                     .res 1
tftp_resend_counter:            .res 1
tftp_break_inner_loop:          .res 1
tftp_current_block_number:      .res 2
tftp_actual_server_port:        .res 2  ; this is read from the reply - it is not (usually) the port # we send the RRQ or WRQ to
tftp_actual_server_ip:          .res 4  ; this is read from the reply - it may not be the IP we sent to (e.g. if we send to broadcast)

tftp_just_set_new_load_address: .res 1

tftp_opcode:            .res 2  ; will be set to 4 if we are doing a RRQ, or 7 if we are doing a DIR
tftp_filename:          .res 2  ; pointer to null terminated name of file to upload/download
tftp_filesize:          .res 2  ; will be set by tftp_download, needs to be set before calling tftp_upload_from_memory
tftp_bytes_remaining:   .res 2


.code

; uploads a file to a tftp server with data retrieved from specified memory location
; inputs:
; tftp_ip: ip address of host to send file to (set to 255.255.255.255 for broadcast)
; tftp_filename: pointer to null terminated name of file to upload
; tftp_load_address: starting address of data to be sent
; tftp_filesize: length of data to send
; outputs: carry flag is set if there was an error
; if a callback vector has been set with tftp_set_callback_vector
; then the specified routine will be called once for each 512 byte packet
; to be sent to the tftp server
tftp_upload_from_memory:
  ldax #copy_ram_to_tftp_block
  jsr tftp_set_callback_vector
  ldax tftp_filesize
  stax tftp_bytes_remaining
  lda #00
  sta tftp_filesize
  sta tftp_filesize+1

; uploads a file to a tftp server with data retrieved from user supplied routine
; inputs:
; tftp_ip: ip address of host to send file to (set to 255.255.255.255 for broadcast)
; tftp_filename: pointer to null terminated name of file to upload
; a callback vector should have been set with tftp_set_callback_vector
; outputs: carry flag is set if there was an error
; the specified routine will be called once for each 512 byte packet
; to be sent from the tftp server.
tftp_upload:
  ldax #$0200                   ; opcode 02 = WRQ
  jmp set_tftp_opcode

; download a file from a tftp server
; inputs:
; tftp_ip: ip address of host to download from (set to 255.255.255.255 for broadcast)
; tftp_filename: pointer to null terminated name of file to download
; tftp_load_address: memory location that dir will be stored in, or $0000 to
; treat first 2 bytes received from tftp server as memory address that rest
; of file should be loaded into (e.g. if downloading a C64 'prg' file)
; outputs: carry flag is set if there was an error
; if a callback vector has been set with tftp_set_callback_vector
; then the specified routine will be called once for each 512 byte packet
; sent from the tftp server (each time AX will point at data block just arrived,
; and tftp_data_block_length will contain number of bytes in that data block)
; otherwise, the buffer at tftp_load_address will be filled
; with file downloaded.
; tftp_load_address: will be set to the actual address loaded into (NB - this field is
; ignored if a callback vector has been set with tftp_set_callback_vector)
tftp_download:
  lda #00
  sta tftp_filesize
  sta tftp_filesize+1
  ldx #$01                      ; opcode 01 = RRQ (A should already be zero from having just reset file length)
set_tftp_opcode:
  stax tftp_opcode
  lda #tftp_initializing
  sta tftp_state
  ldax #0000
  stax tftp_current_block_number
  ldax tftp_load_address
  stax tftp_current_memloc
  ldax #tftp_in
  stax udp_callback
  ldx #$69
  inc tftp_client_port_low_byte ; each transfer uses a different client port
  lda tftp_client_port_low_byte ; so we don't get confused by late replies to a previous call

  jsr udp_add_listener

  bcc :+                        ; bail if we couldn't listen on the port we want
  lda #KPR_ERROR_PORT_IN_USE
  sta ip65_error
  rts
: lda #TFTP_MAX_RESENDS
  sta tftp_resend_counter
@outer_delay_loop:
  jsr timer_read
  txa
  and #TFTP_TIMER_MASK
  sta tftp_timer                ; we only care about the high byte
  lda #0
  sta tftp_break_inner_loop
  lda tftp_state
  cmp #tftp_initializing
  bne @not_initializing
  jsr send_request_packet

  jmp @inner_delay_loop

@not_initializing:
  cmp #tftp_error
  bne @not_error

@exit_with_error:
  ldx #$69
  lda tftp_client_port_low_byte
  jsr udp_remove_listener
  sec
  rts

@not_error:
  cmp #tftp_complete
  bne @not_complete
  jsr send_ack                  ; send the ack for the last block
  bcs @not_complete             ; if we couldn't send the ACK (e.g. coz we need to do an ARP request) then keep looping
  ldx #$69
  lda tftp_client_port_low_byte
  jsr udp_remove_listener
  rts

@not_complete:
  cmp #tftp_transmission_in_progress
  bne @not_transmitting
  jsr send_tftp_packet
  jmp @inner_delay_loop
@not_transmitting:
  jsr send_request_packet

@inner_delay_loop:
  jsr ip65_process
  jsr check_for_abort_key
  bcc @no_abort
  lda #KPR_ERROR_ABORTED_BY_USER
  sta ip65_error
  jmp @exit_with_error
@no_abort:
  lda tftp_break_inner_loop
  bne @outer_delay_loop
  jsr timer_read
  txa
  and #TFTP_TIMER_MASK
  cmp tftp_timer
  beq @inner_delay_loop

  dec tftp_resend_counter
  bne @outer_delay_loop
  lda #KPR_ERROR_TIMEOUT_ON_RECEIVE
  sta ip65_error
  jmp @exit_with_error

send_request_packet:
  lda #tftp_initializing
  sta tftp_state
  ldax tftp_opcode
  stax tftp_outp
  ldax tftp_filename
  stax ptr1

  ldx #$01                      ; we inc x/y at start of loop, so
  ldy #$ff                      ; set them to be 1 below where we want the copy to begin
@copy_filename_loop:
  inx
  iny
  bmi @error_in_send            ; if we get to 0x80 bytes, we've gone too far
  lda (ptr1),y
  sta tftp_outp,x
  bne @copy_filename_loop

  ldy #$ff
@copy_mode_loop:
  inx
  iny
  lda tftp_octet_mode,y
  sta tftp_outp,x
  bne @copy_mode_loop

  inx
  txa
  ldx #0
  stax udp_send_len

  ldx #$69
  lda tftp_client_port_low_byte
  stax udp_send_src_port

  ldx #3                        ; set destination address
: lda tftp_ip,x
  sta udp_send_dest,x
  dex
  bpl :-

  ldax #tftp_server_port        ; set destination port
  stax udp_send_dest_port
  ldax #tftp_outp
  jsr udp_send
  bcs @error_in_send
  lda #tftp_initial_request_sent
  sta tftp_state
  rts
@error_in_send:
  lda #KPR_ERROR_TRANSMIT_FAILED
  sta ip65_error
  sec
  rts

send_ack:
  ldax #$0400                   ; opcode 04 = ACK
  stax tftp_outp
  ldax #04
  stax tftp_send_len
send_tftp_packet:               ; TFTP block should be created in tftp_outp, we just add the UDP&IP stuff and send

  ldx tftp_current_block_number
  lda tftp_current_block_number+1
  stax tftp_outp+2

  ldx #$69
  lda tftp_client_port_low_byte
  stax udp_send_src_port

  lda tftp_actual_server_ip
  sta udp_send_dest
  lda tftp_actual_server_ip+1
  sta udp_send_dest+1
  lda tftp_actual_server_ip+2
  sta udp_send_dest+2
  lda tftp_actual_server_ip+3
  sta udp_send_dest+3
  ldx tftp_actual_server_port
  lda tftp_actual_server_port+1
  stax udp_send_dest_port
  ldax tftp_send_len
  stax udp_send_len

  ldax #tftp_outp
  jsr udp_send
  rts

got_expected_block:
  lda tftp_current_block_number
  inc tftp_current_block_number
  bne :+
  inc tftp_current_block_number+1
: lda #tftp_transmission_in_progress
  sta tftp_state
  lda #TFTP_MAX_RESENDS
  sta tftp_resend_counter
  lda #1
  sta tftp_break_inner_loop

  ldax udp_inp+udp_src_port
  stax tftp_actual_server_port
  ldax ip_inp+ip_src
  stax tftp_actual_server_ip
  ldax ip_inp+ip_src+2
  stax tftp_actual_server_ip+2
  rts

tftp_in:
  lda tftp_inp+1                ; get the opcode
  cmp #5
  bne @not_an_error
@recv_error:
  lda #tftp_error
  sta tftp_state
  lda #KPR_ERROR_TRANSMISSION_REJECTED_BY_PEER
  sta ip65_error
  rts
@not_an_error:
  cmp #3
  beq :+
  jmp @not_data_block
: lda #0
  sta tftp_just_set_new_load_address ; clear the flag
  clc
  lda tftp_load_address
  adc tftp_load_address+1       ; is load address currently $0000?
  bne @dont_set_load_address

  lda tftp_callback_address_set ; have we overridden the default handler?
  bne @dont_set_load_address    ; if so, don't skip the first two bytes in the file

  ldax udp_inp+$0c              ; get first two bytes of data
  stax tftp_load_address        ; make them the new load adress
  stax tftp_current_memloc      ; also the current memory destination
  lda #1                        ; set the flag
  sta tftp_just_set_new_load_address

@dont_set_load_address:
  ldx tftp_inp+3                ; get the (low byte) of the data block
  dex
  cpx tftp_current_block_number
  beq :+
  jmp @not_expected_block_number
: ; this is the block we wanted
  jsr got_expected_block

  lda tftp_just_set_new_load_address
  bne @skip_first_2_bytes_in_calculating_header_length
  lda udp_inp+5                 ; get the low byte of udp packet length
  sec
  sbc #$0c                      ; take off the length of the UDP header+OPCODE + BLOCK

  jmp @adjusted_header_length
@skip_first_2_bytes_in_calculating_header_length:
  lda udp_inp+5                 ; get the low byte of udp packet length
  sec
  sbc #$0e                      ; take off the length of the UDP header+OPCODE + BLOCK + first 2 bytes (memory location)
@adjusted_header_length:
  sta tftp_data_block_length
  lda udp_inp+4                 ; get high byte of the length of the UDP packet
  sbc #0
  sta tftp_data_block_length+1

  lda tftp_just_set_new_load_address
  bne @skip_first_2_bytes_in_calculating_copy_src
  ldax #udp_inp+$0c
  jmp @got_pointer_to_tftp_data
@skip_first_2_bytes_in_calculating_copy_src:
  ldax #udp_inp+$0e
@got_pointer_to_tftp_data:
  stax copy_src
  ldax #output_buffer+2
  stax copy_dest
  ldax tftp_data_block_length
  stax output_buffer
  jsr copymem
  ldax #output_buffer

  jsr tftp_callback_vector
  jsr send_ack

  lda udp_inp+4                 ; check the length of the UDP packet
  cmp #02
  bne @last_block

  lda udp_inp+5
  cmp #$0c
  bne @last_block
  beq @not_last_block
@not_data_block:
  cmp #4                        ; ACK is opcode 4
  beq :+
  jmp @not_ack
: ; it's an ACK, so we must be sending a file
  ldx tftp_inp+3                ; get the (low byte) of the data block
  cpx tftp_current_block_number
  beq :+
  jmp @not_expected_block_number
: ; the last block we sent was acked so now we need to send the next one
  ldax #output_buffer+4
  jsr tftp_callback_vector      ; this (caller supplied) routine should fill the buffer with up to 512 bytes
  stax tftp_data_block_length
  clc
  adc #4
  bcc :+
  inx
: stax tftp_send_len
  ldax #$0300                   ; opcode 03 = DATA
  stax tftp_outp
  jsr got_expected_block
  jsr send_tftp_packet

  lda tftp_data_block_length+1  ; get length of data we just sent (high byte)
  cmp #2
  bne @last_block
@not_last_block:
  inc tftp_filesize+1           ; add $200 to file size
  inc tftp_filesize+1           ; add $200 to file size

@not_ack:
@not_expected_block_number:
  rts

@last_block:
  lda tftp_data_block_length
  sta tftp_filesize             ; this must be the first block that is not a multiple of 512, hence till now the low byte in tftp_filesize is still $00
  lda tftp_data_block_length+1  ; this can only be 0 or 1
  beq :+
  inc tftp_filesize+1
: lda #tftp_complete
  sta tftp_state
  rts

; default handler when block arrives:
; copy to RAM
; assumes tftp_data_block_length has been set, and AX should point to start of data
copy_tftp_block_to_ram:
  clc
  adc #02                       ; skip the 2 byte length at start of buffer
  bcc :+
  inx
: stax copy_src
  ldax tftp_current_memloc
  stax copy_dest
  ldax tftp_data_block_length
  jsr copymem
  clc
  lda tftp_data_block_length    ; update the location where the next data will go
  adc tftp_current_memloc
  sta tftp_current_memloc
  lda tftp_data_block_length+1
  adc tftp_current_memloc+1
  sta tftp_current_memloc+1
  rts

; default handler for uploading a file
copy_ram_to_tftp_block:
  stax copy_dest
  ldax tftp_current_memloc
  stax copy_src
  clc
  lda tftp_bytes_remaining+1
  beq @last_block
  cmp #01
  beq @last_block
  dec tftp_bytes_remaining+1
  dec tftp_bytes_remaining+1
  ldax #$0200
@length_is_set:
  stax tftp_data_block_length
  jsr copymem
  inc tftp_current_memloc+1
  inc tftp_current_memloc+1
  ldax tftp_data_block_length
  clc
  rts
@last_block:
  ldax tftp_bytes_remaining
  jmp @length_is_set

; set up vector of routine to be called when each 512 packet arrives from tftp server
; when downloading OR for routine to be called when ready to send new block
; when uploading.
; when vector is called when downloading, AX will point to data that was downloaded,
; tftp_data_block_length will be set to length of downloaded data block. This will be
; equal to $200 (512) for each block EXCEPT the final block. THe final block will
; always be less than $200 bytes - if the file is an exact multiple if $200 bytes
; long, then a final block will be received with length $00.
; when vector is called when uploading, AX will point to a 512 byte buffer that
; should be filled with the next block. the user supplied routine should set AX
; to be equal to the actual number of bytes inserted into the buffer, which should
; equal to $200 (512) for each block EXCEPT the final block. The final block must
; always be less than $200 bytes - if the file is an exact multiple if $200 bytes
; long, then a final block must be created with length $00.
; inputs:
; AX - address of routine to call for each packet.
; outputs: none
tftp_set_callback_vector:
  stax tftp_callback_vector+1
  inc tftp_callback_address_set
  rts

; clear callback vectors, i.e. all future transfers read from/write to RAM
; inputs: none
; outputs: none
tftp_clear_callbacks:
  lda #0
  sta tftp_callback_address_set
  ldax #copy_tftp_block_to_ram
  jmp tftp_set_callback_vector


.rodata

  tftp_octet_mode: .asciiz "OCTET"


.data

tftp_callback_vector:
  jmp copy_tftp_block_to_ram    ; vector for action to take when a data block received (default is to store block in RAM)

tftp_callback_address_set: .byte 0



; -- LICENSE FOR tftp.s --
; The contents of this file are subject to the Mozilla Public License
; Version 1.1 (the "License"); you may not use this file except in
; compliance with the License. You may obtain a copy of the License at
; http://www.mozilla.org/MPL/
;
; Software distributed under the License is distributed on an "AS IS"
; basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
; License for the specific language governing rights and limitations
; under the License.
;
; The Original Code is ip65.
;
; The Initial Developer of the Original Code is Jonno Downes,
; jonno@jamtronix.com.
; Portions created by the Initial Developer are Copyright (C) 2009
; Jonno Downes. All Rights Reserved.
; -- LICENSE END --