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


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

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

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm – Rev 5537 → 5732