]> git.sur5r.net Git - openldap/blob - servers/slapd/overlays/auditlog.c
ITS#5705
[openldap] / servers / slapd / overlays / auditlog.c
1 /* auditlog.c - log modifications for audit/history purposes */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 2005-2008 The OpenLDAP Foundation.
6  * Portions copyright 2004-2005 Symas Corporation.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted only as authorized by the OpenLDAP
11  * Public License.
12  *
13  * A copy of this license is available in the file LICENSE in the
14  * top-level directory of the distribution or, alternatively, at
15  * <http://www.OpenLDAP.org/license.html>.
16  */
17 /* ACKNOWLEDGEMENTS:
18  * This work was initially developed by Symas Corp. for inclusion in
19  * OpenLDAP Software.  This work was sponsored by Hewlett-Packard.
20  */
21
22 #include "portable.h"
23
24 #ifdef SLAPD_OVER_AUDITLOG
25
26 #include <stdio.h>
27
28 #include <ac/string.h>
29 #include <ac/ctype.h>
30
31 #include "slap.h"
32 #include "config.h"
33 #include "ldif.h"
34
35 typedef struct auditlog_data {
36         ldap_pvt_thread_mutex_t ad_mutex;
37         char *ad_logfile;
38 } auditlog_data;
39
40 static ConfigTable auditlogcfg[] = {
41         { "auditlog", "filename", 2, 2, 0,
42           ARG_STRING|ARG_OFFSET,
43           (void *)offsetof(auditlog_data, ad_logfile),
44           "( OLcfgOvAt:15.1 NAME 'olcAuditlogFile' "
45           "DESC 'Filename for auditlogging' "
46           "SYNTAX OMsDirectoryString )", NULL, NULL },
47         { NULL, NULL, 0, 0, 0, ARG_IGNORED }
48 };
49
50 static ConfigOCs auditlogocs[] = {
51         { "( OLcfgOvOc:15.1 "
52           "NAME 'olcAuditlogConfig' "
53           "DESC 'Auditlog configuration' "
54           "SUP olcOverlayConfig "
55           "MAY ( olcAuditlogFile ) )",
56           Cft_Overlay, auditlogcfg },
57         { NULL, 0, NULL }
58 };
59
60 static int fprint_ldif(FILE *f, char *name, char *val, ber_len_t len) {
61         char *s;
62         if((s = ldif_put(LDIF_PUT_VALUE, name, val, len)) == NULL)
63                 return(-1);
64         fputs(s, f);
65         ber_memfree(s);
66         return(0);
67 }
68
69 static int auditlog_response(Operation *op, SlapReply *rs) {
70         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
71         auditlog_data *ad = on->on_bi.bi_private;
72         FILE *f;
73         Attribute *a;
74         Modifications *m;
75         struct berval *b, *who = NULL;
76         char *what, *suffix;
77         time_t stamp;
78         int i;
79
80         if ( rs->sr_err != LDAP_SUCCESS ) return SLAP_CB_CONTINUE;
81
82         if ( !ad->ad_logfile ) return SLAP_CB_CONTINUE;
83
84 /*
85 ** add or modify: use modifiersName if present
86 **
87 */
88         switch(op->o_tag) {
89                 case LDAP_REQ_MODRDN:   what = "modrdn";        break;
90                 case LDAP_REQ_DELETE:   what = "delete";        break;
91                 case LDAP_REQ_ADD:
92                         what = "add";
93                         for(a = op->ora_e->e_attrs; a; a = a->a_next)
94                                 if( a->a_desc == slap_schema.si_ad_modifiersName ) {
95                                         who = &a->a_vals[0];
96                                         break;
97                                 }
98                         break;
99                 case LDAP_REQ_MODIFY:
100                         what = "modify";
101                         for(m = op->orm_modlist; m; m = m->sml_next)
102                                 if( m->sml_desc == slap_schema.si_ad_modifiersName &&
103                                         ( m->sml_op == LDAP_MOD_ADD ||
104                                         m->sml_op == LDAP_MOD_REPLACE )) {
105                                         who = &m->sml_values[0];
106                                         break;
107                                 }
108                         break;
109                 default:
110                         return SLAP_CB_CONTINUE;
111         }
112
113         suffix = op->o_bd->be_suffix[0].bv_len ? op->o_bd->be_suffix[0].bv_val :
114                 "global";
115
116 /*
117 ** note: this means requestor's dn when modifiersName is null
118 */
119         if ( !who )
120                 who = &op->o_dn;
121
122         ldap_pvt_thread_mutex_lock(&ad->ad_mutex);
123         if((f = fopen(ad->ad_logfile, "a")) == NULL) {
124                 ldap_pvt_thread_mutex_unlock(&ad->ad_mutex);
125                 return SLAP_CB_CONTINUE;
126         }
127
128         stamp = slap_get_time();
129         fprintf(f, "# %s %ld %s%s%s\n",
130                 what, (long)stamp, suffix, who ? " " : "", who ? who->bv_val : "");
131
132         if ( !BER_BVISEMPTY( &op->o_conn->c_dn ) &&
133                 (!who || !dn_match( who, &op->o_conn->c_dn )))
134                 fprintf(f, "# realdn: %s\n", op->o_conn->c_dn.bv_val );
135
136         fprintf(f, "dn: %s\nchangetype: %s\n",
137                 op->o_req_dn.bv_val, what);
138
139         switch(op->o_tag) {
140           case LDAP_REQ_ADD:
141                 for(a = op->ora_e->e_attrs; a; a = a->a_next)
142                   if((b = a->a_vals) != NULL)
143                         for(i = 0; b[i].bv_val; i++)
144                                 fprint_ldif(f, a->a_desc->ad_cname.bv_val, b[i].bv_val, b[i].bv_len);
145                 break;
146
147           case LDAP_REQ_MODIFY:
148                 for(m = op->orm_modlist; m; m = m->sml_next) {
149                         switch(m->sml_op & LDAP_MOD_OP) {
150                                 case LDAP_MOD_ADD:       what = "add";          break;
151                                 case LDAP_MOD_REPLACE:   what = "replace";      break;
152                                 case LDAP_MOD_DELETE:    what = "delete";       break;
153                                 case LDAP_MOD_INCREMENT: what = "increment";    break;
154                                 default:
155                                         fprintf(f, "# MOD_TYPE_UNKNOWN:%02x\n", m->sml_op & LDAP_MOD_OP);
156                                         continue;
157                         }
158                         fprintf(f, "%s: %s\n", what, m->sml_desc->ad_cname.bv_val);
159                         if((b = m->sml_values) != NULL)
160                           for(i = 0; b[i].bv_val; i++)
161                                 fprint_ldif(f, m->sml_desc->ad_cname.bv_val, b[i].bv_val, b[i].bv_len);
162                         fprintf(f, "-\n");
163                 }
164                 break;
165
166           case LDAP_REQ_MODRDN:
167                 fprintf(f, "newrdn: %s\ndeleteoldrdn: %s\n",
168                         op->orr_newrdn.bv_val, op->orr_deleteoldrdn ? "1" : "0");
169                 if(op->orr_newSup) fprintf(f, "newsuperior: %s\n", op->orr_newSup->bv_val);
170                 break;
171
172           case LDAP_REQ_DELETE:
173                 /* nothing else needed */
174                 break;
175         }
176
177         fprintf(f, "# end %s %ld\n\n", what, (long)stamp);
178
179         fclose(f);
180         ldap_pvt_thread_mutex_unlock(&ad->ad_mutex);
181         return SLAP_CB_CONTINUE;
182 }
183
184 static slap_overinst auditlog;
185
186 static int
187 auditlog_db_init(
188         BackendDB *be,
189         ConfigReply *cr
190 )
191 {
192         slap_overinst *on = (slap_overinst *)be->bd_info;
193         auditlog_data *ad = ch_calloc(1, sizeof(auditlog_data));
194
195         on->on_bi.bi_private = ad;
196         ldap_pvt_thread_mutex_init( &ad->ad_mutex );
197         return 0;
198 }
199
200 static int
201 auditlog_db_close(
202         BackendDB *be,
203         ConfigReply *cr
204 )
205 {
206         slap_overinst *on = (slap_overinst *)be->bd_info;
207         auditlog_data *ad = on->on_bi.bi_private;
208
209         free( ad->ad_logfile );
210         ad->ad_logfile = NULL;
211         return 0;
212 }
213
214 static int
215 auditlog_db_destroy(
216         BackendDB *be,
217         ConfigReply *cr
218 )
219 {
220         slap_overinst *on = (slap_overinst *)be->bd_info;
221         auditlog_data *ad = on->on_bi.bi_private;
222
223         ldap_pvt_thread_mutex_destroy( &ad->ad_mutex );
224         free( ad );
225         return 0;
226 }
227
228 int auditlog_initialize() {
229         int rc;
230
231         auditlog.on_bi.bi_type = "auditlog";
232         auditlog.on_bi.bi_db_init = auditlog_db_init;
233         auditlog.on_bi.bi_db_close = auditlog_db_close;
234         auditlog.on_bi.bi_db_destroy = auditlog_db_destroy;
235         auditlog.on_response = auditlog_response;
236
237         auditlog.on_bi.bi_cf_ocs = auditlogocs;
238         rc = config_register_schema( auditlogcfg, auditlogocs );
239         if ( rc ) return rc;
240
241         return overlay_register(&auditlog);
242 }
243
244 #if SLAPD_OVER_AUDITLOG == SLAPD_MOD_DYNAMIC && defined(PIC)
245 int
246 init_module( int argc, char *argv[] )
247 {
248         return auditlog_initialize();
249 }
250 #endif
251
252 #endif /* SLAPD_OVER_AUDITLOG */