Subversion Repositories Kolibri OS

;;  Based on HTTPC.asm for menuetos by ville turjanmaa             ;;

;;  Programmers: Barsuk, Clevermouse, Marat Zakiyanov,             ;;

;;      Kirill Lipatov, dunkaist, HidnPlayr                        ;;

URLMAXLEN       = 1024

__DEBUG__       = 1

        dd      I_END+0x1000    ; esp

        dd      params          ; I_PARAM

include '../../macros.inc'

START:

; load libraries

        stdcall dll.Load, @IMPORT

        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

        mov     [proxyPort], eax

        invoke  ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser

; 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

        DEBUGF  2, "Invalid parameters\n"

        jmp     exit

  .done_with_shared:

        mov     [shared_name], esi

  .done:

        xor     al, al

        stosb

download:

        DEBUGF  1, "Starting download\n"

        call    parse_url

        cmp     [server_ip], 0

        je      dns_error

        call    open_socket

        call    send_request

        mcall   68, 12, BUFFERSIZE      ; create buffer, we'll resize it later if needed..

        call    read_incoming_data

        mcall   close, [socketnum]

        call    parse_result

dns_error:

        cmp     byte [params], 0

        DEBUGF  1, "resetting events\n"

; defaults + mouse

redraw:

still:

        DEBUGF  1, "waiting for events\n"

        je      redraw

        je      key

        je      button

        cmp     eax, EV_MOUSE

        je      mouse

        jmp     still

key:

        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

;

;****************************************************************************

        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

        mov     al, [edx+document]

        cmp     al, ' '

        inc     edx

  .document_done:

        rep     movsb

        xor     edx, edx ; 0

        mov     al, [webAddr + edx]

        jbe     .webaddr_done

        mov     [edi], al

        inc     edi

        inc     edx

        jmp     .webaddr_next

        cmp     byte[proxyUser], 0

        jz      @f

        call    append_proxy_auth_header

    @@:

        mov     esi, connclose

        mov     ecx, connclose_end-connclose

        rep     movsb

        pusha   

        mov     eax, 63

        mov     ebx, 1

        mov     edx, request

    @@:

        mov     cl, [edx]

        cmp     edx, edi

        jz      @f

        mcall

        inc     edx

        jmp     @b

    @@:

        popa

        mov     esi, edi

        sub     esi, request    ; length

        xor     edi, edi        ; flags

        mcall   send, [socketnum], request  ;' HTTP/1.1 .. '

        ret

;****************************************************************************

;    Function

;       read_incoming_data

;

;   Description

;       receive the web page from the server, storing it without processing

;

;****************************************************************************

read_incoming_data:

        DEBUGF  1, "Reading incoming data\n"

        mov     eax, [buf_ptr]

        mov     [pos], eax

  .read:

        mcall   recv, [socketnum], [pos], BUFFERSIZE, 0

        inc     eax             ; -1 = error (socket closed?)

        jz      .error

        dec     eax             ; 0 bytes means the remote end closed the connection

        jz      .no_more_data

        DEBUGF  1, "Got chunk of %u bytes\n", eax

        add     [buf_size], eax

        add     [pos], eax

        push    eax

        mov     ecx, [buf_size]

        add     ecx, BUFFERSIZE

        mcall   68, 20, , [buf_ptr]     ; reallocate memory block (make bigger)

        ; TODO: parse header and resize buffer only once

        pop     eax

        jmp     .read

  .error:

        DEBUGF  1, "Socket error: %u\n", ebx

  .no_more_data:

        mov     eax, [buf_ptr]

        DEBUGF  1, "No more data\n"

        ret

; this function cuts header, and removes chunk sizes if doc is chunked

; in: buf_ptr, pos; out: buf_ptr, pos.

parse_result:

        mov     edi, [buf_ptr]

        mov     edx, [pos]

;        mov     [buf_size], edx

;       mcall   70, fileinfo_tmp

        DEBUGF  1, "Parsing result (%u bytes)\n", edx

; first, find end of headers

  .next_byte:

        cmp     dword[edi], 0x0a0d0a0d

        je      .end_of_headers

        inc     edi

        dec     edx

        ja      .next_byte

        DEBUGF  1, "Uh-oh, there's no end of header!\n"

; no end of headers. it's an error. let client see all those headers.

        ret

  .end_of_headers:

; here we look at headers and search content-length or transfer-encoding headers

        DEBUGF  1, "Found end of header\n"

        sub     edi, [buf_ptr]

        add     edi, 4

        mov     [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 "

; 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

        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'

        sub     bl, '0'

        shl     eax, 1

        lea     eax, [eax + eax * 4]     ; eax *= 10

        add     eax, ebx

  .not_number:

        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

        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

  .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.

;

;       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

;

;****************************************************************************

; 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], ax

        je      pu_001                  ; Found it, so esi+2 is start

        loop    pu_000

pu_002:

; not found, so reset esi to start

        mov     esi, document_user-2

pu_001:

        add     esi, 2

        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

        je      pu_004          ; yep, so none found

        cmp     [esi], byte '/'  ; delimiter?

        je      pu_005          ; yep - process it

        inc     esi

        jmp     pu_003

; 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

        DEBUGF  2, "Downloadng %s\n", document_user

; Look up the ip address, or was it specified?

        jnz     pu_015

        cmp     al, '0'

        jb      pu_010  ; Resolve address

        cmp     al, '9'

        ja      pu_010  ; Resolve address

; Convert address

        mov     esi, proxyAddr-1

        mov     edi, server_ip

        xor     eax, eax

ip1:

        inc     esi

        cmp     [esi], byte '0'

        ja      ip2

        add     eax, ebx

        jmp     ip1

        mov     [edi], al

        xor     eax, eax

        inc     edi

        cmp     edi, server_ip+3

        jbe     ip1

pu_010:

; 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

        jnz     .fail_dns

        mov     eax, [esi + addrinfo.ai_addr]

        mov     eax, [eax + sockaddr_in.sin_addr]

        ret

;   Function

;       append_proxy_auth_header

;       Append header to HTTP request for proxy authentification

;

;***************************************************************************

append_proxy_auth_header:

        mov     ecx, proxy_auth_basic_end - proxy_auth_basic

        mov     esi, proxyUser

        lodsb

        jz      apah001

        call    encode_base64_byte

        call    encode_base64_byte

apah002:

        lodsb

        jmp     apah002

apah003:

        call    encode_base64_final

        mov     dl, al

        ret

ebb001:

        shl     edx, 8

        inc     ecx

ebb002:

        rol     edx, 6

        xor     eax, eax

;   *********************************************

;   *******  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

        or      ecx, 80000000h

        mcall   4, <14, 14>, , type_pls ;"URL:"

; RELOAD

; STOP

; SAVE

; 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_mouse, 'edit_box_mouse'

fileinfo        dd 2, 0, 0

final_size      dd 0

final_buffer    dd 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