r6586: get rid of a few more compiler warnings
[tprouty/samba.git] / source / lib / sysquotas_xfs.c
1 /* 
2    Unix SMB/CIFS implementation.
3    System QUOTA function wrappers for XFS
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 2 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, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21
22 #include "includes.h"
23
24 #undef DBGC_CLASS
25 #define DBGC_CLASS DBGC_QUOTA
26
27 #ifndef HAVE_SYS_QUOTAS
28 #ifdef HAVE_XFS_QUOTAS
29 #undef HAVE_XFS_QUOTAS
30 #endif
31 #endif
32
33 #ifdef HAVE_XFS_QUOTAS
34
35 #ifdef HAVE_LINUX_XFS_QUOTAS
36 #include "samba_linux_quota.h"
37 #include "samba_xfs_quota.h"
38 #define HAVE_GROUP_QUOTA
39 #else /* IRIX */
40 #include <sys/quota.h> 
41 #endif
42
43 /* on IRIX */
44 #ifndef Q_XQUOTAON
45 #define Q_XQUOTAON Q_QUOTAON
46 #endif /* Q_XQUOTAON */
47 #ifndef Q_XQUOTAOFF
48 #define Q_XQUOTAOFF Q_QUOTAOFF
49 #endif /* Q_XQUOTAOFF */
50 #ifndef Q_XGETQSTAT
51 #define Q_XGETQSTAT Q_GETQSTAT
52 #endif /* Q_XGETQSTAT */
53
54 /* currently doesn't support Group and Project quotas on IRIX 
55  */
56
57 #ifndef QCMD
58 #define QCMD(x,y) x
59 #endif
60
61 /*
62  * IRIX has BBSIZE in <sys/param.h>
63  */
64 #ifndef BBSHIFT
65 #define BBSHIFT         9
66 #endif /* BBSHIFT */
67 #ifndef BBSIZE
68 #define BBSIZE          (1<<BBSHIFT)
69 #endif /* BBSIZE */
70
71 /****************************************************************************
72  Abstract out the XFS Quota Manager quota get call.
73 ****************************************************************************/
74 int sys_get_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
75 {
76         int ret = -1;
77         uint32 qflags = 0;
78         SMB_BIG_UINT bsize = (SMB_BIG_UINT)BBSIZE;
79         struct fs_disk_quota D;
80         struct fs_quota_stat F;
81         ZERO_STRUCT(D);
82         ZERO_STRUCT(F);
83
84         if (!bdev||!dp)
85                 smb_panic("sys_get_xfs_quota: called with NULL pointer");
86                 
87         ZERO_STRUCT(*dp);
88         dp->qtype = qtype;
89                 
90         switch (qtype) {
91                 case SMB_USER_QUOTA_TYPE:
92                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
93                                 path, bdev, (unsigned)id.uid));
94
95                         if ((ret=quotactl(QCMD(Q_XGETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D)))
96                                 return ret;
97                         break;
98 #ifdef HAVE_GROUP_QUOTA
99                 case SMB_GROUP_QUOTA_TYPE:
100                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
101                                 path, bdev, (unsigned)id.gid));
102
103                         if ((ret=quotactl(QCMD(Q_XGETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D)))
104                                 return ret;
105                         break;
106 #endif /* HAVE_GROUP_QUOTA */
107                 case SMB_USER_FS_QUOTA_TYPE:
108                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
109                                 path, bdev, (unsigned)id.uid));
110
111                         quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (caddr_t)&F);
112
113                         if (F.qs_flags & XFS_QUOTA_UDQ_ENFD) {
114                                 qflags |= QUOTAS_DENY_DISK;
115                         }
116                         else if (F.qs_flags & XFS_QUOTA_UDQ_ACCT) {
117                                 qflags |= QUOTAS_ENABLED;
118                         }
119
120                         ret = 0;
121
122                         break;
123 #ifdef HAVE_GROUP_QUOTA
124                 case SMB_GROUP_FS_QUOTA_TYPE:
125                         DEBUG(10,("sys_get_xfs_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
126                                 path, bdev, (unsigned)id.gid));
127
128                         quotactl(QCMD(Q_XGETQSTAT,GRPQUOTA), bdev, -1, (caddr_t)&F);
129
130                         if (F.qs_flags & XFS_QUOTA_GDQ_ENFD) {
131                                 qflags |= QUOTAS_DENY_DISK;
132                         }
133                         else if (F.qs_flags & XFS_QUOTA_GDQ_ACCT) {
134                                 qflags |= QUOTAS_ENABLED;
135                         }
136
137                         ret = 0;
138
139                         break;
140 #endif /* HAVE_GROUP_QUOTA */
141                 default:
142                         errno = ENOSYS;
143                         return -1;
144         }
145
146         dp->bsize = bsize;
147         dp->softlimit = (SMB_BIG_UINT)D.d_blk_softlimit;
148         dp->hardlimit = (SMB_BIG_UINT)D.d_blk_hardlimit;
149         dp->ihardlimit = (SMB_BIG_UINT)D.d_ino_hardlimit;
150         dp->isoftlimit = (SMB_BIG_UINT)D.d_ino_softlimit;
151         dp->curinodes = (SMB_BIG_UINT)D.d_icount;
152         dp->curblocks = (SMB_BIG_UINT)D.d_bcount;
153         dp->qflags = qflags;
154
155         return ret;
156 }
157
158 /****************************************************************************
159  Abstract out the XFS Quota Manager quota set call.
160 ****************************************************************************/
161 int sys_set_xfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
162 {
163         int ret = -1;
164         uint32 qflags = 0;
165         SMB_BIG_UINT bsize = (SMB_BIG_UINT)BBSIZE;
166         struct fs_disk_quota D;
167         struct fs_quota_stat F;
168         int q_on = 0;
169         int q_off = 0;
170         ZERO_STRUCT(D);
171         ZERO_STRUCT(F);
172
173         if (!bdev||!dp)
174                 smb_panic("sys_set_xfs_quota: called with NULL pointer");
175         
176         if (bsize == dp->bsize) {
177                 D.d_blk_softlimit = dp->softlimit;
178                 D.d_blk_hardlimit = dp->hardlimit;
179                 D.d_ino_hardlimit = dp->ihardlimit;
180                 D.d_ino_softlimit = dp->isoftlimit;
181         } else {
182                 D.d_blk_softlimit = (dp->softlimit*dp->bsize)/bsize;
183                 D.d_blk_hardlimit = (dp->hardlimit*dp->bsize)/bsize;
184                 D.d_ino_hardlimit = (dp->ihardlimit*dp->bsize)/bsize;
185                 D.d_ino_softlimit = (dp->isoftlimit*dp->bsize)/bsize;           
186         }
187
188         qflags = dp->qflags;
189
190         switch (qtype) {
191                 case SMB_USER_QUOTA_TYPE:
192                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
193                                 path, bdev, (unsigned)id.uid));
194
195                         D.d_fieldmask |= FS_DQ_LIMIT_MASK;
196                         ret = quotactl(QCMD(Q_XSETQLIM,USRQUOTA), bdev, id.uid, (caddr_t)&D);
197                         break;
198 #ifdef HAVE_GROUP_QUOTA
199                 case SMB_GROUP_QUOTA_TYPE:
200                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
201                                 path, bdev, (unsigned)id.gid));
202
203                         D.d_fieldmask |= FS_DQ_LIMIT_MASK;
204                         ret = quotactl(QCMD(Q_XSETQLIM,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
205                         break;
206 #endif /* HAVE_GROUP_QUOTA */
207                 case SMB_USER_FS_QUOTA_TYPE:
208                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
209                                 path, bdev, (unsigned)id.uid));
210
211                         quotactl(QCMD(Q_XGETQSTAT,USRQUOTA), bdev, -1, (caddr_t)&F);
212                         
213                         if (qflags & QUOTAS_DENY_DISK) {
214                                 if (!(F.qs_flags & XFS_QUOTA_UDQ_ENFD))
215                                         q_on |= XFS_QUOTA_UDQ_ENFD;
216                                 if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
217                                         q_on |= XFS_QUOTA_UDQ_ACCT;
218                                 
219                                 if (q_on != 0) {
220                                         ret = quotactl(QCMD(Q_XQUOTAON,USRQUOTA),bdev, -1, (caddr_t)&q_on);
221                                 } else {
222                                         ret = 0;
223                                 }
224
225                         } else if (qflags & QUOTAS_ENABLED) {
226                                 if (F.qs_flags & XFS_QUOTA_UDQ_ENFD)
227                                         q_off |= XFS_QUOTA_UDQ_ENFD;
228
229                                 if (q_off != 0) {
230                                         ret = quotactl(QCMD(Q_XQUOTAOFF,USRQUOTA),bdev, -1, (caddr_t)&q_off);
231                                 } else {
232                                         ret = 0;
233                                 }
234
235                                 if (!(F.qs_flags & XFS_QUOTA_UDQ_ACCT))
236                                         q_on |= XFS_QUOTA_UDQ_ACCT;
237
238                                 if (q_on != 0) {
239                                         ret = quotactl(QCMD(Q_XQUOTAON,USRQUOTA),bdev, -1, (caddr_t)&q_on);
240                                 } else {
241                                         ret = 0;
242                                 }
243                         } else {
244 #if 0
245                         /* Switch on XFS_QUOTA_UDQ_ACCT didn't work!
246                          * only swittching off XFS_QUOTA_UDQ_ACCT work
247                          */
248                                 if (F.qs_flags & XFS_QUOTA_UDQ_ENFD)
249                                         q_off |= XFS_QUOTA_UDQ_ENFD;
250                                 if (F.qs_flags & XFS_QUOTA_UDQ_ACCT)
251                                         q_off |= XFS_QUOTA_UDQ_ACCT;
252
253                                 if (q_off !=0) {
254                                         ret = quotactl(QCMD(Q_XQUOTAOFF,USRQUOTA),bdev, -1, (caddr_t)&q_off);
255                                 } else {
256                                         ret = 0;
257                                 }
258 #else
259                                 ret = -1;
260 #endif
261                         }
262
263                         break;
264 #ifdef HAVE_GROUP_QUOTA
265                 case SMB_GROUP_FS_QUOTA_TYPE:
266                         DEBUG(10,("sys_set_xfs_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
267                                 path, bdev, (unsigned)id.gid));
268
269                         quotactl(QCMD(Q_XGETQSTAT,GRPQUOTA), bdev, -1, (caddr_t)&F);
270                         
271                         if (qflags & QUOTAS_DENY_DISK) {
272                                 if (!(F.qs_flags & XFS_QUOTA_GDQ_ENFD))
273                                         q_on |= XFS_QUOTA_GDQ_ENFD;
274                                 if (!(F.qs_flags & XFS_QUOTA_GDQ_ACCT))
275                                         q_on |= XFS_QUOTA_GDQ_ACCT;
276                                 
277                                 if (q_on != 0) {
278                                         ret = quotactl(QCMD(Q_XQUOTAON,GRPQUOTA),bdev, -1, (caddr_t)&q_on);
279                                 } else {
280                                         ret = 0;
281                                 }
282
283                         } else if (qflags & QUOTAS_ENABLED) {
284                                 if (F.qs_flags & XFS_QUOTA_GDQ_ENFD)
285                                         q_off |= XFS_QUOTA_GDQ_ENFD;
286
287                                 if (q_off != 0) {
288                                         ret = quotactl(QCMD(Q_XQUOTAOFF,GRPQUOTA),bdev, -1, (caddr_t)&q_off);
289                                 } else {
290                                         ret = 0;
291                                 }
292
293                                 if (!(F.qs_flags & XFS_QUOTA_GDQ_ACCT))
294                                         q_on |= XFS_QUOTA_GDQ_ACCT;
295
296                                 if (q_on != 0) {
297                                         ret = quotactl(QCMD(Q_XQUOTAON,GRPQUOTA),bdev, -1, (caddr_t)&q_on);
298                                 } else {
299                                         ret = 0;
300                                 }
301                         } else {
302 #if 0
303                         /* Switch on XFS_QUOTA_UDQ_ACCT didn't work!
304                          * only swittching off XFS_QUOTA_UDQ_ACCT work
305                          */
306                                 if (F.qs_flags & XFS_QUOTA_GDQ_ENFD)
307                                         q_off |= XFS_QUOTA_GDQ_ENFD;
308                                 if (F.qs_flags & XFS_QUOTA_GDQ_ACCT)
309                                         q_off |= XFS_QUOTA_GDQ_ACCT;
310
311                                 if (q_off !=0) {
312                                         ret = quotactl(QCMD(Q_XQUOTAOFF,GRPQUOTA),bdev, -1, (caddr_t)&q_off);
313                                 } else {
314                                         ret = 0;
315                                 }
316 #else
317                                 ret = -1;
318 #endif
319                         }
320
321                         break;
322 #endif /* HAVE_GROUP_QUOTA */
323                 default:
324                         errno = ENOSYS;
325                         return -1;
326         }
327
328         return ret;
329 }
330
331 #else /* HAVE_XFS_QUOTAS */
332  void dummy_sysquotas_xfs(void);
333
334  void dummy_sysquotas_xfs(void){}
335 #endif /* HAVE_XFS_QUOTAS */