| 0,0 → 1,1306 |
|---|
| 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 + <digit> |
| 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 ;; |
| ;;---------------------------------------------------------------------------;; |
| ;< esi = pointer to next list item for result / NULL on error ;; |
| ;;===========================================================================;; |
| ; 1. If no service is given, append one item with zero port. |
| ; append one item with zero socktype/protocol/port. |
| cmp [ebx+__gai_reqdata.service], -1 |
| jnz .has_service |
| call .append_item |
| ; 1a. If neither protocol nor socktype were specified, |
| ; leave zeroes in socktype and protocol. |
| mov cl, [ebx+__gai_reqdata.socktype] |
| test cl, cl |
| jz .no_socktype |
| ; 1b. Otherwise, set socktype and protocol to desired. |
| call .set_socktype |
| .no_socktype: |
| ret |
| .has_service: |
| ; 2. If TCP is allowed, append item for TCP. |
| cmp [ebx+__gai_reqdata.socktype], 0 |
| jz .tcp_ok |
| cmp [ebx+__gai_reqdata.socktype], SOCK_STREAM |
| jnz .tcp_disallowed |
| .tcp_ok: |
| call .append_item |
| mov cl, SOCK_STREAM |
| call .set_socktype |
| call .set_port |
| .tcp_disallowed: |
| ; 3. If UDP is allowed, append item for UDP. |
| cmp [ebx+__gai_reqdata.socktype], 0 |
| jz .udp_ok |
| cmp [ebx+__gai_reqdata.socktype], SOCK_DGRAM |
| jnz .udp_disallowed |
| .udp_ok: |
| call .append_item |
| mov cl, SOCK_DGRAM |
| call .set_socktype |
| call .set_port |
| .udp_disallowed: |
| ret |
| |
| .append_item: |
| ; 1. Allocate memory for struct sockaddr_in and struct addrinfo. |
| push eax |
| push sizeof.addrinfo + sizeof.sockaddr_in |
| pop eax |
| call getaddrinfo._.memalloc |
| ; 2. Check for memory allocation fail. |
| test edi, edi |
| jz .no_memory |
| ; 3. Zero allocated memory. |
| push (sizeof.addrinfo + sizeof.sockaddr_in) / 4 |
| pop ecx |
| xor eax, eax |
| push edi |
| rep stosd |
| pop edi |
| ; 4. Fill struct addrinfo. |
| mov eax, [ebx+__gai_reqdata.flags] |
| mov [edi+addrinfo.ai_flags], eax |
| mov byte [edi+addrinfo.ai_family], AF_INET4 |
| mov byte [edi+addrinfo.ai_addrlen], sizeof.sockaddr_in |
| lea ecx, [edi+sizeof.addrinfo] |
| mov [edi+addrinfo.ai_addr], ecx |
| ; 5. Fill struct sockaddr_in. |
| mov byte [ecx+sockaddr_in.sin_family], AF_INET4 |
| pop eax |
| mov [ecx+sockaddr_in.sin_addr], eax |
| ; 6. Append new item to the list. |
| mov [esi], edi |
| lea esi, [edi+addrinfo.ai_next] |
| ; 7. Return. |
| ret |
| .no_memory: |
| pop eax |
| xor esi, esi |
| ret |
| |
| .set_socktype: |
| ; Set ai_socktype and ai_protocol fields by given socketnum type. |
| mov byte [edi+addrinfo.ai_socktype], cl |
| dec cl |
| jnz .set_udp |
| .set_tcp: |
| mov byte [edi+addrinfo.ai_protocol], IPPROTO_TCP |
| ret |
| .set_udp: |
| mov byte [edi+addrinfo.ai_protocol], IPPROTO_UDP |
| ret |
| |
| .set_port: |
| ; Just copy port from input __gai_reqdata to output addrinfo. |
| push edx |
| mov edx, [ebx+__gai_reqdata.service] |
| xchg dl, dh ; convert to network byte order |
| mov [edi+sizeof.addrinfo+sockaddr_in.sin_port], dx |
| pop edx |
| ret |
| |
| ;;===========================================================================;; |
| ;; void __stdcall getaddrinfo_abort(__in struct __gai_reqdata* reqdata); ;; |
| getaddrinfo_abort: ;; |
| ;;---------------------------------------------------------------------------;; |
| ;? Abort process started by getaddrinfo_start, free all resources. ;; |
| ;;---------------------------------------------------------------------------;; |
| ;> first parameter = pointer to struct __gai_reqdata filled by ..._start ;; |
| ;;===========================================================================;; |
| ; 0. Save used registers for __stdcall. |
| push ebx |
| ; 1. Allocated resources: only socketnum, so close it and return. |
| mov eax, [esp+8] |
| mov ecx, [eax+__gai_reqdata.socketnum] |
| mcall 74, 1 |
| ; 2. Restore used registers and return. |
| pop ebx |
| ret 4 |
| |
| ;;===========================================================================;; |
| ;; void __stdcall freeaddrinfo(__in struct addrinfo* ai); ;; |
| freeaddrinfo: ;; |
| ;;---------------------------------------------------------------------------;; |
| ;? Free one or more addrinfo structures returned by getaddrinfo. ;; |
| ;;---------------------------------------------------------------------------;; |
| ;> first parameter = head of list of structures ;; |
| ; (may be arbitrary sublist of original) ;; |
| ;;===========================================================================;; |
| ; 1. Loop for all items in the list. |
| mov edx, [esp+4] ; eax = ai |
| .loop: |
| test edx, edx |
| jz .done |
| ; 2. Free each item. |
| ; 2a. Free ai_canonname, if allocated. |
| mov eax, [edx+addrinfo.ai_canonname] |
| test eax, eax |
| jz .no_canon_name |
| call getaddrinfo._.memfree |
| .no_canon_name: |
| ; 2b. Remember next item |
| ; (after freeing the field ai_next can became unavailable). |
| pushd [edx+addrinfo.ai_next] |
| ; 2c. Free item itself. |
| xchg eax, edx |
| call getaddrinfo._.memfree |
| ; 2d. Restore pointer to next item and continue loop. |
| pop edx |
| jmp .loop |
| .done: |
| ; 3. Done. |
| ret 4 |
| |
| ;;===========================================================================;; |
| ;;///////////////////////////////////////////////////////////////////////////;; |
| ;;===========================================================================;; |
| ;! Exported functions section ;; |
| ;;===========================================================================;; |
| ;;///////////////////////////////////////////////////////////////////////////;; |
| ;;===========================================================================;; |
| |
| |
| align 4 |
| @EXPORT: |
| export \ |
| lib_init , 'lib_init' , \ |
| 0x00010001 , 'version' , \ |
| inet_addr , 'inet_addr' , \ |
| inet_ntoa , 'inet_ntoa' , \ |
| getaddrinfo , 'getaddrinfo' , \ |
| getaddrinfo_start , 'getaddrinfo_start' , \ |
| getaddrinfo_process , 'getaddrinfo_process' , \ |
| getaddrinfo_abort , 'getaddrinfo_abort' , \ |
| freeaddrinfo , 'freeaddrinfo' |
| |
| ; import from libini |
| align 4 |
| @IMPORT: |
| |
| library libini, 'libini.obj' |
| import libini, \ |
| ini.get_str, 'ini_get_str', \ |
| ini.get_int, 'ini_get_int' |
| |
| |
| section '.data' data readable writable align 16 |
| ; uninitialized data |
| mem.alloc dd ? |
| mem.free dd ? |
| mem.realloc dd ? |
| dll.load dd ? |
| |
| DNSrequestID dd ? |
| |
| inet_ntoa.buffer rb 16 ; static buffer for inet_ntoa |