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