Subversion Repositories Kolibri OS

format MS COFF

public @EXPORT as 'EXPORTS'

include '../struct.inc'

include '../proc32.inc'

include '../macros.inc'

purge section,mov,add,sub

include '../network.inc'

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) (library initialization result)                   ;;

;;===========================================================================;;

	mov	[mem.alloc], eax

	mov	[mem.free], ebx

	mov	[mem.realloc], ecx

	mov	[dll.load], edx

	mov	[DNSrequestID], 1

	stdcall edx, @IMPORT

	xor	eax, eax

	ret

;;===========================================================================;;

;; in_addr_t __stdcall inet_addr(__in const char* hostname);                 ;;

inet_addr:								     ;;

;;---------------------------------------------------------------------------;;

;? Convert the string from standard IPv4 dotted notation to integer IP addr. ;;

;;---------------------------------------------------------------------------;;

;> first parameter = host name                                               ;;

;;---------------------------------------------------------------------------;;

;< eax = IP address on success / -1 on error                                 ;;

;;===========================================================================;;

; 0. Save used registers for __stdcall.

	push	ebx esi edi

	mov	esi, [esp+16]	; esi = hostname

; 1. Check that only allowed symbols are present.

; (hex digits, possibly letters 'x'/'X' and up to 3 dots)

	push	esi

	xor	ecx, ecx

.calcdots_loop:

; loop for all characters in string

	lodsb

; check for end of string

	cmp	al, 0

	jz	.calcdots_loop_done

; check for dot

	cmp	al, '.'

	jz	.dot

; check for digit

	sub	al, '0'

	cmp	al, 9

	jbe	.calcdots_loop

; check for hex letter

	sub	al, 'A' - '0'	; 'A'-'F' -> 0-5, 'a'-'f' -> 20h-25h

	and	al, not 20h

	cmp	al, 'F' - 'A'

	jbe	.calcdots_loop

; check for 'x'/'X'

	cmp	al, 'X' - 'A'

	jz	.calcdots_loop

	jmp	.fail.pop

.dot:

	inc	ecx

	jmp	.calcdots_loop

.calcdots_loop_done:

	cmp	ecx, 4

	jae	.fail.pop

; 2. The name can be valid dotted name; try to convert, checking limit

	pop	esi

	xor	edi, edi	; edi = address

	push	0xFFFFFFFF

	pop	edx		; edx = mask for rest of address

; 2a. Convert name except for last group.

	jecxz	.ip_convert_2b

.ip_convert_2a:

	push	ecx

	mov	ecx, 0xFF	; limit for all groups except for last

	call	.get_number

	pop	ecx

	jc	.fail

	cmp	byte [esi-1], '.'

	jnz	.fail

	shl	edi, 8

	shr	edx, 8

	add	edi, eax

	loop	.ip_convert_2a

; 2b. Convert last group.

.ip_convert_2b:

	mov	ecx, edx

	call	.get_number

	jc	.fail

	cmp	byte [esi-1], 0

	jnz	.fail

@@:

	shl	edi, 8

	shr	edx, 8

	jnz	@b

	add	edi, eax

; 2c. Convert to network byte order.

	bswap	edi

; 3. Set return value, restore used registers and return.

	xchg	eax, edi

.ret:

	pop	edi esi ebx

	ret	4

; 4. On error, return -1.

.fail.pop:

	pop	esi

.fail:

	push	-1

	pop	eax

	jmp	.ret

;;===========================================================================;;

;; Internal auxiliary function for IP parsing.                                        ;;

.get_number:								     ;;

;;---------------------------------------------------------------------------;;

;? Converts string to number.                                                ;;

;;---------------------------------------------------------------------------;;

;> esi -> string                                                             ;;

;> ecx = limit for number                                                    ;;

;;---------------------------------------------------------------------------;;

;< eax = number                                                              ;;

;< CF set on error (too big number) / cleared on success                     ;;

;< esi -> end of number representation                                       ;;

;;===========================================================================;;

; 0. Save edx, which is used in caller.

	push	edx

; 1. Initialize number, zero eax so that lodsb gets full dword.

	xor	eax, eax

	xor	edx, edx

; 2. Get used numeral system: 0x = hex, otherwise 0 = octal, otherwise decimal

	push	10

	pop	ebx

	lodsb

	cmp	al, '0'

	jnz	.convert

	push	8

	pop	ebx

	lodsb

	cmp	al, 'x'

	jnz	.convert

	add	ebx, ebx

; 3. Loop while digits are encountered.

.convert:

; 4. Convert digit from text representation to binary value.

	or	al, 20h ; '0'-'9' -> '0'-'9', 'A'-'F' -> 'a'-'f'

	sub	al, '0'

	cmp	al, 9

	jbe	.digit

	sub	al, 'a' - '0'

	cmp	al, 'f' - 'a'

	ja	.convert_done

	add	al, 10

.digit:

; 5. Digit must be less than base of numeral system.

	cmp	eax, ebx

	jae	.convert_done

; 6. Advance the number.

	imul	edx, ebx

	add	edx, eax

	cmp	edx, ecx

	ja	.gn_error

; 3b. Continue loop.

	lodsb

	jmp	.convert

.convert_done:

; 7. Invalid character, number converted, return success.

	xchg	eax, edx

	pop	edx

	clc

	ret

.gn_error:

; 8. Too big number, return error.

	pop	edx

	stc

	ret

;;===========================================================================;;

;; char* __stdcall inet_ntoa(struct in_addr in);                             ;;

inet_ntoa:								     ;;

;;---------------------------------------------------------------------------;;

;? Convert the Internet host address to standard IPv4 dotted notation.       ;;

;;---------------------------------------------------------------------------;;

;> first parameter = host address                                            ;;

;;---------------------------------------------------------------------------;;

;< eax = pointer to resulting string (in static buffer)                      ;;

;;===========================================================================;;

; 0. Save used registers for __stdcall.

	push	ebx esi edi

	mov	bl, 0xCD	; constant for div 10

; 1. Write octet 4 times.

	mov	edi, .buffer

	mov	edx, [esp+16]	; eax = in

	mov	al, dl

	call	.write

	mov	al, dh

	shr	edx, 16

	call	.write

	mov	al, dl

	call	.write

	mov	al, dh

	call	.write

; 2. Replace final dot with terminating zero.

	mov	byte [edi-1], 0

; 3. Restore used registers, set result value and return.

	pop	edi esi ebx

	mov	eax, .buffer

	ret	4

.write:

	movzx	esi, al

	mul	bl

	add	esi, ('.' shl 8) + '0'

	shr	ah, 3	; ah = al / 10

	movzx	ecx, ah

	add	ecx, ecx

	lea	ecx, [ecx*5]

	sub	esi, ecx	; lobyte(esi) = al % 10, hibyte(esi) = '.'

	test	ah, ah

	jz	.1digit

	cmp	ah, 10

	jb	.2digit

	cmp	ah, 20

	sbb	cl, cl

	add	cl, '2'

	mov	byte [edi], cl

	movzx	ecx, cl

	lea	ecx, [ecx*5]

	sub	ah, cl

	sub	ah, cl

	add	ah, ('0'*11) and 255

	mov	byte [edi+1], ah

	mov	word [edi+2], si

	add	edi, 4

	ret

.2digit:

	add	ah, '0'

	mov	byte [edi], ah

	mov	word [edi+1], si

	add	edi, 3

	ret

.1digit:

	mov	word [edi], si

	add	edi, 2

	ret

struct __gai_reqdata

	socketnum  dd	   ?

; external code should not look on rest of this structure,

; it is internal for getaddrinfo_start/process/abort

	reqid		dw	?	; DNS request ID

	socktype	db	?	; SOCK_* or 0 for any

			db	?

	service 	dd	?

	flags		dd	?

	reserved	rb	16

ends

;;===========================================================================;;

;; int __stdcall getaddrinfo(__in const char* hostname,                      ;;

;;                           __in const char* servname,                      ;;

;;                           __in const struct addrinfo* hints,              ;;

;;                           __out struct addrinfo **res);                   ;;

getaddrinfo:								     ;;

;;---------------------------------------------------------------------------;;

;? Get a list of IP addresses and port numbers for given host and service    ;;

;;---------------------------------------------------------------------------;;

;> first parameter (optional) = host name                                    ;;

;> second parameter (optional) = service name (decimal number for now)       ;;

;> third parameter (optional) = hints for socketnum type                        ;;

;> fourth parameter = pointer to result (head of L1-list)                    ;;

;;---------------------------------------------------------------------------;;

;< eax = 0 on success / one of EAI_ codes on error                           ;;

;;===========================================================================;;

; 0. Save used registers for __stdcall.

	push	ebx esi edi

	mov	edi, [esp+28]	; edi = res

; 1. Create and send DNS packet.

	sub	esp, sizeof.__gai_reqdata	; reserve stack place (1)

	push	esp		; fifth parameter = pointer to (1)

	push	edi		; fourth parameter = res

	push	dword [esp+32+sizeof.__gai_reqdata]	; third parameter = hints

	push	dword [esp+32+sizeof.__gai_reqdata]	; second parameter = servname

	push	dword [esp+32+sizeof.__gai_reqdata]	; first parameter = hostname

	call	getaddrinfo_start

	test	eax, eax

	jns	.ret	; if name resolved without network activity, return

; 2. Wait for DNS reply.

; 2a. Ignore all events except network stack.

	mcall	40, EVM_STACK

	push	eax	; save previous event mask (2)

; 2b. Get upper limit for wait time. Use timeout = 5 seconds.

	mcall	26, 9	; get time stamp

	xchg	esi, eax	; save time stamp to esi

	mov	ebx, 500	; start value for timeout

	add	esi, ebx

.wait:

; 2c. Wait for event with timeout.

	mcall	23	; wait for event - must be stack event

; 2d. Check for timeout.

	test	eax, eax

	lea	eax, [esp+4]	; pointer to (1)

	jz	.timeout

; 3. Got packet. Call processing function.

	push	edi	; second parameter: pointer to result

	push	eax	; first parameter: pointer to reqdata

	call	getaddrinfo_process

; 4. Test whether wait loop must be continued.

	test	eax, eax

	jns	.ret.restore

; 2e. Recalculate timeout value.

	mcall	26, 9

	mov	ebx, esi

	sub	ebx, eax

; 2f. Check that time is not over; if not, continue wait loop

	cmp	ebx, 500

	jbe	.wait

.timeout:

; 5. Timeout: abort and return error

	push	eax

	call	getaddrinfo_abort

	and	dword [edi], 0

	push	EAI_AGAIN

	pop	eax

.ret.restore:

; 6. Restore event mask.

	pop	ebx	; get event mask (2)

	push	eax	; save return code (3)

	mcall	40

	pop	eax	; restore return code (3)

.ret:

; 7. Restore stack pointer, used registers and return.

	add	esp, sizeof.__gai_reqdata	; undo (1)

	pop	edi esi ebx

	ret	16

;;===========================================================================;;

;; int __stdcall getaddrinfo_start(__in const char* hostname,                ;;

;;                                 __in const char* servname,                ;;

;;                                 __in const struct addrinfo* hints,        ;;

;;                                 __out struct addrinfo **res,              ;;

;;                                 __out struct __gai_reqdata* reqdata);     ;;

getaddrinfo_start:							     ;;

;;---------------------------------------------------------------------------;;

;? Initiator for getaddrinfo, sends DNS request                              ;;

;;---------------------------------------------------------------------------;;

;> first 4 parameters same as for getaddrinfo                                ;;

;> last parameter = pointer to buffer for __gai_reqdata, must be passed to   ;;

;>                  getaddrinfo_process as is                                ;;

;;---------------------------------------------------------------------------;;

;< eax = <0 if wait loop must be entered / 0 on success / EAI_* on error     ;;

;;===========================================================================;;

;; Known limitations:                                                        ;;

;; 1. No support for TCP connections =>                                      ;;

;; 1a. Long replies will be truncated, and not all IP addresses will be got. ;;

;; 2. No support for iterative resolving =>                                  ;;

;; 2a. In theory may fail with some servers.                                 ;;

;; 3. Assumes that domain for relative names is always root, ".".            ;;

;; 4. Does not support lookup of services by name,                           ;;

;;    only decimal representation is supported.                              ;;

;; 5. Assumes that IPv4 is always configured, so AI_ADDRCONFIG has no effect.;;

;;===========================================================================;;

; 0. Create stack frame and save used registers for __stdcall.

	push	ebx esi edi

	push	ebp

	mov	ebp, esp

virtual at ebp-8

.recent_restsize dd	?	; this is for memory alloc in ._.generate_data

.recent_page	dd	?	; this is for memory alloc in ._.generate_data

	rd	5	; saved regs and return address

.hostname	dd	?

.servname	dd	?

.hints		dd	?

.res		dd	?

.reqdata	dd	?

end virtual

	xor	edi, edi

	push	edi	; init .recent_page

	push	edi	; init .recent_restsize

; 1. Check that parameters are correct and can be handled by this implementation.

; 1a. If 'res' pointer is given, set result to zero.

	mov	eax, [.res]

	test	eax, eax

	jz	@f

	mov	[eax], edi

@@:

; 1b. Only AI_SUPPORTED flags are supported for hints->ai_flags.

	mov	ecx, [.hints]

	xor	edx, edx

	jecxz	.nohints

	mov	edx, [ecx+addrinfo.ai_flags]

.nohints:

	mov	ebx, [.reqdata]

	mov	[ebx+__gai_reqdata.flags], edx

	push	EAI_BADFLAGS

	pop	eax

	test	edx, not AI_SUPPORTED

	jnz	.ret

; 1c. Either hostname or servname must be given. If AI_CANONNAME is set,

; hostname must also be set.

	cmp	[.hostname], edi

	jnz	@f

	test	dl, AI_CANONNAME

	jnz	.ret

	push	EAI_NONAME

	pop	eax

	cmp	[.servname], edi

	jz	.ret

@@:

; 1d. Only IPv4 is supported, so hints->ai_family must be either PF_UNSPEC or PF_INET.

	push	EAI_FAMILY

	pop	eax

	jecxz	@f

	cmp	[ecx+addrinfo.ai_family], edi

	jz	@f

	cmp	[ecx+addrinfo.ai_family], AF_INET4

	jnz	.ret

@@:

; 1e. Valid combinations for ai_socktype/ai_protocol: 0/0 for any or

;       SOCK_STREAM/IPPROTO_TCP, SOCK_DGRAM/IPPROTO_UDP

;       (raw socketnums are not yet supported by the kernel)

	xor	edx, edx	; assume 0=any if no hints

	jecxz	.socketnum_type_ok

	mov	edx, [ecx+addrinfo.ai_socktype]

	mov	esi, [ecx+addrinfo.ai_protocol]

; 1f. Test for ai_socktype=0 and ai_protocol=0.

	test	edx, edx

	jnz	.check_socktype

	test	esi, esi

	jz	.socketnum_type_ok

; 1g. ai_socktype=0, ai_protocol is nonzero.

	push	EAI_SERVICE

	pop	eax

	inc	edx	; edx = SOCK_STREAM

	cmp	esi, IPPROTO_TCP

	jz	.socketnum_type_ok

	inc	edx	; edx = SOCK_DGRAM

	cmp	esi, IPPROTO_UDP

	jz	.socketnum_type_ok

.ret:

; Restore saved registers, destroy stack frame and return.

	mov	esp, ebp

	pop	ebp

	pop	edi esi ebx

	ret	20

; 1h. ai_socktype is nonzero.

.check_socktype:

	push	EAI_SOCKTYPE

	pop	eax

	cmp	edx, SOCK_STREAM

	jz	.check_tcp

	cmp	edx, SOCK_DGRAM

	jnz	.ret

	test	esi, esi

	jz	.socketnum_type_ok

	cmp	esi, IPPROTO_UDP

	jz	.socketnum_type_ok

	jmp	.ret

.check_tcp:

	test	esi, esi

	jz	.socketnum_type_ok

	cmp	esi, IPPROTO_TCP

	jnz	.ret

.socketnum_type_ok:

	mov	[ebx+__gai_reqdata.socktype], dl

; 2. Resolve service.

; 2a. If no name is given, remember value -1.

	push	-1

	pop	edx

	mov	esi, [.servname]

	test	esi, esi

	jz	.service_resolved

; 2b. Loop for characters of string while digits are encountered.

	xor	edx, edx

	xor	eax, eax

.serv_to_number:

	lodsb

	sub	al, '0'

	cmp	al, 9

	ja	.serv_to_number_done

; for each digit, set edx = edx*10 + 

	lea	edx, [edx*5]

	lea	edx, [edx*2+eax]

; check for correctness: service port must fit in word

	cmp	edx, 0x10000

	jae	.service_not_number

	jmp	.serv_to_number

.serv_to_number_done:

	and	edx, 0xFFFF	; make sure that port fits

; 2c. If zero character reached, name is resolved;

; otherwise, return error (no support for symbolic names yet)

	cmp	al, -'0'

	jz	.service_resolved

.service_not_number:

	push	EAI_NONAME

	pop	eax

	jmp	.ret

.service_resolved:

; 2d. Save result to reqdata.

	mov	[ebx+__gai_reqdata.service], edx

; 3. Process host name.

	mov	esi, [.hostname]

; 3a. If hostname is not given,

;       use localhost for active socketnums and INADDR_ANY for passive socketnums.

	mov	eax, 0x0100007F ; 127.0.0.1 in network byte order

	test	byte [ebx+__gai_reqdata.flags], AI_PASSIVE

	jz	@f

	xor	eax, eax

@@:

	test	esi, esi

	jz	.hostname_is_ip

; 3b. Check for dotted IPv4 name.

	push	esi

	call	inet_addr

	cmp	eax, -1

	jz	.resolve_hostname

.hostname_is_ip:

; 3c. hostname is valid representation of IP address, and we have resolved it.

; Generate result, if .res pointer is not NULL.

	mov	ebx, [.reqdata]

	mov	esi, [.res]

	test	esi, esi

	jz	.no_result

	call	getaddrinfo._.generate_data

; 3d. Check for memory allocation error.

.3d:

	push	EAI_MEMORY

	pop	eax

	test	esi, esi

	jz	.ret

; 3e. If AI_CANONNAME is set, copy input name.

	test	byte [ebx+__gai_reqdata.flags], AI_CANONNAME

	jz	.no_result

; 3f. Calculate length of name.

	push	-1

	pop	ecx

	mov	edi, [.hostname]

	xor	eax, eax

	repnz	scasb

	not	ecx

; 3g. Check whether it fits on one page with main data.

	cmp	ecx, [.recent_restsize]

	jbe	.name_fits

; 3h. If not, allocate new page.

	push	ecx

	add	ecx, 4	; first dword contains number of objects on the page

	mcall	68, 12

	pop	ecx

; 3i. If allocation has failed, free addrinfo and return error.

	test	eax, eax

	jnz	.name_allocated

	push	[.res]

	call	freeaddrinfo

	push	EAI_MEMORY

	pop	eax

	jmp	.ret

.name_allocated:

; 3j. Otherwise, set edi to allocated memory and continue to 3l.

	xchg	edi, eax	; put result to edi

	push	1

	pop	eax

	stosd	; number of objects on the page = 1

	jmp	.copy_name

.name_fits:

; 3k. Get pointer to free memory in allocated page.

	mov	edi, [.recent_page]

	mov	eax, edi

	and	eax, not 0xFFF

	inc	dword [eax]	; increase number of objects

.copy_name:

; 3l. Put pointer to struct addrinfo.

	mov	eax, [.res]

	mov	eax, [eax]

	mov	[eax+addrinfo.ai_canonname], edi

; 3m. Copy name.

	rep	movsb

.no_result:

; 3n. Return success.

	xor	eax, eax

	jmp	.ret

; 4. Host address is not dotted IP. Test whether we are allowed to contact DNS.

; Return error if no.

.resolve_hostname:

	push	EAI_NONAME

	pop	eax

	mov	ebx, [.reqdata]

	test	byte [ebx+__gai_reqdata.flags], AI_NUMERICHOST

	jnz	.ret

; Host address is domain name. Contact DNS server.

	mov	esi, [.hostname]

; 5. Reserve stack place for UDP packet.

; According to RFC1035, maximum UDP packet size in DNS is 512 bytes.

	sub	esp, 512

; 6. Create DNS request packet.

; 6a. Set pointer to start of buffer.

	mov	edi, esp

; 6b. Get request ID, write it to buffer.

	push	1

	pop	eax

lock	xadd	[DNSrequestID], eax	; atomically increment ID, get old value

	stosw

	mov	[ebx+__gai_reqdata.reqid], ax

; 6c. Packed field: QR=0 (query), Opcode=0000 (standard query),

;       AA=0 (ignored in requests), TC=0 (no truncation),

;       RD=1 (recursion desired)

	mov	al, 00000001b

	stosb

; 6d. Packed field: ignored in requests

	mov	al, 0

	stosb

; 6e. Write questions count = 1 and answers count = 0

; Note that network byte order is big-endian.

	mov	eax, 0x00000100

	stosd

; 6f. Write nameservers count = 0 and additional records count = 0

	xor	eax, eax

	stosd

; 6g. Write request data: name

; According to RFC1035, maximum length of name is 255 bytes.

; For correct names, buffer cannot overflow.

	lea	ebx, [esi+256]	; ebx = limit for name (including terminating zero)

; translate string "www.yandex.ru" {00} to byte data {03} "www" {06} "yandex" {02} "ru" {00}

.nameloop:	; here we go in the start of each label: before "www", before "yandex", before "ru"

	xor	ecx, ecx	; ecx = length of current label

	inc	edi	; skip length, it will be filled later

.labelloop:	; here we go for each symbol of name

	lodsb	; get next character

	test	al, al	; terminating zero?

	jz	.endname

	cmp	esi, ebx	; limit exceeded?

	jae	.wrongname

	cmp	al, '.' ; end of label?

	jz	.labelend

	stosb	; put next character

	inc	ecx	; increment label length

	jmp	.labelloop

.wrongname:

	push	EAI_NONAME

	pop	eax

	jmp	.ret

.labelend:

	test	ecx, ecx	; null label can be only in the end of name

	jz	.wrongname

.endname:

	cmp	ecx, 63

	ja	.wrongname

; write length to byte [edi-ecx-1]

	mov	eax, ecx

	neg	eax

	mov	byte [edi+eax-1], cl

	cmp	byte [esi-1], 0 ; that was last label in the name?

	jnz	.nameloop

; write terminating zero if not yet

	mov	al, 0

	cmp	byte [edi-1], al

	jz	@f

	stosb

@@:

; 6h. Write request data:

;       query type = A (host address) = 1,

;       query class = IN (internet IPv4 address) = 1

; Note that network byte order is big-endian.

	mov	eax, 0x01000100

	stosd

; 7. Get DNS server address.

	mcall	75, 0x00000004 ; protocol IP=0, device number=0, function=get DNS address

	cmp	eax, -1

	je	.ret.dnserr

	mov	esi, eax	; put server address to esi

; 8. Open UDP socketnum to DNS server, port 53.

; 8a. Create new socketnum.

	mcall	74, 0, AF_INET4, SOCK_DGRAM

	cmp	eax, -1 ; error?

	jz	.ret.dnserr

	mov	ecx, eax	; put socketnum handle to ecx

; 8b. Create sockaddr structure on the stack.

	push	0

	push	0	; sin_zero

	push	esi	; sin_addr

	push	AF_INET4 + (53 shl 16)

			; sin_family and sin_port in network byte order

; 8c. Connect.

	mcall	74, 4, , esp, sizeof.sockaddr_in

; 8d. Restore the stack, undo 8b.

	add	esp, esi

; 8e. Check result.

	cmp	eax, -1

	jz	.ret.close

; 9. Send DNS request packet.

	sub	edi, esp	; get packet length

	mov	esi, edi

	xor	edi, edi

	mcall	74, 6, , esp

	cmp	eax, -1

	jz	.ret.close

	mov	eax, [.reqdata]

	mov	[eax+__gai_reqdata.socketnum], ecx

	push	-1

	pop	eax	; return status: more processing required

	jmp	.ret.dns

.ret.close:

	mcall	74, 1

.ret.dnserr:

	push	EAI_AGAIN

	pop	eax

.ret.dns:

; 6. Restore stack pointer and return.

	jmp	.ret

;;===========================================================================;;

;; int __stdcall getaddrinfo_process(__in struct __gai_reqdata* reqdata,     ;;

;;                                   __out struct addrinfo** res);           ;;

getaddrinfo_process:							     ;;

;;---------------------------------------------------------------------------;;

;? Processes network events from DNS reply                                   ;;

;;---------------------------------------------------------------------------;;

;> first parameter = pointer to struct __gai_reqdata filled by ..._start     ;;

;> second parameter = same as for getaddrinfo                                ;;

;;---------------------------------------------------------------------------;;

;< eax = -1 if more processing required / 0 on success / >0 = error code     ;;

;;===========================================================================;;

; 0. Create stack frame.

	push	ebp

	mov	ebp, esp

virtual at ebp-.locals_size

.locals_start:

.datagram	rb	512

.addrname	dd	?

.name		dd	?

.res_list_tail	dd	?

.cname		dd	?

.recent_restsize dd	?	; this is for memory alloc in ._.generate_data

.recent_page	dd	?	; this is for memory alloc in ._.generate_data

.locals_size = $ - .locals_start

		rd	2

.reqdata	dd	?

.res		dd	?

end virtual

	xor	eax, eax

	push	eax	; initialize .recent_page

	push	eax	; initialize .recent_restsize

	push	eax	; initialize .cname

	push	[.res]	; initialize .res_list_tail

	sub	esp, .locals_size-16	; reserve place for other vars

	mov	edx, esp	; edx -> buffer for datagram

; 1. Save used registers for __stdcall.

	push	ebx esi edi

	mov	edi, [.reqdata]

; 2. Read UDP datagram.

	mov	ecx, [edi+__gai_reqdata.socketnum]

	push	edi

	mcall	74, 7, , , 512, 0

	pop	edi

; 3. Ignore events for other socketnums (return if no data read)

	test	eax, eax

	jz	.ret.more_processing_required

; 4. Sanity check: discard too short packets.

	xchg	ecx, eax	; save packet length in ecx

	cmp	ecx, 12

	jb	.ret.more_processing_required

; 5. Discard packets with ID != request ID.

	mov	eax, dword [edi+__gai_reqdata.reqid]

	cmp	ax, [edx]

	jnz	.ret.more_processing_required

; 6. Sanity check: discard query packets.

	test	byte [edx+2], 80h

	jz	.ret.more_processing_required

; 7. Sanity check: must be exactly one query (our).

	cmp	word [edx+4], 0x0100	; note network byte order

	jnz	.ret.more_processing_required

; 8. Check for errors. Return EAI_NONAME for error code 3 and EAI_FAIL for other.

	mov	al, [edx+3]

	and	al, 0xF

	jz	@f

	cmp	al, 3

	jnz	.ret.no_recovery

	jmp	.ret.no_name

@@:

; 9. Locate answers section. Exactly 1 query is present in this packet.

	add	ecx, edx	; ecx = limit

	lea	esi, [edx+12]

	call	.skip_name

	lodsd		; skip QTYPE and QCLASS field

	cmp	esi, ecx

	ja	.ret.no_recovery

; 10. Loop through all answers.

	movzx	ebx, word [edx+6]	; get answers count

	xchg	bl, bh		; network -> Intel byte order

.answers_loop:

	dec	ebx

	js	.answers_done

; 10a. Process each record.

	mov	[.name], esi

; 10b. Skip name field.

	call	.skip_name

; 10c. Get record information, handle two types for class IN (internet).

	lodsd		; get type and class

	cmp	esi, ecx

	ja	.ret.no_recovery

	cmp	eax, 0x01000500 ; type=5, class=1?

	jz	.got_cname

	cmp	eax, 0x01000100 ; type=1, class=1?

	jnz	.answers_loop.next

.got_addr:

; 10d. Process record A, host address.

	add	esi, 10

	cmp	esi, ecx

	ja	.ret.no_recovery

	cmp	word [esi-6], 0x0400	; RDATA for A records must be 4 bytes long

	jnz	.ret.no_recovery

	mov	eax, [.name]

	mov	[.addrname], eax

; 10e. Create corresponding record in the answer.

	push	ebx ecx esi

	mov	eax, [esi-4]	; IP address

	mov	esi, [.res_list_tail]	; pointer to result

	test	esi, esi

	jz	.no_result	; do not save if .res is NULL

	mov	ebx, [.reqdata] ; request data

	call	getaddrinfo._.generate_data

	mov	[.res_list_tail], esi

	pop	esi ecx ebx

	cmp	[.res_list_tail], 0

	jnz	.answers_loop

; 10f. If generate_data failed (this means memory allocation failure), abort

	jmp	.ret.no_memory

.no_result:

	pop	esi ecx ebx

	jmp	.answers_loop

.got_cname:

; 10g. Process record CNAME, main host name.

	lea	eax, [esi+6]

	mov	[.cname], eax

.answers_loop.next:

; 10h. Skip other record fields, advance to next record.

	lodsd	; skip TTL

	xor	eax, eax

	lodsw	; get length of RDATA field

	xchg	al, ah	; network -> Intel byte order

	add	esi, eax

	cmp	esi, ecx

	ja	.ret.no_recovery

	jmp	.answers_loop

.answers_done:

; 11. Check that there is at least 1 answer.

	mov	eax, [.res_list_tail]

	cmp	[.res], eax

	jz	.ret.no_data

; 12. If canonical name was required, add it now.

	mov	eax, [.reqdata]

	test	byte [eax+__gai_reqdata.flags], AI_CANONNAME

	jz	.no_canon_name

; 12a. If at least one CNAME record is present, use name from last such record.

; Otherwise, use name from one of A records.

	mov	esi, [.cname]

	test	esi, esi

	jnz	.has_cname

	mov	esi, [.addrname]

.has_cname:

; 12b. Calculate name length.

	call	.get_name_length

	jc	.ret.no_recovery

; 12c. Check that the caller really want to get data.

	cmp	[.res], 0

	jz	.no_canon_name

; 12d. Allocate memory for name.

	call	getaddrinfo._.memalloc

	test	edi, edi

	jz	.ret.no_memory

; 12e. Make first entry in .res list point to canonical name.

	mov	eax, [.res]

	mov	eax, [eax]

	mov	[eax+addrinfo.ai_canonname], edi

; 12f. Decode name.

	call	.decode_name

.no_canon_name:

; 13. Set status to success.

	xor	eax, eax

	jmp	.ret.close

; Handle errors.

.ret.more_processing_required:

	push	-1

	pop	eax

	jmp	.ret

.ret.no_recovery:

	push	EAI_FAIL

	pop	eax

	jmp	.ret.destroy

.ret.no_memory:

	push	EAI_MEMORY

	pop	eax

	jmp	.ret.destroy

.ret.no_name:

.ret.no_data:

	push	EAI_NONAME

	pop	eax

.ret.destroy:

; 14. If an error occured, free memory acquired so far.

	push	eax

	mov	esi, [.res]

	test	esi, esi

	jz	@f

	pushd	[esi]

	call	freeaddrinfo

	and	dword [esi], 0

@@:

	pop	eax

.ret.close:

; 15. Close socketnum.

	push	eax

	mov	ecx, [.reqdata]

	mov	ecx, [ecx+__gai_reqdata.socketnum]

	mcall	74, 1

	pop	eax

; 16. Restore used registers, destroy stack frame and return.

.ret:

	pop	edi esi ebx

	mov	esp, ebp

	pop	ebp

	ret	8

;;===========================================================================;;

;; Internal auxiliary function for skipping names in DNS packet.             ;;

.skip_name:								     ;;

;;---------------------------------------------------------------------------;;

;? Skips name in DNS packet.                                                 ;;

;;---------------------------------------------------------------------------;;

;> esi -> name                                                               ;;

;> ecx = end of packet                                                       ;;

;;---------------------------------------------------------------------------;;

;< esi -> end of name                                                        ;;

;;===========================================================================;;

	xor	eax, eax

	cmp	esi, ecx

	jae	.skip_name.done

	lodsb

	test	al, al

	jz	.skip_name.done

	test	al, 0xC0

	jnz	.skip_name.pointer

	add	esi, eax

	jmp	.skip_name

.skip_name.pointer:

	inc	esi

.skip_name.done:

	ret

;;===========================================================================;;

;; Internal auxiliary function for calculating length of name in DNS packet. ;;

.get_name_length:							     ;;

;;---------------------------------------------------------------------------;;

;? Calculate length of name (including terminating zero) in DNS packet.      ;;

;;---------------------------------------------------------------------------;;

;> edx = start of packet                                                     ;;

;> esi -> name                                                               ;;

;> ecx = end of packet                                                       ;;

;;---------------------------------------------------------------------------;;

;< eax = length of name                                                      ;;

;< CF set on error / cleared on success                                      ;;

;;===========================================================================;;

	xor	ebx, ebx	; ebx will hold data length

.get_name_length.zero:

	xor	eax, eax

.get_name_length.loop:

	cmp	esi, ecx

	jae	.get_name_length.fail

	lodsb

	test	al, al

	jz	.get_name_length.done

	test	al, 0xC0

	jnz	.get_name_length.pointer

	add	esi, eax

	inc	ebx

	add	ebx, eax

	cmp	ebx, 256

	jbe	.get_name_length.loop

.get_name_length.fail:

	stc

	ret

.get_name_length.pointer:

	and	al, 0x3F

	mov	ah, al

	lodsb

	lea	esi, [edx+eax]

	jmp	.get_name_length.zero

.get_name_length.done:

	test	ebx, ebx

	jz	.get_name_length.fail

	xchg	eax, ebx

	clc

	ret

;;===========================================================================;;

;; Internal auxiliary function for decoding DNS name.                        ;;

.decode_name:								     ;;

;;---------------------------------------------------------------------------;;

;? Decode name in DNS packet.                                                ;;

;;---------------------------------------------------------------------------;;

;> edx = start of packet                                                     ;;

;> esi -> name in packet                                                     ;;

;> edi -> buffer for decoded name                                            ;;

;;===========================================================================;;

	xor	eax, eax

	lodsb

	test	al, al

	jz	.decode_name.done

	test	al, 0xC0

	jnz	.decode_name.pointer

	mov	ecx, eax

	rep	movsb

	mov	al, '.'

	stosb

	jmp	.decode_name

.decode_name.pointer:

	and	al, 0x3F

	mov	ah, al

	lodsb

	lea	esi, [edx+eax]

	jmp	.decode_name

.decode_name.done:

	mov	byte [edi-1], 0

	ret

;;===========================================================================;;

;; Internal auxiliary function for allocating memory for getaddrinfo.        ;;

getaddrinfo._.memalloc: 						     ;;

;;---------------------------------------------------------------------------;;

;? Memory allocation.                                                        ;;

;;---------------------------------------------------------------------------;;

;> eax = size in bytes, must be less than page size.                         ;;

;> [ebp-4] = .recent_page = last allocated page                              ;;

;> [ebp-8] = .recent_restsize = bytes rest in last allocated page            ;;

;;---------------------------------------------------------------------------;;

;< edi -> allocated memory / NULL on error                                   ;;

;;===========================================================================;;

; 1. Set edi to result of function.

	mov	edi, [ebp-4]

; 2. Check whether we need to allocate a new page.

	cmp	eax, [ebp-8]

	jbe	.no_new_page

; 2. Allocate new page if need. Reset edi to new result.

	push	eax ebx

	mcall	68, 12, 0x1000

	xchg	edi, eax	; put result to edi

	pop	ebx eax

; 3. Check returned value of allocator. Fail if it failed.

	test	edi, edi

	jz	.ret

; 4. Update .recent_page and .recent_restsize.

	add	edi, 4

	sub	ecx, 4

	mov	[ebp-4], edi

	mov	[ebp-8], ecx

.no_new_page:

; 5. Increase number of objects on this page.

	push	eax

	mov	eax, edi

	and	eax, not 0xFFF

	inc	dword [eax]

	pop	eax

; 6. Advance last allocated pointer, decrease memory size.

	add	[ebp-4], eax

	sub	[ebp-8], eax

; 7. Return.

.ret:

	ret

;;===========================================================================;;

;; Internal auxiliary function for freeing memory for freeaddrinfo.          ;;

getaddrinfo._.memfree:							     ;;

;;---------------------------------------------------------------------------;;

;? Free memory.                                                              ;;

;;---------------------------------------------------------------------------;;

;> eax = pointer                                                             ;;

;;===========================================================================;;

; 1. Get start of page.

	mov	ecx, eax

	and	ecx, not 0xFFF

; 2. Decrease number of objects.

	dec	dword [ecx]

; 3. If it goes to zero, free the page.

	jnz	@f

	push	ebx

	mcall	68, 13

	pop	ebx

@@:

; 4. Done.

	ret

;;===========================================================================;;

getaddrinfo._.generate_data:						     ;;

;;---------------------------------------------------------------------------;;

;? Generate item(s) of getaddrinfo result list by one IP address.            ;;

;;---------------------------------------------------------------------------;;

;> eax = IP address                                                          ;;

;> ebx = request data                                                        ;;

;> esi = pointer to result                                                   ;;

;> [ebp-4] = .recent_page = last allocated page                              ;;

;> [ebp-8] = .recent_restsize = bytes rest in last allocated page            ;;

;;---------------------------------------------------------------------------;;