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 #else
 471
 472 #if           AIX
 473 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
 474 #include <jfs/quota.h>
 475 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
 476 #define dqb_curfiles dqb_curinodes
 477 #define dqb_fhardlimit dqb_ihardlimit
 478 #define dqb_fsoftlimit dqb_isoftlimit
 479 #ifdef _AIXVERSION_530
 480 #include <sys/statfs.h>
 481 #include <sys/vmount.h>
 482 #endif /* AIX 5.3 */
 483 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
 484 #include <sys/quota.h>
 485 #include <devnm.h>
 486 #endif
 487
 488
 489 /****************************************************************************
 490 try to get the disk space from disk quotas - default version
 491 ****************************************************************************/
 492
 493 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 494 {
 495   int r;
 496   struct dqblk D;
 497   uid_t euser_id;
 498 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__)
 499   char dev_disk[256];
 500   SMB_STRUCT_STAT S;
 501
 502   /* find the block device file */
 503
 504   if ((sys_stat(path, &S, false)<0)
 505       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 0)<0))
 506         return (False);
 507
 508 #endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__) */
 509
 510   euser_id = geteuid();
 511
 512 #if   defined(AIX)
 513   /* AIX has both USER and GROUP quotas:
 514      Get the USER quota (ohnielse@fysik.dtu.dk) */
 515 #ifdef _AIXVERSION_530
 516   {
 517     struct statfs statbuf;
 518     quota64_t user_quota;
 519     if (statfs(path,&statbuf) != 0)
 520       return False;
 521     if(statbuf.f_vfstype == MNT_J2)
 522     {
 523     /* For some reason we need to be root for jfs2 */
 524       become_root();
 525       r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
 526       unbecome_root();
 527     /* Copy results to old struct to let the following code work as before */
 528       D.dqb_curblocks  = user_quota.bused;
 529       D.dqb_bsoftlimit = user_quota.bsoft;
 530       D.dqb_bhardlimit = user_quota.bhard;
 531       D.dqb_curfiles   = user_quota.iused;
 532       D.dqb_fsoftlimit = user_quota.isoft;
 533       D.dqb_fhardlimit = user_quota.ihard;
 534     }
 535     else if(statbuf.f_vfstype == MNT_JFS)
 536     {
 537 #endif /* AIX 5.3 */
 538   save_re_uid();
 539   if (set_re_uid() != 0)
 540     return False;
 541   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
 542   restore_re_uid();
 543 #ifdef _AIXVERSION_530
 544     }
 545     else
 546       r = 1; /* Fail for other FS-types */
 547   }
 548 #endif /* AIX 5.3 */
 549 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
 550   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
 551 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
 552
 553   /* Use softlimit to determine disk space, except when it has been exceeded */
 554   *bsize = 1024;
 555
 556   if (r)
 557     {
 558       if (errno == EDQUOT)
 559         {
 560           *dfree =0;
 561           *dsize =D.dqb_curblocks;
 562           return (True);
 563         }
 564       else return(False);
 565     }
 566
 567   /* If softlimit is zero, set it equal to hardlimit.
 568    */
 569
 570   if (D.dqb_bsoftlimit==0)
 571     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 572
 573   if (D.dqb_bsoftlimit==0)
 574     return(False);
 575   /* Use softlimit to determine disk space, except when it has been exceeded */
 576   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
 577 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
 578     ) {
 579       *dfree = 0;
 580       *dsize = D.dqb_curblocks;
 581     }
 582   else {
 583     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 584     *dsize = D.dqb_bsoftlimit;
 585   }
 586   return (True);
 587 }
 588
 589 #endif
 590
 591 #if definedr(LINUX) || defined(SUNOS) || defined (__FreeBSD__) || defined(__DragonFly__)
 592 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
 593 {
 594         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
 595                 return(0);
 596         if (!xdr_int(xdrsp, &args->gqa_uid))
 597                 return(0);
 598         return (1);
 599 }
 600 #endif
 601
 602 #if defined(VXFS_QUOTA)
 603
 604 /****************************************************************************
 605 Try to get the disk space from Veritas disk quotas.
 606     David Lee <T.D.Lee@durham.ac.uk> August 1999.
 607
 608 Background assumptions:
 609     Potentially under many Operating Systems.  Initially Solaris 2.
 610
 611     My guess is that Veritas is largely, though not entirely,
 612     independent of OS.  So I have separated it out.
 613
 614     There may be some details.  For example, OS-specific "include" files.
 615
 616     It is understood that HPUX 10 somehow gets Veritas quotas without
 617     any special effort; if so, this routine need not be compiled in.
 618         Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
 619
 620 Warning:
 621     It is understood that Veritas do not publicly support this ioctl interface.
 622     Rather their preference would be for the user (us) to call the native
 623     OS and then for the OS itself to call through to the VxFS filesystem.
 624     Presumably HPUX 10, see above, does this.
 625
 626 Hints for porting:
 627     Add your OS to "IFLIST" below.
 628     Get it to compile successfully:
 629         Almost certainly "include"s require attention: see SUNOS5.
 630     In the main code above, arrange for it to be called: see SUNOS5.
 631     Test!
 632
 633 ****************************************************************************/
 634
 635 /* "IFLIST"
 636  * This "if" is a list of ports:
 637  *      if defined(OS1) || defined(OS2) || ...
 638  */
 639 #if defined(SUNOS5)
 640
 641 #if defined(SUNOS5)
 642 #include <sys/fs/vx_solaris.h>
 643 #endif
 644 #include <sys/fs/vx_machdep.h>
 645 #include <sys/fs/vx_layout.h>
 646 #include <sys/fs/vx_quota.h>
 647 #include <sys/fs/vx_aioctl.h>
 648 #include <sys/fs/vx_ioctl.h>
 649
 650 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 651 {
 652   uid_t user_id, euser_id;
 653   int ret;
 654   struct vx_dqblk D;
 655   struct vx_quotctl quotabuf;
 656   struct vx_genioctl genbuf;
 657   char *qfname;
 658   int file;
 659
 660   /*
 661    * "name" may or may not include a trailing "/quotas".
 662    * Arranging consistency of calling here in "quotas.c" may not be easy and
 663    * it might be easier to examine and adjust it here.
 664    * Fortunately, VxFS seems not to mind at present.
 665    */
 666   qfname = talloc_strdup(talloc_tos(), name);
 667   if (!qfname) {
 668           return false;
 669   }
 670   /* pstrcat(qfname, "/quotas") ; */    /* possibly examine and adjust "name" */
 671
 672   euser_id = geteuid();
 673   set_effective_uid(0);
 674
 675   DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
 676   if((file=open(qfname, O_RDONLY,0))<0) {
 677     set_effective_uid(euser_id);
 678     return(False);
 679   }
 680   genbuf.ioc_cmd = VX_QUOTACTL;
 681   genbuf.ioc_up = (void *) &quotabuf;
 682
 683   quotabuf.cmd = VX_GETQUOTA;
 684   quotabuf.uid = euser_id;
 685   quotabuf.addr = (caddr_t) &D;
 686   ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
 687   close(file);
 688
 689   set_effective_uid(euser_id);
 690
 691   if (ret < 0) {
 692     DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
 693     return(False);
 694   }
 695
 696   /* If softlimit is zero, set it equal to hardlimit.
 697    */
 698
 699   if (D.dqb_bsoftlimit==0)
 700     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 701
 702   /* Use softlimit to determine disk space. A user exceeding the quota is told
 703    * that there's no space left. Writes might actually work for a bit if the
 704    * hardlimit is set higher than softlimit. Effectively the disk becomes
 705    * made of rubber latex and begins to expand to accommodate the user :-)
 706    */
 707   DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
 708          path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
 709          D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
 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 #endif /* SUNOS5 || ... */
 729
 730 #endif /* VXFS_QUOTA */
 731
 732 #else /* WITH_QUOTAS */
 733
 734 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
 735 {
 736         (*bsize) = 512; /* This value should be ignored */
 737
 738         /* And just to be sure we set some values that hopefully */
 739         /* will be larger that any possible real-world value     */
 740         (*dfree) = (uint64_t)-1;
 741         (*dsize) = (uint64_t)-1;
 742
 743         /* As we have select not to use quotas, allways fail */
 744         return false;
 745 }
 746 #endif /* WITH_QUOTAS */
 747
 748 #else /* HAVE_SYS_QUOTAS */
 749 /* wrapper to the new sys_quota interface
 750    this file should be removed later
 751    */
 752 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
 753 {
 754         int r;
 755         SMB_DISK_QUOTA D;
 756         unid_t id;
 757
 758         id.uid = geteuid();
 759
 760         ZERO_STRUCT(D);
 761         r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
 762
 763         /* Use softlimit to determine disk space, except when it has been exceeded */
 764         *bsize = D.bsize;
 765         if (r == -1) {
 766                 if (errno == EDQUOT) {
 767                         *dfree =0;
 768                         *dsize =D.curblocks;
 769                         return (True);
 770                 } else {
 771                         goto try_group_quota;
 772                 }
 773         }
 774
 775         /* Use softlimit to determine disk space, except when it has been exceeded */
 776         if (
 777                 (D.softlimit && D.curblocks >= D.softlimit) ||
 778                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 779                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 780                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 781         ) {
 782                 *dfree = 0;
 783                 *dsize = D.curblocks;
 784         } else if (D.softlimit==0 && D.hardlimit==0) {
 785                 goto try_group_quota;
 786         } else {
 787                 if (D.softlimit == 0)
 788                         D.softlimit = D.hardlimit;
 789                 *dfree = D.softlimit - D.curblocks;
 790                 *dsize = D.softlimit;
 791         }
 792
 793         return True;
 794
 795 try_group_quota:
 796         id.gid = getegid();
 797
 798         ZERO_STRUCT(D);
 799         r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
 800
 801         /* Use softlimit to determine disk space, except when it has been exceeded */
 802         *bsize = D.bsize;
 803         if (r == -1) {
 804                 if (errno == EDQUOT) {
 805                         *dfree =0;
 806                         *dsize =D.curblocks;
 807                         return (True);
 808                 } else {
 809                         return False;
 810                 }
 811         }
 812
 813         /* Use softlimit to determine disk space, except when it has been exceeded */
 814         if (
 815                 (D.softlimit && D.curblocks >= D.softlimit) ||
 816                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 817                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 818                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 819         ) {
 820                 *dfree = 0;
 821                 *dsize = D.curblocks;
 822         } else if (D.softlimit==0 && D.hardlimit==0) {
 823                 return False;
 824         } else {
 825                 if (D.softlimit == 0)
 826                         D.softlimit = D.hardlimit;
 827                 *dfree = D.softlimit - D.curblocks;
 828                 *dsize = D.softlimit;
 829         }
 830
 831         return (True);
 832 }
 833 #endif /* HAVE_SYS_QUOTAS */