xref: /titanic_41/usr/src/lib/libfsmgt/common/fs_mount_defaults.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * Traverses /etc/vfstab in order to find default mount information about
31  * file systems on the current host.
32  */
33 #include <errno.h>
34 #include <stdlib.h>
35 #include <stdio.h>
36 #include <sys/vfstab.h>
37 #include <sys/types.h>
38 #include <strings.h>
39 #include <thread.h>
40 #include <synch.h>
41 #include "libfsmgt.h"
42 
43 /*
44  * Private constants
45  */
46 
47 static const char sepstr[] = "\t\n";
48 
49 /*
50  * Private variables
51  */
52 static mutex_t		vfstab_lock = DEFAULTMUTEX;
53 
54 
55 /*
56  * Private method declarations
57  */
58 static int cmp_fields(char *, char *, int);
59 static fs_mntdefaults_t	*create_mntdefaults_entry(struct vfstab vfstab_entry,
60 					    int *errp);
61 static struct vfstab	*create_vfstab_filter(fs_mntdefaults_t *filter,
62 					    int *errp);
63 static void		free_vfstab_entry(struct vfstab *vfstab_entry);
64 static char		*create_vfstab_entry_line(struct vfstab *, int *);
65 static int		vfstab_line_cmp(fs_mntdefaults_t *, struct vfstab *);
66 
67 /*
68  * Public methods
69  */
70 
fs_free_mntdefaults_list(fs_mntdefaults_t * headp)71 void fs_free_mntdefaults_list(fs_mntdefaults_t *headp) {
72 	fs_mntdefaults_t	*tmp;
73 
74 	while (headp != NULL) {
75 		tmp = headp->next;
76 		free(headp->resource);
77 		free(headp->fsckdevice);
78 		free(headp->mountp);
79 		free(headp->fstype);
80 		free(headp->fsckpass);
81 		free(headp->mountatboot);
82 		free(headp->mntopts);
83 		headp->next = NULL;
84 		free(headp);
85 
86 		headp = tmp;
87 	}
88 } /* fs_free_mntdefaults_list */
89 
90 /*
91  * Filter by the fields that are filled in on the filter parameter.
92  * Fields that aren't used in filtering the defaults will be NULL.
93  */
fs_get_filtered_mount_defaults(fs_mntdefaults_t * filter,int * errp)94 fs_mntdefaults_t *fs_get_filtered_mount_defaults(fs_mntdefaults_t *filter,
95     int *errp) {
96 
97 	fs_mntdefaults_t	*newp;
98 	fs_mntdefaults_t	*headp;
99 	fs_mntdefaults_t	*tailp;
100 	FILE			*fp;
101 
102 	headp = NULL;
103 	tailp = NULL;
104 
105 
106 	if ((fp = fopen(VFSTAB, "r")) != NULL) {
107 		struct vfstab	vfstab_entry;
108 		struct vfstab	*search_entry;
109 		(void) mutex_lock(&vfstab_lock);
110 		search_entry = create_vfstab_filter(filter, errp);
111 		if (search_entry == NULL) {
112 			/*
113 			 * Out of memory, the error pointer (errp) gets
114 			 * set in create_vfstab_filter.
115 			 */
116 			fs_free_mntdefaults_list(headp);
117 			(void) mutex_unlock(&vfstab_lock);
118 			(void) fclose(fp);
119 			return (NULL);
120 		}
121 
122 		while (getvfsany(fp, &vfstab_entry, search_entry) == 0) {
123 			/*
124 			 * Add to list to be returned
125 			 */
126 			newp = create_mntdefaults_entry(vfstab_entry, errp);
127 			if (newp == NULL) {
128 				/*
129 				 * Out of memory, the error pointer (errp)
130 				 * gets set in create_mntdefaults_entry.
131 				 */
132 				fs_free_mntdefaults_list(headp);
133 				(void) mutex_unlock(&vfstab_lock);
134 				(void) fclose(fp);
135 				return (NULL);
136 			}
137 
138 			if (headp == NULL) {
139 				headp = newp;
140 				tailp = newp;
141 			} else {
142 				tailp->next = newp;
143 				tailp = newp;
144 			}
145 		}
146 		free_vfstab_entry(search_entry);
147 		(void) mutex_unlock(&vfstab_lock);
148 		(void) fclose(fp);
149 
150 	} else {
151 		*errp = errno;
152 	} /* if ((fp = fopen(VFSTAB, "r")) != NULL) */
153 
154 	return (headp);
155 } /* fs_get_filtered_mount_defaults */
156 
157 
158 fs_mntdefaults_t *
fs_get_mount_defaults(int * errp)159 fs_get_mount_defaults(int *errp)
160 {
161 	fs_mntdefaults_t	*newp;
162 	fs_mntdefaults_t	*headp;
163 	fs_mntdefaults_t	*tailp;
164 	FILE			*fp;
165 
166 	headp = NULL;
167 	tailp = NULL;
168 
169 	if ((fp = fopen(VFSTAB, "r")) != NULL) {
170 		struct vfstab 	vfstab_entry;
171 		(void) mutex_lock(&vfstab_lock);
172 		while (getvfsent(fp, &vfstab_entry) == 0) {
173 			/*
174 			 * Add entry to list
175 			 */
176 			newp = create_mntdefaults_entry(vfstab_entry, errp);
177 
178 			if (newp == NULL) {
179 				/*
180 				 * Out of memory, the error pointer (errp)
181 				 * gets set in create_mntdefaults_entry.
182 				 */
183 				(void) fclose(fp);
184 				(void) mutex_unlock(&vfstab_lock);
185 				fs_free_mntdefaults_list(headp);
186 				return (NULL);
187 			}
188 
189 			if (headp == NULL) {
190 				headp = newp;
191 				tailp = newp;
192 			} else {
193 				tailp->next = newp;
194 				tailp = newp;
195 			}
196 		}
197 		(void) fclose(fp);
198 		(void) mutex_unlock(&vfstab_lock);
199 	} else {
200 		*errp = errno;
201 	} /* if ((fp = fopen(VFSTAB, "r")) != NULL) */
202 
203 	/*
204 	 * Caller must free the returned list
205 	 */
206 	return (headp);
207 
208 } /* fs_get_mount_defaults */
209 
210 fs_mntdefaults_t *
fs_add_mount_default(fs_mntdefaults_t * newp,int * errp)211 fs_add_mount_default(fs_mntdefaults_t *newp, int *errp) {
212 
213 	FILE *fp;
214 	struct vfstab *new_entry;
215 	fs_mntdefaults_t *ret_val;
216 
217 	new_entry = create_vfstab_filter(newp, errp);
218 	if (new_entry != NULL) {
219 		if ((fp = fopen(VFSTAB, "a")) != NULL) {
220 			(void) mutex_lock(&vfstab_lock);
221 			putvfsent(fp, new_entry);
222 			free_vfstab_entry(new_entry);
223 			(void) fclose(fp);
224 			(void) mutex_unlock(&vfstab_lock);
225 			ret_val = fs_get_mount_defaults(errp);
226 		} else {
227 			*errp = errno;
228 			free_vfstab_entry(new_entry);
229 			ret_val = NULL;
230 		}
231 	} else {
232 		ret_val = NULL;
233 	}
234 	return (ret_val);
235 } /* fs_add_mount_default */
236 
237 
238 fs_mntdefaults_t *
fs_edit_mount_defaults(fs_mntdefaults_t * old_vfstab_ent,fs_mntdefaults_t * new_vfstab_ent,int * errp)239 fs_edit_mount_defaults(
240     fs_mntdefaults_t *old_vfstab_ent,
241     fs_mntdefaults_t *new_vfstab_ent,
242     int *errp)
243 {
244 	FILE *fp;
245 	fs_mntdefaults_t *ret_val;
246 	char vfstab_line[VFS_LINE_MAX];
247 	char **temp_vfstab = NULL;
248 	char *new_line;
249 	struct vfstab vfstabp, *new_vfstab;
250 	int line_found = 0;
251 
252 	if ((fp = fopen(VFSTAB, "r")) != NULL) {
253 		char *tmp;
254 		int count = 0;
255 		(void) mutex_lock(&vfstab_lock);
256 		while (fgets(vfstab_line, VFS_LINE_MAX, fp) != NULL) {
257 			char *charp;
258 			struct vfstab *vp;
259 			char *orig_line = strdup(vfstab_line);
260 			if (orig_line == NULL) {
261 				*errp = ENOMEM;
262 				(void) fclose(fp);
263 				(void) mutex_unlock(&vfstab_lock);
264 				return (NULL);
265 			}
266 			vp = &vfstabp;
267 			for (charp = vfstab_line;
268 			    *charp == ' ' || *charp == '\t'; charp++);
269 			if (*charp == '#' || *charp == '\n') {
270 				/*
271 				 * Write comments out to temp vfstab
272 				 * image
273 				 */
274 				if (!fileutil_add_string_to_array(
275 				    &temp_vfstab, vfstab_line, &count, errp)) {
276 				    ret_val = NULL;
277 				    line_found = 0;
278 					break;
279 				}
280 				continue;
281 			}
282 			vp->vfs_special = (char *)strtok_r(
283 			    vfstab_line, sepstr, &tmp);
284 			vp->vfs_fsckdev = (char *)strtok_r(
285 			    NULL, sepstr, &tmp);
286 			vp->vfs_mountp = (char *)strtok_r(
287 			    NULL, sepstr, &tmp);
288 			vp->vfs_fstype = (char *)strtok_r(
289 			    NULL, sepstr, &tmp);
290 			vp->vfs_fsckpass = (char *)strtok_r(
291 			    NULL, sepstr, &tmp);
292 			vp->vfs_automnt = (char *)strtok_r(
293 			    NULL, sepstr, &tmp);
294 			vp->vfs_mntopts = (char *)strtok_r(
295 			    NULL, sepstr, &tmp);
296 			if (strtok_r(NULL, sepstr, &tmp) != NULL) {
297 				/*
298 				 * Invalid vfstab line.
299 				 */
300 				*errp = EINVAL;
301 				(void) mutex_unlock(&vfstab_lock);
302 				(void) fclose(fp);
303 				return (NULL);
304 			}
305 
306 			if (vfstab_line_cmp(old_vfstab_ent, vp)) {
307 				line_found = 1;
308 				new_vfstab =
309 				    create_vfstab_filter(
310 				    new_vfstab_ent, errp);
311 				new_line =
312 				    create_vfstab_entry_line(new_vfstab, errp);
313 				if (!fileutil_add_string_to_array(
314 				    &temp_vfstab, new_line, &count, errp)) {
315 					ret_val = NULL;
316 					line_found = 0;
317 					free(new_line);
318 					break;
319 				}
320 				free(new_line);
321 			} else {
322 				if (!fileutil_add_string_to_array(
323 				    &temp_vfstab, orig_line, &count, errp)) {
324 					ret_val = NULL;
325 					line_found = 0;
326 					break;
327 				}
328 			}
329 			free(orig_line);
330 		}
331 		(void) fclose(fp);
332 
333 		if (line_found && temp_vfstab != NULL) {
334 			if ((fp = fopen(VFSTAB, "w")) != NULL) {
335 				int i;
336 				for (i = 0; i < count; i++) {
337 					fprintf(fp, "%s", temp_vfstab[i]);
338 				}
339 				(void) fclose(fp);
340 				(void) mutex_unlock(&vfstab_lock);
341 				ret_val = fs_get_mount_defaults(errp);
342 				fileutil_free_string_array(temp_vfstab, count);
343 			} else {
344 				*errp = errno;
345 				(void) mutex_unlock(&vfstab_lock);
346 				ret_val = NULL;
347 			}
348 		} else {
349 			*errp = errno;
350 			(void) mutex_unlock(&vfstab_lock);
351 			ret_val = NULL;
352 		}
353 	} else {
354 		*errp = errno;
355 		ret_val = NULL;
356 	}
357 	return (ret_val);
358 } /* fs_edit_mount_defaults */
359 
360 fs_mntdefaults_t *
fs_del_mount_default_ent(fs_mntdefaults_t * old_vfstab_ent,int * errp)361 fs_del_mount_default_ent(fs_mntdefaults_t *old_vfstab_ent, int *errp)
362 {
363 	FILE *fp;
364 	fs_mntdefaults_t *ret_val;
365 	char vfstab_line[VFS_LINE_MAX];
366 	struct vfstab vfstabp;
367 	int line_found = 0;
368 
369 	if ((fp = fopen(VFSTAB, "r")) != NULL) {
370 		struct vfstab *vp;
371 		char *tmp;
372 		char *charp;
373 		char *orig_line = NULL;
374 		char **temp_vfstab = NULL;
375 		int count = 0;
376 		vp = &vfstabp;
377 		(void) mutex_lock(&vfstab_lock);
378 		while (fgets(vfstab_line, VFS_LINE_MAX, fp) != NULL) {
379 
380 			orig_line = strdup(vfstab_line);
381 			if (orig_line == NULL) {
382 				*errp = ENOMEM;
383 				(void) fclose(fp);
384 				(void) mutex_unlock(&vfstab_lock);
385 				return (NULL);
386 			}
387 
388 			for (charp = vfstab_line;
389 			    *charp == ' ' || *charp == '\t'; charp++);
390 
391 			if (*charp == '#' || *charp == '\n') {
392 				/*
393 				 * Write comments out to temp vfstab
394 				 * image
395 				 */
396 				if (!fileutil_add_string_to_array(
397 				    &temp_vfstab, vfstab_line, &count, errp)) {
398 					ret_val = NULL;
399 					line_found = 0;
400 					free(orig_line);
401 					break;
402 				}
403 				continue;
404 			}
405 
406 			vp->vfs_special = (char *)strtok_r(
407 			    vfstab_line, sepstr, &tmp);
408 			vp->vfs_fsckdev = (char *)strtok_r(
409 			    NULL, sepstr, &tmp);
410 			vp->vfs_mountp = (char *)strtok_r(
411 			    NULL, sepstr, &tmp);
412 			vp->vfs_fstype = (char *)strtok_r(
413 			    NULL, sepstr, &tmp);
414 			vp->vfs_fsckpass = (char *)strtok_r(
415 			    NULL, sepstr, &tmp);
416 			vp->vfs_automnt = (char *)strtok_r(
417 			    NULL, sepstr, &tmp);
418 			vp->vfs_mntopts = (char *)strtok_r(
419 			    NULL, sepstr, &tmp);
420 
421 			if (strtok_r(NULL, sepstr, &tmp) != NULL) {
422 				/*
423 				 * Invalid vfstab line.
424 				 */
425 				*errp = EINVAL;
426 				free(orig_line);
427 				(void) fclose(fp);
428 				(void) mutex_unlock(&vfstab_lock);
429 				return (NULL);
430 			}
431 
432 			if (vfstab_line_cmp(old_vfstab_ent, vp)) {
433 				line_found = 1;
434 			} else {
435 				if (!fileutil_add_string_to_array(
436 				    &temp_vfstab, orig_line, &count, errp)) {
437 					ret_val = NULL;
438 					line_found = 0;
439 					free(orig_line);
440 					break;
441 				}
442 			}
443 			free(orig_line);
444 		}
445 
446 		(void) fclose(fp);
447 
448 		if (line_found && temp_vfstab != NULL) {
449 			if ((fp = fopen(VFSTAB, "w")) != NULL) {
450 				int i;
451 				for (i = 0; i < count; i++) {
452 					fprintf(fp, "%s", temp_vfstab[i]);
453 				}
454 				(void) fclose(fp);
455 				(void) mutex_unlock(&vfstab_lock);
456 				ret_val = fs_get_mount_defaults(errp);
457 				fileutil_free_string_array(temp_vfstab, count);
458 			} else {
459 				*errp = errno;
460 				(void) mutex_unlock(&vfstab_lock);
461 				fileutil_free_string_array(temp_vfstab, count);
462 				ret_val = NULL;
463 			}
464 		} else {
465 			(void) mutex_unlock(&vfstab_lock);
466 			if (temp_vfstab != NULL) {
467 				fileutil_free_string_array(temp_vfstab, count);
468 			}
469 			ret_val = NULL;
470 		}
471 	} else {
472 		*errp = errno;
473 		ret_val = NULL;
474 	}
475 	return (ret_val);
476 }
477 
478 /*
479  * Private methods
480  */
481 
482 static fs_mntdefaults_t *
create_mntdefaults_entry(struct vfstab vfstab_entry,int * errp)483 create_mntdefaults_entry(struct vfstab vfstab_entry, int *errp) {
484 	fs_mntdefaults_t	*newp;
485 
486 	newp = (fs_mntdefaults_t *)calloc((size_t)1,
487 	    (size_t)sizeof (fs_mntdefaults_t));
488 
489 	if (newp == NULL) {
490 		/*
491 		 * Out of memory
492 		 */
493 		*errp = errno;
494 		return (NULL);
495 	}
496 
497 
498 	if (vfstab_entry.vfs_special != NULL) {
499 		newp->resource = strdup(vfstab_entry.vfs_special);
500 		if (newp->resource == NULL) {
501 			/*
502 			 * Out of memory
503 			 */
504 			*errp = errno;
505 			fs_free_mntdefaults_list(newp);
506 			return (NULL);
507 		}
508 	}
509 
510 
511 	if (vfstab_entry.vfs_fsckdev != NULL) {
512 		newp->fsckdevice = strdup(vfstab_entry.vfs_fsckdev);
513 		if (newp->fsckdevice == NULL) {
514 			/*
515 			 * Out of memory
516 			 */
517 			*errp = errno;
518 			fs_free_mntdefaults_list(newp);
519 			return (NULL);
520 		}
521 	}
522 
523 	if (vfstab_entry.vfs_mountp != NULL) {
524 		newp->mountp = strdup(vfstab_entry.vfs_mountp);
525 		if (newp->mountp == NULL) {
526 			/*
527 			 * Out of memory
528 			 */
529 			*errp = errno;
530 			fs_free_mntdefaults_list(newp);
531 			return (NULL);
532 		}
533 	}
534 
535 	if (vfstab_entry.vfs_fstype != NULL) {
536 		newp->fstype = strdup(vfstab_entry.vfs_fstype);
537 		if (newp->fstype == NULL) {
538 			/*
539 			 * Out of memory
540 			 */
541 			*errp = errno;
542 			fs_free_mntdefaults_list(newp);
543 			return (NULL);
544 		}
545 	}
546 
547 	if (vfstab_entry.vfs_fsckpass != NULL) {
548 		newp->fsckpass = strdup(vfstab_entry.vfs_fsckpass);
549 		if (newp->fsckpass == NULL) {
550 			/*
551 			 * Out of memory
552 			 */
553 			*errp = errno;
554 			fs_free_mntdefaults_list(newp);
555 			return (NULL);
556 		}
557 	}
558 
559 	if (vfstab_entry.vfs_automnt != NULL) {
560 		newp->mountatboot = strdup(vfstab_entry.vfs_automnt);
561 		if (newp->mountatboot == NULL) {
562 			/*
563 			 * Out of memory
564 			 */
565 			*errp = errno;
566 			fs_free_mntdefaults_list(newp);
567 			return (NULL);
568 		}
569 	}
570 
571 	if (vfstab_entry.vfs_mntopts != NULL) {
572 		newp->mntopts = strdup(vfstab_entry.vfs_mntopts);
573 		if (newp->mntopts == NULL) {
574 			/*
575 			 * Out of memory
576 			 */
577 			*errp = errno;
578 			fs_free_mntdefaults_list(newp);
579 			return (NULL);
580 		}
581 	}
582 	newp->next = NULL;
583 
584 	return (newp);
585 
586 } /* create_mntdefaults_entry */
587 
588 static struct vfstab *
create_vfstab_filter(fs_mntdefaults_t * filter,int * errp)589 create_vfstab_filter(fs_mntdefaults_t *filter, int *errp) {
590 	struct vfstab *search_entry;
591 
592 	search_entry = (struct vfstab *)calloc((size_t)1,
593 	    (size_t)sizeof (struct vfstab));
594 	if (search_entry == NULL) {
595 		/*
596 		 * Out of memory
597 		 */
598 		*errp = errno;
599 		return (NULL);
600 	}
601 
602 	/*
603 	 * Populate the filter criteria
604 	 */
605 	if (filter->resource != NULL) {
606 		search_entry->vfs_special = strdup(filter->resource);
607 		if (search_entry->vfs_special == NULL) {
608 			/*
609 			 * Out of memory
610 			 */
611 			*errp = errno;
612 			free_vfstab_entry(search_entry);
613 			return (NULL);
614 		}
615 
616 	}
617 
618 	if (filter->fsckdevice != NULL) {
619 		search_entry->vfs_fsckdev = strdup(filter->fsckdevice);
620 		if (search_entry->vfs_fsckdev ==  NULL) {
621 			/*
622 			 * Out of memory
623 			 */
624 			*errp = errno;
625 			free_vfstab_entry(search_entry);
626 			return (NULL);
627 		}
628 	}
629 
630 	if (filter->mountp != NULL) {
631 		search_entry->vfs_mountp = strdup(filter->mountp);
632 		if (search_entry->vfs_mountp == NULL) {
633 			/*
634 			 * Out of memory
635 			 */
636 			*errp = errno;
637 			free_vfstab_entry(search_entry);
638 			return (NULL);
639 		}
640 	}
641 
642 	if (filter->fstype != NULL) {
643 		search_entry->vfs_fstype = strdup(filter->fstype);
644 		if (search_entry->vfs_fstype == NULL) {
645 			/*
646 			 * Out of memory
647 			 */
648 			*errp = errno;
649 			free_vfstab_entry(search_entry);
650 			return (NULL);
651 		}
652 	}
653 
654 	if (filter->fsckpass != NULL) {
655 		search_entry->vfs_fsckpass = strdup(filter->fsckpass);
656 		if (search_entry->vfs_fsckpass == NULL) {
657 			/*
658 			 * Out of memory
659 			 */
660 			*errp = errno;
661 			free_vfstab_entry(search_entry);
662 			return (NULL);
663 		}
664 	}
665 
666 	if (filter->mountatboot != NULL) {
667 		search_entry->vfs_automnt = strdup(filter->mountatboot);
668 		if (search_entry->vfs_automnt == NULL) {
669 			/*
670 			 * Out of memory
671 			 */
672 			*errp = errno;
673 			free_vfstab_entry(search_entry);
674 			return (NULL);
675 		}
676 	}
677 
678 	if (filter->mntopts != NULL) {
679 		search_entry->vfs_mntopts = strdup(filter->mntopts);
680 		if (search_entry->vfs_mntopts == NULL) {
681 			/*
682 			 * Out of memory
683 			 */
684 			*errp = errno;
685 			free_vfstab_entry(search_entry);
686 			return (NULL);
687 		}
688 	}
689 
690 	return (search_entry);
691 } /* create_vfstab_filter */
692 
free_vfstab_entry(struct vfstab * vfstab_entry)693 static void free_vfstab_entry(struct vfstab *vfstab_entry) {
694 
695 	free(vfstab_entry->vfs_special);
696 	free(vfstab_entry->vfs_fsckdev);
697 	free(vfstab_entry->vfs_mountp);
698 	free(vfstab_entry->vfs_fstype);
699 	free(vfstab_entry->vfs_fsckpass);
700 	free(vfstab_entry->vfs_automnt);
701 	free(vfstab_entry->vfs_mntopts);
702 
703 	free(vfstab_entry);
704 } /* free_vfstab_entry */
705 
706 static int
vfstab_line_cmp(fs_mntdefaults_t * mntdftp,struct vfstab * vp)707 vfstab_line_cmp(fs_mntdefaults_t *mntdftp, struct vfstab *vp) {
708 
709 	int ret_val = 1;
710 
711 	ret_val = cmp_fields(mntdftp->resource, vp->vfs_special, ret_val);
712 	ret_val = cmp_fields(mntdftp->mountp, vp->vfs_mountp, ret_val);
713 
714 	return (ret_val);
715 } /* vfstab_line_cmp */
716 
717 /*
718  * Helper function for comparing fields in a fs_mntdefaults_t to a
719  * vfstab structure. Used in vfstab_line_cmp().
720  */
721 static int
cmp_fields(char * mntdflt_str,char * vfstab_str,int ret_val)722 cmp_fields(char *mntdflt_str, char *vfstab_str, int ret_val) {
723 	if (ret_val != 0) {
724 		if (mntdflt_str != NULL && vfstab_str != NULL) {
725 			if (strcmp(mntdflt_str, vfstab_str) != 0) {
726 				ret_val = 0;
727 			}
728 		} else if (mntdflt_str == NULL || vfstab_str == NULL) {
729 			ret_val = 0;
730 		}
731 	}
732 	return (ret_val);
733 } /* cmp_fields */
734 
735 /*
736  * Helper fuction used by del_vfstab_ent() and edit_vfstab_ent() to
737  * create a vfstab line for writing out to the vfstab file.
738  */
739 char *
create_vfstab_entry_line(struct vfstab * vfstab_ent,int * errp)740 create_vfstab_entry_line(struct vfstab *vfstab_ent, int *errp) {
741 	char *line;
742 	int line_length;
743 	line_length = (
744 	    (vfstab_ent->vfs_special ?
745 		(strlen(vfstab_ent->vfs_special) +1) : 2) +
746 	    (vfstab_ent->vfs_fsckdev ?
747 		(strlen(vfstab_ent->vfs_fsckdev) +1) : 2) +
748 	    (vfstab_ent->vfs_mountp ?
749 		(strlen(vfstab_ent->vfs_mountp) +1) : 2) +
750 	    (vfstab_ent->vfs_fstype ?
751 		(strlen(vfstab_ent->vfs_fstype) +1) : 2) +
752 	    (vfstab_ent->vfs_fsckpass ?
753 		(strlen(vfstab_ent->vfs_fsckpass) +1) : 2) +
754 	    (vfstab_ent->vfs_automnt ?
755 		(strlen(vfstab_ent->vfs_automnt) +1) : 2) +
756 	    (vfstab_ent->vfs_mntopts ?
757 		(strlen(vfstab_ent->vfs_mntopts) +1) : 2));
758 	line = (char *)malloc(line_length + 1);
759 	if (line != NULL) {
760 		sprintf(line, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
761 		    vfstab_ent->vfs_special ? vfstab_ent->vfs_special : "-",
762 		    vfstab_ent->vfs_fsckdev ? vfstab_ent->vfs_fsckdev : "-",
763 		    vfstab_ent->vfs_mountp ? vfstab_ent->vfs_mountp : "-",
764 		    vfstab_ent->vfs_fstype ? vfstab_ent->vfs_fstype : "-",
765 		    vfstab_ent->vfs_fsckpass ? vfstab_ent->vfs_fsckpass : "-",
766 		    vfstab_ent->vfs_automnt ? vfstab_ent->vfs_automnt : "-",
767 		    vfstab_ent->vfs_mntopts ? vfstab_ent->vfs_mntopts : "-");
768 	} else {
769 		*errp = errno;
770 	}
771 	return (line);
772 } /* create_vfstab_entry_line */
773