?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
selftest: put the target on the environment
[Samba.git] / source3 / lib / sysquotas.c
blob12c34edaa2c941b1add2ae1e9a0adc47f007d0a0
1 /*
2 Unix SMB/CIFS implementation.
3 System QUOTA function wrappers
4 Copyright (C) Stefan (metze) Metzmacher 2003
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 #include "includes.h"
22
23 #undef DBGC_CLASS
24 #define DBGC_CLASS DBGC_QUOTA
25
26 #ifdef HAVE_SYS_QUOTAS
27
28 #if defined(HAVE_QUOTACTL_4A)
29
30 /*#endif HAVE_QUOTACTL_4A */
31 #elif defined(HAVE_QUOTACTL_4B)
32
33 #error HAVE_QUOTACTL_4B not implemeted
34
35 /*#endif HAVE_QUOTACTL_4B */
36 #elif defined(HAVE_QUOTACTL_3)
37
38 #error HAVE_QUOTACTL_3 not implemented
39
40 /* #endif HAVE_QUOTACTL_3 */
41 #else /* NO_QUOTACTL_USED */
42
43 #endif /* NO_QUOTACTL_USED */
44
45 #ifdef HAVE_MNTENT
46 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
47 {
48 int ret = -1;
49 SMB_STRUCT_STAT S;
50 FILE *fp;
51 struct mntent *mnt;
52 SMB_DEV_T devno;
53
54 /* find the block device file */
55
56 if (!path||!mntpath||!bdev||!fs)
57 smb_panic("sys_path_to_bdev: called with NULL pointer");
58
59 (*mntpath) = NULL;
60 (*bdev) = NULL;
61 (*fs) = NULL;
62
63 if ( sys_stat(path, &S, false) == -1 )
64 return (-1);
65
66 devno = S.st_ex_dev ;
67
68 fp = setmntent(MOUNTED,"r");
69 if (fp == NULL) {
70 return -1;
71 }
72
73 while ((mnt = getmntent(fp))) {
74 if ( sys_stat(mnt->mnt_dir, &S, false) == -1 )
75 continue ;
76
77 if (S.st_ex_dev == devno) {
78 (*mntpath) = SMB_STRDUP(mnt->mnt_dir);
79 (*bdev) = SMB_STRDUP(mnt->mnt_fsname);
80 (*fs) = SMB_STRDUP(mnt->mnt_type);
81 if ((*mntpath)&&(*bdev)&&(*fs)) {
82 ret = 0;
83 } else {
84 SAFE_FREE(*mntpath);
85 SAFE_FREE(*bdev);
86 SAFE_FREE(*fs);
87 ret = -1;
88 }
89
90 break;
91 }
92 }
93
94 endmntent(fp) ;
95
96 return ret;
97 }
98 /* #endif HAVE_MNTENT */
99 #elif defined(HAVE_DEVNM)
100
101 /* we have this on HPUX, ... */
102 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
103 {
104 int ret = -1;
105 char dev_disk[256];
106 SMB_STRUCT_STAT S;
107
108 if (!path||!mntpath||!bdev||!fs)
109 smb_panic("sys_path_to_bdev: called with NULL pointer");
110
111 (*mntpath) = NULL;
112 (*bdev) = NULL;
113 (*fs) = NULL;
114
115 /* find the block device file */
116
117 if ((ret=sys_stat(path, &S, false))!=0) {
118 return ret;
119 }
120
121 if ((ret=devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 1))!=0) {
122 return ret;
123 }
124
125 /* we should get the mntpath right...
126 * but I don't know how
127 * --metze
128 */
129 (*mntpath) = SMB_STRDUP(path);
130 (*bdev) = SMB_STRDUP(dev_disk);
131 if ((*mntpath)&&(*bdev)) {
132 ret = 0;
133 } else {
134 SAFE_FREE(*mntpath);
135 SAFE_FREE(*bdev);
136 ret = -1;
137 }
138
139
140 return ret;
141 }
142
143 /* #endif HAVE_DEVNM */
144 #else
145 /* we should fake this up...*/
146 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
147 {
148 int ret = -1;
149
150 if (!path||!mntpath||!bdev||!fs)
151 smb_panic("sys_path_to_bdev: called with NULL pointer");
152
153 (*mntpath) = NULL;
154 (*bdev) = NULL;
155 (*fs) = NULL;
156
157 (*mntpath) = SMB_STRDUP(path);
158 if (*mntpath) {
159 ret = 0;
160 } else {
161 SAFE_FREE(*mntpath);
162 ret = -1;
163 }
164
165 return ret;
166 }
167 #endif
168
169 /*********************************************************************
170 Now the list of all filesystem specific quota systems we have found
171 **********************************************************************/
172 static struct {
173 const char *name;
174 int (*get_quota)(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp);
175 int (*set_quota)(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp);
176 } sys_quota_backends[] = {
177 #ifdef HAVE_XFS_QUOTAS
178 {"xfs", sys_get_xfs_quota, sys_set_xfs_quota},
179 #endif /* HAVE_XFS_QUOTAS */
180 #ifdef HAVE_NFS_QUOTAS
181 {"nfs", sys_get_nfs_quota, sys_set_nfs_quota},
182 #endif /* HAVE_NFS_QUOTAS */
183 {NULL, NULL, NULL}
184 };
185
186 static int command_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
187 {
188 const char *get_quota_command;
189 char **lines = NULL;
190
191 get_quota_command = lp_get_quota_command();
192 if (get_quota_command && *get_quota_command) {
193 const char *p;
194 char *p2;
195 char *syscmd = NULL;
196 int _id = -1;
197
198 switch(qtype) {
199 case SMB_USER_QUOTA_TYPE:
200 case SMB_USER_FS_QUOTA_TYPE:
201 _id = id.uid;
202 break;
203 case SMB_GROUP_QUOTA_TYPE:
204 case SMB_GROUP_FS_QUOTA_TYPE:
205 _id = id.gid;
206 break;
207 default:
208 DEBUG(0,("invalid quota type.\n"));
209 return -1;
210 }
211
212 if (asprintf(&syscmd, "%s \"%s\" %d %d",
213 get_quota_command, path, qtype, _id) < 0) {
214 return -1;
215 }
216
217 DEBUG (3, ("get_quota: Running command %s\n", syscmd));
218
219 lines = file_lines_pload(syscmd, NULL);
220 SAFE_FREE(syscmd);
221
222 if (lines) {
223 char *line = lines[0];
224
225 DEBUG (3, ("Read output from get_quota, \"%s\"\n", line));
226
227 /* we need to deal with long long unsigned here, if supported */
228
229 dp->qflags = (enum SMB_QUOTA_TYPE)strtoul(line, &p2, 10);
230 p = p2;
231 while (p && *p && isspace(*p)) {
232 p++;
233 }
234
235 if (p && *p) {
236 dp->curblocks = STR_TO_SMB_BIG_UINT(p, &p);
237 } else {
238 goto invalid_param;
239 }
240
241 while (p && *p && isspace(*p)) {
242 p++;
243 }
244
245 if (p && *p) {
246 dp->softlimit = STR_TO_SMB_BIG_UINT(p, &p);
247 } else {
248 goto invalid_param;
249 }
250
251 while (p && *p && isspace(*p)) {
252 p++;
253 }
254
255 if (p && *p) {
256 dp->hardlimit = STR_TO_SMB_BIG_UINT(p, &p);
257 } else {
258 goto invalid_param;
259 }
260
261 while (p && *p && isspace(*p)) {
262 p++;
263 }
264
265 if (p && *p) {
266 dp->curinodes = STR_TO_SMB_BIG_UINT(p, &p);
267 } else {
268 goto invalid_param;
269 }
270
271 while (p && *p && isspace(*p)) {
272 p++;
273 }
274
275 if (p && *p) {
276 dp->isoftlimit = STR_TO_SMB_BIG_UINT(p, &p);
277 } else {
278 goto invalid_param;
279 }
280
281 while (p && *p && isspace(*p)) {
282 p++;
283 }
284
285 if (p && *p) {
286 dp->ihardlimit = STR_TO_SMB_BIG_UINT(p, &p);
287 } else {
288 goto invalid_param;
289 }
290
291 while (p && *p && isspace(*p)) {
292 p++;
293 }
294
295 if (p && *p) {
296 dp->bsize = STR_TO_SMB_BIG_UINT(p, NULL);
297 } else {
298 dp->bsize = 1024;
299 }
300
301 TALLOC_FREE(lines);
302 lines = NULL;
303
304 DEBUG (3, ("Parsed output of get_quota, ...\n"));
305
306 DEBUGADD (5,(
307 "qflags:%u curblocks:%llu softlimit:%llu hardlimit:%llu\n"
308 "curinodes:%llu isoftlimit:%llu ihardlimit:%llu bsize:%llu\n",
309 dp->qflags,(long long unsigned)dp->curblocks,
310 (long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
311 (long long unsigned)dp->curinodes,
312 (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
313 (long long unsigned)dp->bsize));
314 return 0;
315 }
316
317 DEBUG (0, ("get_quota_command failed!\n"));
318 return -1;
319 }
320
321 errno = ENOSYS;
322 return -1;
323
324 invalid_param:
325
326 TALLOC_FREE(lines);
327 DEBUG(0,("The output of get_quota_command is invalid!\n"));
328 return -1;
329 }
330
331 static int command_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
332 {
333 const char *set_quota_command;
334
335 set_quota_command = lp_set_quota_command();
336 if (set_quota_command && *set_quota_command) {
337 char **lines = NULL;
338 char *syscmd = NULL;
339 int _id = -1;
340
341 switch(qtype) {
342 case SMB_USER_QUOTA_TYPE:
343 case SMB_USER_FS_QUOTA_TYPE:
344 _id = id.uid;
345 break;
346 case SMB_GROUP_QUOTA_TYPE:
347 case SMB_GROUP_FS_QUOTA_TYPE:
348 _id = id.gid;
349 break;
350 default:
351 return -1;
352 }
353
354 if (asprintf(&syscmd,
355 "%s \"%s\" %d %d "
356 "%u %llu %llu "
357 "%llu %llu %llu ",
358 set_quota_command, path, qtype, _id, dp->qflags,
359 (long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
360 (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
361 (long long unsigned)dp->bsize) < 0) {
362 return -1;
363 }
364
365 DEBUG (3, ("get_quota: Running command %s\n", syscmd));
366
367 lines = file_lines_pload(syscmd, NULL);
368 SAFE_FREE(syscmd);
369 if (lines) {
370 char *line = lines[0];
371
372 DEBUG (3, ("Read output from set_quota, \"%s\"\n", line));
373
374 TALLOC_FREE(lines);
375
376 return 0;
377 }
378 DEBUG (0, ("set_quota_command failed!\n"));
379 return -1;
380 }
381
382 errno = ENOSYS;
383 return -1;
384 }
385
386 int sys_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
387 {
388 int ret = -1;
389 int i;
390 bool ready = False;
391 char *mntpath = NULL;
392 char *bdev = NULL;
393 char *fs = NULL;
394
395 if (!path||!dp)
396 smb_panic("sys_get_quota: called with NULL pointer");
397
398 if (command_get_quota(path, qtype, id, dp)==0) {
399 return 0;
400 } else if (errno != ENOSYS) {
401 return -1;
402 }
403
404 if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
405 DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
406 return ret;
407 }
408
409 errno = 0;
410 DEBUG(10,("sys_get_quota() uid(%u, %u)\n", (unsigned)getuid(), (unsigned)geteuid()));
411
412 for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].get_quota);i++) {
413 if (strcmp(fs,sys_quota_backends[i].name)==0) {
414 ret = sys_quota_backends[i].get_quota(mntpath, bdev, qtype, id, dp);
415 if (ret!=0) {
416 DEBUG(3,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
417 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
418 } else {
419 DEBUG(10,("sys_get_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
420 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
421 }
422 ready = True;
423 break;
424 }
425 }
426
427 if (!ready) {
428 /* use the default vfs quota functions */
429 ret=sys_get_vfs_quota(mntpath, bdev, qtype, id, dp);
430 if (ret!=0) {
431 DEBUG(3,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s\n",
432 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
433 } else {
434 DEBUG(10,("sys_get_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
435 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
436 }
437 }
438
439 SAFE_FREE(mntpath);
440 SAFE_FREE(bdev);
441 SAFE_FREE(fs);
442
443 if ((ret!=0)&& (errno == EDQUOT)) {
444 DEBUG(10,("sys_get_quota() warning over quota!\n"));
445 return 0;
446 }
447
448 return ret;
449 }
450
451 int sys_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
452 {
453 int ret = -1;
454 int i;
455 bool ready = False;
456 char *mntpath = NULL;
457 char *bdev = NULL;
458 char *fs = NULL;
459
460 /* find the block device file */
461
462 if (!path||!dp)
463 smb_panic("get_smb_quota: called with NULL pointer");
464
465 if (command_set_quota(path, qtype, id, dp)==0) {
466 return 0;
467 } else if (errno != ENOSYS) {
468 return -1;
469 }
470
471 if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
472 DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
473 return ret;
474 }
475
476 errno = 0;
477 DEBUG(10,("sys_set_quota() uid(%u, %u)\n", (unsigned)getuid(), (unsigned)geteuid()));
478
479 for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].set_quota);i++) {
480 if (strcmp(fs,sys_quota_backends[i].name)==0) {
481 ret = sys_quota_backends[i].set_quota(mntpath, bdev, qtype, id, dp);
482 if (ret!=0) {
483 DEBUG(3,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
484 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
485 } else {
486 DEBUG(10,("sys_set_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
487 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
488 }
489 ready = True;
490 break;
491 }
492 }
493
494 if (!ready) {
495 /* use the default vfs quota functions */
496 ret=sys_set_vfs_quota(mntpath, bdev, qtype, id, dp);
497 if (ret!=0) {
498 DEBUG(3,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
499 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
500 } else {
501 DEBUG(10,("sys_set_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
502 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
503 }
504 }
505
506 SAFE_FREE(mntpath);
507 SAFE_FREE(bdev);
508 SAFE_FREE(fs);
509
510 if ((ret!=0)&& (errno == EDQUOT)) {
511 DEBUG(10,("sys_set_quota() warning over quota!\n"));
512 return 0;
513 }
514
515 return ret;
516 }
517
518 #else /* HAVE_SYS_QUOTAS */
519 void dummy_sysquotas_c(void);
520
521 void dummy_sysquotas_c(void)
522 {
523 return;
524 }
525 #endif /* HAVE_SYS_QUOTAS */
526
Samba GIT mirror