752d2e158a597e2b3b9e893d57c2d8267d1c71de
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 = (STRUCT_STATFS *) malloc (bufsize * sizeof (STRUCT_STATFS)))
471 == NULL)
472 return (NULL);
473 memset (buf, '\0', bufsize * sizeof (STRUCT_STATFS));
475 /* The bufsize needs to be passed in bytes. Really. This is not in the
476 * manpage.. -octo */
477 if ((num = CMD_STATFS (buf, bufsize * sizeof (STRUCT_STATFS), FLAGS_STATFS)) < 1)
478 {
479 #if COLLECT_DEBUG
480 char errbuf[1024];
481 DEBUG ("utils_mount: getv?fsstat failed: %s",
482 sstrerror (errno, errbuf, sizeof (errbuf)));
483 #endif /* COLLECT_DEBUG */
484 free (buf);
485 return (NULL);
486 }
488 for (i = 0; i < num; i++)
489 {
490 if ((new = malloc (sizeof (cu_mount_t))) == NULL)
491 break;
492 memset (new, '\0', sizeof (cu_mount_t));
494 /* Copy values from `struct mnttab' */
495 new->dir = sstrdup (buf[i].f_mntonname);
496 new->spec_device = sstrdup (buf[i].f_mntfromname);
497 new->type = sstrdup (buf[i].f_fstypename);
498 new->options = NULL;
499 new->device = get_device_name (new->options);
500 new->next = NULL;
502 /* Append to list */
503 if (first == NULL)
504 {
505 first = new;
506 last = new;
507 }
508 else
509 {
510 last->next = new;
511 last = new;
512 }
513 }
515 free (buf);
517 return (first);
518 }
519 /* #endif HAVE_GETVFSSTAT || HAVE_GETFSSTAT */
521 /* Solaris (SunOS 10): int getmntent(FILE *fp, struct mnttab *mp); */
522 #elif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT
523 static cu_mount_t *cu_mount_gen_getmntent (void)
524 {
525 struct mnttab mt;
526 FILE *fp;
528 cu_mount_t *first = NULL;
529 cu_mount_t *last = NULL;
530 cu_mount_t *new = NULL;
532 DEBUG ("utils_mount: (void); COLLECTD_MNTTAB = %s", COLLECTD_MNTTAB);
534 if ((fp = fopen (COLLECTD_MNTTAB, "r")) == NULL)
535 {
536 char errbuf[1024];
537 ERROR ("fopen (%s): %s", COLLECTD_MNTTAB,
538 sstrerror (errno, errbuf, sizeof (errbuf)));
539 return (NULL);
540 }
542 while (getmntent (fp, &mt) == 0)
543 {
544 if ((new = malloc (sizeof (cu_mount_t))) == NULL)
545 break;
546 memset (new, '\0', sizeof (cu_mount_t));
548 /* Copy values from `struct mnttab' */
549 new->dir = sstrdup (mt.mnt_mountp);
550 new->spec_device = sstrdup (mt.mnt_special);
551 new->type = sstrdup (mt.mnt_fstype);
552 new->options = sstrdup (mt.mnt_mntopts);
553 new->device = get_device_name (new->options);
554 new->next = NULL;
556 /* Append to list */
557 if (first == NULL)
558 {
559 first = new;
560 last = new;
561 }
562 else
563 {
564 last->next = new;
565 last = new;
566 }
567 }
569 fclose (fp);
571 return (first);
572 } /* static cu_mount_t *cu_mount_gen_getmntent (void) */
573 /* #endif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT */
575 #elif HAVE_SEQ_GETMNTENT
576 #warn "This version of `getmntent' hat not yet been implemented!"
577 /* #endif HAVE_SEQ_GETMNTENT */
579 #elif HAVE_GETMNTENT_R
580 static cu_mount_t *cu_mount_getmntent (void)
581 {
582 FILE *fp;
583 struct mntent me;
584 char mntbuf[1024];
586 cu_mount_t *first = NULL;
587 cu_mount_t *last = NULL;
588 cu_mount_t *new = NULL;
590 DEBUG ("utils_mount: (void); COLLECTD_MNTTAB = %s", COLLECTD_MNTTAB);
592 if ((fp = setmntent (COLLECTD_MNTTAB, "r")) == NULL)
593 {
594 char errbuf[1024];
595 ERROR ("setmntent (%s): %s", COLLECTD_MNTTAB,
596 sstrerror (errno, errbuf, sizeof (errbuf)));
597 return (NULL);
598 }
600 while (getmntent_r (fp, &me, mntbuf, sizeof (mntbuf) ))
601 {
602 if ((new = malloc (sizeof (cu_mount_t))) == NULL)
603 break;
604 memset (new, '\0', sizeof (cu_mount_t));
606 /* Copy values from `struct mntent *' */
607 new->dir = sstrdup (me.mnt_dir);
608 new->spec_device = sstrdup (me.mnt_fsname);
609 new->type = sstrdup (me.mnt_type);
610 new->options = sstrdup (me.mnt_opts);
611 new->device = get_device_name (new->options);
612 new->next = NULL;
614 DEBUG ("utils_mount: new = {dir = %s, spec_device = %s, type = %s, options = %s, device = %s}",
615 new->dir, new->spec_device, new->type, new->options, new->device);
617 /* Append to list */
618 if (first == NULL)
619 {
620 first = new;
621 last = new;
622 }
623 else
624 {
625 last->next = new;
626 last = new;
627 }
628 }
630 endmntent (fp);
632 DEBUG ("utils_mount: return (0x%p)", (void *) first);
634 return (first);
635 } /* HAVE_GETMNTENT_R */
637 #elif HAVE_ONE_GETMNTENT
638 static cu_mount_t *cu_mount_getmntent (void)
639 {
640 FILE *fp;
641 struct mntent *me;
643 cu_mount_t *first = NULL;
644 cu_mount_t *last = NULL;
645 cu_mount_t *new = NULL;
647 DEBUG ("utils_mount: (void); COLLECTD_MNTTAB = %s", COLLECTD_MNTTAB);
649 if ((fp = setmntent (COLLECTD_MNTTAB, "r")) == NULL)
650 {
651 char errbuf[1024];
652 ERROR ("setmntent (%s): %s", COLLECTD_MNTTAB,
653 sstrerror (errno, errbuf, sizeof (errbuf)));
654 return (NULL);
655 }
657 while ((me = getmntent (fp)) != NULL)
658 {
659 if ((new = malloc (sizeof (cu_mount_t))) == NULL)
660 break;
661 memset (new, '\0', sizeof (cu_mount_t));
663 /* Copy values from `struct mntent *' */
664 new->dir = sstrdup (me->mnt_dir);
665 new->spec_device = sstrdup (me->mnt_fsname);
666 new->type = sstrdup (me->mnt_type);
667 new->options = sstrdup (me->mnt_opts);
668 new->device = get_device_name (new->options);
669 new->next = NULL;
671 DEBUG ("utils_mount: new = {dir = %s, spec_device = %s, type = %s, options = %s, device = %s}",
672 new->dir, new->spec_device, new->type, new->options, new->device);
674 /* Append to list */
675 if (first == NULL)
676 {
677 first = new;
678 last = new;
679 }
680 else
681 {
682 last->next = new;
683 last = new;
684 }
685 }
687 endmntent (fp);
689 DEBUG ("utils_mount: return (0x%p)", (void *) first);
691 return (first);
692 }
693 #endif /* HAVE_ONE_GETMNTENT */
695 /* *** *** *** ******************************************** *** *** *** */
696 /* *** *** *** *** *** *** public functions *** *** *** *** *** *** */
697 /* *** *** *** ******************************************** *** *** *** */
699 cu_mount_t *cu_mount_getlist(cu_mount_t **list)
700 {
701 cu_mount_t *new;
702 cu_mount_t *first = NULL;
703 cu_mount_t *last = NULL;
705 if (list == NULL)
706 return (NULL);
708 if (*list != NULL)
709 {
710 first = *list;
711 last = first;
712 while (last->next != NULL)
713 last = last->next;
714 }
716 #if HAVE_LISTMNTENT && 0
717 new = cu_mount_listmntent ();
718 #elif HAVE_GETVFSSTAT || HAVE_GETFSSTAT
719 new = cu_mount_getfsstat ();
720 #elif HAVE_TWO_GETMNTENT || HAVE_GEN_GETMNTENT || HAVE_SUN_GETMNTENT
721 new = cu_mount_gen_getmntent ();
722 #elif HAVE_SEQ_GETMNTENT
723 # error "This version of `getmntent' hat not yet been implemented!"
724 #elif HAVE_ONE_GETMNTENT
725 new = cu_mount_getmntent ();
726 #else
727 # error "Could not determine how to find mountpoints."
728 #endif
730 if (first != NULL)
731 {
732 last->next = new;
733 }
734 else
735 {
736 first = new;
737 last = new;
738 *list = first;
739 }
741 while ((last != NULL) && (last->next != NULL))
742 last = last->next;
744 return (last);
745 } /* cu_mount_t *cu_mount_getlist(cu_mount_t **list) */
747 void cu_mount_freelist (cu_mount_t *list)
748 {
749 cu_mount_t *this;
750 cu_mount_t *next;
752 for (this = list; this != NULL; this = next)
753 {
754 next = this->next;
756 sfree (this->dir);
757 sfree (this->spec_device);
758 sfree (this->device);
759 sfree (this->type);
760 sfree (this->options);
761 sfree (this);
762 }
763 } /* void cu_mount_freelist(cu_mount_t *list) */
765 char *
766 cu_mount_checkoption(char *line, const char *keyword, int full)
767 {
768 char *line2, *l2, *p1, *p2;
769 int l;
771 if(line == NULL || keyword == NULL) {
772 return NULL;
773 }
775 if(full != 0) {
776 full = 1;
777 }
779 line2 = sstrdup(line);
780 l2 = line2;
781 while(*l2 != '\0') {
782 if(*l2 == ',') {
783 *l2 = '\0';
784 }
785 l2++;
786 }
788 l = strlen(keyword);
789 p1 = line - 1;
790 p2 = strchr(line, ',');
791 do {
792 if(strncmp(line2+(p1-line)+1, keyword, l+full) == 0) {
793 free(line2);
794 return p1+1;
795 }
796 p1 = p2;
797 if(p1 != NULL) {
798 p2 = strchr(p1+1, ',');
799 }
800 } while(p1 != NULL);
802 free(line2);
803 return NULL;
804 } /* char *cu_mount_checkoption(char *line, char *keyword, int full) */
806 char *
807 cu_mount_getoptionvalue(char *line, const char *keyword)
808 {
809 char *r;
811 r = cu_mount_checkoption(line, keyword, 0);
812 if(r != NULL) {
813 char *p;
814 r += strlen(keyword);
815 p = strchr(r, ',');
816 if(p == NULL) {
817 return sstrdup(r);
818 } else {
819 char *m;
820 if((p-r) == 1) {
821 return NULL;
822 }
823 m = (char *)smalloc(p-r+1);
824 sstrncpy(m, r, p-r+1);
825 return m;
826 }
827 }
828 return r;
829 } /* char *cu_mount_getoptionvalue(char *line, const char *keyword) */
831 int
832 cu_mount_type(const char *type)
833 {
834 if(strcmp(type, "ext3") == 0) return CUMT_EXT3;
835 if(strcmp(type, "ext2") == 0) return CUMT_EXT2;
836 if(strcmp(type, "ufs") == 0) return CUMT_UFS;
837 if(strcmp(type, "vxfs") == 0) return CUMT_VXFS;
838 if(strcmp(type, "zfs") == 0) return CUMT_ZFS;
839 return CUMT_UNKNOWN;
840 } /* int cu_mount_type(const char *type) */