git.sur5r.net Git - openldap/blob - 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-2006 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 "ldif.h"
  33
  34 typedef struct auditlog_data {
  35         ldap_pvt_thread_mutex_t ad_mutex;
  36         char *ad_logfile;
  37 } auditlog_data;
  38
  39 static int fprint_ldif(FILE *f, char *name, char *val, ber_len_t len) {
  40         char *s;
  41         if((s = ldif_put(LDIF_PUT_VALUE, name, val, len)) == NULL)
  42                 return(-1);
  43         fputs(s, f);
  44         ber_memfree(s);
  45         return(0);
  46 }
  47
  48 static int auditlog_response(Operation *op, SlapReply *rs) {
  49         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
  50         auditlog_data *ad = on->on_bi.bi_private;
  51         FILE *f;
  52         Attribute *a;
  53         Modifications *m;
  54         struct berval *b, *who = NULL;
  55         char *what, *suffix;
  56         long stamp = slap_get_time();
  57         int i;
  58
  59         if ( rs->sr_err != LDAP_SUCCESS ) return SLAP_CB_CONTINUE;
  60
  61         if ( !ad->ad_logfile ) return SLAP_CB_CONTINUE;
  62
  63 /*
  64 ** add or modify: use modifiersName if present
  65 **
  66 */
  67         switch(op->o_tag) {
  68                 case LDAP_REQ_MODRDN:   what = "modrdn";        break;
  69                 case LDAP_REQ_DELETE:   what = "delete";        break;
  70                 case LDAP_REQ_ADD:
  71                         what = "add";
  72                         for(a = op->ora_e->e_attrs; a; a = a->a_next)
  73                                 if( a->a_desc == slap_schema.si_ad_modifiersName ) {
  74                                         who = &a->a_vals[0];
  75                                         break;
  76                                 }
  77                         break;
  78                 case LDAP_REQ_MODIFY:
  79                         what = "modify";
  80                         for(m = op->orm_modlist; m; m = m->sml_next)
  81                                 if( m->sml_desc == slap_schema.si_ad_modifiersName &&
  82                                         ( m->sml_op == LDAP_MOD_ADD ||
  83                                         m->sml_op == LDAP_MOD_REPLACE )) {
  84                                         who = &m->sml_values[0];
  85                                         break;
  86                                 }
  87                         break;
  88                 default:
  89                         return SLAP_CB_CONTINUE;
  90         }
  91
  92         suffix = op->o_bd->be_suffix[0].bv_len ? op->o_bd->be_suffix[0].bv_val :
  93                 "global";
  94
  95 /*
  96 ** note: this means requestor's dn when modifiersName is null
  97 */
  98         if ( !who )
  99                 who = &op->o_dn;
 100
 101         ldap_pvt_thread_mutex_lock(&ad->ad_mutex);
 102         if((f = fopen(ad->ad_logfile, "a")) == NULL) {
 103                 ldap_pvt_thread_mutex_unlock(&ad->ad_mutex);
 104                 return SLAP_CB_CONTINUE;
 105         }
 106
 107         fprintf(f, "# %s %ld %s%s%s\n",
 108                 what, stamp, suffix, who ? " " : "", who ? who->bv_val : "");
 109
 110         if ( !who || !dn_match( who, &op->o_conn->c_dn ))
 111                 fprintf(f, "# realdn: %s\n", op->o_conn->c_dn.bv_val ? op->o_conn->c_dn.bv_val :
 112                         "<empty>" );
 113
 114         fprintf(f, "dn: %s\nchangetype: %s\n",
 115                 op->o_req_dn.bv_val, what);
 116
 117         switch(op->o_tag) {
 118           case LDAP_REQ_ADD:
 119                 for(a = op->ora_e->e_attrs; a; a = a->a_next)
 120                   if((b = a->a_vals) != NULL)
 121                         for(i = 0; b[i].bv_val; i++)
 122                                 fprint_ldif(f, a->a_desc->ad_cname.bv_val, b[i].bv_val, b[i].bv_len);
 123                 break;
 124
 125           case LDAP_REQ_MODIFY:
 126                 for(m = op->orm_modlist; m; m = m->sml_next) {
 127                         switch(m->sml_op & LDAP_MOD_OP) {
 128                                 case LDAP_MOD_ADD:       what = "add";          break;
 129                                 case LDAP_MOD_REPLACE:   what = "replace";      break;
 130                                 case LDAP_MOD_DELETE:    what = "delete";       break;
 131                                 case LDAP_MOD_INCREMENT: what = "increment";    break;
 132                                 default:
 133                                         fprintf(f, "# MOD_TYPE_UNKNOWN:%02x\n", m->sml_op & LDAP_MOD_OP);
 134                                         continue;
 135                         }
 136                         fprintf(f, "%s: %s\n", what, m->sml_desc->ad_cname.bv_val);
 137                         if((b = m->sml_values) != NULL)
 138                           for(i = 0; b[i].bv_val; i++)
 139                                 fprint_ldif(f, m->sml_desc->ad_cname.bv_val, b[i].bv_val, b[i].bv_len);
 140                         fprintf(f, "-\n");
 141                 }
 142                 break;
 143
 144           case LDAP_REQ_MODRDN:
 145                 fprintf(f, "newrdn: %s\ndeleteoldrdn: %s\n",
 146                         op->orr_newrdn.bv_val, op->orr_deleteoldrdn ? "1" : "0");
 147                 if(op->orr_newSup) fprintf(f, "newsuperior: %s\n", op->orr_newSup->bv_val);
 148                 break;
 149
 150           case LDAP_REQ_DELETE:
 151                 /* nothing else needed */
 152                 break;
 153         }
 154
 155         fprintf(f, "# end %s %ld\n\n", what, stamp);
 156
 157         fclose(f);
 158         ldap_pvt_thread_mutex_unlock(&ad->ad_mutex);
 159         return SLAP_CB_CONTINUE;
 160 }
 161
 162 static slap_overinst auditlog;
 163
 164 static int
 165 auditlog_db_init(
 166         BackendDB *be
 167 )
 168 {
 169         slap_overinst *on = (slap_overinst *)be->bd_info;
 170         auditlog_data *ad = ch_malloc(sizeof(auditlog_data));
 171
 172         on->on_bi.bi_private = ad;
 173         ldap_pvt_thread_mutex_init( &ad->ad_mutex );
 174         return 0;
 175 }
 176
 177 static int
 178 auditlog_db_close(
 179         BackendDB *be
 180 )
 181 {
 182         slap_overinst *on = (slap_overinst *)be->bd_info;
 183         auditlog_data *ad = on->on_bi.bi_private;
 184
 185         free( ad->ad_logfile );
 186         ad->ad_logfile = NULL;
 187         return 0;
 188 }
 189
 190 static int
 191 auditlog_db_destroy(
 192         BackendDB *be
 193 )
 194 {
 195         slap_overinst *on = (slap_overinst *)be->bd_info;
 196         auditlog_data *ad = on->on_bi.bi_private;
 197
 198         ldap_pvt_thread_mutex_destroy( &ad->ad_mutex );
 199         free( ad );
 200         return 0;
 201 }
 202
 203 static int
 204 auditlog_config(
 205         BackendDB       *be,
 206         const char      *fname,
 207         int             lineno,
 208         int             argc,
 209         char    **argv
 210 )
 211 {
 212         slap_overinst *on = (slap_overinst *) be->bd_info;
 213         auditlog_data *ad = on->on_bi.bi_private;
 214
 215         /* history log file */
 216         if ( strcasecmp( argv[0], "auditlog" ) == 0 ) {
 217                 if ( argc < 2 ) {
 218                         Debug( LDAP_DEBUG_ANY,
 219             "%s: line %d: missing filename in \"auditlog <filename>\" line\n",
 220                             fname, lineno, 0 );
 221                                 return( 1 );
 222                 }
 223                 ad->ad_logfile = ch_strdup( argv[1] );
 224                 return 0;
 225         }
 226         return SLAP_CONF_UNKNOWN;
 227 }
 228
 229 int auditlog_initialize() {
 230
 231         auditlog.on_bi.bi_type = "auditlog";
 232         auditlog.on_bi.bi_db_init = auditlog_db_init;
 233         auditlog.on_bi.bi_db_config = auditlog_config;
 234         auditlog.on_bi.bi_db_close = auditlog_db_close;
 235         auditlog.on_bi.bi_db_destroy = auditlog_db_destroy;
 236         auditlog.on_response = auditlog_response;
 237
 238         return overlay_register(&auditlog);
 239 }
 240
 241 #if SLAPD_OVER_AUDITLOG == SLAPD_MOD_DYNAMIC && defined(PIC)
 242 int
 243 init_module( int argc, char *argv[] )
 244 {
 245         return auditlog_initialize();
 246 }
 247 #endif
 248
 249 #endif /* SLAPD_OVER_AUDITLOG */