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 /* Restricted to SUNOS5 for the moment, I haven`t access to others to test. */
 116 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 117 {
 118         uid_t uid = euser_id;
 119         struct dqblk D;
 120         char *mnttype = nfspath;
 121         CLIENT *clnt;
 122         struct getquota_rslt gqr;
 123         struct getquota_args args;
 124         char *cutstr, *pathname, *host, *testpath;
 125         int len;
 126         static struct timeval timeout = {2,0};
 127         enum clnt_stat clnt_stat;
 128         bool ret = True;
 129
 130         *bsize = *dfree = *dsize = (uint64_t)0;
 131
 132         len=strcspn(mnttype, ":");
 133         pathname=strstr(mnttype, ":");
 134         cutstr = (char *) SMB_MALLOC(len+1);
 135         if (!cutstr)
 136                 return False;
 137
 138         memset(cutstr, '\0', len+1);
 139         host = strncat(cutstr,mnttype, sizeof(char) * len );
 140         DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
 141         DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
 142         testpath=strchr_m(mnttype, ':');
 143         args.gqa_pathp = testpath+1;
 144         args.gqa_uid = uid;
 145
 146         DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
 147
 148         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
 149                 ret = False;
 150                 goto out;
 151         }
 152
 153         clnt->cl_auth = authunix_create_default();
 154         DEBUG(9,("nfs_quotas: auth_success\n"));
 155
 156         clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, my_xdr_getquota_args, (caddr_t)&args, my_xdr_getquota_rslt, (caddr_t)&gqr, timeout);
 157
 158         if (clnt_stat != RPC_SUCCESS) {
 159                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
 160                 ret = False;
 161                 goto out;
 162         }
 163
 164         /*
 165          * gqr.status returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
 166          * no quota set, and 3 if no permission to get the quota.  If 0 or 3 return
 167          * something sensible.
 168          */
 169
 170         switch (gqr.status) {
 171         case 0:
 172                 DEBUG(9,("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n", gqr.status));
 173                 ret = False;
 174                 goto out;
 175
 176         case 1:
 177                 DEBUG(9,("nfs_quotas: Good quota data\n"));
 178                 D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
 179                 D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
 180                 D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
 181                 break;
 182
 183         case 2:
 184         case 3:
 185                 D.dqb_bsoftlimit = 1;
 186                 D.dqb_curblocks = 1;
 187                 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", gqr.status));
 188                 break;
 189
 190         default:
 191                 DEBUG(9,("nfs_quotas: Remote Quotas Questionable!  Error \"%i\" \n", gqr.status ));
 192                 break;
 193         }
 194
 195         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",
 196                         gqr.status,
 197                         gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
 198                         gqr.getquota_rslt_u.gqr_rquota.rq_active,
 199                         gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
 200                         gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
 201                         gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
 202
 203         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
 204         *dsize = D.dqb_bsoftlimit;
 205
 206         if (D.dqb_curblocks == 1)
 207                 *bsize = 512;
 208
 209         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 210                 *dfree = 0;
 211                 *dsize = D.dqb_curblocks;
 212         } else
 213                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 214
 215   out:
 216
 217         if (clnt) {
 218                 if (clnt->cl_auth)
 219                         auth_destroy(clnt->cl_auth);
 220                 clnt_destroy(clnt);
 221         }
 222
 223         DEBUG(5,("nfs_quotas: For path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
 224
 225         SAFE_FREE(cutstr);
 226         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
 227         return ret;
 228 }
 229 #endif
 230
 231 /****************************************************************************
 232 try to get the disk space from disk quotas (SunOS & Solaris2 version)
 233 Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
 234 ****************************************************************************/
 235
 236 bool disk_quotas(const char *path,
 237                 uint64_t *bsize,
 238                 uint64_t *dfree,
 239                 uint64_t *dsize)
 240 {
 241         uid_t euser_id;
 242         int ret;
 243         struct dqblk D;
 244 #if defined(SUNOS5)
 245         struct quotctl command;
 246         int file;
 247         struct mnttab mnt;
 248 #else /* SunOS4 */
 249         struct mntent *mnt;
 250 #endif
 251         char *name = NULL;
 252         FILE *fd;
 253         SMB_STRUCT_STAT sbuf;
 254         SMB_DEV_T devno;
 255         bool found = false;
 256
 257         euser_id = geteuid();
 258
 259         if (sys_stat(path, &sbuf, false) == -1) {
 260                 return false;
 261         }
 262
 263         devno = sbuf.st_ex_dev ;
 264         DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
 265                 path, (unsigned int)devno));
 266 #if defined(SUNOS5)
 267         if ((fd = fopen(MNTTAB, "r")) == NULL) {
 268                 return false;
 269         }
 270
 271         while (getmntent(fd, &mnt) == 0) {
 272                 if (sys_stat(mnt.mnt_mountp, &sbuf, false) == -1) {
 273                         continue;
 274                 }
 275
 276                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 277                         mnt.mnt_mountp, (unsigned int)devno));
 278
 279                 /* quotas are only on vxfs, UFS or NFS */
 280                 if ((sbuf.st_ex_dev == devno) && (
 281                         strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
 282                         strcmp( mnt.mnt_fstype, "nfs" ) == 0    ||
 283                         strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
 284                                 found = true;
 285                                 name = talloc_asprintf(talloc_tos(),
 286                                                 "%s/quotas",
 287                                                 mnt.mnt_mountp);
 288                                 break;
 289                 }
 290         }
 291
 292         fclose(fd);
 293 #else /* SunOS4 */
 294         if ((fd = setmntent(MOUNTED, "r")) == NULL) {
 295                 return false;
 296         }
 297
 298         while ((mnt = getmntent(fd)) != NULL) {
 299                 if (sys_stat(mnt->mnt_dir, &sbuf, false) == -1) {
 300                         continue;
 301                 }
 302                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 303                                         mnt->mnt_dir,
 304                                         (unsigned int)sbuf.st_ex_dev));
 305                 if (sbuf.st_ex_dev == devno) {
 306                         found = true;
 307                         name = talloc_strdup(talloc_tos(),
 308                                         mnt->mnt_fsname);
 309                         break;
 310                 }
 311         }
 312
 313         endmntent(fd);
 314 #endif
 315         if (!found) {
 316                 return false;
 317         }
 318
 319         if (!name) {
 320                 return false;
 321         }
 322         become_root();
 323
 324 #if defined(SUNOS5)
 325         if (strcmp(mnt.mnt_fstype, "nfs") == 0) {
 326                 bool retval;
 327                 DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n",
 328                                         mnt.mnt_special));
 329                 retval = nfs_quotas(mnt.mnt_special,
 330                                 euser_id, bsize, dfree, dsize);
 331                 unbecome_root();
 332                 return retval;
 333         }
 334
 335         DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
 336         if((file=open(name, O_RDONLY,0))<0) {
 337                 unbecome_root();
 338                 return false;
 339         }
 340         command.op = Q_GETQUOTA;
 341         command.uid = euser_id;
 342         command.addr = (caddr_t) &D;
 343         ret = ioctl(file, Q_QUOTACTL, &command);
 344         close(file);
 345 #else
 346         DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
 347         ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
 348 #endif
 349
 350         unbecome_root();
 351
 352         if (ret < 0) {
 353                 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n",
 354                                         strerror(errno) ));
 355
 356 #if defined(SUNOS5) && defined(VXFS_QUOTA)
 357                 /* If normal quotactl() fails, try vxfs private calls */
 358                 set_effective_uid(euser_id);
 359                 DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
 360                 if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
 361                         bool retval;
 362                         retval = disk_quotas_vxfs(name, path,
 363                                         bsize, dfree, dsize);
 364                         return retval;
 365                 }
 366 #else
 367                 return false;
 368 #endif
 369         }
 370
 371         /* If softlimit is zero, set it equal to hardlimit.
 372          */
 373
 374         if (D.dqb_bsoftlimit==0) {
 375                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
 376         }
 377
 378         /* Use softlimit to determine disk space. A user exceeding the quota
 379          * is told that there's no space left. Writes might actually work for
 380          * a bit if the hardlimit is set higher than softlimit. Effectively
 381          * the disk becomes made of rubber latex and begins to expand to
 382          * accommodate the user :-)
 383          */
 384
 385         if (D.dqb_bsoftlimit==0)
 386                 return(False);
 387         *bsize = DEV_BSIZE;
 388         *dsize = D.dqb_bsoftlimit;
 389
 390         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 391                 *dfree = 0;
 392                 *dsize = D.dqb_curblocks;
 393         } else {
 394                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 395         }
 396
 397         DEBUG(5,("disk_quotas for path \"%s\" returning "
 398                 "bsize %.0f, dfree %.0f, dsize %.0f\n",
 399                 path,(double)*bsize,(double)*dfree,(double)*dsize));
 400
 401         return true;
 402 }
 403
 404
 405 #elif defined(OSF1)
 406 #include <ufs/quota.h>
 407
 408 /****************************************************************************
 409 try to get the disk space from disk quotas - OSF1 version
 410 ****************************************************************************/
 411
 412 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 413 {
 414   int r, save_errno;
 415   struct dqblk D;
 416   SMB_STRUCT_STAT S;
 417   uid_t euser_id;
 418
 419   /*
 420    * This code presumes that OSF1 will only
 421    * give out quota info when the real uid
 422    * matches the effective uid. JRA.
 423    */
 424   euser_id = geteuid();
 425   save_re_uid();
 426   if (set_re_uid() != 0) return False;
 427
 428   r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D);
 429   if (r) {
 430      save_errno = errno;
 431   }
 432
 433   restore_re_uid();
 434
 435   *bsize = DEV_BSIZE;
 436
 437   if (r)
 438   {
 439       if (save_errno == EDQUOT)   /* disk quota exceeded */
 440       {
 441          *dfree = 0;
 442          *dsize = D.dqb_curblocks;
 443          return (True);
 444       }
 445       else
 446          return (False);
 447   }
 448
 449   /* If softlimit is zero, set it equal to hardlimit.
 450    */
 451
 452   if (D.dqb_bsoftlimit==0)
 453     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 454
 455   /* Use softlimit to determine disk space, except when it has been exceeded */
 456
 457   if (D.dqb_bsoftlimit==0)
 458     return(False);
 459
 460   if ((D.dqb_curblocks>D.dqb_bsoftlimit)) {
 461     *dfree = 0;
 462     *dsize = D.dqb_curblocks;
 463   } else {
 464     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 465     *dsize = D.dqb_bsoftlimit;
 466   }
 467   return (True);
 468 }
 469
 470 #elif defined (IRIX6)
 471 /****************************************************************************
 472 try to get the disk space from disk quotas (IRIX 6.2 version)
 473 ****************************************************************************/
 474
 475 #include <sys/quota.h>
 476 #include <mntent.h>
 477
 478 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 479 {
 480   uid_t euser_id;
 481   int r;
 482   struct dqblk D;
 483   struct fs_disk_quota        F;
 484   SMB_STRUCT_STAT S;
 485   FILE *fp;
 486   struct mntent *mnt;
 487   SMB_DEV_T devno;
 488   int found;
 489
 490   /* find the block device file */
 491
 492   if ( sys_stat(path, &S, false) == -1 ) {
 493     return(False) ;
 494   }
 495
 496   devno = S.st_ex_dev ;
 497
 498   fp = setmntent(MOUNTED,"r");
 499   found = False ;
 500
 501   while ((mnt = getmntent(fp))) {
 502     if ( sys_stat(mnt->mnt_dir, &S, false) == -1 )
 503       continue ;
 504     if (S.st_ex_dev == devno) {
 505       found = True ;
 506       break ;
 507     }
 508   }
 509   endmntent(fp) ;
 510
 511   if (!found) {
 512     return(False);
 513   }
 514
 515   euser_id=geteuid();
 516   become_root();
 517
 518   /* Use softlimit to determine disk space, except when it has been exceeded */
 519
 520   *bsize = 512;
 521
 522   if ( 0 == strcmp ( mnt->mnt_type, "efs" ))
 523   {
 524     r=quotactl (Q_GETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &D);
 525
 526     unbecome_root();
 527
 528     if (r==-1)
 529       return(False);
 530
 531     /* Use softlimit to determine disk space, except when it has been exceeded */
 532     if (
 533         (D.dqb_bsoftlimit && D.dqb_curblocks>=D.dqb_bsoftlimit) ||
 534         (D.dqb_bhardlimit && D.dqb_curblocks>=D.dqb_bhardlimit) ||
 535         (D.dqb_fsoftlimit && D.dqb_curfiles>=D.dqb_fsoftlimit) ||
 536         (D.dqb_fhardlimit && D.dqb_curfiles>=D.dqb_fhardlimit)
 537        )
 538     {
 539       *dfree = 0;
 540       *dsize = D.dqb_curblocks;
 541     }
 542     else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
 543     {
 544       return(False);
 545     }
 546     else
 547     {
 548       *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 549       *dsize = D.dqb_bsoftlimit;
 550     }
 551
 552   }
 553   else if ( 0 == strcmp ( mnt->mnt_type, "xfs" ))
 554   {
 555     r=quotactl (Q_XGETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &F);
 556
 557     unbecome_root();
 558
 559     if (r==-1)
 560     {
 561       DEBUG(5, ("quotactl for uid=%u: %s", euser_id, strerror(errno)));
 562       return(False);
 563     }
 564
 565     /* No quota for this user. */
 566     if (F.d_blk_softlimit==0 && F.d_blk_hardlimit==0)
 567     {
 568       return(False);
 569     }
 570
 571     /* Use softlimit to determine disk space, except when it has been exceeded */
 572     if (
 573         (F.d_blk_softlimit && F.d_bcount>=F.d_blk_softlimit) ||
 574         (F.d_blk_hardlimit && F.d_bcount>=F.d_blk_hardlimit) ||
 575         (F.d_ino_softlimit && F.d_icount>=F.d_ino_softlimit) ||
 576         (F.d_ino_hardlimit && F.d_icount>=F.d_ino_hardlimit)
 577        )
 578     {
 579       *dfree = 0;
 580       *dsize = F.d_bcount;
 581     }
 582     else
 583     {
 584       *dfree = (F.d_blk_softlimit - F.d_bcount);
 585       *dsize = F.d_blk_softlimit ? F.d_blk_softlimit : F.d_blk_hardlimit;
 586     }
 587
 588   }
 589   else
 590   {
 591           unbecome_root();
 592           return(False);
 593   }
 594
 595   return (True);
 596
 597 }
 598
 599 #else
 600
 601 #if           AIX
 602 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
 603 #include <jfs/quota.h>
 604 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
 605 #define dqb_curfiles dqb_curinodes
 606 #define dqb_fhardlimit dqb_ihardlimit
 607 #define dqb_fsoftlimit dqb_isoftlimit
 608 #ifdef _AIXVERSION_530
 609 #include <sys/statfs.h>
 610 #include <sys/vmount.h>
 611 #endif /* AIX 5.3 */
 612 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
 613 #include <sys/quota.h>
 614 #include <devnm.h>
 615 #endif
 616
 617
 618 /****************************************************************************
 619 try to get the disk space from disk quotas - default version
 620 ****************************************************************************/
 621
 622 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 623 {
 624   int r;
 625   struct dqblk D;
 626   uid_t euser_id;
 627 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__)
 628   char dev_disk[256];
 629   SMB_STRUCT_STAT S;
 630
 631   /* find the block device file */
 632
 633 #ifdef HPUX
 634   /* Need to set the cache flag to 1 for HPUX. Seems
 635    * to have a significant performance boost when
 636    * lstat calls on /dev access this function.
 637    */
 638   if ((sys_stat(path, &S, false)<0)
 639       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 1)<0))
 640 #else
 641   if ((sys_stat(path, &S, false)<0)
 642       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 0)<0))
 643         return (False);
 644 #endif /* ifdef HPUX */
 645
 646 #endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__) */
 647
 648   euser_id = geteuid();
 649
 650 #ifdef HPUX
 651   /* for HPUX, real uid must be same as euid to execute quotactl for euid */
 652   save_re_uid();
 653   if (set_re_uid() != 0) return False;
 654
 655   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
 656
 657   restore_re_uid();
 658 #else
 659 #if   defined(AIX)
 660   /* AIX has both USER and GROUP quotas:
 661      Get the USER quota (ohnielse@fysik.dtu.dk) */
 662 #ifdef _AIXVERSION_530
 663   {
 664     struct statfs statbuf;
 665     quota64_t user_quota;
 666     if (statfs(path,&statbuf) != 0)
 667       return False;
 668     if(statbuf.f_vfstype == MNT_J2)
 669     {
 670     /* For some reason we need to be root for jfs2 */
 671       become_root();
 672       r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
 673       unbecome_root();
 674     /* Copy results to old struct to let the following code work as before */
 675       D.dqb_curblocks  = user_quota.bused;
 676       D.dqb_bsoftlimit = user_quota.bsoft;
 677       D.dqb_bhardlimit = user_quota.bhard;
 678       D.dqb_curfiles   = user_quota.iused;
 679       D.dqb_fsoftlimit = user_quota.isoft;
 680       D.dqb_fhardlimit = user_quota.ihard;
 681     }
 682     else if(statbuf.f_vfstype == MNT_JFS)
 683     {
 684 #endif /* AIX 5.3 */
 685   save_re_uid();
 686   if (set_re_uid() != 0)
 687     return False;
 688   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
 689   restore_re_uid();
 690 #ifdef _AIXVERSION_530
 691     }
 692     else
 693       r = 1; /* Fail for other FS-types */
 694   }
 695 #endif /* AIX 5.3 */
 696 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
 697   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
 698 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
 699 #endif /* HPUX */
 700
 701   /* Use softlimit to determine disk space, except when it has been exceeded */
 702   *bsize = 1024;
 703
 704   if (r)
 705     {
 706       if (errno == EDQUOT)
 707         {
 708           *dfree =0;
 709           *dsize =D.dqb_curblocks;
 710           return (True);
 711         }
 712       else return(False);
 713     }
 714
 715   /* If softlimit is zero, set it equal to hardlimit.
 716    */
 717
 718   if (D.dqb_bsoftlimit==0)
 719     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 720
 721   if (D.dqb_bsoftlimit==0)
 722     return(False);
 723   /* Use softlimit to determine disk space, except when it has been exceeded */
 724   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
 725 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
 726     ) {
 727       *dfree = 0;
 728       *dsize = D.dqb_curblocks;
 729     }
 730   else {
 731     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 732     *dsize = D.dqb_bsoftlimit;
 733   }
 734   return (True);
 735 }
 736
 737 #endif
 738
 739 #if definedr(LINUX) || defined(SUNOS) || defined (__FreeBSD__) || defined(__DragonFly__)
 740 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
 741 {
 742         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
 743                 return(0);
 744         if (!xdr_int(xdrsp, &args->gqa_uid))
 745                 return(0);
 746         return (1);
 747 }
 748 #endif
 749
 750 #if defined(VXFS_QUOTA)
 751
 752 /****************************************************************************
 753 Try to get the disk space from Veritas disk quotas.
 754     David Lee <T.D.Lee@durham.ac.uk> August 1999.
 755
 756 Background assumptions:
 757     Potentially under many Operating Systems.  Initially Solaris 2.
 758
 759     My guess is that Veritas is largely, though not entirely,
 760     independent of OS.  So I have separated it out.
 761
 762     There may be some details.  For example, OS-specific "include" files.
 763
 764     It is understood that HPUX 10 somehow gets Veritas quotas without
 765     any special effort; if so, this routine need not be compiled in.
 766         Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
 767
 768 Warning:
 769     It is understood that Veritas do not publicly support this ioctl interface.
 770     Rather their preference would be for the user (us) to call the native
 771     OS and then for the OS itself to call through to the VxFS filesystem.
 772     Presumably HPUX 10, see above, does this.
 773
 774 Hints for porting:
 775     Add your OS to "IFLIST" below.
 776     Get it to compile successfully:
 777         Almost certainly "include"s require attention: see SUNOS5.
 778     In the main code above, arrange for it to be called: see SUNOS5.
 779     Test!
 780
 781 ****************************************************************************/
 782
 783 /* "IFLIST"
 784  * This "if" is a list of ports:
 785  *      if defined(OS1) || defined(OS2) || ...
 786  */
 787 #if defined(SUNOS5)
 788
 789 #if defined(SUNOS5)
 790 #include <sys/fs/vx_solaris.h>
 791 #endif
 792 #include <sys/fs/vx_machdep.h>
 793 #include <sys/fs/vx_layout.h>
 794 #include <sys/fs/vx_quota.h>
 795 #include <sys/fs/vx_aioctl.h>
 796 #include <sys/fs/vx_ioctl.h>
 797
 798 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 799 {
 800   uid_t user_id, euser_id;
 801   int ret;
 802   struct vx_dqblk D;
 803   struct vx_quotctl quotabuf;
 804   struct vx_genioctl genbuf;
 805   char *qfname;
 806   int file;
 807
 808   /*
 809    * "name" may or may not include a trailing "/quotas".
 810    * Arranging consistency of calling here in "quotas.c" may not be easy and
 811    * it might be easier to examine and adjust it here.
 812    * Fortunately, VxFS seems not to mind at present.
 813    */
 814   qfname = talloc_strdup(talloc_tos(), name);
 815   if (!qfname) {
 816           return false;
 817   }
 818   /* pstrcat(qfname, "/quotas") ; */    /* possibly examine and adjust "name" */
 819
 820   euser_id = geteuid();
 821   set_effective_uid(0);
 822
 823   DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
 824   if((file=open(qfname, O_RDONLY,0))<0) {
 825     set_effective_uid(euser_id);
 826     return(False);
 827   }
 828   genbuf.ioc_cmd = VX_QUOTACTL;
 829   genbuf.ioc_up = (void *) &quotabuf;
 830
 831   quotabuf.cmd = VX_GETQUOTA;
 832   quotabuf.uid = euser_id;
 833   quotabuf.addr = (caddr_t) &D;
 834   ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
 835   close(file);
 836
 837   set_effective_uid(euser_id);
 838
 839   if (ret < 0) {
 840     DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
 841     return(False);
 842   }
 843
 844   /* If softlimit is zero, set it equal to hardlimit.
 845    */
 846
 847   if (D.dqb_bsoftlimit==0)
 848     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 849
 850   /* Use softlimit to determine disk space. A user exceeding the quota is told
 851    * that there's no space left. Writes might actually work for a bit if the
 852    * hardlimit is set higher than softlimit. Effectively the disk becomes
 853    * made of rubber latex and begins to expand to accommodate the user :-)
 854    */
 855   DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
 856          path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
 857          D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
 858
 859   if (D.dqb_bsoftlimit==0)
 860     return(False);
 861   *bsize = DEV_BSIZE;
 862   *dsize = D.dqb_bsoftlimit;
 863
 864   if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 865      *dfree = 0;
 866      *dsize = D.dqb_curblocks;
 867   } else
 868     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 869
 870   DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",
 871          path,(double)*bsize,(double)*dfree,(double)*dsize));
 872
 873   return(True);
 874 }
 875
 876 #endif /* SUNOS5 || ... */
 877
 878 #endif /* VXFS_QUOTA */
 879
 880 #else /* WITH_QUOTAS */
 881
 882 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
 883 {
 884         (*bsize) = 512; /* This value should be ignored */
 885
 886         /* And just to be sure we set some values that hopefully */
 887         /* will be larger that any possible real-world value     */
 888         (*dfree) = (uint64_t)-1;
 889         (*dsize) = (uint64_t)-1;
 890
 891         /* As we have select not to use quotas, allways fail */
 892         return false;
 893 }
 894 #endif /* WITH_QUOTAS */
 895
 896 #else /* HAVE_SYS_QUOTAS */
 897 /* wrapper to the new sys_quota interface
 898    this file should be removed later
 899    */
 900 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
 901 {
 902         int r;
 903         SMB_DISK_QUOTA D;
 904         unid_t id;
 905
 906         id.uid = geteuid();
 907
 908         ZERO_STRUCT(D);
 909         r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
 910
 911         /* Use softlimit to determine disk space, except when it has been exceeded */
 912         *bsize = D.bsize;
 913         if (r == -1) {
 914                 if (errno == EDQUOT) {
 915                         *dfree =0;
 916                         *dsize =D.curblocks;
 917                         return (True);
 918                 } else {
 919                         goto try_group_quota;
 920                 }
 921         }
 922
 923         /* Use softlimit to determine disk space, except when it has been exceeded */
 924         if (
 925                 (D.softlimit && D.curblocks >= D.softlimit) ||
 926                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 927                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 928                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 929         ) {
 930                 *dfree = 0;
 931                 *dsize = D.curblocks;
 932         } else if (D.softlimit==0 && D.hardlimit==0) {
 933                 goto try_group_quota;
 934         } else {
 935                 if (D.softlimit == 0)
 936                         D.softlimit = D.hardlimit;
 937                 *dfree = D.softlimit - D.curblocks;
 938                 *dsize = D.softlimit;
 939         }
 940
 941         return True;
 942
 943 try_group_quota:
 944         id.gid = getegid();
 945
 946         ZERO_STRUCT(D);
 947         r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
 948
 949         /* Use softlimit to determine disk space, except when it has been exceeded */
 950         *bsize = D.bsize;
 951         if (r == -1) {
 952                 if (errno == EDQUOT) {
 953                         *dfree =0;
 954                         *dsize =D.curblocks;
 955                         return (True);
 956                 } else {
 957                         return False;
 958                 }
 959         }
 960
 961         /* Use softlimit to determine disk space, except when it has been exceeded */
 962         if (
 963                 (D.softlimit && D.curblocks >= D.softlimit) ||
 964                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 965                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 966                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 967         ) {
 968                 *dfree = 0;
 969                 *dsize = D.curblocks;
 970         } else if (D.softlimit==0 && D.hardlimit==0) {
 971                 return False;
 972         } else {
 973                 if (D.softlimit == 0)
 974                         D.softlimit = D.hardlimit;
 975                 *dfree = D.softlimit - D.curblocks;
 976                 *dsize = D.softlimit;
 977         }
 978
 979         return (True);
 980 }
 981 #endif /* HAVE_SYS_QUOTAS */