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