source3/lib/sysquotas_linux.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    System QUOTA function wrappers for LINUX
   4    Copyright (C) Stefan (metze) Metzmacher      2003
   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 #include "includes.h"
  22
  23 #undef DBGC_CLASS
  24 #define DBGC_CLASS DBGC_QUOTA
  25
  26 #ifndef HAVE_SYS_QUOTAS
  27 #ifdef HAVE_QUOTACTL_LINUX
  28 #undef HAVE_QUOTACTL_LINUX
  29 #endif
  30 #endif
  31
  32 #ifdef HAVE_QUOTACTL_LINUX
  33
  34 #include "samba_linux_quota.h"
  35
  36 /****************************************************************************
  37  Abstract out the v1 Linux quota get calls.
  38 ****************************************************************************/
  39 static int sys_get_linux_v1_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
  40 {
  41         int ret = -1;
  42         uint32_t qflags = 0;
  43         struct v1_kern_dqblk D;
  44         uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
  45
  46         ZERO_STRUCT(D);
  47
  48         switch (qtype) {
  49                 case SMB_USER_QUOTA_TYPE:
  50                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
  51                                 path, bdev, (unsigned)id.uid));
  52
  53                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
  54                                 return ret;
  55                         }
  56
  57                         break;
  58                 case SMB_GROUP_QUOTA_TYPE:
  59                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
  60                                 path, bdev, (unsigned)id.gid));
  61
  62                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
  63                                 return ret;
  64                         }
  65
  66                         break;
  67                 case SMB_USER_FS_QUOTA_TYPE:
  68                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
  69                                 path, bdev, (unsigned)id.uid));
  70
  71                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
  72                                 qflags |= QUOTAS_DENY_DISK;
  73                         }
  74
  75                         break;
  76                 case SMB_GROUP_FS_QUOTA_TYPE:
  77                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
  78                                 path, bdev, (unsigned)id.gid));
  79
  80                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
  81                                 qflags |= QUOTAS_DENY_DISK;
  82                         }
  83
  84                         break;
  85                 default:
  86                         errno = ENOSYS;
  87                         return -1;
  88         }
  89
  90         dp->bsize = bsize;
  91         dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
  92         dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
  93         dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
  94         dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
  95         dp->curinodes = (uint64_t)D.dqb_curinodes;
  96         dp->curblocks = (uint64_t)D.dqb_curblocks;
  97
  98
  99         dp->qflags = qflags;
 100
 101         return ret;
 102 }
 103
 104 /****************************************************************************
 105  Abstract out the v1 Linux quota set calls.
 106 ****************************************************************************/
 107 static int sys_set_linux_v1_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 108 {
 109         int ret = -1;
 110         struct v1_kern_dqblk D;
 111         uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
 112
 113         ZERO_STRUCT(D);
 114
 115         if (bsize == dp->bsize) {
 116                 D.dqb_bsoftlimit = dp->softlimit;
 117                 D.dqb_bhardlimit = dp->hardlimit;
 118                 D.dqb_ihardlimit = dp->ihardlimit;
 119                 D.dqb_isoftlimit = dp->isoftlimit;
 120         } else {
 121                 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
 122                 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
 123                 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
 124                 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
 125         }
 126
 127         switch (qtype) {
 128                 case SMB_USER_QUOTA_TYPE:
 129                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
 130                                 path, bdev, (unsigned)id.uid));
 131
 132                         ret = quotactl(QCMD(Q_V1_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
 133                         break;
 134                 case SMB_GROUP_QUOTA_TYPE:
 135                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 136                                 path, bdev, (unsigned)id.gid));
 137
 138                         ret = quotactl(QCMD(Q_V1_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
 139                         break;
 140                 case SMB_USER_FS_QUOTA_TYPE:
 141                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 142                                 path, bdev, (unsigned)id.uid));
 143
 144                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
 145                                 dp->qflags |= QUOTAS_DENY_DISK;
 146                         }
 147
 148                         break;
 149                 case SMB_GROUP_FS_QUOTA_TYPE:
 150                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 151                                 path, bdev, (unsigned)id.gid));
 152
 153                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
 154                                 dp->qflags |= QUOTAS_DENY_DISK;
 155                         }
 156
 157                         break;
 158                 default:
 159                         errno = ENOSYS;
 160                         return -1;
 161         }
 162
 163         return ret;
 164 }
 165
 166 /****************************************************************************
 167  Abstract out the v2 Linux quota get calls.
 168 ****************************************************************************/
 169 static int sys_get_linux_v2_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 170 {
 171         int ret = -1;
 172         uint32_t qflags = 0;
 173         struct v2_kern_dqblk D;
 174         uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
 175
 176         ZERO_STRUCT(D);
 177
 178         switch (qtype) {
 179                 case SMB_USER_QUOTA_TYPE:
 180                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
 181                                 path, bdev, (unsigned)id.uid));
 182
 183                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
 184                                 return ret;
 185                         }
 186
 187                         break;
 188                 case SMB_GROUP_QUOTA_TYPE:
 189                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 190                                 path, bdev, (unsigned)id.gid));
 191
 192                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
 193                                 return ret;
 194                         }
 195
 196                         break;
 197                 case SMB_USER_FS_QUOTA_TYPE:
 198                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 199                                 path, bdev, (unsigned)id.uid));
 200
 201                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
 202                                 qflags |= QUOTAS_DENY_DISK;
 203                         }
 204
 205                         break;
 206                 case SMB_GROUP_FS_QUOTA_TYPE:
 207                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 208                                 path, bdev, (unsigned)id.gid));
 209
 210                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
 211                                 qflags |= QUOTAS_DENY_DISK;
 212                         }
 213
 214                         break;
 215                 default:
 216                         errno = ENOSYS;
 217                         return -1;
 218         }
 219
 220         dp->bsize = bsize;
 221         dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
 222         dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
 223         dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
 224         dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
 225         dp->curinodes = (uint64_t)D.dqb_curinodes;
 226         dp->curblocks = (uint64_t)D.dqb_curspace/bsize;
 227
 228
 229         dp->qflags = qflags;
 230
 231         return ret;
 232 }
 233
 234 /****************************************************************************
 235  Abstract out the v2 Linux quota set calls.
 236 ****************************************************************************/
 237 static int sys_set_linux_v2_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 238 {
 239         int ret = -1;
 240         struct v2_kern_dqblk D;
 241         uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
 242
 243         ZERO_STRUCT(D);
 244
 245         if (bsize == dp->bsize) {
 246                 D.dqb_bsoftlimit = dp->softlimit;
 247                 D.dqb_bhardlimit = dp->hardlimit;
 248                 D.dqb_ihardlimit = dp->ihardlimit;
 249                 D.dqb_isoftlimit = dp->isoftlimit;
 250         } else {
 251                 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
 252                 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
 253                 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
 254                 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
 255         }
 256
 257         switch (qtype) {
 258                 case SMB_USER_QUOTA_TYPE:
 259                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
 260                                 path, bdev, (unsigned)id.uid));
 261
 262                         ret = quotactl(QCMD(Q_V2_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
 263                         break;
 264                 case SMB_GROUP_QUOTA_TYPE:
 265                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 266                                 path, bdev, (unsigned)id.gid));
 267
 268                         ret = quotactl(QCMD(Q_V2_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
 269                         break;
 270                 case SMB_USER_FS_QUOTA_TYPE:
 271                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 272                                 path, bdev, (unsigned)id.uid));
 273
 274                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
 275                                 dp->qflags |= QUOTAS_DENY_DISK;
 276                         }
 277
 278                         break;
 279                 case SMB_GROUP_FS_QUOTA_TYPE:
 280                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 281                                 path, bdev, (unsigned)id.gid));
 282
 283                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
 284                                 dp->qflags |= QUOTAS_DENY_DISK;
 285                         }
 286
 287                         break;
 288                 default:
 289                         errno = ENOSYS;
 290                         return -1;
 291         }
 292
 293         return ret;
 294 }
 295
 296 /****************************************************************************
 297  Abstract out the generic Linux quota get calls.
 298 ****************************************************************************/
 299 static int sys_get_linux_gen_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 300 {
 301         int ret = -1;
 302         uint32_t qflags = 0;
 303         struct if_dqblk D;
 304         uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
 305
 306         ZERO_STRUCT(D);
 307
 308         switch (qtype) {
 309                 case SMB_USER_QUOTA_TYPE:
 310                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
 311                                 path, bdev, (unsigned)id.uid));
 312
 313                         if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
 314                                 return ret;
 315                         }
 316
 317                         break;
 318                 case SMB_GROUP_QUOTA_TYPE:
 319                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 320                                 path, bdev, (unsigned)id.gid));
 321
 322                         if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
 323                                 return ret;
 324                         }
 325
 326                         break;
 327                 case SMB_USER_FS_QUOTA_TYPE:
 328                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 329                                 path, bdev, (unsigned)id.uid));
 330
 331                         if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
 332                                 qflags |= QUOTAS_DENY_DISK;
 333                         }
 334
 335                         break;
 336                 case SMB_GROUP_FS_QUOTA_TYPE:
 337                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 338                                 path, bdev, (unsigned)id.gid));
 339
 340                         if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
 341                                 qflags |= QUOTAS_DENY_DISK;
 342                         }
 343
 344                         break;
 345                 default:
 346                         errno = ENOSYS;
 347                         return -1;
 348         }
 349
 350         dp->bsize = bsize;
 351         dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
 352         dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
 353         dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
 354         dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
 355         dp->curinodes = (uint64_t)D.dqb_curinodes;
 356         dp->curblocks = (uint64_t)D.dqb_curspace/bsize;
 357
 358
 359         dp->qflags = qflags;
 360
 361         return ret;
 362 }
 363
 364 /****************************************************************************
 365  Abstract out the gen Linux quota set calls.
 366 ****************************************************************************/
 367 static int sys_set_linux_gen_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 368 {
 369         int ret = -1;
 370         struct if_dqblk D;
 371         uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
 372
 373         ZERO_STRUCT(D);
 374
 375         if (bsize == dp->bsize) {
 376                 D.dqb_bsoftlimit = dp->softlimit;
 377                 D.dqb_bhardlimit = dp->hardlimit;
 378                 D.dqb_ihardlimit = dp->ihardlimit;
 379                 D.dqb_isoftlimit = dp->isoftlimit;
 380         } else {
 381                 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
 382                 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
 383                 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
 384                 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
 385         }
 386         D.dqb_valid = QIF_LIMITS;
 387
 388         switch (qtype) {
 389                 case SMB_USER_QUOTA_TYPE:
 390                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
 391                                 path, bdev, (unsigned)id.uid));
 392
 393                         ret = quotactl(QCMD(Q_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
 394                         break;
 395                 case SMB_GROUP_QUOTA_TYPE:
 396                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
 397                                 path, bdev, (unsigned)id.gid));
 398
 399                         ret = quotactl(QCMD(Q_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
 400                         break;
 401                 case SMB_USER_FS_QUOTA_TYPE:
 402                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
 403                                 path, bdev, (unsigned)id.uid));
 404
 405                         if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
 406                                 dp->qflags |= QUOTAS_DENY_DISK;
 407                         }
 408
 409                         break;
 410                 case SMB_GROUP_FS_QUOTA_TYPE:
 411                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
 412                                 path, bdev, (unsigned)id.gid));
 413
 414                         if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
 415                                 dp->qflags |= QUOTAS_DENY_DISK;
 416                         }
 417
 418                         break;
 419                 default:
 420                         errno = ENOSYS;
 421                         return -1;
 422         }
 423
 424         return ret;
 425 }
 426
 427 /****************************************************************************
 428  Abstract out the Linux quota get calls.
 429 ****************************************************************************/
 430 int sys_get_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 431 {
 432         int ret = -1;
 433
 434         if (!path||!bdev||!dp)
 435                 smb_panic("sys_set_vfs_quota: called with NULL pointer");
 436
 437         ZERO_STRUCT(*dp);
 438         dp->qtype = qtype;
 439
 440         switch (qtype) {
 441                 case SMB_USER_QUOTA_TYPE:
 442                 case SMB_GROUP_QUOTA_TYPE:
 443                         if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 444                                 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 445                                         if ((ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 446                                                 return ret;
 447                                         }
 448                                 }
 449                         }
 450
 451                         if ((dp->curblocks==0)&&
 452                                 (dp->softlimit==0)&&
 453                                 (dp->hardlimit==0)) {
 454                                 /* the upper layer functions don't want empty quota records...*/
 455                                 return -1;
 456                         }
 457
 458                         break;
 459                 case SMB_USER_FS_QUOTA_TYPE:
 460                         id.uid = getuid();
 461
 462                         if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 463                                 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 464                                         ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp);
 465                                 }
 466                         }
 467
 468                         ret = 0;
 469                         break;
 470                 case SMB_GROUP_FS_QUOTA_TYPE:
 471                         id.gid = getgid();
 472
 473                         if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 474                                 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
 475                                         ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp);
 476                                 }
 477                         }
 478
 479                         ret = 0;
 480                         break;
 481                 default:
 482                         errno = ENOSYS;
 483                         return -1;
 484         }
 485
 486         return ret;
 487 }
 488
 489 /****************************************************************************
 490  Abstract out the Linux quota set calls.
 491 ****************************************************************************/
 492 int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 493 {
 494         int ret = -1;
 495         uint32_t oldqflags = 0;
 496
 497         if (!path||!bdev||!dp)
 498                 smb_panic("sys_set_vfs_quota: called with NULL pointer");
 499
 500         oldqflags = dp->qflags;
 501
 502         switch (qtype) {
 503                 case SMB_USER_QUOTA_TYPE:
 504                 case SMB_GROUP_QUOTA_TYPE:
 505                         if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
 506                                 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
 507                                         if ((ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp))) {
 508                                                 return ret;
 509                                         }
 510                                 }
 511                         }
 512                         break;
 513                 case SMB_USER_FS_QUOTA_TYPE:
 514                         id.uid = getuid();
 515
 516                         if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
 517                                 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
 518                                         ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp);
 519                                 }
 520                         }
 521
 522                         if (oldqflags == dp->qflags) {
 523                                 ret = 0;
 524                         } else {
 525                                 ret = -1;
 526                         }
 527                         break;
 528                 case SMB_GROUP_FS_QUOTA_TYPE:
 529                         id.gid = getgid();
 530
 531                         if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
 532                                 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
 533                                         ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp);
 534                                 }
 535                         }
 536
 537                         if (oldqflags == dp->qflags) {
 538                                 ret = 0;
 539                         } else {
 540                                 ret = -1;
 541                         }
 542
 543                         break;
 544                 default:
 545                         errno = ENOSYS;
 546                         return -1;
 547         }
 548
 549         return ret;
 550 }
 551
 552 #else /* HAVE_QUOTACTL_LINUX */
 553  void dummy_sysquotas_linux(void);
 554
 555  void dummy_sysquotas_linux(void){}
 556 #endif /* HAVE_QUOTACTL_LINUX */