Add NT quotas support. Users allowed now to manage quotas on systems with sysquotas...

(This used to be commit e856a96c2c42c39843e5e1a3a6b0d538e7179900)

diff --git a/source3/Makefile.in b/source3/Makefile.in
index c4d1b306a89e22571278e394b460552aed148c8c..9abe6b3389158f35a8c9f533461469020f6f7f0c 100644 (file)
--- a/source3/Makefile.in
+++ b/source3/Makefile.in
@@ -299,6 +299,7 @@ VFS_EXTD_AUDIT_OBJ = modules/vfs_extd_audit.o
 VFS_FAKE_PERMS_OBJ = modules/vfs_fake_perms.o
 VFS_RECYCLE_OBJ = modules/vfs_recycle.o
 VFS_NETATALK_OBJ = modules/vfs_netatalk.o
+VFS_DEFAULT_QUOTA_OBJ = modules/vfs_default_quota.o
 
 PLAINTEXT_AUTH_OBJ = auth/pampass.o auth/pass_check.o
 
@@ -1058,6 +1059,11 @@ bin/fake_perms.@SHLIBEXT@: $(VFS_FAKE_PERMS_OBJ:.o=.po)
        @$(SHLD) $(LDSHFLAGS) -o $@ $(VFS_FAKE_PERMS_OBJ:.o=.po) \
                @SONAMEFLAG@`basename $@`
 
+bin/default_quota.@SHLIBEXT@: $(VFS_DEFAULT_QUOTA_OBJ:.o=.po)
+       @echo "Building plugin $@"
+       @$(SHLD) $(LDSHFLAGS) -o $@ $(VFS_DEFAULT_QUOTA_OBJ:.o=.po) \
+               @SONAMEFLAG@`basename $@`
+
 bin/wbinfo@EXEEXT@: $(WBINFO_OBJ) @BUILD_POPT@ bin/.dummy
        @echo Linking $@
        @$(LINK) -o $@ $(WBINFO_OBJ) $(LIBS) @POPTLIBS@

diff --git a/source3/configure.in b/source3/configure.in
index 3c33a57f40b09a3ea4334cb7fa451df62d861ae7..13fb60e828b0a8494dbbdf41ba72b259748c27d3 100644 (file)
--- a/source3/configure.in
+++ b/source3/configure.in
@@ -287,7 +287,7 @@ dnl These have to be built static:
 default_static_modules="pdb_smbpasswd pdb_tdbsam rpc_lsa rpc_samr rpc_reg rpc_wks rpc_net rpc_dfs rpc_srv rpc_spoolss auth_rhosts auth_sam auth_unix auth_winbind auth_server auth_domain auth_builtin"
 
 dnl These are preferably build shared, and static if dlopen() is not available
-default_shared_modules="vfs_recycle vfs_audit vfs_extd_audit vfs_netatalk vfs_fake_perms"
+default_shared_modules="vfs_recycle vfs_audit vfs_extd_audit vfs_netatalk vfs_fake_perms vfs_default_quota"
 
 if test "x$developer" = xyes; then
    default_static_modules="$default_static_modules rpc_echo"
@@ -3954,6 +3954,7 @@ SMB_MODULE(vfs_audit, \$(VFS_AUDIT_OBJ), "bin/audit.$SHLIBEXT", VFS)
 SMB_MODULE(vfs_extd_audit, \$(VFS_EXTD_AUDIT_OBJ), "bin/extd_audit.$SHLIBEXT", VFS)
 SMB_MODULE(vfs_netatalk, \$(VFS_NETATALK_OBJ), "bin/netatalk.$SHLIBEXT", VFS)
 SMB_MODULE(vfs_fake_perms, \$(VFS_FAKE_PERMS_OBJ), "bin/fake_perms.$SHLIBEXT", VFS)
+SMB_MODULE(vfs_default_quota, \$(VFS_DEFAULT_QUOTA_OBJ), "bin/default_quota.$SHLIBEXT", VFS)
 SMB_SUBSYSTEM(VFS)
 
 AC_DEFINE_UNQUOTED(STRING_STATIC_MODULES, "$string_static_modules", [String list of builtin modules])

diff --git a/source3/include/sysquotas.h b/source3/include/sysquotas.h
index cfdac0609aafe2525a50708d31bc8f43b104c9e3..b803e6277abbf0fba70f9430aedadeacc4308712 100644 (file)
--- a/source3/include/sysquotas.h
+++ b/source3/include/sysquotas.h
@@ -189,6 +189,22 @@
 #define SMB_QUOTAS_NO_LIMIT    ((SMB_BIG_UINT)(0))
 #define SMB_QUOTAS_NO_SPACE    ((SMB_BIG_UINT)(1))
 
+#define SMB_QUOTAS_SET_NO_LIMIT(dp) \
+{\
+       (dp)->softlimit = SMB_QUOTAS_NO_LIMIT;\
+       (dp)->hardlimit = SMB_QUOTAS_NO_LIMIT;\
+       (dp)->isoftlimit = SMB_QUOTAS_NO_LIMIT;\
+       (dp)->ihardlimit = SMB_QUOTAS_NO_LIMIT;\
+}
+
+#define SMB_QUOTAS_SET_NO_SPACE(dp) \
+{\
+       (dp)->softlimit = SMB_QUOTAS_NO_SPACE;\
+       (dp)->hardlimit = SMB_QUOTAS_NO_SPACE;\
+       (dp)->isoftlimit = SMB_QUOTAS_NO_SPACE;\
+       (dp)->ihardlimit = SMB_QUOTAS_NO_SPACE;\
+}
+
 typedef struct _SMB_DISK_QUOTA {
        enum SMB_QUOTA_TYPE qtype;
        SMB_BIG_UINT bsize;

diff --git a/source3/lib/sysquotas.c b/source3/lib/sysquotas.c
index efc9e65b9de71a28de28cce386f3d87cda6e4549..c5575ef5aadfb5bc01fe93ba0ae621caa2047ecd 100644 (file)
--- a/source3/lib/sysquotas.c
+++ b/source3/lib/sysquotas.c
@@ -48,12 +48,6 @@ static int sys_get_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
 
        switch (qtype) {
                case SMB_USER_QUOTA_TYPE:
-                       /* we use id.uid == 0 for default quotas */
-                       if (id.uid == 0) {
-                               ret = 0;
-                               break;
-                       }
-       
                        if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (CADDR_T)&D))) {
                                return ret;
                        }
@@ -88,13 +82,19 @@ static int sys_get_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                                qflags |= QUOTAS_DENY_DISK;
                        }
 
-                       /* get the default quotas stored in the root's (uid =0) record */
-                       if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, 0, (CADDR_T)&D))) {
-                               return ret;
+                       ret = 0;
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:
+                       id.gid = getgid();
+
+                       if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (CADDR_T)&D))==0) {
+                               qflags |= QUOTAS_DENY_DISK;
                        }
 
                        ret = 0;
                        break;
+#endif /* HAVE_GROUP_QUOTA */
                default:
                        errno = ENOSYS;
                        return -1;
@@ -146,10 +146,7 @@ static int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
 
        switch (qtype) {
                case SMB_USER_QUOTA_TYPE:
-                       /* we use id.uid == 0 for default quotas */
-                       if (id.uid>0) {
-                               ret = quotactl(QCMD(Q_SETQLIM,USRQUOTA), bdev, id.uid, (CADDR_T)&D);
-                       }
+                       ret = quotactl(QCMD(Q_SETQLIM,USRQUOTA), bdev, id.uid, (CADDR_T)&D);
                        break;
 #ifdef HAVE_GROUP_QUOTA
                case SMB_GROUP_QUOTA_TYPE:
@@ -160,7 +157,7 @@ static int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                        /* this stuff didn't work as it should:
                         * switching on/off quota via quotactl()
                         * didn't work!
-                        * So we only set the default limits
+                        * So we just return 0
                         * --metze
                         * 
                         * On HPUX we didn't have the mount path,
@@ -168,9 +165,9 @@ static int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                         *
                         */
 #if 0
-                       uid = getuid();
+                       id.uid = getuid();
 
-                       ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, uid, (CADDR_T)&D);
+                       ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (CADDR_T)&D);
 
                        if ((qflags&QUOTAS_DENY_DISK)||(qflags&QUOTAS_ENABLED)) {
                                if (ret == 0) {
@@ -197,14 +194,59 @@ static int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                        }
 
                        DEBUG(0,("vfs_fs_quota: ret(%d) errno(%d)[%s] uid(%d) bdev[%s]\n",
-                               ret,errno,strerror(errno),uid,bdev));
+                               ret,errno,strerror(errno),id.uid,bdev));
+#else
+                       ret = 0;
 #endif
-                               
-                       /* we use uid == 0 for default quotas */
-                       ret = quotactl(QCMD(Q_SETQLIM,USRQUOTA), bdev, 0, (CADDR_T)&D);
-                       
                        break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:
+                       /* this stuff didn't work as it should:
+                        * switching on/off quota via quotactl()
+                        * didn't work!
+                        * So we just return 0
+                        * --metze
+                        * 
+                        * On HPUX we didn't have the mount path,
+                        * we need to fix sys_path_to_bdev()
+                        *
+                        */
+#if 0
+                       id.gid = getgid();
 
+                       ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id, (CADDR_T)&D);
+
+                       if ((qflags&QUOTAS_DENY_DISK)||(qflags&QUOTAS_ENABLED)) {
+                               if (ret == 0) {
+                                       char *quota_file = NULL;
+                                       
+                                       asprintf(&quota_file,"/%s/%s%s",path, QUOTAFILENAME,GROUPQUOTAFILE_EXTENSION);
+                                       if (quota_file == NULL) {
+                                               DEBUG(0,("asprintf() failed!\n"));
+                                               errno = ENOMEM;
+                                               return -1;
+                                       }
+                                       
+                                       ret = quotactl(QCMD(Q_QUOTAON,GRPQUOTA), bdev, -1,(CADDR_T)quota_file);
+                               } else {
+                                       ret = 0;        
+                               }
+                       } else {
+                               if (ret != 0) {
+                                       /* turn off */
+                                       ret = quotactl(QCMD(Q_QUOTAOFF,GRPQUOTA), bdev, -1, (CADDR_T)0);        
+                               } else {
+                                       ret = 0;
+                               }               
+                       }
+
+                       DEBUG(0,("vfs_fs_quota: ret(%d) errno(%d)[%s] uid(%d) bdev[%s]\n",
+                               ret,errno,strerror(errno),id.gid,bdev));
+#else
+                       ret = 0;
+#endif
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
                default:
                        errno = ENOSYS;
                        return -1;
@@ -383,7 +425,7 @@ static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char
 ****************************************************************************/
 static int sys_get_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
 {
-       int ret;
+       int ret = -1;
        uint32 qflags = 0;
        SMB_BIG_UINT bsize = (SMB_BIG_UINT)BBSIZE;
        struct fs_disk_quota D;
@@ -399,11 +441,6 @@ static int sys_get_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                
        switch (qtype) {
                case SMB_USER_QUOTA_TYPE:
-                       /* we use id.uid == 0 for default quotas */
-                       if (id.uid == 0) {
-                               ret = 0;
-                               break;
-                       }
                        if ((ret=quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), bdev, id.uid, (CADDR_T)&D)))
                                return ret;
                        break;
@@ -413,10 +450,8 @@ static int sys_get_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                                return ret;
                        break;
 #endif /* HAVE_GROUP_QUOTA */
-               case SMB_USER_FS_QUOTA_TYPE:
-                       /* TODO: get quota status from quotactl() ... */        
-                       if ((ret = quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (CADDR_T)&F)))
-                               return ret;
+               case SMB_USER_FS_QUOTA_TYPE:    
+                       quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (CADDR_T)&F);
 
                        if (F.qs_flags & XFS_QUOTA_UDQ_ENFD) {
                                qflags |= QUOTAS_DENY_DISK;
@@ -425,11 +460,24 @@ static int sys_get_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                                qflags |= QUOTAS_ENABLED;
                        }
 
-                       /* we use uid == 0 for default quotas */
-                       if ((ret=quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), bdev, 0, (CADDR_T)&D)))
-                               return ret;
+                       ret = 0;
 
                        break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:   
+                       quotactl(QCMD(Q_XGETQSTAT,GRPQUOTA), bdev, -1, (CADDR_T)&F);
+
+                       if (F.qs_flags & XFS_QUOTA_UDQ_ENFD) {
+                               qflags |= QUOTAS_DENY_DISK;
+                       }
+                       else if (F.qs_flags & XFS_QUOTA_UDQ_ACCT) {
+                               qflags |= QUOTAS_ENABLED;
+                       }
+
+                       ret = 0;
+
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
                default:
                        errno = ENOSYS;
                        return -1;
@@ -481,11 +529,8 @@ static int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
 
        switch (qtype) {
                case SMB_USER_QUOTA_TYPE:
-                       /* we use uid == 0 for default quotas */
-                       if (id.uid>0) {
-                               D.d_fieldmask |= FS_DQ_LIMIT_MASK;
-                               ret = quotactl(QCMD(Q_XSETQLIM,USRQUOTA), bdev, id.uid, (CADDR_T)&D);
-                       }
+                       D.d_fieldmask |= FS_DQ_LIMIT_MASK;
+                       ret = quotactl(QCMD(Q_XSETQLIM,USRQUOTA), bdev, id.uid, (CADDR_T)&D);
                        break;
 #ifdef HAVE_GROUP_QUOTA
                case SMB_GROUP_QUOTA_TYPE:
@@ -494,7 +539,6 @@ static int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                        break;
 #endif /* HAVE_GROUP_QUOTA */
                case SMB_USER_FS_QUOTA_TYPE:
-                       /* TODO */
                        quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (CADDR_T)&F);
                        
                        if (qflags & QUOTAS_DENY_DISK) {
@@ -505,6 +549,8 @@ static int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
                                
                                if (q_on != 0) {
                                        ret = quotactl(QCMD(Q_XQUOTAON,USRQUOTA),bdev, -1, (CADDR_T)&q_on);
+                               } else {
+                                       ret = 0;
                                }
 
                        } else if (qflags & QUOTAS_ENABLED) {
@@ -513,6 +559,8 @@ static int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
 
                                if (q_off != 0) {
                                        ret = quotactl(QCMD(Q_XQUOTAOFF,USRQUOTA),bdev, -1, (CADDR_T)&q_off);
+                               } else {
+                                       ret = 0;
                                }
 
                                if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
@@ -520,6 +568,8 @@ static int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
 
                                if (q_on != 0) {
                                        ret = quotactl(QCMD(Q_XQUOTAON,USRQUOTA),bdev, -1, (CADDR_T)&q_on);
+                               } else {
+                                       ret = 0;
                                }
                        } else {
 #if 0
@@ -533,14 +583,71 @@ static int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_
 
                                if (q_off !=0) {
                                        ret = quotactl(QCMD(Q_XQUOTAOFF,USRQUOTA),bdev, -1, (CADDR_T)&q_off);
+                               } else {
+                                       ret = 0;
                                }
+#else
+                               ret = -1;
 #endif
                        }
+
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:
+                       quotactl(QCMD(Q_XGETQSTAT,GRPQUOTA), bdev, -1, (CADDR_T)&F);
                        
-                       /* we use uid == 0 for default quotas */
-                       D.d_fieldmask |= FS_DQ_LIMIT_MASK;
-                       ret = quotactl(QCMD(Q_XSETQLIM,USRQUOTA), bdev, 0, (CADDR_T)&D);
+                       if (qflags & QUOTAS_DENY_DISK) {
+                               if (!(F.qs_flags & XFS_QUOTA_UDQ_ENFD))
+                                       q_on |= XFS_QUOTA_UDQ_ENFD;
+                               if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
+                                       q_on |= XFS_QUOTA_UDQ_ACCT;
+                               
+                               if (q_on != 0) {
+                                       ret = quotactl(QCMD(Q_XQUOTAON,GRPQUOTA),bdev, -1, (CADDR_T)&q_on);
+                               } else {
+                                       ret = 0;
+                               }
+
+                       } else if (qflags & QUOTAS_ENABLED) {
+                               if (F.qs_flags & XFS_QUOTA_UDQ_ENFD)
+                                       q_off |= XFS_QUOTA_UDQ_ENFD;
+
+                               if (q_off != 0) {
+                                       ret = quotactl(QCMD(Q_XQUOTAOFF,GRPQUOTA),bdev, -1, (CADDR_T)&q_off);
+                               } else {
+                                       ret = 0;
+                               }
+
+                               if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
+                                       q_on |= XFS_QUOTA_UDQ_ACCT;
+
+                               if (q_on != 0) {
+                                       ret = quotactl(QCMD(Q_XQUOTAON,GRPQUOTA),bdev, -1, (CADDR_T)&q_on);
+                               } else {
+                                       ret = 0;
+                               }
+                       } else {
+#if 0
+                       /* Switch on XFS_QUOTA_UDQ_ACCT didn't work!
+                        * only swittching off XFS_QUOTA_UDQ_ACCT work
+                        */
+                               if (F.qs_flags & XFS_QUOTA_UDQ_ENFD)
+                                       q_off |= XFS_QUOTA_UDQ_ENFD;
+                               if (F.qs_flags & XFS_QUOTA_UDQ_ACCT)
+                                       q_off |= XFS_QUOTA_UDQ_ACCT;
+
+                               if (q_off !=0) {
+                                       ret = quotactl(QCMD(Q_XQUOTAOFF,GRPQUOTA),bdev, -1, (CADDR_T)&q_off);
+                               } else {
+                                       ret = 0;
+                               }
+#else
+                               ret = -1;
+#endif
+                       }
+
                        break;
+#endif /* HAVE_GROUP_QUOTA */
                default:
                        errno = ENOSYS;
                        return -1;
@@ -783,12 +890,17 @@ int sys_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DI
        }
 
        if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
+               DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
                return ret;
        }
 
        for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].get_quota);i++) {
                if (strcmp(fs,sys_quota_backends[i].name)==0) {
                        ret = sys_quota_backends[i].get_quota(mntpath, bdev, qtype, id, dp);
+                       if (ret!=0) {
+                               DEBUG(10,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d] ret[%d].\n",
+                                       fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),ret));
+                       }
                        ready = True;
                        break;  
                }               
@@ -796,7 +908,11 @@ int sys_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DI
 
        if (!ready) {
                /* use the default vfs quota functions */
-               ret = sys_get_vfs_quota(mntpath, bdev, qtype, id, dp);
+               ret=sys_get_vfs_quota(mntpath, bdev, qtype, id, dp);
+               if (ret!=0) {
+                       DEBUG(10,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d] ret[%d].\n",
+                               "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),ret));
+               }
        }
 
        SAFE_FREE(mntpath);
@@ -831,12 +947,17 @@ int sys_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DI
        }
 
        if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
+               DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
                return ret;
        }
 
        for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].set_quota);i++) {
                if (strcmp(fs,sys_quota_backends[i].name)==0) {
                        ret = sys_quota_backends[i].set_quota(mntpath, bdev, qtype, id, dp);
+                       if (ret!=0) {
+                               DEBUG(10,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d] ret[%d].\n",
+                                       fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),ret));
+                       }
                        ready = True;
                        break;
                }               
@@ -845,6 +966,10 @@ int sys_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DI
        if (!ready) {
                /* use the default vfs quota functions */
                ret=sys_set_vfs_quota(mntpath, bdev, qtype, id, dp);
+               if (ret!=0) {
+                       DEBUG(10,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d] ret[%d].\n",
+                               "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),ret));
+               }
        }
 
        SAFE_FREE(mntpath);

diff --git a/source3/modules/vfs_default_quota.c b/source3/modules/vfs_default_quota.c
new file mode 100644 (file)
index 0000000..1294a51
--- /dev/null
+++ b/source3/modules/vfs_default_quota.c
@@ -0,0 +1,180 @@
+/* 
+ * Store default Quotas in a specified quota record
+ *
+ * Copyright (C) Stefan (metze) Metzmacher 2003
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_VFS
+
+#define DEFAULT_QUOTA_NAME "default_quota"
+
+#define DEFAULT_QUOTA_UID_DEFAULT              0
+#define DEFAULT_QUOTA_UID_NOLIMIT_DEFAULT      True
+#define DEFAULT_QUOTA_GID_DEFAULT              0
+#define DEFAULT_QUOTA_GID_NOLIMIT_DEFAULT      True
+
+#define DEFAULT_QUOTA_UID(handle) \
+       (uid_t)lp_parm_int(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"uid",DEFAULT_QUOTA_UID_DEFAULT)
+
+#define DEFAULT_QUOTA_UID_NOLIMIT(handle) \
+       lp_parm_bool(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"uid nolimit",DEFAULT_QUOTA_UID_NOLIMIT_DEFAULT)
+
+#define DEFAULT_QUOTA_GID(handle) \
+       (gid_t)lp_parm_int(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"gid",DEFAULT_QUOTA_GID_DEFAULT)
+
+#define DEFAULT_QUOTA_GID_NOLIMIT(handle) \
+       lp_parm_bool(SNUM((handle)->conn),DEFAULT_QUOTA_NAME,"gid nolimit",DEFAULT_QUOTA_GID_NOLIMIT_DEFAULT)
+
+static int default_quota_get_quota(vfs_handle_struct *handle, connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq)
+{
+       int ret = -1;
+
+       if ((ret=SMB_VFS_NEXT_GET_QUOTA(handle, conn, qtype, id, dq))!=0) {
+               return ret;
+       }
+
+       switch (qtype) {
+               case SMB_USER_QUOTA_TYPE:
+                       /* we use id.uid == 0 for default quotas */
+                       if ((id.uid==DEFAULT_QUOTA_UID(handle)) &&
+                               DEFAULT_QUOTA_UID_NOLIMIT(handle)) {
+                               SMB_QUOTAS_SET_NO_LIMIT(dq);
+                       }
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_QUOTA_TYPE:
+                       /* we use id.gid == 0 for default quotas */
+                       if ((id.gid==DEFAULT_QUOTA_GID(handle)) &&
+                               DEFAULT_QUOTA_GID_NOLIMIT(handle)) {
+                               SMB_QUOTAS_SET_NO_LIMIT(dq);
+                       }
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
+               case SMB_USER_FS_QUOTA_TYPE:
+                       {
+                               unid_t qid;
+                               uint32 qflags = dq->qflags;
+                               qid.uid = DEFAULT_QUOTA_UID(handle);
+                               SMB_VFS_NEXT_GET_QUOTA(handle, conn, SMB_USER_QUOTA_TYPE, qid, dq);
+                               dq->qflags = qflags;
+                       }
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:
+                       {
+                               unid_t qid;
+                               uint32 qflags = dq->qflags;
+                               qid.gid = DEFAULT_QUOTA_GID(handle);
+                               SMB_VFS_NEXT_GET_QUOTA(handle, conn, SMB_GROUP_QUOTA_TYPE, qid, dq);
+                               dq->qflags = qflags;
+                       }
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
+               default:
+                       errno = ENOSYS;
+                       return -1;
+                       break;
+       }
+
+       return ret;
+}
+
+static int default_quota_set_quota(vfs_handle_struct *handle, connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq)
+{
+       int ret = -1;
+
+       switch (qtype) {
+               case SMB_USER_QUOTA_TYPE:
+                       /* we use id.uid == 0 for default quotas */
+                       if ((id.uid==DEFAULT_QUOTA_UID(handle)) &&
+                               DEFAULT_QUOTA_UID_NOLIMIT(handle)) {
+                               return -1;
+                       }
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_QUOTA_TYPE:
+                       /* we use id.gid == 0 for default quotas */
+                       if ((id.gid==DEFAULT_QUOTA_GID(handle)) &&
+                               DEFAULT_QUOTA_GID_NOLIMIT(handle)) {
+                               return -1;
+                       }
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
+               case SMB_USER_FS_QUOTA_TYPE:
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
+               default:
+                       errno = ENOSYS;
+                       return -1;
+                       break;
+       }
+
+       if ((ret=SMB_VFS_NEXT_SET_QUOTA(handle, conn, qtype, id, dq))!=0) {
+               return ret;
+       }
+
+       switch (qtype) {
+               case SMB_USER_QUOTA_TYPE:
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_QUOTA_TYPE:
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
+               case SMB_USER_FS_QUOTA_TYPE:
+                       {
+                               unid_t qid;
+                               qid.uid = DEFAULT_QUOTA_UID(handle);
+                               ret = SMB_VFS_NEXT_SET_QUOTA(handle, conn, SMB_USER_QUOTA_TYPE, qid, dq);
+                       }
+                       break;
+#ifdef HAVE_GROUP_QUOTA
+               case SMB_GROUP_FS_QUOTA_TYPE:
+                       {
+                               unid_t qid;
+                               qid.gid = DEFAULT_QUOTA_GID(handle);
+                               ret = SMB_VFS_NEXT_SET_QUOTA(handle, conn, SMB_GROUP_QUOTA_TYPE, qid, dq);
+                       }
+                       break;
+#endif /* HAVE_GROUP_QUOTA */
+               default:
+                       errno = ENOSYS;
+                       return -1;
+                       break;
+       }
+
+       return ret;
+}
+
+/* VFS operations structure */
+
+static vfs_op_tuple default_quota_ops[] = {    
+       {SMB_VFS_OP(default_quota_get_quota),   SMB_VFS_OP_GET_QUOTA,   SMB_VFS_LAYER_TRANSPARENT},
+       {SMB_VFS_OP(default_quota_set_quota),   SMB_VFS_OP_SET_QUOTA,   SMB_VFS_LAYER_TRANSPARENT},
+
+       {SMB_VFS_OP(NULL),                      SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
+};
+
+NTSTATUS vfs_default_quota_init(void)
+{
+       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, DEFAULT_QUOTA_NAME, default_quota_ops);
+}