~ubuntu-branches/ubuntu/karmic/pdnsd/karmic

« back to all changes in this revision

Viewing changes to src/conf-parse.c

  • Committer: Bazaar Package Importer
  • Author(s): Takuo KITAME
  • Date: 2002-04-07 02:30:11 UTC
  • Revision ID: james.westby@ubuntu.com-20020407023011-6zzd1y8a8tk5fz97
Tags: upstream-1.1.7
ImportĀ upstreamĀ versionĀ 1.1.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#ifndef lint
 
2
static char const 
 
3
yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";
 
4
#endif
 
5
#include <stdlib.h>
 
6
#define YYBYACC 1
 
7
#define YYMAJOR 1
 
8
#define YYMINOR 9
 
9
#define YYLEX yylex()
 
10
#define YYEMPTY -1
 
11
#define yyclearin (yychar=(YYEMPTY))
 
12
#define yyerrok (yyerrflag=0)
 
13
#define YYRECOVERING() (yyerrflag!=0)
 
14
static int yygrowstack();
 
15
#define YYPREFIX "yy"
 
16
#line 2 "conf-parse.y"
 
17
/* conf.y - Parser for pdnsd config files.
 
18
   Copyright (C) 2000, 2001 Thomas Moestl
 
19
 
 
20
This file is part of the pdnsd package.
 
21
 
 
22
pdnsd is free software; you can redistribute it and/or modify
 
23
it under the terms of the GNU General Public License as published by
 
24
the Free Software Foundation; either version 2, or (at your option)
 
25
any later version.
 
26
 
 
27
pdnsd is distributed in the hope that it will be useful,
 
28
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
29
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
30
GNU General Public License for more details.
 
31
 
 
32
You should have received a copy of the GNU General Public License
 
33
along with pdsnd; see the file COPYING.  If not, write to
 
34
the Free Software Foundation, 59 Temple Place - Suite 330,
 
35
Boston, MA 02111-1307, USA.  */
 
36
 
 
37
#include <config.h>
 
38
#include "ipvers.h"
 
39
#include <string.h>
 
40
#include <unistd.h>
 
41
#include <sys/types.h>
 
42
#include <sys/socket.h>
 
43
#include <arpa/inet.h>
 
44
#include <stdlib.h>
 
45
#include "conff.h"
 
46
#include "consts.h"
 
47
#include "cache.h"
 
48
#include "dns.h"
 
49
#include "dns_query.h"
 
50
#include "helpers.h"
 
51
 
 
52
#if !defined(lint) && !defined(NO_RCSIDS)
 
53
static char rcsid[]="$Id: conf-parse.y,v 1.36 2001/07/01 21:03:15 tmm Exp $";
 
54
#endif
 
55
 
 
56
dns_cent_t c_cent;
 
57
pdnsd_a c_a;
 
58
unsigned char c_soa_owner[256];
 
59
unsigned char c_soa_r[256];
 
60
soa_r_t c_soa;
 
61
unsigned char c_db[256];
 
62
unsigned char c_ptr[256];
 
63
unsigned char c_owner[256];
 
64
unsigned char c_name[256];
 
65
time_t c_ttl;
 
66
int c_aliases, c_flags;
 
67
unsigned char buf[532];
 
68
char errbuf[256];
 
69
int sz,tp,err;
 
70
int hdtp, htp;
 
71
struct in_addr ina4;
 
72
uint16_t ts;
 
73
 
 
74
int idx;
 
75
 
 
76
#ifndef NO_YYLINENO
 
77
/*
 
78
 * This comes from the generated lexer. It is an undocumented variable in lex, and in flex
 
79
 * we explicitely switch it on.
 
80
 */
 
81
extern int yylineno;
 
82
#endif
 
83
 
 
84
/* Bah. I want strlcpy. */
 
85
#define YSTRNCP(dst, src, err)                                          \
 
86
        do {                                                            \
 
87
                if (!strncp((char *)(dst),(char *)src,sizeof(dst))) {   \
 
88
                        yyerror(err": string too long");                \
 
89
                        YYERROR;                                        \
 
90
                }                                                       \
 
91
        } while(0);
 
92
 
 
93
#line 79 "conf-parse.y"
 
94
typedef union {
 
95
long          num;
 
96
unsigned char *nm;
 
97
} YYSTYPE;
 
98
#line 99 "y.tab.c"
 
99
#define YYERRCODE 256
 
100
#define NUMBER 257
 
101
#define STRING 258
 
102
#define ERROR 259
 
103
#define GLOBAL 260
 
104
#define SERVER 261
 
105
#define RR 262
 
106
#define NEG 263
 
107
#define SOURCE 264
 
108
#define PERM_CACHE 265
 
109
#define CACHE_DIR 266
 
110
#define SERVER_PORT 267
 
111
#define SERVER_IP 268
 
112
#define SCHEME_FILE 269
 
113
#define LINKDOWN_KLUGE 270
 
114
#define MAX_TTL 271
 
115
#define MIN_TTL 272
 
116
#define RUN_AS 273
 
117
#define STRICT_SETUID 274
 
118
#define PARANOID 275
 
119
#define STATUS_CTL 276
 
120
#define DAEMON 277
 
121
#define C_TCP_SERVER 278
 
122
#define PID_FILE 279
 
123
#define C_VERBOSITY 280
 
124
#define C_QUERY_METHOD 281
 
125
#define RUN_IPV4 282
 
126
#define C_DEBUG 283
 
127
#define C_CTL_PERMS 284
 
128
#define C_PROC_LIMIT 285
 
129
#define C_PROCQ_LIMIT 286
 
130
#define TCP_QTIMEOUT 287
 
131
#define C_PAR_QUERIES 288
 
132
#define C_RAND_RECS 289
 
133
#define NEG_TTL 290
 
134
#define NEG_RRS_POL 291
 
135
#define NEG_DOMAIN_POL 292
 
136
#define QUERY_PORT_START 293
 
137
#define QUERY_PORT_END 294
 
138
#define IP 295
 
139
#define PORT 296
 
140
#define SCHEME 297
 
141
#define UPTEST 298
 
142
#define TIMEOUT 299
 
143
#define PING_TIMEOUT 300
 
144
#define PING_IP 301
 
145
#define UPTEST_CMD 302
 
146
#define INTERVAL 303
 
147
#define INTERFACE 304
 
148
#define DEVICE 305
 
149
#define PURGE_CACHE 306
 
150
#define CACHING 307
 
151
#define LEAN_QUERY 308
 
152
#define PRESET 309
 
153
#define PROXY_ONLY 310
 
154
#define INCLUDE 311
 
155
#define EXCLUDE 312
 
156
#define POLICY 313
 
157
#define LABEL 314
 
158
#define A 315
 
159
#define PTR 316
 
160
#define MX 317
 
161
#define SOA 318
 
162
#define CNAME 319
 
163
#define NAME 320
 
164
#define OWNER 321
 
165
#define TTL 322
 
166
#define TYPES 323
 
167
#define FILET 324
 
168
#define SERVE_ALIASES 325
 
169
#define AUTHREC 326
 
170
#define NDOMAIN 327
 
171
#define CONST 328
 
172
#define RRTYPE 329
 
173
const short yylhs[] = {                                        -1,
 
174
    0,    0,   11,    1,   12,    1,   13,    1,   14,    1,
 
175
   16,    1,    2,    2,    3,    3,    3,    3,    3,    3,
 
176
    3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 
177
    3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 
178
    3,    3,    3,    3,    3,    4,    4,    5,    5,    5,
 
179
    5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 
180
    5,    5,    5,    5,    5,    5,    5,    5,    5,    6,
 
181
    6,    7,    7,    7,    7,    7,    7,    7,    7,    7,
 
182
   15,   15,   17,   17,   17,   17,   17,    8,    8,    9,
 
183
    9,    9,    9,   10,   10,   18,   19,
 
184
};
 
185
const short yylen[] = {                                         2,
 
186
    0,    2,    0,    5,    0,    5,    0,    5,    0,    5,
 
187
    0,    5,    0,    2,    4,    4,    4,    4,    4,    4,
 
188
    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 
189
    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 
190
    4,    4,    4,    4,    4,    0,    2,    4,    4,    4,
 
191
    4,    4,    4,    4,    4,    6,    4,    4,    4,    4,
 
192
    4,    4,    4,    4,    4,    4,    4,    4,    4,    0,
 
193
    2,    4,    4,    4,    4,    4,    4,    6,    4,   16,
 
194
    0,    2,    4,    4,    4,    4,    4,    0,    2,    4,
 
195
    4,    4,    4,    1,    3,    1,    1,
 
196
};
 
197
const short yydefred[] = {                                      1,
 
198
    0,    0,    0,    0,    0,    0,    2,    3,    5,    7,
 
199
    9,   11,   13,   46,   70,   88,   81,    0,    0,    0,
 
200
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
201
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
202
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
203
    0,    0,    4,   14,    0,    0,    0,    0,    0,    0,
 
204
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
205
    0,    0,    0,    0,    6,   47,    0,    0,    0,    0,
 
206
    0,    0,    0,    0,    0,    8,   71,    0,    0,    0,
 
207
   10,   89,    0,    0,    0,    0,    0,   12,   82,    0,
 
208
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
209
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
210
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
211
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
212
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
213
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
214
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
215
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
216
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
217
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
218
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
219
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
220
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
221
   96,    0,    0,    0,    0,    0,    0,    0,   16,   15,
 
222
   17,   18,   19,   20,   21,   22,   23,   24,   25,   26,
 
223
   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,
 
224
   37,   38,   39,   40,   41,   42,   43,   44,   45,   48,
 
225
   49,   50,   51,   52,   53,   54,   55,    0,   57,   58,
 
226
   59,   60,   61,   62,   63,   64,   65,   67,   68,   66,
 
227
   69,   76,   77,    0,    0,   79,   72,   73,   74,   75,
 
228
   90,   91,   92,   93,    0,   83,   84,   85,   86,   87,
 
229
    0,    0,    0,   95,   56,   78,    0,    0,    0,    0,
 
230
    0,    0,    0,    0,    0,    0,   80,
 
231
};
 
232
const short yydgoto[] = {                                       1,
 
233
    7,   18,   54,   19,   76,   20,   87,   21,   92,  232,
 
234
   13,   14,   15,   16,   22,   17,   99,  233,    0,
 
235
};
 
236
const short yysindex[] = {                                      0,
 
237
 -249, -116, -114, -107, -106, -105,    0,    0,    0,    0,
 
238
    0,    0,    0,    0,    0,    0,    0, -124,  -86, -125,
 
239
 -115, -122,  -42,  -40,  -38,  -37,  -36,  -35,  -34,  -33,
 
240
  -32,  -31,  -30,  -29,  -28,  -27,  -26,  -25,  -24,  -23,
 
241
  -21,  -20,  -19,  -18,  -17,  -16,  -15,  -14,  -13,  -12,
 
242
  -11,  -10,    0,    0,   -9,   -8,   -7,   -6,   -5,   -4,
 
243
   -3,   -2,   -1,    1,    2,    3,    4,    5,    6,    7,
 
244
    8,    9,   10,   11,    0,    0,   13,   15,   16,   17,
 
245
   18,   19,   20,   21,   22,    0,    0,   23,   24,   25,
 
246
    0,    0,   26,   27,   28,   29,   30,    0,    0, -255,
 
247
 -236, -196, -166, -165, -234, -162, -161, -160, -231, -229,
 
248
 -228, -227, -226, -155, -153, -223, -222, -221, -149, -148,
 
249
 -147, -146, -145, -215, -143, -213, -212, -140, -139, -138,
 
250
 -136, -135, -209, -133, -132, -131, -130, -253, -129, -128,
 
251
 -206, -202, -197, -195, -194, -126, -123, -192, -121, -120,
 
252
 -119, -118,  -87,  -85,  -84,  -83,  -81, -156,  -80,  -78,
 
253
 -321,  -77,  -75,  -74, -151, -142,  121,  124,  126,  128,
 
254
  129,  130,  139,  147,  170,  171,  172,  173,  174,  175,
 
255
  176,  177,  178,  179,  180,  181,  182,  183,  184,  185,
 
256
  186,  187,  188,  189,  190,  191,  192,  193,  194,  195,
 
257
  196,  197,  198,  199,  -39,  200,  201,  202,  203,  204,
 
258
  205,  206,  207,  208,  209,  210,  211,  212,  213,  214,
 
259
  230,  231,  217,  218,  219,  220,  221,  222,  223,  224,
 
260
    0,  225,  241,  227,  228,  229,  232,  233,    0,    0,
 
261
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
262
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
263
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
264
    0,    0,    0,    0,    0,    0,    0,   31,    0,    0,
 
265
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
266
    0,    0,    0,   33,   35,    0,    0,    0,    0,    0,
 
267
    0,    0,    0,    0,  -22,    0,    0,    0,    0,    0,
 
268
  235,  236,  252,    0,    0,    0,   40,  254,   42,  256,
 
269
   44,  258,   46,  260,   48,  247,    0,
 
270
};
 
271
const short yyrindex[] = {                                      0,
 
272
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
273
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
274
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
275
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
276
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
277
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
278
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
279
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
280
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
281
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
282
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
283
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
284
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
285
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
286
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
287
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
288
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
289
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
290
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
291
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
292
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
293
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
294
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
295
    0,    0,  249,    0,    0,    0,    0,    0,    0,    0,
 
296
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
297
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
298
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
299
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
300
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
301
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
302
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
303
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
304
    0,    0,    0,    0,    0,    0,    0,
 
305
};
 
306
const short yygindex[] = {                                      0,
 
307
    0,    0,    0,    0,    0,    0,    0,    0,    0,   12,
 
308
    0,    0,    0,    0,    0,    0,    0,    0,    0,
 
309
};
 
310
#define YYTABLESIZE 317
 
311
const short yytable[] = {                                      86,
 
312
   53,  167,   98,  206,  278,  230,    8,  231,    9,   91,
 
313
    2,    3,    4,    5,    6,   10,   11,   12,  100,  277,
 
314
  101,  169,  102,  103,  104,  105,  106,  107,  108,  109,
 
315
  110,  111,  112,  113,  114,  115,  116,  117,   75,  118,
 
316
  119,  120,  121,  122,  123,  124,  125,  126,  127,  128,
 
317
  129,  130,  131,  132,  133,  134,  135,  136,  137,  138,
 
318
  170,  139,  140,  141,  142,  143,  144,  145,  146,  147,
 
319
  148,  149,  168,  150,  207,  151,  152,  153,  154,  155,
 
320
  156,  157,  158,  159,  160,  161,  162,  163,  164,  165,
 
321
  166,  171,  172,  173,  174,  175,  177,  176,  178,  179,
 
322
  180,  181,  182,  183,  184,  185,  186,  187,  188,  189,
 
323
  190,  191,  192,  193,  194,  195,  196,  197,  201,  198,
 
324
  199,  210,  200,  202,  203,  211,  204,  205,  208,  209,
 
325
  212,  215,  213,  214,  216,  217,  218,  219,  220,  221,
 
326
   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,
 
327
   33,   34,   35,   36,   37,   38,   39,   40,   41,   42,
 
328
   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 
329
  222,  227,  223,  224,  225,  226,  237,  228,  229,  239,
 
330
  234,  235,  240,  236,  241,  238,  242,  243,  244,   77,
 
331
   78,   79,   80,   81,   82,   83,   84,  245,   93,   94,
 
332
   85,   95,   96,   97,   88,  246,   89,   90,   55,   56,
 
333
   57,   58,   59,   60,   61,   62,   63,   64,   65,   66,
 
334
   67,   68,   69,   70,   71,   72,   73,   74,  247,  248,
 
335
  249,  250,  251,  252,  253,  254,  255,  256,  257,  258,
 
336
  259,  260,  261,  262,  263,  264,  265,  266,  267,  268,
 
337
  269,  270,  271,  272,  273,  274,  275,  276,  279,  280,
 
338
  281,  282,  283,  284,  285,  286,  287,  288,  289,  290,
 
339
  291,  292,  293,  294,  295,  296,  297,  298,  299,  300,
 
340
  301,  302,  303,  304,  305,  306,  307,  308,  311,  312,
 
341
  309,  310,  313,  315,  316,  317,  318,  319,  320,  321,
 
342
  322,  323,  324,  325,  326,  327,  231,   94,    0,    0,
 
343
    0,    0,    0,    0,    0,    0,  314,
 
344
};
 
345
const short yycheck[] = {                                     125,
 
346
  125,  257,  125,  257,   44,  327,  123,  329,  123,  125,
 
347
  260,  261,  262,  263,  264,  123,  123,  123,   61,   59,
 
348
   61,  258,   61,   61,   61,   61,   61,   61,   61,   61,
 
349
   61,   61,   61,   61,   61,   61,   61,   61,  125,   61,
 
350
   61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 
351
   61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 
352
  257,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 
353
   61,   61,  328,   61,  328,   61,   61,   61,   61,   61,
 
354
   61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 
355
   61,  258,  258,  328,  257,  257,  328,  258,  328,  328,
 
356
  328,  328,  258,  257,  328,  328,  328,  257,  257,  257,
 
357
  257,  257,  328,  257,  328,  328,  257,  257,  328,  258,
 
358
  257,  328,  258,  257,  257,  328,  258,  258,  258,  258,
 
359
  328,  258,  328,  328,  258,  328,  258,  258,  258,  258,
 
360
  265,  266,  267,  268,  269,  270,  271,  272,  273,  274,
 
361
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
 
362
  285,  286,  287,  288,  289,  290,  291,  292,  293,  294,
 
363
  258,  328,  258,  258,  258,  257,  328,  258,  257,   59,
 
364
  258,  257,   59,  258,   59,  328,   59,   59,   59,  315,
 
365
  316,  317,  318,  319,  320,  321,  322,   59,  321,  322,
 
366
  326,  324,  325,  326,  320,   59,  322,  323,  295,  296,
 
367
  297,  298,  299,  300,  301,  302,  303,  304,  305,  306,
 
368
  307,  308,  309,  310,  311,  312,  313,  314,   59,   59,
 
369
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 
370
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 
371
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 
372
   59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
 
373
   59,   59,   59,   44,   44,   59,   59,   59,   59,   59,
 
374
   59,   59,   59,   59,   44,   59,   59,   59,  258,  257,
 
375
   59,   59,  258,   59,   59,   44,  257,   44,  257,   44,
 
376
  257,   44,  257,   44,  257,   59,  329,   59,   -1,   -1,
 
377
   -1,   -1,   -1,   -1,   -1,   -1,  305,
 
378
};
 
379
#define YYFINAL 1
 
380
#ifndef YYDEBUG
 
381
#define YYDEBUG 0
 
382
#endif
 
383
#define YYMAXTOKEN 329
 
384
#if YYDEBUG
 
385
const char * const yyname[] = {
 
386
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
387
0,0,0,0,0,0,0,0,0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,"'='",0,0,0,0,0,0,
 
388
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
389
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
390
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
391
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 
392
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"NUMBER",
 
393
"STRING","ERROR","GLOBAL","SERVER","RR","NEG","SOURCE","PERM_CACHE","CACHE_DIR",
 
394
"SERVER_PORT","SERVER_IP","SCHEME_FILE","LINKDOWN_KLUGE","MAX_TTL","MIN_TTL",
 
395
"RUN_AS","STRICT_SETUID","PARANOID","STATUS_CTL","DAEMON","C_TCP_SERVER",
 
396
"PID_FILE","C_VERBOSITY","C_QUERY_METHOD","RUN_IPV4","C_DEBUG","C_CTL_PERMS",
 
397
"C_PROC_LIMIT","C_PROCQ_LIMIT","TCP_QTIMEOUT","C_PAR_QUERIES","C_RAND_RECS",
 
398
"NEG_TTL","NEG_RRS_POL","NEG_DOMAIN_POL","QUERY_PORT_START","QUERY_PORT_END",
 
399
"IP","PORT","SCHEME","UPTEST","TIMEOUT","PING_TIMEOUT","PING_IP","UPTEST_CMD",
 
400
"INTERVAL","INTERFACE","DEVICE","PURGE_CACHE","CACHING","LEAN_QUERY","PRESET",
 
401
"PROXY_ONLY","INCLUDE","EXCLUDE","POLICY","LABEL","A","PTR","MX","SOA","CNAME",
 
402
"NAME","OWNER","TTL","TYPES","FILET","SERVE_ALIASES","AUTHREC","NDOMAIN",
 
403
"CONST","RRTYPE",
 
404
};
 
405
const char * const yyrule[] = {
 
406
"$accept : file",
 
407
"file :",
 
408
"file : file spec",
 
409
"$$1 :",
 
410
"spec : GLOBAL '{' $$1 glob_s '}'",
 
411
"$$2 :",
 
412
"spec : SERVER '{' $$2 serv_s '}'",
 
413
"$$3 :",
 
414
"spec : RR '{' $$3 rr_s '}'",
 
415
"$$4 :",
 
416
"spec : NEG '{' $$4 rrneg_s '}'",
 
417
"$$5 :",
 
418
"spec : SOURCE '{' $$5 source_s '}'",
 
419
"glob_s :",
 
420
"glob_s : glob_s glob_el",
 
421
"glob_el : PERM_CACHE '=' CONST ';'",
 
422
"glob_el : PERM_CACHE '=' NUMBER ';'",
 
423
"glob_el : CACHE_DIR '=' STRING ';'",
 
424
"glob_el : SERVER_PORT '=' NUMBER ';'",
 
425
"glob_el : SERVER_IP '=' STRING ';'",
 
426
"glob_el : SCHEME_FILE '=' STRING ';'",
 
427
"glob_el : LINKDOWN_KLUGE '=' CONST ';'",
 
428
"glob_el : MAX_TTL '=' NUMBER ';'",
 
429
"glob_el : MIN_TTL '=' NUMBER ';'",
 
430
"glob_el : RUN_AS '=' STRING ';'",
 
431
"glob_el : STRICT_SETUID '=' CONST ';'",
 
432
"glob_el : PARANOID '=' CONST ';'",
 
433
"glob_el : STATUS_CTL '=' CONST ';'",
 
434
"glob_el : DAEMON '=' CONST ';'",
 
435
"glob_el : C_TCP_SERVER '=' CONST ';'",
 
436
"glob_el : PID_FILE '=' STRING ';'",
 
437
"glob_el : C_VERBOSITY '=' NUMBER ';'",
 
438
"glob_el : C_QUERY_METHOD '=' CONST ';'",
 
439
"glob_el : RUN_IPV4 '=' CONST ';'",
 
440
"glob_el : C_DEBUG '=' CONST ';'",
 
441
"glob_el : C_CTL_PERMS '=' NUMBER ';'",
 
442
"glob_el : C_PROC_LIMIT '=' NUMBER ';'",
 
443
"glob_el : C_PROCQ_LIMIT '=' NUMBER ';'",
 
444
"glob_el : TCP_QTIMEOUT '=' NUMBER ';'",
 
445
"glob_el : C_PAR_QUERIES '=' NUMBER ';'",
 
446
"glob_el : C_RAND_RECS '=' CONST ';'",
 
447
"glob_el : NEG_TTL '=' NUMBER ';'",
 
448
"glob_el : NEG_RRS_POL '=' CONST ';'",
 
449
"glob_el : NEG_DOMAIN_POL '=' CONST ';'",
 
450
"glob_el : QUERY_PORT_START '=' NUMBER ';'",
 
451
"glob_el : QUERY_PORT_END '=' NUMBER ';'",
 
452
"serv_s :",
 
453
"serv_s : serv_s serv_el",
 
454
"serv_el : IP '=' STRING ';'",
 
455
"serv_el : PORT '=' NUMBER ';'",
 
456
"serv_el : SCHEME '=' STRING ';'",
 
457
"serv_el : UPTEST '=' CONST ';'",
 
458
"serv_el : TIMEOUT '=' NUMBER ';'",
 
459
"serv_el : PING_TIMEOUT '=' NUMBER ';'",
 
460
"serv_el : PING_IP '=' STRING ';'",
 
461
"serv_el : UPTEST_CMD '=' STRING ';'",
 
462
"serv_el : UPTEST_CMD '=' STRING ',' STRING ';'",
 
463
"serv_el : INTERVAL '=' NUMBER ';'",
 
464
"serv_el : INTERVAL '=' CONST ';'",
 
465
"serv_el : INTERFACE '=' STRING ';'",
 
466
"serv_el : DEVICE '=' STRING ';'",
 
467
"serv_el : PURGE_CACHE '=' CONST ';'",
 
468
"serv_el : CACHING '=' CONST ';'",
 
469
"serv_el : LEAN_QUERY '=' CONST ';'",
 
470
"serv_el : PRESET '=' CONST ';'",
 
471
"serv_el : PROXY_ONLY '=' CONST ';'",
 
472
"serv_el : POLICY '=' CONST ';'",
 
473
"serv_el : INCLUDE '=' STRING ';'",
 
474
"serv_el : EXCLUDE '=' STRING ';'",
 
475
"serv_el : LABEL '=' STRING ';'",
 
476
"rr_s :",
 
477
"rr_s : rr_s rr_el",
 
478
"rr_el : NAME '=' STRING ';'",
 
479
"rr_el : OWNER '=' STRING ';'",
 
480
"rr_el : TTL '=' NUMBER ';'",
 
481
"rr_el : AUTHREC '=' CONST ';'",
 
482
"rr_el : A '=' STRING ';'",
 
483
"rr_el : PTR '=' STRING ';'",
 
484
"rr_el : MX '=' STRING ',' NUMBER ';'",
 
485
"rr_el : CNAME '=' STRING ';'",
 
486
"rr_el : SOA '=' STRING ',' STRING ',' NUMBER ',' NUMBER ',' NUMBER ',' NUMBER ',' NUMBER ';'",
 
487
"source_s :",
 
488
"source_s : source_s source_el",
 
489
"source_el : OWNER '=' STRING ';'",
 
490
"source_el : TTL '=' NUMBER ';'",
 
491
"source_el : FILET '=' STRING ';'",
 
492
"source_el : SERVE_ALIASES '=' CONST ';'",
 
493
"source_el : AUTHREC '=' CONST ';'",
 
494
"rrneg_s :",
 
495
"rrneg_s : rrneg_s rrneg_el",
 
496
"rrneg_el : NAME '=' STRING ';'",
 
497
"rrneg_el : TTL '=' NUMBER ';'",
 
498
"rrneg_el : TYPES '=' NDOMAIN ';'",
 
499
"rrneg_el : TYPES '=' rr_type_list ';'",
 
500
"rr_type_list : rr_type",
 
501
"rr_type_list : rr_type ',' rr_type_list",
 
502
"rr_type : RRTYPE",
 
503
"errnt : ERROR",
 
504
};
 
505
#endif
 
506
#if YYDEBUG
 
507
#include <stdio.h>
 
508
#endif
 
509
#ifdef YYSTACKSIZE
 
510
#undef YYMAXDEPTH
 
511
#define YYMAXDEPTH YYSTACKSIZE
 
512
#else
 
513
#ifdef YYMAXDEPTH
 
514
#define YYSTACKSIZE YYMAXDEPTH
 
515
#else
 
516
#define YYSTACKSIZE 10000
 
517
#define YYMAXDEPTH 10000
 
518
#endif
 
519
#endif
 
520
#define YYINITSTACKSIZE 200
 
521
int yydebug;
 
522
int yynerrs;
 
523
int yyerrflag;
 
524
int yychar;
 
525
short *yyssp;
 
526
YYSTYPE *yyvsp;
 
527
YYSTYPE yyval;
 
528
YYSTYPE yylval;
 
529
short *yyss;
 
530
short *yysslim;
 
531
YYSTYPE *yyvs;
 
532
int yystacksize;
 
533
#line 917 "conf-parse.y"
 
534
 
 
535
int yyerror (char *s)
 
536
{
 
537
#ifdef NO_YYLINENO
 
538
        fprintf(stderr, "Error in config file: %s\n",s);
 
539
#else
 
540
        fprintf(stderr, "Error in config file (line %i): %s\n",yylineno,s);
 
541
#endif
 
542
        return 0;
 
543
}
 
544
#line 545 "y.tab.c"
 
545
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
 
546
static int yygrowstack()
 
547
{
 
548
    int newsize, i;
 
549
    short *newss;
 
550
    YYSTYPE *newvs;
 
551
 
 
552
    if ((newsize = yystacksize) == 0)
 
553
        newsize = YYINITSTACKSIZE;
 
554
    else if (newsize >= YYMAXDEPTH)
 
555
        return -1;
 
556
    else if ((newsize *= 2) > YYMAXDEPTH)
 
557
        newsize = YYMAXDEPTH;
 
558
    i = yyssp - yyss;
 
559
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
 
560
      (short *)malloc(newsize * sizeof *newss);
 
561
    if (newss == NULL)
 
562
        return -1;
 
563
    yyss = newss;
 
564
    yyssp = newss + i;
 
565
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
 
566
      (YYSTYPE *)malloc(newsize * sizeof *newvs);
 
567
    if (newvs == NULL)
 
568
        return -1;
 
569
    yyvs = newvs;
 
570
    yyvsp = newvs + i;
 
571
    yystacksize = newsize;
 
572
    yysslim = yyss + newsize - 1;
 
573
    return 0;
 
574
}
 
575
 
 
576
#define YYABORT goto yyabort
 
577
#define YYREJECT goto yyabort
 
578
#define YYACCEPT goto yyaccept
 
579
#define YYERROR goto yyerrlab
 
580
 
 
581
#ifndef YYPARSE_PARAM
 
582
#if defined(__cplusplus) || __STDC__
 
583
#define YYPARSE_PARAM_ARG void
 
584
#define YYPARSE_PARAM_DECL
 
585
#else   /* ! ANSI-C/C++ */
 
586
#define YYPARSE_PARAM_ARG
 
587
#define YYPARSE_PARAM_DECL
 
588
#endif  /* ANSI-C/C++ */
 
589
#else   /* YYPARSE_PARAM */
 
590
#ifndef YYPARSE_PARAM_TYPE
 
591
#define YYPARSE_PARAM_TYPE void *
 
592
#endif
 
593
#if defined(__cplusplus) || __STDC__
 
594
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
 
595
#define YYPARSE_PARAM_DECL
 
596
#else   /* ! ANSI-C/C++ */
 
597
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
 
598
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
 
599
#endif  /* ANSI-C/C++ */
 
600
#endif  /* ! YYPARSE_PARAM */
 
601
 
 
602
int
 
603
yyparse (YYPARSE_PARAM_ARG)
 
604
    YYPARSE_PARAM_DECL
 
605
{
 
606
    register int yym, yyn, yystate;
 
607
#if YYDEBUG
 
608
    register const char *yys;
 
609
 
 
610
    if ((yys = getenv("YYDEBUG")))
 
611
    {
 
612
        yyn = *yys;
 
613
        if (yyn >= '0' && yyn <= '9')
 
614
            yydebug = yyn - '0';
 
615
    }
 
616
#endif
 
617
 
 
618
    yynerrs = 0;
 
619
    yyerrflag = 0;
 
620
    yychar = (-1);
 
621
 
 
622
    if (yyss == NULL && yygrowstack()) goto yyoverflow;
 
623
    yyssp = yyss;
 
624
    yyvsp = yyvs;
 
625
    *yyssp = yystate = 0;
 
626
 
 
627
yyloop:
 
628
    if ((yyn = yydefred[yystate])) goto yyreduce;
 
629
    if (yychar < 0)
 
630
    {
 
631
        if ((yychar = yylex()) < 0) yychar = 0;
 
632
#if YYDEBUG
 
633
        if (yydebug)
 
634
        {
 
635
            yys = 0;
 
636
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 
637
            if (!yys) yys = "illegal-symbol";
 
638
            printf("%sdebug: state %d, reading %d (%s)\n",
 
639
                    YYPREFIX, yystate, yychar, yys);
 
640
        }
 
641
#endif
 
642
    }
 
643
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 
644
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 
645
    {
 
646
#if YYDEBUG
 
647
        if (yydebug)
 
648
            printf("%sdebug: state %d, shifting to state %d\n",
 
649
                    YYPREFIX, yystate, yytable[yyn]);
 
650
#endif
 
651
        if (yyssp >= yysslim && yygrowstack())
 
652
        {
 
653
            goto yyoverflow;
 
654
        }
 
655
        *++yyssp = yystate = yytable[yyn];
 
656
        *++yyvsp = yylval;
 
657
        yychar = (-1);
 
658
        if (yyerrflag > 0)  --yyerrflag;
 
659
        goto yyloop;
 
660
    }
 
661
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 
662
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 
663
    {
 
664
        yyn = yytable[yyn];
 
665
        goto yyreduce;
 
666
    }
 
667
    if (yyerrflag) goto yyinrecovery;
 
668
#if defined(lint) || defined(__GNUC__)
 
669
    goto yynewerror;
 
670
#endif
 
671
yynewerror:
 
672
    yyerror("syntax error");
 
673
#if defined(lint) || defined(__GNUC__)
 
674
    goto yyerrlab;
 
675
#endif
 
676
yyerrlab:
 
677
    ++yynerrs;
 
678
yyinrecovery:
 
679
    if (yyerrflag < 3)
 
680
    {
 
681
        yyerrflag = 3;
 
682
        for (;;)
 
683
        {
 
684
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 
685
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 
686
            {
 
687
#if YYDEBUG
 
688
                if (yydebug)
 
689
                    printf("%sdebug: state %d, error recovery shifting\
 
690
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
 
691
#endif
 
692
                if (yyssp >= yysslim && yygrowstack())
 
693
                {
 
694
                    goto yyoverflow;
 
695
                }
 
696
                *++yyssp = yystate = yytable[yyn];
 
697
                *++yyvsp = yylval;
 
698
                goto yyloop;
 
699
            }
 
700
            else
 
701
            {
 
702
#if YYDEBUG
 
703
                if (yydebug)
 
704
                    printf("%sdebug: error recovery discarding state %d\n",
 
705
                            YYPREFIX, *yyssp);
 
706
#endif
 
707
                if (yyssp <= yyss) goto yyabort;
 
708
                --yyssp;
 
709
                --yyvsp;
 
710
            }
 
711
        }
 
712
    }
 
713
    else
 
714
    {
 
715
        if (yychar == 0) goto yyabort;
 
716
#if YYDEBUG
 
717
        if (yydebug)
 
718
        {
 
719
            yys = 0;
 
720
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 
721
            if (!yys) yys = "illegal-symbol";
 
722
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 
723
                    YYPREFIX, yystate, yychar, yys);
 
724
        }
 
725
#endif
 
726
        yychar = (-1);
 
727
        goto yyloop;
 
728
    }
 
729
yyreduce:
 
730
#if YYDEBUG
 
731
    if (yydebug)
 
732
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 
733
                YYPREFIX, yystate, yyn, yyrule[yyn]);
 
734
#endif
 
735
    yym = yylen[yyn];
 
736
    yyval = yyvsp[1-yym];
 
737
    switch (yyn)
 
738
    {
 
739
case 1:
 
740
#line 177 "conf-parse.y"
 
741
{}
 
742
break;
 
743
case 2:
 
744
#line 178 "conf-parse.y"
 
745
{}
 
746
break;
 
747
case 3:
 
748
#line 182 "conf-parse.y"
 
749
{
 
750
#if defined(ENABLE_IPV4) && defined(ENABLE_IPV6)
 
751
                                if (run_ipv6)
 
752
                                        global.a.ipv6=in6addr_any;
 
753
#endif
 
754
                        }
 
755
break;
 
756
case 4:
 
757
#line 188 "conf-parse.y"
 
758
{}
 
759
break;
 
760
case 5:
 
761
#line 189 "conf-parse.y"
 
762
{set_serv_presets(&server); }
 
763
break;
 
764
case 6:
 
765
#line 190 "conf-parse.y"
 
766
{
 
767
                                if (is_inaddr_any(&server.a)) {
 
768
                                        yyerror("bad ip or no ip specified in section");
 
769
                                        YYERROR;
 
770
                                }
 
771
                                if (is_inaddr_any(&server.ping_a)) {
 
772
                                        memcpy(&server.ping_a, &server.a,sizeof(server.ping_a));
 
773
                                }
 
774
                                if (server.uptest==C_EXEC) {
 
775
                                        if (server.uptest_cmd[0]=='\0') {
 
776
                                                yyerror("you must specify uptest_cmd if you specify uptest=exec!");
 
777
                                                YYERROR;
 
778
                                        }
 
779
                                }
 
780
                                add_server(server);
 
781
                        }
 
782
break;
 
783
case 7:
 
784
#line 207 "conf-parse.y"
 
785
{
 
786
                                        c_owner[0]='\0';
 
787
                                        c_name[0]='\0';
 
788
                                        c_ttl=86400;
 
789
                                        c_flags=DF_LOCAL;
 
790
                                        
 
791
                                }
 
792
break;
 
793
case 8:
 
794
#line 215 "conf-parse.y"
 
795
{
 
796
                                if (strlen((char *)c_owner)==0 || strlen((char *)c_name)==0) {
 
797
                                        yyerror("must specify owner and name in a rr record.");
 
798
                                        YYERROR;
 
799
                                }
 
800
 
 
801
                                /* add the authority */
 
802
                                add_cent_rr(&c_cent, c_ttl,0,CF_LOCAL, strlen((char *)c_owner)+1, c_owner, T_NS,0);
 
803
                                add_cache(c_cent);
 
804
                                free_cent(c_cent,0);
 
805
                        }
 
806
break;
 
807
case 9:
 
808
#line 227 "conf-parse.y"
 
809
{
 
810
                                        htp=0;
 
811
                                        hdtp=0;
 
812
                                        c_name[0]='\0';
 
813
                                        c_ttl=86400;
 
814
                                }
 
815
break;
 
816
case 10:
 
817
#line 234 "conf-parse.y"
 
818
{
 
819
                        }
 
820
break;
 
821
case 11:
 
822
#line 237 "conf-parse.y"
 
823
{
 
824
                                        c_owner[0]='\0';
 
825
                                        c_ttl=86400;
 
826
                                        c_flags=DF_LOCAL;
 
827
                                        c_aliases=0;
 
828
                                        
 
829
                                }
 
830
break;
 
831
case 12:
 
832
#line 245 "conf-parse.y"
 
833
{
 
834
                                if (c_owner[0]=='\0') {
 
835
                                        yyerror("you must specify owner in a source record.");
 
836
                                        YYERROR;
 
837
                                }
 
838
                        }
 
839
break;
 
840
case 13:
 
841
#line 253 "conf-parse.y"
 
842
{}
 
843
break;
 
844
case 14:
 
845
#line 254 "conf-parse.y"
 
846
{}
 
847
break;
 
848
case 15:
 
849
#line 258 "conf-parse.y"
 
850
{
 
851
                                if (yyvsp[-1].num==C_OFF) {
 
852
                                        global.perm_cache=0;
 
853
                                } else {
 
854
                                        yyerror("bad qualifier in perm_cache= option.");
 
855
                                        YYERROR;
 
856
                                }
 
857
                        }
 
858
break;
 
859
case 16:
 
860
#line 267 "conf-parse.y"
 
861
{
 
862
                                global.perm_cache=yyvsp[-1].num;
 
863
                        }
 
864
break;
 
865
case 17:
 
866
#line 271 "conf-parse.y"
 
867
{
 
868
                                YSTRNCP(global.cache_dir, (char *)yyvsp[-1].nm, "cache_dir");
 
869
                        }
 
870
break;
 
871
case 18:
 
872
#line 275 "conf-parse.y"
 
873
{
 
874
                                global.port=yyvsp[-1].num;
 
875
                        }
 
876
break;
 
877
case 19:
 
878
#line 279 "conf-parse.y"
 
879
{
 
880
                                if (!str2pdnsd_a((char *)yyvsp[-1].nm,&global.a)) {
 
881
                                        yyerror("bad ip in server_ip= option.");
 
882
                                        YYERROR;
 
883
                                }
 
884
                        }
 
885
break;
 
886
case 20:
 
887
#line 286 "conf-parse.y"
 
888
{
 
889
                                YSTRNCP(global.scheme_file, (char *)yyvsp[-1].nm, "scheme_file");
 
890
                        }
 
891
break;
 
892
case 21:
 
893
#line 290 "conf-parse.y"
 
894
{
 
895
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
896
                                        global.lndown_kluge=(yyvsp[-1].num==C_ON);
 
897
                                } else {
 
898
                                        yyerror("bad qualifier in linkdown_kluge= option.");
 
899
                                        YYERROR;
 
900
                                }
 
901
                        }
 
902
break;
 
903
case 22:
 
904
#line 299 "conf-parse.y"
 
905
{
 
906
                                global.max_ttl=yyvsp[-1].num;
 
907
                        }
 
908
break;
 
909
case 23:
 
910
#line 303 "conf-parse.y"
 
911
{
 
912
                                global.min_ttl=yyvsp[-1].num;
 
913
                        }
 
914
break;
 
915
case 24:
 
916
#line 307 "conf-parse.y"
 
917
{
 
918
                                YSTRNCP(global.run_as, (char *)yyvsp[-1].nm, "run_as");
 
919
                        }
 
920
break;
 
921
case 25:
 
922
#line 311 "conf-parse.y"
 
923
{
 
924
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
925
                                        global.strict_suid=(yyvsp[-1].num==C_ON);
 
926
                                } else {
 
927
                                        yyerror("bad qualifier in strict_setuid= option.");
 
928
                                        YYERROR;
 
929
                                }
 
930
                        }
 
931
break;
 
932
case 26:
 
933
#line 320 "conf-parse.y"
 
934
{
 
935
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
936
                                        global.paranoid=(yyvsp[-1].num==C_ON);
 
937
                                } else {
 
938
                                        yyerror("bad qualifier in paranoid= option.");
 
939
                                        YYERROR;
 
940
                                }
 
941
                        }
 
942
break;
 
943
case 27:
 
944
#line 329 "conf-parse.y"
 
945
{
 
946
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
947
                                        stat_pipe=(yyvsp[-1].num==C_ON);
 
948
                                } else {
 
949
                                        yyerror("bad qualifier in status_pipe= option.");
 
950
                                        YYERROR;
 
951
                                }
 
952
                        }
 
953
break;
 
954
case 28:
 
955
#line 338 "conf-parse.y"
 
956
{
 
957
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
958
                                        daemon_p=(yyvsp[-1].num==C_ON);
 
959
                                } else {
 
960
                                        yyerror("bad qualifier in daemon= option.");
 
961
                                        YYERROR;
 
962
                                }
 
963
                        }
 
964
break;
 
965
case 29:
 
966
#line 347 "conf-parse.y"
 
967
{
 
968
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
969
                                        notcp=(yyvsp[-1].num==C_OFF);
 
970
                                } else {
 
971
                                        yyerror("bad qualifier in tcp_server= option.");
 
972
                                        YYERROR;
 
973
                                }
 
974
                        }
 
975
break;
 
976
case 30:
 
977
#line 356 "conf-parse.y"
 
978
{
 
979
                                YSTRNCP(pidfile, (char *)yyvsp[-1].nm, "pid_file");
 
980
                        }
 
981
break;
 
982
case 31:
 
983
#line 360 "conf-parse.y"
 
984
{
 
985
                                verbosity=yyvsp[-1].num;
 
986
                        }
 
987
break;
 
988
case 32:
 
989
#line 364 "conf-parse.y"
 
990
{
 
991
                                if (yyvsp[-1].num==TCP_ONLY || yyvsp[-1].num==UDP_ONLY || yyvsp[-1].num==TCP_UDP) {
 
992
                                        query_method=yyvsp[-1].num;
 
993
                                } else {
 
994
                                        yyerror("bad qualifier in query_method= option.");
 
995
                                        YYERROR;
 
996
                                }
 
997
                        }
 
998
break;
 
999
case 33:
 
1000
#line 373 "conf-parse.y"
 
1001
{
 
1002
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1003
#if defined(ENABLE_IPV4) && defined(ENABLE_IPV6)
 
1004
                                        run_ipv4=(yyvsp[-1].num==C_ON);
 
1005
                                        run_ipv6=(yyvsp[-1].num!=C_ON);
 
1006
#else
 
1007
                                        yyerror("the run_ipv4 option is only available when pdnsd is compiled with IPv4 AND IPv6 support.");
 
1008
#endif
 
1009
                                } else {
 
1010
                                        yyerror("bad qualifier in run_ipv4= option.");
 
1011
                                        YYERROR;
 
1012
                                }
 
1013
                        }
 
1014
break;
 
1015
case 34:
 
1016
#line 387 "conf-parse.y"
 
1017
{
 
1018
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1019
                                        debug_p=(yyvsp[-1].num==C_ON);
 
1020
                                } else {
 
1021
                                        yyerror("bad qualifier in debug= option.");
 
1022
                                        YYERROR;
 
1023
                                }
 
1024
                        }
 
1025
break;
 
1026
case 35:
 
1027
#line 396 "conf-parse.y"
 
1028
{
 
1029
                                global.ctl_perms=yyvsp[-1].num;
 
1030
                        }
 
1031
break;
 
1032
case 36:
 
1033
#line 400 "conf-parse.y"
 
1034
{
 
1035
                                global.proc_limit=yyvsp[-1].num;
 
1036
                        }
 
1037
break;
 
1038
case 37:
 
1039
#line 404 "conf-parse.y"
 
1040
{
 
1041
                                global.procq_limit=yyvsp[-1].num;
 
1042
                        }
 
1043
break;
 
1044
case 38:
 
1045
#line 408 "conf-parse.y"
 
1046
{
 
1047
                                global.tcp_qtimeout=yyvsp[-1].num;
 
1048
                        }
 
1049
break;
 
1050
case 39:
 
1051
#line 412 "conf-parse.y"
 
1052
{
 
1053
                                global.par_queries=yyvsp[-1].num;
 
1054
                        }
 
1055
break;
 
1056
case 40:
 
1057
#line 416 "conf-parse.y"
 
1058
{
 
1059
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1060
                                        global.rnd_recs=(yyvsp[-1].num==C_ON);
 
1061
                                } else {
 
1062
                                        yyerror("bad qualifier in randomize_recs= option.");
 
1063
                                        YYERROR;
 
1064
                                }
 
1065
                        }
 
1066
break;
 
1067
case 41:
 
1068
#line 425 "conf-parse.y"
 
1069
{
 
1070
                                global.neg_ttl=yyvsp[-1].num;
 
1071
                        }
 
1072
break;
 
1073
case 42:
 
1074
#line 429 "conf-parse.y"
 
1075
{
 
1076
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF || yyvsp[-1].num==C_AUTH) {
 
1077
                                        global.neg_rrs_pol=yyvsp[-1].num;
 
1078
                                } else {
 
1079
                                        yyerror("bad qualifier in neg_rrs_pol= option.");
 
1080
                                        YYERROR;
 
1081
                                }
 
1082
                        }
 
1083
break;
 
1084
case 43:
 
1085
#line 438 "conf-parse.y"
 
1086
{
 
1087
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF || yyvsp[-1].num==C_AUTH) {
 
1088
                                        global.neg_domain_pol=yyvsp[-1].num;
 
1089
                                } else {
 
1090
                                        yyerror("bad qualifier in neg_domain_pol= option.");
 
1091
                                        YYERROR;
 
1092
                                }
 
1093
                        }
 
1094
break;
 
1095
case 44:
 
1096
#line 447 "conf-parse.y"
 
1097
{
 
1098
                                if(yyvsp[-1].num>65536||yyvsp[-1].num<1024) {
 
1099
                                        yyerror("bad value for query_port_start.");
 
1100
                                        YYERROR;
 
1101
                                } else if (global.query_port_end <= yyvsp[-1].num) {
 
1102
                                        yyerror("query_port_end must be greater than query_port_start.");
 
1103
                                        YYERROR;
 
1104
                                } else {
 
1105
                                        global.query_port_start=yyvsp[-1].num;
 
1106
                                }
 
1107
                        }
 
1108
break;
 
1109
case 45:
 
1110
#line 459 "conf-parse.y"
 
1111
{
 
1112
                                if(yyvsp[-1].num>65536||yyvsp[-1].num<1024) {
 
1113
                                        yyerror("bad value for query_port_end.");
 
1114
                                        YYERROR;
 
1115
                                } else if (global.query_port_start >= yyvsp[-1].num) {
 
1116
                                        yyerror("query_port_end must be greater than query_port_start.");
 
1117
                                        YYERROR;
 
1118
                                } else {
 
1119
                                        global.query_port_end=yyvsp[-1].num;
 
1120
                                }
 
1121
                        }
 
1122
break;
 
1123
case 46:
 
1124
#line 472 "conf-parse.y"
 
1125
{}
 
1126
break;
 
1127
case 47:
 
1128
#line 473 "conf-parse.y"
 
1129
{}
 
1130
break;
 
1131
case 48:
 
1132
#line 477 "conf-parse.y"
 
1133
{
 
1134
                                if (!str2pdnsd_a((char *)yyvsp[-1].nm,&server.a)) {
 
1135
                                        yyerror("bad ip in ip= option.");
 
1136
                                        YYERROR;
 
1137
                                }
 
1138
                        }
 
1139
break;
 
1140
case 49:
 
1141
#line 484 "conf-parse.y"
 
1142
{
 
1143
                                server.port=yyvsp[-1].num;
 
1144
                        }
 
1145
break;
 
1146
case 50:
 
1147
#line 488 "conf-parse.y"
 
1148
{
 
1149
                                YSTRNCP(server.scheme, (char *)yyvsp[-1].nm, "scheme");
 
1150
                        }
 
1151
break;
 
1152
case 51:
 
1153
#line 492 "conf-parse.y"
 
1154
{
 
1155
                                if (yyvsp[-1].num==C_PING || yyvsp[-1].num==C_NONE || yyvsp[-1].num==C_IF || yyvsp[-1].num==C_EXEC || yyvsp[-1].num==C_DEV || yyvsp[-1].num==C_DIALD) {
 
1156
                                        server.uptest=yyvsp[-1].num;
 
1157
                                } else {
 
1158
                                        yyerror("bad qualifier in uptest= option.");
 
1159
                                        YYERROR;
 
1160
                                }
 
1161
                        }
 
1162
break;
 
1163
case 52:
 
1164
#line 501 "conf-parse.y"
 
1165
{
 
1166
                                server.timeout=yyvsp[-1].num;
 
1167
                        }
 
1168
break;
 
1169
case 53:
 
1170
#line 505 "conf-parse.y"
 
1171
{
 
1172
                                server.ping_timeout=yyvsp[-1].num;
 
1173
                        }
 
1174
break;
 
1175
case 54:
 
1176
#line 509 "conf-parse.y"
 
1177
{
 
1178
                                if (!str2pdnsd_a((char *)yyvsp[-1].nm,&server.ping_a)) {
 
1179
                                        yyerror("bad ip in ping_ip= option.");
 
1180
                                        YYERROR;
 
1181
                                }
 
1182
                        }
 
1183
break;
 
1184
case 55:
 
1185
#line 516 "conf-parse.y"
 
1186
{
 
1187
                                YSTRNCP(server.uptest_cmd, (char *)yyvsp[-1].nm, "uptest_cmd");
 
1188
                                server.uptest_usr[0] = '\0';
 
1189
                        }
 
1190
break;
 
1191
case 56:
 
1192
#line 521 "conf-parse.y"
 
1193
{
 
1194
                                YSTRNCP(server.uptest_cmd, (char *)yyvsp[-3].nm, "uptest_cmd");
 
1195
                                YSTRNCP(server.uptest_usr, (char *)yyvsp[-1].nm, "uptest_cmd");
 
1196
                        }
 
1197
break;
 
1198
case 57:
 
1199
#line 526 "conf-parse.y"
 
1200
{
 
1201
                                server.interval=yyvsp[-1].num;
 
1202
                        }
 
1203
break;
 
1204
case 58:
 
1205
#line 530 "conf-parse.y"
 
1206
{
 
1207
                                if (yyvsp[-1].num==C_ONQUERY) {
 
1208
                                        server.interval=-1;
 
1209
                                } else {
 
1210
                                        yyerror("bad qualifier in interval= option.");
 
1211
                                        YYERROR;
 
1212
                                }
 
1213
                        }
 
1214
break;
 
1215
case 59:
 
1216
#line 539 "conf-parse.y"
 
1217
{
 
1218
                                YSTRNCP(server.interface, (char *)yyvsp[-1].nm, "interface");
 
1219
                        }
 
1220
break;
 
1221
case 60:
 
1222
#line 543 "conf-parse.y"
 
1223
{
 
1224
                                YSTRNCP(server.device, (char *)yyvsp[-1].nm, "device");
 
1225
                        }
 
1226
break;
 
1227
case 61:
 
1228
#line 547 "conf-parse.y"
 
1229
{
 
1230
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1231
                                        server.purge_cache=(yyvsp[-1].num==C_ON);
 
1232
                                } else {
 
1233
                                        yyerror("bad qualifier in purge_cache= option.");
 
1234
                                        YYERROR;
 
1235
                                }
 
1236
                        }
 
1237
break;
 
1238
case 62:
 
1239
#line 556 "conf-parse.y"
 
1240
{
 
1241
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1242
                                        server.nocache=(yyvsp[-1].num==C_OFF);
 
1243
                                } else {
 
1244
                                        yyerror("bad qualifier in caching= option.");
 
1245
                                        YYERROR;
 
1246
                                }
 
1247
                        }
 
1248
break;
 
1249
case 63:
 
1250
#line 565 "conf-parse.y"
 
1251
{
 
1252
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1253
                                        server.lean_query=(yyvsp[-1].num==C_ON);
 
1254
                                } else {
 
1255
                                        yyerror("bad qualifier in lean_query= option.");
 
1256
                                        YYERROR;
 
1257
                                }
 
1258
                        }
 
1259
break;
 
1260
case 64:
 
1261
#line 574 "conf-parse.y"
 
1262
{
 
1263
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1264
                                        server.is_up=(yyvsp[-1].num==C_ON);
 
1265
                                } else {
 
1266
                                        yyerror("bad qualifier in preset= option.");
 
1267
                                        YYERROR;
 
1268
                                }
 
1269
                        }
 
1270
break;
 
1271
case 65:
 
1272
#line 583 "conf-parse.y"
 
1273
{
 
1274
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1275
                                        server.is_proxy=(yyvsp[-1].num==C_ON);
 
1276
                                } else {
 
1277
                                        yyerror("bad qualifier in proxy_only= option.");
 
1278
                                        YYERROR;
 
1279
                                }
 
1280
                        }
 
1281
break;
 
1282
case 66:
 
1283
#line 592 "conf-parse.y"
 
1284
{
 
1285
                                if (yyvsp[-1].num==C_INCLUDED || yyvsp[-1].num==C_EXCLUDED) {
 
1286
                                        server.policy=yyvsp[-1].num;
 
1287
                                } else {
 
1288
                                        yyerror("bad qualifier in policy= option.");
 
1289
                                        YYERROR;
 
1290
                                }
 
1291
                        }
 
1292
break;
 
1293
case 67:
 
1294
#line 601 "conf-parse.y"
 
1295
{
 
1296
                                char *e;
 
1297
                                
 
1298
                                if ((e=slist_add(&server,(char *)yyvsp[-1].nm,C_INCLUDED))!=NULL) {
 
1299
                                        yyerror(e);
 
1300
                                        YYERROR;
 
1301
                                }
 
1302
                        }
 
1303
break;
 
1304
case 68:
 
1305
#line 610 "conf-parse.y"
 
1306
{
 
1307
                                char *e;
 
1308
                                
 
1309
                                if ((e=slist_add(&server,(char *)yyvsp[-1].nm,C_EXCLUDED))!=NULL) {
 
1310
                                        yyerror(e);
 
1311
                                        YYERROR;
 
1312
                                }
 
1313
                        }
 
1314
break;
 
1315
case 69:
 
1316
#line 619 "conf-parse.y"
 
1317
{
 
1318
                                YSTRNCP(server.label, (char *)yyvsp[-1].nm, "label");
 
1319
                        }
 
1320
break;
 
1321
case 70:
 
1322
#line 624 "conf-parse.y"
 
1323
{}
 
1324
break;
 
1325
case 71:
 
1326
#line 625 "conf-parse.y"
 
1327
{}
 
1328
break;
 
1329
case 72:
 
1330
#line 629 "conf-parse.y"
 
1331
{
 
1332
                                if (strlen((char *)yyvsp[-1].nm)>255) {
 
1333
                                        yyerror("name too long.");
 
1334
                                        YYERROR;
 
1335
                                }
 
1336
                                YSTRNCP(c_name, (char *)yyvsp[-1].nm, "name");
 
1337
                                if (c_owner[0]!='\0') {
 
1338
                                        if (!init_cent(&c_cent, c_name, c_flags, time(NULL), 0, 0)) {
 
1339
                                                fprintf(stderr,"Out of memory.\n");
 
1340
                                                YYERROR;
 
1341
                                        }
 
1342
                                }
 
1343
                        }
 
1344
break;
 
1345
case 73:
 
1346
#line 643 "conf-parse.y"
 
1347
{
 
1348
                                if (strlen((char *)yyvsp[-1].nm)>255) {
 
1349
                                        yyerror("name too long.");
 
1350
                                        YYERROR;
 
1351
                                }
 
1352
                                if (!str2rhn(yyvsp[-1].nm,c_owner)) {
 
1353
                                        yyerror("bad domain name - must end in root domain.");
 
1354
                                        YYERROR;
 
1355
                                }
 
1356
                                if (c_name[0]!='\0') {
 
1357
                                        if (!init_cent(&c_cent, c_name, c_flags, time(NULL), 0, 0)) {
 
1358
                                                fprintf(stderr,"Out of memory.\n");
 
1359
                                                YYERROR;
 
1360
                                        }
 
1361
                                }
 
1362
                        }
 
1363
break;
 
1364
case 74:
 
1365
#line 660 "conf-parse.y"
 
1366
{
 
1367
                                c_ttl=yyvsp[-1].num;
 
1368
                        }
 
1369
break;
 
1370
case 75:
 
1371
#line 664 "conf-parse.y"
 
1372
{
 
1373
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1374
                                        c_flags=(yyvsp[-1].num==C_ON)?DF_LOCAL:0;
 
1375
                                } else {
 
1376
                                        yyerror("Bad qualifier in authrec= option.");
 
1377
                                        YYERROR;
 
1378
                                }
 
1379
                        }
 
1380
break;
 
1381
case 76:
 
1382
#line 673 "conf-parse.y"
 
1383
{
 
1384
                                if (strlen((char *)c_owner)==0 || strlen((char *)c_name)==0) {
 
1385
                                        yyerror("you must specify owner and name before a,ptr and soa records.");
 
1386
                                        YYERROR;
 
1387
                                }
 
1388
                                if (inet_aton((char *)yyvsp[-1].nm,&ina4)) {
 
1389
#if !defined(ENABLE_IPV4) 
 
1390
                                        yyerror("bad ip in a= option.");
 
1391
                                        YYERROR;
 
1392
#else
 
1393
                                        c_a.ipv4=ina4;
 
1394
                                        sz=sizeof(struct in_addr);
 
1395
                                        tp=T_A;
 
1396
#endif
 
1397
                                } else {
 
1398
#if defined(DNS_NEW_RRS) && defined(ENABLE_IPV6)
 
1399
                                        if ((err=inet_pton(AF_INET6,(char *)yyvsp[-1].nm,&c_a.ipv6))!=1) {
 
1400
                                                if (err==0) {
 
1401
                                                        yyerror("bad ip in a= option.");
 
1402
                                                        YYERROR;
 
1403
                                                } else {
 
1404
                                                        perror("inet_pton");
 
1405
                                                        YYERROR;
 
1406
                                                }
 
1407
                                        } else {
 
1408
                                                tp=T_AAAA;
 
1409
                                                sz=sizeof(struct in6_addr);
 
1410
                                        }
 
1411
#else
 
1412
                                        yyerror("bad ip in a= option.");
 
1413
                                        YYERROR;
 
1414
#endif
 
1415
                                }
 
1416
                                add_cent_rr(&c_cent,c_ttl,0,CF_LOCAL,sz,&c_a,tp, 0);
 
1417
                        }
 
1418
break;
 
1419
case 77:
 
1420
#line 709 "conf-parse.y"
 
1421
{
 
1422
                                if (strlen((char *)c_owner)==0 || strlen((char *)c_name)==0) {
 
1423
                                        yyerror("you must specify owner and name before a,ptr and soa records.");
 
1424
                                        YYERROR;
 
1425
                                }
 
1426
                                if (strlen((char *)yyvsp[-1].nm)>255) {
 
1427
                                        yyerror("name too long.");
 
1428
                                        YYERROR;
 
1429
                                }
 
1430
                                if (!str2rhn(yyvsp[-1].nm,c_ptr)) {
 
1431
                                        yyerror("bad domain name - must end in root domain.");
 
1432
                                        YYERROR;
 
1433
                                }
 
1434
                                add_cent_rr(&c_cent,c_ttl,0,CF_LOCAL,rhnlen(c_ptr),c_ptr,T_PTR,0);
 
1435
                        }
 
1436
break;
 
1437
case 78:
 
1438
#line 725 "conf-parse.y"
 
1439
{
 
1440
                                if (strlen((char *)c_owner)==0 || strlen((char *)c_name)==0) {
 
1441
                                        yyerror("you must specify owner and name before mx records.");
 
1442
                                        YYERROR;
 
1443
                                }
 
1444
                                if (strlen((char *)yyvsp[-3].nm)>255) {
 
1445
                                        yyerror("name too long.");
 
1446
                                        YYERROR;
 
1447
                                }
 
1448
                                if (!str2rhn(yyvsp[-3].nm,c_ptr)) {
 
1449
                                        yyerror("bad domain name - must end in root domain.");
 
1450
                                        YYERROR;
 
1451
                                }
 
1452
                                memset(buf,0,sizeof(buf));
 
1453
                                ts=htons(yyvsp[-1].num);
 
1454
                                memcpy(buf,&ts,2);
 
1455
                                rhncpy(buf+2,c_ptr);
 
1456
                                add_cent_rr(&c_cent,c_ttl,0,CF_LOCAL,rhnlen(c_ptr)+2,buf,T_MX,0);
 
1457
                        }
 
1458
break;
 
1459
case 79:
 
1460
#line 745 "conf-parse.y"
 
1461
{
 
1462
                                if (strlen((char *)c_owner)==0 || strlen((char *)c_name)==0) {
 
1463
                                        yyerror("you must specify owner and name before cname records.");
 
1464
                                        YYERROR;
 
1465
                                }
 
1466
                                if (strlen((char *)yyvsp[-1].nm)>255) {
 
1467
                                        yyerror("name too long.");
 
1468
                                        YYERROR;
 
1469
                                }
 
1470
                                if (!str2rhn(yyvsp[-1].nm,c_ptr)) {
 
1471
                                        yyerror("bad domain name - must end in root domain.");
 
1472
                                        YYERROR;
 
1473
                                }
 
1474
                                add_cent_rr(&c_cent,c_ttl,0,CF_LOCAL,rhnlen(c_ptr),c_ptr,T_CNAME,0);
 
1475
                        }
 
1476
break;
 
1477
case 80:
 
1478
#line 761 "conf-parse.y"
 
1479
{
 
1480
                                if (strlen((char *)c_owner)==0 || strlen((char *)c_name)==0) {
 
1481
                                        yyerror("you must specify owner and name before a, ptr and soa records.");
 
1482
                                        YYERROR;
 
1483
                                }
 
1484
                                if (strlen((char *)yyvsp[-13].nm)>255) {
 
1485
                                        yyerror("name too long.");
 
1486
                                        YYERROR;
 
1487
                                }
 
1488
                                if (!str2rhn(yyvsp[-13].nm,c_soa_owner)) {
 
1489
                                        yyerror("bad domain name - must end in root domain.");
 
1490
                                        YYERROR;
 
1491
                                }
 
1492
                                if (strlen((char *)yyvsp[-11].nm)>255) {
 
1493
                                        yyerror("name too long.");
 
1494
                                        YYERROR;
 
1495
                                }
 
1496
                                if (!str2rhn(yyvsp[-11].nm,c_soa_r)) {
 
1497
                                        yyerror("bad domain name - must end in root domain.");
 
1498
                                        YYERROR;
 
1499
                                }
 
1500
                                c_soa.serial=htonl(yyvsp[-9].num);
 
1501
                                c_soa.refresh=htonl(yyvsp[-7].num);
 
1502
                                c_soa.retry=htonl(yyvsp[-5].num);
 
1503
                                c_soa.expire=htonl(yyvsp[-3].num);
 
1504
                                c_soa.minimum=htonl(yyvsp[-1].num);
 
1505
                                memset(buf,0,sizeof(buf));
 
1506
                                idx=rhncpy(buf,c_soa_owner);
 
1507
                                idx+=rhncpy(buf+idx,c_soa_r);
 
1508
                                memcpy(buf+idx,&c_soa,sizeof(soa_r_t));
 
1509
                                idx+=sizeof(soa_r_t);
 
1510
                                add_cent_rr(&c_cent,c_ttl,0,CF_LOCAL,idx,buf,T_SOA,0);
 
1511
                        }
 
1512
break;
 
1513
case 81:
 
1514
#line 796 "conf-parse.y"
 
1515
{}
 
1516
break;
 
1517
case 82:
 
1518
#line 797 "conf-parse.y"
 
1519
{}
 
1520
break;
 
1521
case 83:
 
1522
#line 801 "conf-parse.y"
 
1523
{
 
1524
                                if (strlen((char *)yyvsp[-1].nm)>255) {
 
1525
                                        yyerror("name too long.");
 
1526
                                        YYERROR;
 
1527
                                }
 
1528
                                if (!str2rhn(yyvsp[-1].nm,c_owner)) {
 
1529
                                        yyerror("bad domain name - must end in root domain.");
 
1530
                                        YYERROR;
 
1531
                                }
 
1532
                        }
 
1533
break;
 
1534
case 84:
 
1535
#line 812 "conf-parse.y"
 
1536
{
 
1537
                                c_ttl=yyvsp[-1].num;
 
1538
                        }
 
1539
break;
 
1540
case 85:
 
1541
#line 816 "conf-parse.y"
 
1542
{
 
1543
                                if (strlen((char *)c_owner)==0) {
 
1544
                                        yyerror("you must specify owner before file= in source records.");
 
1545
                                        YYERROR;
 
1546
                                }
 
1547
                                if (!read_hosts((char *)yyvsp[-1].nm, c_owner, c_ttl, c_flags, c_aliases,errbuf,sizeof(errbuf)))
 
1548
                                        fprintf(stderr,"%s\n",errbuf);
 
1549
                        }
 
1550
break;
 
1551
case 86:
 
1552
#line 825 "conf-parse.y"
 
1553
{
 
1554
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1555
                                        c_aliases=(yyvsp[-1].num==C_ON);
 
1556
                                } else {
 
1557
                                        yyerror("Bad qualifier in serve_aliases= option.");
 
1558
                                        YYERROR;
 
1559
                                }
 
1560
                        }
 
1561
break;
 
1562
case 87:
 
1563
#line 834 "conf-parse.y"
 
1564
{
 
1565
                                if (yyvsp[-1].num==C_ON || yyvsp[-1].num==C_OFF) {
 
1566
                                        c_flags=(yyvsp[-1].num==C_ON)?DF_LOCAL:0;
 
1567
                                } else {
 
1568
                                        yyerror("Bad qualifier in authrec= option.");
 
1569
                                        YYERROR;
 
1570
                                }
 
1571
                        }
 
1572
break;
 
1573
case 88:
 
1574
#line 845 "conf-parse.y"
 
1575
{}
 
1576
break;
 
1577
case 89:
 
1578
#line 846 "conf-parse.y"
 
1579
{}
 
1580
break;
 
1581
case 90:
 
1582
#line 851 "conf-parse.y"
 
1583
{
 
1584
                                if (strlen((char *)yyvsp[-1].nm)>255) {
 
1585
                                        yyerror("name too long.");
 
1586
                                        YYERROR;
 
1587
                                }
 
1588
                                YSTRNCP(c_name,(char *)yyvsp[-1].nm, "name");
 
1589
                        }
 
1590
break;
 
1591
case 91:
 
1592
#line 859 "conf-parse.y"
 
1593
{
 
1594
                                c_ttl=yyvsp[-1].num;
 
1595
                        }
 
1596
break;
 
1597
case 92:
 
1598
#line 863 "conf-parse.y"
 
1599
{
 
1600
                                if (htp) {
 
1601
                                        yyerror("You may not specify types=domain together with other types!");
 
1602
                                        YYERROR;
 
1603
                                }
 
1604
                                if (!c_name[0]) {
 
1605
                                        yyerror("you must specify a name before the types= option.");
 
1606
                                        YYERROR;
 
1607
                                }
 
1608
                                hdtp=1;
 
1609
                                if (!init_cent(&c_cent, (unsigned char *)c_name, DF_LOCAL|DF_NEGATIVE, time(NULL), c_ttl,0)) {
 
1610
                                        fprintf(stderr,"Out of memory");
 
1611
                                        YYERROR;
 
1612
                                }
 
1613
                                add_cache(c_cent);
 
1614
                                free_cent(c_cent,0);
 
1615
                        }
 
1616
break;
 
1617
case 93:
 
1618
#line 881 "conf-parse.y"
 
1619
{
 
1620
                        }
 
1621
break;
 
1622
case 94:
 
1623
#line 885 "conf-parse.y"
 
1624
{}
 
1625
break;
 
1626
case 95:
 
1627
#line 886 "conf-parse.y"
 
1628
{}
 
1629
break;
 
1630
case 96:
 
1631
#line 890 "conf-parse.y"
 
1632
{
 
1633
                                if (hdtp) {
 
1634
                                        yyerror("You may not specify types=domain together with other types!.");
 
1635
                                        YYERROR;
 
1636
                                }
 
1637
                                htp=1;
 
1638
                                if (!c_name[0]) {
 
1639
                                        yyerror("you must specify a name before the types= option.");
 
1640
                                        YYERROR;
 
1641
                                }
 
1642
                                if (!init_cent(&c_cent, (unsigned char *)c_name, 0, time(NULL), 0, 0)) {
 
1643
                                        fprintf(stderr,"Out of memory");
 
1644
                                        YYERROR;
 
1645
                                }
 
1646
                                if (!add_cent_rrset(&c_cent,yyvsp[0].num,c_ttl,0,CF_LOCAL|CF_NEGATIVE,0, 0)) {
 
1647
                                        free_cent(c_cent,0);
 
1648
                                        fprintf(stderr,"Out of memory");
 
1649
                                        YYERROR;
 
1650
                                }
 
1651
                                add_cache(c_cent);
 
1652
                                free_cent(c_cent, 0);
 
1653
                                
 
1654
                        }
 
1655
break;
 
1656
case 97:
 
1657
#line 915 "conf-parse.y"
 
1658
{YYERROR;}
 
1659
break;
 
1660
#line 1661 "y.tab.c"
 
1661
    }
 
1662
    yyssp -= yym;
 
1663
    yystate = *yyssp;
 
1664
    yyvsp -= yym;
 
1665
    yym = yylhs[yyn];
 
1666
    if (yystate == 0 && yym == 0)
 
1667
    {
 
1668
#if YYDEBUG
 
1669
        if (yydebug)
 
1670
            printf("%sdebug: after reduction, shifting from state 0 to\
 
1671
 state %d\n", YYPREFIX, YYFINAL);
 
1672
#endif
 
1673
        yystate = YYFINAL;
 
1674
        *++yyssp = YYFINAL;
 
1675
        *++yyvsp = yyval;
 
1676
        if (yychar < 0)
 
1677
        {
 
1678
            if ((yychar = yylex()) < 0) yychar = 0;
 
1679
#if YYDEBUG
 
1680
            if (yydebug)
 
1681
            {
 
1682
                yys = 0;
 
1683
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 
1684
                if (!yys) yys = "illegal-symbol";
 
1685
                printf("%sdebug: state %d, reading %d (%s)\n",
 
1686
                        YYPREFIX, YYFINAL, yychar, yys);
 
1687
            }
 
1688
#endif
 
1689
        }
 
1690
        if (yychar == 0) goto yyaccept;
 
1691
        goto yyloop;
 
1692
    }
 
1693
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 
1694
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 
1695
        yystate = yytable[yyn];
 
1696
    else
 
1697
        yystate = yydgoto[yym];
 
1698
#if YYDEBUG
 
1699
    if (yydebug)
 
1700
        printf("%sdebug: after reduction, shifting from state %d \
 
1701
to state %d\n", YYPREFIX, *yyssp, yystate);
 
1702
#endif
 
1703
    if (yyssp >= yysslim && yygrowstack())
 
1704
    {
 
1705
        goto yyoverflow;
 
1706
    }
 
1707
    *++yyssp = yystate;
 
1708
    *++yyvsp = yyval;
 
1709
    goto yyloop;
 
1710
yyoverflow:
 
1711
    yyerror("yacc stack overflow");
 
1712
yyabort:
 
1713
    return (1);
 
1714
yyaccept:
 
1715
    return (0);
 
1716
}