source: vendor/current/source3/lib/sysquotas_linux.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 16.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 System QUOTA function wrappers for LINUX
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#include "includes.h"
22
23#undef DBGC_CLASS
24#define DBGC_CLASS DBGC_QUOTA
25
26#ifndef HAVE_SYS_QUOTAS
27#ifdef HAVE_QUOTACTL_LINUX
28#undef HAVE_QUOTACTL_LINUX
29#endif
30#endif
31
32#ifdef HAVE_QUOTACTL_LINUX
33
34#include "samba_linux_quota.h"
35
36/****************************************************************************
37 Abstract out the v1 Linux quota get calls.
38****************************************************************************/
39static int sys_get_linux_v1_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
40{
41 int ret = -1;
42 uint32_t qflags = 0;
43 struct v1_kern_dqblk D;
44 uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
45
46 ZERO_STRUCT(D);
47
48 switch (qtype) {
49 case SMB_USER_QUOTA_TYPE:
50 DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
51 path, bdev, (unsigned)id.uid));
52
53 if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
54 return ret;
55 }
56
57 break;
58 case SMB_GROUP_QUOTA_TYPE:
59 DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
60 path, bdev, (unsigned)id.gid));
61
62 if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
63 return ret;
64 }
65
66 break;
67 case SMB_USER_FS_QUOTA_TYPE:
68 DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
69 path, bdev, (unsigned)id.uid));
70
71 if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
72 qflags |= QUOTAS_DENY_DISK;
73 }
74
75 break;
76 case SMB_GROUP_FS_QUOTA_TYPE:
77 DEBUG(10,("sys_get_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
78 path, bdev, (unsigned)id.gid));
79
80 if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
81 qflags |= QUOTAS_DENY_DISK;
82 }
83
84 break;
85 default:
86 errno = ENOSYS;
87 return -1;
88 }
89
90 dp->bsize = bsize;
91 dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
92 dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
93 dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
94 dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
95 dp->curinodes = (uint64_t)D.dqb_curinodes;
96 dp->curblocks = (uint64_t)D.dqb_curblocks;
97
98
99 dp->qflags = qflags;
100
101 return ret;
102}
103
104/****************************************************************************
105 Abstract out the v1 Linux quota set calls.
106****************************************************************************/
107static int sys_set_linux_v1_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
108{
109 int ret = -1;
110 struct v1_kern_dqblk D;
111 uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
112
113 ZERO_STRUCT(D);
114
115 if (bsize == dp->bsize) {
116 D.dqb_bsoftlimit = dp->softlimit;
117 D.dqb_bhardlimit = dp->hardlimit;
118 D.dqb_ihardlimit = dp->ihardlimit;
119 D.dqb_isoftlimit = dp->isoftlimit;
120 } else {
121 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
122 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
123 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
124 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
125 }
126
127 switch (qtype) {
128 case SMB_USER_QUOTA_TYPE:
129 DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
130 path, bdev, (unsigned)id.uid));
131
132 ret = quotactl(QCMD(Q_V1_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
133 break;
134 case SMB_GROUP_QUOTA_TYPE:
135 DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
136 path, bdev, (unsigned)id.gid));
137
138 ret = quotactl(QCMD(Q_V1_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
139 break;
140 case SMB_USER_FS_QUOTA_TYPE:
141 DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
142 path, bdev, (unsigned)id.uid));
143
144 if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
145 dp->qflags |= QUOTAS_DENY_DISK;
146 }
147
148 break;
149 case SMB_GROUP_FS_QUOTA_TYPE:
150 DEBUG(10,("sys_set_linux_v1_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
151 path, bdev, (unsigned)id.gid));
152
153 if ((ret = quotactl(QCMD(Q_V1_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
154 dp->qflags |= QUOTAS_DENY_DISK;
155 }
156
157 break;
158 default:
159 errno = ENOSYS;
160 return -1;
161 }
162
163 return ret;
164}
165
166/****************************************************************************
167 Abstract out the v2 Linux quota get calls.
168****************************************************************************/
169static int sys_get_linux_v2_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
170{
171 int ret = -1;
172 uint32_t qflags = 0;
173 struct v2_kern_dqblk D;
174 uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
175
176 ZERO_STRUCT(D);
177
178 switch (qtype) {
179 case SMB_USER_QUOTA_TYPE:
180 DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
181 path, bdev, (unsigned)id.uid));
182
183 if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
184 return ret;
185 }
186
187 break;
188 case SMB_GROUP_QUOTA_TYPE:
189 DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
190 path, bdev, (unsigned)id.gid));
191
192 if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
193 return ret;
194 }
195
196 break;
197 case SMB_USER_FS_QUOTA_TYPE:
198 DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
199 path, bdev, (unsigned)id.uid));
200
201 if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
202 qflags |= QUOTAS_DENY_DISK;
203 }
204
205 break;
206 case SMB_GROUP_FS_QUOTA_TYPE:
207 DEBUG(10,("sys_get_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
208 path, bdev, (unsigned)id.gid));
209
210 if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
211 qflags |= QUOTAS_DENY_DISK;
212 }
213
214 break;
215 default:
216 errno = ENOSYS;
217 return -1;
218 }
219
220 dp->bsize = bsize;
221 dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
222 dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
223 dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
224 dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
225 dp->curinodes = (uint64_t)D.dqb_curinodes;
226 dp->curblocks = (uint64_t)D.dqb_curspace/bsize;
227
228
229 dp->qflags = qflags;
230
231 return ret;
232}
233
234/****************************************************************************
235 Abstract out the v2 Linux quota set calls.
236****************************************************************************/
237static int sys_set_linux_v2_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
238{
239 int ret = -1;
240 struct v2_kern_dqblk D;
241 uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
242
243 ZERO_STRUCT(D);
244
245 if (bsize == dp->bsize) {
246 D.dqb_bsoftlimit = dp->softlimit;
247 D.dqb_bhardlimit = dp->hardlimit;
248 D.dqb_ihardlimit = dp->ihardlimit;
249 D.dqb_isoftlimit = dp->isoftlimit;
250 } else {
251 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
252 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
253 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
254 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
255 }
256
257 switch (qtype) {
258 case SMB_USER_QUOTA_TYPE:
259 DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
260 path, bdev, (unsigned)id.uid));
261
262 ret = quotactl(QCMD(Q_V2_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
263 break;
264 case SMB_GROUP_QUOTA_TYPE:
265 DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
266 path, bdev, (unsigned)id.gid));
267
268 ret = quotactl(QCMD(Q_V2_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
269 break;
270 case SMB_USER_FS_QUOTA_TYPE:
271 DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
272 path, bdev, (unsigned)id.uid));
273
274 if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
275 dp->qflags |= QUOTAS_DENY_DISK;
276 }
277
278 break;
279 case SMB_GROUP_FS_QUOTA_TYPE:
280 DEBUG(10,("sys_set_linux_v2_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
281 path, bdev, (unsigned)id.gid));
282
283 if ((ret = quotactl(QCMD(Q_V2_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
284 dp->qflags |= QUOTAS_DENY_DISK;
285 }
286
287 break;
288 default:
289 errno = ENOSYS;
290 return -1;
291 }
292
293 return ret;
294}
295
296/****************************************************************************
297 Abstract out the generic Linux quota get calls.
298****************************************************************************/
299static int sys_get_linux_gen_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
300{
301 int ret = -1;
302 uint32_t qflags = 0;
303 struct if_dqblk D;
304 uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
305
306 ZERO_STRUCT(D);
307
308 switch (qtype) {
309 case SMB_USER_QUOTA_TYPE:
310 DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
311 path, bdev, (unsigned)id.uid));
312
313 if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))&&errno != EDQUOT) {
314 return ret;
315 }
316
317 break;
318 case SMB_GROUP_QUOTA_TYPE:
319 DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
320 path, bdev, (unsigned)id.gid));
321
322 if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))&&errno != EDQUOT) {
323 return ret;
324 }
325
326 break;
327 case SMB_USER_FS_QUOTA_TYPE:
328 DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
329 path, bdev, (unsigned)id.uid));
330
331 if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
332 qflags |= QUOTAS_DENY_DISK;
333 }
334
335 break;
336 case SMB_GROUP_FS_QUOTA_TYPE:
337 DEBUG(10,("sys_get_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
338 path, bdev, (unsigned)id.gid));
339
340 if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
341 qflags |= QUOTAS_DENY_DISK;
342 }
343
344 break;
345 default:
346 errno = ENOSYS;
347 return -1;
348 }
349
350 dp->bsize = bsize;
351 dp->softlimit = (uint64_t)D.dqb_bsoftlimit;
352 dp->hardlimit = (uint64_t)D.dqb_bhardlimit;
353 dp->ihardlimit = (uint64_t)D.dqb_ihardlimit;
354 dp->isoftlimit = (uint64_t)D.dqb_isoftlimit;
355 dp->curinodes = (uint64_t)D.dqb_curinodes;
356 dp->curblocks = (uint64_t)D.dqb_curspace/bsize;
357
358
359 dp->qflags = qflags;
360
361 return ret;
362}
363
364/****************************************************************************
365 Abstract out the gen Linux quota set calls.
366****************************************************************************/
367static int sys_set_linux_gen_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
368{
369 int ret = -1;
370 struct if_dqblk D;
371 uint64_t bsize = (uint64_t)QUOTABLOCK_SIZE;
372
373 ZERO_STRUCT(D);
374
375 if (bsize == dp->bsize) {
376 D.dqb_bsoftlimit = dp->softlimit;
377 D.dqb_bhardlimit = dp->hardlimit;
378 D.dqb_ihardlimit = dp->ihardlimit;
379 D.dqb_isoftlimit = dp->isoftlimit;
380 } else {
381 D.dqb_bsoftlimit = (dp->softlimit*dp->bsize)/bsize;
382 D.dqb_bhardlimit = (dp->hardlimit*dp->bsize)/bsize;
383 D.dqb_ihardlimit = (dp->ihardlimit*dp->bsize)/bsize;
384 D.dqb_isoftlimit = (dp->isoftlimit*dp->bsize)/bsize;
385 }
386 D.dqb_valid = QIF_LIMITS;
387
388 switch (qtype) {
389 case SMB_USER_QUOTA_TYPE:
390 DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_USER_QUOTA_TYPE uid[%u]\n",
391 path, bdev, (unsigned)id.uid));
392
393 ret = quotactl(QCMD(Q_SETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D);
394 break;
395 case SMB_GROUP_QUOTA_TYPE:
396 DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_QUOTA_TYPE gid[%u]\n",
397 path, bdev, (unsigned)id.gid));
398
399 ret = quotactl(QCMD(Q_SETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D);
400 break;
401 case SMB_USER_FS_QUOTA_TYPE:
402 DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_USER_FS_QUOTA_TYPE (uid[%u])\n",
403 path, bdev, (unsigned)id.uid));
404
405 if ((ret = quotactl(QCMD(Q_GETQUOTA,USRQUOTA), bdev, id.uid, (caddr_t)&D))==0) {
406 dp->qflags |= QUOTAS_DENY_DISK;
407 }
408
409 break;
410 case SMB_GROUP_FS_QUOTA_TYPE:
411 DEBUG(10,("sys_set_linux_gen_quota: path[%s] bdev[%s] SMB_GROUP_FS_QUOTA_TYPE (gid[%u])\n",
412 path, bdev, (unsigned)id.gid));
413
414 if ((ret = quotactl(QCMD(Q_GETQUOTA,GRPQUOTA), bdev, id.gid, (caddr_t)&D))==0) {
415 dp->qflags |= QUOTAS_DENY_DISK;
416 }
417
418 break;
419 default:
420 errno = ENOSYS;
421 return -1;
422 }
423
424 return ret;
425}
426
427/****************************************************************************
428 Abstract out the Linux quota get calls.
429****************************************************************************/
430int sys_get_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
431{
432 int ret = -1;
433
434 if (!path||!bdev||!dp)
435 smb_panic("sys_set_vfs_quota: called with NULL pointer");
436
437 ZERO_STRUCT(*dp);
438 dp->qtype = qtype;
439
440 switch (qtype) {
441 case SMB_USER_QUOTA_TYPE:
442 case SMB_GROUP_QUOTA_TYPE:
443 if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
444 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
445 if ((ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
446 return ret;
447 }
448 }
449 }
450
451 if ((dp->curblocks==0)&&
452 (dp->softlimit==0)&&
453 (dp->hardlimit==0)) {
454 /* the upper layer functions don't want empty quota records...*/
455 return -1;
456 }
457
458 break;
459 case SMB_USER_FS_QUOTA_TYPE:
460 id.uid = getuid();
461
462 if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
463 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
464 ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp);
465 }
466 }
467
468 ret = 0;
469 break;
470 case SMB_GROUP_FS_QUOTA_TYPE:
471 id.gid = getgid();
472
473 if ((ret=sys_get_linux_gen_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
474 if ((ret=sys_get_linux_v2_quota(path, bdev, qtype, id, dp))&&errno != EDQUOT) {
475 ret=sys_get_linux_v1_quota(path, bdev, qtype, id, dp);
476 }
477 }
478
479 ret = 0;
480 break;
481 default:
482 errno = ENOSYS;
483 return -1;
484 }
485
486 return ret;
487}
488
489/****************************************************************************
490 Abstract out the Linux quota set calls.
491****************************************************************************/
492int sys_set_vfs_quota(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
493{
494 int ret = -1;
495 uint32_t oldqflags = 0;
496
497 if (!path||!bdev||!dp)
498 smb_panic("sys_set_vfs_quota: called with NULL pointer");
499
500 oldqflags = dp->qflags;
501
502 switch (qtype) {
503 case SMB_USER_QUOTA_TYPE:
504 case SMB_GROUP_QUOTA_TYPE:
505 if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
506 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
507 if ((ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp))) {
508 return ret;
509 }
510 }
511 }
512 break;
513 case SMB_USER_FS_QUOTA_TYPE:
514 id.uid = getuid();
515
516 if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
517 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
518 ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp);
519 }
520 }
521
522 if (oldqflags == dp->qflags) {
523 ret = 0;
524 } else {
525 ret = -1;
526 }
527 break;
528 case SMB_GROUP_FS_QUOTA_TYPE:
529 id.gid = getgid();
530
531 if ((ret=sys_set_linux_gen_quota(path, bdev, qtype, id, dp))) {
532 if ((ret=sys_set_linux_v2_quota(path, bdev, qtype, id, dp))) {
533 ret=sys_set_linux_v1_quota(path, bdev, qtype, id, dp);
534 }
535 }
536
537 if (oldqflags == dp->qflags) {
538 ret = 0;
539 } else {
540 ret = -1;
541 }
542
543 break;
544 default:
545 errno = ENOSYS;
546 return -1;
547 }
548
549 return ret;
550}
551
552#else /* HAVE_QUOTACTL_LINUX */
553 void dummy_sysquotas_linux(void);
554
555 void dummy_sysquotas_linux(void){}
556#endif /* HAVE_QUOTACTL_LINUX */
Note: See TracBrowser for help on using the repository browser.