WebSVN – Kolibri OS – Diff – /programs/network/downloader/downloader.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2009-2013. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  downloader.asm - HTTP client for KolibriOS                     ;;
;;                                                                 ;;
;;  Based on HTTPC.asm for menuetos by ville turjanmaa             ;;
;;                                                                 ;;
;;  Programmers: Barsuk, Clevermouse, Marat Zakiyanov,             ;;
;;      Kirill Lipatov, dunkaist, HidnPlayr                        ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
URLMAXLEN       = 1024
BUFFERSIZE      = 4096
 
__DEBUG__       = 1
__DEBUG_LEVEL__ = 1
 
format binary as ""
 
use32
        org     0x0
 
        db      'MENUET01'      ; header
        dd      0x01            ; header version
        dd      START           ; entry point
        dd      IM_END          ; image size
        dd      I_END+0x1000    ; required memory
        dd      I_END+0x1000    ; esp
        dd      params          ; I_PARAM
        dd      0x0             ; I_Path
 
include '../../macros.inc'
include '../../proc32.inc'
include '../../network.inc'
include '../../develop/libraries/box_lib/trunk/box_lib.mac'
include '../../dll.inc'
include '../../debug-fdo.inc'
 
START:
 
        mcall   68, 11                  ; init heap so we can allocate memory dynamically
 
; load libraries
        stdcall dll.Load, @IMPORT
        test    eax, eax
        jnz     exit
 
; prepare webAddr area
        mov     al, ' '
        mov     edi, webAddr
        mov     ecx, URLMAXLEN
        rep     stosb
        xor     eax, eax
        stosb
 
; prepare document area 
        mov     al, '/'
        mov     edi, document
        stosb
        mov     al, ' '
        mov     ecx, URLMAXLEN-1
        rep     stosb
 
; load proxy settings
        invoke  ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr
        invoke  ini.get_int, inifile, sec_proxy, key_proxyport, 80
        mov     [proxyPort], eax
        invoke  ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser
        invoke  ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword
 
; check parameters
        cmp     byte[params], 0         ; no parameters ?
        je      reset_events            ; load the GUI
 
; we have an url, copy untill space or 0
        mov     esi, params
        mov     edi, document_user
        mov     ecx, 1024               ; max parameter size
        mov     [shared_name], 0
  .copy_param:
        lodsb
        test    al, al
        jz      .done
 
        cmp     al, ' '
        jz      .done_with_shared
 
        stosb
        dec     ecx
        jnz     .copy_param
        DEBUGF  2, "Invalid parameters\n"
        jmp     exit
 
  .done_with_shared:
        mov     [shared_name], esi
  .done:
        xor     al, al
        stosb
 
 
download:
 
        DEBUGF  1, "Starting download\n"
 
        call    parse_url
 
        cmp     [server_ip], 0
        je      dns_error
 
        call    open_socket
        call    send_request
 
        mcall   68, 12, BUFFERSIZE      ; create buffer, we'll resize it later if needed..
        mov     [buf_ptr], eax
        mov     [buf_size], 0
 
        call    read_incoming_data
 
        mcall   close, [socketnum]
 
        call    parse_result
        call    save
 
        mcall   68, 13, [final_buffer]  ; free buffer
 
dns_error:
        cmp     byte [params], 0
        jne     exit
 
reset_events:
 
        DEBUGF  1, "resetting events\n"
 
; Report events
; defaults + mouse
        mcall   40,EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER
 
redraw:
        call    draw_window
 
still:
        DEBUGF  1, "waiting for events\n"
 
        mcall   10      ; wait here for event
 
        cmp     eax, EV_REDRAW
        je      redraw
 
        cmp     eax, EV_KEY
        je      key
 
        cmp     eax, EV_BUTTON
        je      button
        
        cmp     eax, EV_MOUSE
        je      mouse
 
        jmp     still
 
key:
        mcall   2       ; read key
 
        stdcall [edit_box_key], dword edit1
 
        cmp     ax, 13 shl 8
        je      download
        
        jmp     still
        
button:
 
        mcall   17      ; get id
 
        cmp     ah, 26
        jne     @f
        call    save_to_file
        jmp     still
  @@:
        cmp     ah, 1   ; button id=1 ?
        je      exit
 
        jmp     download
 
mouse:
        stdcall [edit_box_mouse], edit1
        jmp     still
 
exit:
        DEBUGF  1, "Exiting\n"
        or      eax, -1 ; close this program
        mcall
 
 
save:
        cmp     [shared_name], 0
        je      .use_file
 
        call    save_in_shared
        jmp     .done
 
  .use_file:
 
        call    save_to_file
 
  .done:
 
; if called from command line, then exit
        cmp     byte[params], 0
        jne     exit
 
        mov     ecx, [sc.work_text]
        or      ecx, 0x80000000
        mcall   4, <10, 93>, , download_complete
 
        ret
 
save_in_shared:
 
; open the shared memory area
        mov     esi, 1
        mcall   68, 22, [shared_name], , 1 ; SHM_OPEN+SHM_WRITE
        test    eax, eax
        jz      exit
 
        mov     ecx, [final_size]
; store the size
        mov     [eax], ecx
 
; now copy the data
        lea     edi, [eax+4]
        mov     esi, [final_buffer]
        mov     eax, ecx
        shr     ecx, 2
        rep     movsd
        mov     ecx, eax
        and     ecx, 3
        rep     movsb
 
        ret
 
 
;****************************************************************************
;    Function
;       save_to_file
;
;   Description
;
;
;****************************************************************************
 
save_to_file:
 
        DEBUGF  2, "Saving to file\n"
        mcall   70, fileinfo
 
        ret
 
 
;****************************************************************************
;    Function
;       send_request
;
;   Description
;       Transmits the GET request to the server.
;       This is done as GET then URL then HTTP/1.1', 13, 10, 13, 10 in 3 packets
;
;****************************************************************************
send_request:
 
        DEBUGF  1, "Sending request\n"
 
        mov     esi, string0
        mov     edi, request
        movsd
; If proxy is used, make absolute URI - prepend http://
        cmp     byte[proxyAddr], 0
        jz      .noproxy
        mov     dword[edi], 'http'
        mov     byte[edi+4], ':'
        mov     word[edi+5], '//'
        add     edi, 7
        mov     esi, webAddr
 
  .copy_host_loop:
        lodsb
        cmp     al, ' '
        jz      .noproxy
        stosb
        jmp     .copy_host_loop
 
  .noproxy:
        xor     edx, edx ; 0
 
  .next_edx:
; Determine the length of the url to send in the GET request
        mov     al, [edx+document]
        cmp     al, ' '
        jbe     .document_done
        mov     [edi], al
        inc     edi
        inc     edx
        jmp     .next_edx
 
  .document_done:
        mov     esi, stringh
        mov     ecx, stringh_end-stringh
        rep     movsb
        xor     edx, edx ; 0
 
  .webaddr_next:
        mov     al, [webAddr + edx]
        cmp     al, ' '
        jbe     .webaddr_done
        mov     [edi], al
        inc     edi
        inc     edx
        jmp     .webaddr_next
 
  .webaddr_done:
        cmp     byte[proxyUser], 0
        jz      @f
        call    append_proxy_auth_header
    @@:
        mov     esi, connclose
        mov     ecx, connclose_end-connclose
        rep     movsb
 
        pusha   
        mov     eax, 63
        mov     ebx, 1
        mov     edx, request
    @@:
        mov     cl, [edx]
        cmp     edx, edi
        jz      @f
        mcall
        inc     edx
        jmp     @b
    @@:
        popa
 
        mov     esi, edi
        sub     esi, request    ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], request  ;' HTTP/1.1 .. '
 
        ret
 
;****************************************************************************
;    Function
;       read_incoming_data
;
;   Description
;       receive the web page from the server, storing it without processing
;
;****************************************************************************
read_incoming_data:
 
        DEBUGF  1, "Reading incoming data\n"
 
        mov     eax, [buf_ptr]
        mov     [pos], eax
  .read:
        mcall   recv, [socketnum], [pos], BUFFERSIZE, 0
        inc     eax             ; -1 = error (socket closed?)
        jz      .error
        dec     eax             ; 0 bytes means the remote end closed the connection
        jz      .no_more_data
 
 
 
        DEBUGF  1, "Got chunk of %u bytes\n", eax
 
        add     [buf_size], eax
        add     [pos], eax
        push    eax
        mov     ecx, [buf_size]
        add     ecx, BUFFERSIZE
        mcall   68, 20, , [buf_ptr]     ; reallocate memory block (make bigger)
        ; TODO: parse header and resize buffer only once
        pop     eax
        jmp     .read
 
  .error:
        DEBUGF  1, "Socket error: %u\n", ebx
        
  .no_more_data:
        mov     eax, [buf_ptr]
        sub     [pos], eax
 
        DEBUGF  1, "No more data\n"
 
        ret
        
 
        
; this function cuts header, and removes chunk sizes if doc is chunked
; in: buf_ptr, pos; out: buf_ptr, pos.
        
parse_result:
 
        mov     edi, [buf_ptr]
        mov     edx, [pos]
;        mov     [buf_size], edx
;       mcall   70, fileinfo_tmp
        DEBUGF  1, "Parsing result (%u bytes)\n", edx
 
; first, find end of headers
  .next_byte:
        cmp     dword[edi], 0x0a0d0a0d
        je      .end_of_headers
        inc     edi
        dec     edx
        ja      .next_byte
        DEBUGF  1, "Uh-oh, there's no end of header!\n"
; no end of headers. it's an error. let client see all those headers.
        ret
 
  .end_of_headers:
; here we look at headers and search content-length or transfer-encoding headers
        DEBUGF  1, "Found end of header\n"
 
        sub     edi, [buf_ptr]
        add     edi, 4
        mov     [body_pos], edi  ; store position where document body starts
        mov     [is_chunked], 0
; find content-length in headers
; not good method, but should work for 'Content-Length:'
        mov     esi, [buf_ptr]
        mov     edi, s_contentlength
        mov     ebx, [body_pos]
        xor     edx, edx ; 0
  .cl_next:
        mov     al, [esi]
        cmp     al, [edi + edx]
        jne     .cl_fail
        inc     edx
        cmp     edx, len_contentlength
        je      .cl_found
        jmp     .cl_incr
  .cl_fail:
        xor     edx, edx ; 0
  .cl_incr:
        inc     esi
        dec     ebx
        je      .cl_error
        jmp     .cl_next
  .cl_error:
        DEBUGF  1, "content-length not found\n"
 
; find 'chunked'
; äà, ÿ êîïèðóþ êîä, ýòî óæàñíî, íî ìíå õî÷åòñÿ, ÷òîáû ïîñêîðåå çàðàáîòàëî
; à òàì óæ îòðåôàêòîðþ
        mov     esi, [buf_ptr]
        mov     edi, s_chunked
        mov     ebx, [body_pos]
        xor     edx, edx ; 0
 
  .ch_next:
        mov     al, [esi]
        cmp     al, [edi + edx]
        jne     .ch_fail
        inc     edx
        cmp     edx, len_chunked
        je      .ch_found
        jmp     .ch_incr
 
  .ch_fail:
        xor     edx, edx ; 0
 
  .ch_incr:
        inc     esi
        dec     ebx
        je      .ch_error
        jmp     .ch_next
 
  .ch_error:
; if neither of the 2 headers is found, it's an error
;       DEBUGF  1, "transfer-encoding: chunked not found\n"
        mov     eax, [pos]
        sub     eax, [body_pos]
        jmp     .write_final_size
 
  .ch_found:
        mov     [is_chunked], 1
        mov     eax, [body_pos]
        add     eax, [buf_ptr]
        sub     eax, 2
        mov     [prev_chunk_end], eax
        jmp     parse_chunks
        
  .cl_found:
        call    read_number     ; eax = number from *esi
        DEBUGF  1, "Content length: %u\n", eax
 
  .write_final_size:
        
        mov     ebx, [buf_size]
        sub     ebx, [body_pos]
        cmp     eax, ebx
        jbe     .size_ok
        sub     eax, ebx
        DEBUGF  2, "%u bytes of data are missing!\n", eax
        mov     eax, ebx
  .size_ok:
        mov     [final_size], eax
 
        mov     ebx, [body_pos]
        add     ebx, [buf_ptr]
        mov     [final_buffer], ebx
 
        ret
        
parse_chunks:
        DEBUGF  1, "parse chunks\n"
        ; we have to look through the data and remove sizes of chunks we see
        ; 1. read size of next chunk
        ; 2. if 0, it's end. if not, continue.
        ; 3. make a good buffer and copy a chunk there
        xor     eax, eax
        mov     [final_buffer], eax      ; 0
        mov     [final_size], eax        ; 0
        
.read_size:
        mov     eax, [prev_chunk_end]
        mov     ebx, eax
        sub     ebx, [buf_ptr]
        mov     edx, eax
        DEBUGF  1, "rs "
        cmp     ebx, [pos]
        jae     chunks_end      ; not good
        
        call    read_hex        ; in: eax=pointer to text. out:eax=hex number, ebx=end of text.
        cmp     eax, 0
        jz      chunks_end
 
        add     ebx, 1
        mov     edx, ebx ; edx = size of size of chunk
        
        add     ebx, eax
        mov     [prev_chunk_end], ebx
        
        DEBUGF  1, "sz "
 
; do copying: from buf_ptr+edx to final_buffer+prev_final_size count eax
; realloc final buffer
        push    eax
        push    edx
        push    dword [final_size]
        add     [final_size], eax
        mcall   68, 20, [final_size], [final_buffer]
        mov     [final_buffer], eax
        DEBUGF  1, "re "
        pop     edi
        pop     esi
        pop     ecx
;       add     [pos], ecx
        add     edi, [final_buffer]
        DEBUGF  1, "cp "
 
        rep     movsb
        jmp     .read_size
        
chunks_end:
        DEBUGF  1, "chunks end\n"
        mcall   68, 13, [buf_ptr]       ; free old buffer
 
        ret
 
; reads content-length from [edi+ecx], result in eax
read_number:
        push    ebx
        xor     eax, eax
        xor     ebx, ebx
 
  .next:
        mov     bl, [esi]
 
        cmp     bl, '0'
        jb      .not_number
        cmp     bl, '9'
        ja      .not_number
        sub     bl, '0'
        shl     eax, 1
        lea     eax, [eax + eax * 4]     ; eax *= 10
        add     eax, ebx
 
  .not_number:
        cmp     bl, 13
        je      .done
        inc     esi
        jmp     .next
 
  .done:
        pop     ebx
        ret
        
; reads hex from eax, result in eax, end of text in ebx
read_hex:
        add     eax, 2
        mov     ebx, eax
        mov     eax, [ebx]
        mov     [deba], eax
 
        xor     eax, eax
        xor     ecx, ecx
  .next:
        mov     cl, [ebx]
        inc     ebx
        
        cmp     cl, 0x0d
        jz      .done
 
        or      cl, 0x20
        sub     cl, '0'
        jb      .bad
 
        cmp     cl, 0x9
        jbe     .adding
 
        sub     cl, 'a'-'0'-10
        cmp     cl, 0x0a
        jb      .bad
 
        cmp     cl, 0x0f
        ja      .bad
 
  .adding:
        shl     eax, 4
        or      eax, ecx
  .bad:
        jmp     .next
  .done:
 
        ret
 
;****************************************************************************
;    Function
;       open_socket
;
;   Description
;       opens the socket
;
;****************************************************************************
open_socket:
 
        DEBUGF  1, "opening socket\n"
 
        mov     edx, 80
        cmp     byte [proxyAddr], 0
        jz      @f
        mov     eax, [proxyPort]
        xchg    al, ah
        mov     [server_port], ax
    @@:
 
        mcall   socket, AF_INET4, SOCK_STREAM, 0
        mov     [socketnum], eax
        mcall   connect, [socketnum], sockaddr1, 18
 
        ret
 
 
;****************************************************************************
;    Function
;       parse_url
;
;   Description
;       parses the full url typed in by the user into a web address ( that
;       can be turned into an IP address by DNS ) and the page to display
;       DNS will be used to translate the web address into an IP address, if
;       needed.
;       url is at document_user and will be space terminated.
;       web address goes to webAddr and is space terminated.
;       ip address goes to server_ip
;       page goes to document and is space terminated.
;
;       Supported formats:
;       address
;        is optional, removed and ignored - only http supported
;        is required. It can be an ip address or web address
;        is optional and must start with a leading / character
;
;****************************************************************************
parse_url:
; First, reset destination variables
        mov     al, ' '
        mov     edi, document
        mov     ecx, URLMAXLEN
        rep     stosb
        mov     edi, webAddr
        mov     ecx, URLMAXLEN
        rep     stosb
 
        mov     al, '/'
        mov     [document], al
 
        mov     esi, document_user
; remove any leading protocol text
        mov     ecx, URLMAXLEN
        mov     ax, '//'
 
pu_000:
        cmp     [esi], byte ' '         ; end of text?
        je      pu_002                  ; yep, so not found
        cmp     [esi], ax
        je      pu_001                  ; Found it, so esi+2 is start
        inc     esi
        loop    pu_000
 
pu_002:
; not found, so reset esi to start
        mov     esi, document_user-2
 
pu_001:
        add     esi, 2
        mov     ebx, esi ; save address of start of web address
        mov     edi, document_user + URLMAXLEN   ; end of string
; look for page delimiter - it's a '/' character
pu_003:
        cmp     [esi], byte ' '  ; end of text?
        je      pu_004          ; yep, so none found
        cmp     esi, edi         ; end of string?
        je      pu_004          ; yep, so none found
        cmp     [esi], byte '/'  ; delimiter?
        je      pu_005          ; yep - process it
        inc     esi
        jmp     pu_003
 
pu_005:
; copy page to document address
; esi = delimiter
        push    esi
        mov     ecx, edi         ; end of document_user
        mov     edi, document
 
pu_006:
        movsb
        cmp     esi, ecx
        je      pu_007          ; end of string?
        cmp     [esi], byte ' '  ; end of text
;       je      pu_007          ; äçåí-àññåìáëåð
;       jmp     pu_006          ; íå íàäî ïëîäèòü ñóùíîñòè ïî íàïðàñíó
        jne     pu_006
 
pu_007:
        pop     esi     ; point esi to '/' delimiter
 
pu_004:
; copy web address to webAddr
; start in ebx, end in esi-1
        mov     ecx, esi
        mov     esi, ebx
        mov     edi, webAddr
  @@:
        movsb
        cmp     esi, ecx
        jne     @r
        mov     byte [edi], 0
 
pu_009:
; For debugging, display resulting strings
        DEBUGF  2, "Downloadng %s\n", document_user
 
; Look up the ip address, or was it specified?
        mov     al, [proxyAddr]
        cmp     al, 0
        jnz     pu_015
        mov     al, [webAddr]
pu_015:
        cmp     al, '0'
        jb      pu_010  ; Resolve address
        cmp     al, '9'
        ja      pu_010  ; Resolve address
 
        DEBUGF  1, "GotIP\n"
 
; Convert address
; If proxy is given, get proxy address instead of server
        mov     esi, proxyAddr-1
        cmp     byte[esi+1], 0
        jne     pu_020
        mov     esi, webAddr-1
 
pu_020:
        mov     edi, server_ip
        xor     eax, eax
 
ip1:
        inc     esi
        cmp     [esi], byte '0'
        jb      ip2
        cmp     [esi], byte '9'
        ja      ip2
        imul    eax, 10
        movzx   ebx, byte [esi]
        sub     ebx, 48
        add     eax, ebx
        jmp     ip1
 
ip2:
        mov     [edi], al
        xor     eax, eax
        inc     edi
        cmp     edi, server_ip+3
        jbe     ip1
 
        ret
 
pu_010:
        DEBUGF  1, "Resolving %s\n", webAddr
 
; resolve name
        push    esp     ; reserve stack place
        push    esp     ; fourth parameter
        push    0       ; third parameter
        push    0       ; second parameter
        push    webAddr
        call    [getaddrinfo]
        pop     esi
; TODO: handle error
;        test    eax, eax
;        jnz     .fail_dns
 
; fill in ip
        mov     eax, [esi + addrinfo.ai_addr]
        mov     eax, [eax + sockaddr_in.sin_addr]
        mov     [server_ip], eax
 
; free allocated memory
        push    esi
        call    [freeaddrinfo]
 
        DEBUGF  1, "Resolved to %u.%u.%u.%u\n", [server_ip]:1, [server_ip + 1]:1, [server_ip + 2]:1, [server_ip + 3]:1
 
        ret
 
;***************************************************************************
;   Function
;       append_proxy_auth_header
;
;   Description
;       Append header to HTTP request for proxy authentification
;
;***************************************************************************
append_proxy_auth_header:
        mov     esi, proxy_auth_basic
        mov     ecx, proxy_auth_basic_end - proxy_auth_basic
        rep     movsb
; base64-encode string :
        mov     esi, proxyUser
 
apah000:
        lodsb
        test    al, al
        jz      apah001
        call    encode_base64_byte
        jmp     apah000
 
apah001:
        mov     al, ':'
        call    encode_base64_byte
        mov     esi, proxyPassword
 
apah002:
        lodsb
        test    al, al
        jz      apah003
        call    encode_base64_byte
        jmp     apah002
 
apah003:
        call    encode_base64_final
        ret
 
encode_base64_byte:
        inc     ecx
        shl     edx, 8
        mov     dl, al
        cmp     ecx, 3
        je      ebb001
        ret
 
ebb001:
        shl     edx, 8
        inc     ecx
 
ebb002:
        rol     edx, 6
        xor     eax, eax
        xchg    al, dl
        mov     al, [base64_table+eax]
        stosb
        loop    ebb002
        ret
 
encode_base64_final:
        mov     al, 0
        test    ecx, ecx
        jz      ebf000
        call    encode_base64_byte
        test    ecx, ecx
        jz      ebf001
        call    encode_base64_byte
        mov     byte [edi-2], '='
 
ebf001:
        mov     byte [edi-1], '='
 
ebf000:
        ret
 
;   *********************************************
;   *******  WINDOW DEFINITIONS AND DRAW ********
;   *********************************************
 
draw_window:
 
        mcall   12, 1
 
        mcall   48, 3, sc, 40 ;get system colors
 
        mov     edx, [sc.work]
        or      edx, 0x34000000
        mcall   0, <50, 370>, <350, 140>, , 0, title   ;draw window
        
        mov     ecx, [sc.work_text]
        or      ecx, 80000000h
        mcall   4, <14, 14>, , type_pls ;"URL:"
 
        edit_boxes_set_sys_color edit1, editboxes_end, sc
        stdcall [edit_box_draw], edit1
 
; RELOAD
        mcall   8, <90, 68>, <54, 16>, 22, [sc.work_button]
; STOP
        mcall   , <166, 50>, <54, 16>, 24
; SAVE
        mcall   , <224, 54>, , 26
; BUTTON TEXT
        mov     ecx, [sc.work_button_text]
        or      ecx, 80000000h
        mcall   4, <102, 59>, , button_text
 
        mcall   12, 2 ; end window redraw
 
        ret
 
 
;-----------------------------------------------------------------------------
; Data area
;-----------------------------------------------------------------------------
align   4
@IMPORT:
 
library libini, 'libini.obj', \
        box_lib, 'box_lib.obj', \
        network, 'network.obj'
 
import  libini, \
        ini.get_str, 'ini_get_str', \
        ini.get_int, 'ini_get_int'
 
import  box_lib, \
        edit_box_draw, 'edit_box', \
        edit_box_key, 'edit_box_key', \
        edit_box_mouse, 'edit_box_mouse'
 
import  network,\
        getaddrinfo,    'getaddrinfo',\
        freeaddrinfo,   'freeaddrinfo',\
        inet_ntoa,      'inet_ntoa'
 
;---------------------------------------------------------------------
fileinfo        dd 2, 0, 0
final_size      dd 0
final_buffer    dd 0
                db '/rd/1/.download', 0
        
body_pos        dd 0
buf_size        dd 0
buf_ptr         dd 0
 
deba            dd 0
                db 0
 
;---------------------------------------------------------------------
 
mouse_dd        dd 0
edit1           edit_box 295, 48, 10, 0xffffff, 0xff, 0x80ff, 0, 0x8000, URLMAXLEN, document_user, mouse_dd, ed_focus+ed_always_focus, 7, 7
editboxes_end:
 
;---------------------------------------------------------------------
 
include_debug_strings
 
;---------------------------------------------------------------------
 
type_pls        db 'URL:', 0
button_text     db 'DOWNLOAD     STOP     RESAVE', 0
download_complete db 'File saved as /rd/1/.download', 0
title           db 'HTTP Downloader', 0
 
;---------------------------------------------------------------------
s_contentlength db 'Content-Length:'
len_contentlength = 15
 
s_chunked       db 'Transfer-Encoding: chunked'
len_chunked     = $ - s_chunked
 
string0:        db 'GET '
 
stringh                 db ' HTTP/1.1', 13, 10, 'Host: '
stringh_end:
proxy_auth_basic        db 13, 10, 'Proxy-Authorization: Basic '
proxy_auth_basic_end:
connclose               db 13, 10, 'User-Agent: Kolibrios Downloader', 13, 10, 'Connection: Close', 13, 10, 13, 10
connclose_end:
 
base64_table    db 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
                db '0123456789+/'
 
inifile         db '/sys/settings/network.ini', 0
 
sec_proxy:
key_proxy       db 'proxy', 0
key_proxyport   db 'port', 0
key_user        db 'user', 0
key_password    db 'password', 0
 
sockaddr1:
                dw AF_INET4
server_port     dw 0x5000       ; 80
server_ip       dd 0
                rb 10
 
proxyPort       dd 80
 
shared_name     dd 0
 
;---------------------------------------------------------------------
document_user   db 'http://', 0
;---------------------------------------------------------------------
IM_END:
;---------------------------------------------------------------------
                rb URLMAXLEN-(IM_END - document_user)
;---------------------------------------------------------------------
                sc system_colors
;---------------------------------------------------------------------
align 4
document        rb URLMAXLEN
;---------------------------------------------------------------------
align 4
webAddr         rb URLMAXLEN+1
;---------------------------------------------------------------------
pos             dd ?
socketnum       dd ?
is_chunked      dd ?
prev_chunk_end  dd ?
cur_chunk_size  dd ?
;---------------------------------------------------------------------
 
params          rb 1024
 
request         rb 256
 
proxyAddr       rb 256
proxyUser       rb 256
proxyPassword   rb 256
 
I_END:

Rev 4101	Rev 4345
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2009-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2009-2013. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; downloader.asm - HTTP client for KolibriOS ;;	6	;; downloader.asm - HTTP client for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Based on HTTPC.asm for menuetos by ville turjanmaa ;;	8	;; Based on HTTPC.asm for menuetos by ville turjanmaa ;;
9	;; ;;	9	;; ;;
10	;; Programmers: Barsuk, Clevermouse, Marat Zakiyanov, ;;	10	;; Programmers: Barsuk, Clevermouse, Marat Zakiyanov, ;;
11	;; Kirill Lipatov, dunkaist, HidnPlayr ;;	11	;; Kirill Lipatov, dunkaist, HidnPlayr ;;
12	;; ;;	12	;; ;;
13	;; GNU GENERAL PUBLIC LICENSE ;;	13	;; GNU GENERAL PUBLIC LICENSE ;;
14	;; Version 2, June 1991 ;;	14	;; Version 2, June 1991 ;;
15	;; ;;	15	;; ;;
16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
17		17
18	URLMAXLEN = 1024	18	URLMAXLEN = 1024
19	BUFFERSIZE = 4096	19	BUFFERSIZE = 4096
20		20
21	__DEBUG__ = 1	21	__DEBUG__ = 1
22	__DEBUG_LEVEL__ = 1	22	__DEBUG_LEVEL__ = 1
23		23
24	format binary as ""	24	format binary as ""
25		25
26	use32	26	use32
27	org 0x0	27	org 0x0
28		28
29	db 'MENUET01' ; header	29	db 'MENUET01' ; header
30	dd 0x01 ; header version	30	dd 0x01 ; header version
31	dd START ; entry point	31	dd START ; entry point
32	dd IM_END ; image size	32	dd IM_END ; image size
33	dd I_END+0x1000 ; required memory	33	dd I_END+0x1000 ; required memory
34	dd I_END+0x1000 ; esp	34	dd I_END+0x1000 ; esp
35	dd params ; I_PARAM	35	dd params ; I_PARAM
36	dd 0x0 ; I_Path	36	dd 0x0 ; I_Path
37		37
38	include '../../macros.inc'	38	include '../../macros.inc'
39	include '../../proc32.inc'	39	include '../../proc32.inc'
40	include '../../network.inc'	40	include '../../network.inc'
41	include '../../develop/libraries/box_lib/trunk/box_lib.mac'	41	include '../../develop/libraries/box_lib/trunk/box_lib.mac'
42	include '../../dll.inc'	42	include '../../dll.inc'
43	include '../../debug-fdo.inc'	43	include '../../debug-fdo.inc'
44		44
45	START:	45	START:
46		46
47	mcall 68, 11 ; init heap so we can allocate memory dynamically	47	mcall 68, 11 ; init heap so we can allocate memory dynamically
48		48
49	; load libraries	49	; load libraries
50	stdcall dll.Load, @IMPORT	50	stdcall dll.Load, @IMPORT
51	test eax, eax	51	test eax, eax
52	jnz exit	52	jnz exit
53		53
54	; prepare webAddr area	54	; prepare webAddr area
55	mov al, ' '	55	mov al, ' '
56	mov edi, webAddr	56	mov edi, webAddr
57	mov ecx, URLMAXLEN	57	mov ecx, URLMAXLEN
58	rep stosb	58	rep stosb
59	xor eax, eax	59	xor eax, eax
60	stosb	60	stosb
61		61
62	; prepare document area	62	; prepare document area
63	mov al, '/'	63	mov al, '/'
64	mov edi, document	64	mov edi, document
65	stosb	65	stosb
66	mov al, ' '	66	mov al, ' '
67	mov ecx, URLMAXLEN-1	67	mov ecx, URLMAXLEN-1
68	rep stosb	68	rep stosb
69		69
70	; load proxy settings	70	; load proxy settings
71	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr	71	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr
72	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80	72	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80
73	mov [proxyPort], eax	73	mov [proxyPort], eax
74	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser	74	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser
75	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword	75	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword
76		76
77	; check parameters	77	; check parameters
78	cmp byte[params], 0 ; no parameters ?	78	cmp byte[params], 0 ; no parameters ?
79	je reset_events ; load the GUI	79	je reset_events ; load the GUI
80		80
81	; we have an url, copy untill space or 0	81	; we have an url, copy untill space or 0
82	mov esi, params	82	mov esi, params
83	mov edi, document_user	83	mov edi, document_user
84	mov ecx, 1024 ; max parameter size	84	mov ecx, 1024 ; max parameter size
85	mov [shared_name], 0	85	mov [shared_name], 0
86	.copy_param:	86	.copy_param:
87	lodsb	87	lodsb
88	test al, al	88	test al, al
89	jz .done	89	jz .done
90		90
91	cmp al, ' '	91	cmp al, ' '
92	jz .done_with_shared	92	jz .done_with_shared
93		93
94	stosb	94	stosb
95	dec ecx	95	dec ecx
96	jnz .copy_param	96	jnz .copy_param
97	DEBUGF 2, "Invalid parameters\n"	97	DEBUGF 2, "Invalid parameters\n"
98	jmp exit	98	jmp exit
99		99
100	.done_with_shared:	100	.done_with_shared:
101	mov [shared_name], esi	101	mov [shared_name], esi
102	.done:	102	.done:
103	xor al, al	103	xor al, al
104	stosb	104	stosb
105		105
106		106
107	download:	107	download:
108		108
109	DEBUGF 1, "Starting download\n"	109	DEBUGF 1, "Starting download\n"
110		110
111	call parse_url	111	call parse_url
112		112
113	cmp [server_ip], 0	113	cmp [server_ip], 0
114	je dns_error	114	je dns_error
115		115
116	call open_socket	116	call open_socket
117	call send_request	117	call send_request
118		118
119	mcall 68, 12, BUFFERSIZE ; create buffer, we'll resize it later if needed..	119	mcall 68, 12, BUFFERSIZE ; create buffer, we'll resize it later if needed..
120	mov [buf_ptr], eax	120	mov [buf_ptr], eax
121	mov [buf_size], 0	121	mov [buf_size], 0
122		122
123	call read_incoming_data	123	call read_incoming_data
124		124
125	mcall close, [socketnum]	125	mcall close, [socketnum]
126		126
127	call parse_result	127	call parse_result
128	call save	128	call save
129		129
130	mcall 68, 13, [final_buffer] ; free buffer	130	mcall 68, 13, [final_buffer] ; free buffer
131		131
132	dns_error:	132	dns_error:
133	cmp byte [params], 0	133	cmp byte [params], 0
134	jne exit	134	jne exit
135		135
136	reset_events:	136	reset_events:
137		137
138	DEBUGF 1, "resetting events\n"	138	DEBUGF 1, "resetting events\n"
139		139
140	; Report events	140	; Report events
141	; defaults + mouse	141	; defaults + mouse
142	mcall 40,EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER	142	mcall 40,EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER
143		143
144	redraw:	144	redraw:
145	call draw_window	145	call draw_window
146		146
147	still:	147	still:
148	DEBUGF 1, "waiting for events\n"	148	DEBUGF 1, "waiting for events\n"
149		149
150	mcall 10 ; wait here for event	150	mcall 10 ; wait here for event
151		151
152	cmp eax, EV_REDRAW	152	cmp eax, EV_REDRAW
153	je redraw	153	je redraw
154		154
155	cmp eax, EV_KEY	155	cmp eax, EV_KEY
156	je key	156	je key
157		157
158	cmp eax, EV_BUTTON	158	cmp eax, EV_BUTTON
159	je button	159	je button
160		160
161	cmp eax, EV_MOUSE	161	cmp eax, EV_MOUSE
162	je mouse	162	je mouse
163		163
164	jmp still	164	jmp still
165		165
166	key:	166	key:
167	mcall 2 ; read key	167	mcall 2 ; read key
168		168
169	stdcall [edit_box_key], dword edit1	169	stdcall [edit_box_key], dword edit1
170		170
171	cmp ax, 13 shl 8	171	cmp ax, 13 shl 8
172	je download	172	je download
173		173
174	jmp still	174	jmp still
175		175
176	button:	176	button:
177		177
178	mcall 17 ; get id	178	mcall 17 ; get id
179		179
180	cmp ah, 26	180	cmp ah, 26
181	jne @f	181	jne @f
182	call save_to_file	182	call save_to_file
183	jmp still	183	jmp still
184	@@:	184	@@:
185	cmp ah, 1 ; button id=1 ?	185	cmp ah, 1 ; button id=1 ?
186	je exit	186	je exit
187		187
188	jmp download	188	jmp download
189		189
190	mouse:	190	mouse:
191	stdcall [edit_box_mouse], edit1	191	stdcall [edit_box_mouse], edit1
192	jmp still	192	jmp still
193		193
194	exit:	194	exit:
195	DEBUGF 1, "Exiting\n"	195	DEBUGF 1, "Exiting\n"
196	or eax, -1 ; close this program	196	or eax, -1 ; close this program
197	mcall	197	mcall
198		198
199		199
200	save:	200	save:
201	cmp [shared_name], 0	201	cmp [shared_name], 0
202	je .use_file	202	je .use_file
203		203
204	call save_in_shared	204	call save_in_shared
205	jmp .done	205	jmp .done
206		206
207	.use_file:	207	.use_file:
208		208
209	call save_to_file	209	call save_to_file
210		210
211	.done:	211	.done:
212		212
213	; if called from command line, then exit	213	; if called from command line, then exit
214	cmp byte[params], 0	214	cmp byte[params], 0
215	jne exit	215	jne exit
216		216
217	mov ecx, [sc.work_text]	217	mov ecx, [sc.work_text]
218	or ecx, 0x80000000	218	or ecx, 0x80000000
219	mcall 4, <10, 93>, , download_complete	219	mcall 4, <10, 93>, , download_complete
220		220
221	ret	221	ret
222		222
223	save_in_shared:	223	save_in_shared:
224		224
225	; open the shared memory area	225	; open the shared memory area
226	mov esi, 1	226	mov esi, 1
227	mcall 68, 22, [shared_name], , 1 ; SHM_OPEN+SHM_WRITE	227	mcall 68, 22, [shared_name], , 1 ; SHM_OPEN+SHM_WRITE
228	test eax, eax	228	test eax, eax
229	jz exit	229	jz exit
230		230
231	mov ecx, [final_size]	231	mov ecx, [final_size]
232	; store the size	232	; store the size
233	mov [eax], ecx	233	mov [eax], ecx
234		234
235	; now copy the data	235	; now copy the data
236	lea edi, [eax+4]	236	lea edi, [eax+4]
237	mov esi, [final_buffer]	237	mov esi, [final_buffer]
238	mov eax, ecx	238	mov eax, ecx
239	shr ecx, 2	239	shr ecx, 2
240	rep movsd	240	rep movsd
241	mov ecx, eax	241	mov ecx, eax
242	and ecx, 3	242	and ecx, 3
243	rep movsb	243	rep movsb
244		244
245	ret	245	ret
246		246
247		247
248	;****************************************************************************	248	;****************************************************************************
249	; Function	249	; Function
250	; save_to_file	250	; save_to_file
251	;	251	;
252	; Description	252	; Description
253	;	253	;
254	;	254	;
255	;****************************************************************************	255	;****************************************************************************
256		256
257	save_to_file:	257	save_to_file:
258		258
259	DEBUGF 2, "Saving to file\n"	259	DEBUGF 2, "Saving to file\n"
260	mcall 70, fileinfo	260	mcall 70, fileinfo
261		261
262	ret	262	ret
263		263
264		264
265	;****************************************************************************	265	;****************************************************************************
266	; Function	266	; Function
267	; send_request	267	; send_request
268	;	268	;
269	; Description	269	; Description
270	; Transmits the GET request to the server.	270	; Transmits the GET request to the server.
271	; This is done as GET then URL then HTTP/1.1', 13, 10, 13, 10 in 3 packets	271	; This is done as GET then URL then HTTP/1.1', 13, 10, 13, 10 in 3 packets
272	;	272	;
273	;****************************************************************************	273	;****************************************************************************
274	send_request:	274	send_request:
275		275
276	DEBUGF 1, "Sending request\n"	276	DEBUGF 1, "Sending request\n"
277		277
278	mov esi, string0	278	mov esi, string0
279	mov edi, request	279	mov edi, request
280	movsd	280	movsd
281	; If proxy is used, make absolute URI - prepend http://	281	; If proxy is used, make absolute URI - prepend http://
282	cmp byte[proxyAddr], 0	282	cmp byte[proxyAddr], 0
283	jz .noproxy	283	jz .noproxy
284	mov dword[edi], 'http'	284	mov dword[edi], 'http'
285	mov byte[edi+4], ':'	285	mov byte[edi+4], ':'
286	mov word[edi+5], '//'	286	mov word[edi+5], '//'
287	add edi, 7	287	add edi, 7
288	mov esi, webAddr	288	mov esi, webAddr
289		289
290	.copy_host_loop:	290	.copy_host_loop:
291	lodsb	291	lodsb
292	cmp al, ' '	292	cmp al, ' '
293	jz .noproxy	293	jz .noproxy
294	stosb	294	stosb
295	jmp .copy_host_loop	295	jmp .copy_host_loop
296		296
297	.noproxy:	297	.noproxy:
298	xor edx, edx ; 0	298	xor edx, edx ; 0
299		299
300	.next_edx:	300	.next_edx:
301	; Determine the length of the url to send in the GET request	301	; Determine the length of the url to send in the GET request
302	mov al, [edx+document]	302	mov al, [edx+document]
303	cmp al, ' '	303	cmp al, ' '
304	jbe .document_done	304	jbe .document_done
305	mov [edi], al	305	mov [edi], al
306	inc edi	306	inc edi
307	inc edx	307	inc edx
308	jmp .next_edx	308	jmp .next_edx
309		309
310	.document_done:	310	.document_done:
311	mov esi, stringh	311	mov esi, stringh
312	mov ecx, stringh_end-stringh	312	mov ecx, stringh_end-stringh
313	rep movsb	313	rep movsb
314	xor edx, edx ; 0	314	xor edx, edx ; 0
315		315
316	.webaddr_next:	316	.webaddr_next:
317	mov al, [webAddr + edx]	317	mov al, [webAddr + edx]
318	cmp al, ' '	318	cmp al, ' '
319	jbe .webaddr_done	319	jbe .webaddr_done
320	mov [edi], al	320	mov [edi], al
321	inc edi	321	inc edi
322	inc edx	322	inc edx
323	jmp .webaddr_next	323	jmp .webaddr_next
324		324
325	.webaddr_done:	325	.webaddr_done:
326	cmp byte[proxyUser], 0	326	cmp byte[proxyUser], 0
327	jz @f	327	jz @f
328	call append_proxy_auth_header	328	call append_proxy_auth_header
329	@@:	329	@@:
330	mov esi, connclose	330	mov esi, connclose
331	mov ecx, connclose_end-connclose	331	mov ecx, connclose_end-connclose
332	rep movsb	332	rep movsb
333		333
334	pusha	334	pusha
335	mov eax, 63	335	mov eax, 63
336	mov ebx, 1	336	mov ebx, 1
337	mov edx, request	337	mov edx, request
338	@@:	338	@@:
339	mov cl, [edx]	339	mov cl, [edx]
340	cmp edx, edi	340	cmp edx, edi
341	jz @f	341	jz @f
342	mcall	342	mcall
343	inc edx	343	inc edx
344	jmp @b	344	jmp @b
345	@@:	345	@@:
346	popa	346	popa
347		347
348	mov esi, edi	348	mov esi, edi
349	sub esi, request ; length	349	sub esi, request ; length
350	xor edi, edi ; flags	350	xor edi, edi ; flags
351	mcall send, [socketnum], request ;' HTTP/1.1 .. '	351	mcall send, [socketnum], request ;' HTTP/1.1 .. '
352		352
353	ret	353	ret
354		354
355	;****************************************************************************	355	;****************************************************************************
356	; Function	356	; Function
357	; read_incoming_data	357	; read_incoming_data
358	;	358	;
359	; Description	359	; Description
360	; receive the web page from the server, storing it without processing	360	; receive the web page from the server, storing it without processing
361	;	361	;
362	;****************************************************************************	362	;****************************************************************************
363	read_incoming_data:	363	read_incoming_data:
364		364
365	DEBUGF 1, "Reading incoming data\n"	365	DEBUGF 1, "Reading incoming data\n"
366		366
367	mov eax, [buf_ptr]	367	mov eax, [buf_ptr]
368	mov [pos], eax	368	mov [pos], eax
369	.read:	369	.read:
370	mcall recv, [socketnum], [pos], BUFFERSIZE, 0	370	mcall recv, [socketnum], [pos], BUFFERSIZE, 0
371	inc eax ; -1 = error (socket closed?)	371	inc eax ; -1 = error (socket closed?)
-		372	jz .error
-		373	dec eax ; 0 bytes means the remote end closed the connection
372	jz .no_more_data	374	jz .no_more_data
373	dec eax ; 0 bytes...	-
374	jz .read	-
375		375
376	DEBUGF 1, "Got chunk of %u bytes\n", eax	376	DEBUGF 1, "Got chunk of %u bytes\n", eax
377		377
378	add [buf_size], eax	378	add [buf_size], eax
379	add [pos], eax	379	add [pos], eax
380	push eax	380	push eax
381	mov ecx, [buf_size]	381	mov ecx, [buf_size]
382	add ecx, BUFFERSIZE	382	add ecx, BUFFERSIZE
383	mcall 68, 20, , [buf_ptr] ; reallocate memory block (make bigger)	383	mcall 68, 20, , [buf_ptr] ; reallocate memory block (make bigger)
384	; TODO: parse header and resize buffer only once	384	; TODO: parse header and resize buffer only once
385	pop eax	385	pop eax
386	jmp .read	386	jmp .read
-		387
-		388	.error:
-		389	DEBUGF 1, "Socket error: %u\n", ebx
387		390
388	.no_more_data:	391	.no_more_data:
389	mov eax, [buf_ptr]	392	mov eax, [buf_ptr]
390	sub [pos], eax	393	sub [pos], eax
391		394
392	DEBUGF 1, "No more data\n"	395	DEBUGF 1, "No more data\n"
393		396
394	ret	397	ret
395		398
396		399
397		400
398	; this function cuts header, and removes chunk sizes if doc is chunked	401	; this function cuts header, and removes chunk sizes if doc is chunked
399	; in: buf_ptr, pos; out: buf_ptr, pos.	402	; in: buf_ptr, pos; out: buf_ptr, pos.
400		403
401	parse_result:	404	parse_result:
402		405
403	mov edi, [buf_ptr]	406	mov edi, [buf_ptr]
404	mov edx, [pos]	407	mov edx, [pos]
405	; mov [buf_size], edx	408	; mov [buf_size], edx
406	; mcall 70, fileinfo_tmp	409	; mcall 70, fileinfo_tmp
407	DEBUGF 1, "Parsing result (%u bytes)\n", edx	410	DEBUGF 1, "Parsing result (%u bytes)\n", edx
408		411
409	; first, find end of headers	412	; first, find end of headers
410	.next_byte:	413	.next_byte:
411	cmp dword[edi], 0x0a0d0a0d	414	cmp dword[edi], 0x0a0d0a0d
412	je .end_of_headers	415	je .end_of_headers
413	inc edi	416	inc edi
414	dec edx	417	dec edx
415	ja .next_byte	418	ja .next_byte
416	DEBUGF 1, "Uh-oh, there's no end of header!\n"	419	DEBUGF 1, "Uh-oh, there's no end of header!\n"
417	; no end of headers. it's an error. let client see all those headers.	420	; no end of headers. it's an error. let client see all those headers.
418	ret	421	ret
419		422
420	.end_of_headers:	423	.end_of_headers:
421	; here we look at headers and search content-length or transfer-encoding headers	424	; here we look at headers and search content-length or transfer-encoding headers
422	DEBUGF 1, "Found end of header\n"	425	DEBUGF 1, "Found end of header\n"
423		426
424	sub edi, [buf_ptr]	427	sub edi, [buf_ptr]
425	add edi, 4	428	add edi, 4
426	mov [body_pos], edi ; store position where document body starts	429	mov [body_pos], edi ; store position where document body starts
427	mov [is_chunked], 0	430	mov [is_chunked], 0
428	; find content-length in headers	431	; find content-length in headers
429	; not good method, but should work for 'Content-Length:'	432	; not good method, but should work for 'Content-Length:'
430	mov esi, [buf_ptr]	433	mov esi, [buf_ptr]
431	mov edi, s_contentlength	434	mov edi, s_contentlength
432	mov ebx, [body_pos]	435	mov ebx, [body_pos]
433	xor edx, edx ; 0	436	xor edx, edx ; 0
434	.cl_next:	437	.cl_next:
435	mov al, [esi]	438	mov al, [esi]
436	cmp al, [edi + edx]	439	cmp al, [edi + edx]
437	jne .cl_fail	440	jne .cl_fail
438	inc edx	441	inc edx
439	cmp edx, len_contentlength	442	cmp edx, len_contentlength
440	je .cl_found	443	je .cl_found
441	jmp .cl_incr	444	jmp .cl_incr
442	.cl_fail:	445	.cl_fail:
443	xor edx, edx ; 0	446	xor edx, edx ; 0
444	.cl_incr:	447	.cl_incr:
445	inc esi	448	inc esi
446	dec ebx	449	dec ebx
447	je .cl_error	450	je .cl_error
448	jmp .cl_next	451	jmp .cl_next
449	.cl_error:	452	.cl_error:
450	DEBUGF 1, "content-length not found\n"	453	DEBUGF 1, "content-length not found\n"
451		454
452	; find 'chunked'	455	; find 'chunked'
453	; äà, ÿ êîïèðóþ êîä, ýòî óæàñíî, íî ìíå õî÷åòñÿ, ÷òîáû ïîñêîðåå çàðàáîòàëî	456	; äà, ÿ êîïèðóþ êîä, ýòî óæàñíî, íî ìíå õî÷åòñÿ, ÷òîáû ïîñêîðåå çàðàáîòàëî
454	; à òàì óæ îòðåôàêòîðþ	457	; à òàì óæ îòðåôàêòîðþ
455	mov esi, [buf_ptr]	458	mov esi, [buf_ptr]
456	mov edi, s_chunked	459	mov edi, s_chunked
457	mov ebx, [body_pos]	460	mov ebx, [body_pos]
458	xor edx, edx ; 0	461	xor edx, edx ; 0
459		462
460	.ch_next:	463	.ch_next:
461	mov al, [esi]	464	mov al, [esi]
462	cmp al, [edi + edx]	465	cmp al, [edi + edx]
463	jne .ch_fail	466	jne .ch_fail
464	inc edx	467	inc edx
465	cmp edx, len_chunked	468	cmp edx, len_chunked
466	je .ch_found	469	je .ch_found
467	jmp .ch_incr	470	jmp .ch_incr
468		471
469	.ch_fail:	472	.ch_fail:
470	xor edx, edx ; 0	473	xor edx, edx ; 0
471		474
472	.ch_incr:	475	.ch_incr:
473	inc esi	476	inc esi
474	dec ebx	477	dec ebx
475	je .ch_error	478	je .ch_error
476	jmp .ch_next	479	jmp .ch_next
477		480
478	.ch_error:	481	.ch_error:
479	; if neither of the 2 headers is found, it's an error	482	; if neither of the 2 headers is found, it's an error
480	; DEBUGF 1, "transfer-encoding: chunked not found\n"	483	; DEBUGF 1, "transfer-encoding: chunked not found\n"
481	mov eax, [pos]	484	mov eax, [pos]
482	sub eax, [body_pos]	485	sub eax, [body_pos]
483	jmp .write_final_size	486	jmp .write_final_size
484		487
485	.ch_found:	488	.ch_found:
486	mov [is_chunked], 1	489	mov [is_chunked], 1
487	mov eax, [body_pos]	490	mov eax, [body_pos]
488	add eax, [buf_ptr]	491	add eax, [buf_ptr]
489	sub eax, 2	492	sub eax, 2
490	mov [prev_chunk_end], eax	493	mov [prev_chunk_end], eax
491	jmp parse_chunks	494	jmp parse_chunks
492		495
493	.cl_found:	496	.cl_found:
494	call read_number ; eax = number from *esi	497	call read_number ; eax = number from *esi
495	DEBUGF 1, "Content length: %u\n", eax	498	DEBUGF 1, "Content length: %u\n", eax

Subversion Repositories Kolibri OS

(root)/programs/network/downloader/downloader.asm – Rev 4101 → 4345