1 /*
2 * e2initrd_helper.c - Get the filesystem table
3 *
4 * Copyright 2004 by Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Public
8 * License.
9 * %End-Header%
10 */
11
12 #include "config.h"
13 #include <stdio.h>
14 #include <unistd.h>
15 #ifdef HAVE_STDLIB_H
16 #include <stdlib.h>
17 #endif
18 #include <ctype.h>
19 #include <string.h>
20 #include <time.h>
21 #ifdef HAVE_ERRNO_H
22 #include <errno.h>
23 #endif
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <fcntl.h>
27 #include <utime.h>
28 #ifdef HAVE_GETOPT_H
29 #include <getopt.h>
30 #else
31 extern int optind;
32 extern char *optarg;
33 #endif
34
35 #include "ext2fs/ext2_fs.h"
36 #include "ext2fs/ext2fs.h"
37 #include "blkid/blkid.h"
38 #include "support/nls-enable.h"
39
40 #include "../version.h"
41
42 static const char * program_name = "e2initrd_helper";
43 static char * device_name;
44 static int open_flag;
45 static int root_type;
46 static blkid_cache cache = NULL;
47
48 struct mem_file {
49 char *buf;
50 int size;
51 int ptr;
52 };
53
54 struct fs_info {
55 char *device;
56 char *mountpt;
57 char *type;
58 char *opts;
59 int freq;
60 int passno;
61 int flags;
62 struct fs_info *next;
63 };
64
usage(void)65 static void usage(void)
66 {
67 fprintf(stderr,
68 _("Usage: %s -r device\n"), program_name);
69 exit (1);
70 }
71
get_file(ext2_filsys fs,const char * filename,struct mem_file * ret_file)72 static errcode_t get_file(ext2_filsys fs, const char * filename,
73 struct mem_file *ret_file)
74 {
75 errcode_t retval;
76 char *buf;
77 ext2_file_t e2_file = NULL;
78 unsigned int got;
79 struct ext2_inode inode;
80 ext2_ino_t ino;
81
82 ret_file->buf = 0;
83 ret_file->size = 0;
84 ret_file->ptr = 0;
85
86 retval = ext2fs_namei(fs, EXT2_ROOT_INO, EXT2_ROOT_INO,
87 filename, &ino);
88 if (retval)
89 return retval;
90
91 retval = ext2fs_read_inode(fs, ino, &inode);
92 if (retval)
93 return retval;
94
95 if (inode.i_size_high || (inode.i_size > 65536))
96 return EFBIG;
97
98 buf = malloc(inode.i_size + 1);
99 if (!buf)
100 return ENOMEM;
101 memset(buf, 0, inode.i_size+1);
102
103 retval = ext2fs_file_open(fs, ino, 0, &e2_file);
104 if (retval)
105 goto errout;
106
107 retval = ext2fs_file_read(e2_file, buf, inode.i_size, &got);
108 if (retval)
109 goto errout;
110
111 retval = ext2fs_file_close(e2_file);
112 if (retval)
113 goto errout;
114
115 ret_file->buf = buf;
116 ret_file->size = (int) got;
117 return 0;
118
119 errout:
120 free(buf);
121 if (e2_file)
122 ext2fs_file_close(e2_file);
123 return retval;
124 }
125
get_line(struct mem_file * file)126 static char *get_line(struct mem_file *file)
127 {
128 char *cp, *ret;
129 int s = 0;
130
131 cp = file->buf + file->ptr;
132 while (*cp && *cp != '\n') {
133 cp++;
134 s++;
135 }
136 ret = malloc(s+1);
137 if (!ret)
138 return 0;
139 ret[s]=0;
140 memcpy(ret, file->buf + file->ptr, s);
141 while (*cp && (*cp == '\n' || *cp == '\r')) {
142 cp++;
143 s++;
144 }
145 file->ptr += s;
146 return ret;
147 }
148
mem_file_eof(struct mem_file * file)149 static int mem_file_eof(struct mem_file *file)
150 {
151 return (file->ptr >= file->size);
152 }
153
154 /*
155 * fstab parsing code
156 */
string_copy(const char * s)157 static char *string_copy(const char *s)
158 {
159 char *ret;
160
161 if (!s)
162 return 0;
163 ret = malloc(strlen(s)+1);
164 if (ret)
165 strcpy(ret, s);
166 return ret;
167 }
168
skip_over_blank(char * cp)169 static char *skip_over_blank(char *cp)
170 {
171 while (*cp && isspace(*cp))
172 cp++;
173 return cp;
174 }
175
skip_over_word(char * cp)176 static char *skip_over_word(char *cp)
177 {
178 while (*cp && !isspace(*cp))
179 cp++;
180 return cp;
181 }
182
parse_word(char ** buf)183 static char *parse_word(char **buf)
184 {
185 char *word, *next;
186
187 word = *buf;
188 if (*word == 0)
189 return 0;
190
191 word = skip_over_blank(word);
192 next = skip_over_word(word);
193 if (*next)
194 *next++ = 0;
195 *buf = next;
196 return word;
197 }
198
parse_escape(char * word)199 static void parse_escape(char *word)
200 {
201 char *p, *q;
202 int ac, i;
203
204 if (!word)
205 return;
206
207 for (p = word, q = word; *p; p++, q++) {
208 *q = *p;
209 if (*p != '\\')
210 continue;
211 if (*++p == 0)
212 break;
213 if (*p == 't') {
214 *q = '\t';
215 continue;
216 }
217 if (*p == 'n') {
218 *q = '\n';
219 continue;
220 }
221 if (!isdigit(*p)) {
222 *q = *p;
223 continue;
224 }
225 ac = 0;
226 for (i = 0; i < 3; i++, p++) {
227 if (!isdigit(*p))
228 break;
229 ac = (ac * 8) + (*p - '0');
230 }
231 *q = ac;
232 p--;
233 }
234 *q = 0;
235 }
236
parse_fstab_line(char * line,struct fs_info * fs)237 static int parse_fstab_line(char *line, struct fs_info *fs)
238 {
239 char *dev, *device, *mntpnt, *type, *opts, *freq, *passno, *cp;
240
241 if ((cp = strchr(line, '#')))
242 *cp = 0; /* Ignore everything after the comment char */
243 cp = line;
244
245 device = parse_word(&cp);
246 mntpnt = parse_word(&cp);
247 type = parse_word(&cp);
248 opts = parse_word(&cp);
249 freq = parse_word(&cp);
250 passno = parse_word(&cp);
251
252 if (!device)
253 return -1; /* Allow blank lines */
254
255 if (!mntpnt || !type)
256 return -1;
257
258 parse_escape(device);
259 parse_escape(mntpnt);
260 parse_escape(type);
261 parse_escape(opts);
262 parse_escape(freq);
263 parse_escape(passno);
264
265 dev = blkid_get_devname(cache, device, NULL);
266 if (dev)
267 device = dev;
268
269 if (strchr(type, ','))
270 type = 0;
271
272 fs->device = string_copy(device);
273 fs->mountpt = string_copy(mntpnt);
274 fs->type = string_copy(type);
275 fs->opts = string_copy(opts ? opts : "");
276 fs->freq = freq ? atoi(freq) : -1;
277 fs->passno = passno ? atoi(passno) : -1;
278 fs->flags = 0;
279 fs->next = NULL;
280
281 free(dev);
282
283 return 0;
284 }
285
free_fstab_line(struct fs_info * fs)286 static void free_fstab_line(struct fs_info *fs)
287 {
288 if (fs->device)
289 fs->device = 0;
290 if (fs->mountpt)
291 fs->mountpt = 0;
292 if (fs->type)
293 fs->type = 0;
294 if (fs->opts)
295 fs->opts = 0;
296 memset(fs, 0, sizeof(struct fs_info));
297 }
298
299
PRS(int argc,char ** argv)300 static void PRS(int argc, char **argv)
301 {
302 int c;
303
304 #ifdef ENABLE_NLS
305 setlocale(LC_MESSAGES, "");
306 setlocale(LC_CTYPE, "");
307 bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
308 textdomain(NLS_CAT_NAME);
309 set_com_err_gettext(gettext);
310 #endif
311
312 while ((c = getopt(argc, argv, "rv")) != EOF) {
313 switch (c) {
314 case 'r':
315 root_type++;
316 break;
317
318 case 'v':
319 printf("%s %s (%s)\n", program_name,
320 E2FSPROGS_VERSION, E2FSPROGS_DATE);
321 break;
322 default:
323 usage();
324 }
325 }
326 if (optind < argc - 1 || optind == argc)
327 usage();
328 device_name = blkid_get_devname(NULL, argv[optind], NULL);
329 if (!device_name) {
330 com_err(program_name, 0, _("Unable to resolve '%s'"),
331 argv[optind]);
332 exit(1);
333 }
334 }
335
get_root_type(ext2_filsys fs)336 static void get_root_type(ext2_filsys fs)
337 {
338 errcode_t retval;
339 struct mem_file file;
340 char *buf;
341 struct fs_info fs_info;
342 int ret;
343
344 retval = get_file(fs, "/etc/fstab", &file);
345 if (retval) {
346 com_err(program_name, retval, "couldn't open /etc/fstab");
347 exit(1);
348 }
349
350 while (!mem_file_eof(&file)) {
351 buf = get_line(&file);
352 if (!buf)
353 continue;
354
355 ret = parse_fstab_line(buf, &fs_info);
356 if (ret < 0)
357 goto next_line;
358
359 if (!strcmp(fs_info.mountpt, "/"))
360 printf("%s\n", fs_info.type);
361
362 free_fstab_line(&fs_info);
363
364 next_line:
365 free(buf);
366 }
367 }
368
369
main(int argc,char ** argv)370 int main (int argc, char ** argv)
371 {
372 errcode_t retval;
373 ext2_filsys fs;
374 io_manager io_ptr;
375
376 add_error_table(&et_ext2_error_table);
377
378 blkid_get_cache(&cache, NULL);
379 PRS(argc, argv);
380
381 #ifdef CONFIG_TESTIO_DEBUG
382 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
383 io_ptr = test_io_manager;
384 test_io_backing_manager = unix_io_manager;
385 } else
386 #endif
387 io_ptr = unix_io_manager;
388 retval = ext2fs_open (device_name, open_flag, 0, 0, io_ptr, &fs);
389 if (retval)
390 exit(1);
391
392 if (root_type)
393 get_root_type(fs);
394
395 remove_error_table(&et_ext2_error_table);
396 return (ext2fs_close (fs) ? 1 : 0);
397 }
398