windows-afsdb-fix-20050701
[openafs.git] / 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 #ifndef DJGPP
15 #include <windows.h>
16 #include <winsock2.h>
17 #endif
18 #include "cm_dns_private.h"
19 #include "cm_dns.h"
20 #include <lwp.h>
21 #include <afs/afsint.h>
22 #if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0500)
23 #include <windns.h>
24 #define DNSAPI_ENV
25 #endif
26
27 /*extern void afsi_log(char *pattern, ...);*/
28
29 extern int errno;
30 static char dns_addr[30];
31 #ifdef DJGPP
32 extern char cm_confDir[];
33 #endif
34 static int cm_dnsEnabled = -1;
35
36 void DNSlowerCase(char *str)
37 {
38   int i;
39
40   for (i=0; i<strlen(str); i++)
41     /*str[i] = tolower(str[i]);*/
42     if (str[i] >= 'A' && str[i] <= 'Z')
43       str[i] += 'a' - 'A';
44 }
45
46 int cm_InitDNS(int enabled)
47 {
48 #ifndef DNSAPI_ENV
49   char configpath[100];
50   int len;
51   int code;
52   char *addr;
53   
54   if (!enabled) { fprintf(stderr, "DNS support disabled\n"); cm_dnsEnabled = 0; return 0; }
55
56   /* First try AFS_NS environment var. */
57   addr = getenv("AFS_NS");
58   if (addr && inet_addr(addr) != -1) {
59     strcpy(dns_addr, addr);
60   } else {
61     /* Now check for the AFSDNS.INI file */
62 #ifdef DJGPP
63     strcpy(configpath, cm_confDir);
64 #elif defined(AFS_WIN95_ENV)
65     char *path = getenv("AFSCONF");
66     if (path) strcpy(configpath, path);
67     else strcpy(configpath, "c:\\afscli");
68 #else  /* nt */
69     code = GetWindowsDirectory(configpath, sizeof(configpath));
70     if (code == 0 || code > sizeof(configpath)) return -1;
71 #endif
72     strcat(configpath, "\\afsdns.ini");
73
74     /* Currently we only get (and query) the first nameserver.  Getting
75        list of mult. nameservers should be easy to do. */
76     len = GetPrivateProfileString("AFS Domain Name Servers", "ns1", NULL,
77                             dns_addr, sizeof(dns_addr),
78                             configpath);
79   
80     if (len == 0 || inet_addr(dns_addr) == -1) {
81       fprintf(stderr, "No valid name server addresses found, DNS lookup is "
82                       "disabled\n");
83       cm_dnsEnabled = 0;  /* failed */
84       return -1;     /* No name servers defined */
85     }
86     else fprintf(stderr, "Found DNS server %s\n", dns_addr);
87   }
88 #endif /* DNSAPI_ENV */
89   cm_dnsEnabled = 1;
90   return 0;
91 }
92
93 #ifndef DNSAPI_ENV
94 SOCKADDR_IN setSockAddr(char *server, int port)
95 {
96   SOCKADDR_IN sockAddr;                     
97   int         addrLen = sizeof(SOCKADDR_IN);
98
99 #ifndef WIN32_LEAN_AND_MEAN
100   bzero(&sockAddr,addrLen);
101 #endif /*WIN32_LEAN_AND_MEAN*/
102   sockAddr.sin_family   = AF_INET;
103   sockAddr.sin_port     = htons( port );
104   sockAddr.sin_addr.s_addr = inet_addr( server );
105   /*inet_aton(server, &sockAddr.sin_addr.s_addr);*/
106
107   return (sockAddr);
108 }
109
110 int getRRCount(PDNS_HDR ptr)
111 {
112   return(ntohs(ptr->rr_count));
113 }
114
115
116 int send_DNS_Addr_Query(char* query, 
117                          SOCKET commSock, SOCKADDR_IN sockAddr, char *buffer)
118 {
119   PDNS_HDR    pDNShdr;
120   PDNS_QTAIL  pDNS_qtail;
121
122   int     queryLen = 0;
123   int     res;
124
125 #ifndef WIN32_LEAN_AND_MEAN
126   bzero(buffer,BUFSIZE);
127 #endif /*WIN32_LEAN_AND_MEAN*/
128
129   /*********************************
130    * Build DNS Query Message       *
131    *                               *
132    * hard-coded Adrress (A) query  *
133    *********************************/
134   
135   pDNShdr = (PDNS_HDR)&( buffer[ 0 ] );
136   pDNShdr->id         = htons( 0xDADE );
137   pDNShdr->flags      = htons( DNS_FLAG_RD ); /* do recurse */
138   pDNShdr->q_count    = htons( 1 );           /* one query */
139   pDNShdr->rr_count   = 0;                    /* none in query */
140   pDNShdr->auth_count = 0;                    /* none in query */
141   pDNShdr->add_count  = 0;                    /* none in query */
142   
143   queryLen = putQName( query, &(buffer[ DNS_HDR_LEN ] ) );
144   queryLen += DNS_HDR_LEN; /* query Length is just after the query name and header */
145 #ifdef DEBUG
146   fprintf(stderr, "send_DNS_Addr: query=%s, queryLen=%d\n", query, queryLen);
147 #endif
148   
149   
150   pDNS_qtail = (PDNS_QTAIL) &(buffer[ queryLen ]);
151   pDNS_qtail->qtype = htons(255);/*htons(DNS_RRTYPE_A); */
152   pDNS_qtail->qclass = htons(DNS_RRCLASS_IN); 
153   queryLen +=  DNS_QTAIL_LEN;
154   
155   /**************************
156    * Send DNS Query Message *
157    **************************/
158   
159
160   res = sendto( commSock,
161                 buffer,
162                 queryLen,
163                 0,
164                 (struct sockaddr *) &sockAddr,
165                 sizeof( SOCKADDR_IN ) );
166   
167   /*dumpSbuffer(buffer,queryLen);*/
168
169   if ( res < 0 )
170     {
171 #ifdef DEBUG
172       fprintf(stderr, "send_DNS_Addr_Query: error %d, errno %d\n", res, errno);
173       fprintf(stderr, "sendto() failed \n");
174 #endif
175       return ( -1 );
176     }
177   else
178     {
179     /*printf( "sendto() succeeded\n");*/
180     ;
181     } /* end if */
182   
183   return(0);
184 }
185
186
187 int send_DNS_AFSDB_Query(char* query, 
188                          SOCKET commSock, SOCKADDR_IN sockAddr, char *buffer)
189 {
190   /*static char buffer[BUFSIZE];*/
191
192   PDNS_HDR    pDNShdr;
193   PDNS_QTAIL  pDNS_qtail;
194
195   int     queryLen = 0;
196   int     res;
197
198 #ifndef WIN32_LEAN_AND_MEAN
199   bzero(buffer,BUFSIZE);
200 #endif /*WIN32_LEAN_AND_MEAN*/
201
202   /***************************
203    * Build DNS Query Message *
204    *                         *
205    * hard-coded AFSDB query  *
206    ***************************/
207   
208   pDNShdr = (PDNS_HDR)&( buffer[ 0 ] );
209   pDNShdr->id         = htons( 0xDEAD );
210   pDNShdr->flags      = htons( DNS_FLAG_RD ); /* do recurse */
211   pDNShdr->q_count    = htons( 1 );           /* one query */
212   pDNShdr->rr_count   = 0;                    /* none in query */
213   pDNShdr->auth_count = 0;                    /* none in query */
214   pDNShdr->add_count  = 0;                    /* none in query */
215   
216   queryLen = putQName( query, &(buffer[ DNS_HDR_LEN ] ) );
217   queryLen += DNS_HDR_LEN; /* query Length is just after the query name and header */
218   
219   
220   pDNS_qtail = (PDNS_QTAIL) &(buffer[ queryLen ]);
221   pDNS_qtail->qtype = htons(DNS_RRTYPE_AFSDB); 
222   pDNS_qtail->qclass = htons(DNS_RRCLASS_IN); 
223   queryLen +=  DNS_QTAIL_LEN;
224   
225   /**************************
226    * Send DNS Query Message *
227    **************************/
228   
229   res = sendto( commSock,
230                 buffer,
231                 queryLen,
232                 0,
233                 (struct sockaddr *) &sockAddr,
234                 sizeof( SOCKADDR_IN ) );
235   
236   /*dumpSbuffer(buffer,queryLen);*/
237
238   if ( res < 0 )
239     {
240 #ifdef DEBUG
241       fprintf(stderr, "send_DNS_AFSDB_Query: error %d, errno %d\n", res, errno);
242       fprintf(stderr,  "sendto() failed \n");
243 #endif /* DEBUG */
244       return ( -1 );
245     }
246   else
247     {
248     /*printf( "sendto() succeeded\n");*/
249     ;
250     } /* end if */
251   
252   return(0);
253 }
254
255
256 PDNS_HDR get_DNS_Response(SOCKET commSock, SOCKADDR_IN sockAddr, char *buffer)
257 {
258   /*static char buffer[BUFSIZE];*/
259
260   int         addrLen = sizeof(SOCKADDR_IN);
261   int size;
262
263 #ifndef WIN32_LEAN_AND_MEAN
264   bzero(buffer,BUFSIZE);
265 #endif /*WIN32_LEAN_AND_MEAN*/
266
267   /*****************************
268    * Receive DNS Reply Message *
269    *****************************/
270   
271   /*printf( "calling recvfrom() on connected UDP socket\n" );*/
272   
273   size = recvfrom( commSock,
274                   buffer,
275                   BUFSIZE,
276                   0,
277                   (struct sockaddr *) &sockAddr,
278                   &addrLen );
279   if (size < 0) { fprintf(stderr, "recvfrom error %d\n", errno); return NULL; }
280
281   /*dumpRbuffer(buffer,res);*/
282
283 #ifdef DEBUG
284   fprintf(stderr, "recvfrom returned %d bytes from %s: \n", 
285           size, inet_ntoa( sockAddr.sin_addr ) );
286 #endif /* DEBUG */
287   
288   return((PDNS_HDR)&( buffer[ 0 ] ));
289
290 }
291
292
293 int putQName( char *pHostName, char *pQName )
294 {
295   int     i;
296   char    c;
297   int     j = 0;
298   int     k = 0;
299   
300   DNSlowerCase(pHostName);
301   /*printf( "Hostname: [%s]\n", pHostName );*/
302   
303   for ( i = 0; *( pHostName + i ); i++ )
304     {
305       c = *( pHostName + i );   /* get next character */
306       
307       
308       if ( c == '.' )
309         {
310           /* dot encountered, fill in previous length */
311           if (k!=0){ /*don't process repeated dots*/
312           /*printf( "%c", c );*/
313             *( pQName + j ) = k;
314             j = j+k+1;  /* set index to next counter */
315             k = 0;      /* reset segment length */
316           }
317         }
318       else
319         {
320         /*printf( "%c", c );*/
321           *( pQName + j + k + 1 ) = c;  /* assign to QName */
322           k++;                /* inc count of seg chars */
323         } /* end if */
324     } /* end for loop */
325   
326   *(pQName + j )                  = k;   /* count for final segment */
327
328   *(pQName + j + k + 1 )      = 0;   /* count for trailing NULL segment is 0 */
329   
330   /*printf( "\n" ); */
331   
332   if (c == '.')
333     return ( j + k + 1 );        /* return total length of QName */
334   else
335     return ( j + k + 2 );
336 } /* end putQName() */
337
338
339 u_char * skipRRQName(u_char *pQName)
340 {
341   u_char *ptr;
342   u_char c;
343
344   ptr = pQName;
345   c = *ptr;
346   while (c) {
347     if ( c >= 0xC0 ) {
348     /* skip the 'compression' pointer */
349       ptr = ptr+1;
350       c = '\0';
351     } else {
352       /* skip a normal qname segment */
353       ptr += *ptr;
354       ptr++;
355       c = *ptr;
356     };
357   };
358
359   /* ptr now pointing at terminating zero of query QName,
360      or the pointer for the previous occurrence 
361      (compression)
362    */
363   ptr++;
364
365   return (ptr);
366 } /* end skipRRQName() */
367
368
369
370 u_char * printRRQName( u_char *pQName, PDNS_HDR buffer )
371 {
372   u_short i, k;
373   u_char *buffPtr = (u_char *) buffer;
374   u_char *namePtr;
375   u_char *retPtr;
376   u_char c;
377
378
379   namePtr = pQName;
380   retPtr = 0;
381
382   for ( i = 0; i < BUFSIZE; i++ )
383     {
384       c = *namePtr;
385       if ( c >= 0xC0 ) {
386         c = *(namePtr + 1);
387         retPtr = namePtr+2;
388         namePtr = buffPtr+c; 
389       } else {
390         if ( c == 0 )
391           break;
392         
393         for ( k = 1; k <= c; k++ )
394           {
395             fprintf(stderr, "%c", *( namePtr + k ) );
396           } /* end for loop */
397         fprintf(stderr,".");
398         namePtr += k;
399       }
400     } /* end for loop */
401   fprintf(stderr,"\n");
402   namePtr++; /* skip terminating zero */
403
404   if (retPtr)
405     return(retPtr);
406   else
407     return(namePtr);
408
409 } /* end printRRQName() */
410
411
412 u_char * sPrintRRQName( u_char *pQName, PDNS_HDR buffer, char *str )
413 {
414   u_short i, k;
415   u_char *buffPtr = (u_char *) buffer;
416   u_char *namePtr;
417   u_char *retPtr;
418   u_char c;
419
420   char   section[64];
421
422   strcpy(str,"");
423   namePtr = pQName;
424   retPtr = 0;
425
426   for ( i = 0; i < BUFSIZE; i++ )
427     {
428       c = *namePtr;
429       if ( c >= 0xC0 ) {
430         c = *(namePtr + 1);
431         retPtr = namePtr+2;
432         namePtr = buffPtr+c; 
433       } else {
434         if ( c == 0 )
435           break;
436         
437         for ( k = 1; k <= c; k++ )
438           {
439             sprintf(section,"%c", *( namePtr + k ) );
440             strcat(str,section);
441           } /* end for loop */
442         strcat(str,".");
443         namePtr += k;
444       }
445     } /* end for loop */
446   namePtr++; /* skip terminating zero */
447
448   if (retPtr)
449     return(retPtr);
450   else
451     return(namePtr);
452
453 } /* end sPrintRRQName() */
454
455
456 void printReplyBuffer_AFSDB(PDNS_HDR replyBuff)
457 {
458   u_char *ptr = (u_char *) replyBuff;
459   int    answerCount = ntohs((replyBuff)->rr_count);
460   u_char i;
461   PDNS_AFSDB_RR_HDR 
462          rrPtr;
463
464   ptr += DNS_HDR_LEN;
465
466   /* ptr now pointing at start of QName in query field */
467   ptr = skipRRQName(ptr);
468
469
470   /* skip the query type and class fields */
471   ptr+= DNS_QTAIL_LEN;
472
473   /* ptr should now be at the start of the answer RR sections */
474
475   fprintf(stderr,"---------------------------------\n");
476   for (i=0; i<answerCount ; i++){
477     ptr = skipRRQName(ptr);
478     rrPtr = (PDNS_AFSDB_RR_HDR) ptr;
479     ptr+= DNS_AFSDB_RR_HDR_LEN;
480     if ( ntohs(rrPtr->rr_afsdb_class) == 1) {
481       fprintf(stderr,"AFDB class %d ->  ",ntohs(rrPtr->rr_afsdb_class)); 
482       ptr = printRRQName(ptr,replyBuff); }
483     else
484       ptr = skipRRQName(ptr);
485   };
486   fprintf(stderr,"---------------------------------\n");
487
488
489 };
490
491 void processReplyBuffer_AFSDB(SOCKET commSock, PDNS_HDR replyBuff, int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS], int *numServers, int *ttl)
492   /*PAFS_SRV_LIST (srvList)*/
493 {
494   u_char *ptr = (u_char *) replyBuff;
495   int    answerCount = ntohs((replyBuff)->rr_count);
496   u_char i;
497   PDNS_AFSDB_RR_HDR 
498          rrPtr;
499   int srvCount = 0;
500   char hostName[256];
501   struct in_addr addr;
502   int rc;
503
504   ptr += DNS_HDR_LEN;
505
506   /* ptr now pointing at start of QName in query field */
507   ptr = skipRRQName(ptr);
508
509
510   /* skip the query type and class fields */
511   ptr+= DNS_QTAIL_LEN;
512
513   /* ptr should now be at the start of the answer RR sections */
514
515   answerCount = MIN(answerCount, AFSMAXCELLHOSTS);
516 #ifdef DEBUG
517   fprintf(stderr, "processRep_AFSDB: answerCount=%d\n", answerCount);
518 #endif /* DEBUG */
519
520   for (i=0; i<answerCount ; i++){
521     ptr = skipRRQName(ptr);
522     rrPtr = (PDNS_AFSDB_RR_HDR) ptr;
523     ptr+= DNS_AFSDB_RR_HDR_LEN;
524     if ((ntohs(rrPtr->rr_afsdb_class) == 1) && 
525         (srvCount < MAX_AFS_SRVS)) {
526       /*ptr = sPrintRRQName(ptr,replyBuff,srvList->host[srvList->count]);*/
527       ptr = sPrintRRQName(ptr,replyBuff,hostName);
528       /*ptr = printRRQName(ptr,replyBuff);*/
529       *ttl = ntohl(rrPtr->rr_ttl);
530
531 #ifdef DEBUG
532       fprintf(stderr, "resolving name %s\n", hostName);
533 #endif
534       /* resolve name from DNS query */
535       rc = DNSgetAddr(commSock, hostName, &addr);
536       if (rc < 0)
537         continue;  /* skip this entry */
538 #ifdef DEBUG
539       fprintf(stderr, "processRep_AFSDB: resolved name %s to addr %x\n", hostName, addr);
540 #endif /* DEBUG */
541       memcpy(&cellHostAddrs[srvCount], &addr.s_addr, sizeof(addr.s_addr));
542           strncpy(cellHostNames[srvCount], hostName, MAXCELLCHARS);
543           cellHostNames[srvCount][MAXCELLCHARS-1] = '\0';
544       srvCount++;
545     }
546     else {
547       ptr = skipRRQName(ptr);
548     }
549   }
550
551   *numServers = srvCount;
552
553 }
554
555
556 u_char * processReplyBuffer_Addr(PDNS_HDR replyBuff)
557 {
558   u_char *ptr = (u_char *) replyBuff;
559   int    answerCount = ntohs((replyBuff)->rr_count);
560   PDNS_A_RR_HDR 
561          rrPtr;
562
563 #ifdef DEBUG
564   fprintf(stderr, "processReplyBuffer_Addr: answerCount=%d\n", answerCount);
565 #endif /* DEBUG */
566   if (answerCount == 0) return 0;
567   
568   ptr += DNS_HDR_LEN;
569
570   /* ptr now pointing at start of QName in query field */
571   ptr = skipRRQName(ptr);
572
573
574   /* skip the query type and class fields */
575   ptr+= DNS_QTAIL_LEN;
576
577   /* ptr should now be at the start of the answer RR sections */
578   ptr = skipRRQName(ptr);
579   rrPtr = (PDNS_A_RR_HDR) ptr;
580
581 #ifdef DEBUG
582   fprintf(stderr, "type:%d, class:%d, ttl:%d, rdlength:%d\n",
583          ntohs(rrPtr->rr_type),ntohs(rrPtr->rr_class),
584          ntohl(rrPtr->rr_ttl),ntohs(rrPtr->rr_rdlength));
585   fprintf(stderr, "Count %d\tand Answer %8x\n",answerCount,rrPtr->rr_addr);
586 #endif /* DEBUG */
587
588   ptr += DNS_A_RR_HDR_LEN;
589
590   return (ptr);
591
592 };
593
594 int DNSgetAddr(SOCKET commSock, char *hostName, struct in_addr *iNet)
595 {
596   /* Variables for DNS message parsing and creation */
597   PDNS_HDR  pDNShdr;
598
599   SOCKADDR_IN sockAddr;
600   char buffer[BUFSIZE];
601   u_char *addr;
602   u_long *aPtr;
603   int rc;
604
605   /**********************
606    * Get a DGRAM socket *
607    **********************/
608   
609   sockAddr = setSockAddr(dns_addr, DNS_PORT);
610   
611   rc = send_DNS_Addr_Query(hostName,commSock,sockAddr, buffer);
612   if (rc < 0) return rc;
613   pDNShdr = get_DNS_Response(commSock,sockAddr, buffer);
614   if (pDNShdr == NULL)
615     return -1;
616   
617   addr = processReplyBuffer_Addr(pDNShdr);
618   if (addr == 0)
619     return -1;
620
621   aPtr = (u_long *) addr;
622
623   iNet->s_addr = *aPtr;
624
625   return(0);
626 }
627 #endif /* DNSAPI_ENV */
628
629 int getAFSServer(char *cellName, int *cellHostAddrs, char cellHostNames[][MAXHOSTCHARS], 
630                  int *numServers, int *ttl)
631 {
632 #ifndef DNSAPI_ENV
633    /*static AFS_SRV_LIST srvList;
634     static int ans = 0;*/
635   SOCKET commSock;
636   SOCKADDR_IN sockAddr;
637   PDNS_HDR  pDNShdr;
638   char buffer[BUFSIZE];
639   char query[1024];
640   int rc;
641
642 #ifdef DEBUG
643   fprintf(stderr, "getAFSServer: cell %s, cm_dnsEnabled=%d\n", cellName, cm_dnsEnabled);
644 #endif
645
646 #if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
647   if (cm_dnsEnabled == -1) { /* not yet initialized, eg when called by klog */
648     cm_InitDNS(1);    /* assume enabled */
649   }
650 #endif
651   if (cm_dnsEnabled == 0) {  /* possibly we failed in cm_InitDNS above */
652     fprintf(stderr, "DNS initialization failed, disabled\n");
653     *numServers = 0;
654     return -1;
655   }
656   
657   sockAddr = setSockAddr(dns_addr, DNS_PORT);
658   
659   commSock = socket( AF_INET, SOCK_DGRAM, 0 );
660   if ( commSock < 0 )
661     {
662       /*afsi_log("socket() failed\n");*/
663       fprintf(stderr, "getAFSServer: socket() failed, errno=%d\n", errno);
664       *numServers = 0;
665       return (-1);
666     } 
667   
668 #ifdef DJGPP
669   /* the win95 sock.vxd will not allow sendto for unbound sockets, 
670    *   so just bind to nothing and it works */
671   
672   __djgpp_set_socket_blocking_mode(commSock, 0);
673   bind(commSock,0,sizeof( SOCKADDR_IN ) );
674 #endif /* DJGPP */
675
676   strncpy(query, cellName, 1024);
677   query[1023] = 0;
678   if (query[strlen(query)-1] != '.') {
679     strncat(query,".",1024);
680     query[1023] = 0;
681   }
682
683   rc = send_DNS_AFSDB_Query(cellName,commSock,sockAddr, buffer);
684   if (rc < 0) {
685     fprintf(stderr,"getAFSServer: send_DNS_AFSDB_Query failed\n");
686     *numServers = 0;
687     return -1;
688   }
689     
690   pDNShdr = get_DNS_Response(commSock,sockAddr, buffer);
691   
692   /*printReplyBuffer_AFSDB(pDNShdr);*/
693   if (pDNShdr)
694     processReplyBuffer_AFSDB(commSock, pDNShdr, cellHostAddrs, cellHostNames, numServers, ttl);
695   else
696     *numServers = 0;
697   
698   closesocket(commSock);
699   if (*numServers == 0)
700     return(-1);
701
702   else
703     return 0;
704 #else /* DNSAPI_ENV */
705     PDNS_RECORD pDnsCell, pDnsIter, pDnsVol,pDnsVolIter, pDnsCIter;
706     DWORD i;
707     struct sockaddr_in vlSockAddr;
708     char query[1024];
709
710     *numServers = 0; 
711     *ttl = 0;
712
713     /* query the AFSDB records of cell */
714     strncpy(query, cellName, 1024);
715     query[1023] = 0;
716     if (query[strlen(query)-1] != '.') {
717         strncat(query,".",1024);
718         query[1023] = 0;
719     }
720
721     if (DnsQuery_A(query, DNS_TYPE_AFSDB, DNS_QUERY_STANDARD, NULL, &pDnsCell, NULL) == ERROR_SUCCESS) {
722         memset((void*) &vlSockAddr, 0, sizeof(vlSockAddr));
723                 
724         /* go through the returned records */
725         for (pDnsIter = pDnsCell;pDnsIter; pDnsIter = pDnsIter->pNext) {
726             /* if we find an AFSDB record with Preference set to 1, we found a volserver */
727             if (pDnsIter->wType == DNS_TYPE_AFSDB && pDnsIter->Data.Afsdb.wPreference == 1) {
728                 strncpy(cellHostNames[*numServers], pDnsIter->Data.Afsdb.pNameExchange, MAXHOSTCHARS);
729                 cellHostNames[*numServers][MAXHOSTCHARS-1]='\0';
730                 (*numServers)++;
731                 
732                 if (!*ttl) 
733                     *ttl = pDnsIter->dwTtl;
734                 if (*numServers == AFSMAXCELLHOSTS) 
735                     break;
736             }
737         }
738
739         for (i=0;i<*numServers;i++) 
740             cellHostAddrs[i] = 0;
741
742         /* now check if there are any A records in the results */
743         for (pDnsIter = pDnsCell; pDnsIter; pDnsIter = pDnsIter->pNext) {
744             if(pDnsIter->wType == DNS_TYPE_A)
745                 /* check if its for one of the volservers */
746                 for (i=0;i<*numServers;i++)
747                     if(stricmp(pDnsIter->pName, cellHostNames[i]) == 0)
748                         cellHostAddrs[i] = pDnsIter->Data.A.IpAddress;
749         }       
750
751         for (i=0;i<*numServers;i++) {
752             /* if we don't have an IP yet, then we should try resolving the volserver hostname
753             in a separate query. */
754             if (!cellHostAddrs[i]) {
755                 if (DnsQuery_A(cellHostNames[i], DNS_TYPE_A, DNS_QUERY_STANDARD, NULL, &pDnsVol, NULL) == ERROR_SUCCESS) {
756                     for (pDnsVolIter = pDnsVol; pDnsVolIter; pDnsVolIter=pDnsVolIter->pNext) {
757                         /* if we get an A record, keep it */
758                         if (pDnsVolIter->wType == DNS_TYPE_A && stricmp(cellHostNames[i], pDnsVolIter->pName)==0) {
759                             cellHostAddrs[i] = pDnsVolIter->Data.A.IpAddress;
760                             break;
761                         }
762                         /* if we get a CNAME, look for a corresponding A record */
763                         if (pDnsVolIter->wType == DNS_TYPE_CNAME && stricmp(cellHostNames[i], pDnsVolIter->pName)==0) {
764                             for (pDnsCIter=pDnsVolIter; pDnsCIter; pDnsCIter=pDnsCIter->pNext) {
765                                 if (pDnsCIter->wType == DNS_TYPE_A && stricmp(pDnsVolIter->Data.CNAME.pNameHost, pDnsCIter->pName)==0) {
766                                     cellHostAddrs[i] = pDnsCIter->Data.A.IpAddress;
767                                     break;
768                                 }
769                             }
770                             if (cellHostAddrs[i]) 
771                                 break;
772                             /* TODO: if the additional section is missing, then do another lookup for the CNAME */
773                         }
774                     }
775                     /* we are done with the volserver lookup */
776                     DnsRecordListFree(pDnsVol, DnsFreeRecordListDeep);
777                 }
778             }
779         }
780         DnsRecordListFree(pDnsCell, DnsFreeRecordListDeep);
781     }
782
783     if ( *numServers > 0 )
784         return 0;
785     else        
786         return -1;
787 #endif /* DNSAPI_ENV */
788 }
789 #endif /* AFS_AFSDB_ENV */