← Back to branch summary

~ubuntu-branches/ubuntu/maverick/openldap/maverick-proposed

« back to all changes in this revision

Viewing changes to servers/slapd/bconfig.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug
  • Date: 2009-09-07 13:41:10 UTC
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: james.westby@ubuntu.com-20090907134110-jsdrvn0atu1fex4m
Tags: upstream-2.4.18
Import upstream version 2.4.18

Show diffs side-by-side

added added

removed removed

Lines of Context:
servers/slapd/bconfig.c
1
1
/* bconfig.c - the config backend */
2
 
/* $OpenLDAP: pkg/ldap/servers/slapd/bconfig.c,v 1.202.2.68 2009/06/08 18:24:59 quanah Exp $ */
 
2
/* $OpenLDAP: pkg/ldap/servers/slapd/bconfig.c,v 1.202.2.74 2009/08/25 22:44:24 quanah Exp $ */
3
3
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4
4
 *
5
5
 * Copyright 2005-2009 The OpenLDAP Foundation.
120
120
static ConfigDriver config_overlay;
121
121
static ConfigDriver config_subordinate; 
122
122
static ConfigDriver config_suffix; 
 
123
#ifdef LDAP_TCP_BUFFER
 
124
static ConfigDriver config_tcp_buffer; 
 
125
#endif /* LDAP_TCP_BUFFER */
123
126
static ConfigDriver config_rootdn;
124
127
static ConfigDriver config_rootpw;
125
128
static ConfigDriver config_restrict;
261
264
 * OLcfgOv{Oc|At}:18                    -> memberof
262
265
 * OLcfgOv{Oc|At}:19                    -> collect
263
266
 * OLcfgOv{Oc|At}:20                    -> retcode
 
267
 * OLcfgOv{Oc|At}:21                    -> sssvlv
264
268
 */
265
269
 
266
270
/* alphabetical ordering */
373
377
        { "include", "file", 2, 2, 0, ARG_MAGIC,
374
378
                &config_include, "( OLcfgGlAt:19 NAME 'olcInclude' "
375
379
                        "SUP labeledURI )", NULL, NULL },
376
 
        { "index_substr_if_minlen", "min", 2, 2, 0, ARG_INT|ARG_NONZERO|ARG_MAGIC|CFG_SSTR_IF_MIN,
 
380
        { "index_substr_if_minlen", "min", 2, 2, 0, ARG_UINT|ARG_NONZERO|ARG_MAGIC|CFG_SSTR_IF_MIN,
377
381
                &config_generic, "( OLcfgGlAt:20 NAME 'olcIndexSubstrIfMinLen' "
378
382
                        "SYNTAX OMsInteger SINGLE-VALUE )", NULL, NULL },
379
 
        { "index_substr_if_maxlen", "max", 2, 2, 0, ARG_INT|ARG_NONZERO|ARG_MAGIC|CFG_SSTR_IF_MAX,
 
383
        { "index_substr_if_maxlen", "max", 2, 2, 0, ARG_UINT|ARG_NONZERO|ARG_MAGIC|CFG_SSTR_IF_MAX,
380
384
                &config_generic, "( OLcfgGlAt:21 NAME 'olcIndexSubstrIfMaxLen' "
381
385
                        "SYNTAX OMsInteger SINGLE-VALUE )", NULL, NULL },
382
386
        { "index_substr_any_len", "len", 2, 2, 0, ARG_INT|ARG_NONZERO,
603
607
                &syncrepl_config, "( OLcfgDbAt:0.11 NAME 'olcSyncrepl' "
604
608
                        "EQUALITY caseIgnoreMatch "
605
609
                        "SYNTAX OMsDirectoryString X-ORDERED 'VALUES' )", NULL, NULL },
 
610
        { "tcp-buffer", "[listener=<listener>] [{read|write}=]size", 0, 0, 0,
 
611
#ifndef LDAP_TCP_BUFFER
 
612
                ARG_IGNORED, NULL,
 
613
#else /* LDAP_TCP_BUFFER */
 
614
                ARG_MAGIC, &config_tcp_buffer,
 
615
#endif /* LDAP_TCP_BUFFER */
 
616
                        "( OLcfgGlAt:90 NAME 'olcTCPBuffer' "
 
617
                        "DESC 'Custom TCP buffer size' "
 
618
                        "SYNTAX OMsDirectoryString )", NULL, NULL },
606
619
        { "threads", "count", 2, 2, 0,
607
620
#ifdef NO_THREADS
608
621
                ARG_IGNORED, NULL,
771
784
                 "olcSaslAuxprops $ olcSaslHost $ olcSaslRealm $ olcSaslSecProps $ "
772
785
                 "olcSecurity $ olcServerID $ olcSizeLimit $ "
773
786
                 "olcSockbufMaxIncoming $ olcSockbufMaxIncomingAuth $ "
 
787
                 "olcTCPBuffer $ "
774
788
                 "olcThreads $ olcTimeLimit $ olcTLSCACertificateFile $ "
775
789
                 "olcTLSCACertificatePath $ olcTLSCertificateFile $ "
776
790
                 "olcTLSCertificateKeyFile $ olcTLSCipherSuite $ olcTLSCRLCheck $ "
1080
1094
                        c->value_int = (SLAP_DBMONITORING(c->be) != 0);
1081
1095
                        break;
1082
1096
                case CFG_SSTR_IF_MAX:
1083
 
                        c->value_int = index_substr_if_maxlen;
 
1097
                        c->value_uint = index_substr_if_maxlen;
1084
1098
                        break;
1085
1099
                case CFG_SSTR_IF_MIN:
1086
 
                        c->value_int = index_substr_if_minlen;
 
1100
                        c->value_uint = index_substr_if_minlen;
1087
1101
                        break;
1088
1102
                case CFG_IX_INTLEN:
1089
1103
                        c->value_int = index_intlen;
1823
1837
                                *sip = si;
1824
1838
 
1825
1839
                                if (( slapMode & SLAP_SERVER_MODE ) && c->argc > 2 ) {
1826
 
                                        Listener **l = slapd_get_listeners();
1827
 
                                        int i, isMe = 0;
1828
 
 
1829
 
                                        /* Try a straight compare with Listener strings */
1830
 
                                        for ( i=0; l && l[i]; i++ ) {
1831
 
                                                if ( !strcasecmp( c->argv[2], l[i]->sl_url.bv_val )) {
1832
 
                                                        isMe = 1;
1833
 
                                                        break;
1834
 
                                                }
1835
 
                                        }
1836
 
 
1837
 
                                        /* If hostname is empty, or is localhost, or matches
1838
 
                                         * our hostname, this serverID refers to this host.
1839
 
                                         * Compare it against listeners and ports.
1840
 
                                         */
1841
 
                                        if ( !isMe && ( !lud->lud_host || !lud->lud_host[0] ||
1842
 
                                                !strncasecmp("localhost", lud->lud_host,
1843
 
                                                        STRLENOF("localhost")) ||
1844
 
                                                !strcasecmp( global_host, lud->lud_host ))) {
1845
 
 
1846
 
                                                for ( i=0; l && l[i]; i++ ) {
1847
 
                                                        LDAPURLDesc *lu2;
1848
 
                                                        ldap_url_parse( l[i]->sl_url.bv_val, &lu2 );
1849
 
                                                        do {
1850
 
                                                                if ( strcasecmp( lud->lud_scheme,
1851
 
                                                                        lu2->lud_scheme ))
1852
 
                                                                        break;
1853
 
                                                                if ( lud->lud_port != lu2->lud_port )
1854
 
                                                                        break;
1855
 
                                                                /* Listener on ANY address */
1856
 
                                                                if ( !lu2->lud_host || !lu2->lud_host[0] ) {
1857
 
                                                                        isMe = 1;
1858
 
                                                                        break;
1859
 
                                                                }
1860
 
                                                                /* URL on ANY address */
1861
 
                                                                if ( !lud->lud_host || !lud->lud_host[0] ) {
1862
 
                                                                        isMe = 1;
1863
 
                                                                        break;
1864
 
                                                                }
1865
 
                                                                /* Listener has specific host, must
1866
 
                                                                 * match it
1867
 
                                                                 */
1868
 
                                                                if ( !strcasecmp( lud->lud_host,
1869
 
                                                                        lu2->lud_host )) {
1870
 
                                                                        isMe = 1;
1871
 
                                                                        break;
1872
 
                                                                }
1873
 
                                                        } while(0);
1874
 
                                                        ldap_free_urldesc( lu2 );
1875
 
                                                        if ( isMe ) {
1876
 
                                                                break;
1877
 
                                                        }
1878
 
                                                }
1879
 
                                        }
1880
 
                                        if ( isMe ) {
 
1840
                                        Listener *l = config_check_my_url( c->argv[2], lud );
 
1841
                                        if ( l ) {
1881
1842
                                                slap_serverID = si->si_num;
1882
1843
                                                Debug( LDAP_DEBUG_CONFIG,
1883
1844
                                                        "%s: SID=%d (listener=%s)\n",
1884
1845
                                                        c->log, slap_serverID,
1885
 
                                                        l[i]->sl_url.bv_val );
 
1846
                                                        l->sl_url.bv_val );
1886
1847
                                        }
1887
1848
                                }
1888
1849
                                if ( c->argc > 2 )
1911
1872
                        break;
1912
1873
 
1913
1874
                case CFG_MIRRORMODE:
1914
 
                        if(!SLAP_SHADOW(c->be)) {
 
1875
                        if(c->value_int && !SLAP_SHADOW(c->be)) {
1915
1876
                                snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> database is not a shadow",
1916
1877
                                        c->argv[0] );
1917
1878
                                Debug(LDAP_DEBUG_ANY, "%s: %s\n",
1939
1900
                        break;
1940
1901
 
1941
1902
                case CFG_SSTR_IF_MAX:
1942
 
                        if (c->value_int < index_substr_if_minlen) {
 
1903
                        if (c->value_uint < index_substr_if_minlen) {
1943
1904
                                snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> invalid value", c->argv[0] );
1944
1905
                                Debug(LDAP_DEBUG_ANY, "%s: %s (%d)\n",
1945
1906
                                        c->log, c->cr_msg, c->value_int );
1946
1907
                                return(1);
1947
1908
                        }
1948
 
                        index_substr_if_maxlen = c->value_int;
 
1909
                        index_substr_if_maxlen = c->value_uint;
1949
1910
                        break;
1950
1911
 
1951
1912
                case CFG_SSTR_IF_MIN:
1952
 
                        if (c->value_int > index_substr_if_maxlen) {
 
1913
                        if (c->value_uint > index_substr_if_maxlen) {
1953
1914
                                snprintf( c->cr_msg, sizeof( c->cr_msg ), "<%s> invalid value", c->argv[0] );
1954
1915
                                Debug(LDAP_DEBUG_ANY, "%s: %s (%d)\n",
1955
1916
                                        c->log, c->cr_msg, c->value_int );
1956
1917
                                return(1);
1957
1918
                        }
1958
 
                        index_substr_if_minlen = c->value_int;
 
1919
                        index_substr_if_minlen = c->value_uint;
1959
1920
                        break;
1960
1921
 
1961
1922
#ifdef SLAPD_MODULES
2324
2285
config_subordinate(ConfigArgs *c)
2325
2286
{
2326
2287
        int rc = 1;
2327
 
        int advertise;
 
2288
        int advertise = 0;
2328
2289
 
2329
2290
        switch( c->op ) {
2330
2291
        case SLAP_CONFIG_EMIT:
2349
2310
                break;
2350
2311
        case LDAP_MOD_ADD:
2351
2312
        case SLAP_CONFIG_ADD:
2352
 
                advertise = ( c->argc == 2 && !strcasecmp( c->argv[1], "advertise" ));
 
2313
                if ( c->be->be_nsuffix == NULL ) {
 
2314
                        /* log error */
 
2315
                        snprintf( c->cr_msg, sizeof( c->cr_msg),
 
2316
                                "subordinate configuration needs a suffix" );
 
2317
                        Debug( LDAP_DEBUG_ANY,
 
2318
                                "%s: %s.\n",
 
2319
                                c->log, c->cr_msg, 0 );
 
2320
                        rc = 1;
 
2321
                        break;
 
2322
                }
 
2323
 
 
2324
                if ( c->argc == 2 ) {
 
2325
                        if ( strcasecmp( c->argv[1], "advertise" ) == 0 ) {
 
2326
                                advertise = 1;
 
2327
 
 
2328
                        } else if ( strcasecmp( c->argv[1], "TRUE" ) != 0 ) {
 
2329
                                /* log error */
 
2330
                                snprintf( c->cr_msg, sizeof( c->cr_msg),
 
2331
                                        "subordinate must be \"TRUE\" or \"advertise\"" );
 
2332
                                Debug( LDAP_DEBUG_ANY,
 
2333
                                        "%s: suffix \"%s\": %s.\n",
 
2334
                                        c->log, c->be->be_suffix[0].bv_val, c->cr_msg );
 
2335
                                rc = 1;
 
2336
                                break;
 
2337
                        }
 
2338
                }
 
2339
 
2353
2340
                rc = glue_sub_add( c->be, advertise, CONFIG_ONLINE_ADD( c ));
2354
2341
                break;
2355
2342
        }
2356
 
        return rc;
2357
 
}
 
2343
 
 
2344
        return rc;
 
2345
}
 
2346
 
 
2347
/*
 
2348
 * [listener=<listener>] [{read|write}=]<size>
 
2349
 */
 
2350
 
 
2351
#ifdef LDAP_TCP_BUFFER
 
2352
static BerVarray tcp_buffer;
 
2353
int tcp_buffer_num;
 
2354
 
 
2355
#define SLAP_TCP_RMEM (0x1U)
 
2356
#define SLAP_TCP_WMEM (0x2U)
 
2357
 
 
2358
static int
 
2359
tcp_buffer_parse( struct berval *val, int argc, char **argv,
 
2360
                int *size, int *rw, Listener **l )
 
2361
{
 
2362
        int i, rc = LDAP_SUCCESS;
 
2363
        LDAPURLDesc *lud = NULL;
 
2364
        char *ptr;
 
2365
 
 
2366
        if ( val != NULL && argv == NULL ) {
 
2367
                char *s = val->bv_val;
 
2368
 
 
2369
                argv = ldap_str2charray( s, " \t" );
 
2370
                if ( argv == NULL ) {
 
2371
                        return LDAP_OTHER;
 
2372
                }
 
2373
        }
 
2374
 
 
2375
        i = 0;
 
2376
        if ( strncasecmp( argv[ i ], "listener=", STRLENOF( "listener=" ) )
 
2377
                == 0 )
 
2378
        {
 
2379
                char *url = argv[ i ] + STRLENOF( "listener=" );
 
2380
                
 
2381
                if ( ldap_url_parse( url, &lud ) ) {
 
2382
                        rc = LDAP_INVALID_SYNTAX;
 
2383
                        goto done;
 
2384
                }
 
2385
 
 
2386
                *l = config_check_my_url( url, lud );
 
2387
                if ( *l == NULL ) {
 
2388
                        rc = LDAP_NO_SUCH_ATTRIBUTE;
 
2389
                        goto done;
 
2390
                }
 
2391
 
 
2392
                i++;
 
2393
        }
 
2394
 
 
2395
        ptr = argv[ i ];
 
2396
        if ( strncasecmp( ptr, "read=", STRLENOF( "read=" ) ) == 0 ) {
 
2397
                *rw |= SLAP_TCP_RMEM;
 
2398
                ptr += STRLENOF( "read=" );
 
2399
 
 
2400
        } else if ( strncasecmp( ptr, "write=", STRLENOF( "write=" ) ) == 0 ) {
 
2401
                *rw |= SLAP_TCP_WMEM;
 
2402
                ptr += STRLENOF( "write=" );
 
2403
 
 
2404
        } else {
 
2405
                *rw |= ( SLAP_TCP_RMEM | SLAP_TCP_WMEM );
 
2406
        }
 
2407
 
 
2408
        /* accept any base */
 
2409
        if ( lutil_atoix( size, ptr, 0 ) ) {
 
2410
                rc = LDAP_INVALID_SYNTAX;
 
2411
                goto done;
 
2412
        }
 
2413
 
 
2414
done:;
 
2415
        if ( val != NULL && argv != NULL ) {
 
2416
                ldap_charray_free( argv );
 
2417
        }
 
2418
 
 
2419
        if ( lud != NULL ) {
 
2420
                ldap_free_urldesc( lud );
 
2421
        }
 
2422
 
 
2423
        return rc;
 
2424
}
 
2425
 
 
2426
static int
 
2427
tcp_buffer_delete_one( struct berval *val )
 
2428
{
 
2429
        int rc = 0;
 
2430
        int size = -1, rw = 0;
 
2431
        Listener *l = NULL;
 
2432
 
 
2433
        rc = tcp_buffer_parse( val, 0, NULL, &size, &rw, &l );
 
2434
        if ( rc != 0 ) {
 
2435
                return rc;
 
2436
        }
 
2437
 
 
2438
        if ( l != NULL ) {
 
2439
                int i;
 
2440
                Listener **ll = slapd_get_listeners();
 
2441
 
 
2442
                for ( i = 0; ll[ i ] != NULL; i++ ) {
 
2443
                        if ( ll[ i ] == l ) break;
 
2444
                }
 
2445
 
 
2446
                if ( ll[ i ] == NULL ) {
 
2447
                        return LDAP_NO_SUCH_ATTRIBUTE;
 
2448
                }
 
2449
 
 
2450
                if ( rw & SLAP_TCP_RMEM ) l->sl_tcp_rmem = -1;
 
2451
                if ( rw & SLAP_TCP_WMEM ) l->sl_tcp_wmem = -1;
 
2452
 
 
2453
                for ( i++ ; ll[ i ] != NULL && bvmatch( &l->sl_url, &ll[ i ]->sl_url ); i++ ) {
 
2454
                        if ( rw & SLAP_TCP_RMEM ) ll[ i ]->sl_tcp_rmem = -1;
 
2455
                        if ( rw & SLAP_TCP_WMEM ) ll[ i ]->sl_tcp_wmem = -1;
 
2456
                }
 
2457
 
 
2458
        } else {
 
2459
                /* NOTE: this affects listeners without a specific setting,
 
2460
                 * does not reset all listeners.  If a listener without
 
2461
                 * specific settings was assigned a buffer because of
 
2462
                 * a global setting, it will not be reset.  In any case,
 
2463
                 * buffer changes will only take place at restart. */
 
2464
                if ( rw & SLAP_TCP_RMEM ) slapd_tcp_rmem = -1;
 
2465
                if ( rw & SLAP_TCP_WMEM ) slapd_tcp_wmem = -1;
 
2466
        }
 
2467
 
 
2468
        return rc;
 
2469
}
 
2470
 
 
2471
static int
 
2472
tcp_buffer_delete( BerVarray vals )
 
2473
{
 
2474
        int i;
 
2475
 
 
2476
        for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
 
2477
                tcp_buffer_delete_one( &vals[ i ] );
 
2478
        }
 
2479
 
 
2480
        return 0;
 
2481
}
 
2482
 
 
2483
static int
 
2484
tcp_buffer_unparse( int idx, int size, int rw, Listener *l, struct berval *val )
 
2485
{
 
2486
        char buf[sizeof("2147483648")], *ptr;
 
2487
 
 
2488
        /* unparse for later use */
 
2489
        val->bv_len = snprintf( buf, sizeof( buf ), "%d", size );
 
2490
        if ( l != NULL ) {
 
2491
                val->bv_len += STRLENOF( "listener=" " " ) + l->sl_url.bv_len;
 
2492
        }
 
2493
 
 
2494
        if ( rw != ( SLAP_TCP_RMEM | SLAP_TCP_WMEM ) ) {
 
2495
                if ( rw & SLAP_TCP_RMEM ) {
 
2496
                        val->bv_len += STRLENOF( "read=" );
 
2497
                } else if ( rw & SLAP_TCP_WMEM ) {
 
2498
                        val->bv_len += STRLENOF( "write=" );
 
2499
                }
 
2500
        }
 
2501
 
 
2502
        val->bv_val = SLAP_MALLOC( val->bv_len + 1 );
 
2503
 
 
2504
        ptr = val->bv_val;
 
2505
 
 
2506
        if ( l != NULL ) {
 
2507
                ptr = lutil_strcopy( ptr, "listener=" );
 
2508
                ptr = lutil_strncopy( ptr, l->sl_url.bv_val, l->sl_url.bv_len );
 
2509
                *ptr++ = ' ';
 
2510
        }
 
2511
 
 
2512
        if ( rw != ( SLAP_TCP_RMEM | SLAP_TCP_WMEM ) ) {
 
2513
                if ( rw & SLAP_TCP_RMEM ) {
 
2514
                        ptr = lutil_strcopy( ptr, "read=" );
 
2515
                } else if ( rw & SLAP_TCP_WMEM ) {
 
2516
                        ptr = lutil_strcopy( ptr, "write=" );
 
2517
                }
 
2518
        }
 
2519
 
 
2520
        ptr = lutil_strcopy( ptr, buf );
 
2521
        *ptr = '\0';
 
2522
 
 
2523
        assert( val->bv_val + val->bv_len == ptr );
 
2524
 
 
2525
        return LDAP_SUCCESS;
 
2526
}
 
2527
 
 
2528
static int
 
2529
tcp_buffer_add_one( int argc, char **argv, int idx )
 
2530
{
 
2531
        int rc = 0;
 
2532
        int size = -1, rw = 0;
 
2533
        Listener *l = NULL;
 
2534
 
 
2535
        struct berval val;
 
2536
 
 
2537
        /* parse */
 
2538
        rc = tcp_buffer_parse( NULL, argc, argv, &size, &rw, &l );
 
2539
        if ( rc != 0 ) {
 
2540
                return rc;
 
2541
        }
 
2542
 
 
2543
        /* unparse for later use */
 
2544
        rc = tcp_buffer_unparse( idx, size, rw, l, &val );
 
2545
        if ( rc != LDAP_SUCCESS ) {
 
2546
                return rc;
 
2547
        }
 
2548
 
 
2549
        /* use parsed values */
 
2550
        if ( l != NULL ) {
 
2551
                int i;
 
2552
                Listener **ll = slapd_get_listeners();
 
2553
 
 
2554
                for ( i = 0; ll[ i ] != NULL; i++ ) {
 
2555
                        if ( ll[ i ] == l ) break;
 
2556
                }
 
2557
 
 
2558
                if ( ll[ i ] == NULL ) {
 
2559
                        return LDAP_NO_SUCH_ATTRIBUTE;
 
2560
                }
 
2561
 
 
2562
                /* buffer only applies to TCP listeners;
 
2563
                 * we do not do any check here, and delegate them
 
2564
                 * to setsockopt(2) */
 
2565
                if ( rw & SLAP_TCP_RMEM ) l->sl_tcp_rmem = size;
 
2566
                if ( rw & SLAP_TCP_WMEM ) l->sl_tcp_wmem = size;
 
2567
 
 
2568
                for ( i++ ; ll[ i ] != NULL && bvmatch( &l->sl_url, &ll[ i ]->sl_url ); i++ ) {
 
2569
                        if ( rw & SLAP_TCP_RMEM ) ll[ i ]->sl_tcp_rmem = size;
 
2570
                        if ( rw & SLAP_TCP_WMEM ) ll[ i ]->sl_tcp_wmem = size;
 
2571
                }
 
2572
 
 
2573
        } else {
 
2574
                /* NOTE: this affects listeners without a specific setting,
 
2575
                 * does not set all listeners */
 
2576
                if ( rw & SLAP_TCP_RMEM ) slapd_tcp_rmem = size;
 
2577
                if ( rw & SLAP_TCP_WMEM ) slapd_tcp_wmem = size;
 
2578
        }
 
2579
 
 
2580
        tcp_buffer = SLAP_REALLOC( tcp_buffer, sizeof( struct berval ) * ( tcp_buffer_num + 2 ) );
 
2581
        /* append */
 
2582
        idx = tcp_buffer_num;
 
2583
        tcp_buffer[ idx ] = val;
 
2584
 
 
2585
        tcp_buffer_num++;
 
2586
        BER_BVZERO( &tcp_buffer[ tcp_buffer_num ] );
 
2587
 
 
2588
        return rc;
 
2589
}
 
2590
 
 
2591
static int
 
2592
config_tcp_buffer( ConfigArgs *c )
 
2593
{
 
2594
        if ( c->op == SLAP_CONFIG_EMIT ) {
 
2595
                if ( tcp_buffer == NULL || BER_BVISNULL( &tcp_buffer[ 0 ] ) ) {
 
2596
                        return 1;
 
2597
                }
 
2598
                value_add( &c->rvalue_vals, tcp_buffer );
 
2599
                value_add( &c->rvalue_nvals, tcp_buffer );
 
2600
                
 
2601
        } else if ( c->op == LDAP_MOD_DELETE ) {
 
2602
                if ( !c->line  ) {
 
2603
                        tcp_buffer_delete( tcp_buffer );
 
2604
                        ber_bvarray_free( tcp_buffer );
 
2605
                        tcp_buffer = NULL;
 
2606
                        tcp_buffer_num = 0;
 
2607
 
 
2608
                } else {
 
2609
                        int rc = 0;
 
2610
                        int size = -1, rw = 0;
 
2611
                        Listener *l = NULL;
 
2612
 
 
2613
                        struct berval val = BER_BVNULL;
 
2614
 
 
2615
                        int i;
 
2616
 
 
2617
                        if ( tcp_buffer_num == 0 ) {
 
2618
                                return 1;
 
2619
                        }
 
2620
 
 
2621
                        /* parse */
 
2622
                        rc = tcp_buffer_parse( NULL, c->argc - 1, &c->argv[ 1 ], &size, &rw, &l );
 
2623
                        if ( rc != 0 ) {
 
2624
                                return 1;
 
2625
                        }
 
2626
 
 
2627
                        /* unparse for later use */
 
2628
                        rc = tcp_buffer_unparse( tcp_buffer_num, size, rw, l, &val );
 
2629
                        if ( rc != LDAP_SUCCESS ) {
 
2630
                                return 1;
 
2631
                        }
 
2632
 
 
2633
                        for ( i = 0; !BER_BVISNULL( &tcp_buffer[ i ] ); i++ ) {
 
2634
                                if ( bvmatch( &tcp_buffer[ i ], &val ) ) {
 
2635
                                        break;
 
2636
                                }
 
2637
                        }
 
2638
 
 
2639
                        if ( BER_BVISNULL( &tcp_buffer[ i ] ) ) {
 
2640
                                /* not found */
 
2641
                                rc = 1;
 
2642
                                goto done;
 
2643
                        }
 
2644
 
 
2645
                        tcp_buffer_delete_one( &tcp_buffer[ i ] );
 
2646
                        ber_memfree( tcp_buffer[ i ].bv_val );
 
2647
                        for ( ; i < tcp_buffer_num; i++ ) {
 
2648
                                tcp_buffer[ i ] = tcp_buffer[ i + 1 ];
 
2649
                        }
 
2650
                        tcp_buffer_num--;
 
2651
 
 
2652
done:;
 
2653
                        if ( !BER_BVISNULL( &val ) ) {
 
2654
                                SLAP_FREE( val.bv_val );
 
2655
                        }
 
2656
        
 
2657
                }
 
2658
 
 
2659
        } else {
 
2660
                int rc;
 
2661
                int idx;
 
2662
 
 
2663
                rc = tcp_buffer_add_one( c->argc - 1, &c->argv[ 1 ], idx );
 
2664
                if ( rc ) {
 
2665
                        snprintf( c->cr_msg, sizeof( c->cr_msg ),
 
2666
                                "<%s> unable to add value #%d",
 
2667
                                c->argv[0], idx );
 
2668
                        Debug( LDAP_DEBUG_ANY, "%s: %s\n",
 
2669
                                c->log, c->cr_msg, 0 );
 
2670
                        return 1;
 
2671
                }
 
2672
        }
 
2673
 
 
2674
        return 0;
 
2675
}
 
2676
#endif /* LDAP_TCP_BUFFER */
2358
2677
 
2359
2678
static int
2360
2679
config_suffix(ConfigArgs *c)
3112
3431
}
3113
3432
 
3114
3433
int
3115
 
config_shadow( ConfigArgs *c, int flag )
 
3434
config_shadow( ConfigArgs *c, slap_mask_t flag )
3116
3435
{
3117
3436
        char    *notallowed = NULL;
3118
3437
 
3131
3450
        if ( SLAP_SHADOW(c->be) ) {
3132
3451
                /* if already shadow, only check consistency */
3133
3452
                if ( ( SLAP_DBFLAGS(c->be) & flag ) != flag ) {
3134
 
                        Debug( LDAP_DEBUG_ANY, "%s: inconsistent shadow flag 0x%x.\n", c->log, flag, 0 );
 
3453
                        Debug( LDAP_DEBUG_ANY, "%s: inconsistent shadow flag 0x%lx.\n",
 
3454
                                c->log, flag, 0 );
3135
3455
                        return 1;
3136
3456
                }
3137
3457