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], int *numServers, int *ttl)
 486   /*PAFS_SRV_LIST (srvList)*/
 487 {
 488   u_char *ptr = (u_char *) replyBuff;
 489   int    answerCount = ntohs((replyBuff)->rr_count);
 490   u_char i;
 491   PDNS_AFSDB_RR_HDR
 492          rrPtr;
 493   int srvCount = 0;
 494   char hostName[256];
 495   struct in_addr addr;
 496   int rc;
 497
 498   ptr += DNS_HDR_LEN;
 499
 500   /* ptr now pointing at start of QName in query field */
 501   ptr = skipRRQName(ptr);
 502
 503
 504   /* skip the query type and class fields */
 505   ptr+= DNS_QTAIL_LEN;
 506
 507   /* ptr should now be at the start of the answer RR sections */
 508
 509   answerCount = MIN(answerCount, AFSMAXCELLHOSTS);
 510 #ifdef DEBUG
 511   fprintf(stderr, "processRep_AFSDB: answerCount=%d\n", answerCount);
 512 #endif /* DEBUG */
 513
 514   for (i=0; i<answerCount ; i++){
 515     ptr = skipRRQName(ptr);
 516     rrPtr = (PDNS_AFSDB_RR_HDR) ptr;
 517     ptr+= DNS_AFSDB_RR_HDR_LEN;
 518     if ((ntohs(rrPtr->rr_afsdb_class) == 1) &&
 519         (srvCount < MAX_AFS_SRVS)) {
 520       /*ptr = sPrintRRQName(ptr,replyBuff,srvList->host[srvList->count]);*/
 521       ptr = sPrintRRQName(ptr,replyBuff,hostName);
 522       /*ptr = printRRQName(ptr,replyBuff);*/
 523       *ttl = ntohl(rrPtr->rr_ttl);
 524
 525 #ifdef DEBUG
 526       fprintf(stderr, "resolving name %s\n", hostName);
 527 #endif
 528       /* resolve name from DNS query */
 529       rc = DNSgetAddr(commSock, hostName, &addr);
 530       if (rc < 0)
 531         continue;  /* skip this entry */
 532 #ifdef DEBUG
 533       fprintf(stderr, "processRep_AFSDB: resolved name %s to addr %x\n", hostName, addr);
 534 #endif /* DEBUG */
 535       memcpy(&cellHostAddrs[srvCount], &addr.s_addr, sizeof(addr.s_addr));
 536           strncpy(cellHostNames[srvCount], hostName, CELL_MAXNAMELEN);
 537           cellHostNames[srvCount][CELL_MAXNAMELEN-1] = '\0';
 538       srvCount++;
 539     }
 540     else {
 541       ptr = skipRRQName(ptr);
 542     }
 543   }
 544
 545   *numServers = srvCount;
 546
 547 }
 548
 549
 550 u_char * processReplyBuffer_Addr(PDNS_HDR replyBuff)
 551 {
 552   u_char *ptr = (u_char *) replyBuff;
 553   int    answerCount = ntohs((replyBuff)->rr_count);
 554   PDNS_A_RR_HDR
 555          rrPtr;
 556
 557 #ifdef DEBUG
 558   fprintf(stderr, "processReplyBuffer_Addr: answerCount=%d\n", answerCount);
 559 #endif /* DEBUG */
 560   if (answerCount == 0) return 0;
 561
 562   ptr += DNS_HDR_LEN;
 563
 564   /* ptr now pointing at start of QName in query field */
 565   ptr = skipRRQName(ptr);
 566
 567
 568   /* skip the query type and class fields */
 569   ptr+= DNS_QTAIL_LEN;
 570
 571   /* ptr should now be at the start of the answer RR sections */
 572   ptr = skipRRQName(ptr);
 573   rrPtr = (PDNS_A_RR_HDR) ptr;
 574
 575 #ifdef DEBUG
 576   fprintf(stderr, "type:%d, class:%d, ttl:%d, rdlength:%d\n",
 577          ntohs(rrPtr->rr_type),ntohs(rrPtr->rr_class),
 578          ntohl(rrPtr->rr_ttl),ntohs(rrPtr->rr_rdlength));
 579   fprintf(stderr, "Count %d\tand Answer %8x\n",answerCount,rrPtr->rr_addr);
 580 #endif /* DEBUG */
 581
 582   ptr += DNS_A_RR_HDR_LEN;
 583
 584   return (ptr);
 585
 586 };
 587
 588 int DNSgetAddr(SOCKET commSock, char *hostName, struct in_addr *iNet)
 589 {
 590   /* Variables for DNS message parsing and creation */
 591   PDNS_HDR  pDNShdr;
 592
 593   SOCKADDR_IN sockAddr;
 594   char buffer[BUFSIZE];
 595   u_char *addr;
 596   u_long *aPtr;
 597   int rc;
 598
 599   /**********************
 600    * Get a DGRAM socket *
 601    **********************/
 602
 603   sockAddr = setSockAddr(dns_addr, DNS_PORT);
 604
 605   rc = send_DNS_Addr_Query(hostName,commSock,sockAddr, buffer);
 606   if (rc < 0) return rc;
 607   pDNShdr = get_DNS_Response(commSock,sockAddr, buffer);
 608   if (pDNShdr == NULL)
 609     return -1;
 610
 611   addr = processReplyBuffer_Addr(pDNShdr);
 612   if (addr == 0)
 613     return -1;
 614
 615   aPtr = (u_long *) addr;
 616
 617   iNet->s_addr = *aPtr;
 618
 619   return(0);
 620 }
 621 #endif /* DNSAPI_ENV */
 622
 623 int getAFSServer(char *cellName, int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS],
 624                  int *numServers, int *ttl)
 625 {
 626 #ifndef DNSAPI_ENV
 627     SOCKET commSock;
 628     SOCKADDR_IN sockAddr;
 629     PDNS_HDR  pDNShdr;
 630     char buffer[BUFSIZE];
 631     char query[1024];
 632     int rc;
 633
 634 #ifdef DEBUG
 635     fprintf(stderr, "getAFSServer: cell %s, cm_dnsEnabled=%d\n", cellName, cm_dnsEnabled);
 636 #endif
 637
 638 #if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
 639     if (cm_dnsEnabled == -1) { /* not yet initialized, eg when called by klog */
 640         cm_InitDNS(1);         /* assume enabled */
 641     }
 642 #endif
 643     if (cm_dnsEnabled == 0) {  /* possibly we failed in cm_InitDNS above */
 644         fprintf(stderr, "DNS initialization failed, disabled\n");
 645         *numServers = 0;
 646         return -1;
 647     }
 648
 649     sockAddr = setSockAddr(dns_addr, DNS_PORT);
 650
 651     commSock = socket( AF_INET, SOCK_DGRAM, 0 );
 652     if ( commSock < 0 )
 653     {
 654         /*afsi_log("socket() failed\n");*/
 655         fprintf(stderr, "getAFSServer: socket() failed, errno=%d\n", errno);
 656         *numServers = 0;
 657         return (-1);
 658     }
 659
 660     StringCbCopyA(query, sizeof(query), cellName);
 661     if (query[strlen(query)-1] != '.') {
 662         StringCbCatA(query, sizeof(query), ".");
 663     }
 664
 665     rc = send_DNS_AFSDB_Query(cellName,commSock,sockAddr, buffer);
 666     if (rc < 0) {
 667         fprintf(stderr,"getAFSServer: send_DNS_AFSDB_Query failed\n");
 668         *numServers = 0;
 669         return -1;
 670     }
 671
 672     pDNShdr = get_DNS_Response(commSock,sockAddr, buffer);
 673
 674     /*printReplyBuffer_AFSDB(pDNShdr);*/
 675     if (pDNShdr)
 676         processReplyBuffer_AFSDB(commSock, pDNShdr, cellHostAddrs, cellHostNames, numServers, ttl);
 677     else
 678         *numServers = 0;
 679
 680     closesocket(commSock);
 681     if (*numServers == 0)
 682         return(-1);
 683     else
 684         return 0;
 685 #else /* DNSAPI_ENV */
 686     PDNS_RECORD pDnsCell, pDnsIter, pDnsVol,pDnsVolIter, pDnsCIter;
 687     int i;
 688     struct sockaddr_in vlSockAddr;
 689     char query[1024];
 690
 691 #ifdef AFS_FREELANCE_CLIENT
 692     if ( cm_stricmp_utf8N(cellName, "Freelance.Local.Root") == 0 )
 693         return -1;
 694 #endif /* AFS_FREELANCE_CLIENT */
 695
 696     *numServers = 0;
 697     *ttl = 0;
 698
 699     /* query the AFSDB records of cell */
 700     StringCbCopyA(query, sizeof(query), cellName);
 701     if (query[strlen(query)-1] != '.') {
 702         StringCbCatA(query, sizeof(query), ".");
 703     }
 704
 705     if (DnsQuery_A(query, DNS_TYPE_AFSDB, DNS_QUERY_STANDARD, NULL, &pDnsCell, NULL) == ERROR_SUCCESS) {
 706         memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
 707
 708         /* go through the returned records */
 709         for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) {
 710             /* if we find an AFSDB record with Preference set to 1, we found a volserver */
 711             if (pDnsIter->wType == DNS_TYPE_AFSDB && pDnsIter->Data.Afsdb.wPreference == 1) {
 712                 StringCbCopyA(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]),
 713                               pDnsIter->Data.Afsdb.pNameExchange);
 714                 (*numServers)++;
 715
 716                 if (!*ttl)
 717                     *ttl = pDnsIter->dwTtl;
 718                 if (*numServers == AFSMAXCELLHOSTS)
 719                     break;
 720             }
 721         }
 722
 723         for (i=0;i<*numServers;i++)
 724             cellHostAddrs[i] = 0;
 725
 726         /* now check if there are any A records in the results */
 727         for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 728             if(pDnsIter->wType == DNS_TYPE_A)
 729                 /* check if its for one of the volservers */
 730                 for (i=0;i<*numServers;i++)
 731                     if(cm_stricmp_utf8(pDnsIter->pName, cellHostNames[i]) == 0)
 732                         cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
 733         }
 734
 735         for (i=0;i<*numServers;i++) {
 736             /* if we don't have an IP yet, then we should try resolving the volserver hostname
 737             in a separate query. */
 738             if (!cellHostAddrs[i]) {
 739                 if (DnsQuery_A(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL, &pDnsVol, NULL) == ERROR_SUCCESS) {
 740                     for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
 741                         /* if we get an A record, keep it */
 742                         if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) {
 743                             cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
 744                             break;
 745                         }
 746                         /* if we get a CNAME, look for a corresponding A record */
 747                         if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf8(cellHostNames[i], pDnsVolIter->pName)==0) {
 748                             for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
 749                                 if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf8(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
 750                                     cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
 751                                     break;
 752                                 }
 753                             }
 754                             if (cellHostAddrs[i])
 755                                 break;
 756                             /* TODO: if the additional section is missing, then do another lookup for the CNAME */
 757                         }
 758                     }
 759                     /* we are done with the volserver lookup */
 760                     DnsRecordListFree(pDnsVol, DnsFreeRecordListDeep);
 761                 }
 762             }
 763         }
 764         DnsRecordListFree(pDnsCell, DnsFreeRecordListDeep);
 765     }
 766
 767     if ( *numServers > 0 )
 768         return 0;
 769     else
 770         return -1;
 771 #endif /* DNSAPI_ENV */
 772 }
 773
 774 int getAFSServerW(cm_unichar_t *cellName, int *cellHostAddrs,
 775                   cm_unichar_t cellHostNames[][MAXHOSTCHARS],
 776                   int *numServers, int *ttl)
 777 {
 778 #ifdef DNSAPI_ENV
 779     PDNS_RECORDW pDnsCell, pDnsIter, pDnsVol,pDnsVolIter, pDnsCIter;
 780     int i;
 781     struct sockaddr_in vlSockAddr;
 782     cm_unichar_t query[1024];
 783
 784 #ifdef AFS_FREELANCE_CLIENT
 785     if ( cm_stricmp_utf16(cellName, L"Freelance.Local.Root") == 0 )
 786         return -1;
 787 #endif /* AFS_FREELANCE_CLIENT */
 788
 789     *numServers = 0;
 790     *ttl = 0;
 791
 792     /* query the AFSDB records of cell */
 793     StringCbCopyW(query, sizeof(query), cellName);
 794     if (query[wcslen(query)-1] != L'.') {
 795         StringCbCatW(query, sizeof(query), L".");
 796     }
 797
 798     if (DnsQuery_W(query, DNS_TYPE_AFSDB, DNS_QUERY_STANDARD, NULL, (PDNS_RECORD *) &pDnsCell,
 799                    NULL) == ERROR_SUCCESS) {
 800         memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
 801
 802         /* go through the returned records */
 803         for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) {
 804             /* if we find an AFSDB record with Preference set to 1, we found a volserver */
 805             if (pDnsIter->wType == DNS_TYPE_AFSDB && pDnsIter->Data.Afsdb.wPreference == 1) {
 806                 StringCbCopyW(cellHostNames[*numServers], sizeof(cellHostNames[*numServers]),
 807                               pDnsIter->Data.Afsdb.pNameExchange);
 808                 (*numServers)++;
 809
 810                 if (!*ttl)
 811                     *ttl = pDnsIter->dwTtl;
 812                 if (*numServers == AFSMAXCELLHOSTS)
 813                     break;
 814             }
 815         }
 816
 817         for (i=0;i<*numServers;i++)
 818             cellHostAddrs[i] = 0;
 819
 820         /* now check if there are any A records in the results */
 821         for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
 822             if(pDnsIter->wType == DNS_TYPE_A)
 823                 /* check if its for one of the volservers */
 824                 for (i=0;i<*numServers;i++)
 825                     if(cm_stricmp_utf16(pDnsIter->pName, cellHostNames[i]) == 0)
 826                         cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
 827         }
 828
 829         for (i=0;i<*numServers;i++) {
 830             /* if we don't have an IP yet, then we should try resolving the volserver hostname
 831                in a separate query. */
 832             if (!cellHostAddrs[i]) {
 833                 if (DnsQuery_W(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL,
 834                                (PDNS_RECORD *) &pDnsVol, NULL) == ERROR_SUCCESS) {
 835                     for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
 836                         /* if we get an A record, keep it */
 837                         if (pDnsVolIter->wType == DNS_TYPE_A && cm_stricmp_utf16(cellHostNames[i], pDnsVolIter->pName)==0) {
 838                             cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
 839                             break;
 840                         }
 841                         /* if we get a CNAME, look for a corresponding A record */
 842                         if (pDnsVolIter->wType == DNS_TYPE_CNAME && cm_stricmp_utf16(cellHostNames[i], pDnsVolIter->pName)==0) {
 843                             for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
 844                                 if (pDnsCIter->wType == DNS_TYPE_A && cm_stricmp_utf16(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
 845                                     cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
 846                                     break;
 847                                 }
 848                             }
 849                             if (cellHostAddrs[i])
 850                                 break;
 851                             /* TODO: if the additional section is missing, then do another lookup for the CNAME */
 852                         }
 853                     }
 854                     /* we are done with the volserver lookup */
 855                     DnsRecordListFree((PDNS_RECORD) pDnsVol, DnsFreeRecordListDeep);
 856                 }
 857             }
 858         }
 859         DnsRecordListFree((PDNS_RECORD) pDnsCell, DnsFreeRecordListDeep);
 860     }
 861
 862     if ( *numServers > 0 )
 863         return 0;
 864     else
 865 #endif  /* DNSAPI_ENV */
 866         return -1;
 867 }
 868 #endif /* AFS_AFSDB_ENV */
 869