WebSVN – Kolibri OS – Diff – /programs/network/tftpc/trunk/tftpc.asm


;
;    TFTP Client
   
use32
 org	0x0
 db	'MENUET01'    ; header
 dd	0x01	      ; header version
 dd	START	      ; entry point
 dd	I_END	      ; image size
 dd	I_END+0x10000 ; required memory
 dd	I_END+0x10000 ; esp
 dd	0x0 , 0x0     ; I_Param , I_Path
 
include 'lang.inc'
include '..\..\..\macros.inc'
   
START:				; start of execution
     mov  eax,40		 ; Report events
     mov  ebx,10000111b 	 ; Stack 8 + defaults
     mcall
   
    mov   dword [prompt], p1
    mov  dword [promptlen], p1len - p1
 
red:   
    call draw_window		; at first, draw the window
   
still:
    mov  eax,10 		; wait here for event
    mcall
   
    cmp  eax,1			; redraw request ?
    jz	 red
    cmp  eax,2			; key in buffer ?
    jz	 key
    cmp  eax,3			; button in buffer ?
    jz	 button
   
    jmp  still
 
key:			       ; Keys are not valid at this part of the
    mov  eax,2			; loop. Just read it and ignore
    mcall
    jmp  still
   
button: 		       ; button
    mov  eax,17 		; get id
    mcall
   
    cmp  ah,1			; button id=1 ?
    jnz  noclose
   
   
    ; close socket before exiting
 mov  eax, 53
 mov  ebx, 1
 mov  ecx, [socketNum]
    int   0x40
   
 mov  [socketNum], dword 0
   
   
    or  eax,-1 	; close this program
    mcall
   
noclose:
    cmp  ah,2			; copy file to local machine?
    jnz  nocopyl
   
    mov   dword [prompt], p5
    mov  dword [promptlen], p5len - p5
    call  draw_window		 ;
   
    ; Copy File from Remote Host to this machine
    call translateData	; Convert Filename & IP address
    mov  edi, tftp_filename + 1
    mov  [edi], byte 0x01 ; setup tftp msg
    call copyFromRemote
   
    jmp  still
   
nocopyl:
   
    cmp  ah,3	     ; Copy file to host?
    jnz  nocopyh
   
    mov   dword [prompt], p5
    mov  dword [promptlen], p5len - p5
    call  draw_window		 ;
   
    ; Copy File from this machine to Remote Host
    call translateData	; Convert Filename & IP address
    mov  edi, tftp_filename + 1
    mov  [edi], byte 0x02 ; setup tftp msg
    call copyToRemote
   
    jmp  still
   
nocopyh:
    cmp  ah,4
    jz	 f1
    cmp  ah,5
    jz	 f2
    jmp  nof12
   
  f1:
    mov  [addr],dword source
    mov  [ya],dword 35
    jmp  rk
   
  f2:
    mov  [addr],dword destination
    mov  [ya],dword 35+16
   
  rk:
    mov  ecx,15
    mov  edi,[addr]
    mov  al,' '
    rep  stosb
   
    call print_text
   
    mov  edi,[addr]
   
  f11:
    mov  eax,10
    mcall
    cmp  eax,2
    jz	 fbu
    jmp  still
  fbu:
    mov  eax,2
    mcall  ; get key
    shr  eax,8
    cmp  eax,8
    jnz  nobs
    cmp  edi,[addr]
    jz	 f11
    sub  edi,1
    mov  [edi],byte ' '
    call print_text
    jmp  f11
  nobs:
    cmp  eax,dword 31
    jbe  f11
    cmp  eax,dword 95
    jb	 keyok
    sub  eax,32
  keyok:
    mov  [edi],al
   
    call print_text
   
    add  edi,1
    mov  esi,[addr]
    add  esi,15
    cmp  esi,edi
    jnz  f11
   
    jmp  still
   
print_text:
   
    mov  eax,13
    mov  ebx,103*65536+15*6
    mov  ecx,[ya]
    shl  ecx,16
    mov  cx,8
    mov  edx,0x224466
    mcall
   
    mov  eax,4
    mov  ebx,103*65536
    add  ebx,[ya]
    mov  ecx,0xffffff
    mov  edx,[addr]
    mov  esi,15
    mcall
   
    ret
   
   
  nof12:
    jmp  still
   
   
;***************************************************************************
;   Function
;      translateData
;
;   Description
;      Coverts the filename and IP address typed in by the user into
;      a format suitable for the IP layer.
;
;    The filename, in source, is converted and stored in tftp_filename
;      The host ip, in destination, is converted and stored in tftp_IP
;
;***************************************************************************
translateData:
   
 ; first, build up the tftp command string. This includes the filename
 ; and the transfer protocol
   
   
 ; First, write 0,0
 mov  al, 0
 mov  edi, tftp_filename
 mov  [edi], al
 inc  edi
 mov  [edi], al
 inc  edi
   
 ; Now, write the file name itself, and null terminate it
 mov  ecx, 15
 mov  ah, ' '
 mov  esi, source
   
td001:
 lodsb
 stosb
 cmp  al, ah
 loopnz td001
   
 cmp  al,ah  ; Was the entire buffer full of characters?
 jne  td002
 dec  edi   ; No - so remove ' ' character
   
td002:
 mov  [edi], byte 0
 inc  edi
 mov  [edi], byte 'O'
 inc  edi
 mov  [edi], byte 'C'
 inc  edi
 mov  [edi], byte 'T'
 inc  edi
 mov  [edi], byte 'E'
 inc  edi
 mov  [edi], byte 'T'
 inc  edi
 mov  [edi], byte 0
   
 mov  esi, tftp_filename
 sub  edi, esi
 mov  [tftp_len], edi
   
   
 ; Now, convert the typed IP address into a real address
 ; No validation is done on the number entered
 ; ip addresses must be typed in normally, eg
 ; 192.1.45.24
   
 xor  eax, eax
 mov  dh, 10
 mov  dl, al
 mov  [tftp_IP], eax
   
 ; 192.168.24.1   1.1.1.1       1. 9.2.3.
   
 mov  esi, destination
 mov  edi, tftp_IP
   
 mov  ecx, 4
   
td003:
 lodsb
 sub  al, '0'
 add  dl, al
 lodsb
 cmp  al, '.'
 je  ipNext
 cmp  al, ' '
 je  ipNext
 mov  dh, al
 sub  dh, '0'
 mov  al, 10
 mul  dl
 add  al, dh
 mov  dl, al
 lodsb
 cmp  al, '.'
 je  ipNext
 cmp  al, ' '
 je  ipNext
 mov  dh, al
 sub  dh, '0'
 mov  al, 10
 mul  dl
 add  al, dh
 mov  dl, al
 lodsb
   
ipNext:
 mov  [edi], dl
 inc  edi
 mov  dl, 0
 loop td003
   
 ret
   
   
   
;***************************************************************************
;   Function
;      copyFromRemote
;
;   Description
;
;***************************************************************************
copyFromRemote:
 xor  eax, eax
 mov  [filesize], eax
 mov  eax, I_END + 512 ; This is the point where the file buffer is
 mov  [fileposition], eax
   
 ; Get a random # for the local socket port #
 mov  eax, 3
 int	 0x40
 mov  ecx, eax
 shr  ecx, 8	; Set up the local port # with a random #
   
   ; open socket
 mov  eax, 53
 mov  ebx, 0
 mov  edx, 69	 ; remote port
 mov  esi, [tftp_IP]  ; remote IP ( in intenet format )
    int   0x40
   
   mov	[socketNum], eax
   
 ; make sure there is no data in the socket - there shouldn't be..
   
cfr001:
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	  ; read byte
   
 mov  eax, 53
 mov  ebx, 2
 mov  ecx, [socketNum]
    int   0x40	  ; any more data?
   
 cmp  eax, 0
 jne  cfr001	; yes, so get it
   
 ; Now, request the file
 mov  eax, 53
 mov  ebx, 4
 mov  ecx, [socketNum]
 mov  edx, [tftp_len]
 mov  esi, tftp_filename
    int   0x40
   
cfr002:
    mov  eax,10 		; wait here for event
    mcall
   
    cmp  eax,1			; redraw request ?
    je	 cfr003
    cmp  eax,2			; key in buffer ?
    je	 cfr004
    cmp  eax,3			; button in buffer ?
    je	 cfr005
   
    ; Any data to fetch?
 mov  eax, 53
 mov  ebx, 2
 mov  ecx, [socketNum]
    int   0x40
   
 cmp  eax, 0
 je  cfr002
   
 push eax     ; eax holds # chars
   
 ; Update the text on the display - once
 mov  eax, [prompt]
 cmp  eax, p3
 je  cfr008
    mov   dword [prompt], p3
    mov  dword [promptlen], p3len - p3
    call  draw_window		 ;
   
cfr008:
 ; we have data - this will be a tftp frame
   
 ; read first two bytes - opcode
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte
   
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte
   
 pop  eax
 ; bl holds tftp opcode. Can only be 3 (data) or 5 ( error )
   
 cmp  bl, 3
 jne  cfrerr
   
 push eax
   
 ; do data stuff. Read block #. Read data. Send Ack.
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte
   
 mov  [blockNumber], bl
   
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
 int   0x40   ; read byte
   
 mov  [blockNumber+1], bl
   
cfr007:
   
 mov  eax, 53
 mov  ebx, 2
 mov  ecx, [socketNum]
 mcall   ; any more data?
   
 cmp  eax, 0
 je   no_more_data ; no
   
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
 mcall   ; read byte
   
 mov  esi, [fileposition]
 mov  [esi], bl
 inc  dword [fileposition]
 inc  dword [filesize]
   
 jmp  cfr007					       
   
no_more_data:
   
 ; write the block number into the ack
 mov  al, [blockNumber]
 mov  [ack + 2], al
   
 mov  al, [blockNumber+1]
 mov  [ack + 3], al
   
 ; send an 'ack'
 mov  eax, 53
 mov  ebx, 4
 mov  ecx, [socketNum]
 mov  edx, ackLen - ack
 mov  esi, ack
    int   0x40
   
 ; If # of chars in the frame is less that 516,
 ; this frame is the last
 pop  eax
 cmp  eax, 516
 je  cfr002
   
 ; Write the file
 mov  eax, 33
 mov  ebx, source
 mov  edx, [filesize]
 mov  ecx, I_END + 512
 mov  esi, 0
 mcall
   
 jmp  cfrexit
   
cfrerr:
 ; simple implementation on error - just read all data, and return
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	  ; read byte
   
 mov  eax, 53
 mov  ebx, 2
 mov  ecx, [socketNum]
    int   0x40	  ; any more data?
   
 cmp  eax, 0
 jne  cfrerr	; yes, so get it
   
 jmp  cfr006	; close socket and close app
   
cfr003: 			; redraw request
    call draw_window
    jmp  cfr002
   
cfr004: 			; key pressed
    mov  eax,2			; just read it and ignore
    mcall
    jmp  cfr002
   
cfr005: 		       ; button
    mov  eax,17 		; get id
    mcall
   
    cmp  ah,1			; button id=1 ?
    jne  cfr002     ; If not, ignore.
   
cfr006:
    ; close socket
 mov  eax, 53
 mov  ebx, 1
 mov  ecx, [socketNum]
    int   0x40
   
 mov  [socketNum], dword 0
   
    mov  eax,-1 		; close this program
    mcall
   
    jmp $
   
cfrexit:
    ; close socket
 mov  eax, 53
 mov  ebx, 1
 mov  ecx, [socketNum]
    int   0x40
   
 mov  [socketNum], dword 0
   
    mov   dword [prompt], p4
    mov  dword [promptlen], p4len - p4
    call  draw_window		 ;
   
 ret
   
   
   
;***************************************************************************
;   Function
;      copyToRemote
;
;   Description
;
;***************************************************************************
copyToRemote:
    mov   eax,6    ; Read file from floppy (image)
    mov   ebx,source
    mov   ecx,0
    mov   edx,0xffffffff
    mov   esi,I_END + 512
    int   0x40
   
    cmp   eax,0xffffffff
    jnz   filefound
   
    mov   dword [prompt], p6
    mov  dword [promptlen], p6len - p6
    call  draw_window		 ;
 jmp  ctr_exit
   
filefound:
 mov  [filesize], eax
   
 ; First, set up the file pointers
 mov  eax, 0x01000300
 mov  [blockBuffer], eax ; This makes sure our TFTP header is valid
   
 mov  eax, I_END + 512 ; This is the point where the file buffer is
 mov  [fileposition], eax
   
 mov  eax, [filesize]
 cmp  eax, 512
 jb  ctr000
 mov  eax, 512
ctr000:
 mov  [fileblocksize], ax
   
 ; Get a random # for the local socket port #
 mov  eax, 3
 int	 0x40
 mov  ecx, eax
 shr  ecx, 8	; Set up the local port # with a random #
   
   ; First, open socket
 mov  eax, 53
 mov  ebx, 0
 mov  edx, 69	 ; remote port
 mov  esi, [tftp_IP]
    int   0x40
   
   mov	[socketNum], eax
   
   ; write to socket ( request write file )
 mov  eax, 53
 mov  ebx, 4
 mov  ecx, [socketNum]
 mov  edx, [tftp_len]
 mov  esi, tftp_filename
    int   0x40
   
 ; now, we wait for
 ; UI redraw
 ; UI close
 ; or data from remote
   
ctr001:
    mov   eax,10		 ; wait here for event
    int   0x40
   
    cmp   eax,1 		 ; redraw request ?
    je	  ctr003
    cmp   eax,2 		 ; key in buffer ?
    je	  ctr004
    cmp   eax,3 		 ; button in buffer ?
    je	  ctr005
   
   
    ; Any data in the UDP receive buffer?
 mov  eax, 53
 mov  ebx, 2
 mov  ecx, [socketNum]
    int   0x40
   
 cmp  eax, 0
 je  ctr001
   
 ; Update the text on the display - once
 mov  eax, [prompt]
 cmp  eax, p2
 je  ctr002
   
    mov   dword [prompt], p2
    mov  dword [promptlen], p2len - p2
    call  draw_window		 ;
   
 ; we have data - this will be the ack
ctr002:
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte - opcode
   
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte - opcode
   
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte - block (high byte)
   
 mov  [blockNumber], bl
   
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte - block (low byte )
   
 mov  [blockNumber+1], bl
   
ctr0022:
 mov  eax, 53
 mov  ebx, 3
 mov  ecx, [socketNum]
    int   0x40	 ; read byte (shouldn't have worked)
   
   
 mov  eax, 53
 mov  ebx, 2
 mov  ecx, [socketNum]
    int   0x40	 ; any more data?
   
 cmp  eax, 0
 jne  ctr0022  ; yes, so get it, and dump it
   
 ; If the ack is 0, it is to the request
   
 mov  bx, [blockNumber]
 cmp  bx, 0
 je   txd
   
 ; now, the ack should be one more than the current field - otherwise, resend
   
 cmp  bx, [blockBuffer+2]
 jne  txre     ; not the same, so send again
   
 ; update the block number
 mov  esi, blockBuffer + 3
 mov  al, [esi]
 inc  al
 mov  [esi], al
 cmp  al, 0
 jne  ctr008
 dec  esi
 inc	 byte [esi]
   
ctr008:
 ; Move forward through the file
 mov  eax, [fileposition]
 movzx ebx, word [fileblocksize]
 add  eax, ebx
 mov  [fileposition], eax
   
 ; new ..
 ; fs = 0 , fbs = 512 -> send with fbs = 0
   
 cmp  [filesize],0
 jne  no_special_end
 cmp  [fileblocksize],512
 jne  no_special_end
 mov  ax,0
 jmp  ctr006
no_special_end:
   
 mov  eax, [filesize]
 cmp  eax, 0
 je  ctr009
 cmp  eax, 512
 jb  ctr006
 mov  eax, 512
ctr006:
 mov  [fileblocksize], ax
   
   
txd:
 ; Readjust the file size variable ( before sending )
 mov  eax, [filesize]
 movzx ebx, word [fileblocksize]
 sub  eax, ebx
 mov  [filesize], eax
   
txre:
 ; Copy the fragment of the file to the block buffer
 movzx ecx, word [fileblocksize]
 mov  esi, [fileposition]
 mov  edi, I_END
 cld
 rep  movsb
   
 ; send the file data
 mov  eax, 53
 mov  ebx, 4
 mov  ecx, [socketNum]
 movzx edx, word [fileblocksize]
 add  edx, 4
 mov  esi, blockBuffer
    int   0x40
   
 jmp  ctr001
   
ctr003: 		; redraw
    call  draw_window
    jmp   ctr001
   
ctr004: 		; key
    mov   eax,2 	 ; just read it and ignore
    int   0x40
    jmp   ctr001
   
ctr005: 		; button
    mov   eax,17	 ; get id
    int   0x40
   
    cmp   ah,1		 ; button id=1 ?
    jne   ctr001
   
    ; close socket
 mov  eax, 53
 mov  ebx, 1
 mov  ecx, [socketNum]
    int   0x40
   
 mov  [socketNum], dword 0
   
    mov   eax,-1	 ; close this program
    int   0x40
 jmp  $
   
ctr009:
    ; close socket
 mov  eax, 53
 mov  ebx, 1
 mov  ecx, [socketNum]
    int   0x40
   
    mov   dword [prompt], p4
    mov  dword [promptlen], p4len - p4
    call  draw_window		 ;
   
ctr_exit:
 ret
   
   
   
   
;   *********************************************
;   *******  WINDOW DEFINITIONS AND DRAW ********
;   *********************************************
   
   
draw_window:
   
    mov  eax,12 		   ; function 12:tell os about windowdraw
    mov  ebx,1			   ; 1, start of draw
    mcall
   
				   ; DRAW WINDOW
    mov  eax,0			   ; function 0 : define and draw window
    mov  ebx,100*65536+230	   ; [x start] *65536 + [x size]
    mov  ecx,100*65536+170	   ; [y start] *65536 + [y size]
    mov  edx,0x14224466 	   ; color of work area RRGGBB
    mov  edi,title
    mcall
   
    mov  eax,8		    ; COPY BUTTON
    mov  ebx,20*65536+190
    mov  ecx,79*65536+15
    mov  edx,2
    mov  esi,0x557799
    mcall
   
 ;   mov  eax,8		    ; DELETE BUTTON
    mov  ebx,20*65536+190
    mov  ecx,111*65536+15
    mov  edx,3
    mcall
   
 ;   mov  eax,8
 ;   mov  ebx,200*65536+10
    mov  ecx,34*65536+10
    mov  edx,4
    mcall
   
 ;   mov  eax,8
 ;   mov  ebx,200*65536+10
    mov  ecx,50*65536+10
    mov  edx,5
    mcall
   
   
 ; Copy the file name to the screen buffer
 ; file name is same length as IP address, to
 ; make the math easier later.
    cld
    mov  esi,source
    mov  edi,text+13
    mov  ecx,15
    rep  movsb
   
   
 ; copy the IP address to the screen buffer
    mov  esi,destination
    mov  edi,text+40+13
    mov  ecx,15
    rep  movsb
   
  ; copy the prompt to the screen buffer
    mov  esi,[prompt]
    mov  edi,text+280
    mov  ecx,[promptlen]
    rep  movsb
   
    ; Re-draw the screen text
    cld
    mov  eax,4
    mov  ebx,25*65536+35	   ; draw info text with function 4
    mov  ecx,0xffffff
    mov  edx,text
    mov  esi,40
  newline:
    mcall
    add  ebx,16
    add  edx,40
    cmp  [edx],byte 'x'
    jnz  newline
   
   
    mov  eax,12 		   ; function 12:tell os about windowdraw
    mov  ebx,2			   ; 2, end of draw
    mcall
   
    ret
   
   
; DATA AREA
   
source	     db  'KERNEL.ASM     '
destination  db  '192.168.1.23   '
   
   
tftp_filename:	times 15 + 9 db 0
tftp_IP:   dd 0
tftp_len:   dd 0
   
addr  dd  0x0
ya    dd  0x0
   
fileposition dd 0 ; Points to the current point in the file
filesize  dd 0 ; The number of bytes written / left to write
fileblocksize dw 0 ; The number of bytes to send in this frame
   
text:
    db 'SOURCE FILE: xxxxxxxxxxxxxxx            '
    db 'HOST IP ADD: xxx.xxx.xxx.xxx            '
    db '                                        '
    db '  COPY HOST   ->   LOCAL                '
    db '                                        '
    db '  COPY LOCAL  ->   HOST                 '
    db '                                        '
    db '                                        '
    db 'x' ; <- END MARKER, DONT DELETE
   
   
title	db   'TFTP Client',0   
   
prompt: dd 0
promptlen: dd 0
   
   
p1:  db 'Waiting for Command'
p1len:
   
p2:  db 'Sending File       '
p2len:
   
p3:  db 'Receiving File     '
p3len:
   
p4:  db 'Tranfer Complete   '
p4len:
   
p5:  db 'Contacting Host... '
p5len:
   
p6:  db 'File not found.    '
p6len:
   
ack:
 db 00,04,0,1
ackLen:
   
socketNum:
 dd 0
   
blockNumber:
 dw 0
   
; This must be the last part of the file, because the blockBuffer
; continues at I_END.
blockBuffer:
 db 00, 03, 00, 01
I_END:

Rev 485	Rev 551
1	;	1	;
2	; TFTP Client	2	; TFTP Client
3		3
4	use32	4	use32
5	org 0x0	5	org 0x0
6	db 'MENUET01' ; header	6	db 'MENUET01' ; header
7	dd 0x01 ; header version	7	dd 0x01 ; header version
8	dd START ; entry point	8	dd START ; entry point
9	dd I_END ; image size	9	dd I_END ; image size
10	dd I_END+0x10000 ; required memory	10	dd I_END+0x10000 ; required memory
11	dd I_END+0x10000 ; esp	11	dd I_END+0x10000 ; esp
12	dd 0x0 , 0x0 ; I_Param , I_Path	12	dd 0x0 , 0x0 ; I_Param , I_Path
13		13
14	include 'lang.inc'	14	include 'lang.inc'
15	include '..\..\..\macros.inc'	15	include '..\..\..\macros.inc'
16		16
17	START: ; start of execution	17	START: ; start of execution
18	mov eax,40 ; Report events	18	mov eax,40 ; Report events
19	mov ebx,10000111b ; Stack 8 + defaults	19	mov ebx,10000111b ; Stack 8 + defaults
20	mcall	20	mcall
21		21
22	mov dword [prompt], p1	22	mov dword [prompt], p1
23	mov dword [promptlen], p1len - p1	23	mov dword [promptlen], p1len - p1
24		24
25	red:	25	red:
26	call draw_window ; at first, draw the window	26	call draw_window ; at first, draw the window
27		27
28	still:	28	still:
29	mov eax,10 ; wait here for event	29	mov eax,10 ; wait here for event
30	mcall	30	mcall
31		31
32	cmp eax,1 ; redraw request ?	32	cmp eax,1 ; redraw request ?
33	jz red	33	jz red
34	cmp eax,2 ; key in buffer ?	34	cmp eax,2 ; key in buffer ?
35	jz key	35	jz key
36	cmp eax,3 ; button in buffer ?	36	cmp eax,3 ; button in buffer ?
37	jz button	37	jz button
38		38
39	jmp still	39	jmp still
40		40
41	key: ; Keys are not valid at this part of the	41	key: ; Keys are not valid at this part of the
42	mov eax,2 ; loop. Just read it and ignore	42	mov eax,2 ; loop. Just read it and ignore
43	mcall	43	mcall
44	jmp still	44	jmp still
45		45
46	button: ; button	46	button: ; button
47	mov eax,17 ; get id	47	mov eax,17 ; get id
48	mcall	48	mcall
49		49
50	cmp ah,1 ; button id=1 ?	50	cmp ah,1 ; button id=1 ?
51	jnz noclose	51	jnz noclose
52		52
53		53
54	; close socket before exiting	54	; close socket before exiting
55	mov eax, 53	55	mov eax, 53
56	mov ebx, 1	56	mov ebx, 1
57	mov ecx, [socketNum]	57	mov ecx, [socketNum]
58	int 0x40	58	int 0x40
59		59
60	mov [socketNum], dword 0	60	mov [socketNum], dword 0
61		61
62		62
63	or eax,-1 ; close this program	63	or eax,-1 ; close this program
64	mcall	64	mcall
65		65
66	noclose:	66	noclose:
67	cmp ah,2 ; copy file to local machine?	67	cmp ah,2 ; copy file to local machine?
68	jnz nocopyl	68	jnz nocopyl
69		69
70	mov dword [prompt], p5	70	mov dword [prompt], p5
71	mov dword [promptlen], p5len - p5	71	mov dword [promptlen], p5len - p5
72	call draw_window ;	72	call draw_window ;
73		73
74	; Copy File from Remote Host to this machine	74	; Copy File from Remote Host to this machine
75	call translateData ; Convert Filename & IP address	75	call translateData ; Convert Filename & IP address
76	mov edi, tftp_filename + 1	76	mov edi, tftp_filename + 1
77	mov [edi], byte 0x01 ; setup tftp msg	77	mov [edi], byte 0x01 ; setup tftp msg
78	call copyFromRemote	78	call copyFromRemote
79		79
80	jmp still	80	jmp still
81		81
82	nocopyl:	82	nocopyl:
83		83
84	cmp ah,3 ; Copy file to host?	84	cmp ah,3 ; Copy file to host?
85	jnz nocopyh	85	jnz nocopyh
86		86
87	mov dword [prompt], p5	87	mov dword [prompt], p5
88	mov dword [promptlen], p5len - p5	88	mov dword [promptlen], p5len - p5
89	call draw_window ;	89	call draw_window ;
90		90
91	; Copy File from this machine to Remote Host	91	; Copy File from this machine to Remote Host
92	call translateData ; Convert Filename & IP address	92	call translateData ; Convert Filename & IP address
93	mov edi, tftp_filename + 1	93	mov edi, tftp_filename + 1
94	mov [edi], byte 0x02 ; setup tftp msg	94	mov [edi], byte 0x02 ; setup tftp msg
95	call copyToRemote	95	call copyToRemote
96		96
97	jmp still	97	jmp still
98		98
99	nocopyh:	99	nocopyh:
100	cmp ah,4	100	cmp ah,4
101	jz f1	101	jz f1
102	cmp ah,5	102	cmp ah,5
103	jz f2	103	jz f2
104	jmp nof12	104	jmp nof12
105		105
106	f1:	106	f1:
107	mov [addr],dword source	107	mov [addr],dword source
108	mov [ya],dword 35	108	mov [ya],dword 35
109	jmp rk	109	jmp rk
110		110
111	f2:	111	f2:
112	mov [addr],dword destination	112	mov [addr],dword destination
113	mov [ya],dword 35+16	113	mov [ya],dword 35+16
114		114
115	rk:	115	rk:
116	mov ecx,15	116	mov ecx,15
117	mov edi,[addr]	117	mov edi,[addr]
118	mov al,' '	118	mov al,' '
119	rep stosb	119	rep stosb
120		120
121	call print_text	121	call print_text
122		122
123	mov edi,[addr]	123	mov edi,[addr]
124		124
125	f11:	125	f11:
126	mov eax,10	126	mov eax,10
127	mcall	127	mcall
128	cmp eax,2	128	cmp eax,2
129	jz fbu	129	jz fbu
130	jmp still	130	jmp still
131	fbu:	131	fbu:
132	mov eax,2	132	mov eax,2
133	mcall ; get key	133	mcall ; get key
134	shr eax,8	134	shr eax,8
135	cmp eax,8	135	cmp eax,8
136	jnz nobs	136	jnz nobs
137	cmp edi,[addr]	137	cmp edi,[addr]
138	jz f11	138	jz f11
139	sub edi,1	139	sub edi,1
140	mov [edi],byte ' '	140	mov [edi],byte ' '
141	call print_text	141	call print_text
142	jmp f11	142	jmp f11
143	nobs:	143	nobs:
144	cmp eax,dword 31	144	cmp eax,dword 31
145	jbe f11	145	jbe f11
146	cmp eax,dword 95	146	cmp eax,dword 95
147	jb keyok	147	jb keyok
148	sub eax,32	148	sub eax,32
149	keyok:	149	keyok:
150	mov [edi],al	150	mov [edi],al
151		151
152	call print_text	152	call print_text
153		153
154	add edi,1	154	add edi,1
155	mov esi,[addr]	155	mov esi,[addr]
156	add esi,15	156	add esi,15
157	cmp esi,edi	157	cmp esi,edi
158	jnz f11	158	jnz f11
159		159
160	jmp still	160	jmp still
161		161
162	print_text:	162	print_text:
163		163
164	mov eax,13	164	mov eax,13
165	mov ebx,10365536+156	165	mov ebx,10365536+156
166	mov ecx,[ya]	166	mov ecx,[ya]
167	shl ecx,16	167	shl ecx,16
168	mov cx,8	168	mov cx,8
169	mov edx,0x224466	169	mov edx,0x224466
170	mcall	170	mcall
171		171
172	mov eax,4	172	mov eax,4
173	mov ebx,103*65536	173	mov ebx,103*65536
174	add ebx,[ya]	174	add ebx,[ya]
175	mov ecx,0xffffff	175	mov ecx,0xffffff
176	mov edx,[addr]	176	mov edx,[addr]
177	mov esi,15	177	mov esi,15
178	mcall	178	mcall
179		179
180	ret	180	ret
181		181
182		182
183	nof12:	183	nof12:
184	jmp still	184	jmp still
185		185
186		186
187	;***************************************************************************	187	;***************************************************************************
188	; Function	188	; Function
189	; translateData	189	; translateData
190	;	190	;
191	; Description	191	; Description
192	; Coverts the filename and IP address typed in by the user into	192	; Coverts the filename and IP address typed in by the user into
193	; a format suitable for the IP layer.	193	; a format suitable for the IP layer.
194	;	194	;
195	; The filename, in source, is converted and stored in tftp_filename	195	; The filename, in source, is converted and stored in tftp_filename
196	; The host ip, in destination, is converted and stored in tftp_IP	196	; The host ip, in destination, is converted and stored in tftp_IP
197	;	197	;
198	;***************************************************************************	198	;***************************************************************************
199	translateData:	199	translateData:
200		200
201	; first, build up the tftp command string. This includes the filename	201	; first, build up the tftp command string. This includes the filename
202	; and the transfer protocol	202	; and the transfer protocol
203		203
204		204
205	; First, write 0,0	205	; First, write 0,0
206	mov al, 0	206	mov al, 0
207	mov edi, tftp_filename	207	mov edi, tftp_filename
208	mov [edi], al	208	mov [edi], al
209	inc edi	209	inc edi
210	mov [edi], al	210	mov [edi], al
211	inc edi	211	inc edi
212		212
213	; Now, write the file name itself, and null terminate it	213	; Now, write the file name itself, and null terminate it
214	mov ecx, 15	214	mov ecx, 15
215	mov ah, ' '	215	mov ah, ' '
216	mov esi, source	216	mov esi, source
217		217
218	td001:	218	td001:
219	lodsb	219	lodsb
220	stosb	220	stosb
221	cmp al, ah	221	cmp al, ah
222	loopnz td001	222	loopnz td001
223		223
224	cmp al,ah ; Was the entire buffer full of characters?	224	cmp al,ah ; Was the entire buffer full of characters?
225	jne td002	225	jne td002
226	dec edi ; No - so remove ' ' character	226	dec edi ; No - so remove ' ' character
227		227
228	td002:	228	td002:
229	mov [edi], byte 0	229	mov [edi], byte 0
230	inc edi	230	inc edi
231	mov [edi], byte 'O'	231	mov [edi], byte 'O'
232	inc edi	232	inc edi
233	mov [edi], byte 'C'	233	mov [edi], byte 'C'
234	inc edi	234	inc edi
235	mov [edi], byte 'T'	235	mov [edi], byte 'T'
236	inc edi	236	inc edi
237	mov [edi], byte 'E'	237	mov [edi], byte 'E'
238	inc edi	238	inc edi
239	mov [edi], byte 'T'	239	mov [edi], byte 'T'
240	inc edi	240	inc edi
241	mov [edi], byte 0	241	mov [edi], byte 0
242		242
243	mov esi, tftp_filename	243	mov esi, tftp_filename
244	sub edi, esi	244	sub edi, esi
245	mov [tftp_len], edi	245	mov [tftp_len], edi
246		246
247		247
248	; Now, convert the typed IP address into a real address	248	; Now, convert the typed IP address into a real address
249	; No validation is done on the number entered	249	; No validation is done on the number entered
250	; ip addresses must be typed in normally, eg	250	; ip addresses must be typed in normally, eg
251	; 192.1.45.24	251	; 192.1.45.24
252		252
253	xor eax, eax	253	xor eax, eax
254	mov dh, 10	254	mov dh, 10
255	mov dl, al	255	mov dl, al
256	mov [tftp_IP], eax	256	mov [tftp_IP], eax
257		257
258	; 192.168.24.1 1.1.1.1 1. 9.2.3.	258	; 192.168.24.1 1.1.1.1 1. 9.2.3.
259		259
260	mov esi, destination	260	mov esi, destination
261	mov edi, tftp_IP	261	mov edi, tftp_IP
262		262
263	mov ecx, 4	263	mov ecx, 4
264		264
265	td003:	265	td003:
266	lodsb	266	lodsb
267	sub al, '0'	267	sub al, '0'
268	add dl, al	268	add dl, al
269	lodsb	269	lodsb
270	cmp al, '.'	270	cmp al, '.'
271	je ipNext	271	je ipNext
272	cmp al, ' '	272	cmp al, ' '
273	je ipNext	273	je ipNext
274	mov dh, al	274	mov dh, al
275	sub dh, '0'	275	sub dh, '0'
276	mov al, 10	276	mov al, 10
277	mul dl	277	mul dl
278	add al, dh	278	add al, dh
279	mov dl, al	279	mov dl, al
280	lodsb	280	lodsb
281	cmp al, '.'	281	cmp al, '.'
282	je ipNext	282	je ipNext
283	cmp al, ' '	283	cmp al, ' '
284	je ipNext	284	je ipNext
285	mov dh, al	285	mov dh, al
286	sub dh, '0'	286	sub dh, '0'
287	mov al, 10	287	mov al, 10
288	mul dl	288	mul dl
289	add al, dh	289	add al, dh
290	mov dl, al	290	mov dl, al
291	lodsb	291	lodsb
292		292
293	ipNext:	293	ipNext:
294	mov [edi], dl	294	mov [edi], dl
295	inc edi	295	inc edi
296	mov dl, 0	296	mov dl, 0
297	loop td003	297	loop td003
298		298
299	ret	299	ret
300		300
301		301
302		302
303	;***************************************************************************	303	;***************************************************************************
304	; Function	304	; Function
305	; copyFromRemote	305	; copyFromRemote
306	;	306	;
307	; Description	307	; Description
308	;	308	;
309	;***************************************************************************	309	;***************************************************************************
310	copyFromRemote:	310	copyFromRemote:
311	xor eax, eax	311	xor eax, eax
312	mov [filesize], eax	312	mov [filesize], eax
313	mov eax, I_END + 512 ; This is the point where the file buffer is	313	mov eax, I_END + 512 ; This is the point where the file buffer is
314	mov [fileposition], eax	314	mov [fileposition], eax
315		315
316	; Get a random # for the local socket port #	316	; Get a random # for the local socket port #
317	mov eax, 3	317	mov eax, 3
318	int 0x40	318	int 0x40
319	mov ecx, eax	319	mov ecx, eax
320	shr ecx, 8 ; Set up the local port # with a random #	320	shr ecx, 8 ; Set up the local port # with a random #
321		321
322	; open socket	322	; open socket
323	mov eax, 53	323	mov eax, 53
324	mov ebx, 0	324	mov ebx, 0
325	mov edx, 69 ; remote port	325	mov edx, 69 ; remote port
326	mov esi, [tftp_IP] ; remote IP ( in intenet format )	326	mov esi, [tftp_IP] ; remote IP ( in intenet format )
327	int 0x40	327	int 0x40
328		328
329	mov [socketNum], eax	329	mov [socketNum], eax
330		330
331	; make sure there is no data in the socket - there shouldn't be..	331	; make sure there is no data in the socket - there shouldn't be..
332		332
333	cfr001:	333	cfr001:
334	mov eax, 53	334	mov eax, 53
335	mov ebx, 3	335	mov ebx, 3
336	mov ecx, [socketNum]	336	mov ecx, [socketNum]
337	int 0x40 ; read byte	337	int 0x40 ; read byte
338		338
339	mov eax, 53	339	mov eax, 53
340	mov ebx, 2	340	mov ebx, 2
341	mov ecx, [socketNum]	341	mov ecx, [socketNum]
342	int 0x40 ; any more data?	342	int 0x40 ; any more data?
343		343
344	cmp eax, 0	344	cmp eax, 0
345	jne cfr001 ; yes, so get it	345	jne cfr001 ; yes, so get it
346		346
347	; Now, request the file	347	; Now, request the file
348	mov eax, 53	348	mov eax, 53
349	mov ebx, 4	349	mov ebx, 4
350	mov ecx, [socketNum]	350	mov ecx, [socketNum]
351	mov edx, [tftp_len]	351	mov edx, [tftp_len]
352	mov esi, tftp_filename	352	mov esi, tftp_filename
353	int 0x40	353	int 0x40
354		354
355	cfr002:	355	cfr002:
356	mov eax,10 ; wait here for event	356	mov eax,10 ; wait here for event
357	mcall	357	mcall
358		358
359	cmp eax,1 ; redraw request ?	359	cmp eax,1 ; redraw request ?
360	je cfr003	360	je cfr003
361	cmp eax,2 ; key in buffer ?	361	cmp eax,2 ; key in buffer ?
362	je cfr004	362	je cfr004
363	cmp eax,3 ; button in buffer ?	363	cmp eax,3 ; button in buffer ?
364	je cfr005	364	je cfr005
365		365
366	; Any data to fetch?	366	; Any data to fetch?
367	mov eax, 53	367	mov eax, 53
368	mov ebx, 2	368	mov ebx, 2
369	mov ecx, [socketNum]	369	mov ecx, [socketNum]
370	int 0x40	370	int 0x40
371		371
372	cmp eax, 0	372	cmp eax, 0
373	je cfr002	373	je cfr002
374		374
375	push eax ; eax holds # chars	375	push eax ; eax holds # chars
376		376
377	; Update the text on the display - once	377	; Update the text on the display - once
378	mov eax, [prompt]	378	mov eax, [prompt]
379	cmp eax, p3	379	cmp eax, p3
380	je cfr008	380	je cfr008
381	mov dword [prompt], p3	381	mov dword [prompt], p3
382	mov dword [promptlen], p3len - p3	382	mov dword [promptlen], p3len - p3
383	call draw_window ;	383	call draw_window ;
384		384
385	cfr008:	385	cfr008:
386	; we have data - this will be a tftp frame	386	; we have data - this will be a tftp frame
387		387
388	; read first two bytes - opcode	388	; read first two bytes - opcode
389	mov eax, 53	389	mov eax, 53
390	mov ebx, 3	390	mov ebx, 3
391	mov ecx, [socketNum]	391	mov ecx, [socketNum]
392	int 0x40 ; read byte	392	int 0x40 ; read byte
393		393
394	mov eax, 53	394	mov eax, 53
395	mov ebx, 3	395	mov ebx, 3
396	mov ecx, [socketNum]	396	mov ecx, [socketNum]
397	int 0x40 ; read byte	397	int 0x40 ; read byte
398		398
399	pop eax	399	pop eax
400	; bl holds tftp opcode. Can only be 3 (data) or 5 ( error )	400	; bl holds tftp opcode. Can only be 3 (data) or 5 ( error )
401		401
402	cmp bl, 3	402	cmp bl, 3
403	jne cfrerr	403	jne cfrerr
404		404
405	push eax	405	push eax
406		406
407	; do data stuff. Read block #. Read data. Send Ack.	407	; do data stuff. Read block #. Read data. Send Ack.
408	mov eax, 53	408	mov eax, 53
409	mov ebx, 3	409	mov ebx, 3
410	mov ecx, [socketNum]	410	mov ecx, [socketNum]
411	int 0x40 ; read byte	411	int 0x40 ; read byte
412		412
413	mov [blockNumber], bl	413	mov [blockNumber], bl
414		414
415	mov eax, 53	415	mov eax, 53
416	mov ebx, 3	416	mov ebx, 3
417	mov ecx, [socketNum]	417	mov ecx, [socketNum]
418	int 0x40 ; read byte	418	int 0x40 ; read byte
419		419
420	mov [blockNumber+1], bl	420	mov [blockNumber+1], bl
421		421
422	cfr007:	422	cfr007:
423		423
424	mov eax, 53	424	mov eax, 53
425	mov ebx, 2	425	mov ebx, 2
426	mov ecx, [socketNum]	426	mov ecx, [socketNum]
427	mcall ; any more data?	427	mcall ; any more data?
428		428
429	cmp eax, 0	429	cmp eax, 0
430	je no_more_data ; no	430	je no_more_data ; no
431		431
432	mov eax, 53	432	mov eax, 53
433	mov ebx, 3	433	mov ebx, 3
434	mov ecx, [socketNum]	434	mov ecx, [socketNum]
435	mcall ; read byte	435	mcall ; read byte
436		436
437	mov esi, [fileposition]	437	mov esi, [fileposition]
438	mov [esi], bl	438	mov [esi], bl
439	inc dword [fileposition]	439	inc dword [fileposition]
440	inc dword [filesize]	440	inc dword [filesize]
441		441
442	jmp cfr007	442	jmp cfr007
443		443
444	no_more_data:	444	no_more_data:
445		445
446	; write the block number into the ack	446	; write the block number into the ack
447	mov al, [blockNumber]	447	mov al, [blockNumber]
448	mov [ack + 2], al	448	mov [ack + 2], al
449		449
450	mov al, [blockNumber+1]	450	mov al, [blockNumber+1]
451	mov [ack + 3], al	451	mov [ack + 3], al
452		452
453	; send an 'ack'	453	; send an 'ack'
454	mov eax, 53	454	mov eax, 53
455	mov ebx, 4	455	mov ebx, 4
456	mov ecx, [socketNum]	456	mov ecx, [socketNum]
457	mov edx, ackLen - ack	457	mov edx, ackLen - ack
458	mov esi, ack	458	mov esi, ack
459	int 0x40	459	int 0x40
460		460
461	; If # of chars in the frame is less that 516,	461	; If # of chars in the frame is less that 516,
462	; this frame is the last	462	; this frame is the last
463	pop eax	463	pop eax
464	cmp eax, 516	464	cmp eax, 516
465	je cfr002	465	je cfr002
466		466
467	; Write the file	467	; Write the file
468	mov eax, 33	468	mov eax, 33
469	mov ebx, source	469	mov ebx, source
470	mov edx, [filesize]	470	mov edx, [filesize]
471	mov ecx, I_END + 512	471	mov ecx, I_END + 512
472	mov esi, 0	472	mov esi, 0
473	mcall	473	mcall
474		474
475	jmp cfrexit	475	jmp cfrexit
476		476
477	cfrerr:	477	cfrerr:
478	; simple implementation on error - just read all data, and return	478	; simple implementation on error - just read all data, and return
479	mov eax, 53	479	mov eax, 53
480	mov ebx, 3	480	mov ebx, 3
481	mov ecx, [socketNum]	481	mov ecx, [socketNum]
482	int 0x40 ; read byte	482	int 0x40 ; read byte
483		483
484	mov eax, 53	484	mov eax, 53
485	mov ebx, 2	485	mov ebx, 2
486	mov ecx, [socketNum]	486	mov ecx, [socketNum]
487	int 0x40 ; any more data?	487	int 0x40 ; any more data?
488		488
489	cmp eax, 0	489	cmp eax, 0
490	jne cfrerr ; yes, so get it	490	jne cfrerr ; yes, so get it
491		491
492	jmp cfr006 ; close socket and close app	492	jmp cfr006 ; close socket and close app
493		493
494	cfr003: ; redraw request	494	cfr003: ; redraw request
495	call draw_window	495	call draw_window
496	jmp cfr002	496	jmp cfr002
497		497
498	cfr004: ; key pressed	498	cfr004: ; key pressed
499	mov eax,2 ; just read it and ignore	499	mov eax,2 ; just read it and ignore
500	mcall	500	mcall

Subversion Repositories Kolibri OS

(root)/programs/network/tftpc/trunk/tftpc.asm @ 1017 – Rev 485 → 551