Ok - this is the 64 bit widening check in. It changes the configure
[ira/wip.git] / source3 / smbd / quotas.c
1 #ifdef QUOTAS
2 /* 
3    Unix SMB/Netbios implementation.
4    Version 1.9.
5    support for quotas
6    Copyright (C) Andrew Tridgell 1992-1998
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23
24 /* 
25  * This is one of the most system dependent parts of Samba, and its
26  * done a litle differently. Each system has its own way of doing 
27  * things :-(
28  */
29
30 #include "includes.h"
31
32 extern int DEBUGLEVEL;
33
34 #ifdef LINUX
35
36 #include <sys/types.h>
37 #include <asm/types.h>
38 #include <sys/quota.h>
39
40 #include <mntent.h>
41 #include <linux/unistd.h>
42
43 _syscall4(int, quotactl, int, cmd, const char *, special, int, id, caddr_t, addr);
44
45 /****************************************************************************
46 try to get the disk space from disk quotas (LINUX version)
47 ****************************************************************************/
48
49 BOOL disk_quotas(char *path, int *bsize, int *dfree, int *dsize)
50 {
51   uid_t euser_id;
52   int r;
53   struct dqblk D;
54   SMB_STRUCT_STAT S;
55   FILE *fp;
56   struct mntent *mnt;
57   SMB_DEV_T devno;
58   int found;
59   
60   /* find the block device file */
61   
62   if ( sys_stat(path, &S) == -1 ) {
63     return(False) ;
64   }
65
66   devno = S.st_dev ;
67   
68   fp = setmntent(MOUNTED,"r");
69   found = False ;
70   
71   while ((mnt = getmntent(fp))) {
72     if ( sys_stat(mnt->mnt_dir,&S) == -1 )
73       continue ;
74     if (S.st_dev == devno) {
75       found = True ;
76       break ;
77     }
78   }
79   endmntent(fp) ;
80   
81   if (!found) {
82       return(False);
83     }
84
85   euser_id=geteuid();
86   seteuid(0);  
87   r=quotactl(QCMD(Q_GETQUOTA,USRQUOTA), mnt->mnt_fsname, euser_id, (caddr_t)&D);
88       seteuid(euser_id);
89
90   /* Use softlimit to determine disk space, except when it has been exceeded */
91   *bsize = 1024;
92   if (r)
93     {
94       if (errno == EDQUOT) 
95        {
96          *dfree =0;
97          *dsize =D.dqb_curblocks;
98          return (True);
99     }
100       else return(False);
101   }
102   /* Use softlimit to determine disk space, except when it has been exceeded */
103   if (
104       (D.dqb_bsoftlimit && D.dqb_curblocks>=D.dqb_bsoftlimit) ||
105       (D.dqb_bhardlimit && D.dqb_curblocks>=D.dqb_bhardlimit) ||
106       (D.dqb_isoftlimit && D.dqb_curinodes>=D.dqb_isoftlimit) ||
107       (D.dqb_ihardlimit && D.dqb_curinodes>=D.dqb_ihardlimit)
108      )
109     {
110       *dfree = 0;
111       *dsize = D.dqb_curblocks;
112     }
113   else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
114     {
115       return(False);
116     }
117   else {
118     if (D.dqb_bsoftlimit == 0)
119       D.dqb_bsoftlimit = D.dqb_bhardlimit;
120     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
121     *dsize = D.dqb_bsoftlimit;
122   }
123   return (True);
124 }
125
126 #elif defined(CRAY)
127
128 #include <sys/quota.h>
129 #include <mntent.h>
130
131 /****************************************************************************
132 try to get the disk space from disk quotas (CRAY VERSION)
133 ****************************************************************************/
134 BOOL disk_quotas(char *path, int *bsize, int *dfree, int *dsize)
135 {
136   struct mntent *mnt;
137   FILE *fd;
138   SMB_STRUCT_STAT sbuf;
139   SMB_DEV_T devno ;
140   static SMB_DEV_T devno_cached = 0 ;
141   static pstring name;
142   struct q_request request ;
143   struct qf_header header ;
144   static int quota_default = 0 ;
145   int found ;
146   
147   if ( sys_stat(path,&sbuf) == -1 )
148     return(False) ;
149   
150   devno = sbuf.st_dev ;
151   
152   if ( devno != devno_cached ) {
153     
154     devno_cached = devno ;
155     
156     if ((fd = setmntent(KMTAB)) == NULL)
157       return(False) ;
158     
159     found = False ;
160     
161     while ((mnt = getmntent(fd)) != NULL) {
162       
163       if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
164         continue ;
165       
166       if (sbuf.st_dev == devno) {
167         
168         found = True ;
169         break ;
170         
171       }
172       
173     }
174     
175     pstrcpy(name,mnt->mnt_dir) ;
176     endmntent(fd) ;
177     
178     if ( ! found )
179       return(False) ;
180   }
181   
182   request.qf_magic = QF_MAGIC ;
183   request.qf_entry.id = geteuid() ;
184   
185   if (quotactl(name, Q_GETQUOTA, &request) == -1)
186     return(False) ;
187   
188   if ( ! request.user )
189     return(False) ;
190   
191   if ( request.qf_entry.user_q.f_quota == QFV_DEFAULT ) {
192     
193     if ( ! quota_default ) {
194       
195       if ( quotactl(name, Q_GETHEADER, &header) == -1 )
196         return(False) ;
197       else
198         quota_default = header.user_h.def_fq ;
199     }
200     
201     *dfree = quota_default ;
202     
203   }else if ( request.qf_entry.user_q.f_quota == QFV_PREVENT ) {
204     
205     *dfree = 0 ;
206     
207   }else{
208     
209     *dfree = request.qf_entry.user_q.f_quota ;
210     
211   }
212   
213   *dsize = request.qf_entry.user_q.f_use ;
214   
215   if ( *dfree )
216     *dfree -= *dsize ;
217   
218   if ( *dfree < 0 )
219     *dfree = 0 ;
220   
221   *bsize = 4096 ;  /* Cray blocksize */
222   
223   return(True) ;
224   
225 }
226
227
228 #elif defined(SUNOS5) || defined(SUNOS4)
229
230 #include <fcntl.h>
231 #if defined(SUNOS5)
232 #include <sys/fs/ufs_quota.h>
233 #include <sys/mnttab.h>
234 #else /* defined(SUNOS4) */
235 #include <ufs/quota.h>
236 #include <mntent.h>
237 #endif
238
239 /****************************************************************************
240 try to get the disk space from disk quotas (solaris 2 version)
241 ****************************************************************************/
242 /* Quota code by Peter Urbanec (amiga@cse.unsw.edu.au) */
243 BOOL disk_quotas(char *path, int *bsize, int *dfree, int *dsize)
244 {
245   uid_t user_id, euser_id;
246   int ret;
247   struct dqblk D;
248 #if defined(SUNOS5)
249   struct quotctl command;
250   int file;
251   struct mnttab mnt;
252   static pstring name;
253 #else
254   struct mntent *mnt;
255   static pstring name;
256 #endif
257   FILE *fd;
258   SMB_STRUCT_STAT sbuf;
259   SMB_DEV_T devno ;
260   static SMB_DEV_T devno_cached = 0 ;
261   int found ;
262   
263   if ( sys_stat(path,&sbuf) == -1 )
264     return(False) ;
265   
266   devno = sbuf.st_dev ;
267   DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%o\n", path,devno));
268   if ( devno != devno_cached ) {
269     devno_cached = devno ;
270 #if defined(SUNOS5)
271     if ((fd = fopen(MNTTAB, "r")) == NULL)
272       return(False) ;
273     
274     found = False ;
275     while (getmntent(fd, &mnt) == 0) {
276       if ( sys_stat(mnt.mnt_mountp,&sbuf) == -1 )
277         continue ;
278       DEBUG(5,("disk_quotas: testing \"%s\" devno=%o\n", 
279                mnt.mnt_mountp,sbuf.st_dev));
280       if (sbuf.st_dev == devno) {
281         found = True ;
282         break ;
283       }
284     }
285     
286     pstrcpy(name,mnt.mnt_mountp) ;
287     pstrcat(name,"/quotas") ;
288     fclose(fd) ;
289 #else
290     if ((fd = setmntent(MOUNTED, "r")) == NULL)
291       return(False) ;
292     
293     found = False ;
294     while ((mnt = getmntent(fd)) != NULL) {
295       if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
296         continue ;
297       DEBUG(5,("disk_quotas: testing \"%s\" devno=%o\n", 
298                mnt->mnt_dir,sbuf.st_dev));
299       if (sbuf.st_dev == devno) {
300         found = True ;
301         break ;
302       }
303     }
304     
305     pstrcpy(name,mnt->mnt_fsname) ;
306     endmntent(fd) ;
307 #endif
308     
309     if ( ! found )
310       return(False) ;
311   }
312
313   euser_id = geteuid();
314   user_id = getuid();
315
316   setuid(0);  /* Solaris seems to want to give info only to super-user */
317   seteuid(0);
318
319 #if defined(SUNOS5)
320   DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
321   if((file=open(name, O_RDONLY))<0) {
322     setuid(user_id);  /* Restore the original UID status */
323     seteuid(euser_id);
324     return(False);
325   }
326   command.op = Q_GETQUOTA;
327   command.uid = euser_id;
328   command.addr = (caddr_t) &D;
329   ret = ioctl(file, Q_QUOTACTL, &command);
330   close(file);
331 #else
332   DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
333   ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
334 #endif
335
336   setuid(user_id); /* Restore the original uid status. */
337   seteuid(euser_id);
338
339   if (ret < 0) {
340     DEBUG(2,("disk_quotas ioctl (Solaris) failed\n"));
341     return(False);
342   }
343
344
345   /* Use softlimit to determine disk space. A user exceeding the quota is told
346    * that there's no space left. Writes might actually work for a bit if the
347    * hardlimit is set higher than softlimit. Effectively the disk becomes
348    * made of rubber latex and begins to expand to accommodate the user :-)
349    */
350
351   if (D.dqb_bsoftlimit==0)
352     return(False);
353   *bsize = 512;
354   *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
355   *dsize = D.dqb_bsoftlimit;
356   if(*dfree < 0)
357     {
358      *dfree = 0;
359      *dsize = D.dqb_curblocks;
360     }
361       
362 DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %d, dfree %d, dsize %d\n",
363          path,*bsize,*dfree,*dsize));
364
365       return(True);
366 }
367
368
369 #elif defined(OSF1)
370 #include <ufs/quota.h>
371
372 /****************************************************************************
373 try to get the disk space from disk quotas - OFS1 version
374 ****************************************************************************/
375 BOOL disk_quotas(char *path, int *bsize, int *dfree, int *dsize)
376 {
377   uid_t user_id, euser_id;
378   int r, save_errno;
379   struct dqblk D;
380   SMB_STRUCT_STAT S;
381
382   euser_id = geteuid();
383   user_id = getuid();
384
385   setreuid(euser_id, -1);
386   r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D);
387   if (r)
388      save_errno = errno;
389
390   if (setreuid(user_id, -1) == -1)
391     DEBUG(5,("Unable to reset uid to %d\n", user_id));
392
393   *bsize = DEV_BSIZE;
394
395   if (r)
396   {
397       if (save_errno == EDQUOT)   // disk quota exceeded
398       {
399          *dfree = 0;
400          *dsize = D.dqb_curblocks;
401          return (True);
402       }
403       else
404          return (False);  
405   }
406
407   /* Use softlimit to determine disk space, except when it has been exceeded */
408
409   if (D.dqb_bsoftlimit==0)
410     return(False);
411
412   if ((D.dqb_curblocks>D.dqb_bsoftlimit)) {
413     *dfree = 0;
414     *dsize = D.dqb_curblocks;
415   } else {
416     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
417     *dsize = D.dqb_bsoftlimit;
418   }
419   return (True);
420 }
421
422 #elif defined (SGI6)
423 /****************************************************************************
424 try to get the disk space from disk quotas (IRIX 6.2 version)
425 ****************************************************************************/
426
427 #include <sys/quota.h>
428 #include <mntent.h>
429
430 BOOL disk_quotas(char *path, int *bsize, int *dfree, int *dsize)
431 {
432   uid_t euser_id;
433   int r;
434   struct dqblk D;
435   struct fs_disk_quota        F;
436   SMB_STRUCT_STAT S;
437   FILE *fp;
438   struct mntent *mnt;
439   SMB_DEV_T devno;
440   int found;
441   
442   /* find the block device file */
443   
444   if ( sys_stat(path, &S) == -1 ) {
445     return(False) ;
446   }
447
448   devno = S.st_dev ;
449   
450   fp = setmntent(MOUNTED,"r");
451   found = False ;
452   
453   while ((mnt = getmntent(fp))) {
454     if ( sys_stat(mnt->mnt_dir,&S) == -1 )
455       continue ;
456     if (S.st_dev == devno) {
457       found = True ;
458       break ;
459     }
460   }
461   endmntent(fp) ;
462   
463   if (!found) {
464     return(False);
465   }
466
467   euser_id=geteuid();
468   seteuid(0);  
469
470   /* Use softlimit to determine disk space, except when it has been exceeded */
471
472   *bsize = 512;
473
474   if ( 0 == strcmp ( mnt->mnt_type, "efs" ))
475   {
476     r=quotactl (Q_GETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &D);
477
478     seteuid(euser_id); /* Restore the original uid status. */
479
480     if (r==-1)
481       return(False);
482         
483     /* Use softlimit to determine disk space, except when it has been exceeded */
484     if (
485         (D.dqb_bsoftlimit && D.dqb_curblocks>=D.dqb_bsoftlimit) ||
486         (D.dqb_bhardlimit && D.dqb_curblocks>=D.dqb_bhardlimit) ||
487         (D.dqb_fsoftlimit && D.dqb_curfiles>=D.dqb_fsoftlimit) ||
488         (D.dqb_fhardlimit && D.dqb_curfiles>=D.dqb_fhardlimit)
489        )
490     {
491       *dfree = 0;
492       *dsize = D.dqb_curblocks;
493     }
494     else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
495     {
496       return(False);
497     }
498     else 
499     {
500       *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
501       *dsize = D.dqb_bsoftlimit;
502     }
503
504   }
505   else if ( 0 == strcmp ( mnt->mnt_type, "xfs" ))
506   {
507     r=quotactl (Q_XGETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &F);
508
509     seteuid(euser_id); /* Restore the original uid status. */
510
511     if (r==-1)
512       return(False);
513         
514     /* Use softlimit to determine disk space, except when it has been exceeded */
515     if (
516         (F.d_blk_softlimit && F.d_bcount>=F.d_blk_softlimit) ||
517         (F.d_blk_hardlimit && F.d_bcount>=F.d_blk_hardlimit) ||
518         (F.d_ino_softlimit && F.d_icount>=F.d_ino_softlimit) ||
519         (F.d_ino_hardlimit && F.d_icount>=F.d_ino_hardlimit)
520        )
521     {
522       /*
523        * Fixme!: these are __uint64_t, this may truncate values
524        */
525       *dfree = 0;
526       *dsize = (int) F.d_bcount;
527     }
528     else if (F.d_blk_softlimit==0 && F.d_blk_hardlimit==0)
529     {
530       return(False);
531     }
532     else 
533     {
534       *dfree = (int)(F.d_blk_softlimit - F.d_bcount);
535       *dsize = (int)F.d_blk_softlimit;
536     }
537
538   }
539   else
540   {
541     seteuid(euser_id); /* Restore the original uid status. */
542     return(False);
543   }
544
545   return (True);
546
547 }
548
549 #else
550
551 #if    defined(__FreeBSD__) || defined(__OpenBSD__)
552 #include <ufs/ufs/quota.h>
553 #include <machine/param.h>
554 #elif         AIX
555 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
556 #include <jfs/quota.h>
557 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
558 #define dqb_curfiles dqb_curinodes
559 #define dqb_fhardlimit dqb_ihardlimit
560 #define dqb_fsoftlimit dqb_isoftlimit
561 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
562 #include <sys/quota.h>
563 #include <devnm.h>
564 #endif
565
566 /****************************************************************************
567 try to get the disk space from disk quotas - default version
568 ****************************************************************************/
569 BOOL disk_quotas(char *path, int *bsize, int *dfree, int *dsize)
570 {
571   uid_t euser_id;
572   int r;
573   struct dqblk D;
574 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__)
575   char dev_disk[256];
576   SMB_STRUCT_STAT S;
577   /* find the block device file */
578   if ((sys_stat(path, &S)<0) ||
579       (devnm(S_IFBLK, S.st_dev, dev_disk, 256, 0)<0)) return (False);
580 #endif
581
582   euser_id = geteuid();
583
584 #ifdef HPUX
585   {
586     uid_t user_id;
587
588     /* for HPUX, real uid must be same as euid to execute quotactl for euid */
589     user_id = getuid();
590     setresuid(euser_id,-1,-1);
591     r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
592     if (setresuid(user_id,-1,-1))
593       DEBUG(5,("Unable to reset uid to %d\n", user_id));
594   }
595 #else 
596 #if defined(__FreeBSD__) || defined(__OpenBSD__)
597   {
598     /* FreeBSD patches from Marty Moll <martym@arbor.edu> */
599     uid_t user_id;
600     gid_t egrp_id;
601  
602     /* Need to be root to get quotas in FreeBSD */
603     user_id = getuid();
604     egrp_id = getegid();
605     setuid(0);
606     seteuid(0);
607     r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
608
609     /* As FreeBSD has group quotas, if getting the user
610        quota fails, try getting the group instead. */
611     if (r)
612       r= quotactl(path,QCMD(Q_GETQUOTA,GRPQUOTA),egrp_id,(char *) &D);
613     setuid(user_id);
614     seteuid(euser_id);
615   }
616 #elif defined(AIX)
617   /* AIX has both USER and GROUP quotas: 
618      Get the USER quota (ohnielse@fysik.dtu.dk) */
619   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
620 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
621   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
622 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
623 #endif /* HAVE_SETRES */
624
625   /* Use softlimit to determine disk space, except when it has been exceeded */
626 #if defined(__FreeBSD__) || defined(__OpenBSD__)
627   *bsize = DEV_BSIZE;
628 #else /* !__FreeBSD__ && !__OpenBSD__ */
629   *bsize = 1024;
630 #endif /*!__FreeBSD__ && !__OpenBSD__ */
631
632   if (r)
633     {
634       if (errno == EDQUOT) 
635         {
636           *dfree =0;
637           *dsize =D.dqb_curblocks;
638           return (True);
639         }
640       else return(False);
641     }
642   if (D.dqb_bsoftlimit==0)
643     return(False);
644   /* Use softlimit to determine disk space, except when it has been exceeded */
645   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
646 #if !defined(__FreeBSD__) && !defined(__OpenBSD__)
647 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
648 #endif
649     ) {
650       *dfree = 0;
651       *dsize = D.dqb_curblocks;
652     }
653   else {
654     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
655     *dsize = D.dqb_bsoftlimit;
656   }
657   return (True);
658 }
659
660 #endif
661
662 #else
663 /* this keeps fussy compilers happy */
664  void quotas_dummy(void) {}
665 #endif /* QUOTAS */
666