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

Subversion Repositories Kolibri OS

(root)/programs/network/downloader/downloader.asm @ 3618 – Rev 3566 → 3572