1 /**
2 * collectd - src/utils_mount.c
3 * Copyright (C) 2005,2006 Niki W. Waibel
4 *
5 * This program is free software; you can redistribute it and/
6 * or modify it under the terms of the GNU General Public Li-
7 * cence as published by the Free Software Foundation; either
8 * version 2 of the Licence, or any later version.
9 *
10 * This program is distributed in the hope that it will be use-
11 * ful, but WITHOUT ANY WARRANTY; without even the implied war-
12 * ranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 * See the GNU General Public Licence for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * Author:
20 * Niki W. Waibel <niki.waibel@gmx.net>
21 **/
23 #if HAVE_CONFIG_H
24 # include "config.h"
25 #endif
27 #if HAVE_XFS_XQM_H
28 # define _GNU_SOURCE
29 # include <xfs/xqm.h>
30 #define XFS_SUPER_MAGIC_STR "XFSB"
31 #define XFS_SUPER_MAGIC2_STR "BSFX"
32 #endif
34 #include "collectd.h"
35 #include "utils_mount.h"
37 #include "common.h" /* sstrncpy() et alii */
38 #include "plugin.h" /* ERROR() macro */
41 #if HAVE_GETVFSSTAT
42 # if HAVE_SYS_TYPES_H
43 # include <sys/types.h>
44 # endif
45 # if HAVE_SYS_STATVFS_H
46 # include <sys/statvfs.h>
47 # endif
48 /* #endif HAVE_GETVFSSTAT */
50 #elif HAVE_GETFSSTAT
51 # if HAVE_SYS_PARAM_H
52 # include <sys/param.h>
53 # endif
54 # if HAVE_SYS_UCRED_H
55 # include <sys/ucred.h>
56 # endif
57 # if HAVE_SYS_MOUNT_H
58 # include <sys/mount.h>
59 # endif
60 #endif /* HAVE_GETFSSTAT */
62 #if HAVE_MNTENT_H
63 # include <mntent.h>
64 #endif
65 #if HAVE_SYS_MNTTAB_H
66 # include <sys/mnttab.h>
67 #endif
69 #if HAVE_PATHS_H
70 # include <paths.h>
71 #endif
73 #ifdef COLLECTD_MNTTAB
74 # undef COLLECTD_MNTTAB
75 #endif
77 #if defined(_PATH_MOUNTED) /* glibc */
78 # define COLLECTD_MNTTAB _PATH_MOUNTED
79 #elif defined(MNTTAB) /* Solaris */
80 # define COLLECTD_MNTTAB MNTTAB
81 #elif defined(MNT_MNTTAB)
82 # define COLLECTD_MNTTAB MNT_MNTTAB
83 #elif defined(MNTTABNAME)
84 # define COLLECTD_MNTTAB MNTTABNAME
85 #elif defined(KMTAB)
86 # define COLLECTD_MNTTAB KMTAB
87 #else
88 # define COLLECTD_MNTTAB "/etc/mnttab"
89 #endif
91 /* *** *** *** ********************************************* *** *** *** */
92 /* *** *** *** *** *** *** private functions *** *** *** *** *** *** */
93 /* *** *** *** ********************************************* *** *** *** */
95 /* stolen from quota-3.13 (quota-tools) */
97 #define PROC_PARTITIONS "/proc/partitions"
98 #define DEVLABELDIR "/dev"
99 #define UUID 1
100 #define VOL 2
102 static struct uuidCache_s {
103 struct uuidCache_s *next;
104 char uuid[16];
105 char *label;
106 char *device;
107 } *uuidCache = NULL;
109 #define EXT2_SUPER_MAGIC 0xEF53
110 struct ext2_super_block {
111 unsigned char s_dummy1[56];
112 unsigned char s_magic[2];
113 unsigned char s_dummy2[46];
114 unsigned char s_uuid[16];
115 char s_volume_name[16];
116 };
117 #define ext2magic(s) ((unsigned int)s.s_magic[0] \
118 + (((unsigned int)s.s_magic[1]) << 8))
120 #if HAVE_XFS_XQM_H
121 struct xfs_super_block {
122 unsigned char s_magic[4];
123 unsigned char s_dummy[28];
124 unsigned char s_uuid[16];
125 unsigned char s_dummy2[60];
126 char s_fsname[12];
127 };
128 #endif /* HAVE_XFS_XQM_H */
130 #define REISER_SUPER_MAGIC "ReIsEr2Fs"
131 struct reiserfs_super_block {
132 unsigned char s_dummy1[52];
133 unsigned char s_magic[10];
134 unsigned char s_dummy2[22];
135 unsigned char s_uuid[16];
136 char s_volume_name[16];
137 };
139 /* for now, only ext2 and xfs are supported */
140 static int
141 get_label_uuid(const char *device, char **label, char *uuid)
142 {
143 /* start with ext2 and xfs tests, taken from mount_guess_fstype */
144 /* should merge these later */
145 int fd, rv = 1;
146 size_t namesize;
147 struct ext2_super_block e2sb;
148 #if HAVE_XFS_XQM_H
149 struct xfs_super_block xfsb;
150 #endif
151 struct reiserfs_super_block reisersb;
153 fd = open(device, O_RDONLY);
154 if(fd == -1) {
155 return rv;
156 }
158 if(lseek(fd, 1024, SEEK_SET) == 1024
159 && read(fd, (char *)&e2sb, sizeof(e2sb)) == sizeof(e2sb)
160 && ext2magic(e2sb) == EXT2_SUPER_MAGIC) {
161 memcpy(uuid, e2sb.s_uuid, sizeof(e2sb.s_uuid));
162 namesize = sizeof(e2sb.s_volume_name);
163 *label = smalloc(namesize + 1);
164 sstrncpy(*label, e2sb.s_volume_name, namesize);
165 rv = 0;
166 #if HAVE_XFS_XQM_H
167 } else if(lseek(fd, 0, SEEK_SET) == 0
168 && read(fd, (char *)&xfsb, sizeof(xfsb)) == sizeof(xfsb)
169 && (strncmp((char *)&xfsb.s_magic, XFS_SUPER_MAGIC_STR, 4) == 0 ||
170 strncmp((char *)&xfsb.s_magic, XFS_SUPER_MAGIC2_STR, 4) == 0)) {
171 memcpy(uuid, xfsb.s_uuid, sizeof(xfsb.s_uuid));
172 namesize = sizeof(xfsb.s_fsname);
173 *label = smalloc(namesize + 1);
174 sstrncpy(*label, xfsb.s_fsname, namesize);
175 rv = 0;
176 #endif /* HAVE_XFS_XQM_H */
177 } else if(lseek(fd, 65536, SEEK_SET) == 65536
178 && read(fd, (char *)&reisersb, sizeof(reisersb)) == sizeof(reisersb)
179 && !strncmp((char *)&reisersb.s_magic, REISER_SUPER_MAGIC, 9)) {
180 memcpy(uuid, reisersb.s_uuid, sizeof(reisersb.s_uuid));
181 namesize = sizeof(reisersb.s_volume_name);
182 *label = smalloc(namesize + 1);
183 sstrncpy(*label, reisersb.s_volume_name, namesize);
184 rv = 0;
185 }
186 close(fd);
187 return rv;
188 }
190 static void
191 uuidcache_addentry(char *device, char *label, char *uuid)
192 {
193 struct uuidCache_s *last;
195 if(!uuidCache) {
196 last = uuidCache = smalloc(sizeof(*uuidCache));
197 } else {
198 for(last = uuidCache; last->next; last = last->next);
199 last->next = smalloc(sizeof(*uuidCache));
200 last = last->next;
201 }
202 last->next = NULL;
203 last->device = device;
204 last->label = label;
205 memcpy(last->uuid, uuid, sizeof(last->uuid));
206 }
208 static void
209 uuidcache_init(void)
210 {
211 char line[100];
212 char *s;
213 int ma, mi, sz;
214 static char ptname[100];
215 FILE *procpt;
216 char uuid[16], *label = NULL;
217 char device[110];
218 int firstPass;
219 int handleOnFirst;
221 if(uuidCache) {
222 return;
223 }
225 procpt = fopen(PROC_PARTITIONS, "r");
226 if(procpt == NULL) {
227 return;
228 }
230 for(firstPass = 1; firstPass >= 0; firstPass--) {
231 fseek(procpt, 0, SEEK_SET);
232 while(fgets(line, sizeof(line), procpt)) {
233 if(sscanf(line, " %d %d %d %[^\n ]",
234 &ma, &mi, &sz, ptname) != 4)
235 {
236 continue;
237 }
239 /* skip extended partitions (heuristic: size 1) */
240 if(sz == 1) {
241 continue;
242 }
244 /* look only at md devices on first pass */
245 handleOnFirst = !strncmp(ptname, "md", 2);
246 if(firstPass != handleOnFirst) {
247 continue;
248 }
250 /* skip entire disk (minor 0, 64, ... on ide;
251 0, 16, ... on sd) */
252 /* heuristic: partition name ends in a digit */
254 for(s = ptname; *s; s++);
256 if(isdigit((int)s[-1])) {
257 /*
258 * Note: this is a heuristic only - there is no reason
259 * why these devices should live in /dev.
260 * Perhaps this directory should be specifiable by option.
261 * One might for example have /devlabel with links to /dev
262 * for the devices that may be accessed in this way.
263 * (This is useful, if the cdrom on /dev/hdc must not
264 * be accessed.)
265 */
266 ssnprintf(device, sizeof(device), "%s/%s",
267 DEVLABELDIR, ptname);
268 if(!get_label_uuid(device, &label, uuid)) {
269 uuidcache_addentry(sstrdup(device),
270 label, uuid);
271 }
272 }
273 }
274 }
275 fclose(procpt);
276 }
278 static unsigned char
279 fromhex(char c)
280 {
281 if(isdigit((int)c)) {
282 return (c - '0');
283 } else if(islower((int)c)) {
284 return (c - 'a' + 10);
285 } else {
286 return (c - 'A' + 10);
287 }
288 }
290 static char *
291 get_spec_by_x(int n, const char *t)
292 {
293 struct uuidCache_s *uc;
295 uuidcache_init();
296 uc = uuidCache;
298 while(uc) {
299 switch(n) {
300 case UUID:
301 if(!memcmp(t, uc->uuid, sizeof(uc->uuid))) {
302 return sstrdup(uc->device);
303 }
304 break;
305 case VOL:
306 if(!strcmp(t, uc->label)) {
307 return sstrdup(uc->device);
308 }
309 break;
310 }
311 uc = uc->next;
312 }
313 return NULL;
314 }
316 static char *
317 get_spec_by_uuid(const char *s)
318 {
319 char uuid[16];
320 int i;
322 if(strlen(s) != 36
323 || s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-') {
324 goto bad_uuid;
325 }
327 for(i=0; i<16; i++) {
328 if(*s == '-') {
329 s++;
330 }
331 if(!isxdigit((int)s[0]) || !isxdigit((int)s[1])) {
332 goto bad_uuid;
333 }
334 uuid[i] = ((fromhex(s[0]) << 4) | fromhex(s[1]));
335 s += 2;
336 }
337 return get_spec_by_x(UUID, uuid);
339 bad_uuid:
340 DEBUG("utils_mount: Found an invalid UUID: %s", s);
341 return NULL;
342 }
344 static char *get_spec_by_volume_label(const char *s)
345 {
346 return get_spec_by_x (VOL, s);
347 }
349 static char *get_device_name(const char *optstr)
350 {
351 char *rc;
353 if (optstr == NULL)
354 {
355 return (NULL);
356 }
357 else if (strncmp (optstr, "UUID=", 5) == 0)
358 {
359 DEBUG ("utils_mount: TODO: check UUID= code!");
360 rc = get_spec_by_uuid (optstr + 5);
361 }
362 else if (strncmp (optstr, "LABEL=", 6) == 0)
363 {
364 DEBUG ("utils_mount: TODO: check LABEL= code!");
365 rc = get_spec_by_volume_label (optstr + 6);
366 }
367 else
368 {
369 rc = sstrdup (optstr);
370 }
372 if(!rc)
373 {
374 DEBUG ("utils_mount: Error checking device name: optstr = %s", optstr);
375 }
376 return rc;
377 }
379 /* What weird OS is this..? I can't find any info with google :/ -octo */
380 #if HAVE_LISTMNTENT && 0
381 static cu_mount_t *cu_mount_listmntent (void)
382 {
383 cu_mount_t *last = *list;
384 struct tabmntent *p;
385 struct mntent *mnt;
387 struct tabmntent *mntlist;
388 if(listmntent(&mntlist, COLLECTD_MNTTAB, NULL, NULL) < 0) {
389 #if COLLECT_DEBUG
390 char errbuf[1024];
391 DEBUG("utils_mount: calling listmntent() failed: %s",
392 sstrerror (errno, errbuf, sizeof (errbuf)));
393 #endif /* COLLECT_DEBUG */
394 }
396 for(p = mntlist; p; p = p->next) {
397 char *loop = NULL, *device = NULL;
399 mnt = p->ment;
400 loop = cu_mount_getoptionvalue(mnt->mnt_opts, "loop=");
401 if(loop == NULL) { /* no loop= mount */
402 device = get_device_name(mnt->mnt_fsname);
403 if(device == NULL) {
404 DEBUG("utils_mount: can't get devicename for fs (%s) %s (%s)"
405 ": ignored", mnt->mnt_type,
406 mnt->mnt_dir, mnt->mnt_fsname);
407 continue;
408 }
409 } else {
410 device = loop;
411 }
412 if(*list == NULL) {
413 *list = (cu_mount_t *)smalloc(sizeof(cu_mount_t));
414 last = *list;
415 } else {
416 while(last->next != NULL) { /* is last really last? */
417 last = last->next;
418 }
419 last->next = (cu_mount_t *)smalloc(sizeof(cu_mount_t));
420 last = last->next;
421 }
422 last->dir = sstrdup(mnt->mnt_dir);
423 last->spec_device = sstrdup(mnt->mnt_fsname);
424 last->device = device;
425 last->type = sstrdup(mnt->mnt_type);
426 last->options = sstrdup(mnt->mnt_opts);
427 last->next = NULL;
428 } /* for(p = mntlist; p; p = p->next) */
430 return(last);
431 } /* cu_mount_t *cu_mount_listmntent(void) */
432 /* #endif HAVE_LISTMNTENT */
434 /* 4.4BSD and Mac OS X (getfsstat) or NetBSD (getvfsstat) */
435 #elif HAVE_GETVFSSTAT || HAVE_GETFSSTAT
436 static cu_mount_t *cu_mount_getfsstat (void)
437 {
438 #if HAVE_GETFSSTAT
439 # define STRUCT_STATFS struct statfs
440 # define CMD_STATFS getfsstat
441 # define FLAGS_STATFS MNT_NOWAIT
442 /* #endif HAVE_GETFSSTAT */
443 #elif HAVE_GETVFSSTAT
444 # define STRUCT_STATFS struct statvfs
445 # define CMD_STATFS getvfsstat
446 # define FLAGS_STATFS ST_NOWAIT
447 #endif /* HAVE_GETVFSSTAT */
449 int bufsize;
450 STRUCT_STATFS *buf;
452 int num;
453 int i;
455 cu_mount_t *first = NULL;
456 cu_mount_t *last = NULL;
457 cu_mount_t *new = NULL;
459 /* Get the number of mounted file systems */
460 if ((bufsize = CMD_STATFS (NULL, 0, FLAGS_STATFS)) < 1)
461 {
462 #if COLLECT_DEBUG
463 char errbuf[1024];
464 DEBUG ("utils_mount: getv?fsstat failed: %s",
465 sstrerror (errno, errbuf, sizeof (errbuf)));
466 #endif /* COLLECT_DEBUG */
467 return (NULL);
468 }
470 if ((buf = malloc (bufsize * sizeof (*buf))) == NULL)
471 return (NULL);
472 memset (buf, '\0', bufsize * sizeof (STRUCT_STATFS));
474 /* The bufsize needs to be passed in bytes. Really. This is not in the
475 * manpage.. -octo */
476 if ((num = CMD_STATFS (buf, bufsize * sizeof (STRUCT_STATFS), FLAGS_STATFS)) < 1)
477 {
478 #if COLLECT_DEBUG
479 char errbuf[1024];
480 DEBUG ("utils_mount: getv?fsstat failed: %s",
481 sstrerror (errno, errbuf, sizeof (errbuf)));
482 #endif /* COLLECT_DEBUG */
483 free (buf);
484 return (NULL);
485 }
487 for (i = 0; i < num; i++)
488 {
489 if ((new = malloc (sizeof (*new))) == NULL)
490 break;
491 memset (new, '\0', sizeof (cu_mount_t));
493 /* Copy values from `struct mnttab' */
494 new->dir = sstrdup (buf[i].f_mntonname);
495 new->spec_device = sstrdup (buf[i].f_mntfromname);
496 new->type = sstrdup (buf[i].f_fstypename);
497 new->options = NULL;
498 new->device = get_device_name (new->options);
499 new->next = NULL;
501 /* Append to list */
502 if (first == NULL)
503 {
504 first = new;
505 last = new;
506 }
507 else
508 {
509 last->next = new;
510 last = new;
511 }
512 }
514 free (buf);
516 return (first);
517 }
518 /* #endif HAVE_GETVFSSTAT || HAVE_GETFSSTAT */
520 /* Solaris (SunOS 10): int getmntent(FILE *fp, struct mnttab *mp); */
521 #elif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT
522 static cu_mount_t *cu_mount_gen_getmntent (void)
523 {
524 struct mnttab mt;
525 FILE *fp;
527 cu_mount_t *first = NULL;
528 cu_mount_t *last = NULL;
529 cu_mount_t *new = NULL;
531 DEBUG ("utils_mount: (void); COLLECTD_MNTTAB = %s", COLLECTD_MNTTAB);
533 if ((fp = fopen (COLLECTD_MNTTAB, "r")) == NULL)
534 {
535 char errbuf[1024];
536 ERROR ("fopen (%s): %s", COLLECTD_MNTTAB,
537 sstrerror (errno, errbuf, sizeof (errbuf)));
538 return (NULL);
539 }
541 while (getmntent (fp, &mt) == 0)
542 {
543 if ((new = malloc (sizeof (*new))) == NULL)
544 break;
545 memset (new, '\0', sizeof (cu_mount_t));
547 /* Copy values from `struct mnttab' */
548 new->dir = sstrdup (mt.mnt_mountp);
549 new->spec_device = sstrdup (mt.mnt_special);
550 new->type = sstrdup (mt.mnt_fstype);
551 new->options = sstrdup (mt.mnt_mntopts);
552 new->device = get_device_name (new->options);
553 new->next = NULL;
555 /* Append to list */
556 if (first == NULL)
557 {
558 first = new;
559 last = new;
560 }
561 else
562 {
563 last->next = new;
564 last = new;
565 }
566 }
568 fclose (fp);
570 return (first);
571 } /* static cu_mount_t *cu_mount_gen_getmntent (void) */
572 /* #endif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT */
574 #elif HAVE_SEQ_GETMNTENT
575 #warn "This version of `getmntent' hat not yet been implemented!"
576 /* #endif HAVE_SEQ_GETMNTENT */
578 #elif HAVE_GETMNTENT_R
579 static cu_mount_t *cu_mount_getmntent (void)
580 {
581 FILE *fp;
582 struct mntent me;
583 char mntbuf[1024];
585 cu_mount_t *first = NULL;
586 cu_mount_t *last = NULL;
587 cu_mount_t *new = NULL;
589 DEBUG ("utils_mount: (void); COLLECTD_MNTTAB = %s", COLLECTD_MNTTAB);
591 if ((fp = setmntent (COLLECTD_MNTTAB, "r")) == NULL)
592 {
593 char errbuf[1024];
594 ERROR ("setmntent (%s): %s", COLLECTD_MNTTAB,
595 sstrerror (errno, errbuf, sizeof (errbuf)));
596 return (NULL);
597 }
599 while (getmntent_r (fp, &me, mntbuf, sizeof (mntbuf) ))
600 {
601 if ((new = malloc (sizeof (*new))) == NULL)
602 break;
603 memset (new, '\0', sizeof (cu_mount_t));
605 /* Copy values from `struct mntent *' */
606 new->dir = sstrdup (me.mnt_dir);
607 new->spec_device = sstrdup (me.mnt_fsname);
608 new->type = sstrdup (me.mnt_type);
609 new->options = sstrdup (me.mnt_opts);
610 new->device = get_device_name (new->options);
611 new->next = NULL;
613 DEBUG ("utils_mount: new = {dir = %s, spec_device = %s, type = %s, options = %s, device = %s}",
614 new->dir, new->spec_device, new->type, new->options, new->device);
616 /* Append to list */
617 if (first == NULL)
618 {
619 first = new;
620 last = new;
621 }
622 else
623 {
624 last->next = new;
625 last = new;
626 }
627 }
629 endmntent (fp);
631 DEBUG ("utils_mount: return (0x%p)", (void *) first);
633 return (first);
634 } /* HAVE_GETMNTENT_R */
636 #elif HAVE_ONE_GETMNTENT
637 static cu_mount_t *cu_mount_getmntent (void)
638 {
639 FILE *fp;
640 struct mntent *me;
642 cu_mount_t *first = NULL;
643 cu_mount_t *last = NULL;
644 cu_mount_t *new = NULL;
646 DEBUG ("utils_mount: (void); COLLECTD_MNTTAB = %s", COLLECTD_MNTTAB);
648 if ((fp = setmntent (COLLECTD_MNTTAB, "r")) == NULL)
649 {
650 char errbuf[1024];
651 ERROR ("setmntent (%s): %s", COLLECTD_MNTTAB,
652 sstrerror (errno, errbuf, sizeof (errbuf)));
653 return (NULL);
654 }
656 while ((me = getmntent (fp)) != NULL)
657 {
658 if ((new = malloc (sizeof (*new))) == NULL)
659 break;
660 memset (new, '\0', sizeof (cu_mount_t));
662 /* Copy values from `struct mntent *' */
663 new->dir = sstrdup (me->mnt_dir);
664 new->spec_device = sstrdup (me->mnt_fsname);
665 new->type = sstrdup (me->mnt_type);
666 new->options = sstrdup (me->mnt_opts);
667 new->device = get_device_name (new->options);
668 new->next = NULL;
670 DEBUG ("utils_mount: new = {dir = %s, spec_device = %s, type = %s, options = %s, device = %s}",
671 new->dir, new->spec_device, new->type, new->options, new->device);
673 /* Append to list */
674 if (first == NULL)
675 {
676 first = new;
677 last = new;
678 }
679 else
680 {
681 last->next = new;
682 last = new;
683 }
684 }
686 endmntent (fp);
688 DEBUG ("utils_mount: return (0x%p)", (void *) first);
690 return (first);
691 }
692 #endif /* HAVE_ONE_GETMNTENT */
694 /* *** *** *** ******************************************** *** *** *** */
695 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
696 /* *** *** *** ******************************************** *** *** *** */
698 cu_mount_t *cu_mount_getlist(cu_mount_t **list)
699 {
700 cu_mount_t *new;
701 cu_mount_t *first = NULL;
702 cu_mount_t *last = NULL;
704 if (list == NULL)
705 return (NULL);
707 if (*list != NULL)
708 {
709 first = *list;
710 last = first;
711 while (last->next != NULL)
712 last = last->next;
713 }
715 #if HAVE_LISTMNTENT && 0
716 new = cu_mount_listmntent ();
717 #elif HAVE_GETVFSSTAT || HAVE_GETFSSTAT
718 new = cu_mount_getfsstat ();
719 #elif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT
720 new = cu_mount_gen_getmntent ();
721 #elif HAVE_SEQ_GETMNTENT
722 # error "This version of `getmntent' hat not yet been implemented!"
723 #elif HAVE_ONE_GETMNTENT
724 new = cu_mount_getmntent ();
725 #else
726 # error "Could not determine how to find mountpoints."
727 #endif
729 if (first != NULL)
730 {
731 last->next = new;
732 }
733 else
734 {
735 first = new;
736 last = new;
737 *list = first;
738 }
740 while ((last != NULL) && (last->next != NULL))
741 last = last->next;
743 return (last);
744 } /* cu_mount_t *cu_mount_getlist(cu_mount_t **list) */
746 void cu_mount_freelist (cu_mount_t *list)
747 {
748 cu_mount_t *this;
749 cu_mount_t *next;
751 for (this = list; this != NULL; this = next)
752 {
753 next = this->next;
755 sfree (this->dir);
756 sfree (this->spec_device);
757 sfree (this->device);
758 sfree (this->type);
759 sfree (this->options);
760 sfree (this);
761 }
762 } /* void cu_mount_freelist(cu_mount_t *list) */
764 char *
765 cu_mount_checkoption(char *line, const char *keyword, int full)
766 {
767 char *line2, *l2, *p1, *p2;
768 int l;
770 if(line == NULL || keyword == NULL) {
771 return NULL;
772 }
774 if(full != 0) {
775 full = 1;
776 }
778 line2 = sstrdup(line);
779 l2 = line2;
780 while(*l2 != '\0') {
781 if(*l2 == ',') {
782 *l2 = '\0';
783 }
784 l2++;
785 }
787 l = strlen(keyword);
788 p1 = line - 1;
789 p2 = strchr(line, ',');
790 do {
791 if(strncmp(line2+(p1-line)+1, keyword, l+full) == 0) {
792 free(line2);
793 return p1+1;
794 }
795 p1 = p2;
796 if(p1 != NULL) {
797 p2 = strchr(p1+1, ',');
798 }
799 } while(p1 != NULL);
801 free(line2);
802 return NULL;
803 } /* char *cu_mount_checkoption(char *line, char *keyword, int full) */
805 char *
806 cu_mount_getoptionvalue(char *line, const char *keyword)
807 {
808 char *r;
810 r = cu_mount_checkoption(line, keyword, 0);
811 if(r != NULL) {
812 char *p;
813 r += strlen(keyword);
814 p = strchr(r, ',');
815 if(p == NULL) {
816 return sstrdup(r);
817 } else {
818 char *m;
819 if((p-r) == 1) {
820 return NULL;
821 }
822 m = smalloc(p-r+1);
823 sstrncpy(m, r, p-r+1);
824 return m;
825 }
826 }
827 return r;
828 } /* char *cu_mount_getoptionvalue(char *line, const char *keyword) */
830 int
831 cu_mount_type(const char *type)
832 {
833 if(strcmp(type, "ext3") == 0) return CUMT_EXT3;
834 if(strcmp(type, "ext2") == 0) return CUMT_EXT2;
835 if(strcmp(type, "ufs") == 0) return CUMT_UFS;
836 if(strcmp(type, "vxfs") == 0) return CUMT_VXFS;
837 if(strcmp(type, "zfs") == 0) return CUMT_ZFS;
838 return CUMT_UNKNOWN;
839 } /* int cu_mount_type(const char *type) */