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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2017. 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__ = 2
 
 
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, flags {
 
        mov     eax, buffer
        push    socketnum
        popd    [eax + http_msg.socket]
        lea     esi, [eax + http_msg.http_header]
        push    flags
        pop     [eax + http_msg.flags]
        or      [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  2, "ERROR loading http.obj dependencies\n"
        xor     eax, eax
        inc     eax
        ret
 
 
;;================================================================================================;;
proc HTTP_disconnect identifier ;/////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Stops the open connection                                                                      ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< none                                                                                           ;;
;;================================================================================================;;
 
        pusha
        mov     ebp, [identifier]
 
        test    [ebp + http_msg.flags], FLAG_CONNECTED
        jz      .error
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
 
        popa
        ret
 
  .error:
        DEBUGF  1, "Cannot close already closed connection!\n"
        popa
        ret
 
endp
 
 
;;================================================================================================;;
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_get URL, identifier, flags, add_header ;////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'GET' method.                                               ;;
;;------------------------------------------------------------------------------------------------;;
;> URL                  = pointer to ASCIIZ URL                                                   ;;
;> identifier           = Identifier of an already open connection, or NULL to create a new one.  ;;
;> flags                = Flags indicating how to threat the connection.                          ;;
;> add_header           = pointer to additional header parameters (ASCIIZ), or NULL for none.     ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        and     [flags], 0xff00       ; filter out invalid flags
 
        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
 
        mov     eax, [identifier]
        test    eax, eax
        jz      .open_new
        test    [eax + http_msg.flags], FLAG_CONNECTED
        jz      .error
        mov     eax, [eax + http_msg.socket]
        mov     [socketnum], eax
        jmp     .send_request
 
; Connect to the other side.
  .open_new:
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
  .send_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
        test    [flags], FLAG_KEEPALIVE
        jz      @f
        mov     esi, str_keep
        mov     ecx, str_keep.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"
 
        cmp     [identifier], 0
        je      .new_connection
        invoke  mem.free, [buffer]
        mov     eax, [identifier]
        mov     [buffer], eax
  .new_connection:
        HTTP_init_buffer [buffer], [socketnum], [flags]
        popa
        mov     eax, [buffer]   ; return buffer ptr
        ret
 
  .error:
        DEBUGF  2, "HTTP GET error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_head URL, identifier, flags, add_header ;///////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'HEAD' method.                                              ;;
;? This will only return HTTP header and status, no content                                       ;;
;;------------------------------------------------------------------------------------------------;;
;> URL                  = pointer to ASCIIZ URL                                                   ;;
;> identifier           = Identifier of an already open connection, or NULL to create a new one.  ;;
;> flags                = Flags indicating how to threat the connection.                          ;;
;> add_header           = pointer to additional header parameters (ASCIIZ), or NULL for none.     ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        and     [flags], 0xff00         ; filter out invalid flags
 
        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
 
        mov     eax, [identifier]
        test    eax, eax
        jz      .open_new
        test    [eax + http_msg.flags], FLAG_CONNECTED
        jz      .error
        mov     eax, [eax + http_msg.socket]
        mov     [socketnum], eax
        jmp     .send_request
 
; Connect to the other side.
  .open_new:
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
  .send_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
        test    [flags], FLAG_KEEPALIVE
        jz      @f
        mov     esi, str_keep
        mov     ecx, str_keep.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"
 
        cmp     [identifier], 0
        je      .new_connection
        invoke  mem.free, [buffer]
        mov     eax, [identifier]
        mov     [buffer], eax
  .new_connection:
        HTTP_init_buffer [buffer], [socketnum], [flags]
        popa
        mov     eax, [buffer]   ; return buffer ptr
        ret
 
  .error:
        DEBUGF  2, "HTTP HEAD error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
;;================================================================================================;;
proc HTTP_post URL, identifier, flags, 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                                                   ;;
;> identifier           = Identifier of an already open connection, or NULL to create a new one.  ;;
;> flags                = Flags indicating how to threat the connection.                          ;;
;> 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 (aka Identifier)                                                  ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        and     [flags], 0xff00       ; filter out invalid flags
 
        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
 
        mov     eax, [identifier]
        test    eax, eax
        jz      .open_new
        test    [eax + http_msg.flags], FLAG_CONNECTED
        jz      .error
        mov     eax, [eax + http_msg.socket]
        mov     [socketnum], eax
        jmp     .send_request
 
; Connect to the other side.
  .open_new:
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
  .send_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
        test    [flags], FLAG_KEEPALIVE
        jz      @f
        mov     esi, str_keep
        mov     ecx, str_keep.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"
 
        cmp     [identifier], 0
        je      .new_connection
        invoke  mem.free, [buffer]
        mov     eax, [identifier]
        mov     [buffer], eax
  .new_connection:
        HTTP_init_buffer [buffer], [socketnum], [flags]
        popa
        mov     eax, [buffer]   ; return buffer ptr
        ret
 
  .error:
        DEBUGF  2, "HTTP POST error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_receive identifier ;////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Receive data from the server, parse headers and put data in receive buffer(s).                 ;;
;? 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
 
; If the buffer is full, allocate a new one
        cmp     [ebp + http_msg.buffer_length], 0
        jne     .receive
 
        test    [ebp + http_msg.flags], FLAG_STREAM
        jz      .err_header
 
        test    [ebp + http_msg.flags], FLAG_REUSE_BUFFER
        jz      .new_buffer
 
        mov     eax, [ebp + http_msg.content_ptr]
        mov     [ebp + http_msg.write_ptr], eax
        mov     [ebp + http_msg.buffer_length], BUFFERSIZE
        jmp     .receive
 
  .new_buffer:
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .err_no_ram
        mov     [ebp + http_msg.content_ptr], eax
        mov     [ebp + http_msg.write_ptr], eax
        mov     [ebp + http_msg.buffer_length], BUFFERSIZE
        DEBUGF  1, "New buffer: 0x%x\n", eax
 
; Receive some data
  .receive:
        mov     edi, MSG_DONTWAIT
        test    [ebp + http_msg.flags], FLAG_BLOCK
        jz      @f
        xor     edi, edi
  @@:
        mcall   recv, [ebp + http_msg.socket], [ebp + http_msg.write_ptr], \
                      [ebp + http_msg.buffer_length]
        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?
  .multibuffer:
; 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:
        DEBUGF  1, "chunk_loop write_ptr=0x%x chunk_ptr=0x%x\n", [ebp + http_msg.write_ptr], [ebp + http_msg.chunk_ptr]
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, [ebp + http_msg.chunk_ptr]
        jbe     .need_more_data_chunked                 ; amount of available bytes after chunkline start
 
; Chunkline starts here, convert the ASCII hex number into ebx
        mov     esi, [ebp + http_msg.chunk_ptr]
 
 
        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 chunkline length
        mov     edx, esi
        sub     edx, [ebp + http_msg.chunk_ptr]         ; edx is now length of chunkline
        DEBUGF  1, "Chunkline is %u bytes long\n", edx
; Calculate how many data bytes we have received already
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, [ebp + http_msg.chunk_ptr]
        sub     ecx, edx                                ; ecx is now number of received data bytes (without chunkline)
; Update content_received counter
        add     [ebp + http_msg.content_received], ecx
; Calculate new write ptr
 
 
        sub     [ebp + http_msg.write_ptr], edx
        test    [ebp + http_msg.flags], FLAG_STREAM
        jnz     .dont_resize
; 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!
  .dont_resize:
; 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]
        DEBUGF  1, "Removing chunkline esi=0x%x edi=0x%x ecx=%u\n", esi, edi, ecx
        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:
        test    [ebp + http_msg.flags], FLAG_STREAM
        jnz     .multibuff
        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
 
  .multibuff:
        ; This buffer is full
        popa
        xor     eax, 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
        test    [ebp + http_msg.flags], FLAG_KEEPALIVE
        jnz     @f
        mcall   close, [ebp + http_msg.socket]
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
  @@:
        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  2, "ERROR: server closed connection unexpectedly\n"
        or      [ebp + http_msg.flags], FLAG_TRANSFER_FAILED
        jmp     .abort
 
  .err_header:
        pop     eax
        DEBUGF  2, "ERROR: invalid header\n"
        or      [ebp + http_msg.flags], FLAG_INVALID_HEADER
        jmp     .abort
 
  .err_no_ram:
        DEBUGF  2, "ERROR: out of RAM\n"
        or      [ebp + http_msg.flags], FLAG_NO_RAM
        jmp     .abort
 
  .err_timeout:
        DEBUGF  2, "ERROR: timeout\n"
        or      [ebp + http_msg.flags], FLAG_TIMEOUT_ERROR
        jmp     .abort
 
  .err_socket:
        DEBUGF  2, "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:
 
        test    [ebp + http_msg.flags], FLAG_STREAM
        jz      @f
        mov     edx, BUFFERSIZE
  @@:
 
; 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_send identifier, dataptr, datalength ;//////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Send data to the server                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;> dataptr      = pointer to data to be sent.                                                     ;;
;> datalength   = length of data (in bytes) to be sent                                            ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = number of bytes sent, -1 on error                                                        ;;
;;================================================================================================;;
 
        push    ebx ecx edx esi edi
        mov     edx, [identifier]
        test    [edx + http_msg.flags], FLAG_CONNECTED
        jz      .fail
        mcall   send, [edx + http_msg.socket], [dataptr], [datalength], 0
        pop     edi esi edx ecx ebx
        ret
 
  .fail:
        pop     edi esi edx ecx ebx
        xor     eax, eax
        dec     eax
        ret
 
endp
 
 
;;================================================================================================;;
proc HTTP_find_header_field identifier, headername ;//////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Find a header field in the received HTTP header                                                ;;
;?                                                                                                ;;
;? NOTE: this function returns a pointer which points into the original header data.              ;;
;? The header field is terminated by a CR, LF, space or maybe even tab.                           ;;
;? A free operation should not be operated on this pointer!                                       ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = ptr to http_msg struct                                                          ;;
;> headername   = ptr to ASCIIZ string containing 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 HTTP_escape URI, length ;////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;?                                                                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> URI = ptr to ASCIIZ URI/data                                                                   ;;
;> length = length of URI/data                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ URI/data                                                       ;;
;< ebx = length of escaped URI/data                                                               ;;
;;================================================================================================;;
 
        DEBUGF  1, "HTTP_escape: %s\n", [URI]
 
        pusha
 
        invoke  mem.alloc, URLMAXLEN            ; FIXME: use length provided by caller to guess final size.
        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, 3
        and     bl, not 3
        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
        sub     edi, [esp + 7 * 4]
        dec     edi
        mov     [esp + 4 * 4], edi
 
        popa
        DEBUGF  1, "escaped URL: %s\n", eax
        ret
 
  .error:
        DEBUGF  2, "ERROR: out of RAM!\n"
        popa
        xor     eax, eax
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_unescape URI, length ;//////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;?                                                                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> URI = ptr to ASCIIZ URI                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ URI                                                            ;;
;;================================================================================================;;
 
        DEBUGF  1, "HTTP_unescape: %s\n", [URI]
        pusha
 
        invoke  mem.alloc, URLMAXLEN            ; FIXME: use length provided by caller
        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  2, "ERROR: invalid URI!\n"
        jmp     .loop
 
  .done:
        stosb
        popa
        DEBUGF  1, "unescaped URL: %s\n", eax
        ret
 
  .error:
        DEBUGF  2, "ERROR: out of RAM!\n"
        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
        invoke  getaddrinfo, [hostname], 0, 0, esp
        pop     esi
        test    eax, eax
        jnz     .error1
 
; getaddrinfo returns addrinfo struct, make the pointer to sockaddr struct
        push    esi     ; for freeaddrinfo
        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
 
; Open a new TCP socket
        mcall   socket, AF_INET4, SOCK_STREAM, 0
        test    eax, eax
        jz      .error3
        mov     [socketnum], eax
        DEBUGF  1, "Socket: 0x%x\n", eax
 
; Connect to the server
        mcall   connect, [socketnum], [sockaddr], 18
        test    eax, eax
        jnz     .error3
        DEBUGF  1, "Socket is now connected.\n"
 
        invoke  freeaddrinfo            ; Free allocated memory
        mov     eax, [socketnum]
        ret
 
  .error3:
        DEBUGF  2, "Could not connect to the remote server\n"
        invoke  freeaddrinfo            ; Free allocated memory
        xor     eax, eax
        ret
 
  .error2:
        DEBUGF  2, "Resolving hostname failed\n"
        invoke  freeaddrinfo            ; Free allocated memory
        xor     eax, eax
        ret
 
  .error1:
        DEBUGF  2, "Contacting DNS server failed with EAI code: %x\n", eax
        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     edi, [URL]
        mov     ecx, URLMAXLEN
        mov     ax, '//'
  .loop1:
        cmp     byte[edi], 0            ; end of URL?
        je      .url_ok                 ; yep, so not found
        cmp     [edi], ax
        je      .skip_proto
        inc     edi
        dec     ecx
        jnz     .loop1
        jmp     .invalid
 
  .skip_proto:
        inc     edi                     ; skip the two '/'
        inc     edi
        mov     [URL], edi              ; update pointer so it skips protocol
 
; Find the trailing 0 byte
        xor     al, al
        repne   scasb
        jne     .invalid                ; ecx reached 0 before we reached end of string
 
  .url_ok:
        sub     edi, [URL]              ; calculate total length of URL
        mov     [urlsize], edi
 
; now look for page delimiter - it's a '/' character
        mov     ecx, edi                ; 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  2, "Out of memory!\n"
        xor     eax, eax
        ret
 
  .invalid:
        DEBUGF  2, "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                                                ;;
;;===========================================================================;;
;;///////////////////////////////////////////////////////////////////////////;;
;;===========================================================================;;
 
 
HTTP_stop = HTTP_disconnect
HTTP_process = HTTP_receive
 
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'             , \    ; To be removed
        HTTP_send               , 'send'                , \
        HTTP_receive            , 'receive'             , \
        HTTP_disconnect         , 'disconnect'          , \
        HTTP_free               , 'free'                , \
        HTTP_stop               , 'stop'                , \    ; To be removed
        HTTP_escape             , 'escape'              , \
        HTTP_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.1', 13, 10, 'Connection: Close', 13, 10, 13, 10
  .length       = $ - str_close
str_keep        db 'User-Agent: KolibriOS libHTTP/1.1', 13, 10, 'Connection: Keepalive', 13, 10, 13, 10
  .length       = $ - str_keep
 
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 7009	Rev 7091
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2017. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2017. 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__ = 2	26	__DEBUG_LEVEL__ = 2
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, flags {	57	macro HTTP_init_buffer buffer, socketnum, flags {
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	push flags	63	push flags
64	pop [eax + http_msg.flags]	64	pop [eax + http_msg.flags]
65	or [eax + http_msg.flags], FLAG_CONNECTED	65	or [eax + http_msg.flags], FLAG_CONNECTED
66	mov [eax + http_msg.write_ptr], esi	66	mov [eax + http_msg.write_ptr], esi
67	mov [eax + http_msg.buffer_length], BUFFERSIZE - http_msg.http_header	67	mov [eax + http_msg.buffer_length], BUFFERSIZE - http_msg.http_header
68	mov [eax + http_msg.chunk_ptr], 0	68	mov [eax + http_msg.chunk_ptr], 0
69		69
70	mov [eax + http_msg.status], 0	70	mov [eax + http_msg.status], 0
71	mov [eax + http_msg.header_length], 0	71	mov [eax + http_msg.header_length], 0
72	mov [eax + http_msg.content_ptr], 0	72	mov [eax + http_msg.content_ptr], 0
73	mov [eax + http_msg.content_length], 0	73	mov [eax + http_msg.content_length], 0
74	mov [eax + http_msg.content_received], 0	74	mov [eax + http_msg.content_received], 0
75		75
76	push eax ebp	76	push eax ebp
77	mov ebp, eax	77	mov ebp, eax
78	mcall 26, 9	78	mcall 26, 9
79	mov [ebp + http_msg.timestamp], eax	79	mov [ebp + http_msg.timestamp], eax
80	pop ebp eax	80	pop ebp eax
81	}	81	}
82		82
83	section '.flat' code readable align 16	83	section '.flat' code readable align 16
84		84
85	;;===========================================================================;;	85	;;===========================================================================;;
86	lib_init: ;//////////////////////////////////////////////////////////////////;;	86	lib_init: ;//////////////////////////////////////////////////////////////////;;
87	;;---------------------------------------------------------------------------;;	87	;;---------------------------------------------------------------------------;;
88	;? Library entry point (called after library load) ;;	88	;? Library entry point (called after library load) ;;
89	;;---------------------------------------------------------------------------;;	89	;;---------------------------------------------------------------------------;;
90	;> eax = pointer to memory allocation routine ;;	90	;> eax = pointer to memory allocation routine ;;
91	;> ebx = pointer to memory freeing routine ;;	91	;> ebx = pointer to memory freeing routine ;;
92	;> ecx = pointer to memory reallocation routine ;;	92	;> ecx = pointer to memory reallocation routine ;;
93	;> edx = pointer to library loading routine ;;	93	;> edx = pointer to library loading routine ;;
94	;;---------------------------------------------------------------------------;;	94	;;---------------------------------------------------------------------------;;
95	;< eax = 1 (fail) / 0 (ok) ;;	95	;< eax = 1 (fail) / 0 (ok) ;;
96	;;===========================================================================;;	96	;;===========================================================================;;
97	mov [mem.alloc], eax	97	mov [mem.alloc], eax
98	mov [mem.free], ebx	98	mov [mem.free], ebx
99	mov [mem.realloc], ecx	99	mov [mem.realloc], ecx
100	mov [dll.load], edx	100	mov [dll.load], edx
101		101
102	invoke dll.load, @IMPORT	102	invoke dll.load, @IMPORT
103	test eax, eax	103	test eax, eax
104	jnz .error	104	jnz .error
105		105
106	; load proxy settings	106	; load proxy settings
107	pusha	107	pusha
108	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr	108	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr
109	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80	109	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80
110	mov [proxyPort], eax	110	mov [proxyPort], eax
111	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser	111	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser
112	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword	112	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword
113	popa	113	popa
114		114
115	DEBUGF 1, "HTTP library: init OK\n"	115	DEBUGF 1, "HTTP library: init OK\n"
116	xor eax, eax	116	xor eax, eax
117	ret	117	ret
118		118
119	.error:	119	.error:
120	DEBUGF 2, "ERROR loading http.obj dependencies\n"	120	DEBUGF 2, "ERROR loading http.obj dependencies\n"
121	xor eax, eax	121	xor eax, eax
122	inc eax	122	inc eax
123	ret	123	ret
124		124
125		125
126	;;================================================================================================;;	126	;;================================================================================================;;
127	proc HTTP_disconnect identifier ;/////////////////////////////////////////////////////////////////;;	127	proc HTTP_disconnect identifier ;/////////////////////////////////////////////////////////////////;;
128	;;------------------------------------------------------------------------------------------------;;	128	;;------------------------------------------------------------------------------------------------;;
129	;? Stops the open connection ;;	129	;? Stops the open connection ;;
130	;;------------------------------------------------------------------------------------------------;;	130	;;------------------------------------------------------------------------------------------------;;
131	;> identifier = pointer to buffer containing http_msg struct. ;;	131	;> identifier = pointer to buffer containing http_msg struct. ;;
132	;;------------------------------------------------------------------------------------------------;;	132	;;------------------------------------------------------------------------------------------------;;
133	;< none ;;	133	;< none ;;
134	;;================================================================================================;;	134	;;================================================================================================;;
135		135
136	pusha	136	pusha
137	mov ebp, [identifier]	137	mov ebp, [identifier]
138		138
139	test [ebp + http_msg.flags], FLAG_CONNECTED	139	test [ebp + http_msg.flags], FLAG_CONNECTED
140	jz .error	140	jz .error
141	and [ebp + http_msg.flags], not FLAG_CONNECTED	141	and [ebp + http_msg.flags], not FLAG_CONNECTED
142	mcall close, [ebp + http_msg.socket]	142	mcall close, [ebp + http_msg.socket]
143		143
144	popa	144	popa
145	ret	145	ret
146		146
147	.error:	147	.error:
148	DEBUGF 1, "Cannot close already closed connection!\n"	148	DEBUGF 1, "Cannot close already closed connection!\n"
149	popa	149	popa
150	ret	150	ret
151		151
152	endp	152	endp
153		153
154		154
155	;;================================================================================================;;	155	;;================================================================================================;;
156	proc HTTP_free identifier ;///////////////////////////////////////////////////////////////////////;;	156	proc HTTP_free identifier ;///////////////////////////////////////////////////////////////////////;;
157	;;------------------------------------------------------------------------------------------------;;	157	;;------------------------------------------------------------------------------------------------;;
158	;? Free the http_msg structure ;;	158	;? Free the http_msg structure ;;
159	;;------------------------------------------------------------------------------------------------;;	159	;;------------------------------------------------------------------------------------------------;;
160	;> identifier = pointer to buffer containing http_msg struct. ;;	160	;> identifier = pointer to buffer containing http_msg struct. ;;
161	;;------------------------------------------------------------------------------------------------;;	161	;;------------------------------------------------------------------------------------------------;;
162	;< none ;;	162	;< none ;;
163	;;================================================================================================;;	163	;;================================================================================================;;
164	DEBUGF 1, "HTTP_free: 0x%x\n", [identifier]	164	DEBUGF 1, "HTTP_free: 0x%x\n", [identifier]
165	pusha	165	pusha
166	mov ebp, [identifier]	166	mov ebp, [identifier]
167		167
168	test [ebp + http_msg.flags], FLAG_CONNECTED	168	test [ebp + http_msg.flags], FLAG_CONNECTED
169	jz .not_connected	169	jz .not_connected
170	and [ebp + http_msg.flags], not FLAG_CONNECTED	170	and [ebp + http_msg.flags], not FLAG_CONNECTED
171	mcall close, [ebp + http_msg.socket]	171	mcall close, [ebp + http_msg.socket]
172		172
173	.not_connected:	173	.not_connected:
174	invoke mem.free, ebp	174	invoke mem.free, ebp
175		175
176	popa	176	popa
177	ret	177	ret
178		178
179	endp	179	endp
180		180
181		181
182		182
183	;;================================================================================================;;	183	;;================================================================================================;;
184	proc HTTP_get URL, identifier, flags, add_header ;////////////////////////////////////////////////;;	184	proc HTTP_get URL, identifier, flags, add_header ;////////////////////////////////////////////////;;
185	;;------------------------------------------------------------------------------------------------;;	185	;;------------------------------------------------------------------------------------------------;;
186	;? Initiates a HTTP connection, using 'GET' method. ;;	186	;? Initiates a HTTP connection, using 'GET' method. ;;
187	;;------------------------------------------------------------------------------------------------;;	187	;;------------------------------------------------------------------------------------------------;;
188	;> URL = pointer to ASCIIZ URL ;;	188	;> URL = pointer to ASCIIZ URL ;;
189	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;	189	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;
190	;> flags = Flags indicating how to threat the connection. ;;	190	;> flags = Flags indicating how to threat the connection. ;;
191	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;	191	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;
192	;;------------------------------------------------------------------------------------------------;;	192	;;------------------------------------------------------------------------------------------------;;
193	;< eax = 0 (error) / buffer ptr ;;	193	;< eax = 0 (error) / buffer ptr ;;
194	;;================================================================================================;;	194	;;================================================================================================;;
195	locals	195	locals
196	hostname dd ?	196	hostname dd ?
197	pageaddr dd ?	197	pageaddr dd ?
198	socketnum dd ?	198	socketnum dd ?
199	buffer dd ?	199	buffer dd ?
200	port dd ?	200	port dd ?
201	endl	201	endl
202		202
203	and [flags], 0xff00 ; filter out invalid flags	203	and [flags], 0xff00 ; filter out invalid flags
204		204
205	pusha	205	pusha
206		206
207	; split the URL into hostname and pageaddr	207	; split the URL into hostname and pageaddr
208	stdcall parse_url, [URL]	208	stdcall parse_url, [URL]
209	test eax, eax	209	test eax, eax
210	jz .error	210	jz .error
211	mov [hostname], eax	211	mov [hostname], eax
212	mov [pageaddr], ebx	212	mov [pageaddr], ebx
213	mov [port], ecx	213	mov [port], ecx
214		214
215	mov eax, [identifier]	215	mov eax, [identifier]
216	test eax, eax	216	test eax, eax
217	jz .open_new	217	jz .open_new
218	test [eax + http_msg.flags], FLAG_CONNECTED	218	test [eax + http_msg.flags], FLAG_CONNECTED
219	jz .error	219	jz .error
220	mov eax, [eax + http_msg.socket]	220	mov eax, [eax + http_msg.socket]
221	mov [socketnum], eax	221	mov [socketnum], eax
222	jmp .send_request	222	jmp .send_request
223		223
224	; Connect to the other side.	224	; Connect to the other side.
225	.open_new:	225	.open_new:
226	stdcall open_connection, [hostname], [port]	226	stdcall open_connection, [hostname], [port]
227	test eax, eax	227	test eax, eax
228	jz .error	228	jz .error
229	mov [socketnum], eax	229	mov [socketnum], eax
230		230
231	; Create the HTTP request.	231	; Create the HTTP request.
232	.send_request:	232	.send_request:
233	invoke mem.alloc, BUFFERSIZE	233	invoke mem.alloc, BUFFERSIZE
234	test eax, eax	234	test eax, eax
235	jz .error	235	jz .error
236	mov [buffer], eax	236	mov [buffer], eax
237	mov edi, eax	237	mov edi, eax
238	DEBUGF 1, "Buffer allocated: 0x%x\n", eax	238	DEBUGF 1, "Buffer allocated: 0x%x\n", eax
239		239
240	mov esi, str_get	240	mov esi, str_get
241	copy_till_zero	241	copy_till_zero
242		242
243	; If we are using a proxy, send complete URL, otherwise send only page address.	243	; If we are using a proxy, send complete URL, otherwise send only page address.
244	cmp [proxyAddr], 0	244	cmp [proxyAddr], 0
245	je .no_proxy	245	je .no_proxy
246	mov esi, str_http ; prepend 'http://'	246	mov esi, str_http ; prepend 'http://'
247	copy_till_zero	247	copy_till_zero
248	mov esi, [hostname]	248	mov esi, [hostname]
249	copy_till_zero	249	copy_till_zero
250	.no_proxy:	250	.no_proxy:
251	mov esi, [pageaddr]	251	mov esi, [pageaddr]
252	copy_till_zero	252	copy_till_zero
253		253
254	mov esi, str_http11	254	mov esi, str_http11
255	mov ecx, str_http11.length	255	mov ecx, str_http11.length
256	rep movsb	256	rep movsb
257		257
258	mov esi, [hostname]	258	mov esi, [hostname]
259	copy_till_zero	259	copy_till_zero
260		260
261	cmp byte[proxyUser], 0	261	cmp byte[proxyUser], 0
262	je @f	262	je @f
263	call append_proxy_auth_header	263	call append_proxy_auth_header
264	@@:	264	@@:
265		265
266	mov ax, 0x0a0d	266	mov ax, 0x0a0d
267	stosw	267	stosw
268		268
269	mov esi, [add_header]	269	mov esi, [add_header]
270	test esi, esi	270	test esi, esi
271	jz @f	271	jz @f
272	copy_till_zero	272	copy_till_zero
273	@@:	273	@@:
274		274
275	mov esi, str_close	275	mov esi, str_close
276	mov ecx, str_close.length	276	mov ecx, str_close.length
277	test [flags], FLAG_KEEPALIVE	277	test [flags], FLAG_KEEPALIVE
278	jz @f	278	jz @f
279	mov esi, str_keep	279	mov esi, str_keep
280	mov ecx, str_keep.length	280	mov ecx, str_keep.length
281	@@:	281	@@:
282	rep movsb	282	rep movsb
283		283
284	mov byte[edi], 0	284	mov byte[edi], 0
285	DEBUGF 1, "Request:\n%s", [buffer]	285	DEBUGF 1, "Request:\n%s", [buffer]
286		286
287	; Free unused memory	287	; Free unused memory
288	push edi	288	push edi
289	invoke mem.free, [pageaddr]	289	invoke mem.free, [pageaddr]
290	invoke mem.free, [hostname]	290	invoke mem.free, [hostname]
291	pop esi	291	pop esi
292		292
293	; Send the request	293	; Send the request
294	sub esi, [buffer] ; length	294	sub esi, [buffer] ; length
295	xor edi, edi ; flags	295	xor edi, edi ; flags
296	mcall send, [socketnum], [buffer]	296	mcall send, [socketnum], [buffer]
297	test eax, eax	297	test eax, eax
298	jz .error	298	jz .error
299	DEBUGF 1, "Request has been sent to server.\n"	299	DEBUGF 1, "Request has been sent to server.\n"
300		300
301	cmp [identifier], 0	301	cmp [identifier], 0
302	je .new_connection	302	je .new_connection
303	invoke mem.free, [buffer]	303	invoke mem.free, [buffer]
304	mov eax, [identifier]	304	mov eax, [identifier]
305	mov [buffer], eax	305	mov [buffer], eax
306	.new_connection:	306	.new_connection:
307	HTTP_init_buffer [buffer], [socketnum], [flags]	307	HTTP_init_buffer [buffer], [socketnum], [flags]
308	popa	308	popa
309	mov eax, [buffer] ; return buffer ptr	309	mov eax, [buffer] ; return buffer ptr
310	ret	310	ret
311		311
312	.error:	312	.error:
313	DEBUGF 2, "HTTP GET error!\n"	313	DEBUGF 2, "HTTP GET error!\n"
314	popa	314	popa
315	xor eax, eax ; return 0 = error	315	xor eax, eax ; return 0 = error
316	ret	316	ret
317		317
318	endp	318	endp
319		319
320		320
321		321
322	;;================================================================================================;;	322	;;================================================================================================;;
323	proc HTTP_head URL, identifier, flags, add_header ;///////////////////////////////////////////////;;	323	proc HTTP_head URL, identifier, flags, add_header ;///////////////////////////////////////////////;;
324	;;------------------------------------------------------------------------------------------------;;	324	;;------------------------------------------------------------------------------------------------;;
325	;? Initiates a HTTP connection, using 'HEAD' method. ;;	325	;? Initiates a HTTP connection, using 'HEAD' method. ;;
326	;? This will only return HTTP header and status, no content ;;	326	;? This will only return HTTP header and status, no content ;;
327	;;------------------------------------------------------------------------------------------------;;	327	;;------------------------------------------------------------------------------------------------;;
328	;> URL = pointer to ASCIIZ URL ;;	328	;> URL = pointer to ASCIIZ URL ;;
329	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;	329	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;
330	;> flags = Flags indicating how to threat the connection. ;;	330	;> flags = Flags indicating how to threat the connection. ;;
331	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;	331	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;
332	;;------------------------------------------------------------------------------------------------;;	332	;;------------------------------------------------------------------------------------------------;;
333	;< eax = 0 (error) / buffer ptr ;;	333	;< eax = 0 (error) / buffer ptr ;;
334	;;================================================================================================;;	334	;;================================================================================================;;
335	locals	335	locals
336	hostname dd ?	336	hostname dd ?
337	pageaddr dd ?	337	pageaddr dd ?
338	socketnum dd ?	338	socketnum dd ?
339	buffer dd ?	339	buffer dd ?
340	port dd ?	340	port dd ?
341	endl	341	endl
342		342
343	and [flags], 0xff00 ; filter out invalid flags	343	and [flags], 0xff00 ; filter out invalid flags
344		344
345	pusha	345	pusha
346	; split the URL into hostname and pageaddr	346	; split the URL into hostname and pageaddr
347	stdcall parse_url, [URL]	347	stdcall parse_url, [URL]
348	test eax, eax	348	test eax, eax
349	jz .error	349	jz .error
350	mov [hostname], eax	350	mov [hostname], eax
351	mov [pageaddr], ebx	351	mov [pageaddr], ebx
352	mov [port], ecx	352	mov [port], ecx
353		353
354	mov eax, [identifier]	354	mov eax, [identifier]
355	test eax, eax	355	test eax, eax
356	jz .open_new	356	jz .open_new
357	test [eax + http_msg.flags], FLAG_CONNECTED	357	test [eax + http_msg.flags], FLAG_CONNECTED
358	jz .error	358	jz .error
359	mov eax, [eax + http_msg.socket]	359	mov eax, [eax + http_msg.socket]
360	mov [socketnum], eax	360	mov [socketnum], eax
361	jmp .send_request	361	jmp .send_request
362		362
363	; Connect to the other side.	363	; Connect to the other side.
364	.open_new:	364	.open_new:
365	stdcall open_connection, [hostname], [port]	365	stdcall open_connection, [hostname], [port]
366	test eax, eax	366	test eax, eax
367	jz .error	367	jz .error
368	mov [socketnum], eax	368	mov [socketnum], eax
369		369
370	; Create the HTTP request.	370	; Create the HTTP request.
371	.send_request:	371	.send_request:
372	invoke mem.alloc, BUFFERSIZE	372	invoke mem.alloc, BUFFERSIZE
373	test eax, eax	373	test eax, eax
374	jz .error	374	jz .error
375	mov [buffer], eax	375	mov [buffer], eax
376	mov edi, eax	376	mov edi, eax
377	DEBUGF 1, "Buffer has been allocated.\n"	377	DEBUGF 1, "Buffer has been allocated.\n"
378		378
379	mov esi, str_head	379	mov esi, str_head
380	copy_till_zero	380	copy_till_zero
381		381
382	; If we are using a proxy, send complete URL, otherwise send only page address.	382	; If we are using a proxy, send complete URL, otherwise send only page address.
383	cmp [proxyAddr], 0	383	cmp [proxyAddr], 0
384	je .no_proxy	384	je .no_proxy
385	mov esi, str_http ; prepend 'http://'	385	mov esi, str_http ; prepend 'http://'
386	copy_till_zero	386	copy_till_zero
387	mov esi, [hostname]	387	mov esi, [hostname]
388	copy_till_zero	388	copy_till_zero
389	.no_proxy:	389	.no_proxy:
390	mov esi, [pageaddr]	390	mov esi, [pageaddr]
391	copy_till_zero	391	copy_till_zero
392		392
393	mov esi, str_http11	393	mov esi, str_http11
394	mov ecx, str_http11.length	394	mov ecx, str_http11.length
395	rep movsb	395	rep movsb
396		396
397	mov esi, [hostname]	397	mov esi, [hostname]
398	copy_till_zero	398	copy_till_zero
399		399
400	cmp byte[proxyUser], 0	400	cmp byte[proxyUser], 0
401	je @f	401	je @f
402	call append_proxy_auth_header	402	call append_proxy_auth_header
403	@@:	403	@@:
404		404
405	mov ax, 0x0a0d	405	mov ax, 0x0a0d
406	stosw	406	stosw
407		407
408	mov esi, [add_header]	408	mov esi, [add_header]
409	test esi, esi	409	test esi, esi
410	jz @f	410	jz @f
411	copy_till_zero	411	copy_till_zero
412	@@:	412	@@:
413		413
414	mov esi, str_close	414	mov esi, str_close
415	mov ecx, str_close.length	415	mov ecx, str_close.length
416	test [flags], FLAG_KEEPALIVE	416	test [flags], FLAG_KEEPALIVE
417	jz @f	417	jz @f
418	mov esi, str_keep	418	mov esi, str_keep
419	mov ecx, str_keep.length	419	mov ecx, str_keep.length
420	@@:	420	@@:
421	rep movsb	421	rep movsb
422		422
423	mov byte[edi], 0	423	mov byte[edi], 0
424	DEBUGF 1, "Request:\n%s", [buffer]	424	DEBUGF 1, "Request:\n%s", [buffer]
425		425
426	; Free unused memory	426	; Free unused memory
427	push edi	427	push edi
428	invoke mem.free, [pageaddr]	428	invoke mem.free, [pageaddr]
429	invoke mem.free, [hostname]	429	invoke mem.free, [hostname]
430	pop esi	430	pop esi
431		431
432	; Send the request	432	; Send the request
433	sub esi, [buffer] ; length	433	sub esi, [buffer] ; length
434	xor edi, edi ; flags	434	xor edi, edi ; flags
435	mcall send, [socketnum], [buffer]	435	mcall send, [socketnum], [buffer]
436	test eax, eax	436	test eax, eax
437	jz .error	437	jz .error
438	DEBUGF 1, "Request has been sent to server.\n"	438	DEBUGF 1, "Request has been sent to server.\n"
439		439
440	cmp [identifier], 0	440	cmp [identifier], 0
441	je .new_connection	441	je .new_connection
442	invoke mem.free, [buffer]	442	invoke mem.free, [buffer]
443	mov eax, [identifier]	443	mov eax, [identifier]
444	mov [buffer], eax	444	mov [buffer], eax
445	.new_connection:	445	.new_connection:
446	HTTP_init_buffer [buffer], [socketnum], [flags]	446	HTTP_init_buffer [buffer], [socketnum], [flags]
447	popa	447	popa
448	mov eax, [buffer] ; return buffer ptr	448	mov eax, [buffer] ; return buffer ptr
449	ret	449	ret
450		450
451	.error:	451	.error:
452	DEBUGF 2, "HTTP HEAD error!\n"	452	DEBUGF 2, "HTTP HEAD error!\n"
453	popa	453	popa
454	xor eax, eax ; return 0 = error	454	xor eax, eax ; return 0 = error
455	ret	455	ret
456		456
457	endp	457	endp
458		458
459		459
460	;;================================================================================================;;	460	;;================================================================================================;;
461	proc HTTP_post URL, identifier, flags, add_header, content_type, content_length ;/////////////////;;	461	proc HTTP_post URL, identifier, flags, add_header, content_type, content_length ;/////////////////;;
462	;;------------------------------------------------------------------------------------------------;;	462	;;------------------------------------------------------------------------------------------------;;
463	;? Initiates a HTTP connection, using 'POST' method. ;;	463	;? Initiates a HTTP connection, using 'POST' method. ;;
464	;? This method is used to send data to the HTTP server ;;	464	;? This method is used to send data to the HTTP server ;;
465	;;------------------------------------------------------------------------------------------------;;	465	;;------------------------------------------------------------------------------------------------;;
466	;> URL = pointer to ASCIIZ URL ;;	466	;> URL = pointer to ASCIIZ URL ;;
467	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;	467	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;
468	;> flags = Flags indicating how to threat the connection. ;;	468	;> flags = Flags indicating how to threat the connection. ;;
469	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;	469	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;
470	;> content_type = pointer to ASCIIZ string containing content type ;;	470	;> content_type = pointer to ASCIIZ string containing content type ;;
471	;> content_length = length of content (in bytes) ;;	471	;> content_length = length of content (in bytes) ;;
472	;;------------------------------------------------------------------------------------------------;;	472	;;------------------------------------------------------------------------------------------------;;
473	;< eax = 0 (error) / buffer ptr (aka Identifier) ;;	473	;< eax = 0 (error) / buffer ptr (aka Identifier) ;;
474	;;================================================================================================;;	474	;;================================================================================================;;
475	locals	475	locals
476	hostname dd ?	476	hostname dd ?
477	pageaddr dd ?	477	pageaddr dd ?
478	socketnum dd ?	478	socketnum dd ?
479	buffer dd ?	479	buffer dd ?
480	port dd ?	480	port dd ?
481	endl	481	endl
482		482
483	and [flags], 0xff00 ; filter out invalid flags	483	and [flags], 0xff00 ; filter out invalid flags
484		484
485	pusha	485	pusha
486	; split the URL into hostname and pageaddr	486	; split the URL into hostname and pageaddr
487	stdcall parse_url, [URL]	487	stdcall parse_url, [URL]
488	test eax, eax	488	test eax, eax
489	jz .error	489	jz .error
490	mov [hostname], eax	490	mov [hostname], eax
491	mov [pageaddr], ebx	491	mov [pageaddr], ebx
492	mov [port], ecx	492	mov [port], ecx
493		493
494	mov eax, [identifier]	494	mov eax, [identifier]
495	test eax, eax	495	test eax, eax
496	jz .open_new	496	jz .open_new
497	test [eax + http_msg.flags], FLAG_CONNECTED	497	test [eax + http_msg.flags], FLAG_CONNECTED
498	jz .error	498	jz .error
499	mov eax, [eax + http_msg.socket]	499	mov eax, [eax + http_msg.socket]
500	mov [socketnum], eax	500	mov [socketnum], eax

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm – Rev 7009 → 7091