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%lu",
230 hostname, sbuf->st_ex_dev);
231 if (devname == NULL) {
232 DBG_ERR("talloc_asprintf failed\n");
235 devname_len = talloc_array_length(devname) - 1;
236 TALLOC_FREE(devname);
238 id = fileid_uint64_hash((uint8_t *)devname, devname_len);
242 /* a device mapping using a fsname for files and hostname for dirs */
243 static uint64_t fileid_device_mapping_fsname_nodirs(
244 struct fileid_handle_data *data,
245 const SMB_STRUCT_STAT *sbuf)
247 if (S_ISDIR(sbuf->st_ex_mode)) {
248 return fileid_device_mapping_hostname(data, sbuf);
251 return fileid_device_mapping_fsname(data, sbuf);
254 /* device mapping functions using a fsid */
255 static uint64_t fileid_device_mapping_fsid(struct fileid_handle_data *data,
256 const SMB_STRUCT_STAT *sbuf)
258 struct fileid_mount_entry *m;
260 m = fileid_find_mount_entry(data, sbuf->st_ex_dev);
261 if (!m) return sbuf->st_ex_dev;
263 if (m->devid == (uint64_t)-1) {
264 if (sizeof(fsid_t) > sizeof(uint64_t)) {
265 m->devid = fileid_uint64_hash((uint8_t *)&m->fsid,
281 static int fileid_connect(struct vfs_handle_struct *handle,
282 const char *service, const char *user)
284 struct fileid_handle_data *data;
285 const char *algorithm;
286 const char **fstype_deny_list = NULL;
287 const char **fstype_allow_list = NULL;
288 const char **mntdir_deny_list = NULL;
289 const char **mntdir_allow_list = NULL;
291 int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
297 data = talloc_zero(handle->conn, struct fileid_handle_data);
300 SMB_VFS_NEXT_DISCONNECT(handle);
301 DEBUG(0, ("talloc_zero() failed\n"));
307 * "fileid:mapping" is only here as fallback for old setups
308 * "fileid:algorithm" is the option new setups should use
310 algorithm = lp_parm_const_string(SNUM(handle->conn),
313 algorithm = lp_parm_const_string(SNUM(handle->conn),
314 "fileid", "algorithm",
316 if (strcmp("fsname", algorithm) == 0) {
317 data->device_mapping_fn = fileid_device_mapping_fsname;
318 } else if (strcmp("fsname_nodirs", algorithm) == 0) {
319 data->device_mapping_fn = fileid_device_mapping_fsname_nodirs;
320 } else if (strcmp("fsid", algorithm) == 0) {
321 data->device_mapping_fn = fileid_device_mapping_fsid;
322 } else if (strcmp("hostname", algorithm) == 0) {
323 data->device_mapping_fn = fileid_device_mapping_hostname;
325 SMB_VFS_NEXT_DISCONNECT(handle);
326 DEBUG(0,("fileid_connect(): unknown algorithm[%s]\n", algorithm));
330 fstype_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
331 "fstype deny", NULL);
332 if (fstype_deny_list != NULL) {
333 data->fstype_deny_list = str_list_copy(data, fstype_deny_list);
334 if (data->fstype_deny_list == NULL) {
336 DBG_ERR("str_list_copy failed\n");
337 SMB_VFS_NEXT_DISCONNECT(handle);
343 fstype_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
344 "fstype allow", NULL);
345 if (fstype_allow_list != NULL) {
346 data->fstype_allow_list = str_list_copy(data, fstype_allow_list);
347 if (data->fstype_allow_list == NULL) {
349 DBG_ERR("str_list_copy failed\n");
350 SMB_VFS_NEXT_DISCONNECT(handle);
356 mntdir_deny_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
357 "mntdir deny", NULL);
358 if (mntdir_deny_list != NULL) {
359 data->mntdir_deny_list = str_list_copy(data, mntdir_deny_list);
360 if (data->mntdir_deny_list == NULL) {
362 DBG_ERR("str_list_copy failed\n");
363 SMB_VFS_NEXT_DISCONNECT(handle);
369 mntdir_allow_list = lp_parm_string_list(SNUM(handle->conn), "fileid",
370 "mntdir allow", NULL);
371 if (mntdir_allow_list != NULL) {
372 data->mntdir_allow_list = str_list_copy(data, mntdir_allow_list);
373 if (data->mntdir_allow_list == NULL) {
375 DBG_ERR("str_list_copy failed\n");
376 SMB_VFS_NEXT_DISCONNECT(handle);
382 data->nolockinode = lp_parm_ulong(SNUM(handle->conn), "fileid",
385 SMB_VFS_HANDLE_SET_DATA(handle, data, NULL,
386 struct fileid_handle_data,
389 DEBUG(10, ("fileid_connect(): connect to service[%s] with algorithm[%s]\n",
390 service, algorithm));
395 static void fileid_disconnect(struct vfs_handle_struct *handle)
397 DEBUG(10,("fileid_disconnect() connect to service[%s].\n",
398 lp_servicename(talloc_tos(), SNUM(handle->conn))));
400 SMB_VFS_NEXT_DISCONNECT(handle);
403 static struct file_id fileid_file_id_create(struct vfs_handle_struct *handle,
404 const SMB_STRUCT_STAT *sbuf)
406 struct fileid_handle_data *data;
412 SMB_VFS_HANDLE_GET_DATA(handle, data,
413 struct fileid_handle_data,
416 if ((data->nolockinode != 0) && (id.inode == data->nolockinode)) {
417 devid = fileid_device_mapping_hostname(data, sbuf);
419 devid = data->device_mapping_fn(data, sbuf);
422 id.inode = sbuf->st_ex_ino;
425 DBG_DEBUG("Returning dev [%jx] inode [%jx]\n",
426 (uintmax_t)id.devid, (uintmax_t)id.inode);
431 static struct vfs_fn_pointers vfs_fileid_fns = {
432 .connect_fn = fileid_connect,
433 .disconnect_fn = fileid_disconnect,
434 .file_id_create_fn = fileid_file_id_create
438 NTSTATUS vfs_fileid_init(TALLOC_CTX *ctx)
442 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fileid",
444 if (!NT_STATUS_IS_OK(ret)) {
448 vfs_fileid_debug_level = debug_add_class("fileid");
449 if (vfs_fileid_debug_level == -1) {
450 vfs_fileid_debug_level = DBGC_VFS;
451 DEBUG(0, ("vfs_fileid: Couldn't register custom debugging class!\n"));
453 DEBUG(10, ("vfs_fileid: Debug class number of 'fileid': %d\n", vfs_fileid_debug_level));