source3/modules/vfs_default_quota.c

   1 /*
   2  * Store default Quotas in a specified quota record
   3  *
   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  * This module allows the default quota values,
  22  * in the windows explorer GUI, to be stored on a samba server.
  23  * The problem is that linux filesystems only store quotas
  24  * for users and groups, but no default quotas.
  25  *
  26  * Samba returns NO_LIMIT as the default quotas by default
  27  * and refuses to update them.
  28  *
  29  * With this module you can store the default quotas that are reported to
  30  * a windows client, in the quota record of a user. By default the root user
  31  * is taken because quota limits for root are typically not enforced.
  32  *
  33  * This module takes 2 parametric parameters in smb.conf:
  34  * (the default prefix for them is 'default_quota',
  35  *  it can be overwrittem when you load the module in
  36  *  the 'vfs objects' parameter like this:
  37  *  vfs objects = default_quota:myprefix)
  38  *
  39  * "<myprefix>:uid" parameter takes a integer argument,
  40  *     it specifies the uid of the quota record, that will be taken for
  41  *     storing the default USER-quotas.
  42  *
  43  *     - default value: '0' (for root user)
  44  *     - e.g.: default_quota:uid = 65534
  45  *
  46  * "<myprefix>:uid nolimit" parameter takes a boolean argument,
  47  *     it specifies if we should report the stored default quota values,
  48  *     also for the user record, or if you should just report NO_LIMIT
  49  *     to the windows client for the user specified by the "<prefix>:uid" parameter.
  50  *
  51  *     - default value: yes (that means to report NO_LIMIT)
  52  *     - e.g.: default_quota:uid nolimit = no
  53  *
  54  * "<myprefix>:gid" parameter takes a integer argument,
  55  *     it's just like "<prefix>:uid" but for group quotas.
  56  *     (NOTE: group quotas are not supported from the windows explorer!)
  57  *
  58  *     - default value: '0' (for root group)
  59  *     - e.g.: default_quota:gid = 65534
  60  *
  61  * "<myprefix>:gid nolimit" parameter takes a boolean argument,
  62  *     it's just like "<prefix>:uid nolimit" but for group quotas.
  63  *     (NOTE: group quotas are not supported from the windows explorer!)
  64  *
  65  *     - default value: yes (that means to report NO_LIMIT)
  66  *     - e.g.: default_quota:uid nolimit = no
  67  *
  68  */
  69
  70 #include "includes.h"
  71 #include "smbd/smbd.h"
  72
  73 #undef DBGC_CLASS
  74 #define DBGC_CLASS DBGC_QUOTA
  75
  76 #define DEFAULT_QUOTA_NAME "default_quota"
  77
  78 #define DEFAULT_QUOTA_UID_DEFAULT               0
  79 #define DEFAULT_QUOTA_UID_NOLIMIT_DEFAULT       True
  80 #define DEFAULT_QUOTA_GID_DEFAULT               0
  81 #define DEFAULT_QUOTA_GID_NOLIMIT_DEFAULT       True
  82
  83 #define DEFAULT_QUOTA_UID(handle) \
  84         (uid_t)lp_parm_int(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"uid",DEFAULT_QUOTA_UID_DEFAULT)
  85
  86 #define DEFAULT_QUOTA_UID_NOLIMIT(handle) \
  87         lp_parm_bool(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"uid nolimit",DEFAULT_QUOTA_UID_NOLIMIT_DEFAULT)
  88
  89 #define DEFAULT_QUOTA_GID(handle) \
  90         (gid_t)lp_parm_int(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"gid",DEFAULT_QUOTA_GID_DEFAULT)
  91
  92 #define DEFAULT_QUOTA_GID_NOLIMIT(handle) \
  93         lp_parm_bool(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"gid nolimit",DEFAULT_QUOTA_GID_NOLIMIT_DEFAULT)
  94
  95 static int default_quota_get_quota(vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq)
  96 {
  97         int ret = -1;
  98
  99         if ((ret=SMB_VFS_NEXT_GET_QUOTA(handle, qtype, id, dq))!=0) {
 100                 return ret;
 101         }
 102
 103         switch (qtype) {
 104                 case SMB_USER_QUOTA_TYPE:
 105                         /* we use id.uid == 0 for default quotas */
 106                         if ((id.uid==DEFAULT_QUOTA_UID(handle)) &&
 107                                 DEFAULT_QUOTA_UID_NOLIMIT(handle)) {
 108                                 SMB_QUOTAS_SET_NO_LIMIT(dq);
 109                         }
 110                         break;
 111 #ifdef HAVE_GROUP_QUOTA
 112                 case SMB_GROUP_QUOTA_TYPE:
 113                         /* we use id.gid == 0 for default quotas */
 114                         if ((id.gid==DEFAULT_QUOTA_GID(handle)) &&
 115                                 DEFAULT_QUOTA_GID_NOLIMIT(handle)) {
 116                                 SMB_QUOTAS_SET_NO_LIMIT(dq);
 117                         }
 118                         break;
 119 #endif /* HAVE_GROUP_QUOTA */
 120                 case SMB_USER_FS_QUOTA_TYPE:
 121                         {
 122                                 unid_t qid;
 123                                 uint32 qflags = dq->qflags;
 124                                 qid.uid = DEFAULT_QUOTA_UID(handle);
 125                                 SMB_VFS_NEXT_GET_QUOTA(handle, SMB_USER_QUOTA_TYPE, qid, dq);
 126                                 dq->qflags = qflags;
 127                         }
 128                         break;
 129 #ifdef HAVE_GROUP_QUOTA
 130                 case SMB_GROUP_FS_QUOTA_TYPE:
 131                         {
 132                                 unid_t qid;
 133                                 uint32 qflags = dq->qflags;
 134                                 qid.gid = DEFAULT_QUOTA_GID(handle);
 135                                 SMB_VFS_NEXT_GET_QUOTA(handle, SMB_GROUP_QUOTA_TYPE, qid, dq);
 136                                 dq->qflags = qflags;
 137                         }
 138                         break;
 139 #endif /* HAVE_GROUP_QUOTA */
 140                 default:
 141                         errno = ENOSYS;
 142                         return -1;
 143                         break;
 144         }
 145
 146         return ret;
 147 }
 148
 149 static int default_quota_set_quota(vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq)
 150 {
 151         int ret = -1;
 152
 153         switch (qtype) {
 154                 case SMB_USER_QUOTA_TYPE:
 155                         /* we use id.uid == 0 for default quotas */
 156                         if ((id.uid==DEFAULT_QUOTA_UID(handle)) &&
 157                                 DEFAULT_QUOTA_UID_NOLIMIT(handle)) {
 158                                 return -1;
 159                         }
 160                         break;
 161 #ifdef HAVE_GROUP_QUOTA
 162                 case SMB_GROUP_QUOTA_TYPE:
 163                         /* we use id.gid == 0 for default quotas */
 164                         if ((id.gid==DEFAULT_QUOTA_GID(handle)) &&
 165                                 DEFAULT_QUOTA_GID_NOLIMIT(handle)) {
 166                                 return -1;
 167                         }
 168                         break;
 169 #endif /* HAVE_GROUP_QUOTA */
 170                 case SMB_USER_FS_QUOTA_TYPE:
 171                         break;
 172 #ifdef HAVE_GROUP_QUOTA
 173                 case SMB_GROUP_FS_QUOTA_TYPE:
 174                         break;
 175 #endif /* HAVE_GROUP_QUOTA */
 176                 default:
 177                         errno = ENOSYS;
 178                         return -1;
 179                         break;
 180         }
 181
 182         if ((ret=SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, dq))!=0) {
 183                 return ret;
 184         }
 185
 186         switch (qtype) {
 187                 case SMB_USER_QUOTA_TYPE:
 188                         break;
 189 #ifdef HAVE_GROUP_QUOTA
 190                 case SMB_GROUP_QUOTA_TYPE:
 191                         break;
 192 #endif /* HAVE_GROUP_QUOTA */
 193                 case SMB_USER_FS_QUOTA_TYPE:
 194                         {
 195                                 unid_t qid;
 196                                 qid.uid = DEFAULT_QUOTA_UID(handle);
 197                                 ret = SMB_VFS_NEXT_SET_QUOTA(handle, SMB_USER_QUOTA_TYPE, qid, dq);
 198                         }
 199                         break;
 200 #ifdef HAVE_GROUP_QUOTA
 201                 case SMB_GROUP_FS_QUOTA_TYPE:
 202                         {
 203                                 unid_t qid;
 204                                 qid.gid = DEFAULT_QUOTA_GID(handle);
 205                                 ret = SMB_VFS_NEXT_SET_QUOTA(handle, SMB_GROUP_QUOTA_TYPE, qid, dq);
 206                         }
 207                         break;
 208 #endif /* HAVE_GROUP_QUOTA */
 209                 default:
 210                         errno = ENOSYS;
 211                         return -1;
 212                         break;
 213         }
 214
 215         return ret;
 216 }
 217
 218 static struct vfs_fn_pointers vfs_default_quota_fns = {
 219         .get_quota_fn = default_quota_get_quota,
 220         .set_quota_fn = default_quota_set_quota
 221 };
 222
 223 NTSTATUS vfs_default_quota_init(void);
 224 NTSTATUS vfs_default_quota_init(void)
 225 {
 226         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, DEFAULT_QUOTA_NAME,
 227                                 &vfs_default_quota_fns);
 228 }