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
        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
 
        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      .no_more_data
        dec     eax             ; 0 bytes...
        jz      .read
 
        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
        
  .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], 0x0d0a0d0a  ; ìíå ëåíü ÷èòàòü ñòàíäàðò, ïóñòü áóäóò îáà âàðèàíòà
        je      .end_of_headers
        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/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 3737	Rev 3948
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	call open_socket	112	call open_socket
113	call send_request	113	call send_request
114		114
115	mcall 68, 12, BUFFERSIZE ; create buffer, we'll resize it later if needed..	115	mcall 68, 12, BUFFERSIZE ; create buffer, we'll resize it later if needed..
116	mov [buf_ptr], eax	116	mov [buf_ptr], eax
117	mov [buf_size], 0	117	mov [buf_size], 0
118		118
119	call read_incoming_data	119	call read_incoming_data
120		120
121	mcall close, [socketnum]	121	mcall close, [socketnum]
122		122
123	call parse_result	123	call parse_result
124	call save	124	call save
125		125
126	mcall 68, 13, [final_buffer] ; free buffer	126	mcall 68, 13, [final_buffer] ; free buffer
127		127
128	cmp byte [params], 0	128	cmp byte [params], 0
129	jne exit	129	jne exit
130		130
131	reset_events:	131	reset_events:
132		132
133	DEBUGF 1, "resetting events\n"	133	DEBUGF 1, "resetting events\n"
134		134
135	; Report events	135	; Report events
136	; defaults + mouse	136	; defaults + mouse
137	mcall 40, EVM_REDRAW + EVM_KEY + EVM_BUTTON + EVM_MOUSE	137	mcall 40,EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER
138		138
139	redraw:	139	redraw:
140	call draw_window	140	call draw_window
141		141
142	still:	142	still:
143	DEBUGF 1, "waiting for events\n"	143	DEBUGF 1, "waiting for events\n"
144		144
145	mcall 10 ; wait here for event	145	mcall 10 ; wait here for event
146		146
147	cmp eax, EV_REDRAW	147	cmp eax, EV_REDRAW
148	je redraw	148	je redraw
149		149
150	cmp eax, EV_KEY	150	cmp eax, EV_KEY
151	je key	151	je key
152		152
153	cmp eax, EV_BUTTON	153	cmp eax, EV_BUTTON
154	je button	154	je button
155		155
156	cmp eax, EV_MOUSE	156	cmp eax, EV_MOUSE
157	je mouse	157	je mouse
158		158
159	jmp still	159	jmp still
160		160
161	key:	161	key:
162	mcall 2 ; read key	162	mcall 2 ; read key
163		163
164	stdcall [edit_box_key], dword edit1	164	stdcall [edit_box_key], dword edit1
165		165
166	cmp ax, 13 shl 8	166	cmp ax, 13 shl 8
167	je download	167	je download
168		168
169	jmp still	169	jmp still
170		170
171	button:	171	button:
172		172
173	mcall 17 ; get id	173	mcall 17 ; get id
174		174
175	cmp ah, 26	175	cmp ah, 26
176	jne @f	176	jne @f
177	call save_to_file	177	call save_to_file
178	jmp still	178	jmp still
179	@@:	179	@@:
180	cmp ah, 1 ; button id=1 ?	180	cmp ah, 1 ; button id=1 ?
181	je exit	181	je exit
182		182
183	jmp download	183	jmp download
184		184
185	mouse:	185	mouse:
186	stdcall [edit_box_mouse], edit1	186	stdcall [edit_box_mouse], edit1
187	jmp still	187	jmp still
188		188
189	exit:	189	exit:
190	DEBUGF 1, "Exiting\n"	190	DEBUGF 1, "Exiting\n"
191	or eax, -1 ; close this program	191	or eax, -1 ; close this program
192	mcall	192	mcall
193		193
194		194
195	save:	195	save:
196	cmp [shared_name], 0	196	cmp [shared_name], 0
197	je .use_file	197	je .use_file
198		198
199	call save_in_shared	199	call save_in_shared
200	jmp .done	200	jmp .done
201		201
202	.use_file:	202	.use_file:
203		203
204	call save_to_file	204	call save_to_file
205		205
206	.done:	206	.done:
207		207
208	; if called from command line, then exit	208	; if called from command line, then exit
209	cmp byte[params], 0	209	cmp byte[params], 0
210	jne exit	210	jne exit
211		211
212	mov ecx, [sc.work_text]	212	mov ecx, [sc.work_text]
213	or ecx, 0x80000000	213	or ecx, 0x80000000
214	mcall 4, <10, 93>, , download_complete	214	mcall 4, <10, 93>, , download_complete
215		215
216	ret	216	ret
217		217
218	save_in_shared:	218	save_in_shared:
219		219
220	; open the shared memory area	220	; open the shared memory area
221	mov esi, 1	221	mov esi, 1
222	mcall 68, 22, [shared_name], , 1 ; SHM_OPEN+SHM_WRITE	222	mcall 68, 22, [shared_name], , 1 ; SHM_OPEN+SHM_WRITE
223	test eax, eax	223	test eax, eax
224	jz exit	224	jz exit
225		225
226	mov ecx, [final_size]	226	mov ecx, [final_size]
227	; store the size	227	; store the size
228	mov [eax], ecx	228	mov [eax], ecx
229		229
230	; now copy the data	230	; now copy the data
231	lea edi, [eax+4]	231	lea edi, [eax+4]
232	mov esi, [final_buffer]	232	mov esi, [final_buffer]
233	mov eax, ecx	233	mov eax, ecx
234	shr ecx, 2	234	shr ecx, 2
235	rep movsd	235	rep movsd
236	mov ecx, eax	236	mov ecx, eax
237	and ecx, 3	237	and ecx, 3
238	rep movsb	238	rep movsb
239		239
240	ret	240	ret
241		241
242		242
243	;****************************************************************************	243	;****************************************************************************
244	; Function	244	; Function
245	; save_to_file	245	; save_to_file
246	;	246	;
247	; Description	247	; Description
248	;	248	;
249	;	249	;
250	;****************************************************************************	250	;****************************************************************************
251		251
252	save_to_file:	252	save_to_file:
253		253
254	DEBUGF 2, "Saving to file\n"	254	DEBUGF 2, "Saving to file\n"
255	mcall 70, fileinfo	255	mcall 70, fileinfo
256		256
257	ret	257	ret
258		258
259		259
260	;****************************************************************************	260	;****************************************************************************
261	; Function	261	; Function
262	; send_request	262	; send_request
263	;	263	;
264	; Description	264	; Description
265	; Transmits the GET request to the server.	265	; Transmits the GET request to the server.
266	; This is done as GET then URL then HTTP/1.1', 13, 10, 13, 10 in 3 packets	266	; This is done as GET then URL then HTTP/1.1', 13, 10, 13, 10 in 3 packets
267	;	267	;
268	;****************************************************************************	268	;****************************************************************************
269	send_request:	269	send_request:
270		270
271	DEBUGF 1, "Sending request\n"	271	DEBUGF 1, "Sending request\n"
272		272
273	mov esi, string0	273	mov esi, string0
274	mov edi, request	274	mov edi, request
275	movsd	275	movsd
276	; If proxy is used, make absolute URI - prepend http://	276	; If proxy is used, make absolute URI - prepend http://
277	cmp byte[proxyAddr], 0	277	cmp byte[proxyAddr], 0
278	jz .noproxy	278	jz .noproxy
279	mov dword[edi], 'http'	279	mov dword[edi], 'http'
280	mov byte[edi+4], ':'	280	mov byte[edi+4], ':'
281	mov word[edi+5], '//'	281	mov word[edi+5], '//'
282	add edi, 7	282	add edi, 7
283	mov esi, webAddr	283	mov esi, webAddr
284		284
285	.copy_host_loop:	285	.copy_host_loop:
286	lodsb	286	lodsb
287	cmp al, ' '	287	cmp al, ' '
288	jz .noproxy	288	jz .noproxy
289	stosb	289	stosb
290	jmp .copy_host_loop	290	jmp .copy_host_loop
291		291
292	.noproxy:	292	.noproxy:
293	xor edx, edx ; 0	293	xor edx, edx ; 0
294		294
295	.next_edx:	295	.next_edx:
296	; Determine the length of the url to send in the GET request	296	; Determine the length of the url to send in the GET request
297	mov al, [edx+document]	297	mov al, [edx+document]
298	cmp al, ' '	298	cmp al, ' '
299	jbe .document_done	299	jbe .document_done
300	mov [edi], al	300	mov [edi], al
301	inc edi	301	inc edi
302	inc edx	302	inc edx
303	jmp .next_edx	303	jmp .next_edx
304		304
305	.document_done:	305	.document_done:
306	mov esi, stringh	306	mov esi, stringh
307	mov ecx, stringh_end-stringh	307	mov ecx, stringh_end-stringh
308	rep movsb	308	rep movsb
309	xor edx, edx ; 0	309	xor edx, edx ; 0
310		310
311	.webaddr_next:	311	.webaddr_next:
312	mov al, [webAddr + edx]	312	mov al, [webAddr + edx]
313	cmp al, ' '	313	cmp al, ' '
314	jbe .webaddr_done	314	jbe .webaddr_done
315	mov [edi], al	315	mov [edi], al
316	inc edi	316	inc edi
317	inc edx	317	inc edx
318	jmp .webaddr_next	318	jmp .webaddr_next
319		319
320	.webaddr_done:	320	.webaddr_done:
321	cmp byte[proxyUser], 0	321	cmp byte[proxyUser], 0
322	jz @f	322	jz @f
323	call append_proxy_auth_header	323	call append_proxy_auth_header
324	@@:	324	@@:
325	mov esi, connclose	325	mov esi, connclose
326	mov ecx, connclose_end-connclose	326	mov ecx, connclose_end-connclose
327	rep movsb	327	rep movsb
328		328
329	pusha	329	pusha
330	mov eax, 63	330	mov eax, 63
331	mov ebx, 1	331	mov ebx, 1
332	mov edx, request	332	mov edx, request
333	@@:	333	@@:
334	mov cl, [edx]	334	mov cl, [edx]
335	cmp edx, edi	335	cmp edx, edi
336	jz @f	336	jz @f
337	mcall	337	mcall
338	inc edx	338	inc edx
339	jmp @b	339	jmp @b
340	@@:	340	@@:
341	popa	341	popa
342		342
343	mov esi, edi	343	mov esi, edi
344	sub esi, request ; length	344	sub esi, request ; length
345	xor edi, edi ; flags	345	xor edi, edi ; flags
346	mcall send, [socketnum], request ;' HTTP/1.1 .. '	346	mcall send, [socketnum], request ;' HTTP/1.1 .. '
347		347
348	ret	348	ret
349		349
350	;****************************************************************************	350	;****************************************************************************
351	; Function	351	; Function
352	; read_incoming_data	352	; read_incoming_data
353	;	353	;
354	; Description	354	; Description
355	; receive the web page from the server, storing it without processing	355	; receive the web page from the server, storing it without processing
356	;	356	;
357	;****************************************************************************	357	;****************************************************************************
358	read_incoming_data:	358	read_incoming_data:
359		359
360	DEBUGF 1, "Reading incoming data\n"	360	DEBUGF 1, "Reading incoming data\n"
361		361
362	mov eax, [buf_ptr]	362	mov eax, [buf_ptr]
363	mov [pos], eax	363	mov [pos], eax
364	.read:	364	.read:
365	mcall recv, [socketnum], [pos], BUFFERSIZE, 0	365	mcall recv, [socketnum], [pos], BUFFERSIZE, 0
366	inc eax ; -1 = error (socket closed?)	366	inc eax ; -1 = error (socket closed?)
367	jz .no_more_data	367	jz .no_more_data
368	dec eax ; 0 bytes...	368	dec eax ; 0 bytes...
369	jz .read	369	jz .read
370		370
371	DEBUGF 1, "Got chunk of %u bytes\n", eax	371	DEBUGF 1, "Got chunk of %u bytes\n", eax
372		372
373	add [buf_size], eax	373	add [buf_size], eax
374	add [pos], eax	374	add [pos], eax
375	push eax	375	push eax
376	mov ecx, [buf_size]	376	mov ecx, [buf_size]
377	add ecx, BUFFERSIZE	377	add ecx, BUFFERSIZE
378	mcall 68, 20, , [buf_ptr] ; reallocate memory block (make bigger)	378	mcall 68, 20, , [buf_ptr] ; reallocate memory block (make bigger)
379	; TODO: parse header and resize buffer only once	379	; TODO: parse header and resize buffer only once
380	pop eax	380	pop eax
381	jmp .read	381	jmp .read
382		382
383	.no_more_data:	383	.no_more_data:
384	mov eax, [buf_ptr]	384	mov eax, [buf_ptr]
385	sub [pos], eax	385	sub [pos], eax
386		386
387	DEBUGF 1, "No more data\n"	387	DEBUGF 1, "No more data\n"
388		388
389	ret	389	ret
390		390
391		391
392		392
393	; this function cuts header, and removes chunk sizes if doc is chunked	393	; this function cuts header, and removes chunk sizes if doc is chunked
394	; in: buf_ptr, pos; out: buf_ptr, pos.	394	; in: buf_ptr, pos; out: buf_ptr, pos.
395		395
396	parse_result:	396	parse_result:
397		397
398	mov edi, [buf_ptr]	398	mov edi, [buf_ptr]
399	mov edx, [pos]	399	mov edx, [pos]
400	; mov [buf_size], edx	400	; mov [buf_size], edx
401	; mcall 70, fileinfo_tmp	401	; mcall 70, fileinfo_tmp
402	DEBUGF 1, "Parsing result (%u bytes)\n", edx	402	DEBUGF 1, "Parsing result (%u bytes)\n", edx
403		403
404	; first, find end of headers	404	; first, find end of headers
405	.next_byte:	405	.next_byte:
406	cmp dword[edi], 0x0d0a0d0a ; ìíå ëåíü ÷èòàòü ñòàíäàðò, ïóñòü áóäóò îáà âàðèàíòà	406	cmp dword[edi], 0x0d0a0d0a ; ìíå ëåíü ÷èòàòü ñòàíäàðò, ïóñòü áóäóò îáà âàðèàíòà
407	je .end_of_headers	407	je .end_of_headers
408	cmp dword[edi], 0x0a0d0a0d	408	cmp dword[edi], 0x0a0d0a0d
409	je .end_of_headers	409	je .end_of_headers
410	inc edi	410	inc edi
411	dec edx	411	dec edx
412	ja .next_byte	412	ja .next_byte
413	DEBUGF 1, "Uh-oh, there's no end of header!\n"	413	DEBUGF 1, "Uh-oh, there's no end of header!\n"
414	; no end of headers. it's an error. let client see all those headers.	414	; no end of headers. it's an error. let client see all those headers.
415	ret	415	ret
416		416
417	.end_of_headers:	417	.end_of_headers:
418	; here we look at headers and search content-length or transfer-encoding headers	418	; here we look at headers and search content-length or transfer-encoding headers
419	DEBUGF 1, "Found end of header\n"	419	DEBUGF 1, "Found end of header\n"
420		420
421	sub edi, [buf_ptr]	421	sub edi, [buf_ptr]
422	add edi, 4	422	add edi, 4
423	mov [body_pos], edi ; store position where document body starts	423	mov [body_pos], edi ; store position where document body starts
424	mov [is_chunked], 0	424	mov [is_chunked], 0
425	; find content-length in headers	425	; find content-length in headers
426	; not good method, but should work for 'Content-Length:'	426	; not good method, but should work for 'Content-Length:'
427	mov esi, [buf_ptr]	427	mov esi, [buf_ptr]
428	mov edi, s_contentlength	428	mov edi, s_contentlength
429	mov ebx, [body_pos]	429	mov ebx, [body_pos]
430	xor edx, edx ; 0	430	xor edx, edx ; 0
431	.cl_next:	431	.cl_next:
432	mov al, [esi]	432	mov al, [esi]
433	cmp al, [edi + edx]	433	cmp al, [edi + edx]
434	jne .cl_fail	434	jne .cl_fail
435	inc edx	435	inc edx
436	cmp edx, len_contentlength	436	cmp edx, len_contentlength
437	je .cl_found	437	je .cl_found
438	jmp .cl_incr	438	jmp .cl_incr
439	.cl_fail:	439	.cl_fail:
440	xor edx, edx ; 0	440	xor edx, edx ; 0
441	.cl_incr:	441	.cl_incr:
442	inc esi	442	inc esi
443	dec ebx	443	dec ebx
444	je .cl_error	444	je .cl_error
445	jmp .cl_next	445	jmp .cl_next
446	.cl_error:	446	.cl_error:
447	DEBUGF 1, "content-length not found\n"	447	DEBUGF 1, "content-length not found\n"
448		448
449	; find 'chunked'	449	; find 'chunked'
450	; äà, ÿ êîïèðóþ êîä, ýòî óæàñíî, íî ìíå õî÷åòñÿ, ÷òîáû ïîñêîðåå çàðàáîòàëî	450	; äà, ÿ êîïèðóþ êîä, ýòî óæàñíî, íî ìíå õî÷åòñÿ, ÷òîáû ïîñêîðåå çàðàáîòàëî
451	; à òàì óæ îòðåôàêòîðþ	451	; à òàì óæ îòðåôàêòîðþ
452	mov esi, [buf_ptr]	452	mov esi, [buf_ptr]
453	mov edi, s_chunked	453	mov edi, s_chunked
454	mov ebx, [body_pos]	454	mov ebx, [body_pos]
455	xor edx, edx ; 0	455	xor edx, edx ; 0
456		456
457	.ch_next:	457	.ch_next:
458	mov al, [esi]	458	mov al, [esi]
459	cmp al, [edi + edx]	459	cmp al, [edi + edx]
460	jne .ch_fail	460	jne .ch_fail
461	inc edx	461	inc edx
462	cmp edx, len_chunked	462	cmp edx, len_chunked
463	je .ch_found	463	je .ch_found
464	jmp .ch_incr	464	jmp .ch_incr
465		465
466	.ch_fail:	466	.ch_fail:
467	xor edx, edx ; 0	467	xor edx, edx ; 0
468		468
469	.ch_incr:	469	.ch_incr:
470	inc esi	470	inc esi
471	dec ebx	471	dec ebx
472	je .ch_error	472	je .ch_error
473	jmp .ch_next	473	jmp .ch_next
474		474
475	.ch_error:	475	.ch_error:
476	; if neither of the 2 headers is found, it's an error	476	; if neither of the 2 headers is found, it's an error
477	; DEBUGF 1, "transfer-encoding: chunked not found\n"	477	; DEBUGF 1, "transfer-encoding: chunked not found\n"
478	mov eax, [pos]	478	mov eax, [pos]
479	sub eax, [body_pos]	479	sub eax, [body_pos]
480	jmp .write_final_size	480	jmp .write_final_size
481		481
482	.ch_found:	482	.ch_found:
483	mov [is_chunked], 1	483	mov [is_chunked], 1
484	mov eax, [body_pos]	484	mov eax, [body_pos]
485	add eax, [buf_ptr]	485	add eax, [buf_ptr]
486	sub eax, 2	486	sub eax, 2
487	mov [prev_chunk_end], eax	487	mov [prev_chunk_end], eax
488	jmp parse_chunks	488	jmp parse_chunks
489		489
490	.cl_found:	490	.cl_found:
491	call read_number ; eax = number from *esi	491	call read_number ; eax = number from *esi
492	DEBUGF 1, "Content length: %u\n", eax	492	DEBUGF 1, "Content length: %u\n", eax
493		493
494	.write_final_size:	494	.write_final_size:
495		495
496	mov ebx, [buf_size]	496	mov ebx, [buf_size]
497	sub ebx, [body_pos]	497	sub ebx, [body_pos]
498	cmp eax, ebx	498	cmp eax, ebx
499	jbe .size_ok	499	jbe .size_ok
500	sub eax, ebx	500	sub eax, ebx

Subversion Repositories Kolibri OS

(root)/programs/network/downloader/downloader.asm @ 3970 – Rev 3737 → 3948