← Back to branch summary

~ubuntu-branches/ubuntu/trusty/openldap/trusty-updates

« back to all changes in this revision

Viewing changes to servers/slapd/overlays/accesslog.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-01-23 10:01:13 UTC
  • mfrom: (1.3.4)
  • mto: This revision was merged to the branch mainline in revision 47.
  • Revision ID: package-import@ubuntu.com-20120123100113-z3mg83hvuplv9lyj
Tags: upstream-2.4.28
Import upstream version 2.4.28

Show diffs side-by-side

added added

removed removed

Lines of Context:
servers/slapd/overlays/accesslog.c
1
1
/* accesslog.c - log operations for audit/history purposes */
2
 
/* $OpenLDAP: pkg/ldap/servers/slapd/overlays/accesslog.c,v 1.37.2.34 2011/01/26 23:23:34 quanah Exp $ */
 
2
/* $OpenLDAP$ */
3
3
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4
4
 *
5
5
 * Copyright 2005-2011 The OpenLDAP Foundation.
56
56
        AttributeDescription *attr;
57
57
} log_attr;
58
58
 
 
59
typedef struct log_base {
 
60
        struct log_base *lb_next;
 
61
        slap_mask_t lb_ops;
 
62
        struct berval lb_base;
 
63
        struct berval lb_line;
 
64
} log_base;
 
65
 
59
66
typedef struct log_info {
60
67
        BackendDB *li_db;
61
68
        struct berval li_db_suffix;
67
74
        Entry *li_old;
68
75
        log_attr *li_oldattrs;
69
76
        int li_success;
 
77
        log_base *li_bases;
70
78
        ldap_pvt_thread_rmutex_t li_op_rmutex;
71
79
        ldap_pvt_thread_mutex_t li_log_mutex;
72
80
} log_info;
79
87
        LOG_PURGE,
80
88
        LOG_SUCCESS,
81
89
        LOG_OLD,
82
 
        LOG_OLDATTR
 
90
        LOG_OLDATTR,
 
91
        LOG_BASE
83
92
};
84
93
 
85
94
static ConfigTable log_cfats[] = {
110
119
                        "DESC 'Log old values of these attributes even if unmodified' "
111
120
                        "EQUALITY caseIgnoreMatch "
112
121
                        "SYNTAX OMsDirectoryString )", NULL, NULL },
 
122
        { "logbase", "op|writes|reads|session|all< <baseDN", 3, 3, 0,
 
123
                ARG_MAGIC|LOG_BASE,
 
124
                log_cf_gen, "( OLcfgOvAt:4.7 NAME 'olcAccessLogBase' "
 
125
                        "DESC 'Operation types to log under a specific branch' "
 
126
                        "EQUALITY caseIgnoreMatch "
 
127
                        "SYNTAX OMsDirectoryString )", NULL, NULL },
113
128
        { NULL }
114
129
};
115
130
 
120
135
                "SUP olcOverlayConfig "
121
136
                "MUST olcAccessLogDB "
122
137
                "MAY ( olcAccessLogOps $ olcAccessLogPurge $ olcAccessLogSuccess $ "
123
 
                        "olcAccessLogOld $ olcAccessLogOldAttr ) )",
 
138
                        "olcAccessLogOld $ olcAccessLogOldAttr $ olcAccessLogBase ) )",
124
139
                        Cft_Overlay, log_cfats },
125
140
        { NULL }
126
141
};
785
800
                        else
786
801
                                rc = 1;
787
802
                        break;
 
803
                case LOG_BASE:
 
804
                        if ( li->li_bases ) {
 
805
                                log_base *lb;
 
806
 
 
807
                                for ( lb = li->li_bases; lb; lb=lb->lb_next )
 
808
                                        value_add_one( &c->rvalue_vals, &lb->lb_line );
 
809
                        }
 
810
                        else
 
811
                                rc = 1;
 
812
                        break;
788
813
                }
789
814
                break;
790
815
        case LDAP_MOD_DELETE:
843
868
                                ch_free( la );
844
869
                        }
845
870
                        break;
 
871
                case LOG_BASE:
 
872
                        if ( c->valx < 0 ) {
 
873
                                log_base *lb, *ln;
 
874
 
 
875
                                for ( lb = li->li_bases; lb; lb = ln ) {
 
876
                                        ln = lb->lb_next;
 
877
                                        ch_free( lb );
 
878
                                }
 
879
                        } else {
 
880
                                log_base *lb = NULL, **lp;
 
881
                                int i;
 
882
 
 
883
                                for ( lp = &li->li_bases, i=0; i < c->valx; i++ ) {
 
884
                                        lb = *lp;
 
885
                                        lp = &lb->lb_next;
 
886
                                }
 
887
                                *lp = lb->lb_next;
 
888
                                ch_free( lb );
 
889
                        }
 
890
                        break;
846
891
                }
847
892
                break;
848
893
        default:
926
971
                        }
927
972
                        }
928
973
                        break;
 
974
                case LOG_BASE: {
 
975
                        slap_mask_t m = 0;
 
976
                        rc = verbstring_to_mask( logops, c->argv[1], '|', &m );
 
977
                        if ( rc == 0 ) {
 
978
                                struct berval dn, ndn;
 
979
                                ber_str2bv( c->argv[2], 0, 0, &dn );
 
980
                                rc = dnNormalize( 0, NULL, NULL, &dn, &ndn, NULL );
 
981
                                if ( rc == 0 ) {
 
982
                                        log_base *lb;
 
983
                                        struct berval mbv;
 
984
                                        char *ptr;
 
985
                                        mask_to_verbstring( logops, m, '|', &mbv );
 
986
                                        lb = ch_malloc( sizeof( log_base ) + mbv.bv_len + ndn.bv_len + 3 + 1 );
 
987
                                        lb->lb_line.bv_val = (char *)(lb + 1);
 
988
                                        lb->lb_line.bv_len = mbv.bv_len + ndn.bv_len + 3;
 
989
                                        ptr = lutil_strcopy( lb->lb_line.bv_val, mbv.bv_val );
 
990
                                        *ptr++ = ' ';
 
991
                                        *ptr++ = '"';
 
992
                                        lb->lb_base.bv_val = ptr;
 
993
                                        lb->lb_base.bv_len = ndn.bv_len;
 
994
                                        ptr = lutil_strcopy( ptr, ndn.bv_val );
 
995
                                        *ptr++ = '"';
 
996
                                        lb->lb_ops = m;
 
997
                                        lb->lb_next = li->li_bases;
 
998
                                        li->li_bases = lb;
 
999
                                } else {
 
1000
                                        snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s invalid DN: %s",
 
1001
                                                c->argv[0], c->argv[2] );
 
1002
                                        Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
 
1003
                                                "%s: %s\n", c->log, c->cr_msg, 0 );
 
1004
                                        rc = ARG_BAD_CONF;
 
1005
                                }
 
1006
                        } else {
 
1007
                                snprintf( c->cr_msg, sizeof( c->cr_msg ), "%s invalid ops: %s",
 
1008
                                        c->argv[0], c->argv[1] );
 
1009
                                Debug( LDAP_DEBUG_CONFIG|LDAP_DEBUG_NONE,
 
1010
                                        "%s: %s\n", c->log, c->cr_msg, 0 );
 
1011
                                rc = ARG_BAD_CONF;
 
1012
                        }
 
1013
                        }
 
1014
                        break;
929
1015
                }
930
1016
                break;
931
1017
        }
1369
1455
        }       /* Unbind and Abandon never reach here */
1370
1456
 
1371
1457
        lo = logops+logop+EN_OFFSET;
1372
 
        if ( !( li->li_ops & lo->mask ))
1373
 
                return SLAP_CB_CONTINUE;
 
1458
        if ( !( li->li_ops & lo->mask )) {
 
1459
                log_base *lb;
 
1460
 
 
1461
                i = 0;
 
1462
                for ( lb = li->li_bases; lb; lb=lb->lb_next )
 
1463
                        if (( lb->lb_ops & lo->mask ) && dnIsSuffix( &op->o_req_ndn, &lb->lb_base )) {
 
1464
                                i = 1;
 
1465
                                break;
 
1466
                        }
 
1467
                if ( !i )
 
1468
                        return SLAP_CB_CONTINUE;
 
1469
        }
1374
1470
 
1375
1471
        if ( lo->mask & LOG_OP_WRITES ) {
1376
1472
                slap_callback *cb;
1609
1705
                if ( !BER_BVISEMPTY( &op->ors_filterstr ))
1610
1706
                        attr_merge_one( e, ad_reqFilter, &op->ors_filterstr, NULL );
1611
1707
                if ( op->ors_attrs ) {
 
1708
                        int j;
1612
1709
                        /* count them */
1613
1710
                        for (i=0; !BER_BVISNULL(&op->ors_attrs[i].an_name );i++)
1614
1711
                                ;
1615
1712
                        vals = op->o_tmpalloc( (i+1) * sizeof(struct berval),
1616
1713
                                op->o_tmpmemctx );
1617
 
                        for (i=0; !BER_BVISNULL(&op->ors_attrs[i].an_name );i++)
1618
 
                                vals[i] = op->ors_attrs[i].an_name;
1619
 
                        vals[i].bv_val = NULL;
1620
 
                        vals[i].bv_len = 0;
 
1714
                        for (i=0, j=0; !BER_BVISNULL(&op->ors_attrs[i].an_name );i++) {
 
1715
                                if (!BER_BVISEMPTY(&op->ors_attrs[i].an_name)) {
 
1716
                                        vals[j] = op->ors_attrs[i].an_name;
 
1717
                                        j++;
 
1718
                                }
 
1719
                        }
 
1720
                        BER_BVZERO(&vals[j]);
1621
1721
                        attr_merge( e, ad_reqAttr, vals, NULL );
1622
1722
                        op->o_tmpfree( vals, op->o_tmpmemctx );
1623
1723
                }
1759
1859
{
1760
1860
        slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
1761
1861
        log_info *li = on->on_bi.bi_private;
 
1862
        int doit = 0;
1762
1863
 
1763
1864
        /* These internal ops are not logged */
1764
1865
        if ( op->o_dont_replicate && op->orm_no_opattrs )
1765
1866
                return SLAP_CB_CONTINUE;
1766
1867
 
 
1868
 
1767
1869
        if ( li->li_ops & LOG_OP_WRITES ) {
 
1870
                doit = 1;
 
1871
        } else {
 
1872
                log_base *lb;
 
1873
                for ( lb = li->li_bases; lb; lb = lb->lb_next )
 
1874
                        if (( lb->lb_ops & LOG_OP_WRITES ) && dnIsSuffix( &op->o_req_ndn, &lb->lb_base )) {
 
1875
                                doit = 1;
 
1876
                                break;
 
1877
                        }
 
1878
        }
 
1879
                        
 
1880
        if ( doit ) {
1768
1881
                slap_callback *cb = op->o_tmpalloc( sizeof( slap_callback ), op->o_tmpmemctx ), *cb2;
1769
1882
                cb->sc_cleanup = accesslog_mod_cleanup;
1770
1883
                cb->sc_response = NULL;
1807
1920
                SlapReply rs2 = {REP_RESULT};
1808
1921
                Entry *e;
1809
1922
 
1810
 
                if ( !( li->li_ops & LOG_OP_UNBIND ))
1811
 
                        return SLAP_CB_CONTINUE;
 
1923
                if ( !( li->li_ops & LOG_OP_UNBIND )) {
 
1924
                        log_base *lb;
 
1925
                        int i = 0;
 
1926
 
 
1927
                        for ( lb = li->li_bases; lb; lb=lb->lb_next )
 
1928
                                if (( lb->lb_ops & LOG_OP_UNBIND ) && dnIsSuffix( &op->o_ndn, &lb->lb_base )) {
 
1929
                                        i = 1;
 
1930
                                        break;
 
1931
                                }
 
1932
                        if ( !i )
 
1933
                                return SLAP_CB_CONTINUE;
 
1934
                }
1812
1935
 
1813
1936
                e = accesslog_entry( op, rs, LOG_EN_UNBIND, &op2 );
1814
1937
                op2.o_hdr = op->o_hdr;
1842
1965
        char buf[64];
1843
1966
        struct berval bv;
1844
1967
 
1845
 
        if ( !op->o_time || !( li->li_ops & LOG_OP_ABANDON ))
 
1968
        if ( !op->o_time )
1846
1969
                return SLAP_CB_CONTINUE;
1847
1970
 
 
1971
        if ( !( li->li_ops & LOG_OP_ABANDON )) {
 
1972
                log_base *lb;
 
1973
                int i = 0;
 
1974
 
 
1975
                for ( lb = li->li_bases; lb; lb=lb->lb_next )
 
1976
                        if (( lb->lb_ops & LOG_OP_ABANDON ) && dnIsSuffix( &op->o_ndn, &lb->lb_base )) {
 
1977
                                i = 1;
 
1978
                                break;
 
1979
                        }
 
1980
                if ( !i )
 
1981
                        return SLAP_CB_CONTINUE;
 
1982
        }
 
1983
 
1848
1984
        e = accesslog_entry( op, rs, LOG_EN_ABANDON, &op2 );
1849
1985
        bv.bv_val = buf;
1850
1986
        bv.bv_len = snprintf( buf, sizeof( buf ), "%d", op->orn_msgid );
1974
2110
                AttributeDescription *ad = NULL;
1975
2111
                const char *text = NULL;
1976
2112
                Entry *e_ctx;
 
2113
                BackendDB db;
1977
2114
 
1978
2115
                e = entry_alloc();
1979
2116
                ber_dupbv( &e->e_name, li->li_db->be_suffix );
2018
2155
                        }
2019
2156
                        be_entry_release_rw( op, e_ctx, 0 );
2020
2157
                }
2021
 
                op->o_bd = li->li_db;
 
2158
                db = *li->li_db;
 
2159
                op->o_bd = &db;
2022
2160
 
2023
2161
                op->ora_e = e;
2024
2162
                op->o_req_dn = e->e_name;
2026
2164
                op->o_callback = &nullsc;
2027
2165
                SLAP_DBFLAGS( op->o_bd ) |= SLAP_DBFLAG_NOLASTMOD;
2028
2166
                rc = op->o_bd->be_add( op, &rs );
2029
 
                SLAP_DBFLAGS( op->o_bd ) ^= SLAP_DBFLAG_NOLASTMOD;
2030
2167
                if ( e == op->ora_e )
2031
2168
                        entry_free( e );
2032
2169
        }