git.sur5r.net Git - openldap/blob - servers/slapd/back-ldbm/attr.c

   1 /* attr.c - backend routines for dealing with attributes */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/socket.h>
  13 #include <ac/string.h>
  14
  15 #include "slap.h"
  16 #include "back-ldbm.h"
  17
  18 /* for the cache of attribute information (which are indexed, etc.) */
  19 typedef struct ldbm_attrinfo {
  20         char    *ai_type;       /* type name (cn, sn, ...)      */
  21         int     ai_indexmask;   /* how the attr is indexed      */
  22 } AttrInfo;
  23
  24 static int
  25 ainfo_type_cmp(
  26     char                *type,
  27     AttrInfo    *a
  28 )
  29 {
  30         return( strcasecmp( type, a->ai_type ) );
  31 }
  32
  33 static int
  34 ainfo_cmp(
  35     AttrInfo    *a,
  36     AttrInfo    *b
  37 )
  38 {
  39         return( strcasecmp( a->ai_type, b->ai_type ) );
  40 }
  41
  42 /*
  43  * Called when a duplicate "index" line is encountered.
  44  *
  45  * returns 1 => original from init code, indexmask updated
  46  *         2 => original not from init code, warn the user
  47  */
  48
  49 static int
  50 ainfo_dup(
  51     AttrInfo    *a,
  52     AttrInfo    *b
  53 )
  54 {
  55         /*
  56          * if the duplicate definition is because we initialized the attr,
  57          * just add what came from the config file. otherwise, complain.
  58          */
  59         if ( a->ai_indexmask & SLAP_INDEX_FROMINIT ) {
  60                 a->ai_indexmask |= b->ai_indexmask;
  61
  62                 return( 1 );
  63         }
  64
  65         return( 2 );
  66 }
  67
  68 void
  69 attr_mask(
  70     struct ldbminfo     *li,
  71     char                *type,
  72     int                 *indexmask )
  73 {
  74         AttrInfo        *a;
  75
  76         *indexmask = 0;
  77         if ( (a = (AttrInfo *) avl_find( li->li_attrs, type,
  78             (AVL_CMP) ainfo_type_cmp )) == NULL ) {
  79                 if ( (a = (AttrInfo *) avl_find( li->li_attrs, "default",
  80                     (AVL_CMP) ainfo_type_cmp )) == NULL ) {
  81                         return;
  82                 }
  83         }
  84         *indexmask = a->ai_indexmask;
  85 }
  86
  87 void
  88 attr_index_config(
  89     struct ldbminfo     *li,
  90     const char          *fname,
  91     int                 lineno,
  92     int                 argc,
  93     char                **argv,
  94     int                 init
  95 )
  96 {
  97         int             i, j;
  98         char            **attrs, **indexes;
  99         AttrInfo        *a;
 100
 101         attrs = str2charray( argv[0], "," );
 102         if ( argc > 1 ) {
 103                 indexes = str2charray( argv[1], "," );
 104         }
 105         for ( i = 0; attrs[i] != NULL; i++ ) {
 106                 a = (AttrInfo *) ch_malloc( sizeof(AttrInfo) );
 107                 a->ai_type = ch_strdup( attrs[i] );
 108
 109                 if ( argc == 1 ) {
 110                         a->ai_indexmask = (
 111                                 SLAP_INDEX_PRESENCE | SLAP_INDEX_EQUALITY |
 112                             SLAP_INDEX_APPROX | SLAP_INDEX_SUB);
 113                 } else {
 114                         a->ai_indexmask = 0;
 115                         for ( j = 0; indexes[j] != NULL; j++ ) {
 116                                 if ( strncasecmp( indexes[j], "pres", 4 )
 117                                     == 0 ) {
 118                                         a->ai_indexmask |= SLAP_INDEX_PRESENCE;
 119                                 } else if ( strncasecmp( indexes[j], "eq", 2 )
 120                                     == 0 ) {
 121                                         a->ai_indexmask |= SLAP_INDEX_EQUALITY;
 122                                 } else if ( strncasecmp( indexes[j], "approx",
 123                                     6 ) == 0 ) {
 124                                         a->ai_indexmask |= SLAP_INDEX_APPROX;
 125                                 } else if ( strncasecmp( indexes[j], "sub", 3 )
 126                                     == 0 ) {
 127                                         a->ai_indexmask |= SLAP_INDEX_SUB;
 128                                 } else if ( strncasecmp( indexes[j], "none", 4 )
 129                                     == 0 ) {
 130                                         if ( a->ai_indexmask != 0 ) {
 131                                                 fprintf( stderr,
 132 "%s: line %d: index type \"none\" cannot be combined with other types\n",
 133                                                     fname, lineno );
 134                                         }
 135                                         a->ai_indexmask = 0;
 136                                 } else {
 137                                         fprintf( stderr,
 138                         "%s: line %d: unknown index type \"%s\" (ignored)\n",
 139                                             fname, lineno, indexes[j] );
 140                                         fprintf( stderr,
 141         "valid index types are \"pres\", \"eq\", \"approx\", or \"sub\"\n" );
 142                                 }
 143                         }
 144                 }
 145                 if ( init ) {
 146                         a->ai_indexmask |= SLAP_INDEX_FROMINIT;
 147                 }
 148
 149                 switch (avl_insert( &li->li_attrs, (caddr_t) a,
 150                         (AVL_CMP) ainfo_cmp, (AVL_DUP) ainfo_dup ))
 151                 {
 152                 case 1:         /* duplicate - updating init version */
 153                         free( a->ai_type );
 154                         free( (char *) a );
 155                         break;
 156
 157                 case 2:         /* user duplicate - ignore and warn */
 158                         fprintf( stderr,
 159     "%s: line %d: duplicate index definition for attr \"%s\" (ignored)\n",
 160                             fname, lineno, a->ai_type );
 161                         free( a->ai_type );
 162                         free( (char *) a );
 163                         break;
 164
 165                 default:;       /* inserted ok */
 166                         /* FALL */
 167                 }
 168         }
 169         charray_free( attrs );
 170         if ( argc > 1 )
 171                 charray_free( indexes );
 172 }
 173
 174
 175 static void
 176 ainfo_free( void *attr )
 177 {
 178         AttrInfo *ai = attr;
 179         free( ai->ai_type );
 180         free( ai );
 181 }
 182
 183 void
 184 attr_index_destroy( Avlnode *tree )
 185 {
 186         avl_free( tree, ainfo_free );
 187 }
 188