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

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