source: vendor/current/source3/lib/sysquotas.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

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