dsdb: audit samdb and password changes
[nivanova/samba-autobuild/.git] / source4 / dsdb / samdb / ldb_modules / audit_log.c
1 /*
2    ldb database library
3
4    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 /*
21  * Provide an audit log of changes made to the database and at a
22  * higher level details of any password changes and resets.
23  *
24  */
25
26 #include "includes.h"
27 #include "ldb_module.h"
28 #include "lib/audit_logging/audit_logging.h"
29
30 #include "dsdb/samdb/samdb.h"
31 #include "dsdb/samdb/ldb_modules/util.h"
32 #include "libcli/security/dom_sid.h"
33 #include "auth/common_auth.h"
34 #include "param/param.h"
35
36 #define OPERATION_JSON_TYPE "dsdbChange"
37 #define OPERATION_HR_TAG "DSDB Change"
38 #define OPERATION_MAJOR 1
39 #define OPERATION_MINOR 0
40 #define OPERATION_LOG_LVL 5
41
42 #define PASSWORD_JSON_TYPE "passwordChange"
43 #define PASSWORD_HR_TAG "Password Change"
44 #define PASSWORD_MAJOR 1
45 #define PASSWORD_MINOR 0
46 #define PASSWORD_LOG_LVL 5
47
48 #define TRANSACTION_JSON_TYPE "dsdbTransaction"
49 #define TRANSACTION_HR_TAG "DSDB Transaction"
50 #define TRANSACTION_MAJOR 1
51 #define TRANSACTION_MINOR 0
52 /*
53  * Currently we only log roll backs and prepare commit failures
54  */
55 #define TRANSACTION_LOG_LVL 5
56
57 #define REPLICATION_JSON_TYPE "replicatedUpdate"
58 #define REPLICATION_HR_TAG "Replicated Update"
59 #define REPLICATION_MAJOR 1
60 #define REPLICATION_MINOR 0
61 #define REPLICATION_LOG_LVL 5
62 /*
63  * Attribute values are truncated in the logs if they are longer than
64  * MAX_LENGTH
65  */
66 #define MAX_LENGTH 1024
67
68 #define min(a, b) (((a)>(b))?(b):(a))
69
70 /*
71  * Private data for the module, stored in the ldb_module private data
72  */
73 struct audit_context {
74         /*
75          * Should details of database operations be sent over the
76          * messaging bus.
77          */
78         bool send_samdb_events;
79         /*
80          * Should details of password changes and resets be sent over
81          * the messaging bus.
82          */
83         bool send_password_events;
84         /*
85          * The messaging context to send the messages over.  Will only
86          * be set if send_samdb_events or send_password_events are
87          * true.
88          */
89         struct imessaging_context *msg_ctx;
90         /*
91          * Unique transaction id for the current transaction
92          */
93         struct GUID transaction_guid;
94 };
95
96 /*
97  * @brief Has the password changed.
98  *
99  * Does the message contain a change to one of the password attributes? The
100  * password attributes are defined in DSDB_PASSWORD_ATTRIBUTES
101  *
102  * @return true if the message contains a password attribute
103  *
104  */
105 static bool has_password_changed(const struct ldb_message *message)
106 {
107         int i;
108         if (message == NULL) {
109                 return false;
110         }
111         for (i=0;i<message->num_elements;i++) {
112                 if (dsdb_audit_is_password_attribute(
113                         message->elements[i].name)) {
114                         return true;
115                 }
116         }
117         return false;
118 }
119
120 /*
121  * @brief Is the request a password "Change" or a "Reset"
122  *
123  * Get a description of the action being performed on the user password.  This
124  * routine assumes that the request contains password attributes and that the
125  * password ACL checks have been performed by acl.c
126  *
127  * @param request the ldb_request to inspect
128  * @param reply the ldb_reply, will contain the password controls
129  *
130  * @return "Change" if the password is being changed.
131  *         "Reset"  if the password is being reset.
132  */
133 static const char *get_password_action(
134         const struct ldb_request *request,
135         const struct ldb_reply *reply)
136 {
137         if(request->operation == LDB_ADD) {
138                 return "Reset";
139         } else {
140                 struct ldb_control *pav_ctrl = NULL;
141                 struct dsdb_control_password_acl_validation *pav = NULL;
142
143                 pav_ctrl = ldb_reply_get_control(
144                         discard_const(reply),
145                         DSDB_CONTROL_PASSWORD_ACL_VALIDATION_OID);
146                 if (pav_ctrl == NULL) {
147                         return "Reset";
148                 }
149
150                 pav = talloc_get_type_abort(
151                         pav_ctrl->data,
152                         struct dsdb_control_password_acl_validation);
153
154                 if (pav->pwd_reset) {
155                         return "Reset";
156                 } else {
157                         return "Change";
158                 }
159         }
160 }
161
162
163 #ifdef HAVE_JANSSON
164 /*
165  * @brief generate a JSON object detailing an ldb operation.
166  *
167  * Generate a JSON object detailing an ldb operation.
168  *
169  * @param module the ldb module
170  * @param request the request
171  * @param reply the result of the operation.
172  *
173  * @return the generated JSON object, should be freed with json_free.
174  *
175  */
176 static struct json_object operation_json(
177         struct ldb_module *module,
178         const struct ldb_request *request,
179         const struct ldb_reply *reply)
180 {
181         struct ldb_context *ldb = NULL;
182         const struct dom_sid *sid = NULL;
183         bool as_system = false;
184         struct json_object wrapper;
185         struct json_object audit;
186         const struct tsocket_address *remote = NULL;
187         const char *dn = NULL;
188         const char* operation = NULL;
189         const struct GUID *unique_session_token = NULL;
190         const struct ldb_message *message = NULL;
191         struct audit_context *ac = talloc_get_type(
192                 ldb_module_get_private(module),
193                 struct audit_context);
194
195         ldb = ldb_module_get_ctx(module);
196
197         remote = dsdb_audit_get_remote_address(ldb);
198         if (remote != NULL && dsdb_audit_is_system_session(module)) {
199                 as_system = true;
200                 sid = dsdb_audit_get_actual_sid(ldb);
201                 unique_session_token =
202                         dsdb_audit_get_actual_unique_session_token(ldb);
203         } else {
204                 sid = dsdb_audit_get_user_sid(module);
205                 unique_session_token =
206                         dsdb_audit_get_unique_session_token(module);
207         }
208         dn = dsdb_audit_get_primary_dn(request);
209         operation = dsdb_audit_get_operation_name(request);
210
211         audit = json_new_object();
212         json_add_version(&audit, OPERATION_MAJOR, OPERATION_MINOR);
213         json_add_int(&audit, "statusCode", reply->error);
214         json_add_string(&audit, "status", ldb_strerror(reply->error));
215         json_add_string(&audit, "operation", operation);
216         json_add_address(&audit, "remoteAddress", remote);
217         json_add_bool(&audit, "performedAsSystem", as_system);
218         json_add_sid(&audit, "userSid", sid);
219         json_add_string(&audit, "dn", dn);
220         json_add_guid(&audit, "transactionId", &ac->transaction_guid);
221         json_add_guid(&audit, "sessionId", unique_session_token);
222
223         message = dsdb_audit_get_message(request);
224         if (message != NULL) {
225                 struct json_object attributes =
226                         dsdb_audit_attributes_json(
227                                 request->operation,
228                                 message);
229                 json_add_object(&audit, "attributes", &attributes);
230         }
231
232         wrapper = json_new_object();
233         json_add_timestamp(&wrapper);
234         json_add_string(&wrapper, "type", OPERATION_JSON_TYPE);
235         json_add_object(&wrapper, OPERATION_JSON_TYPE, &audit);
236         return wrapper;
237 }
238
239 /*
240  * @brief generate a JSON object detailing a replicated update.
241  *
242  * Generate a JSON object detailing a replicated update
243  *
244  * @param module the ldb module
245  * @param request the request
246  * @paran reply the result of the operation
247  *
248  * @return the generated JSON object, should be freed with json_free.
249  *
250  */
251 static struct json_object replicated_update_json(
252         struct ldb_module *module,
253         const struct ldb_request *request,
254         const struct ldb_reply *reply)
255 {
256         struct json_object wrapper;
257         struct json_object audit;
258         struct audit_context *ac = talloc_get_type(
259                 ldb_module_get_private(module),
260                 struct audit_context);
261         struct dsdb_extended_replicated_objects *ro = talloc_get_type(
262                 request->op.extended.data,
263                 struct dsdb_extended_replicated_objects);
264         const char *partition_dn = NULL;
265         const char *error = NULL;
266
267         partition_dn = ldb_dn_get_linearized(ro->partition_dn);
268         error = get_friendly_werror_msg(ro->error);
269
270         audit = json_new_object();
271         json_add_version(&audit, REPLICATION_MAJOR, REPLICATION_MINOR);
272         json_add_int(&audit, "statusCode", reply->error);
273         json_add_string(&audit, "status", ldb_strerror(reply->error));
274         json_add_guid(&audit, "transactionId", &ac->transaction_guid);
275         json_add_int(&audit, "objectCount", ro->num_objects);
276         json_add_int(&audit, "linkCount", ro->linked_attributes_count);
277         json_add_string(&audit, "partitionDN", partition_dn);
278         json_add_string(&audit, "error", error);
279         json_add_int(&audit, "errorCode", W_ERROR_V(ro->error));
280         json_add_guid(
281                 &audit,
282                 "sourceDsa",
283                 &ro->source_dsa->source_dsa_obj_guid);
284         json_add_guid(
285                 &audit,
286                 "invocationId",
287                 &ro->source_dsa->source_dsa_invocation_id);
288
289         wrapper = json_new_object();
290         json_add_timestamp(&wrapper);
291         json_add_string(&wrapper, "type", REPLICATION_JSON_TYPE);
292         json_add_object(&wrapper, REPLICATION_JSON_TYPE, &audit);
293         return wrapper;
294 }
295
296 /*
297  * @brief generate a JSON object detailing a password change.
298  *
299  * Generate a JSON object detailing a password change.
300  *
301  * @param module the ldb module
302  * @param request the request
303  * @param reply the result/response
304  * @param status the status code returned for the underlying ldb operation.
305  *
306  * @return the generated JSON object.
307  *
308  */
309 static struct json_object password_change_json(
310         struct ldb_module *module,
311         const struct ldb_request *request,
312         const struct ldb_reply *reply)
313 {
314         struct ldb_context *ldb = NULL;
315         const struct dom_sid *sid = NULL;
316         const char* dn = NULL;
317         struct json_object wrapper;
318         struct json_object audit;
319         const struct tsocket_address *remote = NULL;
320         const char* action = NULL;
321         const struct GUID *unique_session_token = NULL;
322         struct audit_context *ac = talloc_get_type(
323                 ldb_module_get_private(module),
324                 struct audit_context);
325
326
327         ldb = ldb_module_get_ctx(module);
328
329         remote = dsdb_audit_get_remote_address(ldb);
330         sid = dsdb_audit_get_user_sid(module);
331         dn = dsdb_audit_get_primary_dn(request);
332         action = get_password_action(request, reply);
333         unique_session_token = dsdb_audit_get_unique_session_token(module);
334
335         audit = json_new_object();
336         json_add_version(&audit, PASSWORD_MAJOR, PASSWORD_MINOR);
337         json_add_int(&audit, "statusCode", reply->error);
338         json_add_string(&audit, "status", ldb_strerror(reply->error));
339         json_add_address(&audit, "remoteAddress", remote);
340         json_add_sid(&audit, "userSid", sid);
341         json_add_string(&audit, "dn", dn);
342         json_add_string(&audit, "action", action);
343         json_add_guid(&audit, "transactionId", &ac->transaction_guid);
344         json_add_guid(&audit, "sessionId", unique_session_token);
345
346         wrapper = json_new_object();
347         json_add_timestamp(&wrapper);
348         json_add_string(&wrapper, "type", PASSWORD_JSON_TYPE);
349         json_add_object(&wrapper, PASSWORD_JSON_TYPE, &audit);
350
351         return wrapper;
352 }
353
354
355 /*
356  * @brief create a JSON object containing details of a transaction event.
357  *
358  * Create a JSON object detailing a transaction transaction life cycle events,
359  * i.e. begin, commit, roll back
360  *
361  * @param action a one word description of the event/action
362  * @param transaction_id the GUID identifying the current transaction.
363  *
364  * @return a JSON object detailing the event
365  */
366 static struct json_object transaction_json(
367         const char *action,
368         struct GUID *transaction_id)
369 {
370         struct json_object wrapper;
371         struct json_object audit;
372
373         audit = json_new_object();
374         json_add_version(&audit, TRANSACTION_MAJOR, TRANSACTION_MINOR);
375         json_add_string(&audit, "action", action);
376         json_add_guid(&audit, "transactionId", transaction_id);
377
378         wrapper = json_new_object();
379         json_add_timestamp(&wrapper);
380         json_add_string(&wrapper, "type", TRANSACTION_JSON_TYPE);
381         json_add_object(&wrapper, TRANSACTION_JSON_TYPE, &audit);
382
383         return wrapper;
384 }
385
386
387 /*
388  * @brief generate a JSON object detailing a commit failure.
389  *
390  * Generate a JSON object containing details of a commit failure.
391  *
392  * @param action the commit action, "commit" or "prepare"
393  * @param status the status code returned by commit
394  * @param reason any extra failure information/reason available
395  * @param transaction_id the GUID identifying the current transaction.
396  */
397 static struct json_object commit_failure_json(
398         const char *action,
399         int status,
400         const char *reason,
401         struct GUID *transaction_id)
402 {
403         struct json_object wrapper;
404         struct json_object audit;
405
406         audit = json_new_object();
407         json_add_version(&audit, TRANSACTION_MAJOR, TRANSACTION_MINOR);
408         json_add_string(&audit, "action", action);
409         json_add_guid(&audit, "transactionId", transaction_id);
410         json_add_int(&audit, "statusCode", status);
411         json_add_string(&audit, "status", ldb_strerror(status));
412         json_add_string(&audit, "reason", reason);
413
414         wrapper = json_new_object();
415         json_add_timestamp(&wrapper);
416         json_add_string(&wrapper, "type", TRANSACTION_JSON_TYPE);
417         json_add_object(&wrapper, TRANSACTION_JSON_TYPE, &audit);
418
419         return wrapper;
420 }
421
422 #endif
423 /*
424  * @brief Print a human readable log line for a password change event.
425  *
426  * Generate a human readable log line detailing a password change.
427  *
428  * @param mem_ctx The talloc context that will own the generated log line.
429  * @param module the ldb module
430  * @param request the request
431  * @param reply the result/response
432  * @param status the status code returned for the underlying ldb operation.
433  *
434  * @return the generated log line.
435  */
436 static char *password_change_human_readable(
437         TALLOC_CTX *mem_ctx,
438         struct ldb_module *module,
439         const struct ldb_request *request,
440         const struct ldb_reply *reply)
441 {
442         struct ldb_context *ldb = NULL;
443         const char *remote_host = NULL;
444         const struct dom_sid *sid = NULL;
445         const char *user_sid = NULL;
446         const char *timestamp = NULL;
447         char *log_entry = NULL;
448         const char *action = NULL;
449         const char *dn = NULL;
450
451         TALLOC_CTX *ctx = talloc_new(NULL);
452
453         ldb = ldb_module_get_ctx(module);
454
455         remote_host = dsdb_audit_get_remote_host(ldb, ctx);
456         sid = dsdb_audit_get_user_sid(module);
457         user_sid = dom_sid_string(ctx, sid);
458         timestamp = audit_get_timestamp(ctx);
459         action = get_password_action(request, reply);
460         dn = dsdb_audit_get_primary_dn(request);
461
462         log_entry = talloc_asprintf(
463                 mem_ctx,
464                 "[%s] at [%s] status [%s] "
465                 "remote host [%s] SID [%s] DN [%s]",
466                 action,
467                 timestamp,
468                 ldb_strerror(reply->error),
469                 remote_host,
470                 user_sid,
471                 dn);
472         TALLOC_FREE(ctx);
473         return log_entry;
474 }
475 /*
476  * @brief Generate a human readable string, detailing attributes in a message
477  *
478  * For modify operations each attribute is prefixed with the action.
479  * Normal values are enclosed in []
480  * Base64 values are enclosed in {}
481  * Truncated values are indicated by three trailing dots "..."
482  *
483  * @param ldb The ldb_context
484  * @param buffer The attributes will be appended to the buffer.
485  *               assumed to have been allocated via talloc.
486  * @param operation The operation type
487  * @param message the message to process
488  *
489  */
490 static char *log_attributes(
491         struct ldb_context *ldb,
492         char *buffer,
493         enum ldb_request_type operation,
494         const struct ldb_message *message)
495 {
496         int i, j;
497         for (i=0;i<message->num_elements;i++) {
498                 if (i > 0) {
499                         buffer = talloc_asprintf_append_buffer(buffer, " ");
500                 }
501
502                 if (message->elements[i].name == NULL) {
503                         ldb_debug(
504                                 ldb,
505                                 LDB_DEBUG_ERROR,
506                                 "Error: Invalid element name (NULL) at "
507                                 "position %d", i);
508                         return NULL;
509                 }
510
511                 if (operation == LDB_MODIFY) {
512                         const char *action =NULL;
513                         action = dsdb_audit_get_modification_action(
514                                 message->elements[i].flags);
515                         buffer = talloc_asprintf_append_buffer(
516                                 buffer,
517                                 "%s: %s ",
518                                 action,
519                                 message->elements[i].name);
520                 } else {
521                         buffer = talloc_asprintf_append_buffer(
522                                 buffer,
523                                 "%s ",
524                                 message->elements[i].name);
525                 }
526
527                 if (dsdb_audit_redact_attribute(message->elements[i].name)) {
528                         /*
529                          * Do not log the value of any secret or password
530                          * attributes
531                          */
532                         buffer = talloc_asprintf_append_buffer(
533                                 buffer,
534                                 "[REDACTED SECRET ATTRIBUTE]");
535                         continue;
536                 }
537
538                 for (j=0;j<message->elements[i].num_values;j++) {
539                         struct ldb_val v;
540                         bool use_b64_encode = false;
541                         int length;
542                         if (j > 0) {
543                                 buffer = talloc_asprintf_append_buffer(
544                                         buffer,
545                                         " ");
546                         }
547
548                         v = message->elements[i].values[j];
549                         length = min(MAX_LENGTH, v.length);
550                         use_b64_encode = ldb_should_b64_encode(ldb, &v);
551                         if (use_b64_encode) {
552                                 const char *encoded = ldb_base64_encode(
553                                         buffer,
554                                         (char *)v.data,
555                                         length);
556                                 buffer = talloc_asprintf_append_buffer(
557                                         buffer,
558                                         "{%s%s}",
559                                         encoded,
560                                         (v.length > MAX_LENGTH ? "..." : ""));
561                         } else {
562                                 buffer = talloc_asprintf_append_buffer(
563                                         buffer,
564                                         "[%*.*s%s]",
565                                         length,
566                                         length,
567                                         (char *)v.data,
568                                         (v.length > MAX_LENGTH ? "..." : ""));
569                         }
570                 }
571         }
572         return buffer;
573 }
574
575 /*
576  * @brief generate a human readable log entry detailing an ldb operation.
577  *
578  * Generate a human readable log entry detailing an ldb operation.
579  *
580  * @param mem_ctx The talloc context owning the returned string.
581  * @param module the ldb module
582  * @param request the request
583  * @param reply the result of the operation
584  *
585  * @return the log entry.
586  *
587  */
588 static char *operation_human_readable(
589         TALLOC_CTX *mem_ctx,
590         struct ldb_module *module,
591         const struct ldb_request *request,
592         const struct ldb_reply *reply)
593 {
594         struct ldb_context *ldb = NULL;
595         const char *remote_host = NULL;
596         const struct dom_sid *sid = NULL;
597         const char *user_sid = NULL;
598         const char *timestamp = NULL;
599         const char *op_name = NULL;
600         char *log_entry = NULL;
601         const char *dn = NULL;
602         const char *new_dn = NULL;
603         const struct ldb_message *message = NULL;
604
605         TALLOC_CTX *ctx = talloc_new(NULL);
606
607         ldb = ldb_module_get_ctx(module);
608
609         remote_host = dsdb_audit_get_remote_host(ldb, ctx);
610         if (remote_host != NULL && dsdb_audit_is_system_session(module)) {
611                 sid = dsdb_audit_get_actual_sid(ldb);
612         } else {
613                 sid = dsdb_audit_get_user_sid(module);
614         }
615         user_sid = dom_sid_string(ctx, sid);
616         timestamp = audit_get_timestamp(ctx);
617         op_name = dsdb_audit_get_operation_name(request);
618         dn = dsdb_audit_get_primary_dn(request);
619         new_dn = dsdb_audit_get_secondary_dn(request);
620
621         message = dsdb_audit_get_message(request);
622
623         log_entry = talloc_asprintf(
624                 mem_ctx,
625                 "[%s] at [%s] status [%s] "
626                 "remote host [%s] SID [%s] DN [%s]",
627                 op_name,
628                 timestamp,
629                 ldb_strerror(reply->error),
630                 remote_host,
631                 user_sid,
632                 dn);
633         if (new_dn != NULL) {
634                 log_entry = talloc_asprintf_append_buffer(
635                         log_entry,
636                         " New DN [%s]",
637                         new_dn);
638         }
639         if (message != NULL) {
640                 log_entry = talloc_asprintf_append_buffer(log_entry,
641                                                           " attributes [");
642                 log_entry = log_attributes(ldb,
643                                            log_entry,
644                                            request->operation,
645                                            message);
646                 log_entry = talloc_asprintf_append_buffer(log_entry, "]");
647         }
648         TALLOC_FREE(ctx);
649         return log_entry;
650 }
651
652 /*
653  * @brief generate a human readable log entry detailing a replicated update
654  *        operation.
655  *
656  * Generate a human readable log entry detailing a replicated update operation
657  *
658  * @param mem_ctx The talloc context owning the returned string.
659  * @param module the ldb module
660  * @param request the request
661  * @param reply the result of the operation.
662  *
663  * @return the log entry.
664  *
665  */
666 static char *replicated_update_human_readable(
667         TALLOC_CTX *mem_ctx,
668         struct ldb_module *module,
669         const struct ldb_request *request,
670         const struct ldb_reply *reply)
671 {
672         struct dsdb_extended_replicated_objects *ro = talloc_get_type(
673                 request->op.extended.data,
674                 struct dsdb_extended_replicated_objects);
675         const char *partition_dn = NULL;
676         const char *error = NULL;
677         char *log_entry = NULL;
678         char *timestamp = NULL;
679         struct GUID_txt_buf object_buf;
680         const char *object = NULL;
681         struct GUID_txt_buf invocation_buf;
682         const char *invocation = NULL;
683
684
685         TALLOC_CTX *ctx = talloc_new(NULL);
686
687         timestamp = audit_get_timestamp(ctx);
688         error = get_friendly_werror_msg(ro->error);
689         partition_dn = ldb_dn_get_linearized(ro->partition_dn);
690         object = GUID_buf_string(
691                 &ro->source_dsa->source_dsa_obj_guid,
692                 &object_buf);
693         invocation = GUID_buf_string(
694                 &ro->source_dsa->source_dsa_invocation_id,
695                 &invocation_buf);
696
697
698         log_entry = talloc_asprintf(
699                 mem_ctx,
700                 "at [%s] status [%s] error [%s] partition [%s] objects [%d] "
701                 "links [%d] object [%s] invocation [%s]",
702                 timestamp,
703                 ldb_strerror(reply->error),
704                 error,
705                 partition_dn,
706                 ro->num_objects,
707                 ro->linked_attributes_count,
708                 object,
709                 invocation);
710
711         TALLOC_FREE(ctx);
712         return log_entry;
713 }
714 /*
715  * @brief create a human readable log entry detailing a transaction event.
716  *
717  * Create a human readable log entry detailing a transaction event.
718  * i.e. begin, commit, roll back
719  *
720  * @param mem_ctx The talloc context owning the returned string.
721  * @param action a one word description of the event/action
722  * @param transaction_id the GUID identifying the current transaction.
723  *
724  * @return the log entry
725  */
726 static char *transaction_human_readable(
727         TALLOC_CTX *mem_ctx,
728         const char* action)
729 {
730         const char *timestamp = NULL;
731         char *log_entry = NULL;
732
733         TALLOC_CTX *ctx = talloc_new(NULL);
734
735         timestamp = audit_get_timestamp(ctx);
736
737         log_entry = talloc_asprintf(
738                 mem_ctx,
739                 "[%s] at [%s]",
740                 action,
741                 timestamp);
742
743         TALLOC_FREE(ctx);
744         return log_entry;
745 }
746
747 /*
748  * @brief generate a human readable log entry detailing a commit failure.
749  *
750  * Generate generate a human readable log entry detailing a commit failure.
751  *
752  * @param mem_ctx The talloc context owning the returned string.
753  * @param action the commit action, "prepare" or "commit"
754  * @param status the status code returned by commit
755  * @param reason any extra failure information/reason available
756  *
757  * @return the log entry
758  */
759 static char *commit_failure_human_readable(
760         TALLOC_CTX *mem_ctx,
761         const char *action,
762         int status,
763         const char *reason)
764 {
765         const char *timestamp = NULL;
766         char *log_entry = NULL;
767
768         TALLOC_CTX *ctx = talloc_new(NULL);
769
770         timestamp = audit_get_timestamp(ctx);
771
772         log_entry = talloc_asprintf(
773                 mem_ctx,
774                 "[%s] at [%s] status [%d] reason [%s]",
775                 action,
776                 timestamp,
777                 status,
778                 reason);
779
780         TALLOC_FREE(ctx);
781         return log_entry;
782 }
783
784 /*
785  * @brief log details of a standard ldb operation.
786  *
787  * Log the details of an ldb operation in JSON and or human readable format
788  * and send over the message bus.
789  *
790  * @param module the ldb_module
791  * @param request the operation request.
792  * @param reply the operation result.
793  * @param the status code returned for the operation.
794  *
795  */
796 static void log_standard_operation(
797         struct ldb_module *module,
798         const struct ldb_request *request,
799         const struct ldb_reply *reply)
800 {
801
802         const struct ldb_message *message = dsdb_audit_get_message(request);
803         bool password_changed = has_password_changed(message);
804         struct audit_context *ac =
805                 talloc_get_type(ldb_module_get_private(module),
806                                 struct audit_context);
807
808         TALLOC_CTX *ctx = talloc_new(NULL);
809
810         if (CHECK_DEBUGLVLC(DBGC_DSDB_AUDIT, OPERATION_LOG_LVL)) {
811                 char *entry = NULL;
812                 entry = operation_human_readable(
813                         ctx,
814                         module,
815                         request,
816                         reply);
817                 audit_log_human_text(
818                         OPERATION_HR_TAG,
819                         entry,
820                         DBGC_DSDB_AUDIT,
821                         OPERATION_LOG_LVL);
822                 TALLOC_FREE(entry);
823         }
824         if (CHECK_DEBUGLVLC(DBGC_DSDB_PWD_AUDIT, PASSWORD_LOG_LVL)) {
825                 if (password_changed) {
826                         char *entry = NULL;
827                         entry = password_change_human_readable(
828                                 ctx,
829                                 module,
830                                 request,
831                                 reply);
832                         audit_log_human_text(
833                                 PASSWORD_HR_TAG,
834                                 entry,
835                                 DBGC_DSDB_PWD_AUDIT,
836                                 PASSWORD_LOG_LVL);
837                         TALLOC_FREE(entry);
838                 }
839         }
840 #ifdef HAVE_JANSSON
841         if (CHECK_DEBUGLVLC(DBGC_DSDB_AUDIT_JSON, OPERATION_LOG_LVL) ||
842                 (ac->msg_ctx && ac->send_samdb_events)) {
843                 struct json_object json;
844                 json = operation_json(module, request, reply);
845                 audit_log_json(
846                         OPERATION_JSON_TYPE,
847                         &json,
848                         DBGC_DSDB_AUDIT_JSON,
849                         OPERATION_LOG_LVL);
850                 if (ac->msg_ctx && ac->send_password_events) {
851                         audit_message_send(
852                                 ac->msg_ctx,
853                                 DSDB_EVENT_NAME,
854                                 MSG_DSDB_LOG,
855                                 &json);
856                 }
857                 json_free(&json);
858         }
859         if (CHECK_DEBUGLVLC(DBGC_DSDB_PWD_AUDIT_JSON, PASSWORD_LOG_LVL) ||
860                 (ac->msg_ctx && ac->send_password_events)) {
861                 if (password_changed) {
862                         struct json_object json;
863                         json = password_change_json(module, request, reply);
864                         audit_log_json(
865                                 PASSWORD_JSON_TYPE,
866                                 &json,
867                                 DBGC_DSDB_PWD_AUDIT_JSON,
868                                 PASSWORD_LOG_LVL);
869                         if (ac->send_password_events) {
870                                 audit_message_send(
871                                         ac->msg_ctx,
872                                         DSDB_PWD_EVENT_NAME,
873                                         MSG_DSDB_PWD_LOG,
874                                         &json);
875                         }
876                         json_free(&json);
877                 }
878         }
879 #endif
880         TALLOC_FREE(ctx);
881 }
882
883 /*
884  * @brief log details of a replicated update.
885  *
886  * Log the details of a replicated update in JSON and or human readable
887  * format and send over the message bus.
888  *
889  * @param module the ldb_module
890  * @param request the operation request
891  * @param reply the result of the operation.
892  *
893  */
894 static void log_replicated_operation(
895         struct ldb_module *module,
896         const struct ldb_request *request,
897         const struct ldb_reply *reply)
898 {
899
900         struct audit_context *ac =
901                 talloc_get_type(ldb_module_get_private(module),
902                                 struct audit_context);
903
904         TALLOC_CTX *ctx = talloc_new(NULL);
905
906         if (CHECK_DEBUGLVLC(DBGC_DSDB_AUDIT, REPLICATION_LOG_LVL)) {
907                 char *entry = NULL;
908                 entry = replicated_update_human_readable(
909                         ctx,
910                         module,
911                         request,
912                         reply);
913                 audit_log_human_text(
914                         REPLICATION_HR_TAG,
915                         entry,
916                         DBGC_DSDB_AUDIT,
917                         REPLICATION_LOG_LVL);
918                 TALLOC_FREE(entry);
919         }
920 #ifdef HAVE_JANSSON
921         if (CHECK_DEBUGLVLC(DBGC_DSDB_AUDIT_JSON, REPLICATION_LOG_LVL) ||
922                 (ac->msg_ctx && ac->send_samdb_events)) {
923                 struct json_object json;
924                 json = replicated_update_json(module, request, reply);
925                 audit_log_json(
926                         REPLICATION_JSON_TYPE,
927                         &json,
928                         DBGC_DSDB_AUDIT_JSON,
929                         REPLICATION_LOG_LVL);
930                 if (ac->send_samdb_events) {
931                         audit_message_send(
932                                 ac->msg_ctx,
933                                 DSDB_EVENT_NAME,
934                                 MSG_DSDB_LOG,
935                                 &json);
936                 }
937                 json_free(&json);
938         }
939 #endif
940         TALLOC_FREE(ctx);
941 }
942
943 /*
944  * @brief log details of an ldb operation.
945  *
946  * Log the details of an ldb operation in JSON and or human readable format
947  * and send over the message bus.
948  *
949  * @param module the ldb_module
950  * @param request the operation request
951  * @part reply the result of the operation
952  *
953  */
954 static void log_operation(
955         struct ldb_module *module,
956         const struct ldb_request *request,
957         const struct ldb_reply *reply)
958 {
959
960         if (request->operation == LDB_EXTENDED) {
961                 if (strcmp(
962                         request->op.extended.oid,
963                         DSDB_EXTENDED_REPLICATED_OBJECTS_OID) != 0) {
964
965                         log_replicated_operation(module, request, reply);
966                 }
967         } else {
968                 log_standard_operation(module, request, reply);
969         }
970 }
971
972 /*
973  * @brief log details of a transaction event.
974  *
975  * Log the details of a transaction event in JSON and or human readable format
976  * and send over the message bus.
977  *
978  * @param module the ldb_module
979  * @param  action the transaction event i.e. begin, commit, roll back.
980  *
981  */
982 static void log_transaction(
983         struct ldb_module *module,
984         const char *action)
985 {
986
987         struct audit_context *ac =
988                 talloc_get_type(ldb_module_get_private(module),
989                                 struct audit_context);
990
991         TALLOC_CTX *ctx = talloc_new(NULL);
992
993         if (CHECK_DEBUGLVLC(DBGC_DSDB_TXN_AUDIT, TRANSACTION_LOG_LVL)) {
994                 char* entry = NULL;
995                 entry = transaction_human_readable(ctx, action);
996                 audit_log_human_text(
997                         TRANSACTION_HR_TAG,
998                         entry,
999                         DBGC_DSDB_TXN_AUDIT,
1000                         TRANSACTION_LOG_LVL);
1001                 TALLOC_FREE(entry);
1002         }
1003 #ifdef HAVE_JANSSON
1004         if (CHECK_DEBUGLVLC(DBGC_DSDB_TXN_AUDIT_JSON, TRANSACTION_LOG_LVL) ||
1005                 (ac->msg_ctx && ac->send_samdb_events)) {
1006                 struct json_object json;
1007                 json = transaction_json(action, &ac->transaction_guid);
1008                 audit_log_json(
1009                         TRANSACTION_JSON_TYPE,
1010                         &json,
1011                         DBGC_DSDB_TXN_AUDIT_JSON,
1012                         TRANSACTION_LOG_LVL);
1013                 if (ac->send_samdb_events) {
1014                         audit_message_send(
1015                                 ac->msg_ctx,
1016                                 DSDB_EVENT_NAME,
1017                                 MSG_DSDB_LOG,
1018                                 &json);
1019                 }
1020                 json_free(&json);
1021         }
1022 #endif
1023         TALLOC_FREE(ctx);
1024 }
1025
1026 /*
1027  * @brief log details of a commit failure.
1028  *
1029  * Log the details of a commit failure in JSON and or human readable
1030  * format and send over the message bus.
1031  *
1032  * @param module the ldb_module
1033  * @param action the commit action "prepare" or "commit"
1034  * @param status the ldb status code returned by prepare commit.
1035  *
1036  */
1037 static void log_commit_failure(
1038         struct ldb_module *module,
1039         const char *action,
1040         int status)
1041 {
1042
1043         struct audit_context *ac =
1044                 talloc_get_type(ldb_module_get_private(module),
1045                                 struct audit_context);
1046         const char* reason = dsdb_audit_get_ldb_error_string(module, status);
1047
1048         TALLOC_CTX *ctx = talloc_new(NULL);
1049
1050         if (CHECK_DEBUGLVLC(DBGC_DSDB_TXN_AUDIT, TRANSACTION_LOG_LVL)) {
1051                 char* entry = NULL;
1052                 entry = commit_failure_human_readable(
1053                         ctx,
1054                         action,
1055                         status,
1056                         reason);
1057                 audit_log_human_text(
1058                         TRANSACTION_HR_TAG,
1059                         entry,
1060                         DBGC_DSDB_TXN_AUDIT,
1061                         TRANSACTION_LOG_LVL);
1062                 TALLOC_FREE(entry);
1063         }
1064 #ifdef HAVE_JANSSON
1065         if (CHECK_DEBUGLVLC(DBGC_DSDB_TXN_AUDIT_JSON, TRANSACTION_LOG_LVL) ||
1066                 (ac->msg_ctx && ac->send_samdb_events)) {
1067                 struct json_object json;
1068                 json = commit_failure_json(
1069                         action,
1070                         status,
1071                         reason,
1072                         &ac->transaction_guid);
1073                 audit_log_json(
1074                         TRANSACTION_JSON_TYPE,
1075                         &json,
1076                         DBGC_DSDB_TXN_AUDIT_JSON,
1077                         TRANSACTION_LOG_LVL);
1078                 if (ac->send_samdb_events) {
1079                         audit_message_send(ac->msg_ctx,
1080                                            DSDB_EVENT_NAME,
1081                                            MSG_DSDB_LOG,
1082                                            &json);
1083                 }
1084                 json_free(&json);
1085         }
1086 #endif
1087         TALLOC_FREE(ctx);
1088 }
1089
1090 /*
1091  * Context needed by audit_callback
1092  */
1093 struct audit_callback_context {
1094         struct ldb_request *request;
1095         struct ldb_module *module;
1096 };
1097
1098 /*
1099  * @brief call back function for the ldb_operations.
1100  *
1101  * As the LDB operations are async, and we wish to examine the results of
1102  * the operations, a callback needs to be registered to process the results
1103  * of the LDB operations.
1104  *
1105  * @param req the ldb request
1106  * @param res the result of the operation
1107  *
1108  * @return the LDB_STATUS
1109  */
1110 static int audit_callback(struct ldb_request *req, struct ldb_reply *ares)
1111 {
1112         struct audit_callback_context *ac = NULL;
1113
1114         ac = talloc_get_type(
1115                 req->context,
1116                 struct audit_callback_context);
1117
1118         if (!ares) {
1119                 return ldb_module_done(
1120                         ac->request,
1121                         NULL,
1122                         NULL,
1123                         LDB_ERR_OPERATIONS_ERROR);
1124         }
1125
1126         /* pass on to the callback */
1127         switch (ares->type) {
1128         case LDB_REPLY_ENTRY:
1129                 return ldb_module_send_entry(
1130                         ac->request,
1131                         ares->message,
1132                         ares->controls);
1133
1134         case LDB_REPLY_REFERRAL:
1135                 return ldb_module_send_referral(
1136                         ac->request,
1137                         ares->referral);
1138
1139         case LDB_REPLY_DONE:
1140                 /*
1141                  * Log the operation once DONE
1142                  */
1143                 log_operation(ac->module, ac->request, ares);
1144                 return ldb_module_done(
1145                         ac->request,
1146                         ares->controls,
1147                         ares->response,
1148                         ares->error);
1149
1150         default:
1151                 /* Can't happen */
1152                 return LDB_ERR_OPERATIONS_ERROR;
1153         }
1154 }
1155
1156 /*
1157  * @brief Add the current transaction identifier to the request.
1158  *
1159  * Add the current transaction identifier in the module private data,
1160  * to the request as a control.
1161  *
1162  * @param module
1163  * @param req the request.
1164  *
1165  * @return an LDB_STATUS code, LDB_SUCCESS if successful.
1166  */
1167 static int add_transaction_id(
1168         struct ldb_module *module,
1169         struct ldb_request *req)
1170 {
1171         struct audit_context *ac =
1172                 talloc_get_type(ldb_module_get_private(module),
1173                                 struct audit_context);
1174         struct dsdb_control_transaction_identifier *transaction_id;
1175
1176         transaction_id = talloc_zero(
1177                 req,
1178                 struct dsdb_control_transaction_identifier);
1179         if (transaction_id == NULL) {
1180                 struct ldb_context *ldb = ldb_module_get_ctx(module);
1181                 return ldb_oom(ldb);
1182         }
1183         transaction_id->transaction_guid = ac->transaction_guid;
1184         ldb_request_add_control(req,
1185                                 DSDB_CONTROL_TRANSACTION_IDENTIFIER_OID,
1186                                 false,
1187                                 transaction_id);
1188         return LDB_SUCCESS;
1189
1190 }
1191
1192 /*
1193  * @brief log details of an add operation.
1194  *
1195  * Log the details of an add operation.
1196  *
1197  * @param module the ldb_module
1198  * @param req the ldb_request
1199  *
1200  * @return ldb status code
1201  */
1202 static int log_add(
1203         struct ldb_module *module,
1204         struct ldb_request *req)
1205 {
1206         struct audit_callback_context *context = NULL;
1207         struct ldb_request *new_req = NULL;
1208         struct ldb_context *ldb = NULL;
1209         int ret;
1210
1211         ldb = ldb_module_get_ctx(module);
1212         context = talloc_zero(req, struct audit_callback_context);
1213
1214         if (context == NULL) {
1215                 return ldb_oom(ldb);
1216         }
1217         context->request = req;
1218         context->module  = module;
1219         /*
1220          * We want to log the return code status, so we need to register
1221          * a callback function to get the actual result.
1222          * We need to take a new copy so that we don't alter the callers copy
1223          */
1224         ret = ldb_build_add_req(
1225                 &new_req,
1226                 ldb,
1227                 req,
1228                 req->op.add.message,
1229                 req->controls,
1230                 context,
1231                 audit_callback,
1232                 req);
1233         if (ret != LDB_SUCCESS) {
1234                 return ret;
1235         }
1236         ret = add_transaction_id(module, new_req);
1237         if (ret != LDB_SUCCESS) {
1238                 return ret;
1239         }
1240         return ldb_next_request(module, new_req);
1241 }
1242
1243 /*
1244  * @brief log details of an delete operation.
1245  *
1246  * Log the details of an delete operation.
1247  *
1248  * @param module the ldb_module
1249  * @param req the ldb_request
1250  *
1251  * @return ldb status code
1252  */
1253 static int log_delete(
1254         struct ldb_module *module,
1255         struct ldb_request *req)
1256 {
1257         struct audit_callback_context *context = NULL;
1258         struct ldb_request *new_req = NULL;
1259         struct ldb_context *ldb = NULL;
1260         int ret;
1261
1262         ldb = ldb_module_get_ctx(module);
1263         context = talloc_zero(req, struct audit_callback_context);
1264
1265         if (context == NULL) {
1266                 return ldb_oom(ldb);
1267         }
1268         context->request = req;
1269         context->module  = module;
1270         /*
1271          * We want to log the return code status, so we need to register
1272          * a callback function to get the actual result.
1273          * We need to take a new copy so that we don't alter the callers copy
1274          */
1275         ret = ldb_build_del_req(&new_req,
1276                                 ldb,
1277                                 req,
1278                                 req->op.del.dn,
1279                                 req->controls,
1280                                 context,
1281                                 audit_callback,
1282                                 req);
1283         if (ret != LDB_SUCCESS) {
1284                 return ret;
1285         }
1286         ret = add_transaction_id(module, new_req);
1287         if (ret != LDB_SUCCESS) {
1288                 return ret;
1289         }
1290         return ldb_next_request(module, new_req);
1291 }
1292
1293 /*
1294  * @brief log details of a modify operation.
1295  *
1296  * Log the details of a modify operation.
1297  *
1298  * @param module the ldb_module
1299  * @param req the ldb_request
1300  *
1301  * @return ldb status code
1302  */
1303 static int log_modify(
1304         struct ldb_module *module,
1305         struct ldb_request *req)
1306 {
1307         struct audit_callback_context *context = NULL;
1308         struct ldb_request *new_req = NULL;
1309         struct ldb_context *ldb = NULL;
1310         int ret;
1311
1312         ldb = ldb_module_get_ctx(module);
1313         context = talloc_zero(req, struct audit_callback_context);
1314
1315         if (context == NULL) {
1316                 return ldb_oom(ldb);
1317         }
1318         context->request = req;
1319         context->module  = module;
1320         /*
1321          * We want to log the return code status, so we need to register
1322          * a callback function to get the actual result.
1323          * We need to take a new copy so that we don't alter the callers copy
1324          */
1325         ret = ldb_build_mod_req(
1326                 & new_req,
1327                 ldb,
1328                 req,
1329                 req->op.mod.message,
1330                 req->controls,
1331                 context,
1332                 audit_callback,
1333                 req);
1334         if (ret != LDB_SUCCESS) {
1335                 return ret;
1336         }
1337         ret = add_transaction_id(module, new_req);
1338         if (ret != LDB_SUCCESS) {
1339                 return ret;
1340         }
1341         return ldb_next_request(module, new_req);
1342 }
1343
1344 /*
1345  * @brief process a transaction start.
1346  *
1347  * process a transaction start, as we don't currently log transaction starts
1348  * just generate the new transaction_id.
1349  *
1350  * @param module the ldb_module
1351  * @param req the ldb_request
1352  *
1353  * @return ldb status code
1354  */
1355 static int log_start_transaction(struct ldb_module *module)
1356 {
1357         struct audit_context *ac =
1358                 talloc_get_type(ldb_module_get_private(module),
1359                                 struct audit_context);
1360
1361         /*
1362          * We do not log transaction begins
1363          * however we do generate a new transaction_id
1364          *
1365          */
1366         ac->transaction_guid = GUID_random();
1367         return ldb_next_start_trans(module);
1368 }
1369
1370 /*
1371  * @brief log details of a prepare commit.
1372  *
1373  * Log the details of a prepare commit, currently only details of
1374  * failures are logged.
1375  *
1376  * @param module the ldb_module
1377  * @param req the ldb_request
1378  *
1379  * @return ldb status code
1380  */
1381 static int log_prepare_commit(struct ldb_module *module)
1382 {
1383
1384         int ret = ldb_next_prepare_commit(module);
1385         if (ret != LDB_SUCCESS) {
1386                 /*
1387                  * We currently only log prepare commit failures
1388                  */
1389                 log_commit_failure(module, "prepare", ret);
1390         }
1391         return ret;
1392 }
1393
1394 /*
1395  * @brief process a transaction end aka commit.
1396  *
1397  * process a transaction end, as we don't currently log transaction ends
1398  * just clear transaction_id.
1399  *
1400  * @param module the ldb_module
1401  * @param req the ldb_request
1402  *
1403  * @return ldb status code
1404  */
1405 static int log_end_transaction(struct ldb_module *module)
1406 {
1407         struct audit_context *ac =
1408                 talloc_get_type(ldb_module_get_private(module),
1409                                 struct audit_context);
1410         int ret = 0;
1411
1412         /*
1413          * Clear the transaction id inserted by log_start_transaction
1414          */
1415         memset(&ac->transaction_guid, 0, sizeof(struct GUID));
1416
1417         ret = ldb_next_end_trans(module);
1418         if (ret != LDB_SUCCESS) {
1419                 /*
1420                  * We currently only log commit failures
1421                  */
1422                 log_commit_failure(module, "commit", ret);
1423         }
1424         return ret;
1425 }
1426
1427 /*
1428  * @brief log details of a transaction delete aka roll back.
1429  *
1430  * Log details of a transaction roll back.
1431  *
1432  * @param module the ldb_module
1433  * @param req the ldb_request
1434  *
1435  * @return ldb status code
1436  */
1437 static int log_del_transaction(struct ldb_module *module)
1438 {
1439         struct audit_context *ac =
1440                 talloc_get_type(ldb_module_get_private(module),
1441                                 struct audit_context);
1442
1443         log_transaction(module, "rollback");
1444         memset(&ac->transaction_guid, 0, sizeof(struct GUID));
1445         return ldb_next_del_trans(module);
1446 }
1447
1448 /*
1449  * @brief log details of an extended operation.
1450  *
1451  * Log the details of an extended operation.
1452  *
1453  * @param module the ldb_module
1454  * @param req the ldb_request
1455  *
1456  * @return ldb status code
1457  */
1458 static int log_extended(
1459         struct ldb_module *module,
1460         struct ldb_request *req)
1461 {
1462         struct audit_callback_context *context = NULL;
1463         struct ldb_request *new_req = NULL;
1464         struct ldb_context *ldb = NULL;
1465         int ret;
1466
1467         /*
1468          * Currently we only log replication extended operations
1469          */
1470         if (strcmp(
1471                 req->op.extended.oid,
1472                 DSDB_EXTENDED_REPLICATED_OBJECTS_OID) != 0) {
1473
1474                 return ldb_next_request(module, req);
1475         }
1476         ldb = ldb_module_get_ctx(module);
1477         context = talloc_zero(req, struct audit_callback_context);
1478
1479         if (context == NULL) {
1480                 return ldb_oom(ldb);
1481         }
1482         context->request = req;
1483         context->module  = module;
1484         /*
1485          * We want to log the return code status, so we need to register
1486          * a callback function to get the actual result.
1487          * We need to take a new copy so that we don't alter the callers copy
1488          */
1489         ret = ldb_build_extended_req(
1490                 &new_req,
1491                 ldb,
1492                 req,
1493                 req->op.extended.oid,
1494                 req->op.extended.data,
1495                 req->controls,
1496                 context,
1497                 audit_callback,
1498                 req);
1499         if (ret != LDB_SUCCESS) {
1500                 return ret;
1501         }
1502         ret = add_transaction_id(module, new_req);
1503         if (ret != LDB_SUCCESS) {
1504                 return ret;
1505         }
1506         return ldb_next_request(module, new_req);
1507 }
1508
1509 /*
1510  * @brief module initialisation
1511  */
1512 static int log_init(struct ldb_module *module)
1513 {
1514
1515         struct ldb_context *ldb = ldb_module_get_ctx(module);
1516         struct audit_context *context = NULL;
1517         struct loadparm_context *lp_ctx
1518                 = talloc_get_type_abort(ldb_get_opaque(ldb, "loadparm"),
1519                                         struct loadparm_context);
1520         struct tevent_context *ec = ldb_get_event_context(ldb);
1521         bool sdb_events = false;
1522         bool pwd_events = false;
1523
1524         context = talloc_zero(module, struct audit_context);
1525         if (context == NULL) {
1526                 return ldb_module_oom(module);
1527         }
1528
1529         if (lp_ctx != NULL) {
1530                 sdb_events = lpcfg_dsdb_event_notification(lp_ctx);
1531                 pwd_events = lpcfg_dsdb_password_event_notification(lp_ctx);
1532         }
1533         if (sdb_events || pwd_events) {
1534                 context->send_samdb_events = sdb_events;
1535                 context->send_password_events = pwd_events;
1536                 context->msg_ctx = imessaging_client_init(ec, lp_ctx, ec);
1537         }
1538
1539         ldb_module_set_private(module, context);
1540         return ldb_next_init(module);
1541 }
1542
1543 static const struct ldb_module_ops ldb_audit_log_module_ops = {
1544         .name              = "audit_log",
1545         .init_context      = log_init,
1546         .add               = log_add,
1547         .modify            = log_modify,
1548         .del               = log_delete,
1549         .start_transaction = log_start_transaction,
1550         .prepare_commit    = log_prepare_commit,
1551         .end_transaction   = log_end_transaction,
1552         .del_transaction   = log_del_transaction,
1553         .extended          = log_extended,
1554 };
1555
1556 int ldb_audit_log_module_init(const char *version)
1557 {
1558         LDB_MODULE_CHECK_VERSION(version);
1559         return ldb_register_module(&ldb_audit_log_module_ops);
1560 }