This commit was manufactured by cvs2svn to create tag
[iptables.git] / 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 }