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