git.sur5r.net Git - openldap/blob - libraries/libldap/getdxbyname.c

   1 #ifdef LDAP_DNS
   2 /*
   3  *  Copyright (c) 1995 Regents of the University of Michigan.
   4  *  All rights reserved.
   5  *
   6  * ldap_getdxbyname - retrieve DX records from the DNS (from TXT records for now)
   7  */
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <ctype.h>
  11
  12 #ifdef MACOS
  13 #include <stdlib.h>
  14 #include "macos.h"
  15 #endif /* MACOS */
  16
  17 #if !defined(MACOS) && !defined(DOS) && !defined( _WIN32 )
  18 #include <sys/types.h>
  19 #include <netinet/in.h>
  20 #include <arpa/nameser.h>
  21 #include <sys/time.h>
  22 #include <sys/types.h>
  23 #include <sys/socket.h>
  24 #include <netdb.h>
  25 #include <resolv.h>
  26 #endif
  27 #include "lber.h"
  28 #include "ldap.h"
  29 #include "ldap-int.h"
  30
  31 #if defined( DOS ) || defined( _WIN32 )
  32 #include "msdos.h"
  33 #endif /* DOS */
  34
  35
  36 #ifdef NEEDPROTOS
  37 static char ** decode_answer( unsigned char *answer, int len );
  38 #else /* NEEDPROTOS */
  39 static char **decode_answer();
  40 #endif /* NEEDPROTOS */
  41
  42 extern int h_errno;
  43 extern char *h_errlist[];
  44
  45
  46 #define MAX_TO_SORT     32
  47
  48
  49 /*
  50  * ldap_getdxbyname - lookup DNS DX records for domain and return an ordered
  51  *      array.
  52  */
  53 char **
  54 ldap_getdxbyname( char *domain )
  55 {
  56     unsigned char       buf[ PACKETSZ ];
  57     char                **dxs;
  58     int                 rc;
  59
  60     Debug( LDAP_DEBUG_TRACE, "ldap_getdxbyname( %s )\n", domain, 0, 0 );
  61
  62     memset( buf, 0, sizeof( buf ));
  63
  64     if (( rc = res_search( domain, C_IN, T_TXT, buf, sizeof( buf ))) < 0
  65                 || ( dxs = decode_answer( buf, rc )) == NULL ) {
  66         /*
  67          * punt:  return list conisting of the original domain name only
  68          */
  69         if (( dxs = (char **)malloc( 2 * sizeof( char * ))) == NULL ||
  70                 ( dxs[ 0 ] = strdup( domain )) == NULL ) {
  71             if ( dxs != NULL ) {
  72                 free( dxs );
  73             }
  74             dxs = NULL;
  75         } else {
  76             dxs[ 1 ] = NULL;
  77         }
  78     }
  79
  80     return( dxs );
  81 }
  82
  83
  84 static char **
  85 decode_answer( unsigned char *answer, int len )
  86 {
  87     HEADER              *hp;
  88     char                buf[ 256 ], **dxs;
  89     unsigned char       *eom, *p;
  90     int                 ancount, err, rc, type, class, dx_count, rr_len;
  91     int                 dx_pref[ MAX_TO_SORT ];
  92
  93 #ifdef LDAP_DEBUG
  94 #ifdef notdef
  95     if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
  96                 __p_query( answer );
  97     }
  98 #endif
  99 #endif /* LDAP_DEBUG */
 100
 101     dxs = NULL;
 102     hp = (HEADER *)answer;
 103     eom = answer + len;
 104
 105     if ( ntohs( hp->qdcount ) != 1 ) {
 106         h_errno = NO_RECOVERY;
 107         return( NULL );
 108     }
 109
 110     ancount = ntohs( hp->ancount );
 111     if ( ancount < 1 ) {
 112         h_errno = NO_DATA;
 113         return( NULL );
 114     }
 115
 116     /*
 117      * skip over the query
 118      */
 119     p = answer + HFIXEDSZ;
 120     if (( rc = dn_expand( answer, eom, p, buf, sizeof( buf ))) < 0 ) {
 121         h_errno = NO_RECOVERY;
 122         return( NULL );
 123     }
 124     p += ( rc + QFIXEDSZ );
 125
 126     /*
 127      * pull out the answers we are interested in
 128      */
 129     err = dx_count = 0;
 130     while ( ancount > 0 && err == 0 && p < eom ) {
 131         if (( rc = dn_expand( answer, eom, p, buf, sizeof( buf ))) < 0 ) {
 132             err = NO_RECOVERY;
 133             continue;
 134         }
 135         p += rc;        /* skip over name */
 136         type = _getshort( p );
 137         p += INT16SZ;
 138         class = _getshort( p );
 139         p += INT16SZ;
 140         p += INT32SZ;           /* skip over TTL */
 141         rr_len = _getshort( p );
 142         p += INT16SZ;
 143         if ( class == C_IN && type == T_TXT ) {
 144             int         i, n, pref, txt_len;
 145             char        *q, *r;
 146
 147             q = (char *)p;
 148             while ( q < (char *)p + rr_len && err == 0 ) {
 149                 if ( *q >= 3 && strncasecmp( q + 1, "dx:", 3 ) == 0 ) {
 150                     txt_len = *q - 3;
 151                     r = q + 4;
 152                     while ( isspace( *r )) {
 153                         ++r;
 154                         --txt_len;
 155                     }
 156                     pref = 0;
 157                     while ( isdigit( *r )) {
 158                         pref *= 10;
 159                         pref += ( *r - '0' );
 160                         ++r;
 161                         --txt_len;
 162                     }
 163                     if ( dx_count < MAX_TO_SORT - 1 ) {
 164                         dx_pref[ dx_count ] = pref;
 165                     }
 166                     while ( isspace( *r )) {
 167                         ++r;
 168                         --txt_len;
 169                     }
 170                     if ( dx_count == 0 ) {
 171                         dxs = (char **)malloc( 2 * sizeof( char * ));
 172                     } else {
 173                         dxs = (char **)realloc( dxs,
 174                                 ( dx_count + 2 ) * sizeof( char * ));
 175                     }
 176                     if ( dxs == NULL || ( dxs[ dx_count ] =
 177                                 (char *)calloc( 1, txt_len + 1 )) == NULL ) {
 178                         err = NO_RECOVERY;
 179                         continue;
 180                     }
 181                     memcpy( dxs[ dx_count ], r, txt_len );
 182                     dxs[ ++dx_count ] = NULL;
 183                 }
 184                 q += ( *q + 1 );        /* move past last TXT record */
 185             }
 186         }
 187         p += rr_len;
 188     }
 189
 190     if ( err == 0 ) {
 191         if ( dx_count == 0 ) {
 192             err = NO_DATA;
 193         } else {
 194             /*
 195              * sort records based on associated preference value
 196              */
 197             int         i, j, sort_count, tmp_pref;
 198             char        *tmp_dx;
 199
 200             sort_count = ( dx_count < MAX_TO_SORT ) ? dx_count : MAX_TO_SORT;
 201             for ( i = 0; i < sort_count; ++i ) {
 202                 for ( j = i + 1; j < sort_count; ++j ) {
 203                     if ( dx_pref[ i ] > dx_pref[ j ] ) {
 204                         tmp_pref = dx_pref[ i ];
 205                         dx_pref[ i ] = dx_pref[ j ];
 206                         dx_pref[ j ] = tmp_pref;
 207                         tmp_dx = dxs[ i ];
 208                         dxs[ i ] = dxs[ j ];
 209                         dxs[ j ] = tmp_dx;
 210                     }
 211                 }
 212             }
 213         }
 214     }
 215
 216     h_errno = err;
 217     return( dxs );
 218 }
 219
 220 #endif /* LDAP_DNS */