Subversion Repositories Kolibri OS

        stack           rb 0

        home_dir        rb 1024

        fpath           rb 1024*3

        type            db ?    ; ASCII/EBDIC/IMAGE/..

        socketnum       dd ?    ; Commands socket

        state           dd ?    ; disconnected/logging in/logged in/..

        passivesocknum  dd ?    ; when in passive mode, this is the listening socket

        datasocketnum   dd ?    ; socket used for data transfers

        datasock        sockaddr_in

        buffer          rb BUFFERSIZE

        cmp     byte [esi], 0x20        ; skip all leading characters

        inc     esi

        dec     ecx

        cmp     ecx, 3

        ja      parse_cmd

        ret

  .ok:

        cmp     byte [esi+3], 0x20

        mov     byte [esi+3], 0

       @@:

        mov     eax, [esi]

        mov     edi, commands           ; list of commands to scan

  .scanloop:

        cmp     eax, [edi]

        jne     .try_next

        jmp     dword [edi+4]

  .try_next:

        cmp     byte [edi], 0

        jne     .scanloop

  .error:

        ret

        db 'ABOR'

        db 'CDUP'

        dd cmdCDUP

        db 'CWD', 0

        dd cmdCWD

        db 'DELE'

        dd cmdDELE

        db 'LIST'

        dd cmdLIST

        db 'NLST'

        dd cmdNLST

        db 'NOOP'

        dd cmdNOOP

        db 'PASS'

        dd cmdPASS

        db 'PASV'

        dd cmdPASV

        db 'PWD', 0

        dd cmdPWD

        db 'PORT'

        dd cmdPORT

        db 'QUIT'

        dd cmdQUIT

        db 'RETR'

        dd cmdRETR

        db 'STOR'

        dd cmdSTOR

        db 'SYST'

        dd cmdSYST

        db 'TYPE'

        dd cmdTYPE

        db 'USER'

        dd cmdUSER

        db 'XPWD'

        dd cmdPWD

        db 0            ; end marker

        ; TODO: abort the current filetransfer

        ret

align 4

        cmp     byte [edx + thread_data.work_dir+1], 0

        mov     ecx, 1024

        lea     edi, [edx + thread_data.work_dir+1024]

        repne   scasb

        std

        dec     edi

        mov     al,'/'

        scasb

        cld

        mov     byte[edi], 0

  .done:

        ret

align 4

        sub     ecx, 4

        add     esi, 4

  .scan:

        push    ecx

        mov     ecx, 1024

  .find_zero:

        cmp     byte [edi], 0

        je      .found_zero

        inc     edi

        loop    .find_zero

  .found_zero:

        pop     ecx

  .scan2:

        cmp     byte [esi], '/'

        inc     esi

        dec     ecx

        jz      .done

       @@:

  .loop:

        cmp     al, 0x20

        jb      .done

        cmp     al, '.'

        je      .up

  .continue:

        stosb

        loop    .loop

  .done:

        cmp     byte [edi-1], '/'

        je      @f

        mov     byte [edi], '/'

        inc     edi

       @@:

        mov     byte [edi], 0

        mcall   send, [edx + thread_data.socketnum], str250, str250.length, 0

        ret

  .up:

        cmp     al, '.'

        jne     .continue

;;;;        TODO: find second last '\' in work_dir and make next char zero

        jmp     .scan2

  .err:

        ret

align 4

        ret

align 4

; If we are in active mode, it's time to open a data socket..

        jne     @f

        mov     ecx, [edx + thread_data.datasocketnum]

        lea     edx, [edx + thread_data.datasock]

        mov     esi, sizeof.thread_data.datasock

        mcall   connect

        mov     edx, [esp+4]                                    ; thread_data pointer

        cmp     eax, -1

        je      socketerror

  @@:

; Create fpath from home_dir and work_dir

        lea     eax, [edx + thread_data.fpath]

        call    [con_write_asciiz]

        push    str_newline

        call    [con_write_asciiz]

; Start the search

        push    str_mask

        lea     eax, [edx + thread_data.fpath]

        push    eax

        call    [file.find.first]

        test    eax, eax

        lea     edi, [edx + thread_data.buffer]

        test    eax, eax        ; did we find a file?

        mov     ebx, eax        ; yes, save the descripter in ebx

; first, convert the attributes

        jnz     .folder

        test    [ebx + FileInfoA.Attributes], FA_READONLY

        mov     eax, '-rw-'

        jmp     .attr

  .folder:

        stosd

        jmp     .attr

  .readonly:

        stosd

  .attr:

        stosd

        mov     ax, 'w-'

        stosw

        mov     al, ' '

        stosb

; now..

        stosw

; now write owner, everything is owned by FTP, woohoo!

        stosd

        stosd

; now the filesize in ascii

        call    dword_to_ascii

        mov     al, ' '

; then date (month/day/year)

        mov     eax, [months + 4*eax]

        stosd

        movzx   eax, [ebx + FileInfoA.DateModify + FileDateTime.day]

        mov     al, ' '

        movzx   eax, [ebx + FileInfoA.DateModify + FileDateTime.year]

        mov     al, ' '

; and last but not least, filename

        mov     ecx, 264

  .nameloop:

        lodsb

        test    al, al

        jz      .namedone

        stosb

        loop    .nameloop

; insert a cr lf

        mov     ax, 0x0a0d

        stosw

; check next file

        call    [file.find.next]

        jmp     .parse_file

; close file desc

        push    ebx

        call    [file.find.close]

; append the string with a 0

        stosb

; Warn the client we're about to send the data

        mcall   send, [edx + thread_data.socketnum], str150, str150.length, 0    ; here it comes..

        pop     edx esi

; and send it to the client

        lea     edx, [edx + thread_data.buffer]

        sub     esi, edx

        xor     edi, edi

        mcall   send

; close the data socket..

        mcall   close, [edx + thread_data.datasocketnum]

        cmp     [edx + thread_data.mode], MODE_PASSIVE_OK

        mov     [edx + thread_data.mode], MODE_NOTREADY

      @@:

; And send "transfer ok" on the base connection

        ret

  .nosuchdir:

        ret

        ; TODO: same as list but simpler output format

        ret

align 4

        ret

align 4

        ; TODO: verify password

        mcall   send, [edx + thread_data.socketnum], str230, str230.length, 0

        push    str_pass_ok

        mov     edx, [esp+4]                                    ; thread_data pointer

        ret

align 4

; Open a new TCP socket

        mov     edx, [esp+4]                                    ; thread_data pointer

        cmp     eax, -1

        je      socketerror

        mov     [edx + thread_data.passivesocknum], eax

; Bind it to a known local port

        mov     [edx + thread_data.datasock.sin_port], 2000

        mov     [edx + thread_data.datasock.sin_addr], 0

        mov     ecx, eax ;[edx + thread_data.passivesocknum]

        mov     esi, sizeof.thread_data.datasock

        mcall   bind

        mov     edx, [esp+4]                                    ; thread_data pointer

        cmp     eax, -1

        je      bind_err

; And set it to listen!

; Tell our thread we are ready to accept incoming calls

        mov     [edx + thread_data.mode], MODE_PASSIVE_WAIT

; Now tell the client where to connect to in this format:

; where a1.a2.a3.a4 is the IP address and p1*256+p2 is the port number.

        lea     edi, [edx + thread_data.buffer]

        mov     eax, '227 '     ; FIXME (now hardcoded to 127.0.0.1:2000)

        stosd

        mov     eax, '(127'

        stosd

        mov     eax, ',0,0'

        stosd

        mov     eax, ',1,7'

        stosd

        mov     eax, ',208'

        stosd

        mov     al, ')'

        stosb

        mov     ax, 0x0a0d

        stosw

        xor     al, al

        stosb

        lea     esi, [edi - thread_data.buffer]

        mov     ecx, [edx + thread_data.socketnum]

        lea     edx, [edx + thread_data.buffer]

        xor     esi, esi

        mcall   send

        ret

align 4

        mov     dword [edx + thread_data.buffer], '257 '

        lea     edi, [edx + thread_data.buffer+5]

        mov     ecx, 1024

  .loop:

        lodsb

        or      al, al

        jz      .ok

        stosb

        dec     ecx

        jnz     .loop

  .ok:

        lea     esi, [edi - thread_data.buffer + 4]

        sub     esi, edx

        mov     ecx, [edx + thread_data.socketnum]

        lea     edx, [edx + thread_data.buffer]

        mcall   send, , , , 0

;        push    work_dir

;        call    [con_printf]

        ret

align 4

; PORT a1,a2,a3,a4,p1,p2

        mov     [edx + thread_data.mode], MODE_ACTIVE

        lea     esi, [esi+5]

        call    ascii_to_byte

        mov     bl, al

        inc     esi             ; skip past ','

        call    ascii_to_byte

        mov     bh, al

        shl     ebx, 16

        inc     esi

        call    ascii_to_byte

        mov     bl, al

        inc     esi

        call    ascii_to_byte

        mov     bh, al

        inc     esi

        rol     ebx, 16

; And put it in datasock

; Now the same with portnumber

        mov     bh, al

        inc     esi

        call    ascii_to_byte

        mov     bl, al

; Save it in datasock too

; We will open the socket, but do not connect yet!

        mcall   socket, AF_INET4, SOCK_STREAM, 0

        mov     edx, [esp+4]                                    ; thread_data pointer

        cmp     eax, -1

        je      socketerror

        mov     [edx + thread_data.datasocketnum], eax

; Tell the client we are ready

        mcall   send, [edx + thread_data.socketnum], str225, str225.length, 0

        ret

        mcall   close, [edx + thread_data.datasocketnum]

        mcall   close;, [edx + thread_data.socketnum]

        add     esp, 4          ; get rid of call return address

align 4

        sub     ecx, 5

        cmp     [edx + thread_data.mode], MODE_ACTIVE

        push    esi

        mov     ecx, [edx + thread_data.datasocketnum]

        lea     edx, [edx + thread_data.datasock]

        mov     esi, sizeof.thread_data.datasock

        mcall   connect

        pop     esi

        mov     edx, [esp+4]                                    ; thread_data pointer

        cmp     eax, -1

        je      socketerror

  @@:

        push    esi

        pop     esi

        dec     edi

        add     esi, 5

        mov     ecx, 1024

  .loop:

        lodsb

        cmp     al, 0x20

        jl      .done

        stosb

        loop    .loop

  .done:

        xor     al, al

        stosb

        lea     eax, [edx + thread_data.fpath]

        call    [con_write_asciiz]

        push    str_newline

        call    [con_write_asciiz]

        push    O_READ

        push    eax

        call    [file.open]

        test    eax, eax

        jz      .cannot_open

        push    eax

        pop     ebx

        mov     edx, [esp+4]                                    ; thread_data pointer

        push    BUFFERSIZE

        lea     eax, [edx + thread_data.buffer]

        push    eax

        push    ebx

        call    [file.read]

        cmp     eax, -1

        je      .cannot_open    ; fixme: this is not the correct error

        push    eax

        mov     esi, eax

        mov     ecx, [edx + thread_data.datasocketnum]

        lea     edx, [edx + thread_data.buffer]

        xor     esi, esi

        mcall   send

        pop     ebx

        pop     ecx

        mov     edx, [esp+4]                                    ; thread_data pointer

        cmp     eax, -1

        je      socketerror

        cmp     ecx, BUFFERSIZE

        mcall   close, [edx + thread_data.datasocketnum]

        cmp     [edx + thread_data.mode], MODE_PASSIVE_OK

        mov     [edx + thread_data.mode], MODE_PASSIVE_WAIT

      @@:

        mcall   send, [edx + thread_data.socketnum], str226, str226.length, 0    ; transfer ok

        ret

  .cannot_open:

        call    [con_set_flags]

        push    str_notfound

        call    [con_write_asciiz]

        pushd   0x07

        call    [con_set_flags]

        mcall   send, [edx + thread_data.socketnum], str550, str550.length, 0    ; file not found

        ret

align 4

        ; TODO: check if user has write permission, and write file if so

        ret

align 4

        mcall   send, [edx + thread_data.socketnum], str215, str215.length, 0

        ret

align 4

        cmp     ecx, 6

        mov     al, byte[esi+5]

        cmp     al, 'A'

        cmp     al, 'E'

        je      .ebdic

        cmp     al, 'I'

        je      .image

        cmp     al, 'L'

        je      .local

        jmp     parse_cmd.error

  .ascii:

        jmp     .subtype

  .ebdic:

  .subtype:

        cmp     ecx, 8

        mov     al, byte[esi+7]

        cmp     al, 'N'

        cmp     al, 'T'

        je      .telnet

        cmp     al, 'C'

        je      .asacc

        jmp     parse_cmd.error

  .non_print:

        jmp     .ok

  .telnet:

        jmp     .ok

  .asacc:

        jmp     .ok

  .image:

        jmp     .ok

  .local:

        jb      parse_cmd.error

        mov     al, byte[esi+7]

        jb      parse_cmd.error

        cmp     al, 9

        ja      parse_cmd.error

        or      al, TYPE_LOCAL

        mov     [edx + thread_data.type], al

  .ok:

        ret

align 4

        ; TODO: check user and set home directory (and permissions)

        mcall   send, [edx + thread_data.socketnum], str331, str331.length, 0

        mov     [edx + thread_data.state], STATE_LOGIN

        mov     byte [edx + thread_data.work_dir], "/"

        push    str_logged_in

        ret

        xor     eax, eax

  .loop:

        sub     bl, '0'

        jb      .done

        cmp     bl, 9

        ja      .done

        lea     eax, [eax*4 + eax]      ;

        shl     eax, 1                  ; eax = eax * 10

        add     eax, ebx

        inc     esi

        jmp     .loop

  .done:

        ret

align 4

        mov     eax, '1'

        ret

align 4

        lea     edi, [edx + thread_data.fpath]

        mov     ecx, 1024

  .loop1:

        lodsb

        or      al, al

        jz      .next

        stosb

        loop    .loop1

  .next:

        cmp     byte[edi-1], '/'

        dec     edi

       @@:

        lea     esi, [edx + thread_data.work_dir]

  .loop2:

        lodsb

        or      al, al

        jz      .done

        stosb

        loop    .loop2

  .done:

        ret

        pushd   0x0c

        push    str_sockerr

        call    [con_write_asciiz]

        pushd   0x07

        call    [con_set_flags]

        mcall   send, [edx + thread_data.socketnum], str425, str425.length, 0    ; data connection error

        ret

str200  db '200 Command OK.', 13, 10

.length = $ - str200

str215  db '215 UNIX type: L8', 13, 10

.length = $ - str215

str220  db '220 KolibriOS FTP Daemon 1.0', 13, 10

.length = $ - str220

str221  db '221 Bye!', 13, 10

.length = $ - str221

str225  db '225 Data connection open', 13, 10

.length = $ - str225

str226  db '226 Transfer OK, Closing connection', 13, 10

.length = $ - str226

str230  db '230 You are now logged in.', 13, 10

.length = $ - str230

str250  db '250 command successful', 13, 10

.length = $ - str250

str331  db '331 Please specify the password.', 13, 10

.length = $ - str331

str421  db '421 Timeout!', 13, 10

.length = $ - str421

str425  db '425 Cant open data connection.', 13, 10

.length = $ - str425

str500  db '500 Unsupported command', 13, 10

.length = $ - str500

str550  db '550 No such file', 13, 10

.length = $ - str550