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

Subversion Repositories Kolibri OS

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