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 2 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, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 * This is one of the most system dependent parts of Samba, and its
24 * done a litle differently. Each system has its own way of doing
31 #define DBGC_CLASS DBGC_QUOTA
33 #ifndef HAVE_SYS_QUOTAS
35 /* just a quick hack because sysquotas.h is included before linux/quota.h */
36 #ifdef QUOTABLOCK_SIZE
37 #undef QUOTABLOCK_SIZE
42 #if defined(VXFS_QUOTA)
45 * In addition to their native filesystems, some systems have Veritas VxFS.
46 * Declare here, define at end: reduces likely "include" interaction problems.
47 * David Lee <T.D.Lee@durham.ac.uk>
49 BOOL
disk_quotas_vxfs(const pstring name
, char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
);
51 #endif /* VXFS_QUOTA */
55 #include <sys/types.h>
59 * This shouldn't be neccessary - it should be /usr/include/sys/quota.h
60 * So we include all the files has *should* be in the system into a large,
61 * grungy samba_linux_quoatas.h Sometimes I *hate* Linux :-). JRA.
64 #include "samba_linux_quota.h"
65 #include "samba_xfs_quota.h"
67 typedef struct _LINUX_SMB_DISK_QUOTA
{
69 SMB_BIG_UINT hardlimit
; /* In bsize units. */
70 SMB_BIG_UINT softlimit
; /* In bsize units. */
71 SMB_BIG_UINT curblocks
; /* In bsize units. */
72 SMB_BIG_UINT ihardlimit
; /* inode hard limit. */
73 SMB_BIG_UINT isoftlimit
; /* inode soft limit. */
74 SMB_BIG_UINT curinodes
; /* Current used inodes. */
75 } LINUX_SMB_DISK_QUOTA
;
77 /****************************************************************************
78 Abstract out the XFS Quota Manager quota get call.
79 ****************************************************************************/
81 static int get_smb_linux_xfs_quota(char *path
, uid_t euser_id
, gid_t egrp_id
, LINUX_SMB_DISK_QUOTA
*dp
)
83 struct fs_disk_quota D
;
88 ret
= quotactl(QCMD(Q_XGETQUOTA
,USRQUOTA
), path
, euser_id
, (caddr_t
)&D
);
91 ret
= quotactl(QCMD(Q_XGETQUOTA
,GRPQUOTA
), path
, egrp_id
, (caddr_t
)&D
);
96 dp
->bsize
= (SMB_BIG_UINT
)512;
97 dp
->softlimit
= (SMB_BIG_UINT
)D
.d_blk_softlimit
;
98 dp
->hardlimit
= (SMB_BIG_UINT
)D
.d_blk_hardlimit
;
99 dp
->ihardlimit
= (SMB_BIG_UINT
)D
.d_ino_hardlimit
;
100 dp
->isoftlimit
= (SMB_BIG_UINT
)D
.d_ino_softlimit
;
101 dp
->curinodes
= (SMB_BIG_UINT
)D
.d_icount
;
102 dp
->curblocks
= (SMB_BIG_UINT
)D
.d_bcount
;
107 /****************************************************************************
108 Abstract out the old and new Linux quota get calls.
109 ****************************************************************************/
111 static int get_smb_linux_v1_quota(char *path
, uid_t euser_id
, gid_t egrp_id
, LINUX_SMB_DISK_QUOTA
*dp
)
113 struct v1_kern_dqblk D
;
118 ret
= quotactl(QCMD(Q_V1_GETQUOTA
,USRQUOTA
), path
, euser_id
, (caddr_t
)&D
);
120 if (ret
&& errno
!= EDQUOT
)
121 ret
= quotactl(QCMD(Q_V1_GETQUOTA
,GRPQUOTA
), path
, egrp_id
, (caddr_t
)&D
);
123 if (ret
&& errno
!= EDQUOT
)
126 dp
->bsize
= (SMB_BIG_UINT
)QUOTABLOCK_SIZE
;
127 dp
->softlimit
= (SMB_BIG_UINT
)D
.dqb_bsoftlimit
;
128 dp
->hardlimit
= (SMB_BIG_UINT
)D
.dqb_bhardlimit
;
129 dp
->ihardlimit
= (SMB_BIG_UINT
)D
.dqb_ihardlimit
;
130 dp
->isoftlimit
= (SMB_BIG_UINT
)D
.dqb_isoftlimit
;
131 dp
->curinodes
= (SMB_BIG_UINT
)D
.dqb_curinodes
;
132 dp
->curblocks
= (SMB_BIG_UINT
)D
.dqb_curblocks
;
137 static int get_smb_linux_v2_quota(char *path
, uid_t euser_id
, gid_t egrp_id
, LINUX_SMB_DISK_QUOTA
*dp
)
139 struct v2_kern_dqblk D
;
144 ret
= quotactl(QCMD(Q_V2_GETQUOTA
,USRQUOTA
), path
, euser_id
, (caddr_t
)&D
);
146 if (ret
&& errno
!= EDQUOT
)
147 ret
= quotactl(QCMD(Q_V2_GETQUOTA
,GRPQUOTA
), path
, egrp_id
, (caddr_t
)&D
);
149 if (ret
&& errno
!= EDQUOT
)
152 dp
->bsize
= (SMB_BIG_UINT
)QUOTABLOCK_SIZE
;
153 dp
->softlimit
= (SMB_BIG_UINT
)D
.dqb_bsoftlimit
;
154 dp
->hardlimit
= (SMB_BIG_UINT
)D
.dqb_bhardlimit
;
155 dp
->ihardlimit
= (SMB_BIG_UINT
)D
.dqb_ihardlimit
;
156 dp
->isoftlimit
= (SMB_BIG_UINT
)D
.dqb_isoftlimit
;
157 dp
->curinodes
= (SMB_BIG_UINT
)D
.dqb_curinodes
;
158 dp
->curblocks
= ((SMB_BIG_UINT
)D
.dqb_curspace
) / dp
->bsize
;
163 /****************************************************************************
164 Brand-new generic quota interface.
165 ****************************************************************************/
167 static int get_smb_linux_gen_quota(char *path
, uid_t euser_id
, gid_t egrp_id
, LINUX_SMB_DISK_QUOTA
*dp
)
174 ret
= quotactl(QCMD(Q_GETQUOTA
,USRQUOTA
), path
, euser_id
, (caddr_t
)&D
);
176 if (ret
&& errno
!= EDQUOT
)
177 ret
= quotactl(QCMD(Q_GETQUOTA
,GRPQUOTA
), path
, egrp_id
, (caddr_t
)&D
);
179 if (ret
&& errno
!= EDQUOT
)
182 dp
->bsize
= (SMB_BIG_UINT
)QUOTABLOCK_SIZE
;
183 dp
->softlimit
= (SMB_BIG_UINT
)D
.dqb_bsoftlimit
;
184 dp
->hardlimit
= (SMB_BIG_UINT
)D
.dqb_bhardlimit
;
185 dp
->ihardlimit
= (SMB_BIG_UINT
)D
.dqb_ihardlimit
;
186 dp
->isoftlimit
= (SMB_BIG_UINT
)D
.dqb_isoftlimit
;
187 dp
->curinodes
= (SMB_BIG_UINT
)D
.dqb_curinodes
;
188 dp
->curblocks
= ((SMB_BIG_UINT
)D
.dqb_curspace
) / dp
->bsize
;
193 /****************************************************************************
194 Try to get the disk space from disk quotas (LINUX version).
195 ****************************************************************************/
197 BOOL
disk_quotas(const char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
202 LINUX_SMB_DISK_QUOTA D
;
209 euser_id
= geteuid();
212 /* find the block device file */
214 if ( sys_stat(path
, &S
) == -1 )
219 fp
= setmntent(MOUNTED
,"r");
222 while ((mnt
= getmntent(fp
))) {
223 if ( sys_stat(mnt
->mnt_dir
,&S
) == -1 )
226 if (S
.st_dev
== devno
) {
238 set_effective_uid(0);
240 if (strcmp(mnt
->mnt_type
, "xfs")==0) {
241 r
=get_smb_linux_xfs_quota(mnt
->mnt_fsname
, euser_id
, egrp_id
, &D
);
243 r
=get_smb_linux_gen_quota(mnt
->mnt_fsname
, euser_id
, egrp_id
, &D
);
244 if (r
== -1 && errno
!= EDQUOT
) {
245 r
=get_smb_linux_v2_quota(mnt
->mnt_fsname
, euser_id
, egrp_id
, &D
);
246 if (r
== -1 && errno
!= EDQUOT
)
247 r
=get_smb_linux_v1_quota(mnt
->mnt_fsname
, euser_id
, egrp_id
, &D
);
253 /* Use softlimit to determine disk space, except when it has been exceeded */
256 if (errno
== EDQUOT
) {
265 /* Use softlimit to determine disk space, except when it has been exceeded */
267 (D
.softlimit
&& D
.curblocks
>= D
.softlimit
) ||
268 (D
.hardlimit
&& D
.curblocks
>= D
.hardlimit
) ||
269 (D
.isoftlimit
&& D
.curinodes
>= D
.isoftlimit
) ||
270 (D
.ihardlimit
&& D
.curinodes
>=D
.ihardlimit
)
273 *dsize
= D
.curblocks
;
274 } else if (D
.softlimit
==0 && D
.hardlimit
==0) {
277 if (D
.softlimit
== 0)
278 D
.softlimit
= D
.hardlimit
;
279 *dfree
= D
.softlimit
- D
.curblocks
;
280 *dsize
= D
.softlimit
;
288 #include <sys/quota.h>
291 /****************************************************************************
292 try to get the disk space from disk quotas (CRAY VERSION)
293 ****************************************************************************/
295 BOOL
disk_quotas(const char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
299 SMB_STRUCT_STAT sbuf
;
301 static SMB_DEV_T devno_cached
= 0 ;
303 struct q_request request
;
304 struct qf_header header
;
305 static int quota_default
= 0 ;
308 if ( sys_stat(path
,&sbuf
) == -1 )
311 devno
= sbuf
.st_dev
;
313 if ( devno
!= devno_cached
) {
315 devno_cached
= devno
;
317 if ((fd
= setmntent(KMTAB
)) == NULL
)
322 while ((mnt
= getmntent(fd
)) != NULL
) {
324 if ( sys_stat(mnt
->mnt_dir
,&sbuf
) == -1 )
327 if (sbuf
.st_dev
== devno
) {
336 pstrcpy(name
,mnt
->mnt_dir
) ;
343 request
.qf_magic
= QF_MAGIC
;
344 request
.qf_entry
.id
= geteuid() ;
346 if (quotactl(name
, Q_GETQUOTA
, &request
) == -1)
349 if ( ! request
.user
)
352 if ( request
.qf_entry
.user_q
.f_quota
== QFV_DEFAULT
) {
354 if ( ! quota_default
) {
356 if ( quotactl(name
, Q_GETHEADER
, &header
) == -1 )
359 quota_default
= header
.user_h
.def_fq
;
362 *dfree
= quota_default
;
364 }else if ( request
.qf_entry
.user_q
.f_quota
== QFV_PREVENT
) {
370 *dfree
= request
.qf_entry
.user_q
.f_quota
;
374 *dsize
= request
.qf_entry
.user_q
.f_use
;
376 if ( *dfree
< *dsize
)
381 *bsize
= 4096 ; /* Cray blocksize */
388 #elif defined(SUNOS5) || defined(SUNOS4)
391 #include <sys/param.h>
393 #include <sys/fs/ufs_quota.h>
394 #include <sys/mnttab.h>
395 #include <sys/mntent.h>
396 #else /* defined(SUNOS4) */
397 #include <ufs/quota.h>
403 /****************************************************************************
404 Allows querying of remote hosts for quotas on NFS mounted shares.
405 Supports normal NFS and AMD mounts.
406 Alan Romeril <a.romeril@ic.ac.uk> July 2K.
407 ****************************************************************************/
410 #include <rpc/types.h>
411 #include <rpcsvc/rquota.h>
412 #include <rpc/nettype.h>
415 static int quotastat
;
417 static int xdr_getquota_args(XDR
*xdrsp
, struct getquota_args
*args
)
419 if (!xdr_string(xdrsp
, &args
->gqa_pathp
, RQ_PATHLEN
))
421 if (!xdr_int(xdrsp
, &args
->gqa_uid
))
426 static int xdr_getquota_rslt(XDR
*xdrsp
, struct getquota_rslt
*gqr
)
428 if (!xdr_int(xdrsp
, "astat
)) {
429 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
432 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_bsize
)) {
433 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
436 if (!xdr_bool(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_active
)) {
437 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
440 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_bhardlimit
)) {
441 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
444 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_bsoftlimit
)) {
445 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
448 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_curblocks
)) {
449 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
455 /* Restricted to SUNOS5 for the moment, I haven`t access to others to test. */
456 static BOOL
nfs_quotas(char *nfspath
, uid_t euser_id
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
458 uid_t uid
= euser_id
;
460 char *mnttype
= nfspath
;
462 struct getquota_rslt gqr
;
463 struct getquota_args args
;
464 char *cutstr
, *pathname
, *host
, *testpath
;
466 static struct timeval timeout
= {2,0};
467 enum clnt_stat clnt_stat
;
470 *bsize
= *dfree
= *dsize
= (SMB_BIG_UINT
)0;
472 len
=strcspn(mnttype
, ":");
473 pathname
=strstr(mnttype
, ":");
474 cutstr
= (char *) SMB_MALLOC(len
+1);
478 memset(cutstr
, '\0', len
+1);
479 host
= strncat(cutstr
,mnttype
, sizeof(char) * len
);
480 DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr
));
481 DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype
));
482 testpath
=strchr_m(mnttype
, ':');
483 args
.gqa_pathp
= testpath
+1;
486 DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host
, RQUOTAPROG
, RQUOTAVERS
, "udp"));
488 if ((clnt
= clnt_create(host
, RQUOTAPROG
, RQUOTAVERS
, "udp")) == NULL
) {
493 clnt
->cl_auth
= authunix_create_default();
494 DEBUG(9,("nfs_quotas: auth_success\n"));
496 clnt_stat
=clnt_call(clnt
, RQUOTAPROC_GETQUOTA
, xdr_getquota_args
, (caddr_t
)&args
, xdr_getquota_rslt
, (caddr_t
)&gqr
, timeout
);
498 if (clnt_stat
!= RPC_SUCCESS
) {
499 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
505 * quotastat returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
506 * no quota set, and 3 if no permission to get the quota. If 0 or 3 return
507 * something sensible.
510 switch ( quotastat
) {
512 DEBUG(9,("nfs_quotas: Remote Quotas Failed! Error \"%i\" \n", quotastat
));
517 DEBUG(9,("nfs_quotas: Good quota data\n"));
518 D
.dqb_bsoftlimit
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsoftlimit
;
519 D
.dqb_bhardlimit
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_bhardlimit
;
520 D
.dqb_curblocks
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_curblocks
;
525 D
.dqb_bsoftlimit
= 1;
527 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", quotastat
));
531 DEBUG(9,("nfs_quotas: Remote Quotas Questionable! Error \"%i\" \n", quotastat
));
535 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",
537 gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsize
,
538 gqr
.getquota_rslt_u
.gqr_rquota
.rq_active
,
539 gqr
.getquota_rslt_u
.gqr_rquota
.rq_bhardlimit
,
540 gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsoftlimit
,
541 gqr
.getquota_rslt_u
.gqr_rquota
.rq_curblocks
));
543 *bsize
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsize
;
544 *dsize
= D
.dqb_bsoftlimit
;
546 if (D
.dqb_curblocks
== D
.dqb_curblocks
== 1)
549 if (D
.dqb_curblocks
> D
.dqb_bsoftlimit
) {
551 *dsize
= D
.dqb_curblocks
;
553 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
559 auth_destroy(clnt
->cl_auth
);
563 DEBUG(5,("nfs_quotas: For path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",args
.gqa_pathp
,(double)*bsize
,(double)*dfree
,(double)*dsize
));
566 DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
571 /****************************************************************************
572 try to get the disk space from disk quotas (SunOS & Solaris2 version)
573 Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
574 ****************************************************************************/
576 BOOL
disk_quotas(const char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
582 struct quotctl command
;
584 static struct mnttab mnt
;
592 SMB_STRUCT_STAT sbuf
;
594 static SMB_DEV_T devno_cached
= 0 ;
597 euser_id
= geteuid();
599 if ( sys_stat(path
,&sbuf
) == -1 )
602 devno
= sbuf
.st_dev
;
603 DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n", path
,(unsigned int)devno
));
604 if ( devno
!= devno_cached
) {
605 devno_cached
= devno
;
607 if ((fd
= sys_fopen(MNTTAB
, "r")) == NULL
)
611 slprintf(devopt
, sizeof(devopt
) - 1, "dev=%x", (unsigned int)devno
);
612 while (getmntent(fd
, &mnt
) == 0) {
613 if( !hasmntopt(&mnt
, devopt
) )
616 DEBUG(5,("disk_quotas: testing \"%s\" %s\n", mnt
.mnt_mountp
,devopt
));
618 /* quotas are only on vxfs, UFS or NFS */
619 if ( strcmp( mnt
.mnt_fstype
, MNTTYPE_UFS
) == 0 ||
620 strcmp( mnt
.mnt_fstype
, "nfs" ) == 0 ||
621 strcmp( mnt
.mnt_fstype
, "vxfs" ) == 0 ) {
627 pstrcpy(name
,mnt
.mnt_mountp
) ;
628 pstrcat(name
,"/quotas") ;
631 if ((fd
= setmntent(MOUNTED
, "r")) == NULL
)
635 while ((mnt
= getmntent(fd
)) != NULL
) {
636 if ( sys_stat(mnt
->mnt_dir
,&sbuf
) == -1 )
638 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n", mnt
->mnt_dir
,(unsigned int)sbuf
.st_dev
));
639 if (sbuf
.st_dev
== devno
) {
645 pstrcpy(name
,mnt
->mnt_fsname
) ;
654 set_effective_uid(0);
657 if ( strcmp( mnt
.mnt_fstype
, "nfs" ) == 0) {
659 DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n", mnt
.mnt_special
));
660 retval
= nfs_quotas(mnt
.mnt_special
, euser_id
, bsize
, dfree
, dsize
);
665 DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name
));
666 if((file
=sys_open(name
, O_RDONLY
,0))<0) {
670 command
.op
= Q_GETQUOTA
;
671 command
.uid
= euser_id
;
672 command
.addr
= (caddr_t
) &D
;
673 ret
= ioctl(file
, Q_QUOTACTL
, &command
);
676 DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name
));
677 ret
= quotactl(Q_GETQUOTA
, name
, euser_id
, &D
);
683 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n", strerror(errno
) ));
685 #if defined(SUNOS5) && defined(VXFS_QUOTA)
686 /* If normal quotactl() fails, try vxfs private calls */
687 set_effective_uid(euser_id
);
688 DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt
.mnt_fstype
));
689 if ( 0 == strcmp ( mnt
.mnt_fstype
, "vxfs" )) {
691 retval
= disk_quotas_vxfs(name
, path
, bsize
, dfree
, dsize
);
699 /* If softlimit is zero, set it equal to hardlimit.
702 if (D
.dqb_bsoftlimit
==0)
703 D
.dqb_bsoftlimit
= D
.dqb_bhardlimit
;
705 /* Use softlimit to determine disk space. A user exceeding the quota is told
706 * that there's no space left. Writes might actually work for a bit if the
707 * hardlimit is set higher than softlimit. Effectively the disk becomes
708 * made of rubber latex and begins to expand to accommodate the user :-)
711 if (D
.dqb_bsoftlimit
==0)
714 *dsize
= D
.dqb_bsoftlimit
;
716 if (D
.dqb_curblocks
> D
.dqb_bsoftlimit
) {
718 *dsize
= D
.dqb_curblocks
;
720 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
722 DEBUG(5,("disk_quotas for path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",
723 path
,(double)*bsize
,(double)*dfree
,(double)*dsize
));
730 #include <ufs/quota.h>
732 /****************************************************************************
733 try to get the disk space from disk quotas - OSF1 version
734 ****************************************************************************/
736 BOOL
disk_quotas(const char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
744 * This code presumes that OSF1 will only
745 * give out quota info when the real uid
746 * matches the effective uid. JRA.
748 euser_id
= geteuid();
750 if (set_re_uid() != 0) return False
;
752 r
= quotactl(path
,QCMD(Q_GETQUOTA
, USRQUOTA
),euser_id
,(char *) &D
);
763 if (save_errno
== EDQUOT
) /* disk quota exceeded */
766 *dsize
= D
.dqb_curblocks
;
773 /* If softlimit is zero, set it equal to hardlimit.
776 if (D
.dqb_bsoftlimit
==0)
777 D
.dqb_bsoftlimit
= D
.dqb_bhardlimit
;
779 /* Use softlimit to determine disk space, except when it has been exceeded */
781 if (D
.dqb_bsoftlimit
==0)
784 if ((D
.dqb_curblocks
>D
.dqb_bsoftlimit
)) {
786 *dsize
= D
.dqb_curblocks
;
788 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
789 *dsize
= D
.dqb_bsoftlimit
;
794 #elif defined (IRIX6)
795 /****************************************************************************
796 try to get the disk space from disk quotas (IRIX 6.2 version)
797 ****************************************************************************/
799 #include <sys/quota.h>
802 BOOL
disk_quotas(const char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
807 struct fs_disk_quota F
;
814 /* find the block device file */
816 if ( sys_stat(path
, &S
) == -1 ) {
822 fp
= setmntent(MOUNTED
,"r");
825 while ((mnt
= getmntent(fp
))) {
826 if ( sys_stat(mnt
->mnt_dir
,&S
) == -1 )
828 if (S
.st_dev
== devno
) {
841 set_effective_uid(0);
843 /* Use softlimit to determine disk space, except when it has been exceeded */
847 if ( 0 == strcmp ( mnt
->mnt_type
, "efs" ))
849 r
=quotactl (Q_GETQUOTA
, mnt
->mnt_fsname
, euser_id
, (caddr_t
) &D
);
856 /* Use softlimit to determine disk space, except when it has been exceeded */
858 (D
.dqb_bsoftlimit
&& D
.dqb_curblocks
>=D
.dqb_bsoftlimit
) ||
859 (D
.dqb_bhardlimit
&& D
.dqb_curblocks
>=D
.dqb_bhardlimit
) ||
860 (D
.dqb_fsoftlimit
&& D
.dqb_curfiles
>=D
.dqb_fsoftlimit
) ||
861 (D
.dqb_fhardlimit
&& D
.dqb_curfiles
>=D
.dqb_fhardlimit
)
865 *dsize
= D
.dqb_curblocks
;
867 else if (D
.dqb_bsoftlimit
==0 && D
.dqb_bhardlimit
==0)
873 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
874 *dsize
= D
.dqb_bsoftlimit
;
878 else if ( 0 == strcmp ( mnt
->mnt_type
, "xfs" ))
880 r
=quotactl (Q_XGETQUOTA
, mnt
->mnt_fsname
, euser_id
, (caddr_t
) &F
);
887 /* Use softlimit to determine disk space, except when it has been exceeded */
889 (F
.d_blk_softlimit
&& F
.d_bcount
>=F
.d_blk_softlimit
) ||
890 (F
.d_blk_hardlimit
&& F
.d_bcount
>=F
.d_blk_hardlimit
) ||
891 (F
.d_ino_softlimit
&& F
.d_icount
>=F
.d_ino_softlimit
) ||
892 (F
.d_ino_hardlimit
&& F
.d_icount
>=F
.d_ino_hardlimit
)
898 else if (F
.d_blk_softlimit
==0 && F
.d_blk_hardlimit
==0)
904 *dfree
= (F
.d_blk_softlimit
- F
.d_bcount
);
905 *dsize
= F
.d_blk_softlimit
;
921 #if defined(__FreeBSD__) || defined(__OpenBSD__)
922 #include <ufs/ufs/quota.h>
923 #include <machine/param.h>
925 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
926 #include <jfs/quota.h>
927 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
928 #define dqb_curfiles dqb_curinodes
929 #define dqb_fhardlimit dqb_ihardlimit
930 #define dqb_fsoftlimit dqb_isoftlimit
931 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
932 #include <sys/quota.h>
936 #if defined(__FreeBSD__)
939 #include <rpc/types.h>
940 #include <rpcsvc/rquota.h>
941 #ifdef HAVE_RPC_NETTYPE_H
942 #include <rpc/nettype.h>
946 static int quotastat
;
948 static int my_xdr_getquota_args(XDR
*xdrsp
, struct getquota_args
*args
)
950 if (!xdr_string(xdrsp
, &args
->gqa_pathp
, RQ_PATHLEN
))
952 if (!xdr_int(xdrsp
, &args
->gqa_uid
))
957 static int my_xdr_getquota_rslt(XDR
*xdrsp
, struct getquota_rslt
*gqr
)
959 if (!xdr_int(xdrsp
, "astat
)) {
960 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
963 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_bsize
)) {
964 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
967 if (!xdr_bool(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_active
)) {
968 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
971 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_bhardlimit
)) {
972 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
975 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_bsoftlimit
)) {
976 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
979 if (!xdr_int(xdrsp
, &gqr
->getquota_rslt_u
.gqr_rquota
.rq_curblocks
)) {
980 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
986 /* Works on FreeBSD, too. :-) */
987 static BOOL
nfs_quotas(char *nfspath
, uid_t euser_id
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
989 uid_t uid
= euser_id
;
991 char *mnttype
= nfspath
;
993 struct getquota_rslt gqr
;
994 struct getquota_args args
;
995 char *cutstr
, *pathname
, *host
, *testpath
;
997 static struct timeval timeout
= {2,0};
998 enum clnt_stat clnt_stat
;
1001 *bsize
= *dfree
= *dsize
= (SMB_BIG_UINT
)0;
1003 len
=strcspn(mnttype
, ":");
1004 pathname
=strstr(mnttype
, ":");
1005 cutstr
= (char *) SMB_MALLOC(len
+1);
1009 memset(cutstr
, '\0', len
+1);
1010 host
= strncat(cutstr
,mnttype
, sizeof(char) * len
);
1011 DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr
));
1012 DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype
));
1013 testpath
=strchr_m(mnttype
, ':');
1014 args
.gqa_pathp
= testpath
+1;
1017 DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host
, RQUOTAPROG
, RQUOTAVERS
, "udp"));
1019 if ((clnt
= clnt_create(host
, RQUOTAPROG
, RQUOTAVERS
, "udp")) == NULL
) {
1024 clnt
->cl_auth
= authunix_create_default();
1025 DEBUG(9,("nfs_quotas: auth_success\n"));
1027 clnt_stat
=clnt_call(clnt
, RQUOTAPROC_GETQUOTA
, (const xdrproc_t
) my_xdr_getquota_args
, (caddr_t
)&args
, (const xdrproc_t
) my_xdr_getquota_rslt
, (caddr_t
)&gqr
, timeout
);
1029 if (clnt_stat
!= RPC_SUCCESS
) {
1030 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
1036 * quotastat returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
1037 * no quota set, and 3 if no permission to get the quota. If 0 or 3 return
1038 * something sensible.
1041 switch ( quotastat
) {
1043 DEBUG(9,("nfs_quotas: Remote Quotas Failed! Error \"%i\" \n", quotastat
));
1048 DEBUG(9,("nfs_quotas: Good quota data\n"));
1049 D
.dqb_bsoftlimit
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsoftlimit
;
1050 D
.dqb_bhardlimit
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_bhardlimit
;
1051 D
.dqb_curblocks
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_curblocks
;
1056 D
.dqb_bsoftlimit
= 1;
1057 D
.dqb_curblocks
= 1;
1058 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", quotastat
));
1062 DEBUG(9,("nfs_quotas: Remote Quotas Questionable! Error \"%i\" \n", quotastat
));
1066 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",
1068 gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsize
,
1069 gqr
.getquota_rslt_u
.gqr_rquota
.rq_active
,
1070 gqr
.getquota_rslt_u
.gqr_rquota
.rq_bhardlimit
,
1071 gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsoftlimit
,
1072 gqr
.getquota_rslt_u
.gqr_rquota
.rq_curblocks
));
1074 if (D
.dqb_bsoftlimit
== 0)
1075 D
.dqb_bsoftlimit
= D
.dqb_bhardlimit
;
1076 if (D
.dqb_bsoftlimit
== 0)
1079 *bsize
= gqr
.getquota_rslt_u
.gqr_rquota
.rq_bsize
;
1080 *dsize
= D
.dqb_bsoftlimit
;
1082 if (D
.dqb_curblocks
== D
.dqb_curblocks
== 1)
1085 if (D
.dqb_curblocks
> D
.dqb_bsoftlimit
) {
1087 *dsize
= D
.dqb_curblocks
;
1089 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
1095 auth_destroy(clnt
->cl_auth
);
1099 DEBUG(5,("nfs_quotas: For path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",args
.gqa_pathp
,(double)*bsize
,(double)*dfree
,(double)*dsize
));
1102 DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
1108 /****************************************************************************
1109 try to get the disk space from disk quotas - default version
1110 ****************************************************************************/
1112 BOOL
disk_quotas(const char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
1117 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__)
1121 /* find the block device file */
1124 /* Need to set the cache flag to 1 for HPUX. Seems
1125 * to have a significant performance boost when
1126 * lstat calls on /dev access this function.
1128 if ((sys_stat(path
, &S
)<0) || (devnm(S_IFBLK
, S
.st_dev
, dev_disk
, 256, 1)<0))
1130 if ((sys_stat(path
, &S
)<0) || (devnm(S_IFBLK
, S
.st_dev
, dev_disk
, 256, 0)<0))
1132 #endif /* ifdef HPUX */
1134 #endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) */
1136 euser_id
= geteuid();
1139 /* for HPUX, real uid must be same as euid to execute quotactl for euid */
1141 if (set_re_uid() != 0) return False
;
1143 r
=quotactl(Q_GETQUOTA
, dev_disk
, euser_id
, &D
);
1147 #if defined(__FreeBSD__) || defined(__OpenBSD__)
1149 /* FreeBSD patches from Marty Moll <martym@arbor.edu> */
1151 #if defined(__FreeBSD__)
1153 struct statfs
*mnts
;
1157 if (sys_stat(path
,&st
) < 0)
1161 mntsize
= getmntinfo(&mnts
,MNT_NOWAIT
);
1165 for (i
= 0; i
< mntsize
; i
++) {
1166 if (sys_stat(mnts
[i
].f_mntonname
,&st
) < 0)
1168 if (st
.st_dev
== devno
)
1176 set_effective_uid(0);
1178 #if defined(__FreeBSD__)
1179 if (strcmp(mnts
[i
].f_fstypename
,"nfs") == 0) {
1181 retval
= nfs_quotas(mnts
[i
].f_mntfromname
,euser_id
,bsize
,dfree
,dsize
);
1187 egrp_id
= getegid();
1188 r
= quotactl(path
,QCMD(Q_GETQUOTA
,USRQUOTA
),euser_id
,(char *) &D
);
1190 /* As FreeBSD has group quotas, if getting the user
1191 quota fails, try getting the group instead. */
1193 r
= quotactl(path
,QCMD(Q_GETQUOTA
,GRPQUOTA
),egrp_id
,(char *) &D
);
1199 /* AIX has both USER and GROUP quotas:
1200 Get the USER quota (ohnielse@fysik.dtu.dk) */
1202 if (set_re_uid() != 0)
1204 r
= quotactl(path
,QCMD(Q_GETQUOTA
,USRQUOTA
),euser_id
,(char *) &D
);
1206 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
1207 r
=quotactl(Q_GETQUOTA
, dev_disk
, euser_id
, &D
);
1208 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
1211 /* Use softlimit to determine disk space, except when it has been exceeded */
1212 #if defined(__FreeBSD__) || defined(__OpenBSD__)
1214 #else /* !__FreeBSD__ && !__OpenBSD__ */
1216 #endif /*!__FreeBSD__ && !__OpenBSD__ */
1220 if (errno
== EDQUOT
)
1223 *dsize
=D
.dqb_curblocks
;
1229 /* If softlimit is zero, set it equal to hardlimit.
1232 if (D
.dqb_bsoftlimit
==0)
1233 D
.dqb_bsoftlimit
= D
.dqb_bhardlimit
;
1235 if (D
.dqb_bsoftlimit
==0)
1237 /* Use softlimit to determine disk space, except when it has been exceeded */
1238 if ((D
.dqb_curblocks
>D
.dqb_bsoftlimit
)
1239 #if !defined(__FreeBSD__) && !defined(__OpenBSD__)
1240 ||((D
.dqb_curfiles
>D
.dqb_fsoftlimit
) && (D
.dqb_fsoftlimit
!= 0))
1244 *dsize
= D
.dqb_curblocks
;
1247 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
1248 *dsize
= D
.dqb_bsoftlimit
;
1255 #if defined(VXFS_QUOTA)
1257 /****************************************************************************
1258 Try to get the disk space from Veritas disk quotas.
1259 David Lee <T.D.Lee@durham.ac.uk> August 1999.
1261 Background assumptions:
1262 Potentially under many Operating Systems. Initially Solaris 2.
1264 My guess is that Veritas is largely, though not entirely,
1265 independent of OS. So I have separated it out.
1267 There may be some details. For example, OS-specific "include" files.
1269 It is understood that HPUX 10 somehow gets Veritas quotas without
1270 any special effort; if so, this routine need not be compiled in.
1271 Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
1274 It is understood that Veritas do not publicly support this ioctl interface.
1275 Rather their preference would be for the user (us) to call the native
1276 OS and then for the OS itself to call through to the VxFS filesystem.
1277 Presumably HPUX 10, see above, does this.
1280 Add your OS to "IFLIST" below.
1281 Get it to compile successfully:
1282 Almost certainly "include"s require attention: see SUNOS5.
1283 In the main code above, arrange for it to be called: see SUNOS5.
1286 ****************************************************************************/
1289 * This "if" is a list of ports:
1290 * if defined(OS1) || defined(OS2) || ...
1295 #include <sys/fs/vx_solaris.h>
1297 #include <sys/fs/vx_machdep.h>
1298 #include <sys/fs/vx_layout.h>
1299 #include <sys/fs/vx_quota.h>
1300 #include <sys/fs/vx_aioctl.h>
1301 #include <sys/fs/vx_ioctl.h>
1303 BOOL
disk_quotas_vxfs(const pstring name
, char *path
, SMB_BIG_UINT
*bsize
, SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
1305 uid_t user_id
, euser_id
;
1308 struct vx_quotctl quotabuf
;
1309 struct vx_genioctl genbuf
;
1314 * "name" may or may not include a trailing "/quotas".
1315 * Arranging consistency of calling here in "quotas.c" may not be easy and
1316 * it might be easier to examine and adjust it here.
1317 * Fortunately, VxFS seems not to mind at present.
1319 pstrcpy(qfname
, name
) ;
1320 /* pstrcat(qfname, "/quotas") ; */ /* possibly examine and adjust "name" */
1322 euser_id
= geteuid();
1323 set_effective_uid(0);
1325 DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname
));
1326 if((file
=sys_open(qfname
, O_RDONLY
,0))<0) {
1327 set_effective_uid(euser_id
);
1330 genbuf
.ioc_cmd
= VX_QUOTACTL
;
1331 genbuf
.ioc_up
= (void *) "abuf
;
1333 quotabuf
.cmd
= VX_GETQUOTA
;
1334 quotabuf
.uid
= euser_id
;
1335 quotabuf
.addr
= (caddr_t
) &D
;
1336 ret
= ioctl(file
, VX_ADMIN_IOCTL
, &genbuf
);
1339 set_effective_uid(euser_id
);
1342 DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno
) ));
1346 /* If softlimit is zero, set it equal to hardlimit.
1349 if (D
.dqb_bsoftlimit
==0)
1350 D
.dqb_bsoftlimit
= D
.dqb_bhardlimit
;
1352 /* Use softlimit to determine disk space. A user exceeding the quota is told
1353 * that there's no space left. Writes might actually work for a bit if the
1354 * hardlimit is set higher than softlimit. Effectively the disk becomes
1355 * made of rubber latex and begins to expand to accommodate the user :-)
1357 DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
1358 path
, D
.dqb_curblocks
, D
.dqb_bsoftlimit
, D
.dqb_bhardlimit
,
1359 D
.dqb_curfiles
, D
.dqb_fsoftlimit
, D
.dqb_fhardlimit
));
1361 if (D
.dqb_bsoftlimit
==0)
1364 *dsize
= D
.dqb_bsoftlimit
;
1366 if (D
.dqb_curblocks
> D
.dqb_bsoftlimit
) {
1368 *dsize
= D
.dqb_curblocks
;
1370 *dfree
= D
.dqb_bsoftlimit
- D
.dqb_curblocks
;
1372 DEBUG(5,("disk_quotas for path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",
1373 path
,(double)*bsize
,(double)*dfree
,(double)*dsize
));
1378 #endif /* SUNOS5 || ... */
1380 #endif /* VXFS_QUOTA */
1382 #else /* WITH_QUOTAS */
1384 BOOL
disk_quotas(const char *path
,SMB_BIG_UINT
*bsize
,SMB_BIG_UINT
*dfree
,SMB_BIG_UINT
*dsize
)
1386 (*bsize
) = 512; /* This value should be ignored */
1388 /* And just to be sure we set some values that hopefully */
1389 /* will be larger that any possible real-world value */
1390 (*dfree
) = (SMB_BIG_UINT
)-1;
1391 (*dsize
) = (SMB_BIG_UINT
)-1;
1393 /* As we have select not to use quotas, allways fail */
1396 #endif /* WITH_QUOTAS */
1398 #else /* HAVE_SYS_QUOTAS */
1399 /* wrapper to the new sys_quota interface
1400 this file should be removed later
1402 BOOL
disk_quotas(const char *path
,SMB_BIG_UINT
*bsize
,SMB_BIG_UINT
*dfree
,SMB_BIG_UINT
*dsize
)
1411 r
=sys_get_quota(path
, SMB_USER_QUOTA_TYPE
, id
, &D
);
1413 /* Use softlimit to determine disk space, except when it has been exceeded */
1416 if (errno
== EDQUOT
) {
1418 *dsize
=D
.curblocks
;
1421 goto try_group_quota
;
1425 /* Use softlimit to determine disk space, except when it has been exceeded */
1427 (D
.softlimit
&& D
.curblocks
>= D
.softlimit
) ||
1428 (D
.hardlimit
&& D
.curblocks
>= D
.hardlimit
) ||
1429 (D
.isoftlimit
&& D
.curinodes
>= D
.isoftlimit
) ||
1430 (D
.ihardlimit
&& D
.curinodes
>=D
.ihardlimit
)
1433 *dsize
= D
.curblocks
;
1434 } else if (D
.softlimit
==0 && D
.hardlimit
==0) {
1435 goto try_group_quota
;
1437 if (D
.softlimit
== 0)
1438 D
.softlimit
= D
.hardlimit
;
1439 *dfree
= D
.softlimit
- D
.curblocks
;
1440 *dsize
= D
.softlimit
;
1449 r
=sys_get_quota(path
, SMB_GROUP_QUOTA_TYPE
, id
, &D
);
1451 /* Use softlimit to determine disk space, except when it has been exceeded */
1454 if (errno
== EDQUOT
) {
1456 *dsize
=D
.curblocks
;
1463 /* Use softlimit to determine disk space, except when it has been exceeded */
1465 (D
.softlimit
&& D
.curblocks
>= D
.softlimit
) ||
1466 (D
.hardlimit
&& D
.curblocks
>= D
.hardlimit
) ||
1467 (D
.isoftlimit
&& D
.curinodes
>= D
.isoftlimit
) ||
1468 (D
.ihardlimit
&& D
.curinodes
>=D
.ihardlimit
)
1471 *dsize
= D
.curblocks
;
1472 } else if (D
.softlimit
==0 && D
.hardlimit
==0) {
1475 if (D
.softlimit
== 0)
1476 D
.softlimit
= D
.hardlimit
;
1477 *dfree
= D
.softlimit
- D
.curblocks
;
1478 *dsize
= D
.softlimit
;
1483 #endif /* HAVE_SYS_QUOTAS */