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

Subversion Repositories Kolibri OS

(root)/programs/network/downloader/downloader.asm – Rev 3970 → 3971