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