WebSVN – Kolibri OS – Diff – /programs/develop/libraries/http/http.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2014. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  HTTP library for KolibriOS                                     ;;
;;                                                                 ;;
;;   Written by hidnplayr@kolibrios.org                            ;;
;;   Proxy code written by CleverMouse                             ;;
;;                                                                 ;;
;;         GNU GENERAL PUBLIC LICENSE                              ;;
;;          Version 2, June 1991                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; references:
; "HTTP made really easy", http://www.jmarshall.com/easy/http/
; "Hypertext Transfer Protocol -- HTTP/1.1", http://tools.ietf.org/html/rfc2616
 
 
        URLMAXLEN       = 65535
        BUFFERSIZE      = 8192
        TIMEOUT         = 500  ; in 1/100 s
 
        __DEBUG__       = 1
        __DEBUG_LEVEL__ = 1
 
 
format MS COFF
 
public @EXPORT as 'EXPORTS'
 
include '../../../struct.inc'
include '../../../proc32.inc'
include '../../../macros.inc'
purge section,mov,add,sub
include '../../../debug-fdo.inc'
 
include '../../../network.inc'
include 'http.inc'
 
virtual at 0
        http_msg http_msg
end virtual
 
macro copy_till_zero {
local   .copyloop, .copydone
  .copyloop:
        lodsb
        test    al, al
        jz      .copydone
        stosb
        jmp     .copyloop
  .copydone:
}
 
macro HTTP_init_buffer buffer, socketnum {
 
        mov     eax, buffer
        push    socketnum
        popd    [eax + http_msg.socket]
        lea     esi, [eax + http_msg.http_header]
        mov     [eax + http_msg.flags], FLAG_CONNECTED
        mov     [eax + http_msg.write_ptr], esi
        mov     [eax + http_msg.buffer_length], BUFFERSIZE -  http_msg.http_header
        mov     [eax + http_msg.chunk_ptr], 0
 
        mov     [eax + http_msg.status], 0
        mov     [eax + http_msg.header_length], 0
        mov     [eax + http_msg.content_ptr], 0
        mov     [eax + http_msg.content_length], 0
        mov     [eax + http_msg.content_received], 0
 
        push    eax ebp
        mov     ebp, eax
        mcall   26, 9
        mov     [ebp + http_msg.timestamp], eax
        pop     ebp eax
}
 
section '.flat' code readable align 16
 
;;===========================================================================;;
lib_init: ;//////////////////////////////////////////////////////////////////;;
;;---------------------------------------------------------------------------;;
;? Library entry point (called after library load)                           ;;
;;---------------------------------------------------------------------------;;
;> eax = pointer to memory allocation routine                                ;;
;> ebx = pointer to memory freeing routine                                   ;;
;> ecx = pointer to memory reallocation routine                              ;;
;> edx = pointer to library loading routine                                  ;;
;;---------------------------------------------------------------------------;;
;< eax = 1 (fail) / 0 (ok)                                                   ;;
;;===========================================================================;;
        mov     [mem.alloc], eax
        mov     [mem.free], ebx
        mov     [mem.realloc], ecx
        mov     [dll.load], edx
 
        invoke  dll.load, @IMPORT
        test    eax, eax
        jnz     .error
 
; load proxy settings
        pusha
        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
        popa
 
        DEBUGF  1, "HTTP library: init OK\n"
        xor     eax, eax
        ret
 
  .error:
        DEBUGF  1, "ERROR loading libraries\n"
        xor     eax, eax
        inc     eax
        ret
 
 
 
 
;;================================================================================================;;
proc HTTP_get URL, add_header ;///////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'GET' method.                                               ;;
;;------------------------------------------------------------------------------------------------;;
;> URL          = pointer to ASCIIZ URL                                                           ;;
;> add_header   = pointer to additional header parameters (ASCIIZ), or null for none.             ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        sockaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        pusha
 
; split the URL into hostname and pageaddr
        stdcall parse_url, [URL]
        test    eax, eax
        jz      .error
        mov     [hostname], eax
        mov     [pageaddr], ebx
        mov     [port], ecx
 
; Connect to the other side.
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .error
        mov     [buffer], eax
        mov     edi, eax
        DEBUGF  1, "Buffer allocated: 0x%x\n", eax
 
        mov     esi, str_get
        copy_till_zero
 
; If we are using a proxy, send complete URL, otherwise send only page address.
        cmp     [proxyAddr], 0
        je      .no_proxy
        mov     esi, str_http           ; prepend 'http://'
        copy_till_zero
        mov     esi, [hostname]
        copy_till_zero
  .no_proxy:
        mov     esi, [pageaddr]
        copy_till_zero
 
        mov     esi, str_http11
        mov     ecx, str_http11.length
        rep     movsb
 
        mov     esi, [hostname]
        copy_till_zero
 
        cmp     byte[proxyUser], 0
        je      @f
        call    append_proxy_auth_header
  @@:
 
        mov     ax, 0x0a0d
        stosw
 
        mov     esi, [add_header]
        test    esi, esi
        jz      @f
        copy_till_zero
  @@:
 
        mov     esi, str_close
        mov     ecx, str_close.length
        rep     movsb
 
        mov     byte[edi], 0
        DEBUGF  1, "Request:\n%s", [buffer]
 
; Free unused memory
        push    edi
        invoke  mem.free, [pageaddr]
        invoke  mem.free, [hostname]
        pop     esi
 
; Send the request
        sub     esi, [buffer]   ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], [buffer]
        test    eax, eax
        jz      .error
        DEBUGF  1, "Request has been sent to server.\n"
 
        HTTP_init_buffer [buffer], [socketnum]
 
        popa
        mov     eax, [buffer]   ; return buffer ptr
        ret
 
  .error:
        DEBUGF  1, "Error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_head URL, add_header ;//////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'HEAD' method.                                              ;;
;? This will only return HTTP header and status, no content                                       ;;
;;------------------------------------------------------------------------------------------------;;
;> URL          = pointer to ASCIIZ URL                                                           ;;
;> add_header   = pointer to additional header parameters (ASCIIZ), or null for none.             ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        sockaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        pusha
; split the URL into hostname and pageaddr
        stdcall parse_url, [URL]
        test    eax, eax
        jz      .error
        mov     [hostname], eax
        mov     [pageaddr], ebx
        mov     [port], ecx
 
; Connect to the other side.
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .error
        mov     [buffer], eax
        mov     edi, eax
        DEBUGF  1, "Buffer has been allocated.\n"
 
        mov     esi, str_head
        copy_till_zero
 
; If we are using a proxy, send complete URL, otherwise send only page address.
        cmp     [proxyAddr], 0
        je      .no_proxy
        mov     esi, str_http           ; prepend 'http://'
        copy_till_zero
        mov     esi, [hostname]
        copy_till_zero
  .no_proxy:
        mov     esi, [pageaddr]
        copy_till_zero
 
        mov     esi, str_http11
        mov     ecx, str_http11.length
        rep     movsb
 
        mov     esi, [hostname]
        copy_till_zero
 
        cmp     byte[proxyUser], 0
        je      @f
        call    append_proxy_auth_header
  @@:
 
        mov     ax, 0x0a0d
        stosw
 
        mov     esi, [add_header]
        test    esi, esi
        jz      @f
        copy_till_zero
  @@:
 
        mov     esi, str_close
        mov     ecx, str_close.length
        rep     movsb
 
        mov     byte[edi], 0
        DEBUGF  1, "Request:\n%s", [buffer]
 
 
; Free unused memory
        push    edi
        invoke  mem.free, [pageaddr]
        invoke  mem.free, [hostname]
        pop     esi
 
; Send the request
        sub     esi, [buffer]   ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], [buffer]
        test    eax, eax
        jz      .error
        DEBUGF  1, "Request has been sent to server.\n"
 
        HTTP_init_buffer [buffer], [socketnum]
 
        popa
        mov     eax, [buffer]
        ret                     ; return buffer ptr
 
  .error:
        DEBUGF  1, "Error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
;;================================================================================================;;
proc HTTP_post URL, add_header, content_type, content_length ;////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'POST' method.                                              ;;
;? This method is used to send data to the HTTP server                                            ;;
;;------------------------------------------------------------------------------------------------;;
;> URL                  = pointer to ASCIIZ URL                                                   ;;
;> add_header           = pointer to additional header parameters (ASCIIZ), or null for none.     ;;
;> content_type         = pointer to ASCIIZ string containing content type                        ;;
;> content_length       = length of content (in bytes)                                            ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        sockaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        pusha
; split the URL into hostname and pageaddr
        stdcall parse_url, [URL]
        test    eax, eax
        jz      .error
        mov     [hostname], eax
        mov     [pageaddr], ebx
        mov     [port], ecx
 
; Connect to the other side.
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .error
        mov     [buffer], eax
        mov     edi, eax
        DEBUGF  1, "Buffer has been allocated.\n"
 
        mov     esi, str_post
        copy_till_zero
 
; If we are using a proxy, send complete URL, otherwise send only page address.
        cmp     [proxyAddr], 0
        je      .no_proxy
        mov     esi, str_http           ; prepend 'http://'
        copy_till_zero
        mov     esi, [hostname]
        copy_till_zero
  .no_proxy:
        mov     esi, [pageaddr]
        copy_till_zero
 
        mov     esi, str_http11
        mov     ecx, str_http11.length
        rep     movsb
 
        mov     esi, [hostname]
        copy_till_zero
 
        mov     esi, str_post_cl
        mov     ecx, str_post_cl.length
        rep     movsb
 
        mov     eax, [content_length]
        call    eax_ascii_dec
 
        mov     esi, str_post_ct
        mov     ecx, str_post_ct.length
        rep     movsb
 
        mov     esi, [content_type]
        copy_till_zero
 
        cmp     byte[proxyUser], 0
        je      @f
        call    append_proxy_auth_header
  @@:
 
        mov     ax, 0x0a0d
        stosw
 
        mov     esi, [add_header]
        test    esi, esi
        jz      @f
        copy_till_zero
  @@:
 
        mov     esi, str_close
        mov     ecx, str_close.length
        rep     movsb
 
        mov     byte[edi], 0
        DEBUGF  1, "Request:\n%s", [buffer]
 
; Free unused memory
        push    edi
        invoke  mem.free, [pageaddr]
        invoke  mem.free, [hostname]
        pop     esi
 
; Send the request
        sub     esi, [buffer]   ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], [buffer]
        test    eax, eax
        jz      .error
        DEBUGF  1, "Request has been sent to server.\n"
 
        HTTP_init_buffer [buffer], [socketnum]
 
        popa
        mov     eax, [buffer]
        ret                     ; return buffer ptr
 
  .error:
        DEBUGF  1, "Error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_process identifier ;////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Receive data from the server, parse headers and put data in receive buffer.                    ;;
;? To complete a transfer, this procedure must be called over and over again untill it returns 0. ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = -1 (not finished) / 0 finished                                                           ;;
;;================================================================================================;;
 
        pusha
        mov     ebp, [identifier]
 
; If the connection is closed, return immediately
        test    [ebp + http_msg.flags], FLAG_CONNECTED
        jz      .connection_closed
 
; Receive some data
        mcall   recv, [ebp + http_msg.socket], [ebp + http_msg.write_ptr], \
                      [ebp + http_msg.buffer_length], MSG_DONTWAIT
        cmp     eax, 0xffffffff
        je      .check_socket
 
        test    eax, eax
        jz      .server_closed
        DEBUGF  1, "Received %u bytes\n", eax
 
; Update timestamp
        push    eax
        mcall   26, 9
        mov     [ebp + http_msg.timestamp], eax
        pop     eax
 
; Update pointers
        mov     edi, [ebp + http_msg.write_ptr]
        add     [ebp + http_msg.write_ptr], eax
        sub     [ebp + http_msg.buffer_length], eax
 
; If data is chunked, combine chunks into contiguous data.
        test    [ebp + http_msg.flags], FLAG_CHUNKED
        jnz     .chunk_loop
 
; Did we detect the (final) header yet?
        test    [ebp + http_msg.flags], FLAG_GOT_HEADER
        jnz     .header_parsed
 
;--------------------------------------------------------------
;
; Header parsing code begins here
;
 
; We havent found the (final) header yet, search for it..
  .scan_again:
        ; eax = total number of bytes received so far
        mov     eax, [ebp + http_msg.write_ptr]
        sub     eax, http_msg.http_header
        sub     eax, ebp
        sub     eax, [ebp + http_msg.header_length]
        ; edi is ptr to begin of header
        lea     edi, [ebp + http_msg.http_header]
        add     edi, [ebp + http_msg.header_length]
        ; put it in esi for next proc too
        mov     esi, edi
        sub     eax, 3
        jle     .need_more_data_for_header
  .scan_loop:
        ; scan for end of header (empty line)
        cmp     dword[edi], 0x0a0d0a0d                  ; end of header
        je      .end_of_header
        cmp     word[edi+2], 0x0a0a                     ; notice the use of offset + 2, to calculate header length correctly :)
        je      .end_of_header
        inc     edi
        dec     eax
        jnz     .scan_loop
        jmp     .need_more_data_for_header
 
  .end_of_header:
        add     edi, 4 - http_msg.http_header
        sub     edi, ebp
        mov     [ebp + http_msg.header_length], edi     ; If this isnt the final header, we'll use this as an offset to find real header.
        DEBUGF  1, "Header length: %u\n", edi
 
; Ok, we have found the header
        cmp     dword[esi], 'HTTP'
        jne     .err_header
        cmp     dword[esi+4], '/1.0'
        je      .http_1.0
        cmp     dword[esi+4], '/1.1'
        jne     .err_header
        or      [ebp + http_msg.flags], FLAG_HTTP11
  .http_1.0:
        cmp     byte[esi+8], ' '
        jne     .err_header
 
        add     esi, 9
        xor     eax, eax
        xor     ebx, ebx
        mov     ecx, 3
  .statusloop:
        lodsb
        sub     al, '0'
        jb      .err_header
        cmp     al, 9
        ja      .err_header
        lea     ebx, [ebx + 4*ebx]
        shl     ebx, 1
        add     ebx, eax
        dec     ecx
        jnz     .statusloop
 
; Ignore "100 - Continue" lines
        cmp     ebx, 100
        je      .scan_again
 
        DEBUGF  1, "Status: %u\n", ebx
        mov     [ebp + http_msg.status], ebx
        or      [ebp + http_msg.flags], FLAG_GOT_HEADER
 
; Now, convert all header names to lowercase.
; This way, it will be much easier to find certain header fields, later on.
        lea     esi, [ebp + http_msg.http_header]
        mov     ecx, [ebp + http_msg.header_length]
  .need_newline:
        inc     esi
        dec     ecx
        jz      .convert_done
        cmp     byte[esi], 10
        jne     .need_newline
; We have found a newline
; A line beginning with space or tabs has no header fields.
        inc     esi
        dec     ecx
        jz      .convert_done
        cmp     byte[esi], ' '
        je      .need_newline
        cmp     byte[esi], 9    ; horizontal tab
        je      .need_newline
        jmp     .convert_loop
  .next_char:
        inc     esi
        dec     ecx
        jz      .convert_done
  .convert_loop:
        cmp     byte[esi], ':'
        je      .need_newline
        cmp     byte[esi], 'A'
        jb      .next_char
        cmp     byte[esi], 'Z'
        ja      .next_char
        or      byte[esi], 0x20 ; convert to lowercase
        jmp     .next_char
  .convert_done:
        mov     byte[esi-1], 0
        lea     esi, [ebp + http_msg.http_header]
        DEBUGF  1, "Header names converted to lowercase:\n%s\n", esi
 
; Check for content-length header field.
        stdcall HTTP_find_header_field, ebp, str_cl
        test    eax, eax
        jz      .no_content
        or      [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
 
        xor     edx, edx
  .cl_loop:
        movzx   ebx, byte[eax]
        inc     eax
        cmp     bl, 10
        je      .cl_ok
        cmp     bl, 13
        je      .cl_ok
        cmp     bl, ' '
        je      .cl_ok
        sub     bl, '0'
        jb      .err_header
        cmp     bl, 9
        ja      .err_header
        lea     edx, [edx + edx*4]      ; edx = edx*10
        shl     edx, 1                  ;
        add     edx, ebx
        jmp     .cl_loop
 
  .cl_ok:
        mov     [ebp + http_msg.content_length], edx
        DEBUGF  1, "Content-length: %u\n", edx
 
        test    edx, edx
        jz      .got_all_data
 
        call    alloc_contentbuff
        test    eax, eax
        jz      .err_no_ram
        xor     eax, eax
        jmp     .header_parsed
 
  .no_content:
        DEBUGF  1, "Content-length not found.\n"
 
; We didnt find 'content-length', maybe server is using chunked transfer encoding?
; Try to find 'transfer-encoding' header.
        stdcall HTTP_find_header_field, ebp, str_te
        test    eax, eax
        jnz     .ct_hdr_found
 
  .not_chunked:
        mov     edx, BUFFERSIZE
        call    alloc_contentbuff
        test    eax, eax
        jz      .err_no_ram
        xor     eax, eax
        jmp     .header_parsed
 
  .ct_hdr_found:
        mov     ebx, dword[eax]
        or      ebx, 0x20202020
        cmp     ebx, 'chun'
        jne     .not_chunked
        mov     ebx, dword[eax+4]
        or      ebx, 0x00202020
        and     ebx, 0x00ffffff
        cmp     ebx, 'ked'
        jne     .not_chunked
 
        or      [ebp + http_msg.flags], FLAG_CHUNKED
        DEBUGF  1, "Transfer type is: chunked\n"
 
        mov     edx, BUFFERSIZE
        call    alloc_contentbuff
        test    eax, eax
        jz      .err_no_ram
 
; Set chunk pointer where first chunk should begin.
        mov     eax, [ebp + http_msg.content_ptr]
        mov     [ebp + http_msg.chunk_ptr], eax
 
;--------------------------------------------------------------
;
; Chunk parsing code begins here
;
 
  .chunk_loop:
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, [ebp + http_msg.chunk_ptr]
        jbe     .need_more_data_chunked
 
; Chunkline starts here, convert the ASCII hex number into ebx
        mov     esi, [ebp + http_msg.chunk_ptr]
        DEBUGF  1, "Chunkline begins at 0x%x\n", esi
 
        xor     ebx, ebx
        cmp     byte[esi], 0x0d
        jne     .chunk_hex_loop
        dec     ecx
        jz      .need_more_data_chunked
        inc     esi
        cmp     byte[esi], 0x0a
        jne     .chunk_hex_loop
        dec     ecx
        jz      .need_more_data_chunked
        inc     esi
  .chunk_hex_loop:
        lodsb
        sub     al, '0'
        jb      .chunk_hex_end
        cmp     al, 9
        jbe     .chunk_hex
        sub     al, 'A' - '0' - 10
        jb      .chunk_hex_end
        cmp     al, 15
        jbe     .chunk_hex
        sub     al, 'a' - 'A'
        cmp     al, 15
        ja      .chunk_hex_end
  .chunk_hex:
        shl     ebx, 4
        add     bl, al
        dec     ecx
        jnz     .chunk_hex_loop
        jmp     .need_more_data_chunked
  .chunk_hex_end:
; Chunkline ends with a CR LF or simply LF
        dec     esi
  .end_of_chunkline?:
        lodsb
        cmp     al, 10                                  ; chunkline must always end with LF
        je      .end_of_chunkline
        dec     ecx
        jnz     .end_of_chunkline?
        xor     eax, eax
        jmp     .need_more_data_chunked                 ; chunkline is incomplete, request more data
  .end_of_chunkline:
        DEBUGF  1, "Chunk of 0x%x bytes\n", ebx
; If chunk size is 0, all chunks have been received.
        test    ebx, ebx
        jz      .got_all_data_chunked
; Calculate how many data bytes we have received already
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, [ebp + http_msg.chunk_ptr]         ; ecx is now number of received data bytes
; Update content_received counter
        add     [ebp + http_msg.content_received], ecx
; Calculate new write ptr
        mov     edx, esi
        sub     edx, [ebp + http_msg.chunk_ptr]         ; edx is now length of chunkline
        sub     [ebp + http_msg.write_ptr], edx
; Realloc buffer, make it 'chunksize' bigger.
        lea     edx, [ebx + BUFFERSIZE]
        mov     [ebp + http_msg.buffer_length], edx     ; remaining space in new buffer
        add     edx, [ebp + http_msg.write_ptr]
        sub     edx, [ebp + http_msg.content_ptr]
        DEBUGF  1, "Resizing buffer 0x%x, it will now be %u bytes\n", [ebp + http_msg.content_ptr], edx
        invoke  mem.realloc, [ebp + http_msg.content_ptr], edx
        DEBUGF  1, "New buffer = 0x%x\n", eax
        or      eax, eax
        jz      .err_no_ram
        call    recalculate_pointers                    ; Because it's possible that buffer begins on another address now
        add     esi, eax                                ; recalculate esi too!
; Remove chunk header (aka chunkline) from the buffer by shifting all received data after chunkt_ptr to the left
        mov     edi, [ebp + http_msg.chunk_ptr]
        rep movsb
; Update chunk ptr to point to next chunk
        add     [ebp + http_msg.chunk_ptr], ebx
; Set number of received bytes to 0, we already updated content_received
        xor     eax, eax
        jmp     .chunk_loop
 
;--------------------------------------------------------------
;
; end of proc code begins here
;
 
  .header_parsed:
        ; Header was already parsed and connection isnt chunked.
        ; Update content_received
        add     [ebp + http_msg.content_received], eax
        ; If we received content-length parameter, check if we received all the data
        test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
        jz      @f
        mov     eax, [ebp + http_msg.content_received]
        cmp     eax, [ebp + http_msg.content_length]
        jae     .got_all_data
  @@:
        cmp     [ebp + http_msg.buffer_length], 0
        je      .buffer_full
        ; Need more data
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .buffer_full:
        ; Lets make it bigger..
        mov     eax, [ebp + http_msg.write_ptr]
        add     eax, BUFFERSIZE
        sub     eax, [ebp + http_msg.content_ptr]
        invoke  mem.realloc, [ebp + http_msg.content_ptr], eax
        or      eax, eax
        jz      .err_no_ram
        call    recalculate_pointers
        mov     [ebp + http_msg.buffer_length], BUFFERSIZE
        ; Need more data
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .need_more_data_for_header:
        cmp     [ebp + http_msg.buffer_length], 0
        je      .err_header                     ; It's just too damn long!
        ; Need more data
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .need_more_data_chunked:
        ; We only got a partial chunk, or need more chunks, update content_received and request more data
        add     [ebp + http_msg.content_received], eax
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .got_all_data_chunked:
        ; Woohoo, we got all the chunked data, calculate total number of bytes received.
        mov     eax, [ebp + http_msg.chunk_ptr]
        sub     eax, [ebp + http_msg.content_ptr]
        mov     [ebp + http_msg.content_length], eax
        mov     [ebp + http_msg.content_received], eax
  .got_all_data:
        DEBUGF  1, "We got all the data! (%u bytes)\n", [ebp + http_msg.content_received]
        or      [ebp + http_msg.flags], FLAG_GOT_ALL_DATA
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
        popa
        xor     eax, eax
        ret
 
;--------------------------------------------------------------
;
; error handeling code begins here
;
 
  .check_socket:
        cmp     ebx, EWOULDBLOCK
        jne     .err_socket
        mcall   26, 9
        sub     eax, [ebp + http_msg.timestamp]
        cmp     eax, TIMEOUT
        ja      .err_timeout
        ; Need more data
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .server_closed:
        DEBUGF  1, "server closed connection, transfer complete?\n"
        test    [ebp + http_msg.flags], FLAG_GOT_HEADER
        jz      .err_server_closed
        test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
        jz      .got_all_data
  .err_server_closed:
        pop     eax
        DEBUGF  1, "ERROR: server closed connection unexpectedly\n"
        or      [ebp + http_msg.flags], FLAG_TRANSFER_FAILED
        jmp     .abort
 
  .err_header:
        pop     eax
        DEBUGF  1, "ERROR: invalid header\n"
        or      [ebp + http_msg.flags], FLAG_INVALID_HEADER
        jmp     .abort
 
  .err_no_ram:
        DEBUGF  1, "ERROR: out of RAM\n"
        or      [ebp + http_msg.flags], FLAG_NO_RAM
        jmp     .abort
 
  .err_timeout:
        DEBUGF  1, "ERROR: timeout\n"
        or      [ebp + http_msg.flags], FLAG_TIMEOUT_ERROR
        jmp     .abort
 
  .err_socket:
        DEBUGF  1, "ERROR: socket error %u\n", ebx
        or      [ebp + http_msg.flags], FLAG_SOCKET_ERROR
  .abort:
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
  .connection_closed:
        popa
        xor     eax, eax
        ret
 
endp
 
 
alloc_contentbuff:
 
; Allocate content buffer
        invoke  mem.alloc, edx
        or      eax, eax
        jz      .no_ram
 
        DEBUGF  1, "Content buffer allocated: 0x%x\n", eax
 
; Copy already received content into content buffer
        mov     edi, eax
        lea     esi, [ebp + http_msg.http_header]
        add     esi, [ebp + http_msg.header_length]
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, esi
        mov     ebx, ecx
        rep movsb
 
; Update pointers to point to new buffer
        mov     [ebp + http_msg.content_ptr], eax
        mov     [ebp + http_msg.content_received], ebx
        sub     edx, ebx
        mov     [ebp + http_msg.buffer_length], edx
        add     eax, ebx
        mov     [ebp + http_msg.write_ptr], eax
 
; Shrink header buffer
        mov     eax, http_msg.http_header
        add     eax, [ebp + http_msg.header_length]
        invoke  mem.realloc, ebp, eax
        or      eax, eax
  .no_ram:
 
        ret
 
 
 
recalculate_pointers:
 
        sub     eax, [ebp + http_msg.content_ptr]
        jz      .done
        add     [ebp + http_msg.content_ptr], eax
        add     [ebp + http_msg.write_ptr], eax
        add     [ebp + http_msg.chunk_ptr], eax
 
  .done:
        ret
 
 
 
 
;;================================================================================================;;
proc HTTP_free identifier ;///////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Free the http_msg structure                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< none                                                                                           ;;
;;================================================================================================;;
        DEBUGF  1, "HTTP_free: 0x%x\n", [identifier]
        pusha
        mov     ebp, [identifier]
 
        test    [ebp + http_msg.flags], FLAG_CONNECTED
        jz      .not_connected
 
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
 
  .not_connected:
        invoke  mem.free, ebp
 
        popa
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_stop identifier ;///////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Stops the open connection                                                                      ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< none                                                                                           ;;
;;================================================================================================;;
 
        pusha
        mov     ebp, [identifier]
 
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
 
        popa
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_find_header_field identifier, headername ;//////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Find a header field in the received HTTP header                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = ptr to http_msg struct                                                          ;;
;> headername   = ptr to ASCIIZ string containg field you want to find (must be in lowercase)     ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to content of the HTTP header field                                      ;;
;;================================================================================================;;
        push    ebx ecx edx esi edi
 
        DEBUGF  1, "Find header field: %s\n", [headername]
 
        mov     ebx, [identifier]
        test    [ebx + http_msg.flags], FLAG_GOT_HEADER
        jz      .fail
 
        lea     edx, [ebx + http_msg.http_header]
        mov     ecx, edx
        add     ecx, [ebx + http_msg.header_length]
 
  .restart:
        mov     esi, [headername]
        mov     edi, edx
  .loop:
        cmp     edi, ecx
        jae     .fail
        lodsb
        scasb
        je      .loop
        test    al, al
        jz      .done?
  .next:
        inc     edx
        jmp     .restart
 
  .not_done:
        inc     edi
  .done?:
        cmp     byte[edi-1], ':'
        je      .almost_done
        cmp     byte[edi-1], ' '
        je      .not_done
        cmp     byte[edi-1], 9  ; tab
        je      .not_done
 
        jmp     .next
 
  .almost_done:                 ; FIXME: buffer overflow?
        dec     edi
        DEBUGF  1, "Found header field\n"
  .spaceloop:
        inc     edi
        cmp     byte[edi], ' '
        je      .spaceloop
        cmp     byte[edi], 9    ; tab
        je      .spaceloop
 
        mov     eax, edi
        pop     edi esi edx ecx ebx
        ret
 
  .fail:
        DEBUGF  1, "Header field not found\n"
        pop     edi esi edx ecx ebx
        xor     eax, eax
        ret
 
endp
 
 
 
;;================================================================================================;;
proc URI_escape URI ;/////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;?                                                                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> URI = ptr to ASCIIZ URI                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ URI                                                            ;;
;;================================================================================================;;
 
        pusha
 
        invoke  mem.alloc, URLMAXLEN
        test    eax, eax
        jz      .error
        mov     [esp + 7 * 4], eax              ; return ptr in eax
        mov     esi, [URI]
        mov     edi, eax
        xor     ebx, ebx
        xor     ecx, ecx
  .loop:
        lodsb
        test    al, al
        jz      .done
 
        mov     cl, al
        and     cl, 0x1f
        mov     bl, al
        shr     bl, 5
        bt      dword[bits_must_escape + ebx], ecx
        jc      .escape
 
        stosb
        jmp     .loop
 
  .escape:
        mov     al, '%'
        stosb
        mov     bl, byte[esi-1]
        shr     bl, 4
        mov     al, byte[str_hex + ebx]
        stosb
        mov     bl, byte[esi-1]
        and     bl, 0x0f
        mov     al, byte[str_hex + ebx]
        stosb
        jmp     .loop
 
 
  .done:
        stosb
 
        popa
        ret
 
  .error:
        popa
        xor     eax, eax
        ret
 
endp
 
 
 
;;================================================================================================;;
proc URI_unescape URI ;///////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;?                                                                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> URI = ptr to ASCIIZ URI                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ URI                                                            ;;
;;================================================================================================;;
 
        pusha
 
        invoke  mem.alloc, URLMAXLEN
        test    eax, eax
        jz      .error
        mov     [esp + 7 * 4], eax              ; return ptr in eax
        mov     esi, [URI]
        mov     edi, eax
  .loop:
        lodsb
        test    al, al
        jz      .done
 
        cmp     al, '%'
        je      .unescape
 
        stosb
        jmp     .loop
 
  .unescape:
        xor     ebx, ebx
        xor     ecx, ecx
  .unescape_nibble:
        lodsb
        sub     al, '0'
        jb      .fail
        cmp     al, 9
        jbe     .nibble_ok
        sub     al, 'A' - '0' - 10
        jb      .fail
        cmp     al, 15
        jbe     .nibble_ok
        sub     al, 'a' - 'A'
        cmp     al, 15
        ja      .fail
  .nibble_ok:
        shl     bl, 8
        or      bl, al
        dec     ecx
        jc      .unescape_nibble
        mov     al, bl
        stosb
        jmp     .loop
 
  .fail:
        DEBUGF  1, "ERROR: invalid URI!\n"
        jmp     .loop
 
  .done:
        stosb
 
        popa
        ret
 
  .error:
        popa
        xor     eax, eax
        ret
 
endp
 
 
 
 
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Internal procedures section                                                                    ;;
;;                                                                                                ;;
;; NOTICE: These procedures do not follow stdcall conventions and thus may destroy any register.  ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
 
 
 
;;================================================================================================;;
proc open_connection hostname, port ;/////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Connects to a HTTP server                                                                      ;;
;;------------------------------------------------------------------------------------------------;;
;> hostname     = ptr to ASCIIZ hostname                                                          ;;
;> port         = port (x86 byte order)                                                           ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / socketnum                                                                    ;;
;;================================================================================================;;
 
locals
        sockaddr        dd ?
        socketnum       dd ?
endl
 
        cmp     [proxyAddr], 0
        je      .no_proxy
 
        mov     [hostname], proxyAddr
 
        push    [proxyPort]
        pop     [port]
  .no_proxy:
 
; Resolve the hostname
        DEBUGF  1, "Resolving hostname\n"
        push    esp     ; reserve stack place
        push    esp     ; fourth parameter
        push    0       ; third parameter
        push    0       ; second parameter
        push    [hostname]
        call    [getaddrinfo]
        pop     esi
        test    eax, eax
        jnz     .error1
 
; getaddrinfo returns addrinfo struct, make the pointer to sockaddr struct
        mov     esi, [esi + addrinfo.ai_addr]
        mov     [sockaddr], esi
        mov     eax, [esi + sockaddr_in.sin_addr]
        test    eax, eax
        jz      .error2
 
        DEBUGF  1, "Server ip=%u.%u.%u.%u\n", \
        [esi + sockaddr_in.sin_addr]:1, [esi + sockaddr_in.sin_addr + 1]:1, \
        [esi + sockaddr_in.sin_addr + 2]:1, [esi + sockaddr_in.sin_addr + 3]:1
 
        mov     [esi + sockaddr_in.sin_family], AF_INET4
        mov     eax, [port]
        xchg    al, ah
        mov     [esi + sockaddr_in.sin_port], ax
 
; Connect to the server.
        mcall   socket, AF_INET4, SOCK_STREAM, 0
        test    eax, eax
        jz      .error2
        mov     [socketnum], eax
        DEBUGF  1, "Socket: 0x%x\n", eax
 
        mcall   connect, [socketnum], [sockaddr], 18
        test    eax, eax
        jnz     .error2
        DEBUGF  1, "Socket is now connected.\n"
 
; free allocated memory
        push    [sockaddr]
        call    [freeaddrinfo]
 
        mov     eax, [socketnum]
        ret
 
  .error2:
 
; free allocated memory
        push    [sockaddr]
        call    [freeaddrinfo]
 
  .error1:
        xor     eax, eax
        ret
 
endp
 
 
;;================================================================================================;;
proc parse_url URL ;//////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Split a given URL into hostname and pageaddr                                                   ;;
;;------------------------------------------------------------------------------------------------;;
;> URL = ptr to ASCIIZ URL                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ hostname                                                       ;;
;< ebx = ptr to ASCIIZ pageaddr                                                                   ;;
;< ecx = port number                                                                              ;;
;;================================================================================================;;
 
locals
        urlsize         dd ?
        hostname        dd ?
        pageaddr        dd ?
        port            dd ?
endl
 
        DEBUGF  1, "parsing URL: %s\n", [URL]
 
; remove any leading protocol text
        mov     esi, [URL]
        mov     ecx, URLMAXLEN
        mov     ax, '//'
  .loop1:
        cmp     byte[esi], 0            ; end of URL?
        je      .url_ok                 ; yep, so not found
        cmp     [esi], ax
        je      .skip_proto
        inc     esi
        dec     ecx
        jnz     .loop1
        jmp     .invalid
 
  .skip_proto:
        inc     esi                     ; skip the two '/'
        inc     esi
        mov     [URL], esi              ; update pointer so it skips protocol
        jmp     .loop1                  ; we still need to find the length of the URL
 
  .url_ok:
        sub     esi, [URL]              ; calculate total length of URL
        mov     [urlsize], esi
 
 
; now look for page delimiter - it's a '/' character
        mov     ecx, esi                ; URL length
        mov     edi, [URL]
        mov     al, '/'
        repne   scasb
        jne     @f
        dec     edi                     ; return one char, '/' must be part of the pageaddr
        inc     ecx                     ;
  @@:
        push    ecx edi                 ; remember the pointer and length of pageaddr
 
 
; Create new buffer and put hostname in it.
        mov     ecx, edi
        sub     ecx, [URL]
        inc     ecx                     ; we will add a 0 byte at the end
        invoke  mem.alloc, ecx
        or      eax, eax
        jz      .no_mem
 
        mov     [hostname], eax         ; copy hostname to buffer
        mov     edi, eax
        mov     esi, [URL]
        dec     ecx
        rep     movsb
        xor     al, al
        stosb
 
; Check if user provided a port, and convert it if so.
        mov     esi, [hostname]
        mov     [port], 80              ; default port if user didnt provide one
  .portloop:
        lodsb
        test    al, al
        jz      .no_port
        cmp     al, ':'
        jne     .portloop
 
        push    esi
        call    ascii_dec_ebx
        pop     edi
        cmp     byte[esi-1], 0
        jne     .invalid
        cmp     [proxyAddr], 0          ; remove port number from hostname
        jne     @f                      ; unless when we are using proxy
        mov     byte[edi-1], 0
  @@:
        test    ebx, ebx
        je      .invalid
        cmp     ebx, 0xffff
        ja      .invalid
        mov     [port], ebx
  .no_port:
 
 
; Did user provide a pageaddr?
        mov     [pageaddr], str_slash   ; assume there is no pageaddr
        pop     esi ecx
        test    ecx, ecx
        jz      .no_page
 
; Create new buffer and put pageaddr into it.
        inc     ecx                     ; we will add a 0 byte at the end
        invoke  mem.alloc, ecx
        or      eax, eax
        jz      .no_mem
 
        mov     [pageaddr], eax         ; copy pageaddr to buffer
        mov     edi, eax
        dec     ecx
        rep     movsb
        xor     al, al
        stosb
 
  .no_page:
        mov     eax, [hostname]
        mov     ebx, [pageaddr]
        mov     ecx, [port]
 
        DEBUGF  1, "hostname: %s\n", eax
        DEBUGF  1, "pageaddr: %s\n", ebx
        DEBUGF  1, "port: %u\n", ecx
 
        ret
 
  .no_mem:
        DEBUGF  1, "Out of memory!\n"
        xor     eax, eax
        ret
 
  .invalid:
        DEBUGF  1, "Invalid URL!\n"
        xor     eax, eax
        ret
 
endp
 
 
 
 
 
;;================================================================================================;;
proc append_proxy_auth_header ;///////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Appends the proxy authentication header                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;> /                                                                                              ;;
;;------------------------------------------------------------------------------------------------;;
;< /                                                                                              ;;
;;================================================================================================;;
        mov     esi, str_proxy_auth
        mov     ecx, str_proxy_auth.length
        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
 
endp
 
 
;;================================================================================================;;
proc eax_ascii_dec ;//////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Convert eax to ASCII decimal number                                                            ;;
;;------------------------------------------------------------------------------------------------;;
;> eax = number                                                                                   ;;
;> edi = ptr where to write ASCII decimal number                                                  ;;
;;------------------------------------------------------------------------------------------------;;
;< /                                                                                              ;;
;;================================================================================================;;
 
        push    -'0'
        mov     ecx, 10
  .loop:
        xor     edx, edx
        div     ecx
 
        push    edx
        test    eax, eax
        jnz     .loop
 
  .loop2:
        pop     eax
        add     al, '0'
        jz      .done
        stosb
        jmp     .loop2
  .done:
 
        ret
 
endp
 
 
;;================================================================================================;;
proc ascii_dec_ebx ;//////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Convert ASCII decimal number to ebx                                                            ;;
;;------------------------------------------------------------------------------------------------;;
;> esi = ptr where to read ASCII decimal number                                                   ;;
;;------------------------------------------------------------------------------------------------;;
;> ebx = number                                                                                   ;;
;;================================================================================================;;
 
        xor     eax, eax
        xor     ebx, ebx
  .loop:
        lodsb
        sub     al, '0'
        jb      .done
        cmp     al, 9
        ja      .done
        lea     ebx, [ebx + 4*ebx]
        shl     ebx, 1
        add     ebx, eax
        jmp     .loop
  .done:
 
        ret
 
endp
 
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Imported functions section                                                                     ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
 
align 16
@IMPORT:
 
library \
        libini, 'libini.obj', \
        network, 'network.obj'
 
import  libini, \
        ini.get_str, 'ini_get_str', \
        ini.get_int, 'ini_get_int'
 
import  network,\
        getaddrinfo, 'getaddrinfo',\
        freeaddrinfo,  'freeaddrinfo',\
        inet_ntoa, 'inet_ntoa'
 
;;===========================================================================;;
;;///////////////////////////////////////////////////////////////////////////;;
;;===========================================================================;;
;! Exported functions section                                                ;;
;;===========================================================================;;
;;///////////////////////////////////////////////////////////////////////////;;
;;===========================================================================;;
 
 
align 4
@EXPORT:
export  \
        lib_init                , 'lib_init'            , \
        0x00010001              , 'version'             , \
        HTTP_get                , 'get'                 , \
        HTTP_head               , 'head'                , \
        HTTP_post               , 'post'                , \
        HTTP_find_header_field  , 'find_header_field'   , \
        HTTP_process            , 'process'             , \
        HTTP_free               , 'free'                , \
        HTTP_stop               , 'stop'                , \
        URI_escape              , 'escape'              , \
        URI_unescape            , 'unescape'
 
;        HTTP_put                , 'put'                 , \
;        HTTP_delete             , 'delete'              , \
;        HTTP_trace              , 'trace'               , \
;        HTTP_connect            , 'connect'             , \
 
 
 
section '.data' data readable writable align 16
 
inifile         db '/sys/settings/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
 
str_http11      db ' HTTP/1.1', 13, 10, 'Host: '
  .length       = $ - str_http11
str_post_cl     db 13, 10, 'Content-Length: '
  .length       = $ - str_post_cl
str_post_ct     db 13, 10, 'Content-Type: '
  .length       = $ - str_post_ct
str_proxy_auth  db 13, 10, 'Proxy-Authorization: Basic '
  .length       = $ - str_proxy_auth
str_close       db 'User-Agent: KolibriOS libHTTP/1.0', 13, 10, 'Connection: Close', 13, 10, 13, 10
  .length       = $ - str_close
 
str_http        db 'http://', 0
 
base64_table    db 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
                db '0123456789+/'
 
str_cl          db 'content-length', 0
str_slash       db '/', 0
str_te          db 'transfer-encoding', 0
str_get         db 'GET ', 0
str_head        db 'HEAD ', 0
str_post        db 'POST ', 0
 
bits_must_escape:
dd      0xffffffff                                                      ; 00-1F
dd      1 shl 0 + 1 shl 2 + 1 shl 3 + 1 shl 5 + 1 shl 28 + 1 shl 30     ; "#%<>
dd      1 shl 27 + 1 shl 28 + 1 shl 29 + 1 shl 30                       ;[\]^
dd      1 shl 0 + 1 shl 27 + 1 shl 28 + 1 shl 29 + 1 shl 31             ;`{|} DEL
 
dd      0xffffffff
dd      0xffffffff
dd      0xffffffff
dd      0xffffffff
 
str_hex:
db '0123456789ABCDEF'
 
include_debug_strings
 
; uninitialized data
mem.alloc       dd ?
mem.free        dd ?
mem.realloc     dd ?
dll.load        dd ?
 
proxyAddr       rb 256
proxyUser       rb 256
proxyPassword   rb 256
proxyPort       dd ?

Rev 4829	Rev 4830
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2014. 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	;; HTTP library for KolibriOS ;;	6	;; HTTP library for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org ;;	8	;; Written by hidnplayr@kolibrios.org ;;
9	;; Proxy code written by CleverMouse ;;	9	;; Proxy code written by CleverMouse ;;
10	;; ;;	10	;; ;;
11	;; GNU GENERAL PUBLIC LICENSE ;;	11	;; GNU GENERAL PUBLIC LICENSE ;;
12	;; Version 2, June 1991 ;;	12	;; Version 2, June 1991 ;;
13	;; ;;	13	;; ;;
14	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	14	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
15		15
16	; references:	16	; references:
17	; "HTTP made really easy", http://www.jmarshall.com/easy/http/	17	; "HTTP made really easy", http://www.jmarshall.com/easy/http/
18	; "Hypertext Transfer Protocol -- HTTP/1.1", http://tools.ietf.org/html/rfc2616	18	; "Hypertext Transfer Protocol -- HTTP/1.1", http://tools.ietf.org/html/rfc2616
19		19
20		20
21	URLMAXLEN = 65535	21	URLMAXLEN = 65535
22	BUFFERSIZE = 8192	22	BUFFERSIZE = 8192
23	TIMEOUT = 500 ; in 1/100 s	23	TIMEOUT = 500 ; in 1/100 s
24		24
25	__DEBUG__ = 1	25	__DEBUG__ = 1
26	__DEBUG_LEVEL__ = 1	26	__DEBUG_LEVEL__ = 1
27		27
28		28
29	format MS COFF	29	format MS COFF
30		30
31	public @EXPORT as 'EXPORTS'	31	public @EXPORT as 'EXPORTS'
32		32
33	include '../../../struct.inc'	33	include '../../../struct.inc'
34	include '../../../proc32.inc'	34	include '../../../proc32.inc'
35	include '../../../macros.inc'	35	include '../../../macros.inc'
36	purge section,mov,add,sub	36	purge section,mov,add,sub
37	include '../../../debug-fdo.inc'	37	include '../../../debug-fdo.inc'
38		38
39	include '../../../network.inc'	39	include '../../../network.inc'
40	include 'http.inc'	40	include 'http.inc'
41		41
42	virtual at 0	42	virtual at 0
43	http_msg http_msg	43	http_msg http_msg
44	end virtual	44	end virtual
45		45
46	macro copy_till_zero {	46	macro copy_till_zero {
47	local .copyloop, .copydone	47	local .copyloop, .copydone
48	.copyloop:	48	.copyloop:
49	lodsb	49	lodsb
50	test al, al	50	test al, al
51	jz .copydone	51	jz .copydone
52	stosb	52	stosb
53	jmp .copyloop	53	jmp .copyloop
54	.copydone:	54	.copydone:
55	}	55	}
56		56
57	macro HTTP_init_buffer buffer, socketnum {	57	macro HTTP_init_buffer buffer, socketnum {
58		58
59	mov eax, buffer	59	mov eax, buffer
60	push socketnum	60	push socketnum
61	popd [eax + http_msg.socket]	61	popd [eax + http_msg.socket]
62	lea esi, [eax + http_msg.http_header]	62	lea esi, [eax + http_msg.http_header]
63	mov [eax + http_msg.flags], FLAG_CONNECTED	63	mov [eax + http_msg.flags], FLAG_CONNECTED
64	mov [eax + http_msg.write_ptr], esi	64	mov [eax + http_msg.write_ptr], esi
65	mov [eax + http_msg.buffer_length], BUFFERSIZE - http_msg.http_header	65	mov [eax + http_msg.buffer_length], BUFFERSIZE - http_msg.http_header
66	mov [eax + http_msg.chunk_ptr], 0	66	mov [eax + http_msg.chunk_ptr], 0
67		67
68	mov [eax + http_msg.status], 0	68	mov [eax + http_msg.status], 0
69	mov [eax + http_msg.header_length], 0	69	mov [eax + http_msg.header_length], 0
70	mov [eax + http_msg.content_ptr], 0	70	mov [eax + http_msg.content_ptr], 0
71	mov [eax + http_msg.content_length], 0	71	mov [eax + http_msg.content_length], 0
72	mov [eax + http_msg.content_received], 0	72	mov [eax + http_msg.content_received], 0
73		73
74	push eax ebp	74	push eax ebp
75	mov ebp, eax	75	mov ebp, eax
76	mcall 26, 9	76	mcall 26, 9
77	mov [ebp + http_msg.timestamp], eax	77	mov [ebp + http_msg.timestamp], eax
78	pop ebp eax	78	pop ebp eax
79	}	79	}
80		80
81	section '.flat' code readable align 16	81	section '.flat' code readable align 16
82		82
83	;;===========================================================================;;	83	;;===========================================================================;;
84	lib_init: ;//////////////////////////////////////////////////////////////////;;	84	lib_init: ;//////////////////////////////////////////////////////////////////;;
85	;;---------------------------------------------------------------------------;;	85	;;---------------------------------------------------------------------------;;
86	;? Library entry point (called after library load) ;;	86	;? Library entry point (called after library load) ;;
87	;;---------------------------------------------------------------------------;;	87	;;---------------------------------------------------------------------------;;
88	;> eax = pointer to memory allocation routine ;;	88	;> eax = pointer to memory allocation routine ;;
89	;> ebx = pointer to memory freeing routine ;;	89	;> ebx = pointer to memory freeing routine ;;
90	;> ecx = pointer to memory reallocation routine ;;	90	;> ecx = pointer to memory reallocation routine ;;
91	;> edx = pointer to library loading routine ;;	91	;> edx = pointer to library loading routine ;;
92	;;---------------------------------------------------------------------------;;	92	;;---------------------------------------------------------------------------;;
93	;< eax = 1 (fail) / 0 (ok) ;;	93	;< eax = 1 (fail) / 0 (ok) ;;
94	;;===========================================================================;;	94	;;===========================================================================;;
95	mov [mem.alloc], eax	95	mov [mem.alloc], eax
96	mov [mem.free], ebx	96	mov [mem.free], ebx
97	mov [mem.realloc], ecx	97	mov [mem.realloc], ecx
98	mov [dll.load], edx	98	mov [dll.load], edx
99		99
100	invoke dll.load, @IMPORT	100	invoke dll.load, @IMPORT
101	test eax, eax	101	test eax, eax
102	jnz .error	102	jnz .error
103		103
104	; load proxy settings	104	; load proxy settings
105	pusha	105	pusha
106	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr	106	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr
107	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80	107	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80
108	mov [proxyPort], eax	108	mov [proxyPort], eax
109	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser	109	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser
110	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword	110	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword
111	popa	111	popa
112		112
113	DEBUGF 1, "HTTP library: init OK\n"	113	DEBUGF 1, "HTTP library: init OK\n"
114	xor eax, eax	114	xor eax, eax
115	ret	115	ret
116		116
117	.error:	117	.error:
118	DEBUGF 1, "ERROR loading libraries\n"	118	DEBUGF 1, "ERROR loading libraries\n"
119	xor eax, eax	119	xor eax, eax
120	inc eax	120	inc eax
121	ret	121	ret
122		122
123		123
124		124
125		125
126	;;================================================================================================;;	126	;;================================================================================================;;
127	proc HTTP_get URL, add_header ;///////////////////////////////////////////////////////////////////;;	127	proc HTTP_get URL, add_header ;///////////////////////////////////////////////////////////////////;;
128	;;------------------------------------------------------------------------------------------------;;	128	;;------------------------------------------------------------------------------------------------;;
129	;? Initiates a HTTP connection, using 'GET' method. ;;	129	;? Initiates a HTTP connection, using 'GET' method. ;;
130	;;------------------------------------------------------------------------------------------------;;	130	;;------------------------------------------------------------------------------------------------;;
131	;> URL = pointer to ASCIIZ URL ;;	131	;> URL = pointer to ASCIIZ URL ;;
132	;> add_header = pointer to additional header parameters (ASCIIZ), or null for none. ;;	132	;> add_header = pointer to additional header parameters (ASCIIZ), or null for none. ;;
133	;;------------------------------------------------------------------------------------------------;;	133	;;------------------------------------------------------------------------------------------------;;
134	;< eax = 0 (error) / buffer ptr ;;	134	;< eax = 0 (error) / buffer ptr ;;
135	;;================================================================================================;;	135	;;================================================================================================;;
136	locals	136	locals
137	hostname dd ?	137	hostname dd ?
138	pageaddr dd ?	138	pageaddr dd ?
139	sockaddr dd ?	139	sockaddr dd ?
140	socketnum dd ?	140	socketnum dd ?
141	buffer dd ?	141	buffer dd ?
142	port dd ?	142	port dd ?
143	endl	143	endl
144		144
145	pusha	145	pusha
146		146
147	; split the URL into hostname and pageaddr	147	; split the URL into hostname and pageaddr
148	stdcall parse_url, [URL]	148	stdcall parse_url, [URL]
149	test eax, eax	149	test eax, eax
150	jz .error	150	jz .error
151	mov [hostname], eax	151	mov [hostname], eax
152	mov [pageaddr], ebx	152	mov [pageaddr], ebx
153	mov [port], ecx	153	mov [port], ecx
154		154
155	; Connect to the other side.	155	; Connect to the other side.
156	stdcall open_connection, [hostname], [port]	156	stdcall open_connection, [hostname], [port]
157	test eax, eax	157	test eax, eax
158	jz .error	158	jz .error
159	mov [socketnum], eax	159	mov [socketnum], eax
160		160
161	; Create the HTTP request.	161	; Create the HTTP request.
162	invoke mem.alloc, BUFFERSIZE	162	invoke mem.alloc, BUFFERSIZE
163	test eax, eax	163	test eax, eax
164	jz .error	164	jz .error
165	mov [buffer], eax	165	mov [buffer], eax
166	mov edi, eax	166	mov edi, eax
167	DEBUGF 1, "Buffer allocated: 0x%x\n", eax	167	DEBUGF 1, "Buffer allocated: 0x%x\n", eax
168		168
169	mov esi, str_get	169	mov esi, str_get
170	copy_till_zero	170	copy_till_zero
171		171
172	; If we are using a proxy, send complete URL, otherwise send only page address.	172	; If we are using a proxy, send complete URL, otherwise send only page address.
173	cmp [proxyAddr], 0	173	cmp [proxyAddr], 0
174	je .no_proxy	174	je .no_proxy
175	mov esi, str_http ; prepend 'http://'	175	mov esi, str_http ; prepend 'http://'
176	copy_till_zero	176	copy_till_zero
177	mov esi, [hostname]	177	mov esi, [hostname]
178	copy_till_zero	178	copy_till_zero
179	.no_proxy:	179	.no_proxy:
180	mov esi, [pageaddr]	180	mov esi, [pageaddr]
181	copy_till_zero	181	copy_till_zero
182		182
183	mov esi, str_http11	183	mov esi, str_http11
184	mov ecx, str_http11.length	184	mov ecx, str_http11.length
185	rep movsb	185	rep movsb
186		186
187	mov esi, [hostname]	187	mov esi, [hostname]
188	copy_till_zero	188	copy_till_zero
189		189
190	cmp byte[proxyUser], 0	190	cmp byte[proxyUser], 0
191	je @f	191	je @f
192	call append_proxy_auth_header	192	call append_proxy_auth_header
193	@@:	193	@@:
194		194
195	mov ax, 0x0a0d	195	mov ax, 0x0a0d
196	stosw	196	stosw
197		197
198	mov esi, [add_header]	198	mov esi, [add_header]
199	test esi, esi	199	test esi, esi
200	jz @f	200	jz @f
201	copy_till_zero	201	copy_till_zero
202	@@:	202	@@:
203		203
204	mov esi, str_close	204	mov esi, str_close
205	mov ecx, str_close.length	205	mov ecx, str_close.length
206	rep movsb	206	rep movsb
207		207
208	mov byte[edi], 0	208	mov byte[edi], 0
209	DEBUGF 1, "Request:\n%s", [buffer]	209	DEBUGF 1, "Request:\n%s", [buffer]
210		210
211	; Free unused memory	211	; Free unused memory
212	push edi	212	push edi
213	invoke mem.free, [pageaddr]	213	invoke mem.free, [pageaddr]
214	invoke mem.free, [hostname]	214	invoke mem.free, [hostname]
215	pop esi	215	pop esi
216		216
217	; Send the request	217	; Send the request
218	sub esi, [buffer] ; length	218	sub esi, [buffer] ; length
219	xor edi, edi ; flags	219	xor edi, edi ; flags
220	mcall send, [socketnum], [buffer]	220	mcall send, [socketnum], [buffer]
221	test eax, eax	221	test eax, eax
222	jz .error	222	jz .error
223	DEBUGF 1, "Request has been sent to server.\n"	223	DEBUGF 1, "Request has been sent to server.\n"
224		224
225	HTTP_init_buffer [buffer], [socketnum]	225	HTTP_init_buffer [buffer], [socketnum]
226		226
227	popa	227	popa
228	mov eax, [buffer] ; return buffer ptr	228	mov eax, [buffer] ; return buffer ptr
229	ret	229	ret
230		230
231	.error:	231	.error:
232	DEBUGF 1, "Error!\n"	232	DEBUGF 1, "Error!\n"
233	popa	233	popa
234	xor eax, eax ; return 0 = error	234	xor eax, eax ; return 0 = error
235	ret	235	ret
236		236
237	endp	237	endp
238		238
239		239
240		240
241	;;================================================================================================;;	241	;;================================================================================================;;
242	proc HTTP_head URL, add_header ;//////////////////////////////////////////////////////////////////;;	242	proc HTTP_head URL, add_header ;//////////////////////////////////////////////////////////////////;;
243	;;------------------------------------------------------------------------------------------------;;	243	;;------------------------------------------------------------------------------------------------;;
244	;? Initiates a HTTP connection, using 'HEAD' method. ;;	244	;? Initiates a HTTP connection, using 'HEAD' method. ;;
245	;? This will only return HTTP header and status, no content ;;	245	;? This will only return HTTP header and status, no content ;;
246	;;------------------------------------------------------------------------------------------------;;	246	;;------------------------------------------------------------------------------------------------;;
247	;> URL = pointer to ASCIIZ URL ;;	247	;> URL = pointer to ASCIIZ URL ;;
248	;> add_header = pointer to additional header parameters (ASCIIZ), or null for none. ;;	248	;> add_header = pointer to additional header parameters (ASCIIZ), or null for none. ;;
249	;;------------------------------------------------------------------------------------------------;;	249	;;------------------------------------------------------------------------------------------------;;
250	;< eax = 0 (error) / buffer ptr ;;	250	;< eax = 0 (error) / buffer ptr ;;
251	;;================================================================================================;;	251	;;================================================================================================;;
252	locals	252	locals
253	hostname dd ?	253	hostname dd ?
254	pageaddr dd ?	254	pageaddr dd ?
255	sockaddr dd ?	255	sockaddr dd ?
256	socketnum dd ?	256	socketnum dd ?
257	buffer dd ?	257	buffer dd ?
258	port dd ?	258	port dd ?
259	endl	259	endl
260		260
261	pusha	261	pusha
262	; split the URL into hostname and pageaddr	262	; split the URL into hostname and pageaddr
263	stdcall parse_url, [URL]	263	stdcall parse_url, [URL]
264	test eax, eax	264	test eax, eax
265	jz .error	265	jz .error
266	mov [hostname], eax	266	mov [hostname], eax
267	mov [pageaddr], ebx	267	mov [pageaddr], ebx
268	mov [port], ecx	268	mov [port], ecx
269		269
270	; Connect to the other side.	270	; Connect to the other side.
271	stdcall open_connection, [hostname], [port]	271	stdcall open_connection, [hostname], [port]
272	test eax, eax	272	test eax, eax
273	jz .error	273	jz .error
274	mov [socketnum], eax	274	mov [socketnum], eax
275		275
276	; Create the HTTP request.	276	; Create the HTTP request.
277	invoke mem.alloc, BUFFERSIZE	277	invoke mem.alloc, BUFFERSIZE
278	test eax, eax	278	test eax, eax
279	jz .error	279	jz .error
280	mov [buffer], eax	280	mov [buffer], eax
281	mov edi, eax	281	mov edi, eax
282	DEBUGF 1, "Buffer has been allocated.\n"	282	DEBUGF 1, "Buffer has been allocated.\n"
283		283
284	mov esi, str_head	284	mov esi, str_head
285	copy_till_zero	285	copy_till_zero
286		286
287	; If we are using a proxy, send complete URL, otherwise send only page address.	287	; If we are using a proxy, send complete URL, otherwise send only page address.
288	cmp [proxyAddr], 0	288	cmp [proxyAddr], 0
289	je .no_proxy	289	je .no_proxy
290	mov esi, str_http ; prepend 'http://'	290	mov esi, str_http ; prepend 'http://'
291	copy_till_zero	291	copy_till_zero
292	mov esi, [hostname]	292	mov esi, [hostname]
293	copy_till_zero	293	copy_till_zero
294	.no_proxy:	294	.no_proxy:
295	mov esi, [pageaddr]	295	mov esi, [pageaddr]
296	copy_till_zero	296	copy_till_zero
297		297
298	mov esi, str_http11	298	mov esi, str_http11
299	mov ecx, str_http11.length	299	mov ecx, str_http11.length
300	rep movsb	300	rep movsb
301		301
302	mov esi, [hostname]	302	mov esi, [hostname]
303	copy_till_zero	303	copy_till_zero
304		304
305	cmp byte[proxyUser], 0	305	cmp byte[proxyUser], 0
306	je @f	306	je @f
307	call append_proxy_auth_header	307	call append_proxy_auth_header
308	@@:	308	@@:
309		309
310	mov ax, 0x0a0d	310	mov ax, 0x0a0d
311	stosw	311	stosw
312		312
313	mov esi, [add_header]	313	mov esi, [add_header]
314	test esi, esi	314	test esi, esi
315	jz @f	315	jz @f
316	copy_till_zero	316	copy_till_zero
317	@@:	317	@@:
318		318
319	mov esi, str_close	319	mov esi, str_close
320	mov ecx, str_close.length	320	mov ecx, str_close.length
321	rep movsb	321	rep movsb
322		322
323	mov byte[edi], 0	323	mov byte[edi], 0
324	DEBUGF 1, "Request:\n%s", [buffer]	324	DEBUGF 1, "Request:\n%s", [buffer]
325		325
326		326
327	; Free unused memory	327	; Free unused memory
328	push edi	328	push edi
329	invoke mem.free, [pageaddr]	329	invoke mem.free, [pageaddr]
330	invoke mem.free, [hostname]	330	invoke mem.free, [hostname]
331	pop esi	331	pop esi
332		332
333	; Send the request	333	; Send the request
334	sub esi, [buffer] ; length	334	sub esi, [buffer] ; length
335	xor edi, edi ; flags	335	xor edi, edi ; flags
336	mcall send, [socketnum], [buffer]	336	mcall send, [socketnum], [buffer]
337	test eax, eax	337	test eax, eax
338	jz .error	338	jz .error
339	DEBUGF 1, "Request has been sent to server.\n"	339	DEBUGF 1, "Request has been sent to server.\n"
340		340
341	HTTP_init_buffer [buffer], [socketnum]	341	HTTP_init_buffer [buffer], [socketnum]
342		342
343	popa	343	popa
344	mov eax, [buffer]	344	mov eax, [buffer]
345	ret ; return buffer ptr	345	ret ; return buffer ptr
346		346
347	.error:	347	.error:
348	DEBUGF 1, "Error!\n"	348	DEBUGF 1, "Error!\n"
349	popa	349	popa
350	xor eax, eax ; return 0 = error	350	xor eax, eax ; return 0 = error
351	ret	351	ret
352		352
353	endp	353	endp
354		354
355		355
356	;;================================================================================================;;	356	;;================================================================================================;;
357	proc HTTP_post URL, add_header, content_type, content_length ;////////////////////////////////////;;	357	proc HTTP_post URL, add_header, content_type, content_length ;////////////////////////////////////;;
358	;;------------------------------------------------------------------------------------------------;;	358	;;------------------------------------------------------------------------------------------------;;
359	;? Initiates a HTTP connection, using 'POST' method. ;;	359	;? Initiates a HTTP connection, using 'POST' method. ;;
360	;? This method is used to send data to the HTTP server ;;	360	;? This method is used to send data to the HTTP server ;;
361	;;------------------------------------------------------------------------------------------------;;	361	;;------------------------------------------------------------------------------------------------;;
362	;> URL = pointer to ASCIIZ URL ;;	362	;> URL = pointer to ASCIIZ URL ;;
363	;> add_header = pointer to additional header parameters (ASCIIZ), or null for none. ;;	363	;> add_header = pointer to additional header parameters (ASCIIZ), or null for none. ;;
364	;> content_type = pointer to ASCIIZ string containing content type ;;	364	;> content_type = pointer to ASCIIZ string containing content type ;;
365	;> content_length = length of content (in bytes) ;;	365	;> content_length = length of content (in bytes) ;;
366	;;------------------------------------------------------------------------------------------------;;	366	;;------------------------------------------------------------------------------------------------;;
367	;< eax = 0 (error) / buffer ptr ;;	367	;< eax = 0 (error) / buffer ptr ;;
368	;;================================================================================================;;	368	;;================================================================================================;;
369	locals	369	locals
370	hostname dd ?	370	hostname dd ?
371	pageaddr dd ?	371	pageaddr dd ?
372	sockaddr dd ?	372	sockaddr dd ?
373	socketnum dd ?	373	socketnum dd ?
374	buffer dd ?	374	buffer dd ?
375	port dd ?	375	port dd ?
376	endl	376	endl
377		377
378	pusha	378	pusha
379	; split the URL into hostname and pageaddr	379	; split the URL into hostname and pageaddr
380	stdcall parse_url, [URL]	380	stdcall parse_url, [URL]
381	test eax, eax	381	test eax, eax
382	jz .error	382	jz .error
383	mov [hostname], eax	383	mov [hostname], eax
384	mov [pageaddr], ebx	384	mov [pageaddr], ebx
385	mov [port], ecx	385	mov [port], ecx
386		386
387	; Connect to the other side.	387	; Connect to the other side.
388	stdcall open_connection, [hostname], [port]	388	stdcall open_connection, [hostname], [port]
389	test eax, eax	389	test eax, eax
390	jz .error	390	jz .error
391	mov [socketnum], eax	391	mov [socketnum], eax
392		392
393	; Create the HTTP request.	393	; Create the HTTP request.
394	invoke mem.alloc, BUFFERSIZE	394	invoke mem.alloc, BUFFERSIZE
395	test eax, eax	395	test eax, eax
396	jz .error	396	jz .error
397	mov [buffer], eax	397	mov [buffer], eax
398	mov edi, eax	398	mov edi, eax
399	DEBUGF 1, "Buffer has been allocated.\n"	399	DEBUGF 1, "Buffer has been allocated.\n"
400		400
401	mov esi, str_post	401	mov esi, str_post
402	copy_till_zero	402	copy_till_zero
403		403
404	; If we are using a proxy, send complete URL, otherwise send only page address.	404	; If we are using a proxy, send complete URL, otherwise send only page address.
405	cmp [proxyAddr], 0	405	cmp [proxyAddr], 0
406	je .no_proxy	406	je .no_proxy
407	mov esi, str_http ; prepend 'http://'	407	mov esi, str_http ; prepend 'http://'
408	copy_till_zero	408	copy_till_zero
409	mov esi, [hostname]	409	mov esi, [hostname]
410	copy_till_zero	410	copy_till_zero
411	.no_proxy:	411	.no_proxy:
412	mov esi, [pageaddr]	412	mov esi, [pageaddr]
413	copy_till_zero	413	copy_till_zero
414		414
415	mov esi, str_http11	415	mov esi, str_http11
416	mov ecx, str_http11.length	416	mov ecx, str_http11.length
417	rep movsb	417	rep movsb
418		418
419	mov esi, [hostname]	419	mov esi, [hostname]
420	copy_till_zero	420	copy_till_zero
421		421
422	mov esi, str_post_cl	422	mov esi, str_post_cl
423	mov ecx, str_post_cl.length	423	mov ecx, str_post_cl.length
424	rep movsb	424	rep movsb
425		425
426	mov eax, [content_length]	426	mov eax, [content_length]
427	call eax_ascii_dec	427	call eax_ascii_dec
428		428
429	mov esi, str_post_ct	429	mov esi, str_post_ct
430	mov ecx, str_post_ct.length	430	mov ecx, str_post_ct.length
431	rep movsb	431	rep movsb
432		432
433	mov esi, [content_type]	433	mov esi, [content_type]
434	copy_till_zero	434	copy_till_zero
435		435
436	cmp byte[proxyUser], 0	436	cmp byte[proxyUser], 0
437	je @f	437	je @f
438	call append_proxy_auth_header	438	call append_proxy_auth_header
439	@@:	439	@@:
440		440
441	mov ax, 0x0a0d	441	mov ax, 0x0a0d
442	stosw	442	stosw
443		443
444	mov esi, [add_header]	444	mov esi, [add_header]
445	test esi, esi	445	test esi, esi
446	jz @f	446	jz @f
447	copy_till_zero	447	copy_till_zero
448	@@:	448	@@:
449		449
450	mov esi, str_close	450	mov esi, str_close
451	mov ecx, str_close.length	451	mov ecx, str_close.length
452	rep movsb	452	rep movsb
453		453
454	mov byte[edi], 0	454	mov byte[edi], 0
455	DEBUGF 1, "Request:\n%s", [buffer]	455	DEBUGF 1, "Request:\n%s", [buffer]
456		456
457	; Free unused memory	457	; Free unused memory
458	push edi	458	push edi
459	invoke mem.free, [pageaddr]	459	invoke mem.free, [pageaddr]
460	invoke mem.free, [hostname]	460	invoke mem.free, [hostname]
461	pop esi	461	pop esi
462		462
463	; Send the request	463	; Send the request
464	sub esi, [buffer] ; length	464	sub esi, [buffer] ; length
465	xor edi, edi ; flags	465	xor edi, edi ; flags
466	mcall send, [socketnum], [buffer]	466	mcall send, [socketnum], [buffer]
467	test eax, eax	467	test eax, eax
468	jz .error	468	jz .error
469	DEBUGF 1, "Request has been sent to server.\n"	469	DEBUGF 1, "Request has been sent to server.\n"
470		470
471	HTTP_init_buffer [buffer], [socketnum]	471	HTTP_init_buffer [buffer], [socketnum]
472		472
473	popa	473	popa
474	mov eax, [buffer]	474	mov eax, [buffer]
475	ret ; return buffer ptr	475	ret ; return buffer ptr
476		476
477	.error:	477	.error:
478	DEBUGF 1, "Error!\n"	478	DEBUGF 1, "Error!\n"
479	popa	479	popa
480	xor eax, eax ; return 0 = error	480	xor eax, eax ; return 0 = error
481	ret	481	ret
482		482
483	endp	483	endp
484		484
485		485
486		486
487	;;================================================================================================;;	487	;;================================================================================================;;
488	proc HTTP_process identifier ;////////////////////////////////////////////////////////////////////;;	488	proc HTTP_process identifier ;////////////////////////////////////////////////////////////////////;;
489	;;------------------------------------------------------------------------------------------------;;	489	;;------------------------------------------------------------------------------------------------;;
490	;? Receive data from the server, parse headers and put data in receive buffer. ;;	490	;? Receive data from the server, parse headers and put data in receive buffer. ;;
491	;? To complete a transfer, this procedure must be called over and over again untill it returns 0. ;;	491	;? To complete a transfer, this procedure must be called over and over again untill it returns 0. ;;
492	;;------------------------------------------------------------------------------------------------;;	492	;;------------------------------------------------------------------------------------------------;;
493	;> identifier = pointer to buffer containing http_msg struct. ;;	493	;> identifier = pointer to buffer containing http_msg struct. ;;
494	;;------------------------------------------------------------------------------------------------;;	494	;;------------------------------------------------------------------------------------------------;;
495	;< eax = -1 (not finished) / 0 finished ;;	495	;< eax = -1 (not finished) / 0 finished ;;
496	;;================================================================================================;;	496	;;================================================================================================;;
497		497
498	pusha	498	pusha
499	mov ebp, [identifier]	499	mov ebp, [identifier]
500		500

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm – Rev 4829 → 4830