source3/modules/vfs_fake_dfq.c

   1 /*
   2  * Fake Disk-Free and Quota VFS module.  Implements passthrough operation
   3  * of all VFS calls, except for "disk free" and "get quota" which
   4  * are handled by reading a text file named ".dfq" in the current directory.
   5  *
   6  * This module is intended for testing purposes.
   7  *
   8  * Copyright (C) Uri Simchoni, 2016
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include "includes.h"
  25 #include "smbd/smbd.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_VFS
  29
  30 static int dfq_get_quota(struct vfs_handle_struct *handle,
  31                         const struct smb_filename *smb_fname,
  32                         enum SMB_QUOTA_TYPE qtype,
  33                         unid_t id,
  34                         SMB_DISK_QUOTA *qt);
  35
  36 static uint64_t dfq_load_param(int snum, const char *path, const char *section,
  37                                const char *param, uint64_t def_val)
  38 {
  39         uint64_t ret;
  40
  41         char *option =
  42             talloc_asprintf(talloc_tos(), "%s/%s/%s", section, param, path);
  43         if (option == NULL) {
  44                 return def_val;
  45         }
  46
  47         ret = (uint64_t)lp_parm_ulonglong(snum, "fake_dfq", option,
  48                                           (unsigned long long)def_val);
  49
  50         TALLOC_FREE(option);
  51
  52         return ret;
  53 }
  54
  55 static uint64_t dfq_disk_free(vfs_handle_struct *handle,
  56                                 const struct smb_filename *smb_fname,
  57                                 uint64_t *bsize,
  58                                 uint64_t *dfree,
  59                                 uint64_t *dsize)
  60 {
  61         uint64_t free_1k;
  62         int snum = SNUM(handle->conn);
  63         uint64_t dfq_bsize = 0;
  64         struct smb_filename *rpath_fname = NULL;
  65
  66         /* look up the params based on real path to be resilient
  67          * to refactoring of path<->realpath
  68          */
  69         rpath_fname = SMB_VFS_NEXT_REALPATH(handle, talloc_tos(), smb_fname);
  70         if (rpath_fname != NULL) {
  71                 dfq_bsize = dfq_load_param(snum, rpath_fname->base_name,
  72                                 "df", "block size", 0);
  73         }
  74         if (dfq_bsize == 0) {
  75                 TALLOC_FREE(rpath_fname);
  76                 return SMB_VFS_NEXT_DISK_FREE(handle, smb_fname, bsize, dfree,
  77                                               dsize);
  78         }
  79
  80         *bsize = dfq_bsize;
  81         *dfree = dfq_load_param(snum, rpath_fname->base_name,
  82                                 "df", "disk free", 0);
  83         *dsize = dfq_load_param(snum, rpath_fname->base_name,
  84                                 "df", "disk size", 0);
  85
  86         if ((*bsize) < 1024) {
  87                 free_1k = (*dfree) / (1024 / (*bsize));
  88         } else {
  89                 free_1k = ((*bsize) / 1024) * (*dfree);
  90         }
  91
  92         TALLOC_FREE(rpath_fname);
  93         return free_1k;
  94 }
  95
  96 static int dfq_get_quota(struct vfs_handle_struct *handle,
  97                         const struct smb_filename *smb_fname,
  98                         enum SMB_QUOTA_TYPE qtype,
  99                         unid_t id,
 100                         SMB_DISK_QUOTA *qt)
 101 {
 102         int rc = 0;
 103         int save_errno;
 104         char *section = NULL;
 105         int snum = SNUM(handle->conn);
 106         uint64_t bsize = 0;
 107         struct smb_filename *rpath_fname = NULL;
 108
 109         rpath_fname = SMB_VFS_NEXT_REALPATH(handle, talloc_tos(), smb_fname);
 110         if (rpath_fname == NULL) {
 111                 goto dflt;
 112         }
 113
 114         switch (qtype) {
 115         case SMB_USER_QUOTA_TYPE:
 116                 section = talloc_asprintf(talloc_tos(), "u%llu",
 117                                           (unsigned long long)id.uid);
 118                 break;
 119         case SMB_GROUP_QUOTA_TYPE:
 120                 section = talloc_asprintf(talloc_tos(), "g%llu",
 121                                           (unsigned long long)id.gid);
 122                 break;
 123         case SMB_USER_FS_QUOTA_TYPE:
 124                 section = talloc_strdup(talloc_tos(), "udflt");
 125                 break;
 126         case SMB_GROUP_FS_QUOTA_TYPE:
 127                 section = talloc_strdup(talloc_tos(), "gdflt");
 128                 break;
 129         default:
 130                 break;
 131         }
 132
 133         if (section == NULL) {
 134                 goto dflt;
 135         }
 136
 137         bsize = dfq_load_param(snum, rpath_fname->base_name,
 138                                 section, "block size", 4096);
 139         if (bsize == 0) {
 140                 goto dflt;
 141         }
 142
 143         if (dfq_load_param(snum, rpath_fname->base_name,
 144                                 section, "err", 0) != 0) {
 145                 errno = ENOTSUP;
 146                 rc = -1;
 147                 goto out;
 148         }
 149
 150         if (dfq_load_param(snum, rpath_fname->base_name,
 151                                 section, "nosys", 0) != 0) {
 152                 errno = ENOSYS;
 153                 rc = -1;
 154                 goto out;
 155         }
 156
 157         ZERO_STRUCTP(qt);
 158
 159         qt->bsize = bsize;
 160         qt->hardlimit = dfq_load_param(snum, rpath_fname->base_name,
 161                                 section, "hard limit", 0);
 162         qt->softlimit = dfq_load_param(snum, rpath_fname->base_name,
 163                                 section, "soft limit", 0);
 164         qt->curblocks = dfq_load_param(snum, rpath_fname->base_name,
 165                                 section, "cur blocks", 0);
 166         qt->ihardlimit =
 167             dfq_load_param(snum, rpath_fname->base_name,
 168                                 section, "inode hard limit", 0);
 169         qt->isoftlimit =
 170             dfq_load_param(snum, rpath_fname->base_name,
 171                                 section, "inode soft limit", 0);
 172         qt->curinodes = dfq_load_param(snum, rpath_fname->base_name,
 173                                 section, "cur inodes", 0);
 174         qt->qflags = dfq_load_param(snum, rpath_fname->base_name,
 175                                 section, "qflags", QUOTAS_DENY_DISK);
 176
 177         goto out;
 178
 179 dflt:
 180         rc = SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, qt);
 181
 182 out:
 183         save_errno = errno;
 184         TALLOC_FREE(section);
 185         TALLOC_FREE(rpath_fname);
 186         errno = save_errno;
 187         return rc;
 188 }
 189
 190 struct vfs_fn_pointers vfs_fake_dfq_fns = {
 191     /* Disk operations */
 192
 193     .disk_free_fn = dfq_disk_free,
 194     .get_quota_fn = dfq_get_quota,
 195 };
 196
 197 static_decl_vfs;
 198 NTSTATUS vfs_fake_dfq_init(TALLOC_CTX *ctx)
 199 {
 200         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_dfq",
 201                                 &vfs_fake_dfq_fns);
 202 }