?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dns: Check for talloc_memdup failure
[Samba.git] / source3 / lib / sysquotas.c
blobeef87beafe0a940d70d9af0cc1acb605f4f36ee8
1 /*
2 Unix SMB/CIFS implementation.
3 System QUOTA function wrappers
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 #include "lib/util_file.h"
23
24 #undef DBGC_CLASS
25 #define DBGC_CLASS DBGC_QUOTA
26
27 #ifdef HAVE_SYS_QUOTAS
28
29 #if defined(HAVE_QUOTACTL_4A)
30
31 /*#endif HAVE_QUOTACTL_4A */
32 #elif defined(HAVE_QUOTACTL_4B)
33
34 /*#endif HAVE_QUOTACTL_4B */
35 #elif defined(HAVE_QUOTACTL_3)
36
37 #error HAVE_QUOTACTL_3 not implemented
38
39 /* #endif HAVE_QUOTACTL_3 */
40 #else /* NO_QUOTACTL_USED */
41
42 #endif /* NO_QUOTACTL_USED */
43
44 #if defined(HAVE_MNTENT) && defined(HAVE_REALPATH)
45 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
46 {
47 int ret = -1;
48 SMB_STRUCT_STAT S;
49 FILE *fp;
50 struct mntent *mnt = NULL;
51 SMB_DEV_T devno;
52 char *stat_mntpath = NULL;
53 char *p;
54
55 /* find the block device file */
56 (*mntpath) = NULL;
57 (*bdev) = NULL;
58 (*fs) = NULL;
59
60 if (sys_stat(path, &S, false) != 0) {
61 return -1;
62 }
63
64 devno = S.st_ex_dev ;
65
66 stat_mntpath = sys_realpath(path);
67 if (stat_mntpath == NULL) {
68 DBG_WARNING("realpath(%s) failed - %s\n", path,
69 strerror(errno));
70 goto out;
71 }
72
73 if (sys_stat(stat_mntpath, &S, false) != 0) {
74 DBG_WARNING("cannot stat real path %s - %s\n", stat_mntpath,
75 strerror(errno));
76 goto out;
77 }
78
79 if (S.st_ex_dev != devno) {
80 DBG_WARNING("device on real path has changed\n");
81 goto out;
82 }
83
84 while (true) {
85 char save_ch;
86
87 p = strrchr(stat_mntpath, '/');
88 if (p == NULL) {
89 DBG_ERR("realpath for %s does not begin with a '/'\n",
90 path);
91 goto out;
92 }
93
94 if (p == stat_mntpath) {
95 ++p;
96 }
97
98 save_ch = *p;
99 *p = 0;
100 if (sys_stat(stat_mntpath, &S, false) != 0) {
101 DBG_WARNING("cannot stat real path component %s - %s\n",
102 stat_mntpath, strerror(errno));
103 goto out;
104 }
105 if (S.st_ex_dev != devno) {
106 *p = save_ch;
107 break;
108 }
109
110 if (p <= stat_mntpath + 1) {
111 break;
112 }
113 }
114
115 fp = setmntent(MOUNTED,"r");
116 if (fp == NULL) {
117 goto out;
118 }
119
120 while ((mnt = getmntent(fp))) {
121 if (!strequal(mnt->mnt_dir, stat_mntpath)) {
122 continue;
123 }
124
125 if ( sys_stat(mnt->mnt_dir, &S, false) == -1 )
126 continue ;
127
128 if (S.st_ex_dev == devno) {
129 (*mntpath) = SMB_STRDUP(mnt->mnt_dir);
130 (*bdev) = SMB_STRDUP(mnt->mnt_fsname);
131 (*fs) = SMB_STRDUP(mnt->mnt_type);
132 if ((*mntpath)&&(*bdev)&&(*fs)) {
133 ret = 0;
134 } else {
135 SAFE_FREE(*mntpath);
136 SAFE_FREE(*bdev);
137 SAFE_FREE(*fs);
138 ret = -1;
139 }
140
141 break;
142 }
143 }
144
145 endmntent(fp) ;
146
147 out:
148 SAFE_FREE(stat_mntpath);
149 return ret;
150 }
151 /* #endif HAVE_MNTENT */
152 #elif defined(HAVE_DEVNM)
153
154 /* we have this on HPUX, ... */
155 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
156 {
157 int ret = -1;
158 char dev_disk[256];
159 SMB_STRUCT_STAT S;
160
161 if (!path||!mntpath||!bdev||!fs)
162 smb_panic("sys_path_to_bdev: called with NULL pointer");
163
164 (*mntpath) = NULL;
165 (*bdev) = NULL;
166 (*fs) = NULL;
167
168 /* find the block device file */
169
170 if ((ret=sys_stat(path, &S, false))!=0) {
171 return ret;
172 }
173
174 if ((ret=devnm(S_IFBLK, S.st_ex_dev, dev_disk, 256, 1))!=0) {
175 return ret;
176 }
177
178 /* we should get the mntpath right...
179 * but I don't know how
180 * --metze
181 */
182 (*mntpath) = SMB_STRDUP(path);
183 (*bdev) = SMB_STRDUP(dev_disk);
184 if ((*mntpath)&&(*bdev)) {
185 ret = 0;
186 } else {
187 SAFE_FREE(*mntpath);
188 SAFE_FREE(*bdev);
189 ret = -1;
190 }
191
192
193 return ret;
194 }
195
196 /* #endif HAVE_DEVNM */
197 #else
198 /* we should fake this up...*/
199 static int sys_path_to_bdev(const char *path, char **mntpath, char **bdev, char **fs)
200 {
201 int ret = -1;
202
203 if (!path||!mntpath||!bdev||!fs)
204 smb_panic("sys_path_to_bdev: called with NULL pointer");
205
206 (*mntpath) = NULL;
207 (*bdev) = NULL;
208 (*fs) = NULL;
209
210 (*mntpath) = SMB_STRDUP(path);
211 if (*mntpath) {
212 ret = 0;
213 } else {
214 SAFE_FREE(*mntpath);
215 ret = -1;
216 }
217
218 return ret;
219 }
220 #endif
221
222 /*********************************************************************
223 Now the list of all filesystem specific quota systems we have found
224 **********************************************************************/
225 static struct {
226 const char *name;
227 int (*get_quota)(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp);
228 int (*set_quota)(const char *path, const char *bdev, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp);
229 } sys_quota_backends[] = {
230 #if defined HAVE_XFS_QUOTAS
231 {"xfs", sys_get_xfs_quota, sys_set_xfs_quota},
232 {"gfs", sys_get_xfs_quota, sys_set_xfs_quota},
233 {"gfs2", sys_get_xfs_quota, sys_set_xfs_quota},
234 #endif /* HAVE_XFS_QUOTAS */
235 #ifdef HAVE_NFS_QUOTAS
236 {"nfs", sys_get_nfs_quota, sys_set_nfs_quota},
237 {"nfs4", sys_get_nfs_quota, sys_set_nfs_quota},
238 #endif /* HAVE_NFS_QUOTAS */
239 {NULL, NULL, NULL}
240 };
241
242 static int command_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
243 {
244 const char *get_quota_command;
245 char **lines = NULL;
246
247 get_quota_command = lp_get_quota_command(talloc_tos());
248 if (get_quota_command && *get_quota_command) {
249 const char *p;
250 char *p2;
251 char *syscmd = NULL;
252 int _id = -1;
253
254 switch(qtype) {
255 case SMB_USER_QUOTA_TYPE:
256 case SMB_USER_FS_QUOTA_TYPE:
257 _id = id.uid;
258 break;
259 case SMB_GROUP_QUOTA_TYPE:
260 case SMB_GROUP_FS_QUOTA_TYPE:
261 _id = id.gid;
262 break;
263 default:
264 DEBUG(0,("invalid quota type.\n"));
265 return -1;
266 }
267
268 if (asprintf(&syscmd, "%s %s %d %d",
269 get_quota_command, path, qtype, _id) < 0) {
270 return -1;
271 }
272
273 DEBUG (3, ("get_quota: Running command %s\n", syscmd));
274
275 lines = file_lines_pload(talloc_tos(), syscmd, NULL);
276 SAFE_FREE(syscmd);
277
278 if (lines) {
279 char *line = lines[0];
280
281 DEBUG (3, ("Read output from get_quota, \"%s\"\n", line));
282
283 /* we need to deal with long long unsigned here, if supported */
284
285 dp->qflags = strtoul(line, &p2, 10);
286 p = p2;
287 while (p && *p && isspace(*p)) {
288 p++;
289 }
290
291 if (p && *p) {
292 dp->curblocks = STR_TO_SMB_BIG_UINT(p, &p);
293 } else {
294 goto invalid_param;
295 }
296
297 while (p && *p && isspace(*p)) {
298 p++;
299 }
300
301 if (p && *p) {
302 dp->softlimit = STR_TO_SMB_BIG_UINT(p, &p);
303 } else {
304 goto invalid_param;
305 }
306
307 while (p && *p && isspace(*p)) {
308 p++;
309 }
310
311 if (p && *p) {
312 dp->hardlimit = STR_TO_SMB_BIG_UINT(p, &p);
313 } else {
314 goto invalid_param;
315 }
316
317 while (p && *p && isspace(*p)) {
318 p++;
319 }
320
321 if (p && *p) {
322 dp->curinodes = STR_TO_SMB_BIG_UINT(p, &p);
323 } else {
324 goto invalid_param;
325 }
326
327 while (p && *p && isspace(*p)) {
328 p++;
329 }
330
331 if (p && *p) {
332 dp->isoftlimit = STR_TO_SMB_BIG_UINT(p, &p);
333 } else {
334 goto invalid_param;
335 }
336
337 while (p && *p && isspace(*p)) {
338 p++;
339 }
340
341 if (p && *p) {
342 dp->ihardlimit = STR_TO_SMB_BIG_UINT(p, &p);
343 } else {
344 goto invalid_param;
345 }
346
347 while (p && *p && isspace(*p)) {
348 p++;
349 }
350
351 if (p && *p) {
352 dp->bsize = STR_TO_SMB_BIG_UINT(p, NULL);
353 } else {
354 dp->bsize = 1024;
355 }
356
357 TALLOC_FREE(lines);
358 lines = NULL;
359
360 DEBUG (3, ("Parsed output of get_quota, ...\n"));
361
362 DEBUGADD (5,(
363 "qflags:%u curblocks:%llu softlimit:%llu hardlimit:%llu\n"
364 "curinodes:%llu isoftlimit:%llu ihardlimit:%llu bsize:%llu\n",
365 dp->qflags,(long long unsigned)dp->curblocks,
366 (long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
367 (long long unsigned)dp->curinodes,
368 (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
369 (long long unsigned)dp->bsize));
370 return 0;
371 }
372
373 DEBUG (0, ("get_quota_command failed!\n"));
374 return -1;
375 }
376
377 errno = ENOSYS;
378 return -1;
379
380 invalid_param:
381
382 TALLOC_FREE(lines);
383 DEBUG(0,("The output of get_quota_command is invalid!\n"));
384 return -1;
385 }
386
387 static int command_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
388 {
389 const char *set_quota_command;
390
391 set_quota_command = lp_set_quota_command(talloc_tos());
392 if (set_quota_command && *set_quota_command) {
393 char **lines = NULL;
394 char *syscmd = NULL;
395 int _id = -1;
396
397 switch(qtype) {
398 case SMB_USER_QUOTA_TYPE:
399 case SMB_USER_FS_QUOTA_TYPE:
400 _id = id.uid;
401 break;
402 case SMB_GROUP_QUOTA_TYPE:
403 case SMB_GROUP_FS_QUOTA_TYPE:
404 _id = id.gid;
405 break;
406 default:
407 return -1;
408 }
409
410 if (asprintf(&syscmd,
411 "%s %s %d %d "
412 "%u %llu %llu "
413 "%llu %llu %llu ",
414 set_quota_command, path, qtype, _id, dp->qflags,
415 (long long unsigned)dp->softlimit,(long long unsigned)dp->hardlimit,
416 (long long unsigned)dp->isoftlimit,(long long unsigned)dp->ihardlimit,
417 (long long unsigned)dp->bsize) < 0) {
418 return -1;
419 }
420
421 DEBUG (3, ("get_quota: Running command %s\n", syscmd));
422
423 lines = file_lines_pload(talloc_tos(), syscmd, NULL);
424 SAFE_FREE(syscmd);
425 if (lines) {
426 char *line = lines[0];
427
428 DEBUG (3, ("Read output from set_quota, \"%s\"\n", line));
429
430 TALLOC_FREE(lines);
431
432 return 0;
433 }
434 DEBUG (0, ("set_quota_command failed!\n"));
435 return -1;
436 }
437
438 errno = ENOSYS;
439 return -1;
440 }
441
442 int sys_get_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
443 {
444 int ret = -1;
445 int i;
446 bool ready = False;
447 char *mntpath = NULL;
448 char *bdev = NULL;
449 char *fs = NULL;
450
451 if (!path||!dp)
452 smb_panic("sys_get_quota: called with NULL pointer");
453
454 if (command_get_quota(path, qtype, id, dp)==0) {
455 return 0;
456 } else if (errno != ENOSYS) {
457 return -1;
458 }
459
460 if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
461 DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
462 return ret;
463 }
464
465 errno = 0;
466 DEBUG(10,("sys_get_quota() uid(%u, %u), fs(%s)\n", (unsigned)getuid(), (unsigned)geteuid(), fs));
467
468 for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].get_quota);i++) {
469 if (strcmp(fs,sys_quota_backends[i].name)==0) {
470 ret = sys_quota_backends[i].get_quota(mntpath, bdev, qtype, id, dp);
471 if (ret!=0) {
472 DEBUG(3,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
473 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
474 } else {
475 DEBUG(10,("sys_get_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
476 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
477 }
478 ready = True;
479 break;
480 }
481 }
482
483 if (!ready) {
484 /* use the default vfs quota functions */
485 ret=sys_get_vfs_quota(mntpath, bdev, qtype, id, dp);
486 if (ret!=0) {
487 DEBUG(3,("sys_get_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s\n",
488 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
489 } else {
490 DEBUG(10,("sys_get_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
491 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
492 }
493 }
494
495 SAFE_FREE(mntpath);
496 SAFE_FREE(bdev);
497 SAFE_FREE(fs);
498
499 return ret;
500 }
501
502 int sys_set_quota(const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dp)
503 {
504 int ret = -1;
505 int i;
506 bool ready = False;
507 char *mntpath = NULL;
508 char *bdev = NULL;
509 char *fs = NULL;
510
511 /* find the block device file */
512
513 if (!path||!dp)
514 smb_panic("get_smb_quota: called with NULL pointer");
515
516 if (command_set_quota(path, qtype, id, dp)==0) {
517 return 0;
518 } else if (errno != ENOSYS) {
519 return -1;
520 }
521
522 if ((ret=sys_path_to_bdev(path,&mntpath,&bdev,&fs))!=0) {
523 DEBUG(0,("sys_path_to_bdev() failed for path [%s]!\n",path));
524 return ret;
525 }
526
527 errno = 0;
528 DEBUG(10,("sys_set_quota() uid(%u, %u)\n", (unsigned)getuid(), (unsigned)geteuid()));
529
530 for (i=0;(fs && sys_quota_backends[i].name && sys_quota_backends[i].set_quota);i++) {
531 if (strcmp(fs,sys_quota_backends[i].name)==0) {
532 ret = sys_quota_backends[i].set_quota(mntpath, bdev, qtype, id, dp);
533 if (ret!=0) {
534 DEBUG(3,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
535 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
536 } else {
537 DEBUG(10,("sys_set_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
538 fs,mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
539 }
540 ready = True;
541 break;
542 }
543 }
544
545 if (!ready) {
546 /* use the default vfs quota functions */
547 ret=sys_set_vfs_quota(mntpath, bdev, qtype, id, dp);
548 if (ret!=0) {
549 DEBUG(3,("sys_set_%s_quota() failed for mntpath[%s] bdev[%s] qtype[%d] id[%d]: %s.\n",
550 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid),strerror(errno)));
551 } else {
552 DEBUG(10,("sys_set_%s_quota() called for mntpath[%s] bdev[%s] qtype[%d] id[%d].\n",
553 "vfs",mntpath,bdev,qtype,(qtype==SMB_GROUP_QUOTA_TYPE?id.gid:id.uid)));
554 }
555 }
556
557 SAFE_FREE(mntpath);
558 SAFE_FREE(bdev);
559 SAFE_FREE(fs);
560
561 return ret;
562 }
563
564 #else /* HAVE_SYS_QUOTAS */
565 void dummy_sysquotas_c(void);
566
567 void dummy_sysquotas_c(void)
568 {
569 return;
570 }
571 #endif /* HAVE_SYS_QUOTAS */
572
Samba GIT mirror