?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WHATSNEW: Add release notes for Samba 4.13.14.
[Samba.git] / source3 / modules / vfs_fileid.c
blob3c9cd33f6f292b4ceb445ecd3d1db030e96f68b1
1 /*
2 * VFS module to alter the algorithm to calculate
3 * the struct file_id used as key for the share mode
4 * and byte range locking db's.
5 *
6 * Copyright (C) 2007, Stefan Metzmacher
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "smbd/smbd.h"
24 #include "system/filesys.h"
25
26 static int vfs_fileid_debug_level = DBGC_VFS;
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS vfs_fileid_debug_level
30
31 struct fileid_mount_entry {
32 SMB_DEV_T device;
33 const char *mnt_fsname;
34 fsid_t fsid;
35 uint64_t devid;
36 };
37
38 struct fileid_handle_data {
39 uint64_t (*device_mapping_fn)(struct fileid_handle_data *data,
40 const SMB_STRUCT_STAT *sbuf);
41 uint64_t (*extid_mapping_fn)(struct fileid_handle_data *data,
42 const SMB_STRUCT_STAT *sbuf);
43 char **fstype_deny_list;
44 char **fstype_allow_list;
45 char **mntdir_deny_list;
46 char **mntdir_allow_list;
47 unsigned num_mount_entries;
48 struct fileid_mount_entry *mount_entries;
49 ino_t nolockinode;
50 };
51
52 /* check if a mount entry is allowed based on fstype and mount directory */
53 static bool fileid_mount_entry_allowed(struct fileid_handle_data *data,
54 struct mntent *m)
55 {
56 int i;
57 char **fstype_deny = data->fstype_deny_list;
58 char **fstype_allow = data->fstype_allow_list;
59 char **mntdir_deny = data->mntdir_deny_list;
60 char **mntdir_allow = data->mntdir_allow_list;
61
62 if (fstype_deny != NULL) {
63 for (i = 0; fstype_deny[i] != NULL; i++) {
64 if (strcmp(m->mnt_type, fstype_deny[i]) == 0) {
65 return false;
66 }
67 }
68 }
69 if (fstype_allow != NULL) {
70 for (i = 0; fstype_allow[i] != NULL; i++) {
71 if (strcmp(m->mnt_type, fstype_allow[i]) == 0) {
72 break;
73 }
74 }
75 if (fstype_allow[i] == NULL) {
76 return false;
77 }
78 }
79 if (mntdir_deny != NULL) {
80 for (i=0; mntdir_deny[i] != NULL; i++) {
81 if (strcmp(m->mnt_dir, mntdir_deny[i]) == 0) {
82 return false;
83 }
84 }
85 }
86 if (mntdir_allow != NULL) {
87 for (i=0; mntdir_allow[i] != NULL; i++) {
88 if (strcmp(m->mnt_dir, mntdir_allow[i]) == 0) {
89 break;
90 }
91 }
92 if (mntdir_allow[i] == NULL) {
93 return false;
94 }
95 }
96 return true;
97 }
98
99
100 /* load all the mount entries from the mtab */
101 static void fileid_load_mount_entries(struct fileid_handle_data *data)
102 {
103 FILE *f;
104 struct mntent *m;
105
106 data->num_mount_entries = 0;
107 TALLOC_FREE(data->mount_entries);
108
109 f = setmntent("/etc/mtab", "r");
110 if (!f) return;
111
112 while ((m = getmntent(f))) {
113 struct stat st;
114 struct statfs sfs;
115 struct fileid_mount_entry *cur;
116 bool allowed;
117
118 allowed = fileid_mount_entry_allowed(data, m);
119 if (!allowed) {
120 DBG_DEBUG("skipping mount entry %s\n", m->mnt_dir);
121 continue;
122 }
123 if (stat(m->mnt_dir, &st) != 0) continue;
124 if (statfs(m->mnt_dir, &sfs) != 0) continue;
125
126 if (strncmp(m->mnt_fsname, "/dev/", 5) == 0) {
127 m->mnt_fsname += 5;
128 }
129
130 data->mount_entries = talloc_realloc(data,
131 data->mount_entries,
132 struct fileid_mount_entry,
133 data->num_mount_entries+1);
134 if (data->mount_entries == NULL) {
135 goto nomem;
136 }
137
138 cur = &data->mount_entries[data->num_mount_entries];
139 cur->device = st.st_dev;
140 cur->mnt_fsname = talloc_strdup(data->mount_entries,
141 m->mnt_fsname);
142 if (!cur->mnt_fsname) goto nomem;
143 cur->fsid = sfs.f_fsid;
144 cur->devid = (uint64_t)-1;
145
146 data->num_mount_entries++;
147 }
148 endmntent(f);
149 return;
150
151 nomem:
152 if (f) endmntent(f);
153
154 data->num_mount_entries = 0;
155 TALLOC_FREE(data->mount_entries);
156
157 return;
158 }
159
160 /* find a mount entry given a dev_t */
161 static struct fileid_mount_entry *fileid_find_mount_entry(struct fileid_handle_data *data,
162 SMB_DEV_T dev)
163 {
164 unsigned i;
165
166 if (data->num_mount_entries == 0) {
167 fileid_load_mount_entries(data);
168 }
169 for (i=0;i<data->num_mount_entries;i++) {
170 if (data->mount_entries[i].device == dev) {
171 return &data->mount_entries[i];
172 }
173 }
174 /* 2nd pass after reloading */
175 fileid_load_mount_entries(data);
176 for (i=0;i<data->num_mount_entries;i++) {
177 if (data->mount_entries[i].device == dev) {
178 return &data->mount_entries[i];
179 }
180 }
181 return NULL;
182 }
183
184
185 /* a 64 bit hash, based on the one in tdb */
186 static uint64_t fileid_uint64_hash(const uint8_t *s, size_t len)
187 {
188 uint64_t value; /* Used to compute the hash value. */
189 uint32_t i; /* Used to cycle through random values. */
190
191 /* Set the initial value from the key size. */
192 for (value = 0x238F13AFLL * len, i=0; i < len; i++)
193 value = (value + (((uint64_t)s[i]) << (i*5 % 24)));
194
195 return (1103515243LL * value + 12345LL);
196 }
197
198 /* a device mapping using a fsname */
199 static uint64_t fileid_device_mapping_fsname(struct fileid_handle_data *data,
200 const SMB_STRUCT_STAT *sbuf)
201 {
202 struct fileid_mount_entry *m;
203
204 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
205 if (!m) return sbuf->st_ex_dev;
206
207 if (m->devid == (uint64_t)-1) {
208 m->devid = fileid_uint64_hash((const uint8_t *)m->mnt_fsname,
209 strlen(m->mnt_fsname));
210 }
211
212 return m->devid;
213 }
214
215 /* a device mapping using a hostname */
216 static uint64_t fileid_device_mapping_hostname(struct fileid_handle_data *data,
217 const SMB_STRUCT_STAT *sbuf)
218 {
219 char hostname[HOST_NAME_MAX+1];
220 char *devname = NULL;
221 uint64_t id;
222 size_t devname_len;
223 int rc;
224
225 rc = gethostname(hostname, HOST_NAME_MAX+1);
226 if (rc != 0) {
227 DBG_ERR("gethostname failed\n");
228 return UINT64_MAX;
229 }
230
231 devname = talloc_asprintf(talloc_tos(), "%s%ju",
232 hostname, (uintmax_t)sbuf->st_ex_dev);
233 if (devname == NULL) {
234 DBG_ERR("talloc_asprintf failed\n");
235 return UINT64_MAX;
236 }
237 devname_len = talloc_array_length(devname) - 1;
238
239 id = fileid_uint64_hash((uint8_t *)devname, devname_len);
240
241 TALLOC_FREE(devname);
242
243 return id;
244 }
245
246 /* a device mapping using a fsname for files and hostname for dirs */
247 static uint64_t fileid_device_mapping_fsname_nodirs(
248 struct fileid_handle_data *data,
249 const SMB_STRUCT_STAT *sbuf)
250 {
251 if (S_ISDIR(sbuf->st_ex_mode)) {
252 return fileid_device_mapping_hostname(data, sbuf);
253 }
254
255 return fileid_device_mapping_fsname(data, sbuf);
256 }
257
258 /* device mapping functions using a fsid */
259 static uint64_t fileid_device_mapping_fsid(struct fileid_handle_data *data,
260 const SMB_STRUCT_STAT *sbuf)
261 {
262 struct fileid_mount_entry *m;
263
264 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
265 if (!m) return sbuf->st_ex_dev;
266
267 if (m->devid == (uint64_t)-1) {
268 if (sizeof(fsid_t) > sizeof(uint64_t)) {
269 m->devid = fileid_uint64_hash((uint8_t *)&m->fsid,
270 sizeof(m->fsid));
271 } else {
272 union {
273 uint64_t ret;
274 fsid_t fsid;
275 } u;
276 ZERO_STRUCT(u);
277 u.fsid = m->fsid;
278 m->devid = u.ret;
279 }
280 }
281
282 return m->devid;
283 }
284
285 static uint64_t fileid_extid_mapping_zero(struct fileid_handle_data *data,
286 const SMB_STRUCT_STAT *sbuf)
287 {
288 return 0;
289 }
290
291 static uint64_t fileid_extid_mapping_pid(struct fileid_handle_data *data,
292 const SMB_STRUCT_STAT *sbuf)
293 {
294 return getpid();
295 }
296
297 static int get_connectpath_ino(struct vfs_handle_struct *handle,
298 ino_t *ino)
299 {
300 struct smb_filename *fname = NULL;
301 int ret;
302
303 fname = synthetic_smb_fname(talloc_tos(),
304 handle->conn->connectpath,
305 NULL,
306 NULL,
307 0,
308 0);
309 if (fname == NULL) {
310 DBG_ERR("synthetic_smb_fname failed\n");
311 return -1;
312 }
313
314 ret = SMB_VFS_NEXT_STAT(handle, fname);
315 if (ret != 0) {
316 DBG_ERR("stat failed for %s with %s\n",
317 handle->conn->connectpath, strerror(errno));
318 TALLOC_FREE(fname);
319 return -1;
320 }
321 *ino = fname->st.st_ex_ino;
322 TALLOC_FREE(fname);
323
324 return 0;
325 }
326
327 static int fileid_connect(struct vfs_handle_struct *handle,
328 const char *service, const char *user)
329 {
330 struct fileid_handle_data *data;
331 const char *algorithm;
332 const char **fstype_deny_list = NULL;
333 const char **fstype_allow_list = NULL;
334 const char **mntdir_deny_list = NULL;
335 const char **mntdir_allow_list = NULL;
336 int saved_errno;
337 int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
338
339 if (ret < 0) {
340 return ret;
341 }
342
343 data = talloc_zero(handle->conn, struct fileid_handle_data);
344 if (!data) {
345 saved_errno = errno;
346 SMB_VFS_NEXT_DISCONNECT(handle);
347 DEBUG(0, ("talloc_zero() failed\n"));
348 errno = saved_errno;
349 return -1;
350 }
351
352 data->nolockinode = 0;
353
354 /*
355 * "fileid:mapping" is only here as fallback for old setups
356 * "fileid:algorithm" is the option new setups should use
357 */
358 algorithm = lp_parm_const_string(SNUM(handle->conn),
359 "fileid", "mapping",
360 "fsname");
361 algorithm = lp_parm_const_string(SNUM(handle->conn),
362 "fileid", "algorithm",
363 algorithm);
364 if (strcmp("fsname", algorithm) == 0) {
365 data->device_mapping_fn = fileid_device_mapping_fsname;
366 data->extid_mapping_fn = fileid_extid_mapping_zero;
367 } else if (strcmp("fsname_nodirs", algorithm) == 0) {
368 data->device_mapping_fn = fileid_device_mapping_fsname_nodirs;
369 data->extid_mapping_fn = fileid_extid_mapping_zero;
370 } else if (strcmp("fsid", algorithm) == 0) {
371 data->device_mapping_fn = fileid_device_mapping_fsid;
372 data->extid_mapping_fn = fileid_extid_mapping_zero;
373 } else if (strcmp("hostname", algorithm) == 0) {
374 data->device_mapping_fn = fileid_device_mapping_hostname;
375 data->extid_mapping_fn = fileid_extid_mapping_zero;
376 } else if (strcmp("fsname_norootdir", algorithm) == 0) {
377 data->device_mapping_fn = fileid_device_mapping_fsname;
378 data->extid_mapping_fn = fileid_extid_mapping_zero;
379
380 ret = get_connectpath_ino(handle, &data->nolockinode);
381 if (ret != 0) {
382 saved_errno = errno;
383 SMB_VFS_NEXT_DISCONNECT(handle);
384 errno = saved_errno;
385 return -1;
386 }
387 } else if (strcmp("fsname_norootdir_ext", algorithm) == 0) {
388 data->device_mapping_fn = fileid_device_mapping_fsname;
389 data->extid_mapping_fn = fileid_extid_mapping_pid;
390
391 ret = get_connectpath_ino(handle, &data->nolockinode);
392 if (ret != 0) {
393 saved_errno = errno;
394 SMB_VFS_NEXT_DISCONNECT(handle);
395 errno = saved_errno;
396 return -1;
397 }
398 } else {
399 SMB_VFS_NEXT_DISCONNECT(handle);
400 DEBUG(0,("fileid_connect(): unknown algorithm[%s]\n", algorithm));
401 return -1;
402 }
403
404 fstype_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
405 "fstype deny", NULL);
406 if (fstype_deny_list != NULL) {
407 data->fstype_deny_list = str_list_copy(data, fstype_deny_list);
408 if (data->fstype_deny_list == NULL) {
409 saved_errno = errno;
410 DBG_ERR("str_list_copy failed\n");
411 SMB_VFS_NEXT_DISCONNECT(handle);
412 errno = saved_errno;
413 return -1;
414 }
415 }
416
417 fstype_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
418 "fstype allow", NULL);
419 if (fstype_allow_list != NULL) {
420 data->fstype_allow_list = str_list_copy(data, fstype_allow_list);
421 if (data->fstype_allow_list == NULL) {
422 saved_errno = errno;
423 DBG_ERR("str_list_copy failed\n");
424 SMB_VFS_NEXT_DISCONNECT(handle);
425 errno = saved_errno;
426 return -1;
427 }
428 }
429
430 mntdir_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
431 "mntdir deny", NULL);
432 if (mntdir_deny_list != NULL) {
433 data->mntdir_deny_list = str_list_copy(data, mntdir_deny_list);
434 if (data->mntdir_deny_list == NULL) {
435 saved_errno = errno;
436 DBG_ERR("str_list_copy failed\n");
437 SMB_VFS_NEXT_DISCONNECT(handle);
438 errno = saved_errno;
439 return -1;
440 }
441 }
442
443 mntdir_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
444 "mntdir allow", NULL);
445 if (mntdir_allow_list != NULL) {
446 data->mntdir_allow_list = str_list_copy(data, mntdir_allow_list);
447 if (data->mntdir_allow_list == NULL) {
448 saved_errno = errno;
449 DBG_ERR("str_list_copy failed\n");
450 SMB_VFS_NEXT_DISCONNECT(handle);
451 errno = saved_errno;
452 return -1;
453 }
454 }
455
456 data->nolockinode = lp_parm_ulong(SNUM(handle->conn), "fileid",
457 "nolockinode", data->nolockinode);
458
459 SMB_VFS_HANDLE_SET_DATA(handle, data, NULL,
460 struct fileid_handle_data,
461 return -1);
462
463 DBG_DEBUG("connect to service[%s] with algorithm[%s] nolockinode %lli\n",
464 service, algorithm, (long long) data->nolockinode);
465
466 return 0;
467 }
468
469 static void fileid_disconnect(struct vfs_handle_struct *handle)
470 {
471 const struct loadparm_substitution *lp_sub =
472 loadparm_s3_global_substitution();
473
474 DEBUG(10,("fileid_disconnect() connect to service[%s].\n",
475 lp_servicename(talloc_tos(), lp_sub, SNUM(handle->conn))));
476
477 SMB_VFS_NEXT_DISCONNECT(handle);
478 }
479
480 static struct file_id fileid_file_id_create(struct vfs_handle_struct *handle,
481 const SMB_STRUCT_STAT *sbuf)
482 {
483 struct fileid_handle_data *data;
484 struct file_id id;
485 uint64_t devid;
486
487 ZERO_STRUCT(id);
488
489 SMB_VFS_HANDLE_GET_DATA(handle, data,
490 struct fileid_handle_data,
491 return id);
492
493 if ((data->nolockinode != 0) &&
494 (sbuf->st_ex_ino == data->nolockinode)) {
495 devid = fileid_device_mapping_hostname(data, sbuf);
496 id.extid = data->extid_mapping_fn(data, sbuf);
497 } else {
498 devid = data->device_mapping_fn(data, sbuf);
499 }
500
501 id.inode = sbuf->st_ex_ino;
502 id.devid = devid;
503
504 DBG_DEBUG("Returning dev [%jx] inode [%jx] extid [%jx]\n",
505 (uintmax_t)id.devid, (uintmax_t)id.inode, (uintmax_t)id.extid);
506
507 return id;
508 }
509
510 static struct vfs_fn_pointers vfs_fileid_fns = {
511 .connect_fn = fileid_connect,
512 .disconnect_fn = fileid_disconnect,
513 .file_id_create_fn = fileid_file_id_create
514 };
515
516 static_decl_vfs;
517 NTSTATUS vfs_fileid_init(TALLOC_CTX *ctx)
518 {
519 NTSTATUS ret;
520
521 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fileid",
522 &vfs_fileid_fns);
523 if (!NT_STATUS_IS_OK(ret)) {
524 return ret;
525 }
526
527 vfs_fileid_debug_level = debug_add_class("fileid");
528 if (vfs_fileid_debug_level == -1) {
529 vfs_fileid_debug_level = DBGC_VFS;
530 DEBUG(0, ("vfs_fileid: Couldn't register custom debugging class!\n"));
531 } else {
532 DEBUG(10, ("vfs_fileid: Debug class number of 'fileid': %d\n", vfs_fileid_debug_level));
533 }
534
535 return ret;
536 }
Samba GIT mirror