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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2020. 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      = 512*1024
        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     ebx, [buffersize]
        sub     ebx, http_msg.http_header
        mov     [eax + http_msg.buffer_length], ebx
        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_buffersize_get ;////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Get HTTP buffer size                                                                           ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = buffer size in bytes                                                                     ;;
;;================================================================================================;;
 
        mov     eax, [buffersize]
        ret
 
endp
 
;;================================================================================================;;
proc HTTP_buffersize_set ;////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Set HTTP buffer size                                                                           ;;
;;------------------------------------------------------------------------------------------------;;
;> eax = buffer size in bytes                                                                     ;;
;;================================================================================================;;
 
        mov     [buffersize], eax
        ret
 
endp
 
 
;;================================================================================================;;
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 + http_msg.content_ptr]
        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
 
        DEBUGF  1, "HTTP POST (%s).\n", [URL]
 
        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:
        DEBUGF  1, "Opening new connection.\n"
        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
        DEBUGF  1, "HTTP POST complete.\n"
        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
 
; Check if our receive buffer still has space
        cmp     [ebp + http_msg.buffer_length], 0
        jne     .receive
 
        test    [ebp + http_msg.flags], FLAG_RING
        jnz     .need_more_space
 
        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
        push    [buffersize]
        pop     [ebp + http_msg.buffer_length]
        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
        push    [buffersize]
        pop     [ebp + http_msg.buffer_length]
        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 ", 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
        DEBUGF  1, "buffer length = %d\n", [ebp + http_msg.buffer_length]
 
; 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.
        mov     edx, ebx
        add     edx, [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:
        ; If we're using ring buffer, check we crossed the boundary
        test    [ebp + http_msg.flags], FLAG_RING
        jz      @f
        mov     ebx, [ebp + http_msg.content_ptr]
        add     ebx, [buffersize]
        cmp     [ebp + http_msg.write_ptr], ebx
        jb      @f
        DEBUGF  1, "Restarting at beginning of ring buffer\n"
        mov     ebx, [buffersize]
        sub     [ebp + http_msg.write_ptr], ebx
  @@:
        ; 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
        push    [buffersize]
        pop     [ebp + http_msg.buffer_length]
        ; 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:
; If we're using ring buffer, check we crossed the boundary
        test    [ebp + http_msg.flags], FLAG_RING
        jz      @f
        mov     ebx, [ebp + http_msg.content_ptr]
        add     ebx, [buffersize]
        cmp     [ebp + http_msg.write_ptr], ebx
        jb      @f
        DEBUGF  1, "Restarting at beginning of ring buffer\n"
        mov     ebx, [buffersize]
        sub     [ebp + http_msg.write_ptr], ebx
  @@:
        ; 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"
        mcall   close, [ebp + http_msg.socket]
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        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  ; TODO: dont abort connection (requires rechecking all codepaths..)
 
  .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:
  .continue:
        popa
        xor     eax, eax
        ret
 
  .need_more_space:
        DEBUGF  1, "Buffer is full!\n"
        and     [ebp + http_msg.flags], not FLAG_NEED_MORE_SPACE
        popa
        xor     eax, eax
        ret
 
endp
 
 
alloc_contentbuff:
 
        test    [ebp + http_msg.flags], FLAG_RING
        jz      @f
 
        DEBUGF  1, "Allocating ring buffer\n"
        mcall   68, 29, [buffersize]
        or      eax, eax
        jz      .no_ram
        jmp     .allocated
  @@:
 
        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
 
  .allocated:
        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
        ret
 
  .no_ram:
        DEBUGF  2, "Error allocating content buffer!\n"
        mov     [ebp + http_msg.buffer_length], 0       ;;;
        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     edx, URLMAXLEN-1                ; Remaining space in temp buffer minus one for 0 byte
        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
        dec     edx
        jnz     .loop
        jmp     .out_of_space
 
  .escape:
        sub     edx, 3
        jbe     .out_of_space
        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
 
 
  .out_of_space:
        DEBUGF  2, "ERROR: buffer too small!\n"
 
  .done:
        xor     al, al
        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     edx, URLMAXLEN-1                ; Remaining space in temp buffer minus one for 0 byte
        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
        dec     edx
        jnz     .loop
        jmp     .out_of_space
 
  .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
        dec     edx
        jnz     .loop
        jmp     .out_of_space
 
  .fail:
        DEBUGF  2, "ERROR: invalid URI!\n"
        jmp     .loop
 
  .out_of_space:
        DEBUGF  2, "ERROR: buffer too small!\n"
 
  .done:
        xor     al, al
        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_buffersize_get     , 'buffersize_get'      , \
        HTTP_buffersize_set     , 'buffersize_set'      , \
        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: keep-alive', 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'
 
buffersize      dd BUFFERSIZE
 
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 8571	Rev 8575
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2020. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2020. 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 = 512*1024	22	BUFFERSIZE = 512*1024
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		67
68	mov ebx, [buffersize]	68	mov ebx, [buffersize]
69	sub ebx, http_msg.http_header	69	sub ebx, http_msg.http_header
70	mov [eax + http_msg.buffer_length], ebx	70	mov [eax + http_msg.buffer_length], ebx
71	mov [eax + http_msg.chunk_ptr], 0	71	mov [eax + http_msg.chunk_ptr], 0
72		72
73	mov [eax + http_msg.status], 0	73	mov [eax + http_msg.status], 0
74	mov [eax + http_msg.header_length], 0	74	mov [eax + http_msg.header_length], 0
75	mov [eax + http_msg.content_ptr], 0	75	mov [eax + http_msg.content_ptr], 0
76	mov [eax + http_msg.content_length], 0	76	mov [eax + http_msg.content_length], 0
77	mov [eax + http_msg.content_received], 0	77	mov [eax + http_msg.content_received], 0
78		78
79	push eax ebp	79	push eax ebp
80	mov ebp, eax	80	mov ebp, eax
81	mcall 26, 9	81	mcall 26, 9
82	mov [ebp + http_msg.timestamp], eax	82	mov [ebp + http_msg.timestamp], eax
83	pop ebp eax	83	pop ebp eax
84	}	84	}
85		85
86	section '.flat' code readable align 16	86	section '.flat' code readable align 16
87		87
88	;;===========================================================================;;	88	;;===========================================================================;;
89	lib_init: ;//////////////////////////////////////////////////////////////////;;	89	lib_init: ;//////////////////////////////////////////////////////////////////;;
90	;;---------------------------------------------------------------------------;;	90	;;---------------------------------------------------------------------------;;
91	;? Library entry point (called after library load) ;;	91	;? Library entry point (called after library load) ;;
92	;;---------------------------------------------------------------------------;;	92	;;---------------------------------------------------------------------------;;
93	;> eax = pointer to memory allocation routine ;;	93	;> eax = pointer to memory allocation routine ;;
94	;> ebx = pointer to memory freeing routine ;;	94	;> ebx = pointer to memory freeing routine ;;
95	;> ecx = pointer to memory reallocation routine ;;	95	;> ecx = pointer to memory reallocation routine ;;
96	;> edx = pointer to library loading routine ;;	96	;> edx = pointer to library loading routine ;;
97	;;---------------------------------------------------------------------------;;	97	;;---------------------------------------------------------------------------;;
98	;< eax = 1 (fail) / 0 (ok) ;;	98	;< eax = 1 (fail) / 0 (ok) ;;
99	;;===========================================================================;;	99	;;===========================================================================;;
100	mov [mem.alloc], eax	100	mov [mem.alloc], eax
101	mov [mem.free], ebx	101	mov [mem.free], ebx
102	mov [mem.realloc], ecx	102	mov [mem.realloc], ecx
103	mov [dll.load], edx	103	mov [dll.load], edx
104		104
105	invoke dll.load, @IMPORT	105	invoke dll.load, @IMPORT
106	test eax, eax	106	test eax, eax
107	jnz .error	107	jnz .error
108		108
109	; load proxy settings	109	; load proxy settings
110	pusha	110	pusha
111	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr	111	invoke ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr
112	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80	112	invoke ini.get_int, inifile, sec_proxy, key_proxyport, 80
113	mov [proxyPort], eax	113	mov [proxyPort], eax
114	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser	114	invoke ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser
115	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword	115	invoke ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword
116	popa	116	popa
117		117
118	DEBUGF 1, "HTTP library: init OK\n"	118	DEBUGF 1, "HTTP library: init OK\n"
119	xor eax, eax	119	xor eax, eax
120	ret	120	ret
121		121
122	.error:	122	.error:
123	DEBUGF 2, "ERROR loading http.obj dependencies\n"	123	DEBUGF 2, "ERROR loading http.obj dependencies\n"
124	xor eax, eax	124	xor eax, eax
125	inc eax	125	inc eax
126	ret	126	ret
127		127
128		128
129	;;================================================================================================;;	129	;;================================================================================================;;
130	proc HTTP_buffersize_get ;////////////////////////////////////////////////////////////////////////;;	130	proc HTTP_buffersize_get ;////////////////////////////////////////////////////////////////////////;;
131	;;------------------------------------------------------------------------------------------------;;	131	;;------------------------------------------------------------------------------------------------;;
132	;? Get HTTP buffer size ;;	132	;? Get HTTP buffer size ;;
133	;;------------------------------------------------------------------------------------------------;;	133	;;------------------------------------------------------------------------------------------------;;
134	;< eax = buffer size in bytes ;;	134	;< eax = buffer size in bytes ;;
135	;;================================================================================================;;	135	;;================================================================================================;;
136		136
137	mov eax, [buffersize]	137	mov eax, [buffersize]
138	ret	138	ret
139		139
140	endp	140	endp
141		141
142	;;================================================================================================;;	142	;;================================================================================================;;
143	proc HTTP_buffersize_set ;////////////////////////////////////////////////////////////////////////;;	143	proc HTTP_buffersize_set ;////////////////////////////////////////////////////////////////////////;;
144	;;------------------------------------------------------------------------------------------------;;	144	;;------------------------------------------------------------------------------------------------;;
145	;? Set HTTP buffer size ;;	145	;? Set HTTP buffer size ;;
146	;;------------------------------------------------------------------------------------------------;;	146	;;------------------------------------------------------------------------------------------------;;
147	;> eax = buffer size in bytes ;;	147	;> eax = buffer size in bytes ;;
148	;;================================================================================================;;	148	;;================================================================================================;;
149		149
150	mov [buffersize], eax	150	mov [buffersize], eax
151	ret	151	ret
152		152
153	endp	153	endp
154		154
155		155
156	;;================================================================================================;;	156	;;================================================================================================;;
157	proc HTTP_disconnect identifier ;/////////////////////////////////////////////////////////////////;;	157	proc HTTP_disconnect identifier ;/////////////////////////////////////////////////////////////////;;
158	;;------------------------------------------------------------------------------------------------;;	158	;;------------------------------------------------------------------------------------------------;;
159	;? Stops the open connection ;;	159	;? Stops the open connection ;;
160	;;------------------------------------------------------------------------------------------------;;	160	;;------------------------------------------------------------------------------------------------;;
161	;> identifier = pointer to buffer containing http_msg struct. ;;	161	;> identifier = pointer to buffer containing http_msg struct. ;;
162	;;------------------------------------------------------------------------------------------------;;	162	;;------------------------------------------------------------------------------------------------;;
163	;< none ;;	163	;< none ;;
164	;;================================================================================================;;	164	;;================================================================================================;;
165		165
166	pusha	166	pusha
167	mov ebp, [identifier]	167	mov ebp, [identifier]
168		168
169	test [ebp + http_msg.flags], FLAG_CONNECTED	169	test [ebp + http_msg.flags], FLAG_CONNECTED
170	jz .error	170	jz .error
171	and [ebp + http_msg.flags], not FLAG_CONNECTED	171	and [ebp + http_msg.flags], not FLAG_CONNECTED
172	mcall close, [ebp + http_msg.socket]	172	mcall close, [ebp + http_msg.socket]
173		173
174	popa	174	popa
175	ret	175	ret
176		176
177	.error:	177	.error:
178	DEBUGF 1, "Cannot close already closed connection!\n"	178	DEBUGF 1, "Cannot close already closed connection!\n"
179	popa	179	popa
180	ret	180	ret
181		181
182	endp	182	endp
183		183
184		184
185	;;================================================================================================;;	185	;;================================================================================================;;
186	proc HTTP_free identifier ;///////////////////////////////////////////////////////////////////////;;	186	proc HTTP_free identifier ;///////////////////////////////////////////////////////////////////////;;
187	;;------------------------------------------------------------------------------------------------;;	187	;;------------------------------------------------------------------------------------------------;;
188	;? Free the http_msg structure ;;	188	;? Free the http_msg structure ;;
189	;;------------------------------------------------------------------------------------------------;;	189	;;------------------------------------------------------------------------------------------------;;
190	;> identifier = pointer to buffer containing http_msg struct. ;;	190	;> identifier = pointer to buffer containing http_msg struct. ;;
191	;;------------------------------------------------------------------------------------------------;;	191	;;------------------------------------------------------------------------------------------------;;
192	;< none ;;	192	;< none ;;
193	;;================================================================================================;;	193	;;================================================================================================;;
194	DEBUGF 1, "HTTP_free: 0x%x\n", [identifier]	194	DEBUGF 1, "HTTP_free: 0x%x\n", [identifier]
195	pusha	195	pusha
196	mov ebp, [identifier]	196	mov ebp, [identifier]
197		197
198	test [ebp + http_msg.flags], FLAG_CONNECTED	198	test [ebp + http_msg.flags], FLAG_CONNECTED
199	jz .not_connected	199	jz .not_connected
200	and [ebp + http_msg.flags], not FLAG_CONNECTED	200	and [ebp + http_msg.flags], not FLAG_CONNECTED
201	mcall close, [ebp + http_msg.socket]	201	mcall close, [ebp + http_msg.socket]
202		202
203	.not_connected:	203	.not_connected:
-		204	invoke mem.free, [ebp + http_msg.content_ptr]
204	invoke mem.free, ebp	205	invoke mem.free, ebp
205		-
206	popa	206	popa
207	ret	207	ret
208		208
209	endp	209	endp
210		210
211		211
212		212
213	;;================================================================================================;;	213	;;================================================================================================;;
214	proc HTTP_get URL, identifier, flags, add_header ;////////////////////////////////////////////////;;	214	proc HTTP_get URL, identifier, flags, add_header ;////////////////////////////////////////////////;;
215	;;------------------------------------------------------------------------------------------------;;	215	;;------------------------------------------------------------------------------------------------;;
216	;? Initiates a HTTP connection, using 'GET' method. ;;	216	;? Initiates a HTTP connection, using 'GET' method. ;;
217	;;------------------------------------------------------------------------------------------------;;	217	;;------------------------------------------------------------------------------------------------;;
218	;> URL = pointer to ASCIIZ URL ;;	218	;> URL = pointer to ASCIIZ URL ;;
219	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;	219	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;
220	;> flags = Flags indicating how to threat the connection. ;;	220	;> flags = Flags indicating how to threat the connection. ;;
221	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;	221	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;
222	;;------------------------------------------------------------------------------------------------;;	222	;;------------------------------------------------------------------------------------------------;;
223	;< eax = 0 (error) / buffer ptr ;;	223	;< eax = 0 (error) / buffer ptr ;;
224	;;================================================================================================;;	224	;;================================================================================================;;
225	locals	225	locals
226	hostname dd ?	226	hostname dd ?
227	pageaddr dd ?	227	pageaddr dd ?
228	socketnum dd ?	228	socketnum dd ?
229	buffer dd ?	229	buffer dd ?
230	port dd ?	230	port dd ?
231	endl	231	endl
232		232
233	and [flags], 0xff00 ; filter out invalid flags	233	and [flags], 0xff00 ; filter out invalid flags
234		234
235	pusha	235	pusha
236		236
237	; split the URL into hostname and pageaddr	237	; split the URL into hostname and pageaddr
238	stdcall parse_url, [URL]	238	stdcall parse_url, [URL]
239	test eax, eax	239	test eax, eax
240	jz .error	240	jz .error
241	mov [hostname], eax	241	mov [hostname], eax
242	mov [pageaddr], ebx	242	mov [pageaddr], ebx
243	mov [port], ecx	243	mov [port], ecx
244		244
245	mov eax, [identifier]	245	mov eax, [identifier]
246	test eax, eax	246	test eax, eax
247	jz .open_new	247	jz .open_new
248	test [eax + http_msg.flags], FLAG_CONNECTED	248	test [eax + http_msg.flags], FLAG_CONNECTED
249	jz .error	249	jz .error
250	mov eax, [eax + http_msg.socket]	250	mov eax, [eax + http_msg.socket]
251	mov [socketnum], eax	251	mov [socketnum], eax
252	jmp .send_request	252	jmp .send_request
253		253
254	; Connect to the other side.	254	; Connect to the other side.
255	.open_new:	255	.open_new:
256	stdcall open_connection, [hostname], [port]	256	stdcall open_connection, [hostname], [port]
257	test eax, eax	257	test eax, eax
258	jz .error	258	jz .error
259	mov [socketnum], eax	259	mov [socketnum], eax
260		260
261	; Create the HTTP request.	261	; Create the HTTP request.
262	.send_request:	262	.send_request:
263	invoke mem.alloc, [buffersize]	263	invoke mem.alloc, [buffersize]
264	test eax, eax	264	test eax, eax
265	jz .error	265	jz .error
266	mov [buffer], eax	266	mov [buffer], eax
267	mov edi, eax	267	mov edi, eax
268	DEBUGF 1, "Buffer allocated: 0x%x\n", eax	268	DEBUGF 1, "Buffer allocated: 0x%x\n", eax
269		269
270	mov esi, str_get	270	mov esi, str_get
271	copy_till_zero	271	copy_till_zero
272		272
273	; If we are using a proxy, send complete URL, otherwise send only page address.	273	; If we are using a proxy, send complete URL, otherwise send only page address.
274	cmp [proxyAddr], 0	274	cmp [proxyAddr], 0
275	je .no_proxy	275	je .no_proxy
276	mov esi, str_http ; prepend 'http://'	276	mov esi, str_http ; prepend 'http://'
277	copy_till_zero	277	copy_till_zero
278	mov esi, [hostname]	278	mov esi, [hostname]
279	copy_till_zero	279	copy_till_zero
280	.no_proxy:	280	.no_proxy:
281	mov esi, [pageaddr]	281	mov esi, [pageaddr]
282	copy_till_zero	282	copy_till_zero
283		283
284	mov esi, str_http11	284	mov esi, str_http11
285	mov ecx, str_http11.length	285	mov ecx, str_http11.length
286	rep movsb	286	rep movsb
287		287
288	mov esi, [hostname]	288	mov esi, [hostname]
289	copy_till_zero	289	copy_till_zero
290		290
291	cmp byte[proxyUser], 0	291	cmp byte[proxyUser], 0
292	je @f	292	je @f
293	call append_proxy_auth_header	293	call append_proxy_auth_header
294	@@:	294	@@:
295		295
296	mov ax, 0x0a0d	296	mov ax, 0x0a0d
297	stosw	297	stosw
298		298
299	mov esi, [add_header]	299	mov esi, [add_header]
300	test esi, esi	300	test esi, esi
301	jz @f	301	jz @f
302	copy_till_zero	302	copy_till_zero
303	@@:	303	@@:
304		304
305	mov esi, str_close	305	mov esi, str_close
306	mov ecx, str_close.length	306	mov ecx, str_close.length
307	test [flags], FLAG_KEEPALIVE	307	test [flags], FLAG_KEEPALIVE
308	jz @f	308	jz @f
309	mov esi, str_keep	309	mov esi, str_keep
310	mov ecx, str_keep.length	310	mov ecx, str_keep.length
311	@@:	311	@@:
312	rep movsb	312	rep movsb
313		313
314	mov byte[edi], 0	314	mov byte[edi], 0
315	DEBUGF 1, "Request:\n%s", [buffer]	315	DEBUGF 1, "Request:\n%s", [buffer]
316		316
317	; Free unused memory	317	; Free unused memory
318	push edi	318	push edi
319	invoke mem.free, [pageaddr]	319	invoke mem.free, [pageaddr]
320	invoke mem.free, [hostname]	320	invoke mem.free, [hostname]
321	pop esi	321	pop esi
322		322
323	; Send the request	323	; Send the request
324	sub esi, [buffer] ; length	324	sub esi, [buffer] ; length
325	xor edi, edi ; flags	325	xor edi, edi ; flags
326	mcall send, [socketnum], [buffer]	326	mcall send, [socketnum], [buffer]
327	test eax, eax	327	test eax, eax
328	jz .error	328	jz .error
329	DEBUGF 1, "Request has been sent to server.\n"	329	DEBUGF 1, "Request has been sent to server.\n"
330		330
331	cmp [identifier], 0	331	cmp [identifier], 0
332	je .new_connection	332	je .new_connection
333	invoke mem.free, [buffer]	333	invoke mem.free, [buffer]
334	mov eax, [identifier]	334	mov eax, [identifier]
335	mov [buffer], eax	335	mov [buffer], eax
336	.new_connection:	336	.new_connection:
337	HTTP_init_buffer [buffer], [socketnum], [flags]	337	HTTP_init_buffer [buffer], [socketnum], [flags]
338	popa	338	popa
339	mov eax, [buffer] ; return buffer ptr	339	mov eax, [buffer] ; return buffer ptr
340	ret	340	ret
341		341
342	.error:	342	.error:
343	DEBUGF 2, "HTTP GET error!\n"	343	DEBUGF 2, "HTTP GET error!\n"
344	popa	344	popa
345	xor eax, eax ; return 0 = error	345	xor eax, eax ; return 0 = error
346	ret	346	ret
347		347
348	endp	348	endp
349		349
350		350
351		351
352	;;================================================================================================;;	352	;;================================================================================================;;
353	proc HTTP_head URL, identifier, flags, add_header ;///////////////////////////////////////////////;;	353	proc HTTP_head URL, identifier, flags, add_header ;///////////////////////////////////////////////;;
354	;;------------------------------------------------------------------------------------------------;;	354	;;------------------------------------------------------------------------------------------------;;
355	;? Initiates a HTTP connection, using 'HEAD' method. ;;	355	;? Initiates a HTTP connection, using 'HEAD' method. ;;
356	;? This will only return HTTP header and status, no content ;;	356	;? This will only return HTTP header and status, no content ;;
357	;;------------------------------------------------------------------------------------------------;;	357	;;------------------------------------------------------------------------------------------------;;
358	;> URL = pointer to ASCIIZ URL ;;	358	;> URL = pointer to ASCIIZ URL ;;
359	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;	359	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;
360	;> flags = Flags indicating how to threat the connection. ;;	360	;> flags = Flags indicating how to threat the connection. ;;
361	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;	361	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;
362	;;------------------------------------------------------------------------------------------------;;	362	;;------------------------------------------------------------------------------------------------;;
363	;< eax = 0 (error) / buffer ptr ;;	363	;< eax = 0 (error) / buffer ptr ;;
364	;;================================================================================================;;	364	;;================================================================================================;;
365	locals	365	locals
366	hostname dd ?	366	hostname dd ?
367	pageaddr dd ?	367	pageaddr dd ?
368	socketnum dd ?	368	socketnum dd ?
369	buffer dd ?	369	buffer dd ?
370	port dd ?	370	port dd ?
371	endl	371	endl
372		372
373	and [flags], 0xff00 ; filter out invalid flags	373	and [flags], 0xff00 ; filter out invalid flags
374		374
375	pusha	375	pusha
376	; split the URL into hostname and pageaddr	376	; split the URL into hostname and pageaddr
377	stdcall parse_url, [URL]	377	stdcall parse_url, [URL]
378	test eax, eax	378	test eax, eax
379	jz .error	379	jz .error
380	mov [hostname], eax	380	mov [hostname], eax
381	mov [pageaddr], ebx	381	mov [pageaddr], ebx
382	mov [port], ecx	382	mov [port], ecx
383		383
384	mov eax, [identifier]	384	mov eax, [identifier]
385	test eax, eax	385	test eax, eax
386	jz .open_new	386	jz .open_new
387	test [eax + http_msg.flags], FLAG_CONNECTED	387	test [eax + http_msg.flags], FLAG_CONNECTED
388	jz .error	388	jz .error
389	mov eax, [eax + http_msg.socket]	389	mov eax, [eax + http_msg.socket]
390	mov [socketnum], eax	390	mov [socketnum], eax
391	jmp .send_request	391	jmp .send_request
392		392
393	; Connect to the other side.	393	; Connect to the other side.
394	.open_new:	394	.open_new:
395	stdcall open_connection, [hostname], [port]	395	stdcall open_connection, [hostname], [port]
396	test eax, eax	396	test eax, eax
397	jz .error	397	jz .error
398	mov [socketnum], eax	398	mov [socketnum], eax
399		399
400	; Create the HTTP request.	400	; Create the HTTP request.
401	.send_request:	401	.send_request:
402	invoke mem.alloc, [buffersize]	402	invoke mem.alloc, [buffersize]
403	test eax, eax	403	test eax, eax
404	jz .error	404	jz .error
405	mov [buffer], eax	405	mov [buffer], eax
406	mov edi, eax	406	mov edi, eax
407	DEBUGF 1, "Buffer has been allocated.\n"	407	DEBUGF 1, "Buffer has been allocated.\n"
408		408
409	mov esi, str_head	409	mov esi, str_head
410	copy_till_zero	410	copy_till_zero
411		411
412	; If we are using a proxy, send complete URL, otherwise send only page address.	412	; If we are using a proxy, send complete URL, otherwise send only page address.
413	cmp [proxyAddr], 0	413	cmp [proxyAddr], 0
414	je .no_proxy	414	je .no_proxy
415	mov esi, str_http ; prepend 'http://'	415	mov esi, str_http ; prepend 'http://'
416	copy_till_zero	416	copy_till_zero
417	mov esi, [hostname]	417	mov esi, [hostname]
418	copy_till_zero	418	copy_till_zero
419	.no_proxy:	419	.no_proxy:
420	mov esi, [pageaddr]	420	mov esi, [pageaddr]
421	copy_till_zero	421	copy_till_zero
422		422
423	mov esi, str_http11	423	mov esi, str_http11
424	mov ecx, str_http11.length	424	mov ecx, str_http11.length
425	rep movsb	425	rep movsb
426		426
427	mov esi, [hostname]	427	mov esi, [hostname]
428	copy_till_zero	428	copy_till_zero
429		429
430	cmp byte[proxyUser], 0	430	cmp byte[proxyUser], 0
431	je @f	431	je @f
432	call append_proxy_auth_header	432	call append_proxy_auth_header
433	@@:	433	@@:
434		434
435	mov ax, 0x0a0d	435	mov ax, 0x0a0d
436	stosw	436	stosw
437		437
438	mov esi, [add_header]	438	mov esi, [add_header]
439	test esi, esi	439	test esi, esi
440	jz @f	440	jz @f
441	copy_till_zero	441	copy_till_zero
442	@@:	442	@@:
443		443
444	mov esi, str_close	444	mov esi, str_close
445	mov ecx, str_close.length	445	mov ecx, str_close.length
446	test [flags], FLAG_KEEPALIVE	446	test [flags], FLAG_KEEPALIVE
447	jz @f	447	jz @f
448	mov esi, str_keep	448	mov esi, str_keep
449	mov ecx, str_keep.length	449	mov ecx, str_keep.length
450	@@:	450	@@:
451	rep movsb	451	rep movsb
452		452
453	mov byte[edi], 0	453	mov byte[edi], 0
454	DEBUGF 1, "Request:\n%s", [buffer]	454	DEBUGF 1, "Request:\n%s", [buffer]
455		455
456	; Free unused memory	456	; Free unused memory
457	push edi	457	push edi
458	invoke mem.free, [pageaddr]	458	invoke mem.free, [pageaddr]
459	invoke mem.free, [hostname]	459	invoke mem.free, [hostname]
460	pop esi	460	pop esi
461		461
462	; Send the request	462	; Send the request
463	sub esi, [buffer] ; length	463	sub esi, [buffer] ; length
464	xor edi, edi ; flags	464	xor edi, edi ; flags
465	mcall send, [socketnum], [buffer]	465	mcall send, [socketnum], [buffer]
466	test eax, eax	466	test eax, eax
467	jz .error	467	jz .error
468	DEBUGF 1, "Request has been sent to server.\n"	468	DEBUGF 1, "Request has been sent to server.\n"
469		469
470	cmp [identifier], 0	470	cmp [identifier], 0
471	je .new_connection	471	je .new_connection
472	invoke mem.free, [buffer]	472	invoke mem.free, [buffer]
473	mov eax, [identifier]	473	mov eax, [identifier]
474	mov [buffer], eax	474	mov [buffer], eax
475	.new_connection:	475	.new_connection:
476	HTTP_init_buffer [buffer], [socketnum], [flags]	476	HTTP_init_buffer [buffer], [socketnum], [flags]
477	popa	477	popa
478	mov eax, [buffer] ; return buffer ptr	478	mov eax, [buffer] ; return buffer ptr
479	ret	479	ret
480		480
481	.error:	481	.error:
482	DEBUGF 2, "HTTP HEAD error!\n"	482	DEBUGF 2, "HTTP HEAD error!\n"
483	popa	483	popa
484	xor eax, eax ; return 0 = error	484	xor eax, eax ; return 0 = error
485	ret	485	ret
486		486
487	endp	487	endp
488		488
489		489
490	;;================================================================================================;;	490	;;================================================================================================;;
491	proc HTTP_post URL, identifier, flags, add_header, content_type, content_length ;/////////////////;;	491	proc HTTP_post URL, identifier, flags, add_header, content_type, content_length ;/////////////////;;
492	;;------------------------------------------------------------------------------------------------;;	492	;;------------------------------------------------------------------------------------------------;;
493	;? Initiates a HTTP connection, using 'POST' method. ;;	493	;? Initiates a HTTP connection, using 'POST' method. ;;
494	;? This method is used to send data to the HTTP server ;;	494	;? This method is used to send data to the HTTP server ;;
495	;;------------------------------------------------------------------------------------------------;;	495	;;------------------------------------------------------------------------------------------------;;
496	;> URL = pointer to ASCIIZ URL ;;	496	;> URL = pointer to ASCIIZ URL ;;
497	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;	497	;> identifier = Identifier of an already open connection, or NULL to create a new one. ;;
498	;> flags = Flags indicating how to threat the connection. ;;	498	;> flags = Flags indicating how to threat the connection. ;;
499	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;	499	;> add_header = pointer to additional header parameters (ASCIIZ), or NULL for none. ;;

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm @ 7523 – Rev 8571 → 8575