ip6tables-restore.c

   1 /* Code to restore the iptables state, from file by ip6tables-save.
   2  * Author:  Andras Kis-Szabo <kisza@sch.bme.hu>
   3  *
   4  * based on iptables-restore
   5  * Authors:
   6  *      Harald Welte <laforge@gnumonks.org>
   7  *      Rusty Russell <rusty@linuxcare.com.au>
   8  * This code is distributed under the terms of GNU GPL v2
   9  *
  10  * $Id: ip6tables-restore.c,v 1.12 2003/05/02 15:30:11 laforge Exp $
  11  */
  12
  13 #include <getopt.h>
  14 #include <sys/errno.h>
  15 #include <string.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include "ip6tables.h"
  19 #include "libiptc/libip6tc.h"
  20
  21 #ifdef DEBUG
  22 #define DEBUGP(x, args...) fprintf(stderr, x, ## args)
  23 #else
  24 #define DEBUGP(x, args...)
  25 #endif
  26
  27 static int binary = 0, counters = 0, verbose = 0, noflush = 0;
  28
  29 /* Keeping track of external matches and targets.  */
  30 static struct option options[] = {
  31         { "binary", 0, 0, 'b' },
  32         { "counters", 0, 0, 'c' },
  33         { "verbose", 1, 0, 'v' },
  34         { "help", 0, 0, 'h' },
  35         { "noflush", 0, 0, 'n'},
  36         { "modprobe", 1, 0, 'M'},
  37         { 0 }
  38 };
  39
  40 static void print_usage(const char *name, const char *version) __attribute__((noreturn));
  41
  42 static void print_usage(const char *name, const char *version)
  43 {
  44         fprintf(stderr, "Usage: %s [-b] [-c] [-v] [-h]\n"
  45                         "          [ --binary ]\n"
  46                         "          [ --counters ]\n"
  47                         "          [ --verbose ]\n"
  48                         "          [ --help ]\n"
  49                         "          [ --noflush ]\n"
  50                         "          [ --modprobe=<command>]\n", name);
  51
  52         exit(1);
  53 }
  54
  55 ip6tc_handle_t create_handle(const char *tablename, const char* modprobe)
  56 {
  57         ip6tc_handle_t handle;
  58
  59         handle = ip6tc_init(tablename);
  60
  61         if (!handle) {
  62                 /* try to insmod the module if iptc_init failed */
  63                 ip6tables_insmod("ip6_tables", modprobe);
  64                 handle = ip6tc_init(tablename);
  65         }
  66
  67         if (!handle) {
  68                 exit_error(PARAMETER_PROBLEM, "%s: unable to initialize"
  69                         "table '%s'\n", program_name, tablename);
  70                 exit(1);
  71         }
  72         return handle;
  73 }
  74
  75 int parse_counters(char *string, struct ip6t_counters *ctr)
  76 {
  77         return (sscanf(string, "[%llu:%llu]", &ctr->pcnt, &ctr->bcnt) == 2);
  78 }
  79
  80 /* global new argv and argc */
  81 static char *newargv[255];
  82 static int newargc;
  83
  84 /* function adding one argument to newargv, updating newargc
  85  * returns true if argument added, false otherwise */
  86 static int add_argv(char *what) {
  87         DEBUGP("add_argv: %s\n", what);
  88         if (what && ((newargc + 1) < sizeof(newargv)/sizeof(char *))) {
  89                 newargv[newargc] = strdup(what);
  90                 newargc++;
  91                 return 1;
  92         } else
  93                 return 0;
  94 }
  95
  96 static void free_argv(void) {
  97         int i;
  98
  99         for (i = 0; i < newargc; i++)
 100                 free(newargv[i]);
 101 }
 102
 103 int main(int argc, char *argv[])
 104 {
 105         ip6tc_handle_t handle = NULL;
 106         char buffer[10240];
 107         int c;
 108         char curtable[IP6T_TABLE_MAXNAMELEN + 1];
 109         FILE *in;
 110         const char *modprobe = 0;
 111         int in_table = 0;
 112
 113         program_name = "ip6tables-restore";
 114         program_version = IPTABLES_VERSION;
 115         line = 0;
 116
 117 #ifdef NO_SHARED_LIBS
 118         init_extensions();
 119 #endif
 120
 121         while ((c = getopt_long(argc, argv, "bcvhnM:", options, NULL)) != -1) {
 122                 switch (c) {
 123                         case 'b':
 124                                 binary = 1;
 125                                 break;
 126                         case 'c':
 127                                 counters = 1;
 128                                 break;
 129                         case 'v':
 130                                 verbose = 1;
 131                                 break;
 132                         case 'h':
 133                                 print_usage("ip6tables-restore",
 134                                             IPTABLES_VERSION);
 135                                 break;
 136                         case 'n':
 137                                 noflush = 1;
 138                                 break;
 139                         case 'M':
 140                                 modprobe = optarg;
 141                                 break;
 142                 }
 143         }
 144
 145         if (optind == argc - 1) {
 146                 in = fopen(argv[optind], "r");
 147                 if (!in) {
 148                         fprintf(stderr, "Can't open %s: %s", argv[optind],
 149                                 strerror(errno));
 150                         exit(1);
 151                 }
 152         }
 153         else if (optind < argc) {
 154                 fprintf(stderr, "Unknown arguments found on commandline");
 155                 exit(1);
 156         }
 157         else in = stdin;
 158
 159         /* Grab standard input. */
 160         while (fgets(buffer, sizeof(buffer), in)) {
 161                 int ret;
 162
 163                 line++;
 164                 if (buffer[0] == '\n') continue;
 165                 else if (buffer[0] == '#') {
 166                         if (verbose) fputs(buffer, stdout);
 167                         continue;
 168                 } else if ((strcmp(buffer, "COMMIT\n") == 0) && (in_table)) {
 169                         DEBUGP("Calling commit\n");
 170                         ret = ip6tc_commit(&handle);
 171                         in_table = 0;
 172                 } else if ((buffer[0] == '*') && (!in_table)) {
 173                         /* New table */
 174                         char *table;
 175
 176                         table = strtok(buffer+1, " \t\n");
 177                         DEBUGP("line %u, table '%s'\n", line, table);
 178                         if (!table) {
 179                                 exit_error(PARAMETER_PROBLEM,
 180                                         "%s: line %u table name invalid\n",
 181                                         program_name, line);
 182                                 exit(1);
 183                         }
 184                         strncpy(curtable, table, IP6T_TABLE_MAXNAMELEN);
 185
 186                         if (handle)
 187                                 ip6tc_free(&handle);
 188
 189                         handle = create_handle(table, modprobe);
 190                         if (noflush == 0) {
 191                                 DEBUGP("Cleaning all chains of table '%s'\n",
 192                                         table);
 193                                 for_each_chain(flush_entries, verbose, 1,
 194                                                 &handle);
 195
 196                                 DEBUGP("Deleting all user-defined chains "
 197                                        "of table '%s'\n", table);
 198                                 for_each_chain(delete_chain, verbose, 0,
 199                                                 &handle) ;
 200                         }
 201
 202                         ret = 1;
 203                         in_table = 1;
 204
 205                 } else if ((buffer[0] == ':') && (in_table)) {
 206                         /* New chain. */
 207                         char *policy, *chain;
 208
 209                         chain = strtok(buffer+1, " \t\n");
 210                         DEBUGP("line %u, chain '%s'\n", line, chain);
 211                         if (!chain) {
 212                                 exit_error(PARAMETER_PROBLEM,
 213                                            "%s: line %u chain name invalid\n",
 214                                            program_name, line);
 215                                 exit(1);
 216                         }
 217
 218                         if (!ip6tc_builtin(chain, handle)) {
 219                                 DEBUGP("Creating new chain '%s'\n", chain);
 220                                 if (!ip6tc_create_chain(chain, &handle))
 221                                         exit_error(PARAMETER_PROBLEM,
 222                                                    "error creating chain "
 223                                                    "'%s':%s\n", chain,
 224                                                    strerror(errno));
 225                         }
 226
 227                         policy = strtok(NULL, " \t\n");
 228                         DEBUGP("line %u, policy '%s'\n", line, policy);
 229                         if (!policy) {
 230                                 exit_error(PARAMETER_PROBLEM,
 231                                            "%s: line %u policy invalid\n",
 232                                            program_name, line);
 233                                 exit(1);
 234                         }
 235
 236                         if (strcmp(policy, "-") != 0) {
 237                                 struct ip6t_counters count;
 238
 239                                 if (counters) {
 240                                         char *ctrs;
 241                                         ctrs = strtok(NULL, " \t\n");
 242
 243                                         parse_counters(ctrs, &count);
 244
 245                                 } else {
 246                                         memset(&count, 0,
 247                                                sizeof(struct ip6t_counters));
 248                                 }
 249
 250                                 DEBUGP("Setting policy of chain %s to %s\n",
 251                                         chain, policy);
 252
 253                                 if (!ip6tc_set_policy(chain, policy, &count,
 254                                                      &handle))
 255                                         exit_error(OTHER_PROBLEM,
 256                                                 "Can't set policy `%s'"
 257                                                 " on `%s' line %u: %s\n",
 258                                                 chain, policy, line,
 259                                                 ip6tc_strerror(errno));
 260                         }
 261
 262                         ret = 1;
 263
 264                 } else if (in_table) {
 265                         int a;
 266                         char *ptr = buffer;
 267                         char *pcnt = NULL;
 268                         char *bcnt = NULL;
 269                         char *parsestart;
 270
 271                         /* the parser */
 272                         char *param_start, *curchar;
 273                         int quote_open;
 274
 275                         /* reset the newargv */
 276                         newargc = 0;
 277
 278                         if (buffer[0] == '[') {
 279                                 /* we have counters in our input */
 280                                 ptr = strchr(buffer, ']');
 281                                 if (!ptr)
 282                                         exit_error(PARAMETER_PROBLEM,
 283                                                    "Bad line %u: need ]\n",
 284                                                    line);
 285
 286                                 pcnt = strtok(buffer+1, ":");
 287                                 if (!pcnt)
 288                                         exit_error(PARAMETER_PROBLEM,
 289                                                    "Bad line %u: need :\n",
 290                                                    line);
 291
 292                                 bcnt = strtok(NULL, "]");
 293                                 if (!bcnt)
 294                                         exit_error(PARAMETER_PROBLEM,
 295                                                    "Bad line %u: need ]\n",
 296                                                    line);
 297
 298                                 /* start command parsing after counter */
 299                                 parsestart = ptr + 1;
 300                         } else {
 301                                 /* start command parsing at start of line */
 302                                 parsestart = buffer;
 303                         }
 304
 305                         add_argv(argv[0]);
 306                         add_argv("-t");
 307                         add_argv((char *) &curtable);
 308
 309                         if (counters && pcnt && bcnt) {
 310                                 add_argv("--set-counters");
 311                                 add_argv((char *) pcnt);
 312                                 add_argv((char *) bcnt);
 313                         }
 314
 315                         /* After fighting with strtok enough, here's now
 316                          * a 'real' parser. According to Rusty I'm now no
 317                          * longer a real hacker, but I can live with that */
 318
 319                         quote_open = 0;
 320                         param_start = parsestart;
 321
 322                         for (curchar = parsestart; *curchar; curchar++) {
 323                                 if (*curchar == '"') {
 324                                         if (quote_open) {
 325                                                 quote_open = 0;
 326                                                 *curchar = ' ';
 327                                         } else {
 328                                                 quote_open = 1;
 329                                                 param_start++;
 330                                         }
 331                                 }
 332                                 if (*curchar == ' '
 333                                     || *curchar == '\t'
 334                                     || * curchar == '\n') {
 335                                         char param_buffer[1024];
 336                                         int param_len = curchar-param_start;
 337
 338                                         if (quote_open)
 339                                                 continue;
 340
 341                                         if (!param_len) {
 342                                                 /* two spaces? */
 343                                                 param_start++;
 344                                                 continue;
 345                                         }
 346
 347                                         /* end of one parameter */
 348                                         strncpy(param_buffer, param_start,
 349                                                 param_len);
 350                                         *(param_buffer+param_len) = '\0';
 351
 352                                         /* check if table name specified */
 353                                         if (!strncmp(param_buffer, "-t", 3)
 354                                             || !strncmp(param_buffer, "--table", 8)) {
 355                                                 exit_error(PARAMETER_PROBLEM,
 356                                                    "Line %u seems to have a "
 357                                                    "-t table option.\n", line);
 358                                                 exit(1);
 359                                         }
 360
 361                                         add_argv(param_buffer);
 362                                         param_start += param_len + 1;
 363                                 } else {
 364                                         /* regular character, skip */
 365                                 }
 366                         }
 367
 368                         DEBUGP("calling do_command6(%u, argv, &%s, handle):\n",
 369                                 newargc, curtable);
 370
 371                         for (a = 0; a < newargc; a++)
 372                                 DEBUGP("argv[%u]: %s\n", a, newargv[a]);
 373
 374                         ret = do_command6(newargc, newargv,
 375                                          &newargv[2], &handle);
 376
 377                         free_argv();
 378                 }
 379                 if (!ret) {
 380                         fprintf(stderr, "%s: line %u failed\n",
 381                                         program_name, line);
 382                         exit(1);
 383                 }
 384         }
 385
 386         return 0;
 387 }