Context Navigation

source: branches/samba-3.0/source/smbd/quotas.c@ 1029

Visit:

Last change on this file since 1029 was 105, checked in by Paul Smedley, 18 years ago
Update source to 3.0.27a
File size: 41.2 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	support for quotas
4	Copyright (C) Andrew Tridgell 1992-1998
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	/*
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
25	* things :-(
26	*/
27
28	#include "includes.h"
29
30	#undef DBGC_CLASS
31	#define DBGC_CLASS DBGC_QUOTA
32
33	#ifndef HAVE_SYS_QUOTAS
34
35	/* just a quick hack because sysquotas.h is included before linux/quota.h */
36	#ifdef QUOTABLOCK_SIZE
37	#undef QUOTABLOCK_SIZE
38	#endif
39
40	#ifdef WITH_QUOTAS
41
42	#if defined(VXFS_QUOTA)
43
44	/*
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>
48	*/
49	BOOL disk_quotas_vxfs(const pstring name, char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize);
50
51	#endif /* VXFS_QUOTA */
52
53	#ifdef LINUX
54
55	#include <sys/types.h>
56	#include <mntent.h>
57
58	/*
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.
62	*/
63
64	#include "samba_linux_quota.h"
65	#include "samba_xfs_quota.h"
66
67	typedef struct _LINUX_SMB_DISK_QUOTA {
68	SMB_BIG_UINT bsize;
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;
76
77	/****************************************************************************
78	Abstract out the XFS Quota Manager quota get call.
79	****************************************************************************/
80
81	static int get_smb_linux_xfs_quota(char path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA dp)
82	{
83	struct fs_disk_quota D;
84	int ret;
85
86	ZERO_STRUCT(D);
87
88	ret = quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
89
90	if (ret)
91	ret = quotactl(QCMD(Q_XGETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
92
93	if (ret)
94	return ret;
95
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;
103
104	return ret;
105	}
106
107	/****************************************************************************
108	Abstract out the old and new Linux quota get calls.
109	****************************************************************************/
110
111	static int get_smb_linux_v1_quota(char path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA dp)
112	{
113	struct v1_kern_dqblk D;
114	int ret;
115
116	ZERO_STRUCT(D);
117
118	ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
119
120	if (ret && errno != EDQUOT)
121	ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
122
123	if (ret && errno != EDQUOT)
124	return ret;
125
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;
133
134	return ret;
135	}
136
137	static int get_smb_linux_v2_quota(char path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA dp)
138	{
139	struct v2_kern_dqblk D;
140	int ret;
141
142	ZERO_STRUCT(D);
143
144	ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
145
146	if (ret && errno != EDQUOT)
147	ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
148
149	if (ret && errno != EDQUOT)
150	return ret;
151
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;
159
160	return ret;
161	}
162
163	/****************************************************************************
164	Brand-new generic quota interface.
165	****************************************************************************/
166
167	static int get_smb_linux_gen_quota(char path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA dp)
168	{
169	struct if_dqblk D;
170	int ret;
171
172	ZERO_STRUCT(D);
173
174	ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
175
176	if (ret && errno != EDQUOT)
177	ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
178
179	if (ret && errno != EDQUOT)
180	return ret;
181
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;
189
190	return ret;
191	}
192
193	/****************************************************************************
194	Try to get the disk space from disk quotas (LINUX version).
195	****************************************************************************/
196
197	BOOL disk_quotas(const char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
198	{
199	int r;
200	SMB_STRUCT_STAT S;
201	FILE *fp;
202	LINUX_SMB_DISK_QUOTA D;
203	struct mntent *mnt;
204	SMB_DEV_T devno;
205	int found;
206	uid_t euser_id;
207	gid_t egrp_id;
208
209	ZERO_STRUCT(D);
210
211	euser_id = geteuid();
212	egrp_id = getegid();
213
214	/* find the block device file */
215
216	if ( sys_stat(path, &S) == -1 )
217	return(False) ;
218
219	devno = S.st_dev ;
220
221	if ((fp = setmntent(MOUNTED,"r")) == NULL)
222	return(False) ;
223
224	found = False ;
225
226	while ((mnt = getmntent(fp))) {
227	if ( sys_stat(mnt->mnt_dir,&S) == -1 )
228	continue ;
229
230	if (S.st_dev == devno) {
231	found = True ;
232	break;
233	}
234	}
235
236	endmntent(fp) ;
237
238	if (!found)
239	return(False);
240
241	become_root();
242
243	if (strcmp(mnt->mnt_type, "xfs")==0) {
244	r=get_smb_linux_xfs_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
245	} else {
246	r=get_smb_linux_gen_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
247	if (r == -1 && errno != EDQUOT) {
248	r=get_smb_linux_v2_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
249	if (r == -1 && errno != EDQUOT)
250	r=get_smb_linux_v1_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
251	}
252	}
253
254	unbecome_root();
255
256	/* Use softlimit to determine disk space, except when it has been exceeded */
257	*bsize = D.bsize;
258	if (r == -1) {
259	if (errno == EDQUOT) {
260	*dfree =0;
261	*dsize =D.curblocks;
262	return (True);
263	} else {
264	return(False);
265	}
266	}
267
268	/* Use softlimit to determine disk space, except when it has been exceeded */
269	if (
270	(D.softlimit && D.curblocks >= D.softlimit) \|\|
271	(D.hardlimit && D.curblocks >= D.hardlimit) \|\|
272	(D.isoftlimit && D.curinodes >= D.isoftlimit) \|\|
273	(D.ihardlimit && D.curinodes>=D.ihardlimit)
274	) {
275	*dfree = 0;
276	*dsize = D.curblocks;
277	} else if (D.softlimit==0 && D.hardlimit==0) {
278	return(False);
279	} else {
280	if (D.softlimit == 0)
281	D.softlimit = D.hardlimit;
282	*dfree = D.softlimit - D.curblocks;
283	*dsize = D.softlimit;
284	}
285
286	return (True);
287	}
288
289	#elif defined(CRAY)
290
291	#include <sys/quota.h>
292	#include <mntent.h>
293
294	/****************************************************************************
295	try to get the disk space from disk quotas (CRAY VERSION)
296	****************************************************************************/
297
298	BOOL disk_quotas(const char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
299	{
300	struct mntent *mnt;
301	FILE *fd;
302	SMB_STRUCT_STAT sbuf;
303	SMB_DEV_T devno ;
304	static SMB_DEV_T devno_cached = 0 ;
305	static pstring name;
306	struct q_request request ;
307	struct qf_header header ;
308	static int quota_default = 0 ;
309	int found ;
310
311	if ( sys_stat(path,&sbuf) == -1 )
312	return(False) ;
313
314	devno = sbuf.st_dev ;
315
316	if ( devno != devno_cached ) {
317
318	devno_cached = devno ;
319
320	if ((fd = setmntent(KMTAB)) == NULL)
321	return(False) ;
322
323	found = False ;
324
325	while ((mnt = getmntent(fd)) != NULL) {
326
327	if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
328	continue ;
329
330	if (sbuf.st_dev == devno) {
331
332	found = True ;
333	break ;
334
335	}
336
337	}
338
339	pstrcpy(name,mnt->mnt_dir) ;
340	endmntent(fd) ;
341
342	if ( ! found )
343	return(False) ;
344	}
345
346	request.qf_magic = QF_MAGIC ;
347	request.qf_entry.id = geteuid() ;
348
349	if (quotactl(name, Q_GETQUOTA, &request) == -1)
350	return(False) ;
351
352	if ( ! request.user )
353	return(False) ;
354
355	if ( request.qf_entry.user_q.f_quota == QFV_DEFAULT ) {
356
357	if ( ! quota_default ) {
358
359	if ( quotactl(name, Q_GETHEADER, &header) == -1 )
360	return(False) ;
361	else
362	quota_default = header.user_h.def_fq ;
363	}
364
365	*dfree = quota_default ;
366
367	}else if ( request.qf_entry.user_q.f_quota == QFV_PREVENT ) {
368
369	*dfree = 0 ;
370
371	}else{
372
373	*dfree = request.qf_entry.user_q.f_quota ;
374
375	}
376
377	*dsize = request.qf_entry.user_q.f_use ;
378
379	if ( dfree < dsize )
380	*dfree = 0 ;
381	else
382	dfree -= dsize ;
383
384	bsize = 4096 ; / Cray blocksize */
385
386	return(True) ;
387
388	}
389
390
391	#elif defined(SUNOS5) \|\| defined(SUNOS4)
392
393	#include <fcntl.h>
394	#include <sys/param.h>
395	#if defined(SUNOS5)
396	#include <sys/fs/ufs_quota.h>
397	#include <sys/mnttab.h>
398	#include <sys/mntent.h>
399	#else /* defined(SUNOS4) */
400	#include <ufs/quota.h>
401	#include <mntent.h>
402	#endif
403
404	#if defined(SUNOS5)
405
406	/****************************************************************************
407	Allows querying of remote hosts for quotas on NFS mounted shares.
408	Supports normal NFS and AMD mounts.
409	Alan Romeril <a.romeril@ic.ac.uk> July 2K.
410	****************************************************************************/
411
412	#include <rpc/rpc.h>
413	#include <rpc/types.h>
414	#include <rpcsvc/rquota.h>
415	#include <rpc/nettype.h>
416	#include <rpc/xdr.h>
417
418	static int quotastat;
419
420	static int my_xdr_getquota_args(XDR xdrsp, struct getquota_args args)
421	{
422	if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
423	return(0);
424	if (!xdr_int(xdrsp, &args->gqa_uid))
425	return(0);
426	return (1);
427	}
428
429	static int my_xdr_getquota_rslt(XDR xdrsp, struct getquota_rslt gqr)
430	{
431	if (!xdr_int(xdrsp, &quotastat)) {
432	DEBUG(6,("nfs_quotas: Status bad or zero\n"));
433	return 0;
434	}
435	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
436	DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
437	return 0;
438	}
439	if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
440	DEBUG(6,("nfs_quotas: Active bad or zero\n"));
441	return 0;
442	}
443	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
444	DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
445	return 0;
446	}
447	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
448	DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
449	return 0;
450	}
451	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
452	DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
453	return 0;
454	}
455	return (1);
456	}
457
458	/* Restricted to SUNOS5 for the moment, I haven`t access to others to test. */
459	static BOOL nfs_quotas(char nfspath, uid_t euser_id, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
460	{
461	uid_t uid = euser_id;
462	struct dqblk D;
463	char *mnttype = nfspath;
464	CLIENT *clnt;
465	struct getquota_rslt gqr;
466	struct getquota_args args;
467	char cutstr, pathname, host, testpath;
468	int len;
469	static struct timeval timeout = {2,0};
470	enum clnt_stat clnt_stat;
471	BOOL ret = True;
472
473	bsize = dfree = *dsize = (SMB_BIG_UINT)0;
474
475	len=strcspn(mnttype, ":");
476	pathname=strstr(mnttype, ":");
477	cutstr = (char *) SMB_MALLOC(len+1);
478	if (!cutstr)
479	return False;
480
481	memset(cutstr, '\0', len+1);
482	host = strncat(cutstr,mnttype, sizeof(char) * len );
483	DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
484	DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
485	testpath=strchr_m(mnttype, ':');
486	args.gqa_pathp = testpath+1;
487	args.gqa_uid = uid;
488
489	DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
490
491	if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
492	ret = False;
493	goto out;
494	}
495
496	clnt->cl_auth = authunix_create_default();
497	DEBUG(9,("nfs_quotas: auth_success\n"));
498
499	clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, my_xdr_getquota_args, (caddr_t)&args, my_xdr_getquota_rslt, (caddr_t)&gqr, timeout);
500
501	if (clnt_stat != RPC_SUCCESS) {
502	DEBUG(9,("nfs_quotas: clnt_call fail\n"));
503	ret = False;
504	goto out;
505	}
506
507	/*
508	* quotastat returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
509	* no quota set, and 3 if no permission to get the quota. If 0 or 3 return
510	* something sensible.
511	*/
512
513	switch ( quotastat ) {
514	case 0:
515	DEBUG(9,("nfs_quotas: Remote Quotas Failed! Error \"%i\" \n", quotastat ));
516	ret = False;
517	goto out;
518
519	case 1:
520	DEBUG(9,("nfs_quotas: Good quota data\n"));
521	D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
522	D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
523	D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
524	break;
525
526	case 2:
527	case 3:
528	D.dqb_bsoftlimit = 1;
529	D.dqb_curblocks = 1;
530	DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", quotastat ));
531	break;
532
533	default:
534	DEBUG(9,("nfs_quotas: Remote Quotas Questionable! Error \"%i\" \n", quotastat ));
535	break;
536	}
537
538	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",
539	quotastat,
540	gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
541	gqr.getquota_rslt_u.gqr_rquota.rq_active,
542	gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
543	gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
544	gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
545
546	*bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
547	*dsize = D.dqb_bsoftlimit;
548
549	if (D.dqb_curblocks == D.dqb_curblocks == 1)
550	*bsize = 512;
551
552	if (D.dqb_curblocks > D.dqb_bsoftlimit) {
553	*dfree = 0;
554	*dsize = D.dqb_curblocks;
555	} else
556	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
557
558	out:
559
560	if (clnt) {
561	if (clnt->cl_auth)
562	auth_destroy(clnt->cl_auth);
563	clnt_destroy(clnt);
564	}
565
566	DEBUG(5,("nfs_quotas: For path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)bsize,(double)dfree,(double)*dsize));
567
568	SAFE_FREE(cutstr);
569	DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
570	return ret;
571	}
572	#endif
573
574	/****************************************************************************
575	try to get the disk space from disk quotas (SunOS & Solaris2 version)
576	Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
577	****************************************************************************/
578
579	BOOL disk_quotas(const char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
580	{
581	uid_t euser_id;
582	int ret;
583	struct dqblk D;
584	#if defined(SUNOS5)
585	struct quotctl command;
586	int file;
587	static struct mnttab mnt;
588	static pstring name;
589	#else /* SunOS4 */
590	struct mntent *mnt;
591	static pstring name;
592	#endif
593	FILE *fd;
594	SMB_STRUCT_STAT sbuf;
595	SMB_DEV_T devno ;
596	static SMB_DEV_T devno_cached = 0 ;
597	static int found ;
598
599	euser_id = geteuid();
600
601	if ( sys_stat(path,&sbuf) == -1 )
602	return(False) ;
603
604	devno = sbuf.st_dev ;
605	DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
606	path, (unsigned int)devno));
607	if ( devno != devno_cached ) {
608	devno_cached = devno ;
609	#if defined(SUNOS5)
610	if ((fd = sys_fopen(MNTTAB, "r")) == NULL)
611	return(False) ;
612
613	found = False ;
614
615	while (getmntent(fd, &mnt) == 0) {
616	if (sys_stat(mnt.mnt_mountp, &sbuf) == -1)
617	continue;
618
619	DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
620	mnt.mnt_mountp, (unsigned int)devno));
621
622	/* quotas are only on vxfs, UFS or NFS */
623	if ( (sbuf.st_dev == devno) && (
624	strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 \|\|
625	strcmp( mnt.mnt_fstype, "nfs" ) == 0 \|\|
626	strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
627	found = True ;
628	break;
629	}
630	}
631
632	pstrcpy(name,mnt.mnt_mountp) ;
633	pstrcat(name,"/quotas") ;
634	fclose(fd) ;
635	#else /* SunOS4 */
636	if ((fd = setmntent(MOUNTED, "r")) == NULL)
637	return(False) ;
638
639	found = False ;
640	while ((mnt = getmntent(fd)) != NULL) {
641	if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
642	continue ;
643	DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n", mnt->mnt_dir,(unsigned int)sbuf.st_dev));
644	if (sbuf.st_dev == devno) {
645	found = True ;
646	break;
647	}
648	}
649
650	pstrcpy(name,mnt->mnt_fsname) ;
651	endmntent(fd) ;
652	#endif
653	}
654
655	if ( ! found )
656	return(False) ;
657
658	become_root();
659
660	#if defined(SUNOS5)
661	if ( strcmp( mnt.mnt_fstype, "nfs" ) == 0) {
662	BOOL retval;
663	DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n", mnt.mnt_special));
664	retval = nfs_quotas(mnt.mnt_special, euser_id, bsize, dfree, dsize);
665	unbecome_root();
666	return retval;
667	}
668
669	DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
670	if((file=sys_open(name, O_RDONLY,0))<0) {
671	unbecome_root();
672	return(False);
673	}
674	command.op = Q_GETQUOTA;
675	command.uid = euser_id;
676	command.addr = (caddr_t) &D;
677	ret = ioctl(file, Q_QUOTACTL, &command);
678	close(file);
679	#else
680	DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
681	ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
682	#endif
683
684	unbecome_root();
685
686	if (ret < 0) {
687	DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n", strerror(errno) ));
688
689	#if defined(SUNOS5) && defined(VXFS_QUOTA)
690	/* If normal quotactl() fails, try vxfs private calls */
691	set_effective_uid(euser_id);
692	DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
693	if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
694	BOOL retval;
695	retval = disk_quotas_vxfs(name, path, bsize, dfree, dsize);
696	return(retval);
697	}
698	#else
699	return(False);
700	#endif
701	}
702
703	/* If softlimit is zero, set it equal to hardlimit.
704	*/
705
706	if (D.dqb_bsoftlimit==0)
707	D.dqb_bsoftlimit = D.dqb_bhardlimit;
708
709	/* Use softlimit to determine disk space. A user exceeding the quota is told
710	* that there's no space left. Writes might actually work for a bit if the
711	* hardlimit is set higher than softlimit. Effectively the disk becomes
712	* made of rubber latex and begins to expand to accommodate the user :-)
713	*/
714
715	if (D.dqb_bsoftlimit==0)
716	return(False);
717	*bsize = DEV_BSIZE;
718	*dsize = D.dqb_bsoftlimit;
719
720	if (D.dqb_curblocks > D.dqb_bsoftlimit) {
721	*dfree = 0;
722	*dsize = D.dqb_curblocks;
723	} else
724	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
725
726	DEBUG(5,("disk_quotas for path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",
727	path,(double)bsize,(double)dfree,(double)*dsize));
728
729	return(True);
730	}
731
732
733	#elif defined(OSF1)
734	#include <ufs/quota.h>
735
736	/****************************************************************************
737	try to get the disk space from disk quotas - OSF1 version
738	****************************************************************************/
739
740	BOOL disk_quotas(const char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
741	{
742	int r, save_errno;
743	struct dqblk D;
744	SMB_STRUCT_STAT S;
745	uid_t euser_id;
746
747	/*
748	* This code presumes that OSF1 will only
749	* give out quota info when the real uid
750	* matches the effective uid. JRA.
751	*/
752	euser_id = geteuid();
753	save_re_uid();
754	if (set_re_uid() != 0) return False;
755
756	r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D);
757	if (r) {
758	save_errno = errno;
759	}
760
761	restore_re_uid();
762
763	*bsize = DEV_BSIZE;
764
765	if (r)
766	{
767	if (save_errno == EDQUOT) /* disk quota exceeded */
768	{
769	*dfree = 0;
770	*dsize = D.dqb_curblocks;
771	return (True);
772	}
773	else
774	return (False);
775	}
776
777	/* If softlimit is zero, set it equal to hardlimit.
778	*/
779
780	if (D.dqb_bsoftlimit==0)
781	D.dqb_bsoftlimit = D.dqb_bhardlimit;
782
783	/* Use softlimit to determine disk space, except when it has been exceeded */
784
785	if (D.dqb_bsoftlimit==0)
786	return(False);
787
788	if ((D.dqb_curblocks>D.dqb_bsoftlimit)) {
789	*dfree = 0;
790	*dsize = D.dqb_curblocks;
791	} else {
792	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
793	*dsize = D.dqb_bsoftlimit;
794	}
795	return (True);
796	}
797
798	#elif defined (IRIX6)
799	/****************************************************************************
800	try to get the disk space from disk quotas (IRIX 6.2 version)
801	****************************************************************************/
802
803	#include <sys/quota.h>
804	#include <mntent.h>
805
806	BOOL disk_quotas(const char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
807	{
808	uid_t euser_id;
809	int r;
810	struct dqblk D;
811	struct fs_disk_quota F;
812	SMB_STRUCT_STAT S;
813	FILE *fp;
814	struct mntent *mnt;
815	SMB_DEV_T devno;
816	int found;
817
818	/* find the block device file */
819
820	if ( sys_stat(path, &S) == -1 ) {
821	return(False) ;
822	}
823
824	devno = S.st_dev ;
825
826	fp = setmntent(MOUNTED,"r");
827	found = False ;
828
829	while ((mnt = getmntent(fp))) {
830	if ( sys_stat(mnt->mnt_dir,&S) == -1 )
831	continue ;
832	if (S.st_dev == devno) {
833	found = True ;
834	break ;
835	}
836	}
837	endmntent(fp) ;
838
839	if (!found) {
840	return(False);
841	}
842
843	euser_id=geteuid();
844	become_root();
845
846	/* Use softlimit to determine disk space, except when it has been exceeded */
847
848	*bsize = 512;
849
850	if ( 0 == strcmp ( mnt->mnt_type, "efs" ))
851	{
852	r=quotactl (Q_GETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &D);
853
854	unbecome_root();
855
856	if (r==-1)
857	return(False);
858
859	/* Use softlimit to determine disk space, except when it has been exceeded */
860	if (
861	(D.dqb_bsoftlimit && D.dqb_curblocks>=D.dqb_bsoftlimit) \|\|
862	(D.dqb_bhardlimit && D.dqb_curblocks>=D.dqb_bhardlimit) \|\|
863	(D.dqb_fsoftlimit && D.dqb_curfiles>=D.dqb_fsoftlimit) \|\|
864	(D.dqb_fhardlimit && D.dqb_curfiles>=D.dqb_fhardlimit)
865	)
866	{
867	*dfree = 0;
868	*dsize = D.dqb_curblocks;
869	}
870	else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
871	{
872	return(False);
873	}
874	else
875	{
876	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
877	*dsize = D.dqb_bsoftlimit;
878	}
879
880	}
881	else if ( 0 == strcmp ( mnt->mnt_type, "xfs" ))
882	{
883	r=quotactl (Q_XGETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &F);
884
885	unbecome_root();
886
887	if (r==-1)
888	{
889	DEBUG(5, ("quotactl for uid=%u: %s", euser_id, strerror(errno)));
890	return(False);
891	}
892
893	/* No quota for this user. */
894	if (F.d_blk_softlimit==0 && F.d_blk_hardlimit==0)
895	{
896	return(False);
897	}
898
899	/* Use softlimit to determine disk space, except when it has been exceeded */
900	if (
901	(F.d_blk_softlimit && F.d_bcount>=F.d_blk_softlimit) \|\|
902	(F.d_blk_hardlimit && F.d_bcount>=F.d_blk_hardlimit) \|\|
903	(F.d_ino_softlimit && F.d_icount>=F.d_ino_softlimit) \|\|
904	(F.d_ino_hardlimit && F.d_icount>=F.d_ino_hardlimit)
905	)
906	{
907	*dfree = 0;
908	*dsize = F.d_bcount;
909	}
910	else
911	{
912	*dfree = (F.d_blk_softlimit - F.d_bcount);
913	*dsize = F.d_blk_softlimit ? F.d_blk_softlimit : F.d_blk_hardlimit;
914	}
915
916	}
917	else
918	{
919	unbecome_root();
920	return(False);
921	}
922
923	return (True);
924
925	}
926
927	#else
928
929	#if defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| defined(__DragonFly__)
930	#include <ufs/ufs/quota.h>
931	#include <machine/param.h>
932	#elif AIX
933	/* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
934	#include <jfs/quota.h>
935	/* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
936	#define dqb_curfiles dqb_curinodes
937	#define dqb_fhardlimit dqb_ihardlimit
938	#define dqb_fsoftlimit dqb_isoftlimit
939	#ifdef _AIXVERSION_530
940	#include <sys/statfs.h>
941	#include <sys/vmount.h>
942	#endif /* AIX 5.3 */
943	#else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
944	#include <sys/quota.h>
945	#include <devnm.h>
946	#endif
947
948	#if defined(__FreeBSD__) \|\| defined(__DragonFly__)
949
950	#include <rpc/rpc.h>
951	#include <rpc/types.h>
952	#include <rpcsvc/rquota.h>
953	#ifdef HAVE_RPC_NETTYPE_H
954	#include <rpc/nettype.h>
955	#endif
956	#include <rpc/xdr.h>
957
958	static int quotastat;
959
960	static int my_xdr_getquota_args(XDR xdrsp, struct getquota_args args)
961	{
962	if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
963	return(0);
964	if (!xdr_int(xdrsp, &args->gqa_uid))
965	return(0);
966	return (1);
967	}
968
969	static int my_xdr_getquota_rslt(XDR xdrsp, struct getquota_rslt gqr)
970	{
971	if (!xdr_int(xdrsp, &quotastat)) {
972	DEBUG(6,("nfs_quotas: Status bad or zero\n"));
973	return 0;
974	}
975	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
976	DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
977	return 0;
978	}
979	if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
980	DEBUG(6,("nfs_quotas: Active bad or zero\n"));
981	return 0;
982	}
983	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
984	DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
985	return 0;
986	}
987	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
988	DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
989	return 0;
990	}
991	if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
992	DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
993	return 0;
994	}
995	return (1);
996	}
997
998	/* Works on FreeBSD, too. :-) */
999	static BOOL nfs_quotas(char nfspath, uid_t euser_id, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
1000	{
1001	uid_t uid = euser_id;
1002	struct dqblk D;
1003	char *mnttype = nfspath;
1004	CLIENT *clnt;
1005	struct getquota_rslt gqr;
1006	struct getquota_args args;
1007	char cutstr, pathname, host, testpath;
1008	int len;
1009	static struct timeval timeout = {2,0};
1010	enum clnt_stat clnt_stat;
1011	BOOL ret = True;
1012
1013	bsize = dfree = *dsize = (SMB_BIG_UINT)0;
1014
1015	len=strcspn(mnttype, ":");
1016	pathname=strstr(mnttype, ":");
1017	cutstr = (char *) SMB_MALLOC(len+1);
1018	if (!cutstr)
1019	return False;
1020
1021	memset(cutstr, '\0', len+1);
1022	host = strncat(cutstr,mnttype, sizeof(char) * len );
1023	DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
1024	DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
1025	testpath=strchr_m(mnttype, ':');
1026	args.gqa_pathp = testpath+1;
1027	args.gqa_uid = uid;
1028
1029	DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
1030
1031	if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
1032	ret = False;
1033	goto out;
1034	}
1035
1036	clnt->cl_auth = authunix_create_default();
1037	DEBUG(9,("nfs_quotas: auth_success\n"));
1038
1039	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);
1040
1041	if (clnt_stat != RPC_SUCCESS) {
1042	DEBUG(9,("nfs_quotas: clnt_call fail\n"));
1043	ret = False;
1044	goto out;
1045	}
1046
1047	/*
1048	* quotastat returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
1049	* no quota set, and 3 if no permission to get the quota. If 0 or 3 return
1050	* something sensible.
1051	*/
1052
1053	switch ( quotastat ) {
1054	case 0:
1055	DEBUG(9,("nfs_quotas: Remote Quotas Failed! Error \"%i\" \n", quotastat ));
1056	ret = False;
1057	goto out;
1058
1059	case 1:
1060	DEBUG(9,("nfs_quotas: Good quota data\n"));
1061	D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
1062	D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
1063	D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
1064	break;
1065
1066	case 2:
1067	case 3:
1068	D.dqb_bsoftlimit = 1;
1069	D.dqb_curblocks = 1;
1070	DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", quotastat ));
1071	break;
1072
1073	default:
1074	DEBUG(9,("nfs_quotas: Remote Quotas Questionable! Error \"%i\" \n", quotastat ));
1075	break;
1076	}
1077
1078	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",
1079	quotastat,
1080	gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
1081	gqr.getquota_rslt_u.gqr_rquota.rq_active,
1082	gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
1083	gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
1084	gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
1085
1086	if (D.dqb_bsoftlimit == 0)
1087	D.dqb_bsoftlimit = D.dqb_bhardlimit;
1088	if (D.dqb_bsoftlimit == 0)
1089	return False;
1090
1091	*bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
1092	*dsize = D.dqb_bsoftlimit;
1093
1094	if (D.dqb_curblocks == D.dqb_curblocks == 1)
1095	*bsize = DEV_BSIZE;
1096
1097	if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1098	*dfree = 0;
1099	*dsize = D.dqb_curblocks;
1100	} else
1101	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1102
1103	out:
1104
1105	if (clnt) {
1106	if (clnt->cl_auth)
1107	auth_destroy(clnt->cl_auth);
1108	clnt_destroy(clnt);
1109	}
1110
1111	DEBUG(5,("nfs_quotas: For path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)bsize,(double)dfree,(double)*dsize));
1112
1113	SAFE_FREE(cutstr);
1114	DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
1115	return ret;
1116	}
1117
1118	#endif
1119
1120	/****************************************************************************
1121	try to get the disk space from disk quotas - default version
1122	****************************************************************************/
1123
1124	BOOL disk_quotas(const char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
1125	{
1126	int r;
1127	struct dqblk D;
1128	uid_t euser_id;
1129	#if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__)
1130	char dev_disk[256];
1131	SMB_STRUCT_STAT S;
1132
1133	/* find the block device file */
1134
1135	#ifdef HPUX
1136	/* Need to set the cache flag to 1 for HPUX. Seems
1137	* to have a significant performance boost when
1138	* lstat calls on /dev access this function.
1139	*/
1140	if ((sys_stat(path, &S)<0) \|\| (devnm(S_IFBLK, S.st_dev, dev_disk, 256, 1)<0))
1141	#else
1142	if ((sys_stat(path, &S)<0) \|\| (devnm(S_IFBLK, S.st_dev, dev_disk, 256, 0)<0))
1143	return (False);
1144	#endif /* ifdef HPUX */
1145
1146	#endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__) */
1147
1148	euser_id = geteuid();
1149
1150	#ifdef HPUX
1151	/* for HPUX, real uid must be same as euid to execute quotactl for euid */
1152	save_re_uid();
1153	if (set_re_uid() != 0) return False;
1154
1155	r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1156
1157	restore_re_uid();
1158	#else
1159	#if defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| defined(__DragonFly__)
1160	{
1161	/* FreeBSD patches from Marty Moll <martym@arbor.edu> */
1162	gid_t egrp_id;
1163	#if defined(__FreeBSD__) \|\| defined(__DragonFly__)
1164	SMB_DEV_T devno;
1165	struct statfs *mnts;
1166	SMB_STRUCT_STAT st;
1167	int mntsize, i;
1168
1169	if (sys_stat(path,&st) < 0)
1170	return False;
1171	devno = st.st_dev;
1172
1173	mntsize = getmntinfo(&mnts,MNT_NOWAIT);
1174	if (mntsize <= 0)
1175	return False;
1176
1177	for (i = 0; i < mntsize; i++) {
1178	if (sys_stat(mnts[i].f_mntonname,&st) < 0)
1179	return False;
1180	if (st.st_dev == devno)
1181	break;
1182	}
1183	if (i == mntsize)
1184	return False;
1185	#endif
1186
1187	become_root();
1188
1189	#if defined(__FreeBSD__) \|\| defined(__DragonFly__)
1190	if (strcmp(mnts[i].f_fstypename,"nfs") == 0) {
1191	BOOL retval;
1192	retval = nfs_quotas(mnts[i].f_mntfromname,euser_id,bsize,dfree,dsize);
1193	unbecome_root();
1194	return retval;
1195	}
1196	#endif
1197
1198	egrp_id = getegid();
1199	r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1200
1201	/* As FreeBSD has group quotas, if getting the user
1202	quota fails, try getting the group instead. */
1203	if (r) {
1204	r= quotactl(path,QCMD(Q_GETQUOTA,GRPQUOTA),egrp_id,(char *) &D);
1205	}
1206
1207	unbecome_root();
1208	}
1209	#elif defined(AIX)
1210	/* AIX has both USER and GROUP quotas:
1211	Get the USER quota (ohnielse@fysik.dtu.dk) */
1212	#ifdef _AIXVERSION_530
1213	{
1214	struct statfs statbuf;
1215	quota64_t user_quota;
1216	if (statfs(path,&statbuf) != 0)
1217	return False;
1218	if(statbuf.f_vfstype == MNT_J2)
1219	{
1220	/* For some reason we need to be root for jfs2 */
1221	become_root();
1222	r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
1223	unbecome_root();
1224	/* Copy results to old struct to let the following code work as before */
1225	D.dqb_curblocks = user_quota.bused;
1226	D.dqb_bsoftlimit = user_quota.bsoft;
1227	D.dqb_bhardlimit = user_quota.bhard;
1228	D.dqb_curfiles = user_quota.iused;
1229	D.dqb_fsoftlimit = user_quota.isoft;
1230	D.dqb_fhardlimit = user_quota.ihard;
1231	}
1232	else if(statbuf.f_vfstype == MNT_JFS)
1233	{
1234	#endif /* AIX 5.3 */
1235	save_re_uid();
1236	if (set_re_uid() != 0)
1237	return False;
1238	r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1239	restore_re_uid();
1240	#ifdef _AIXVERSION_530
1241	}
1242	else
1243	r = 1; /* Fail for other FS-types */
1244	}
1245	#endif /* AIX 5.3 */
1246	#else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1247	r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1248	#endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1249	#endif /* HPUX */
1250
1251	/* Use softlimit to determine disk space, except when it has been exceeded */
1252	#if defined(__FreeBSD__) \|\| defined(__OpenBSD__) \|\| defined(__DragonFly__)
1253	*bsize = DEV_BSIZE;
1254	#else /* !__FreeBSD__ && !__OpenBSD__ && !__DragonFly__ */
1255	*bsize = 1024;
1256	#endif /!__FreeBSD__ && !__OpenBSD__ && !__DragonFly__ /
1257
1258	if (r)
1259	{
1260	if (errno == EDQUOT)
1261	{
1262	*dfree =0;
1263	*dsize =D.dqb_curblocks;
1264	return (True);
1265	}
1266	else return(False);
1267	}
1268
1269	/* If softlimit is zero, set it equal to hardlimit.
1270	*/
1271
1272	if (D.dqb_bsoftlimit==0)
1273	D.dqb_bsoftlimit = D.dqb_bhardlimit;
1274
1275	if (D.dqb_bsoftlimit==0)
1276	return(False);
1277	/* Use softlimit to determine disk space, except when it has been exceeded */
1278	if ((D.dqb_curblocks>D.dqb_bsoftlimit)
1279	#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
1280	\|\|((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
1281	#endif
1282	) {
1283	*dfree = 0;
1284	*dsize = D.dqb_curblocks;
1285	}
1286	else {
1287	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1288	*dsize = D.dqb_bsoftlimit;
1289	}
1290	return (True);
1291	}
1292
1293	#endif
1294
1295	#if defined(VXFS_QUOTA)
1296
1297	/****************************************************************************
1298	Try to get the disk space from Veritas disk quotas.
1299	David Lee <T.D.Lee@durham.ac.uk> August 1999.
1300
1301	Background assumptions:
1302	Potentially under many Operating Systems. Initially Solaris 2.
1303
1304	My guess is that Veritas is largely, though not entirely,
1305	independent of OS. So I have separated it out.
1306
1307	There may be some details. For example, OS-specific "include" files.
1308
1309	It is understood that HPUX 10 somehow gets Veritas quotas without
1310	any special effort; if so, this routine need not be compiled in.
1311	Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
1312
1313	Warning:
1314	It is understood that Veritas do not publicly support this ioctl interface.
1315	Rather their preference would be for the user (us) to call the native
1316	OS and then for the OS itself to call through to the VxFS filesystem.
1317	Presumably HPUX 10, see above, does this.
1318
1319	Hints for porting:
1320	Add your OS to "IFLIST" below.
1321	Get it to compile successfully:
1322	Almost certainly "include"s require attention: see SUNOS5.
1323	In the main code above, arrange for it to be called: see SUNOS5.
1324	Test!
1325
1326	****************************************************************************/
1327
1328	/* "IFLIST"
1329	* This "if" is a list of ports:
1330	* if defined(OS1) \|\| defined(OS2) \|\| ...
1331	*/
1332	#if defined(SUNOS5)
1333
1334	#if defined(SUNOS5)
1335	#include <sys/fs/vx_solaris.h>
1336	#endif
1337	#include <sys/fs/vx_machdep.h>
1338	#include <sys/fs/vx_layout.h>
1339	#include <sys/fs/vx_quota.h>
1340	#include <sys/fs/vx_aioctl.h>
1341	#include <sys/fs/vx_ioctl.h>
1342
1343	BOOL disk_quotas_vxfs(const pstring name, char path, SMB_BIG_UINT bsize, SMB_BIG_UINT dfree, SMB_BIG_UINT dsize)
1344	{
1345	uid_t user_id, euser_id;
1346	int ret;
1347	struct vx_dqblk D;
1348	struct vx_quotctl quotabuf;
1349	struct vx_genioctl genbuf;
1350	pstring qfname;
1351	int file;
1352
1353	/*
1354	* "name" may or may not include a trailing "/quotas".
1355	* Arranging consistency of calling here in "quotas.c" may not be easy and
1356	* it might be easier to examine and adjust it here.
1357	* Fortunately, VxFS seems not to mind at present.
1358	*/
1359	pstrcpy(qfname, name) ;
1360	/* pstrcat(qfname, "/quotas") ; / / possibly examine and adjust "name" */
1361
1362	euser_id = geteuid();
1363	set_effective_uid(0);
1364
1365	DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
1366	if((file=sys_open(qfname, O_RDONLY,0))<0) {
1367	set_effective_uid(euser_id);
1368	return(False);
1369	}
1370	genbuf.ioc_cmd = VX_QUOTACTL;
1371	genbuf.ioc_up = (void *) &quotabuf;
1372
1373	quotabuf.cmd = VX_GETQUOTA;
1374	quotabuf.uid = euser_id;
1375	quotabuf.addr = (caddr_t) &D;
1376	ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
1377	close(file);
1378
1379	set_effective_uid(euser_id);
1380
1381	if (ret < 0) {
1382	DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
1383	return(False);
1384	}
1385
1386	/* If softlimit is zero, set it equal to hardlimit.
1387	*/
1388
1389	if (D.dqb_bsoftlimit==0)
1390	D.dqb_bsoftlimit = D.dqb_bhardlimit;
1391
1392	/* Use softlimit to determine disk space. A user exceeding the quota is told
1393	* that there's no space left. Writes might actually work for a bit if the
1394	* hardlimit is set higher than softlimit. Effectively the disk becomes
1395	* made of rubber latex and begins to expand to accommodate the user :-)
1396	*/
1397	DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
1398	path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
1399	D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
1400
1401	if (D.dqb_bsoftlimit==0)
1402	return(False);
1403	*bsize = DEV_BSIZE;
1404	*dsize = D.dqb_bsoftlimit;
1405
1406	if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1407	*dfree = 0;
1408	*dsize = D.dqb_curblocks;
1409	} else
1410	*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1411
1412	DEBUG(5,("disk_quotas for path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",
1413	path,(double)bsize,(double)dfree,(double)*dsize));
1414
1415	return(True);
1416	}
1417
1418	#endif /* SUNOS5 \|\| ... */
1419
1420	#endif /* VXFS_QUOTA */
1421
1422	#else /* WITH_QUOTAS */
1423
1424	BOOL disk_quotas(const char path,SMB_BIG_UINT bsize,SMB_BIG_UINT dfree,SMB_BIG_UINT dsize)
1425	{
1426	(bsize) = 512; / This value should be ignored */
1427
1428	/* And just to be sure we set some values that hopefully */
1429	/* will be larger that any possible real-world value */
1430	(*dfree) = (SMB_BIG_UINT)-1;
1431	(*dsize) = (SMB_BIG_UINT)-1;
1432
1433	/* As we have select not to use quotas, allways fail */
1434	return False;
1435	}
1436	#endif /* WITH_QUOTAS */
1437
1438	#else /* HAVE_SYS_QUOTAS */
1439	/* wrapper to the new sys_quota interface
1440	this file should be removed later
1441	*/
1442	BOOL disk_quotas(const char path,SMB_BIG_UINT bsize,SMB_BIG_UINT dfree,SMB_BIG_UINT dsize)
1443	{
1444	int r;
1445	SMB_DISK_QUOTA D;
1446	unid_t id;
1447
1448	id.uid = geteuid();
1449
1450	ZERO_STRUCT(D);
1451	r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
1452
1453	/* Use softlimit to determine disk space, except when it has been exceeded */
1454	*bsize = D.bsize;
1455	if (r == -1) {
1456	if (errno == EDQUOT) {
1457	*dfree =0;
1458	*dsize =D.curblocks;
1459	return (True);
1460	} else {
1461	goto try_group_quota;
1462	}
1463	}
1464
1465	/* Use softlimit to determine disk space, except when it has been exceeded */
1466	if (
1467	(D.softlimit && D.curblocks >= D.softlimit) \|\|
1468	(D.hardlimit && D.curblocks >= D.hardlimit) \|\|
1469	(D.isoftlimit && D.curinodes >= D.isoftlimit) \|\|
1470	(D.ihardlimit && D.curinodes>=D.ihardlimit)
1471	) {
1472	*dfree = 0;
1473	*dsize = D.curblocks;
1474	} else if (D.softlimit==0 && D.hardlimit==0) {
1475	goto try_group_quota;
1476	} else {
1477	if (D.softlimit == 0)
1478	D.softlimit = D.hardlimit;
1479	*dfree = D.softlimit - D.curblocks;
1480	*dsize = D.softlimit;
1481	}
1482
1483	return True;
1484
1485	try_group_quota:
1486	id.gid = getegid();
1487
1488	ZERO_STRUCT(D);
1489	r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
1490
1491	/* Use softlimit to determine disk space, except when it has been exceeded */
1492	*bsize = D.bsize;
1493	if (r == -1) {
1494	if (errno == EDQUOT) {
1495	*dfree =0;
1496	*dsize =D.curblocks;
1497	return (True);
1498	} else {
1499	return False;
1500	}
1501	}
1502
1503	/* Use softlimit to determine disk space, except when it has been exceeded */
1504	if (
1505	(D.softlimit && D.curblocks >= D.softlimit) \|\|
1506	(D.hardlimit && D.curblocks >= D.hardlimit) \|\|
1507	(D.isoftlimit && D.curinodes >= D.isoftlimit) \|\|
1508	(D.ihardlimit && D.curinodes>=D.ihardlimit)
1509	) {
1510	*dfree = 0;
1511	*dsize = D.curblocks;
1512	} else if (D.softlimit==0 && D.hardlimit==0) {
1513	return False;
1514	} else {
1515	if (D.softlimit == 0)
1516	D.softlimit = D.hardlimit;
1517	*dfree = D.softlimit - D.curblocks;
1518	*dsize = D.softlimit;
1519	}
1520
1521	return (True);
1522	}
1523	#endif /* HAVE_SYS_QUOTAS */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: