gdiplus: Add test for ImageLockModeUserInputBuf.
[wine] / dlls / dnsapi / query.c
1 /*
2  * DNS support
3  *
4  * Copyright (C) 2006 Hans Leidekker
5  * 
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.
10  *
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.
15  *
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
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include "wine/debug.h"
24
25 #include <stdarg.h>
26 #include <string.h>
27 #include <sys/types.h>
28
29 #ifdef HAVE_NETINET_IN_H
30 # include <netinet/in.h>
31 #endif
32 #ifdef HAVE_ARPA_NAMESER_H
33 # include <arpa/nameser.h>
34 #endif
35 #ifdef HAVE_RESOLV_H
36 # include <resolv.h>
37 #endif
38 #ifdef HAVE_NETDB_H
39 # include <netdb.h>
40 #endif
41
42 #include "windef.h"
43 #include "winbase.h"
44 #include "winerror.h"
45 #include "winnls.h"
46 #include "windns.h"
47 #include "nb30.h"
48
49 #include "dnsapi.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(dnsapi);
52
53 #ifdef HAVE_RESOLV
54
55 /* call res_init() just once because of a bug in Mac OS X 10.4 */
56 /* call once per thread on systems that have per-thread _res */
57 static void initialise_resolver( void )
58 {
59     if ((_res.options & RES_INIT) == 0)
60         res_init();
61 }
62
63 static const char *dns_section_to_str( ns_sect section )
64 {
65     switch (section)
66     {
67     case ns_s_qd:   return "Question";
68     case ns_s_an:   return "Answer";
69     case ns_s_ns:   return "Authority";
70     case ns_s_ar:   return "Additional";
71     default:
72     {
73         static char tmp[5];
74         FIXME( "unknown section: 0x%02x\n", section );
75         sprintf( tmp, "0x%02x", section );
76         return tmp;
77     }
78     }
79 }
80
81 static unsigned long dns_map_options( DWORD options )
82 {
83     unsigned long ret = 0;
84             
85     if (options == DNS_QUERY_STANDARD)
86         return RES_DEFAULT;
87
88     if (options & DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE)
89         ret |= RES_IGNTC;
90     if (options & DNS_QUERY_USE_TCP_ONLY)
91         ret |= RES_USEVC;
92     if (options & DNS_QUERY_NO_RECURSION)
93         ret &= ~RES_RECURSE;
94     if (options & DNS_QUERY_NO_LOCAL_NAME)
95         ret &= ~RES_DNSRCH;
96     if (options & DNS_QUERY_NO_HOSTS_FILE)
97         ret |= RES_NOALIASES;
98     if (options & DNS_QUERY_TREAT_AS_FQDN)
99         ret &= ~RES_DEFNAMES;
100
101     if (options & DNS_QUERY_DONT_RESET_TTL_VALUES)
102         FIXME( "option DNS_QUERY_DONT_RESET_TTL_VALUES not implemented\n" );
103     if (options & DNS_QUERY_RESERVED)
104         FIXME( "option DNS_QUERY_RESERVED not implemented\n" );
105     if (options & DNS_QUERY_WIRE_ONLY)
106         FIXME( "option DNS_QUERY_WIRE_ONLY not implemented\n" );
107     if (options & DNS_QUERY_NO_WIRE_QUERY)
108         FIXME( "option DNS_QUERY_NO_WIRE_QUERY not implemented\n" );
109     if (options & DNS_QUERY_BYPASS_CACHE)
110         FIXME( "option DNS_QUERY_BYPASS_CACHE not implemented\n" );
111     if (options & DNS_QUERY_RETURN_MESSAGE)
112         FIXME( "option DNS_QUERY_RETURN_MESSAGE not implemented\n" );
113
114     if (options & DNS_QUERY_NO_NETBT)
115         TRACE( "netbios query disabled\n" );
116
117     return ret;
118 }
119
120 static DNS_STATUS dns_map_error( int error )
121 {
122     switch (error)
123     {
124     case ns_r_noerror:  return ERROR_SUCCESS;
125     case ns_r_formerr:  return DNS_ERROR_RCODE_FORMAT_ERROR;
126     case ns_r_servfail: return DNS_ERROR_RCODE_SERVER_FAILURE;
127     case ns_r_nxdomain: return DNS_ERROR_RCODE_NAME_ERROR;
128     case ns_r_notimpl:  return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
129     case ns_r_refused:  return DNS_ERROR_RCODE_REFUSED;
130     case ns_r_yxdomain: return DNS_ERROR_RCODE_YXDOMAIN;
131     case ns_r_yxrrset:  return DNS_ERROR_RCODE_YXRRSET;
132     case ns_r_nxrrset:  return DNS_ERROR_RCODE_NXRRSET;
133     case ns_r_notauth:  return DNS_ERROR_RCODE_NOTAUTH;
134     case ns_r_notzone:  return DNS_ERROR_RCODE_NOTZONE;
135     default:
136         FIXME( "unmapped error code: %d\n", error );
137         return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
138     }
139 }
140
141 static DNS_STATUS dns_map_h_errno( int error )
142 {
143     switch (error)
144     {
145     case NO_DATA:
146     case HOST_NOT_FOUND: return DNS_ERROR_RCODE_NAME_ERROR;
147     case TRY_AGAIN:      return DNS_ERROR_RCODE_SERVER_FAILURE;
148     case NO_RECOVERY:    return DNS_ERROR_RCODE_REFUSED;
149     case NETDB_INTERNAL: return DNS_ERROR_RCODE;
150     default:
151         FIXME( "unmapped error code: %d\n", error );
152         return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
153     }
154 }
155
156 static char *dns_dname_from_msg( ns_msg msg, const unsigned char *pos )
157 {
158     int len;
159     char *str, dname[NS_MAXDNAME] = ".";
160
161     /* returns *compressed* length, ignore it */
162     len = dns_ns_name_uncompress( ns_msg_base( msg ), ns_msg_end( msg ),
163                                   pos, dname, sizeof(dname) );
164
165     len = strlen( dname );
166     str = heap_alloc( len + 1 );
167     if (str) strcpy( str, dname );
168     return str;
169 }
170
171 static char *dns_str_from_rdata( const unsigned char *rdata )
172 {
173     char *str;
174     unsigned int len = rdata[0];
175
176     str = heap_alloc( len + 1 );
177     if (str)
178     {
179         memcpy( str, ++rdata, len );
180         str[len] = '\0';
181     }
182     return str;
183 }
184
185 static unsigned int dns_get_record_size( const ns_rr *rr )
186 {
187     const unsigned char *pos = rr->rdata;
188     unsigned int num = 0, size = sizeof(DNS_RECORDA);
189
190     switch (rr->type)
191     {
192     case ns_t_key:
193     {
194         pos += sizeof(WORD) + sizeof(BYTE) + sizeof(BYTE);
195         size += rr->rdata + rr->rdlength - pos - 1;
196         break;
197     }
198     case ns_t_sig:
199     {
200         pos += sizeof(PCHAR) + sizeof(WORD) + 2 * sizeof(BYTE);
201         pos += 3 * sizeof(DWORD) + 2 * sizeof(WORD);
202         size += rr->rdata + rr->rdlength - pos - 1;
203         break;
204     }
205     case ns_t_hinfo:
206     case ns_t_isdn:
207     case ns_t_txt:
208     case ns_t_x25:
209     {
210         while (pos[0] && pos < rr->rdata + rr->rdlength)
211         {
212             num++;
213             pos += pos[0] + 1;
214         }
215         size += (num - 1) * sizeof(PCHAR);
216         break;
217     }
218     case ns_t_null:
219     {
220         size += rr->rdlength - 1;
221         break;
222     }
223     case ns_t_nxt:
224     case ns_t_wks:
225     case 0xff01:  /* WINS */
226     {
227         FIXME( "unhandled type: %s\n", dns_type_to_str( rr->type ) );
228         break;
229     }
230     default:
231         break;
232     }
233     return size;
234 }
235
236 static DNS_STATUS dns_copy_rdata( ns_msg msg, const ns_rr *rr, DNS_RECORDA *r, WORD *dlen )
237 {
238     DNS_STATUS ret = ERROR_SUCCESS;
239     const unsigned char *pos = rr->rdata;
240     unsigned int i, size;
241
242     switch (rr->type)
243     {
244     case ns_t_a:
245     {
246         r->Data.A.IpAddress = *(const DWORD *)pos;
247         *dlen = sizeof(DNS_A_DATA);
248         break; 
249     }
250     case ns_t_aaaa:
251     {
252         for (i = 0; i < sizeof(IP6_ADDRESS)/sizeof(DWORD); i++)
253         {
254             r->Data.AAAA.Ip6Address.IP6Dword[i] = *(const DWORD *)pos;
255             pos += sizeof(DWORD);
256         }
257
258         *dlen = sizeof(DNS_AAAA_DATA);
259         break;
260     }
261     case ns_t_key:
262     {
263         /* FIXME: byte order? */
264         r->Data.KEY.wFlags      = *(const WORD *)pos;   pos += sizeof(WORD);
265         r->Data.KEY.chProtocol  = *pos++;
266         r->Data.KEY.chAlgorithm = *pos++;
267
268         size = rr->rdata + rr->rdlength - pos;
269
270         for (i = 0; i < size; i++)
271             r->Data.KEY.Key[i] = *pos++;
272
273         *dlen = sizeof(DNS_KEY_DATA) + (size - 1) * sizeof(BYTE);
274         break;
275     }
276     case ns_t_rp:
277     case ns_t_minfo:
278     {
279         r->Data.MINFO.pNameMailbox = dns_dname_from_msg( msg, pos );
280         if (!r->Data.MINFO.pNameMailbox) return ERROR_NOT_ENOUGH_MEMORY;
281
282         if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
283             return DNS_ERROR_BAD_PACKET;
284
285         r->Data.MINFO.pNameErrorsMailbox = dns_dname_from_msg( msg, pos );
286         if (!r->Data.MINFO.pNameErrorsMailbox)
287         {
288             heap_free( r->Data.MINFO.pNameMailbox );
289             return ERROR_NOT_ENOUGH_MEMORY;
290         }
291
292         *dlen = sizeof(DNS_MINFO_DATAA);
293         break; 
294     }
295     case ns_t_afsdb:
296     case ns_t_rt:
297     case ns_t_mx:
298     {
299         r->Data.MX.wPreference = ntohs( *(const WORD *)pos );
300         r->Data.MX.pNameExchange = dns_dname_from_msg( msg, pos + sizeof(WORD) );
301         if (!r->Data.MX.pNameExchange) return ERROR_NOT_ENOUGH_MEMORY;
302
303         *dlen = sizeof(DNS_MX_DATAA);
304         break; 
305     }
306     case ns_t_null:
307     {
308         r->Data.Null.dwByteCount = rr->rdlength;
309         memcpy( r->Data.Null.Data, rr->rdata, rr->rdlength );
310
311         *dlen = sizeof(DNS_NULL_DATA) + rr->rdlength - 1;
312         break;
313     }
314     case ns_t_cname:
315     case ns_t_ns:
316     case ns_t_mb:
317     case ns_t_md:
318     case ns_t_mf:
319     case ns_t_mg:
320     case ns_t_mr:
321     case ns_t_ptr:
322     {
323         r->Data.PTR.pNameHost = dns_dname_from_msg( msg, pos );
324         if (!r->Data.PTR.pNameHost) return ERROR_NOT_ENOUGH_MEMORY;
325
326         *dlen = sizeof(DNS_PTR_DATAA);
327         break;
328     }
329     case ns_t_sig:
330     {
331         r->Data.SIG.pNameSigner = dns_dname_from_msg( msg, pos );
332         if (!r->Data.SIG.pNameSigner) return ERROR_NOT_ENOUGH_MEMORY;
333
334         if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
335             return DNS_ERROR_BAD_PACKET;
336
337         /* FIXME: byte order? */
338         r->Data.SIG.wTypeCovered  = *(const WORD *)pos;   pos += sizeof(WORD);
339         r->Data.SIG.chAlgorithm   = *pos++;
340         r->Data.SIG.chLabelCount  = *pos++;
341         r->Data.SIG.dwOriginalTtl = *(const DWORD *)pos;  pos += sizeof(DWORD);
342         r->Data.SIG.dwExpiration  = *(const DWORD *)pos;  pos += sizeof(DWORD);
343         r->Data.SIG.dwTimeSigned  = *(const DWORD *)pos;  pos += sizeof(DWORD);
344         r->Data.SIG.wKeyTag       = *(const WORD *)pos;
345
346         size = rr->rdata + rr->rdlength - pos;
347
348         for (i = 0; i < size; i++)
349             r->Data.SIG.Signature[i] = *pos++;
350
351         *dlen = sizeof(DNS_SIG_DATAA) + (size - 1) * sizeof(BYTE);
352         break; 
353     }
354     case ns_t_soa:
355     {
356         r->Data.SOA.pNamePrimaryServer = dns_dname_from_msg( msg, pos );
357         if (!r->Data.SOA.pNamePrimaryServer) return ERROR_NOT_ENOUGH_MEMORY;
358
359         if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
360             return DNS_ERROR_BAD_PACKET;
361
362         r->Data.SOA.pNameAdministrator = dns_dname_from_msg( msg, pos );
363         if (!r->Data.SOA.pNameAdministrator)
364         {
365             heap_free( r->Data.SOA.pNamePrimaryServer );
366             return ERROR_NOT_ENOUGH_MEMORY;
367         }
368
369         if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
370             return DNS_ERROR_BAD_PACKET;
371
372         r->Data.SOA.dwSerialNo   = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
373         r->Data.SOA.dwRefresh    = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
374         r->Data.SOA.dwRetry      = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
375         r->Data.SOA.dwExpire     = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
376         r->Data.SOA.dwDefaultTtl = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
377
378         *dlen = sizeof(DNS_SOA_DATAA);
379         break; 
380     }
381     case ns_t_srv:
382     {
383         r->Data.SRV.wPriority = ntohs( *(const WORD *)pos ); pos += sizeof(WORD);
384         r->Data.SRV.wWeight   = ntohs( *(const WORD *)pos ); pos += sizeof(WORD);
385         r->Data.SRV.wPort     = ntohs( *(const WORD *)pos ); pos += sizeof(WORD);
386
387         r->Data.SRV.pNameTarget = dns_dname_from_msg( msg, pos );
388         if (!r->Data.SRV.pNameTarget) return ERROR_NOT_ENOUGH_MEMORY;
389
390         *dlen = sizeof(DNS_SRV_DATAA);
391         break; 
392     }
393     case ns_t_hinfo:
394     case ns_t_isdn:
395     case ns_t_x25:
396     case ns_t_txt:
397     {
398         i = 0;
399         while (pos[0] && pos < rr->rdata + rr->rdlength)
400         {
401             r->Data.TXT.pStringArray[i] = dns_str_from_rdata( pos );
402             if (!r->Data.TXT.pStringArray[i])
403             {
404                 while (i > 0) heap_free( r->Data.TXT.pStringArray[--i] );
405                 return ERROR_NOT_ENOUGH_MEMORY;
406             }
407             i++;
408             pos += pos[0] + 1;
409         }
410         r->Data.TXT.dwStringCount = i;
411         *dlen = sizeof(DNS_TXT_DATAA) + (i - 1) * sizeof(PCHAR);
412         break;
413     }
414     case ns_t_atma:
415     case ns_t_loc:
416     case ns_t_nxt:
417     case ns_t_tsig:
418     case ns_t_wks:
419     case 0x00f9:  /* TKEY */
420     case 0xff01:  /* WINS */
421     case 0xff02:  /* WINSR */
422     default:
423         FIXME( "unhandled type: %s\n", dns_type_to_str( rr->type ) );
424         return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
425     }
426
427     return ret;
428
429
430 static DNS_STATUS dns_copy_record( ns_msg msg, ns_sect section,
431                                    unsigned short num, DNS_RECORDA **recp )
432 {
433     DNS_STATUS ret;
434     DNS_RECORDA *record;
435     WORD dlen;
436     ns_rr rr;
437
438     if (dns_ns_parserr( &msg, section, num, &rr ) < 0)
439         return DNS_ERROR_BAD_PACKET;
440
441     if (!(record = heap_alloc_zero( dns_get_record_size( &rr ) )))
442         return ERROR_NOT_ENOUGH_MEMORY;
443
444     record->pName = dns_strdup_u( rr.name );
445     if (!record->pName)
446     {
447         heap_free( record );
448         return ERROR_NOT_ENOUGH_MEMORY;
449     }
450
451     record->wType = rr.type;
452     record->Flags.S.Section = section;
453     record->Flags.S.CharSet = DnsCharSetUtf8;
454     record->dwTtl = rr.ttl;
455
456     if ((ret = dns_copy_rdata( msg, &rr, record, &dlen )))
457     {
458         heap_free( record->pName );
459         heap_free( record );
460         return ret;
461     }
462     record->wDataLength = dlen;
463     *recp = record;
464
465     TRACE( "found %s record in %s section\n",
466            dns_type_to_str( rr.type ), dns_section_to_str( section ) );
467     return ERROR_SUCCESS;
468 }
469
470 #define DEFAULT_TTL  1200
471
472 static DNS_STATUS dns_do_query_netbios( PCSTR name, DNS_RECORDA **recp )
473 {
474     NCB ncb;
475     UCHAR ret;
476     DNS_RRSET rrset;
477     FIND_NAME_BUFFER *buffer;
478     FIND_NAME_HEADER *header;
479     DNS_RECORDA *record = NULL;
480     unsigned int i, len;
481     DNS_STATUS status = ERROR_INVALID_NAME;
482
483     len = strlen( name );
484     if (len >= NCBNAMSZ) return DNS_ERROR_RCODE_NAME_ERROR;
485
486     DNS_RRSET_INIT( rrset );
487
488     memset( &ncb, 0, sizeof(ncb) );
489     ncb.ncb_command = NCBFINDNAME;
490
491     memset( ncb.ncb_callname, ' ', sizeof(ncb.ncb_callname) );
492     memcpy( ncb.ncb_callname, name, len );
493     ncb.ncb_callname[NCBNAMSZ - 1] = '\0';
494
495     ret = Netbios( &ncb );
496     if (ret != NRC_GOODRET) return ERROR_INVALID_NAME;
497
498     header = (FIND_NAME_HEADER *)ncb.ncb_buffer;
499     buffer = (FIND_NAME_BUFFER *)((char *)header + sizeof(FIND_NAME_HEADER));
500
501     for (i = 0; i < header->node_count; i++) 
502     {
503         record = heap_alloc_zero( sizeof(DNS_RECORDA) );
504         if (!record)
505         {
506             status = ERROR_NOT_ENOUGH_MEMORY;
507             goto exit;
508         }
509         else
510         {
511             record->pName = dns_strdup_u( name );
512             if (!record->pName)
513             {
514                 status = ERROR_NOT_ENOUGH_MEMORY;
515                 goto exit;
516             }
517
518             record->wType = DNS_TYPE_A;
519             record->Flags.S.Section = DnsSectionAnswer;
520             record->Flags.S.CharSet = DnsCharSetUtf8;
521             record->dwTtl = DEFAULT_TTL;
522
523             /* FIXME: network byte order? */
524             record->Data.A.IpAddress = *(DWORD *)((char *)buffer[i].destination_addr + 2);
525
526             DNS_RRSET_ADD( rrset, (DNS_RECORD *)record );
527         }
528     }
529     status = ERROR_SUCCESS;
530
531 exit:
532     DNS_RRSET_TERMINATE( rrset );
533
534     if (status != ERROR_SUCCESS)
535         DnsRecordListFree( rrset.pFirstRR, DnsFreeRecordList );
536     else
537         *recp = (DNS_RECORDA *)rrset.pFirstRR;
538
539     return status;
540 }
541
542 /* res_init() must have been called before calling these three functions.
543  */
544 static DNS_STATUS dns_set_serverlist( const IP4_ARRAY *addrs )
545 {
546     int i;
547
548     if (addrs->AddrCount > MAXNS) 
549     {
550         WARN( "too many servers: %d only using the first: %d\n",
551               addrs->AddrCount, MAXNS );
552         _res.nscount = MAXNS;
553     }
554     else _res.nscount = addrs->AddrCount;
555
556     for (i = 0; i < _res.nscount; i++)
557         _res.nsaddr_list[i].sin_addr.s_addr = addrs->AddrArray[i];
558
559     return ERROR_SUCCESS;
560 }
561
562 static DNS_STATUS dns_get_serverlist( PIP4_ARRAY addrs, PDWORD len )
563 {
564     unsigned int size;
565     int i;
566
567     size = sizeof(IP4_ARRAY) + sizeof(IP4_ADDRESS) * (_res.nscount - 1);
568     if (!addrs || *len < size)
569     {
570         *len = size;
571         return ERROR_INSUFFICIENT_BUFFER;
572     }
573
574     addrs->AddrCount = _res.nscount;
575
576     for (i = 0; i < _res.nscount; i++)
577         addrs->AddrArray[i] = _res.nsaddr_list[i].sin_addr.s_addr;
578
579     return ERROR_SUCCESS;
580 }
581
582 static DNS_STATUS dns_do_query( PCSTR name, WORD type, DWORD options,
583                                 PDNS_RECORDA *result )
584 {
585     DNS_STATUS ret = DNS_ERROR_RCODE_NOT_IMPLEMENTED;
586
587     unsigned int i, num;
588     unsigned char answer[NS_PACKETSZ];
589     ns_sect sections[] = { ns_s_an, ns_s_ar };
590     ns_msg msg;
591
592     DNS_RECORDA *record = NULL;
593     DNS_RRSET rrset;
594     int len;
595
596     DNS_RRSET_INIT( rrset );
597
598     len = res_query( name, ns_c_in, type, answer, sizeof(answer) );
599     if (len < 0)
600     {
601         ret = dns_map_h_errno( h_errno );
602         goto exit;
603     }
604
605     if (dns_ns_initparse( answer, len, &msg ) < 0)
606     {
607         ret = DNS_ERROR_BAD_PACKET;
608         goto exit;
609     }
610
611 #define RCODE_MASK 0x0f
612     if ((msg._flags & RCODE_MASK) != ns_r_noerror)
613     {
614         ret = dns_map_error( msg._flags & RCODE_MASK );
615         goto exit;
616     }
617
618     for (i = 0; i < sizeof(sections)/sizeof(sections[0]); i++)
619     {
620         for (num = 0; num < ns_msg_count( msg, sections[i] ); num++)
621         {
622             ret = dns_copy_record( msg, sections[i], num, &record );
623             if (ret != ERROR_SUCCESS) goto exit;
624
625             DNS_RRSET_ADD( rrset, (DNS_RECORD *)record );
626         }
627     }
628
629 exit:
630     DNS_RRSET_TERMINATE( rrset );
631
632     if (ret != ERROR_SUCCESS)
633         DnsRecordListFree( rrset.pFirstRR, DnsFreeRecordList );
634     else
635         *result = (DNS_RECORDA *)rrset.pFirstRR;
636
637     return ret;
638 }
639
640 #endif /* HAVE_RESOLV */
641
642 /******************************************************************************
643  * DnsQuery_A           [DNSAPI.@]
644  *
645  */
646 DNS_STATUS WINAPI DnsQuery_A( PCSTR name, WORD type, DWORD options, PVOID servers,
647                               PDNS_RECORDA *result, PVOID *reserved )
648 {
649     WCHAR *nameW;
650     DNS_RECORDW *resultW;
651     DNS_STATUS status;
652
653     TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name), dns_type_to_str( type ),
654            options, servers, result, reserved );
655
656     if (!name || !result)
657         return ERROR_INVALID_PARAMETER;
658
659     nameW = dns_strdup_aw( name );
660     if (!nameW) return ERROR_NOT_ENOUGH_MEMORY;
661
662     status = DnsQuery_W( nameW, type, options, servers, &resultW, reserved ); 
663
664     if (status == ERROR_SUCCESS)
665     {
666         *result = (DNS_RECORDA *)DnsRecordSetCopyEx(
667              (DNS_RECORD *)resultW, DnsCharSetUnicode, DnsCharSetAnsi );
668
669         if (!*result) status = ERROR_NOT_ENOUGH_MEMORY;
670         DnsRecordListFree( (DNS_RECORD *)resultW, DnsFreeRecordList );
671     }
672
673     heap_free( nameW );
674     return status;
675 }
676
677 /******************************************************************************
678  * DnsQuery_UTF8              [DNSAPI.@]
679  *
680  */
681 DNS_STATUS WINAPI DnsQuery_UTF8( PCSTR name, WORD type, DWORD options, PVOID servers,
682                                  PDNS_RECORDA *result, PVOID *reserved )
683 {
684     DNS_STATUS ret = DNS_ERROR_RCODE_NOT_IMPLEMENTED;
685 #ifdef HAVE_RESOLV
686
687     TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name), dns_type_to_str( type ),
688            options, servers, result, reserved );
689
690     if (!name || !result)
691         return ERROR_INVALID_PARAMETER;
692
693     initialise_resolver();
694     _res.options |= dns_map_options( options );
695
696     if (servers && (ret = dns_set_serverlist( servers )))
697         return ret;
698
699     ret = dns_do_query( name, type, options, result );
700
701     if (ret == DNS_ERROR_RCODE_NAME_ERROR && type == DNS_TYPE_A &&
702         !(options & DNS_QUERY_NO_NETBT))
703     {
704         TRACE( "dns lookup failed, trying netbios query\n" );
705         ret = dns_do_query_netbios( name, result );
706     }
707
708 #endif
709     return ret;
710 }
711
712 /******************************************************************************
713  * DnsQuery_W              [DNSAPI.@]
714  *
715  */
716 DNS_STATUS WINAPI DnsQuery_W( PCWSTR name, WORD type, DWORD options, PVOID servers,
717                               PDNS_RECORDW *result, PVOID *reserved )
718 {
719     char *nameU;
720     DNS_RECORDA *resultA;
721     DNS_STATUS status;
722
723     TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_w(name), dns_type_to_str( type ),
724            options, servers, result, reserved );
725
726     if (!name || !result)
727         return ERROR_INVALID_PARAMETER;
728
729     nameU = dns_strdup_wu( name );
730     if (!nameU) return ERROR_NOT_ENOUGH_MEMORY;
731
732     status = DnsQuery_UTF8( nameU, type, options, servers, &resultA, reserved ); 
733
734     if (status == ERROR_SUCCESS)
735     {
736         *result = (DNS_RECORDW *)DnsRecordSetCopyEx(
737             (DNS_RECORD *)resultA, DnsCharSetUtf8, DnsCharSetUnicode );
738
739         if (!*result) status = ERROR_NOT_ENOUGH_MEMORY;
740         DnsRecordListFree( (DNS_RECORD *)resultA, DnsFreeRecordList );
741     }
742
743     heap_free( nameU );
744     return status;
745 }
746
747 static DNS_STATUS dns_get_hostname_a( COMPUTER_NAME_FORMAT format,
748                                       PSTR buffer, PDWORD len )
749 {
750     char name[256];
751     DWORD size = sizeof(name)/sizeof(name[0]);
752
753     if (!GetComputerNameExA( format, name, &size ))
754         return DNS_ERROR_NAME_DOES_NOT_EXIST;
755
756     if (!buffer || (size = lstrlenA( name ) + 1) > *len)
757     {
758         *len = size;
759         return ERROR_INSUFFICIENT_BUFFER;
760     }
761
762     lstrcpyA( buffer, name );
763     return ERROR_SUCCESS;
764 }
765
766 static DNS_STATUS dns_get_hostname_w( COMPUTER_NAME_FORMAT format,
767                                       PWSTR buffer, PDWORD len )
768 {
769     WCHAR name[256];
770     DWORD size = sizeof(name)/sizeof(name[0]);
771
772     if (!GetComputerNameExW( format, name, &size ))
773         return DNS_ERROR_NAME_DOES_NOT_EXIST;
774
775     if (!buffer || (size = lstrlenW( name ) + 1) > *len)
776     {
777         *len = size;
778         return ERROR_INSUFFICIENT_BUFFER;
779     }
780
781     lstrcpyW( buffer, name );
782     return ERROR_SUCCESS;
783 }
784
785 /******************************************************************************
786  * DnsQueryConfig          [DNSAPI.@]
787  *
788  */
789 DNS_STATUS WINAPI DnsQueryConfig( DNS_CONFIG_TYPE config, DWORD flag, PCWSTR adapter,
790                                   PVOID reserved, PVOID buffer, PDWORD len )
791 {
792     DNS_STATUS ret = ERROR_INVALID_PARAMETER;
793
794     TRACE( "(%d,0x%08x,%s,%p,%p,%p)\n", config, flag, debugstr_w(adapter),
795            reserved, buffer, len );
796
797     if (!len) return ERROR_INVALID_PARAMETER;
798
799     switch (config)
800     {
801     case DnsConfigDnsServerList:
802     {
803 #ifdef HAVE_RESOLV
804         initialise_resolver();
805         ret = dns_get_serverlist( buffer, len );
806         break;
807 #else
808         WARN( "compiled without resolver support\n" );
809         break;
810 #endif
811     }
812     case DnsConfigHostName_A:
813     case DnsConfigHostName_UTF8:
814         return dns_get_hostname_a( ComputerNameDnsHostname, buffer, len );
815
816     case DnsConfigFullHostName_A:
817     case DnsConfigFullHostName_UTF8:
818         return dns_get_hostname_a( ComputerNameDnsFullyQualified, buffer, len );
819
820     case DnsConfigPrimaryDomainName_A:
821     case DnsConfigPrimaryDomainName_UTF8:
822         return dns_get_hostname_a( ComputerNameDnsDomain, buffer, len );
823
824     case DnsConfigHostName_W:
825         return dns_get_hostname_w( ComputerNameDnsHostname, buffer, len );
826
827     case DnsConfigFullHostName_W:
828         return dns_get_hostname_w( ComputerNameDnsFullyQualified, buffer, len );
829
830     case DnsConfigPrimaryDomainName_W:
831         return dns_get_hostname_w( ComputerNameDnsDomain, buffer, len );
832
833     case DnsConfigAdapterDomainName_A:
834     case DnsConfigAdapterDomainName_W:
835     case DnsConfigAdapterDomainName_UTF8:
836     case DnsConfigSearchList:
837     case DnsConfigAdapterInfo:
838     case DnsConfigPrimaryHostNameRegistrationEnabled:
839     case DnsConfigAdapterHostNameRegistrationEnabled:
840     case DnsConfigAddressRegistrationMaxCount:
841         FIXME( "unimplemented config type %d\n", config );
842         break;
843
844     default:
845         WARN( "unknown config type: %d\n", config );
846         break;
847     }
848     return ret;
849 }