Line data    Source code

       1             : #include <stdio.h>
       2             : #include <stdlib.h>
       3             : #include <libgen.h>
       4             : #include <sysexits.h>
       5             : 
       6             : #include <sys/types.h>
       7             : #include <sys/stat.h>
       8             : #include <fcntl.h>
       9             : 
      10             : 
      11             : #include <libintl.h>
      12             : #define _(String) gettext(String)
      13             : 
      14             : #include <string.h>
      15             : #include <errno.h>
      16             : #include <unistd.h>
      17             : #include "tunegfs2.h"
      18             : 
      19             : static struct tunegfs2 tunegfs2_struct;
      20             : static struct tunegfs2 *tfs = &tunegfs2_struct;
      21             : 
      22           0 : static void parse_mount_options(char *arg)
      23             : {
      24             :         struct opt_map *m;
      25             :         char *s, *c;
      26             :         int l;
      27             :         struct opt_map {
      28             :                 const char *tag;
      29             :                 int *flag;
      30             :                 char **val;
      31           0 :         } map[]= {
      32           0 :                 { "lockproto=", &tfs->opt_proto, &tfs->proto },
      33           0 :                 { "locktable=", &tfs->opt_table, &tfs->table },
      34             :                 { NULL, NULL, NULL }
      35             :         };
      36             : 
      37           0 :         s = arg;
      38           0 :         for (m = &map[0]; m->tag; m++) {
      39           0 :                 l = strlen(m->tag);
      40           0 :                 if (!strncmp(s, m->tag, l)) {
      41           0 :                         *(m->flag) = 1;
      42           0 :                         *(m->val) = s + l;
      43           0 :                         c = strchr(*(m->val), ',');
      44           0 :                         if (!c)
      45           0 :                                 break;
      46           0 :                         *c='\0';
      47           0 :                         s = c+1;
      48             :                 }
      49             :         }
      50           0 : }
      51             : 
      52           1 : static void usage(char *name)
      53             : {
      54           1 :         printf("%s %s [-hlV] [-L <%s>] [-U <%s>] [-o <%s>] [-r <%s>] <%s>\n",
      55             :                _("Usage:"), basename(name), _("label"), _("UUID"),
      56             :                _("mount options"), _("version"), _("device"));
      57           1 : }
      58             : 
      59           0 : static void version(void)
      60             : {
      61           0 :         printf("tunegfs2 (%s %s)\n", __DATE__, __TIME__);
      62           0 : }
      63             : 
      64             : #ifndef UNITTESTS
      65           9 : int main(int argc, char **argv)
      66             : {
      67             :         int c, status;
      68           9 :         int flags = O_RDWR | O_EXCL;
      69             : 
      70           9 :         memset(tfs, 0, sizeof(struct tunegfs2));
      71          17 :         while((c = getopt(argc, argv, "hL:U:lo:Vr:")) != -1) {
      72           9 :                 switch(c) {
      73           0 :                 case 'h':
      74           0 :                         usage(argv[0]);
      75           0 :                         return 0;
      76           0 :                 case 'L':
      77           0 :                         tfs->opt_label = 1;
      78           0 :                         tfs->label = optarg;
      79           0 :                         break;
      80           1 :                 case 'U':
      81           1 :                         tfs->opt_uuid = 1;
      82           1 :                         tfs->uuid = optarg;
      83           1 :                         break;
      84           3 :                 case 'l':
      85           3 :                         tfs->opt_list = 1;
      86           3 :                         flags = O_RDONLY;
      87           3 :                         break;
      88           0 :                 case 'o':
      89           0 :                         parse_mount_options(optarg);
      90           0 :                         break;
      91           0 :                 case 'V':
      92           0 :                         version();
      93           0 :                         return 0;
      94           4 :                 case 'r':
      95           4 :                         tfs->opt_format = 1;
      96           4 :                         tfs->format = optarg;
      97           4 :                         break;
      98           1 :                 default:
      99           1 :                         fprintf(stderr, _("Invalid option: %c\n"), c);
     100           1 :                         usage(argv[0]);
     101           1 :                         return EX_USAGE;
     102             :                 }
     103             :         }
     104             : 
     105           8 :         if ((argc - optind) != 1) {
     106           0 :                 fprintf(stderr, _("Incorrect number of arguments\n"));
     107           0 :                 usage(argv[0]);
     108           0 :                 return EX_USAGE;
     109             :         }
     110             : 
     111           8 :         if (tfs->opt_label && tfs->opt_table) {
     112           0 :                 fprintf(stderr, _("The -L argument cannot be used with the 'locktable' option\n"));
     113           0 :                 usage(argv[0]);
     114           0 :                 return EX_USAGE;
     115             :         }
     116             : 
     117           8 :         tfs->devicename = argv[optind];
     118           8 :         tfs->fd = open(tfs->devicename, flags);
     119             : 
     120           8 :         if (tfs->fd < 0) {
     121           0 :                 fprintf(stderr, _("Unable to open device %s: %s\n"),
     122           0 :                                 tfs->devicename, strerror(errno));
     123           0 :                 return EX_IOERR;
     124             :         }
     125             : 
     126           8 :         status = read_super(tfs);
     127           8 :         if (status)
     128           2 :                 goto out;
     129             : 
     130           6 :         if (tfs->opt_uuid) {
     131           1 :                 status = change_uuid(tfs, tfs->uuid);
     132           1 :                 if (status)
     133           0 :                         goto out;
     134             :         }
     135             : 
     136           6 :         if (tfs->opt_proto) {
     137           0 :                 status = change_lockproto(tfs, tfs->proto);
     138           0 :                 if (status)
     139           0 :                         goto out;
     140             :         }
     141             : 
     142           6 :         if (tfs->opt_label) {
     143           0 :                 status = change_locktable(tfs, tfs->label);
     144           0 :                 if (status)
     145           0 :                         goto out;
     146             :         }
     147             : 
     148           6 :         if (tfs->opt_table) {
     149           0 :                 status = change_locktable(tfs, tfs->table);
     150           0 :                 if (status)
     151           0 :                         goto out;
     152             :         }
     153           6 :         if (tfs->opt_format) {
     154           4 :                 status = change_format(tfs, tfs->format);
     155           4 :                 if (status)
     156           3 :                         goto out;
     157             :         }
     158           3 :         if (tfs->opt_label || tfs->opt_uuid || tfs->opt_table ||
     159           2 :             tfs->opt_proto || tfs->opt_format) {
     160           2 :                 status = write_super(tfs);
     161           2 :                 if (status)
     162           0 :                         goto out;
     163             :         }
     164             : 
     165           3 :         if (tfs->opt_list)
     166           1 :                 print_super(tfs);
     167             : 
     168           3 :         close(tfs->fd);
     169           8 : out:
     170           8 :         return status;
     171             : }
     172             : #endif /* UNITTESTS */