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 > D.dqb_bsoftlimit) {
 750                 *dfree = 0;
 751                 *dsize = D.dqb_curblocks;
 752         } else
 753                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 754
 755   out:
 756
 757         if (clnt) {
 758                 if (clnt->cl_auth)
 759                         auth_destroy(clnt->cl_auth);
 760                 clnt_destroy(clnt);
 761         }
 762
 763         DEBUG(5,("nfs_quotas: For path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
 764
 765         SAFE_FREE(cutstr);
 766         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
 767         return ret;
 768 }
 769 #endif
 770
 771 /****************************************************************************
 772 try to get the disk space from disk quotas (SunOS & Solaris2 version)
 773 Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
 774 ****************************************************************************/
 775
 776 bool disk_quotas(const char *path,
 777                 uint64_t *bsize,
 778                 uint64_t *dfree,
 779                 uint64_t *dsize)
 780 {
 781         uid_t euser_id;
 782         int ret;
 783         struct dqblk D;
 784 #if defined(SUNOS5)
 785         struct quotctl command;
 786         int file;
 787         struct mnttab mnt;
 788 #else /* SunOS4 */
 789         struct mntent *mnt;
 790 #endif
 791         char *name = NULL;
 792         FILE *fd;
 793         SMB_STRUCT_STAT sbuf;
 794         SMB_DEV_T devno;
 795         bool found = false;
 796
 797         euser_id = geteuid();
 798
 799         if (sys_stat(path, &sbuf, false) == -1) {
 800                 return false;
 801         }
 802
 803         devno = sbuf.st_ex_dev ;
 804         DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
 805                 path, (unsigned int)devno));
 806 #if defined(SUNOS5)
 807         if ((fd = sys_fopen(MNTTAB, "r")) == NULL) {
 808                 return false;
 809         }
 810
 811         while (getmntent(fd, &mnt) == 0) {
 812                 if (sys_stat(mnt.mnt_mountp, &sbuf, false) == -1) {
 813                         continue;
 814                 }
 815
 816                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 817                         mnt.mnt_mountp, (unsigned int)devno));
 818
 819                 /* quotas are only on vxfs, UFS or NFS */
 820                 if ((sbuf.st_ex_dev == devno) && (
 821                         strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
 822                         strcmp( mnt.mnt_fstype, "nfs" ) == 0    ||
 823                         strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
 824                                 found = true;
 825                                 name = talloc_asprintf(talloc_tos(),
 826                                                 "%s/quotas",
 827                                                 mnt.mnt_mountp);
 828                                 break;
 829                 }
 830         }
 831
 832         fclose(fd);
 833 #else /* SunOS4 */
 834         if ((fd = setmntent(MOUNTED, "r")) == NULL) {
 835                 return false;
 836         }
 837
 838         while ((mnt = getmntent(fd)) != NULL) {
 839                 if (sys_stat(mnt->mnt_dir, &sbuf, false) == -1) {
 840                         continue;
 841                 }
 842                 DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
 843                                         mnt->mnt_dir,
 844                                         (unsigned int)sbuf.st_ex_dev));
 845                 if (sbuf.st_ex_dev == devno) {
 846                         found = true;
 847                         name = talloc_strdup(talloc_tos(),
 848                                         mnt->mnt_fsname);
 849                         break;
 850                 }
 851         }
 852
 853         endmntent(fd);
 854 #endif
 855         if (!found) {
 856                 return false;
 857         }
 858
 859         if (!name) {
 860                 return false;
 861         }
 862         become_root();
 863
 864 #if defined(SUNOS5)
 865         if (strcmp(mnt.mnt_fstype, "nfs") == 0) {
 866                 bool retval;
 867                 DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n",
 868                                         mnt.mnt_special));
 869                 retval = nfs_quotas(mnt.mnt_special,
 870                                 euser_id, bsize, dfree, dsize);
 871                 unbecome_root();
 872                 return retval;
 873         }
 874
 875         DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
 876         if((file=sys_open(name, O_RDONLY,0))<0) {
 877                 unbecome_root();
 878                 return false;
 879         }
 880         command.op = Q_GETQUOTA;
 881         command.uid = euser_id;
 882         command.addr = (caddr_t) &D;
 883         ret = ioctl(file, Q_QUOTACTL, &command);
 884         close(file);
 885 #else
 886         DEBUG(5,("disk_quotas: trying quotactl on device \"%s\"\n", name));
 887         ret = quotactl(Q_GETQUOTA, name, euser_id, &D);
 888 #endif
 889
 890         unbecome_root();
 891
 892         if (ret < 0) {
 893                 DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n",
 894                                         strerror(errno) ));
 895
 896 #if defined(SUNOS5) && defined(VXFS_QUOTA)
 897                 /* If normal quotactl() fails, try vxfs private calls */
 898                 set_effective_uid(euser_id);
 899                 DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
 900                 if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
 901                         bool retval;
 902                         retval = disk_quotas_vxfs(name, path,
 903                                         bsize, dfree, dsize);
 904                         return retval;
 905                 }
 906 #else
 907                 return false;
 908 #endif
 909         }
 910
 911         /* If softlimit is zero, set it equal to hardlimit.
 912          */
 913
 914         if (D.dqb_bsoftlimit==0) {
 915                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
 916         }
 917
 918         /* Use softlimit to determine disk space. A user exceeding the quota
 919          * is told that there's no space left. Writes might actually work for
 920          * a bit if the hardlimit is set higher than softlimit. Effectively
 921          * the disk becomes made of rubber latex and begins to expand to
 922          * accommodate the user :-)
 923          */
 924
 925         if (D.dqb_bsoftlimit==0)
 926                 return(False);
 927         *bsize = DEV_BSIZE;
 928         *dsize = D.dqb_bsoftlimit;
 929
 930         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
 931                 *dfree = 0;
 932                 *dsize = D.dqb_curblocks;
 933         } else {
 934                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
 935         }
 936
 937         DEBUG(5,("disk_quotas for path \"%s\" returning "
 938                 "bsize %.0f, dfree %.0f, dsize %.0f\n",
 939                 path,(double)*bsize,(double)*dfree,(double)*dsize));
 940
 941         return true;
 942 }
 943
 944
 945 #elif defined(OSF1)
 946 #include <ufs/quota.h>
 947
 948 /****************************************************************************
 949 try to get the disk space from disk quotas - OSF1 version
 950 ****************************************************************************/
 951
 952 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
 953 {
 954   int r, save_errno;
 955   struct dqblk D;
 956   SMB_STRUCT_STAT S;
 957   uid_t euser_id;
 958
 959   /*
 960    * This code presumes that OSF1 will only
 961    * give out quota info when the real uid
 962    * matches the effective uid. JRA.
 963    */
 964   euser_id = geteuid();
 965   save_re_uid();
 966   if (set_re_uid() != 0) return False;
 967
 968   r= quotactl(path,QCMD(Q_GETQUOTA, USRQUOTA),euser_id,(char *) &D);
 969   if (r) {
 970      save_errno = errno;
 971   }
 972
 973   restore_re_uid();
 974
 975   *bsize = DEV_BSIZE;
 976
 977   if (r)
 978   {
 979       if (save_errno == EDQUOT)   /* disk quota exceeded */
 980       {
 981          *dfree = 0;
 982          *dsize = D.dqb_curblocks;
 983          return (True);
 984       }
 985       else
 986          return (False);
 987   }
 988
 989   /* If softlimit is zero, set it equal to hardlimit.
 990    */
 991
 992   if (D.dqb_bsoftlimit==0)
 993     D.dqb_bsoftlimit = D.dqb_bhardlimit;
 994
 995   /* Use softlimit to determine disk space, except when it has been exceeded */
 996
 997   if (D.dqb_bsoftlimit==0)
 998     return(False);
 999
1000   if ((D.dqb_curblocks>D.dqb_bsoftlimit)) {
1001     *dfree = 0;
1002     *dsize = D.dqb_curblocks;
1003   } else {
1004     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1005     *dsize = D.dqb_bsoftlimit;
1006   }
1007   return (True);
1008 }
1009
1010 #elif defined (IRIX6)
1011 /****************************************************************************
1012 try to get the disk space from disk quotas (IRIX 6.2 version)
1013 ****************************************************************************/
1014
1015 #include <sys/quota.h>
1016 #include <mntent.h>
1017
1018 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1019 {
1020   uid_t euser_id;
1021   int r;
1022   struct dqblk D;
1023   struct fs_disk_quota        F;
1024   SMB_STRUCT_STAT S;
1025   FILE *fp;
1026   struct mntent *mnt;
1027   SMB_DEV_T devno;
1028   int found;
1029
1030   /* find the block device file */
1031
1032   if ( sys_stat(path, &S, false) == -1 ) {
1033     return(False) ;
1034   }
1035
1036   devno = S.st_ex_dev ;
1037
1038   fp = setmntent(MOUNTED,"r");
1039   found = False ;
1040
1041   while ((mnt = getmntent(fp))) {
1042     if ( sys_stat(mnt->mnt_dir, &S, false) == -1 )
1043       continue ;
1044     if (S.st_ex_dev == devno) {
1045       found = True ;
1046       break ;
1047     }
1048   }
1049   endmntent(fp) ;
1050
1051   if (!found) {
1052     return(False);
1053   }
1054
1055   euser_id=geteuid();
1056   become_root();
1057
1058   /* Use softlimit to determine disk space, except when it has been exceeded */
1059
1060   *bsize = 512;
1061
1062   if ( 0 == strcmp ( mnt->mnt_type, "efs" ))
1063   {
1064     r=quotactl (Q_GETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &D);
1065
1066     unbecome_root();
1067
1068     if (r==-1)
1069       return(False);
1070
1071     /* Use softlimit to determine disk space, except when it has been exceeded */
1072     if (
1073         (D.dqb_bsoftlimit && D.dqb_curblocks>=D.dqb_bsoftlimit) ||
1074         (D.dqb_bhardlimit && D.dqb_curblocks>=D.dqb_bhardlimit) ||
1075         (D.dqb_fsoftlimit && D.dqb_curfiles>=D.dqb_fsoftlimit) ||
1076         (D.dqb_fhardlimit && D.dqb_curfiles>=D.dqb_fhardlimit)
1077        )
1078     {
1079       *dfree = 0;
1080       *dsize = D.dqb_curblocks;
1081     }
1082     else if (D.dqb_bsoftlimit==0 && D.dqb_bhardlimit==0)
1083     {
1084       return(False);
1085     }
1086     else
1087     {
1088       *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1089       *dsize = D.dqb_bsoftlimit;
1090     }
1091
1092   }
1093   else if ( 0 == strcmp ( mnt->mnt_type, "xfs" ))
1094   {
1095     r=quotactl (Q_XGETQUOTA, mnt->mnt_fsname, euser_id, (caddr_t) &F);
1096
1097     unbecome_root();
1098
1099     if (r==-1)
1100     {
1101       DEBUG(5, ("quotactl for uid=%u: %s", euser_id, strerror(errno)));
1102       return(False);
1103     }
1104
1105     /* No quota for this user. */
1106     if (F.d_blk_softlimit==0 && F.d_blk_hardlimit==0)
1107     {
1108       return(False);
1109     }
1110
1111     /* Use softlimit to determine disk space, except when it has been exceeded */
1112     if (
1113         (F.d_blk_softlimit && F.d_bcount>=F.d_blk_softlimit) ||
1114         (F.d_blk_hardlimit && F.d_bcount>=F.d_blk_hardlimit) ||
1115         (F.d_ino_softlimit && F.d_icount>=F.d_ino_softlimit) ||
1116         (F.d_ino_hardlimit && F.d_icount>=F.d_ino_hardlimit)
1117        )
1118     {
1119       *dfree = 0;
1120       *dsize = F.d_bcount;
1121     }
1122     else
1123     {
1124       *dfree = (F.d_blk_softlimit - F.d_bcount);
1125       *dsize = F.d_blk_softlimit ? F.d_blk_softlimit : F.d_blk_hardlimit;
1126     }
1127
1128   }
1129   else
1130   {
1131           unbecome_root();
1132           return(False);
1133   }
1134
1135   return (True);
1136
1137 }
1138
1139 #else
1140
1141 #if    defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
1142 #include <ufs/ufs/quota.h>
1143 #include <machine/param.h>
1144 #elif         AIX
1145 /* AIX quota patch from Ole Holm Nielsen <ohnielse@fysik.dtu.dk> */
1146 #include <jfs/quota.h>
1147 /* AIX 4.X: Rename members of the dqblk structure (ohnielse@fysik.dtu.dk) */
1148 #define dqb_curfiles dqb_curinodes
1149 #define dqb_fhardlimit dqb_ihardlimit
1150 #define dqb_fsoftlimit dqb_isoftlimit
1151 #ifdef _AIXVERSION_530
1152 #include <sys/statfs.h>
1153 #include <sys/vmount.h>
1154 #endif /* AIX 5.3 */
1155 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1156 #include <sys/quota.h>
1157 #include <devnm.h>
1158 #endif
1159
1160 #if defined(__FreeBSD__) || defined(__DragonFly__)
1161
1162 #include <rpc/rpc.h>
1163 #include <rpc/types.h>
1164 #include <rpcsvc/rquota.h>
1165 #ifdef HAVE_RPC_NETTYPE_H
1166 #include <rpc/nettype.h>
1167 #endif
1168 #include <rpc/xdr.h>
1169
1170 static int my_xdr_getquota_args(XDR *xdrsp, struct getquota_args *args)
1171 {
1172         if (!xdr_string(xdrsp, &args->gqa_pathp, RQ_PATHLEN ))
1173                 return(0);
1174         if (!xdr_int(xdrsp, &args->gqa_uid))
1175                 return(0);
1176         return (1);
1177 }
1178
1179 static int my_xdr_getquota_rslt(XDR *xdrsp, struct getquota_rslt *gqr)
1180 {
1181         int quotastat;
1182
1183         if (!xdr_int(xdrsp, &quotastat)) {
1184                 DEBUG(6,("nfs_quotas: Status bad or zero\n"));
1185                 return 0;
1186         }
1187         gqr->status = quotastat;
1188
1189         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsize)) {
1190                 DEBUG(6,("nfs_quotas: Block size bad or zero\n"));
1191                 return 0;
1192         }
1193         if (!xdr_bool(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_active)) {
1194                 DEBUG(6,("nfs_quotas: Active bad or zero\n"));
1195                 return 0;
1196         }
1197         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bhardlimit)) {
1198                 DEBUG(6,("nfs_quotas: Hardlimit bad or zero\n"));
1199                 return 0;
1200         }
1201         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_bsoftlimit)) {
1202                 DEBUG(6,("nfs_quotas: Softlimit bad or zero\n"));
1203                 return 0;
1204         }
1205         if (!xdr_int(xdrsp, &gqr->getquota_rslt_u.gqr_rquota.rq_curblocks)) {
1206                 DEBUG(6,("nfs_quotas: Currentblocks bad or zero\n"));
1207                 return 0;
1208         }
1209         return (1);
1210 }
1211
1212 /* Works on FreeBSD, too. :-) */
1213 static bool nfs_quotas(char *nfspath, uid_t euser_id, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1214 {
1215         uid_t uid = euser_id;
1216         struct dqblk D;
1217         char *mnttype = nfspath;
1218         CLIENT *clnt;
1219         struct getquota_rslt gqr;
1220         struct getquota_args args;
1221         char *cutstr, *pathname, *host, *testpath;
1222         int len;
1223         static struct timeval timeout = {2,0};
1224         enum clnt_stat clnt_stat;
1225         bool ret = True;
1226
1227         *bsize = *dfree = *dsize = (uint64_t)0;
1228
1229         len=strcspn(mnttype, ":");
1230         pathname=strstr(mnttype, ":");
1231         cutstr = (char *) SMB_MALLOC(len+1);
1232         if (!cutstr)
1233                 return False;
1234
1235         memset(cutstr, '\0', len+1);
1236         host = strncat(cutstr,mnttype, sizeof(char) * len );
1237         DEBUG(5,("nfs_quotas: looking for mount on \"%s\"\n", cutstr));
1238         DEBUG(5,("nfs_quotas: of path \"%s\"\n", mnttype));
1239         testpath=strchr_m(mnttype, ':');
1240         args.gqa_pathp = testpath+1;
1241         args.gqa_uid = uid;
1242
1243         DEBUG(5,("nfs_quotas: Asking for host \"%s\" rpcprog \"%i\" rpcvers \"%i\" network \"%s\"\n", host, RQUOTAPROG, RQUOTAVERS, "udp"));
1244
1245         if ((clnt = clnt_create(host, RQUOTAPROG, RQUOTAVERS, "udp")) == NULL) {
1246                 ret = False;
1247                 goto out;
1248         }
1249
1250         clnt->cl_auth = authunix_create_default();
1251         DEBUG(9,("nfs_quotas: auth_success\n"));
1252
1253         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);
1254
1255         if (clnt_stat != RPC_SUCCESS) {
1256                 DEBUG(9,("nfs_quotas: clnt_call fail\n"));
1257                 ret = False;
1258                 goto out;
1259         }
1260
1261         /*
1262          * gqr->status returns 0 if the rpc call fails, 1 if quotas exist, 2 if there is
1263          * no quota set, and 3 if no permission to get the quota.  If 0 or 3 return
1264          * something sensible.
1265          */
1266
1267         switch (gqr.status) {
1268         case 0:
1269                 DEBUG(9,("nfs_quotas: Remote Quotas Failed!  Error \"%i\" \n", gqr.status));
1270                 ret = False;
1271                 goto out;
1272
1273         case 1:
1274                 DEBUG(9,("nfs_quotas: Good quota data\n"));
1275                 D.dqb_bsoftlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit;
1276                 D.dqb_bhardlimit = gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit;
1277                 D.dqb_curblocks = gqr.getquota_rslt_u.gqr_rquota.rq_curblocks;
1278                 break;
1279
1280         case 2:
1281         case 3:
1282                 D.dqb_bsoftlimit = 1;
1283                 D.dqb_curblocks = 1;
1284                 DEBUG(9,("nfs_quotas: Remote Quotas returned \"%i\" \n", gqr.status));
1285                 break;
1286
1287         default:
1288                 DEBUG(9,("nfs_quotas: Remote Quotas Questionable!  Error \"%i\" \n", gqr.status));
1289                 break;
1290         }
1291
1292         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",
1293                         gqr.status,
1294                         gqr.getquota_rslt_u.gqr_rquota.rq_bsize,
1295                         gqr.getquota_rslt_u.gqr_rquota.rq_active,
1296                         gqr.getquota_rslt_u.gqr_rquota.rq_bhardlimit,
1297                         gqr.getquota_rslt_u.gqr_rquota.rq_bsoftlimit,
1298                         gqr.getquota_rslt_u.gqr_rquota.rq_curblocks));
1299
1300         if (D.dqb_bsoftlimit == 0)
1301                 D.dqb_bsoftlimit = D.dqb_bhardlimit;
1302         if (D.dqb_bsoftlimit == 0)
1303                 return False;
1304
1305         *bsize = gqr.getquota_rslt_u.gqr_rquota.rq_bsize;
1306         *dsize = D.dqb_bsoftlimit;
1307
1308         if (D.dqb_curblocks == 1)
1309                 *bsize = DEV_BSIZE;
1310
1311         if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1312                 *dfree = 0;
1313                 *dsize = D.dqb_curblocks;
1314         } else
1315                 *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1316
1317   out:
1318
1319         if (clnt) {
1320                 if (clnt->cl_auth)
1321                         auth_destroy(clnt->cl_auth);
1322                 clnt_destroy(clnt);
1323         }
1324
1325         DEBUG(5,("nfs_quotas: For path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",args.gqa_pathp,(double)*bsize,(double)*dfree,(double)*dsize));
1326
1327         SAFE_FREE(cutstr);
1328         DEBUG(10,("nfs_quotas: End of nfs_quotas\n" ));
1329         return ret;
1330 }
1331
1332 #endif
1333
1334 /****************************************************************************
1335 try to get the disk space from disk quotas - default version
1336 ****************************************************************************/
1337
1338 bool disk_quotas(const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1339 {
1340   int r;
1341   struct dqblk D;
1342   uid_t euser_id;
1343 #if !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__)
1344   char dev_disk[256];
1345   SMB_STRUCT_STAT S;
1346
1347   /* find the block device file */
1348
1349 #ifdef HPUX
1350   /* Need to set the cache flag to 1 for HPUX. Seems
1351    * to have a significant performance boost when
1352    * lstat calls on /dev access this function.
1353    */
1354   if ((sys_stat(path, &S, false)<0)
1355       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 1)<0))
1356 #else
1357   if ((sys_stat(path, &S, false)<0)
1358       || (devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 0)<0))
1359         return (False);
1360 #endif /* ifdef HPUX */
1361
1362 #endif /* !defined(__FreeBSD__) && !defined(AIX) && !defined(__OpenBSD__) && !defined(__DragonFly__) */
1363
1364   euser_id = geteuid();
1365
1366 #ifdef HPUX
1367   /* for HPUX, real uid must be same as euid to execute quotactl for euid */
1368   save_re_uid();
1369   if (set_re_uid() != 0) return False;
1370
1371   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1372
1373   restore_re_uid();
1374 #else
1375 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
1376   {
1377     /* FreeBSD patches from Marty Moll <martym@arbor.edu> */
1378     gid_t egrp_id;
1379 #if defined(__FreeBSD__) || defined(__DragonFly__)
1380     SMB_DEV_T devno;
1381     struct statfs *mnts;
1382     SMB_STRUCT_STAT st;
1383     int mntsize, i;
1384
1385     if (sys_stat(path, &st, false) < 0)
1386         return False;
1387     devno = st.st_ex_dev;
1388
1389     mntsize = getmntinfo(&mnts,MNT_NOWAIT);
1390     if (mntsize <= 0)
1391         return False;
1392
1393     for (i = 0; i < mntsize; i++) {
1394         if (sys_stat(mnts[i].f_mntonname, &st, false) < 0)
1395             return False;
1396         if (st.st_ex_dev == devno)
1397             break;
1398     }
1399     if (i == mntsize)
1400         return False;
1401 #endif
1402
1403     become_root();
1404
1405 #if defined(__FreeBSD__) || defined(__DragonFly__)
1406     if (strcmp(mnts[i].f_fstypename,"nfs") == 0) {
1407         bool retval;
1408         retval = nfs_quotas(mnts[i].f_mntfromname,euser_id,bsize,dfree,dsize);
1409         unbecome_root();
1410         return retval;
1411     }
1412 #endif
1413
1414     egrp_id = getegid();
1415     r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1416
1417     /* As FreeBSD has group quotas, if getting the user
1418        quota fails, try getting the group instead. */
1419     if (r) {
1420             r= quotactl(path,QCMD(Q_GETQUOTA,GRPQUOTA),egrp_id,(char *) &D);
1421     }
1422
1423     unbecome_root();
1424   }
1425 #elif defined(AIX)
1426   /* AIX has both USER and GROUP quotas:
1427      Get the USER quota (ohnielse@fysik.dtu.dk) */
1428 #ifdef _AIXVERSION_530
1429   {
1430     struct statfs statbuf;
1431     quota64_t user_quota;
1432     if (statfs(path,&statbuf) != 0)
1433       return False;
1434     if(statbuf.f_vfstype == MNT_J2)
1435     {
1436     /* For some reason we need to be root for jfs2 */
1437       become_root();
1438       r = quotactl(path,QCMD(Q_J2GETQUOTA,USRQUOTA),euser_id,(char *) &user_quota);
1439       unbecome_root();
1440     /* Copy results to old struct to let the following code work as before */
1441       D.dqb_curblocks  = user_quota.bused;
1442       D.dqb_bsoftlimit = user_quota.bsoft;
1443       D.dqb_bhardlimit = user_quota.bhard;
1444       D.dqb_curfiles   = user_quota.iused;
1445       D.dqb_fsoftlimit = user_quota.isoft;
1446       D.dqb_fhardlimit = user_quota.ihard;
1447     }
1448     else if(statbuf.f_vfstype == MNT_JFS)
1449     {
1450 #endif /* AIX 5.3 */
1451   save_re_uid();
1452   if (set_re_uid() != 0)
1453     return False;
1454   r= quotactl(path,QCMD(Q_GETQUOTA,USRQUOTA),euser_id,(char *) &D);
1455   restore_re_uid();
1456 #ifdef _AIXVERSION_530
1457     }
1458     else
1459       r = 1; /* Fail for other FS-types */
1460   }
1461 #endif /* AIX 5.3 */
1462 #else /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1463   r=quotactl(Q_GETQUOTA, dev_disk, euser_id, &D);
1464 #endif /* !__FreeBSD__ && !AIX && !__OpenBSD__ && !__DragonFly__ */
1465 #endif /* HPUX */
1466
1467   /* Use softlimit to determine disk space, except when it has been exceeded */
1468 #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
1469   *bsize = DEV_BSIZE;
1470 #else /* !__FreeBSD__ && !__OpenBSD__ && !__DragonFly__ */
1471   *bsize = 1024;
1472 #endif /*!__FreeBSD__ && !__OpenBSD__ && !__DragonFly__ */
1473
1474   if (r)
1475     {
1476       if (errno == EDQUOT)
1477         {
1478           *dfree =0;
1479           *dsize =D.dqb_curblocks;
1480           return (True);
1481         }
1482       else return(False);
1483     }
1484
1485   /* If softlimit is zero, set it equal to hardlimit.
1486    */
1487
1488   if (D.dqb_bsoftlimit==0)
1489     D.dqb_bsoftlimit = D.dqb_bhardlimit;
1490
1491   if (D.dqb_bsoftlimit==0)
1492     return(False);
1493   /* Use softlimit to determine disk space, except when it has been exceeded */
1494   if ((D.dqb_curblocks>D.dqb_bsoftlimit)
1495 #if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__DragonFly__)
1496 ||((D.dqb_curfiles>D.dqb_fsoftlimit) && (D.dqb_fsoftlimit != 0))
1497 #endif
1498     ) {
1499       *dfree = 0;
1500       *dsize = D.dqb_curblocks;
1501     }
1502   else {
1503     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1504     *dsize = D.dqb_bsoftlimit;
1505   }
1506   return (True);
1507 }
1508
1509 #endif
1510
1511 #if defined(VXFS_QUOTA)
1512
1513 /****************************************************************************
1514 Try to get the disk space from Veritas disk quotas.
1515     David Lee <T.D.Lee@durham.ac.uk> August 1999.
1516
1517 Background assumptions:
1518     Potentially under many Operating Systems.  Initially Solaris 2.
1519
1520     My guess is that Veritas is largely, though not entirely,
1521     independent of OS.  So I have separated it out.
1522
1523     There may be some details.  For example, OS-specific "include" files.
1524
1525     It is understood that HPUX 10 somehow gets Veritas quotas without
1526     any special effort; if so, this routine need not be compiled in.
1527         Dirk De Wachter <Dirk.DeWachter@rug.ac.be>
1528
1529 Warning:
1530     It is understood that Veritas do not publicly support this ioctl interface.
1531     Rather their preference would be for the user (us) to call the native
1532     OS and then for the OS itself to call through to the VxFS filesystem.
1533     Presumably HPUX 10, see above, does this.
1534
1535 Hints for porting:
1536     Add your OS to "IFLIST" below.
1537     Get it to compile successfully:
1538         Almost certainly "include"s require attention: see SUNOS5.
1539     In the main code above, arrange for it to be called: see SUNOS5.
1540     Test!
1541
1542 ****************************************************************************/
1543
1544 /* "IFLIST"
1545  * This "if" is a list of ports:
1546  *      if defined(OS1) || defined(OS2) || ...
1547  */
1548 #if defined(SUNOS5)
1549
1550 #if defined(SUNOS5)
1551 #include <sys/fs/vx_solaris.h>
1552 #endif
1553 #include <sys/fs/vx_machdep.h>
1554 #include <sys/fs/vx_layout.h>
1555 #include <sys/fs/vx_quota.h>
1556 #include <sys/fs/vx_aioctl.h>
1557 #include <sys/fs/vx_ioctl.h>
1558
1559 bool disk_quotas_vxfs(const char *name, char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize)
1560 {
1561   uid_t user_id, euser_id;
1562   int ret;
1563   struct vx_dqblk D;
1564   struct vx_quotctl quotabuf;
1565   struct vx_genioctl genbuf;
1566   char *qfname;
1567   int file;
1568
1569   /*
1570    * "name" may or may not include a trailing "/quotas".
1571    * Arranging consistency of calling here in "quotas.c" may not be easy and
1572    * it might be easier to examine and adjust it here.
1573    * Fortunately, VxFS seems not to mind at present.
1574    */
1575   qfname = talloc_strdup(talloc_tos(), name);
1576   if (!qfname) {
1577           return false;
1578   }
1579   /* pstrcat(qfname, "/quotas") ; */    /* possibly examine and adjust "name" */
1580
1581   euser_id = geteuid();
1582   set_effective_uid(0);
1583
1584   DEBUG(5,("disk_quotas: looking for VxFS quotas file \"%s\"\n", qfname));
1585   if((file=sys_open(qfname, O_RDONLY,0))<0) {
1586     set_effective_uid(euser_id);
1587     return(False);
1588   }
1589   genbuf.ioc_cmd = VX_QUOTACTL;
1590   genbuf.ioc_up = (void *) &quotabuf;
1591
1592   quotabuf.cmd = VX_GETQUOTA;
1593   quotabuf.uid = euser_id;
1594   quotabuf.addr = (caddr_t) &D;
1595   ret = ioctl(file, VX_ADMIN_IOCTL, &genbuf);
1596   close(file);
1597
1598   set_effective_uid(euser_id);
1599
1600   if (ret < 0) {
1601     DEBUG(5,("disk_quotas ioctl (VxFS) failed. Error = %s\n", strerror(errno) ));
1602     return(False);
1603   }
1604
1605   /* If softlimit is zero, set it equal to hardlimit.
1606    */
1607
1608   if (D.dqb_bsoftlimit==0)
1609     D.dqb_bsoftlimit = D.dqb_bhardlimit;
1610
1611   /* Use softlimit to determine disk space. A user exceeding the quota is told
1612    * that there's no space left. Writes might actually work for a bit if the
1613    * hardlimit is set higher than softlimit. Effectively the disk becomes
1614    * made of rubber latex and begins to expand to accommodate the user :-)
1615    */
1616   DEBUG(5,("disk_quotas for path \"%s\" block c/s/h %ld/%ld/%ld; file c/s/h %ld/%ld/%ld\n",
1617          path, D.dqb_curblocks, D.dqb_bsoftlimit, D.dqb_bhardlimit,
1618          D.dqb_curfiles, D.dqb_fsoftlimit, D.dqb_fhardlimit));
1619
1620   if (D.dqb_bsoftlimit==0)
1621     return(False);
1622   *bsize = DEV_BSIZE;
1623   *dsize = D.dqb_bsoftlimit;
1624
1625   if (D.dqb_curblocks > D.dqb_bsoftlimit) {
1626      *dfree = 0;
1627      *dsize = D.dqb_curblocks;
1628   } else
1629     *dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
1630
1631   DEBUG(5,("disk_quotas for path \"%s\" returning  bsize %.0f, dfree %.0f, dsize %.0f\n",
1632          path,(double)*bsize,(double)*dfree,(double)*dsize));
1633
1634   return(True);
1635 }
1636
1637 #endif /* SUNOS5 || ... */
1638
1639 #endif /* VXFS_QUOTA */
1640
1641 #else /* WITH_QUOTAS */
1642
1643 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
1644 {
1645         (*bsize) = 512; /* This value should be ignored */
1646
1647         /* And just to be sure we set some values that hopefully */
1648         /* will be larger that any possible real-world value     */
1649         (*dfree) = (uint64_t)-1;
1650         (*dsize) = (uint64_t)-1;
1651
1652         /* As we have select not to use quotas, allways fail */
1653         return false;
1654 }
1655 #endif /* WITH_QUOTAS */
1656
1657 #else /* HAVE_SYS_QUOTAS */
1658 /* wrapper to the new sys_quota interface
1659    this file should be removed later
1660    */
1661 bool disk_quotas(const char *path,uint64_t *bsize,uint64_t *dfree,uint64_t *dsize)
1662 {
1663         int r;
1664         SMB_DISK_QUOTA D;
1665         unid_t id;
1666
1667         id.uid = geteuid();
1668
1669         ZERO_STRUCT(D);
1670         r=sys_get_quota(path, SMB_USER_QUOTA_TYPE, id, &D);
1671
1672         /* Use softlimit to determine disk space, except when it has been exceeded */
1673         *bsize = D.bsize;
1674         if (r == -1) {
1675                 if (errno == EDQUOT) {
1676                         *dfree =0;
1677                         *dsize =D.curblocks;
1678                         return (True);
1679                 } else {
1680                         goto try_group_quota;
1681                 }
1682         }
1683
1684         /* Use softlimit to determine disk space, except when it has been exceeded */
1685         if (
1686                 (D.softlimit && D.curblocks >= D.softlimit) ||
1687                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
1688                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
1689                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
1690         ) {
1691                 *dfree = 0;
1692                 *dsize = D.curblocks;
1693         } else if (D.softlimit==0 && D.hardlimit==0) {
1694                 goto try_group_quota;
1695         } else {
1696                 if (D.softlimit == 0)
1697                         D.softlimit = D.hardlimit;
1698                 *dfree = D.softlimit - D.curblocks;
1699                 *dsize = D.softlimit;
1700         }
1701
1702         return True;
1703
1704 try_group_quota:
1705         id.gid = getegid();
1706
1707         ZERO_STRUCT(D);
1708         r=sys_get_quota(path, SMB_GROUP_QUOTA_TYPE, id, &D);
1709
1710         /* Use softlimit to determine disk space, except when it has been exceeded */
1711         *bsize = D.bsize;
1712         if (r == -1) {
1713                 if (errno == EDQUOT) {
1714                         *dfree =0;
1715                         *dsize =D.curblocks;
1716                         return (True);
1717                 } else {
1718                         return False;
1719                 }
1720         }
1721
1722         /* Use softlimit to determine disk space, except when it has been exceeded */
1723         if (
1724                 (D.softlimit && D.curblocks >= D.softlimit) ||
1725                 (D.hardlimit && D.curblocks >= D.hardlimit) ||
1726                 (D.isoftlimit && D.curinodes >= D.isoftlimit) ||
1727                 (D.ihardlimit && D.curinodes>=D.ihardlimit)
1728         ) {
1729                 *dfree = 0;
1730                 *dsize = D.curblocks;
1731         } else if (D.softlimit==0 && D.hardlimit==0) {
1732                 return False;
1733         } else {
1734                 if (D.softlimit == 0)
1735                         D.softlimit = D.hardlimit;
1736                 *dfree = D.softlimit - D.curblocks;
1737                 *dsize = D.softlimit;
1738         }
1739
1740         return (True);
1741 }
1742 #endif /* HAVE_SYS_QUOTAS */