misc/e2initrd_helper.c

   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
  65 static void usage(void)
  66 {
  67         fprintf(stderr,
  68                 _("Usage: %s -r device\n"), program_name);
  69         exit (1);
  70 }
  71
  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
 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
 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  */
 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
 169 static char *skip_over_blank(char *cp)
 170 {
 171         while (*cp && isspace(*cp))
 172                 cp++;
 173         return cp;
 174 }
 175
 176 static char *skip_over_word(char *cp)
 177 {
 178         while (*cp && !isspace(*cp))
 179                 cp++;
 180         return cp;
 181 }
 182
 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
 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
 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
 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
 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
 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
 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 }