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)
68 static int resolver_initialised
;
70 /* call res_init() just once because of a bug in Mac OSX 10.4 */
71 static void initialise_resolver( void )
73 if (!resolver_initialised
)
76 resolver_initialised
= 1;
80 static const char *dns_section_to_str( ns_sect section
)
84 case ns_s_qd
: return "Question";
85 case ns_s_an
: return "Answer";
86 case ns_s_ns
: return "Authority";
87 case ns_s_ar
: return "Additional";
91 FIXME( "unknown section: 0x%02x\n", section
);
92 sprintf( tmp
, "0x%02x", section
);
98 static unsigned long dns_map_options( DWORD options
)
100 unsigned long ret
= 0;
102 if (options
== DNS_QUERY_STANDARD
)
105 if (options
& DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE
)
107 if (options
& DNS_QUERY_USE_TCP_ONLY
)
109 if (options
& DNS_QUERY_NO_RECURSION
)
111 if (options
& DNS_QUERY_NO_LOCAL_NAME
)
113 if (options
& DNS_QUERY_NO_HOSTS_FILE
)
114 ret
|= RES_NOALIASES
;
115 if (options
& DNS_QUERY_TREAT_AS_FQDN
)
116 ret
&= ~RES_DEFNAMES
;
118 if (options
& DNS_QUERY_DONT_RESET_TTL_VALUES
)
119 FIXME( "option DNS_QUERY_DONT_RESET_TTL_VALUES not implemented\n" );
120 if (options
& DNS_QUERY_RESERVED
)
121 FIXME( "option DNS_QUERY_RESERVED not implemented\n" );
122 if (options
& DNS_QUERY_WIRE_ONLY
)
123 FIXME( "option DNS_QUERY_WIRE_ONLY not implemented\n" );
124 if (options
& DNS_QUERY_NO_WIRE_QUERY
)
125 FIXME( "option DNS_QUERY_NO_WIRE_QUERY not implemented\n" );
126 if (options
& DNS_QUERY_BYPASS_CACHE
)
127 FIXME( "option DNS_QUERY_BYPASS_CACHE not implemented\n" );
128 if (options
& DNS_QUERY_RETURN_MESSAGE
)
129 FIXME( "option DNS_QUERY_RETURN_MESSAGE not implemented\n" );
131 if (options
& DNS_QUERY_NO_NETBT
)
132 TRACE( "netbios query disabled\n" );
137 static DNS_STATUS
dns_map_error( int error
)
141 case ns_r_noerror
: return ERROR_SUCCESS
;
142 case ns_r_formerr
: return DNS_ERROR_RCODE_FORMAT_ERROR
;
143 case ns_r_servfail
: return DNS_ERROR_RCODE_SERVER_FAILURE
;
144 case ns_r_nxdomain
: return DNS_ERROR_RCODE_NAME_ERROR
;
145 case ns_r_notimpl
: return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
146 case ns_r_refused
: return DNS_ERROR_RCODE_REFUSED
;
147 case ns_r_yxdomain
: return DNS_ERROR_RCODE_YXDOMAIN
;
148 case ns_r_yxrrset
: return DNS_ERROR_RCODE_YXRRSET
;
149 case ns_r_nxrrset
: return DNS_ERROR_RCODE_NXRRSET
;
150 case ns_r_notauth
: return DNS_ERROR_RCODE_NOTAUTH
;
151 case ns_r_notzone
: return DNS_ERROR_RCODE_NOTZONE
;
153 FIXME( "unmapped error code: %d\n", error
);
154 return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
158 static DNS_STATUS
dns_map_h_errno( int error
)
163 case HOST_NOT_FOUND
: return DNS_ERROR_RCODE_NAME_ERROR
;
164 case TRY_AGAIN
: return DNS_ERROR_RCODE_SERVER_FAILURE
;
165 case NO_RECOVERY
: return DNS_ERROR_RCODE_REFUSED
;
166 case NETDB_INTERNAL
: return DNS_ERROR_RCODE
;
168 FIXME( "unmapped error code: %d\n", error
);
169 return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
173 static char *dns_dname_from_msg( ns_msg msg
, const unsigned char *pos
)
176 char *str
, dname
[NS_MAXDNAME
] = ".";
178 /* returns *compressed* length, ignore it */
179 len
= dns_ns_name_uncompress( ns_msg_base( msg
), ns_msg_end( msg
),
180 pos
, dname
, sizeof(dname
) );
182 len
= strlen( dname
);
183 str
= dns_alloc( len
+ 1 );
184 if (str
) strcpy( str
, dname
);
188 static char *dns_str_from_rdata( const unsigned char *rdata
)
191 unsigned int len
= rdata
[0];
193 str
= dns_alloc( len
+ 1 );
196 memcpy( str
, ++rdata
, len
);
202 static unsigned int dns_get_record_size( const ns_rr
*rr
)
204 const unsigned char *pos
= rr
->rdata
;
205 unsigned int num
= 0, size
= sizeof(DNS_RECORDA
);
211 pos
+= sizeof(WORD
) + sizeof(BYTE
) + sizeof(BYTE
);
212 size
+= rr
->rdata
+ rr
->rdlength
- pos
- 1;
217 pos
+= sizeof(PCHAR
) + sizeof(WORD
) + 2 * sizeof(BYTE
);
218 pos
+= 3 * sizeof(DWORD
) + 2 * sizeof(WORD
);
219 size
+= rr
->rdata
+ rr
->rdlength
- pos
- 1;
227 while (pos
[0] && pos
< rr
->rdata
+ rr
->rdlength
)
232 size
+= (num
- 1) * sizeof(PCHAR
);
237 size
+= rr
->rdlength
- 1;
242 case 0xff01: /* WINS */
244 FIXME( "unhandled type: %s\n", dns_type_to_str( rr
->type
) );
253 static DNS_STATUS
dns_copy_rdata( ns_msg msg
, const ns_rr
*rr
, DNS_RECORDA
*r
, WORD
*dlen
)
255 DNS_STATUS ret
= ERROR_SUCCESS
;
256 const unsigned char *pos
= rr
->rdata
;
257 unsigned int i
, size
;
263 r
->Data
.A
.IpAddress
= *(const DWORD
*)pos
;
264 *dlen
= sizeof(DNS_A_DATA
);
269 for (i
= 0; i
< sizeof(IP6_ADDRESS
)/sizeof(DWORD
); i
++)
271 r
->Data
.AAAA
.Ip6Address
.IP6Dword
[i
] = *(const DWORD
*)pos
;
272 pos
+= sizeof(DWORD
);
275 *dlen
= sizeof(DNS_AAAA_DATA
);
280 /* FIXME: byte order? */
281 r
->Data
.KEY
.wFlags
= *(const WORD
*)pos
; pos
+= sizeof(WORD
);
282 r
->Data
.KEY
.chProtocol
= *(const BYTE
*)pos
++;
283 r
->Data
.KEY
.chAlgorithm
= *(const BYTE
*)pos
++;
285 size
= rr
->rdata
+ rr
->rdlength
- pos
;
287 for (i
= 0; i
< size
; i
++)
288 r
->Data
.KEY
.Key
[i
] = *(const BYTE
*)pos
++;
290 *dlen
= sizeof(DNS_KEY_DATA
) + (size
- 1) * sizeof(BYTE
);
296 r
->Data
.MINFO
.pNameMailbox
= dns_dname_from_msg( msg
, pos
);
297 if (!r
->Data
.MINFO
.pNameMailbox
) return ERROR_NOT_ENOUGH_MEMORY
;
299 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
300 return DNS_ERROR_BAD_PACKET
;
302 r
->Data
.MINFO
.pNameErrorsMailbox
= dns_dname_from_msg( msg
, pos
);
303 if (!r
->Data
.MINFO
.pNameErrorsMailbox
)
305 dns_free( r
->Data
.MINFO
.pNameMailbox
);
306 return ERROR_NOT_ENOUGH_MEMORY
;
309 *dlen
= sizeof(DNS_MINFO_DATAA
);
316 r
->Data
.MX
.wPreference
= ntohs( *(const WORD
*)pos
);
317 r
->Data
.MX
.pNameExchange
= dns_dname_from_msg( msg
, pos
+ sizeof(WORD
) );
318 if (!r
->Data
.MX
.pNameExchange
) return ERROR_NOT_ENOUGH_MEMORY
;
320 *dlen
= sizeof(DNS_MX_DATAA
);
325 r
->Data
.Null
.dwByteCount
= rr
->rdlength
;
326 memcpy( r
->Data
.Null
.Data
, rr
->rdata
, rr
->rdlength
);
328 *dlen
= sizeof(DNS_NULL_DATA
) + rr
->rdlength
- 1;
340 r
->Data
.PTR
.pNameHost
= dns_dname_from_msg( msg
, pos
);
341 if (!r
->Data
.PTR
.pNameHost
) return ERROR_NOT_ENOUGH_MEMORY
;
343 *dlen
= sizeof(DNS_PTR_DATAA
);
348 r
->Data
.SIG
.pNameSigner
= dns_dname_from_msg( msg
, pos
);
349 if (!r
->Data
.SIG
.pNameSigner
) return ERROR_NOT_ENOUGH_MEMORY
;
351 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
352 return DNS_ERROR_BAD_PACKET
;
354 /* FIXME: byte order? */
355 r
->Data
.SIG
.wTypeCovered
= *(const WORD
*)pos
; pos
+= sizeof(WORD
);
356 r
->Data
.SIG
.chAlgorithm
= *(const BYTE
*)pos
++;
357 r
->Data
.SIG
.chLabelCount
= *(const BYTE
*)pos
++;
358 r
->Data
.SIG
.dwOriginalTtl
= *(const DWORD
*)pos
; pos
+= sizeof(DWORD
);
359 r
->Data
.SIG
.dwExpiration
= *(const DWORD
*)pos
; pos
+= sizeof(DWORD
);
360 r
->Data
.SIG
.dwTimeSigned
= *(const DWORD
*)pos
; pos
+= sizeof(DWORD
);
361 r
->Data
.SIG
.wKeyTag
= *(const WORD
*)pos
;
363 size
= rr
->rdata
+ rr
->rdlength
- pos
;
365 for (i
= 0; i
< size
; i
++)
366 r
->Data
.SIG
.Signature
[i
] = *(const BYTE
*)pos
++;
368 *dlen
= sizeof(DNS_SIG_DATAA
) + (size
- 1) * sizeof(BYTE
);
373 r
->Data
.SOA
.pNamePrimaryServer
= dns_dname_from_msg( msg
, pos
);
374 if (!r
->Data
.SOA
.pNamePrimaryServer
) return ERROR_NOT_ENOUGH_MEMORY
;
376 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
377 return DNS_ERROR_BAD_PACKET
;
379 r
->Data
.SOA
.pNameAdministrator
= dns_dname_from_msg( msg
, pos
);
380 if (!r
->Data
.SOA
.pNameAdministrator
)
382 dns_free( r
->Data
.SOA
.pNamePrimaryServer
);
383 return ERROR_NOT_ENOUGH_MEMORY
;
386 if (dns_ns_name_skip( &pos
, ns_msg_end( msg
) ) < 0)
387 return DNS_ERROR_BAD_PACKET
;
389 r
->Data
.SOA
.dwSerialNo
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
390 r
->Data
.SOA
.dwRefresh
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
391 r
->Data
.SOA
.dwRetry
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
392 r
->Data
.SOA
.dwExpire
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
393 r
->Data
.SOA
.dwDefaultTtl
= ntohl( *(const DWORD
*)pos
); pos
+= sizeof(DWORD
);
395 *dlen
= sizeof(DNS_SOA_DATAA
);
400 r
->Data
.SRV
.wPriority
= ntohs( *(const WORD
*)pos
); pos
+= sizeof(WORD
);
401 r
->Data
.SRV
.wWeight
= ntohs( *(const WORD
*)pos
); pos
+= sizeof(WORD
);
402 r
->Data
.SRV
.wPort
= ntohs( *(const WORD
*)pos
); pos
+= sizeof(WORD
);
404 r
->Data
.SRV
.pNameTarget
= dns_dname_from_msg( msg
, pos
);
405 if (!r
->Data
.SRV
.pNameTarget
) return ERROR_NOT_ENOUGH_MEMORY
;
407 *dlen
= sizeof(DNS_SRV_DATAA
);
416 while (pos
[0] && pos
< rr
->rdata
+ rr
->rdlength
)
418 r
->Data
.TXT
.pStringArray
[i
] = dns_str_from_rdata( pos
);
419 if (!r
->Data
.TXT
.pStringArray
[i
])
421 for (--i
; i
>= 0; i
--)
422 dns_free( r
->Data
.TXT
.pStringArray
[i
] );
423 return ERROR_NOT_ENOUGH_MEMORY
;
428 r
->Data
.TXT
.dwStringCount
= i
;
429 *dlen
= sizeof(DNS_TXT_DATAA
) + (i
- 1) * sizeof(PCHAR
);
437 case 0x00f9: /* TKEY */
438 case 0xff01: /* WINS */
439 case 0xff02: /* WINSR */
441 FIXME( "unhandled type: %s\n", dns_type_to_str( rr
->type
) );
442 return DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
448 static DNS_STATUS
dns_copy_record( ns_msg msg
, ns_sect section
,
449 unsigned short num
, DNS_RECORDA
**recp
)
456 if (dns_ns_parserr( &msg
, section
, num
, &rr
) < 0)
457 return DNS_ERROR_BAD_PACKET
;
459 if (!(record
= dns_zero_alloc( dns_get_record_size( &rr
) )))
460 return ERROR_NOT_ENOUGH_MEMORY
;
462 record
->pName
= dns_strdup_u( rr
.name
);
466 return ERROR_NOT_ENOUGH_MEMORY
;
469 record
->wType
= rr
.type
;
470 record
->Flags
.S
.Section
= section
;
471 record
->Flags
.S
.CharSet
= DnsCharSetUtf8
;
472 record
->dwTtl
= rr
.ttl
;
474 if ((ret
= dns_copy_rdata( msg
, &rr
, record
, &dlen
)))
476 dns_free( record
->pName
);
480 record
->wDataLength
= dlen
;
483 TRACE( "found %s record in %s section\n",
484 dns_type_to_str( rr
.type
), dns_section_to_str( section
) );
485 return ERROR_SUCCESS
;
488 #define DEFAULT_TTL 1200
490 static DNS_STATUS
dns_do_query_netbios( PCSTR name
, DNS_RECORDA
**recp
)
495 FIND_NAME_BUFFER
*buffer
;
496 FIND_NAME_HEADER
*header
;
497 DNS_RECORDA
*record
= NULL
;
499 DNS_STATUS status
= ERROR_INVALID_NAME
;
501 len
= strlen( name
);
502 if (len
>= NCBNAMSZ
) return DNS_ERROR_RCODE_NAME_ERROR
;
504 DNS_RRSET_INIT( rrset
);
506 memset( &ncb
, 0, sizeof(ncb
) );
507 ncb
.ncb_command
= NCBFINDNAME
;
509 memset( ncb
.ncb_callname
, ' ', sizeof(ncb
.ncb_callname
) );
510 memcpy( ncb
.ncb_callname
, name
, len
);
511 ncb
.ncb_callname
[NCBNAMSZ
- 1] = '\0';
513 ret
= Netbios( &ncb
);
514 if (ret
!= NRC_GOODRET
) return ERROR_INVALID_NAME
;
516 header
= (FIND_NAME_HEADER
*)ncb
.ncb_buffer
;
517 buffer
= (FIND_NAME_BUFFER
*)((char *)header
+ sizeof(FIND_NAME_HEADER
));
519 for (i
= 0; i
< header
->node_count
; i
++)
521 record
= dns_zero_alloc( sizeof(DNS_RECORDA
) );
524 status
= ERROR_NOT_ENOUGH_MEMORY
;
529 record
->pName
= dns_strdup_u( name
);
532 status
= ERROR_NOT_ENOUGH_MEMORY
;
536 record
->wType
= DNS_TYPE_A
;
537 record
->Flags
.S
.Section
= DnsSectionAnswer
;
538 record
->Flags
.S
.CharSet
= DnsCharSetUtf8
;
539 record
->dwTtl
= DEFAULT_TTL
;
541 /* FIXME: network byte order? */
542 record
->Data
.A
.IpAddress
= *(DWORD
*)((char *)buffer
[i
].destination_addr
+ 2);
544 DNS_RRSET_ADD( rrset
, (DNS_RECORD
*)record
);
547 status
= ERROR_SUCCESS
;
550 DNS_RRSET_TERMINATE( rrset
);
552 if (status
!= ERROR_SUCCESS
)
553 DnsRecordListFree( rrset
.pFirstRR
, DnsFreeRecordList
);
555 *recp
= (DNS_RECORDA
*)rrset
.pFirstRR
;
560 /* The resolver lock must be held and res_init() must have been
561 * called before calling these three functions.
563 static DNS_STATUS
dns_set_serverlist( const IP4_ARRAY
*addrs
)
567 if (addrs
->AddrCount
> MAXNS
)
569 WARN( "too many servers: %d only using the first: %d\n",
570 addrs
->AddrCount
, MAXNS
);
571 _res
.nscount
= MAXNS
;
573 else _res
.nscount
= addrs
->AddrCount
;
575 for (i
= 0; i
< _res
.nscount
; i
++)
576 _res
.nsaddr_list
[i
].sin_addr
.s_addr
= addrs
->AddrArray
[i
];
578 return ERROR_SUCCESS
;
581 static DNS_STATUS
dns_get_serverlist( PIP4_ARRAY addrs
, PDWORD len
)
583 unsigned int i
, size
;
585 size
= sizeof(IP4_ARRAY
) + sizeof(IP4_ADDRESS
) * (_res
.nscount
- 1);
586 if (!addrs
|| *len
< size
)
589 return ERROR_INSUFFICIENT_BUFFER
;
592 addrs
->AddrCount
= _res
.nscount
;
594 for (i
= 0; i
< _res
.nscount
; i
++)
595 addrs
->AddrArray
[i
] = _res
.nsaddr_list
[i
].sin_addr
.s_addr
;
597 return ERROR_SUCCESS
;
600 static DNS_STATUS
dns_do_query( PCSTR name
, WORD type
, DWORD options
,
601 PDNS_RECORDA
*result
)
603 DNS_STATUS ret
= DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
606 unsigned char answer
[NS_PACKETSZ
];
607 ns_sect sections
[] = { ns_s_an
, ns_s_ar
};
610 DNS_RECORDA
*record
= NULL
;
614 DNS_RRSET_INIT( rrset
);
616 len
= res_query( name
, ns_c_in
, type
, answer
, sizeof(answer
) );
619 ret
= dns_map_h_errno( h_errno
);
623 if (dns_ns_initparse( answer
, len
, &msg
) < 0)
625 ret
= DNS_ERROR_BAD_PACKET
;
629 #define RCODE_MASK 0x0f
630 if ((msg
._flags
& RCODE_MASK
) != ns_r_noerror
)
632 ret
= dns_map_error( msg
._flags
& RCODE_MASK
);
636 for (i
= 0; i
< sizeof(sections
)/sizeof(sections
[0]); i
++)
638 for (num
= 0; num
< ns_msg_count( msg
, sections
[i
] ); num
++)
640 ret
= dns_copy_record( msg
, sections
[i
], num
, &record
);
641 if (ret
!= ERROR_SUCCESS
) goto exit
;
643 DNS_RRSET_ADD( rrset
, (DNS_RECORD
*)record
);
648 DNS_RRSET_TERMINATE( rrset
);
650 if (ret
!= ERROR_SUCCESS
)
651 DnsRecordListFree( rrset
.pFirstRR
, DnsFreeRecordList
);
653 *result
= (DNS_RECORDA
*)rrset
.pFirstRR
;
658 #endif /* HAVE_RESOLV */
660 /******************************************************************************
661 * DnsQuery_A [DNSAPI.@]
664 DNS_STATUS WINAPI
DnsQuery_A( PCSTR name
, WORD type
, DWORD options
, PIP4_ARRAY servers
,
665 PDNS_RECORDA
*result
, PVOID
*reserved
)
668 DNS_RECORDW
*resultW
;
671 TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name
), dns_type_to_str( type
),
672 options
, servers
, result
, reserved
);
674 if (!name
|| !result
)
675 return ERROR_INVALID_PARAMETER
;
677 nameW
= dns_strdup_aw( name
);
678 if (!nameW
) return ERROR_NOT_ENOUGH_MEMORY
;
680 status
= DnsQuery_W( nameW
, type
, options
, servers
, &resultW
, reserved
);
682 if (status
== ERROR_SUCCESS
)
684 *result
= (DNS_RECORDA
*)DnsRecordSetCopyEx(
685 (DNS_RECORD
*)resultW
, DnsCharSetUnicode
, DnsCharSetAnsi
);
687 if (!*result
) status
= ERROR_NOT_ENOUGH_MEMORY
;
688 DnsRecordListFree( (DNS_RECORD
*)resultW
, DnsFreeRecordList
);
695 /******************************************************************************
696 * DnsQuery_UTF8 [DNSAPI.@]
699 DNS_STATUS WINAPI
DnsQuery_UTF8( PCSTR name
, WORD type
, DWORD options
, PIP4_ARRAY servers
,
700 PDNS_RECORDA
*result
, PVOID
*reserved
)
702 DNS_STATUS ret
= DNS_ERROR_RCODE_NOT_IMPLEMENTED
;
705 TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name
), dns_type_to_str( type
),
706 options
, servers
, result
, reserved
);
708 if (!name
|| !result
)
709 return ERROR_INVALID_PARAMETER
;
713 initialise_resolver();
714 _res
.options
|= dns_map_options( options
);
716 if (servers
&& (ret
= dns_set_serverlist( servers
)))
722 ret
= dns_do_query( name
, type
, options
, result
);
724 if (ret
== DNS_ERROR_RCODE_NAME_ERROR
&& type
== DNS_TYPE_A
&&
725 !(options
& DNS_QUERY_NO_NETBT
))
727 TRACE( "dns lookup failed, trying netbios query\n" );
728 ret
= dns_do_query_netbios( name
, result
);
737 /******************************************************************************
738 * DnsQuery_W [DNSAPI.@]
741 DNS_STATUS WINAPI
DnsQuery_W( PCWSTR name
, WORD type
, DWORD options
, PIP4_ARRAY servers
,
742 PDNS_RECORDW
*result
, PVOID
*reserved
)
745 DNS_RECORDA
*resultA
;
748 TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_w(name
), dns_type_to_str( type
),
749 options
, servers
, result
, reserved
);
751 if (!name
|| !result
)
752 return ERROR_INVALID_PARAMETER
;
754 nameU
= dns_strdup_wu( name
);
755 if (!nameU
) return ERROR_NOT_ENOUGH_MEMORY
;
757 status
= DnsQuery_UTF8( nameU
, type
, options
, servers
, &resultA
, reserved
);
759 if (status
== ERROR_SUCCESS
)
761 *result
= (DNS_RECORDW
*)DnsRecordSetCopyEx(
762 (DNS_RECORD
*)resultA
, DnsCharSetUtf8
, DnsCharSetUnicode
);
764 if (!*result
) status
= ERROR_NOT_ENOUGH_MEMORY
;
765 DnsRecordListFree( (DNS_RECORD
*)resultA
, DnsFreeRecordList
);
772 static DNS_STATUS
dns_get_hostname_a( COMPUTER_NAME_FORMAT format
,
773 LPSTR buffer
, PDWORD len
)
776 DWORD size
= sizeof(name
);
778 if (!GetComputerNameExA( format
, name
, &size
))
779 return DNS_ERROR_NAME_DOES_NOT_EXIST
;
781 if (!buffer
|| (size
= lstrlenA( name
) + 1) > *len
)
784 return ERROR_INSUFFICIENT_BUFFER
;
787 lstrcpyA( buffer
, name
);
788 return ERROR_SUCCESS
;
791 static DNS_STATUS
dns_get_hostname_w( COMPUTER_NAME_FORMAT format
,
792 LPWSTR buffer
, PDWORD len
)
795 DWORD size
= sizeof(name
);
797 if (!GetComputerNameExW( format
, name
, &size
))
798 return DNS_ERROR_NAME_DOES_NOT_EXIST
;
800 if (!buffer
|| (size
= lstrlenW( name
) + 1) > *len
)
803 return ERROR_INSUFFICIENT_BUFFER
;
806 lstrcpyW( buffer
, name
);
807 return ERROR_SUCCESS
;
810 /******************************************************************************
811 * DnsQueryConfig [DNSAPI.@]
814 DNS_STATUS WINAPI
DnsQueryConfig( DNS_CONFIG_TYPE config
, DWORD flag
, PWSTR adapter
,
815 PVOID reserved
, PVOID buffer
, PDWORD len
)
817 DNS_STATUS ret
= ERROR_INVALID_PARAMETER
;
819 TRACE( "(%d,0x%08x,%s,%p,%p,%p)\n", config
, flag
, debugstr_w(adapter
),
820 reserved
, buffer
, len
);
822 if (!len
) return ERROR_INVALID_PARAMETER
;
826 case DnsConfigDnsServerList
:
831 initialise_resolver();
832 ret
= dns_get_serverlist( buffer
, len
);
837 WARN( "compiled without resolver support\n" );
841 case DnsConfigHostName_A
:
842 case DnsConfigHostName_UTF8
:
843 return dns_get_hostname_a( ComputerNameDnsHostname
, buffer
, len
);
845 case DnsConfigFullHostName_A
:
846 case DnsConfigFullHostName_UTF8
:
847 return dns_get_hostname_a( ComputerNameDnsFullyQualified
, buffer
, len
);
849 case DnsConfigPrimaryDomainName_A
:
850 case DnsConfigPrimaryDomainName_UTF8
:
851 return dns_get_hostname_a( ComputerNameDnsDomain
, buffer
, len
);
853 case DnsConfigHostName_W
:
854 return dns_get_hostname_w( ComputerNameDnsHostname
, buffer
, len
);
856 case DnsConfigFullHostName_W
:
857 return dns_get_hostname_w( ComputerNameDnsFullyQualified
, buffer
, len
);
859 case DnsConfigPrimaryDomainName_W
:
860 return dns_get_hostname_w( ComputerNameDnsDomain
, buffer
, len
);
862 case DnsConfigAdapterDomainName_A
:
863 case DnsConfigAdapterDomainName_W
:
864 case DnsConfigAdapterDomainName_UTF8
:
865 case DnsConfigSearchList
:
866 case DnsConfigAdapterInfo
:
867 case DnsConfigPrimaryHostNameRegistrationEnabled
:
868 case DnsConfigAdapterHostNameRegistrationEnabled
:
869 case DnsConfigAddressRegistrationMaxCount
:
870 FIXME( "unimplemented config type %d\n", config
);
874 WARN( "unknown config type: %d\n", config
);