source/smbd/quotas.c

   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         euser_id = geteuid();
 210         egrp_id = getegid();
 211
 212         /* find the block device file */
 213
 214         if ( sys_stat(path, &S) == -1 )
 215                 return(False) ;
 216
 217         devno = S.st_dev ;
 218
 219         fp = setmntent(MOUNTED,"r");
 220         found = False ;
 221
 222         while ((mnt = getmntent(fp))) {
 223                 if ( sys_stat(mnt->mnt_dir,&S) == -1 )
 224                         continue ;
 225
 226                 if (S.st_dev == devno) {
 227                         found = True ;
 228                         break;
 229                 }
 230         }
 231
 232         endmntent(fp) ;
 233
 234         if (!found)
 235                 return(False);
 236
 237         save_re_uid();
 238         set_effective_uid(0);
 239
 240         if (strcmp(mnt->mnt_type, "xfs")==0) {
 241                 r=get_smb_linux_xfs_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
 242         } else {
 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);
 248                 }
 249         }
 250
 251         restore_re_uid();
 252
 253         /* Use softlimit to determine disk space, except when it has been exceeded */
 254         *bsize = D.bsize;
 255         if (r == -1) {
 256                 if (errno == EDQUOT) {
 257                         *dfree =0;
 258                         *dsize =D.curblocks;
 259                         return (True);
 260                 } else {
 261                         return(False);
 262                 }
 263         }
 264
 265         /* Use softlimit to determine disk space, except when it has been exceeded */
 266         if (
 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)
 271         ) {
 272                 *dfree = 0;
 273                 *dsize = D.curblocks;
 274         } else if (D.softlimit==0 && D.hardlimit==0) {
 275                 return(False);
 276         } else {
 277                 if (D.softlimit == 0)
 278                         D.softlimit = D.hardlimit;
 279                 *dfree = D.softlimit - D.curblocks;
 280                 *dsize = D.softlimit;
 281         }
 282
 283         return (True);
 284 }
 285
 286 #elif defined(CRAY)
 287
 288 #include <sys/quota.h>
 289 #include <mntent.h>
 290
 291 /****************************************************************************
 292 try to get the disk space from disk quotas (CRAY VERSION)
 293 ****************************************************************************/
 294
 295 BOOL disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 296 {
 297   struct mntent *mnt;
 298   FILE *fd;
 299   SMB_STRUCT_STAT sbuf;
 300   SMB_DEV_T devno ;
 301   static SMB_DEV_T devno_cached = 0 ;
 302   static pstring name;
 303   struct q_request request ;
 304   struct qf_header header ;
 305   static int quota_default = 0 ;
 306   int found ;
 307
 308   if ( sys_stat(path,&sbuf) == -1 )
 309     return(False) ;
 310
 311   devno = sbuf.st_dev ;
 312
 313   if ( devno != devno_cached ) {
 314
 315     devno_cached = devno ;
 316
 317     if ((fd = setmntent(KMTAB)) == NULL)
 318       return(False) ;
 319
 320     found = False ;
 321
 322     while ((mnt = getmntent(fd)) != NULL) {
 323
 324       if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
 325         continue ;
 326
 327       if (sbuf.st_dev == devno) {
 328
 329         found = True ;
 330         break ;
 331
 332       }
 333
 334     }
 335
 336     pstrcpy(name,mnt->mnt_dir) ;
 337     endmntent(fd) ;
 338
 339     if ( ! found )
 340       return(False) ;
 341   }
 342
 343   request.qf_magic = QF_MAGIC ;
 344   request.qf_entry.id = geteuid() ;
 345
 346   if (quotactl(name, Q_GETQUOTA, &request) == -1)
 347     return(False) ;
 348
 349   if ( ! request.user )
 350     return(False) ;
 351
 352   if ( request.qf_entry.user_q.f_quota == QFV_DEFAULT ) {
 353
 354     if ( ! quota_default ) {
 355
 356       if ( quotactl(name, Q_GETHEADER, &header) == -1 )
 357         return(False) ;
 358       else
 359         quota_default = header.user_h.def_fq ;
 360     }
 361
 362     *dfree = quota_default ;
 363
 364   }else if ( request.qf_entry.user_q.f_quota == QFV_PREVENT ) {
 365
 366     *dfree = 0 ;
 367
 368   }else{
 369
 370     *dfree = request.qf_entry.user_q.f_quota ;
 371
 372   }
 373
 374   *dsize = request.qf_entry.user_q.f_use ;
 375
 376   if ( *dfree < *dsize )
 377     *dfree = 0 ;
 378   else
 379     *dfree -= *dsize ;
 380
 381   *bsize = 4096 ;  /* Cray blocksize */
 382
 383   return(True) ;
 384
 385 }
 386
 387
 388 #elif defined(SUNOS5) || defined(SUNOS4)
 389
 390 #include <fcntl.h>
 391 #include <sys/param.h>
 392 #if defined(SUNOS5)
 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>
 398 #include <mntent.h>
 399 #endif
 400
 401 #if defined(SUNOS5)
 402
 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 ****************************************************************************/
 408
 409 #include <rpc/rpc.h>
 410 #include <rpc/types.h>
 411 #include <rpcsvc/rquota.h>
 412 #include <rpc/nettype.h>
 413 #include <rpc/xdr.h>
 414
 415 static int quotastat;
 416
 417 static int xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
 418 {
 419         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
 420                 return(0);
 421         if (!xdr_int(xdrsp, &args->gqa_uid))
 422                 return(0);
 423         return (1);
 424 }
 425
 426 static int xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
 427 {
 428         if (!xdr_int(xdrsp, &quotastat)) {
 429                 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
 430                 return 0;
 431         }
 432         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
 433                 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
 434                 return 0;
 435         }
 436         if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
 437                 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
 438                 return 0;
 439         }
 440         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
 441                 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
 442                 return 0;
 443         }
 444         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
 445                 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
 446                 return 0;
 447         }
 448         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
 449                 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
 450                 return 0;
 451         }
 452         return (1);
 453 }
 454
 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)
 457 {
 458         uid_t uid = euser_id;
 459         struct dqblk D;
 460         char *mnttype = nfspath;
 461         CLIENT *clnt;
 462         struct getquota_rslt gqr;
 463         struct getquota_args args;
 464         char *cutstr, *pathname, *host, *testpath;
 465         int len;
 466         static struct timeval timeout = {2,0};
 467         enum clnt_stat clnt_stat;
 468         BOOL ret = True;
 469
 470         *bsize = *dfree = *dsize = (SMB_BIG_UINT)0;
 471
 472         len=strcspn(mnttype, ":");
 473         pathname=strstr(mnttype, ":");
 474         cutstr = (char *) malloc(len+1);
 475         if (!cutstr)
 476                 return False;
 477
 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;
 484         args.gqa_uid = uid;
 485
 486         DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
 487
 488         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
 489                 ret = False;
 490                 goto out;
 491         }
 492
 493         clnt->cl_auth = authunix_create_default();
 494         DEBUG(9,("nfs_quotas: auth_success\n"));
 495
 496         clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, xdr_getquota_args, (caddr_t)&args, xdr_getquota_rslt, (caddr_t)&gqr, timeout);
 497
 498         if (clnt_stat != RPC_SUCCESS) {
 499                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
 500                 ret = False;
 501                 goto out;
 502         }
 503
 504         /*
 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.
 508          */
 509
 510         switch ( quotastat ) {
 511         case 0:
 512                 DEBUG(9,("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n", quotastat ));
 513                 ret = False;
 514                 goto out;
 515
 516         case 1:
 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;
 521                 break;
 522
 523         case 2:
 524         case 3:
 525                 D.dqb_bsoftlimit = 1;
 526                 D.dqb_curblocks = 1;
 527                 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", quotastat ));
 528                 break;
 529
 530         default:
 531                 DEBUG(9,("nfs_quotas: Remote Quotas Questionable!  Error \"%i\" \n", quotastat ));
 532                 break;
 533         }
 534
 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",
 536                         quotastat,
 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));
 542
 543         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
 544         *dsize = D.dqb_bsoftlimit;
 545
 546         if (D.dqb_curblocks == D.dqb_curblocks == 1)
 547                 *bsize = 512;
 548
 549         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 550                 *dfree = 0;
 551                 *dsize = D.dqb_curblocks;
 552         } else
 553                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 554
 555   out:
 556
 557         if (clnt) {
 558                 if (clnt->cl_auth)
 559                         auth_destroy(clnt->cl_auth);
 560                 clnt_destroy(clnt);
 561         }
 562
 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));
 564
 565         SAFE_FREE(cutstr);
 566         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
 567         return ret;
 568 }
 569 #endif
 570
 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 ****************************************************************************/
 575
 576 BOOL disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 577 {
 578         uid_t euser_id;
 579         int ret;
 580         struct dqblk D;
 581 #if defined(SUNOS5)
 582         struct quotctl command;
 583         int file;
 584         static struct mnttab mnt;
 585         static pstring name;
 586         pstring devopt;
 587 #else /* SunOS4 */
 588         struct mntent *mnt;
 589         static pstring name;
 590 #endif
 591         FILE *fd;
 592         SMB_STRUCT_STAT sbuf;
 593         SMB_DEV_T devno ;
 594         static SMB_DEV_T devno_cached = 0 ;
 595         static int found ;
 596
 597         euser_id = geteuid();
 598
 599         if ( sys_stat(path,&sbuf) == -1 )
 600                 return(False) ;
 601
 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 ;
 606 #if defined(SUNOS5)
 607                 if ((fd = sys_fopen(MNTTAB, "r")) == NULL)
 608                         return(False) ;
 609
 610                 found = False ;
 611                 slprintf(devopt, sizeof(devopt) - 1, "dev=%x", (unsigned int)devno);
 612                 while (getmntent(fd, &mnt) == 0) {
 613                         if( !hasmntopt(&mnt, devopt) )
 614                                 continue;
 615
 616                         DEBUG(5,("disk_quotas: testing \"%s\" %s\n", mnt.mnt_mountp,devopt));
 617
 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  ) {
 622                                         found = True ;
 623                                         break;
 624                         }
 625                 }
 626
 627                 pstrcpy(name,mnt.mnt_mountp) ;
 628                 pstrcat(name,"/quotas") ;
 629                 fclose(fd) ;
 630 #else /* SunOS4 */
 631                 if ((fd = setmntent(MOUNTED, "r")) == NULL)
 632                         return(False) ;
 633
 634                 found = False ;
 635                 while ((mnt = getmntent(fd)) != NULL) {
 636                         if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
 637                                 continue ;
 638                         DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n", mnt->mnt_dir,(unsigned int)sbuf.st_dev));
 639                         if (sbuf.st_dev == devno) {
 640                                 found = True ;
 641                                 break;
 642                         }
 643                 }
 644
 645                 pstrcpy(name,mnt->mnt_fsname) ;
 646                 endmntent(fd) ;
 647 #endif
 648         }
 649
 650         if ( ! found )
 651                 return(False) ;
 652
 653         save_re_uid();
 654         set_effective_uid(0);
 655
 656 #if defined(SUNOS5)
 657         if ( strcmp( mnt.mnt_fstype, "nfs" ) == 0) {
 658                 BOOL retval;
 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);
 661                 restore_re_uid();
 662                 return retval;
 663         }
 664
 665         DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
 666         if((file=sys_open(name, O_RDONLY,0))<0) {
 667                 restore_re_uid();
 668                 return(False);
 669         }
 670         command.op = Q_GETQUOTA;
 671         command.uid = euser_id;
 672         command.addr = (caddr_t) &D;
 673         ret = ioctl(file, Q_QUOTACTL, &command);
 674         close(file);
 675 #else
 676         DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
 677         ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
 678 #endif
 679
 680         restore_re_uid();
 681
 682         if (ret < 0) {
 683                 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n", strerror(errno) ));
 684
 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" )) {
 690                         BOOL retval;
 691                         retval = disk_quotas_vxfs(name, path, bsize, dfree, dsize);
 692                         return(retval);
 693                 }
 694 #else
 695                 return(False);
 696 #endif
 697         }
 698
 699         /* If softlimit is zero, set it equal to hardlimit.
 700          */
 701
 702         if (D.dqb_bsoftlimit==0)
 703                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
 704
 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 :-)
 709          */
 710
 711         if (D.dqb_bsoftlimit==0)
 712                 return(False);
 713         *bsize = DEV_BSIZE;
 714         *dsize = D.dqb_bsoftlimit;
 715
 716         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 717                 *dfree = 0;
 718                 *dsize = D.dqb_curblocks;
 719         } else
 720                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 721
 722         DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",
 723                 path,(double)*bsize,(double)*dfree,(double)*dsize));
 724
 725         return(True);
 726 }
 727
 728
 729 #elif defined(OSF1)
 730 #include <ufs/quota.h>
 731
 732 /****************************************************************************
 733 try to get the disk space from disk quotas - OSF1 version
 734 ****************************************************************************/
 735
 736 BOOL disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 737 {
 738   int r, save_errno;
 739   struct dqblk D;
 740   SMB_STRUCT_STAT S;
 741   uid_t euser_id;
 742
 743   /*
 744    * This code presumes that OSF1 will only
 745    * give out quota info when the real uid
 746    * matches the effective uid. JRA.
 747    */
 748   euser_id = geteuid();
 749   save_re_uid();
 750   if (set_re_uid() != 0) return False;
 751
 752   r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D);
 753   if (r) {
 754      save_errno = errno;
 755   }
 756
 757   restore_re_uid();
 758
 759   *bsize = DEV_BSIZE;
 760
 761   if (r)
 762   {
 763       if (save_errno == EDQUOT)   /* disk quota exceeded */
 764       {
 765          *dfree = 0;
 766          *dsize = D.dqb_curblocks;
 767          return (True);
 768       }
 769       else
 770          return (False);
 771   }
 772
 773   /* If softlimit is zero, set it equal to hardlimit.
 774    */
 775
 776   if (D.dqb_bsoftlimit==0)
 777     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 778
 779   /* Use softlimit to determine disk space, except when it has been exceeded */
 780
 781   if (D.dqb_bsoftlimit==0)
 782     return(False);
 783
 784   if ((D.dqb_curblocks>D.dqb_bsoftlimit)) {
 785     *dfree = 0;
 786     *dsize = D.dqb_curblocks;
 787   } else {
 788     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 789     *dsize = D.dqb_bsoftlimit;
 790   }
 791   return (True);
 792 }
 793
 794 #elif defined (IRIX6)
 795 /****************************************************************************
 796 try to get the disk space from disk quotas (IRIX 6.2 version)
 797 ****************************************************************************/
 798
 799 #include <sys/quota.h>
 800 #include <mntent.h>
 801
 802 BOOL disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 803 {
 804   uid_t euser_id;
 805   int r;
 806   struct dqblk D;
 807   struct fs_disk_quota        F;
 808   SMB_STRUCT_STAT S;
 809   FILE *fp;
 810   struct mntent *mnt;
 811   SMB_DEV_T devno;
 812   int found;
 813
 814   /* find the block device file */
 815
 816   if ( sys_stat(path, &S) == -1 ) {
 817     return(False) ;
 818   }
 819
 820   devno = S.st_dev ;
 821
 822   fp = setmntent(MOUNTED,"r");
 823   found = False ;
 824
 825   while ((mnt = getmntent(fp))) {
 826     if ( sys_stat(mnt->mnt_dir,&S) == -1 )
 827       continue ;
 828     if (S.st_dev == devno) {
 829       found = True ;
 830       break ;
 831     }
 832   }
 833   endmntent(fp) ;
 834
 835   if (!found) {
 836     return(False);
 837   }
 838
 839   euser_id=geteuid();
 840   save_re_uid();
 841   set_effective_uid(0);
 842
 843   /* Use softlimit to determine disk space, except when it has been exceeded */
 844
 845   *bsize = 512;
 846
 847   if ( 0 == strcmp ( mnt->mnt_type, "efs" ))
 848   {
 849     r=quotactl (Q_GETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &D);
 850
 851     restore_re_uid();
 852
 853     if (r==-1)
 854       return(False);
 855
 856     /* Use softlimit to determine disk space, except when it has been exceeded */
 857     if (
 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)
 862        )
 863     {
 864       *dfree = 0;
 865       *dsize = D.dqb_curblocks;
 866     }
 867     else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
 868     {
 869       return(False);
 870     }
 871     else
 872     {
 873       *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 874       *dsize = D.dqb_bsoftlimit;
 875     }
 876
 877   }
 878   else if ( 0 == strcmp ( mnt->mnt_type, "xfs" ))
 879   {
 880     r=quotactl (Q_XGETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &F);
 881
 882     restore_re_uid();
 883
 884     if (r==-1)
 885       return(False);
 886
 887     /* Use softlimit to determine disk space, except when it has been exceeded */
 888     if (
 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)
 893        )
 894     {
 895       *dfree = 0;
 896       *dsize = F.d_bcount;
 897     }
 898     else if (F.d_blk_softlimit==0 && F.d_blk_hardlimit==0)
 899     {
 900       return(False);
 901     }
 902     else
 903     {
 904       *dfree = (F.d_blk_softlimit - F.d_bcount);
 905       *dsize = F.d_blk_softlimit;
 906     }
 907
 908   }
 909   else
 910   {
 911           restore_re_uid();
 912           return(False);
 913   }
 914
 915   return (True);
 916
 917 }
 918
 919 #else
 920
 921 #if    defined(__FreeBSD__) || defined(__OpenBSD__)
 922 #include <ufs/ufs/quota.h>
 923 #include <machine/param.h>
 924 #elif         AIX
 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>
 933 #include <devnm.h>
 934 #endif
 935
 936 /****************************************************************************
 937 try to get the disk space from disk quotas - default version
 938 ****************************************************************************/
 939
 940 BOOL disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
 941 {
 942   int r;
 943   struct dqblk D;
 944   uid_t euser_id;
 945 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__)
 946   char dev_disk[256];
 947   SMB_STRUCT_STAT S;
 948
 949   /* find the block device file */
 950
 951 #ifdef HPUX
 952   /* Need to set the cache flag to 1 for HPUX. Seems
 953    * to have a significant performance boost when
 954    * lstat calls on /dev access this function.
 955    */
 956   if ((sys_stat(path, &S)<0) || (devnm(S_IFBLK, S.st_dev, dev_disk, 256, 1)<0))
 957 #else
 958   if ((sys_stat(path, &S)<0) || (devnm(S_IFBLK, S.st_dev, dev_disk, 256, 0)<0))
 959         return (False);
 960 #endif /* ifdef HPUX */
 961
 962 #endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) */
 963
 964   euser_id = geteuid();
 965
 966 #ifdef HPUX
 967   /* for HPUX, real uid must be same as euid to execute quotactl for euid */
 968   save_re_uid();
 969   if (set_re_uid() != 0) return False;
 970
 971   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
 972
 973   restore_re_uid();
 974 #else
 975 #if defined(__FreeBSD__) || defined(__OpenBSD__)
 976   {
 977     /* FreeBSD patches from Marty Moll <martym@arbor.edu> */
 978     gid_t egrp_id;
 979
 980     save_re_uid();
 981     set_effective_uid(0);
 982
 983     egrp_id = getegid();
 984     r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
 985
 986     /* As FreeBSD has group quotas, if getting the user
 987        quota fails, try getting the group instead. */
 988     if (r) {
 989             r= quotactl(path,QCMD(Q_GETQUOTA,GRPQUOTA),egrp_id,(char *) &D);
 990     }
 991
 992     restore_re_uid();
 993   }
 994 #elif defined(AIX)
 995   /* AIX has both USER and GROUP quotas:
 996      Get the USER quota (ohnielse@fysik.dtu.dk) */
 997   save_re_uid();
 998   if (set_re_uid() != 0)
 999     return False;
1000   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1001   restore_re_uid();
1002 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
1003   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1004 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ */
1005 #endif /* HPUX */
1006
1007   /* Use softlimit to determine disk space, except when it has been exceeded */
1008 #if defined(__FreeBSD__) || defined(__OpenBSD__)
1009   *bsize = DEV_BSIZE;
1010 #else /* !__FreeBSD__ && !__OpenBSD__ */
1011   *bsize = 1024;
1012 #endif /*!__FreeBSD__ && !__OpenBSD__ */
1013
1014   if (r)
1015     {
1016       if (errno == EDQUOT)
1017         {
1018           *dfree =0;
1019           *dsize =D.dqb_curblocks;
1020           return (True);
1021         }
1022       else return(False);
1023     }
1024
1025   /* If softlimit is zero, set it equal to hardlimit.
1026    */
1027
1028   if (D.dqb_bsoftlimit==0)
1029     D.dqb_bsoftlimit = D.dqb_bhardlimit;
1030
1031   if (D.dqb_bsoftlimit==0)
1032     return(False);
1033   /* Use softlimit to determine disk space, except when it has been exceeded */
1034   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
1035 #if !defined(__FreeBSD__) && !defined(__OpenBSD__)
1036 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
1037 #endif
1038     ) {
1039       *dfree = 0;
1040       *dsize = D.dqb_curblocks;
1041     }
1042   else {
1043     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1044     *dsize = D.dqb_bsoftlimit;
1045   }
1046   return (True);
1047 }
1048
1049 #endif
1050
1051 #if defined(VXFS_QUOTA)
1052
1053 /****************************************************************************
1054 Try to get the disk space from Veritas disk quotas.
1055     David Lee <T.D.Lee@durham.ac.uk> August 1999.
1056
1057 Background assumptions:
1058     Potentially under many Operating Systems.  Initially Solaris 2.
1059
1060     My guess is that Veritas is largely, though not entirely,
1061     independent of OS.  So I have separated it out.
1062
1063     There may be some details.  For example, OS-specific "include" files.
1064
1065     It is understood that HPUX 10 somehow gets Veritas quotas without
1066     any special effort; if so, this routine need not be compiled in.
1067         Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
1068
1069 Warning:
1070     It is understood that Veritas do not publicly support this ioctl interface.
1071     Rather their preference would be for the user (us) to call the native
1072     OS and then for the OS itself to call through to the VxFS filesystem.
1073     Presumably HPUX 10, see above, does this.
1074
1075 Hints for porting:
1076     Add your OS to "IFLIST" below.
1077     Get it to compile successfully:
1078         Almost certainly "include"s require attention: see SUNOS5.
1079     In the main code above, arrange for it to be called: see SUNOS5.
1080     Test!
1081
1082 ****************************************************************************/
1083
1084 /* "IFLIST"
1085  * This "if" is a list of ports:
1086  *      if defined(OS1) || defined(OS2) || ...
1087  */
1088 #if defined(SUNOS5)
1089
1090 #if defined(SUNOS5)
1091 #include <sys/fs/vx_solaris.h>
1092 #endif
1093 #include <sys/fs/vx_machdep.h>
1094 #include <sys/fs/vx_layout.h>
1095 #include <sys/fs/vx_quota.h>
1096 #include <sys/fs/vx_aioctl.h>
1097 #include <sys/fs/vx_ioctl.h>
1098
1099 BOOL disk_quotas_vxfs(const pstring name, char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
1100 {
1101   uid_t user_id, euser_id;
1102   int ret;
1103   struct vx_dqblk D;
1104   struct vx_quotctl quotabuf;
1105   struct vx_genioctl genbuf;
1106   pstring qfname;
1107   int file;
1108
1109   /*
1110    * "name" may or may not include a trailing "/quotas".
1111    * Arranging consistency of calling here in "quotas.c" may not be easy and
1112    * it might be easier to examine and adjust it here.
1113    * Fortunately, VxFS seems not to mind at present.
1114    */
1115   pstrcpy(qfname, name) ;
1116   /* pstrcat(qfname, "/quotas") ; */    /* possibly examine and adjust "name" */
1117
1118   euser_id = geteuid();
1119   set_effective_uid(0);
1120
1121   DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
1122   if((file=sys_open(qfname, O_RDONLY,0))<0) {
1123     set_effective_uid(euser_id);
1124     return(False);
1125   }
1126   genbuf.ioc_cmd = VX_QUOTACTL;
1127   genbuf.ioc_up = (void *) &quotabuf;
1128
1129   quotabuf.cmd = VX_GETQUOTA;
1130   quotabuf.uid = euser_id;
1131   quotabuf.addr = (caddr_t) &D;
1132   ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
1133   close(file);
1134
1135   set_effective_uid(euser_id);
1136
1137   if (ret < 0) {
1138     DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
1139     return(False);
1140   }
1141
1142   /* If softlimit is zero, set it equal to hardlimit.
1143    */
1144
1145   if (D.dqb_bsoftlimit==0)
1146     D.dqb_bsoftlimit = D.dqb_bhardlimit;
1147
1148   /* Use softlimit to determine disk space. A user exceeding the quota is told
1149    * that there's no space left. Writes might actually work for a bit if the
1150    * hardlimit is set higher than softlimit. Effectively the disk becomes
1151    * made of rubber latex and begins to expand to accommodate the user :-)
1152    */
1153   DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
1154          path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
1155          D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
1156
1157   if (D.dqb_bsoftlimit==0)
1158     return(False);
1159   *bsize = DEV_BSIZE;
1160   *dsize = D.dqb_bsoftlimit;
1161
1162   if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1163      *dfree = 0;
1164      *dsize = D.dqb_curblocks;
1165   } else
1166     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1167
1168   DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",
1169          path,(double)*bsize,(double)*dfree,(double)*dsize));
1170
1171   return(True);
1172 }
1173
1174 #endif /* SUNOS5 || ... */
1175
1176 #endif /* VXFS_QUOTA */
1177
1178 #else /* WITH_QUOTAS */
1179
1180 BOOL disk_quotas(const char *path,SMB_BIG_UINT *bsize,SMB_BIG_UINT *dfree,SMB_BIG_UINT *dsize)
1181 {
1182   (*bsize) = 512; /* This value should be ignored */
1183
1184   /* And just to be sure we set some values that hopefully */
1185   /* will be larger that any possible real-world value     */
1186   (*dfree) = (SMB_BIG_UINT)-1;
1187   (*dsize) = (SMB_BIG_UINT)-1;
1188
1189   /* As we have select not to use quotas, allways fail */
1190   return False;
1191 }
1192 #endif /* WITH_QUOTAS */
1193
1194 #else /* HAVE_SYS_QUOTAS */
1195 /* wrapper to the new sys_quota interface
1196    this file should be removed later
1197    */
1198 BOOL disk_quotas(const char *path,SMB_BIG_UINT *bsize,SMB_BIG_UINT *dfree,SMB_BIG_UINT *dsize)
1199 {
1200         int r;
1201         SMB_DISK_QUOTA D;
1202         unid_t id;
1203
1204         id.uid = geteuid();
1205
1206         ZERO_STRUCT(D);
1207         r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
1208
1209         /* Use softlimit to determine disk space, except when it has been exceeded */
1210         *bsize = D.bsize;
1211         if (r == -1) {
1212                 if (errno == EDQUOT) {
1213                         *dfree =0;
1214                         *dsize =D.curblocks;
1215                         return (True);
1216                 } else {
1217                         goto try_group_quota;
1218                 }
1219         }
1220
1221         /* Use softlimit to determine disk space, except when it has been exceeded */
1222         if (
1223                 (D.softlimit && D.curblocks >= D.softlimit) ||
1224                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
1225                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
1226                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
1227         ) {
1228                 *dfree = 0;
1229                 *dsize = D.curblocks;
1230         } else if (D.softlimit==0 && D.hardlimit==0) {
1231                 goto try_group_quota;
1232         } else {
1233                 if (D.softlimit == 0)
1234                         D.softlimit = D.hardlimit;
1235                 *dfree = D.softlimit - D.curblocks;
1236                 *dsize = D.softlimit;
1237         }
1238
1239         return True;
1240
1241 try_group_quota:
1242         id.gid = getegid();
1243
1244         ZERO_STRUCT(D);
1245         r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
1246
1247         /* Use softlimit to determine disk space, except when it has been exceeded */
1248         *bsize = D.bsize;
1249         if (r == -1) {
1250                 if (errno == EDQUOT) {
1251                         *dfree =0;
1252                         *dsize =D.curblocks;
1253                         return (True);
1254                 } else {
1255                         return False;
1256                 }
1257         }
1258
1259         /* Use softlimit to determine disk space, except when it has been exceeded */
1260         if (
1261                 (D.softlimit && D.curblocks >= D.softlimit) ||
1262                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
1263                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
1264                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
1265         ) {
1266                 *dfree = 0;
1267                 *dsize = D.curblocks;
1268         } else if (D.softlimit==0 && D.hardlimit==0) {
1269                 return False;
1270         } else {
1271                 if (D.softlimit == 0)
1272                         D.softlimit = D.hardlimit;
1273                 *dfree = D.softlimit - D.curblocks;
1274                 *dsize = D.softlimit;
1275         }
1276
1277         return (True);
1278 }
1279 #endif /* HAVE_SYS_QUOTAS */