]>
Commit | Line | Data |
---|---|---|
845dcb57 | 1 | /* Utilities for reading/writing fstab, mtab, etc. |
d614a753 | 2 | Copyright (C) 1995-2020 Free Software Foundation, Inc. |
df4ef2ab | 3 | This file is part of the GNU C Library. |
845dcb57 | 4 | |
df4ef2ab | 5 | The GNU C Library is free software; you can redistribute it and/or |
41bdb6e2 AJ |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
845dcb57 | 9 | |
df4ef2ab UD |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
41bdb6e2 | 13 | Lesser General Public License for more details. |
845dcb57 | 14 | |
41bdb6e2 | 15 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 | 16 | License along with the GNU C Library; if not, see |
5a82c748 | 17 | <https://www.gnu.org/licenses/>. */ |
845dcb57 | 18 | |
53308042 | 19 | #include <alloca.h> |
845dcb57 | 20 | #include <mntent.h> |
08b7e998 | 21 | #include <stdbool.h> |
845dcb57 | 22 | #include <stdio.h> |
2706ee38 | 23 | #include <stdio_ext.h> |
845dcb57 UD |
24 | #include <string.h> |
25 | #include <sys/types.h> | |
26 | ||
3ce1f295 UD |
27 | #define flockfile(s) _IO_flockfile (s) |
28 | #define funlockfile(s) _IO_funlockfile (s) | |
50304ef0 | 29 | |
6b87a564 UD |
30 | #undef __setmntent |
31 | #undef __endmntent | |
32 | #undef __getmntent_r | |
33 | ||
845dcb57 UD |
34 | /* Prepare to begin reading and/or writing mount table entries from the |
35 | beginning of FILE. MODE is as for `fopen'. */ | |
36 | FILE * | |
37 | __setmntent (const char *file, const char *mode) | |
38 | { | |
ee8449f7 | 39 | /* Extend the mode parameter with "c" to disable cancellation in the |
312be3f9 | 40 | I/O functions and "e" to set FD_CLOEXEC. */ |
ee8449f7 | 41 | size_t modelen = strlen (mode); |
312be3f9 UD |
42 | char newmode[modelen + 3]; |
43 | memcpy (mempcpy (newmode, mode, modelen), "ce", 3); | |
ee8449f7 | 44 | FILE *result = fopen (file, newmode); |
2706ee38 UD |
45 | |
46 | if (result != NULL) | |
47 | /* We do the locking ourselves. */ | |
b4c4f776 | 48 | __fsetlocking (result, FSETLOCKING_BYCALLER); |
2706ee38 UD |
49 | |
50 | return result; | |
845dcb57 | 51 | } |
30917259 | 52 | libc_hidden_def (__setmntent) |
845dcb57 UD |
53 | weak_alias (__setmntent, setmntent) |
54 | ||
55 | ||
56 | /* Close a stream opened with `setmntent'. */ | |
57 | int | |
58 | __endmntent (FILE *stream) | |
59 | { | |
60 | if (stream) /* SunOS 4.x allows for NULL stream */ | |
61 | fclose (stream); | |
62 | return 1; /* SunOS 4.x says to always return 1 */ | |
63 | } | |
30917259 | 64 | libc_hidden_def (__endmntent) |
845dcb57 UD |
65 | weak_alias (__endmntent, endmntent) |
66 | ||
67 | ||
b0b422e8 UD |
68 | /* Since the values in a line are separated by spaces, a name cannot |
69 | contain a space. Therefore some programs encode spaces in names | |
70 | by the strings "\040". We undo the encoding when reading an entry. | |
71 | The decoding happens in place. */ | |
72 | static char * | |
73 | decode_name (char *buf) | |
74 | { | |
75 | char *rp = buf; | |
76 | char *wp = buf; | |
77 | ||
78 | do | |
79 | if (rp[0] == '\\' && rp[1] == '0' && rp[2] == '4' && rp[3] == '0') | |
80 | { | |
81 | /* \040 is a SPACE. */ | |
82 | *wp++ = ' '; | |
83 | rp += 3; | |
84 | } | |
37369d1c | 85 | else if (rp[0] == '\\' && rp[1] == '0' && rp[2] == '1' && rp[3] == '1') |
b0b422e8 | 86 | { |
e796f92f | 87 | /* \011 is a TAB. */ |
b0b422e8 UD |
88 | *wp++ = '\t'; |
89 | rp += 3; | |
90 | } | |
37369d1c UD |
91 | else if (rp[0] == '\\' && rp[1] == '0' && rp[2] == '1' && rp[3] == '2') |
92 | { | |
93 | /* \012 is a NEWLINE. */ | |
94 | *wp++ = '\n'; | |
95 | rp += 3; | |
96 | } | |
b0b422e8 UD |
97 | else if (rp[0] == '\\' && rp[1] == '\\') |
98 | { | |
99 | /* We have to escape \\ to be able to represent all characters. */ | |
100 | *wp++ = '\\'; | |
101 | rp += 1; | |
102 | } | |
21800751 UD |
103 | else if (rp[0] == '\\' && rp[1] == '1' && rp[2] == '3' && rp[3] == '4') |
104 | { | |
105 | /* \134 is also \\. */ | |
106 | *wp++ = '\\'; | |
107 | rp += 3; | |
108 | } | |
b0b422e8 UD |
109 | else |
110 | *wp++ = *rp; | |
111 | while (*rp++ != '\0'); | |
112 | ||
113 | return buf; | |
114 | } | |
115 | ||
08b7e998 IK |
116 | static bool |
117 | get_mnt_entry (FILE *stream, struct mntent *mp, char *buffer, int bufsiz) | |
845dcb57 | 118 | { |
b0b422e8 | 119 | char *cp; |
845dcb57 UD |
120 | char *head; |
121 | ||
122 | do | |
123 | { | |
124 | char *end_ptr; | |
125 | ||
84e5e756 | 126 | if (__fgets_unlocked (buffer, bufsiz, stream) == NULL) |
08b7e998 | 127 | return false; |
845dcb57 UD |
128 | |
129 | end_ptr = strchr (buffer, '\n'); | |
130 | if (end_ptr != NULL) /* chop newline */ | |
fb87ee96 | 131 | { |
b0e805fa MF |
132 | /* Do not walk past the start of buffer if it's all whitespace. */ |
133 | while (end_ptr != buffer | |
134 | && (end_ptr[-1] == ' ' || end_ptr[-1] == '\t')) | |
fb87ee96 VN |
135 | end_ptr--; |
136 | *end_ptr = '\0'; | |
137 | } | |
845dcb57 UD |
138 | else |
139 | { | |
140 | /* Not the whole line was read. Do it now but forget it. */ | |
141 | char tmp[1024]; | |
84e5e756 | 142 | while (__fgets_unlocked (tmp, sizeof tmp, stream) != NULL) |
845dcb57 UD |
143 | if (strchr (tmp, '\n') != NULL) |
144 | break; | |
145 | } | |
146 | ||
147 | head = buffer + strspn (buffer, " \t"); | |
148 | /* skip empty lines and comment lines: */ | |
b0b422e8 UD |
149 | } |
150 | while (head[0] == '\0' || head[0] == '#'); | |
845dcb57 | 151 | |
b0b422e8 UD |
152 | cp = __strsep (&head, " \t"); |
153 | mp->mnt_fsname = cp != NULL ? decode_name (cp) : (char *) ""; | |
845dcb57 UD |
154 | if (head) |
155 | head += strspn (head, " \t"); | |
b0b422e8 UD |
156 | cp = __strsep (&head, " \t"); |
157 | mp->mnt_dir = cp != NULL ? decode_name (cp) : (char *) ""; | |
845dcb57 UD |
158 | if (head) |
159 | head += strspn (head, " \t"); | |
b0b422e8 UD |
160 | cp = __strsep (&head, " \t"); |
161 | mp->mnt_type = cp != NULL ? decode_name (cp) : (char *) ""; | |
845dcb57 UD |
162 | if (head) |
163 | head += strspn (head, " \t"); | |
b0b422e8 UD |
164 | cp = __strsep (&head, " \t"); |
165 | mp->mnt_opts = cp != NULL ? decode_name (cp) : (char *) ""; | |
845dcb57 UD |
166 | switch (head ? sscanf (head, " %d %d ", &mp->mnt_freq, &mp->mnt_passno) : 0) |
167 | { | |
168 | case 0: | |
169 | mp->mnt_freq = 0; | |
32db86d5 | 170 | /* Fall through. */ |
845dcb57 UD |
171 | case 1: |
172 | mp->mnt_passno = 0; | |
32db86d5 | 173 | /* Fall through. */ |
845dcb57 | 174 | case 2: |
49f3a758 | 175 | break; |
845dcb57 | 176 | } |
08b7e998 IK |
177 | |
178 | return true; | |
179 | } | |
180 | ||
181 | /* Read one mount table entry from STREAM. Returns a pointer to storage | |
182 | reused on the next call, or null for EOF or error (use feof/ferror to | |
183 | check). */ | |
184 | struct mntent * | |
185 | __getmntent_r (FILE *stream, struct mntent *mp, char *buffer, int bufsiz) | |
186 | { | |
187 | struct mntent *result; | |
188 | ||
189 | flockfile (stream); | |
190 | while (true) | |
191 | if (get_mnt_entry (stream, mp, buffer, bufsiz)) | |
192 | { | |
193 | /* If the file system is autofs look for a mount option hint | |
194 | ("ignore") to skip the entry. */ | |
195 | if (strcmp (mp->mnt_type, "autofs") == 0 && __hasmntopt (mp, "ignore")) | |
196 | memset (mp, 0, sizeof (*mp)); | |
197 | else | |
198 | { | |
199 | result = mp; | |
200 | break; | |
201 | } | |
202 | } | |
203 | else | |
204 | { | |
205 | result = NULL; | |
206 | break; | |
207 | } | |
71412a8c | 208 | funlockfile (stream); |
845dcb57 | 209 | |
08b7e998 | 210 | return result; |
845dcb57 | 211 | } |
30917259 | 212 | libc_hidden_def (__getmntent_r) |
845dcb57 UD |
213 | weak_alias (__getmntent_r, getmntent_r) |
214 | ||
9798906a SP |
215 | /* Write STR into STREAM, escaping whitespaces as we go. Do not check for |
216 | errors here; we check the stream status in __ADDMNTENT. */ | |
217 | static void | |
218 | write_string (FILE *stream, const char *str) | |
219 | { | |
220 | char c; | |
221 | const char *encode_chars = " \t\n\\"; | |
b0b422e8 | 222 | |
9798906a SP |
223 | while ((c = *str++) != '\0') |
224 | { | |
225 | if (strchr (encode_chars, c) == NULL) | |
226 | fputc_unlocked (c, stream); | |
227 | else | |
228 | { | |
229 | fputc_unlocked ('\\', stream); | |
230 | fputc_unlocked (((c & 0xc0) >> 6) + '0', stream); | |
231 | fputc_unlocked (((c & 0x38) >> 3) + '0', stream); | |
232 | fputc_unlocked (((c & 0x07) >> 0) + '0', stream); | |
233 | } | |
234 | } | |
235 | fputc_unlocked (' ', stream); | |
236 | } | |
b0b422e8 | 237 | |
845dcb57 UD |
238 | /* Write the mount table entry described by MNT to STREAM. |
239 | Return zero on success, nonzero on failure. */ | |
240 | int | |
241 | __addmntent (FILE *stream, const struct mntent *mnt) | |
242 | { | |
9798906a SP |
243 | int ret = 1; |
244 | ||
845dcb57 | 245 | if (fseek (stream, 0, SEEK_END)) |
9798906a SP |
246 | return ret; |
247 | ||
248 | flockfile (stream); | |
249 | ||
250 | write_string (stream, mnt->mnt_fsname); | |
251 | write_string (stream, mnt->mnt_dir); | |
252 | write_string (stream, mnt->mnt_type); | |
253 | write_string (stream, mnt->mnt_opts); | |
254 | fprintf (stream, "%d %d\n", mnt->mnt_freq, mnt->mnt_passno); | |
255 | ||
256 | ret = ferror (stream) != 0 || fflush (stream) != 0; | |
257 | ||
258 | funlockfile (stream); | |
259 | ||
260 | return ret; | |
845dcb57 UD |
261 | } |
262 | weak_alias (__addmntent, addmntent) | |
263 | ||
264 | ||
265 | /* Search MNT->mnt_opts for an option matching OPT. | |
266 | Returns the address of the substring, or null if none found. */ | |
267 | char * | |
268 | __hasmntopt (const struct mntent *mnt, const char *opt) | |
269 | { | |
270 | const size_t optlen = strlen (opt); | |
271 | char *rest = mnt->mnt_opts, *p; | |
272 | ||
273 | while ((p = strstr (rest, opt)) != NULL) | |
274 | { | |
66f17705 UD |
275 | if ((p == rest || p[-1] == ',') |
276 | && (p[optlen] == '\0' || p[optlen] == '=' || p[optlen] == ',')) | |
845dcb57 UD |
277 | return p; |
278 | ||
66f17705 | 279 | rest = strchr (p, ','); |
df4ef2ab UD |
280 | if (rest == NULL) |
281 | break; | |
282 | ++rest; | |
845dcb57 UD |
283 | } |
284 | ||
285 | return NULL; | |
286 | } | |
d1903329 | 287 | libc_hidden_def (__hasmntopt) |
845dcb57 | 288 | weak_alias (__hasmntopt, hasmntopt) |