dlls/dnsapi/libresolv.c

   1 /*
   2  * Unix interface for libresolv
   3  *
   4  * Copyright 2021 Hans Leidekker for CodeWeavers
   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 #if 0
  22 #pragma makedep unix
  23 #endif
  24
  25 #include "config.h"
  26
  27 #ifdef HAVE_RESOLV
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <sys/types.h>
  33
  34 #ifdef HAVE_NETINET_IN_H
  35 # include <netinet/in.h>
  36 #endif
  37 #ifdef HAVE_ARPA_NAMESER_H
  38 # include <arpa/nameser.h>
  39 #endif
  40 #ifdef HAVE_RESOLV_H
  41 # include <resolv.h>
  42 #endif
  43 #ifdef HAVE_NETDB_H
  44 # include <netdb.h>
  45 #endif
  46
  47 #include "ntstatus.h"
  48 #define WIN32_NO_STATUS
  49 #include "windef.h"
  50 #include "winternl.h"
  51 #include "winbase.h"
  52 #include "windns.h"
  53 #define USE_WS_PREFIX
  54 #include "ws2def.h"
  55 #include "ws2ipdef.h"
  56
  57 #include "wine/debug.h"
  58 #include "dnsapi.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(dnsapi);
  61
  62 /* call res_init() just once because of a bug in Mac OS X 10.4 */
  63 /* call once per thread on systems that have per-thread _res */
  64 static void init_resolver( void )
  65 {
  66     if (!(_res.options & RES_INIT)) res_init();
  67 }
  68
  69 static unsigned long map_options( DWORD options )
  70 {
  71     unsigned long ret = 0;
  72
  73     if (options == DNS_QUERY_STANDARD)
  74         return RES_DEFAULT;
  75
  76     if (options & DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE)
  77         ret |= RES_IGNTC;
  78     if (options & DNS_QUERY_USE_TCP_ONLY)
  79         ret |= RES_USEVC;
  80     if (options & DNS_QUERY_NO_RECURSION)
  81         ret &= ~RES_RECURSE;
  82     if (options & DNS_QUERY_NO_LOCAL_NAME)
  83         ret &= ~RES_DNSRCH;
  84     if (options & DNS_QUERY_NO_HOSTS_FILE)
  85         ret |= RES_NOALIASES;
  86     if (options & DNS_QUERY_TREAT_AS_FQDN)
  87         ret &= ~RES_DEFNAMES;
  88
  89     if (options & DNS_QUERY_DONT_RESET_TTL_VALUES)
  90         FIXME( "option DNS_QUERY_DONT_RESET_TTL_VALUES not implemented\n" );
  91     if (options & DNS_QUERY_RESERVED)
  92         FIXME( "option DNS_QUERY_RESERVED not implemented\n" );
  93     if (options & DNS_QUERY_WIRE_ONLY)
  94         FIXME( "option DNS_QUERY_WIRE_ONLY not implemented\n" );
  95     if (options & DNS_QUERY_NO_WIRE_QUERY)
  96         FIXME( "option DNS_QUERY_NO_WIRE_QUERY not implemented\n" );
  97     if (options & DNS_QUERY_BYPASS_CACHE)
  98         FIXME( "option DNS_QUERY_BYPASS_CACHE not implemented\n" );
  99     if (options & DNS_QUERY_RETURN_MESSAGE)
 100         FIXME( "option DNS_QUERY_RETURN_MESSAGE not implemented\n" );
 101
 102     if (options & DNS_QUERY_NO_NETBT)
 103         TRACE( "netbios query disabled\n" );
 104
 105     return ret;
 106 }
 107
 108 static DNS_STATUS map_h_errno( int error )
 109 {
 110     switch (error)
 111     {
 112     case NO_DATA:
 113     case HOST_NOT_FOUND: return DNS_ERROR_RCODE_NAME_ERROR;
 114     case TRY_AGAIN:      return DNS_ERROR_RCODE_SERVER_FAILURE;
 115     case NO_RECOVERY:    return DNS_ERROR_RCODE_REFUSED;
 116 #ifdef NETDB_INTERNAL
 117     case NETDB_INTERNAL: return DNS_ERROR_RCODE;
 118 #endif
 119     default:
 120         FIXME( "unmapped error code: %d\n", error );
 121         return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
 122     }
 123 }
 124
 125 static NTSTATUS resolv_get_searchlist( void *args )
 126 {
 127     const struct get_searchlist_params *params = args;
 128     DNS_TXT_DATAW *list = params->list;
 129     DWORD i, needed, str_needed = 0;
 130     char *ptr, *end;
 131
 132     init_resolver();
 133
 134     for (i = 0; i < MAXDNSRCH + 1 && _res.dnsrch[i]; i++)
 135         str_needed += (strlen(_res.dnsrch[i]) + 1) * sizeof(WCHAR);
 136
 137     needed = FIELD_OFFSET(DNS_TXT_DATAW, pStringArray[i]) + str_needed;
 138
 139     if (!list || *params->len < needed)
 140     {
 141         *params->len = needed;
 142         return !list ? ERROR_SUCCESS : ERROR_MORE_DATA;
 143     }
 144
 145     *params->len = needed;
 146     list->dwStringCount = i;
 147
 148     ptr = (char *)(list->pStringArray + i);
 149     end = ptr + str_needed;
 150     for (i = 0; i < MAXDNSRCH + 1 && _res.dnsrch[i]; i++)
 151     {
 152         list->pStringArray[i] = (WCHAR *)ptr;
 153         ptr += ntdll_umbstowcs( _res.dnsrch[i], strlen(_res.dnsrch[i]) + 1,
 154                                 list->pStringArray[i], end - ptr );
 155     }
 156     return ERROR_SUCCESS;
 157 }
 158
 159
 160 static inline int filter( unsigned short sin_family, USHORT family )
 161 {
 162     if (sin_family != AF_INET && sin_family != AF_INET6) return TRUE;
 163     if (sin_family == AF_INET6 && family == WS_AF_INET) return TRUE;
 164     if (sin_family == AF_INET && family == WS_AF_INET6) return TRUE;
 165
 166     return FALSE;
 167 }
 168
 169 #ifdef HAVE_RES_GETSERVERS
 170
 171 static NTSTATUS resolv_get_serverlist( void *args )
 172 {
 173     const struct get_serverlist_params *params = args;
 174     DNS_ADDR_ARRAY *addrs = params->addrs;
 175     struct __res_state *state = &_res;
 176     DWORD i, found, total, needed;
 177     union res_sockaddr_union *buf;
 178
 179     init_resolver();
 180
 181     total = res_getservers( state, NULL, 0 );
 182     if (!total) return DNS_ERROR_NO_DNS_SERVERS;
 183
 184     if (!addrs && params->family != WS_AF_INET && params->family != WS_AF_INET6)
 185     {
 186         *params->len = FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[total]);
 187         return ERROR_SUCCESS;
 188     }
 189
 190     buf = malloc( total * sizeof(union res_sockaddr_union) );
 191     if (!buf) return ERROR_NOT_ENOUGH_MEMORY;
 192
 193     total = res_getservers( state, buf, total );
 194
 195     for (i = 0, found = 0; i < total; i++)
 196     {
 197         if (filter( buf[i].sin.sin_family, params->family )) continue;
 198         found++;
 199     }
 200     if (!found) return DNS_ERROR_NO_DNS_SERVERS;
 201
 202     needed = FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[found]);
 203     if (!addrs || *params->len < needed)
 204     {
 205         *params->len = needed;
 206         return !addrs ? ERROR_SUCCESS : ERROR_MORE_DATA;
 207     }
 208     *params->len = needed;
 209     memset( addrs, 0, needed );
 210     addrs->AddrCount = addrs->MaxCount = found;
 211
 212     for (i = 0, found = 0; i < total; i++)
 213     {
 214         if (filter( buf[i].sin.sin_family, params->family )) continue;
 215
 216         if (buf[i].sin6.sin6_family == AF_INET6)
 217         {
 218             SOCKADDR_IN6 *sa = (SOCKADDR_IN6 *)addrs->AddrArray[found].MaxSa;
 219             sa->sin6_family = WS_AF_INET6;
 220             memcpy( &sa->sin6_addr, &buf[i].sin6.sin6_addr, sizeof(sa->sin6_addr) );
 221             addrs->AddrArray[found].Data.DnsAddrUserDword[0] = sizeof(*sa);
 222         }
 223         else
 224         {
 225             SOCKADDR_IN *sa = (SOCKADDR_IN *)addrs->AddrArray[found].MaxSa;
 226             sa->sin_family = WS_AF_INET;
 227             sa->sin_addr.WS_s_addr = buf[i].sin.sin_addr.s_addr;
 228             addrs->AddrArray[found].Data.DnsAddrUserDword[0] = sizeof(*sa);
 229         }
 230         found++;
 231     }
 232
 233     free( buf );
 234     return ERROR_SUCCESS;
 235 }
 236
 237 #else
 238
 239 static NTSTATUS resolv_get_serverlist( void *args )
 240 {
 241     const struct get_serverlist_params *params = args;
 242     DNS_ADDR_ARRAY *addrs = params->addrs;
 243     DWORD needed, found, i;
 244
 245     init_resolver();
 246
 247     if (!_res.nscount) return DNS_ERROR_NO_DNS_SERVERS;
 248     if (!addrs && params->family != WS_AF_INET && params->family != WS_AF_INET6)
 249     {
 250         *params->len = FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[_res.nscount]);
 251         return ERROR_SUCCESS;
 252     }
 253
 254     for (i = 0, found = 0; i < _res.nscount; i++)
 255     {
 256         unsigned short sin_family = AF_INET;
 257 #ifdef HAVE_STRUCT___RES_STATE__U__EXT_NSCOUNT6
 258         if (_res._u._ext.nsaddrs[i]) sin_family = _res._u._ext.nsaddrs[i]->sin6_family;
 259 #endif
 260         if (filter( sin_family, params->family )) continue;
 261         found++;
 262     }
 263     if (!found) return DNS_ERROR_NO_DNS_SERVERS;
 264
 265     needed = FIELD_OFFSET(DNS_ADDR_ARRAY, AddrArray[found]);
 266     if (!addrs || *params->len < needed)
 267     {
 268         *params->len = needed;
 269         return !addrs ? ERROR_SUCCESS : ERROR_MORE_DATA;
 270     }
 271     *params->len = needed;
 272     memset( addrs, 0, needed );
 273     addrs->AddrCount = addrs->MaxCount = found;
 274
 275     for (i = 0, found = 0; i < _res.nscount; i++)
 276     {
 277         unsigned short sin_family = AF_INET;
 278 #ifdef HAVE_STRUCT___RES_STATE__U__EXT_NSCOUNT6
 279         if (_res._u._ext.nsaddrs[i]) sin_family = _res._u._ext.nsaddrs[i]->sin6_family;
 280 #endif
 281         if (filter( sin_family, params->family )) continue;
 282
 283 #ifdef HAVE_STRUCT___RES_STATE__U__EXT_NSCOUNT6
 284         if (sin_family == AF_INET6)
 285         {
 286             SOCKADDR_IN6 *sa = (SOCKADDR_IN6 *)addrs->AddrArray[found].MaxSa;
 287             sa->sin6_family = WS_AF_INET6;
 288             memcpy( &sa->sin6_addr, &_res._u._ext.nsaddrs[i]->sin6_addr, sizeof(sa->sin6_addr) );
 289             addrs->AddrArray[found].Data.DnsAddrUserDword[0] = sizeof(*sa);
 290         }
 291         else
 292 #endif
 293         {
 294             SOCKADDR_IN *sa = (SOCKADDR_IN *)addrs->AddrArray[found].MaxSa;
 295             sa->sin_family = WS_AF_INET;
 296             sa->sin_addr.WS_s_addr = _res.nsaddr_list[i].sin_addr.s_addr;
 297             addrs->AddrArray[found].Data.DnsAddrUserDword[0] = sizeof(*sa);
 298         }
 299         found++;
 300     }
 301
 302     return ERROR_SUCCESS;
 303 }
 304 #endif
 305
 306 static NTSTATUS resolv_set_serverlist( void *args )
 307 {
 308     const IP4_ARRAY *addrs = args;
 309     int i;
 310
 311     init_resolver();
 312
 313     if (!addrs || !addrs->AddrCount) return ERROR_SUCCESS;
 314     if (addrs->AddrCount > MAXNS)
 315     {
 316         WARN( "too many servers: %d only using the first: %d\n",
 317               (UINT)addrs->AddrCount, MAXNS );
 318         _res.nscount = MAXNS;
 319     }
 320     else _res.nscount = addrs->AddrCount;
 321
 322     for (i = 0; i < _res.nscount; i++)
 323         _res.nsaddr_list[i].sin_addr.s_addr = addrs->AddrArray[i];
 324
 325     return ERROR_SUCCESS;
 326 }
 327
 328 static NTSTATUS resolv_query( void *args )
 329 {
 330     const struct query_params *params = args;
 331     DNS_STATUS ret = ERROR_SUCCESS;
 332     int len;
 333
 334     init_resolver();
 335     _res.options |= map_options( params->options );
 336
 337     if ((len = res_query( params->name, ns_c_in, params->type, params->buf, *params->len )) < 0)
 338         ret = map_h_errno( h_errno );
 339     else
 340         *params->len = len;
 341     return ret;
 342 }
 343
 344 const unixlib_entry_t __wine_unix_call_funcs[] =
 345 {
 346     resolv_get_searchlist,
 347     resolv_get_serverlist,
 348     resolv_set_serverlist,
 349     resolv_query,
 350 };
 351
 352 #ifdef _WIN64
 353
 354 typedef ULONG PTR32;
 355
 356 static NTSTATUS wow64_resolv_get_searchlist( void *args )
 357 {
 358     struct
 359     {
 360         PTR32  list;
 361         PTR32  len;
 362     } const *params32 = args;
 363
 364     struct get_searchlist_params params =
 365     {
 366         ULongToPtr(params32->list),
 367         ULongToPtr(params32->len)
 368     };
 369
 370     return resolv_get_searchlist( &params );
 371 }
 372
 373 static NTSTATUS wow64_resolv_get_serverlist( void *args )
 374 {
 375     struct
 376     {
 377         USHORT family;
 378         PTR32  addrs;
 379         PTR32  len;
 380     } const *params32 = args;
 381
 382     struct get_serverlist_params params =
 383     {
 384         params32->family,
 385         ULongToPtr(params32->addrs),
 386         ULongToPtr(params32->len)
 387     };
 388
 389     return resolv_get_serverlist( &params );
 390 }
 391
 392 static NTSTATUS wow64_resolv_query( void *args )
 393 {
 394     struct
 395     {
 396         PTR32  name;
 397         WORD   type;
 398         DWORD  options;
 399         PTR32  buf;
 400         PTR32  len;
 401     } const *params32 = args;
 402
 403     struct query_params params =
 404     {
 405         ULongToPtr(params32->name),
 406         params32->type,
 407         params32->options,
 408         ULongToPtr(params32->buf),
 409         ULongToPtr(params32->len)
 410     };
 411
 412     return resolv_query( &params );
 413 }
 414
 415 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
 416 {
 417     wow64_resolv_get_searchlist,
 418     wow64_resolv_get_serverlist,
 419     resolv_set_serverlist,
 420     wow64_resolv_query,
 421 };
 422
 423 #endif  /* _WIN64 */
 424
 425 #endif /* HAVE_RESOLV */