1 /*
2 * Fake Disk-Free and Quota VFS module. Implements passthrough operation
3 * of all VFS calls, except for "disk free" and "get quota" which
4 * are handled by reading a text file named ".dfq" in the current directory.
5 *
6 * This module is intended for testing purposes.
7 *
8 * Copyright (C) Uri Simchoni, 2016
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "smbd/smbd.h"
26
27 #undef DBGC_CLASS
28 #define DBGC_CLASS DBGC_VFS
29
30 static int dfq_get_quota(struct vfs_handle_struct *handle,
31 const struct smb_filename *smb_fname,
32 enum SMB_QUOTA_TYPE qtype,
33 unid_t id,
34 SMB_DISK_QUOTA *qt);
35
dfq_load_param(int snum,const char * path,const char * section,const char * param,uint64_t def_val)36 static uint64_t dfq_load_param(int snum, const char *path, const char *section,
37 const char *param, uint64_t def_val)
38 {
39 uint64_t ret;
40
41 char *option =
42 talloc_asprintf(talloc_tos(), "%s/%s/%s", section, param, path);
43 if (option == NULL) {
44 return def_val;
45 }
46
47 ret = (uint64_t)lp_parm_ulonglong(snum, "fake_dfq", option,
48 (unsigned long long)def_val);
49
50 TALLOC_FREE(option);
51
52 return ret;
53 }
54
dfq_disk_free(vfs_handle_struct * handle,const struct smb_filename * smb_fname,uint64_t * bsize,uint64_t * dfree,uint64_t * dsize)55 static uint64_t dfq_disk_free(vfs_handle_struct *handle,
56 const struct smb_filename *smb_fname,
57 uint64_t *bsize,
58 uint64_t *dfree,
59 uint64_t *dsize)
60 {
61 uint64_t free_1k;
62 int snum = SNUM(handle->conn);
63 uint64_t dfq_bsize = 0;
64 struct smb_filename *rpath_fname = NULL;
65
66 /* look up the params based on real path to be resilient
67 * to refactoring of path<->realpath
68 */
69 rpath_fname = SMB_VFS_NEXT_REALPATH(handle, talloc_tos(), smb_fname);
70 if (rpath_fname != NULL) {
71 dfq_bsize = dfq_load_param(snum, rpath_fname->base_name,
72 "df", "block size", 0);
73 }
74 if (dfq_bsize == 0) {
75 TALLOC_FREE(rpath_fname);
76 return SMB_VFS_NEXT_DISK_FREE(handle, smb_fname, bsize, dfree,
77 dsize);
78 }
79
80 *bsize = dfq_bsize;
81 *dfree = dfq_load_param(snum, rpath_fname->base_name,
82 "df", "disk free", 0);
83 *dsize = dfq_load_param(snum, rpath_fname->base_name,
84 "df", "disk size", 0);
85
86 if ((*bsize) < 1024) {
87 free_1k = (*dfree) / (1024 / (*bsize));
88 } else {
89 free_1k = ((*bsize) / 1024) * (*dfree);
90 }
91
92 TALLOC_FREE(rpath_fname);
93 return free_1k;
94 }
95
dfq_get_quota(struct vfs_handle_struct * handle,const struct smb_filename * smb_fname,enum SMB_QUOTA_TYPE qtype,unid_t id,SMB_DISK_QUOTA * qt)96 static int dfq_get_quota(struct vfs_handle_struct *handle,
97 const struct smb_filename *smb_fname,
98 enum SMB_QUOTA_TYPE qtype,
99 unid_t id,
100 SMB_DISK_QUOTA *qt)
101 {
102 int rc = 0;
103 int save_errno;
104 char *section = NULL;
105 int snum = SNUM(handle->conn);
106 uint64_t bsize = 0;
107 struct smb_filename *rpath_fname = NULL;
108
109 rpath_fname = SMB_VFS_NEXT_REALPATH(handle, talloc_tos(), smb_fname);
110 if (rpath_fname == NULL) {
111 goto dflt;
112 }
113
114 switch (qtype) {
115 case SMB_USER_QUOTA_TYPE:
116 section = talloc_asprintf(talloc_tos(), "u%llu",
117 (unsigned long long)id.uid);
118 break;
119 case SMB_GROUP_QUOTA_TYPE:
120 section = talloc_asprintf(talloc_tos(), "g%llu",
121 (unsigned long long)id.gid);
122 break;
123 case SMB_USER_FS_QUOTA_TYPE:
124 section = talloc_strdup(talloc_tos(), "udflt");
125 break;
126 case SMB_GROUP_FS_QUOTA_TYPE:
127 section = talloc_strdup(talloc_tos(), "gdflt");
128 break;
129 default:
130 break;
131 }
132
133 if (section == NULL) {
134 goto dflt;
135 }
136
137 bsize = dfq_load_param(snum, rpath_fname->base_name,
138 section, "block size", 4096);
139 if (bsize == 0) {
140 goto dflt;
141 }
142
143 if (dfq_load_param(snum, rpath_fname->base_name,
144 section, "err", 0) != 0) {
145 errno = ENOTSUP;
146 rc = -1;
147 goto out;
148 }
149
150 if (dfq_load_param(snum, rpath_fname->base_name,
151 section, "nosys", 0) != 0) {
152 errno = ENOSYS;
153 rc = -1;
154 goto out;
155 }
156
157 ZERO_STRUCTP(qt);
158
159 qt->bsize = bsize;
160 qt->hardlimit = dfq_load_param(snum, rpath_fname->base_name,
161 section, "hard limit", 0);
162 qt->softlimit = dfq_load_param(snum, rpath_fname->base_name,
163 section, "soft limit", 0);
164 qt->curblocks = dfq_load_param(snum, rpath_fname->base_name,
165 section, "cur blocks", 0);
166 qt->ihardlimit =
167 dfq_load_param(snum, rpath_fname->base_name,
168 section, "inode hard limit", 0);
169 qt->isoftlimit =
170 dfq_load_param(snum, rpath_fname->base_name,
171 section, "inode soft limit", 0);
172 qt->curinodes = dfq_load_param(snum, rpath_fname->base_name,
173 section, "cur inodes", 0);
174 qt->qflags = dfq_load_param(snum, rpath_fname->base_name,
175 section, "qflags", QUOTAS_DENY_DISK);
176
177 goto out;
178
179 dflt:
180 rc = SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, qt);
181
182 out:
183 save_errno = errno;
184 TALLOC_FREE(section);
185 TALLOC_FREE(rpath_fname);
186 errno = save_errno;
187 return rc;
188 }
189
dfq_fake_stat(struct vfs_handle_struct * handle,struct smb_filename * smb_fname,SMB_STRUCT_STAT * sbuf)190 static void dfq_fake_stat(struct vfs_handle_struct *handle,
191 struct smb_filename *smb_fname,
192 SMB_STRUCT_STAT *sbuf)
193 {
194 int snum = SNUM(handle->conn);
195 char *full_path = NULL;
196 char *to_free = NULL;
197 char path[PATH_MAX + 1];
198 int len;
199 gid_t gid;
200
201 len = full_path_tos(handle->conn->cwd_fsp->fsp_name->base_name,
202 smb_fname->base_name,
203 path, sizeof(path),
204 &full_path, &to_free);
205 if (len == -1) {
206 DBG_ERR("Could not allocate memory in full_path_tos.\n");
207 return;
208 }
209
210 gid = dfq_load_param(snum, full_path, "stat", "sgid", 0);
211 if (gid != 0) {
212 sbuf->st_ex_gid = gid;
213 sbuf->st_ex_mode |= S_ISGID;
214 }
215
216 TALLOC_FREE(to_free);
217 }
218
dfq_stat(vfs_handle_struct * handle,struct smb_filename * smb_fname)219 static int dfq_stat(vfs_handle_struct *handle,
220 struct smb_filename *smb_fname)
221 {
222 int ret;
223
224 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
225 if (ret == -1) {
226 return ret;
227 }
228
229 dfq_fake_stat(handle, smb_fname, &smb_fname->st);
230
231 return 0;
232 }
233
dfq_fstat(vfs_handle_struct * handle,files_struct * fsp,SMB_STRUCT_STAT * sbuf)234 static int dfq_fstat(vfs_handle_struct *handle,
235 files_struct *fsp,
236 SMB_STRUCT_STAT *sbuf)
237 {
238 int ret;
239
240 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
241 if (ret == -1) {
242 return ret;
243 }
244
245 dfq_fake_stat(handle, fsp->fsp_name, sbuf);
246
247 return 0;
248 }
249
dfq_lstat(vfs_handle_struct * handle,struct smb_filename * smb_fname)250 static int dfq_lstat(vfs_handle_struct *handle,
251 struct smb_filename *smb_fname)
252 {
253 int ret;
254
255 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
256 if (ret == -1) {
257 return ret;
258 }
259
260 dfq_fake_stat(handle, smb_fname, &smb_fname->st);
261
262 return 0;
263 }
264
265 struct vfs_fn_pointers vfs_fake_dfq_fns = {
266 /* Disk operations */
267
268 .disk_free_fn = dfq_disk_free,
269 .get_quota_fn = dfq_get_quota,
270
271 .stat_fn = dfq_stat,
272 .fstat_fn = dfq_fstat,
273 .lstat_fn = dfq_lstat,
274 };
275
276 static_decl_vfs;
vfs_fake_dfq_init(TALLOC_CTX * ctx)277 NTSTATUS vfs_fake_dfq_init(TALLOC_CTX *ctx)
278 {
279 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_dfq",
280 &vfs_fake_dfq_fns);
281 }
282