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.
6 * Copyright (C) 2007, Stefan Metzmacher
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.
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.
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/>.
23 #include "smbd/smbd.h"
24 #include "system/filesys.h"
26 static int vfs_fileid_debug_level = DBGC_VFS;
29 #define DBGC_CLASS vfs_fileid_debug_level
31 struct fileid_mount_entry {
33 const char *mnt_fsname;
38 struct fileid_handle_data {
39 uint64_t (*device_mapping_fn)(struct fileid_handle_data *data,
40 const SMB_STRUCT_STAT *sbuf);
41 char **fstype_deny_list;
42 char **fstype_allow_list;
43 char **mntdir_deny_list;
44 char **mntdir_allow_list;
45 unsigned num_mount_entries;
46 struct fileid_mount_entry *mount_entries;
50 /* check if a mount entry is allowed based on fstype and mount directory */
51 static bool fileid_mount_entry_allowed(struct fileid_handle_data *data,
55 char **fstype_deny = data->fstype_deny_list;
56 char **fstype_allow = data->fstype_allow_list;
57 char **mntdir_deny = data->mntdir_deny_list;
58 char **mntdir_allow = data->mntdir_allow_list;
60 if (fstype_deny != NULL) {
61 for (i = 0; fstype_deny[i] != NULL; i++) {
62 if (strcmp(m->mnt_type, fstype_deny[i]) == 0) {
67 if (fstype_allow != NULL) {
68 for (i = 0; fstype_allow[i] != NULL; i++) {
69 if (strcmp(m->mnt_type, fstype_allow[i]) == 0) {
73 if (fstype_allow[i] == NULL) {
77 if (mntdir_deny != NULL) {
78 for (i=0; mntdir_deny[i] != NULL; i++) {
79 if (strcmp(m->mnt_dir, mntdir_deny[i]) == 0) {
84 if (mntdir_allow != NULL) {
85 for (i=0; mntdir_allow[i] != NULL; i++) {
86 if (strcmp(m->mnt_dir, mntdir_allow[i]) == 0) {
90 if (mntdir_allow[i] == NULL) {
98 /* load all the mount entries from the mtab */
99 static void fileid_load_mount_entries(struct fileid_handle_data *data)
104 data->num_mount_entries = 0;
105 TALLOC_FREE(data->mount_entries);
107 f = setmntent("/etc/mtab", "r");
110 while ((m = getmntent(f))) {
113 struct fileid_mount_entry *cur;
116 allowed = fileid_mount_entry_allowed(data, m);
118 DBG_DEBUG("skipping mount entry %s\n", m->mnt_dir);
121 if (stat(m->mnt_dir, &st) != 0) continue;
122 if (statfs(m->mnt_dir, &sfs) != 0) continue;
124 if (strncmp(m->mnt_fsname, "/dev/", 5) == 0) {
128 data->mount_entries = talloc_realloc(data,
130 struct fileid_mount_entry,
131 data->num_mount_entries+1);
132 if (data->mount_entries == NULL) {
136 cur = &data->mount_entries[data->num_mount_entries];
137 cur->device = st.st_dev;
138 cur->mnt_fsname = talloc_strdup(data->mount_entries,
140 if (!cur->mnt_fsname) goto nomem;
141 cur->fsid = sfs.f_fsid;
142 cur->devid = (uint64_t)-1;
144 data->num_mount_entries++;
152 data->num_mount_entries = 0;
153 TALLOC_FREE(data->mount_entries);
158 /* find a mount entry given a dev_t */
159 static struct fileid_mount_entry *fileid_find_mount_entry(struct fileid_handle_data *data,
164 if (data->num_mount_entries == 0) {
165 fileid_load_mount_entries(data);
167 for (i=0;i<data->num_mount_entries;i++) {
168 if (data->mount_entries[i].device == dev) {
169 return &data->mount_entries[i];
172 /* 2nd pass after reloading */
173 fileid_load_mount_entries(data);
174 for (i=0;i<data->num_mount_entries;i++) {
175 if (data->mount_entries[i].device == dev) {
176 return &data->mount_entries[i];
183 /* a 64 bit hash, based on the one in tdb */
184 static uint64_t fileid_uint64_hash(const uint8_t *s, size_t len)
186 uint64_t value; /* Used to compute the hash value. */
187 uint32_t i; /* Used to cycle through random values. */
189 /* Set the initial value from the key size. */
190 for (value = 0x238F13AFLL * len, i=0; i < len; i++)
191 value = (value + (((uint64_t)s[i]) << (i*5 % 24)));
193 return (1103515243LL * value + 12345LL);
196 /* a device mapping using a fsname */
197 static uint64_t fileid_device_mapping_fsname(struct fileid_handle_data *data,
198 const SMB_STRUCT_STAT *sbuf)
200 struct fileid_mount_entry *m;
202 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
203 if (!m) return sbuf->st_ex_dev;
205 if (m->devid == (uint64_t)-1) {
206 m->devid = fileid_uint64_hash((const uint8_t *)m->mnt_fsname,
207 strlen(m->mnt_fsname));
213 /* a device mapping using a hostname */
214 static uint64_t fileid_device_mapping_hostname(struct fileid_handle_data *data,
215 const SMB_STRUCT_STAT *sbuf)
217 char hostname[HOST_NAME_MAX+1];
218 char *devname = NULL;
223 rc = gethostname(hostname, HOST_NAME_MAX+1);
225 DBG_ERR("gethostname failed\n");
229 devname = talloc_asprintf(talloc_tos(), "%s%ju",
230 hostname, (uintmax_t)sbuf->st_ex_dev);
231 if (devname == NULL) {
232 DBG_ERR("talloc_asprintf failed\n");
235 devname_len = talloc_array_length(devname) - 1;
237 id = fileid_uint64_hash((uint8_t *)devname, devname_len);
239 TALLOC_FREE(devname);
244 /* a device mapping using a fsname for files and hostname for dirs */
245 static uint64_t fileid_device_mapping_fsname_nodirs(
246 struct fileid_handle_data *data,
247 const SMB_STRUCT_STAT *sbuf)
249 if (S_ISDIR(sbuf->st_ex_mode)) {
250 return fileid_device_mapping_hostname(data, sbuf);
253 return fileid_device_mapping_fsname(data, sbuf);
256 /* device mapping functions using a fsid */
257 static uint64_t fileid_device_mapping_fsid(struct fileid_handle_data *data,
258 const SMB_STRUCT_STAT *sbuf)
260 struct fileid_mount_entry *m;
262 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
263 if (!m) return sbuf->st_ex_dev;
265 if (m->devid == (uint64_t)-1) {
266 if (sizeof(fsid_t) > sizeof(uint64_t)) {
267 m->devid = fileid_uint64_hash((uint8_t *)&m->fsid,
283 static int get_connectpath_ino(struct vfs_handle_struct *handle,
286 struct smb_filename *fname = NULL;
289 fname = synthetic_smb_fname(talloc_tos(),
290 handle->conn->connectpath,
295 DBG_ERR("synthetic_smb_fname failed\n");
299 ret = SMB_VFS_NEXT_STAT(handle, fname);
302 DBG_ERR("stat failed for %s with %s\n",
303 handle->conn->connectpath, strerror(errno));
310 static int fileid_connect(struct vfs_handle_struct *handle,
311 const char *service, const char *user)
313 struct fileid_handle_data *data;
314 const char *algorithm;
315 const char **fstype_deny_list = NULL;
316 const char **fstype_allow_list = NULL;
317 const char **mntdir_deny_list = NULL;
318 const char **mntdir_allow_list = NULL;
320 int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
326 data = talloc_zero(handle->conn, struct fileid_handle_data);
329 SMB_VFS_NEXT_DISCONNECT(handle);
330 DEBUG(0, ("talloc_zero() failed\n"));
335 data->nolockinode = 0;
338 * "fileid:mapping" is only here as fallback for old setups
339 * "fileid:algorithm" is the option new setups should use
341 algorithm = lp_parm_const_string(SNUM(handle->conn),
344 algorithm = lp_parm_const_string(SNUM(handle->conn),
345 "fileid", "algorithm",
347 if (strcmp("fsname", algorithm) == 0) {
348 data->device_mapping_fn = fileid_device_mapping_fsname;
349 } else if (strcmp("fsname_nodirs", algorithm) == 0) {
350 data->device_mapping_fn = fileid_device_mapping_fsname_nodirs;
351 } else if (strcmp("fsid", algorithm) == 0) {
352 data->device_mapping_fn = fileid_device_mapping_fsid;
353 } else if (strcmp("hostname", algorithm) == 0) {
354 data->device_mapping_fn = fileid_device_mapping_hostname;
355 } else if (strcmp("fsname_norootdir", algorithm) == 0) {
356 data->device_mapping_fn = fileid_device_mapping_fsname;
358 ret = get_connectpath_ino(handle, &data->nolockinode);
361 SMB_VFS_NEXT_DISCONNECT(handle);
366 SMB_VFS_NEXT_DISCONNECT(handle);
367 DEBUG(0,("fileid_connect(): unknown algorithm[%s]\n", algorithm));
371 fstype_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
372 "fstype deny", NULL);
373 if (fstype_deny_list != NULL) {
374 data->fstype_deny_list = str_list_copy(data, fstype_deny_list);
375 if (data->fstype_deny_list == NULL) {
377 DBG_ERR("str_list_copy failed\n");
378 SMB_VFS_NEXT_DISCONNECT(handle);
384 fstype_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
385 "fstype allow", NULL);
386 if (fstype_allow_list != NULL) {
387 data->fstype_allow_list = str_list_copy(data, fstype_allow_list);
388 if (data->fstype_allow_list == NULL) {
390 DBG_ERR("str_list_copy failed\n");
391 SMB_VFS_NEXT_DISCONNECT(handle);
397 mntdir_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
398 "mntdir deny", NULL);
399 if (mntdir_deny_list != NULL) {
400 data->mntdir_deny_list = str_list_copy(data, mntdir_deny_list);
401 if (data->mntdir_deny_list == NULL) {
403 DBG_ERR("str_list_copy failed\n");
404 SMB_VFS_NEXT_DISCONNECT(handle);
410 mntdir_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
411 "mntdir allow", NULL);
412 if (mntdir_allow_list != NULL) {
413 data->mntdir_allow_list = str_list_copy(data, mntdir_allow_list);
414 if (data->mntdir_allow_list == NULL) {
416 DBG_ERR("str_list_copy failed\n");
417 SMB_VFS_NEXT_DISCONNECT(handle);
423 data->nolockinode = lp_parm_ulong(SNUM(handle->conn), "fileid",
424 "nolockinode", data->nolockinode);
426 SMB_VFS_HANDLE_SET_DATA(handle, data, NULL,
427 struct fileid_handle_data,
430 DBG_DEBUG("connect to service[%s] with algorithm[%s] nolockinode %lli\n",
431 service, algorithm, (long long) data->nolockinode);
436 static void fileid_disconnect(struct vfs_handle_struct *handle)
438 DEBUG(10,("fileid_disconnect() connect to service[%s].\n",
439 lp_servicename(talloc_tos(), SNUM(handle->conn))));
441 SMB_VFS_NEXT_DISCONNECT(handle);
444 static struct file_id fileid_file_id_create(struct vfs_handle_struct *handle,
445 const SMB_STRUCT_STAT *sbuf)
447 struct fileid_handle_data *data;
453 SMB_VFS_HANDLE_GET_DATA(handle, data,
454 struct fileid_handle_data,
457 if ((data->nolockinode != 0) && (id.inode == data->nolockinode)) {
458 devid = fileid_device_mapping_hostname(data, sbuf);
460 devid = data->device_mapping_fn(data, sbuf);
463 id.inode = sbuf->st_ex_ino;
466 DBG_DEBUG("Returning dev [%jx] inode [%jx]\n",
467 (uintmax_t)id.devid, (uintmax_t)id.inode);
472 static struct vfs_fn_pointers vfs_fileid_fns = {
473 .connect_fn = fileid_connect,
474 .disconnect_fn = fileid_disconnect,
475 .file_id_create_fn = fileid_file_id_create
479 NTSTATUS vfs_fileid_init(TALLOC_CTX *ctx)
483 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fileid",
485 if (!NT_STATUS_IS_OK(ret)) {
489 vfs_fileid_debug_level = debug_add_class("fileid");
490 if (vfs_fileid_debug_level == -1) {
491 vfs_fileid_debug_level = DBGC_VFS;
492 DEBUG(0, ("vfs_fileid: Couldn't register custom debugging class!\n"));
494 DEBUG(10, ("vfs_fileid: Debug class number of 'fileid': %d\n", vfs_fileid_debug_level));