4 * Copyright (C) 2006 Hans Leidekker
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
23 #include "wine/debug.h"
27 #include <sys/types.h>
29 #ifdef HAVE_NETINET_IN_H
30 # include <netinet/in.h>
32 #ifdef HAVE_ARPA_NAMESER_H
33 # include <arpa/nameser.h>
51 WINE_DEFAULT_DEBUG_CHANNEL(dnsapi
);
55 static CRITICAL_SECTION resolver_cs
;
56 static CRITICAL_SECTION_DEBUG resolver_cs_debug
=
59 { &resolver_cs_debug
.ProcessLocksList
,
60 &resolver_cs_debug
.ProcessLocksList
},
61 0, 0, { (DWORD_PTR
)(__FILE__
": resolver_cs") }
63 static CRITICAL_SECTION resolver_cs
= { &resolver_cs_debug
, -1, 0, 0, 0, 0 };
65 #define LOCK_RESOLVER() do { EnterCriticalSection( &resolver_cs ); } while (0)
66 #define UNLOCK_RESOLVER() do { LeaveCriticalSection( &resolver_cs ); } while (0)
69 static const char *dns_section_to_str( ns_sect section
)
73 case ns_s_qd
: return "Question";
74 case ns_s_an
: return "Answer";
75 case ns_s_ns
: return "Authority";
76 case ns_s_ar
: return "Additional";
80 FIXME( "unknown section: 0x%02x\n", section
);
81 sprintf( tmp
, "0x%02x", section
);
87 static unsigned long dns_map_options( DWORD options
)
89 unsigned long ret
= 0;
91 if (options
== DNS_QUERY_STANDARD
)
94 if (options
& DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE
)
96 if (options
& DNS_QUERY_USE_TCP_ONLY
)
98 if (options
& DNS_QUERY_NO_RECURSION
)
100 if (options
& DNS_QUERY_NO_LOCAL_NAME
)
102 if (options
& DNS_QUERY_NO_HOSTS_FILE
)
103 ret
|= RES_NOALIASES
;
104 if (options
& DNS_QUERY_TREAT_AS_FQDN
)
105 ret
&= ~RES_DEFNAMES
;
107 if (options
& DNS_QUERY_DONT_RESET_TTL_VALUES
)
108 FIXME( "option DNS_QUERY_DONT_RESET_TTL_VALUES not implemented\n" );
109 if (options
& DNS_QUERY_RESERVED
)
110 FIXME( "option DNS_QUERY_RESERVED not implemented\n" );
111 if (options
& DNS_QUERY_WIRE_ONLY
)
112 FIXME( "option DNS_QUERY_WIRE_ONLY not implemented\n" );
113 if (options
& DNS_QUERY_NO_WIRE_QUERY
)
114 FIXME( "option DNS_QUERY_NO_WIRE_QUERY not implemented\n" );
115 if (options
& DNS_QUERY_BYPASS_CACHE
)
116 FIXME( "option DNS_QUERY_BYPASS_CACHE not implemented\n" );
117 if (options
& DNS_QUERY_RETURN_MESSAGE
)
118 FIXME( "option DNS_QUERY_RETURN_MESSAGE not implemented\n" );
120 if (options
& DNS_QUERY_NO_NETBT
)
121 TRACE( "netbios query disabled\n" );
126 static DNS_STATUS
dns_map_error( int error
)
130 case ns_r_noerror
: return ERROR_SUCCESS
;
131 case ns_r_formerr
: return DNS_ERROR_RCODE_FORMAT_ERROR
;
132 case ns_r_servfail
: return DNS_ERROR_RCODE_SERVER_FAILURE
;
133 case ns_r_nxdomain
: return DNS_ERROR_RCODE_NAME_ERROR
;
134 case ns_r_notimpl
: return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
135 case ns_r_refused
: return DNS_ERROR_RCODE_REFUSED
;
136 case ns_r_yxdomain
: return DNS_ERROR_RCODE_YXDOMAIN
;
137 case ns_r_yxrrset
: return DNS_ERROR_RCODE_YXRRSET
;
138 case ns_r_nxrrset
: return DNS_ERROR_RCODE_NXRRSET
;
139 case ns_r_notauth
: return DNS_ERROR_RCODE_NOTAUTH
;
140 case ns_r_notzone
: return DNS_ERROR_RCODE_NOTZONE
;
142 FIXME( "unmapped error code: %d\n", error
);
143 return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
147 static DNS_STATUS
dns_map_h_errno( int error
)
152 case HOST_NOT_FOUND
: return DNS_ERROR_RCODE_NAME_ERROR
;
153 case TRY_AGAIN
: return DNS_ERROR_RCODE_SERVER_FAILURE
;
154 case NO_RECOVERY
: return DNS_ERROR_RCODE_REFUSED
;
155 case NETDB_INTERNAL
: return DNS_ERROR_RCODE
;
157 FIXME( "unmapped error code: %d\n", error
);
158 return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
162 static char *dns_dname_from_msg( ns_msg msg
, const unsigned char *pos
)
165 char *str
, dname
[NS_MAXDNAME
] = ".";
167 /* returns *compressed* length, ignore it */
168 len
= dns_ns_name_uncompress( ns_msg_base( msg
), ns_msg_end( msg
),
169 pos
, dname
, sizeof(dname
) );
171 len
= strlen( dname
);
172 str
= dns_alloc( len
+ 1 );
173 if (str
) strcpy( str
, dname
);
177 static char *dns_str_from_rdata( const unsigned char *rdata
)
180 unsigned int len
= rdata
[0];
182 str
= dns_alloc( len
+ 1 );
185 memcpy( str
, ++rdata
, len
);
191 static unsigned int dns_get_record_size( ns_rr
*rr
)
193 const unsigned char *pos
= rr
->rdata
;
194 unsigned int num
= 0, size
= sizeof(DNS_RECORDA
);
200 pos
+= sizeof(WORD
) + sizeof(BYTE
) + sizeof(BYTE
);
201 size
+= rr
->rdata
+ rr
->rdlength
- pos
- 1;
206 pos
+= sizeof(PCHAR
) + sizeof(WORD
) + 2 * sizeof(BYTE
);
207 pos
+= 3 * sizeof(DWORD
) + 2 * sizeof(WORD
);
208 size
+= rr
->rdata
+ rr
->rdlength
- pos
- 1;
216 while (pos
[0] && pos
< rr
->rdata
+ rr
->rdlength
)
221 size
+= (num
- 1) * sizeof(PCHAR
);
226 size
+= rr
->rdlength
- 1;
231 case 0xff01: /* WINS */
233 FIXME( "unhandled type: %s\n", dns_type_to_str( rr
->type
) );
242 static DNS_STATUS
dns_copy_rdata( ns_msg msg
, ns_rr
*rr
, DNS_RECORDA
*r
, WORD
*dlen
)
244 DNS_STATUS ret
= ERROR_SUCCESS
;
245 const unsigned char *pos
= rr
->rdata
;
246 unsigned int i
, size
;
252 r
->Data
.A
.IpAddress
= *(const DWORD
*)pos
;
253 *dlen
= sizeof(DNS_A_DATA
);
258 for (i
= 0; i
< sizeof(IP6_ADDRESS
)/sizeof(DWORD
); i
++)
260 r
->Data
.AAAA
.Ip6Address
.IP6Dword
[i
] = *(const DWORD
*)pos
;
261 pos
+= sizeof(DWORD
);
264 *dlen
= sizeof(DNS_AAAA_DATA
);
269 /* FIXME: byte order? */
270 r
->Data
.KEY
.wFlags
= *(const WORD
*)pos
; pos
+= sizeof(WORD
);
271 r
->Data
.KEY
.chProtocol
= *(const BYTE
*)pos
++;
272 r
->Data
.KEY
.chAlgorithm
= *(const BYTE
*)pos
++;
274 size
= rr
->rdata
+ rr
->rdlength
- pos
;
276 for (i
= 0; i
< size
; i
++)
277 r
->Data
.KEY
.Key
[i
] = *(const BYTE
*)pos
++;
279 *dlen
= sizeof(DNS_KEY_DATA
) + (size
- 1) * sizeof(BYTE
);
285 r
->Data
.MINFO
.pNameMailbox
= dns_dname_from_msg( msg
, pos
);
286 if (!r
->Data
.MINFO
.pNameMailbox
) return ERROR_NOT_ENOUGH_MEMORY
;
288 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
289 return DNS_ERROR_BAD_PACKET
;
291 r
->Data
.MINFO
.pNameErrorsMailbox
= dns_dname_from_msg( msg
, pos
);
292 if (!r
->Data
.MINFO
.pNameErrorsMailbox
)
294 dns_free( r
->Data
.MINFO
.pNameMailbox
);
295 return ERROR_NOT_ENOUGH_MEMORY
;
298 *dlen
= sizeof(DNS_MINFO_DATAA
);
305 r
->Data
.MX
.wPreference
= ntohs( *(const WORD
*)pos
);
306 r
->Data
.MX
.pNameExchange
= dns_dname_from_msg( msg
, pos
+ sizeof(WORD
) );
307 if (!r
->Data
.MX
.pNameExchange
) return ERROR_NOT_ENOUGH_MEMORY
;
309 *dlen
= sizeof(DNS_MX_DATAA
);
314 r
->Data
.Null
.dwByteCount
= rr
->rdlength
;
315 memcpy( r
->Data
.Null
.Data
, rr
->rdata
, rr
->rdlength
);
317 *dlen
= sizeof(DNS_NULL_DATA
) + rr
->rdlength
- 1;
329 r
->Data
.PTR
.pNameHost
= dns_dname_from_msg( msg
, pos
);
330 if (!r
->Data
.PTR
.pNameHost
) return ERROR_NOT_ENOUGH_MEMORY
;
332 *dlen
= sizeof(DNS_PTR_DATAA
);
337 r
->Data
.SIG
.pNameSigner
= dns_dname_from_msg( msg
, pos
);
338 if (!r
->Data
.SIG
.pNameSigner
) return ERROR_NOT_ENOUGH_MEMORY
;
340 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
341 return DNS_ERROR_BAD_PACKET
;
343 /* FIXME: byte order? */
344 r
->Data
.SIG
.wTypeCovered
= *(const WORD
*)pos
; pos
+= sizeof(WORD
);
345 r
->Data
.SIG
.chAlgorithm
= *(const BYTE
*)pos
++;
346 r
->Data
.SIG
.chLabelCount
= *(const BYTE
*)pos
++;
347 r
->Data
.SIG
.dwOriginalTtl
= *(const DWORD
*)pos
; pos
+= sizeof(DWORD
);
348 r
->Data
.SIG
.dwExpiration
= *(const DWORD
*)pos
; pos
+= sizeof(DWORD
);
349 r
->Data
.SIG
.dwTimeSigned
= *(const DWORD
*)pos
; pos
+= sizeof(DWORD
);
350 r
->Data
.SIG
.wKeyTag
= *(const WORD
*)pos
;
352 size
= rr
->rdata
+ rr
->rdlength
- pos
;
354 for (i
= 0; i
< size
; i
++)
355 r
->Data
.SIG
.Signature
[i
] = *(const BYTE
*)pos
++;
357 *dlen
= sizeof(DNS_SIG_DATAA
) + (size
- 1) * sizeof(BYTE
);
362 r
->Data
.SOA
.pNamePrimaryServer
= dns_dname_from_msg( msg
, pos
);
363 if (!r
->Data
.SOA
.pNamePrimaryServer
) return ERROR_NOT_ENOUGH_MEMORY
;
365 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
366 return DNS_ERROR_BAD_PACKET
;
368 r
->Data
.SOA
.pNameAdministrator
= dns_dname_from_msg( msg
, pos
);
369 if (!r
->Data
.SOA
.pNameAdministrator
)
371 dns_free( r
->Data
.SOA
.pNamePrimaryServer
);
372 return ERROR_NOT_ENOUGH_MEMORY
;
375 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
376 return DNS_ERROR_BAD_PACKET
;
378 r
->Data
.SOA
.dwSerialNo
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
379 r
->Data
.SOA
.dwRefresh
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
380 r
->Data
.SOA
.dwRetry
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
381 r
->Data
.SOA
.dwExpire
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
382 r
->Data
.SOA
.dwDefaultTtl
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
384 *dlen
= sizeof(DNS_SOA_DATAA
);
389 r
->Data
.SRV
.wPriority
= ntohs( *(const WORD
*)pos
); pos
+= sizeof(WORD
);
390 r
->Data
.SRV
.wWeight
= ntohs( *(const WORD
*)pos
); pos
+= sizeof(WORD
);
391 r
->Data
.SRV
.wPort
= ntohs( *(const WORD
*)pos
); pos
+= sizeof(WORD
);
393 r
->Data
.SRV
.pNameTarget
= dns_dname_from_msg( msg
, pos
);
394 if (!r
->Data
.SRV
.pNameTarget
) return ERROR_NOT_ENOUGH_MEMORY
;
396 *dlen
= sizeof(DNS_SRV_DATAA
);
405 while (pos
[0] && pos
< rr
->rdata
+ rr
->rdlength
)
407 r
->Data
.TXT
.pStringArray
[i
] = dns_str_from_rdata( pos
);
408 if (!r
->Data
.TXT
.pStringArray
[i
])
410 for (--i
; i
>= 0; i
--)
411 dns_free( r
->Data
.TXT
.pStringArray
[i
] );
412 return ERROR_NOT_ENOUGH_MEMORY
;
417 r
->Data
.TXT
.dwStringCount
= i
;
418 *dlen
= sizeof(DNS_TXT_DATAA
) + (i
- 1) * sizeof(PCHAR
);
426 case 0x00f9: /* TKEY */
427 case 0xff01: /* WINS */
428 case 0xff02: /* WINSR */
430 FIXME( "unhandled type: %s\n", dns_type_to_str( rr
->type
) );
431 return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
437 static DNS_STATUS
dns_copy_record( ns_msg msg
, ns_sect section
,
438 unsigned short num
, DNS_RECORDA
**recp
)
445 if (dns_ns_parserr( &msg
, section
, num
, &rr
) < 0)
446 return DNS_ERROR_BAD_PACKET
;
448 if (!(record
= dns_zero_alloc( dns_get_record_size( &rr
) )))
449 return ERROR_NOT_ENOUGH_MEMORY
;
451 record
->pName
= dns_strdup_u( rr
.name
);
455 return ERROR_NOT_ENOUGH_MEMORY
;
458 record
->wType
= rr
.type
;
459 record
->Flags
.S
.Section
= section
;
460 record
->Flags
.S
.CharSet
= DnsCharSetUtf8
;
461 record
->dwTtl
= rr
.ttl
;
463 if ((ret
= dns_copy_rdata( msg
, &rr
, record
, &dlen
)))
465 dns_free( record
->pName
);
469 record
->wDataLength
= dlen
;
472 TRACE( "found %s record in %s section\n",
473 dns_type_to_str( rr
.type
), dns_section_to_str( section
) );
474 return ERROR_SUCCESS
;
477 #define DEFAULT_TTL 1200
479 static DNS_STATUS
dns_do_query_netbios( PCSTR name
, DNS_RECORDA
**recp
)
484 FIND_NAME_BUFFER
*buffer
;
485 FIND_NAME_HEADER
*header
;
486 DNS_RECORDA
*record
= NULL
;
488 DNS_STATUS status
= ERROR_INVALID_NAME
;
490 len
= strlen( name
);
491 if (len
>= NCBNAMSZ
) return DNS_ERROR_RCODE_NAME_ERROR
;
493 DNS_RRSET_INIT( rrset
);
495 memset( &ncb
, 0, sizeof(ncb
) );
496 ncb
.ncb_command
= NCBFINDNAME
;
498 memset( ncb
.ncb_callname
, ' ', sizeof(ncb
.ncb_callname
) );
499 memcpy( ncb
.ncb_callname
, name
, len
);
500 ncb
.ncb_callname
[NCBNAMSZ
- 1] = '\0';
502 ret
= Netbios( &ncb
);
503 if (ret
!= NRC_GOODRET
) return ERROR_INVALID_NAME
;
505 header
= (FIND_NAME_HEADER
*)ncb
.ncb_buffer
;
506 buffer
= (FIND_NAME_BUFFER
*)((char *)header
+ sizeof(FIND_NAME_HEADER
));
508 for (i
= 0; i
< header
->node_count
; i
++)
510 record
= dns_zero_alloc( sizeof(DNS_RECORDA
) );
513 status
= ERROR_NOT_ENOUGH_MEMORY
;
518 record
->pName
= dns_strdup_u( name
);
521 status
= ERROR_NOT_ENOUGH_MEMORY
;
525 record
->wType
= DNS_TYPE_A
;
526 record
->Flags
.S
.Section
= DnsSectionAnswer
;
527 record
->Flags
.S
.CharSet
= DnsCharSetUtf8
;
528 record
->dwTtl
= DEFAULT_TTL
;
530 /* FIXME: network byte order? */
531 record
->Data
.A
.IpAddress
= *(DWORD
*)((char *)buffer
[i
].destination_addr
+ 2);
533 DNS_RRSET_ADD( rrset
, (DNS_RECORD
*)record
);
538 DNS_RRSET_TERMINATE( rrset
);
540 if (status
!= ERROR_SUCCESS
)
541 DnsRecordListFree( rrset
.pFirstRR
, DnsFreeRecordList
);
543 *recp
= (DNS_RECORDA
*)rrset
.pFirstRR
;
548 /* The resolver lock must be held and res_init() must have been
549 * called before calling these three functions.
551 static DNS_STATUS
dns_set_serverlist( PIP4_ARRAY addrs
)
555 if (addrs
->AddrCount
> MAXNS
)
557 WARN( "too many servers: %d only using the first: %d\n",
558 addrs
->AddrCount
, MAXNS
);
559 _res
.nscount
= MAXNS
;
561 else _res
.nscount
= addrs
->AddrCount
;
563 for (i
= 0; i
< _res
.nscount
; i
++)
564 _res
.nsaddr_list
[i
].sin_addr
.s_addr
= addrs
->AddrArray
[i
];
566 return ERROR_SUCCESS
;
569 static DNS_STATUS
dns_get_serverlist( PIP4_ARRAY addrs
, PDWORD len
)
571 unsigned int i
, size
;
573 size
= sizeof(IP4_ARRAY
) + sizeof(IP4_ADDRESS
) * (_res
.nscount
- 1);
574 if (!addrs
|| *len
< size
)
577 return ERROR_INSUFFICIENT_BUFFER
;
580 addrs
->AddrCount
= _res
.nscount
;
582 for (i
= 0; i
< _res
.nscount
; i
++)
583 addrs
->AddrArray
[i
] = _res
.nsaddr_list
[i
].sin_addr
.s_addr
;
585 return ERROR_SUCCESS
;
588 static DNS_STATUS
dns_do_query( PCSTR name
, WORD type
, DWORD options
,
589 PDNS_RECORDA
*result
)
591 DNS_STATUS ret
= DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
594 unsigned char answer
[NS_PACKETSZ
];
595 ns_sect sections
[] = { ns_s_an
, ns_s_ar
};
598 DNS_RECORDA
*record
= NULL
;
602 DNS_RRSET_INIT( rrset
);
604 len
= res_query( name
, ns_c_in
, type
, answer
, sizeof(answer
) );
607 ret
= dns_map_h_errno( h_errno
);
611 if (dns_ns_initparse( answer
, len
, &msg
) < 0)
613 ret
= DNS_ERROR_BAD_PACKET
;
617 #define RCODE_MASK 0x0f
618 if ((msg
._flags
& RCODE_MASK
) != ns_r_noerror
)
620 ret
= dns_map_error( msg
._flags
& RCODE_MASK
);
624 for (i
= 0; i
< sizeof(sections
)/sizeof(sections
[0]); i
++)
626 for (num
= 0; num
< ns_msg_count( msg
, sections
[i
] ); num
++)
628 ret
= dns_copy_record( msg
, sections
[i
], num
, &record
);
629 if (ret
!= ERROR_SUCCESS
) goto exit
;
631 DNS_RRSET_ADD( rrset
, (DNS_RECORD
*)record
);
636 DNS_RRSET_TERMINATE( rrset
);
638 if (ret
!= ERROR_SUCCESS
)
639 DnsRecordListFree( rrset
.pFirstRR
, DnsFreeRecordList
);
641 *result
= (DNS_RECORDA
*)rrset
.pFirstRR
;
646 #endif /* HAVE_RESOLV */
648 /******************************************************************************
649 * DnsQuery_A [DNSAPI.@]
652 DNS_STATUS WINAPI
DnsQuery_A( PCSTR name
, WORD type
, DWORD options
, PIP4_ARRAY servers
,
653 PDNS_RECORDA
*result
, PVOID
*reserved
)
656 DNS_RECORDW
*resultW
;
659 TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name
), dns_type_to_str( type
),
660 options
, servers
, result
, reserved
);
662 if (!name
|| !result
)
663 return ERROR_INVALID_PARAMETER
;
665 nameW
= dns_strdup_aw( name
);
666 if (!nameW
) return ERROR_NOT_ENOUGH_MEMORY
;
668 status
= DnsQuery_W( nameW
, type
, options
, servers
, &resultW
, reserved
);
670 if (status
== ERROR_SUCCESS
)
672 *result
= (DNS_RECORDA
*)DnsRecordSetCopyEx(
673 (DNS_RECORD
*)resultW
, DnsCharSetUnicode
, DnsCharSetAnsi
);
675 if (!*result
) status
= ERROR_NOT_ENOUGH_MEMORY
;
676 DnsRecordListFree( (DNS_RECORD
*)resultW
, DnsFreeRecordList
);
683 /******************************************************************************
684 * DnsQuery_UTF8 [DNSAPI.@]
687 DNS_STATUS WINAPI
DnsQuery_UTF8( PCSTR name
, WORD type
, DWORD options
, PIP4_ARRAY servers
,
688 PDNS_RECORDA
*result
, PVOID
*reserved
)
690 DNS_STATUS ret
= DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
693 TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name
), dns_type_to_str( type
),
694 options
, servers
, result
, reserved
);
696 if (!name
|| !result
)
697 return ERROR_INVALID_PARAMETER
;
702 _res
.options
|= dns_map_options( options
);
704 if (servers
&& (ret
= dns_set_serverlist( servers
)))
710 ret
= dns_do_query( name
, type
, options
, result
);
712 if (ret
== DNS_ERROR_RCODE_NAME_ERROR
&& type
== DNS_TYPE_A
&&
713 !(options
& DNS_QUERY_NO_NETBT
))
715 TRACE( "dns lookup failed, trying netbios query\n" );
716 ret
= dns_do_query_netbios( name
, result
);
725 /******************************************************************************
726 * DnsQuery_W [DNSAPI.@]
729 DNS_STATUS WINAPI
DnsQuery_W( PCWSTR name
, WORD type
, DWORD options
, PIP4_ARRAY servers
,
730 PDNS_RECORDW
*result
, PVOID
*reserved
)
733 DNS_RECORDA
*resultA
;
736 TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_w(name
), dns_type_to_str( type
),
737 options
, servers
, result
, reserved
);
739 if (!name
|| !result
)
740 return ERROR_INVALID_PARAMETER
;
742 nameU
= dns_strdup_wu( name
);
743 if (!nameU
) return ERROR_NOT_ENOUGH_MEMORY
;
745 status
= DnsQuery_UTF8( nameU
, type
, options
, servers
, &resultA
, reserved
);
747 if (status
== ERROR_SUCCESS
)
749 *result
= (DNS_RECORDW
*)DnsRecordSetCopyEx(
750 (DNS_RECORD
*)resultA
, DnsCharSetUtf8
, DnsCharSetUnicode
);
752 if (!*result
) status
= ERROR_NOT_ENOUGH_MEMORY
;
753 DnsRecordListFree( (DNS_RECORD
*)resultA
, DnsFreeRecordList
);
760 static DNS_STATUS
dns_get_hostname_a( COMPUTER_NAME_FORMAT format
,
761 LPSTR buffer
, PDWORD len
)
764 DWORD size
= sizeof(name
);
766 if (!GetComputerNameExA( format
, name
, &size
))
767 return DNS_ERROR_NAME_DOES_NOT_EXIST
;
769 if (!buffer
|| (size
= lstrlenA( name
) + 1) > *len
)
772 return ERROR_INSUFFICIENT_BUFFER
;
775 lstrcpyA( buffer
, name
);
776 return ERROR_SUCCESS
;
779 static DNS_STATUS
dns_get_hostname_w( COMPUTER_NAME_FORMAT format
,
780 LPWSTR buffer
, PDWORD len
)
783 DWORD size
= sizeof(name
);
785 if (!GetComputerNameExW( format
, name
, &size
))
786 return DNS_ERROR_NAME_DOES_NOT_EXIST
;
788 if (!buffer
|| (size
= lstrlenW( name
) + 1) > *len
)
791 return ERROR_INSUFFICIENT_BUFFER
;
794 lstrcpyW( buffer
, name
);
795 return ERROR_SUCCESS
;
798 /******************************************************************************
799 * DnsQueryConfig [DNSAPI.@]
802 DNS_STATUS WINAPI
DnsQueryConfig( DNS_CONFIG_TYPE config
, DWORD flag
, PWSTR adapter
,
803 PVOID reserved
, PVOID buffer
, PDWORD len
)
805 DNS_STATUS ret
= ERROR_INVALID_PARAMETER
;
807 TRACE( "(%d,0x%08x,%s,%p,%p,%p)\n", config
, flag
, debugstr_w(adapter
),
808 reserved
, buffer
, len
);
810 if (!len
) return ERROR_INVALID_PARAMETER
;
814 case DnsConfigDnsServerList
:
820 ret
= dns_get_serverlist( buffer
, len
);
825 WARN( "compiled without resolver support\n" );
829 case DnsConfigHostName_A
:
830 case DnsConfigHostName_UTF8
:
831 return dns_get_hostname_a( ComputerNameDnsHostname
, buffer
, len
);
833 case DnsConfigFullHostName_A
:
834 case DnsConfigFullHostName_UTF8
:
835 return dns_get_hostname_a( ComputerNameDnsFullyQualified
, buffer
, len
);
837 case DnsConfigPrimaryDomainName_A
:
838 case DnsConfigPrimaryDomainName_UTF8
:
839 return dns_get_hostname_a( ComputerNameDnsDomain
, buffer
, len
);
841 case DnsConfigHostName_W
:
842 return dns_get_hostname_w( ComputerNameDnsHostname
, buffer
, len
);
844 case DnsConfigFullHostName_W
:
845 return dns_get_hostname_w( ComputerNameDnsFullyQualified
, buffer
, len
);
847 case DnsConfigPrimaryDomainName_W
:
848 return dns_get_hostname_w( ComputerNameDnsDomain
, buffer
, len
);
850 case DnsConfigAdapterDomainName_A
:
851 case DnsConfigAdapterDomainName_W
:
852 case DnsConfigAdapterDomainName_UTF8
:
853 case DnsConfigSearchList
:
854 case DnsConfigAdapterInfo
:
855 case DnsConfigPrimaryHostNameRegistrationEnabled
:
856 case DnsConfigAdapterHostNameRegistrationEnabled
:
857 case DnsConfigAddressRegistrationMaxCount
:
858 FIXME( "unimplemented config type %d\n", config
);
862 WARN( "unknown config type: %d\n", config
);