src/WINNT/afsd/cm_dns.c

   1 /* Copyright 2000, International Business Machines Corporation and others.
   2  * All Rights Reserved.
   3  *
   4  * This software has been released under the terms of the IBM Public
   5  * License.  For details, see the LICENSE file in the top-level source
   6  * directory or online at http://www.openafs.org/dl/license10.html
   7  */
   8
   9 #ifdef AFS_AFSDB_ENV
  10
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13 #include <afs/cellconfig.h>
  14 #include <windows.h>
  15 #include <winsock2.h>
  16 #include "cm_dns_private.h"
  17 #include "cm_nls.h"
  18 #include "cm_dns.h"
  19 #include <lwp.h>
  20 #include <afs/afsint.h>
  21 #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
  22 #include <windns.h>
  23 #define DNSAPI_ENV
  24 #endif
  25 #include <errno.h>
  26 #include <strsafe.h>
  27
  28 /*extern void afsi_log(char *pattern, ...);*/
  29
  30 static char dns_addr[30];
  31 static int cm_dnsEnabled = -1;
  32
  33 void DNSlowerCase(char *str)
  34 {
  35     unsigned int i;
  36
  37     for (i=0; i<strlen(str); i++)
  38         /*str[i] = tolower(str[i]);*/
  39         if (str[i] >= 'A' && str[i] <= 'Z')
  40             str[i] += 'a' - 'A';
  41 }
  42
  43 int cm_InitDNS(int enabled)
  44 {
  45 #ifndef DNSAPI_ENV
  46     char configpath[100];
  47     int len;
  48     int code;
  49     char *addr;
  50
  51     if (!enabled) {
  52         fprintf(stderr, "DNS support disabled\n");
  53         cm_dnsEnabled = 0;
  54         return 0;
  55     }
  56
  57     /* First try AFS_NS environment var. */
  58     addr = getenv("AFS_NS");
  59     if (addr && inet_addr(addr) != -1) {
  60         strcpy(dns_addr, addr);
  61     } else {
  62         /* Now check for the AFSDNS.INI file */
  63         code = GetWindowsDirectory(configpath, sizeof(configpath));
  64         if (code == 0 || code > sizeof(configpath)) return -1;
  65         strcat(configpath, "\\afsdns.ini");
  66
  67         /* Currently we only get (and query) the first nameserver.  Getting
  68         list of mult. nameservers should be easy to do. */
  69         len = GetPrivateProfileString("AFS Domain Name Servers", "ns1", NULL,
  70                                        dns_addr, sizeof(dns_addr),
  71                                        configpath);
  72
  73         if (len == 0 || inet_addr(dns_addr) == -1) {
  74             fprintf(stderr, "No valid name server addresses found, DNS lookup is "
  75                      "disabled\n");
  76             cm_dnsEnabled = 0;  /* failed */
  77             return -1;     /* No name servers defined */
  78         }
  79         else
  80             fprintf(stderr, "Found DNS server %s\n", dns_addr);
  81     }
  82 #endif /* DNSAPI_ENV */
  83     cm_dnsEnabled = 1;
  84     return 0;
  85 }
  86
  87 #ifndef DNSAPI_ENV
  88 SOCKADDR_IN setSockAddr(char *server, int port)
  89 {
  90   SOCKADDR_IN sockAddr;
  91   int         addrLen = sizeof(SOCKADDR_IN);
  92
  93 #ifndef WIN32_LEAN_AND_MEAN
  94   bzero(&sockAddr,addrLen);
  95 #endif /*WIN32_LEAN_AND_MEAN*/
  96   sockAddr.sin_family   = AF_INET;
  97   sockAddr.sin_port     = htons( port );
  98   sockAddr.sin_addr.s_addr = inet_addr( server );
  99   /*inet_aton(server, &sockAddr.sin_addr.s_addr);*/
 100
 101   return (sockAddr);
 102 }
 103
 104 int getRRCount(PDNS_HDR ptr)
 105 {
 106   return(ntohs(ptr->rr_count));
 107 }
 108
 109
 110 int send_DNS_Addr_Query(char* query,
 111                          SOCKET commSock, SOCKADDR_IN sockAddr, char *buffer)
 112 {
 113   PDNS_HDR    pDNShdr;
 114   PDNS_QTAIL  pDNS_qtail;
 115
 116   int     queryLen = 0;
 117   int     res;
 118
 119 #ifndef WIN32_LEAN_AND_MEAN
 120   bzero(buffer,BUFSIZE);
 121 #endif /*WIN32_LEAN_AND_MEAN*/
 122
 123   /*********************************
 124    * Build DNS Query Message       *
 125    *                               *
 126    * hard-coded Adrress (A) query  *
 127    *********************************/
 128
 129   pDNShdr = (PDNS_HDR)&( buffer[ 0 ] );
 130   pDNShdr->id         = htons( 0xDADE );
 131   pDNShdr->flags      = htons( DNS_FLAG_RD ); /* do recurse */
 132   pDNShdr->q_count    = htons( 1 );           /* one query */
 133   pDNShdr->rr_count   = 0;                    /* none in query */
 134   pDNShdr->auth_count = 0;                    /* none in query */
 135   pDNShdr->add_count  = 0;                    /* none in query */
 136
 137   queryLen = putQName( query, &(buffer[ DNS_HDR_LEN ] ) );
 138   queryLen += DNS_HDR_LEN; /* query Length is just after the query name and header */
 139 #ifdef DEBUG
 140   fprintf(stderr, "send_DNS_Addr: query=%s, queryLen=%d\n", query, queryLen);
 141 #endif
 142
 143
 144   pDNS_qtail = (PDNS_QTAIL) &(buffer[ queryLen ]);
 145   pDNS_qtail->qtype = htons(255);/*htons(DNS_RRTYPE_A); */
 146   pDNS_qtail->qclass = htons(DNS_RRCLASS_IN);
 147   queryLen +=  DNS_QTAIL_LEN;
 148
 149   /**************************
 150    * Send DNS Query Message *
 151    **************************/
 152
 153
 154   res = sendto( commSock,
 155                 buffer,
 156                 queryLen,
 157                 0,
 158                 (struct sockaddr *) &sockAddr,
 159                 sizeof( SOCKADDR_IN ) );
 160
 161   /*dumpSbuffer(buffer,queryLen);*/
 162
 163   if ( res < 0 )
 164     {
 165 #ifdef DEBUG
 166       fprintf(stderr, "send_DNS_Addr_Query: error %d, errno %d\n", res, errno);
 167       fprintf(stderr, "sendto() failed \n");
 168 #endif
 169       return ( -1 );
 170     }
 171   else
 172     {
 173     /*printf( "sendto() succeeded\n");*/
 174     ;
 175     } /* end if */
 176
 177   return(0);
 178 }
 179
 180
 181 int send_DNS_AFSDB_Query(char* query,
 182                          SOCKET commSock, SOCKADDR_IN sockAddr, char *buffer)
 183 {
 184   /*static char buffer[BUFSIZE];*/
 185
 186   PDNS_HDR    pDNShdr;
 187   PDNS_QTAIL  pDNS_qtail;
 188
 189   int     queryLen = 0;
 190   int     res;
 191
 192 #ifndef WIN32_LEAN_AND_MEAN
 193   bzero(buffer,BUFSIZE);
 194 #endif /*WIN32_LEAN_AND_MEAN*/
 195
 196   /***************************
 197    * Build DNS Query Message *
 198    *                         *
 199    * hard-coded AFSDB query  *
 200    ***************************/
 201
 202   pDNShdr = (PDNS_HDR)&( buffer[ 0 ] );
 203   pDNShdr->id         = htons( 0xDEAD );
 204   pDNShdr->flags      = htons( DNS_FLAG_RD ); /* do recurse */
 205   pDNShdr->q_count    = htons( 1 );           /* one query */
 206   pDNShdr->rr_count   = 0;                    /* none in query */
 207   pDNShdr->auth_count = 0;                    /* none in query */
 208   pDNShdr->add_count  = 0;                    /* none in query */
 209
 210   queryLen = putQName( query, &(buffer[ DNS_HDR_LEN ] ) );
 211   queryLen += DNS_HDR_LEN; /* query Length is just after the query name and header */
 212
 213
 214   pDNS_qtail = (PDNS_QTAIL) &(buffer[ queryLen ]);
 215   pDNS_qtail->qtype = htons(DNS_RRTYPE_AFSDB);
 216   pDNS_qtail->qclass = htons(DNS_RRCLASS_IN);
 217   queryLen +=  DNS_QTAIL_LEN;
 218
 219   /**************************
 220    * Send DNS Query Message *
 221    **************************/
 222
 223   res = sendto( commSock,
 224                 buffer,
 225                 queryLen,
 226                 0,
 227                 (struct sockaddr *) &sockAddr,
 228                 sizeof( SOCKADDR_IN ) );
 229
 230   /*dumpSbuffer(buffer,queryLen);*/
 231
 232   if ( res < 0 )
 233     {
 234 #ifdef DEBUG
 235       fprintf(stderr, "send_DNS_AFSDB_Query: error %d, errno %d\n", res, errno);
 236       fprintf(stderr,  "sendto() failed \n");
 237 #endif /* DEBUG */
 238       return ( -1 );
 239     }
 240   else
 241     {
 242     /*printf( "sendto() succeeded\n");*/
 243     ;
 244     } /* end if */
 245
 246   return(0);
 247 }
 248
 249
 250 PDNS_HDR get_DNS_Response(SOCKET commSock, SOCKADDR_IN sockAddr, char *buffer)
 251 {
 252   /*static char buffer[BUFSIZE];*/
 253
 254   int         addrLen = sizeof(SOCKADDR_IN);
 255   int size;
 256
 257 #ifndef WIN32_LEAN_AND_MEAN
 258   bzero(buffer,BUFSIZE);
 259 #endif /*WIN32_LEAN_AND_MEAN*/
 260
 261   /*****************************
 262    * Receive DNS Reply Message *
 263    *****************************/
 264
 265   /*printf( "calling recvfrom() on connected UDP socket\n" );*/
 266
 267   size = recvfrom( commSock,
 268                   buffer,
 269                   BUFSIZE,
 270                   0,
 271                   (struct sockaddr *) &sockAddr,
 272                   &addrLen );
 273   if (size < 0) { fprintf(stderr, "recvfrom error %d\n", errno); return NULL; }
 274
 275   /*dumpRbuffer(buffer,res);*/
 276
 277 #ifdef DEBUG
 278   fprintf(stderr, "recvfrom returned %d bytes from %s: \n",
 279           size, inet_ntoa( sockAddr.sin_addr ) );
 280 #endif /* DEBUG */
 281
 282   return((PDNS_HDR)&( buffer[ 0 ] ));
 283
 284 }
 285
 286
 287 int putQName( char *pHostName, char *pQName )
 288 {
 289   int     i;
 290   char    c;
 291   int     j = 0;
 292   int     k = 0;
 293
 294   DNSlowerCase(pHostName);
 295   /*printf( "Hostname: [%s]\n", pHostName );*/
 296
 297   for ( i = 0; *( pHostName + i ); i++ )
 298     {
 299       c = *( pHostName + i );   /* get next character */
 300
 301
 302       if ( c == '.' )
 303         {
 304           /* dot encountered, fill in previous length */
 305           if (k!=0){ /*don't process repeated dots*/
 306           /*printf( "%c", c );*/
 307             *( pQName + j ) = k;
 308             j = j+k+1;  /* set index to next counter */
 309             k = 0;      /* reset segment length */
 310           }
 311         }
 312       else
 313         {
 314         /*printf( "%c", c );*/
 315           *( pQName + j + k + 1 ) = c;  /* assign to QName */
 316           k++;                /* inc count of seg chars */
 317         } /* end if */
 318     } /* end for loop */
 319
 320   *(pQName + j )                  = k;   /* count for final segment */
 321
 322   *(pQName + j + k + 1 )      = 0;   /* count for trailing NULL segment is 0 */
 323
 324   /*printf( "\n" ); */
 325
 326   if (c == '.')
 327     return ( j + k + 1 );        /* return total length of QName */
 328   else
 329     return ( j + k + 2 );
 330 } /* end putQName() */
 331
 332
 333 u_char * skipRRQName(u_char *pQName)
 334 {
 335   u_char *ptr;
 336   u_char c;
 337
 338   ptr = pQName;
 339   c = *ptr;
 340   while (c) {
 341     if ( c >= 0xC0 ) {
 342     /* skip the 'compression' pointer */
 343       ptr = ptr+1;
 344       c = '\0';
 345     } else {
 346       /* skip a normal qname segment */
 347       ptr += *ptr;
 348       ptr++;
 349       c = *ptr;
 350     };
 351   };
 352
 353   /* ptr now pointing at terminating zero of query QName,
 354      or the pointer for the previous occurrence
 355      (compression)
 356    */
 357   ptr++;
 358
 359   return (ptr);
 360 } /* end skipRRQName() */
 361
 362
 363
 364 u_char * printRRQName( u_char *pQName, PDNS_HDR buffer )
 365 {
 366   u_short i, k;
 367   u_char *buffPtr = (u_char *) buffer;
 368   u_char *namePtr;
 369   u_char *retPtr;
 370   u_char c;
 371
 372
 373   namePtr = pQName;
 374   retPtr = 0;
 375
 376   for ( i = 0; i < BUFSIZE; i++ )
 377     {
 378       c = *namePtr;
 379       if ( c >= 0xC0 ) {
 380         c = *(namePtr + 1);
 381         retPtr = namePtr+2;
 382         namePtr = buffPtr+c;
 383       } else {
 384         if ( c == 0 )
 385           break;
 386
 387         for ( k = 1; k <= c; k++ )
 388           {
 389             fprintf(stderr, "%c", *( namePtr + k ) );
 390           } /* end for loop */
 391         fprintf(stderr,".");
 392         namePtr += k;
 393       }
 394     } /* end for loop */
 395   fprintf(stderr,"\n");
 396   namePtr++; /* skip terminating zero */
 397
 398   if (retPtr)
 399     return(retPtr);
 400   else
 401     return(namePtr);
 402
 403 } /* end printRRQName() */
 404
 405
 406 u_char * sPrintRRQName( u_char *pQName, PDNS_HDR buffer, char *str )
 407 {
 408   u_short i, k;
 409   u_char *buffPtr = (u_char *) buffer;
 410   u_char *namePtr;
 411   u_char *retPtr;
 412   u_char c;
 413
 414   char   section[64];
 415
 416   strcpy(str,"");
 417   namePtr = pQName;
 418   retPtr = 0;
 419
 420   for ( i = 0; i < BUFSIZE; i++ )
 421     {
 422       c = *namePtr;
 423       if ( c >= 0xC0 ) {
 424         c = *(namePtr + 1);
 425         retPtr = namePtr+2;
 426         namePtr = buffPtr+c;
 427       } else {
 428         if ( c == 0 )
 429           break;
 430
 431         for ( k = 1; k <= c; k++ )
 432           {
 433             sprintf(section,"%c", *( namePtr + k ) );
 434             strcat(str,section);
 435           } /* end for loop */
 436         strcat(str,".");
 437         namePtr += k;
 438       }
 439     } /* end for loop */
 440   namePtr++; /* skip terminating zero */
 441
 442   if (retPtr)
 443     return(retPtr);
 444   else
 445     return(namePtr);
 446
 447 } /* end sPrintRRQName() */
 448
 449
 450 void printReplyBuffer_AFSDB(PDNS_HDR replyBuff)
 451 {
 452   u_char *ptr = (u_char *) replyBuff;
 453   int    answerCount = ntohs((replyBuff)->rr_count);
 454   u_char i;
 455   PDNS_AFSDB_RR_HDR
 456          rrPtr;
 457
 458   ptr += DNS_HDR_LEN;
 459
 460   /* ptr now pointing at start of QName in query field */
 461   ptr = skipRRQName(ptr);
 462
 463
 464   /* skip the query type and class fields */
 465   ptr+= DNS_QTAIL_LEN;
 466
 467   /* ptr should now be at the start of the answer RR sections */
 468
 469   fprintf(stderr,"---------------------------------\n");
 470   for (i=0; i<answerCount ; i++){
 471     ptr = skipRRQName(ptr);
 472     rrPtr = (PDNS_AFSDB_RR_HDR) ptr;
 473     ptr+= DNS_AFSDB_RR_HDR_LEN;
 474     if ( ntohs(rrPtr->rr_afsdb_class) == 1) {
 475       fprintf(stderr,"AFDB class %d ->  ",ntohs(rrPtr->rr_afsdb_class));
 476       ptr = printRRQName(ptr,replyBuff); }
 477     else
 478       ptr = skipRRQName(ptr);
 479   };
 480   fprintf(stderr,"---------------------------------\n");
 481
 482
 483 };
 484
 485 void processReplyBuffer_AFSDB(SOCKET commSock, PDNS_HDR replyBuff, int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS],
 486                               unsigned short ipRanks[], int *numServers, int *ttl)
 487   /*PAFS_SRV_LIST (srvList)*/
 488 {
 489   u_char *ptr = (u_char *) replyBuff;
 490   int    answerCount = ntohs((replyBuff)->rr_count);
 491   u_char i;
 492   PDNS_AFSDB_RR_HDR
 493          rrPtr;
 494   int srvCount = 0;
 495   char hostName[256];
 496   struct in_addr addr;
 497   int rc;
 498
 499   ptr += DNS_HDR_LEN;
 500
 501   /* ptr now pointing at start of QName in query field */
 502   ptr = skipRRQName(ptr);
 503
 504
 505   /* skip the query type and class fields */
 506   ptr+= DNS_QTAIL_LEN;
 507
 508   /* ptr should now be at the start of the answer RR sections */
 509
 510   answerCount = MIN(answerCount, AFSMAXCELLHOSTS);
 511 #ifdef DEBUG
 512   fprintf(stderr, "processRep_AFSDB: answerCount=%d\n", answerCount);
 513 #endif /* DEBUG */
 514
 515   for (i=0; i<answerCount ; i++){
 516     ptr = skipRRQName(ptr);
 517     rrPtr = (PDNS_AFSDB_RR_HDR) ptr;
 518     ptr+= DNS_AFSDB_RR_HDR_LEN;
 519     if ((ntohs(rrPtr->rr_afsdb_class) == 1) &&
 520         (srvCount < MAX_AFS_SRVS)) {
 521       /*ptr = sPrintRRQName(ptr,replyBuff,srvList->host[srvList->count]);*/
 522       ptr = sPrintRRQName(ptr,replyBuff,hostName);
 523       /*ptr = printRRQName(ptr,replyBuff);*/
 524       *ttl = ntohl(rrPtr->rr_ttl);
 525
 526 #ifdef DEBUG
 527       fprintf(stderr, "resolving name %s\n", hostName);
 528 #endif
 529       /* resolve name from DNS query */
 530       rc = DNSgetAddr(commSock, hostName, &addr);
 531       if (rc < 0)
 532         continue;  /* skip this entry */
 533 #ifdef DEBUG
 534       fprintf(stderr, "processRep_AFSDB: resolved name %s to addr %x\n", hostName, addr);
 535 #endif /* DEBUG */
 536       memcpy(&cellHostAddrs[srvCount], &addr.s_addr, sizeof(addr.s_addr));
 537           strncpy(cellHostNames[srvCount], hostName, CELL_MAXNAMELEN);
 538           cellHostNames[srvCount][CELL_MAXNAMELEN-1] = '\0';
 539       ipRanks[srvCount] = 0;
 540       srvCount++;
 541     }
 542     else {
 543       ptr = skipRRQName(ptr);
 544     }
 545   }
 546
 547   *numServers = srvCount;
 548
 549 }
 550
 551
 552 u_char * processReplyBuffer_Addr(PDNS_HDR replyBuff)
 553 {
 554   u_char *ptr = (u_char *) replyBuff;
 555   int    answerCount = ntohs((replyBuff)->rr_count);
 556   PDNS_A_RR_HDR
 557          rrPtr;
 558
 559 #ifdef DEBUG
 560   fprintf(stderr, "processReplyBuffer_Addr: answerCount=%d\n", answerCount);
 561 #endif /* DEBUG */
 562   if (answerCount == 0) return 0;
 563
 564   ptr += DNS_HDR_LEN;
 565
 566   /* ptr now pointing at start of QName in query field */
 567   ptr = skipRRQName(ptr);
 568
 569
 570   /* skip the query type and class fields */
 571   ptr+= DNS_QTAIL_LEN;
 572
 573   /* ptr should now be at the start of the answer RR sections */
 574   ptr = skipRRQName(ptr);
 575   rrPtr = (PDNS_A_RR_HDR) ptr;
 576
 577 #ifdef DEBUG
 578   fprintf(stderr, "type:%d, class:%d, ttl:%d, rdlength:%d\n",
 579          ntohs(rrPtr->rr_type),ntohs(rrPtr->rr_class),
 580          ntohl(rrPtr->rr_ttl),ntohs(rrPtr->rr_rdlength));
 581   fprintf(stderr, "Count %d\tand Answer %8x\n",answerCount,rrPtr->rr_addr);
 582 #endif /* DEBUG */
 583
 584   ptr += DNS_A_RR_HDR_LEN;
 585
 586   return (ptr);
 587
 588 };
 589
 590 int DNSgetAddr(SOCKET commSock, char *hostName, struct in_addr *iNet)
 591 {
 592   /* Variables for DNS message parsing and creation */
 593   PDNS_HDR  pDNShdr;
 594
 595   SOCKADDR_IN sockAddr;
 596   char buffer[BUFSIZE];
 597   u_char *addr;
 598   u_long *aPtr;
 599   int rc;
 600
 601   /**********************
 602    * Get a DGRAM socket *
 603    **********************/
 604
 605   sockAddr = setSockAddr(dns_addr, DNS_PORT);
 606
 607   rc = send_DNS_Addr_Query(hostName,commSock,sockAddr, buffer);
 608   if (rc < 0) return rc;
 609   pDNShdr = get_DNS_Response(commSock,sockAddr, buffer);
 610   if (pDNShdr == NULL)
 611     return -1;
 612
 613   addr = processReplyBuffer_Addr(pDNShdr);
 614   if (addr == 0)
 615     return -1;
 616
 617   aPtr = (u_long *) addr;
 618
 619   iNet->s_addr = *aPtr;
 620
 621   return(0);
 622 }
 623 #endif /* DNSAPI_ENV */
 624
 625 int getAFSServer(char *cellName, int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS],
 626                  unsigned short ipRanks[], int *numServers, int *ttl)
 627 {
 628 #ifndef DNSAPI_ENV
 629     SOCKET commSock;
 630     SOCKADDR_IN sockAddr;
 631     PDNS_HDR  pDNShdr;
 632     char buffer[BUFSIZE];
 633     char query[1024];
 634     int rc;
 635
 636 #ifdef DEBUG
 637     fprintf(stderr, "getAFSServer: cell %s, cm_dnsEnabled=%d\n", cellName, cm_dnsEnabled);
 638 #endif
 639
 640 #if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
 641     if (cm_dnsEnabled == -1) { /* not yet initialized, eg when called by klog */
 642         cm_InitDNS(1);         /* assume enabled */
 643     }
 644 #endif
 645     if (cm_dnsEnabled == 0) {  /* possibly we failed in cm_InitDNS above */
 646         fprintf(stderr, "DNS initialization failed, disabled\n");
 647         *numServers = 0;
 648         return -1;
 649     }
 650
 651     sockAddr = setSockAddr(dns_addr, DNS_PORT);
 652
 653     commSock = socket( AF_INET, SOCK_DGRAM, 0 );
 654     if ( commSock < 0 )
 655     {
 656         /*afsi_log("socket() failed\n");*/
 657         fprintf(stderr, "getAFSServer: socket() failed, errno=%d\n", errno);
 658         *numServers = 0;
 659         return (-1);
 660     }
 661
 662     StringCbCopyA(query, sizeof(query), cellName);
 663     if (query[strlen(query)-1] != '.') {
 664         StringCbCatA(query, sizeof(query), ".");
 665     }
 666
 667     rc = send_DNS_AFSDB_Query(cellName,commSock,sockAddr, buffer);
 668     if (rc < 0) {
 669         closesocket(commSock);
 670         fprintf(stderr,"getAFSServer: send_DNS_AFSDB_Query failed\n");
 671         *numServers = 0;
 672         return -1;
 673     }
 674
 675     pDNShdr = get_DNS_Response(commSock,sockAddr, buffer);
 676
 677     /*printReplyBuffer_AFSDB(pDNShdr);*/
 678     if (pDNShdr)
 679         processReplyBuffer_AFSDB(commSock, pDNShdr, cellHostAddrs, cellHostNames, ipRanks, numServers, ttl);
 680     else
 681         *numServers = 0;
 682
 683     closesocket(commSock);
 684     if (*numServers == 0)
 685         return(-1);
 686     else
 687         return 0;
 688 #else /* DNSAPI_ENV */
 689     PDNS_RECORD pDnsCell, pDnsIter, pDnsVol, pDnsVolIter, pDnsCIter;
 690     int i;
 691     struct sockaddr_in vlSockAddr;
 692     char query[1024];
 693
 694 #ifdef AFS_FREELANCE_CLIENT
 695     if ( cm_stricmp_utf8N(cellName, "Freelance.Local.Root") == 0 )
 696         return -1;
 697 #endif /* AFS_FREELANCE_CLIENT */
 698
 699     *numServers = 0;
 700     *ttl = 0;
 701
 702     /* query the AFSDB records of cell */
 703     StringCbCopyA(query, sizeof(query), cellName);
 704     if (query[strlen(query)-1] != '.') {
 705         StringCbCatA(query, sizeof(query), ".");
 706     }
 707
 708     if (DnsQuery_A(query, DNS_TYPE_AFSDB, DNS_QUERY_STANDARD, NULL, &pDnsCell, NULL) == ERROR_SUCCESS) {
 709         memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
 710
 711         /* go through the returned records */
 712         for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) {
 713             /* if we find an AFSDB record with Preference set to 1, we found a afs3-vlserver */
 714             if (pDnsIter->wType == DNS_TYPE_AFSDB && pDnsIter->Data.Afsdb.wPreference == 1) {
 715                 StringCbCopyA(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]),
 716                               pDnsIter->Data.Afsdb.pNameExchange);
 717                 ipRanks[*numServers] = 0;
 718                 (*numServers)++;
 719
 720                 if (!*ttl)
 721                     *ttl = pDnsIter->dwTtl;
 722                 if (*numServers == AFSMAXCELLHOSTS)
 723                     break;
 724             }
 725         }
 726
 727         for (i=0;i<*numServers;i++)
 728             cellHostAddrs[i] = 0;
 729
 730         /* now check if there are any A records in the results */
 731         for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 732             if(pDnsIter->wType == DNS_TYPE_A)
 733                 /* check if its for one of the afs3-vlservers */
 734                 for (i=0;i<*numServers;i++)
 735                     if(cm_stricmp_utf8(pDnsIter->pName, cellHostNames[i]) == 0)
 736                         cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
 737         }
 738
 739         for (i=0;i<*numServers;i++) {
 740             /* if we don't have an IP yet, then we should try resolving the afs3-vlserver hostname
 741             in a separate query. */
 742             if (!cellHostAddrs[i]) {
 743                 if (DnsQuery_A(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL, &pDnsVol, NULL) == ERROR_SUCCESS) {
 744                     for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
 745                         /* if we get an A record, keep it */
 746                         if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) {
 747                             cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
 748                             break;
 749                         }
 750                         /* if we get a CNAME, look for a corresponding A record */
 751                         if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) {
 752                             for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
 753                                 if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf8(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
 754                                     cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
 755                                     break;
 756                                 }
 757                             }
 758                             if (cellHostAddrs[i])
 759                                 break;
 760                             /* TODO: if the additional section is missing, then do another lookup for the CNAME */
 761                         }
 762                     }
 763                     /* we are done with the afs3-vlserver lookup */
 764                     DnsRecordListFree(pDnsVol, DnsFreeRecordListDeep);
 765                 }
 766             }
 767         }
 768         DnsRecordListFree(pDnsCell, DnsFreeRecordListDeep);
 769     }
 770     else {
 771         /* query the SRV _afs3-vlserver._udp records of cell */
 772         StringCbPrintf(query, sizeof(query), "_afs3-vlserver._udp.%s", cellName);
 773         if (query[strlen(query)-1] != '.') {
 774             StringCbCatA(query, sizeof(query), ".");
 775         }
 776
 777         if (DnsQuery_A(query, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &pDnsCell, NULL) == ERROR_SUCCESS) {
 778             memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
 779
 780             /* go through the returned records */
 781             for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) {
 782                 /* if we find an SRV record, we found a afs3-vlserver */
 783                 if (pDnsIter->wType == DNS_TYPE_SRV) {
 784                     StringCbCopyA(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]),
 785                                    pDnsIter->Data.SRV.pNameTarget);
 786                     ipRanks[*numServers] = pDnsIter->Data.SRV.wPriority;
 787                     (*numServers)++;
 788
 789                     if (!*ttl)
 790                         *ttl = pDnsIter->dwTtl;
 791                     if (*numServers == AFSMAXCELLHOSTS)
 792                         break;
 793                 }
 794             }
 795
 796             for (i=0;i<*numServers;i++)
 797                 cellHostAddrs[i] = 0;
 798
 799             /* now check if there are any A records in the results */
 800             for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 801                 if(pDnsIter->wType == DNS_TYPE_A)
 802                     /* check if its for one of the afs3-vlservers */
 803                     for (i=0;i<*numServers;i++)
 804                         if(cm_stricmp_utf8(pDnsIter->pName, cellHostNames[i]) == 0)
 805                             cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
 806             }
 807
 808             for (i=0;i<*numServers;i++) {
 809                 /* if we don't have an IP yet, then we should try resolving the afs3-vlserver hostname
 810                 in a separate query. */
 811                 if (!cellHostAddrs[i]) {
 812                     if (DnsQuery_A(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL, &pDnsVol, NULL) == ERROR_SUCCESS) {
 813                         for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
 814                             /* if we get an A record, keep it */
 815                             if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) {
 816                                 cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
 817                                 break;
 818                             }
 819                             /* if we get a CNAME, look for a corresponding A record */
 820                             if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) {
 821                                 for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
 822                                     if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf8(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
 823                                         cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
 824                                         break;
 825                                     }
 826                                 }
 827                                 if (cellHostAddrs[i])
 828                                     break;
 829                                 /* TODO: if the additional section is missing, then do another lookup for the CNAME */
 830                             }
 831                         }
 832                         /* we are done with the afs3-vlserver lookup */
 833                         DnsRecordListFree(pDnsVol, DnsFreeRecordListDeep);
 834                     }
 835                 }
 836             }
 837             DnsRecordListFree(pDnsCell, DnsFreeRecordListDeep);
 838         }
 839     }
 840
 841     if ( *numServers > 0 )
 842         return 0;
 843     else
 844         return -1;
 845 #endif /* DNSAPI_ENV */
 846 }
 847
 848 int getAFSServerW(cm_unichar_t *cellName, int *cellHostAddrs,
 849                   cm_unichar_t cellHostNames[][MAXHOSTCHARS],
 850                   unsigned short ipRanks[],
 851                   int *numServers, int *ttl)
 852 {
 853 #ifdef DNSAPI_ENV
 854     PDNS_RECORDW pDnsCell, pDnsIter, pDnsVol,pDnsVolIter, pDnsCIter;
 855     int i;
 856     struct sockaddr_in vlSockAddr;
 857     cm_unichar_t query[1024];
 858
 859 #ifdef AFS_FREELANCE_CLIENT
 860     if ( cm_stricmp_utf16(cellName, L"Freelance.Local.Root") == 0 )
 861         return -1;
 862 #endif /* AFS_FREELANCE_CLIENT */
 863
 864     *numServers = 0;
 865     *ttl = 0;
 866
 867     /* query the AFSDB records of cell */
 868     StringCbCopyW(query, sizeof(query), cellName);
 869     if (query[wcslen(query)-1] != L'.') {
 870         StringCbCatW(query, sizeof(query), L".");
 871     }
 872
 873     if (DnsQuery_W(query, DNS_TYPE_AFSDB, DNS_QUERY_STANDARD, NULL, (PDNS_RECORD *) &pDnsCell,
 874                    NULL) == ERROR_SUCCESS) {
 875         memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
 876
 877         /* go through the returned records */
 878         for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) {
 879             /* if we find an AFSDB record with Preference set to 1, we found a afs3-vlserver */
 880             if (pDnsIter->wType == DNS_TYPE_AFSDB && pDnsIter->Data.Afsdb.wPreference == 1) {
 881                 StringCbCopyW(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]),
 882                               pDnsIter->Data.Afsdb.pNameExchange);
 883                 ipRanks[*numServers] = 0;
 884                 (*numServers)++;
 885
 886                 if (!*ttl)
 887                     *ttl = pDnsIter->dwTtl;
 888                 if (*numServers == AFSMAXCELLHOSTS)
 889                     break;
 890             }
 891         }
 892
 893         for (i=0;i<*numServers;i++)
 894             cellHostAddrs[i] = 0;
 895
 896         /* now check if there are any A records in the results */
 897         for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 898             if(pDnsIter->wType == DNS_TYPE_A)
 899                 /* check if its for one of the afs3-vlservers */
 900                 for (i=0;i<*numServers;i++)
 901                     if(cm_stricmp_utf16(pDnsIter->pName, cellHostNames[i]) == 0)
 902                         cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
 903         }
 904
 905         for (i=0;i<*numServers;i++) {
 906             /* if we don't have an IP yet, then we should try resolving the afs3-vlserver hostname
 907                in a separate query. */
 908             if (!cellHostAddrs[i]) {
 909                 if (DnsQuery_W(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL,
 910                                (PDNS_RECORD *) &pDnsVol, NULL) == ERROR_SUCCESS) {
 911                     for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
 912                         /* if we get an A record, keep it */
 913                         if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf16(cellHostNames[i], pDnsVolIter->pName)==0) {
 914                             cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
 915                             break;
 916                         }
 917                         /* if we get a CNAME, look for a corresponding A record */
 918                         if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf16(cellHostNames[i], pDnsVolIter->pName)==0) {
 919                             for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
 920                                 if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf16(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
 921                                     cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
 922                                     break;
 923                                 }
 924                             }
 925                             if (cellHostAddrs[i])
 926                                 break;
 927                             /* TODO: if the additional section is missing, then do another lookup for the CNAME */
 928                         }
 929                     }
 930                     /* we are done with the afs3-vlserver lookup */
 931                     DnsRecordListFree((PDNS_RECORD) pDnsVol, DnsFreeRecordListDeep);
 932                 }
 933             }
 934         }
 935         DnsRecordListFree((PDNS_RECORD) pDnsCell, DnsFreeRecordListDeep);
 936     }
 937     else {
 938         /* query the SRV _afs3-vlserver._udp records of cell */
 939         StringCbPrintfW(query, sizeof(query), L"_afs3-vlserver._udp.%S", cellName);
 940         if (query[wcslen(query)-1] != L'.') {
 941             StringCbCatW(query, sizeof(query), L".");
 942         }
 943
 944         if (DnsQuery_W(query, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, (PDNS_RECORD *) &pDnsCell,
 945                         NULL) == ERROR_SUCCESS) {
 946             memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
 947
 948             /* go through the returned records */
 949             for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 950                 /* if we find an SRV record, we found a afs3-vlserver */
 951                 if (pDnsIter->wType == DNS_TYPE_SRV) {
 952                     StringCbCopyW(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]),
 953                                    pDnsIter->Data.SRV.pNameTarget);
 954                     ipRanks[*numServers] = pDnsIter->Data.SRV.wPriority;
 955                     (*numServers)++;
 956
 957                     if (!*ttl)
 958                         *ttl = pDnsIter->dwTtl;
 959                     if (*numServers == AFSMAXCELLHOSTS)
 960                         break;
 961                 }
 962             }
 963
 964             for (i=0;i<*numServers;i++)
 965                 cellHostAddrs[i] = 0;
 966
 967             /* now check if there are any A records in the results */
 968             for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 969                 if(pDnsIter->wType == DNS_TYPE_A)
 970                     /* check if its for one of the afs3-vlservers */
 971                     for (i=0;i<*numServers;i++)
 972                         if(cm_stricmp_utf16(pDnsIter->pName, cellHostNames[i]) == 0)
 973                             cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
 974             }
 975
 976             for (i=0;i<*numServers;i++) {
 977                 /* if we don't have an IP yet, then we should try resolving the afs3-vlserver hostname
 978                 in a separate query. */
 979                 if (!cellHostAddrs[i]) {
 980                     if (DnsQuery_W(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL,
 981                                     (PDNS_RECORD *) &pDnsVol, NULL) == ERROR_SUCCESS) {
 982                         for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
 983                             /* if we get an A record, keep it */
 984                             if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf16(cellHostNames[i], pDnsVolIter->pName)==0) {
 985                                 cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
 986                                 break;
 987                             }
 988                             /* if we get a CNAME, look for a corresponding A record */
 989                             if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf16(cellHostNames[i], pDnsVolIter->pName)==0) {
 990                                 for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
 991                                     if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf16(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
 992                                         cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
 993                                         break;
 994                                     }
 995                                 }
 996                                 if (cellHostAddrs[i])
 997                                     break;
 998                                 /* TODO: if the additional section is missing, then do another lookup for the CNAME */
 999                             }
1000                         }
1001                         /* we are done with the afs3-vlserver lookup */
1002                         DnsRecordListFree((PDNS_RECORD) pDnsVol, DnsFreeRecordListDeep);
1003                     }
1004                 }
1005             }
1006             DnsRecordListFree((PDNS_RECORD) pDnsCell, DnsFreeRecordListDeep);
1007         }
1008     }
1009
1010     if ( *numServers > 0 )
1011         return 0;
1012     else
1013 #endif  /* DNSAPI_ENV */
1014         return -1;
1015 }
1016 #endif /* AFS_AFSDB_ENV */
1017