source3/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 3 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, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20
  21 /*
  22  * This is one of the most system dependent parts of Samba, and its
  23  * done a litle differently. Each system has its own way of doing
  24  * things :-(
  25  */
  26
  27 #include "includes.h"
  28 #include "smbd/smbd.h"
  29 #include "system/filesys.h"
  30
  31 #undef DBGC_CLASS
  32 #define DBGC_CLASS DBGC_QUOTA
  33
  34 #ifndef HAVE_SYS_QUOTAS
  35
  36 /* just a quick hack because sysquotas.h is included before linux/quota.h */
  37 #ifdef QUOTABLOCK_SIZE
  38 #undef QUOTABLOCK_SIZE
  39 #endif
  40
  41 #ifdef WITH_QUOTAS
  42
  43 #if defined(VXFS_QUOTA)
  44
  45 /*
  46  * In addition to their native filesystems, some systems have Veritas VxFS.
  47  * Declare here, define at end: reduces likely "include" interaction problems.
  48  *      David Lee <T.D.Lee@durham.ac.uk>
  49  */
  50 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize);
  51
  52 #endif /* VXFS_QUOTA */
  53
  54
  55 #if defined(SUNOS5) || defined(SUNOS4)
  56
  57 #include <fcntl.h>
  58 #include <sys/param.h>
  59 #if defined(SUNOS5)
  60 #include <sys/fs/ufs_quota.h>
  61 #include <sys/mnttab.h>
  62 #include <sys/mntent.h>
  63 #else /* defined(SUNOS4) */
  64 #include <ufs/quota.h>
  65 #include <mntent.h>
  66 #endif
  67
  68 #if defined(SUNOS5)
  69
  70 /****************************************************************************
  71  Allows querying of remote hosts for quotas on NFS mounted shares.
  72  Supports normal NFS and AMD mounts.
  73  Alan Romeril <a.romeril@ic.ac.uk> July 2K.
  74 ****************************************************************************/
  75
  76 #include <rpc/rpc.h>
  77 #include <rpc/types.h>
  78 #include <rpcsvc/rquota.h>
  79 #include <rpc/nettype.h>
  80 #include <rpc/xdr.h>
  81
  82 static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
  83 {
  84         int quotastat;
  85
  86         if (!xdr_int(xdrsp, &quotastat)) {
  87                 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
  88                 return 0;
  89         }
  90         gqr->status = quotastat;
  91
  92         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
  93                 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
  94                 return 0;
  95         }
  96         if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
  97                 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
  98                 return 0;
  99         }
 100         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
 101                 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
 102                 return 0;
 103         }
 104         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
 105                 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
 106                 return 0;
 107         }
 108         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
 109                 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
 110                 return 0;
 111         }
 112         return (1);
 113 }
 114
 115 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
 116 {
 117         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
 118                 return(0);
 119         if (!xdr_int(xdrsp, &args->gqa_uid))
 120                 return(0);
 121         return (1);
 122 }
 123
 124 /* Restricted to SUNOS5 for the moment, I haven`t access to others to test. */
 125 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 126 {
 127         uid_t uid = euser_id;
 128         struct dqblk D;
 129         char *mnttype = nfspath;
 130         CLIENT *clnt;
 131         struct getquota_rslt gqr;
 132         struct getquota_args args;
 133         char *cutstr, *pathname, *host, *testpath;
 134         int len;
 135         static struct timeval timeout = {2,0};
 136         enum clnt_stat clnt_stat;
 137         bool ret = True;
 138
 139         *bsize = *dfree = *dsize = (uint64_t)0;
 140
 141         len=strcspn(mnttype, ":");
 142         pathname=strstr(mnttype, ":");
 143         cutstr = (char *) SMB_MALLOC(len+1);
 144         if (!cutstr)
 145                 return False;
 146
 147         memset(cutstr, '\0', len+1);
 148         host = strncat(cutstr,mnttype, sizeof(char) * len );
 149         DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
 150         DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
 151         testpath=strchr_m(mnttype, ':');
 152         args.gqa_pathp = testpath+1;
 153         args.gqa_uid = uid;
 154
 155         DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
 156
 157         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
 158                 ret = False;
 159                 goto out;
 160         }
 161
 162         clnt->cl_auth = authunix_create_default();
 163         DEBUG(9,("nfs_quotas: auth_success\n"));
 164
 165         clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, my_xdr_getquota_args, (caddr_t)&args, my_xdr_getquota_rslt, (caddr_t)&gqr, timeout);
 166
 167         if (clnt_stat != RPC_SUCCESS) {
 168                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
 169                 ret = False;
 170                 goto out;
 171         }
 172
 173         /*
 174          * gqr.status returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
 175          * no quota set, and 3 if no permission to get the quota.  If 0 or 3 return
 176          * something sensible.
 177          */
 178
 179         switch (gqr.status) {
 180         case 0:
 181                 DEBUG(9,("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n", gqr.status));
 182                 ret = False;
 183                 goto out;
 184
 185         case 1:
 186                 DEBUG(9,("nfs_quotas: Good quota data\n"));
 187                 D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
 188                 D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
 189                 D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
 190                 break;
 191
 192         case 2:
 193         case 3:
 194                 D.dqb_bsoftlimit = 1;
 195                 D.dqb_curblocks = 1;
 196                 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", gqr.status));
 197                 break;
 198
 199         default:
 200                 DEBUG(9,("nfs_quotas: Remote Quotas Questionable!  Error \"%i\" \n", gqr.status ));
 201                 break;
 202         }
 203
 204         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",
 205                         gqr.status,
 206                         gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
 207                         gqr.getquota_rslt_u.gqr_rquota.rq_active,
 208                         gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
 209                         gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
 210                         gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
 211
 212         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
 213         *dsize = D.dqb_bsoftlimit;
 214
 215         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 216                 *dfree = 0;
 217                 *dsize = D.dqb_curblocks;
 218         } else
 219                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 220
 221   out:
 222
 223         if (clnt) {
 224                 if (clnt->cl_auth)
 225                         auth_destroy(clnt->cl_auth);
 226                 clnt_destroy(clnt);
 227         }
 228
 229         DEBUG(5,("nfs_quotas: For path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
 230
 231         SAFE_FREE(cutstr);
 232         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
 233         return ret;
 234 }
 235 #endif
 236
 237 /****************************************************************************
 238 try to get the disk space from disk quotas (SunOS & Solaris2 version)
 239 Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
 240 ****************************************************************************/
 241
 242 bool disk_quotas(const char *path,
 243                 uint64_t *bsize,
 244                 uint64_t *dfree,
 245                 uint64_t *dsize)
 246 {
 247         uid_t euser_id;
 248         int ret;
 249         struct dqblk D;
 250 #if defined(SUNOS5)
 251         struct quotctl command;
 252         int file;
 253         struct mnttab mnt;
 254 #else /* SunOS4 */
 255         struct mntent *mnt;
 256 #endif
 257         char *name = NULL;
 258         FILE *fd;
 259         SMB_STRUCT_STAT sbuf;
 260         SMB_DEV_T devno;
 261         bool found = false;
 262
 263         euser_id = geteuid();
 264
 265         if (sys_stat(path, &sbuf, false) == -1) {
 266                 return false;
 267         }
 268
 269         devno = sbuf.st_ex_dev ;
 270         DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
 271                 path, (unsigned int)devno));
 272 #if defined(SUNOS5)
 273         if ((fd = fopen(MNTTAB, "r")) == NULL) {
 274                 return false;
 275         }
 276
 277         while (getmntent(fd, &mnt) == 0) {
 278                 if (sys_stat(mnt.mnt_mountp, &sbuf, false) == -1) {
 279                         continue;
 280                 }
 281
 282                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 283                         mnt.mnt_mountp, (unsigned int)devno));
 284
 285                 /* quotas are only on vxfs, UFS or NFS */
 286                 if ((sbuf.st_ex_dev == devno) && (
 287                         strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
 288                         strcmp( mnt.mnt_fstype, "nfs" ) == 0    ||
 289                         strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
 290                                 found = true;
 291                                 name = talloc_asprintf(talloc_tos(),
 292                                                 "%s/quotas",
 293                                                 mnt.mnt_mountp);
 294                                 break;
 295                 }
 296         }
 297
 298         fclose(fd);
 299 #else /* SunOS4 */
 300         if ((fd = setmntent(MOUNTED, "r")) == NULL) {
 301                 return false;
 302         }
 303
 304         while ((mnt = getmntent(fd)) != NULL) {
 305                 if (sys_stat(mnt->mnt_dir, &sbuf, false) == -1) {
 306                         continue;
 307                 }
 308                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 309                                         mnt->mnt_dir,
 310                                         (unsigned int)sbuf.st_ex_dev));
 311                 if (sbuf.st_ex_dev == devno) {
 312                         found = true;
 313                         name = talloc_strdup(talloc_tos(),
 314                                         mnt->mnt_fsname);
 315                         break;
 316                 }
 317         }
 318
 319         endmntent(fd);
 320 #endif
 321         if (!found) {
 322                 return false;
 323         }
 324
 325         if (!name) {
 326                 return false;
 327         }
 328         become_root();
 329
 330 #if defined(SUNOS5)
 331         if (strcmp(mnt.mnt_fstype, "nfs") == 0) {
 332                 bool retval;
 333                 DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n",
 334                                         mnt.mnt_special));
 335                 retval = nfs_quotas(mnt.mnt_special,
 336                                 euser_id, bsize, dfree, dsize);
 337                 unbecome_root();
 338                 return retval;
 339         }
 340
 341         DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
 342         if((file=open(name, O_RDONLY,0))<0) {
 343                 unbecome_root();
 344                 return false;
 345         }
 346         command.op = Q_GETQUOTA;
 347         command.uid = euser_id;
 348         command.addr = (caddr_t) &D;
 349         ret = ioctl(file, Q_QUOTACTL, &command);
 350         close(file);
 351 #else
 352         DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
 353         ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
 354 #endif
 355
 356         unbecome_root();
 357
 358         if (ret < 0) {
 359                 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n",
 360                                         strerror(errno) ));
 361
 362 #if defined(SUNOS5) && defined(VXFS_QUOTA)
 363                 /* If normal quotactl() fails, try vxfs private calls */
 364                 set_effective_uid(euser_id);
 365                 DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
 366                 if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
 367                         bool retval;
 368                         retval = disk_quotas_vxfs(name, path,
 369                                         bsize, dfree, dsize);
 370                         return retval;
 371                 }
 372 #else
 373                 return false;
 374 #endif
 375         }
 376
 377         /* If softlimit is zero, set it equal to hardlimit.
 378          */
 379
 380         if (D.dqb_bsoftlimit==0) {
 381                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
 382         }
 383
 384         /* Use softlimit to determine disk space. A user exceeding the quota
 385          * is told that there's no space left. Writes might actually work for
 386          * a bit if the hardlimit is set higher than softlimit. Effectively
 387          * the disk becomes made of rubber latex and begins to expand to
 388          * accommodate the user :-)
 389          */
 390
 391         if (D.dqb_bsoftlimit==0)
 392                 return(False);
 393         *bsize = DEV_BSIZE;
 394         *dsize = D.dqb_bsoftlimit;
 395
 396         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 397                 *dfree = 0;
 398                 *dsize = D.dqb_curblocks;
 399         } else {
 400                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 401         }
 402
 403         DEBUG(5,("disk_quotas for path \"%s\" returning "
 404                 "bsize %.0f, dfree %.0f, dsize %.0f\n",
 405                 path,(double)*bsize,(double)*dfree,(double)*dsize));
 406
 407         return true;
 408 }
 409
 410
 411 #else
 412
 413 #if           AIX
 414 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
 415 #include <jfs/quota.h>
 416 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
 417 #define dqb_curfiles dqb_curinodes
 418 #define dqb_fhardlimit dqb_ihardlimit
 419 #define dqb_fsoftlimit dqb_isoftlimit
 420 #ifdef _AIXVERSION_530
 421 #include <sys/statfs.h>
 422 #include <sys/vmount.h>
 423 #endif /* AIX 5.3 */
 424 #else /* !AIX */
 425 #include <sys/quota.h>
 426 #include <devnm.h>
 427 #endif
 428
 429
 430 /****************************************************************************
 431 try to get the disk space from disk quotas - default version
 432 ****************************************************************************/
 433
 434 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 435 {
 436   int r;
 437   struct dqblk D;
 438   uid_t euser_id;
 439 #if !defined(AIX)
 440   char dev_disk[256];
 441   SMB_STRUCT_STAT S;
 442
 443   /* find the block device file */
 444
 445   if ((sys_stat(path, &S, false)<0)
 446       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 0)<0))
 447         return (False);
 448
 449 #endif /* !defined(AIX) */
 450
 451   euser_id = geteuid();
 452
 453 #if   defined(AIX)
 454   /* AIX has both USER and GROUP quotas:
 455      Get the USER quota (ohnielse@fysik.dtu.dk) */
 456 #ifdef _AIXVERSION_530
 457   {
 458     struct statfs statbuf;
 459     quota64_t user_quota;
 460     if (statfs(path,&statbuf) != 0)
 461       return False;
 462     if(statbuf.f_vfstype == MNT_J2)
 463     {
 464     /* For some reason we need to be root for jfs2 */
 465       become_root();
 466       r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
 467       unbecome_root();
 468     /* Copy results to old struct to let the following code work as before */
 469       D.dqb_curblocks  = user_quota.bused;
 470       D.dqb_bsoftlimit = user_quota.bsoft;
 471       D.dqb_bhardlimit = user_quota.bhard;
 472       D.dqb_curfiles   = user_quota.iused;
 473       D.dqb_fsoftlimit = user_quota.isoft;
 474       D.dqb_fhardlimit = user_quota.ihard;
 475     }
 476     else if(statbuf.f_vfstype == MNT_JFS)
 477     {
 478 #endif /* AIX 5.3 */
 479   save_re_uid();
 480   if (set_re_uid() != 0)
 481     return False;
 482   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
 483   restore_re_uid();
 484 #ifdef _AIXVERSION_530
 485     }
 486     else
 487       r = 1; /* Fail for other FS-types */
 488   }
 489 #endif /* AIX 5.3 */
 490 #else /* !AIX */
 491   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
 492 #endif /* !AIX */
 493
 494   /* Use softlimit to determine disk space, except when it has been exceeded */
 495   *bsize = 1024;
 496
 497   if (r)
 498     {
 499       if (errno == EDQUOT)
 500         {
 501           *dfree =0;
 502           *dsize =D.dqb_curblocks;
 503           return (True);
 504         }
 505       else return(False);
 506     }
 507
 508   /* If softlimit is zero, set it equal to hardlimit.
 509    */
 510
 511   if (D.dqb_bsoftlimit==0)
 512     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 513
 514   if (D.dqb_bsoftlimit==0)
 515     return(False);
 516   /* Use softlimit to determine disk space, except when it has been exceeded */
 517   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
 518 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
 519     ) {
 520       *dfree = 0;
 521       *dsize = D.dqb_curblocks;
 522     }
 523   else {
 524     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 525     *dsize = D.dqb_bsoftlimit;
 526   }
 527   return (True);
 528 }
 529
 530 #endif
 531
 532 #if defined(VXFS_QUOTA)
 533
 534 /****************************************************************************
 535 Try to get the disk space from Veritas disk quotas.
 536     David Lee <T.D.Lee@durham.ac.uk> August 1999.
 537
 538 Background assumptions:
 539     Potentially under many Operating Systems.  Initially Solaris 2.
 540
 541     My guess is that Veritas is largely, though not entirely,
 542     independent of OS.  So I have separated it out.
 543
 544     There may be some details.  For example, OS-specific "include" files.
 545
 546     It is understood that HPUX 10 somehow gets Veritas quotas without
 547     any special effort; if so, this routine need not be compiled in.
 548         Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
 549
 550 Warning:
 551     It is understood that Veritas do not publicly support this ioctl interface.
 552     Rather their preference would be for the user (us) to call the native
 553     OS and then for the OS itself to call through to the VxFS filesystem.
 554     Presumably HPUX 10, see above, does this.
 555
 556 Hints for porting:
 557     Add your OS to "IFLIST" below.
 558     Get it to compile successfully:
 559         Almost certainly "include"s require attention: see SUNOS5.
 560     In the main code above, arrange for it to be called: see SUNOS5.
 561     Test!
 562
 563 ****************************************************************************/
 564
 565 /* "IFLIST"
 566  * This "if" is a list of ports:
 567  *      if defined(OS1) || defined(OS2) || ...
 568  */
 569 #if defined(SUNOS5)
 570
 571 #if defined(SUNOS5)
 572 #include <sys/fs/vx_solaris.h>
 573 #endif
 574 #include <sys/fs/vx_machdep.h>
 575 #include <sys/fs/vx_layout.h>
 576 #include <sys/fs/vx_quota.h>
 577 #include <sys/fs/vx_aioctl.h>
 578 #include <sys/fs/vx_ioctl.h>
 579
 580 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 581 {
 582   uid_t user_id, euser_id;
 583   int ret;
 584   struct vx_dqblk D;
 585   struct vx_quotctl quotabuf;
 586   struct vx_genioctl genbuf;
 587   char *qfname;
 588   int file;
 589
 590   /*
 591    * "name" may or may not include a trailing "/quotas".
 592    * Arranging consistency of calling here in "quotas.c" may not be easy and
 593    * it might be easier to examine and adjust it here.
 594    * Fortunately, VxFS seems not to mind at present.
 595    */
 596   qfname = talloc_strdup(talloc_tos(), name);
 597   if (!qfname) {
 598           return false;
 599   }
 600   /* pstrcat(qfname, "/quotas") ; */    /* possibly examine and adjust "name" */
 601
 602   euser_id = geteuid();
 603   set_effective_uid(0);
 604
 605   DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
 606   if((file=open(qfname, O_RDONLY,0))<0) {
 607     set_effective_uid(euser_id);
 608     return(False);
 609   }
 610   genbuf.ioc_cmd = VX_QUOTACTL;
 611   genbuf.ioc_up = (void *) &quotabuf;
 612
 613   quotabuf.cmd = VX_GETQUOTA;
 614   quotabuf.uid = euser_id;
 615   quotabuf.addr = (caddr_t) &D;
 616   ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
 617   close(file);
 618
 619   set_effective_uid(euser_id);
 620
 621   if (ret < 0) {
 622     DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
 623     return(False);
 624   }
 625
 626   /* If softlimit is zero, set it equal to hardlimit.
 627    */
 628
 629   if (D.dqb_bsoftlimit==0)
 630     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 631
 632   /* Use softlimit to determine disk space. A user exceeding the quota is told
 633    * that there's no space left. Writes might actually work for a bit if the
 634    * hardlimit is set higher than softlimit. Effectively the disk becomes
 635    * made of rubber latex and begins to expand to accommodate the user :-)
 636    */
 637   DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
 638          path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
 639          D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
 640
 641   if (D.dqb_bsoftlimit==0)
 642     return(False);
 643   *bsize = DEV_BSIZE;
 644   *dsize = D.dqb_bsoftlimit;
 645
 646   if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 647      *dfree = 0;
 648      *dsize = D.dqb_curblocks;
 649   } else
 650     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 651
 652   DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",
 653          path,(double)*bsize,(double)*dfree,(double)*dsize));
 654
 655   return(True);
 656 }
 657
 658 #endif /* SUNOS5 || ... */
 659
 660 #endif /* VXFS_QUOTA */
 661
 662 #else /* WITH_QUOTAS */
 663
 664 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
 665 {
 666         (*bsize) = 512; /* This value should be ignored */
 667
 668         /* And just to be sure we set some values that hopefully */
 669         /* will be larger that any possible real-world value     */
 670         (*dfree) = (uint64_t)-1;
 671         (*dsize) = (uint64_t)-1;
 672
 673         /* As we have select not to use quotas, allways fail */
 674         return false;
 675 }
 676 #endif /* WITH_QUOTAS */
 677
 678 #else /* HAVE_SYS_QUOTAS */
 679 /* wrapper to the new sys_quota interface
 680    this file should be removed later
 681    */
 682 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
 683 {
 684         int r;
 685         SMB_DISK_QUOTA D;
 686         unid_t id;
 687
 688         id.uid = geteuid();
 689
 690         ZERO_STRUCT(D);
 691         r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
 692
 693         /* Use softlimit to determine disk space, except when it has been exceeded */
 694         *bsize = D.bsize;
 695         if (r == -1) {
 696                 if (errno == EDQUOT) {
 697                         *dfree =0;
 698                         *dsize =D.curblocks;
 699                         return (True);
 700                 } else {
 701                         goto try_group_quota;
 702                 }
 703         }
 704
 705         /* Use softlimit to determine disk space, except when it has been exceeded */
 706         if (
 707                 (D.softlimit && D.curblocks >= D.softlimit) ||
 708                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 709                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 710                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 711         ) {
 712                 *dfree = 0;
 713                 *dsize = D.curblocks;
 714         } else if (D.softlimit==0 && D.hardlimit==0) {
 715                 goto try_group_quota;
 716         } else {
 717                 if (D.softlimit == 0)
 718                         D.softlimit = D.hardlimit;
 719                 *dfree = D.softlimit - D.curblocks;
 720                 *dsize = D.softlimit;
 721         }
 722
 723         return True;
 724
 725 try_group_quota:
 726         id.gid = getegid();
 727
 728         ZERO_STRUCT(D);
 729         r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
 730
 731         /* Use softlimit to determine disk space, except when it has been exceeded */
 732         *bsize = D.bsize;
 733         if (r == -1) {
 734                 if (errno == EDQUOT) {
 735                         *dfree =0;
 736                         *dsize =D.curblocks;
 737                         return (True);
 738                 } else {
 739                         return False;
 740                 }
 741         }
 742
 743         /* Use softlimit to determine disk space, except when it has been exceeded */
 744         if (
 745                 (D.softlimit && D.curblocks >= D.softlimit) ||
 746                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 747                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 748                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 749         ) {
 750                 *dfree = 0;
 751                 *dsize = D.curblocks;
 752         } else if (D.softlimit==0 && D.hardlimit==0) {
 753                 return False;
 754         } else {
 755                 if (D.softlimit == 0)
 756                         D.softlimit = D.hardlimit;
 757                 *dfree = D.softlimit - D.curblocks;
 758                 *dsize = D.softlimit;
 759         }
 760
 761         return (True);
 762 }
 763 #endif /* HAVE_SYS_QUOTAS */