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 <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winerror.h"
  25 #include "winnls.h"
  26 #include "windns.h"
  27 #include "nb30.h"
  28 #include "ws2def.h"
  29
  30 #include "wine/debug.h"
  31 #include "dnsapi.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(dnsapi);
  34
  35 #define DEFAULT_TTL  1200
  36
  37 static DNS_STATUS do_query_netbios( PCSTR name, DNS_RECORDA **recp )
  38 {
  39     NCB ncb;
  40     UCHAR ret;
  41     DNS_RRSET rrset;
  42     FIND_NAME_BUFFER *buffer;
  43     FIND_NAME_HEADER *header;
  44     DNS_RECORDA *record = NULL;
  45     unsigned int i, len;
  46     DNS_STATUS status = ERROR_INVALID_NAME;
  47
  48     len = strlen( name );
  49     if (len >= NCBNAMSZ) return DNS_ERROR_RCODE_NAME_ERROR;
  50
  51     DNS_RRSET_INIT( rrset );
  52
  53     memset( &ncb, 0, sizeof(ncb) );
  54     ncb.ncb_command = NCBFINDNAME;
  55
  56     memset( ncb.ncb_callname, ' ', sizeof(ncb.ncb_callname) );
  57     memcpy( ncb.ncb_callname, name, len );
  58     ncb.ncb_callname[NCBNAMSZ - 1] = '\0';
  59
  60     ret = Netbios( &ncb );
  61     if (ret != NRC_GOODRET) return ERROR_INVALID_NAME;
  62
  63     header = (FIND_NAME_HEADER *)ncb.ncb_buffer;
  64     buffer = (FIND_NAME_BUFFER *)((char *)header + sizeof(FIND_NAME_HEADER));
  65
  66     for (i = 0; i < header->node_count; i++)
  67     {
  68         record = calloc( 1, sizeof(DNS_RECORDA) );
  69         if (!record)
  70         {
  71             status = ERROR_NOT_ENOUGH_MEMORY;
  72             goto exit;
  73         }
  74         else
  75         {
  76             record->pName = strdup( name );
  77             if (!record->pName)
  78             {
  79                 status = ERROR_NOT_ENOUGH_MEMORY;
  80                 free( record );
  81                 goto exit;
  82             }
  83
  84             record->wType = DNS_TYPE_A;
  85             record->Flags.S.Section = DnsSectionAnswer;
  86             record->Flags.S.CharSet = DnsCharSetUtf8;
  87             record->dwTtl = DEFAULT_TTL;
  88
  89             /* FIXME: network byte order? */
  90             record->Data.A.IpAddress = *(DWORD *)((char *)buffer[i].destination_addr + 2);
  91
  92             DNS_RRSET_ADD( rrset, (DNS_RECORD *)record );
  93         }
  94     }
  95     status = ERROR_SUCCESS;
  96
  97 exit:
  98     DNS_RRSET_TERMINATE( rrset );
  99
 100     if (status != ERROR_SUCCESS)
 101         DnsRecordListFree( rrset.pFirstRR, DnsFreeRecordList );
 102     else
 103         *recp = (DNS_RECORDA *)rrset.pFirstRR;
 104
 105     return status;
 106 }
 107
 108 static const char *debugstr_query_request(const DNS_QUERY_REQUEST *req)
 109 {
 110     if (!req) return "(null)";
 111     return wine_dbg_sprintf("{%lu %s %s %I64x %p %lu %p %p}", req->Version,
 112             debugstr_w(req->QueryName), debugstr_type(req->QueryType),
 113             req->QueryOptions, req->pDnsServerList, req->InterfaceIndex,
 114             req->pQueryCompletionCallback, req->pQueryContext);
 115 }
 116
 117 /******************************************************************************
 118  * DnsQueryEx           [DNSAPI.@]
 119  *
 120  */
 121 DNS_STATUS WINAPI DnsQueryEx(DNS_QUERY_REQUEST *request, DNS_QUERY_RESULT *result, DNS_QUERY_CANCEL *cancel)
 122 {
 123     FIXME("(%s, %p, %p)\n", debugstr_query_request(request), result, cancel);
 124     return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
 125 }
 126
 127 /******************************************************************************
 128  * DnsQuery_A           [DNSAPI.@]
 129  *
 130  */
 131 DNS_STATUS WINAPI DnsQuery_A( const char *name, WORD type, DWORD options, void *servers, DNS_RECORDA **result,
 132                               void **reserved )
 133 {
 134     WCHAR *nameW;
 135     DNS_RECORDW *resultW;
 136     DNS_STATUS status;
 137
 138     TRACE( "(%s, %s, %#lx, %p, %p, %p)\n", debugstr_a(name), debugstr_type( type ),
 139            options, servers, result, reserved );
 140
 141     if (!name || !result)
 142         return ERROR_INVALID_PARAMETER;
 143
 144     nameW = strdup_aw( name );
 145     if (!nameW) return ERROR_NOT_ENOUGH_MEMORY;
 146
 147     status = DnsQuery_W( nameW, type, options, servers, &resultW, reserved );
 148
 149     if (status == ERROR_SUCCESS)
 150     {
 151         *result = (DNS_RECORDA *)DnsRecordSetCopyEx(
 152              (DNS_RECORD *)resultW, DnsCharSetUnicode, DnsCharSetAnsi );
 153
 154         if (!*result) status = ERROR_NOT_ENOUGH_MEMORY;
 155         DnsRecordListFree( (DNS_RECORD *)resultW, DnsFreeRecordList );
 156     }
 157
 158     free( nameW );
 159     return status;
 160 }
 161
 162 /******************************************************************************
 163  * DnsQuery_UTF8              [DNSAPI.@]
 164  *
 165  */
 166 DNS_STATUS WINAPI DnsQuery_UTF8( const char *name, WORD type, DWORD options, void *servers, DNS_RECORDA **result,
 167                                  void **reserved )
 168 {
 169     DNS_STATUS ret = DNS_ERROR_RCODE_NOT_IMPLEMENTED;
 170     unsigned char answer[4096];
 171     DWORD len = sizeof(answer);
 172     struct query_params query_params = { name, type, options, answer, &len };
 173
 174     TRACE( "(%s, %s, %#lx, %p, %p, %p)\n", debugstr_a(name), debugstr_type( type ),
 175            options, servers, result, reserved );
 176
 177     if (!name || !result)
 178         return ERROR_INVALID_PARAMETER;
 179
 180     if ((ret = RESOLV_CALL( set_serverlist, servers ))) return ret;
 181
 182     ret = RESOLV_CALL( query, &query_params );
 183     if (!ret)
 184     {
 185         DNS_MESSAGE_BUFFER *buffer = (DNS_MESSAGE_BUFFER *)answer;
 186
 187         if (len < sizeof(buffer->MessageHead)) return DNS_ERROR_BAD_PACKET;
 188         DNS_BYTE_FLIP_HEADER_COUNTS( &buffer->MessageHead );
 189         switch (buffer->MessageHead.ResponseCode)
 190         {
 191         case DNS_RCODE_NOERROR:  ret = DnsExtractRecordsFromMessage_UTF8( buffer, len, result ); break;
 192         case DNS_RCODE_FORMERR:  ret = DNS_ERROR_RCODE_FORMAT_ERROR; break;
 193         case DNS_RCODE_SERVFAIL: ret = DNS_ERROR_RCODE_SERVER_FAILURE; break;
 194         case DNS_RCODE_NXDOMAIN: ret = DNS_ERROR_RCODE_NAME_ERROR; break;
 195         case DNS_RCODE_NOTIMPL:  ret = DNS_ERROR_RCODE_NOT_IMPLEMENTED; break;
 196         case DNS_RCODE_REFUSED:  ret = DNS_ERROR_RCODE_REFUSED; break;
 197         case DNS_RCODE_YXDOMAIN: ret = DNS_ERROR_RCODE_YXDOMAIN; break;
 198         case DNS_RCODE_YXRRSET:  ret = DNS_ERROR_RCODE_YXRRSET; break;
 199         case DNS_RCODE_NXRRSET:  ret = DNS_ERROR_RCODE_NXRRSET; break;
 200         case DNS_RCODE_NOTAUTH:  ret = DNS_ERROR_RCODE_NOTAUTH; break;
 201         case DNS_RCODE_NOTZONE:  ret = DNS_ERROR_RCODE_NOTZONE; break;
 202         default:                 ret = DNS_ERROR_RCODE_NOT_IMPLEMENTED; break;
 203         }
 204     }
 205
 206     if (ret == DNS_ERROR_RCODE_NAME_ERROR && type == DNS_TYPE_A &&
 207         !(options & DNS_QUERY_NO_NETBT))
 208     {
 209         TRACE( "dns lookup failed, trying netbios query\n" );
 210         ret = do_query_netbios( name, result );
 211     }
 212
 213     return ret;
 214 }
 215
 216 /******************************************************************************
 217  * DnsQuery_W              [DNSAPI.@]
 218  *
 219  */
 220 DNS_STATUS WINAPI DnsQuery_W( const WCHAR *name, WORD type, DWORD options, void *servers, DNS_RECORDW **result,
 221                               void **reserved )
 222 {
 223     char *nameU;
 224     DNS_RECORDA *resultA;
 225     DNS_STATUS status;
 226
 227     TRACE( "(%s, %s, %#lx, %p, %p, %p)\n", debugstr_w(name), debugstr_type( type ),
 228            options, servers, result, reserved );
 229
 230     if (!name || !result)
 231         return ERROR_INVALID_PARAMETER;
 232
 233     nameU = strdup_wu( name );
 234     if (!nameU) return ERROR_NOT_ENOUGH_MEMORY;
 235
 236     status = DnsQuery_UTF8( nameU, type, options, servers, &resultA, reserved );
 237
 238     if (status == ERROR_SUCCESS)
 239     {
 240         *result = (DNS_RECORDW *)DnsRecordSetCopyEx(
 241             (DNS_RECORD *)resultA, DnsCharSetUtf8, DnsCharSetUnicode );
 242
 243         if (!*result) status = ERROR_NOT_ENOUGH_MEMORY;
 244         DnsRecordListFree( (DNS_RECORD *)resultA, DnsFreeRecordList );
 245     }
 246
 247     free( nameU );
 248     return status;
 249 }
 250
 251 static DNS_STATUS get_hostname_a( COMPUTER_NAME_FORMAT format, PSTR buffer, PDWORD len )
 252 {
 253     char name[256];
 254     DWORD size = ARRAY_SIZE(name);
 255
 256     if (!GetComputerNameExA( format, name, &size ))
 257         return DNS_ERROR_NAME_DOES_NOT_EXIST;
 258
 259     if (!buffer || (size = lstrlenA( name ) + 1) > *len)
 260     {
 261         *len = size;
 262         return ERROR_INSUFFICIENT_BUFFER;
 263     }
 264
 265     lstrcpyA( buffer, name );
 266     return ERROR_SUCCESS;
 267 }
 268
 269 static DNS_STATUS get_hostname_w( COMPUTER_NAME_FORMAT format, PWSTR buffer, PDWORD len )
 270 {
 271     WCHAR name[256];
 272     DWORD size = ARRAY_SIZE(name);
 273
 274     if (!GetComputerNameExW( format, name, &size ))
 275         return DNS_ERROR_NAME_DOES_NOT_EXIST;
 276
 277     if (!buffer || (size = lstrlenW( name ) + 1) > *len)
 278     {
 279         *len = size;
 280         return ERROR_INSUFFICIENT_BUFFER;
 281     }
 282
 283     lstrcpyW( buffer, name );
 284     return ERROR_SUCCESS;
 285 }
 286
 287 static DNS_STATUS get_dns_server_list( IP4_ARRAY *out, DWORD *len )
 288 {
 289     char buf[FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[3])];
 290     DNS_ADDR_ARRAY *servers = (DNS_ADDR_ARRAY *)buf;
 291     DWORD ret, needed, i, num, array_len = sizeof(buf);
 292     struct get_serverlist_params params = { AF_INET, servers, &array_len };
 293     for (;;)
 294     {
 295         ret = RESOLV_CALL( get_serverlist, &params );
 296         if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) goto err;
 297         num = (array_len - FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[0])) / sizeof(DNS_ADDR);
 298         needed = FIELD_OFFSET(IP4_ARRAY, AddrArray[num]);
 299         if (!out || *len < needed)
 300         {
 301             *len = needed;
 302             ret = !out ? ERROR_SUCCESS : ERROR_MORE_DATA;
 303             goto err;
 304         }
 305         if (!ret) break;
 306
 307         if ((char *)servers != buf) free( servers );
 308         servers = malloc( array_len );
 309         if (!servers)
 310         {
 311             ret = ERROR_NOT_ENOUGH_MEMORY;
 312             goto err;
 313         }
 314     }
 315
 316     out->AddrCount = num;
 317     for (i = 0; i < num; i++)
 318         out->AddrArray[i] = ((SOCKADDR_IN *)servers->AddrArray[i].MaxSa)->sin_addr.s_addr;
 319     *len = needed;
 320     ret = ERROR_SUCCESS;
 321
 322 err:
 323     if ((char *)servers != buf) free( servers );
 324     return ret;
 325 }
 326
 327 /******************************************************************************
 328  * DnsQueryConfig          [DNSAPI.@]
 329  *
 330  */
 331 DNS_STATUS WINAPI DnsQueryConfig( DNS_CONFIG_TYPE config, DWORD flag, const WCHAR *adapter, void *reserved,
 332                                   void *buffer, DWORD *len )
 333 {
 334     DNS_STATUS ret = ERROR_INVALID_PARAMETER;
 335
 336     TRACE( "(%d, %#lx, %s, %p, %p, %p)\n", config, flag, debugstr_w(adapter), reserved, buffer, len );
 337
 338     if (!len) return ERROR_INVALID_PARAMETER;
 339
 340     switch (config)
 341     {
 342     case DnsConfigDnsServerList:
 343         return get_dns_server_list( buffer, len );
 344
 345     case DnsConfigHostName_A:
 346     case DnsConfigHostName_UTF8:
 347         return get_hostname_a( ComputerNameDnsHostname, buffer, len );
 348
 349     case DnsConfigFullHostName_A:
 350     case DnsConfigFullHostName_UTF8:
 351         return get_hostname_a( ComputerNameDnsFullyQualified, buffer, len );
 352
 353     case DnsConfigPrimaryDomainName_A:
 354     case DnsConfigPrimaryDomainName_UTF8:
 355         return get_hostname_a( ComputerNameDnsDomain, buffer, len );
 356
 357     case DnsConfigHostName_W:
 358         return get_hostname_w( ComputerNameDnsHostname, buffer, len );
 359
 360     case DnsConfigFullHostName_W:
 361         return get_hostname_w( ComputerNameDnsFullyQualified, buffer, len );
 362
 363     case DnsConfigPrimaryDomainName_W:
 364         return get_hostname_w( ComputerNameDnsDomain, buffer, len );
 365
 366     case DnsConfigAdapterDomainName_A:
 367     case DnsConfigAdapterDomainName_W:
 368     case DnsConfigAdapterDomainName_UTF8:
 369     case DnsConfigAdapterInfo:
 370     case DnsConfigPrimaryHostNameRegistrationEnabled:
 371     case DnsConfigAdapterHostNameRegistrationEnabled:
 372     case DnsConfigAddressRegistrationMaxCount:
 373         FIXME( "unimplemented config type %d\n", config );
 374         break;
 375
 376     case DnsConfigDnsServersUnspec:
 377     {
 378         struct get_serverlist_params params = { AF_UNSPEC, buffer, len };
 379         return RESOLV_CALL( get_serverlist, &params );
 380     }
 381     case DnsConfigDnsServersIpv4:
 382     {
 383         struct get_serverlist_params params = { AF_INET, buffer, len };
 384         return RESOLV_CALL( get_serverlist, &params );
 385     }
 386     case DnsConfigDnsServersIpv6:
 387     {
 388         struct get_serverlist_params params = { AF_INET6, buffer, len };
 389         return RESOLV_CALL( get_serverlist, &params );
 390     }
 391     /* Windows does not implement this, but we need it in iphlpapi. */
 392     case DnsConfigSearchList:
 393     {
 394         struct get_searchlist_params params = { buffer, len };
 395         return RESOLV_CALL( get_searchlist, &params );
 396     }
 397     default:
 398         WARN( "unknown config type: %d\n", config );
 399         break;
 400     }
 401     return ret;
 402 }