source: branches/samba-3.0/source/lib/sysquotas.c@ 108

Last change on this file since 108 was 1, checked in by Paul Smedley, 18 years ago

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