Line data Source code
1 : /*
2 : * Auditing VFS module for samba. Log selected file operations to syslog
3 : * facility.
4 : *
5 : * Copyright (C) Tim Potter, 1999-2000
6 : * Copyright (C) Alexander Bokovoy, 2002
7 : * Copyright (C) John H Terpstra, 2003
8 : * Copyright (C) Stefan (metze) Metzmacher, 2003
9 : * Copyright (C) Volker Lendecke, 2004
10 : *
11 : * This program is free software; you can redistribute it and/or modify
12 : * it under the terms of the GNU General Public License as published by
13 : * the Free Software Foundation; either version 3 of the License, or
14 : * (at your option) any later version.
15 : *
16 : * This program is distributed in the hope that it will be useful,
17 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : * GNU General Public License for more details.
20 : *
21 : * You should have received a copy of the GNU General Public License
22 : * along with this program; if not, see <http://www.gnu.org/licenses/>.
23 : */
24 :
25 : /*
26 : * This module implements parseable logging for all Samba VFS operations.
27 : *
28 : * You use it as follows:
29 : *
30 : * [tmp]
31 : * path = /tmp
32 : * vfs objects = full_audit
33 : * full_audit:prefix = %u|%I
34 : * full_audit:success = open opendir create_file
35 : * full_audit:failure = all
36 : *
37 : * vfs op can be "all" which means log all operations.
38 : * vfs op can be "none" which means no logging.
39 : *
40 : * This leads to syslog entries of the form:
41 : * smbd_audit: nobody|192.168.234.1|opendir|ok|/tmp
42 : * smbd_audit: nobody|192.168.234.1|create_file|fail (No such file or directory)|0x1|file|open|/ts/doesNotExist
43 : * smbd_audit: nobody|192.168.234.1|open|ok|w|/tmp/file.txt
44 : * smbd_audit: nobody|192.168.234.1|create_file|ok|0x3|file|open|/tmp/file.txt
45 : *
46 : * where "nobody" is the connected username and "192.168.234.1" is the
47 : * client's IP address.
48 : *
49 : * Options:
50 : *
51 : * prefix: A macro expansion template prepended to the syslog entry.
52 : *
53 : * success: A list of VFS operations for which a successful completion should
54 : * be logged. Defaults to no logging at all. The special operation "all" logs
55 : * - you guessed it - everything.
56 : *
57 : * failure: A list of VFS operations for which failure to complete should be
58 : * logged. Defaults to logging everything.
59 : */
60 :
61 :
62 : #include "includes.h"
63 : #include "system/filesys.h"
64 : #include "system/syslog.h"
65 : #include "smbd/smbd.h"
66 : #include "../librpc/gen_ndr/ndr_netlogon.h"
67 : #include "auth.h"
68 : #include "ntioctl.h"
69 : #include "lib/param/loadparm.h"
70 : #include "lib/util/bitmap.h"
71 : #include "lib/util/tevent_unix.h"
72 : #include "libcli/security/sddl.h"
73 : #include "passdb/machine_sid.h"
74 : #include "lib/util/tevent_ntstatus.h"
75 : #include "lib/util/string_wrappers.h"
76 : #include "source3/lib/substitute.h"
77 :
78 : static int vfs_full_audit_debug_level = DBGC_VFS;
79 :
80 : struct vfs_full_audit_private_data {
81 : struct bitmap *success_ops;
82 : struct bitmap *failure_ops;
83 : int syslog_facility;
84 : int syslog_priority;
85 : bool log_secdesc;
86 : bool do_syslog;
87 : };
88 :
89 : #undef DBGC_CLASS
90 : #define DBGC_CLASS vfs_full_audit_debug_level
91 :
92 : typedef enum _vfs_op_type {
93 : SMB_VFS_OP_NOOP = -1,
94 :
95 : /* Disk operations */
96 :
97 : SMB_VFS_OP_CONNECT = 0,
98 : SMB_VFS_OP_DISCONNECT,
99 : SMB_VFS_OP_DISK_FREE,
100 : SMB_VFS_OP_GET_QUOTA,
101 : SMB_VFS_OP_SET_QUOTA,
102 : SMB_VFS_OP_GET_SHADOW_COPY_DATA,
103 : SMB_VFS_OP_STATVFS,
104 : SMB_VFS_OP_FS_CAPABILITIES,
105 : SMB_VFS_OP_GET_DFS_REFERRALS,
106 : SMB_VFS_OP_CREATE_DFS_PATHAT,
107 : SMB_VFS_OP_READ_DFS_PATHAT,
108 :
109 : /* Directory operations */
110 :
111 : SMB_VFS_OP_FDOPENDIR,
112 : SMB_VFS_OP_READDIR,
113 : SMB_VFS_OP_SEEKDIR,
114 : SMB_VFS_OP_TELLDIR,
115 : SMB_VFS_OP_REWINDDIR,
116 : SMB_VFS_OP_MKDIRAT,
117 : SMB_VFS_OP_CLOSEDIR,
118 :
119 : /* File operations */
120 :
121 : SMB_VFS_OP_OPEN,
122 : SMB_VFS_OP_OPENAT,
123 : SMB_VFS_OP_CREATE_FILE,
124 : SMB_VFS_OP_CLOSE,
125 : SMB_VFS_OP_READ,
126 : SMB_VFS_OP_PREAD,
127 : SMB_VFS_OP_PREAD_SEND,
128 : SMB_VFS_OP_PREAD_RECV,
129 : SMB_VFS_OP_WRITE,
130 : SMB_VFS_OP_PWRITE,
131 : SMB_VFS_OP_PWRITE_SEND,
132 : SMB_VFS_OP_PWRITE_RECV,
133 : SMB_VFS_OP_LSEEK,
134 : SMB_VFS_OP_SENDFILE,
135 : SMB_VFS_OP_RECVFILE,
136 : SMB_VFS_OP_RENAMEAT,
137 : SMB_VFS_OP_FSYNC_SEND,
138 : SMB_VFS_OP_FSYNC_RECV,
139 : SMB_VFS_OP_STAT,
140 : SMB_VFS_OP_FSTAT,
141 : SMB_VFS_OP_LSTAT,
142 : SMB_VFS_OP_FSTATAT,
143 : SMB_VFS_OP_GET_ALLOC_SIZE,
144 : SMB_VFS_OP_UNLINKAT,
145 : SMB_VFS_OP_FCHMOD,
146 : SMB_VFS_OP_FCHOWN,
147 : SMB_VFS_OP_LCHOWN,
148 : SMB_VFS_OP_CHDIR,
149 : SMB_VFS_OP_GETWD,
150 : SMB_VFS_OP_NTIMES,
151 : SMB_VFS_OP_FNTIMES,
152 : SMB_VFS_OP_FTRUNCATE,
153 : SMB_VFS_OP_FALLOCATE,
154 : SMB_VFS_OP_LOCK,
155 : SMB_VFS_OP_FILESYSTEM_SHAREMODE,
156 : SMB_VFS_OP_FCNTL,
157 : SMB_VFS_OP_LINUX_SETLEASE,
158 : SMB_VFS_OP_GETLOCK,
159 : SMB_VFS_OP_SYMLINKAT,
160 : SMB_VFS_OP_READLINKAT,
161 : SMB_VFS_OP_LINKAT,
162 : SMB_VFS_OP_MKNODAT,
163 : SMB_VFS_OP_REALPATH,
164 : SMB_VFS_OP_FCHFLAGS,
165 : SMB_VFS_OP_FILE_ID_CREATE,
166 : SMB_VFS_OP_FS_FILE_ID,
167 : SMB_VFS_OP_FSTREAMINFO,
168 : SMB_VFS_OP_GET_REAL_FILENAME,
169 : SMB_VFS_OP_GET_REAL_FILENAME_AT,
170 : SMB_VFS_OP_CONNECTPATH,
171 : SMB_VFS_OP_BRL_LOCK_WINDOWS,
172 : SMB_VFS_OP_BRL_UNLOCK_WINDOWS,
173 : SMB_VFS_OP_STRICT_LOCK_CHECK,
174 : SMB_VFS_OP_TRANSLATE_NAME,
175 : SMB_VFS_OP_PARENT_PATHNAME,
176 : SMB_VFS_OP_FSCTL,
177 : SMB_VFS_OP_OFFLOAD_READ_SEND,
178 : SMB_VFS_OP_OFFLOAD_READ_RECV,
179 : SMB_VFS_OP_OFFLOAD_WRITE_SEND,
180 : SMB_VFS_OP_OFFLOAD_WRITE_RECV,
181 : SMB_VFS_OP_FGET_COMPRESSION,
182 : SMB_VFS_OP_SET_COMPRESSION,
183 : SMB_VFS_OP_SNAP_CHECK_PATH,
184 : SMB_VFS_OP_SNAP_CREATE,
185 : SMB_VFS_OP_SNAP_DELETE,
186 :
187 : /* DOS attribute operations. */
188 : SMB_VFS_OP_GET_DOS_ATTRIBUTES_SEND,
189 : SMB_VFS_OP_GET_DOS_ATTRIBUTES_RECV,
190 : SMB_VFS_OP_FGET_DOS_ATTRIBUTES,
191 : SMB_VFS_OP_FSET_DOS_ATTRIBUTES,
192 :
193 : /* NT ACL operations. */
194 :
195 : SMB_VFS_OP_FGET_NT_ACL,
196 : SMB_VFS_OP_FSET_NT_ACL,
197 : SMB_VFS_OP_AUDIT_FILE,
198 :
199 : /* POSIX ACL operations. */
200 :
201 : SMB_VFS_OP_SYS_ACL_GET_FD,
202 : SMB_VFS_OP_SYS_ACL_BLOB_GET_FD,
203 : SMB_VFS_OP_SYS_ACL_SET_FD,
204 : SMB_VFS_OP_SYS_ACL_DELETE_DEF_FD,
205 :
206 : /* EA operations. */
207 : SMB_VFS_OP_GETXATTRAT_SEND,
208 : SMB_VFS_OP_GETXATTRAT_RECV,
209 : SMB_VFS_OP_FGETXATTR,
210 : SMB_VFS_OP_FLISTXATTR,
211 : SMB_VFS_OP_REMOVEXATTR,
212 : SMB_VFS_OP_FREMOVEXATTR,
213 : SMB_VFS_OP_FSETXATTR,
214 :
215 : /* aio operations */
216 : SMB_VFS_OP_AIO_FORCE,
217 :
218 : /* offline operations */
219 : SMB_VFS_OP_IS_OFFLINE,
220 : SMB_VFS_OP_SET_OFFLINE,
221 :
222 : /* Durable handle operations. */
223 : SMB_VFS_OP_DURABLE_COOKIE,
224 : SMB_VFS_OP_DURABLE_DISCONNECT,
225 : SMB_VFS_OP_DURABLE_RECONNECT,
226 :
227 : SMB_VFS_OP_FREADDIR_ATTR,
228 :
229 : /* This should always be last enum value */
230 :
231 : SMB_VFS_OP_LAST
232 : } vfs_op_type;
233 :
234 : /* The following array *must* be in the same order as defined in vfs_op_type */
235 :
236 : static struct {
237 : vfs_op_type type;
238 : const char *name;
239 : } vfs_op_names[] = {
240 : { SMB_VFS_OP_CONNECT, "connect" },
241 : { SMB_VFS_OP_DISCONNECT, "disconnect" },
242 : { SMB_VFS_OP_DISK_FREE, "disk_free" },
243 : { SMB_VFS_OP_GET_QUOTA, "get_quota" },
244 : { SMB_VFS_OP_SET_QUOTA, "set_quota" },
245 : { SMB_VFS_OP_GET_SHADOW_COPY_DATA, "get_shadow_copy_data" },
246 : { SMB_VFS_OP_STATVFS, "statvfs" },
247 : { SMB_VFS_OP_FS_CAPABILITIES, "fs_capabilities" },
248 : { SMB_VFS_OP_GET_DFS_REFERRALS, "get_dfs_referrals" },
249 : { SMB_VFS_OP_CREATE_DFS_PATHAT, "create_dfs_pathat" },
250 : { SMB_VFS_OP_READ_DFS_PATHAT, "read_dfs_pathat" },
251 : { SMB_VFS_OP_FDOPENDIR, "fdopendir" },
252 : { SMB_VFS_OP_READDIR, "readdir" },
253 : { SMB_VFS_OP_SEEKDIR, "seekdir" },
254 : { SMB_VFS_OP_TELLDIR, "telldir" },
255 : { SMB_VFS_OP_REWINDDIR, "rewinddir" },
256 : { SMB_VFS_OP_MKDIRAT, "mkdirat" },
257 : { SMB_VFS_OP_CLOSEDIR, "closedir" },
258 : { SMB_VFS_OP_OPEN, "open" },
259 : { SMB_VFS_OP_OPENAT, "openat" },
260 : { SMB_VFS_OP_CREATE_FILE, "create_file" },
261 : { SMB_VFS_OP_CLOSE, "close" },
262 : { SMB_VFS_OP_READ, "read" },
263 : { SMB_VFS_OP_PREAD, "pread" },
264 : { SMB_VFS_OP_PREAD_SEND, "pread_send" },
265 : { SMB_VFS_OP_PREAD_RECV, "pread_recv" },
266 : { SMB_VFS_OP_WRITE, "write" },
267 : { SMB_VFS_OP_PWRITE, "pwrite" },
268 : { SMB_VFS_OP_PWRITE_SEND, "pwrite_send" },
269 : { SMB_VFS_OP_PWRITE_RECV, "pwrite_recv" },
270 : { SMB_VFS_OP_LSEEK, "lseek" },
271 : { SMB_VFS_OP_SENDFILE, "sendfile" },
272 : { SMB_VFS_OP_RECVFILE, "recvfile" },
273 : { SMB_VFS_OP_RENAMEAT, "renameat" },
274 : { SMB_VFS_OP_FSYNC_SEND, "fsync_send" },
275 : { SMB_VFS_OP_FSYNC_RECV, "fsync_recv" },
276 : { SMB_VFS_OP_STAT, "stat" },
277 : { SMB_VFS_OP_FSTAT, "fstat" },
278 : { SMB_VFS_OP_LSTAT, "lstat" },
279 : { SMB_VFS_OP_FSTATAT, "fstatat" },
280 : { SMB_VFS_OP_GET_ALLOC_SIZE, "get_alloc_size" },
281 : { SMB_VFS_OP_UNLINKAT, "unlinkat" },
282 : { SMB_VFS_OP_FCHMOD, "fchmod" },
283 : { SMB_VFS_OP_FCHOWN, "fchown" },
284 : { SMB_VFS_OP_LCHOWN, "lchown" },
285 : { SMB_VFS_OP_CHDIR, "chdir" },
286 : { SMB_VFS_OP_GETWD, "getwd" },
287 : { SMB_VFS_OP_NTIMES, "ntimes" },
288 : { SMB_VFS_OP_FNTIMES, "fntimes" },
289 : { SMB_VFS_OP_FTRUNCATE, "ftruncate" },
290 : { SMB_VFS_OP_FALLOCATE,"fallocate" },
291 : { SMB_VFS_OP_LOCK, "lock" },
292 : { SMB_VFS_OP_FILESYSTEM_SHAREMODE, "filesystem_sharemode" },
293 : { SMB_VFS_OP_FCNTL, "fcntl" },
294 : { SMB_VFS_OP_LINUX_SETLEASE, "linux_setlease" },
295 : { SMB_VFS_OP_GETLOCK, "getlock" },
296 : { SMB_VFS_OP_SYMLINKAT, "symlinkat" },
297 : { SMB_VFS_OP_READLINKAT,"readlinkat" },
298 : { SMB_VFS_OP_LINKAT, "linkat" },
299 : { SMB_VFS_OP_MKNODAT, "mknodat" },
300 : { SMB_VFS_OP_REALPATH, "realpath" },
301 : { SMB_VFS_OP_FCHFLAGS, "fchflags" },
302 : { SMB_VFS_OP_FILE_ID_CREATE, "file_id_create" },
303 : { SMB_VFS_OP_FS_FILE_ID, "fs_file_id" },
304 : { SMB_VFS_OP_FSTREAMINFO, "fstreaminfo" },
305 : { SMB_VFS_OP_GET_REAL_FILENAME, "get_real_filename" },
306 : { SMB_VFS_OP_GET_REAL_FILENAME_AT, "get_real_filename_at" },
307 : { SMB_VFS_OP_CONNECTPATH, "connectpath" },
308 : { SMB_VFS_OP_BRL_LOCK_WINDOWS, "brl_lock_windows" },
309 : { SMB_VFS_OP_BRL_UNLOCK_WINDOWS, "brl_unlock_windows" },
310 : { SMB_VFS_OP_STRICT_LOCK_CHECK, "strict_lock_check" },
311 : { SMB_VFS_OP_TRANSLATE_NAME, "translate_name" },
312 : { SMB_VFS_OP_PARENT_PATHNAME, "parent_pathname" },
313 : { SMB_VFS_OP_FSCTL, "fsctl" },
314 : { SMB_VFS_OP_OFFLOAD_READ_SEND, "offload_read_send" },
315 : { SMB_VFS_OP_OFFLOAD_READ_RECV, "offload_read_recv" },
316 : { SMB_VFS_OP_OFFLOAD_WRITE_SEND, "offload_write_send" },
317 : { SMB_VFS_OP_OFFLOAD_WRITE_RECV, "offload_write_recv" },
318 : { SMB_VFS_OP_FGET_COMPRESSION, "fget_compression" },
319 : { SMB_VFS_OP_SET_COMPRESSION, "set_compression" },
320 : { SMB_VFS_OP_SNAP_CHECK_PATH, "snap_check_path" },
321 : { SMB_VFS_OP_SNAP_CREATE, "snap_create" },
322 : { SMB_VFS_OP_SNAP_DELETE, "snap_delete" },
323 : { SMB_VFS_OP_GET_DOS_ATTRIBUTES_SEND, "get_dos_attributes_send" },
324 : { SMB_VFS_OP_GET_DOS_ATTRIBUTES_RECV, "get_dos_attributes_recv" },
325 : { SMB_VFS_OP_FGET_DOS_ATTRIBUTES, "fget_dos_attributes" },
326 : { SMB_VFS_OP_FSET_DOS_ATTRIBUTES, "fset_dos_attributes" },
327 : { SMB_VFS_OP_FGET_NT_ACL, "fget_nt_acl" },
328 : { SMB_VFS_OP_FSET_NT_ACL, "fset_nt_acl" },
329 : { SMB_VFS_OP_AUDIT_FILE, "audit_file" },
330 : { SMB_VFS_OP_SYS_ACL_GET_FD, "sys_acl_get_fd" },
331 : { SMB_VFS_OP_SYS_ACL_BLOB_GET_FD, "sys_acl_blob_get_fd" },
332 : { SMB_VFS_OP_SYS_ACL_SET_FD, "sys_acl_set_fd" },
333 : { SMB_VFS_OP_SYS_ACL_DELETE_DEF_FD, "sys_acl_delete_def_fd" },
334 : { SMB_VFS_OP_GETXATTRAT_SEND, "getxattrat_send" },
335 : { SMB_VFS_OP_GETXATTRAT_RECV, "getxattrat_recv" },
336 : { SMB_VFS_OP_FGETXATTR, "fgetxattr" },
337 : { SMB_VFS_OP_FLISTXATTR, "flistxattr" },
338 : { SMB_VFS_OP_REMOVEXATTR, "removexattr" },
339 : { SMB_VFS_OP_FREMOVEXATTR, "fremovexattr" },
340 : { SMB_VFS_OP_FSETXATTR, "fsetxattr" },
341 : { SMB_VFS_OP_AIO_FORCE, "aio_force" },
342 : { SMB_VFS_OP_IS_OFFLINE, "is_offline" },
343 : { SMB_VFS_OP_SET_OFFLINE, "set_offline" },
344 : { SMB_VFS_OP_DURABLE_COOKIE, "durable_cookie" },
345 : { SMB_VFS_OP_DURABLE_DISCONNECT, "durable_disconnect" },
346 : { SMB_VFS_OP_DURABLE_RECONNECT, "durable_reconnect" },
347 : { SMB_VFS_OP_FREADDIR_ATTR, "freaddir_attr" },
348 : { SMB_VFS_OP_LAST, NULL }
349 : };
350 :
351 2579 : static int audit_syslog_facility(vfs_handle_struct *handle)
352 : {
353 : static const struct enum_list enum_log_facilities[] = {
354 : #ifdef LOG_AUTH
355 : { LOG_AUTH, "AUTH" },
356 : #endif
357 : #ifdef LOG_AUTHPRIV
358 : { LOG_AUTHPRIV, "AUTHPRIV" },
359 : #endif
360 : #ifdef LOG_AUDIT
361 : { LOG_AUDIT, "AUDIT" },
362 : #endif
363 : #ifdef LOG_CONSOLE
364 : { LOG_CONSOLE, "CONSOLE" },
365 : #endif
366 : #ifdef LOG_CRON
367 : { LOG_CRON, "CRON" },
368 : #endif
369 : #ifdef LOG_DAEMON
370 : { LOG_DAEMON, "DAEMON" },
371 : #endif
372 : #ifdef LOG_FTP
373 : { LOG_FTP, "FTP" },
374 : #endif
375 : #ifdef LOG_INSTALL
376 : { LOG_INSTALL, "INSTALL" },
377 : #endif
378 : #ifdef LOG_KERN
379 : { LOG_KERN, "KERN" },
380 : #endif
381 : #ifdef LOG_LAUNCHD
382 : { LOG_LAUNCHD, "LAUNCHD" },
383 : #endif
384 : #ifdef LOG_LFMT
385 : { LOG_LFMT, "LFMT" },
386 : #endif
387 : #ifdef LOG_LPR
388 : { LOG_LPR, "LPR" },
389 : #endif
390 : #ifdef LOG_MAIL
391 : { LOG_MAIL, "MAIL" },
392 : #endif
393 : #ifdef LOG_MEGASAFE
394 : { LOG_MEGASAFE, "MEGASAFE" },
395 : #endif
396 : #ifdef LOG_NETINFO
397 : { LOG_NETINFO, "NETINFO" },
398 : #endif
399 : #ifdef LOG_NEWS
400 : { LOG_NEWS, "NEWS" },
401 : #endif
402 : #ifdef LOG_NFACILITIES
403 : { LOG_NFACILITIES, "NFACILITIES" },
404 : #endif
405 : #ifdef LOG_NTP
406 : { LOG_NTP, "NTP" },
407 : #endif
408 : #ifdef LOG_RAS
409 : { LOG_RAS, "RAS" },
410 : #endif
411 : #ifdef LOG_REMOTEAUTH
412 : { LOG_REMOTEAUTH, "REMOTEAUTH" },
413 : #endif
414 : #ifdef LOG_SECURITY
415 : { LOG_SECURITY, "SECURITY" },
416 : #endif
417 : #ifdef LOG_SYSLOG
418 : { LOG_SYSLOG, "SYSLOG" },
419 : #endif
420 : #ifdef LOG_USER
421 : { LOG_USER, "USER" },
422 : #endif
423 : #ifdef LOG_UUCP
424 : { LOG_UUCP, "UUCP" },
425 : #endif
426 : { LOG_LOCAL0, "LOCAL0" },
427 : { LOG_LOCAL1, "LOCAL1" },
428 : { LOG_LOCAL2, "LOCAL2" },
429 : { LOG_LOCAL3, "LOCAL3" },
430 : { LOG_LOCAL4, "LOCAL4" },
431 : { LOG_LOCAL5, "LOCAL5" },
432 : { LOG_LOCAL6, "LOCAL6" },
433 : { LOG_LOCAL7, "LOCAL7" },
434 : { -1, NULL }
435 : };
436 :
437 : int facility;
438 :
439 2579 : facility = lp_parm_enum(SNUM(handle->conn), "full_audit", "facility", enum_log_facilities, LOG_USER);
440 :
441 2579 : return facility;
442 : }
443 :
444 2579 : static int audit_syslog_priority(vfs_handle_struct *handle)
445 : {
446 : static const struct enum_list enum_log_priorities[] = {
447 : { LOG_EMERG, "EMERG" },
448 : { LOG_ALERT, "ALERT" },
449 : { LOG_CRIT, "CRIT" },
450 : { LOG_ERR, "ERR" },
451 : { LOG_WARNING, "WARNING" },
452 : { LOG_NOTICE, "NOTICE" },
453 : { LOG_INFO, "INFO" },
454 : { LOG_DEBUG, "DEBUG" },
455 : { -1, NULL }
456 : };
457 :
458 : int priority;
459 :
460 2579 : priority = lp_parm_enum(SNUM(handle->conn), "full_audit", "priority",
461 : enum_log_priorities, LOG_NOTICE);
462 2579 : if (priority == -1) {
463 0 : priority = LOG_WARNING;
464 : }
465 :
466 2579 : return priority;
467 : }
468 :
469 0 : static char *audit_prefix(TALLOC_CTX *ctx, connection_struct *conn)
470 : {
471 : const struct loadparm_substitution *lp_sub =
472 0 : loadparm_s3_global_substitution();
473 0 : char *prefix = NULL;
474 : char *result;
475 :
476 0 : prefix = talloc_strdup(ctx,
477 0 : lp_parm_const_string(SNUM(conn), "full_audit",
478 : "prefix", "%u|%I"));
479 0 : if (!prefix) {
480 0 : return NULL;
481 : }
482 0 : result = talloc_sub_full(ctx,
483 0 : lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
484 0 : conn->session_info->unix_info->unix_name,
485 0 : conn->connectpath,
486 0 : conn->session_info->unix_token->gid,
487 0 : conn->session_info->unix_info->sanitized_username,
488 0 : conn->session_info->info->domain_name,
489 : prefix);
490 0 : TALLOC_FREE(prefix);
491 0 : return result;
492 : }
493 :
494 828079 : static bool log_success(struct vfs_full_audit_private_data *pd, vfs_op_type op)
495 : {
496 828079 : if (pd->success_ops == NULL) {
497 0 : return True;
498 : }
499 :
500 828079 : return bitmap_query(pd->success_ops, op);
501 : }
502 :
503 75611 : static bool log_failure(struct vfs_full_audit_private_data *pd, vfs_op_type op)
504 : {
505 75611 : if (pd->failure_ops == NULL)
506 0 : return True;
507 :
508 75611 : return bitmap_query(pd->failure_ops, op);
509 : }
510 :
511 5158 : static struct bitmap *init_bitmap(TALLOC_CTX *mem_ctx, const char **ops)
512 : {
513 : struct bitmap *bm;
514 :
515 5158 : if (ops == NULL) {
516 0 : DBG_ERR("init_bitmap, ops list is empty (logic error)\n");
517 0 : return NULL;
518 : }
519 :
520 5158 : bm = bitmap_talloc(mem_ctx, SMB_VFS_OP_LAST);
521 5158 : if (bm == NULL) {
522 0 : DBG_ERR("Could not alloc bitmap\n");
523 0 : return NULL;
524 : }
525 :
526 5158 : for (; *ops != NULL; ops += 1) {
527 : int i;
528 5158 : bool neg = false;
529 : const char *op;
530 :
531 5158 : if (strequal(*ops, "all")) {
532 0 : for (i=0; i<SMB_VFS_OP_LAST; i++) {
533 0 : bitmap_set(bm, i);
534 : }
535 0 : continue;
536 : }
537 :
538 5158 : if (strequal(*ops, "none")) {
539 5158 : break;
540 : }
541 :
542 0 : op = ops[0];
543 0 : if (op[0] == '!') {
544 0 : neg = true;
545 0 : op += 1;
546 : }
547 :
548 0 : for (i=0; i<SMB_VFS_OP_LAST; i++) {
549 0 : if ((vfs_op_names[i].name == NULL)
550 0 : || (vfs_op_names[i].type != i)) {
551 0 : smb_panic("vfs_full_audit.c: name table not "
552 : "in sync with vfs_op_type enums\n");
553 : }
554 0 : if (strequal(op, vfs_op_names[i].name)) {
555 0 : if (neg) {
556 0 : bitmap_clear(bm, i);
557 : } else {
558 0 : bitmap_set(bm, i);
559 : }
560 0 : break;
561 : }
562 : }
563 0 : if (i == SMB_VFS_OP_LAST) {
564 0 : DBG_ERR("Could not find opname %s\n", *ops);
565 0 : TALLOC_FREE(bm);
566 0 : return NULL;
567 : }
568 : }
569 5158 : return bm;
570 : }
571 :
572 0 : static const char *audit_opname(vfs_op_type op)
573 : {
574 0 : if (op >= SMB_VFS_OP_LAST)
575 0 : return "INVALID VFS OP";
576 0 : return vfs_op_names[op].name;
577 : }
578 :
579 : static TALLOC_CTX *tmp_do_log_ctx;
580 : /*
581 : * Get us a temporary talloc context usable just for DEBUG arguments
582 : */
583 1625597 : static TALLOC_CTX *do_log_ctx(void)
584 : {
585 1625597 : if (tmp_do_log_ctx == NULL) {
586 580111 : tmp_do_log_ctx = talloc_named_const(NULL, 0, "do_log_ctx");
587 : }
588 1625597 : return tmp_do_log_ctx;
589 : }
590 :
591 : static void do_log(vfs_op_type op, bool success, vfs_handle_struct *handle,
592 : const char *format, ...) PRINTF_ATTRIBUTE(4, 5);
593 :
594 903690 : static void do_log(vfs_op_type op, bool success, vfs_handle_struct *handle,
595 : const char *format, ...)
596 : {
597 : struct vfs_full_audit_private_data *pd;
598 : fstring err_msg;
599 903690 : char *audit_pre = NULL;
600 : va_list ap;
601 903690 : char *op_msg = NULL;
602 :
603 903690 : SMB_VFS_HANDLE_GET_DATA(handle, pd,
604 : struct vfs_full_audit_private_data,
605 : return;);
606 :
607 903690 : if (success && (!log_success(pd, op)))
608 828079 : goto out;
609 :
610 75611 : if (!success && (!log_failure(pd, op)))
611 75611 : goto out;
612 :
613 0 : if (success)
614 0 : fstrcpy(err_msg, "ok");
615 : else
616 0 : fstr_sprintf(err_msg, "fail (%s)", strerror(errno));
617 :
618 0 : va_start(ap, format);
619 0 : op_msg = talloc_vasprintf(talloc_tos(), format, ap);
620 0 : va_end(ap);
621 :
622 0 : if (!op_msg) {
623 0 : goto out;
624 : }
625 :
626 0 : audit_pre = audit_prefix(talloc_tos(), handle->conn);
627 :
628 0 : if (pd->do_syslog) {
629 : int priority;
630 :
631 : /*
632 : * Specify the facility to interoperate with other syslog
633 : * callers (smbd for example).
634 : */
635 0 : priority = pd->syslog_priority | pd->syslog_facility;
636 :
637 0 : syslog(priority, "%s|%s|%s|%s\n",
638 : audit_pre ? audit_pre : "",
639 : audit_opname(op), err_msg, op_msg);
640 : } else {
641 0 : DEBUG(1, ("%s|%s|%s|%s\n",
642 : audit_pre ? audit_pre : "",
643 : audit_opname(op), err_msg, op_msg));
644 : }
645 903690 : out:
646 903690 : TALLOC_FREE(audit_pre);
647 903690 : TALLOC_FREE(op_msg);
648 903690 : TALLOC_FREE(tmp_do_log_ctx);
649 : }
650 :
651 : /**
652 : * Return a string using the do_log_ctx()
653 : */
654 580255 : static const char *smb_fname_str_do_log(struct connection_struct *conn,
655 : const struct smb_filename *smb_fname)
656 : {
657 580255 : char *fname = NULL;
658 : NTSTATUS status;
659 :
660 580255 : if (smb_fname == NULL) {
661 0 : return "";
662 : }
663 :
664 580255 : if (smb_fname->base_name[0] != '/') {
665 522671 : char *abs_name = NULL;
666 522671 : struct smb_filename *fname_copy = cp_smb_filename(
667 : do_log_ctx(),
668 : smb_fname);
669 522671 : if (fname_copy == NULL) {
670 0 : return "";
671 : }
672 :
673 522671 : if (!ISDOT(smb_fname->base_name)) {
674 213312 : abs_name = talloc_asprintf(do_log_ctx(),
675 : "%s/%s",
676 213312 : conn->cwd_fsp->fsp_name->base_name,
677 213312 : smb_fname->base_name);
678 : } else {
679 309359 : abs_name = talloc_strdup(do_log_ctx(),
680 309359 : conn->cwd_fsp->fsp_name->base_name);
681 : }
682 522671 : if (abs_name == NULL) {
683 0 : return "";
684 : }
685 522671 : fname_copy->base_name = abs_name;
686 522671 : smb_fname = fname_copy;
687 : }
688 :
689 580255 : status = get_full_smb_filename(do_log_ctx(), smb_fname, &fname);
690 580255 : if (!NT_STATUS_IS_OK(status)) {
691 0 : return "";
692 : }
693 580255 : return fname;
694 : }
695 :
696 : /**
697 : * Return an fsp debug string using the do_log_ctx()
698 : */
699 346665 : static const char *fsp_str_do_log(const struct files_struct *fsp)
700 : {
701 346665 : return smb_fname_str_do_log(fsp->conn, fsp->fsp_name);
702 : }
703 :
704 : /* Implementation of vfs_ops. Pass everything on to the default
705 : operation but log event first. */
706 :
707 2579 : static int smb_full_audit_connect(vfs_handle_struct *handle,
708 : const char *svc, const char *user)
709 : {
710 : int result;
711 2579 : const char *none[] = { "none" };
712 2579 : struct vfs_full_audit_private_data *pd = NULL;
713 :
714 2579 : result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
715 2579 : if (result < 0) {
716 0 : return result;
717 : }
718 :
719 2579 : pd = talloc_zero(handle, struct vfs_full_audit_private_data);
720 2579 : if (!pd) {
721 0 : SMB_VFS_NEXT_DISCONNECT(handle);
722 0 : return -1;
723 : }
724 :
725 2579 : pd->syslog_facility = audit_syslog_facility(handle);
726 2579 : if (pd->syslog_facility == -1) {
727 0 : DEBUG(1, ("%s: Unknown facility %s\n", __func__,
728 : lp_parm_const_string(SNUM(handle->conn),
729 : "full_audit", "facility",
730 : "USER")));
731 0 : SMB_VFS_NEXT_DISCONNECT(handle);
732 0 : return -1;
733 : }
734 :
735 2579 : pd->syslog_priority = audit_syslog_priority(handle);
736 :
737 2579 : pd->log_secdesc = lp_parm_bool(SNUM(handle->conn),
738 : "full_audit", "log_secdesc", false);
739 :
740 2579 : pd->do_syslog = lp_parm_bool(SNUM(handle->conn),
741 : "full_audit", "syslog", true);
742 :
743 : #ifdef WITH_SYSLOG
744 2579 : if (pd->do_syslog) {
745 0 : openlog("smbd_audit", 0, pd->syslog_facility);
746 : }
747 : #endif
748 :
749 2579 : pd->success_ops = init_bitmap(
750 2579 : pd, lp_parm_string_list(SNUM(handle->conn), "full_audit",
751 : "success", none));
752 2579 : if (pd->success_ops == NULL) {
753 0 : DBG_ERR("Invalid success operations list. Failing connect\n");
754 0 : SMB_VFS_NEXT_DISCONNECT(handle);
755 0 : return -1;
756 : }
757 2579 : pd->failure_ops = init_bitmap(
758 2579 : pd, lp_parm_string_list(SNUM(handle->conn), "full_audit",
759 : "failure", none));
760 2579 : if (pd->failure_ops == NULL) {
761 0 : DBG_ERR("Invalid failure operations list. Failing connect\n");
762 0 : SMB_VFS_NEXT_DISCONNECT(handle);
763 0 : return -1;
764 : }
765 :
766 : /* Store the private data. */
767 2579 : SMB_VFS_HANDLE_SET_DATA(handle, pd, NULL,
768 : struct vfs_full_audit_private_data, return -1);
769 :
770 2579 : do_log(SMB_VFS_OP_CONNECT, True, handle,
771 : "%s", svc);
772 :
773 2579 : return 0;
774 : }
775 :
776 2579 : static void smb_full_audit_disconnect(vfs_handle_struct *handle)
777 : {
778 : const struct loadparm_substitution *lp_sub =
779 2579 : loadparm_s3_global_substitution();
780 :
781 2579 : SMB_VFS_NEXT_DISCONNECT(handle);
782 :
783 2579 : do_log(SMB_VFS_OP_DISCONNECT, True, handle,
784 2579 : "%s", lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn)));
785 :
786 : /* The bitmaps will be disconnected when the private
787 : data is deleted. */
788 2579 : }
789 :
790 183 : static uint64_t smb_full_audit_disk_free(vfs_handle_struct *handle,
791 : const struct smb_filename *smb_fname,
792 : uint64_t *bsize,
793 : uint64_t *dfree,
794 : uint64_t *dsize)
795 : {
796 : uint64_t result;
797 :
798 183 : result = SMB_VFS_NEXT_DISK_FREE(handle, smb_fname, bsize, dfree, dsize);
799 :
800 : /* Don't have a reasonable notion of failure here */
801 :
802 183 : do_log(SMB_VFS_OP_DISK_FREE,
803 : True,
804 : handle,
805 : "%s",
806 : smb_fname_str_do_log(handle->conn, smb_fname));
807 :
808 183 : return result;
809 : }
810 :
811 366 : static int smb_full_audit_get_quota(struct vfs_handle_struct *handle,
812 : const struct smb_filename *smb_fname,
813 : enum SMB_QUOTA_TYPE qtype,
814 : unid_t id,
815 : SMB_DISK_QUOTA *qt)
816 : {
817 : int result;
818 :
819 366 : result = SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, qt);
820 :
821 366 : do_log(SMB_VFS_OP_GET_QUOTA,
822 : (result >= 0),
823 : handle,
824 : "%s",
825 : smb_fname_str_do_log(handle->conn, smb_fname));
826 :
827 366 : return result;
828 : }
829 :
830 0 : static int smb_full_audit_set_quota(struct vfs_handle_struct *handle,
831 : enum SMB_QUOTA_TYPE qtype, unid_t id,
832 : SMB_DISK_QUOTA *qt)
833 : {
834 : int result;
835 :
836 0 : result = SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt);
837 :
838 0 : do_log(SMB_VFS_OP_SET_QUOTA, (result >= 0), handle, "");
839 :
840 0 : return result;
841 : }
842 :
843 44 : static int smb_full_audit_get_shadow_copy_data(struct vfs_handle_struct *handle,
844 : struct files_struct *fsp,
845 : struct shadow_copy_data *shadow_copy_data,
846 : bool labels)
847 : {
848 : int result;
849 :
850 44 : result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp, shadow_copy_data, labels);
851 :
852 44 : do_log(SMB_VFS_OP_GET_SHADOW_COPY_DATA, (result >= 0), handle, "");
853 :
854 44 : return result;
855 : }
856 :
857 1745 : static int smb_full_audit_statvfs(struct vfs_handle_struct *handle,
858 : const struct smb_filename *smb_fname,
859 : struct vfs_statvfs_struct *statbuf)
860 : {
861 : int result;
862 :
863 1745 : result = SMB_VFS_NEXT_STATVFS(handle, smb_fname, statbuf);
864 :
865 1745 : do_log(SMB_VFS_OP_STATVFS, (result >= 0), handle, "");
866 :
867 1745 : return result;
868 : }
869 :
870 1745 : static uint32_t smb_full_audit_fs_capabilities(struct vfs_handle_struct *handle, enum timestamp_set_resolution *p_ts_res)
871 : {
872 : int result;
873 :
874 1745 : result = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
875 :
876 1745 : do_log(SMB_VFS_OP_FS_CAPABILITIES, true, handle, "");
877 :
878 1745 : return result;
879 : }
880 :
881 1463 : static NTSTATUS smb_full_audit_get_dfs_referrals(
882 : struct vfs_handle_struct *handle,
883 : struct dfs_GetDFSReferral *r)
884 : {
885 : NTSTATUS status;
886 :
887 1463 : status = SMB_VFS_NEXT_GET_DFS_REFERRALS(handle, r);
888 :
889 1463 : do_log(SMB_VFS_OP_GET_DFS_REFERRALS, NT_STATUS_IS_OK(status),
890 : handle, "");
891 :
892 1463 : return status;
893 : }
894 :
895 0 : static NTSTATUS smb_full_audit_create_dfs_pathat(struct vfs_handle_struct *handle,
896 : struct files_struct *dirfsp,
897 : const struct smb_filename *smb_fname,
898 : const struct referral *reflist,
899 : size_t referral_count)
900 : {
901 : NTSTATUS status;
902 0 : struct smb_filename *full_fname = NULL;
903 :
904 0 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
905 : dirfsp,
906 : smb_fname);
907 0 : if (full_fname == NULL) {
908 0 : return NT_STATUS_NO_MEMORY;
909 : }
910 :
911 0 : status = SMB_VFS_NEXT_CREATE_DFS_PATHAT(handle,
912 : dirfsp,
913 : smb_fname,
914 : reflist,
915 : referral_count);
916 :
917 0 : do_log(SMB_VFS_OP_CREATE_DFS_PATHAT,
918 0 : NT_STATUS_IS_OK(status),
919 : handle,
920 : "%s",
921 : smb_fname_str_do_log(handle->conn, full_fname));
922 :
923 0 : TALLOC_FREE(full_fname);
924 0 : return status;
925 : }
926 :
927 11234 : static NTSTATUS smb_full_audit_read_dfs_pathat(struct vfs_handle_struct *handle,
928 : TALLOC_CTX *mem_ctx,
929 : struct files_struct *dirfsp,
930 : struct smb_filename *smb_fname,
931 : struct referral **ppreflist,
932 : size_t *preferral_count)
933 : {
934 11234 : struct smb_filename *full_fname = NULL;
935 : NTSTATUS status;
936 :
937 11234 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
938 : dirfsp,
939 : smb_fname);
940 11234 : if (full_fname == NULL) {
941 0 : return NT_STATUS_NO_MEMORY;
942 : }
943 :
944 11234 : status = SMB_VFS_NEXT_READ_DFS_PATHAT(handle,
945 : mem_ctx,
946 : dirfsp,
947 : smb_fname,
948 : ppreflist,
949 : preferral_count);
950 :
951 11234 : do_log(SMB_VFS_OP_READ_DFS_PATHAT,
952 11234 : NT_STATUS_IS_OK(status),
953 : handle,
954 : "%s",
955 : smb_fname_str_do_log(handle->conn, full_fname));
956 :
957 11234 : TALLOC_FREE(full_fname);
958 11234 : return status;
959 : }
960 :
961 0 : static NTSTATUS smb_full_audit_snap_check_path(struct vfs_handle_struct *handle,
962 : TALLOC_CTX *mem_ctx,
963 : const char *service_path,
964 : char **base_volume)
965 : {
966 : NTSTATUS status;
967 :
968 0 : status = SMB_VFS_NEXT_SNAP_CHECK_PATH(handle, mem_ctx, service_path,
969 : base_volume);
970 0 : do_log(SMB_VFS_OP_SNAP_CHECK_PATH, NT_STATUS_IS_OK(status),
971 : handle, "");
972 :
973 0 : return status;
974 : }
975 :
976 0 : static NTSTATUS smb_full_audit_snap_create(struct vfs_handle_struct *handle,
977 : TALLOC_CTX *mem_ctx,
978 : const char *base_volume,
979 : time_t *tstamp,
980 : bool rw,
981 : char **base_path,
982 : char **snap_path)
983 : {
984 : NTSTATUS status;
985 :
986 0 : status = SMB_VFS_NEXT_SNAP_CREATE(handle, mem_ctx, base_volume, tstamp,
987 : rw, base_path, snap_path);
988 0 : do_log(SMB_VFS_OP_SNAP_CREATE, NT_STATUS_IS_OK(status), handle, "");
989 :
990 0 : return status;
991 : }
992 :
993 0 : static NTSTATUS smb_full_audit_snap_delete(struct vfs_handle_struct *handle,
994 : TALLOC_CTX *mem_ctx,
995 : char *base_path,
996 : char *snap_path)
997 : {
998 : NTSTATUS status;
999 :
1000 0 : status = SMB_VFS_NEXT_SNAP_DELETE(handle, mem_ctx, base_path,
1001 : snap_path);
1002 0 : do_log(SMB_VFS_OP_SNAP_DELETE, NT_STATUS_IS_OK(status), handle, "");
1003 :
1004 0 : return status;
1005 : }
1006 :
1007 2302 : static DIR *smb_full_audit_fdopendir(vfs_handle_struct *handle,
1008 : files_struct *fsp, const char *mask, uint32_t attr)
1009 : {
1010 : DIR *result;
1011 :
1012 2302 : result = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
1013 :
1014 2302 : do_log(SMB_VFS_OP_FDOPENDIR, (result != NULL), handle, "%s",
1015 : fsp_str_do_log(fsp));
1016 :
1017 2302 : return result;
1018 : }
1019 :
1020 19120 : static struct dirent *smb_full_audit_readdir(vfs_handle_struct *handle,
1021 : struct files_struct *dirfsp,
1022 : DIR *dirp,
1023 : SMB_STRUCT_STAT *sbuf)
1024 : {
1025 : struct dirent *result;
1026 :
1027 19120 : result = SMB_VFS_NEXT_READDIR(handle, dirfsp, dirp, sbuf);
1028 :
1029 : /* This operation has no reasonable error condition
1030 : * (End of dir is also failure), so always succeed.
1031 : */
1032 19120 : do_log(SMB_VFS_OP_READDIR, True, handle, "");
1033 :
1034 19120 : return result;
1035 : }
1036 :
1037 0 : static void smb_full_audit_seekdir(vfs_handle_struct *handle,
1038 : DIR *dirp, long offset)
1039 : {
1040 0 : SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset);
1041 :
1042 0 : do_log(SMB_VFS_OP_SEEKDIR, True, handle, "");
1043 0 : }
1044 :
1045 15061 : static long smb_full_audit_telldir(vfs_handle_struct *handle,
1046 : DIR *dirp)
1047 : {
1048 : long result;
1049 :
1050 15061 : result = SMB_VFS_NEXT_TELLDIR(handle, dirp);
1051 :
1052 15061 : do_log(SMB_VFS_OP_TELLDIR, True, handle, "");
1053 :
1054 15061 : return result;
1055 : }
1056 :
1057 0 : static void smb_full_audit_rewinddir(vfs_handle_struct *handle,
1058 : DIR *dirp)
1059 : {
1060 0 : SMB_VFS_NEXT_REWINDDIR(handle, dirp);
1061 :
1062 0 : do_log(SMB_VFS_OP_REWINDDIR, True, handle, "");
1063 0 : }
1064 :
1065 176 : static int smb_full_audit_mkdirat(vfs_handle_struct *handle,
1066 : struct files_struct *dirfsp,
1067 : const struct smb_filename *smb_fname,
1068 : mode_t mode)
1069 : {
1070 176 : struct smb_filename *full_fname = NULL;
1071 : int result;
1072 :
1073 176 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1074 : dirfsp,
1075 : smb_fname);
1076 176 : if (full_fname == NULL) {
1077 0 : errno = ENOMEM;
1078 0 : return -1;
1079 : }
1080 :
1081 176 : result = SMB_VFS_NEXT_MKDIRAT(handle,
1082 : dirfsp,
1083 : smb_fname,
1084 : mode);
1085 :
1086 176 : do_log(SMB_VFS_OP_MKDIRAT,
1087 : (result >= 0),
1088 : handle,
1089 : "%s",
1090 : smb_fname_str_do_log(handle->conn, full_fname));
1091 :
1092 176 : TALLOC_FREE(full_fname);
1093 :
1094 176 : return result;
1095 : }
1096 :
1097 2302 : static int smb_full_audit_closedir(vfs_handle_struct *handle,
1098 : DIR *dirp)
1099 : {
1100 : int result;
1101 :
1102 2302 : result = SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
1103 :
1104 2302 : do_log(SMB_VFS_OP_CLOSEDIR, (result >= 0), handle, "");
1105 :
1106 2302 : return result;
1107 : }
1108 :
1109 73127 : static int smb_full_audit_openat(vfs_handle_struct *handle,
1110 : const struct files_struct *dirfsp,
1111 : const struct smb_filename *smb_fname,
1112 : struct files_struct *fsp,
1113 : const struct vfs_open_how *how)
1114 : {
1115 : int result;
1116 :
1117 73127 : result = SMB_VFS_NEXT_OPENAT(handle, dirfsp, smb_fname, fsp, how);
1118 :
1119 146254 : do_log(SMB_VFS_OP_OPENAT, (result >= 0), handle, "%s|%s",
1120 73127 : ((how->flags & O_WRONLY) || (how->flags & O_RDWR))?"w":"r",
1121 : fsp_str_do_log(fsp));
1122 :
1123 73127 : return result;
1124 : }
1125 :
1126 7397 : static NTSTATUS smb_full_audit_create_file(vfs_handle_struct *handle,
1127 : struct smb_request *req,
1128 : struct files_struct *dirfsp,
1129 : struct smb_filename *smb_fname,
1130 : uint32_t access_mask,
1131 : uint32_t share_access,
1132 : uint32_t create_disposition,
1133 : uint32_t create_options,
1134 : uint32_t file_attributes,
1135 : uint32_t oplock_request,
1136 : const struct smb2_lease *lease,
1137 : uint64_t allocation_size,
1138 : uint32_t private_flags,
1139 : struct security_descriptor *sd,
1140 : struct ea_list *ea_list,
1141 : files_struct **result_fsp,
1142 : int *pinfo,
1143 : const struct smb2_create_blobs *in_context_blobs,
1144 : struct smb2_create_blobs *out_context_blobs)
1145 : {
1146 : NTSTATUS result;
1147 : const char* str_create_disposition;
1148 :
1149 7397 : switch (create_disposition) {
1150 2 : case FILE_SUPERSEDE:
1151 2 : str_create_disposition = "supersede";
1152 2 : break;
1153 93 : case FILE_OVERWRITE_IF:
1154 93 : str_create_disposition = "overwrite_if";
1155 93 : break;
1156 7005 : case FILE_OPEN:
1157 7005 : str_create_disposition = "open";
1158 7005 : break;
1159 2 : case FILE_OVERWRITE:
1160 2 : str_create_disposition = "overwrite";
1161 2 : break;
1162 139 : case FILE_CREATE:
1163 139 : str_create_disposition = "create";
1164 139 : break;
1165 154 : case FILE_OPEN_IF:
1166 154 : str_create_disposition = "open_if";
1167 154 : break;
1168 2 : default:
1169 2 : str_create_disposition = "unknown";
1170 : }
1171 :
1172 7397 : result = SMB_VFS_NEXT_CREATE_FILE(
1173 : handle, /* handle */
1174 : req, /* req */
1175 : dirfsp, /* dirfsp */
1176 : smb_fname, /* fname */
1177 : access_mask, /* access_mask */
1178 : share_access, /* share_access */
1179 : create_disposition, /* create_disposition*/
1180 : create_options, /* create_options */
1181 : file_attributes, /* file_attributes */
1182 : oplock_request, /* oplock_request */
1183 : lease, /* lease */
1184 : allocation_size, /* allocation_size */
1185 : private_flags,
1186 : sd, /* sd */
1187 : ea_list, /* ea_list */
1188 : result_fsp, /* result */
1189 : pinfo, /* pinfo */
1190 : in_context_blobs, out_context_blobs); /* create context */
1191 :
1192 14794 : do_log(SMB_VFS_OP_CREATE_FILE, (NT_STATUS_IS_OK(result)), handle,
1193 : "0x%x|%s|%s|%s", access_mask,
1194 7397 : create_options & FILE_DIRECTORY_FILE ? "dir" : "file",
1195 : str_create_disposition,
1196 : smb_fname_str_do_log(handle->conn, smb_fname));
1197 :
1198 7397 : return result;
1199 : }
1200 :
1201 37787 : static int smb_full_audit_close(vfs_handle_struct *handle, files_struct *fsp)
1202 : {
1203 : int result;
1204 :
1205 37787 : result = SMB_VFS_NEXT_CLOSE(handle, fsp);
1206 :
1207 37787 : do_log(SMB_VFS_OP_CLOSE, (result >= 0), handle, "%s",
1208 : fsp_str_do_log(fsp));
1209 :
1210 37787 : return result;
1211 : }
1212 :
1213 0 : static ssize_t smb_full_audit_pread(vfs_handle_struct *handle, files_struct *fsp,
1214 : void *data, size_t n, off_t offset)
1215 : {
1216 : ssize_t result;
1217 :
1218 0 : result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
1219 :
1220 0 : do_log(SMB_VFS_OP_PREAD, (result >= 0), handle, "%s",
1221 : fsp_str_do_log(fsp));
1222 :
1223 0 : return result;
1224 : }
1225 :
1226 : struct smb_full_audit_pread_state {
1227 : vfs_handle_struct *handle;
1228 : files_struct *fsp;
1229 : ssize_t ret;
1230 : struct vfs_aio_state vfs_aio_state;
1231 : };
1232 :
1233 : static void smb_full_audit_pread_done(struct tevent_req *subreq);
1234 :
1235 19 : static struct tevent_req *smb_full_audit_pread_send(
1236 : struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
1237 : struct tevent_context *ev, struct files_struct *fsp,
1238 : void *data, size_t n, off_t offset)
1239 : {
1240 : struct tevent_req *req, *subreq;
1241 : struct smb_full_audit_pread_state *state;
1242 :
1243 19 : req = tevent_req_create(mem_ctx, &state,
1244 : struct smb_full_audit_pread_state);
1245 19 : if (req == NULL) {
1246 0 : do_log(SMB_VFS_OP_PREAD_SEND, false, handle, "%s",
1247 : fsp_str_do_log(fsp));
1248 0 : return NULL;
1249 : }
1250 19 : state->handle = handle;
1251 19 : state->fsp = fsp;
1252 :
1253 19 : subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp, data,
1254 : n, offset);
1255 19 : if (tevent_req_nomem(subreq, req)) {
1256 0 : do_log(SMB_VFS_OP_PREAD_SEND, false, handle, "%s",
1257 : fsp_str_do_log(fsp));
1258 0 : return tevent_req_post(req, ev);
1259 : }
1260 19 : tevent_req_set_callback(subreq, smb_full_audit_pread_done, req);
1261 :
1262 19 : do_log(SMB_VFS_OP_PREAD_SEND, true, handle, "%s", fsp_str_do_log(fsp));
1263 19 : return req;
1264 : }
1265 :
1266 19 : static void smb_full_audit_pread_done(struct tevent_req *subreq)
1267 : {
1268 19 : struct tevent_req *req = tevent_req_callback_data(
1269 : subreq, struct tevent_req);
1270 19 : struct smb_full_audit_pread_state *state = tevent_req_data(
1271 : req, struct smb_full_audit_pread_state);
1272 :
1273 19 : state->ret = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
1274 19 : TALLOC_FREE(subreq);
1275 19 : tevent_req_done(req);
1276 19 : }
1277 :
1278 19 : static ssize_t smb_full_audit_pread_recv(struct tevent_req *req,
1279 : struct vfs_aio_state *vfs_aio_state)
1280 : {
1281 19 : struct smb_full_audit_pread_state *state = tevent_req_data(
1282 : req, struct smb_full_audit_pread_state);
1283 :
1284 19 : if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1285 0 : do_log(SMB_VFS_OP_PREAD_RECV, false, state->handle, "%s",
1286 0 : fsp_str_do_log(state->fsp));
1287 0 : return -1;
1288 : }
1289 :
1290 19 : do_log(SMB_VFS_OP_PREAD_RECV, (state->ret >= 0), state->handle, "%s",
1291 19 : fsp_str_do_log(state->fsp));
1292 :
1293 19 : *vfs_aio_state = state->vfs_aio_state;
1294 19 : return state->ret;
1295 : }
1296 :
1297 20 : static ssize_t smb_full_audit_pwrite(vfs_handle_struct *handle, files_struct *fsp,
1298 : const void *data, size_t n,
1299 : off_t offset)
1300 : {
1301 : ssize_t result;
1302 :
1303 20 : result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
1304 :
1305 20 : do_log(SMB_VFS_OP_PWRITE, (result >= 0), handle, "%s",
1306 : fsp_str_do_log(fsp));
1307 :
1308 20 : return result;
1309 : }
1310 :
1311 : struct smb_full_audit_pwrite_state {
1312 : vfs_handle_struct *handle;
1313 : files_struct *fsp;
1314 : ssize_t ret;
1315 : struct vfs_aio_state vfs_aio_state;
1316 : };
1317 :
1318 : static void smb_full_audit_pwrite_done(struct tevent_req *subreq);
1319 :
1320 49 : static struct tevent_req *smb_full_audit_pwrite_send(
1321 : struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
1322 : struct tevent_context *ev, struct files_struct *fsp,
1323 : const void *data, size_t n, off_t offset)
1324 : {
1325 : struct tevent_req *req, *subreq;
1326 : struct smb_full_audit_pwrite_state *state;
1327 :
1328 49 : req = tevent_req_create(mem_ctx, &state,
1329 : struct smb_full_audit_pwrite_state);
1330 49 : if (req == NULL) {
1331 0 : do_log(SMB_VFS_OP_PWRITE_SEND, false, handle, "%s",
1332 : fsp_str_do_log(fsp));
1333 0 : return NULL;
1334 : }
1335 49 : state->handle = handle;
1336 49 : state->fsp = fsp;
1337 :
1338 49 : subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp, data,
1339 : n, offset);
1340 49 : if (tevent_req_nomem(subreq, req)) {
1341 0 : do_log(SMB_VFS_OP_PWRITE_SEND, false, handle, "%s",
1342 : fsp_str_do_log(fsp));
1343 0 : return tevent_req_post(req, ev);
1344 : }
1345 49 : tevent_req_set_callback(subreq, smb_full_audit_pwrite_done, req);
1346 :
1347 49 : do_log(SMB_VFS_OP_PWRITE_SEND, true, handle, "%s",
1348 : fsp_str_do_log(fsp));
1349 49 : return req;
1350 : }
1351 :
1352 49 : static void smb_full_audit_pwrite_done(struct tevent_req *subreq)
1353 : {
1354 49 : struct tevent_req *req = tevent_req_callback_data(
1355 : subreq, struct tevent_req);
1356 49 : struct smb_full_audit_pwrite_state *state = tevent_req_data(
1357 : req, struct smb_full_audit_pwrite_state);
1358 :
1359 49 : state->ret = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
1360 49 : TALLOC_FREE(subreq);
1361 49 : tevent_req_done(req);
1362 49 : }
1363 :
1364 49 : static ssize_t smb_full_audit_pwrite_recv(struct tevent_req *req,
1365 : struct vfs_aio_state *vfs_aio_state)
1366 : {
1367 49 : struct smb_full_audit_pwrite_state *state = tevent_req_data(
1368 : req, struct smb_full_audit_pwrite_state);
1369 :
1370 49 : if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1371 0 : do_log(SMB_VFS_OP_PWRITE_RECV, false, state->handle, "%s",
1372 0 : fsp_str_do_log(state->fsp));
1373 0 : return -1;
1374 : }
1375 :
1376 49 : do_log(SMB_VFS_OP_PWRITE_RECV, (state->ret >= 0), state->handle, "%s",
1377 49 : fsp_str_do_log(state->fsp));
1378 :
1379 49 : *vfs_aio_state = state->vfs_aio_state;
1380 49 : return state->ret;
1381 : }
1382 :
1383 0 : static off_t smb_full_audit_lseek(vfs_handle_struct *handle, files_struct *fsp,
1384 : off_t offset, int whence)
1385 : {
1386 : ssize_t result;
1387 :
1388 0 : result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
1389 :
1390 0 : do_log(SMB_VFS_OP_LSEEK, (result != (ssize_t)-1), handle,
1391 : "%s", fsp_str_do_log(fsp));
1392 :
1393 0 : return result;
1394 : }
1395 :
1396 0 : static ssize_t smb_full_audit_sendfile(vfs_handle_struct *handle, int tofd,
1397 : files_struct *fromfsp,
1398 : const DATA_BLOB *hdr, off_t offset,
1399 : size_t n)
1400 : {
1401 : ssize_t result;
1402 :
1403 0 : result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
1404 :
1405 0 : do_log(SMB_VFS_OP_SENDFILE, (result >= 0), handle,
1406 : "%s", fsp_str_do_log(fromfsp));
1407 :
1408 0 : return result;
1409 : }
1410 :
1411 0 : static ssize_t smb_full_audit_recvfile(vfs_handle_struct *handle, int fromfd,
1412 : files_struct *tofsp,
1413 : off_t offset,
1414 : size_t n)
1415 : {
1416 : ssize_t result;
1417 :
1418 0 : result = SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
1419 :
1420 0 : do_log(SMB_VFS_OP_RECVFILE, (result >= 0), handle,
1421 : "%s", fsp_str_do_log(tofsp));
1422 :
1423 0 : return result;
1424 : }
1425 :
1426 20 : static int smb_full_audit_renameat(vfs_handle_struct *handle,
1427 : files_struct *srcfsp,
1428 : const struct smb_filename *smb_fname_src,
1429 : files_struct *dstfsp,
1430 : const struct smb_filename *smb_fname_dst)
1431 : {
1432 : int result;
1433 : int saved_errno;
1434 20 : struct smb_filename *full_fname_src = NULL;
1435 20 : struct smb_filename *full_fname_dst = NULL;
1436 :
1437 20 : full_fname_src = full_path_from_dirfsp_atname(talloc_tos(),
1438 : srcfsp,
1439 : smb_fname_src);
1440 20 : if (full_fname_src == NULL) {
1441 0 : errno = ENOMEM;
1442 0 : return -1;
1443 : }
1444 20 : full_fname_dst = full_path_from_dirfsp_atname(talloc_tos(),
1445 : dstfsp,
1446 : smb_fname_dst);
1447 20 : if (full_fname_dst == NULL) {
1448 0 : TALLOC_FREE(full_fname_src);
1449 0 : errno = ENOMEM;
1450 0 : return -1;
1451 : }
1452 :
1453 20 : result = SMB_VFS_NEXT_RENAMEAT(handle,
1454 : srcfsp,
1455 : smb_fname_src,
1456 : dstfsp,
1457 : smb_fname_dst);
1458 :
1459 20 : if (result == -1) {
1460 0 : saved_errno = errno;
1461 : }
1462 20 : do_log(SMB_VFS_OP_RENAMEAT, (result >= 0), handle, "%s|%s",
1463 : smb_fname_str_do_log(handle->conn, full_fname_src),
1464 : smb_fname_str_do_log(handle->conn, full_fname_dst));
1465 :
1466 20 : TALLOC_FREE(full_fname_src);
1467 20 : TALLOC_FREE(full_fname_dst);
1468 :
1469 20 : if (result == -1) {
1470 0 : errno = saved_errno;
1471 : }
1472 20 : return result;
1473 : }
1474 :
1475 : struct smb_full_audit_fsync_state {
1476 : vfs_handle_struct *handle;
1477 : files_struct *fsp;
1478 : int ret;
1479 : struct vfs_aio_state vfs_aio_state;
1480 : };
1481 :
1482 : static void smb_full_audit_fsync_done(struct tevent_req *subreq);
1483 :
1484 0 : static struct tevent_req *smb_full_audit_fsync_send(
1485 : struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
1486 : struct tevent_context *ev, struct files_struct *fsp)
1487 : {
1488 : struct tevent_req *req, *subreq;
1489 : struct smb_full_audit_fsync_state *state;
1490 :
1491 0 : req = tevent_req_create(mem_ctx, &state,
1492 : struct smb_full_audit_fsync_state);
1493 0 : if (req == NULL) {
1494 0 : do_log(SMB_VFS_OP_FSYNC_SEND, false, handle, "%s",
1495 : fsp_str_do_log(fsp));
1496 0 : return NULL;
1497 : }
1498 0 : state->handle = handle;
1499 0 : state->fsp = fsp;
1500 :
1501 0 : subreq = SMB_VFS_NEXT_FSYNC_SEND(state, ev, handle, fsp);
1502 0 : if (tevent_req_nomem(subreq, req)) {
1503 0 : do_log(SMB_VFS_OP_FSYNC_SEND, false, handle, "%s",
1504 : fsp_str_do_log(fsp));
1505 0 : return tevent_req_post(req, ev);
1506 : }
1507 0 : tevent_req_set_callback(subreq, smb_full_audit_fsync_done, req);
1508 :
1509 0 : do_log(SMB_VFS_OP_FSYNC_SEND, true, handle, "%s", fsp_str_do_log(fsp));
1510 0 : return req;
1511 : }
1512 :
1513 0 : static void smb_full_audit_fsync_done(struct tevent_req *subreq)
1514 : {
1515 0 : struct tevent_req *req = tevent_req_callback_data(
1516 : subreq, struct tevent_req);
1517 0 : struct smb_full_audit_fsync_state *state = tevent_req_data(
1518 : req, struct smb_full_audit_fsync_state);
1519 :
1520 0 : state->ret = SMB_VFS_FSYNC_RECV(subreq, &state->vfs_aio_state);
1521 0 : TALLOC_FREE(subreq);
1522 0 : tevent_req_done(req);
1523 0 : }
1524 :
1525 0 : static int smb_full_audit_fsync_recv(struct tevent_req *req,
1526 : struct vfs_aio_state *vfs_aio_state)
1527 : {
1528 0 : struct smb_full_audit_fsync_state *state = tevent_req_data(
1529 : req, struct smb_full_audit_fsync_state);
1530 :
1531 0 : if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1532 0 : do_log(SMB_VFS_OP_FSYNC_RECV, false, state->handle, "%s",
1533 0 : fsp_str_do_log(state->fsp));
1534 0 : return -1;
1535 : }
1536 :
1537 0 : do_log(SMB_VFS_OP_FSYNC_RECV, (state->ret >= 0), state->handle, "%s",
1538 0 : fsp_str_do_log(state->fsp));
1539 :
1540 0 : *vfs_aio_state = state->vfs_aio_state;
1541 0 : return state->ret;
1542 : }
1543 :
1544 48668 : static int smb_full_audit_stat(vfs_handle_struct *handle,
1545 : struct smb_filename *smb_fname)
1546 : {
1547 : int result;
1548 :
1549 48668 : result = SMB_VFS_NEXT_STAT(handle, smb_fname);
1550 :
1551 48668 : do_log(SMB_VFS_OP_STAT, (result >= 0), handle, "%s",
1552 : smb_fname_str_do_log(handle->conn, smb_fname));
1553 :
1554 48668 : return result;
1555 : }
1556 :
1557 205783 : static int smb_full_audit_fstat(vfs_handle_struct *handle, files_struct *fsp,
1558 : SMB_STRUCT_STAT *sbuf)
1559 : {
1560 : int result;
1561 :
1562 205783 : result = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
1563 :
1564 205783 : do_log(SMB_VFS_OP_FSTAT, (result >= 0), handle, "%s",
1565 : fsp_str_do_log(fsp));
1566 :
1567 205783 : return result;
1568 : }
1569 :
1570 103 : static int smb_full_audit_lstat(vfs_handle_struct *handle,
1571 : struct smb_filename *smb_fname)
1572 : {
1573 : int result;
1574 :
1575 103 : result = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
1576 :
1577 103 : do_log(SMB_VFS_OP_LSTAT, (result >= 0), handle, "%s",
1578 : smb_fname_str_do_log(handle->conn, smb_fname));
1579 :
1580 103 : return result;
1581 : }
1582 :
1583 120 : static int smb_full_audit_fstatat(
1584 : struct vfs_handle_struct *handle,
1585 : const struct files_struct *dirfsp,
1586 : const struct smb_filename *smb_fname,
1587 : SMB_STRUCT_STAT *sbuf,
1588 : int flags)
1589 : {
1590 : int result;
1591 :
1592 120 : result = SMB_VFS_NEXT_FSTATAT(handle, dirfsp, smb_fname, sbuf, flags);
1593 :
1594 120 : do_log(SMB_VFS_OP_FSTATAT,
1595 : (result >= 0),
1596 : handle,
1597 : "%s/%s",
1598 : fsp_str_do_log(dirfsp),
1599 : smb_fname_str_do_log(handle->conn, smb_fname));
1600 :
1601 120 : return result;
1602 : }
1603 13487 : static uint64_t smb_full_audit_get_alloc_size(vfs_handle_struct *handle,
1604 : files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
1605 : {
1606 : uint64_t result;
1607 :
1608 13487 : result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
1609 :
1610 13487 : do_log(SMB_VFS_OP_GET_ALLOC_SIZE, (result != (uint64_t)-1), handle,
1611 : "%llu", (unsigned long long)result);
1612 :
1613 13487 : return result;
1614 : }
1615 :
1616 333 : static int smb_full_audit_unlinkat(vfs_handle_struct *handle,
1617 : struct files_struct *dirfsp,
1618 : const struct smb_filename *smb_fname,
1619 : int flags)
1620 : {
1621 333 : struct smb_filename *full_fname = NULL;
1622 : int result;
1623 :
1624 333 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1625 : dirfsp,
1626 : smb_fname);
1627 333 : if (full_fname == NULL) {
1628 0 : return -1;
1629 : }
1630 :
1631 333 : result = SMB_VFS_NEXT_UNLINKAT(handle,
1632 : dirfsp,
1633 : smb_fname,
1634 : flags);
1635 :
1636 333 : do_log(SMB_VFS_OP_UNLINKAT, (result >= 0), handle, "%s",
1637 : smb_fname_str_do_log(handle->conn, full_fname));
1638 :
1639 333 : TALLOC_FREE(full_fname);
1640 333 : return result;
1641 : }
1642 :
1643 0 : static int smb_full_audit_fchmod(vfs_handle_struct *handle, files_struct *fsp,
1644 : mode_t mode)
1645 : {
1646 : int result;
1647 :
1648 0 : result = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
1649 :
1650 0 : do_log(SMB_VFS_OP_FCHMOD, (result >= 0), handle,
1651 : "%s|%o", fsp_str_do_log(fsp), mode);
1652 :
1653 0 : return result;
1654 : }
1655 :
1656 0 : static int smb_full_audit_fchown(vfs_handle_struct *handle, files_struct *fsp,
1657 : uid_t uid, gid_t gid)
1658 : {
1659 : int result;
1660 :
1661 0 : result = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
1662 :
1663 0 : do_log(SMB_VFS_OP_FCHOWN, (result >= 0), handle, "%s|%ld|%ld",
1664 : fsp_str_do_log(fsp), (long int)uid, (long int)gid);
1665 :
1666 0 : return result;
1667 : }
1668 :
1669 0 : static int smb_full_audit_lchown(vfs_handle_struct *handle,
1670 : const struct smb_filename *smb_fname,
1671 : uid_t uid,
1672 : gid_t gid)
1673 : {
1674 : int result;
1675 :
1676 0 : result = SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
1677 :
1678 0 : do_log(SMB_VFS_OP_LCHOWN, (result >= 0), handle, "%s|%ld|%ld",
1679 0 : smb_fname->base_name, (long int)uid, (long int)gid);
1680 :
1681 0 : return result;
1682 : }
1683 :
1684 17538 : static int smb_full_audit_chdir(vfs_handle_struct *handle,
1685 : const struct smb_filename *smb_fname)
1686 : {
1687 : int result;
1688 :
1689 17538 : result = SMB_VFS_NEXT_CHDIR(handle, smb_fname);
1690 :
1691 17538 : do_log(SMB_VFS_OP_CHDIR,
1692 : (result >= 0),
1693 : handle,
1694 : "chdir|%s",
1695 : smb_fname_str_do_log(handle->conn, smb_fname));
1696 :
1697 17538 : return result;
1698 : }
1699 :
1700 3267 : static struct smb_filename *smb_full_audit_getwd(vfs_handle_struct *handle,
1701 : TALLOC_CTX *ctx)
1702 : {
1703 : struct smb_filename *result;
1704 :
1705 3267 : result = SMB_VFS_NEXT_GETWD(handle, ctx);
1706 :
1707 3267 : do_log(SMB_VFS_OP_GETWD, (result != NULL), handle, "%s",
1708 : result == NULL? "" : result->base_name);
1709 :
1710 3267 : return result;
1711 : }
1712 :
1713 113 : static int smb_full_audit_fntimes(vfs_handle_struct *handle,
1714 : files_struct *fsp,
1715 : struct smb_file_time *ft)
1716 : {
1717 : int result;
1718 113 : time_t create_time = convert_timespec_to_time_t(ft->create_time);
1719 113 : time_t atime = convert_timespec_to_time_t(ft->atime);
1720 113 : time_t mtime = convert_timespec_to_time_t(ft->mtime);
1721 113 : time_t ctime = convert_timespec_to_time_t(ft->ctime);
1722 113 : const char *create_time_str = "";
1723 113 : const char *atime_str = "";
1724 113 : const char *mtime_str = "";
1725 113 : const char *ctime_str = "";
1726 113 : TALLOC_CTX *frame = talloc_stackframe();
1727 :
1728 113 : if (frame == NULL) {
1729 0 : errno = ENOMEM;
1730 0 : return -1;
1731 : }
1732 :
1733 113 : result = SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
1734 :
1735 113 : if (create_time > 0) {
1736 113 : create_time_str = timestring(frame, create_time);
1737 : }
1738 113 : if (atime > 0) {
1739 113 : atime_str = timestring(frame, atime);
1740 : }
1741 113 : if (mtime > 0) {
1742 113 : mtime_str = timestring(frame, mtime);
1743 : }
1744 113 : if (ctime > 0) {
1745 113 : ctime_str = timestring(frame, ctime);
1746 : }
1747 :
1748 113 : do_log(SMB_VFS_OP_FNTIMES,
1749 : (result >= 0),
1750 : handle,
1751 : "%s|%s|%s|%s|%s",
1752 : fsp_str_do_log(fsp),
1753 : create_time_str,
1754 : atime_str,
1755 : mtime_str,
1756 : ctime_str);
1757 :
1758 113 : TALLOC_FREE(frame);
1759 :
1760 113 : return result;
1761 : }
1762 :
1763 14 : static int smb_full_audit_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
1764 : off_t len)
1765 : {
1766 : int result;
1767 :
1768 14 : result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
1769 :
1770 14 : do_log(SMB_VFS_OP_FTRUNCATE, (result >= 0), handle,
1771 : "%s", fsp_str_do_log(fsp));
1772 :
1773 14 : return result;
1774 : }
1775 :
1776 0 : static int smb_full_audit_fallocate(vfs_handle_struct *handle, files_struct *fsp,
1777 : uint32_t mode,
1778 : off_t offset,
1779 : off_t len)
1780 : {
1781 : int result;
1782 :
1783 0 : result = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
1784 :
1785 0 : do_log(SMB_VFS_OP_FALLOCATE, (result >= 0), handle,
1786 : "%s", fsp_str_do_log(fsp));
1787 :
1788 0 : return result;
1789 : }
1790 :
1791 10 : static bool smb_full_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
1792 : int op, off_t offset, off_t count, int type)
1793 : {
1794 : bool result;
1795 :
1796 10 : result = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
1797 :
1798 10 : do_log(SMB_VFS_OP_LOCK, result, handle, "%s", fsp_str_do_log(fsp));
1799 :
1800 10 : return result;
1801 : }
1802 :
1803 0 : static int smb_full_audit_filesystem_sharemode(struct vfs_handle_struct *handle,
1804 : struct files_struct *fsp,
1805 : uint32_t share_access,
1806 : uint32_t access_mask)
1807 : {
1808 : int result;
1809 :
1810 0 : result = SMB_VFS_NEXT_FILESYSTEM_SHAREMODE(handle,
1811 : fsp,
1812 : share_access,
1813 : access_mask);
1814 :
1815 0 : do_log(SMB_VFS_OP_FILESYSTEM_SHAREMODE, (result >= 0), handle, "%s",
1816 : fsp_str_do_log(fsp));
1817 :
1818 0 : return result;
1819 : }
1820 :
1821 620 : static int smb_full_audit_fcntl(struct vfs_handle_struct *handle,
1822 : struct files_struct *fsp,
1823 : int cmd, va_list cmd_arg)
1824 : {
1825 : void *arg;
1826 : va_list dup_cmd_arg;
1827 : int result;
1828 :
1829 620 : va_copy(dup_cmd_arg, cmd_arg);
1830 620 : arg = va_arg(dup_cmd_arg, void *);
1831 620 : result = SMB_VFS_NEXT_FCNTL(handle, fsp, cmd, arg);
1832 620 : va_end(dup_cmd_arg);
1833 :
1834 620 : do_log(SMB_VFS_OP_FCNTL, (result >= 0), handle, "%s",
1835 : fsp_str_do_log(fsp));
1836 :
1837 620 : return result;
1838 : }
1839 :
1840 0 : static int smb_full_audit_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
1841 : int leasetype)
1842 : {
1843 : int result;
1844 :
1845 0 : result = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
1846 :
1847 0 : do_log(SMB_VFS_OP_LINUX_SETLEASE, (result >= 0), handle, "%s",
1848 : fsp_str_do_log(fsp));
1849 :
1850 0 : return result;
1851 : }
1852 :
1853 88 : static bool smb_full_audit_getlock(vfs_handle_struct *handle, files_struct *fsp,
1854 : off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
1855 : {
1856 : bool result;
1857 :
1858 88 : result = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype, ppid);
1859 :
1860 88 : do_log(SMB_VFS_OP_GETLOCK, result, handle, "%s", fsp_str_do_log(fsp));
1861 :
1862 88 : return result;
1863 : }
1864 :
1865 0 : static int smb_full_audit_symlinkat(vfs_handle_struct *handle,
1866 : const struct smb_filename *link_contents,
1867 : struct files_struct *dirfsp,
1868 : const struct smb_filename *new_smb_fname)
1869 : {
1870 0 : struct smb_filename *full_fname = NULL;
1871 : int result;
1872 :
1873 0 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1874 : dirfsp,
1875 : new_smb_fname);
1876 0 : if (full_fname == NULL) {
1877 0 : return -1;
1878 : }
1879 :
1880 0 : result = SMB_VFS_NEXT_SYMLINKAT(handle,
1881 : link_contents,
1882 : dirfsp,
1883 : new_smb_fname);
1884 :
1885 0 : do_log(SMB_VFS_OP_SYMLINKAT,
1886 : (result >= 0),
1887 : handle,
1888 : "%s|%s",
1889 0 : link_contents->base_name,
1890 : smb_fname_str_do_log(handle->conn, full_fname));
1891 :
1892 0 : TALLOC_FREE(full_fname);
1893 :
1894 0 : return result;
1895 : }
1896 :
1897 14786 : static int smb_full_audit_readlinkat(vfs_handle_struct *handle,
1898 : const struct files_struct *dirfsp,
1899 : const struct smb_filename *smb_fname,
1900 : char *buf,
1901 : size_t bufsiz)
1902 : {
1903 14786 : struct smb_filename *full_fname = NULL;
1904 : int result;
1905 :
1906 14786 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1907 : dirfsp,
1908 : smb_fname);
1909 14786 : if (full_fname == NULL) {
1910 0 : return -1;
1911 : }
1912 :
1913 14786 : result = SMB_VFS_NEXT_READLINKAT(handle,
1914 : dirfsp,
1915 : smb_fname,
1916 : buf,
1917 : bufsiz);
1918 :
1919 14786 : do_log(SMB_VFS_OP_READLINKAT,
1920 : (result >= 0),
1921 : handle,
1922 : "%s",
1923 : smb_fname_str_do_log(handle->conn, full_fname));
1924 :
1925 14786 : TALLOC_FREE(full_fname);
1926 :
1927 14786 : return result;
1928 : }
1929 :
1930 4 : static int smb_full_audit_linkat(vfs_handle_struct *handle,
1931 : files_struct *srcfsp,
1932 : const struct smb_filename *old_smb_fname,
1933 : files_struct *dstfsp,
1934 : const struct smb_filename *new_smb_fname,
1935 : int flags)
1936 : {
1937 4 : struct smb_filename *old_full_fname = NULL;
1938 4 : struct smb_filename *new_full_fname = NULL;
1939 : int result;
1940 :
1941 4 : old_full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1942 : srcfsp,
1943 : old_smb_fname);
1944 4 : if (old_full_fname == NULL) {
1945 0 : return -1;
1946 : }
1947 4 : new_full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1948 : dstfsp,
1949 : new_smb_fname);
1950 4 : if (new_full_fname == NULL) {
1951 0 : TALLOC_FREE(old_full_fname);
1952 0 : return -1;
1953 : }
1954 4 : result = SMB_VFS_NEXT_LINKAT(handle,
1955 : srcfsp,
1956 : old_smb_fname,
1957 : dstfsp,
1958 : new_smb_fname,
1959 : flags);
1960 :
1961 4 : do_log(SMB_VFS_OP_LINKAT,
1962 : (result >= 0),
1963 : handle,
1964 : "%s|%s",
1965 : smb_fname_str_do_log(handle->conn, old_full_fname),
1966 : smb_fname_str_do_log(handle->conn, new_full_fname));
1967 :
1968 4 : TALLOC_FREE(old_full_fname);
1969 4 : TALLOC_FREE(new_full_fname);
1970 :
1971 4 : return result;
1972 : }
1973 :
1974 0 : static int smb_full_audit_mknodat(vfs_handle_struct *handle,
1975 : files_struct *dirfsp,
1976 : const struct smb_filename *smb_fname,
1977 : mode_t mode,
1978 : SMB_DEV_T dev)
1979 : {
1980 0 : struct smb_filename *full_fname = NULL;
1981 : int result;
1982 :
1983 0 : full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1984 : dirfsp,
1985 : smb_fname);
1986 0 : if (full_fname == NULL) {
1987 0 : return -1;
1988 : }
1989 :
1990 0 : result = SMB_VFS_NEXT_MKNODAT(handle,
1991 : dirfsp,
1992 : smb_fname,
1993 : mode,
1994 : dev);
1995 :
1996 0 : do_log(SMB_VFS_OP_MKNODAT,
1997 : (result >= 0),
1998 : handle,
1999 : "%s",
2000 : smb_fname_str_do_log(handle->conn, full_fname));
2001 :
2002 0 : TALLOC_FREE(full_fname);
2003 :
2004 0 : return result;
2005 : }
2006 :
2007 39081 : static struct smb_filename *smb_full_audit_realpath(vfs_handle_struct *handle,
2008 : TALLOC_CTX *ctx,
2009 : const struct smb_filename *smb_fname)
2010 : {
2011 39081 : struct smb_filename *result_fname = NULL;
2012 :
2013 39081 : result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
2014 :
2015 39081 : do_log(SMB_VFS_OP_REALPATH,
2016 : (result_fname != NULL),
2017 : handle,
2018 : "%s",
2019 : smb_fname_str_do_log(handle->conn, smb_fname));
2020 :
2021 39081 : return result_fname;
2022 : }
2023 :
2024 0 : static int smb_full_audit_fchflags(vfs_handle_struct *handle,
2025 : struct files_struct *fsp,
2026 : unsigned int flags)
2027 : {
2028 : int result;
2029 :
2030 0 : result = SMB_VFS_NEXT_FCHFLAGS(handle, fsp, flags);
2031 :
2032 0 : do_log(SMB_VFS_OP_FCHFLAGS,
2033 : (result != 0),
2034 : handle,
2035 : "%s",
2036 0 : smb_fname_str_do_log(handle->conn, fsp->fsp_name));
2037 :
2038 0 : return result;
2039 : }
2040 :
2041 235151 : static struct file_id smb_full_audit_file_id_create(struct vfs_handle_struct *handle,
2042 : const SMB_STRUCT_STAT *sbuf)
2043 : {
2044 235151 : struct file_id id_zero = { 0 };
2045 : struct file_id result;
2046 : struct file_id_buf idbuf;
2047 :
2048 235151 : result = SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf);
2049 :
2050 235151 : do_log(SMB_VFS_OP_FILE_ID_CREATE,
2051 235151 : !file_id_equal(&id_zero, &result),
2052 : handle,
2053 : "%s",
2054 235151 : file_id_str_buf(result, &idbuf));
2055 :
2056 235151 : return result;
2057 : }
2058 :
2059 5775 : static uint64_t smb_full_audit_fs_file_id(struct vfs_handle_struct *handle,
2060 : const SMB_STRUCT_STAT *sbuf)
2061 : {
2062 : uint64_t result;
2063 :
2064 5775 : result = SMB_VFS_NEXT_FS_FILE_ID(handle, sbuf);
2065 :
2066 5775 : do_log(SMB_VFS_OP_FS_FILE_ID,
2067 : result != 0,
2068 : handle, "%" PRIu64, result);
2069 :
2070 5775 : return result;
2071 : }
2072 :
2073 635 : static NTSTATUS smb_full_audit_fstreaminfo(vfs_handle_struct *handle,
2074 : struct files_struct *fsp,
2075 : TALLOC_CTX *mem_ctx,
2076 : unsigned int *pnum_streams,
2077 : struct stream_struct **pstreams)
2078 : {
2079 : NTSTATUS result;
2080 :
2081 635 : result = SMB_VFS_NEXT_FSTREAMINFO(handle, fsp, mem_ctx,
2082 : pnum_streams, pstreams);
2083 :
2084 1270 : do_log(SMB_VFS_OP_FSTREAMINFO,
2085 635 : NT_STATUS_IS_OK(result),
2086 : handle,
2087 : "%s",
2088 635 : smb_fname_str_do_log(handle->conn, fsp->fsp_name));
2089 :
2090 635 : return result;
2091 : }
2092 :
2093 1438 : static NTSTATUS smb_full_audit_get_real_filename_at(
2094 : struct vfs_handle_struct *handle,
2095 : struct files_struct *dirfsp,
2096 : const char *name,
2097 : TALLOC_CTX *mem_ctx,
2098 : char **found_name)
2099 : {
2100 : NTSTATUS result;
2101 :
2102 1438 : result = SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
2103 : handle, dirfsp, name, mem_ctx, found_name);
2104 :
2105 1438 : do_log(SMB_VFS_OP_GET_REAL_FILENAME_AT,
2106 1438 : NT_STATUS_IS_OK(result),
2107 : handle,
2108 : "%s/%s->%s",
2109 : fsp_str_dbg(dirfsp),
2110 : name,
2111 1438 : NT_STATUS_IS_OK(result) ? *found_name : "");
2112 :
2113 1438 : return result;
2114 : }
2115 :
2116 49711 : static const char *smb_full_audit_connectpath(
2117 : vfs_handle_struct *handle,
2118 : const struct files_struct *dirfsp,
2119 : const struct smb_filename *smb_fname)
2120 : {
2121 : const char *result;
2122 :
2123 49711 : result = SMB_VFS_NEXT_CONNECTPATH(handle, dirfsp, smb_fname);
2124 :
2125 49711 : do_log(SMB_VFS_OP_CONNECTPATH,
2126 : result != NULL,
2127 : handle,
2128 : "%s",
2129 : smb_fname_str_do_log(handle->conn, smb_fname));
2130 :
2131 49711 : return result;
2132 : }
2133 :
2134 5 : static NTSTATUS smb_full_audit_brl_lock_windows(struct vfs_handle_struct *handle,
2135 : struct byte_range_lock *br_lck,
2136 : struct lock_struct *plock)
2137 : {
2138 : NTSTATUS result;
2139 :
2140 5 : result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock);
2141 :
2142 5 : do_log(SMB_VFS_OP_BRL_LOCK_WINDOWS, NT_STATUS_IS_OK(result), handle,
2143 : "%s:%llu-%llu. type=%d.",
2144 5 : fsp_str_do_log(brl_fsp(br_lck)),
2145 5 : (unsigned long long)plock->start,
2146 5 : (unsigned long long)plock->size,
2147 5 : plock->lock_type);
2148 :
2149 5 : return result;
2150 : }
2151 :
2152 9 : static bool smb_full_audit_brl_unlock_windows(struct vfs_handle_struct *handle,
2153 : struct byte_range_lock *br_lck,
2154 : const struct lock_struct *plock)
2155 : {
2156 : bool result;
2157 :
2158 9 : result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, br_lck, plock);
2159 :
2160 9 : do_log(SMB_VFS_OP_BRL_UNLOCK_WINDOWS, (result == 0), handle,
2161 9 : "%s:%llu-%llu:%d", fsp_str_do_log(brl_fsp(br_lck)),
2162 9 : (unsigned long long)plock->start,
2163 9 : (unsigned long long)plock->size,
2164 18 : plock->lock_type);
2165 :
2166 9 : return result;
2167 : }
2168 :
2169 88 : static bool smb_full_audit_strict_lock_check(struct vfs_handle_struct *handle,
2170 : struct files_struct *fsp,
2171 : struct lock_struct *plock)
2172 : {
2173 : bool result;
2174 :
2175 88 : result = SMB_VFS_NEXT_STRICT_LOCK_CHECK(handle, fsp, plock);
2176 :
2177 88 : do_log(SMB_VFS_OP_STRICT_LOCK_CHECK, result, handle,
2178 : "%s:%llu-%llu:%d", fsp_str_do_log(fsp),
2179 88 : (unsigned long long)plock->start,
2180 88 : (unsigned long long)plock->size,
2181 88 : plock->lock_type);
2182 :
2183 88 : return result;
2184 : }
2185 :
2186 17775 : static NTSTATUS smb_full_audit_translate_name(struct vfs_handle_struct *handle,
2187 : const char *name,
2188 : enum vfs_translate_direction direction,
2189 : TALLOC_CTX *mem_ctx,
2190 : char **mapped_name)
2191 : {
2192 : NTSTATUS result;
2193 :
2194 17775 : result = SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx,
2195 : mapped_name);
2196 :
2197 17775 : do_log(SMB_VFS_OP_TRANSLATE_NAME, NT_STATUS_IS_OK(result), handle, "");
2198 :
2199 17775 : return result;
2200 : }
2201 :
2202 43211 : static NTSTATUS smb_full_audit_parent_pathname(struct vfs_handle_struct *handle,
2203 : TALLOC_CTX *mem_ctx,
2204 : const struct smb_filename *smb_fname_in,
2205 : struct smb_filename **parent_dir_out,
2206 : struct smb_filename **atname_out)
2207 : {
2208 : NTSTATUS result;
2209 :
2210 43211 : result = SMB_VFS_NEXT_PARENT_PATHNAME(handle,
2211 : mem_ctx,
2212 : smb_fname_in,
2213 : parent_dir_out,
2214 : atname_out);
2215 43211 : do_log(SMB_VFS_OP_CONNECTPATH,
2216 43211 : NT_STATUS_IS_OK(result),
2217 : handle,
2218 : "%s",
2219 : smb_fname_str_do_log(handle->conn, smb_fname_in));
2220 :
2221 43211 : return result;
2222 : }
2223 :
2224 48 : static NTSTATUS smb_full_audit_fsctl(struct vfs_handle_struct *handle,
2225 : struct files_struct *fsp,
2226 : TALLOC_CTX *ctx,
2227 : uint32_t function,
2228 : uint16_t req_flags,
2229 : const uint8_t *_in_data,
2230 : uint32_t in_len,
2231 : uint8_t **_out_data,
2232 : uint32_t max_out_len,
2233 : uint32_t *out_len)
2234 : {
2235 : NTSTATUS result;
2236 :
2237 48 : result = SMB_VFS_NEXT_FSCTL(handle,
2238 : fsp,
2239 : ctx,
2240 : function,
2241 : req_flags,
2242 : _in_data,
2243 : in_len,
2244 : _out_data,
2245 : max_out_len,
2246 : out_len);
2247 :
2248 48 : do_log(SMB_VFS_OP_FSCTL, NT_STATUS_IS_OK(result), handle, "");
2249 :
2250 48 : return result;
2251 : }
2252 :
2253 0 : static struct tevent_req *smb_full_audit_offload_read_send(
2254 : TALLOC_CTX *mem_ctx,
2255 : struct tevent_context *ev,
2256 : struct vfs_handle_struct *handle,
2257 : struct files_struct *fsp,
2258 : uint32_t fsctl,
2259 : uint32_t ttl,
2260 : off_t offset,
2261 : size_t to_copy)
2262 : {
2263 0 : struct tevent_req *req = NULL;
2264 :
2265 0 : req = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
2266 : fsctl, ttl, offset, to_copy);
2267 :
2268 0 : do_log(SMB_VFS_OP_OFFLOAD_READ_SEND, req, handle, "");
2269 :
2270 0 : return req;
2271 : }
2272 :
2273 0 : static NTSTATUS smb_full_audit_offload_read_recv(
2274 : struct tevent_req *req,
2275 : struct vfs_handle_struct *handle,
2276 : TALLOC_CTX *mem_ctx,
2277 : uint32_t *flags,
2278 : uint64_t *xferlen,
2279 : DATA_BLOB *_token_blob)
2280 : {
2281 : NTSTATUS status;
2282 :
2283 0 : status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(req, handle, mem_ctx,
2284 : flags, xferlen, _token_blob);
2285 :
2286 0 : do_log(SMB_VFS_OP_OFFLOAD_READ_RECV, NT_STATUS_IS_OK(status), handle, "");
2287 :
2288 0 : return status;
2289 : }
2290 :
2291 0 : static struct tevent_req *smb_full_audit_offload_write_send(struct vfs_handle_struct *handle,
2292 : TALLOC_CTX *mem_ctx,
2293 : struct tevent_context *ev,
2294 : uint32_t fsctl,
2295 : DATA_BLOB *token,
2296 : off_t transfer_offset,
2297 : struct files_struct *dest_fsp,
2298 : off_t dest_off,
2299 : off_t num)
2300 : {
2301 : struct tevent_req *req;
2302 :
2303 0 : req = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, mem_ctx, ev,
2304 : fsctl, token, transfer_offset,
2305 : dest_fsp, dest_off, num);
2306 :
2307 0 : do_log(SMB_VFS_OP_OFFLOAD_WRITE_SEND, req, handle, "");
2308 :
2309 0 : return req;
2310 : }
2311 :
2312 0 : static NTSTATUS smb_full_audit_offload_write_recv(struct vfs_handle_struct *handle,
2313 : struct tevent_req *req,
2314 : off_t *copied)
2315 : {
2316 : NTSTATUS result;
2317 :
2318 0 : result = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(handle, req, copied);
2319 :
2320 0 : do_log(SMB_VFS_OP_OFFLOAD_WRITE_RECV, NT_STATUS_IS_OK(result), handle, "");
2321 :
2322 0 : return result;
2323 : }
2324 :
2325 0 : static NTSTATUS smb_full_audit_fget_compression(vfs_handle_struct *handle,
2326 : TALLOC_CTX *mem_ctx,
2327 : struct files_struct *fsp,
2328 : uint16_t *_compression_fmt)
2329 : {
2330 : NTSTATUS result;
2331 :
2332 0 : result = SMB_VFS_NEXT_FGET_COMPRESSION(handle, mem_ctx, fsp,
2333 : _compression_fmt);
2334 :
2335 0 : do_log(SMB_VFS_OP_FGET_COMPRESSION, NT_STATUS_IS_OK(result), handle,
2336 : "%s",
2337 : fsp_str_do_log(fsp));
2338 :
2339 0 : return result;
2340 : }
2341 :
2342 0 : static NTSTATUS smb_full_audit_set_compression(vfs_handle_struct *handle,
2343 : TALLOC_CTX *mem_ctx,
2344 : struct files_struct *fsp,
2345 : uint16_t compression_fmt)
2346 : {
2347 : NTSTATUS result;
2348 :
2349 0 : result = SMB_VFS_NEXT_SET_COMPRESSION(handle, mem_ctx, fsp,
2350 : compression_fmt);
2351 :
2352 0 : do_log(SMB_VFS_OP_SET_COMPRESSION, NT_STATUS_IS_OK(result), handle,
2353 : "%s", fsp_str_do_log(fsp));
2354 :
2355 0 : return result;
2356 : }
2357 :
2358 5017 : static NTSTATUS smb_full_audit_freaddir_attr(struct vfs_handle_struct *handle,
2359 : struct files_struct *fsp,
2360 : TALLOC_CTX *mem_ctx,
2361 : struct readdir_attr_data **pattr_data)
2362 : {
2363 : NTSTATUS status;
2364 :
2365 5017 : status = SMB_VFS_NEXT_FREADDIR_ATTR(handle, fsp, mem_ctx, pattr_data);
2366 :
2367 5017 : do_log(SMB_VFS_OP_FREADDIR_ATTR,
2368 5017 : NT_STATUS_IS_OK(status),
2369 : handle,
2370 : "%s",
2371 : fsp_str_do_log(fsp));
2372 :
2373 5017 : return status;
2374 : }
2375 :
2376 : struct smb_full_audit_get_dos_attributes_state {
2377 : struct vfs_aio_state aio_state;
2378 : vfs_handle_struct *handle;
2379 : files_struct *dir_fsp;
2380 : const struct smb_filename *smb_fname;
2381 : uint32_t dosmode;
2382 : };
2383 :
2384 : static void smb_full_audit_get_dos_attributes_done(struct tevent_req *subreq);
2385 :
2386 0 : static struct tevent_req *smb_full_audit_get_dos_attributes_send(
2387 : TALLOC_CTX *mem_ctx,
2388 : struct tevent_context *ev,
2389 : struct vfs_handle_struct *handle,
2390 : files_struct *dir_fsp,
2391 : struct smb_filename *smb_fname)
2392 : {
2393 0 : struct tevent_req *req = NULL;
2394 0 : struct smb_full_audit_get_dos_attributes_state *state = NULL;
2395 0 : struct tevent_req *subreq = NULL;
2396 :
2397 0 : req = tevent_req_create(mem_ctx, &state,
2398 : struct smb_full_audit_get_dos_attributes_state);
2399 0 : if (req == NULL) {
2400 0 : do_log(SMB_VFS_OP_GET_DOS_ATTRIBUTES_SEND,
2401 : false,
2402 : handle,
2403 : "%s/%s",
2404 : fsp_str_do_log(dir_fsp),
2405 : smb_fname->base_name);
2406 0 : return NULL;
2407 : }
2408 0 : *state = (struct smb_full_audit_get_dos_attributes_state) {
2409 : .handle = handle,
2410 : .dir_fsp = dir_fsp,
2411 : .smb_fname = smb_fname,
2412 : };
2413 :
2414 0 : subreq = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES_SEND(mem_ctx,
2415 : ev,
2416 : handle,
2417 : dir_fsp,
2418 : smb_fname);
2419 0 : if (tevent_req_nomem(subreq, req)) {
2420 0 : do_log(SMB_VFS_OP_GET_DOS_ATTRIBUTES_SEND,
2421 : false,
2422 : handle,
2423 : "%s/%s",
2424 : fsp_str_do_log(dir_fsp),
2425 : smb_fname->base_name);
2426 0 : return tevent_req_post(req, ev);
2427 : }
2428 0 : tevent_req_set_callback(subreq,
2429 : smb_full_audit_get_dos_attributes_done,
2430 : req);
2431 :
2432 0 : do_log(SMB_VFS_OP_GET_DOS_ATTRIBUTES_SEND,
2433 : true,
2434 : handle,
2435 : "%s/%s",
2436 : fsp_str_do_log(dir_fsp),
2437 : smb_fname->base_name);
2438 :
2439 0 : return req;
2440 : }
2441 :
2442 0 : static void smb_full_audit_get_dos_attributes_done(struct tevent_req *subreq)
2443 : {
2444 : struct tevent_req *req =
2445 0 : tevent_req_callback_data(subreq,
2446 : struct tevent_req);
2447 : struct smb_full_audit_get_dos_attributes_state *state =
2448 0 : tevent_req_data(req,
2449 : struct smb_full_audit_get_dos_attributes_state);
2450 : NTSTATUS status;
2451 :
2452 0 : status = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES_RECV(subreq,
2453 : &state->aio_state,
2454 : &state->dosmode);
2455 0 : TALLOC_FREE(subreq);
2456 0 : if (tevent_req_nterror(req, status)) {
2457 0 : return;
2458 : }
2459 :
2460 0 : tevent_req_done(req);
2461 0 : return;
2462 : }
2463 :
2464 0 : static NTSTATUS smb_full_audit_get_dos_attributes_recv(struct tevent_req *req,
2465 : struct vfs_aio_state *aio_state,
2466 : uint32_t *dosmode)
2467 : {
2468 : struct smb_full_audit_get_dos_attributes_state *state =
2469 0 : tevent_req_data(req,
2470 : struct smb_full_audit_get_dos_attributes_state);
2471 : NTSTATUS status;
2472 :
2473 0 : if (tevent_req_is_nterror(req, &status)) {
2474 0 : do_log(SMB_VFS_OP_GET_DOS_ATTRIBUTES_RECV,
2475 : false,
2476 : state->handle,
2477 : "%s/%s",
2478 0 : fsp_str_do_log(state->dir_fsp),
2479 0 : state->smb_fname->base_name);
2480 0 : tevent_req_received(req);
2481 0 : return status;
2482 : }
2483 :
2484 0 : do_log(SMB_VFS_OP_GET_DOS_ATTRIBUTES_RECV,
2485 : true,
2486 : state->handle,
2487 : "%s/%s",
2488 0 : fsp_str_do_log(state->dir_fsp),
2489 0 : state->smb_fname->base_name);
2490 :
2491 0 : *aio_state = state->aio_state;
2492 0 : *dosmode = state->dosmode;
2493 0 : tevent_req_received(req);
2494 0 : return NT_STATUS_OK;
2495 : }
2496 :
2497 18473 : static NTSTATUS smb_full_audit_fget_dos_attributes(
2498 : struct vfs_handle_struct *handle,
2499 : struct files_struct *fsp,
2500 : uint32_t *dosmode)
2501 : {
2502 : NTSTATUS status;
2503 :
2504 18473 : status = SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES(handle,
2505 : fsp,
2506 : dosmode);
2507 :
2508 18473 : do_log(SMB_VFS_OP_FGET_DOS_ATTRIBUTES,
2509 18473 : NT_STATUS_IS_OK(status),
2510 : handle,
2511 : "%s",
2512 : fsp_str_do_log(fsp));
2513 :
2514 18473 : return status;
2515 : }
2516 :
2517 417 : static NTSTATUS smb_full_audit_fset_dos_attributes(
2518 : struct vfs_handle_struct *handle,
2519 : struct files_struct *fsp,
2520 : uint32_t dosmode)
2521 : {
2522 : NTSTATUS status;
2523 :
2524 417 : status = SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES(handle,
2525 : fsp,
2526 : dosmode);
2527 :
2528 417 : do_log(SMB_VFS_OP_FSET_DOS_ATTRIBUTES,
2529 417 : NT_STATUS_IS_OK(status),
2530 : handle,
2531 : "%s",
2532 : fsp_str_do_log(fsp));
2533 :
2534 417 : return status;
2535 : }
2536 :
2537 2186 : static NTSTATUS smb_full_audit_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
2538 : uint32_t security_info,
2539 : TALLOC_CTX *mem_ctx,
2540 : struct security_descriptor **ppdesc)
2541 : {
2542 : NTSTATUS result;
2543 :
2544 2186 : result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
2545 : mem_ctx, ppdesc);
2546 :
2547 2186 : do_log(SMB_VFS_OP_FGET_NT_ACL, NT_STATUS_IS_OK(result), handle,
2548 : "%s", fsp_str_do_log(fsp));
2549 :
2550 2186 : return result;
2551 : }
2552 :
2553 350 : static NTSTATUS smb_full_audit_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
2554 : uint32_t security_info_sent,
2555 : const struct security_descriptor *psd)
2556 : {
2557 : struct vfs_full_audit_private_data *pd;
2558 : NTSTATUS result;
2559 350 : char *sd = NULL;
2560 :
2561 350 : SMB_VFS_HANDLE_GET_DATA(handle, pd,
2562 : struct vfs_full_audit_private_data,
2563 : return NT_STATUS_INTERNAL_ERROR);
2564 :
2565 350 : if (pd->log_secdesc) {
2566 0 : sd = sddl_encode(talloc_tos(), psd, get_global_sam_sid());
2567 : }
2568 :
2569 350 : result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
2570 :
2571 350 : do_log(SMB_VFS_OP_FSET_NT_ACL, NT_STATUS_IS_OK(result), handle,
2572 : "%s [%s]", fsp_str_do_log(fsp), sd ? sd : "");
2573 :
2574 350 : TALLOC_FREE(sd);
2575 :
2576 350 : return result;
2577 : }
2578 :
2579 0 : static NTSTATUS smb_full_audit_audit_file(struct vfs_handle_struct *handle,
2580 : struct smb_filename *file,
2581 : struct security_acl *sacl,
2582 : uint32_t access_requested,
2583 : uint32_t access_denied)
2584 : {
2585 : NTSTATUS result;
2586 :
2587 0 : result = SMB_VFS_NEXT_AUDIT_FILE(handle,
2588 : file,
2589 : sacl,
2590 : access_requested,
2591 : access_denied);
2592 :
2593 0 : do_log(SMB_VFS_OP_AUDIT_FILE, NT_STATUS_IS_OK(result), handle,
2594 : "%s",
2595 : smb_fname_str_do_log(handle->conn, file));
2596 :
2597 0 : return result;
2598 : }
2599 :
2600 0 : static SMB_ACL_T smb_full_audit_sys_acl_get_fd(vfs_handle_struct *handle,
2601 : files_struct *fsp,
2602 : SMB_ACL_TYPE_T type,
2603 : TALLOC_CTX *mem_ctx)
2604 : {
2605 : SMB_ACL_T result;
2606 :
2607 0 : result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle,
2608 : fsp,
2609 : type,
2610 : mem_ctx);
2611 :
2612 0 : do_log(SMB_VFS_OP_SYS_ACL_GET_FD, (result != NULL), handle,
2613 : "%s", fsp_str_do_log(fsp));
2614 :
2615 0 : return result;
2616 : }
2617 :
2618 0 : static int smb_full_audit_sys_acl_blob_get_fd(vfs_handle_struct *handle,
2619 : files_struct *fsp,
2620 : TALLOC_CTX *mem_ctx,
2621 : char **blob_description,
2622 : DATA_BLOB *blob)
2623 : {
2624 : int result;
2625 :
2626 0 : result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle, fsp, mem_ctx, blob_description, blob);
2627 :
2628 0 : do_log(SMB_VFS_OP_SYS_ACL_BLOB_GET_FD, (result >= 0), handle,
2629 : "%s", fsp_str_do_log(fsp));
2630 :
2631 0 : return result;
2632 : }
2633 :
2634 0 : static int smb_full_audit_sys_acl_set_fd(vfs_handle_struct *handle,
2635 : struct files_struct *fsp,
2636 : SMB_ACL_TYPE_T type,
2637 : SMB_ACL_T theacl)
2638 : {
2639 : int result;
2640 :
2641 0 : result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, type, theacl);
2642 :
2643 0 : do_log(SMB_VFS_OP_SYS_ACL_SET_FD, (result >= 0), handle,
2644 : "%s", fsp_str_do_log(fsp));
2645 :
2646 0 : return result;
2647 : }
2648 :
2649 0 : static int smb_full_audit_sys_acl_delete_def_fd(vfs_handle_struct *handle,
2650 : struct files_struct *fsp)
2651 : {
2652 : int result;
2653 :
2654 0 : result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FD(handle, fsp);
2655 :
2656 0 : do_log(SMB_VFS_OP_SYS_ACL_DELETE_DEF_FD,
2657 : (result >= 0),
2658 : handle,
2659 : "%s",
2660 : fsp_str_do_log(fsp));
2661 :
2662 0 : return result;
2663 : }
2664 :
2665 : struct smb_full_audit_getxattrat_state {
2666 : struct vfs_aio_state aio_state;
2667 : vfs_handle_struct *handle;
2668 : files_struct *dir_fsp;
2669 : const struct smb_filename *smb_fname;
2670 : const char *xattr_name;
2671 : ssize_t xattr_size;
2672 : uint8_t *xattr_value;
2673 : };
2674 :
2675 : static void smb_full_audit_getxattrat_done(struct tevent_req *subreq);
2676 :
2677 0 : static struct tevent_req *smb_full_audit_getxattrat_send(
2678 : TALLOC_CTX *mem_ctx,
2679 : struct tevent_context *ev,
2680 : struct vfs_handle_struct *handle,
2681 : files_struct *dir_fsp,
2682 : const struct smb_filename *smb_fname,
2683 : const char *xattr_name,
2684 : size_t alloc_hint)
2685 : {
2686 0 : struct tevent_req *req = NULL;
2687 0 : struct tevent_req *subreq = NULL;
2688 0 : struct smb_full_audit_getxattrat_state *state = NULL;
2689 :
2690 0 : req = tevent_req_create(mem_ctx, &state,
2691 : struct smb_full_audit_getxattrat_state);
2692 0 : if (req == NULL) {
2693 0 : do_log(SMB_VFS_OP_GETXATTRAT_SEND,
2694 : false,
2695 : handle,
2696 : "%s/%s|%s",
2697 : fsp_str_do_log(dir_fsp),
2698 0 : smb_fname->base_name,
2699 : xattr_name);
2700 0 : return NULL;
2701 : }
2702 0 : *state = (struct smb_full_audit_getxattrat_state) {
2703 : .handle = handle,
2704 : .dir_fsp = dir_fsp,
2705 : .smb_fname = smb_fname,
2706 : .xattr_name = xattr_name,
2707 : };
2708 :
2709 0 : subreq = SMB_VFS_NEXT_GETXATTRAT_SEND(state,
2710 : ev,
2711 : handle,
2712 : dir_fsp,
2713 : smb_fname,
2714 : xattr_name,
2715 : alloc_hint);
2716 0 : if (tevent_req_nomem(subreq, req)) {
2717 0 : do_log(SMB_VFS_OP_GETXATTRAT_SEND,
2718 : false,
2719 : handle,
2720 : "%s/%s|%s",
2721 : fsp_str_do_log(dir_fsp),
2722 0 : smb_fname->base_name,
2723 : xattr_name);
2724 0 : return tevent_req_post(req, ev);
2725 : }
2726 0 : tevent_req_set_callback(subreq, smb_full_audit_getxattrat_done, req);
2727 :
2728 0 : do_log(SMB_VFS_OP_GETXATTRAT_SEND,
2729 : true,
2730 : handle,
2731 : "%s/%s|%s",
2732 : fsp_str_do_log(dir_fsp),
2733 0 : smb_fname->base_name,
2734 : xattr_name);
2735 :
2736 0 : return req;
2737 : }
2738 :
2739 0 : static void smb_full_audit_getxattrat_done(struct tevent_req *subreq)
2740 : {
2741 0 : struct tevent_req *req = tevent_req_callback_data(
2742 : subreq, struct tevent_req);
2743 0 : struct smb_full_audit_getxattrat_state *state = tevent_req_data(
2744 : req, struct smb_full_audit_getxattrat_state);
2745 :
2746 0 : state->xattr_size = SMB_VFS_NEXT_GETXATTRAT_RECV(subreq,
2747 : &state->aio_state,
2748 : state,
2749 : &state->xattr_value);
2750 0 : TALLOC_FREE(subreq);
2751 0 : if (state->xattr_size == -1) {
2752 0 : tevent_req_error(req, state->aio_state.error);
2753 0 : return;
2754 : }
2755 :
2756 0 : tevent_req_done(req);
2757 : }
2758 :
2759 0 : static ssize_t smb_full_audit_getxattrat_recv(struct tevent_req *req,
2760 : struct vfs_aio_state *aio_state,
2761 : TALLOC_CTX *mem_ctx,
2762 : uint8_t **xattr_value)
2763 : {
2764 0 : struct smb_full_audit_getxattrat_state *state = tevent_req_data(
2765 : req, struct smb_full_audit_getxattrat_state);
2766 : ssize_t xattr_size;
2767 :
2768 0 : if (tevent_req_is_unix_error(req, &aio_state->error)) {
2769 0 : do_log(SMB_VFS_OP_GETXATTRAT_RECV,
2770 : false,
2771 : state->handle,
2772 : "%s/%s|%s",
2773 0 : fsp_str_do_log(state->dir_fsp),
2774 0 : state->smb_fname->base_name,
2775 : state->xattr_name);
2776 0 : tevent_req_received(req);
2777 0 : return -1;
2778 : }
2779 :
2780 0 : do_log(SMB_VFS_OP_GETXATTRAT_RECV,
2781 : true,
2782 : state->handle,
2783 : "%s/%s|%s",
2784 0 : fsp_str_do_log(state->dir_fsp),
2785 0 : state->smb_fname->base_name,
2786 : state->xattr_name);
2787 :
2788 0 : *aio_state = state->aio_state;
2789 0 : xattr_size = state->xattr_size;
2790 0 : if (xattr_value != NULL) {
2791 0 : *xattr_value = talloc_move(mem_ctx, &state->xattr_value);
2792 : }
2793 :
2794 0 : tevent_req_received(req);
2795 0 : return xattr_size;
2796 : }
2797 :
2798 0 : static ssize_t smb_full_audit_fgetxattr(struct vfs_handle_struct *handle,
2799 : struct files_struct *fsp,
2800 : const char *name, void *value, size_t size)
2801 : {
2802 : ssize_t result;
2803 :
2804 0 : result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, value, size);
2805 :
2806 0 : do_log(SMB_VFS_OP_FGETXATTR, (result >= 0), handle,
2807 : "%s|%s", fsp_str_do_log(fsp), name);
2808 :
2809 0 : return result;
2810 : }
2811 :
2812 0 : static ssize_t smb_full_audit_flistxattr(struct vfs_handle_struct *handle,
2813 : struct files_struct *fsp, char *list,
2814 : size_t size)
2815 : {
2816 : ssize_t result;
2817 :
2818 0 : result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
2819 :
2820 0 : do_log(SMB_VFS_OP_FLISTXATTR, (result >= 0), handle,
2821 : "%s", fsp_str_do_log(fsp));
2822 :
2823 0 : return result;
2824 : }
2825 :
2826 0 : static int smb_full_audit_fremovexattr(struct vfs_handle_struct *handle,
2827 : struct files_struct *fsp,
2828 : const char *name)
2829 : {
2830 : int result;
2831 :
2832 0 : result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
2833 :
2834 0 : do_log(SMB_VFS_OP_FREMOVEXATTR, (result >= 0), handle,
2835 : "%s|%s", fsp_str_do_log(fsp), name);
2836 :
2837 0 : return result;
2838 : }
2839 :
2840 0 : static int smb_full_audit_fsetxattr(struct vfs_handle_struct *handle,
2841 : struct files_struct *fsp, const char *name,
2842 : const void *value, size_t size, int flags)
2843 : {
2844 : int result;
2845 :
2846 0 : result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, value, size, flags);
2847 :
2848 0 : do_log(SMB_VFS_OP_FSETXATTR, (result >= 0), handle,
2849 : "%s|%s", fsp_str_do_log(fsp), name);
2850 :
2851 0 : return result;
2852 : }
2853 :
2854 0 : static bool smb_full_audit_aio_force(struct vfs_handle_struct *handle,
2855 : struct files_struct *fsp)
2856 : {
2857 : bool result;
2858 :
2859 0 : result = SMB_VFS_NEXT_AIO_FORCE(handle, fsp);
2860 0 : do_log(SMB_VFS_OP_AIO_FORCE, result, handle,
2861 : "%s", fsp_str_do_log(fsp));
2862 :
2863 0 : return result;
2864 : }
2865 :
2866 0 : static NTSTATUS smb_full_audit_durable_cookie(struct vfs_handle_struct *handle,
2867 : struct files_struct *fsp,
2868 : TALLOC_CTX *mem_ctx,
2869 : DATA_BLOB *cookie)
2870 : {
2871 : NTSTATUS result;
2872 :
2873 0 : result = SMB_VFS_NEXT_DURABLE_COOKIE(handle,
2874 : fsp,
2875 : mem_ctx,
2876 : cookie);
2877 :
2878 0 : do_log(SMB_VFS_OP_DURABLE_COOKIE, NT_STATUS_IS_OK(result), handle,
2879 : "%s", fsp_str_do_log(fsp));
2880 :
2881 0 : return result;
2882 : }
2883 :
2884 0 : static NTSTATUS smb_full_audit_durable_disconnect(
2885 : struct vfs_handle_struct *handle,
2886 : struct files_struct *fsp,
2887 : const DATA_BLOB old_cookie,
2888 : TALLOC_CTX *mem_ctx,
2889 : DATA_BLOB *new_cookie)
2890 : {
2891 : NTSTATUS result;
2892 :
2893 0 : result = SMB_VFS_NEXT_DURABLE_DISCONNECT(handle,
2894 : fsp,
2895 : old_cookie,
2896 : mem_ctx,
2897 : new_cookie);
2898 :
2899 0 : do_log(SMB_VFS_OP_DURABLE_DISCONNECT, NT_STATUS_IS_OK(result), handle,
2900 : "%s", fsp_str_do_log(fsp));
2901 :
2902 0 : return result;
2903 : }
2904 :
2905 0 : static NTSTATUS smb_full_audit_durable_reconnect(
2906 : struct vfs_handle_struct *handle,
2907 : struct smb_request *smb1req,
2908 : struct smbXsrv_open *op,
2909 : const DATA_BLOB old_cookie,
2910 : TALLOC_CTX *mem_ctx,
2911 : struct files_struct **fsp,
2912 : DATA_BLOB *new_cookie)
2913 : {
2914 : NTSTATUS result;
2915 :
2916 0 : result = SMB_VFS_NEXT_DURABLE_RECONNECT(handle,
2917 : smb1req,
2918 : op,
2919 : old_cookie,
2920 : mem_ctx,
2921 : fsp,
2922 : new_cookie);
2923 :
2924 0 : do_log(SMB_VFS_OP_DURABLE_RECONNECT,
2925 0 : NT_STATUS_IS_OK(result),
2926 : handle,
2927 : "");
2928 :
2929 0 : return result;
2930 : }
2931 :
2932 : static struct vfs_fn_pointers vfs_full_audit_fns = {
2933 :
2934 : /* Disk operations */
2935 :
2936 : .connect_fn = smb_full_audit_connect,
2937 : .disconnect_fn = smb_full_audit_disconnect,
2938 : .disk_free_fn = smb_full_audit_disk_free,
2939 : .get_quota_fn = smb_full_audit_get_quota,
2940 : .set_quota_fn = smb_full_audit_set_quota,
2941 : .get_shadow_copy_data_fn = smb_full_audit_get_shadow_copy_data,
2942 : .statvfs_fn = smb_full_audit_statvfs,
2943 : .fs_capabilities_fn = smb_full_audit_fs_capabilities,
2944 : .get_dfs_referrals_fn = smb_full_audit_get_dfs_referrals,
2945 : .create_dfs_pathat_fn = smb_full_audit_create_dfs_pathat,
2946 : .read_dfs_pathat_fn = smb_full_audit_read_dfs_pathat,
2947 : .fdopendir_fn = smb_full_audit_fdopendir,
2948 : .readdir_fn = smb_full_audit_readdir,
2949 : .seekdir_fn = smb_full_audit_seekdir,
2950 : .telldir_fn = smb_full_audit_telldir,
2951 : .rewind_dir_fn = smb_full_audit_rewinddir,
2952 : .mkdirat_fn = smb_full_audit_mkdirat,
2953 : .closedir_fn = smb_full_audit_closedir,
2954 : .openat_fn = smb_full_audit_openat,
2955 : .create_file_fn = smb_full_audit_create_file,
2956 : .close_fn = smb_full_audit_close,
2957 : .pread_fn = smb_full_audit_pread,
2958 : .pread_send_fn = smb_full_audit_pread_send,
2959 : .pread_recv_fn = smb_full_audit_pread_recv,
2960 : .pwrite_fn = smb_full_audit_pwrite,
2961 : .pwrite_send_fn = smb_full_audit_pwrite_send,
2962 : .pwrite_recv_fn = smb_full_audit_pwrite_recv,
2963 : .lseek_fn = smb_full_audit_lseek,
2964 : .sendfile_fn = smb_full_audit_sendfile,
2965 : .recvfile_fn = smb_full_audit_recvfile,
2966 : .renameat_fn = smb_full_audit_renameat,
2967 : .fsync_send_fn = smb_full_audit_fsync_send,
2968 : .fsync_recv_fn = smb_full_audit_fsync_recv,
2969 : .stat_fn = smb_full_audit_stat,
2970 : .fstat_fn = smb_full_audit_fstat,
2971 : .lstat_fn = smb_full_audit_lstat,
2972 : .fstatat_fn = smb_full_audit_fstatat,
2973 : .get_alloc_size_fn = smb_full_audit_get_alloc_size,
2974 : .unlinkat_fn = smb_full_audit_unlinkat,
2975 : .fchmod_fn = smb_full_audit_fchmod,
2976 : .fchown_fn = smb_full_audit_fchown,
2977 : .lchown_fn = smb_full_audit_lchown,
2978 : .chdir_fn = smb_full_audit_chdir,
2979 : .getwd_fn = smb_full_audit_getwd,
2980 : .fntimes_fn = smb_full_audit_fntimes,
2981 : .ftruncate_fn = smb_full_audit_ftruncate,
2982 : .fallocate_fn = smb_full_audit_fallocate,
2983 : .lock_fn = smb_full_audit_lock,
2984 : .filesystem_sharemode_fn = smb_full_audit_filesystem_sharemode,
2985 : .fcntl_fn = smb_full_audit_fcntl,
2986 : .linux_setlease_fn = smb_full_audit_linux_setlease,
2987 : .getlock_fn = smb_full_audit_getlock,
2988 : .symlinkat_fn = smb_full_audit_symlinkat,
2989 : .readlinkat_fn = smb_full_audit_readlinkat,
2990 : .linkat_fn = smb_full_audit_linkat,
2991 : .mknodat_fn = smb_full_audit_mknodat,
2992 : .realpath_fn = smb_full_audit_realpath,
2993 : .fchflags_fn = smb_full_audit_fchflags,
2994 : .file_id_create_fn = smb_full_audit_file_id_create,
2995 : .fs_file_id_fn = smb_full_audit_fs_file_id,
2996 : .offload_read_send_fn = smb_full_audit_offload_read_send,
2997 : .offload_read_recv_fn = smb_full_audit_offload_read_recv,
2998 : .offload_write_send_fn = smb_full_audit_offload_write_send,
2999 : .offload_write_recv_fn = smb_full_audit_offload_write_recv,
3000 : .fget_compression_fn = smb_full_audit_fget_compression,
3001 : .set_compression_fn = smb_full_audit_set_compression,
3002 : .snap_check_path_fn = smb_full_audit_snap_check_path,
3003 : .snap_create_fn = smb_full_audit_snap_create,
3004 : .snap_delete_fn = smb_full_audit_snap_delete,
3005 : .fstreaminfo_fn = smb_full_audit_fstreaminfo,
3006 : .get_real_filename_at_fn = smb_full_audit_get_real_filename_at,
3007 : .connectpath_fn = smb_full_audit_connectpath,
3008 : .brl_lock_windows_fn = smb_full_audit_brl_lock_windows,
3009 : .brl_unlock_windows_fn = smb_full_audit_brl_unlock_windows,
3010 : .strict_lock_check_fn = smb_full_audit_strict_lock_check,
3011 : .translate_name_fn = smb_full_audit_translate_name,
3012 : .parent_pathname_fn = smb_full_audit_parent_pathname,
3013 : .fsctl_fn = smb_full_audit_fsctl,
3014 : .get_dos_attributes_send_fn = smb_full_audit_get_dos_attributes_send,
3015 : .get_dos_attributes_recv_fn = smb_full_audit_get_dos_attributes_recv,
3016 : .fget_dos_attributes_fn = smb_full_audit_fget_dos_attributes,
3017 : .fset_dos_attributes_fn = smb_full_audit_fset_dos_attributes,
3018 : .fget_nt_acl_fn = smb_full_audit_fget_nt_acl,
3019 : .fset_nt_acl_fn = smb_full_audit_fset_nt_acl,
3020 : .audit_file_fn = smb_full_audit_audit_file,
3021 : .sys_acl_get_fd_fn = smb_full_audit_sys_acl_get_fd,
3022 : .sys_acl_blob_get_fd_fn = smb_full_audit_sys_acl_blob_get_fd,
3023 : .sys_acl_set_fd_fn = smb_full_audit_sys_acl_set_fd,
3024 : .sys_acl_delete_def_fd_fn = smb_full_audit_sys_acl_delete_def_fd,
3025 : .getxattrat_send_fn = smb_full_audit_getxattrat_send,
3026 : .getxattrat_recv_fn = smb_full_audit_getxattrat_recv,
3027 : .fgetxattr_fn = smb_full_audit_fgetxattr,
3028 : .flistxattr_fn = smb_full_audit_flistxattr,
3029 : .fremovexattr_fn = smb_full_audit_fremovexattr,
3030 : .fsetxattr_fn = smb_full_audit_fsetxattr,
3031 : .aio_force_fn = smb_full_audit_aio_force,
3032 : .durable_cookie_fn = smb_full_audit_durable_cookie,
3033 : .durable_disconnect_fn = smb_full_audit_durable_disconnect,
3034 : .durable_reconnect_fn = smb_full_audit_durable_reconnect,
3035 : .freaddir_attr_fn = smb_full_audit_freaddir_attr,
3036 : };
3037 :
3038 : static_decl_vfs;
3039 1122 : NTSTATUS vfs_full_audit_init(TALLOC_CTX *ctx)
3040 : {
3041 : NTSTATUS ret;
3042 :
3043 1122 : smb_vfs_assert_all_fns(&vfs_full_audit_fns, "full_audit");
3044 :
3045 1122 : ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "full_audit",
3046 : &vfs_full_audit_fns);
3047 :
3048 1122 : if (!NT_STATUS_IS_OK(ret))
3049 0 : return ret;
3050 :
3051 1122 : vfs_full_audit_debug_level = debug_add_class("full_audit");
3052 1122 : if (vfs_full_audit_debug_level == -1) {
3053 0 : vfs_full_audit_debug_level = DBGC_VFS;
3054 0 : DEBUG(0, ("vfs_full_audit: Couldn't register custom debugging "
3055 : "class!\n"));
3056 : } else {
3057 1122 : DEBUG(10, ("vfs_full_audit: Debug class number of "
3058 : "'full_audit': %d\n", vfs_full_audit_debug_level));
3059 : }
3060 :
3061 1122 : return ret;
3062 : }
|
