lib/sysquotas_linux.c

説明を見る。
00001 /* 
00002    Unix SMB/CIFS implementation.
00003    System QUOTA function wrappers for LINUX
00004    Copyright (C) Stefan (metze) Metzmacher      2003
00005    
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2 of the License, or
00009    (at your option) any later version.
00010    
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015    
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00019 */
00020 
00021 
00022 #include "includes.h"
00023 
00024 #undef DBGC_CLASS
00025 #define DBGC_CLASS DBGC_QUOTA
00026 
00027 #ifndef HAVE_SYS_QUOTAS
00028 #ifdef HAVE_QUOTACTL_LINUX
00029 #undef HAVE_QUOTACTL_LINUX
00030 #endif
00031 #endif
00032 
00033 #ifdef HAVE_QUOTACTL_LINUX 
00034 
00035 #include "samba_linux_quota.h"
00036 
00037 /****************************************************************************
00038  Abstract out the v1 Linux quota get calls.
00039 ****************************************************************************/
00040 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)
00041 {
00042         int ret = -1;
00043         uint32 qflags = 0;
00044         struct v1_kern_dqblk D;
00045         SMB_BIG_UINT bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE;
00046 
00047         ZERO_STRUCT(D);
00048 
00049         switch (qtype) {
00050                 case SMB_USER_QUOTA_TYPE:
00051                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
00052                                 path, bdev, (unsigned)id.uid));
00053 
00054                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
00055                                 return ret;
00056                         }
00057 
00058                         break;
00059                 case SMB_GROUP_QUOTA_TYPE:
00060                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
00061                                 path, bdev, (unsigned)id.gid));
00062 
00063                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
00064                                 return ret;
00065                         }
00066 
00067                         break;
00068                 case SMB_USER_FS_QUOTA_TYPE:
00069                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
00070                                 path, bdev, (unsigned)id.uid));
00071 
00072                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
00073                                 qflags |= QUOTAS_DENY_DISK;
00074                         }
00075 
00076                         break;
00077                 case SMB_GROUP_FS_QUOTA_TYPE:
00078                         DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
00079                                 path, bdev, (unsigned)id.gid));
00080 
00081                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
00082                                 qflags |= QUOTAS_DENY_DISK;
00083                         }
00084 
00085                         break;
00086                 default:
00087                         errno = ENOSYS;
00088                         return -1;
00089         }
00090 
00091         dp->bsize = bsize;
00092         dp->softlimit = (SMB_BIG_UINT)D.dqb_bsoftlimit;
00093         dp->hardlimit = (SMB_BIG_UINT)D.dqb_bhardlimit;
00094         dp->ihardlimit = (SMB_BIG_UINT)D.dqb_ihardlimit;
00095         dp->isoftlimit = (SMB_BIG_UINT)D.dqb_isoftlimit;
00096         dp->curinodes = (SMB_BIG_UINT)D.dqb_curinodes;
00097         dp->curblocks = (SMB_BIG_UINT)D.dqb_curblocks;
00098 
00099 
00100         dp->qflags = qflags;
00101 
00102         return ret;
00103 }
00104 
00105 /****************************************************************************
00106  Abstract out the v1 Linux quota set calls.
00107 ****************************************************************************/
00108 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)
00109 {
00110         int ret = -1;
00111         uint32 qflags = 0;
00112         uint32 oldqflags = 0;
00113         struct v1_kern_dqblk D;
00114         SMB_BIG_UINT bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE;
00115 
00116         ZERO_STRUCT(D);
00117 
00118         if (bsize == dp->bsize) {
00119                 D.dqb_bsoftlimit = dp->softlimit;
00120                 D.dqb_bhardlimit = dp->hardlimit;
00121                 D.dqb_ihardlimit = dp->ihardlimit;
00122                 D.dqb_isoftlimit = dp->isoftlimit;
00123         } else {
00124                 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
00125                 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
00126                 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
00127                 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
00128         }
00129 
00130         qflags = dp->qflags;
00131 
00132         switch (qtype) {
00133                 case SMB_USER_QUOTA_TYPE:
00134                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
00135                                 path, bdev, (unsigned)id.uid));
00136 
00137                         ret = quotactl(QCMD(Q_V1_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
00138                         break;
00139                 case SMB_GROUP_QUOTA_TYPE:
00140                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
00141                                 path, bdev, (unsigned)id.gid));
00142 
00143                         ret = quotactl(QCMD(Q_V1_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
00144                         break;
00145                 case SMB_USER_FS_QUOTA_TYPE:
00146                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
00147                                 path, bdev, (unsigned)id.uid));
00148 
00149                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
00150                                 oldqflags |= QUOTAS_DENY_DISK;
00151                         }
00152 
00153                         break;
00154                 case SMB_GROUP_FS_QUOTA_TYPE:
00155                         DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
00156                                 path, bdev, (unsigned)id.gid));
00157 
00158                         if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
00159                                 oldqflags |= QUOTAS_DENY_DISK;
00160                         }
00161 
00162                         break;
00163                 default:
00164                         errno = ENOSYS;
00165                         return -1;
00166         }
00167 
00168         return ret;
00169 }
00170 
00171 /****************************************************************************
00172  Abstract out the v2 Linux quota get calls.
00173 ****************************************************************************/
00174 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)
00175 {
00176         int ret = -1;
00177         uint32 qflags = 0;
00178         struct v2_kern_dqblk D;
00179         SMB_BIG_UINT bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE;
00180 
00181         ZERO_STRUCT(D);
00182 
00183         switch (qtype) {
00184                 case SMB_USER_QUOTA_TYPE:
00185                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
00186                                 path, bdev, (unsigned)id.uid));
00187 
00188                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
00189                                 return ret;
00190                         }
00191 
00192                         break;
00193                 case SMB_GROUP_QUOTA_TYPE:
00194                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
00195                                 path, bdev, (unsigned)id.gid));
00196 
00197                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
00198                                 return ret;
00199                         }
00200 
00201                         break;
00202                 case SMB_USER_FS_QUOTA_TYPE:
00203                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
00204                                 path, bdev, (unsigned)id.uid));
00205 
00206                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
00207                                 qflags |= QUOTAS_DENY_DISK;
00208                         }
00209 
00210                         break;
00211                 case SMB_GROUP_FS_QUOTA_TYPE:
00212                         DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
00213                                 path, bdev, (unsigned)id.gid));
00214 
00215                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
00216                                 qflags |= QUOTAS_DENY_DISK;
00217                         }
00218 
00219                         break;
00220                 default:
00221                         errno = ENOSYS;
00222                         return -1;
00223         }
00224 
00225         dp->bsize = bsize;
00226         dp->softlimit = (SMB_BIG_UINT)D.dqb_bsoftlimit;
00227         dp->hardlimit = (SMB_BIG_UINT)D.dqb_bhardlimit;
00228         dp->ihardlimit = (SMB_BIG_UINT)D.dqb_ihardlimit;
00229         dp->isoftlimit = (SMB_BIG_UINT)D.dqb_isoftlimit;
00230         dp->curinodes = (SMB_BIG_UINT)D.dqb_curinodes;
00231         dp->curblocks = (SMB_BIG_UINT)D.dqb_curspace/bsize;
00232 
00233 
00234         dp->qflags = qflags;
00235 
00236         return ret;
00237 }
00238 
00239 /****************************************************************************
00240  Abstract out the v2 Linux quota set calls.
00241 ****************************************************************************/
00242 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)
00243 {
00244         int ret = -1;
00245         uint32 qflags = 0;
00246         uint32 oldqflags = 0;
00247         struct v2_kern_dqblk D;
00248         SMB_BIG_UINT bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE;
00249 
00250         ZERO_STRUCT(D);
00251 
00252         if (bsize == dp->bsize) {
00253                 D.dqb_bsoftlimit = dp->softlimit;
00254                 D.dqb_bhardlimit = dp->hardlimit;
00255                 D.dqb_ihardlimit = dp->ihardlimit;
00256                 D.dqb_isoftlimit = dp->isoftlimit;
00257         } else {
00258                 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
00259                 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
00260                 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
00261                 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
00262         }
00263 
00264         qflags = dp->qflags;
00265 
00266         switch (qtype) {
00267                 case SMB_USER_QUOTA_TYPE:
00268                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
00269                                 path, bdev, (unsigned)id.uid));
00270 
00271                         ret = quotactl(QCMD(Q_V2_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
00272                         break;
00273                 case SMB_GROUP_QUOTA_TYPE:
00274                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
00275                                 path, bdev, (unsigned)id.gid));
00276 
00277                         ret = quotactl(QCMD(Q_V2_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
00278                         break;
00279                 case SMB_USER_FS_QUOTA_TYPE:
00280                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
00281                                 path, bdev, (unsigned)id.uid));
00282 
00283                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
00284                                 oldqflags |= QUOTAS_DENY_DISK;
00285                         }
00286 
00287                         break;
00288                 case SMB_GROUP_FS_QUOTA_TYPE:
00289                         DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
00290                                 path, bdev, (unsigned)id.gid));
00291 
00292                         if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
00293                                 oldqflags |= QUOTAS_DENY_DISK;
00294                         }
00295 
00296                         break;
00297                 default:
00298                         errno = ENOSYS;
00299                         return -1;
00300         }
00301 
00302         return ret;
00303 }
00304 
00305 /****************************************************************************
00306  Abstract out the generic Linux quota get calls.
00307 ****************************************************************************/
00308 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)
00309 {
00310         int ret = -1;
00311         uint32 qflags = 0;
00312         struct if_dqblk D;
00313         SMB_BIG_UINT bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE;
00314 
00315         ZERO_STRUCT(D);
00316 
00317         switch (qtype) {
00318                 case SMB_USER_QUOTA_TYPE:
00319                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
00320                                 path, bdev, (unsigned)id.uid));
00321 
00322                         if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
00323                                 return ret;
00324                         }
00325 
00326                         break;
00327                 case SMB_GROUP_QUOTA_TYPE:
00328                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
00329                                 path, bdev, (unsigned)id.gid));
00330 
00331                         if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
00332                                 return ret;
00333                         }
00334 
00335                         break;
00336                 case SMB_USER_FS_QUOTA_TYPE:
00337                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
00338                                 path, bdev, (unsigned)id.uid));
00339 
00340                         if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
00341                                 qflags |= QUOTAS_DENY_DISK;
00342                         }
00343 
00344                         break;
00345                 case SMB_GROUP_FS_QUOTA_TYPE:
00346                         DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
00347                                 path, bdev, (unsigned)id.gid));
00348 
00349                         if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
00350                                 qflags |= QUOTAS_DENY_DISK;
00351                         }
00352 
00353                         break;
00354                 default:
00355                         errno = ENOSYS;
00356                         return -1;
00357         }
00358 
00359         dp->bsize = bsize;
00360         dp->softlimit = (SMB_BIG_UINT)D.dqb_bsoftlimit;
00361         dp->hardlimit = (SMB_BIG_UINT)D.dqb_bhardlimit;
00362         dp->ihardlimit = (SMB_BIG_UINT)D.dqb_ihardlimit;
00363         dp->isoftlimit = (SMB_BIG_UINT)D.dqb_isoftlimit;
00364         dp->curinodes = (SMB_BIG_UINT)D.dqb_curinodes;
00365         dp->curblocks = (SMB_BIG_UINT)D.dqb_curspace/bsize;
00366 
00367 
00368         dp->qflags = qflags;
00369 
00370         return ret;
00371 }
00372 
00373 /****************************************************************************
00374  Abstract out the gen Linux quota set calls.
00375 ****************************************************************************/
00376 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)
00377 {
00378         int ret = -1;
00379         uint32 qflags = 0;
00380         uint32 oldqflags = 0;
00381         struct if_dqblk D;
00382         SMB_BIG_UINT bsize = (SMB_BIG_UINT)QUOTABLOCK_SIZE;
00383 
00384         ZERO_STRUCT(D);
00385 
00386         if (bsize == dp->bsize) {
00387                 D.dqb_bsoftlimit = dp->softlimit;
00388                 D.dqb_bhardlimit = dp->hardlimit;
00389                 D.dqb_ihardlimit = dp->ihardlimit;
00390                 D.dqb_isoftlimit = dp->isoftlimit;
00391         } else {
00392                 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
00393                 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
00394                 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
00395                 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
00396         }
00397         D.dqb_valid = QIF_LIMITS;
00398 
00399         qflags = dp->qflags;
00400 
00401         switch (qtype) {
00402                 case SMB_USER_QUOTA_TYPE:
00403                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
00404                                 path, bdev, (unsigned)id.uid));
00405 
00406                         ret = quotactl(QCMD(Q_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
00407                         break;
00408                 case SMB_GROUP_QUOTA_TYPE:
00409                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
00410                                 path, bdev, (unsigned)id.gid));
00411 
00412                         ret = quotactl(QCMD(Q_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
00413                         break;
00414                 case SMB_USER_FS_QUOTA_TYPE:
00415                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
00416                                 path, bdev, (unsigned)id.uid));
00417 
00418                         if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
00419                                 oldqflags |= QUOTAS_DENY_DISK;
00420                         }
00421 
00422                         break;
00423                 case SMB_GROUP_FS_QUOTA_TYPE:
00424                         DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
00425                                 path, bdev, (unsigned)id.gid));
00426 
00427                         if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
00428                                 oldqflags |= QUOTAS_DENY_DISK;
00429                         }
00430 
00431                         break;
00432                 default:
00433                         errno = ENOSYS;
00434                         return -1;
00435         }
00436 
00437         return ret;
00438 }
00439 
00440 /****************************************************************************
00441  Abstract out the Linux quota get calls.
00442 ****************************************************************************/
00443 int sys_get_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
00444 {
00445         int ret = -1;
00446 
00447         if (!path||!bdev||!dp)
00448                 smb_panic("sys_set_vfs_quota: called with NULL pointer");
00449 
00450         ZERO_STRUCT(*dp);
00451         dp->qtype = qtype;
00452 
00453         switch (qtype) {
00454                 case SMB_USER_QUOTA_TYPE:
00455                 case SMB_GROUP_QUOTA_TYPE:
00456                         if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00457                                 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00458                                         if ((ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00459                                                 return ret;
00460                                         }
00461                                 }
00462                         }
00463 
00464                         if ((dp->curblocks==0)&&
00465                                 (dp->softlimit==0)&&
00466                                 (dp->hardlimit==0)) {
00467                                 /* the upper layer functions don't want empty quota records...*/
00468                                 return -1;
00469                         }
00470 
00471                         break;
00472                 case SMB_USER_FS_QUOTA_TYPE:
00473                         id.uid = getuid();
00474 
00475                         if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00476                                 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00477                                         ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp);
00478                                 }
00479                         }
00480 
00481                         ret = 0;
00482                         break;
00483                 case SMB_GROUP_FS_QUOTA_TYPE:
00484                         id.gid = getgid();
00485 
00486                         if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00487                                 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
00488                                         ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp);
00489                                 }
00490                         }
00491 
00492                         ret = 0;
00493                         break;
00494                 default:
00495                         errno = ENOSYS;
00496                         return -1;
00497         }
00498 
00499         return ret;
00500 }
00501 
00502 /****************************************************************************
00503  Abstract out the Linux quota set calls.
00504 ****************************************************************************/
00505 int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
00506 {
00507         int ret = -1;
00508         uint32 oldqflags = 0;
00509 
00510         if (!path||!bdev||!dp)
00511                 smb_panic("sys_set_vfs_quota: called with NULL pointer");
00512 
00513         oldqflags = dp->qflags;
00514 
00515         switch (qtype) {
00516                 case SMB_USER_QUOTA_TYPE:
00517                 case SMB_GROUP_QUOTA_TYPE:
00518                         if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
00519                                 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
00520                                         if ((ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp))) {
00521                                                 return ret;
00522                                         }
00523                                 }
00524                         }
00525                         break;
00526                 case SMB_USER_FS_QUOTA_TYPE:
00527                         id.uid = getuid();
00528 
00529                         if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
00530                                 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
00531                                         ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp);
00532                                 }
00533                         }
00534 
00535                         if (oldqflags == dp->qflags) {
00536                                 ret = 0;
00537                         } else {
00538                                 ret = -1;
00539                         }
00540                         break;
00541                 case SMB_GROUP_FS_QUOTA_TYPE:
00542                         id.gid = getgid();
00543 
00544                         if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
00545                                 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
00546                                         ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp);
00547                                 }
00548                         }
00549 
00550                         if (oldqflags == dp->qflags) {
00551                                 ret = 0;
00552                         } else {
00553                                 ret = -1;
00554                         }
00555 
00556                         break;
00557                 default:
00558                         errno = ENOSYS;
00559                         return -1;
00560         }
00561 
00562         return ret;
00563 }
00564 
00565 #else /* HAVE_QUOTACTL_LINUX */
00566  void dummy_sysquotas_linux(void);
00567 
00568  void dummy_sysquotas_linux(void){}
00569 #endif /* HAVE_QUOTACTL_LINUX */

Sambaに対してSat Aug 29 21:22:59 2009に生成されました。  doxygen 1.4.7