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 #ifdef LINUX
  55
  56 #include <sys/types.h>
  57 #include <mntent.h>
  58
  59 /*
  60  * This shouldn't be neccessary - it should be /usr/include/sys/quota.h
  61  * So we include all the files has *should* be in the system into a large,
  62  * grungy samba_linux_quoatas.h Sometimes I *hate* Linux :-). JRA.
  63  */
  64
  65 #include "samba_linux_quota.h"
  66
  67 typedef struct _LINUX_SMB_DISK_QUOTA {
  68         uint64_t bsize;
  69         uint64_t hardlimit; /* In bsize units. */
  70         uint64_t softlimit; /* In bsize units. */
  71         uint64_t curblocks; /* In bsize units. */
  72         uint64_t ihardlimit; /* inode hard limit. */
  73         uint64_t isoftlimit; /* inode soft limit. */
  74         uint64_t curinodes; /* Current used inodes. */
  75 } LINUX_SMB_DISK_QUOTA;
  76
  77
  78 /*
  79  * nfs quota support
  80  * (essentially taken from FreeBSD / SUNOS5 section)
  81  */
  82 #include <rpc/rpc.h>
  83 #include <rpc/types.h>
  84 #include <rpcsvc/rquota.h>
  85 #ifdef HAVE_RPC_NETTYPE_H
  86 #include <rpc/nettype.h>
  87 #endif
  88 #include <rpc/xdr.h>
  89
  90 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
  91 {
  92         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
  93                 return(0);
  94         if (!xdr_int(xdrsp, &args->gqa_uid))
  95                 return(0);
  96         return (1);
  97 }
  98
  99 static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
 100 {
 101         int quotastat;
 102
 103         if (!xdr_int(xdrsp, &quotastat)) {
 104                 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
 105                 return 0;
 106         }
 107         gqr->status = quotastat;
 108
 109         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
 110                 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
 111                 return 0;
 112         }
 113         if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
 114                 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
 115                 return 0;
 116         }
 117         if (!xdr_int(xdrsp, (int *)&gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
 118                 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
 119                 return 0;
 120         }
 121         if (!xdr_int(xdrsp, (int *)&gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
 122                 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
 123                 return 0;
 124         }
 125         if (!xdr_int(xdrsp, (int *)&gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
 126                 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
 127                 return 0;
 128         }
 129         return 1;
 130 }
 131
 132 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize,
 133                        uint64_t *dfree, uint64_t *dsize)
 134 {
 135         uid_t uid = euser_id;
 136         LINUX_SMB_DISK_QUOTA D;
 137         char *mnttype = nfspath;
 138         CLIENT *clnt;
 139         struct getquota_rslt gqr;
 140         struct getquota_args args;
 141         char *cutstr, *pathname, *host, *testpath;
 142         int len;
 143         static struct timeval timeout = {2,0};
 144         enum clnt_stat clnt_stat;
 145         bool ret = True;
 146
 147         *bsize = *dfree = *dsize = (uint64_t)0;
 148
 149         len=strcspn(mnttype, ":");
 150         pathname=strstr(mnttype, ":");
 151         cutstr = (char *) SMB_MALLOC(len+1);
 152         if (!cutstr)
 153                 return False;
 154
 155         memset(cutstr, '\0', len+1);
 156         host = strncat(cutstr,mnttype, sizeof(char) * len );
 157         DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
 158         DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
 159         testpath=strchr_m(mnttype, ':');
 160         args.gqa_pathp = testpath+1;
 161         args.gqa_uid = uid;
 162
 163         DEBUG(5, ("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers "
 164                   "\"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS,
 165                   "udp"));
 166
 167         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
 168                 ret = False;
 169                 goto out;
 170         }
 171
 172         clnt->cl_auth = authunix_create_default();
 173         DEBUG(9,("nfs_quotas: auth_success\n"));
 174
 175         clnt_stat=clnt_call(clnt,
 176                             RQUOTAPROC_GETQUOTA,
 177                             (const xdrproc_t)my_xdr_getquota_args,
 178                             (caddr_t)&args,
 179                             (const xdrproc_t)my_xdr_getquota_rslt,
 180                             (caddr_t)&gqr, timeout);
 181
 182         if (clnt_stat != RPC_SUCCESS) {
 183                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
 184                 ret = False;
 185                 goto out;
 186         }
 187
 188         /*
 189          * gqr.status returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
 190          * no quota set, and 3 if no permission to get the quota.  If 0 or 3 return
 191          * something sensible.
 192          */
 193
 194         switch (gqr.status) {
 195         case 0:
 196                 DEBUG(9, ("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n",
 197                           gqr.status));
 198                 ret = False;
 199                 goto out;
 200
 201         case 1:
 202                 DEBUG(9,("nfs_quotas: Good quota data\n"));
 203                 D.softlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
 204                 D.hardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
 205                 D.curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
 206                 break;
 207
 208         case 2:
 209         case 3:
 210                 D.softlimit = 1;
 211                 D.curblocks = 1;
 212                 DEBUG(9, ("nfs_quotas: Remote Quotas returned \"%i\" \n",
 213                           gqr.status));
 214                 break;
 215
 216         default:
 217                 DEBUG(9, ("nfs_quotas: Remote Quotas Questionable!  "
 218                           "Error \"%i\" \n", gqr.status));
 219                 break;
 220         }
 221
 222         DEBUG(10, ("nfs_quotas: Let`s look at D a bit closer... "
 223                    "status \"%i\" bsize \"%i\" active? \"%i\" bhard "
 224                    "\"%i\" bsoft \"%i\" curb \"%i\" \n",
 225                    gqr.status,
 226                    gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
 227                    gqr.getquota_rslt_u.gqr_rquota.rq_active,
 228                    gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
 229                    gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
 230                    gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
 231
 232         if (D.softlimit == 0)
 233                 D.softlimit = D.hardlimit;
 234         if (D.softlimit == 0)
 235                 return False;
 236
 237         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
 238         *dsize = D.softlimit;
 239
 240         if (D.curblocks == 1)
 241                 *bsize = DEV_BSIZE;
 242
 243         if (D.curblocks > D.softlimit) {
 244                 *dfree = 0;
 245                 *dsize = D.curblocks;
 246         } else
 247                 *dfree = D.softlimit - D.curblocks;
 248
 249   out:
 250
 251         if (clnt) {
 252                 if (clnt->cl_auth)
 253                         auth_destroy(clnt->cl_auth);
 254                 clnt_destroy(clnt);
 255         }
 256
 257         DEBUG(5, ("nfs_quotas: For path \"%s\" returning "
 258                   "bsize %.0f, dfree %.0f, dsize %.0f\n",
 259                   args.gqa_pathp, (double)*bsize, (double)*dfree,
 260                   (double)*dsize));
 261
 262         SAFE_FREE(cutstr);
 263         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
 264         return ret;
 265 }
 266
 267 /* end of nfs quota section */
 268
 269 #ifdef HAVE_LINUX_DQBLK_XFS_H
 270 #include <linux/dqblk_xfs.h>
 271
 272 /****************************************************************************
 273  Abstract out the XFS Quota Manager quota get call.
 274 ****************************************************************************/
 275
 276 static int get_smb_linux_xfs_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp)
 277 {
 278         struct fs_disk_quota D;
 279         int ret;
 280
 281         ZERO_STRUCT(D);
 282
 283         ret = quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
 284
 285         if (ret)
 286                 ret = quotactl(QCMD(Q_XGETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
 287
 288         if (ret)
 289                 return ret;
 290
 291         dp->bsize = (uint64_t)512;
 292         dp->softlimit = (uint64_t)D.d_blk_softlimit;
 293         dp->hardlimit = (uint64_t)D.d_blk_hardlimit;
 294         dp->ihardlimit = (uint64_t)D.d_ino_hardlimit;
 295         dp->isoftlimit = (uint64_t)D.d_ino_softlimit;
 296         dp->curinodes = (uint64_t)D.d_icount;
 297         dp->curblocks = (uint64_t)D.d_bcount;
 298
 299         return ret;
 300 }
 301 #else
 302 static int get_smb_linux_xfs_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp)
 303 {
 304         DEBUG(0,("XFS quota support not available\n"));
 305         errno = ENOSYS;
 306         return -1;
 307 }
 308 #endif
 309
 310
 311 /****************************************************************************
 312  Abstract out the old and new Linux quota get calls.
 313 ****************************************************************************/
 314
 315 static int get_smb_linux_v1_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp)
 316 {
 317         struct v1_kern_dqblk D;
 318         int ret;
 319
 320         ZERO_STRUCT(D);
 321
 322         ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
 323
 324         if (ret && errno != EDQUOT)
 325                 ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
 326
 327         if (ret && errno != EDQUOT)
 328                 return ret;
 329
 330         dp->bsize = (uint64_t)QUOTABLOCK_SIZE;
 331         dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
 332         dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
 333         dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
 334         dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
 335         dp->curinodes = (uint64_t)D.dqb_curinodes;
 336         dp->curblocks = (uint64_t)D.dqb_curblocks;
 337
 338         return ret;
 339 }
 340
 341 static int get_smb_linux_v2_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp)
 342 {
 343         struct v2_kern_dqblk D;
 344         int ret;
 345
 346         ZERO_STRUCT(D);
 347
 348         ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
 349
 350         if (ret && errno != EDQUOT)
 351                 ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
 352
 353         if (ret && errno != EDQUOT)
 354                 return ret;
 355
 356         dp->bsize = (uint64_t)QUOTABLOCK_SIZE;
 357         dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
 358         dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
 359         dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
 360         dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
 361         dp->curinodes = (uint64_t)D.dqb_curinodes;
 362         dp->curblocks = ((uint64_t)D.dqb_curspace) / dp->bsize;
 363
 364         return ret;
 365 }
 366
 367 /****************************************************************************
 368  Brand-new generic quota interface.
 369 ****************************************************************************/
 370
 371 static int get_smb_linux_gen_quota(char *path, uid_t euser_id, gid_t egrp_id, LINUX_SMB_DISK_QUOTA *dp)
 372 {
 373         struct if_dqblk D;
 374         int ret;
 375
 376         ZERO_STRUCT(D);
 377
 378         ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), path, euser_id, (caddr_t)&D);
 379
 380         if (ret && errno != EDQUOT)
 381                 ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), path, egrp_id, (caddr_t)&D);
 382
 383         if (ret && errno != EDQUOT)
 384                 return ret;
 385
 386         dp->bsize = (uint64_t)QUOTABLOCK_SIZE;
 387         dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
 388         dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
 389         dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
 390         dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
 391         dp->curinodes = (uint64_t)D.dqb_curinodes;
 392         dp->curblocks = ((uint64_t)D.dqb_curspace) / dp->bsize;
 393
 394         return ret;
 395 }
 396
 397 /****************************************************************************
 398  Try to get the disk space from disk quotas (LINUX version).
 399 ****************************************************************************/
 400
 401 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 402 {
 403         int r;
 404         SMB_STRUCT_STAT S;
 405         FILE *fp;
 406         LINUX_SMB_DISK_QUOTA D;
 407         struct mntent *mnt;
 408         SMB_DEV_T devno;
 409         int found;
 410         uid_t euser_id;
 411         gid_t egrp_id;
 412
 413         ZERO_STRUCT(D);
 414
 415         euser_id = geteuid();
 416         egrp_id = getegid();
 417
 418         /* find the block device file */
 419
 420         if (sys_stat(path, &S, false) == -1 )
 421                 return(False) ;
 422
 423         devno = S.st_ex_dev ;
 424
 425         if ((fp = setmntent(MOUNTED,"r")) == NULL)
 426                 return(False) ;
 427
 428         found = False ;
 429
 430         while ((mnt = getmntent(fp))) {
 431                 if (sys_stat(mnt->mnt_dir, &S, false) == -1)
 432                         continue ;
 433
 434                 if (S.st_ex_dev == devno) {
 435                         found = True ;
 436                         break;
 437                 }
 438         }
 439
 440         endmntent(fp) ;
 441
 442         if (!found)
 443                 return(False);
 444
 445         become_root();
 446
 447         if (strcmp(mnt->mnt_type, "nfs") == 0) {
 448                 bool retval;
 449                 retval = nfs_quotas(mnt->mnt_fsname , euser_id, bsize, dfree, dsize);
 450                 unbecome_root();
 451                 return retval;
 452         }
 453
 454         if (strcmp(mnt->mnt_type, "xfs")==0) {
 455                 r=get_smb_linux_xfs_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
 456         } else {
 457                 r=get_smb_linux_gen_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
 458                 if (r == -1 && errno != EDQUOT) {
 459                         r=get_smb_linux_v2_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
 460                         if (r == -1 && errno != EDQUOT)
 461                                 r=get_smb_linux_v1_quota(mnt->mnt_fsname, euser_id, egrp_id, &D);
 462                 }
 463         }
 464
 465         unbecome_root();
 466
 467         /* Use softlimit to determine disk space, except when it has been exceeded */
 468         *bsize = D.bsize;
 469         if (r == -1) {
 470                 if (errno == EDQUOT) {
 471                         *dfree =0;
 472                         *dsize =D.curblocks;
 473                         return (True);
 474                 } else {
 475                         return(False);
 476                 }
 477         }
 478
 479         /* Use softlimit to determine disk space, except when it has been exceeded */
 480         if (
 481                 (D.softlimit && D.curblocks >= D.softlimit) ||
 482                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
 483                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
 484                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
 485         ) {
 486                 *dfree = 0;
 487                 *dsize = D.curblocks;
 488         } else if (D.softlimit==0 && D.hardlimit==0) {
 489                 return(False);
 490         } else {
 491                 if (D.softlimit == 0)
 492                         D.softlimit = D.hardlimit;
 493                 *dfree = D.softlimit - D.curblocks;
 494                 *dsize = D.softlimit;
 495         }
 496
 497         return (True);
 498 }
 499
 500 #elif defined(CRAY)
 501
 502 #include <sys/quota.h>
 503 #include <mntent.h>
 504
 505 /****************************************************************************
 506 try to get the disk space from disk quotas (CRAY VERSION)
 507 ****************************************************************************/
 508
 509 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 510 {
 511         struct mntent *mnt;
 512         FILE *fd;
 513         SMB_STRUCT_STAT sbuf;
 514         SMB_DEV_T devno ;
 515         struct q_request request ;
 516         struct qf_header header ;
 517         int quota_default = 0 ;
 518         bool found = false;
 519
 520         if (sys_stat(path, &sbuf, false) == -1) {
 521                 return false;
 522         }
 523
 524         devno = sbuf.st_ex_dev ;
 525
 526         if ((fd = setmntent(KMTAB)) == NULL) {
 527                 return false;
 528         }
 529
 530         while ((mnt = getmntent(fd)) != NULL) {
 531                 if (sys_stat(mnt->mnt_dir, &sbuf, false) == -1) {
 532                         continue;
 533                 }
 534                 if (sbuf.st_ex_dev == devno) {
 535                         found = frue ;
 536                         break;
 537                 }
 538         }
 539
 540         name = talloc_strdup(talloc_tos(), mnt->mnt_dir);
 541         endmntent(fd);
 542         if (!found) {
 543                 return false;
 544         }
 545
 546         if (!name) {
 547                 return false;
 548         }
 549
 550         request.qf_magic = QF_MAGIC ;
 551         request.qf_entry.id = geteuid() ;
 552
 553         if (quotactl(name, Q_GETQUOTA, &request) == -1) {
 554                 return false;
 555         }
 556
 557         if (!request.user) {
 558                 return False;
 559         }
 560
 561         if (request.qf_entry.user_q.f_quota == QFV_DEFAULT) {
 562                 if (!quota_default) {
 563                         if (quotactl(name, Q_GETHEADER, &header) == -1) {
 564                                 return false;
 565                         } else {
 566                                 quota_default = header.user_h.def_fq;
 567                         }
 568                 }
 569                 *dfree = quota_default;
 570         } else if (request.qf_entry.user_q.f_quota == QFV_PREVENT) {
 571                 *dfree = 0;
 572         } else {
 573                 *dfree = request.qf_entry.user_q.f_quota;
 574         }
 575
 576         *dsize = request.qf_entry.user_q.f_use;
 577
 578         if (*dfree < *dsize) {
 579                 *dfree = 0;
 580         } else {
 581                 *dfree -= *dsize;
 582         }
 583
 584         *bsize = 4096 ;  /* Cray blocksize */
 585         return true;
 586 }
 587
 588
 589 #elif defined(SUNOS5) || defined(SUNOS4)
 590
 591 #include <fcntl.h>
 592 #include <sys/param.h>
 593 #if defined(SUNOS5)
 594 #include <sys/fs/ufs_quota.h>
 595 #include <sys/mnttab.h>
 596 #include <sys/mntent.h>
 597 #else /* defined(SUNOS4) */
 598 #include <ufs/quota.h>
 599 #include <mntent.h>
 600 #endif
 601
 602 #if defined(SUNOS5)
 603
 604 /****************************************************************************
 605  Allows querying of remote hosts for quotas on NFS mounted shares.
 606  Supports normal NFS and AMD mounts.
 607  Alan Romeril <a.romeril@ic.ac.uk> July 2K.
 608 ****************************************************************************/
 609
 610 #include <rpc/rpc.h>
 611 #include <rpc/types.h>
 612 #include <rpcsvc/rquota.h>
 613 #include <rpc/nettype.h>
 614 #include <rpc/xdr.h>
 615
 616 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
 617 {
 618         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
 619                 return(0);
 620         if (!xdr_int(xdrsp, &args->gqa_uid))
 621                 return(0);
 622         return (1);
 623 }
 624
 625 static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
 626 {
 627         int quotastat;
 628
 629         if (!xdr_int(xdrsp, &quotastat)) {
 630                 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
 631                 return 0;
 632         }
 633         gqr->status = quotastat;
 634
 635         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
 636                 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
 637                 return 0;
 638         }
 639         if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
 640                 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
 641                 return 0;
 642         }
 643         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
 644                 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
 645                 return 0;
 646         }
 647         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
 648                 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
 649                 return 0;
 650         }
 651         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
 652                 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
 653                 return 0;
 654         }
 655         return (1);
 656 }
 657
 658 /* Restricted to SUNOS5 for the moment, I haven`t access to others to test. */
 659 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 660 {
 661         uid_t uid = euser_id;
 662         struct dqblk D;
 663         char *mnttype = nfspath;
 664         CLIENT *clnt;
 665         struct getquota_rslt gqr;
 666         struct getquota_args args;
 667         char *cutstr, *pathname, *host, *testpath;
 668         int len;
 669         static struct timeval timeout = {2,0};
 670         enum clnt_stat clnt_stat;
 671         bool ret = True;
 672
 673         *bsize = *dfree = *dsize = (uint64_t)0;
 674
 675         len=strcspn(mnttype, ":");
 676         pathname=strstr(mnttype, ":");
 677         cutstr = (char *) SMB_MALLOC(len+1);
 678         if (!cutstr)
 679                 return False;
 680
 681         memset(cutstr, '\0', len+1);
 682         host = strncat(cutstr,mnttype, sizeof(char) * len );
 683         DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
 684         DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
 685         testpath=strchr_m(mnttype, ':');
 686         args.gqa_pathp = testpath+1;
 687         args.gqa_uid = uid;
 688
 689         DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
 690
 691         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
 692                 ret = False;
 693                 goto out;
 694         }
 695
 696         clnt->cl_auth = authunix_create_default();
 697         DEBUG(9,("nfs_quotas: auth_success\n"));
 698
 699         clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, my_xdr_getquota_args, (caddr_t)&args, my_xdr_getquota_rslt, (caddr_t)&gqr, timeout);
 700
 701         if (clnt_stat != RPC_SUCCESS) {
 702                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
 703                 ret = False;
 704                 goto out;
 705         }
 706
 707         /*
 708          * gqr.status returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
 709          * no quota set, and 3 if no permission to get the quota.  If 0 or 3 return
 710          * something sensible.
 711          */
 712
 713         switch (gqr.status) {
 714         case 0:
 715                 DEBUG(9,("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n", gqr.status));
 716                 ret = False;
 717                 goto out;
 718
 719         case 1:
 720                 DEBUG(9,("nfs_quotas: Good quota data\n"));
 721                 D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
 722                 D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
 723                 D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
 724                 break;
 725
 726         case 2:
 727         case 3:
 728                 D.dqb_bsoftlimit = 1;
 729                 D.dqb_curblocks = 1;
 730                 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", gqr.status));
 731                 break;
 732
 733         default:
 734                 DEBUG(9,("nfs_quotas: Remote Quotas Questionable!  Error \"%i\" \n", gqr.status ));
 735                 break;
 736         }
 737
 738         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",
 739                         gqr.status,
 740                         gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
 741                         gqr.getquota_rslt_u.gqr_rquota.rq_active,
 742                         gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
 743                         gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
 744                         gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
 745
 746         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
 747         *dsize = D.dqb_bsoftlimit;
 748
 749         if (D.dqb_curblocks == 1)
 750                 *bsize = 512;
 751
 752         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 753                 *dfree = 0;
 754                 *dsize = D.dqb_curblocks;
 755         } else
 756                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 757
 758   out:
 759
 760         if (clnt) {
 761                 if (clnt->cl_auth)
 762                         auth_destroy(clnt->cl_auth);
 763                 clnt_destroy(clnt);
 764         }
 765
 766         DEBUG(5,("nfs_quotas: For path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
 767
 768         SAFE_FREE(cutstr);
 769         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
 770         return ret;
 771 }
 772 #endif
 773
 774 /****************************************************************************
 775 try to get the disk space from disk quotas (SunOS & Solaris2 version)
 776 Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
 777 ****************************************************************************/
 778
 779 bool disk_quotas(const char *path,
 780                 uint64_t *bsize,
 781                 uint64_t *dfree,
 782                 uint64_t *dsize)
 783 {
 784         uid_t euser_id;
 785         int ret;
 786         struct dqblk D;
 787 #if defined(SUNOS5)
 788         struct quotctl command;
 789         int file;
 790         struct mnttab mnt;
 791 #else /* SunOS4 */
 792         struct mntent *mnt;
 793 #endif
 794         char *name = NULL;
 795         FILE *fd;
 796         SMB_STRUCT_STAT sbuf;
 797         SMB_DEV_T devno;
 798         bool found = false;
 799
 800         euser_id = geteuid();
 801
 802         if (sys_stat(path, &sbuf, false) == -1) {
 803                 return false;
 804         }
 805
 806         devno = sbuf.st_ex_dev ;
 807         DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
 808                 path, (unsigned int)devno));
 809 #if defined(SUNOS5)
 810         if ((fd = fopen(MNTTAB, "r")) == NULL) {
 811                 return false;
 812         }
 813
 814         while (getmntent(fd, &mnt) == 0) {
 815                 if (sys_stat(mnt.mnt_mountp, &sbuf, false) == -1) {
 816                         continue;
 817                 }
 818
 819                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 820                         mnt.mnt_mountp, (unsigned int)devno));
 821
 822                 /* quotas are only on vxfs, UFS or NFS */
 823                 if ((sbuf.st_ex_dev == devno) && (
 824                         strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
 825                         strcmp( mnt.mnt_fstype, "nfs" ) == 0    ||
 826                         strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
 827                                 found = true;
 828                                 name = talloc_asprintf(talloc_tos(),
 829                                                 "%s/quotas",
 830                                                 mnt.mnt_mountp);
 831                                 break;
 832                 }
 833         }
 834
 835         fclose(fd);
 836 #else /* SunOS4 */
 837         if ((fd = setmntent(MOUNTED, "r")) == NULL) {
 838                 return false;
 839         }
 840
 841         while ((mnt = getmntent(fd)) != NULL) {
 842                 if (sys_stat(mnt->mnt_dir, &sbuf, false) == -1) {
 843                         continue;
 844                 }
 845                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 846                                         mnt->mnt_dir,
 847                                         (unsigned int)sbuf.st_ex_dev));
 848                 if (sbuf.st_ex_dev == devno) {
 849                         found = true;
 850                         name = talloc_strdup(talloc_tos(),
 851                                         mnt->mnt_fsname);
 852                         break;
 853                 }
 854         }
 855
 856         endmntent(fd);
 857 #endif
 858         if (!found) {
 859                 return false;
 860         }
 861
 862         if (!name) {
 863                 return false;
 864         }
 865         become_root();
 866
 867 #if defined(SUNOS5)
 868         if (strcmp(mnt.mnt_fstype, "nfs") == 0) {
 869                 bool retval;
 870                 DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n",
 871                                         mnt.mnt_special));
 872                 retval = nfs_quotas(mnt.mnt_special,
 873                                 euser_id, bsize, dfree, dsize);
 874                 unbecome_root();
 875                 return retval;
 876         }
 877
 878         DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
 879         if((file=open(name, O_RDONLY,0))<0) {
 880                 unbecome_root();
 881                 return false;
 882         }
 883         command.op = Q_GETQUOTA;
 884         command.uid = euser_id;
 885         command.addr = (caddr_t) &D;
 886         ret = ioctl(file, Q_QUOTACTL, &command);
 887         close(file);
 888 #else
 889         DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
 890         ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
 891 #endif
 892
 893         unbecome_root();
 894
 895         if (ret < 0) {
 896                 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n",
 897                                         strerror(errno) ));
 898
 899 #if defined(SUNOS5) && defined(VXFS_QUOTA)
 900                 /* If normal quotactl() fails, try vxfs private calls */
 901                 set_effective_uid(euser_id);
 902                 DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
 903                 if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
 904                         bool retval;
 905                         retval = disk_quotas_vxfs(name, path,
 906                                         bsize, dfree, dsize);
 907                         return retval;
 908                 }
 909 #else
 910                 return false;
 911 #endif
 912         }
 913
 914         /* If softlimit is zero, set it equal to hardlimit.
 915          */
 916
 917         if (D.dqb_bsoftlimit==0) {
 918                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
 919         }
 920
 921         /* Use softlimit to determine disk space. A user exceeding the quota
 922          * is told that there's no space left. Writes might actually work for
 923          * a bit if the hardlimit is set higher than softlimit. Effectively
 924          * the disk becomes made of rubber latex and begins to expand to
 925          * accommodate the user :-)
 926          */
 927
 928         if (D.dqb_bsoftlimit==0)
 929                 return(False);
 930         *bsize = DEV_BSIZE;
 931         *dsize = D.dqb_bsoftlimit;
 932
 933         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 934                 *dfree = 0;
 935                 *dsize = D.dqb_curblocks;
 936         } else {
 937                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 938         }
 939
 940         DEBUG(5,("disk_quotas for path \"%s\" returning "
 941                 "bsize %.0f, dfree %.0f, dsize %.0f\n",
 942                 path,(double)*bsize,(double)*dfree,(double)*dsize));
 943
 944         return true;
 945 }
 946
 947
 948 #elif defined(OSF1)
 949 #include <ufs/quota.h>
 950
 951 /****************************************************************************
 952 try to get the disk space from disk quotas - OSF1 version
 953 ****************************************************************************/
 954
 955 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 956 {
 957   int r, save_errno;
 958   struct dqblk D;
 959   SMB_STRUCT_STAT S;
 960   uid_t euser_id;
 961
 962   /*
 963    * This code presumes that OSF1 will only
 964    * give out quota info when the real uid
 965    * matches the effective uid. JRA.
 966    */
 967   euser_id = geteuid();
 968   save_re_uid();
 969   if (set_re_uid() != 0) return False;
 970
 971   r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D);
 972   if (r) {
 973      save_errno = errno;
 974   }
 975
 976   restore_re_uid();
 977
 978   *bsize = DEV_BSIZE;
 979
 980   if (r)
 981   {
 982       if (save_errno == EDQUOT)   /* disk quota exceeded */
 983       {
 984          *dfree = 0;
 985          *dsize = D.dqb_curblocks;
 986          return (True);
 987       }
 988       else
 989          return (False);
 990   }
 991
 992   /* If softlimit is zero, set it equal to hardlimit.
 993    */
 994
 995   if (D.dqb_bsoftlimit==0)
 996     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 997
 998   /* Use softlimit to determine disk space, except when it has been exceeded */
 999
1000   if (D.dqb_bsoftlimit==0)
1001     return(False);
1002
1003   if ((D.dqb_curblocks>D.dqb_bsoftlimit)) {
1004     *dfree = 0;
1005     *dsize = D.dqb_curblocks;
1006   } else {
1007     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1008     *dsize = D.dqb_bsoftlimit;
1009   }
1010   return (True);
1011 }
1012
1013 #elif defined (IRIX6)
1014 /****************************************************************************
1015 try to get the disk space from disk quotas (IRIX 6.2 version)
1016 ****************************************************************************/
1017
1018 #include <sys/quota.h>
1019 #include <mntent.h>
1020
1021 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1022 {
1023   uid_t euser_id;
1024   int r;
1025   struct dqblk D;
1026   struct fs_disk_quota        F;
1027   SMB_STRUCT_STAT S;
1028   FILE *fp;
1029   struct mntent *mnt;
1030   SMB_DEV_T devno;
1031   int found;
1032
1033   /* find the block device file */
1034
1035   if ( sys_stat(path, &S, false) == -1 ) {
1036     return(False) ;
1037   }
1038
1039   devno = S.st_ex_dev ;
1040
1041   fp = setmntent(MOUNTED,"r");
1042   found = False ;
1043
1044   while ((mnt = getmntent(fp))) {
1045     if ( sys_stat(mnt->mnt_dir, &S, false) == -1 )
1046       continue ;
1047     if (S.st_ex_dev == devno) {
1048       found = True ;
1049       break ;
1050     }
1051   }
1052   endmntent(fp) ;
1053
1054   if (!found) {
1055     return(False);
1056   }
1057
1058   euser_id=geteuid();
1059   become_root();
1060
1061   /* Use softlimit to determine disk space, except when it has been exceeded */
1062
1063   *bsize = 512;
1064
1065   if ( 0 == strcmp ( mnt->mnt_type, "efs" ))
1066   {
1067     r=quotactl (Q_GETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &D);
1068
1069     unbecome_root();
1070
1071     if (r==-1)
1072       return(False);
1073
1074     /* Use softlimit to determine disk space, except when it has been exceeded */
1075     if (
1076         (D.dqb_bsoftlimit && D.dqb_curblocks>=D.dqb_bsoftlimit) ||
1077         (D.dqb_bhardlimit && D.dqb_curblocks>=D.dqb_bhardlimit) ||
1078         (D.dqb_fsoftlimit && D.dqb_curfiles>=D.dqb_fsoftlimit) ||
1079         (D.dqb_fhardlimit && D.dqb_curfiles>=D.dqb_fhardlimit)
1080        )
1081     {
1082       *dfree = 0;
1083       *dsize = D.dqb_curblocks;
1084     }
1085     else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
1086     {
1087       return(False);
1088     }
1089     else
1090     {
1091       *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1092       *dsize = D.dqb_bsoftlimit;
1093     }
1094
1095   }
1096   else if ( 0 == strcmp ( mnt->mnt_type, "xfs" ))
1097   {
1098     r=quotactl (Q_XGETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &F);
1099
1100     unbecome_root();
1101
1102     if (r==-1)
1103     {
1104       DEBUG(5, ("quotactl for uid=%u: %s", euser_id, strerror(errno)));
1105       return(False);
1106     }
1107
1108     /* No quota for this user. */
1109     if (F.d_blk_softlimit==0 && F.d_blk_hardlimit==0)
1110     {
1111       return(False);
1112     }
1113
1114     /* Use softlimit to determine disk space, except when it has been exceeded */
1115     if (
1116         (F.d_blk_softlimit && F.d_bcount>=F.d_blk_softlimit) ||
1117         (F.d_blk_hardlimit && F.d_bcount>=F.d_blk_hardlimit) ||
1118         (F.d_ino_softlimit && F.d_icount>=F.d_ino_softlimit) ||
1119         (F.d_ino_hardlimit && F.d_icount>=F.d_ino_hardlimit)
1120        )
1121     {
1122       *dfree = 0;
1123       *dsize = F.d_bcount;
1124     }
1125     else
1126     {
1127       *dfree = (F.d_blk_softlimit - F.d_bcount);
1128       *dsize = F.d_blk_softlimit ? F.d_blk_softlimit : F.d_blk_hardlimit;
1129     }
1130
1131   }
1132   else
1133   {
1134           unbecome_root();
1135           return(False);
1136   }
1137
1138   return (True);
1139
1140 }
1141
1142 #else
1143
1144 #if    defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
1145 #include <ufs/ufs/quota.h>
1146 #include <machine/param.h>
1147 #elif         AIX
1148 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
1149 #include <jfs/quota.h>
1150 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
1151 #define dqb_curfiles dqb_curinodes
1152 #define dqb_fhardlimit dqb_ihardlimit
1153 #define dqb_fsoftlimit dqb_isoftlimit
1154 #ifdef _AIXVERSION_530
1155 #include <sys/statfs.h>
1156 #include <sys/vmount.h>
1157 #endif /* AIX 5.3 */
1158 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1159 #include <sys/quota.h>
1160 #include <devnm.h>
1161 #endif
1162
1163 #if defined(__FreeBSD__) || defined(__DragonFly__)
1164
1165 #include <rpc/rpc.h>
1166 #include <rpc/types.h>
1167 #include <rpcsvc/rquota.h>
1168 #ifdef HAVE_RPC_NETTYPE_H
1169 #include <rpc/nettype.h>
1170 #endif
1171 #include <rpc/xdr.h>
1172
1173 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
1174 {
1175         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
1176                 return(0);
1177         if (!xdr_int(xdrsp, &args->gqa_uid))
1178                 return(0);
1179         return (1);
1180 }
1181
1182 static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
1183 {
1184         int quotastat;
1185
1186         if (!xdr_int(xdrsp, &quotastat)) {
1187                 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
1188                 return 0;
1189         }
1190         gqr->status = quotastat;
1191
1192         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
1193                 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
1194                 return 0;
1195         }
1196         if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
1197                 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
1198                 return 0;
1199         }
1200         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
1201                 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
1202                 return 0;
1203         }
1204         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
1205                 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
1206                 return 0;
1207         }
1208         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
1209                 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
1210                 return 0;
1211         }
1212         return (1);
1213 }
1214
1215 /* Works on FreeBSD, too. :-) */
1216 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1217 {
1218         uid_t uid = euser_id;
1219         struct dqblk D;
1220         char *mnttype = nfspath;
1221         CLIENT *clnt;
1222         struct getquota_rslt gqr;
1223         struct getquota_args args;
1224         char *cutstr, *pathname, *host, *testpath;
1225         int len;
1226         static struct timeval timeout = {2,0};
1227         enum clnt_stat clnt_stat;
1228         bool ret = True;
1229
1230         *bsize = *dfree = *dsize = (uint64_t)0;
1231
1232         len=strcspn(mnttype, ":");
1233         pathname=strstr(mnttype, ":");
1234         cutstr = (char *) SMB_MALLOC(len+1);
1235         if (!cutstr)
1236                 return False;
1237
1238         memset(cutstr, '\0', len+1);
1239         host = strncat(cutstr,mnttype, sizeof(char) * len );
1240         DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
1241         DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
1242         testpath=strchr_m(mnttype, ':');
1243         args.gqa_pathp = testpath+1;
1244         args.gqa_uid = uid;
1245
1246         DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
1247
1248         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
1249                 ret = False;
1250                 goto out;
1251         }
1252
1253         clnt->cl_auth = authunix_create_default();
1254         DEBUG(9,("nfs_quotas: auth_success\n"));
1255
1256         clnt_stat=clnt_call(clnt, RQUOTAPROC_GETQUOTA, (const xdrproc_t) my_xdr_getquota_args, (caddr_t)&args, (const xdrproc_t) my_xdr_getquota_rslt, (caddr_t)&gqr, timeout);
1257
1258         if (clnt_stat != RPC_SUCCESS) {
1259                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
1260                 ret = False;
1261                 goto out;
1262         }
1263
1264         /*
1265          * gqr->status returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
1266          * no quota set, and 3 if no permission to get the quota.  If 0 or 3 return
1267          * something sensible.
1268          */
1269
1270         switch (gqr.status) {
1271         case 0:
1272                 DEBUG(9,("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n", gqr.status));
1273                 ret = False;
1274                 goto out;
1275
1276         case 1:
1277                 DEBUG(9,("nfs_quotas: Good quota data\n"));
1278                 D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
1279                 D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
1280                 D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
1281                 break;
1282
1283         case 2:
1284         case 3:
1285                 D.dqb_bsoftlimit = 1;
1286                 D.dqb_curblocks = 1;
1287                 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", gqr.status));
1288                 break;
1289
1290         default:
1291                 DEBUG(9,("nfs_quotas: Remote Quotas Questionable!  Error \"%i\" \n", gqr.status));
1292                 break;
1293         }
1294
1295         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",
1296                         gqr.status,
1297                         gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
1298                         gqr.getquota_rslt_u.gqr_rquota.rq_active,
1299                         gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
1300                         gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
1301                         gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
1302
1303         if (D.dqb_bsoftlimit == 0)
1304                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
1305         if (D.dqb_bsoftlimit == 0)
1306                 return False;
1307
1308         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
1309         *dsize = D.dqb_bsoftlimit;
1310
1311         if (D.dqb_curblocks == 1)
1312                 *bsize = DEV_BSIZE;
1313
1314         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1315                 *dfree = 0;
1316                 *dsize = D.dqb_curblocks;
1317         } else
1318                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1319
1320   out:
1321
1322         if (clnt) {
1323                 if (clnt->cl_auth)
1324                         auth_destroy(clnt->cl_auth);
1325                 clnt_destroy(clnt);
1326         }
1327
1328         DEBUG(5,("nfs_quotas: For path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
1329
1330         SAFE_FREE(cutstr);
1331         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
1332         return ret;
1333 }
1334
1335 #endif
1336
1337 /****************************************************************************
1338 try to get the disk space from disk quotas - default version
1339 ****************************************************************************/
1340
1341 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1342 {
1343   int r;
1344   struct dqblk D;
1345   uid_t euser_id;
1346 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__)
1347   char dev_disk[256];
1348   SMB_STRUCT_STAT S;
1349
1350   /* find the block device file */
1351
1352 #ifdef HPUX
1353   /* Need to set the cache flag to 1 for HPUX. Seems
1354    * to have a significant performance boost when
1355    * lstat calls on /dev access this function.
1356    */
1357   if ((sys_stat(path, &S, false)<0)
1358       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 1)<0))
1359 #else
1360   if ((sys_stat(path, &S, false)<0)
1361       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 0)<0))
1362         return (False);
1363 #endif /* ifdef HPUX */
1364
1365 #endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__) */
1366
1367   euser_id = geteuid();
1368
1369 #ifdef HPUX
1370   /* for HPUX, real uid must be same as euid to execute quotactl for euid */
1371   save_re_uid();
1372   if (set_re_uid() != 0) return False;
1373
1374   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1375
1376   restore_re_uid();
1377 #else
1378 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
1379   {
1380     /* FreeBSD patches from Marty Moll <martym@arbor.edu> */
1381     gid_t egrp_id;
1382 #if defined(__FreeBSD__) || defined(__DragonFly__)
1383     SMB_DEV_T devno;
1384     struct statfs *mnts;
1385     SMB_STRUCT_STAT st;
1386     int mntsize, i;
1387
1388     if (sys_stat(path, &st, false) < 0)
1389         return False;
1390     devno = st.st_ex_dev;
1391
1392     mntsize = getmntinfo(&mnts,MNT_NOWAIT);
1393     if (mntsize <= 0)
1394         return False;
1395
1396     for (i = 0; i < mntsize; i++) {
1397         if (sys_stat(mnts[i].f_mntonname, &st, false) < 0)
1398             return False;
1399         if (st.st_ex_dev == devno)
1400             break;
1401     }
1402     if (i == mntsize)
1403         return False;
1404 #endif
1405
1406     become_root();
1407
1408 #if defined(__FreeBSD__) || defined(__DragonFly__)
1409     if (strcmp(mnts[i].f_fstypename,"nfs") == 0) {
1410         bool retval;
1411         retval = nfs_quotas(mnts[i].f_mntfromname,euser_id,bsize,dfree,dsize);
1412         unbecome_root();
1413         return retval;
1414     }
1415 #endif
1416
1417     egrp_id = getegid();
1418     r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1419
1420     /* As FreeBSD has group quotas, if getting the user
1421        quota fails, try getting the group instead. */
1422     if (r) {
1423             r= quotactl(path,QCMD(Q_GETQUOTA,GRPQUOTA),egrp_id,(char *) &D);
1424     }
1425
1426     unbecome_root();
1427   }
1428 #elif defined(AIX)
1429   /* AIX has both USER and GROUP quotas:
1430      Get the USER quota (ohnielse@fysik.dtu.dk) */
1431 #ifdef _AIXVERSION_530
1432   {
1433     struct statfs statbuf;
1434     quota64_t user_quota;
1435     if (statfs(path,&statbuf) != 0)
1436       return False;
1437     if(statbuf.f_vfstype == MNT_J2)
1438     {
1439     /* For some reason we need to be root for jfs2 */
1440       become_root();
1441       r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
1442       unbecome_root();
1443     /* Copy results to old struct to let the following code work as before */
1444       D.dqb_curblocks  = user_quota.bused;
1445       D.dqb_bsoftlimit = user_quota.bsoft;
1446       D.dqb_bhardlimit = user_quota.bhard;
1447       D.dqb_curfiles   = user_quota.iused;
1448       D.dqb_fsoftlimit = user_quota.isoft;
1449       D.dqb_fhardlimit = user_quota.ihard;
1450     }
1451     else if(statbuf.f_vfstype == MNT_JFS)
1452     {
1453 #endif /* AIX 5.3 */
1454   save_re_uid();
1455   if (set_re_uid() != 0)
1456     return False;
1457   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1458   restore_re_uid();
1459 #ifdef _AIXVERSION_530
1460     }
1461     else
1462       r = 1; /* Fail for other FS-types */
1463   }
1464 #endif /* AIX 5.3 */
1465 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1466   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1467 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1468 #endif /* HPUX */
1469
1470   /* Use softlimit to determine disk space, except when it has been exceeded */
1471 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
1472   *bsize = DEV_BSIZE;
1473 #else /* !__FreeBSD__ && !__OpenBSD__ && !__DragonFly__ */
1474   *bsize = 1024;
1475 #endif /*!__FreeBSD__ && !__OpenBSD__ && !__DragonFly__ */
1476
1477   if (r)
1478     {
1479       if (errno == EDQUOT)
1480         {
1481           *dfree =0;
1482           *dsize =D.dqb_curblocks;
1483           return (True);
1484         }
1485       else return(False);
1486     }
1487
1488   /* If softlimit is zero, set it equal to hardlimit.
1489    */
1490
1491   if (D.dqb_bsoftlimit==0)
1492     D.dqb_bsoftlimit = D.dqb_bhardlimit;
1493
1494   if (D.dqb_bsoftlimit==0)
1495     return(False);
1496   /* Use softlimit to determine disk space, except when it has been exceeded */
1497   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
1498 #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
1499 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
1500 #endif
1501     ) {
1502       *dfree = 0;
1503       *dsize = D.dqb_curblocks;
1504     }
1505   else {
1506     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1507     *dsize = D.dqb_bsoftlimit;
1508   }
1509   return (True);
1510 }
1511
1512 #endif
1513
1514 #if defined(VXFS_QUOTA)
1515
1516 /****************************************************************************
1517 Try to get the disk space from Veritas disk quotas.
1518     David Lee <T.D.Lee@durham.ac.uk> August 1999.
1519
1520 Background assumptions:
1521     Potentially under many Operating Systems.  Initially Solaris 2.
1522
1523     My guess is that Veritas is largely, though not entirely,
1524     independent of OS.  So I have separated it out.
1525
1526     There may be some details.  For example, OS-specific "include" files.
1527
1528     It is understood that HPUX 10 somehow gets Veritas quotas without
1529     any special effort; if so, this routine need not be compiled in.
1530         Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
1531
1532 Warning:
1533     It is understood that Veritas do not publicly support this ioctl interface.
1534     Rather their preference would be for the user (us) to call the native
1535     OS and then for the OS itself to call through to the VxFS filesystem.
1536     Presumably HPUX 10, see above, does this.
1537
1538 Hints for porting:
1539     Add your OS to "IFLIST" below.
1540     Get it to compile successfully:
1541         Almost certainly "include"s require attention: see SUNOS5.
1542     In the main code above, arrange for it to be called: see SUNOS5.
1543     Test!
1544
1545 ****************************************************************************/
1546
1547 /* "IFLIST"
1548  * This "if" is a list of ports:
1549  *      if defined(OS1) || defined(OS2) || ...
1550  */
1551 #if defined(SUNOS5)
1552
1553 #if defined(SUNOS5)
1554 #include <sys/fs/vx_solaris.h>
1555 #endif
1556 #include <sys/fs/vx_machdep.h>
1557 #include <sys/fs/vx_layout.h>
1558 #include <sys/fs/vx_quota.h>
1559 #include <sys/fs/vx_aioctl.h>
1560 #include <sys/fs/vx_ioctl.h>
1561
1562 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1563 {
1564   uid_t user_id, euser_id;
1565   int ret;
1566   struct vx_dqblk D;
1567   struct vx_quotctl quotabuf;
1568   struct vx_genioctl genbuf;
1569   char *qfname;
1570   int file;
1571
1572   /*
1573    * "name" may or may not include a trailing "/quotas".
1574    * Arranging consistency of calling here in "quotas.c" may not be easy and
1575    * it might be easier to examine and adjust it here.
1576    * Fortunately, VxFS seems not to mind at present.
1577    */
1578   qfname = talloc_strdup(talloc_tos(), name);
1579   if (!qfname) {
1580           return false;
1581   }
1582   /* pstrcat(qfname, "/quotas") ; */    /* possibly examine and adjust "name" */
1583
1584   euser_id = geteuid();
1585   set_effective_uid(0);
1586
1587   DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
1588   if((file=open(qfname, O_RDONLY,0))<0) {
1589     set_effective_uid(euser_id);
1590     return(False);
1591   }
1592   genbuf.ioc_cmd = VX_QUOTACTL;
1593   genbuf.ioc_up = (void *) &quotabuf;
1594
1595   quotabuf.cmd = VX_GETQUOTA;
1596   quotabuf.uid = euser_id;
1597   quotabuf.addr = (caddr_t) &D;
1598   ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
1599   close(file);
1600
1601   set_effective_uid(euser_id);
1602
1603   if (ret < 0) {
1604     DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
1605     return(False);
1606   }
1607
1608   /* If softlimit is zero, set it equal to hardlimit.
1609    */
1610
1611   if (D.dqb_bsoftlimit==0)
1612     D.dqb_bsoftlimit = D.dqb_bhardlimit;
1613
1614   /* Use softlimit to determine disk space. A user exceeding the quota is told
1615    * that there's no space left. Writes might actually work for a bit if the
1616    * hardlimit is set higher than softlimit. Effectively the disk becomes
1617    * made of rubber latex and begins to expand to accommodate the user :-)
1618    */
1619   DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
1620          path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
1621          D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
1622
1623   if (D.dqb_bsoftlimit==0)
1624     return(False);
1625   *bsize = DEV_BSIZE;
1626   *dsize = D.dqb_bsoftlimit;
1627
1628   if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1629      *dfree = 0;
1630      *dsize = D.dqb_curblocks;
1631   } else
1632     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1633
1634   DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",
1635          path,(double)*bsize,(double)*dfree,(double)*dsize));
1636
1637   return(True);
1638 }
1639
1640 #endif /* SUNOS5 || ... */
1641
1642 #endif /* VXFS_QUOTA */
1643
1644 #else /* WITH_QUOTAS */
1645
1646 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
1647 {
1648         (*bsize) = 512; /* This value should be ignored */
1649
1650         /* And just to be sure we set some values that hopefully */
1651         /* will be larger that any possible real-world value     */
1652         (*dfree) = (uint64_t)-1;
1653         (*dsize) = (uint64_t)-1;
1654
1655         /* As we have select not to use quotas, allways fail */
1656         return false;
1657 }
1658 #endif /* WITH_QUOTAS */
1659
1660 #else /* HAVE_SYS_QUOTAS */
1661 /* wrapper to the new sys_quota interface
1662    this file should be removed later
1663    */
1664 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
1665 {
1666         int r;
1667         SMB_DISK_QUOTA D;
1668         unid_t id;
1669
1670         id.uid = geteuid();
1671
1672         ZERO_STRUCT(D);
1673         r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
1674
1675         /* Use softlimit to determine disk space, except when it has been exceeded */
1676         *bsize = D.bsize;
1677         if (r == -1) {
1678                 if (errno == EDQUOT) {
1679                         *dfree =0;
1680                         *dsize =D.curblocks;
1681                         return (True);
1682                 } else {
1683                         goto try_group_quota;
1684                 }
1685         }
1686
1687         /* Use softlimit to determine disk space, except when it has been exceeded */
1688         if (
1689                 (D.softlimit && D.curblocks >= D.softlimit) ||
1690                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
1691                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
1692                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
1693         ) {
1694                 *dfree = 0;
1695                 *dsize = D.curblocks;
1696         } else if (D.softlimit==0 && D.hardlimit==0) {
1697                 goto try_group_quota;
1698         } else {
1699                 if (D.softlimit == 0)
1700                         D.softlimit = D.hardlimit;
1701                 *dfree = D.softlimit - D.curblocks;
1702                 *dsize = D.softlimit;
1703         }
1704
1705         return True;
1706
1707 try_group_quota:
1708         id.gid = getegid();
1709
1710         ZERO_STRUCT(D);
1711         r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
1712
1713         /* Use softlimit to determine disk space, except when it has been exceeded */
1714         *bsize = D.bsize;
1715         if (r == -1) {
1716                 if (errno == EDQUOT) {
1717                         *dfree =0;
1718                         *dsize =D.curblocks;
1719                         return (True);
1720                 } else {
1721                         return False;
1722                 }
1723         }
1724
1725         /* Use softlimit to determine disk space, except when it has been exceeded */
1726         if (
1727                 (D.softlimit && D.curblocks >= D.softlimit) ||
1728                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
1729                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
1730                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
1731         ) {
1732                 *dfree = 0;
1733                 *dsize = D.curblocks;
1734         } else if (D.softlimit==0 && D.hardlimit==0) {
1735                 return False;
1736         } else {
1737                 if (D.softlimit == 0)
1738                         D.softlimit = D.hardlimit;
1739                 *dfree = D.softlimit - D.curblocks;
1740                 *dsize = D.softlimit;
1741         }
1742
1743         return (True);
1744 }
1745 #endif /* HAVE_SYS_QUOTAS */