git.sur5r.net Git - openldap/blob - servers/slapd/overlays/constraint.c

   1 /* constraint.c - Overlay to constrain attributes to certain values */
   2 /*
   3  *
   4  * Copyright 2003-2004 Hewlett-Packard Company
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in the file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15 /*
  16  * Author: Neil Dunbar <neil.dunbar@hp.com>
  17  */
  18 #include "portable.h"
  19
  20 #ifdef SLAPD_OVER_CONSTRAINT
  21
  22 #include <stdio.h>
  23
  24 #include <ac/string.h>
  25 #include <ac/socket.h>
  26 #include <ac/regex.h>
  27
  28 #include "slap.h"
  29 #include "config.h"
  30
  31 /*
  32  * This overlay limits the values which can be placed into an
  33  * attribute, over and above the limits placed by the schema.
  34  *
  35  * It traps only LDAP adds and modify commands (and only seeks to
  36  * control the add and modify value mods of a modify)
  37  */
  38
  39 #define REGEX_STR "regex"
  40
  41 /*
  42  * Linked list of attribute constraints which we should enforce.
  43  * This is probably a sub optimal structure - some form of sorted
  44  * array would be better if the number of attributes contrained is
  45  * likely to be much bigger than 4 or 5. We stick with a list for
  46  * the moment.
  47  */
  48
  49 typedef struct constraint {
  50     struct constraint *ap_next;
  51     AttributeDescription *ap;
  52     regex_t *re;
  53     char *re_str; /* string representation of regex */
  54 } constraint;
  55
  56 enum {
  57     CONSTRAINT_ATTRIBUTE = 1
  58 };
  59
  60 static ConfigDriver constraint_cf_gen;
  61
  62 static ConfigTable constraintcfg[] = {
  63     { "constraint_attribute", "attribute regex <regular expression>",
  64       4, 4, 0, ARG_MAGIC | CONSTRAINT_ATTRIBUTE, constraint_cf_gen,
  65       "( OLcfgOvAt:13.1 NAME 'olcConstraintAttribute' "
  66       "DESC 'regular expression constraint for attribute' "
  67       "SYNTAX OMsDirectoryString )", NULL, NULL },
  68     { NULL, NULL, 0, 0, 0, ARG_IGNORED }
  69 };
  70
  71 static ConfigOCs constraintocs[] = {
  72     { "( OLcfgOvOc:13.1 "
  73       "NAME 'olcConstraintConfig' "
  74       "DESC 'Constraint overlay configuration' "
  75       "SUP olcOverlayConfig "
  76       "MAY ( olcConstraintAttribute ) )",
  77       Cft_Overlay, constraintcfg },
  78     { NULL, 0, NULL }
  79 };
  80
  81 static int
  82 constraint_cf_gen( ConfigArgs *c )
  83 {
  84     slap_overinst *on = (slap_overinst *)(c->bi);
  85     constraint *cn = on->on_bi.bi_private, *cp;
  86     struct berval bv;
  87     int i, rc = 0;
  88     constraint ap = { NULL, NULL, NULL  }, *a2 = NULL;
  89     regmatch_t rm[2];
  90     const char *text = NULL;
  91
  92     switch ( c->op ) {
  93         case SLAP_CONFIG_EMIT:
  94             switch (c->type) {
  95                 case CONSTRAINT_ATTRIBUTE:
  96                     for (cp=cn; cp; cp=cp->ap_next) {
  97                         int len;
  98                         char *s;
  99
 100                         len = cp->ap->ad_cname.bv_len +
 101                             strlen( REGEX_STR ) + strlen( cp->re_str) + 3;
 102                         s = ch_malloc(len);
 103                         if (!s) continue;
 104                         snprintf(s, len, "%s %s %s", cp->ap->ad_cname.bv_val,
 105                                  REGEX_STR, cp->re_str);
 106                         bv.bv_val = s;
 107                         bv.bv_len = strlen(s);
 108                         rc = value_add_one( &c->rvalue_vals, &bv );
 109                         if (rc) return rc;
 110                         rc = value_add_one( &c->rvalue_nvals, &bv );
 111                         if (rc) return rc;
 112                         ch_free(s);
 113                     }
 114                     break;
 115                 default:
 116                     abort();
 117                     break;
 118             }
 119             break;
 120         case LDAP_MOD_DELETE:
 121             switch (c->type) {
 122                 case CONSTRAINT_ATTRIBUTE:
 123                     if (!cn) break; /* nothing to do */
 124
 125                     if (c->valx < 0) {
 126                             /* zap all constraints */
 127                         while (cn) {
 128                             cp = cn->ap_next;
 129                             if (cn->re) {
 130                                 regfree(cn->re);
 131                                 ch_free(cn->re);
 132                             }
 133                             if (cn->re_str) ch_free(cn->re_str);
 134                             ch_free(cn);
 135                             cn = cp;
 136                         }
 137
 138                         on->on_bi.bi_private = NULL;
 139                     } else {
 140                         constraint **cpp;
 141
 142                             /* zap constraint numbered 'valx' */
 143                         for(i=0, cp = cn, cpp = &cn;
 144                             (cp) && (i<c->valx);
 145                             i++, cpp = &cp->ap_next, cp = *cpp);
 146
 147                         if (cp) {
 148                                 /* zap cp, and join cpp to cp->ap_next */
 149                             *cpp = cp->ap_next;
 150                             if (cp->re) {
 151                                 regfree(cp->re);
 152                                 ch_free(cp->re);
 153                             }
 154                             if (cp->re_str) ch_free(cp->re_str);
 155                             ch_free(cp);
 156                         }
 157                         on->on_bi.bi_private = cn;
 158                     }
 159
 160                     break;
 161                 default:
 162                     abort();
 163                     break;
 164             }
 165             break;
 166         case SLAP_CONFIG_ADD:
 167         case LDAP_MOD_ADD:
 168             switch (c->type) {
 169                 case CONSTRAINT_ATTRIBUTE:
 170                     if ( slap_str2ad( c->argv[1], &ap.ap, &text ) ) {
 171                         Debug( LDAP_DEBUG_CONFIG,
 172                                "constraint_add: <%s>: attribute description unknown %s.\n",
 173                                c->argv[1], text, 0 );
 174                         return( ARG_BAD_CONF );
 175                     }
 176
 177                     if ( strcasecmp( c->argv[2], "regex" ) == 0) {
 178                         int err;
 179
 180                         ap.re = ch_malloc( sizeof(regex_t) );
 181                         if ((err = regcomp( ap.re,
 182                                             c->argv[3], REG_EXTENDED )) != 0) {
 183                             char errmsg[1024];
 184
 185                             regerror( err, ap.re, errmsg, sizeof(errmsg) );
 186                             ch_free(ap.re);
 187                             Debug( LDAP_DEBUG_CONFIG,
 188                                    "%s: Illegal regular expression \"%s\": Error %s\n",
 189                                    c->argv[1], c->argv[3], errmsg);
 190                             ap.re = NULL;
 191                             return( ARG_BAD_CONF );
 192                         }
 193                         ap.re_str = ch_strdup( c->argv[3] );
 194                     } else {
 195                         Debug( LDAP_DEBUG_CONFIG,
 196                                "%s: Unknown constraint type: %s\n",
 197                                c->argv[1], c->argv[2], 0 );
 198                         return ( ARG_BAD_CONF );
 199                     }
 200
 201
 202                     a2 = ch_malloc( sizeof(constraint) );
 203                     a2->ap_next = on->on_bi.bi_private;
 204                     a2->ap = ap.ap;
 205                     a2->re = ap.re;
 206                     a2->re_str = ap.re_str;
 207                     on->on_bi.bi_private = a2;
 208                     break;
 209                 default:
 210                     abort();
 211                     break;
 212             }
 213             break;
 214         default:
 215             abort();
 216     }
 217
 218     return rc;
 219 }
 220
 221 static int
 222 constraint_violation( constraint *c, struct berval *bv )
 223 {
 224     if ((!c) || (!bv)) return 0;
 225
 226     if ((c->re) &&
 227         (regexec(c->re, bv->bv_val, 0, NULL, 0) == REG_NOMATCH))
 228
 229         return 1; /* regular expression violation */
 230
 231     return 0;
 232 }
 233
 234 static char *
 235 print_message( const char *fmt, AttributeDescription *a )
 236 {
 237     char *ret;
 238     int sz;
 239
 240     sz = strlen(fmt) + a->ad_cname.bv_len + 1;
 241     ret = ch_malloc(sz);
 242     snprintf( ret, sz, fmt, a->ad_cname.bv_val );
 243     return ret;
 244 }
 245
 246 static int
 247 constraint_add( Operation *op, SlapReply *rs )
 248 {
 249     slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
 250     Attribute *a;
 251     constraint *c = on->on_bi.bi_private, *cp;
 252     BerVarray b = NULL;
 253     int i;
 254     const char *rsv = "add breaks regular expression constraint on %s";
 255     char *msg;
 256
 257     if ((a = op->ora_e->e_attrs) == NULL) {
 258         op->o_bd->bd_info = (BackendInfo *)(on->on_info);
 259         send_ldap_error(op, rs, LDAP_INVALID_SYNTAX,
 260                         "constraint_add() got null op.ora_e.e_attrs");
 261         return(rs->sr_err);
 262     }
 263
 264     for(; a; a = a->a_next ) {
 265             /* we don't constrain operational attributes */
 266
 267         if (is_at_operational(a->a_desc->ad_type)) continue;
 268
 269         for(cp = c; cp; cp = cp->ap_next) {
 270             if (cp->ap != a->a_desc) continue;
 271             if ((b = a->a_vals) == NULL) continue;
 272
 273             for(i=0; b[i].bv_val; i++) {
 274                 int cv = constraint_violation( cp, &b[i]);
 275
 276                 if (cv) {
 277                         /* regex violation */
 278                     op->o_bd->bd_info = (BackendInfo *)(on->on_info);
 279                     msg = print_message( rsv, a->a_desc );
 280                     send_ldap_error(op, rs, LDAP_CONSTRAINT_VIOLATION, msg );
 281                     ch_free(msg);
 282                     return (rs->sr_err);
 283                 }
 284             }
 285         }
 286     }
 287         /* Default is to just fall through to the normal processing */
 288     return SLAP_CB_CONTINUE;
 289 }
 290
 291 static int
 292 constraint_modify( Operation *op, SlapReply *rs )
 293 {
 294     slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
 295     constraint *c = on->on_bi.bi_private, *cp;
 296     Modifications *m;
 297     BerVarray b = NULL;
 298     int i;
 299     const char *rsv = "modify breaks regular expression constraint on %s";
 300     char *msg;
 301
 302     if ((m = op->orm_modlist) == NULL) {
 303         op->o_bd->bd_info = (BackendInfo *)(on->on_info);
 304         send_ldap_error(op, rs, LDAP_INVALID_SYNTAX,
 305                         "constraint_modify() got null orm_modlist");
 306         return(rs->sr_err);
 307     }
 308
 309     for(;m; m = m->sml_next) {
 310         if (is_at_operational( m->sml_desc->ad_type )) continue;
 311         if ((( m->sml_op & LDAP_MOD_OP ) != LDAP_MOD_ADD) &&
 312             (( m->sml_op & LDAP_MOD_OP ) != LDAP_MOD_REPLACE))
 313             continue;
 314             /* we only care about ADD and REPLACE modifications */
 315         if ((( b = m->sml_values ) == NULL ) || (b[0].bv_val == NULL))
 316             continue;
 317
 318         for(cp = c; cp; cp = cp->ap_next) {
 319             if (cp->ap != m->sml_desc) continue;
 320
 321             for(i=0; b[i].bv_val; i++) {
 322                 int cv = constraint_violation( cp, &b[i]);
 323
 324                 if (cv) {
 325                         /* regex violation */
 326                     op->o_bd->bd_info = (BackendInfo *)(on->on_info);
 327                     msg = print_message( rsv, m->sml_desc );
 328                     send_ldap_error(op, rs, LDAP_CONSTRAINT_VIOLATION, msg );
 329                     ch_free(msg);
 330                     return (rs->sr_err);
 331                 }
 332             }
 333         }
 334     }
 335
 336     return SLAP_CB_CONTINUE;
 337 }
 338
 339 static int
 340 constraint_close(
 341     BackendDB *be
 342     )
 343 {
 344     slap_overinst *on = (slap_overinst *) be->bd_info;
 345     constraint *ap, *a2;
 346
 347     for ( ap = on->on_bi.bi_private; ap; ap = a2 ) {
 348         a2 = ap->ap_next;
 349         if (ap->re_str) ch_free(ap->re_str);
 350         if (ap->re) {
 351             regfree( ap->re );
 352             ch_free( ap->re );
 353         }
 354
 355         ch_free( ap );
 356     }
 357
 358     return 0;
 359 }
 360
 361 static slap_overinst constraint_ovl;
 362
 363 /* This overlay is set up for dynamic loading via moduleload. For static
 364  * configuration, you'll need to arrange for the slap_overinst to be
 365  * initialized and registered by some other function inside slapd.
 366  */
 367
 368 #if SLAPD_OVER_CONSTRAINT == SLAPD_MOD_DYNAMIC
 369 static
 370 #endif
 371 int
 372 constraint_initialize( void ) {
 373     int rc;
 374
 375     constraint_ovl.on_bi.bi_type = "constraint";
 376     constraint_ovl.on_bi.bi_db_close = constraint_close;
 377     constraint_ovl.on_bi.bi_op_add = constraint_add;
 378     constraint_ovl.on_bi.bi_op_modify = constraint_modify;
 379
 380     constraint_ovl.on_bi.bi_private = NULL;
 381
 382     constraint_ovl.on_bi.bi_cf_ocs = constraintocs;
 383     rc = config_register_schema( constraintcfg, constraintocs );
 384     if (rc) return rc;
 385
 386     return overlay_register( &constraint_ovl );
 387 }
 388
 389 #if SLAPD_OVER_CONSTRAINT == SLAPD_MOD_DYNAMIC
 390 int init_module(int argc, char *argv[]) {
 391     return constraint_initialize();
 392 }
 393 #endif
 394
 395 #endif /* defined(SLAPD_OVER_CONSTRAINT) */
 396