2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
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.
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.
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/>.
22 * This is one of the most system dependent parts of Samba, and its
23 * done a litle differently. Each system has its own way of doing
28 #include "smbd/smbd.h"
29 #include "system/filesys.h"
32 #define DBGC_CLASS DBGC_QUOTA
34 #ifndef HAVE_SYS_QUOTAS
36 /* just a quick hack because sysquotas.h is included before linux/quota.h */
37 #ifdef QUOTABLOCK_SIZE
38 #undef QUOTABLOCK_SIZE
43 #if defined(VXFS_QUOTA)
46 * In addition to their native filesystems, some systems have Veritas VxFS.
47 * Declare here, define at end: reduces likely "include" interaction problems.
48 * David Lee <T.D.Lee@durham.ac.uk>
50 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize);
52 #endif /* VXFS_QUOTA */
55 #if defined(SUNOS5) || defined(SUNOS4)
58 #include <sys/param.h>
60 #include <sys/fs/ufs_quota.h>
61 #include <sys/mnttab.h>
62 #include <sys/mntent.h>
63 #else /* defined(SUNOS4) */
64 #include <ufs/quota.h>
70 /****************************************************************************
71 Allows querying of remote hosts for quotas on NFS mounted shares.
72 Supports normal NFS and AMD mounts.
73 Alan Romeril <a.romeril@ic.ac.uk> July 2K.
74 ****************************************************************************/
77 #include <rpc/types.h>
78 #include <rpcsvc/rquota.h>
79 #include <rpc/nettype.h>
82 static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
86 if (!xdr_int(xdrsp, "astat)) {
87 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
90 gqr->status = quotastat;
92 if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
93 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
96 if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
97 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
100 if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
101 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
104 if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
105 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
108 if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
109 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
115 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
117 if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
119 if (!xdr_int(xdrsp, &args->gqa_uid))
124 /* Restricted to SUNOS5 for the moment, I haven`t access to others to test. */
125 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
127 uid_t uid = euser_id;
129 char *mnttype = nfspath;
131 struct getquota_rslt gqr;
132 struct getquota_args args;
133 char *cutstr, *pathname, *host, *testpath;
135 static struct timeval timeout = {2,0};
136 enum clnt_stat clnt_stat;
139 *bsize = *dfree = *dsize = (uint64_t)0;
141 len=strcspn(mnttype, ":");
142 pathname=strstr(mnttype, ":");
143 cutstr = (char *) SMB_MALLOC(len+1);
147 memset(cutstr, '\0', len+1);
148 host = strncat(cutstr,mnttype, sizeof(char) * len );
149 DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
150 DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
151 testpath=strchr_m(mnttype, ':');
152 args.gqa_pathp = testpath+1;
155 DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
157 if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
162 clnt->cl_auth = authunix_create_default();
163 DEBUG(9,("nfs_quotas: auth_success\n"));
165 clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, my_xdr_getquota_args, (caddr_t)&args, my_xdr_getquota_rslt, (caddr_t)&gqr, timeout);
167 if (clnt_stat != RPC_SUCCESS) {
168 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
174 * gqr.status returns 1 if quotas exist, 2 if there is
175 * no quota set, and 3 if no permission to get the quota.
176 * If 3, return something sensible.
179 switch (gqr.status) {
181 DEBUG(9,("nfs_quotas: Good quota data\n"));
182 D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
183 D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
184 D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
189 D.dqb_bsoftlimit = 1;
191 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", gqr.status));
195 DEBUG(9, ("nfs_quotas: Unknown Remote Quota Status \"%i\"\n",
201 DEBUG(10,("nfs_quotas: Let`s look at D a bit closer... status \"%i\" bsize \"%i\" active? \"%i\" bhard \"%i\" bsoft \"%i\" curb \"%i\" \n",
203 gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
204 gqr.getquota_rslt_u.gqr_rquota.rq_active,
205 gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
206 gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
207 gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
209 *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
210 *dsize = D.dqb_bsoftlimit;
212 if (D.dqb_curblocks > D.dqb_bsoftlimit) {
214 *dsize = D.dqb_curblocks;
216 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
222 auth_destroy(clnt->cl_auth);
226 DEBUG(5,("nfs_quotas: For path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
229 DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
234 /****************************************************************************
235 try to get the disk space from disk quotas (SunOS & Solaris2 version)
236 Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
237 ****************************************************************************/
239 bool disk_quotas(const char *path,
248 struct quotctl command;
256 SMB_STRUCT_STAT sbuf;
260 euser_id = geteuid();
262 if (sys_stat(path, &sbuf, false) == -1) {
266 devno = sbuf.st_ex_dev ;
267 DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
268 path, (unsigned int)devno));
270 if ((fd = fopen(MNTTAB, "r")) == NULL) {
274 while (getmntent(fd, &mnt) == 0) {
275 if (sys_stat(mnt.mnt_mountp, &sbuf, false) == -1) {
279 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
280 mnt.mnt_mountp, (unsigned int)devno));
282 /* quotas are only on vxfs, UFS or NFS */
283 if ((sbuf.st_ex_dev == devno) && (
284 strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
285 strcmp( mnt.mnt_fstype, "nfs" ) == 0 ||
286 strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
288 name = talloc_asprintf(talloc_tos(),
297 if ((fd = setmntent(MOUNTED, "r")) == NULL) {
301 while ((mnt = getmntent(fd)) != NULL) {
302 if (sys_stat(mnt->mnt_dir, &sbuf, false) == -1) {
305 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
307 (unsigned int)sbuf.st_ex_dev));
308 if (sbuf.st_ex_dev == devno) {
310 name = talloc_strdup(talloc_tos(),
328 if (strcmp(mnt.mnt_fstype, "nfs") == 0) {
330 DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n",
332 retval = nfs_quotas(mnt.mnt_special,
333 euser_id, bsize, dfree, dsize);
338 DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
339 if((file=open(name, O_RDONLY,0))<0) {
343 command.op = Q_GETQUOTA;
344 command.uid = euser_id;
345 command.addr = (caddr_t) &D;
346 ret = ioctl(file, Q_QUOTACTL, &command);
349 DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
350 ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
356 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n",
359 #if defined(SUNOS5) && defined(VXFS_QUOTA)
360 /* If normal quotactl() fails, try vxfs private calls */
361 set_effective_uid(euser_id);
362 DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
363 if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
365 retval = disk_quotas_vxfs(name, path,
366 bsize, dfree, dsize);
374 /* If softlimit is zero, set it equal to hardlimit.
377 if (D.dqb_bsoftlimit==0) {
378 D.dqb_bsoftlimit = D.dqb_bhardlimit;
381 /* Use softlimit to determine disk space. A user exceeding the quota
382 * is told that there's no space left. Writes might actually work for
383 * a bit if the hardlimit is set higher than softlimit. Effectively
384 * the disk becomes made of rubber latex and begins to expand to
385 * accommodate the user :-)
388 if (D.dqb_bsoftlimit==0)
391 *dsize = D.dqb_bsoftlimit;
393 if (D.dqb_curblocks > D.dqb_bsoftlimit) {
395 *dsize = D.dqb_curblocks;
397 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
400 DEBUG(5,("disk_quotas for path \"%s\" returning "
401 "bsize %.0f, dfree %.0f, dsize %.0f\n",
402 path,(double)*bsize,(double)*dfree,(double)*dsize));
411 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
412 #include <jfs/quota.h>
413 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
414 #define dqb_curfiles dqb_curinodes
415 #define dqb_fhardlimit dqb_ihardlimit
416 #define dqb_fsoftlimit dqb_isoftlimit
417 #ifdef _AIXVERSION_530
418 #include <sys/statfs.h>
419 #include <sys/vmount.h>
422 #include <sys/quota.h>
427 /****************************************************************************
428 try to get the disk space from disk quotas - default version
429 ****************************************************************************/
431 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
440 /* find the block device file */
442 if ((sys_stat(path, &S, false)<0)
443 || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 0)<0))
446 #endif /* !defined(AIX) */
448 euser_id = geteuid();
451 /* AIX has both USER and GROUP quotas:
452 Get the USER quota (ohnielse@fysik.dtu.dk) */
453 #ifdef _AIXVERSION_530
455 struct statfs statbuf;
456 quota64_t user_quota;
457 if (statfs(path,&statbuf) != 0)
459 if(statbuf.f_vfstype == MNT_J2)
461 /* For some reason we need to be root for jfs2 */
463 r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
465 /* Copy results to old struct to let the following code work as before */
466 D.dqb_curblocks = user_quota.bused;
467 D.dqb_bsoftlimit = user_quota.bsoft;
468 D.dqb_bhardlimit = user_quota.bhard;
469 D.dqb_curfiles = user_quota.iused;
470 D.dqb_fsoftlimit = user_quota.isoft;
471 D.dqb_fhardlimit = user_quota.ihard;
473 else if(statbuf.f_vfstype == MNT_JFS)
477 if (set_re_uid() != 0)
479 r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
481 #ifdef _AIXVERSION_530
484 r = 1; /* Fail for other FS-types */
488 r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
491 /* Use softlimit to determine disk space, except when it has been exceeded */
499 *dsize =D.dqb_curblocks;
505 /* If softlimit is zero, set it equal to hardlimit.
508 if (D.dqb_bsoftlimit==0)
509 D.dqb_bsoftlimit = D.dqb_bhardlimit;
511 if (D.dqb_bsoftlimit==0)
513 /* Use softlimit to determine disk space, except when it has been exceeded */
514 if ((D.dqb_curblocks>D.dqb_bsoftlimit)
515 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
518 *dsize = D.dqb_curblocks;
521 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
522 *dsize = D.dqb_bsoftlimit;
529 #if defined(VXFS_QUOTA)
531 /****************************************************************************
532 Try to get the disk space from Veritas disk quotas.
533 David Lee <T.D.Lee@durham.ac.uk> August 1999.
535 Background assumptions:
536 Potentially under many Operating Systems. Initially Solaris 2.
538 My guess is that Veritas is largely, though not entirely,
539 independent of OS. So I have separated it out.
541 There may be some details. For example, OS-specific "include" files.
543 It is understood that HPUX 10 somehow gets Veritas quotas without
544 any special effort; if so, this routine need not be compiled in.
545 Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
548 It is understood that Veritas do not publicly support this ioctl interface.
549 Rather their preference would be for the user (us) to call the native
550 OS and then for the OS itself to call through to the VxFS filesystem.
551 Presumably HPUX 10, see above, does this.
554 Add your OS to "IFLIST" below.
555 Get it to compile successfully:
556 Almost certainly "include"s require attention: see SUNOS5.
557 In the main code above, arrange for it to be called: see SUNOS5.
560 ****************************************************************************/
563 * This "if" is a list of ports:
564 * if defined(OS1) || defined(OS2) || ...
569 #include <sys/fs/vx_solaris.h>
571 #include <sys/fs/vx_machdep.h>
572 #include <sys/fs/vx_layout.h>
573 #include <sys/fs/vx_quota.h>
574 #include <sys/fs/vx_aioctl.h>
575 #include <sys/fs/vx_ioctl.h>
577 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
579 uid_t user_id, euser_id;
582 struct vx_quotctl quotabuf;
583 struct vx_genioctl genbuf;
588 * "name" may or may not include a trailing "/quotas".
589 * Arranging consistency of calling here in "quotas.c" may not be easy and
590 * it might be easier to examine and adjust it here.
591 * Fortunately, VxFS seems not to mind at present.
593 qfname = talloc_strdup(talloc_tos(), name);
597 /* pstrcat(qfname, "/quotas") ; */ /* possibly examine and adjust "name" */
599 euser_id = geteuid();
600 set_effective_uid(0);
602 DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
603 if((file=open(qfname, O_RDONLY,0))<0) {
604 set_effective_uid(euser_id);
607 genbuf.ioc_cmd = VX_QUOTACTL;
608 genbuf.ioc_up = (void *) "abuf;
610 quotabuf.cmd = VX_GETQUOTA;
611 quotabuf.uid = euser_id;
612 quotabuf.addr = (caddr_t) &D;
613 ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
616 set_effective_uid(euser_id);
619 DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
623 /* If softlimit is zero, set it equal to hardlimit.
626 if (D.dqb_bsoftlimit==0)
627 D.dqb_bsoftlimit = D.dqb_bhardlimit;
629 /* Use softlimit to determine disk space. A user exceeding the quota is told
630 * that there's no space left. Writes might actually work for a bit if the
631 * hardlimit is set higher than softlimit. Effectively the disk becomes
632 * made of rubber latex and begins to expand to accommodate the user :-)
634 DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
635 path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
636 D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
638 if (D.dqb_bsoftlimit==0)
641 *dsize = D.dqb_bsoftlimit;
643 if (D.dqb_curblocks > D.dqb_bsoftlimit) {
645 *dsize = D.dqb_curblocks;
647 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
649 DEBUG(5,("disk_quotas for path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",
650 path,(double)*bsize,(double)*dfree,(double)*dsize));
655 #endif /* SUNOS5 || ... */
657 #endif /* VXFS_QUOTA */
659 #else /* WITH_QUOTAS */
661 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
663 (*bsize) = 512; /* This value should be ignored */
665 /* And just to be sure we set some values that hopefully */
666 /* will be larger that any possible real-world value */
667 (*dfree) = (uint64_t)-1;
668 (*dsize) = (uint64_t)-1;
670 /* As we have select not to use quotas, allways fail */
673 #endif /* WITH_QUOTAS */
675 #else /* HAVE_SYS_QUOTAS */
676 /* wrapper to the new sys_quota interface
677 this file should be removed later
679 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
688 r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
690 /* Use softlimit to determine disk space, except when it has been exceeded */
693 if (errno == EDQUOT) {
698 goto try_group_quota;
702 /* Use softlimit to determine disk space, except when it has been exceeded */
704 (D.softlimit && D.curblocks >= D.softlimit) ||
705 (D.hardlimit && D.curblocks >= D.hardlimit) ||
706 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
707 (D.ihardlimit && D.curinodes>=D.ihardlimit)
710 *dsize = D.curblocks;
711 } else if (D.softlimit==0 && D.hardlimit==0) {
712 goto try_group_quota;
714 if (D.softlimit == 0)
715 D.softlimit = D.hardlimit;
716 *dfree = D.softlimit - D.curblocks;
717 *dsize = D.softlimit;
726 r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
728 /* Use softlimit to determine disk space, except when it has been exceeded */
731 if (errno == EDQUOT) {
740 /* Use softlimit to determine disk space, except when it has been exceeded */
742 (D.softlimit && D.curblocks >= D.softlimit) ||
743 (D.hardlimit && D.curblocks >= D.hardlimit) ||
744 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
745 (D.ihardlimit && D.curinodes>=D.ihardlimit)
748 *dsize = D.curblocks;
749 } else if (D.softlimit==0 && D.hardlimit==0) {
752 if (D.softlimit == 0)
753 D.softlimit = D.hardlimit;
754 *dfree = D.softlimit - D.curblocks;
755 *dsize = D.softlimit;
760 #endif /* HAVE_SYS_QUOTAS */