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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2013. 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      = 4096
        TIMEOUT         = 1000  ; in 1/100 s
 
        __DEBUG__       = 1
        __DEBUG_LEVEL__ = 1
 
 
format MS COFF
 
public @EXPORT as 'EXPORTS'
 
include '../../../struct.inc'
include '../../../proc32.inc'
include '../../../macros.inc'
purge section,mov,add,sub
include '../../../debug-fdo.inc'
 
include '../../../network.inc'
include 'http.inc'
 
virtual at 0
        http_msg http_msg
end virtual
 
macro copy_till_zero {
local   .copyloop, .copydone
  .copyloop:
        lodsb
        test    al, al
        jz      .copydone
        stosb
        jmp     .copyloop
  .copydone:
}
 
macro HTTP_init_buffer buffer, socketnum {
 
        mov     eax, buffer
        push    socketnum
        popd    [eax + http_msg.socket]
        lea     esi, [eax + http_msg.data]
        mov     [eax + http_msg.flags], FLAG_CONNECTED
        mov     [eax + http_msg.write_ptr], esi
        mov     [eax + http_msg.buffer_length], BUFFERSIZE -  http_msg.data
        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_length], 0
        mov     [eax + http_msg.content_received], 0
 
        push    eax ebp
        mov     ebp, eax
        mcall   29, 9
        mov     [ebp + http_msg.timestamp], eax
        pop     ebp eax
}
 
section '.flat' code readable align 16
 
;;===========================================================================;;
lib_init: ;//////////////////////////////////////////////////////////////////;;
;;---------------------------------------------------------------------------;;
;? Library entry point (called after library load)                           ;;
;;---------------------------------------------------------------------------;;
;> eax = pointer to memory allocation routine                                ;;
;> ebx = pointer to memory freeing routine                                   ;;
;> ecx = pointer to memory reallocation routine                              ;;
;> edx = pointer to library loading routine                                  ;;
;;---------------------------------------------------------------------------;;
;< eax = 1 (fail) / 0 (ok)                                                   ;;
;;===========================================================================;;
        mov     [mem.alloc], eax
        mov     [mem.free], ebx
        mov     [mem.realloc], ecx
        mov     [dll.load], edx
 
        invoke  dll.load, @IMPORT
        test    eax, eax
        jnz     .error
 
; load proxy settings
        pusha
        invoke  ini.get_str, inifile, sec_proxy, key_proxy, proxyAddr, 256, proxyAddr
        invoke  ini.get_int, inifile, sec_proxy, key_proxyport, 80
        mov     [proxyPort], eax
        invoke  ini.get_str, inifile, sec_proxy, key_user, proxyUser, 256, proxyUser
        invoke  ini.get_str, inifile, sec_proxy, key_password, proxyPassword, 256, proxyPassword
        popa
 
        DEBUGF  1, "HTTP library: init OK\n"
 
        xor     eax, eax
        ret
 
  .error:
        DEBUGF  1, "ERROR loading libraries\n"
 
        xor     eax, eax
        inc     eax
 
        ret
 
 
 
 
;;================================================================================================;;
proc HTTP_get URL, add_header ;///////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'GET' method.                                               ;;
;;------------------------------------------------------------------------------------------------;;
;> URL          = pointer to ASCIIZ URL                                                           ;;
;> add_header   = pointer to additional header parameters (ASCIIZ), or null for none.             ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        sockaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        pusha
 
; split the URL into hostname and pageaddr
        stdcall parse_url, [URL]
        test    eax, eax
        jz      .error
        mov     [hostname], eax
        mov     [pageaddr], ebx
        mov     [port], ecx
 
; Connect to the other side.
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .error
        mov     [buffer], eax
        mov     edi, eax
        DEBUGF  1, "Buffer has been allocated.\n"
 
        mov     esi, str_get
        copy_till_zero
 
; If we are using a proxy, send complete URL, otherwise send only page address.
        cmp     [proxyAddr], 0
        je      .no_proxy
        mov     esi, str_http           ; prepend 'http://'
        copy_till_zero
        mov     esi, [hostname]
        copy_till_zero
  .no_proxy:
        mov     esi, [pageaddr]
        copy_till_zero
 
        mov     esi, str_http11
        mov     ecx, str_http11.length
        rep     movsb
 
        mov     esi, [hostname]
        copy_till_zero
 
        cmp     byte[proxyUser], 0
        je      @f
        call    append_proxy_auth_header
  @@:
 
        mov     ax, 0x0a0d
        stosw
 
        mov     esi, [add_header]
        test    esi, esi
        jz      @f
        copy_till_zero
  @@:
 
 
 
 
 
 
        mov     esi, str_close
        mov     ecx, str_close.length
        rep     movsb
 
        mov     byte[edi], 0
        DEBUGF  1, "Request:\n%s", [buffer]
 
; Free unused memory
        push    edi
        invoke  mem.free, [pageaddr]
        invoke  mem.free, [hostname]
        pop     esi
 
; Send the request
        sub     esi, [buffer]   ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], [buffer]
        test    eax, eax
        jz      .error
        DEBUGF  1, "Request has been sent to server.\n"
 
        HTTP_init_buffer [buffer], [socketnum]
 
        popa
        mov     eax, [buffer]   ; return buffer ptr
        ret
 
  .error:
        DEBUGF  1, "Error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_head URL, add_header ;//////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'HEAD' method.                                              ;;
;;------------------------------------------------------------------------------------------------;;
;> URL          = pointer to ASCIIZ URL                                                           ;;
;> add_header   = pointer to additional header parameters (ASCIIZ), or null for none.             ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        sockaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        pusha
; split the URL into hostname and pageaddr
        stdcall parse_url, [URL]
        test    eax, eax
        jz      .error
        mov     [hostname], eax
        mov     [pageaddr], ebx
        mov     [port], ecx
 
; Connect to the other side.
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .error
        mov     [buffer], eax
        mov     edi, eax
        DEBUGF  1, "Buffer has been allocated.\n"
 
        mov     esi, str_head
        copy_till_zero
 
; If we are using a proxy, send complete URL, otherwise send only page address.
        cmp     [proxyAddr], 0
        je      .no_proxy
        mov     esi, str_http           ; prepend 'http://'
        copy_till_zero
        mov     esi, [hostname]
        copy_till_zero
  .no_proxy:
        mov     esi, [pageaddr]
        copy_till_zero
 
        mov     esi, str_http11
        mov     ecx, str_http11.length
        rep     movsb
 
        mov     esi, [hostname]
        copy_till_zero
 
        cmp     byte[proxyUser], 0
        je      @f
        call    append_proxy_auth_header
  @@:
 
        mov     ax, 0x0a0d
        stosw
 
        mov     esi, [add_header]
        test    esi, esi
        jz      @f
        copy_till_zero
  @@:
 
 
 
 
 
 
        mov     esi, str_close
        mov     ecx, str_close.length
        rep     movsb
 
        mov     byte[edi], 0
        DEBUGF  1, "Request:\n%s", [buffer]
 
 
; Free unused memory
        push    edi
        invoke  mem.free, [pageaddr]
        invoke  mem.free, [hostname]
        pop     esi
 
; Send the request
        sub     esi, [buffer]   ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], [buffer]
        test    eax, eax
        jz      .error
        DEBUGF  1, "Request has been sent to server.\n"
 
        HTTP_init_buffer [buffer], [socketnum]
 
        popa
        mov     eax, [buffer]
        ret                     ; return buffer ptr
 
  .error:
        DEBUGF  1, "Error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
;;================================================================================================;;
proc HTTP_post URL, add_header, content_type, content_length ;////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Initiates a HTTP connection, using 'GET' method.                                               ;;
;;------------------------------------------------------------------------------------------------;;
;> URL                  = pointer to ASCIIZ URL                                                   ;;
;> add_header           = pointer to additional header parameters (ASCIIZ), or null for none.     ;;
;> content_type         = pointer to ASCIIZ string containing content type                        ;;
;> content_length       = length of content (in bytes)                                            ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / buffer ptr                                                                   ;;
;;================================================================================================;;
locals
        hostname        dd ?
        pageaddr        dd ?
        sockaddr        dd ?
        socketnum       dd ?
        buffer          dd ?
        port            dd ?
endl
 
        pusha
; split the URL into hostname and pageaddr
        stdcall parse_url, [URL]
        test    eax, eax
        jz      .error
        mov     [hostname], eax
        mov     [pageaddr], ebx
        mov     [port], ecx
 
; Connect to the other side.
        stdcall open_connection, [hostname], [port]
        test    eax, eax
        jz      .error
        mov     [socketnum], eax
 
; Create the HTTP request.
        invoke  mem.alloc, BUFFERSIZE
        test    eax, eax
        jz      .error
        mov     [buffer], eax
        mov     edi, eax
        DEBUGF  1, "Buffer has been allocated.\n"
 
        mov     esi, str_post
        copy_till_zero
 
; If we are using a proxy, send complete URL, otherwise send only page address.
        cmp     [proxyAddr], 0
        je      .no_proxy
        mov     esi, str_http           ; prepend 'http://'
        copy_till_zero
        mov     esi, [hostname]
        copy_till_zero
  .no_proxy:
        mov     esi, [pageaddr]
        copy_till_zero
 
        mov     esi, str_http11
        mov     ecx, str_http11.length
        rep     movsb
 
        mov     esi, [hostname]
        copy_till_zero
 
        mov     esi, str_post_cl
        mov     ecx, str_post_cl.length
        rep     movsb
 
        mov     eax, [content_length]
        call    eax_ascii_dec
 
        mov     esi, str_post_ct
        mov     ecx, str_post_ct.length
        rep     movsb
 
        mov     esi, [content_type]
        copy_till_zero
 
        cmp     byte[proxyUser], 0
        je      @f
        call    append_proxy_auth_header
  @@:
 
        mov     ax, 0x0a0d
        stosw
 
        mov     esi, [add_header]
        test    esi, esi
        jz      @f
        copy_till_zero
  @@:
 
 
 
 
 
 
        mov     esi, str_close
        mov     ecx, str_close.length
        rep     movsb
 
        mov     byte[edi], 0
        DEBUGF  1, "Request:\n%s", [buffer]
 
; Free unused memory
        push    edi
        invoke  mem.free, [pageaddr]
        invoke  mem.free, [hostname]
        pop     esi
 
; Send the request
        sub     esi, [buffer]   ; length
        xor     edi, edi        ; flags
        mcall   send, [socketnum], [buffer]
        test    eax, eax
        jz      .error
        DEBUGF  1, "Request has been sent to server.\n"
 
        HTTP_init_buffer [buffer], [socketnum]
 
        popa
        mov     eax, [buffer]
        ret                     ; return buffer ptr
 
  .error:
        DEBUGF  1, "Error!\n"
        popa
        xor     eax, eax        ; return 0 = error
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_process identifier ;////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Receive data from the server, parse headers and put data in receive buffer.                    ;;
;? To complete a transfer, this procedure must be called over and over again untill it returns 0. ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = -1 (not finished) / 0 finished                                                           ;;
;;================================================================================================;;
        pusha
        mov     ebp, [identifier]
 
; If the connection is closed, return immediately
        test    [ebp + http_msg.flags], FLAG_CONNECTED
        jz      .connection_closed
 
; Receive some data
        mcall   recv, [ebp + http_msg.socket], [ebp + http_msg.write_ptr], \
                      [ebp + http_msg.buffer_length], MSG_DONTWAIT
        cmp     eax, 0xffffffff
        je      .check_socket
 
        test    eax, eax
        jz      .server_closed
        DEBUGF  1, "Received %u bytes\n", eax
 
; Update timestamp
        push    eax
        mcall   29, 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
        jz      .got_all_data
 
; 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
 
; 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.data
        sub     eax, ebp
        sub     eax, [ebp + http_msg.header_length]
        ; edi is ptr to begin of header
        lea     edi, [ebp + http_msg.data]
        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
  .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
 
  .end_of_header:
        add     edi, 4 - http_msg.data
        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 header:
        cmp     dword[esi], 'HTTP'
        jne     .invalid_header
        cmp     dword[esi+4], '/1.0'
        je      .http_1.0
        cmp     dword[esi+4], '/1.1'
        jne     .invalid_header
        or      [ebp + http_msg.flags], FLAG_HTTP11
  .http_1.0:
        cmp     byte[esi+8], ' '
        jne     .invalid_header
 
        add     esi, 9
        xor     eax, eax
        xor     ebx, ebx
        mov     ecx, 3
  .statusloop:
        lodsb
        sub     al, '0'
        jb      .invalid_header
        cmp     al, 9
        ja      .invalid_header
        lea     ebx, [ebx + 4*ebx]
        shl     ebx, 1
        add     ebx, eax
        dec     ecx
        jnz     .statusloop
 
; Ignore "100 - Continue" headers
        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.data]
        mov     ecx, [ebp + http_msg.header_length]
  .need_newline:
        inc     esi
        dec     ecx
        jz      .convert_done
        cmp     byte[esi], 10
        jne     .need_newline
; Ok, we have 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.data]
        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      .invalid_header
        cmp     bl, 9
        ja      .invalid_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
 
; Resize buffer according to content-length.
        add     edx, [ebp + http_msg.header_length]
        add     edx, http_msg.data
 
        mov     ecx, edx
        sub     ecx, [ebp + http_msg.write_ptr]
        mov     [ebp + http_msg.buffer_length], ecx
 
        invoke  mem.realloc, ebp, edx
        or      eax, eax
        jz      .no_ram
 
  .not_chunked:
        mov     eax, [ebp + http_msg.write_ptr]
        sub     eax, [ebp + http_msg.header_length]
        sub     eax, http_msg.data
        sub     eax, ebp
        jmp     .header_parsed  ; hooray!
 
  .no_content:
        DEBUGF  1, "Content-length not found.\n"
 
; We didnt find 'content-length', maybe server is using chunked transfer encoding?
; Try to find 'transfer-encoding' header.
        stdcall HTTP_find_header_field, ebp, str_te
        test    eax, eax
        jz      .not_chunked
 
        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"
 
; Set chunk pointer where first chunk should begin.
        lea     eax, [ebp + http_msg.data]
        add     eax, [ebp + http_msg.header_length]
        mov     [ebp + http_msg.chunk_ptr], eax
 
  .chunk_loop:
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, [ebp + http_msg.chunk_ptr]
        jb      .need_more_data_chunked         ; TODO: use this ecx !!!
 
; Chunkline starts here, convert the ASCII hex number into ebx
        mov     esi, [ebp + http_msg.chunk_ptr]
        xor     ebx, ebx
  .chunk_hexloop:
        lodsb
        sub     al, '0'
        jb      .chunk_
        cmp     al, 9
        jbe     .chunk_hex
        sub     al, 'A' - '0' - 10
        jb      .chunk_
        cmp     al, 15
        jbe     .chunk_hex
        sub     al, 'a' - 'A'
        cmp     al, 15
        ja      .chunk_
  .chunk_hex:
        shl     ebx, 4
        add     bl, al
        jmp     .chunk_hexloop
  .chunk_:
        DEBUGF  1, "got chunk of %u bytes\n", ebx
;;        cmp     esi, [ebp + http_msg.chunk_ptr]
;;        je
; If chunk size is 0, all chunks have been received.
        test    ebx, ebx
        jz      .got_all_data_chunked           ; last chunk, hooray! FIXME: what if it wasnt a valid hex number???
 
; Chunkline ends with a CR, LF or simply LF
  .end_of_chunkline?:
        cmp     al, 10
        je      .end_of_chunkline
        lodsb
        cmp     edi, [ebp + http_msg.write_ptr]
        jb      .end_of_chunkline?
        jmp     .need_more_data
 
  .end_of_chunkline:
; Update chunk ptr, and remember old one
        mov     edi, [ebp + http_msg.chunk_ptr]
        add     [ebp + http_msg.chunk_ptr], ebx
; Realloc buffer, make it 'chunksize' bigger.
        mov     eax, [ebp + http_msg.buffer_length]
        add     eax, ebx
        invoke  mem.realloc, ebp, eax
        or      eax, eax
        jz      .no_ram
        add     [ebp + http_msg.buffer_length], ebx
 
; Update write ptr
        mov     eax, esi
        sub     eax, edi
        sub     [ebp + http_msg.write_ptr], eax
 
; Now move all received data to the left (remove chunk header).
; Update content_length accordingly.
        mov     ecx, [ebp + http_msg.write_ptr]
        sub     ecx, esi
        add     [ebp + http_msg.content_received], ecx
        rep     movsb
        jmp     .chunk_loop
 
; Check if we got all the data.
  .header_parsed:
        add     [ebp + http_msg.content_received], eax
        test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
        jz      .need_more_data_and_space
        mov     eax, [ebp + http_msg.content_received]
        cmp     eax, [ebp + http_msg.content_length]
        jae     .got_all_data
        jmp     .need_more_data
 
  .need_more_data_and_space:
        mov     eax, [ebp + http_msg.write_ptr]
        add     eax, BUFFERSIZE
        sub     eax, ebp
        invoke  mem.realloc, ebp, eax
        or      eax, eax
        jz      .no_ram
        mov     [ebp + http_msg.buffer_length], BUFFERSIZE
 
  .need_more_data:
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .need_more_data_chunked:
        add     [ebp + http_msg.content_received], eax
        popa
        xor     eax, eax
        dec     eax
        ret
 
  .got_all_data_chunked:
        mov     eax, [ebp + http_msg.chunk_ptr]
        sub     eax, [ebp + http_msg.header_length]
        sub     eax, http_msg.data
        sub     eax, ebp
        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
 
  .check_socket:
        cmp     ebx, EWOULDBLOCK
        jne     .socket_error
 
        mcall   29, 9
        sub     eax, TIMEOUT
        cmp     eax, [ebp + http_msg.timestamp]
        jb      .need_more_data
        DEBUGF  1, "ERROR: timeout\n"
        or      [ebp + http_msg.flags], FLAG_TIMEOUT_ERROR
        jmp     .disconnect
 
  .server_closed:
        DEBUGF  1, "server closed connection, transfer complete?\n"
        test    [ebp + http_msg.flags], FLAG_GOT_HEADER
        jz      .server_error
        test    [ebp + http_msg.flags], FLAG_CONTENT_LENGTH
        jz      .got_all_data
 
  .server_error:
        pop     eax
        DEBUGF  1, "ERROR: server closed connection unexpectedly\n"
        or      [ebp + http_msg.flags], FLAG_TRANSFER_FAILED
        jmp     .disconnect
 
  .invalid_header:
        pop     eax
        DEBUGF  1, "ERROR: invalid header\n"
        or      [ebp + http_msg.flags], FLAG_INVALID_HEADER
        jmp     .disconnect
 
  .no_ram:
        DEBUGF  1, "ERROR: out of RAM\n"
        or      [ebp + http_msg.flags], FLAG_NO_RAM
        jmp     .disconnect
 
  .socket_error:
        DEBUGF  1, "ERROR: socket error %u\n", ebx
        or      [ebp + http_msg.flags], FLAG_SOCKET_ERROR
  .disconnect:
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
  .connection_closed:
        popa
        xor     eax, eax
        ret
 
endp
 
 
 
 
;;================================================================================================;;
proc HTTP_free identifier ;///////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Free the http_msg structure                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< none                                                                                           ;;
;;================================================================================================;;
 
        pusha
        mov     ebp, [identifier]
 
        test    [ebp + http_msg.flags], FLAG_CONNECTED
        jz      .not_connected
 
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
 
  .not_connected:
        invoke  mem.free, ebp
 
        popa
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_stop identifier ;///////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Stops the open connection                                                                      ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = pointer to buffer containing http_msg struct.                                   ;;
;;------------------------------------------------------------------------------------------------;;
;< none                                                                                           ;;
;;================================================================================================;;
 
        pusha
        mov     ebp, [identifier]
 
        and     [ebp + http_msg.flags], not FLAG_CONNECTED
        mcall   close, [ebp + http_msg.socket]
 
        popa
        ret
 
endp
 
 
 
;;================================================================================================;;
proc HTTP_find_header_field identifier, headername ;//////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Find a header field in the received HTTP header                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> identifier   = ptr to http_msg struct                                                          ;;
;> headername   = ptr to ASCIIZ string containg field you want to find (must be in lowercase)     ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to content of the HTTP header field                                      ;;
;;================================================================================================;;
        push    ebx ecx edx esi edi
 
        DEBUGF  1, "Find header field: %s\n", [headername]
 
        mov     ebx, [identifier]
        test    [ebx + http_msg.flags], FLAG_GOT_HEADER
        jz      .fail
 
        lea     edx, [ebx + http_msg.data]
        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:
        pop     edi esi edx ecx ebx
        xor     eax, eax
        ret
 
endp
 
 
 
;;================================================================================================;;
proc URI_escape URI ;/////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;?                                                                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> URI = ptr to ASCIIZ URI                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ URI                                                            ;;
;;================================================================================================;;
 
        pusha
 
        invoke  mem.alloc, URLMAXLEN
        test    eax, eax
        jz      .error
        mov     [esp + 7 * 4], eax              ; return ptr in eax
        mov     esi, [URI]
        mov     edi, eax
        xor     ebx, ebx
        xor     ecx, ecx
  .loop:
        lodsb
        test    al, al
        jz      .done
 
        mov     cl, al
        and     cl, 0x1f
        mov     bl, al
        shr     bl, 5
        bt      dword[bits_must_escape + ebx], ecx
        jc      .escape
 
        stosb
        jmp     .loop
 
  .escape:
        mov     al, '%'
        stosb
        mov     bl, byte[esi-1]
        shr     bl, 4
        mov     al, byte[str_hex + ebx]
        stosb
        mov     bl, byte[esi-1]
        and     bl, 0x0f
        mov     al, byte[str_hex + ebx]
        stosb
        jmp     .loop
 
 
  .done:
        stosb
 
        popa
        ret
 
  .error:
        popa
        xor     eax, eax
        ret
 
endp
 
 
 
;;================================================================================================;;
proc URI_unescape URI ;///////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;?                                                                                                ;;
;;------------------------------------------------------------------------------------------------;;
;> URI = ptr to ASCIIZ URI                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ URI                                                            ;;
;;================================================================================================;;
 
        pusha
 
        invoke  mem.alloc, URLMAXLEN
        test    eax, eax
        jz      .error
        mov     [esp + 7 * 4], eax              ; return ptr in eax
        mov     esi, [URI]
        mov     edi, eax
  .loop:
        lodsb
        test    al, al
        jz      .done
 
        cmp     al, '%'
        je      .unescape
 
        stosb
        jmp     .loop
 
  .unescape:
        xor     ebx, ebx
        xor     ecx, ecx
  .unescape_nibble:
        lodsb
        sub     al, '0'
        jb      .fail
        cmp     al, 9
        jbe     .nibble_ok
        sub     al, 'A' - '0' - 10
        jb      .fail
        cmp     al, 15
        jbe     .nibble_ok
        sub     al, 'a' - 'A'
        cmp     al, 15
        ja      .fail
  .nibble_ok:
        shl     bl, 8
        or      bl, al
        dec     ecx
        jc      .unescape_nibble
        mov     al, bl
        stosb
        jmp     .loop
 
  .fail:
        DEBUGF  1, "ERROR: invalid URI!\n"
        jmp     .loop
 
  .done:
        stosb
 
        popa
        ret
 
  .error:
        popa
        xor     eax, eax
        ret
 
endp
 
 
 
 
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Internal procedures section                                                                    ;;
;;                                                                                                ;;
;; NOTICE: These procedures do not follow stdcall conventions and thus may destroy any register.  ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
 
 
 
;;================================================================================================;;
proc open_connection hostname, port ;/////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Connects to a HTTP server                                                                      ;;
;;------------------------------------------------------------------------------------------------;;
;> hostname     = ptr to ASCIIZ hostname                                                          ;;
;> port         = port (x86 byte order)                                                           ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / socketnum                                                                    ;;
;;================================================================================================;;
 
locals
        sockaddr        dd ?
        socketnum       dd ?
endl
 
        cmp     [proxyAddr], 0
        je      .no_proxy
 
        mov     [hostname], proxyAddr
 
        push    [proxyPort]
        pop     [port]
  .no_proxy:
 
; Resolve the hostname
        DEBUGF  1, "Resolving hostname\n"
        push    esp     ; reserve stack place
        push    esp     ; fourth parameter
        push    0       ; third parameter
        push    0       ; second parameter
        push    [hostname]
        call    [getaddrinfo]
        pop     esi
        test    eax, eax
        jnz     .error1
 
; getaddrinfo returns addrinfo struct, make the pointer to sockaddr struct
        mov     esi, [esi + addrinfo.ai_addr]
        mov     [sockaddr], esi
        mov     eax, [esi + sockaddr_in.sin_addr]
        test    eax, eax
        jz      .error2
 
        DEBUGF  1, "Server ip=%u.%u.%u.%u\n", \
        [esi + sockaddr_in.sin_addr]:1, [esi + sockaddr_in.sin_addr + 1]:1, \
        [esi + sockaddr_in.sin_addr + 2]:1, [esi + sockaddr_in.sin_addr + 3]:1
 
        mov     [esi + sockaddr_in.sin_family], AF_INET4
        mov     eax, [port]
        xchg    al, ah
        mov     [esi + sockaddr_in.sin_port], ax
 
; Connect to the server.
        mcall   socket, AF_INET4, SOCK_STREAM, 0
        test    eax, eax
        jz      .error2
        mov     [socketnum], eax
        DEBUGF  1, "Socket: 0x%x\n", eax
 
        mcall   connect, [socketnum], [sockaddr], 18
        test    eax, eax
        jnz     .error2
        DEBUGF  1, "Socket is now connected.\n"
 
; free allocated memory
        push    [sockaddr]
        call    [freeaddrinfo]
 
        mov     eax, [socketnum]
        ret
 
  .error2:
 
; free allocated memory
        push    [sockaddr]
        call    [freeaddrinfo]
 
  .error1:
        xor     eax, eax
        ret
 
endp
 
 
;;================================================================================================;;
proc parse_url URL ;//////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Split a given URL into hostname and pageaddr                                                   ;;
;;------------------------------------------------------------------------------------------------;;
;> URL = ptr to ASCIIZ URL                                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 (error) / ptr to ASCIIZ hostname                                                       ;;
;< ebx = ptr to ASCIIZ pageaddr                                                                   ;;
;< ecx = port number                                                                              ;;
;;================================================================================================;;
 
locals
        urlsize         dd ?
        hostname        dd ?
        pageaddr        dd ?
        port            dd ?
endl
 
        DEBUGF  1, "parsing URL: %s\n", [URL]
 
; remove any leading protocol text
        mov     esi, [URL]
        mov     ecx, URLMAXLEN
        mov     ax, '//'
  .loop1:
        cmp     byte[esi], 0            ; end of URL?
        je      .url_ok                 ; yep, so not found
        cmp     [esi], ax
        je      .skip_proto
        inc     esi
        dec     ecx
        jnz     .loop1
        jmp     .invalid
 
  .skip_proto:
        inc     esi                     ; skip the two '/'
        inc     esi
        mov     [URL], esi              ; update pointer so it skips protocol
        jmp     .loop1                  ; we still need to find the length of the URL
 
  .url_ok:
        sub     esi, [URL]              ; calculate total length of URL
        mov     [urlsize], esi
 
 
; now look for page delimiter - it's a '/' character
        mov     ecx, esi                ; URL length
        mov     edi, [URL]
        mov     al, '/'
        repne   scasb
        jne     @f
        dec     edi                     ; return one char, '/' must be part of the pageaddr
        inc     ecx                     ;
  @@:
        push    ecx edi                 ; remember the pointer and length of pageaddr
 
 
; Create new buffer and put hostname in it.
        mov     ecx, edi
        sub     ecx, [URL]
        inc     ecx                     ; we will add a 0 byte at the end
        invoke  mem.alloc, ecx
        or      eax, eax
        jz      .no_mem
 
        mov     [hostname], eax         ; copy hostname to buffer
        mov     edi, eax
        mov     esi, [URL]
        dec     ecx
        rep     movsb
        xor     al, al
        stosb
 
; Check if user provided a port, and convert it if so.
        mov     esi, [hostname]
        mov     [port], 80              ; default port if user didnt provide one
  .portloop:
        lodsb
        test    al, al
        jz      .no_port
        cmp     al, ':'
        jne     .portloop
 
        push    esi
        call    ascii_dec_ebx
        pop     edi
        cmp     byte[esi-1], 0
        jne     .invalid
        cmp     [proxyAddr], 0          ; remove port number from hostname
        jne     @f                      ; unless when we are using proxy
        mov     byte[edi-1], 0
  @@:
        test    ebx, ebx
        je      .invalid
        cmp     ebx, 0xffff
        ja      .invalid
        mov     [port], ebx
  .no_port:
 
 
; Did user provide a pageaddr?
        mov     [pageaddr], str_slash   ; assume there is no pageaddr
        pop     esi ecx
        test    ecx, ecx
        jz      .no_page
 
; Create new buffer and put pageaddr into it.
        inc     ecx                     ; we will add a 0 byte at the end
        invoke  mem.alloc, ecx
        or      eax, eax
        jz      .no_mem
 
        mov     [pageaddr], eax         ; copy pageaddr to buffer
        mov     edi, eax
        dec     ecx
        rep     movsb
        xor     al, al
        stosb
 
  .no_page:
        mov     eax, [hostname]
        mov     ebx, [pageaddr]
        mov     ecx, [port]
 
        DEBUGF  1, "hostname: %s\n", eax
        DEBUGF  1, "pageaddr: %s\n", ebx
        DEBUGF  1, "port: %u\n", ecx
 
        ret
 
  .no_mem:
        DEBUGF  1, "Out of memory!\n"
        xor     eax, eax
        ret
 
  .invalid:
        DEBUGF  1, "Invalid URL!\n"
        xor     eax, eax
        ret
 
endp
 
 
 
 
 
;;================================================================================================;;
proc append_proxy_auth_header ;///////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Appends the proxy authentication header                                                        ;;
;;------------------------------------------------------------------------------------------------;;
;> /                                                                                              ;;
;;------------------------------------------------------------------------------------------------;;
;< /                                                                                              ;;
;;================================================================================================;;
        mov     esi, str_proxy_auth
        mov     ecx, str_proxy_auth.length
        rep     movsb
; base64-encode string :
        mov     esi, proxyUser
 
apah000:
        lodsb
        test    al, al
        jz      apah001
        call    encode_base64_byte
        jmp     apah000
 
apah001:
        mov     al, ':'
        call    encode_base64_byte
        mov     esi, proxyPassword
 
apah002:
        lodsb
        test    al, al
        jz      apah003
        call    encode_base64_byte
        jmp     apah002
 
apah003:
        call    encode_base64_final
        ret
 
encode_base64_byte:
        inc     ecx
        shl     edx, 8
        mov     dl, al
        cmp     ecx, 3
        je      ebb001
        ret
 
ebb001:
        shl     edx, 8
        inc     ecx
 
ebb002:
        rol     edx, 6
        xor     eax, eax
        xchg    al, dl
        mov     al, [base64_table+eax]
        stosb
        loop    ebb002
        ret
 
encode_base64_final:
        mov     al, 0
        test    ecx, ecx
        jz      ebf000
        call    encode_base64_byte
        test    ecx, ecx
        jz      ebf001
        call    encode_base64_byte
        mov     byte [edi-2], '='
 
ebf001:
        mov     byte [edi-1], '='
 
ebf000:
        ret
 
endp
 
 
;;================================================================================================;;
proc eax_ascii_dec ;//////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Convert eax to ASCII decimal number                                                            ;;
;;------------------------------------------------------------------------------------------------;;
;> eax = number                                                                                   ;;
;> edi = ptr where to write ASCII decimal number                                                  ;;
;;------------------------------------------------------------------------------------------------;;
;< /                                                                                              ;;
;;================================================================================================;;
 
        push    -'0'
        mov     ecx, 10
  .loop:
        xor     edx, edx
        div     ecx
        add     dl, '0'
        push    edx
        test    eax, eax
        jnz     .loop
 
  .loop2:
        pop     eax
        add     al, '0'
        jz      .done
        stosb
        jmp     .loop2
  .done:
 
        ret
 
endp
 
 
;;================================================================================================;;
proc ascii_dec_ebx ;//////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Convert ASCII decimal number to ebx                                                            ;;
;;------------------------------------------------------------------------------------------------;;
;> esi = ptr where to read ASCII decimal number                                                   ;;
;;------------------------------------------------------------------------------------------------;;
;> ebx = number                                                                                   ;;
;;================================================================================================;;
 
        xor     eax, eax
        xor     ebx, ebx
  .loop:
        lodsb
        sub     al, '0'
        jb      .done
        cmp     al, 9
        ja      .done
        lea     ebx, [ebx + 4*ebx]
        shl     ebx, 1
        add     ebx, eax
        jmp     .loop
  .done:
 
        ret
 
endp
 
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Imported functions section                                                                     ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
 
align 16
@IMPORT:
 
library \
        libini, 'libini.obj', \
        network, 'network.obj'
 
import  libini, \
        ini.get_str, 'ini_get_str', \
        ini.get_int, 'ini_get_int'
 
import  network,\
        getaddrinfo, 'getaddrinfo',\
        freeaddrinfo,  'freeaddrinfo',\
        inet_ntoa, 'inet_ntoa'
 
;;===========================================================================;;
;;///////////////////////////////////////////////////////////////////////////;;
;;===========================================================================;;
;! Exported functions section                                                ;;
;;===========================================================================;;
;;///////////////////////////////////////////////////////////////////////////;;
;;===========================================================================;;
 
 
align 4
@EXPORT:
export  \
        lib_init                , 'lib_init'            , \
        0x00010001              , 'version'             , \
        HTTP_get                , 'get'                 , \
        HTTP_head               , 'head'                , \
        HTTP_post               , 'post'                , \
        HTTP_find_header_field  , 'find_header_field'   , \
        HTTP_process            , 'process'             , \
        HTTP_free               , 'free'                , \
        HTTP_stop               , 'stop'                , \
        URI_escape              , 'escape'              , \
        URI_unescape            , 'unescape'
 
;        HTTP_put                , 'put'                 , \
;        HTTP_delete             , 'delete'              , \
;        HTTP_trace              , 'trace'               , \
;        HTTP_connect            , 'connect'             , \
 
 
 
section '.data' data readable writable align 16
 
inifile         db '/sys/settings/network.ini', 0
 
sec_proxy:
key_proxy       db 'proxy', 0
key_proxyport   db 'port', 0
key_user        db 'user', 0
key_password    db 'password', 0
 
str_http11      db ' HTTP/1.1', 13, 10, 'Host: '
  .length       = $ - str_http11
str_post_cl     db 13, 10, 'Content-Length: '
  .length       = $ - str_post_cl
str_post_ct     db 13, 10, 'Content-Type: '
  .length       = $ - str_post_ct
 
 
str_proxy_auth  db 13, 10, 'Proxy-Authorization: Basic '
  .length       = $ - str_proxy_auth
str_close       db 'User-Agent: KolibriOS libHTTP/1.0', 13, 10, 'Connection: Close', 13, 10, 13, 10
  .length       = $ - str_close
 
str_http        db 'http://', 0
 
base64_table    db 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
                db '0123456789+/'
 
str_cl          db 'content-length', 0
str_slash       db '/', 0
str_te          db 'transfer-encoding', 0
str_get         db 'GET ', 0
str_head        db 'HEAD ', 0
str_post        db 'POST ', 0
 
bits_must_escape:
dd      0xffffffff                                                      ; 00-1F
dd      1 shl 0 + 1 shl 2 + 1 shl 3 + 1 shl 5 + 1 shl 28 + 1 shl 30     ; "#%<>
dd      1 shl 27 + 1 shl 28 + 1 shl 29 + 1 shl 30                       ;[\]^
dd      1 shl 0 + 1 shl 27 + 1 shl 28 + 1 shl 29 + 1 shl 31             ;`{|} DEL
 
dd      0xffffffff
dd      0xffffffff
dd      0xffffffff
dd      0xffffffff
 
str_hex:
db '0123456789ABCDEF'
 
include_debug_strings
 
; uninitialized data
mem.alloc       dd ?
mem.free        dd ?
mem.realloc     dd ?
dll.load        dd ?
 
proxyAddr       rb 256
proxyUser       rb 256
proxyPassword   rb 256
proxyPort       dd ?

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

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/http/http.asm – Rev 4233 → 4241